meta_search 0.3.0 → 0.5.0

data/lib/meta_search/utility.rb

@@ -57,7 +57,7 @@ module MetaSearch
     end
     
     def collapse_multiparameter_options(opts)
-      opts.each_key do |k|
+      opts.keys.each do |k|
         if k.include?("(")
           real_attribute, position = k.split(/\(|\)/)
           cast = %w(a s i).include?(position.last) ? position.last : nil

data/lib/meta_search/where.rb

@@ -12,14 +12,14 @@ module MetaSearch
   # === All data types
   #
   # * _equals_ (alias: _eq_) - Just as it sounds.
-  # * _does_not_equal_ (alias: _ne_) - The opposite of equals, oddly enough.
+  # * _does_not_equal_ (aliases: _ne_, _noteq_) - The opposite of equals, oddly enough.
   # * _in_ - Takes an array, matches on equality with any of the items in the array.
-  # * _not_in_ (alias: _ni_) - Like above, but negated.
+  # * _not_in_ (aliases: _ni_, _notin_) - Like above, but negated.
   #
   # === Strings
   #
-  # * _contains_ (alias: _like_) - Substring match.
-  # * _does_not_contain_ (alias: _nlike_) - Negative substring match.
+  # * _contains_ (aliases: _like_, _matches_) - Substring match.
+  # * _does_not_contain_ (aliases: _nlike_, _nmatches_) - Negative substring match.
   # * _starts_with_ (alias: _sw_) - Match strings beginning with the entered term.
   # * _does_not_start_with_ (alias: _dnsw_) - The opposite of above.
   # * _ends_with_ (alias: _ew_) - Match strings ending with the entered term.
@@ -28,9 +28,9 @@ module MetaSearch
   # === Numbers, dates, and times
   #
   # * _greater_than_ (alias: _gt_) - Greater than.
-  # * _greater_than_or_equal_to_ (alias: _gte_) - Greater than or equal to.
+  # * _greater_than_or_equal_to_ (aliases: _gte_, _gteq_) - Greater than or equal to.
   # * _less_than_ (alias: _lt_) - Less than.
-  # * _less_than_or_equal_to_ (alias: _lte_) - Less than or equal to.
+  # * _less_than_or_equal_to_ (aliases: _lte_, _lteq_) - Less than or equal to.
   #
   # So, given a model like this...
   #
@@ -43,8 +43,16 @@ module MetaSearch
   # ...you might end up with attributes like <tt>title_contains</tt>,
   # <tt>comments_title_starts_with</tt>, <tt>moderations_value_less_than</tt>,
   # <tt>author_name_equals</tt>, and so on.
+  #
+  # Additionally, all of the above predicate types also have an _any and _all version, which
+  # expects an array of the corresponding parameter type, and requires any or all of the
+  # parameters to be a match, respectively. So:
+  #
+  #   Article.search :author_name_starts_with_any => ['Jim', 'Bob', 'Fred']
+  #
+  # will match articles authored by Jimmy, Bobby, or Freddy, but not Winifred.
   class Where
-    attr_reader :name, :aliases, :types, :condition, :substitutions, :formatter
+    attr_reader :name, :aliases, :types, :predicate, :formatter, :validator
     def initialize(where)
       if [String,Symbol].include?(where.class)
         where = Where.get(where) or raise ArgumentError("A where could not be instantiated for the argument #{where}")
@@ -52,22 +60,33 @@ module MetaSearch
       @name = where[:name]
       @aliases = where[:aliases]
       @types = where[:types]
-      @condition = where[:condition]
-      @substitutions = where[:substitutions]
+      @predicate = where[:predicate]
+      @validator = where[:validator]
       @formatter = where[:formatter]
-      @keep_arrays = where[:keep_arrays]
+      @splat_param = where[:splat_param]
+    end
+    
+    def splat_param?
+      !!@splat_param
+    end
+    
+    # Format a parameter for searching using the Where's defined formatter.
+    def format_param(param)
+      formatter.call(param)
     end
     
-    def keep_arrays?
-      @keep_arrays
+    # Validate the parameter for use in a search using the Where's defined validator.
+    def validate(param)
+      validator.call(param)
     end
     
-    # Checks that the given +value+ is valid to use for the substitutions of this where.
-    # Requires that there are the same number of parameters as substitutions, and none of'
-    # them is blank.
-    def valid_substitutions?(*values)
-      values.flatten! unless values.size > 1 || self.keep_arrays?
-      self.substitutions.count('?') == values.select {|v| !v.blank?}.size
+    # Evaluate the Where for the given relation, attribute, and parameter(s)
+    def eval(relation, attribute, param)
+      if splat_param?
+        relation.where(attribute.send(predicate, *format_param(param)))
+      else
+        relation.where(attribute.send(predicate, format_param(param)))
+      end
     end
     
     class << self
@@ -75,11 +94,12 @@ module MetaSearch
       # in your application's <tt>config/initializers/meta_search.rb</tt>, place lines
       # like this:
       #
-      #   MetaSearch::Where.add :between, :btw, {
-      #     :types =>  [:integer, :float, :decimal, :date, :datetime, :timestamp, :time],
-      #     :condition => 'BETWEEN',
-      #     :substitutions => '? AND ?',
-      #     :formatter => Proc.new {|param| param}
+      # MetaSearch::Where.add :between, :btw,
+      #   :predicate => :in,
+      #   :types => [:integer, :float, :decimal, :date, :datetime, :timestamp, :time],
+      #   :formatter => Proc.new {|param| Range.new(param.first, param.last)},
+      #   :validator => Proc.new {|param|
+      #     param.is_a?(Array) && !(param[0].blank? || param[1].blank?)
       #   }
       #
       # The first options are all names for the where. Well, the first is a name, the rest
@@ -90,20 +110,8 @@ module MetaSearch
       # Which is one of several MetaSearch constants available for type assignment (the others
       # being +DATES+, +TIIMES+, +STRINGS+, and +NUMBERS+).
       #
-      # <tt>condition</tt> is the condition placed between the column and the substitutions, such as
-      # BETWEEN, IN, or =. Default is =.
-      #
-      # <tt>substitutions</tt> is the text that comes next. It's normally going to have some
-      # question marks in it (for variable substitution) if it's going to be of much use. The
-      # default is ?. Keep in mind if you use more than one ? MetaSearch will require an array
-      # be passed to the attribute for substitution.
-      #
-      # <tt>keep_arrays</tt> tells MetaSearch that if any arrays are received as parameters, they
-      # should be used as-is in the substitution, rather than flattened and passed as a list.
-      # For example, this is the definition of the "in" Where:
-      #
-      #   ['in', {:types => ALL_TYPES, :condition => 'IN', :substitutions => '(?)',
-      #    :keep_arrays => true}]
+      # <tt>predicate</tt> is the Arel::Attribute predication (read: conditional operator) used
+      # for the comparison. Default is :eq, or equality.
       #
       # <tt>formatter</tt> is the Proc that will do any formatting to the variables to be substituted.
       # The default proc is <tt>{|param| param}</tt>, which doesn't really do anything. If you pass a
@@ -111,25 +119,73 @@ module MetaSearch
       #
       # For example, this is the definition of the "contains" Where:
       #
-      #   ['contains', 'like', {:types => STRINGS, :condition => 'LIKE', :formatter => '"%#{param}%"'}]
+      #   ['contains', 'like', {:types => STRINGS, :predicate => :matches, :formatter => '"%#{param}%"'}]
       #
       # Be sure to single-quote the string, so that variables aren't interpolated until later. If in doubt,
       # just use a Proc.
+      #
+      # <tt>validator</tt> is the Proc that will be used to check whether a parameter supplied to the
+      # Where is valid. If it is not valid, it won't be used in the query. The default is
+      # <tt>{|param| !param.blank?}</tt>, so that empty parameters aren't added to the search, but you
+      # can get more complex if you desire, like the one in the between example, above.
+      #
+      # <tt>splat_param</tt>, if true, will cause the parameters sent to the predicate in question
+      # to be splatted (converted to an argument list). This is not normally useful and defaults to
+      # false, but is used when automatically creating compound Wheres (*_any, *_all) so that the
+      # Arel attribute method gets the correct parameter list.
       def add(*args)
+        where = create_where_from_args(*args)
+        create_where_compounds_for(where)
+      end
+      
+      # Returns the complete array of Wheres
+      def all
+        @@wheres
+      end
+      
+      # Get the where matching a method or predicate.
+      def get(method_id_or_predicate)
+        return nil unless where_key = @@wheres.keys.
+          sort {|a,b| b.length <=> a.length}.
+          detect {|n| method_id_or_predicate.to_s.match(/#{n}=?$/)}
+        where = @@wheres[where_key]
+        where = @@wheres[where] if where.is_a?(String)
+        where
+      end
+      
+      # Set the wheres to their default values, removing any customized settings.
+      def initialize_wheres
+        @@wheres = {}
+        DEFAULT_WHERES.each do |where|
+          add(*where)
+        end
+      end
+      
+      private
+      
+      # "Creates" the Where by adding it (and its aliases) to the current hash of wheres. It then
+      # instantiates a Where and returns it for use.
+      def create_where_from_args(*args)
         opts = args.last.is_a?(Hash) ? args.pop : {}
         args = args.compact.flatten.map {|a| a.to_s }
         raise ArgumentError, "Name parameter required" if args.blank?
         opts[:name] ||= args.first
         opts[:types] ||= ALL_TYPES
         opts[:types] = [opts[:types]].flatten
-        opts[:condition] ||= '='
-        opts[:substitutions] ||= '?'
-        opts[:keep_arrays] ||= false
+        opts[:predicate] ||= :eq
+        opts[:splat_param] ||= false
         opts[:formatter] ||= Proc.new {|param| param}
         if opts[:formatter].is_a?(String)
           formatter = opts[:formatter]
           opts[:formatter] = Proc.new {|param| eval formatter}
         end
+        unless opts[:formatter].respond_to?(:call)
+          raise ArgumentError, "Invalid formatter for #{opts[:name]}, should be a Proc or String."
+        end
+        opts[:validator] ||= Proc.new {|param| !param.blank?}
+        unless opts[:validator].respond_to?(:call)
+          raise ArgumentError, "Invalid validator for #{opts[:name]}, should be a Proc."
+        end
         opts[:aliases] ||= [args - [opts[:name]]].flatten
         @@wheres ||= {}
         if @@wheres.has_key?(opts[:name])
@@ -143,28 +199,30 @@ module MetaSearch
             @@wheres[a] = opts[:name]
           end
         end
+        new(opts[:name])
       end
       
-      # Returns the complete array of Wheres
-      def all
-        @@wheres
-      end
-      
-      # Get the where matching a method or condition.
-      def get(method_id_or_condition)
-        return nil unless where_key = @@wheres.keys.
-          sort {|a,b| b.length <=> a.length}.
-          detect {|n| method_id_or_condition.to_s.match(/#{n}=?$/)}
-        where = @@wheres[where_key]
-        where = @@wheres[where] if where.is_a?(String)
-        where
-      end
-      
-      # Set the wheres to their default values, removing any customized settings.
-      def initialize_wheres
-        @@wheres = {}
-        DEFAULT_WHERES.each do |where|
-          add(*where)
+      # Takes the provided +where+ param and derives two additional Wheres from it, with the
+      # name appended by _any/_all. These will use Arel's grouped predicate methods (matching
+      # the same naming convention) to be invoked instead, with a list of possible/required
+      # matches.
+      def create_where_compounds_for(where)
+        ['any', 'all'].each do |compound|
+          args = [where.name, *where.aliases].map {|n| "#{n}_#{compound}"}
+          create_where_from_args(*args + [{
+            :types => where.types,
+            :predicate => "#{where.predicate}_#{compound}".to_sym,
+            :splat_param => true,
+            # Only use valid elements in the array
+            :formatter => Proc.new {|param|
+              param.select {|p| where.validator.call(p)}.map {|p| where.formatter.call(p)}
+            },
+            # Compound where is valid if it has at least one element which is valid
+            :validator => Proc.new {|param|
+              param.is_a?(Array) &&
+              !param.select {|p| where.validator.call(p)}.blank?}
+            }]
+          )
         end
       end
     end

data/meta_search.gemspec

@@ -5,12 +5,16 @@
 
 Gem::Specification.new do |s|
   s.name = %q{meta_search}
-  s.version = "0.3.0"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ernie Miller"]
-  s.date = %q{2010-03-16}
-  s.description = %q{Adds a search method to your ActiveRecord models which returns an object to be used in form_for while constructing a search. Works with Rails 3 only.}
+  s.date = %q{2010-06-08}
+  s.description = %q{
+      Allows simple search forms to be created against an AR3 model
+      and its associations, has useful view helpers for sort links
+      and multiparameter fields as well.
+    }
   s.email = %q{ernie@metautonomo.us}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -19,6 +23,8 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
      ".gitignore",
+     ".gitmodules",
+     "Gemfile",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
@@ -26,11 +32,13 @@ Gem::Specification.new do |s|
      "lib/meta_search.rb",
      "lib/meta_search/builder.rb",
      "lib/meta_search/exceptions.rb",
-     "lib/meta_search/helpers/action_view.rb",
+     "lib/meta_search/helpers.rb",
+     "lib/meta_search/helpers/form_builder.rb",
+     "lib/meta_search/helpers/form_helper.rb",
+     "lib/meta_search/helpers/url_helper.rb",
+     "lib/meta_search/method.rb",
      "lib/meta_search/model_compatibility.rb",
-     "lib/meta_search/railtie.rb",
      "lib/meta_search/searches/active_record.rb",
-     "lib/meta_search/searches/base.rb",
      "lib/meta_search/utility.rb",
      "lib/meta_search/where.rb",
      "meta_search.gemspec",
@@ -50,11 +58,11 @@ Gem::Specification.new do |s|
      "test/test_search.rb",
      "test/test_view_helpers.rb"
   ]
-  s.homepage = %q{http://metautonomo.us}
+  s.homepage = %q{http://metautonomo.us/projects/metasearch/}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{ActiveRecord 3 object-based searching.}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{ActiveRecord 3 object-based searching for your form_for enjoyment.}
   s.test_files = [
     "test/fixtures/company.rb",
      "test/fixtures/data_type.rb",
@@ -71,13 +79,25 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<activerecord>, [">= 3.0.0.beta"])
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 3.0.0.beta4"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.0.beta4"])
+      s.add_runtime_dependency(%q<actionpack>, [">= 3.0.0.beta4"])
+      s.add_runtime_dependency(%q<arel>, [">= 0.4.0"])
     else
-      s.add_dependency(%q<activerecord>, [">= 3.0.0.beta"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<activerecord>, [">= 3.0.0.beta4"])
+      s.add_dependency(%q<activesupport>, [">= 3.0.0.beta4"])
+      s.add_dependency(%q<actionpack>, [">= 3.0.0.beta4"])
+      s.add_dependency(%q<arel>, [">= 0.4.0"])
     end
   else
-    s.add_dependency(%q<activerecord>, [">= 3.0.0.beta"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<activerecord>, [">= 3.0.0.beta4"])
+    s.add_dependency(%q<activesupport>, [">= 3.0.0.beta4"])
+    s.add_dependency(%q<actionpack>, [">= 3.0.0.beta4"])
+    s.add_dependency(%q<arel>, [">= 0.4.0"])
   end
 end
 

data/test/fixtures/company.rb

@@ -4,6 +4,19 @@ class Company < ActiveRecord::Base
   has_many :slackers, :class_name => "Developer", :conditions => {:slacker => true}
   has_many :notes, :as => :notable
   has_many :data_types
-  metasearch_exclude_attr :updated_at
-  metasearch_exclude_assoc :notes
+  
+  scope :backwards_name, lambda {|name| where(:name => name.reverse)}
+  scope :with_slackers_by_name_and_salary_range,
+    lambda {|name, low, high|
+      joins(:slackers).where(:developers => {:name => name, :salary => low..high})
+    }
+  search_methods :backwards_name, :backwards_name_as_string
+  search_methods :with_slackers_by_name_and_salary_range,
+    :splat_param => true, :type => [:string, :integer, :integer]
+  attr_unsearchable :updated_at
+  assoc_unsearchable :notes
+  
+  def self.backwards_name_as_string(name)
+    name.reverse
+  end
 end

data/test/fixtures/data_types.yml

@@ -6,9 +6,9 @@ dt_<%= n %>:
   int       : <%= n ** 3 %>
   flt       : <%= n.to_f / 2.0 %>
   dec       : <%= n.to_f ** (n + 0.1) %>
-  dtm       : <%= Time.utc(2009, 12, 24) + 86400 * n %>
-  tms       : <%= Time.utc(2009, 12, 24) + 86400 * n %>
-  tim       : <%= Time.utc(2000, 01, 01, n+8, n) %>
+  dtm       : <%= (Time.utc(2009, 12, 24) + 86400 * n).to_s(:db) %>
+  tms       : <%= (Time.utc(2009, 12, 24) + 86400 * n).to_s(:db) %>
+  tim       : <%= Time.utc(2000, 01, 01, n+8, n).to_s(:db) %>
   dat       : <%= (Date.new(2009, 12, 24) + n).strftime("%Y-%m-%d") %>
   bin       : <%= "BLOB#{n}" * n %>
   bln       : <%= n % 2 > 0 ? true : false %>

data/test/fixtures/developer.rb

@@ -2,4 +2,7 @@ class Developer < ActiveRecord::Base
   belongs_to :company
   has_and_belongs_to_many :projects
   has_many :notes, :as => :notable
+  
+  attr_searchable :name, :salary
+  assoc_searchable :notes, :projects, :company
 end

data/test/helper.rb

@@ -10,7 +10,7 @@ FIXTURES_PATH = File.join(File.dirname(__FILE__), 'fixtures')
 Time.zone = 'Eastern Time (US & Canada)'
 
 ActiveRecord::Base.establish_connection(
-  :adapter => 'sqlite3',
+  :adapter => defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3',
   :database => ':memory:'
 )
 
@@ -27,11 +27,15 @@ Fixtures.create_fixtures(FIXTURES_PATH, ActiveRecord::Base.connection.tables)
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'meta_search'
-require 'meta_search/searches/active_record'
-require 'meta_search/helpers/action_view'
-
-MetaSearch::Searches::ActiveRecord.enable!
-MetaSearch::Helpers::FormBuilder.enable!
 
 class Test::Unit::TestCase
+  def self.context_a_search_against(name, object, &block)
+    context "A search against #{name}" do
+      setup do
+        @s = object.search
+      end
+
+      merge_block(&block) if block_given?
+    end
+  end
 end

data/test/test_search.rb

@@ -1,350 +1,564 @@
 require 'helper'
 
 class TestSearch < Test::Unit::TestCase
-  
-  context "A company search" do
-    setup do
-      @s = Company.search
-    end
-    
-    should "have an association named developers" do
-      assert @s.association(:developers)
-    end
-    
-    should "have a column named name" do
-      assert @s.column(:name)
-    end
-      
-    should "exclude the column named updated_at" do
-      assert_nil @s.column(:updated_at)
-    end
-    
-    should "raise an error if we try to search on updated_at" do
-      assert_raise NoMethodError do
-        @s.updated_at_eq = [2009, 1, 1]
-      end
-    end
-    
-    should "exclude the association named notes" do
-      assert_nil @s.association(:notes)
-    end
-    
-    should "raise an error if we try to search on notes" do
-      assert_raise NoMethodError do
-        @s.notes_note_eq = 'Blah'
+
+  [{:name => 'Company', :object => Company},
+   {:name => 'Company as a Relation', :object => Company.scoped}].each do |object|
+    context_a_search_against object[:name], object[:object] do
+      should "have a relation attribute which is an ActiveRecord::Relation" do
+        assert_equal ActiveRecord::Relation, @s.relation.class
       end
-    end
-    
-    should "honor its associations' excluded attributes" do
-      assert_nil @s.association_column(:data_types, :str)
-    end
-    
-    should "raise an error if we try to search data_types.str" do
-      assert_raise NoMethodError do
-        @s.data_types_str_eq = 'Blah'
+
+      should "have a base attribute which is a Class inheriting from ActiveRecord::Base" do
+        assert_equal Company, @s.base
+        assert_contains @s.base.ancestors, ActiveRecord::Base
       end
-    end
-    
-    context "where name contains optical" do
-      setup do
-        @s.name_contains = 'optical'
+
+      should "have an association named developers" do
+        assert @s.get_association(:developers)
       end
-    
-      should "return one result" do
-        assert_equal 1, @s.all.size
+
+      should "have a column named name" do
+        assert @s.get_column(:name)
       end
-    
-      should "return a company named Advanced Optical Solutions" do
-        assert_contains @s.all, Company.where(:name => 'Advanced Optical Solutions').first
+
+      should "exclude the column named updated_at" do
+        assert_nil @s.get_column(:updated_at)
       end
-    
-      should "not return a company named Initech" do
-        assert_does_not_contain @s.all, Company.where(:name => "Initech").first
+
+      should "raise an error if we try to search on updated_at" do
+        assert_raise NoMethodError do
+          @s.updated_at_eq = [2009, 1, 1]
+        end
       end
-    end
-  
-    context "where developer name starts with Ernie" do
-      setup do
-        @s.developers_name_starts_with = 'Ernie'
+
+      should "exclude the association named notes" do
+        assert_nil @s.get_association(:notes)
       end
-    
-      should "return one result" do
-        assert_equal 1, @s.all.size
+
+      should "raise an error if we try to search on notes" do
+        assert_raise NoMethodError do
+          @s.notes_note_eq = 'Blah'
+        end
       end
-      
-      should "return a company named Mission Data" do
-        assert_contains @s.all, Company.where(:name => 'Mission Data').first
+
+      should "honor its associations' excluded attributes" do
+        assert_nil @s.get_attribute(:data_types_str)
       end
-    
-      should "not return a company named Initech" do
-        assert_does_not_contain @s.all, Company.where(:name => "Initech").first
+
+      should "raise an error if we try to search data_types.str" do
+        assert_raise NoMethodError do
+          @s.data_types_str_eq = 'Blah'
+        end
       end
-      
-      context "and slackers salary is greater than $70k" do
+
+      context "sorted by name in ascending order" do
         setup do
-          @s.slackers_salary_gt = 70000
+          @s.meta_sort = 'name.asc'
         end
-        
-        should "return no results" do
-          assert_equal 0, @s.all.size
+
+        should "sort by name in ascending order" do
+          assert_equal Company.order('name asc').all,
+                       @s.all
         end
-        
-        should "join developers twice" do
-          assert @s.to_sql.match(/join "developers".*join "developers"/i)
+      end
+
+      context "sorted by name in descending order" do
+        setup do
+          @s.meta_sort = 'name.desc'
         end
-        
-        should "alias the second join of developers" do
-          assert @s.to_sql.match(/join "developers" "slackers_companies"/i)
+
+        should "sort by name in descending order" do
+          assert_equal Company.order('name desc').all,
+                       @s.all
         end
       end
-    end
-    
-    context "where developer note indicates he will crack yo skull" do
-      setup do
-        @s.developer_notes_note_equals = "Will show you what he's doing."
-      end
-      
-      should "return one result" do
-        assert_equal 1, @s.all.size
-      end
-      
-      should "return a company named Advanced Optical Solutions" do
-        assert_contains @s.all, Company.where(:name => 'Advanced Optical Solutions').first
-      end
-    
-      should "not return a company named Mission Data" do
-        assert_does_not_contain @s.all, Company.where(:name => "Mission Data").first
-      end
-    end
-  end
-  
-  context "A developer search" do
-    setup do
-      @s = Developer.search
-    end
-    
-    should "have an association named projects" do
-      assert @s.association(:projects)
-    end
-    
-    context "where developer is Bob-approved" do
-      setup do
-        @s.notes_note_equals = "A straight shooter with upper management written all over him."
-      end
-      
-      should "return Peter Gibbons" do
-        assert_contains @s.all, Developer.where(:name => 'Peter Gibbons').first
+
+      context "where name contains optical" do
+        setup do
+          @s.name_contains = 'optical'
+        end
+
+        should "return one result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "return a company named Advanced Optical Solutions" do
+          assert_contains @s.all, Company.where(:name => 'Advanced Optical Solutions').first
+        end
+
+        should "not return a company named Initech" do
+          assert_does_not_contain @s.all, Company.where(:name => "Initech").first
+        end
       end
-    end
-    
-    context "where name ends with Miller" do
-      setup do
-        @s.name_ends_with = 'Miller'
+
+      context "where developer name starts with Ernie" do
+        setup do
+          @s.developers_name_starts_with = 'Ernie'
+        end
+
+        should "return one result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "return a company named Mission Data" do
+          assert_contains @s.all, Company.where(:name => 'Mission Data').first
+        end
+
+        should "not return a company named Initech" do
+          assert_does_not_contain @s.all, Company.where(:name => "Initech").first
+        end
+
+        context "and slackers salary is greater than $70k" do
+          setup do
+            @s.slackers_salary_gt = 70000
+          end
+
+          should "return no results" do
+            assert_equal 0, @s.all.size
+          end
+
+          should "join developers twice" do
+            assert @s.to_sql.match(/join\s+"?developers"?.*join\s+"?developers"?/i)
+          end
+
+          should "alias the second join of developers" do
+            assert @s.to_sql.match(/join\s+"?developers"?\s+"?slackers_companies"?/i)
+          end
+        end
       end
-      
-      should "return one result" do
-        assert_equal 1, @s.all.size
+
+      context "where developer note indicates he will crack yo skull" do
+        setup do
+          @s.developer_notes_note_equals = "Will show you what he's doing."
+        end
+
+        should "return one result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "return a company named Advanced Optical Solutions" do
+          assert_contains @s.all, Company.where(:name => 'Advanced Optical Solutions').first
+        end
+
+        should "not return a company named Mission Data" do
+          assert_does_not_contain @s.all, Company.where(:name => "Mission Data").first
+        end
       end
-      
-      should "return a developer named Ernie Miller" do
-        assert_contains @s.all, Developer.where(:name => 'Ernie Miller').first
+
+      context "where developer note indicates he will crack yo skull through two associations" do
+        setup do
+          @s.developers_notes_note_equals = "Will show you what he's doing."
+        end
+
+        should "return one result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "return a company named Advanced Optical Solutions" do
+          assert_contains @s.all, Company.where(:name => 'Advanced Optical Solutions').first
+        end
+
+        should "not return a company named Mission Data" do
+          assert_does_not_contain @s.all, Company.where(:name => "Mission Data").first
+        end
       end
-    
-      should "not return a developer named Herb Myers" do
-        assert_does_not_contain @s.all, Developer.where(:name => "Herb Myers").first
+
+      context "where developer note indicates he will crack yo skull through four associations" do
+        setup do
+          @s.developers_company_developers_notes_note_equals = "Will show you what he's doing."
+        end
+
+        should "return two results, one of which is a duplicate due to joins" do
+          assert_equal 2, @s.all.size
+          assert_equal 1, @s.all.uniq.size
+        end
+
+        should "return a company named Advanced Optical Solutions" do
+          assert_contains @s.all, Company.where(:name => 'Advanced Optical Solutions').first
+        end
+
+        should "not return a company named Mission Data" do
+          assert_does_not_contain @s.all, Company.where(:name => "Mission Data").first
+        end
       end
-    end
-    
-    context "where project estimated hours are greater than or equal to 1000" do
-      setup do
-        @s.projects_estimated_hours_gte = 1000
+
+      context "with a join more than five tables deep (including source table)" do
+        setup do
+          @s.developers_company_developers_company_developers_name_equals = "Ernie Miller"
+        end
+
+        should "raise an error when the relation is accessed" do
+          assert_raise MetaSearch::JoinDepthError do
+            @s.all
+          end
+        end
       end
-      
-      should "return three results" do
-        assert_equal 3, @s.all.size
+
+      context "where backwards name is hcetinI" do
+        setup do
+          @s.backwards_name = 'hcetinI'
+        end
+
+        should "return 1 result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "return a company named Initech" do
+          assert_contains @s.all, Company.where(:name => 'Initech').first
+        end
       end
-      
-      should "return these developers" do
-        assert_same_elements @s.all.collect {|d| d.name},
-                             ['Peter Gibbons', 'Michael Bolton', 'Samir Nagheenanajar']
+
+      context "where with_slackers_by_name_and_salary_range is sent an array with 3 values" do
+        setup do
+          @s.with_slackers_by_name_and_salary_range = ['Peter Gibbons', 90000, 110000]
+        end
+
+        should "return 1 result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "return a company named Initech" do
+          assert_contains @s.all, Company.where(:name => 'Initech').first
+        end
       end
-    end
-    
-    context "where project estimated hours are greater than 1000" do
-      setup do
-        @s.projects_estimated_hours_gt = 1000
+
+      should "raise an error when the wrong number of parameters would be supplied to a custom search" do
+        assert_raise ArgumentError do
+          @s.with_slackers_by_name_and_salary_range = ['Peter Gibbons', 90000]
+        end
       end
-      
-      should "return no results" do
-        assert_equal 0, @s.all.size
+
+      should "raise an error when a custom search method does not return a relation" do
+        assert_raise MetaSearch::NonRelationReturnedError do
+          @s.backwards_name_as_string = 'hcetinI'
+        end
       end
     end
   end
-  
-  context "A data type search" do
-    setup do
-      @s = DataType.search
-    end
-    
-    should "raise an error on a contains search against a boolean column" do
-      assert_raise NoMethodError do
-        @s.bln_contains = "true"
-      end
-    end
-    
-    context "where boolean column equals true" do
-      setup do
-        @s.bln_equals = true
-      end
-      
-      should "return five results" do
-        assert_equal 5, @s.all.size
+
+  [{:name => 'Developer', :object => Developer},
+   {:name => 'Developer as a Relation', :object => Developer.scoped}].each do |object|
+    context_a_search_against object[:name], object[:object] do
+      should "exclude the column named company_id" do
+        assert_nil @s.get_column(:company_id)
       end
-      
-      should "contain no results with a false boolean column" do
-        assert_does_not_contain @s.all.collect {|r| r.bln}, false
+
+      should "have an association named projects" do
+        assert @s.get_association(:projects)
       end
-    end
-    
-    context "where date column is Christmas 2009 by array" do
-      setup do
-        @s.dat_equals = [2009, 12, 25]
+
+      context "sorted by company name in ascending order" do
+        setup do
+          @s.meta_sort = 'company_name.asc'
+        end
+
+        should "sort by company name in ascending order" do
+          assert_equal Developer.joins(:company).order('companies.name asc').all,
+                       @s.all
+        end
       end
-      
-      should "return one result" do
-        assert_equal 1, @s.all.size
+
+      context "sorted by company name in descending order" do
+        setup do
+          @s.meta_sort = 'company_name.desc'
+        end
+
+        should "sort by company name in descending order" do
+          assert_equal Developer.joins(:company).order('companies.name desc').all,
+                       @s.all
+        end
       end
-      
-      should "contain a result with Christmas 2009 as its date" do
-        assert_equal Date.parse('2009/12/25'), @s.first.dat
+
+      context "where developer is Bob-approved" do
+        setup do
+          @s.notes_note_equals = "A straight shooter with upper management written all over him."
+        end
+
+        should "return Peter Gibbons" do
+          assert_contains @s.all, Developer.where(:name => 'Peter Gibbons').first
+        end
       end
-    end
-    
-    context "where date column is Christmas 2009 by Date object" do
-      setup do
-        @s.dat_equals = Date.new(2009, 12, 25)
+
+      context "where name ends with Miller" do
+        setup do
+          @s.name_ends_with = 'Miller'
+        end
+
+        should "return one result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "return a developer named Ernie Miller" do
+          assert_contains @s.all, Developer.where(:name => 'Ernie Miller').first
+        end
+
+        should "not return a developer named Herb Myers" do
+          assert_does_not_contain @s.all, Developer.where(:name => "Herb Myers").first
+        end
       end
-      
-      should "return one result" do
-        assert_equal 1, @s.all.size
+
+      context "where name starts with any of Ernie, Herb, or Peter" do
+        setup do
+          @s.name_starts_with_any = ['Ernie', 'Herb', 'Peter']
+        end
+
+        should "return three results" do
+          assert_equal 3, @s.all.size
+        end
+
+        should "return a developer named Ernie Miller" do
+          assert_contains @s.all, Developer.where(:name => 'Ernie Miller').first
+        end
+
+        should "not return a developer named Samir Nagheenanajar" do
+          assert_does_not_contain @s.all, Developer.where(:name => "Samir Nagheenanajar").first
+        end
       end
-      
-      should "contain a result with Christmas 2009 as its date" do
-        assert_equal Date.parse('2009/12/25'), @s.first.dat
+
+      context "where name does not equal Ernie Miller" do
+        setup do
+          @s.name_ne = 'Ernie Miller'
+        end
+
+        should "return seven results" do
+          assert_equal 7, @s.all.size
+        end
+
+        should "not return a developer named Ernie Miller" do
+          assert_does_not_contain @s.all, Developer.where(:name => "Ernie Miller").first
+        end
       end
-    end
-    
-    context "where time column is > 1:00 PM and < 3:30 PM" do
-      setup do
-        @s.tim_gt = Time.parse('2000-01-01 13:00') # Rails "dummy time" format
-        @s.tim_lt = Time.parse('2000-01-01 15:30') # Rails "dummy time" format
+
+      context "where name contains all of a, e, and i" do
+        setup do
+          @s.name_contains_all = ['a', 'e', 'i']
+        end
+
+        should "return two results" do
+          assert_equal 2, @s.all.size
+        end
+
+        should "return a developer named Samir Nagheenanajar" do
+          assert_contains @s.all, Developer.where(:name => "Samir Nagheenanajar").first
+        end
+
+        should "not return a developer named Ernie Miller" do
+          assert_does_not_contain @s.all, Developer.where(:name => 'Ernie Miller').first
+        end
       end
-      
-      should "return three results" do
-        assert_equal 3, @s.all.size
+
+      context "where project estimated hours are greater than or equal to 1000" do
+        setup do
+          @s.projects_estimated_hours_gte = 1000
+        end
+
+        should "return three results" do
+          assert_equal 3, @s.all.size
+        end
+
+        should "return these developers" do
+          assert_same_elements @s.all.collect {|d| d.name},
+                               ['Peter Gibbons', 'Michael Bolton', 'Samir Nagheenanajar']
+        end
       end
-      
-      should "not contain results with time column before or after constraints" do
-        assert_empty @s.all.select {|r|
-          r.tim < Time.parse('2000-01-01 13:00') || r.tim > Time.parse('2000-01-01 15:30')
-        }
+
+      context "where project estimated hours are greater than 1000" do
+        setup do
+          @s.projects_estimated_hours_gt = 1000
+        end
+
+        should "return no results" do
+          assert_equal 0, @s.all.size
+        end
       end
     end
-    
-    context "where timestamp column is in the year 2010" do
-      setup do
-        @s.tms_gte = Time.utc(2010, 1, 1)
-      end
-      
-      should "return two results" do
-        assert_equal 2, @s.all.size
+  end
+
+  [{:name => 'DataType', :object => DataType},
+   {:name => 'DataType as a Relation', :object => DataType.scoped}].each do |object|
+    context_a_search_against object[:name], object[:object] do
+      should "raise an error on a contains search against a boolean column" do
+        assert_raise NoMethodError do
+          @s.bln_contains = "true"
+        end
       end
-      
-      should "not contain results with timestamp column before 2010" do
-        assert_empty @s.all.select {|r|
-          r.tms < Time.utc(2010, 1, 1)
-        }
+
+      context "where boolean column equals true" do
+        setup do
+          @s.bln_equals = true
+        end
+
+        should "return five results" do
+          assert_equal 5, @s.all.size
+        end
+
+        should "contain no results with a false boolean column" do
+          assert_does_not_contain @s.all.collect {|r| r.bln}, false
+        end
       end
-    end
-    
-    context "where datetime column is before the year 2010" do
-      setup do
-        @s.tms_lt = Time.utc(2010, 1, 1)
+
+      context "where date column is Christmas 2009 by array" do
+        setup do
+          @s.dat_equals = [2009, 12, 25]
+        end
+
+        should "return one result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "contain a result with Christmas 2009 as its date" do
+          assert_equal Date.parse('2009/12/25'), @s.first.dat
+        end
       end
-      
-      should "return seven results" do
-        assert_equal 7, @s.all.size
+
+      context "where date column is Christmas 2009 by Date object" do
+        setup do
+          @s.dat_equals = Date.new(2009, 12, 25)
+        end
+
+        should "return one result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "contain a result with Christmas 2009 as its date" do
+          assert_equal Date.parse('2009/12/25'), @s.first.dat
+        end
       end
-      
-      should "not contain results with timestamp in 2010" do
-        assert_empty @s.all.select {|r|
-          r.tms >= Time.utc(2010, 1, 1)
-        }
+
+      context "where time column is > 1:00 PM and < 3:30 PM" do
+        setup do
+          @s.tim_gt = Time.parse('2000-01-01 13:00') # Rails "dummy time" format
+          @s.tim_lt = Time.parse('2000-01-01 15:30') # Rails "dummy time" format
+        end
+
+        should "return three results" do
+          assert_equal 3, @s.all.size
+        end
+
+        should "not contain results with time column before or after constraints" do
+          assert_equal [], @s.all.select {|r|
+            r.tim < Time.parse('2000-01-01 13:00') || r.tim > Time.parse('2000-01-01 15:30')
+          }
+        end
       end
-    end
-    
-    context "where decimal column is  > 5000" do
-      setup do
-        @s.dec_gt = 5000
+
+      context "where timestamp column is in the year 2010" do
+        setup do
+          @s.tms_gte = Time.utc(2010, 1, 1)
+        end
+
+        should "return two results" do
+          assert_equal 2, @s.all.size
+        end
+
+        should "not contain results with timestamp column before 2010" do
+          assert_equal [], @s.all.select {|r|
+            r.tms < Time.utc(2010, 1, 1)
+          }
+        end
       end
-      
-      should "return four results" do
-        assert_equal 4, @s.all.size
+
+      context "where timestamp column is before the year 2010" do
+        setup do
+          @s.tms_lt = Time.utc(2010, 1, 1)
+        end
+
+        should "return seven results" do
+          assert_equal 7, @s.all.size
+        end
+
+        should "not contain results with timestamp in 2010" do
+          assert_equal [], @s.all.select {|r|
+            r.tms >= Time.utc(2010, 1, 1)
+          }
+        end
       end
-      
-      should "not contain results with decimal column <= 5000" do
-        assert_empty @s.all.select {|r|
-          r.dec <= 5000
-        }
+
+      context "where decimal column is  > 5000" do
+        setup do
+          @s.dec_gt = 5000
+        end
+
+        should "return four results" do
+          assert_equal 4, @s.all.size
+        end
+
+        should "not contain results with decimal column <= 5000" do
+          assert_equal [], @s.all.select {|r|
+            r.dec <= 5000
+          }
+        end
       end
-    end
-    
-    context "where float column is between 2.5 and 3.5" do
-      setup do
-        @s.flt_gte = 2.5
-        @s.flt_lte = 3.5
+
+      context "where float column is between 2.5 and 3.5" do
+        setup do
+          @s.flt_gte = 2.5
+          @s.flt_lte = 3.5
+        end
+
+        should "return three results" do
+          assert_equal 3, @s.all.size
+        end
+
+        should "not contain results with float column outside constraints" do
+          assert_equal [], @s.all.select {|r|
+            r.flt < 2.5 || r.flt > 3.5
+          }
+        end
       end
-      
-      should "return three results" do
-        assert_equal 3, @s.all.size
+
+      context "where integer column is in the set (1, 8, 729)" do
+        setup do
+          @s.int_in = [1, 8, 729]
+        end
+
+        should "return three results" do
+          assert_equal 3, @s.all.size
+        end
+
+        should "not contain results outside the specified set" do
+          assert_equal [], @s.all.select {|r|
+            ![1, 8, 729].include?(r.int)
+          }
+        end
       end
-      
-      should "not contain results with float column outside constraints" do
-        assert_empty @s.all.select {|r|
-          r.flt < 2.5 || r.flt > 3.5
-        }
+
+      context "where integer column is not in the set (1, 8, 729)" do
+        setup do
+          @s.int_not_in = [1, 8, 729]
+        end
+
+        should "return six results" do
+          assert_equal 6, @s.all.size
+        end
+
+        should "not contain results outside the specified set" do
+          assert_equal [], @s.all.reject {|r|
+            ![1, 8, 729].include?(r.int)
+          }
+        end
       end
     end
-    
-    context "where integer column is in the set (1, 8, 729)" do
-      setup do
-        @s.int_in = [1, 8, 729]
-      end
-      
-      should "return three results" do
-        assert_equal 3, @s.all.size
-      end
-      
-      should "not contain results outside the specified set" do
-        assert_empty @s.all.select {|r|
-          ![1, 8, 729].include?(r.int)
-        }
-      end
+  end
+
+  context_a_search_against "a relation with existing criteria and joins",
+                           Company.where(:name => "Initech").joins(:developers) do
+    should "return the same results as a non-searched relation with no search terms" do
+      assert_equal Company.where(:name => "Initech").joins(:developers).all, @s.all
     end
-    
-    context "where integer column is not in the set (1, 8, 729)" do
+
+    context "with a search against the joined association's data" do
       setup do
-        @s.int_not_in = [1, 8, 729]
+        @s.developers_salary_less_than = 75000
       end
-      
-      should "return six results" do
-        assert_equal 6, @s.all.size
+
+      should "not ask to join the association twice" do
+        assert_equal 1, @s.relation.joins_values.size
       end
-      
-      should "not contain results outside the specified set" do
-        assert_empty @s.all.reject {|r|
-          ![1, 8, 729].include?(r.int)
-        }
+
+      should "return a filtered result set based on the criteria of the searched relation" do
+        assert_equal Company.where(:name => 'Initech').all, @s.all.uniq
       end
     end
   end