meta_search 0.9.8 → 0.9.9

data/CHANGELOG

@@ -1,3 +1,11 @@
+Changes since 0.9.8 (2010-10-20):
+  * ARel 2.x and Rails 3.0.2 compatability
+  * sort_link uses search_key from builder. Search_key defaults to "search"
+  * sort_link will localize attribute names.
+  * You can now create two scopes on your model named sort_by_something_asc
+    and sort_by_something_desc, and sort_link will then allow you to specify
+    :something as a parameter, then use your scope to perform custom sorting.
+
 Changes since 0.9.7 (2010-10-12):
   * Play nicely regardless of MetaWhere/MetaSearch load order.
   * Big fix - stop altering the supplied hash in Builder#build.

data/Gemfile

@@ -1,9 +1,3 @@
 source :rubygems
-gem "arel", "~> 1.0.1"
-gem "activerecord", "~> 3.0.0"
-gem "activesupport", "~> 3.0.0"
-gem "actionpack", "~> 3.0.0"
-group :test do
-  gem "rake"
-  gem "shoulda"
-end
+
+gemspec

data/README.rdoc

@@ -309,13 +309,27 @@ Normally, you won't supply this parameter yourself, but instead will use the hel
 <tt>sort_link</tt> in your views, like so:
 
   <%= sort_link @search, :title %>
-  <%= sort_link @search, :created_at %>
+
+Or, if in the context of a form_for against a MetaSearch::Builder:
+
+  <%= f.sort_link :title %>
 
 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.
 
+You can sort by more than one column as well, by creating a link like:
+
+  <%= sort_link :name_and_salary %>
+
+If you'd like to do a custom sort, you can do so by setting up two scopes in your model:
+
+  scope :sort_by_custom_name_asc, order('custom_name ASC')
+  scope :sort_by_custom_name_desc, order('custom_name DESC')
+
+You can then do <tt>sort_link @search, :custom_name</tt> and it will work as you expect.
+
 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.

data/Rakefile

@@ -15,10 +15,10 @@ begin
     gem.homepage = "http://metautonomo.us/projects/metasearch/"
     gem.authors = ["Ernie Miller"]
     gem.add_development_dependency "shoulda"
-    gem.add_dependency "activerecord", "~> 3.0.0"
-    gem.add_dependency "activesupport", "~> 3.0.0"
-    gem.add_dependency "actionpack", "~> 3.0.0"
-    gem.add_dependency "arel", "~> 1.0.1"
+    gem.add_dependency "activerecord", "~> 3.0.2"
+    gem.add_dependency "activesupport", "~> 3.0.2"
+    gem.add_dependency "actionpack", "~> 3.0.2"
+    gem.add_dependency "arel", "~> 2.0.2"
     gem.post_install_message = <<END
 
 *** Thanks for installing MetaSearch! ***

data/VERSION

@@ -1 +1 @@
-0.9.8
+0.9.9

data/lib/meta_search/builder.rb

@@ -22,7 +22,7 @@ module MetaSearch
     include ModelCompatibility
     include Utility
 
-    attr_reader :base, :search_attributes, :join_dependency, :errors
+    attr_reader :base, :search_key, :search_attributes, :join_dependency, :errors
     delegate *RELATION_METHODS + [:to => :relation]
 
     # Initialize a new Builder. Requires a base model to wrap, and supports a couple of options
@@ -30,7 +30,7 @@ module MetaSearch
     def initialize(base_or_relation, opts = {})
       @relation = base_or_relation.scoped
       @base = @relation.klass
-      @opts = opts
+      @search_key = opts[:search_key] ? opts[:search_key].to_s : 'search'
       @join_dependency = build_join_dependency
       @search_attributes = {}
       @errors = ActiveModel::Errors.new(self)
@@ -42,19 +42,23 @@ module MetaSearch
     end
 
     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
+      base.columns_hash[column.to_s] unless base_excludes_attribute(base, column)
+    end
+
+    def base_excludes_attribute(base, column)
+      base._metasearch_include_attributes.blank? ?
+        base._metasearch_exclude_attributes.include?(column.to_s) :
+        !base._metasearch_include_attributes.include?(column.to_s)
     end
 
     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
+      base.reflect_on_association(assoc.to_sym) unless base_excludes_association(base, assoc)
+    end
+
+    def base_excludes_association(base, assoc)
+      base._metasearch_include_associations.blank? ?
+        base._metasearch_exclude_associations.include?(assoc.to_s) :
+        !base._metasearch_include_associations.include?(assoc.to_s)
     end
 
     def get_attribute(name, parent = @join_dependency.join_base)
@@ -62,9 +66,9 @@ module MetaSearch
       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]
+          attribute = relation[name]
         else
-          attribute = @relation.table[name]
+          attribute = @relation.arel_table[name]
         end
       elsif (segments = name.to_s.split(/_/)).size > 1
         remainder = []
@@ -103,9 +107,8 @@ module MetaSearch
     end
 
     def respond_to?(method_id, include_private = false)
-      return true if super # Hopefully we've already defined the method.
+      return true if super
 
-      # Curses! Looks like we'll need to do this the hard way.
       method_name = method_id.to_s
       if RELATION_METHODS.map(&:to_s).include?(method_name)
         true
@@ -123,6 +126,22 @@ module MetaSearch
 
     private
 
+    def assign_attributes(opts)
+      opts.each_pair do |k, v|
+        self.send("#{k}=", v)
+      end
+    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 method_missing(method_id, *args, &block)
       method_name = method_id.to_s
       if method_name =~ /^meta_sort=?$/
@@ -141,43 +160,22 @@ module MetaSearch
       end
     end
 
-    def build_join_dependency
-      joins = @relation.joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
-
-      association_joins = joins.select do |j|
-        [Hash, Array, Symbol].include?(j.class) && !array_of_strings?(j)
-      end
-
-      stashed_association_joins = joins.select do |j|
-        j.is_a?(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)
-      end
-
-      non_association_joins = (joins - association_joins - stashed_association_joins)
-      custom_joins = custom_join_sql(*non_association_joins)
-
-      ActiveRecord::Associations::ClassMethods::JoinDependency.new(@base, association_joins, custom_joins)
+    def matches_named_method(name)
+      method_name = name.to_s.sub(/\=$/, '')
+      return method_name if @base._metasearch_methods.has_key?(method_name)
     end
 
-    def custom_join_sql(*joins)
-      arel = @relation.table
-      joins.each do |join|
-        next if join.blank?
-
-        case join
-        when Hash, Array, Symbol
-          if array_of_strings?(join)
-            join_string = join.join(' ')
-            arel = arel.join(join_string)
-          end
-        else
-          arel = arel.join(join)
-        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, predicate = match.captures
+      attributes = attribute.split(/_or_/)
+      if attributes.all? {|a| where.types.include?(column_type(a))}
+        return match
       end
-      arel.joins(arel)
-    end
-
-    def array_of_strings?(o)
-      o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
+      nil
     end
 
     def get_sort
@@ -187,36 +185,24 @@ module MetaSearch
     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
-
-    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)
-            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)
+      if ['asc','desc'].include?(direction)
+        if @base.respond_to?("sort_by_#{column}_#{direction}")
+          search_attributes['meta_sort'] = val
+          @relation = @relation.send("sort_by_#{column}_#{direction}")
+        elsif attribute = get_attribute(column)
+          search_attributes['meta_sort'] = val
+          @relation = @relation.order(attribute.send(direction).to_sql)
+        elsif column.scan('_and_').present?
+          attribute_names = column.split('_and_')
+          attributes = attribute_names.map {|n| get_attribute(n)}
+          if attribute_names.size == attributes.compact.size # We found all attributes
+            search_attributes['meta_sort'] = val
+            attributes.each do |attribute|
+              @relation = @relation.order(attribute.send(direction).to_sql)
             end
           end
         end
       end
-      type
     end
 
     def get_named_method_value(name)
@@ -250,6 +236,38 @@ module MetaSearch
       end
     end
 
+    def column_type(name, base = @base)
+      type = nil
+      if column = get_column(name, base)
+        type = column.type
+      elsif (segments = name.split(/_/)).size > 1
+        type = type_from_association_segments(segments, base)
+      end
+      type
+    end
+
+    def type_from_association_segments(segments, base)
+      remainder = []
+      found_assoc = nil
+      type = nil
+      while remainder.unshift(segments.pop) && segments.size > 0 && !found_assoc do
+        if found_assoc = get_association(segments.join('_'), base)
+          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
+      type
+    end
+
     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 &&
@@ -257,75 +275,47 @@ module MetaSearch
         assoc.parent == parent
       end
       unless found_association
-        @join_dependency.send(:build_with_metasearch, association, parent, Arel::OuterJoin, klass)
+        @join_dependency.send(:build_with_metasearch, association, parent, Arel::Nodes::OuterJoin, klass)
         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 build_join_dependency
+      joins = @relation.joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
 
-    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, predicate = match.captures
-      attributes = attribute.split(/_or_/)
-      if attributes.all? {|a| where.types.include?(column_type(a))}
-        return match
+      association_joins = joins.select do |j|
+        [Hash, Array, Symbol].include?(j.class) && !array_of_strings?(j)
       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")
+      stashed_association_joins = joins.select do |j|
+        j.is_a?(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)
       end
-      method_name
-    end
 
-    def assign_attributes(opts)
-      opts.each_pair do |k, v|
-        self.send("#{k}=", v)
-      end
-    end
+      non_association_joins = (joins - association_joins - stashed_association_joins)
+      custom_joins = custom_join_sql(*non_association_joins)
 
-    def type_for(attribute)
-      column = self.column(attribute)
-      column.type if column
+      ActiveRecord::Associations::ClassMethods::JoinDependency.new(@base, association_joins, custom_joins)
     end
 
-    def class_for(attribute)
-      column = self.column(attribute)
-      column.klass if column
-    end
+    def custom_join_sql(*joins)
+      arel = @relation.table
+      joins.each do |join|
+        next if join.blank?
 
-    def association_type_for(association, attribute)
-      column = self.association_column(association, attribute)
-      column.type if column
+        case join
+        when Hash, Array, Symbol
+          if array_of_strings?(join)
+            join_string = join.join(' ')
+            arel = arel.join(join_string)
+          end
+        else
+          arel = arel.join(join)
+        end
+      end
+      arel.joins(arel)
     end
 
-    def association_class_for(association, attribute)
-      column = self.association_column(association, attribute)
-      column.klass if column
-    end
   end
 end

data/lib/meta_search/helpers/form_helper.rb

@@ -2,17 +2,22 @@ module MetaSearch
   module Helpers
     module FormHelper
       def apply_form_for_options!(object_or_array, options)
-        if object_or_array.is_a?(Array) && (builder = object_or_array.detect {|o| o.is_a? MetaSearch::Builder})
-          html_options = {
-            :class  => options[:as] ? "#{options[:as]}_search" : "#{builder.base.to_s.underscore}_search",
-            :id => options[:as] ? "#{options[:as]}_search" : "#{builder.base.to_s.underscore}_search",
-            :method => :get }
-          options[:html] ||= {}
-          options[:html].reverse_merge!(html_options)
-          options[:url] ||= polymorphic_path(object_or_array.map {|o| o.is_a?(MetaSearch::Builder) ? o.base : o})
+        if object_or_array.is_a?(MetaSearch::Builder)
+          builder = object_or_array
+          url = polymorphic_path(object_or_array.base)
+        elsif object_or_array.is_a?(Array) && (builder = object_or_array.detect {|o| o.is_a?(MetaSearch::Builder)})
+          url = polymorphic_path(object_or_array.map {|o| o.is_a?(MetaSearch::Builder) ? o.base : o})
         else
-          super
+          super and return
         end
+
+        html_options = {
+          :class  => options[:as] ? "#{options[:as]}_search" : "#{builder.base.to_s.underscore}_search",
+          :id => options[:as] ? "#{options[:as]}_search" : "#{builder.base.to_s.underscore}_search",
+          :method => :get }
+        options[:html] ||= {}
+        options[:html].reverse_merge!(html_options)
+        options[:url] ||= url
       end
     end
   end

data/lib/meta_search/helpers/url_helper.rb

@@ -19,7 +19,7 @@ module MetaSearch
       def sort_link(builder, attribute, *args)
         raise ArgumentError, "Need a MetaSearch::Builder search object as first param!" unless builder.is_a?(MetaSearch::Builder)
         attr_name = attribute.to_s
-        name = (args.size > 0 && !args.first.is_a?(Hash)) ? args.shift.to_s : attr_name.humanize
+        name = (args.size > 0 && !args.first.is_a?(Hash)) ? args.shift.to_s : builder.base.human_attribute_name(attr_name)
         prev_attr, prev_order = builder.search_attributes['meta_sort'].to_s.split('.')
         current_order = prev_attr == attr_name ? prev_order : nil
         new_order = current_order == 'asc' ? 'desc' : 'asc'
@@ -28,7 +28,7 @@ module MetaSearch
         css = ['sort_link', current_order].compact.join(' ')
         html_options[:class] = [css, html_options[:class]].compact.join(' ')
         options.merge!(
-          'search' => builder.search_attributes.merge(
+          builder.search_key => builder.search_attributes.merge(
             'meta_sort' => [attr_name, new_order].join('.')
           )
         )

data/lib/meta_search/join_dependency.rb

@@ -13,8 +13,8 @@ module MetaSearch
         join_associations.detect {|a| association == a} ||
         (
           association.class == MetaSearch::PolymorphicJoinAssociation ?
-          build_with_metasearch(association.reflection.name, association.find_parent_in(self) || join_base, association.join_class, association.reflection.klass) :
-          build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_class)
+          build_with_metasearch(association.reflection.name, association.find_parent_in(self) || join_base, association.join_type, association.reflection.klass) :
+          build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_type)
         )
       end
       self
@@ -22,7 +22,7 @@ module MetaSearch
 
     protected
 
-      def build_with_metasearch(association, parent = nil, join_class = Arel::InnerJoin, polymorphic_class = nil)
+      def build_with_metasearch(association, parent = nil, join_type = Arel::Nodes::InnerJoin, polymorphic_class = nil)
         parent ||= @joins.last
         case association
         when Symbol, String
@@ -30,13 +30,17 @@ module MetaSearch
           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)
+            association = build_polymorphic_join_association(reflection, parent, polymorphic_class)
+            association.join_type = join_type
+            @joins << association
           else
             @reflections << reflection
-            @joins << build_join_association(reflection, parent).with_join_class(join_class)
+            association = build_join_association(reflection, parent)
+            association.join_type = join_type
+            @joins << association
           end
         else
-          build(association, parent, join_class) # Shouldn't get here.
+          build(association, parent, join_type) # Shouldn't get here.
         end
       end
 
@@ -59,7 +63,7 @@ module MetaSearch
       @parent_table_name  = @parent.active_record.table_name
       @aliased_table_name = aliased_table_name_for(table_name)
       @join               = nil
-      @join_class         = Arel::InnerJoin
+      @join_type        = Arel::Nodes::InnerJoin
     end
 
     def ==(other)

data/lib/meta_search/model_compatibility.rb

@@ -1,13 +1,13 @@
 module MetaSearch
-  # Just a little module to mix in so that ActionPack doesn't complain.
+
   module ModelCompatibility
+
     def self.included(base)
       base.extend ClassMethods
     end
 
-    # Force default "Update search" text
     def persisted?
-      true
+      false
     end
 
     def to_key
@@ -21,26 +21,29 @@ module MetaSearch
     def to_model
       self
     end
+  end
 
-    class Name < String
-      attr_reader :singular, :plural, :element, :collection, :partial_path, :human
-      alias_method :cache_key, :collection
-
-      def initialize
-        super("Search")
-        @singular = "search".freeze
-        @plural = "searches".freeze
-        @element = "search".freeze
-        @human = "Search".freeze
-        @collection = "meta_search/searches".freeze
-        @partial_path = "#{@collection}/#{@element}".freeze
-      end
+  class Name < String
+    attr_reader :singular, :plural, :element, :collection, :partial_path, :human, :param_key, :route_key
+    alias_method :cache_key, :collection
+
+    def initialize
+      super("Search")
+      @singular = "search".freeze
+      @plural = "searches".freeze
+      @element = "search".freeze
+      @human = "Search".freeze
+      @collection = "meta_search/searches".freeze
+      @partial_path = "#{@collection}/#{@element}".freeze
+      @param_key = "search".freeze
+      @route_key = "searches".freeze
     end
+  end
 
-    module ClassMethods
-      def model_name
-        @_model_name ||= Name.new
-      end
+  module ClassMethods
+    def model_name
+      @_model_name ||= Name.new
     end
   end
+
 end

data/lib/meta_search/searches/active_record.rb

@@ -2,92 +2,94 @@ require 'active_support/concern'
 require 'meta_search/method'
 require 'meta_search/builder'
 
-module MetaSearch::Searches
-  module ActiveRecord
+module MetaSearch
+  module Searches
+    module ActiveRecord
 
-    def self.included(base)
-      base.extend ClassMethods
+      def self.included(base)
+        base.extend ClassMethods
 
-      base.class_eval do
-        class_attribute :_metasearch_include_attributes, :_metasearch_exclude_attributes
-        class_attribute :_metasearch_include_associations, :_metasearch_exclude_associations
-        class_attribute :_metasearch_methods
-        self._metasearch_include_attributes =
-          self._metasearch_exclude_attributes =
-          self._metasearch_exclude_associations =
-          self._metasearch_include_associations = []
-        self._metasearch_methods = {}
+        base.class_eval do
+          class_attribute :_metasearch_include_attributes, :_metasearch_exclude_attributes
+          class_attribute :_metasearch_include_associations, :_metasearch_exclude_associations
+          class_attribute :_metasearch_methods
+          self._metasearch_include_attributes =
+            self._metasearch_exclude_attributes =
+            self._metasearch_exclude_associations =
+            self._metasearch_include_associations = []
+          self._metasearch_methods = {}
+        end
       end
-    end
 
-    module ClassMethods
-      # Prepares the search to run against your model. Returns an instance of
-      # MetaSearch::Builder, which behaves pretty much like an ActiveRecord::Relation,
-      # in that it doesn't actually query the database until you do something that
-      # requires it to do so.
-      def metasearch(opts = {})
-        opts ||= {} # to catch nil params
-        search_options = opts.delete(:search_options) || {}
-        builder = MetaSearch::Builder.new(self, search_options)
-        builder.build(opts)
-      end
+      module ClassMethods
+        # Prepares the search to run against your model. Returns an instance of
+        # MetaSearch::Builder, which behaves pretty much like an ActiveRecord::Relation,
+        # in that it doesn't actually query the database until you do something that
+        # requires it to do so.
+        def metasearch(params = nil, opts = nil)
+          builder = MetaSearch::Builder.new(self, opts || {})
+          builder.build(params || {})
+        end
 
-      alias_method :search, :metasearch unless respond_to?(:search)
+        alias_method :search, :metasearch unless respond_to?(:search)
 
-      private
+        private
 
-      # Excludes model attributes from searchability. This means that searches can't be created against
-      # these columns, whether the search is based on this model, or the model's attributes are being
-      # searched by association from another model. If a Comment <tt>belongs_to :article</tt> but declares
-      # <tt>attr_unsearchable :user_id</tt> then <tt>Comment.search</tt> won't accept parameters
-      # like <tt>:user_id_equals</tt>, nor will an Article.search accept the parameter
-      # <tt>:comments_user_id_equals</tt>.
-      def attr_unsearchable(*args)
-        args.flatten.each do |attr|
-          attr = attr.to_s
-          raise(ArgumentError, "No persisted attribute (column) named #{attr} in #{self}") unless self.columns_hash.has_key?(attr)
-          self._metasearch_exclude_attributes = (self._metasearch_exclude_attributes + [attr]).uniq
+        # Excludes model attributes from searchability. This means that searches can't be created against
+        # these columns, whether the search is based on this model, or the model's attributes are being
+        # searched by association from another model. If a Comment <tt>belongs_to :article</tt> but declares
+        # <tt>attr_unsearchable :user_id</tt> then <tt>Comment.search</tt> won't accept parameters
+        # like <tt>:user_id_equals</tt>, nor will an Article.search accept the parameter
+        # <tt>:comments_user_id_equals</tt>.
+        def attr_unsearchable(*args)
+          args.flatten.each do |attr|
+            attr = attr.to_s
+            raise(ArgumentError, "No persisted attribute (column) named #{attr} in #{self}") unless self.columns_hash.has_key?(attr)
+            self._metasearch_exclude_attributes = (self._metasearch_exclude_attributes + [attr]).uniq
+          end
         end
-      end
 
-      # Like <tt>attr_unsearchable</tt>, but operates as a whitelist rather than blacklist. If both
-      # <tt>attr_searchable</tt> and <tt>attr_unsearchable</tt> are present, the latter
-      # is ignored.
-      def attr_searchable(*args)
-        args.flatten.each do |attr|
-          attr = attr.to_s
-          raise(ArgumentError, "No persisted attribute (column) named #{attr} in #{self}") unless self.columns_hash.has_key?(attr)
-          self._metasearch_include_attributes = (self._metasearch_include_attributes + [attr]).uniq
+        # Like <tt>attr_unsearchable</tt>, but operates as a whitelist rather than blacklist. If both
+        # <tt>attr_searchable</tt> and <tt>attr_unsearchable</tt> are present, the latter
+        # is ignored.
+        def attr_searchable(*args)
+          args.flatten.each do |attr|
+            attr = attr.to_s
+            raise(ArgumentError, "No persisted attribute (column) named #{attr} in #{self}") unless self.columns_hash.has_key?(attr)
+            self._metasearch_include_attributes = (self._metasearch_include_attributes + [attr]).uniq
+          end
         end
-      end
 
-      # Excludes model associations from searchability. This mean that searches can't be created against
-      # these associations. An article that <tt>has_many :comments</tt> but excludes comments from
-      # searching by declaring <tt>assoc_unsearchable :comments</tt> won't make any of the
-      # <tt>comments_*</tt> methods available.
-      def assoc_unsearchable(*args)
-        args.flatten.each do |assoc|
-          assoc = assoc.to_s
-          raise(ArgumentError, "No such association #{assoc} in #{self}") unless self.reflect_on_all_associations.map {|a| a.name.to_s}.include?(assoc)
-          self._metasearch_exclude_associations = (self._metasearch_exclude_associations + [assoc]).uniq
+        # Excludes model associations from searchability. This mean that searches can't be created against
+        # these associations. An article that <tt>has_many :comments</tt> but excludes comments from
+        # searching by declaring <tt>assoc_unsearchable :comments</tt> won't make any of the
+        # <tt>comments_*</tt> methods available.
+        def assoc_unsearchable(*args)
+          args.flatten.each do |assoc|
+            assoc = assoc.to_s
+            raise(ArgumentError, "No such association #{assoc} in #{self}") unless self.reflect_on_all_associations.map {|a| a.name.to_s}.include?(assoc)
+            self._metasearch_exclude_associations = (self._metasearch_exclude_associations + [assoc]).uniq
+          end
         end
-      end
 
-      # As with <tt>attr_searchable</tt> this is the whitelist version of
-      # <tt>assoc_unsearchable</tt>
-      def assoc_searchable(*args)
-        args.flatten.each do |assoc|
-          assoc = assoc.to_s
-          raise(ArgumentError, "No such association #{assoc} in #{self}") unless self.reflect_on_all_associations.map {|a| a.name.to_s}.include?(assoc)
-          self._metasearch_include_associations = (self._metasearch_include_associations + [assoc]).uniq
+        # As with <tt>attr_searchable</tt> this is the whitelist version of
+        # <tt>assoc_unsearchable</tt>
+        def assoc_searchable(*args)
+          args.flatten.each do |assoc|
+            assoc = assoc.to_s
+            raise(ArgumentError, "No such association #{assoc} in #{self}") unless self.reflect_on_all_associations.map {|a| a.name.to_s}.include?(assoc)
+            self._metasearch_include_associations = (self._metasearch_include_associations + [assoc]).uniq
+          end
         end
-      end
 
-      def search_methods(*args)
-        opts = args.last.is_a?(Hash) ? args.pop : {}
-        args.flatten.map(&:to_s).each do |arg|
-          self._metasearch_methods[arg] = MetaSearch::Method.new(arg, opts)
+        def search_methods(*args)
+          opts = args.last.is_a?(Hash) ? args.pop : {}
+          args.flatten.map(&:to_s).each do |arg|
+            self._metasearch_methods[arg] = MetaSearch::Method.new(arg, opts)
+          end
         end
+
+        alias_method :search_method, :search_methods
       end
     end
   end

data/lib/meta_search/utility.rb

@@ -8,6 +8,20 @@ module MetaSearch
 
     private
 
+    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 array_of_strings?(o)
+      o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
+    end
+
     def array_of_arrays?(vals)
       vals.is_a?(Array) && vals.first.is_a?(Array)
     end

data/lib/meta_search/where.rb

@@ -245,7 +245,6 @@ module MetaSearch
           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)}

data/lib/meta_search.rb

@@ -13,11 +13,11 @@ module MetaSearch
     ['equals', 'eq', {:validator => Proc.new {|param| !param.blank? || (param == false)}}],
     ['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}%"'}],
+    ['does_not_contain', 'nlike', 'not_matches', {:types => STRINGS, :predicate => :does_not_match, :formatter => '"%#{param}%"'}],
     ['starts_with', 'sw', {:types => STRINGS, :predicate => :matches, :formatter => '"#{param}%"'}],
-    ['does_not_start_with', 'dnsw', {:types => STRINGS, :predicate => :not_matches, :formatter => '"%#{param}%"'}],
+    ['does_not_start_with', 'dnsw', {:types => STRINGS, :predicate => :does_not_match, :formatter => '"%#{param}%"'}],
     ['ends_with', 'ew', {:types => STRINGS, :predicate => :matches, :formatter => '"%#{param}"'}],
-    ['does_not_end_with', 'dnew', {:types => STRINGS, :predicate => :not_matches, :formatter => '"%#{param}"'}],
+    ['does_not_end_with', 'dnew', {:types => STRINGS, :predicate => :does_not_match, :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}],
@@ -26,8 +26,8 @@ module MetaSearch
     ['not_in', 'ni', 'not_in', {:types => ALL_TYPES, :predicate => :not_in}],
     ['is_true', {:types => BOOLEANS, :skip_compounds => true}],
     ['is_false', {:types => BOOLEANS, :skip_compounds => true, :formatter => Proc.new {|param| !param}}],
-    ['is_present', {:types => (NUMBERS + STRINGS), :predicate => :not_eq_all, :splat_param => true, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| [nil, '']}}],
-    ['is_blank', {:types => (NUMBERS + STRINGS), :predicate => :eq_any, :splat_param => true, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| [nil, '']}}],
+    ['is_present', {:types => (NUMBERS + STRINGS), :predicate => :not_eq_all, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| [nil, '']}}],
+    ['is_blank', {:types => (NUMBERS + STRINGS), :predicate => :eq_any, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| [nil, '']}}],
     ['is_null', {:types => ALL_TYPES, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| nil}}],
     ['is_not_null', {:types => ALL_TYPES, :predicate => :not_eq, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| nil}}]
   ]

data/meta_search.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{meta_search}
-  s.version = "0.9.8"
+  s.version = "0.9.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ernie Miller"]
-  s.date = %q{2010-10-20}
+  s.date = %q{2010-11-15}
   s.description = %q{
       Allows simple search forms to be created against an AR3 model
       and its associations, has useful view helpers for sort links
@@ -57,6 +57,8 @@ Gem::Specification.new do |s|
      "test/fixtures/projects.yml",
      "test/fixtures/schema.rb",
      "test/helper.rb",
+     "test/locales/en.yml",
+     "test/locales/es.yml",
      "test/test_search.rb",
      "test/test_view_helpers.rb"
   ]
@@ -91,23 +93,23 @@ you're feeling especially appreciative. It'd help me justify this
 
     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"])
-      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.0"])
-      s.add_runtime_dependency(%q<actionpack>, ["~> 3.0.0"])
-      s.add_runtime_dependency(%q<arel>, ["~> 1.0.1"])
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.2"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.2"])
+      s.add_runtime_dependency(%q<actionpack>, ["~> 3.0.2"])
+      s.add_runtime_dependency(%q<arel>, ["~> 2.0.2"])
     else
       s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
-      s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
-      s.add_dependency(%q<actionpack>, ["~> 3.0.0"])
-      s.add_dependency(%q<arel>, ["~> 1.0.1"])
+      s.add_dependency(%q<activerecord>, ["~> 3.0.2"])
+      s.add_dependency(%q<activesupport>, ["~> 3.0.2"])
+      s.add_dependency(%q<actionpack>, ["~> 3.0.2"])
+      s.add_dependency(%q<arel>, ["~> 2.0.2"])
     end
   else
     s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
-    s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
-    s.add_dependency(%q<actionpack>, ["~> 3.0.0"])
-    s.add_dependency(%q<arel>, ["~> 1.0.1"])
+    s.add_dependency(%q<activerecord>, ["~> 3.0.2"])
+    s.add_dependency(%q<activesupport>, ["~> 3.0.2"])
+    s.add_dependency(%q<actionpack>, ["~> 3.0.2"])
+    s.add_dependency(%q<arel>, ["~> 2.0.2"])
   end
 end
 

data/test/fixtures/developer.rb

@@ -2,7 +2,10 @@ 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
+
+  scope :sort_by_salary_and_name_asc, order('salary ASC, name ASC')
+  scope :sort_by_salary_and_name_desc, order('salary DESC, name DESC')
 end

data/test/helper.rb

@@ -25,6 +25,8 @@ end
 
 Fixtures.create_fixtures(FIXTURES_PATH, ActiveRecord::Base.connection.tables)
 
+I18n.load_path = Dir[File.join(File.dirname(__FILE__), 'locales', '*.{rb,yml}')]
+
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 

data/test/locales/en.yml

@@ -0,0 +1,36 @@
+en:
+  date:
+    formats:
+      # Use the strftime parameters for formats.
+      # When no format has been given, it uses default.
+      # You can provide other formats here if you like!
+      default: "%Y-%m-%d"
+      short: "%b %d"
+      long: "%B %d, %Y"
+
+    day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
+    abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
+
+    # Don't forget the nil at the beginning; there's no such thing as a 0th month
+    month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
+    abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
+    # Used in date_select and datetime_select.
+    order:
+      - :year
+      - :month
+      - :day
+
+  time:
+    formats:
+      default: "%a, %d %b %Y %H:%M:%S %z"
+      short: "%d %b %H:%M"
+      long: "%B %d, %Y %H:%M"
+    am: "am"
+    pm: "pm"
+
+# Used in array.to_sentence.
+  support:
+    array:
+      words_connector: ", "
+      two_words_connector: " and "
+      last_word_connector: ", and "

data/test/locales/es.yml

@@ -0,0 +1,5 @@
+es:
+  activerecord:
+    attributes:
+      company:
+        name: Nombre

data/test/test_search.rb

@@ -298,6 +298,17 @@ class TestSearch < Test::Unit::TestCase
         end
       end
 
+      context "sorted by salary and name in descending order" do
+        setup do
+          @s.meta_sort = 'salary_and_name.desc'
+        end
+
+        should "sort by salary and name in descending order" do
+          assert_equal Developer.order('salary DESC, name DESC').all,
+                       @s.all
+        end
+      end
+
       context "where developer is Bob-approved" do
         setup do
           @s.notes_note_equals = "A straight shooter with upper management written all over him."

data/test/test_view_helpers.rb

@@ -198,6 +198,80 @@ class TestViewHelpers < ActionView::TestCase
       assert_no_match /Created at &#9650;/,
                       @f.sort_link(:created_at, :controller => 'companies')
     end
+
+    context "and a localization" do
+      setup do
+        I18n.locale = :es
+      end
+
+      teardown do
+        I18n.locale = nil
+      end
+
+      should "use the localized name for the attribute" do
+        assert_match /Nombre/,
+                     @f.sort_link(:name, :controller => 'companies')
+      end
+    end
+  end
+
+  context "A developer search form sorted by a custom sort method" do
+    setup do
+      @s = Developer.search
+      @s.meta_sort = 'salary_and_name.asc'
+      form_for @s do |f|
+        @f = f
+      end
+    end
+
+    should "generate a sort link with humanized text" do
+      assert_match /Salary and name &#9650;/,
+                   @f.sort_link(:salary_and_name, :controller => 'developers')
+    end
+
+    should "sort results as expected" do
+      assert_equal Developer.order('salary ASC, name ASC'),
+                   @s.all
+    end
+  end
+
+  context "A developer search form sorted by multiple columns" do
+    setup do
+      @s = Developer.search
+      @s.meta_sort = 'name_and_salary.asc'
+      form_for @s do |f|
+        @f = f
+      end
+    end
+
+    should "generate a sort link with humanized text" do
+      assert_match /Name and salary &#9650;/,
+                   @f.sort_link(:name_and_salary, :controller => 'developers')
+    end
+
+    should "order by both columns in the order they were specified" do
+      assert_match /ORDER BY "developers"."name" ASC, "developers"."salary" ASC/,
+                   @s.to_sql
+    end
+
+    should "return expected results" do
+      assert_equal Developer.order('name ASC, salary ASC').all,
+                   @s.all
+    end
+  end
+
+  context "A company search form with an alternate search_key" do
+    setup do
+      @s = Company.search({}, :search_key => 'searchy_mcsearchhead')
+      form_for @s do |f|
+        @f = f
+      end
+    end
+
+    should "generate a sort link that places meta_sort param under the specified key" do
+      assert_match /searchy_mcsearchhead/,
+                   @f.sort_link(:name, :controller => 'companies')
+    end
   end
 
   context "A company search" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 8
-  version: 0.9.8
+  - 9
+  version: 0.9.9
 platform: ruby
 authors: 
 - Ernie Miller
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-20 00:00:00 -04:00
+date: 2010-11-15 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,8 +41,8 @@ dependencies:
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 2
+        version: 3.0.2
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -56,8 +56,8 @@ dependencies:
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 2
+        version: 3.0.2
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -71,8 +71,8 @@ dependencies:
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 2
+        version: 3.0.2
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
@@ -84,10 +84,10 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version 
         segments: 
-        - 1
+        - 2
         - 0
-        - 1
-        version: 1.0.1
+        - 2
+        version: 2.0.2
   type: :runtime
   version_requirements: *id005
 description: "\n      Allows simple search forms to be created against an AR3 model\n      and its associations, has useful view helpers for sort links\n      and multiparameter fields as well.\n    "
@@ -136,6 +136,8 @@ files:
 - test/fixtures/projects.yml
 - test/fixtures/schema.rb
 - test/helper.rb
+- test/locales/en.yml
+- test/locales/es.yml
 - test/test_search.rb
 - test/test_view_helpers.rb
 has_rdoc: true