Sensible Arrays

sensible-array.rb

module Sensible
  module Array
    class ::Array
      alias_method :select_std, :select
      def select arg = nil, &cb
        preselected = case arg
                      # no argument ⇒ standard processing
                      when NilClass then self
                      # strings are matched as is
                      when String then select_std do |e|
                        e.is_a?(String) && e =~ Regexp.new(Regexp.escape(arg))
                      end
                      # return only same and derived classes
                      when Class then select_std do |e|
                        e < arg
                      end
                      # inclusive deep recurse
                      when Array then arg.inject([]) do |memo, e|
                        memo + select(e)
                      end.uniq
                      # for any other use `=~` operator
                      else select_std do |e|
                             begin
                               e.respond_to?(:to_s) && e.to_s =~ arg
                             rescue TypeError => e
                               false
                             end
                           end
                      end
        block_given? ? preselected.send(:select_std, &cb) : preselected
      end
      private :select_std

      def to_proc
        lambda do |item|
          case item
          when Hash then item.select { |k, _| self.include? k }
          when Class
            map do |i|
              if i.respond_to?(:to_sym)
                is = i.to_sym
                [
                  item.singleton_methods.include?(is) ? item.singleton_method(is) : nil,
                  item.instance_methods.include?(is) ? item.instance_method(is) : nil
                ]
              else
                [nil, nil]
              end
            end
          when lambda do |it|
                 count do |i|
                   i.respond_to?(:to_sym) && it.respond_to?(i.to_sym)
                 end == length # > 0 might be an option
               end then map { |m| item.send(m) }
          else item.send(*self)
          end
        end
      end
    end
  end
end

p [Integer, Fixnum, String].select(Numeric)
# [Integer, Fixnum]

p ['one', 'two', 'three'].select('o')
# ["one", "two"]

p ['one', 'two', 'three'].select(/\At/)
# ["two", "three"]

p [Integer, Fixnum].map &[:to_s, 'to_f']
# [
#    [[nil, #<UnboundMethod: Integer(Kernel)#to_s>], [nil, nil]], 
#    [[nil, #<UnboundMethod: Fixnum#to_s>], [nil, #<UnboundMethod: Fixnum#to_f>]]
# ]

p [{a: 1, b: 2, c: 3}].map(&[:a, :c])
# [{:a=>1, :c=>3}]