meta_search 0.9.6 → 0.9.7

data/CHANGELOG

@@ -1,5 +1,17 @@
+Changes since 0.9.6 (2010-09-29):
+  * Support _or_-separated conditions. I'm not crazy about 'em, but it's
+    an oft-requested feature.
+  * Support search on polymorphic belongs_to associations. Uses the same
+    syntax users of Searchlogic are familiar with, association_classname_type.
+    For example: commentable_article_type_contains
+  * Join using left outer joins instead of inner joins. This lets you do
+    some interesting things like search for all articles with no comments via
+    comments_id_is_null.
+  * No longer define method on the metaclass - stick to standard method_missing
+    for both correctness and performance.
+
 Changes since 0.9.5 (2010-09-28):
-  * Fix issue with formatters supplied s strings
+  * Fix issue with formatters supplied as strings
 
 Changes since 0.9.4 (2010-09-18):
   * Rename check_boxes and collection_check_boxes to checks and

data/README.rdoc

@@ -17,7 +17,9 @@ In your controller:
 
   def index
     @search = Article.search(params[:search])
-    @articles = @search.all   # or @search.relation to lazy load in view
+    @articles = @search.all   # load all matching records
+    # @articles = @search.relation # Retrieve the relation, to lazy-load in view
+    # @articles = @search.paginate(:page => params[:page]) # Who doesn't love will_paginate?
   end
 
 In your view:
@@ -31,7 +33,72 @@ In your view:
     <%= f.submit %>
   <% end %>
 
-The default Where types are listed at MetaSearch::Where. Options for the search method are documented at MetaSearch::Searches::Base.
+Options for the search method are documented at MetaSearch::Searches::Base.
+
+== "Wheres", and what they're good for
+
+Wheres are how MetaSearch does its magic. Wheres have a name (and possible aliases) which are
+appended to your model and association attributes. When you instantiate a MetaSearch::Builder
+against a model (manually or by calling your model's +search+ method) the builder responds to
+methods named for your model's attributes and associations, suffixed by the name of the Where.
+
+These are the default Wheres, broken down by the types of ActiveRecord columns they can search
+against:
+
+=== All data types
+
+* _equals_ (alias: _eq_) - Just as it sounds.
+* _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_ (aliases: _ni_, _notin_) - Like above, but negated.
+* _is_null_ - The column has an SQL NULL value.
+* _is_not_null_ - The column contains anything but NULL.
+
+=== Strings
+
+* _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.
+* _does_not_end_with_ (alias: _dnew_) - Negative of above.
+
+=== Numbers, dates, and times
+
+* _greater_than_ (alias: _gt_) - Greater than.
+* _greater_than_or_equal_to_ (aliases: _gte_, _gteq_) - Greater than or equal to.
+* _less_than_ (alias: _lt_) - Less than.
+* _less_than_or_equal_to_ (aliases: _lte_, _lteq_) - Less than or equal to.
+
+=== Booleans
+
+* _is_true_ - Is true. Useful for a checkbox like "only show admin users".
+* _is_false_ - The complement of _is_true_.
+
+=== Non-boolean data types
+
+* _is_present_ - As with _is_true_, useful with a checkbox. Not NULL or the empty string.
+* _is_blank_ - Returns records with a value of NULL or the empty string in the column.
+
+So, given a model like this...
+
+  class Article < ActiveRecord::Base
+    belongs_to :author
+    has_many :comments
+    has_many :moderations, :through => :comments
+  end
+
+...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.
 
 == Advanced usage
 
@@ -48,6 +115,32 @@ Or, you can build up any relation you like and call the search method on that ob
   @projects_with_awesome_users_search =
     Project.joins(:user).where(:users => {:awesome => true}).search(params[:search])
 
+=== ORed conditions
+
+If you'd like to match on one of several possible columns, you can do this:
+
+  <%= f.text_field :title_or_description_contains %>
+  <%= f.text_field :title_or_author_name_starts_with %>
+
+Caveats:
+
+* Only one match type is supported. You <b>can't</b> do
+  <tt>title_matches_or_description_starts_with</tt> for instance.
+* If you're matching across associations, remember that the associated table will be
+  INNER JOINed, therefore limiting results to those that at least have a corresponding
+  record in the associated table.
+
+=== 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] %>
+
 === Multi-level associations
 
 MetaSearch will allow you to traverse your associations in one form, generating the
@@ -76,9 +169,45 @@ 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.
 
+In the case of polymorphic belongs_to associations, things work a bit differently. Let's say
+you have the following models:
+
+  class Article < ActiveRecord::Base
+    has_many :comments, :as => :commentable
+  end
+
+  class Post < ActiveRecord::Base
+    has_many :comments, :as => :commentable
+  end
+
+  class Comment < ActiveRecord::Base
+    belongs_to :commentable, :polymorphic => true
+    validates_presence_of :body
+  end
+
+Your first instinct might be to set up a text field for :commentable_body_contains, but
+you can't do this. MetaSearch would have no way to know which class lies on the other side
+of the polymorphic association, so it wouldn't be able to join the correct tables.
+
+Instead, you'll follow a convention Searchlogic users are already familiar with, using the
+name of the polymorphic association, then the underscored class name (AwesomeClass becomes
+awesome_class), then the delimiter "type", to tell MetaSearch anything that follows is an
+attribute name. For example:
+
+  <%= f.text_field :commentable_article_type_body_contains %>
+
+If you'd like to match on multiple types of polymorphic associations, you can join them
+with \_or_, just like any other conditions:
+
+  <%= f.text_field :commentable_article_type_body_or_commentable_post_type_body_contains %>
+
+It's not pretty, but it works. Alternately, consider creating a custom search method as
+described below to save yourself some typing if you're creating a lot of these types of
+search fields.
+
 === 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,
+If none of the built-in search criteria work for you, you can add new Wheres. To do so,
 create an initializer (<tt>/config/initializers/meta_search.rb</tt>, for instance) and add lines
 like:
 
@@ -144,17 +273,6 @@ 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,

data/VERSION

@@ -1 +1 @@
-0.9.6
+0.9.7

data/lib/meta_search/builder.rb

@@ -4,12 +4,6 @@ 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
@@ -77,8 +71,19 @@ module MetaSearch
         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)
+            if found_assoc.options[:polymorphic]
+              unless delimiter = remainder.index('type')
+                raise PolymorphicAssociationMissingTypeError, "Polymorphic association specified without a type"
+              end
+              polymorphic_class, attribute_name = remainder[0...delimiter].join('_'),
+                                                  remainder[delimiter + 1...remainder.size].join('_')
+              polymorphic_class = polymorphic_class.classify.constantize
+              join = build_or_find_association(found_assoc.name, parent, polymorphic_class)
+              attribute = get_attribute(attribute_name, join)
+            else
+              join = build_or_find_association(found_assoc.name, parent, found_assoc.klass)
+              attribute = get_attribute(remainder.join('_'), join)
+            end
           end
         end
       end
@@ -97,11 +102,11 @@ module MetaSearch
       self
     end
 
-    def respond_to?(method_name, include_private = false)
+    def respond_to?(method_id, include_private = false)
       return true if super # Hopefully we've already defined the method.
 
       # Curses! Looks like we'll need to do this the hard way.
-      method_name = method_name.to_s
+      method_name = method_id.to_s
       if RELATION_METHODS.map(&:to_s).include?(method_name)
         true
       elsif method_name.match(/^meta_sort=?$/)
@@ -119,20 +124,18 @@ module MetaSearch
     private
 
     def method_missing(method_id, *args, &block)
-      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 = method_id.to_s
+      if method_name =~ /^meta_sort=?$/
+        method_name =~ /=$/ ? set_sort(args.first) : get_sort
+      elsif match = method_name.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_named_method(method_name)
+        method_name =~ /=$/ ? set_named_method_value(match, args.first) : get_named_method_value(match)
       elsif match = matches_attribute_method(method_id)
         attribute, predicate = match.captures
-        build_attribute_method(attribute, predicate)
-        self.send(preferred_method_name(method_id), *args)
+        method_name =~ /=$/ ? set_attribute_method_value(attribute, predicate, args.first) : get_attribute_method_value(attribute, predicate)
       else
         super
       end
@@ -177,20 +180,16 @@ module MetaSearch
       o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
     end
 
-    def build_sort_method
-      singleton_class.instance_eval do
-        define_method(:meta_sort) do
-          search_attributes['meta_sort']
-        end
+    def get_sort
+      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
+    def set_sort(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
 
@@ -203,58 +202,62 @@ module MetaSearch
         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)
+            if found_assoc.options[:polymorphic]
+              unless delimiter = remainder.index('type')
+                raise PolymorphicAssociationMissingTypeError, "Polymorphic association specified without a type"
+              end
+              polymorphic_class, attribute_name = remainder[0...delimiter].join('_'),
+                                                  remainder[delimiter + 1...remainder.size].join('_')
+              polymorphic_class = polymorphic_class.classify.constantize
+              type = column_type(attribute_name, polymorphic_class)
+            else
+              type = column_type(remainder.join('_'), found_assoc.klass)
+            end
           end
         end
       end
       type
     end
 
-    def build_named_method(name)
-      meth = @base._metasearch_methods[name]
-      singleton_class.instance_eval do
-        define_method(name) do
-          search_attributes[name]
-        end
+    def get_named_method_value(name)
+      search_attributes[name]
+    end
 
-        define_method("#{name}=") do |val|
-          search_attributes[name] = meth.cast_param(val)
-          if meth.validate(search_attributes[name])
-            return_value = meth.evaluate(@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
+    def set_named_method_value(name, val)
+      meth = @base._metasearch_methods[name]
+      search_attributes[name] = meth.cast_param(val)
+      if meth.validate(search_attributes[name])
+        return_value = meth.evaluate(@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
 
-    def build_attribute_method(attribute, predicate)
-      singleton_class.instance_eval do
-        define_method("#{attribute}_#{predicate}") do
-          search_attributes["#{attribute}_#{predicate}"]
-        end
+    def get_attribute_method_value(attribute, predicate)
+      search_attributes["#{attribute}_#{predicate}"]
+    end
 
-        define_method("#{attribute}_#{predicate}=") do |val|
-          where = Where.new(predicate)
-          search_attributes["#{attribute}_#{predicate}"] = cast_attributes(where.cast || column_type(attribute), val)
-          if where.validate(search_attributes["#{attribute}_#{predicate}"])
-            arel_attribute = get_attribute(attribute)
-            @relation = where.evaluate(@relation, arel_attribute, search_attributes["#{attribute}_#{predicate}"])
-          end
-        end
+    def set_attribute_method_value(attribute, predicate, val)
+      where = Where.new(predicate)
+      attributes = attribute.split(/_or_/)
+      search_attributes["#{attribute}_#{predicate}"] = cast_attributes(where.cast || column_type(attributes.first), val)
+      if where.validate(search_attributes["#{attribute}_#{predicate}"])
+        arel_attributes = attributes.map {|a| get_attribute(a)}
+        @relation = where.evaluate(@relation, arel_attributes, search_attributes["#{attribute}_#{predicate}"])
       end
     end
 
-    def build_or_find_association(association, parent = @join_dependency.join_base)
+    def build_or_find_association(association, parent = @join_dependency.join_base, klass = nil)
       found_association = @join_dependency.join_associations.detect do |assoc|
         assoc.reflection.name == association.to_sym &&
+        assoc.reflection.klass == klass &&
         assoc.parent == parent
       end
       unless found_association
-        @join_dependency.send(:build, association, parent)
+        @join_dependency.send(:build, association, parent, Arel::OuterJoin, klass)
         found_association = @join_dependency.join_associations.last
         @relation = @relation.joins(found_association)
       end
@@ -282,28 +285,13 @@ module MetaSearch
       return nil unless method_name && where
       match = method_name.match("^(.*)_(#{where.name})=?$")
       attribute, predicate = match.captures
-      if where.types.include?(column_type(attribute))
+      attributes = attribute.split(/_or_/)
+      if attributes.all? {|a| where.types.include?(column_type(a))}
         return match
       end
       nil
     end
 
-    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_name.match("^(#{association})_(#{test_attribute})_(#{predicate})=?$")
-          return match if where.types.include?(association_type_for(association, test_attribute))
-        end
-      end
-      nil
-    end
-
     def preferred_method_name(method_id)
       method_name = method_id.to_s
       where = Where.new(method_name) rescue nil

data/lib/meta_search/exceptions.rb

@@ -1,4 +1,17 @@
 module MetaSearch
+  # Raised when type casting for a column fails.
   class TypeCastError < StandardError; end
+
+  # Raised if you don't return a relation from a custom search method.
   class NonRelationReturnedError < StandardError; end
+
+  # 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
+
+  # Raised if you try to search on a polymorphic belongs_to association without specifying
+  # its type.
+  class PolymorphicAssociationMissingTypeError < StandardError; end
 end

data/lib/meta_search/join_dependency.rb

@@ -0,0 +1,91 @@
+module MetaSearch
+
+  module JoinDependency
+
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :build, :metasearch
+        alias_method_chain :graft, :metasearch
+      end
+    end
+
+    def graft_with_metasearch(*associations)
+      associations.each do |association|
+        join_associations.detect {|a| association == a} ||
+        build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_class, association.reflection.klass)
+      end
+      self
+    end
+
+    protected
+
+      def build_with_metasearch(association, parent = nil, join_class = Arel::InnerJoin, polymorphic_class = nil)
+        parent ||= @joins.last
+        case association
+        when Symbol, String
+          reflection = parent.reflections[association.to_s.intern] or
+          raise ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?"
+          if reflection.options[:polymorphic]
+            @reflections << reflection
+            @joins << build_polymorphic_join_association(reflection, parent, polymorphic_class).with_join_class(join_class)
+          else
+            @reflections << reflection
+            @joins << build_join_association(reflection, parent).with_join_class(join_class)
+          end
+        else
+          build_without_metasearch(association, parent, join_class)
+        end
+      end
+
+      def build_polymorphic_join_association(reflection, parent, klass)
+        PolymorphicJoinAssociation.new(reflection, self, klass, parent)
+      end
+  end
+
+  class PolymorphicJoinAssociation < ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
+
+    def initialize(reflection, join_dependency, polymorphic_class, parent = nil)
+      reflection.check_validity!
+      @active_record = polymorphic_class
+      @cached_record = {}
+      @join_dependency    = join_dependency
+      @parent             = parent || join_dependency.join_base
+      @reflection         = reflection.clone
+      @reflection.instance_eval "def klass; #{polymorphic_class} end"
+      @aliased_prefix     = "t#{ join_dependency.joins.size }"
+      @parent_table_name  = @parent.active_record.table_name
+      @aliased_table_name = aliased_table_name_for(table_name)
+      @join               = nil
+      @join_class         = Arel::InnerJoin
+    end
+
+    def ==(other)
+      other.class == self.class &&
+      other.reflection == reflection &&
+      other.active_record == active_record &&
+      other.parent == parent
+    end
+
+    def association_join
+      return @join if @join
+
+      aliased_table = Arel::Table.new(table_name, :as => @aliased_table_name, :engine => arel_engine)
+      parent_table = Arel::Table.new(parent.table_name, :as => parent.aliased_table_name, :engine => arel_engine)
+
+      @join = [
+        aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.primary_key_name]),
+        parent_table[options[:foreign_type]].eq(active_record.base_class.name)
+      ]
+
+      unless klass.descends_from_active_record?
+        sti_column = aliased_table[klass.inheritance_column]
+        sti_condition = sti_column.eq(klass.sti_name)
+        klass.descendants.each {|subclass| sti_condition = sti_condition.or(sti_column.eq(subclass.sti_name)) }
+
+        @join << sti_condition
+      end
+
+      @join
+    end
+  end
+end

data/lib/meta_search/utility.rb

@@ -2,6 +2,10 @@ require 'meta_search/exceptions'
 
 module MetaSearch
   module Utility #:nodoc:
+
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
+    FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
+
     private
 
     def array_of_arrays?(vals)
@@ -47,13 +51,25 @@ module MetaSearch
           val.in_time_zone rescue nil
         end
       when *BOOLEANS
-        ActiveRecord::ConnectionAdapters::Column.value_to_boolean(val)
+        if val.is_a?(String) && value.blank?
+          nil
+        else
+          TRUE_VALUES.include?(val)
+        end
       when :integer
         val.blank? ? nil : val.to_i
       when :float
         val.blank? ? nil : val.to_f
       when :decimal
-        val.blank? ? nil : ActiveRecord::ConnectionAdapters::Column.value_to_decimal(val)
+        if val.blank?
+          nil
+        elsif val.class == BigDecimal
+          val
+        elsif val.respond_to?(:to_d)
+          val.to_d
+        else
+          val.to_s.to_d
+        end
       else
         raise TypeCastError, "Unable to cast columns of type #{type}"
       end
@@ -76,13 +92,5 @@ module MetaSearch
       end
       opts
     end
-
-    def quote_table_name(name)
-      ActiveRecord::Base.connection.quote_table_name(name)
-    end
-
-    def quote_column_name(name)
-      ActiveRecord::Base.connection.quote_column_name(name)
-    end
   end
 end

data/lib/meta_search/where.rb

@@ -15,6 +15,8 @@ module MetaSearch
   # * _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_ (aliases: _ni_, _notin_) - Like above, but negated.
+  # * _is_null_ - The column has an SQL NULL value.
+  # * _is_not_null_ - The column contains anything but NULL.
   #
   # === Strings
   #
@@ -97,12 +99,14 @@ module MetaSearch
     end
 
     # Evaluate the Where for the given relation, attribute, and parameter(s)
-    def evaluate(relation, attribute, param)
+    def evaluate(relation, attributes, param)
       if splat_param?
-        relation.where(attribute.send(predicate, *format_param(param)))
+        conditions = attributes.map {|a| a.send(predicate, *format_param(param))}
       else
-        relation.where(attribute.send(predicate, format_param(param)))
+        conditions = attributes.map {|a| a.send(predicate, format_param(param))}
       end
+
+      relation.where(conditions.inject(nil) {|memo, c| memo ? memo.or(c) : c})
     end
 
     class << self

data/lib/meta_search.rb

@@ -41,9 +41,11 @@ require 'active_record'
 require 'active_support'
 require 'action_view'
 require 'action_controller'
+require 'meta_search/join_dependency'
 require 'meta_search/searches/active_record'
 require 'meta_search/helpers'
 
+ActiveRecord::Associations::ClassMethods::JoinDependency.send(:include, MetaSearch::JoinDependency)
 ActiveRecord::Base.send(:include, MetaSearch::Searches::ActiveRecord)
 ActionView::Helpers::FormBuilder.send(:include, MetaSearch::Helpers::FormBuilder)
 ActionController::Base.helper(MetaSearch::Helpers::UrlHelper)

data/meta_search.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{meta_search}
-  s.version = "0.9.6"
+  s.version = "0.9.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ernie Miller"]
-  s.date = %q{2010-09-29}
+  s.date = %q{2010-10-11}
   s.description = %q{
       Allows simple search forms to be created against an AR3 model
       and its associations, has useful view helpers for sort links
@@ -37,6 +37,7 @@ Gem::Specification.new do |s|
      "lib/meta_search/helpers/form_builder.rb",
      "lib/meta_search/helpers/form_helper.rb",
      "lib/meta_search/helpers/url_helper.rb",
+     "lib/meta_search/join_dependency.rb",
      "lib/meta_search/method.rb",
      "lib/meta_search/model_compatibility.rb",
      "lib/meta_search/searches/active_record.rb",

data/test/test_search.rb

@@ -308,6 +308,17 @@ class TestSearch < Test::Unit::TestCase
         end
       end
 
+      context "where name or company name starts with m" do
+        setup do
+          @s.name_or_company_name_starts_with = "m"
+        end
+
+        should "return Michael Bolton and all employees of Mission Data" do
+          assert_equal @s.all, Developer.where(:name => 'Michael Bolton').all +
+                               Company.where(:name => 'Mission Data').first.developers
+        end
+      end
+
       context "where name ends with Miller" do
         setup do
           @s.name_ends_with = 'Miller'
@@ -400,6 +411,24 @@ class TestSearch < Test::Unit::TestCase
           assert_equal 0, @s.all.size
         end
       end
+
+      context "where developer is named Ernie Miller by polymorphic belongs_to against an association" do
+        setup do
+          @s.notes_notable_developer_type_name_equals = "Ernie 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
     end
   end
 
@@ -729,6 +758,43 @@ class TestSearch < Test::Unit::TestCase
           assert_equal 0, @s.all.select {|r| r.name = nil}.size
         end
       end
+
+      context "where notes_id is null" do
+        setup do
+          @s.notes_id_is_null = true
+        end
+
+        should "return 2 results" do
+          assert_equal 2, @s.all.size
+        end
+
+        should "contain no results with notes" do
+          assert_equal 0, @s.all.select {|r| r.notes.size > 0}.size
+        end
+      end
+    end
+  end
+
+  [{:name => 'Note', :object => Note},
+   {:name => 'Note as a Relation', :object => Note.scoped}].each do |object|
+    context_a_search_against object[:name], object[:object] do
+      should "allow search on polymorphic belongs_to associations" do
+        @s.notable_project_type_name_contains = 'MetaSearch'
+        assert_equal Project.find_by_name('MetaSearch Development').notes, @s.all
+      end
+
+      should "allow search on multiple polymorphic belongs_to associations" do
+        @s.notable_project_type_name_or_notable_developer_type_name_starts_with = 'M'
+        assert_equal Project.find_by_name('MetaSearch Development').notes +
+                     Developer.find_by_name('Michael Bolton').notes,
+                     @s.all
+      end
+
+      should "raise an error when attempting to search against polymorphic belongs_to association without a type" do
+        assert_raises ::MetaSearch::PolymorphicAssociationMissingTypeError do
+          @s.notable_name_contains = 'MetaSearch'
+        end
+      end
     end
   end
 end

data/test/test_view_helpers.rb

@@ -7,7 +7,7 @@ class TestViewHelpers < ActionView::TestCase
   include MetaSearch::Helpers::UrlHelper
 
   router = ActionDispatch::Routing::RouteSet.new
-  router.draw do |map|
+  router.draw do
     resources :developers
     resources :companies
     resources :projects

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 6
-  version: 0.9.6
+  - 7
+  version: 0.9.7
 platform: ruby
 authors: 
 - Ernie Miller
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-29 00:00:00 -04:00
+date: 2010-10-11 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -116,6 +116,7 @@ files:
 - lib/meta_search/helpers/form_builder.rb
 - lib/meta_search/helpers/form_helper.rb
 - lib/meta_search/helpers/url_helper.rb
+- lib/meta_search/join_dependency.rb
 - lib/meta_search/method.rb
 - lib/meta_search/model_compatibility.rb
 - lib/meta_search/searches/active_record.rb