meta_search 0.9.10 → 0.9.11

data/CHANGELOG

@@ -1,3 +1,12 @@
+Changes since 0.9.10 (2010-11-18):
+  * Skip attempts to sort if someone passes an empty string to meta_sort
+  * Allow conditions on search_methods, (attr|assoc)_(un)?searchable using :if.
+    Option should be an object that responds to call and accepts the
+    MetaSearch::Builder instance as a parameter. Unused options passed to the
+    Model.search method will be available for your conditions to act on.
+  * Access attribute setters if a param is supplied - @search.attr_name(val)
+    behaves like @search.attr_name = val
+
 Changes since 0.9.9 (2010-11-15):
   * Fix bug introduced by new polymorphic belongs_to association code in
     honoring :url param to form_for

data/VERSION

@@ -1 +1 @@
-0.9.10
+0.9.11

data/lib/meta_search/builder.rb

@@ -22,38 +22,28 @@ module MetaSearch
     include ModelCompatibility
     include Utility
 
-    attr_reader :base, :relation, :search_key, :search_attributes, :join_dependency, :errors
+    attr_reader :base, :relation, :search_key, :search_attributes, :join_dependency, :errors, :options
     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_or_relation, opts = {})
+      opts = opts.dup
       @relation = base_or_relation.scoped
       @base = @relation.klass
-      @search_key = opts[:search_key] ? opts[:search_key].to_s : 'search'
+      @search_key = (opts.delete(:search_key) || 'search').to_s
+      @options = opts  # Let's just hang on to other options for use in authorization blocks
       @join_dependency = build_join_dependency
       @search_attributes = {}
       @errors = ActiveModel::Errors.new(self)
     end
 
     def get_column(column, base = @base)
-      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)
+      base.columns_hash[column.to_s] if base._metasearch_attribute_authorized?(column, self)
     end
 
     def get_association(assoc, base = @base)
-      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)
+      base.reflect_on_association(assoc.to_sym) if base._metasearch_association_authorized?(assoc, self)
     end
 
     def get_attribute(name, parent = @join_dependency.join_base)
@@ -134,16 +124,16 @@ module MetaSearch
     def method_missing(method_id, *args, &block)
       method_name = method_id.to_s
       if method_name =~ /^meta_sort=?$/
-        method_name =~ /=$/ ? set_sort(args.first) : get_sort
+        (args.any? || 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_name)
-        method_name =~ /=$/ ? set_named_method_value(match, args.first) : get_named_method_value(match)
+        (args.any? || 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
-        method_name =~ /=$/ ? set_attribute_method_value(attribute, predicate, args.first) : get_attribute_method_value(attribute, predicate)
+         (args.any? || method_name =~ /=$/) ? set_attribute_method_value(attribute, predicate, args.first) : get_attribute_method_value(attribute, predicate)
       else
         super
       end
@@ -151,7 +141,7 @@ module MetaSearch
 
     def matches_named_method(name)
       method_name = name.to_s.sub(/\=$/, '')
-      return method_name if @base._metasearch_methods.has_key?(method_name)
+      return method_name if @base._metasearch_method_authorized?(method_name, self)
     end
 
     def matches_attribute_method(method_id)
@@ -172,6 +162,7 @@ module MetaSearch
     end
 
     def set_sort(val)
+      return if val.blank?
       column, direction = val.split('.')
       direction ||= 'asc'
       if ['asc','desc'].include?(direction)
@@ -199,7 +190,7 @@ module MetaSearch
     end
 
     def set_named_method_value(name, val)
-      meth = @base._metasearch_methods[name]
+      meth = @base._metasearch_methods[name][:method]
       search_attributes[name] = meth.cast_param(val)
       if meth.validate(search_attributes[name])
         return_value = meth.evaluate(@relation, search_attributes[name])

data/lib/meta_search/join_dependency.rb

@@ -22,25 +22,27 @@ module MetaSearch
 
     protected
 
-      def build_with_metasearch(association, parent = nil, join_type = Arel::Nodes::InnerJoin, polymorphic_class = nil)
+      def build_with_metasearch(associations, parent = nil, join_type = Arel::Nodes::InnerJoin, polymorphic_class = nil)
         parent ||= @joins.last
-        case association
+
+        case associations
         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]
+          reflection = parent.reflections[associations.to_s.intern] or
+            raise ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?"
+          unless (association = find_join_association(reflection, parent)) && (!polymorphic_class || association.active_record == polymorphic_class)
             @reflections << reflection
-            association = build_polymorphic_join_association(reflection, parent, polymorphic_class)
-            association.join_type = join_type
-            @joins << association
-          else
-            @reflections << reflection
-            association = build_join_association(reflection, parent)
+            if reflection.options[:polymorphic]
+              raise ArgumentError, "You can't create a polymorphic belongs_to join without specifying the polymorphic class!" unless polymorphic_class
+              association = build_polymorphic_join_association(reflection, parent, polymorphic_class)
+            else
+              association = build_join_association(reflection, parent)
+            end
             association.join_type = join_type
             @joins << association
           end
+          association
         else
-          build(association, parent, join_type) # Shouldn't get here.
+          build(associations, parent, join_type)
         end
       end
 
@@ -58,12 +60,12 @@ module MetaSearch
       @join_dependency    = join_dependency
       @parent             = parent || join_dependency.join_base
       @reflection         = reflection.clone
-      @reflection.instance_eval "def klass; #{polymorphic_class} end"
+      @reflection.instance_variable_set(:"@klass", polymorphic_class)
       @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_type        = Arel::Nodes::InnerJoin
+      @join_type          = Arel::Nodes::InnerJoin
     end
 
     def ==(other)
@@ -81,15 +83,11 @@ module MetaSearch
 
       @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)
+        parent_table[options[:foreign_type]].eq(active_record.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
+      if options[:conditions]
+        @join << interpolate_sql(sanitize_sql(options[:conditions], aliased_table_name))
       end
 
       @join

data/lib/meta_search/locale/en.yml

@@ -1,5 +1,6 @@
 en:
   meta_search:
+    or: 'or'
     predicates:
       equals: "%{attribute} equals"
       does_not_equal: "%{attribute} doesn't equal"

data/lib/meta_search/model_compatibility.rb

@@ -58,13 +58,16 @@ module MetaSearch
       if method_name
         predicate = Where.get(method_name)[:name]
         predicate_attribute = method_name.sub(/_#{predicate}=?$/, '')
+        predicate_attributes = predicate_attribute.split(/_or_/).map { |att|
+          klass.human_attribute_name(att)
+        }.join(" #{I18n.translate(:"meta_search.or", :default => 'or')} ")
         defaults << :"meta_search.predicates.#{predicate}"
       end
 
       defaults << options.delete(:default) if options[:default]
       defaults << attribute.to_s.humanize
 
-      options.reverse_merge! :count => 1, :default => defaults, :attribute => klass.human_attribute_name(predicate_attribute || attribute)
+      options.reverse_merge! :count => 1, :default => defaults, :attribute => predicate_attributes || klass.human_attribute_name(attribute)
       I18n.translate(defaults.shift, options)
     end
   end

data/lib/meta_search/searches/active_record.rb

@@ -17,7 +17,7 @@ module MetaSearch
           self._metasearch_include_attributes =
             self._metasearch_exclude_attributes =
             self._metasearch_exclude_associations =
-            self._metasearch_include_associations = []
+            self._metasearch_include_associations = {}
           self._metasearch_methods = {}
         end
       end
@@ -34,6 +34,30 @@ module MetaSearch
 
         alias_method :search, :metasearch unless respond_to?(:search)
 
+        def _metasearch_method_authorized?(name, metasearch_object)
+          name = name.to_s
+          meth = self._metasearch_methods[name]
+          meth && (meth[:if] ? meth[:if].call(metasearch_object) : true)
+        end
+
+        def _metasearch_attribute_authorized?(name, metasearch_object)
+          name = name.to_s
+          if self._metasearch_include_attributes.empty?
+            !_metasearch_excludes_attribute?(name, metasearch_object)
+          else
+            _metasearch_includes_attribute?(name, metasearch_object)
+          end
+        end
+
+        def _metasearch_association_authorized?(name, metasearch_object)
+          name = name.to_s
+          if self._metasearch_include_associations.empty?
+            !_metasearch_excludes_association?(name, metasearch_object)
+          else
+            _metasearch_includes_association?(name, metasearch_object)
+          end
+        end
+
         private
 
         # Excludes model attributes from searchability. This means that searches can't be created against
@@ -43,10 +67,15 @@ module MetaSearch
         # like <tt>:user_id_equals</tt>, nor will an Article.search accept the parameter
         # <tt>:comments_user_id_equals</tt>.
         def attr_unsearchable(*args)
+          opts = args.extract_options!
           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
+            self._metasearch_exclude_attributes = self._metasearch_exclude_attributes.merge(
+              attr => {
+                :if => opts[:if]
+              }
+            )
           end
         end
 
@@ -54,10 +83,15 @@ module MetaSearch
         # <tt>attr_searchable</tt> and <tt>attr_unsearchable</tt> are present, the latter
         # is ignored.
         def attr_searchable(*args)
+          opts = args.extract_options!
           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
+            self._metasearch_include_attributes = self._metasearch_include_attributes.merge(
+              attr => {
+                :if => opts[:if]
+              }
+            )
           end
         end
 
@@ -66,31 +100,68 @@ module MetaSearch
         # searching by declaring <tt>assoc_unsearchable :comments</tt> won't make any of the
         # <tt>comments_*</tt> methods available.
         def assoc_unsearchable(*args)
+          opts = args.extract_options!
           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
+            self._metasearch_exclude_associations = self._metasearch_exclude_associations.merge(
+              assoc => {
+                :if => opts[:if]
+              }
+            )
           end
         end
 
         # As with <tt>attr_searchable</tt> this is the whitelist version of
         # <tt>assoc_unsearchable</tt>
         def assoc_searchable(*args)
+          opts = args.extract_options!
           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
+            self._metasearch_include_associations = self._metasearch_include_associations.merge(
+              assoc => {
+                :if => opts[:if]
+              }
+            )
           end
         end
 
         def search_methods(*args)
-          opts = args.last.is_a?(Hash) ? args.pop : {}
+          opts = args.extract_options!
+          authorizer = opts.delete(:if)
           args.flatten.map(&:to_s).each do |arg|
-            self._metasearch_methods[arg] = MetaSearch::Method.new(arg, opts)
+            self._metasearch_methods = self._metasearch_methods.merge(
+              arg => {
+                :method => MetaSearch::Method.new(arg, opts),
+                :if => authorizer
+              }
+            )
           end
         end
 
         alias_method :search_method, :search_methods
+
+        def _metasearch_includes_attribute?(name, metasearch_object)
+          attr = self._metasearch_include_attributes[name]
+          attr && (attr[:if] ? attr[:if].call(metasearch_object) : true)
+        end
+
+        def _metasearch_excludes_attribute?(name, metasearch_object)
+          attr = self._metasearch_exclude_attributes[name]
+          attr && (attr[:if] ? attr[:if].call(metasearch_object) : true)
+        end
+
+        def _metasearch_includes_association?(name, metasearch_object)
+          assoc = self._metasearch_include_associations[name]
+          assoc && (assoc[:if] ? assoc[:if].call(metasearch_object) : true)
+        end
+
+        def _metasearch_excludes_association?(name, metasearch_object)
+          assoc = self._metasearch_exclude_associations[name]
+          assoc && (assoc[:if] ? assoc[:if].call(metasearch_object) : true)
+        end
+
       end
     end
 

data/lib/meta_search.rb

@@ -32,9 +32,15 @@ module MetaSearch
     ['is_not_null', {:types => ALL_TYPES, :predicate => :not_eq, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| nil}}]
   ]
 
-  RELATION_METHODS = [:joins, :includes, :select, :order, :where, :having,
-                      :to_a, :all, :count, :length, :size, :to_sql, :debug_sql, :paginate,
-                      :find_each, :first, :last, :each, :arel]
+  RELATION_METHODS = [
+    # Query construction
+    :joins, :includes, :select, :order, :where, :having, :group,
+    # Results, debug, array methods
+    :to_a, :all, :length, :size, :to_sql, :debug_sql, :paginate,
+    :find_each, :first, :last, :each, :arel, :in_groups_of, :group_by,
+    # Calculations
+    :count, :average, :minimum, :maximum, :sum
+  ]
 end
 
 require 'active_record'

data/meta_search.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{meta_search}
-  s.version = "0.9.10"
+  s.version = "0.9.11"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ernie Miller"]
-  s.date = %q{2010-11-18}
+  s.date = %q{2011-01-06}
   s.description = %q{
       Allows simple search forms to be created against an AR3 model
       and its associations, has useful view helpers for sort links

data/test/fixtures/company.rb

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

data/test/fixtures/developer.rb

@@ -3,8 +3,8 @@ class Developer < ActiveRecord::Base
   has_and_belongs_to_many :projects
   has_many :notes, :as => :notable
 
-  attr_searchable :name, :salary
-  assoc_searchable :notes, :projects, :company
+  attr_searchable :name, :salary, :if => proc {|s| !s.options[:user] || s.options[:user] == 'privileged'}
+  assoc_searchable :notes, :projects, :company, :if => proc {|s| !s.options[:user] || s.options[:user] == 'privileged'}
 
   scope :sort_by_salary_and_name_asc, order('salary ASC, name ASC')
   scope :sort_by_salary_and_name_desc, order('salary DESC, name DESC')

data/test/locales/flanders.yml

@@ -3,9 +3,14 @@ flanders:
     attributes:
       company:
         name: "Company name-diddly"
+      developer:
+        name: "Developer name-diddly"
+        salary: "Developer salary-doodly"
   meta_search:
+    or: 'or-diddly'
     predicates:
       contains: "%{attribute} contains-diddly"
+      equals: "%{attribute} equals-diddly"
     attributes:
       company:
         reverse_name: "Company reverse name-diddly"

data/test/test_search.rb

@@ -2,6 +2,78 @@ require 'helper'
 
 class TestSearch < Test::Unit::TestCase
 
+  context "A Company search where options[:user] = 'blocked'" do
+    setup do
+      @s = Company.search({}, :user => 'blocked')
+    end
+
+    should "not respond_to? a search against backwards_name" do
+      assert !@s.respond_to?(:backwards_name), "The search responded to :backwards_name"
+    end
+
+    should "raise an error if we try to search on backwards_name" do
+      assert_raise NoMethodError do
+        @s.backwards_name = 'blah'
+      end
+    end
+
+    should "not respond_to? a search against updated_at_eq" do
+      assert !@s.respond_to?(:updated_at_eq), "The search responded to :updated_at_eq"
+    end
+
+    should "raise an error if we try to search on updated_at" do
+      assert_raise NoMethodError do
+        @s.updated_at_eq = 'blah'
+      end
+    end
+
+    should "not respond_to? a search against notes_note_matches" do
+      assert !@s.respond_to?(:notes_note_matches), "The search responded to :notes_note_matches"
+    end
+
+    should "raise an error if we try to search on notes_note_matches" do
+      assert_raise NoMethodError do
+        @s.notes_note_matches = '%blah%'
+      end
+    end
+  end
+
+  context "A Developer search where options[:user] = 'privileged'" do
+    setup do
+      @s = Developer.search({}, :user => 'privileged')
+    end
+
+    should "respond_to? a search against name_eq" do
+      assert_respond_to @s, :name_eq
+    end
+
+    should "not raise an error on a search against name_eq" do
+      assert_nothing_raised do
+        @s.name_eq = 'blah'
+      end
+    end
+
+    should "respond_to? a search against company_name_eq" do
+      assert_respond_to @s, :company_name_eq
+    end
+
+    should "not raise an error on a search against name_eq" do
+      assert_nothing_raised do
+        @s.company_name_eq = 'blah'
+      end
+    end
+
+    should "respond_to? a search against company_updated_at_eq" do
+      assert_respond_to @s, :company_updated_at_eq
+    end
+
+    should "not raise an error on a search against company_updated_at_eq" do
+      assert_nothing_raised do
+        @s.company_updated_at_eq = Time.now
+      end
+    end
+  end
+
   [{:name => 'Company', :object => Company},
    {:name => 'Company as a Relation', :object => Company.scoped}].each do |object|
     context_a_search_against object[:name], object[:object] do
@@ -86,31 +158,57 @@ class TestSearch < Test::Unit::TestCase
         end
       end
 
-      context "sorted by name in ascending order" do
+      context "when meta_sort value is empty string" do
         setup do
-          @s.meta_sort = 'name.asc'
+          @s.meta_sort = ''
         end
 
-        should "sort by name in ascending order" do
-          assert_equal Company.order('name asc').all,
-                       @s.all
+        should "not raise an error, just ignore sorting" do
+          assert_nothing_raised do
+            assert_equal Company.all, @s.all
+          end
         end
       end
 
-      context "sorted by name in descending order" do
+      should "sort by name in ascending order" do
+        @s.meta_sort = 'name.asc'
+        assert_equal Company.order('name asc').all,
+                     @s.all
+      end
+
+      should "sort by name in ascending order as a method call" do
+        @s.meta_sort 'name.asc'
+        assert_equal Company.order('name asc').all,
+                     @s.all
+      end
+
+      should "sort by name in descending order" do
+        @s.meta_sort = 'name.desc'
+        assert_equal Company.order('name desc').all,
+                     @s.all
+      end
+
+      context "where name contains optical" do
         setup do
-          @s.meta_sort = 'name.desc'
+          @s.name_contains = 'optical'
         end
 
-        should "sort by name in descending order" do
-          assert_equal Company.order('name desc').all,
-                       @s.all
+        should "return one result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "return a company named Advanced Optical Solutions" do
+          assert_contains @s.all, Company.where(:name => 'Advanced Optical Solutions').first
+        end
+
+        should "not return a company named Initech" do
+          assert_does_not_contain @s.all, Company.where(:name => "Initech").first
         end
       end
 
-      context "where name contains optical" do
+      context "where name contains optical as a method call" do
         setup do
-          @s.name_contains = 'optical'
+          @s.name_contains 'optical'
         end
 
         should "return one result" do
@@ -217,6 +315,20 @@ class TestSearch < Test::Unit::TestCase
         end
       end
 
+      context "where backwards name is hcetinI as a method call" do
+        setup do
+          @s.backwards_name 'hcetinI'
+        end
+
+        should "return 1 result" do
+          assert_equal 1, @s.all.size
+        end
+
+        should "return a company named Initech" do
+          assert_contains @s.all, Company.where(:name => 'Initech').first
+        end
+      end
+
       context "where backwards name is hcetinI" do
         setup do
           @s.backwards_name = 'hcetinI'

data/test/test_view_helpers.rb

@@ -63,6 +63,10 @@ class TestViewHelpers < ActionView::TestCase
         assert_match /Company reverse name-diddly/, @f1.label(:reverse_name)
         assert_match /Developer name-diddly contains-aroonie/, @f2.label(:name_like)
       end
+
+      should "localize more than one attribute when joined with or" do
+        assert_match /Developer name-diddly or-diddly Developer salary-doodly equals-diddly/, @f2.label(:name_or_salary_eq)
+      end
     end
   end
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 10
-  version: 0.9.10
+  - 11
+  version: 0.9.11
 platform: ruby
 authors: 
 - Ernie Miller
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-18 00:00:00 -05:00
+date: 2011-01-06 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency