meta_search 0.3.0 → 0.5.0

data/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "vendor/rails"]
+	path = vendor/rails
+	url = git://github.com/rails/rails.git
+[submodule "vendor/arel"]
+	path = vendor/arel
+	url = git://github.com/ernie/arel.git

data/Gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+gem "arel", ">= 0.4.0"
+gem "rails", ">= 3.0.0.beta4"
+group :test do
+  gem "rake"
+  gem "shoulda"
+end

data/README.rdoc

@@ -1,23 +1,28 @@
 = MetaSearch
 
-Extensible searching for your form_for enjoyment.
+MetaSearch is extensible searching for your form_for enjoyment. It “wraps” one of your ActiveRecord models, providing methods that allow you to build up search conditions against that model, and has a few extra form helpers to simplify sorting and supplying multiple parameters to your condition methods as well.
 
 == Getting Started
 
-Add a line to your Gemfile:
+In your Gemfile:
 
-  gem "meta_search"
+  gem "meta_search"  # Last officially released gem
+  # gem "meta_search", :git => "git://github.com/ernie/meta_search.git" # Track git repo
+
+or, to install as a plugin:
+
+  rails plugin install git://github.com/ernie/meta_search.git
 
 In your controller:
 
   def index
     @search = Article.search(params[:search])
-    @articles = @search.all
+    @articles = @search.all   # or @search.relation to lazy load in view
   end
 
 In your view:
 
-  <% form_for :search, @search, :html => {:method => :get} do |f| %>
+  <%= form_for @search, :url => articles_path, :html => {:method => :get} do |f| %>
     <%= f.label :title_contains %>
     <%= f.text_field :title_contains %><br />
     <%= f.label :comments_created_at_greater_than, 'With comments after' %>
@@ -25,21 +30,107 @@ In your view:
     <!-- etc... -->
     <%= f.submit %>
   <% end %>
-  
+
 The default Where types are listed at MetaSearch::Where. Options for the search method are documented at MetaSearch::Searches::Base.
 
 == Advanced usage
 
+=== Narrowing the scope of a search
+
+While the most common use case is to simply call Model.search(params[:search]), there
+may be times where you want to scope your search more tightly. For instance, only allowing
+users to search their own projects (assuming a current_user method returning the current user):
+
+  @search = current_user.projects.search(params[:search])
+
+Or, you can build up any relation you like and call the search method on that object:
+
+  @projects_with_awesome_users_search =
+    Project.joins(:user).where(:users => {:awesome => true}).search(params[:search])
+
+=== Multi-level associations
+
+MetaSearch will allow you traverse your associations in one form, generating the necessary
+joins along the way. If you have the following models...
+
+  class Company < ActiveRecord::Base
+    has_many :developers
+  end
+
+  class Developer < ActiveRecord::Base
+    belongs_to :company
+    has_many :notes
+  end
+
+...you can do this in your form to search your companies by developers with certain notes:
+
+  <%= f.text_field :developers_notes_note %>
+
+You can travel forward and back through the associations, so this would also work (though
+be entirely pointless in this case):
+
+  <%= f.text_field :developers_notes_developer_company_name %>
+
+However, to prevent abuse, this is limited to associations of a total "depth" of 5 levels.
+This means that while starting from a Company model, as above, you could do
+Company -> :developers -> :notes -> :developer -> :company, which has gotten you right
+back where you started, but "travels" through 5 models total.
+
 === Adding a new Where
 
 If none of the built-in search criteria work for you, you can add a new Where (or 5). To do so,
 create an initializer (<tt>/config/initializers/meta_search.rb</tt>, for instance) and add lines
 like:
 
-  MetaSearch::Where.add :between, :btw, {:condition => 'BETWEEN', :substitutions => '? AND ?'}
+  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?)
+    }
 
 See MetaSearch::Where for info on the supported options.
 
+=== Accessing custom search methods (and named scopes!)
+
+MetaSearch can be given access to any class method on your model to extend its search capabilities.
+The only rule is that the method must return an ActiveRecord::Relation so that MetaSearch can
+continue to extend the search with other attributes. Conveniently, scopes (formerly "named scopes")
+do this already.
+
+Consider the following model:
+
+  class Company < ActiveRecord::Base
+    has_many :slackers, :class_name => "Developer", :conditions => {:slacker => true}
+    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})
+      }
+  end
+
+To allow MetaSearch access to a model method, including a named scope, just use
+<tt>search_methods</tt> in the model:
+
+  search_methods :backwards_name
+
+This will allow you to add a text field named :backwards_name to your search form, and
+it will behave as you might expect.
+
+In the case of the second scope, we have multiple parameters to pass in, of different
+types. We can pass the following to <tt>search_methods</tt>:
+
+  search_methods :with_slackers_by_name_and_salary_range,
+    :splat_param => true, :type => [:string, :integer, :integer]
+
+MetaSearch needs us to tell it that we don't want to keep the array supplied to it as-is, but
+"splat" it when passing it to the model method. Regarding <tt>:types</tt>: In this case,
+ActiveRecord would have been smart enough to handle the typecasting for us, but I wanted to
+demonstrate how we can tell MetaSearch that a given parameter is of a specific database "column type." This is just a hint MetaSearch uses in the same way it does when casting "Where" params based
+on the DB column being searched. It's also important so that things like dates get handled
+properly by FormBuilder.
+
 === multiparameter_field
 
 The example Where above adds support for a "between" search, which requires an array with
@@ -53,49 +144,97 @@ MetaSearch adds a helper for this:
 lets you sandwich a list of fields, each in hash format, between the attribute and the usual
 options hash. See MetaSearch::Helpers::FormBuilder for more info.
 
+=== Compound conditions (any/all)
+
+All Where types automatically get an "any" and "all" variant. This has the same name and
+aliases as the original, but is suffixed with _any and _all, for an "OR" or "AND" search,
+respectively. So, if you want to provide the user with 5 different search boxes to enter
+possible article titles:
+
+  <%= f.multiparameter_field :title_contains_any,
+        *5.times.inject([]) {|a, b| a << {:field_type => :text_field}} +
+        [:size => 10] %>
+
 === check_boxes and collection_check_boxes
 
 If you need to get an array into your where, and you don't care about parameter order,
 you might choose to use a select or collection_select with multiple selection enabled,
 but everyone hates multiple selection boxes. MetaSearch adds a couple of additional
 helpers, +check_boxes+ and +collection_check_boxes+ to handle multiple selections in a
-more visually appealing manner. It can be called with or without a block, so something
-like this is possible:
+more visually appealing manner. They can be called with or without a block. Without a
+block, you get an array of MetaSearch::Check objects to do with as you please.
 
-  <table>
-    <th colspan="2">How many heads?</th>
+With a block, each check is yielded to your template, like so:
+
+  <h4>How many heads?</h4>
+  <ul>
     <% f.check_boxes :number_of_heads_in,
-       [['One', 1], ['Two', 2], ['Three', 3]], :class => 'checkboxy' do |c| %>
-       <tr>
-         <td><%= c[:check_box] %></td>
-         <td><%= c[:label] %></td>
-       </tr>
+      [['One', 1], ['Two', 2], ['Three', 3]], :class => 'checkboxy' do |check| %>
+      <li>
+        <%= check.box %>
+        <%= check.label %>
+      </li>
     <% end %>
-  </table>
+  </ul>
 
 Again, full documentation is in MetaSearch::Helpers::FormBuilder.
 
-=== Excluding attributes and associations
+=== Sorting columns
+
+If you'd like to sort by a specific column in your results (the attributes of the base model)
+or an association column then supply the <tt>meta_sort</tt> parameter in your form.
+The parameter takes the form <tt>column.direction</tt> where +column+ is the column name or
+underscore-separated association_column combination, and +direction+ is one of "asc" or "desc"
+for ascending or descending, respectively.
+
+Normally, you won't supply this parameter yourself, but instead will use the helper method
+<tt>sort_link</tt> in your views, like so:
+
+  <%= sort_link @search, :title %>
+  <%= sort_link @search, :created_at %>
+
+The <tt>@search</tt> object is the instance of MetaSearch::Builder you got back earlier from
+your controller. The other required parameter is the attribute name itself. Optionally,
+you can provide a string as a 3rd parameter to override the default link name, and then
+additional hashed for the +options+ and +html_options+ hashes for link_to.
+
+All <tt>sort_link</tt>-generated links will have the CSS class sort_link, as well as a
+directional class (ascending or descending) if the link is for a currently sorted column,
+for your styling enjoyment.
 
-If you'd like to prevent certain associations or attributes from being searchable, you can control
-this inside your models:
+This feature should hopefully help out those of you migrating from SearchLogic, and a thanks
+goes out to Ben Johnson for the HTML entities used for the up and down arrows, which provide
+a nice default look.
+
+=== Including/excluding attributes and associations
+
+If you'd like to allow only certain associations or attributes to be searched, you can do
+so inside your models
 
   class Article < ActiveRecord::Base
-    metasearch_exclude_attr :some_private_data, :another_private_column
-    metasearch_exclude_assoc :an_association_that_should_not_be_searched, :and_another
+    attr_searchable :some_public_data, :some_more_searchable_stuff
+    assoc_searchable :search_this_association_why_dontcha
   end
 
-You get the idea. Excluded attributes on a model will be honored across associations, so
-if an Article <tt>has_many :comments</tt> and the Comment model looks something like this:
+If you'd rather blacklist attributes and associations rather than whitelist, use the
+<tt>attr_unsearchable</tt> and <tt>assoc_unsearchable</tt> method instead. If a
+whitelist is supplied, it takes precedence.
+
+Excluded attributes on a model will be honored across associations, so if an Article
+<tt>has_many :comments</tt> and the Comment model looks something like this:
 
-  Comment < ActiveRecord::Base
+  class Comment < ActiveRecord::Base
     validates_presence_of :user_id, :body
-    metasearch_exclude_attr :user_id
+    attr_unsearchable :user_id
   end
 
 Then your call to <tt>Article.search</tt> will allow <tt>:comments_body_contains</tt>
 but not <tt>:comments_user_id_equals</tt> to be passed.
 
+== Reporting issues
+
+Please report any issues using {Lighthouse}[http://metautonomous.lighthouseapp.com/projects/53012-metasearch/]. Thanks in advance for helping me improve MetaSearch!
+
 == Copyright
 
 Copyright (c) 2010 {Ernie Miller}[http://metautonomo.us]. See LICENSE for details.

data/Rakefile

@@ -5,12 +5,20 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "meta_search"
-    gem.summary = %Q{ActiveRecord 3 object-based searching.}
-    gem.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.}
+    gem.summary = %Q{ActiveRecord 3 object-based searching for your form_for enjoyment.}
+    gem.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.
+    }
     gem.email = "ernie@metautonomo.us"
-    gem.homepage = "http://metautonomo.us"
+    gem.homepage = "http://metautonomo.us/projects/metasearch/"
     gem.authors = ["Ernie Miller"]
-    gem.add_development_dependency "activerecord", ">= 3.0.0.beta"
+    gem.add_development_dependency "shoulda"
+    gem.add_dependency "activerecord", ">= 3.0.0.beta4"
+    gem.add_dependency "activesupport", ">= 3.0.0.beta4"
+    gem.add_dependency "actionpack", ">= 3.0.0.beta4"
+    gem.add_dependency "arel", ">= 0.4.0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -21,6 +29,10 @@ end
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
+  test.libs << 'vendor/rails/activerecord/lib'
+  test.libs << 'vendor/rails/activesupport/lib'
+  test.libs << 'vendor/rails/actionpack/lib'
+  test.libs << 'vendor/arel/lib'
   test.pattern = 'test/**/test_*.rb'
   test.verbose = true
 end
@@ -38,7 +50,8 @@ rescue LoadError
   end
 end
 
-task :test => :check_dependencies
+# Don't check dependencies on test, we're using vendored libraries
+# task :test => :check_dependencies
 
 task :default => :test
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.5.0

data/lib/meta_search.rb

@@ -6,26 +6,36 @@ module MetaSearch
   BOOLEANS = [:boolean]
   ALL_TYPES = NUMBERS + STRINGS + DATES + TIMES + BOOLEANS
 
+  # Change this only if you know what you're doing. It's here for your protection.
+  MAX_JOIN_DEPTH = 5
+
   DEFAULT_WHERES = [
     ['equals', 'eq'],
-    ['does_not_equal', 'ne', {:types => ALL_TYPES, :condition => '!='}],
-    ['contains', 'like', {:types => STRINGS, :condition => 'LIKE', :formatter => '"%#{param}%"'}],
-    ['does_not_contain', 'nlike', {:types => STRINGS, :condition => 'NOT LIKE', :formatter => '"%#{param}%"'}],
-    ['starts_with', 'sw', {:types => STRINGS, :condition => 'LIKE', :formatter => '"#{param}%"'}],
-    ['does_not_start_with', 'dnsw', {:types => STRINGS, :condition => 'NOT LIKE', :formatter => '"%#{param}%"'}],
-    ['ends_with', 'ew', {:types => STRINGS, :condition => 'LIKE', :formatter => '"%#{param}"'}],
-    ['does_not_end_with', 'dnew', {:types => STRINGS, :condition => 'NOT LIKE', :formatter => '"%#{param}"'}],
-    ['greater_than', 'gt', {:types => (NUMBERS + DATES + TIMES), :condition => '>'}],
-    ['less_than', 'lt', {:types => (NUMBERS + DATES + TIMES), :condition => '<'}],
-    ['greater_than_or_equal_to', 'gte', {:types => (NUMBERS + DATES + TIMES), :condition => '>='}],
-    ['less_than_or_equal_to', 'lte', {:types => (NUMBERS + DATES + TIMES), :condition => '<='}],
-    ['in', {:types => ALL_TYPES, :condition => 'IN', :substitutions => '(?)', :keep_arrays => true}],
-    ['not_in', 'ni', {:types => ALL_TYPES, :condition => 'NOT IN', :substitutions => '(?)', :keep_arrays => true}]
+    ['does_not_equal', 'ne', 'not_eq', {:types => ALL_TYPES, :predicate => :not_eq}],
+    ['contains', 'like', 'matches', {:types => STRINGS, :predicate => :matches, :formatter => '"%#{param}%"'}],
+    ['does_not_contain', 'nlike', 'not_matches', {:types => STRINGS, :predicate => :not_matches, :formatter => '"%#{param}%"'}],
+    ['starts_with', 'sw', {:types => STRINGS, :predicate => :matches, :formatter => '"#{param}%"'}],
+    ['does_not_start_with', 'dnsw', {:types => STRINGS, :predicate => :not_matches, :formatter => '"%#{param}%"'}],
+    ['ends_with', 'ew', {:types => STRINGS, :predicate => :matches, :formatter => '"%#{param}"'}],
+    ['does_not_end_with', 'dnew', {:types => STRINGS, :predicate => :not_matches, :formatter => '"%#{param}"'}],
+    ['greater_than', 'gt', {:types => (NUMBERS + DATES + TIMES), :predicate => :gt}],
+    ['less_than', 'lt', {:types => (NUMBERS + DATES + TIMES), :predicate => :lt}],
+    ['greater_than_or_equal_to', 'gte', 'gteq', {:types => (NUMBERS + DATES + TIMES), :predicate => :gteq}],
+    ['less_than_or_equal_to', 'lte', 'lteq', {:types => (NUMBERS + DATES + TIMES), :predicate => :lteq}],
+    ['in', {:types => ALL_TYPES, :predicate => :in}],
+    ['not_in', 'ni', 'not_in', {:types => ALL_TYPES, :predicate => :not_in}]
   ]
-  
-  RELATION_METHODS = [:joins, :includes, :all, :count, :to_sql, :paginate, :find_each, :first, :last, :each]
+
+  RELATION_METHODS = [:joins, :includes, :to_a, :all, :count, :to_sql, :paginate, :autojoin, :find_each, :first, :last, :each, :arel]
 end
 
-if defined?(::Rails::Railtie)
-  require 'meta_search/railtie'
-end
+require 'active_record'
+require 'action_view'
+require 'action_controller'
+require 'meta_search/searches/active_record'
+require 'meta_search/helpers'
+
+ActiveRecord::Base.send(:include, MetaSearch::Searches::ActiveRecord)
+ActionView::Helpers::FormBuilder.send(:include, MetaSearch::Helpers::FormBuilder)
+ActionController::Base.helper(MetaSearch::Helpers::UrlHelper)
+ActionController::Base.helper(MetaSearch::Helpers::FormHelper)

data/lib/meta_search/builder.rb

@@ -4,6 +4,12 @@ require 'meta_search/where'
 require 'meta_search/utility'
 
 module MetaSearch
+  # Raised if you try to access a relation that's joining too many tables to itself.
+  # This is designed to prevent a malicious user from accessing something like
+  # :developers_company_developers_company_developers_company_developers_company_...,
+  # resulting in a query that could cause issues for your database server.
+  class JoinDepthError < StandardError; end
+
   # Builder is the workhorse of MetaSearch -- it is the class that handles dynamically generating
   # methods based on a supplied model, and is what gets instantiated when you call your model's search
   # method. Builder doesn't generate any methods until they're needed, using method_missing to compare
@@ -21,59 +27,79 @@ module MetaSearch
   class Builder
     include ModelCompatibility
     include Utility
-    
-    attr_reader :base, :search_attributes, :relation, :join_dependency
-    delegate *RELATION_METHODS, :to => :relation
+
+    attr_reader :base, :search_attributes, :join_dependency
+    delegate *RELATION_METHODS + [:to => :relation]
 
     # Initialize a new Builder. Requires a base model to wrap, and supports a couple of options
     # for how it will expose this model and its associations to your controllers/views.
-    def initialize(base, opts = {})
-      @base = base
+    def initialize(base_or_relation, opts = {})
+      @relation = base_or_relation.scoped
+      @base = @relation.klass
       @opts = opts
-      @associations = {}
-      @join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@base, [], nil)
+      @join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@base, @relation.joins_values, nil)
       @search_attributes = {}
-      @relation = @base.scoped
     end
-    
-    # Return the column info for the given model attribute (if not excluded as outlined above)
-    def column(attr)
-      @base.columns_hash[attr.to_s] if self.includes_attribute?(attr)
+
+    def relation
+      enforce_join_depth_limit!
+      @relation
     end
-    
-    # Return the association reflection for the named association (if not excluded as outlined
-    # above)
-    def association(association)
-       if self.includes_association?(association)
-        @associations[association.to_sym] ||= @base.reflect_on_association(association.to_sym)
+
+    def get_column(column, base = @base)
+      if base._metasearch_include_attributes.blank?
+        base.columns_hash[column.to_s] unless base._metasearch_exclude_attributes.include?(column.to_s)
+      else
+        base.columns_hash[column.to_s] if base._metasearch_include_attributes.include?(column.to_s)
       end
     end
-    
-    # Return the column info for given association and column (if the association is not
-    # excluded from search)
-    def association_column(association, attr)
-      if self.includes_association?(association)
-        assoc = self.association(association)
-        assoc.klass.columns_hash[attr.to_s] unless assoc.klass._metasearch_exclude_attributes.include?(attr.to_s)
+
+    def get_association(assoc, base = @base)
+      if base._metasearch_include_associations.blank?
+        base.reflect_on_association(assoc.to_sym) unless base._metasearch_exclude_associations.include?(assoc.to_s)
+      else
+        base.reflect_on_association(assoc.to_sym) if base._metasearch_include_associations.include?(assoc.to_s)
       end
     end
-    
-    def included_attributes
-      @included_attributes ||= @base.column_names - @base._metasearch_exclude_attributes
-    end
-    
-    def includes_attribute?(attr)
-      self.included_attributes.include?(attr.to_s)
+
+    def get_attribute(name, parent = @join_dependency.join_base)
+      attribute = nil
+      if get_column(name, parent.active_record)
+        if parent.is_a?(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)
+          relation = parent.relation.is_a?(Array) ? parent.relation.last : parent.relation
+          attribute = relation.table[name]
+        else
+          attribute = @relation.table[name]
+        end
+      elsif (segments = name.to_s.split(/_/)).size > 1
+        remainder = []
+        found_assoc = nil
+        while remainder.unshift(segments.pop) && segments.size > 0 && !found_assoc do
+          if found_assoc = get_association(segments.join('_'), parent.active_record)
+            join = build_or_find_association(found_assoc.name, parent)
+            attribute = get_attribute(remainder.join('_'), join)
+          end
+        end
+      end
+      attribute
     end
-    
-    def included_associations
-      @included_associations ||= @base.reflect_on_all_associations.map {|a| a.name.to_s} - @base._metasearch_exclude_associations
+
+    def base_includes_association?(base, assoc)
+      if base._metasearch_include_associations.blank?
+        base.reflect_on_association(assoc.to_sym) unless base._metasearch_exclude_associations.include?(assoc.to_s)
+      else
+        base.reflect_on_association(assoc.to_sym) if base._metasearch_include_associations.include?(assoc.to_s)
+      end
     end
-    
-    def includes_association?(assoc)
-      self.included_associations.include?(assoc.to_s)
+
+    def base_includes_attribute?(base, attribute)
+      if base._metasearch_include_attributes.blank?
+        base.column_names.detect(attribute.to_s) unless base._metasearch_exclude_attributes.include?(attribute.to_s)
+      else
+        base.column_names.detect(attribute.to_s) if base._metasearch_include_attributes.include?(attribute.to_s)
+      end
     end
-    
+
     # Build the search with the given search options. Options are in the form of a hash
     # with keys matching the names creted by the Builder's "wheres" as outlined in
     # MetaSearch::Where
@@ -85,139 +111,166 @@ module MetaSearch
       assign_attributes(opts)
       self
     end
-    
+
     private
-    
+
     def method_missing(method_id, *args, &block)
-      if match = method_id.to_s.match(/^(.*)\(([0-9]+).*\)$/)
+      if method_id.to_s =~ /^meta_sort=?$/
+        build_sort_method
+        self.send(method_id, *args)
+      elsif match = method_id.to_s.match(/^(.*)\(([0-9]+).*\)$/) # Multiparameter reader
         method_name, index = match.captures
         vals = self.send(method_name)
         vals.is_a?(Array) ? vals[index.to_i - 1] : nil
+      elsif match = matches_named_method(method_id)
+        build_named_method(match)
+        self.send(method_id, *args)
       elsif match = matches_attribute_method(method_id)
-        condition, attribute, association = match.captures.reverse
-        build_method(association, attribute, condition)
+        attribute, predicate = match.captures
+        build_attribute_method(attribute, predicate)
         self.send(preferred_method_name(method_id), *args)
-      elsif match = matches_where_method(method_id)
-        condition = match.captures.first
-        build_where_method(condition, Where.new(condition))
-        self.send(method_id, *args)
       else
         super
       end
     end
-    
-    def build_method(association, attribute, suffix)
-      if association.blank?
-        build_attribute_method(attribute, suffix)
-      else
-        build_association_method(association, attribute, suffix)
+
+    def build_sort_method
+      singleton_class.instance_eval do
+        define_method(:meta_sort) do
+          search_attributes['meta_sort']
+        end
+
+        define_method(:meta_sort=) do |val|
+          column, direction = val.split('.')
+          direction ||= 'asc'
+          if ['asc','desc'].include?(direction) && attribute = get_attribute(column)
+            search_attributes['meta_sort'] = val
+            @relation = @relation.order(attribute.send(direction).to_sql)
+          end
+        end
       end
     end
-    
-    def build_association_method(association, attribute, type)
-      metaclass.instance_eval do        
-        define_method("#{association}_#{attribute}_#{type}") do
-          search_attributes["#{association}_#{attribute}_#{type}"]
-        end
-      
-        define_method("#{association}_#{attribute}_#{type}=") do |val|
-          search_attributes["#{association}_#{attribute}_#{type}"] = cast_attributes(association_type_for(association, attribute), val)
-          where = Where.new(type)
-          if where.valid_substitutions?(search_attributes["#{association}_#{attribute}_#{type}"])
-            join = build_or_find_association(association)
-            self.send("add_#{type}_where", join.aliased_table_name, attribute, search_attributes["#{association}_#{attribute}_#{type}"])
+
+    def column_type(name, base = @base)
+      type = nil
+      if column = get_column(name, base)
+        type = column.type
+      elsif (segments = name.split(/_/)).size > 1
+        remainder = []
+        found_assoc = nil
+        while remainder.unshift(segments.pop) && segments.size > 0 && !found_assoc do
+          if found_assoc = get_association(segments.join('_'), base)
+            type = column_type(remainder.join('_'), found_assoc.klass)
           end
         end
       end
+      type
     end
-    
-    def build_attribute_method(attribute, type)
-      metaclass.instance_eval do
-        define_method("#{attribute}_#{type}") do
-          search_attributes["#{attribute}_#{type}"]
+
+    def build_named_method(name)
+      meth = @base._metasearch_methods[name]
+      singleton_class.instance_eval do
+        define_method(name) do
+          search_attributes[name]
         end
-      
-        define_method("#{attribute}_#{type}=") do |val|
-          search_attributes["#{attribute}_#{type}"] = cast_attributes(type_for(attribute), val)
-          where = Where.new(type)
-          if where.valid_substitutions?(search_attributes["#{attribute}_#{type}"])
-            self.send("add_#{type}_where", @base.table_name, attribute, search_attributes["#{attribute}_#{type}"])
+
+        define_method("#{name}=") do |val|
+          search_attributes[name] = meth.cast_param(val)
+          if meth.validate(search_attributes[name])
+            return_value = meth.eval(@relation, search_attributes[name])
+            if return_value.is_a?(ActiveRecord::Relation)
+              @relation = return_value
+            else
+              raise NonRelationReturnedError, "Custom search methods must return an ActiveRecord::Relation. #{name} returned a #{return_value.class}"
+            end
           end
         end
       end
     end
-    
-    def build_where_method(condition, where)
-      metaclass.instance_eval do
-        define_method("add_#{condition}_where") do |table, attribute, *args|
-          args.flatten! unless where.keep_arrays?
-          @relation = @relation.where(
-            "#{quote_table_name table}.#{quote_column_name attribute} " + 
-            "#{where.condition} #{where.substitutions}", *format_params(where.formatter, *args)
-          )
+
+    def build_attribute_method(attribute, predicate)
+      singleton_class.instance_eval do
+        define_method("#{attribute}_#{predicate}") do
+          search_attributes["#{attribute}_#{predicate}"]
+        end
+
+        define_method("#{attribute}_#{predicate}=") do |val|
+          search_attributes["#{attribute}_#{predicate}"] = cast_attributes(column_type(attribute), val)
+          where = Where.new(predicate)
+          if where.validate(search_attributes["#{attribute}_#{predicate}"])
+            arel_attribute = get_attribute(attribute)
+            @relation = where.eval(@relation, arel_attribute, search_attributes["#{attribute}_#{predicate}"])
+          end
         end
       end
     end
-    
-    def format_params(formatter, *params)
-      par = params.map {|p| formatter.call(p)}
-    end
-    
-    def build_or_find_association(association)
+
+    def build_or_find_association(association, parent = @join_dependency.join_base)
       found_association = @join_dependency.join_associations.detect do |assoc|
-        assoc.reflection.name == association.to_sym
+        assoc.reflection.name == association.to_sym &&
+        assoc.parent == parent
       end
       unless found_association
-        @relation = @relation.joins(association.to_sym)
-        @join_dependency.send(:build, association.to_sym, @join_dependency.join_base)
+        @join_dependency.send(:build, association, parent)
         found_association = @join_dependency.join_associations.last
+        @relation = @relation.joins(found_association)
       end
       found_association
     end
-    
+
+    def enforce_join_depth_limit!
+      raise JoinDepthError, "Maximum join depth of #{MAX_JOIN_DEPTH} exceeded." if @join_dependency.join_associations.detect {|ja|
+        gauge_depth_of_join_association(ja) > MAX_JOIN_DEPTH
+      }
+    end
+
+    def gauge_depth_of_join_association(ja)
+      1 + (ja.respond_to?(:parent) ? gauge_depth_of_join_association(ja.parent) : 0)
+    end
+
+    def matches_named_method(name)
+      method_name = name.to_s.sub(/\=$/, '')
+      return method_name if @base._metasearch_methods.has_key?(method_name)
+    end
+
     def matches_attribute_method(method_id)
       method_name = preferred_method_name(method_id)
       where = Where.new(method_id) rescue nil
       return nil unless method_name && where
       match = method_name.match("^(.*)_(#{where.name})=?$")
-      attribute, condition = match.captures
-      if where.types.include?(type_for(attribute))
+      attribute, predicate = match.captures
+      if where.types.include?(column_type(attribute))
         return match
-      elsif match = matches_association(method_name, attribute, condition)
-        association, attribute = match.captures
-        return match if where.types.include?(association_type_for(association, attribute))
       end
       nil
     end
-    
-    def preferred_method_name(method_id)
-      method_name = method_id.to_s
-      where = Where.new(method_name) rescue nil
-      return nil unless where
-      where.aliases.each do |a|
-        break if method_name.sub!(/#{a}(=?)$/, "#{where.name}\\1")
-      end
-      method_name
-    end
-    
-    def matches_association(method_id, attribute, condition)
+
+    def matches_association_method(method_id)
+      method_name = preferred_method_name(method_id)
+      where = Where.new(method_id) rescue nil
+      return nil unless method_name && where
+      match = method_name.match("^(.*)_(#{where.name})=?$")
+      attribute, predicate = match.captures
       self.included_associations.each do |association|
         test_attribute = attribute.dup
         if test_attribute.gsub!(/^#{association}_/, '') &&
-          match = method_id.to_s.match("^(#{association})_(#{test_attribute})_(#{condition})=?$")
-          return match
+          match = method_name.match("^(#{association})_(#{test_attribute})_(#{predicate})=?$")
+          return match if where.types.include?(association_type_for(association, test_attribute))
         end
       end
       nil
     end
-    
-    def matches_where_method(method_id)
-      if match = method_id.to_s.match(/^add_(.*)_where$/)
-        condition = match.captures.first
-        Where.get(condition) ? match : nil
+
+    def preferred_method_name(method_id)
+      method_name = method_id.to_s
+      where = Where.new(method_name) rescue nil
+      return nil unless where
+      where.aliases.each do |a|
+        break if method_name.sub!(/#{a}(=?)$/, "#{where.name}\\1")
       end
+      method_name
     end
-    
+
     def assign_attributes(opts)
       opts.each_pair do |k, v|
         self.send("#{k}=", v)
@@ -228,17 +281,17 @@ module MetaSearch
       column = self.column(attribute)
       column.type if column
     end
-    
+
     def class_for(attribute)
       column = self.column(attribute)
       column.klass if column
     end
-    
+
     def association_type_for(association, attribute)
       column = self.association_column(association, attribute)
       column.type if column
     end
-    
+
     def association_class_for(association, attribute)
       column = self.association_column(association, attribute)
       column.klass if column