How to create composable scopes for plain Ruby arrays

Question

One of the things that I really like about Active Record is its named scopes and being able to chain scopes together to build expressive queries.

What would be a similar way to achieve this with plain Ruby Enumerables/Arrays, ideally without monkey-patching Enumerable or Array in any dangerous way?

For example:

### ActiveRecord Model
class User < ActiveRecord::Base
  scope :customers, -> { where(:role => 'customer') }
  scope :speaking, ->(lang) { where(:language => lang) }
end

# querying
User.customers.language('English')  # all English customers

### Plain-Ruby Array
module User
  class << self
    def customers
      users.select { |u| u[:role] == 'customer' }
    end

    def speaking(lang)
      users.select { |u| u[:language] == lang }
    end

    private

    def users
      [
        {:name => 'John', :language => 'English', :role => 'customer'},
        {:name => 'Jean', :language => 'French', :role => 'customer'},
        {:name => 'Hans', :language => 'German', :role => 'user'},
        {:name => 'Max', :language => 'English', :role => 'user'}
      ]
    end
  end
end

User.customers  # all customers
User.language('English')  # all English speakers
# how do I achieve something similar to User.customers.language('English') ...?

I know I can build a method customers_with_language inside the module, but I'm looking for a general way to solve this with any number of "scopes".

Answer 1

Here is a crude implementation of a ScopableArray, which inherits an Array:

class ScopableArray < Array
  def method_missing(method_sym, *args)
    ScopableArray.new(select { |u| u[method_sym] == args[0] } )
  end
end

When this class receives a method it does not identify, it assumes you want to filter it according to a field of the method's name with the argument's value:

users = ScopableArray.new([
    {:name => 'John', :language => 'English', :role => 'customer'},
    {:name => 'Jean', :language => 'French', :role => 'customer'},
    {:name => 'Hans', :language => 'German', :role => 'user'},
    {:name => 'Max', :language => 'English', :role => 'user'}
])

users.role('customer')
# => [{:name=>"John", :language=>"English", :role=>"customer"}, {:name=>"Jean", :language=>"French", :role=>"customer"}]
users.role('customer').language('English')
# => [{:name=>"John", :language=>"English", :role=>"customer"}]

---

You can also look at ActiveRecord's implementation pattern for a more elaborate scheme where you can define scopes by passing a name and a callable block, something like this:

class ScopableArray2 < Array
  class << self
    def scope(name, body)
      unless body.respond_to?(:call)
        raise ArgumentError, 'The scope body needs to be callable.'
      end

      define_method(name) do |*args|
        dup.select! { |x| body.call(x, *args) }
      end
    end
  end
end

Then you can do something like this:

class Users < ScopableArray2
  scope :customers, ->(x) { x[:role] == 'customer' }
  scope :speaking, ->(x, lang) { x[:language] == lang }
end

users = Users.new([
        {:name => 'John', :language => 'English', :role => 'customer'},
        {:name => 'Jean', :language => 'French', :role => 'customer'},
        {:name => 'Hans', :language => 'German', :role => 'user'},
        {:name => 'Max', :language => 'English', :role => 'user'}
    ])

users.customers.speaking('English')
# => [{:name=>"John", :language=>"English", :role=>"customer"}]