queryable_array 0.0.0

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Sean Huber - shuber@huberry.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,124 @@
+= queryable_array
+
+{<img src="https://secure.travis-ci.org/shuber/queryable_array.png"/>}[http://travis-ci.org/shuber/queryable_array]
+{<img src="https://gemnasium.com/shuber/queryable_array.png"/>}[https://gemnasium.com/shuber/queryable_array]
+{<img src="https://d25lcipzij17d.cloudfront.net/badge.png?v=0.0.0"/>}[http://rubygems.org/gems/queryable_array]
+{<img src="https://codeclimate.com/badge.png" />}[https://codeclimate.com/github/shuber/queryable_array]
+
+A +QueryableArray+ inherits from +Array+ and is intended to store a group of
+objects which share the same attributes allowing them to be searched. It
+overrides <tt>[]</tt>, +find_all+ and +method_missing+ to provide a simplified DSL
+for looking up objects by querying their attributes.
+
+View the full documentation over at rubydoc.info[http://rubydoc.info/github/shuber/queryable_array/frames].
+
+== Installation
+
+  gem install queryable_array
+
+
+== Usage
+
+=== Basic
+
+Initialize the +QueryableArray+ with a collection of objects e.g. +Page+ objects from a database
+
+  pages = QueryableArray.new Page.all
+
+The +pages+ object can then be queried by passing a search hash to the +[]+ method
+
+  pages[uri: '/']                    # => #<Page @uri='/' @name='Home'>
+  pages[name: 'About']               # => #<Page @uri='/about' @name='About'>
+  pages[uri: '/', name: 'Home']      # => #<Page @uri='/' @name='Home'>
+  pages[uri: '/', name: 'Mismatch']  # => nil
+
+Notice that it only returns the first matching object or nil if one is not found. If you'd like to find
+all matching objects, simply wrap your search hash in an array
+
+  pages[[published: true]]  # => [#<Page @uri='/' @name='Home' @published=true>, #<Page @uri='/about' @name='About' @published=true>, ...]
+  pages[[uri: '/missing']]  # => []
+
+Attributes may also be searched by regular expressions
+
+  pages[name: /home/i]   # => #<Page @uri='/' @name='Home'>
+  pages[[uri: /users/]]  # => [#<Page @uri='/users/bob' @name='Bob'>, #<Page @uri='/users/steve' @name='Steve'>, ...]
+
+The methods +find_by+ and +find_all+ behave as aliases for <tt>[search_hash]</tt> and <tt>[[search_hash]]</tt> respectively
+
+  pages.find_by(name: 'Home')     # => #<Page @uri='/' @name='Home'>
+  pages.find_by(name: 'Missing')  # => nil
+  pages.find_all(uri: /users/)    # => [#<Page @uri='/users/bob' @name='Bob'>, #<Page @uri='/users/steve' @name='Steve'>, ...]
+
+The existing block form for those methods work as well
+
+  pages.find_all { |page| page.uri =~ /users/ }  # => [#<Page @uri='/users/bob' @name='Bob'>, #<Page @uri='/users/steve' @name='Steve'>, ...]
+
+A +Proc+ object may be passed to <tt>[]</tt> as well
+
+  pages[uri: proc { |uri| uri.split('/').size > 1 }]  # => #<Page @uri='/users/bob' @name='Bob'>
+  pages[proc { |page| page.uri == '/' }]              # => #<Page @uri='/' @name='Home'>
+
+Lookups by index or ranges still behave exactly as they do in regular +Array+ objects
+
+  pages[0]     # => #<Page @uri='/' @name='Home'>
+  pages[-1]    # => #<Page @uri='/zebras' @name='Zebras'>
+  pages[99]    # => nil
+  pages[0..1]  # => [#<Page @uri='/' @name='Home'>, #<Page @uri='/about' @name='About'>]
+
+
+=== Default finders
+
+A +QueryableArray+ object can be initialized with a +default_finder+ to make lookups even simpler
+
+  pages = QueryableArray.new Page.all, :uri
+
+Now the +pages+ object can be searched easily by +uri+
+
+  pages['/']         # => #<Page @uri='/' @name='Home'>
+  pages['/about']    # => #<Page @uri='/about' @name='About'>
+  pages['/missing']  # => nil
+
+You can even specify multiple +default_finders+
+
+  pages = QueryableArray.new Page.all, [:uri, :name]
+
+  pages['/about']  # => #<Page @uri='/about' @name='About'>
+  pages['About']   # => #<Page @uri='/about' @name='About'>
+  pages[/home/i]   # => #<Page @uri='/' @name='Home'>
+
+Wrapping your search inside an array still returns all matches
+
+  pages[[/users/]]  # => [#<Page @uri='/users/bob' @name='Bob'>, #<Page @uri='/users/steve' @name='Steve'>, ...]
+
+
+=== Dynamic attribute-based finders
+
+<tt>QueryableArray#method_missing</tt> allows you to lookup objects using a notation like the +ActiveRecord+ dynamic finders
+
+  pages.find_by_uri('/')                   # => #<Page @uri='/' @name='Home'>
+  pages.find_by_uri_and_name('/', 'Home')  # => #<Page @uri='/' @name='Home'>
+  pages.find_by_uri('/missing')            # => nil
+
+  pages.find_all_by_uri('/')               # => [#<Page @uri='/' @name='Home'>]
+  pages.find_all_by_uri(/users/)           # => [#<Page @uri='/users/bob' @name='Bob'>, #<Page @uri='/users/steve' @name='Steve'>, ...]
+
+
+=== Dot notation finders
+
+If any +default_finders+ are defined you may even use dot notation to lookup objects by those attributes
+
+  pages = QueryableArray.new Page.all, :name
+
+  pages.sitemap               # => #<Page @uri='/sitemap' @name='Sitemap'>
+  pages.missing               # => NoMethodError
+  QueryableArray.new.missing  # => NoMethodError
+
+Calling <tt>pages.sitemap</tt> behaves the same as <tt>pages[/sitemap/i]</tt>
+
+To perform a case-sensitive search, simply append a <tt>!</tt> to the end of your method call
+e.g. <tt>pages.sitemap!</tt> which calls <tt>pages['sitemap']</tt>
+
+You may also query to see if a match exists by appending a <tt>?</tt> to your search
+
+  pages.sitemap?  # => true
+  pages.missing?  # => false

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rake/testtask'
+require 'rdoc/task'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the queryable_array gem.'
+Rake::TestTask.new(:test) do |t|
+  t.libs.push 'lib'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+desc 'Generate documentation for the queryable_array gem.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'queryable_array'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/queryable_array/default_finder.rb

@@ -0,0 +1,49 @@
+class QueryableArray < Array
+  module DefaultFinder
+    attr_accessor :default_finders
+
+    # Accepts an initial +array+ which defaults to +[]+. An optional +default_finders+
+    # may also be specified as the second argument which is used in +QueryableArray#[]+
+    # for quick lookups. It defaults to +nil+ which disables this behavior. See the
+    # +QueryableArray#[]+ method for more documentation.
+    def initialize(array = [], default_finders = nil)
+      super array
+      self.default_finders = Array(default_finders)
+    end
+
+    # If +default_finders+ has been set and +key+ is not a +Fixnum+ then it
+    # loops thru each +default_finders+ and returns the first matching result
+    # of +find_by(finder => key)+ or +find_all(finder => key.first)+ if +key+
+    # is an +Array+. If +key+ is already a +Hash+ or an +Array+ containing one
+    # then it acts like an alias for +find_by+ or +find_all+ respectively. It
+    # behaves exactly like its superclass +Array+ in all other cases.
+    #
+    #   pages = QueryableArray.new(Page.all, [:uri, :name])
+    #
+    #   pages['/']        # => #<Page @uri='/'>
+    #   pages['Home']     # => #<Page @name='Home'>
+    #   pages[/home/i]    # => #<Page @name='Home'>
+    #   pages['missing']  # => nil
+    def [](key)
+      super
+    rescue TypeError => error
+      if default_finders.empty?
+        raise error
+      else
+        method, key = key.is_a?(Array) ? [:find_all, key.first] : [:find_by, key]
+        send method, &query(key)
+      end
+    end
+
+    def query(search)
+      Proc.new do |object|
+        proc = search.respond_to?(:call) ? search : Proc.new do |object|
+          default_finders.any? do |attribute|
+            finder(attribute => search).call object
+          end
+        end
+        proc.call object
+      end
+    end
+  end
+end

data/lib/queryable_array/dot_notation.rb

@@ -0,0 +1,39 @@
+require 'queryable_array/default_finder'
+
+class QueryableArray < Array
+  module DotNotation
+    def self.included(base)
+      base.send :include, DefaultFinder
+    end
+
+    # If +method_name+ does not have a <tt>!</tt> or <tt>?</tt> suffix then +self[/#{method_name}/i]+
+    # is returned. If it returns +nil+ or raises +TypeError+ (no +default_finders+) then +super+ is returned.
+    #
+    # If +method_name+ ends in a <tt>!</tt> then +self[method_name]+ (without the <tt>!</tt>) is returned. If +method_name+
+    # ends with a <tt>?</tt> then a boolean is returned determining whether or not a match was found.
+    #
+    #   users = QueryableArray.new User.all, :username
+    #
+    #   users.bob                             # => #<User @name='bob'>
+    #   users.BOB                             # => #<User @name='bob'>
+    #   users.missing                         # => NoMethodError
+    #   QueryableArray.new.missing            # => NoMethodError
+    def method_missing(method_name, *arguments)
+      if method_name.to_s =~ /^(.+?)([\!\?])?$/
+        search = $2 == '!' ? $1 : /#{$1}/i
+        value = begin
+          self[search]
+        rescue TypeError
+          nil
+        end
+        $2 == '?' ? !!value : (value || super)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_super)
+      !!(method_name.to_s =~/\?$/ || super || send(method_name))
+    rescue NoMethodError
+      false
+    end
+  end
+end

data/lib/queryable_array/dynamic_finder.rb

@@ -0,0 +1,50 @@
+class QueryableArray < Array
+  module DynamicFinder
+    def self.included(base)
+      base.send :alias_method, :find_all_by, :find_all
+    end
+
+    # Determines if the +method_name+ passed to it can be parsed into a search hash
+    # for +finder+.
+    #
+    #   finder? :find_by_name                      # => true
+    #   finder? :find_by_first_name_and_last_name  # => true
+    #   finder? :find_all_by_last_name             # => true
+    #   finder? :find_all_by_last_name_and_city    # => true
+    #   finder? :find_by_name_or_age               # => false
+    #   finder? :find_first_by_name                # => false
+    #   finder? :find_name                         # => false
+    #   finder? :some_method                       # => false
+    def finder?(method_name)
+      if match = method_name.to_s.match(/^(find_(by|all_by))_(.+?)([\?\!])?$/i)
+        keys = [:method_name, :prefix, :type, :attributes, :suffix]
+        Hash[keys.zip match.to_a]
+      end
+    end
+
+    # If +method_name+ is a +finder?+ then it creates a search hash by zipping the
+    # names of attributes parsed from +method_name+ as keys and +arguments+ as expected
+    # values. The search hash is then passed to +find_all+ or +find_by+ depending
+    # on what type of method was called.
+    #
+    #   users = QueryableArray.new User.all, :username
+    #
+    #   users.find_by_name 'bob'              # => #<User @name='bob'>
+    #   users.find_by_name_and_age 'jim', 23  # => #<User @name='jim' @age=23>
+    #   users.find_all_by_age 27              # => [#<User @age=27>, #<User @age=27>, ...]
+    def method_missing(method_name, *arguments)
+      if query = finder?(method_name)
+        search = Hash[query[:attributes].split('_and_').zip(arguments)]
+        send "find_#{query[:type]}", search
+      else
+        super
+      end
+    end
+
+    # Determines if +method_name+ is a +finder?+ and delegates the call to its
+    # superclass +Array+ if it's not.
+    def respond_to_missing?(method_name, include_super)
+      !!finder?(method_name) || super
+    end
+  end
+end

data/lib/queryable_array/queryable.rb

@@ -0,0 +1,44 @@
+class QueryableArray < Array
+  module Queryable
+    # Returns a QueryableArray of objects matching +search+ criteria. When a +block+
+    # is specified, it behaves exactly like +Enumerable#find_all+. Otherwise the
+    # +search+ hash is converted into a +finder+ proc and passed as the block 
+    # argument to +Enumerable#find_all+.
+    #
+    #   users.find_all(age: 30)                  # => [#<User @age=30>, #<User @age=30>, ...]
+    #   users.find_all(name: 'missing')          # => []
+    #   users.find_all { |user| user.age < 30 }  # => [#<User @age=22>, #<User @age=26>, ...]
+    def find_all(search = {}, &block)
+      block = finder search unless block_given?
+      self.class.new super(&block)
+    end
+
+    # Behaves exactly like +find_all+ but only returns the first match. If no match
+    # is found then +nil+ is returned.
+    #
+    #   users.find_by(age: 25)          # => #<User @age=25>
+    #   users.find_by(name: 'missing')  # => nil
+    def find_by(search = {}, &block)
+      block = finder search unless block_given?
+      find(&block)
+    end
+
+    # Accepts a +search+ hash and returns a +Proc+ which determines if all of an
+    # object's attributes match their expected search values. It can be used as
+    # the block arguments for +find+, +find_by+ and +find_all+.
+    #
+    #   query = finder name: 'bob'     # => proc { |user| user.name == 'bob' }
+    #   query User.new(name: 'steve')  # => false
+    #   query User.new(name: 'bob')    # => true
+    #
+    #   users.find(&query)             # => #<User @name='bob'>
+    def finder(search)
+      Proc.new do |object|
+        search.all? do |attribute, expected|
+          value = object.send attribute if object.respond_to?(attribute)
+          expected == value || expected === value || (expected.respond_to?(:call) && expected.call(value))
+        end
+      end
+    end
+  end
+end

data/lib/queryable_array/shorthand.rb

@@ -0,0 +1,24 @@
+class QueryableArray < Array
+  module Shorthand
+    # If +key+ is a +Hash+ or an +Array+ containing one
+    # then it acts like an alias for +find_by+ or +find_all+ respectively. It
+    # behaves exactly like its superclass +Array+ in all other cases.
+    #
+    #   pages = QueryableArray.new Page.all
+    #
+    #   pages[uri: '/']                # => #<Page @uri='/' @name='Home'>
+    #   pages[uri: '/', name: 'Home']  # => #<Page @uri='/' @name='Home'>
+    #   pages[uri: '/', name: 'Typo']  # => nil
+    #
+    #   pages[[uri: '/']]                # => [#<Page @uri='/' @name='Home'>]
+    #   pages[[uri: '/', name: 'Typo']]  # => []
+    def [](key)
+      # Try to handle numeric indexes, ranges, and anything else that is
+      # natively supported by Array first
+      super
+    rescue TypeError => error
+      method, key = key.is_a?(Array) ? [:find_all, key.first] : [:find_by, key]
+      key.is_a?(Hash) ? send(method, key) : raise(error)
+    end
+  end
+end

data/lib/queryable_array/version.rb

@@ -0,0 +1,11 @@
+class QueryableArray < Array
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 0
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH].join('.')
+    end
+  end
+end

data/lib/queryable_array.rb

@@ -0,0 +1,16 @@
+require 'respond_to_missing'
+require 'queryable_array/dot_notation'
+require 'queryable_array/dynamic_finder'
+require 'queryable_array/queryable'
+require 'queryable_array/shorthand'
+
+# A +QueryableArray+ inherits from +Array+ and is intended to store a group of
+# objects which share the same attributes allowing them to be searched. It
+# overrides +[]+, +find_all+ and +method_missing+ to provide a simplified DSL
+# for looking up objects by querying their attributes.
+class QueryableArray < Array
+  include Queryable
+  include Shorthand
+  include DotNotation
+  include DynamicFinder
+end

data/test/queryable_array_test.rb

@@ -0,0 +1,187 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'queryable_array'
+
+describe QueryableArray do
+  let(:page) { Struct.new(:uri, :name) }
+  let(:pages) { (1..3).inject([]) { |pages, index| pages << page.new("page_#{index}", "PAGE_#{index}") } }
+  let(:collection) { QueryableArray.new pages, [:uri, :name] }
+
+  describe :[] do
+    it 'should accept Fixnum arguments' do
+      collection[0].must_equal pages[0]
+      collection[99].must_be_nil
+    end
+
+    it 'should lookup objects by default_finders' do
+      collection['page_1'].must_equal pages[0]
+      collection['PAGE_1'].must_equal pages[0]
+      collection['page_99'].must_be_nil
+    end
+
+    it 'should lookup objects by regex' do
+      collection[/page_1/].must_equal pages[0]
+    end
+
+    it 'should lookup objects by hash' do
+      collection[:uri => 'page_1'].must_equal pages[0]
+      collection[:uri => 'page_1', :name => 'PAGE_1'].must_equal pages[0]
+      collection[:uri => 'page_1', :name => 'INVALID'].must_equal nil
+    end
+
+    it 'should not accept shorthand searches if default_finders is nil' do
+      proc { QueryableArray.new(pages)['page_1'] }.must_raise TypeError
+    end
+
+    it 'should accept an array to return all matches' do
+      collection[['page_1']].must_equal [pages[0]]
+      collection[[/page/]].must_equal pages
+      collection[['missing']].must_equal []
+      collection[[:uri => 'page_1']].must_equal [pages[0]]
+      collection[[:uri => 'page_1', :name => 'PAGE_1']].must_equal [pages[0]]
+      collection[[:uri => /page/]].must_equal pages
+      collection[[:uri => 'page_1', :name => 'INVALID']].must_equal []
+    end
+
+    it 'should check all attributes before returning matches' do
+      struct = Struct.new(:first_name, :last_name)
+      collection = QueryableArray.new [struct.new('steve', 'hudson'), struct.new('hudson', 'jones')], [:first_name, :last_name]
+      collection[['hudson']].must_equal collection
+    end
+
+    it 'should accept a proc' do
+      collection[:name => proc { |name| $1.to_i == 2 if name =~ /.+?(\d+)$/ }].must_equal pages[1]
+      collection[proc { |page| page.uri == 'page_1' }].must_equal pages[0]
+    end
+
+    it 'should accept callable objects' do
+      callable = Class.new { def self.call(object); object.to_s == 'PAGE_1'; end }
+      collection[:name => callable].must_equal pages[0]
+      collection[callable].must_be_nil
+      pages[0].instance_eval { def to_s; 'PAGE_1'; end }
+      collection[callable].must_equal pages[0]
+    end
+
+    it 'should not throw NoMethodError if an attribute does not exist' do
+      collection[:missing => 'test'].must_be_nil
+      collection[[:missing => 'test']].must_equal []
+    end
+  end
+
+  describe :find_by do
+    it 'should only return the first match' do
+      struct = Struct.new(:name, :age)
+      collection = QueryableArray.new [struct.new('bob', 23), struct.new('steve', 23)]
+      collection.find_by(:age => 23).must_equal collection[0]
+    end
+  end
+
+  describe :find_all do
+    it 'should return a QueryableArray instance' do
+      collection.find_all { |page| page.uri == 'page_1' }.must_be_instance_of QueryableArray
+    end
+
+    it 'should lookup by search Hash' do
+      collection.find_all(:uri => 'page_1').must_equal [pages[0]]
+      collection.find_all(:uri => 'page_1', :name => 'PAGE_1').must_equal [pages[0]]
+      collection.find_all(:uri => 'page_1', :name => 'PAGE_3').must_equal []
+    end
+
+    it 'should lookup by regex matches' do
+      collection.find_all(:uri => /^page_\d$/).must_equal collection
+      collection.find_all(:uri => /^page_1$/).must_equal [pages[0]]
+    end
+
+    it 'should be aliased as find_all_by' do
+      collection.respond_to?(:find_all_by).must_equal true
+      collection.find_all_by(:uri => 'page_1').must_equal collection.find_all(:uri => 'page_1')
+    end
+  end
+
+  describe :finder? do
+    it 'should check if a method matches a finder' do
+      collection.finder?('find_by_name').wont_be_nil
+      collection.finder?('find_all_by_name').wont_be_nil
+      collection.finder?('find_by_name_and_uri').wont_be_nil
+      collection.finder?('find_all_by_name_and_uri').wont_be_nil
+      collection.finder?('find_by_nil?').wont_be_nil
+      collection.finder?('find_by_name!').wont_be_nil
+      collection.finder?('find_by').must_be_nil
+    end
+
+    describe 'a match' do
+      let(:match) { collection.finder?('find_all_by_name_and_email_address!') }
+      let(:singular) { collection.finder?('find_by_name') }
+      let(:keys) { [:method_name, :prefix, :type, :attributes, :suffix] }
+
+      it 'should return a Hash object' do
+        match.must_be_instance_of Hash
+      end
+
+      it 'should return results in a specific order' do
+        match.must_equal Hash[keys.zip %w[find_all_by_name_and_email_address! find_all_by all_by name_and_email_address !]]
+        singular.must_equal Hash[keys.zip ['find_by_name', 'find_by', 'by', 'name', nil]]
+      end
+    end
+  end
+
+  describe :method_missing do
+    it 'should pass finder methods to find_by' do
+      pages = collection.find_all_by_name('PAGE_1')
+      pages.size.must_equal 1
+      pages[0].name.must_equal 'PAGE_1'
+      collection.find_by_name('PAGE_1').must_equal pages[0]
+    end
+
+    it 'should allow searches by undefined methods' do
+      collection.find_by_undefined_method('PAGE_1').must_be_nil
+    end
+
+    it 'should allow multiple search attributes' do
+      collection.find_by_name_and_uri('PAGE_1', 'page_1').must_equal pages[0]
+      collection.find_by_name_and_uri('PAGE_1', 'page_3').must_be_nil
+    end
+
+    it 'should allow default finder lookups by method name using regex' do
+      collection.page_1.must_equal pages[0]
+      collection.PAGE_1.must_equal pages[0]
+      collection.pAgE_1.must_equal pages[0]
+      proc { collection.page_99 }.must_raise NoMethodError
+    end
+
+    it 'should allow strict default finder lookups by method name using the raw value' do
+      collection.page_1!.must_equal pages[0]
+      collection.PAGE_1!.must_equal pages[0]
+      proc { collection.pAgE_1! }.must_raise NoMethodError
+    end
+
+    it 'should pass non finder methods to super' do
+      proc { collection.missing }.must_raise NoMethodError
+    end
+
+    it 'should return a boolean when looking up using a ?' do
+      collection.page_1?.must_equal true
+      collection.pAgE_1?.must_equal true
+      collection.missing?.must_equal false
+    end
+  end
+
+  describe :respond_to_missing? do
+    it 'should check if the method is a finder' do
+      collection.respond_to?(:find_by_name).must_equal true
+      collection.respond_to?(:find_all_by_name).must_equal true
+      collection.respond_to?(:find_stuff).must_equal false
+      collection.respond_to?(:invalid).must_equal false
+    end
+
+    it 'should check if the method can be handled by DotNotation' do
+      collection.respond_to?(:page_1).must_equal true
+      collection.respond_to?(:PAGE_1).must_equal true
+      collection.respond_to?(:pAgE_1).must_equal true
+      collection.respond_to?(:page_1?).must_equal true
+      collection.respond_to?(:missing?).must_equal true
+      collection.respond_to?(:page_1!).must_equal true
+      collection.respond_to?(:pAgE_1!).must_equal false
+      collection.respond_to?(:missing).must_equal false
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'minitest/spec'
+require 'turn/autorun'
+
+Turn.config.format = :dot

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: queryable_array
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sean Huber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: respond_to_missing
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: QueryableArray is intended to store a group of objects which share the
+  same attributes allowing them to be searched with a simplified DSL
+email: shuber@huberry.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/queryable_array/default_finder.rb
+- lib/queryable_array/dot_notation.rb
+- lib/queryable_array/dynamic_finder.rb
+- lib/queryable_array/queryable.rb
+- lib/queryable_array/shorthand.rb
+- lib/queryable_array/version.rb
+- lib/queryable_array.rb
+- Gemfile
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- test/queryable_array_test.rb
+- test/test_helper.rb
+homepage: http://github.com/shuber/queryable_array
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides a simplified DSL allowing arrays of objects to be searched by their
+  attributes
+test_files:
+- test/queryable_array_test.rb
+- test/test_helper.rb