binarylogic-searchlogic 2.2.3 → 2.3.0

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+== 2.3.0 released 2009-08-22
+
+* Thanks to laserlemon for support of ranges and arrays in the equals condition.
+* Added feature to combine condition with 'or'.
+
 == 2.2.3 released 2009-07-31
 
 * Fixed bug when an associations named scope joins is a string or an array of strings, the joins we add in automatically should also be a string, not a symbol.

data/README.rdoc

@@ -1,17 +1,17 @@
 = Searchlogic
 
-Searchlogic provides common named scopes and object based searching for ActiveRecord.
+Searchlogic provides tools that make using ActiveRecord named scopes easier and less repetitive. It helps keep your code DRY, clean, and simple.
 
 == Helpful links
 
 * <b>Documentation:</b> http://rdoc.info/projects/binarylogic/searchlogic
 * <b>Repository:</b> http://github.com/binarylogic/searchlogic/tree/master
-* <b>Bugs / feature suggestions:</b> http://binarylogic.lighthouseapp.com/projects/16601-searchlogic
+* <b>Issues:</b> http://github.com/binarylogic/searchlogic/issues
 * <b>Google group:</b> http://groups.google.com/group/searchlogic
 
 <b>Before contacting me directly, please read:</b>
 
-If you find a bug or a problem please post it on lighthouse. If you need help with something, please use google groups. I check both regularly and get emails when anything happens, so that is the best place to get help. This also benefits other people in the future with the same questions / problems. Thank you.
+If you find a bug or a problem please post it in the issues section. If you need help with something, please use google groups. I check both regularly and get emails when anything happens, so that is the best place to get help. This also benefits other people in the future with the same questions / problems. Thank you.
 
 == Install & use
 
@@ -40,35 +40,48 @@ Instead of explaining what Searchlogic can do, let me show you. Let's start at t
   
   # Searchlogic gives you a bunch of named scopes for free:
   User.username_equals("bjohnson")
+  User.username_equals(["bjohnson", "thunt"])
+  User.username_equals("a".."b")
   User.username_does_not_equal("bjohnson")
   User.username_begins_with("bjohnson")
+  User.username_not_begin_with("bjohnson")
   User.username_like("bjohnson")
+  User.username_not_like("bjohnson")
   User.username_ends_with("bjohnson")
+  User.username_not_end_with("bjohnson")
   User.age_greater_than(20)
   User.age_greater_than_or_equal_to(20)
   User.age_less_than(20)
   User.age_less_than_or_equal_to(20)
   User.username_null
+  User.username_not_null
   User.username_blank
-  
-  # You can also order by columns
-  User.ascend_by_username
-  User.descend_by_username
-  User.order("ascend_by_username")
 
 Any named scope Searchlogic creates is dynamic and created via method_missing. Meaning it will only create what you need. Also, keep in mind, these are just named scopes, you can chain them, call methods off of them, etc:
 
-  scope = User.username_like("bjohnson").age_greater_than(20).ascend_by_username
+  scope = User.username_like("bjohnson").age_greater_than(20).id_less_than(55)
   scope.all
   scope.first
   scope.count
   # etc...
 
-That's all pretty standard, but here's where Searchlogic starts to get interesting...
+For a complete list of conditions please see the constants in Searchlogic::NamedScopes::Conditions.
+
+== Use condition aliases
+
+Typing out 'greater_than_or_equal_to' is not fun. Instead Searchlogic provides various aliases for the conditions. For a complete list please see Searchlogic::NamedScopes::Conditions. But they are pretty straightforward:
+
+  User.username_is(10)
+  User.username_eq(10)
+  User.id_lt(10)
+  User.id_lte(10)
+  # etc...
+
+== Search using scopes in associated classes
 
-== Search using conditions on associated columns
+This is my favorite part of Searchlogic. You can dynamically call scopes on associated classes and Searchlogic will take care of creating the necessary joins for you. This is REALY nice for keeping your code DRY. The best way to explain this is to show you:
 
-You also get named scopes for any of your associations:
+Let's take some basic scopes that Searchlogic provides:
 
   # We have the following relationships
   User.has_many :orders
@@ -83,7 +96,17 @@ You also get named scopes for any of your associations:
   User.ascend_by_order_total
   User.descend_by_orders_line_items_price
 
-Again these are just named scopes. You can chain them together, call methods off of them, etc. What's great about these named scopes is that they do NOT use the :include option, making them <em>much</em> faster. Instead they leverage the :joins option, which is great for performance. To prove my point here is a quick benchmark from an application I am working on:
+This is recursive, you can travel through your associations simply by typing it in the name of the method. Again these are just named scopes. You can chain them together, call methods off of them, etc.
+
+Also, these conditions aren't limited to the scopes Searchlogic provides. You can use your own scopes. Like this:
+
+  LineItem.named_scope :expensive, :conditions => "line_items.price > 500"
+  
+  User.orders_line_items_expensive(true)
+
+As I stated above, Searchlogic will take care of creating the necessary joins for you. This is REALLY nice when trying to keep your code DRY, because if you wanted to use a scope like this in your User model you would have to copy over the conditions. Now you have 2 named scopes that are essentially doing the same thing. Why do that when you can dynamically access that scope using this feature?
+
+Another thing to note is that the joins created by Searchlogic do NOT use the :include option, making them <em>much</em> faster. Instead they leverage the :joins option, which is great for performance. To prove my point here is a quick benchmark from an application I am working on:
 
   Benchmark.bm do |x|
     x.report { 10.times { Event.tickets_id_gt(10).all(:include => :tickets) } }
@@ -99,6 +122,45 @@ If you want to use the :include option, just specify it:
 
 Obviously, only do this if you want to actually use the included objects. Including objects into a query can be helpful with performance, especially when solving an N+1 query problem.
 
+== Order your search
+
+Just like the various conditions, Searchlogic gives you some very basic scopes for ordering your data:
+
+  User.ascend_by_id
+  User.descend_by_id
+  User.ascend_by_orders_line_items_price
+  # etc...
+
+== Use any or all
+
+Every condition you've seen in this readme also has 2 related conditions that you can use. Example:
+
+  User.username_like_any("bjohnson", "thunt")   # will return any users that have either of the strings in their username
+  User.username_like_all("bjohnson", "thunt")   # will return any users that have all of the strings in their username
+  User.username_like_any(["bjohnson", "thunt"]) # also accepts an array
+
+This is great for checkbox filters, etc. Where you can pass an array right from your form to this condition.
+
+== Combine scopes with 'OR'
+
+In the same fashion that Searchlogic provides a tool for accessing scopes in associated classes, it also provides a tool for combining scopes with 'OR'. As we all know, when scopes are combined they are joined with 'AND', but sometimes you need to combine scopes with 'OR'. Searchlogic solves this problem:
+
+  User.username_or_first_name_like("ben")
+  => "username LIKE '%ben%' OR first_name like'%ben%'"
+  
+  User.id_or_age_lt_or_username_or_first_name_begins_with(10)
+  => "id < 10 OR age < 10 OR username LIKE 'ben%' OR first_name like'ben%'"
+
+Notice you don't have to specify the explicit condition (like, gt, lt, begins with, etc.). You just need to eventually specify it. If you specify a column it will just use the next condition specified. So instead of:
+
+  User.username_like_or_first_name_like("ben")
+
+You can do:
+
+  User.username_or_first_name_like("ben")
+
+Again, these just map to named scopes. Use Searchlogic's dynamic scopes, use scopes on associations, use your own custom scopes. As long as it maps to a named scope it will join the conditions with 'OR'. There are no limitations.
+
 == Make searching and ordering data in your application trivial
 
 The above is great, but what about tying all of this in with a search form in your application? What would be really nice is if we could use an object that represented a single search. Like this...
@@ -178,16 +240,6 @@ Now just throw it in your form:
 
 This really allows Searchlogic to extend beyond what it provides internally. If Searchlogic doesn't provide a named scope for that crazy edge case that you need, just create your own named scope and use it. The sky is the limit.
 
-== Use any or all
-
-Every condition you've seen in this readme also has 2 related conditions that you can use. Example:
-
-  User.username_like_any("bjohnson", "thunt")   # will return any users that have either of the strings in their username
-  User.username_like_all("bjohnson", "thunt")   # will return any users that have all of the strings in their username
-  User.username_like_any(["bjohnson", "thunt"]) # also accepts an array
-
-This is great for checkbox filters, etc. Where you can pass an array right from your form to this condition.
-
 == Pagination (leverage will_paginate)
 
 Instead of recreating the wheel with pagination, Searchlogic works great with will_paginate. All that Searchlogic is doing is creating named scopes, and will_paginate works great with named scopes:

data/Rakefile

@@ -5,14 +5,15 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "searchlogic"
-    gem.summary = "Searchlogic provides common named scopes and object based searching for ActiveRecord."
-    gem.description = "Searchlogic provides common named scopes and object based searching for ActiveRecord."
+    gem.summary = "Searchlogic provides tools that make using ActiveRecord named scopes easier and less repetitive."
+    gem.description = "Searchlogic provides tools that make using ActiveRecord named scopes easier and less repetitive."
     gem.email = "bjohnson@binarylogic.com"
     gem.homepage = "http://github.com/binarylogic/searchlogic"
     gem.authors = ["Ben Johnson of Binary Logic"]
     gem.rubyforge_project = "searchlogic"
     gem.add_dependency "activerecord", ">= 2.0.0"
   end
+  Jeweler::RubyforgeTasks.new
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
@@ -29,15 +30,6 @@ Spec::Rake::SpecTask.new(:rcov) do |spec|
   spec.rcov = true
 end
 
+task :spec => :check_dependencies
 
 task :default => :spec
-
-begin
-  require 'rake/contrib/sshpublisher'
-  namespace :rubyforge do
-    desc "Release gem to RubyForge"
-    task :release => ["rubyforge:release:gem"]
-  end
-rescue LoadError
-  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
-end

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 3
+:minor: 3
+:patch: 0
 :major: 2
-:minor: 2

data/lib/searchlogic/active_record/consistency.rb

@@ -8,7 +8,7 @@ module Searchlogic
           alias_method_chain :merge_joins, :searchlogic
         end
       end
-    
+      
       # In AR multiple joins are sometimes in a single join query, and other times they
       # are not. The merge_joins method in AR should account for this, but it doesn't.
       # This fixes that problem. This way there is one join per string, which allows

data/lib/searchlogic/active_record/named_scopes.rb

@@ -43,9 +43,18 @@ module Searchlogic
       # you to use when writing your own named scopes. This way you know for sure
       # that duplicate joins will be removed when chaining scopes together that
       # use the same join.
+      #
+      # Also, don't worry about breaking up the joins or retriving multiple joins.
+      # ActiveRecord will remove dupilicate joins and Searchlogic assists ActiveRecord in
+      # breaking up your joins so that they are unique.
       def inner_joins(association_name)
         ::ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, association_name, nil).join_associations.collect { |assoc| assoc.association_join }
       end
+      
+      # See inner_joins, except this creates LEFT OUTER joins.
+      def left_outer_joins(association_name)
+        ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, association_name, nil).join_associations.collect { |assoc| assoc.association_join }
+      end
     end
   end
 end

data/lib/searchlogic/named_scopes/alias_scope.rb

@@ -1,20 +1,11 @@
 module Searchlogic
   module NamedScopes
     # Adds the ability to create alias scopes that allow you to alias a named
-    # scope or create a named scope procedure, while at the same time letting
-    # Searchlogic know that this is a safe method.
+    # scope or create a named scope procedure. See the alias_scope method for a more
+    # detailed explanation.
     module AliasScope
-      # The searchlogic Search class takes a hash and chains the values together as named scopes.
-      # For security reasons the only hash keys that are allowed must be mapped to named scopes.
-      # You can not pass the name of a class method and expect that to be called. In some instances
-      # you might create a class method that essentially aliases a named scope or represents a
-      # named scope procedure. Ex:
-      #
-      #   User.named_scope :teenager, :conditions => ["age >= ? AND age <= ?", 13, 19]
-      #
-      # This is obviously a very basic example, but there is logic that is duplicated here. For
-      # more complicated named scopes this might make more sense, but to make my point you could
-      # do something like this instead
+      # In some instances you might create a class method that essentially aliases a named scope
+      # or represents a named scope procedure. Ex:
       #
       #   class User
       #     def teenager
@@ -22,13 +13,24 @@ module Searchlogic
       #     end
       #   end
       #
-      # As I stated above, you could not use this method with the Searchlogic::Search class because
-      # there is no way to tell that this is actually a named scope. Instead, Searchlogic lets you
-      # do something like this:
+      # This is obviously a very basic example, but notice how we are utilizing already existing named
+      # scopes so that we do not have to repeat ourself. This method makes a lot more sense when you are
+      # dealing with complicated named scope.
+      #
+      # There is a problem though. What if you want to use this in your controller's via the 'search' method:
+      #
+      #   User.search(:teenager => true)
+      #
+      # You would expect that to work, but how does Searchlogic::Search tell the difference between your
+      # 'teenager' method and the 'destroy_all' method. It can't, there is no way to tell unless we actually
+      # call the method, which we obviously can not do.
+      #
+      # The being said, we need a way to tell searchlogic that this is method is safe. Here's how you do that:
       #
       #   User.alias_scope :teenager, lambda { age_gte(13).age_lte(19) }
       #
-      # It fits in better, at the same time Searchlogic will know this is an acceptable named scope.
+      # This feels better, it feels like our other scopes, and it provides a way to tell Searchlogic that this
+      # is a safe method.
       def alias_scope(name, options = nil)
         alias_scopes[name.to_sym] = options
         (class << self; self end).instance_eval do

data/lib/searchlogic/named_scopes/association_conditions.rb

@@ -1,21 +1,11 @@
 module Searchlogic
   module NamedScopes
-    # Handles dynamically creating named scopes for associations.
+    # Handles dynamically creating named scopes for associations. See the README for a detailed explanation.
     module AssociationConditions
       def condition?(name) # :nodoc:
         super || association_condition?(name)
       end
       
-      def primary_condition_name(name) # :nodoc:
-        if result = super
-          result
-        elsif association_condition?(name)
-          name.to_sym
-        else
-          nil
-        end
-      end
-      
       private
         def association_condition?(name)
           !association_condition_details(name).nil?
@@ -31,7 +21,7 @@ module Searchlogic
         end
         
         def association_condition_details(name)
-          assocs = reflect_on_all_associations.reject { |assoc| assoc.options[:polymorphic] }
+          assocs = reflect_on_all_associations.reject { |assoc| assoc.options[:polymorphic] }.sort { |a, b| b.name.to_s.size <=> a.name.to_s.size }
           return nil if assocs.empty?
           
           if name.to_s =~ /^(#{assocs.collect(&:name).join("|")})_(\w+)$/
@@ -64,23 +54,7 @@ module Searchlogic
             prepare_named_scope_options(options, association)
             options
           else
-            # The underlying condition requires parameters, let's match the parameters it requires
-            # and pass those onto the named scope. We can't use proxy_options because that returns the
-            # result after a value has been passed.
-            proc_args = []
-            if arity > 0
-              arity.times { |i| proc_args << "arg#{i}"}
-            else
-              positive_arity = arity * -1
-              positive_arity.times do |i|
-                if i == (positive_arity - 1)
-                  proc_args << "*arg#{i}"
-                else
-                  proc_args << "arg#{i}"
-                end
-              end
-            end
-            
+            proc_args = arity_args(arity)
             arg_type = (scope_options.respond_to?(:searchlogic_arg_type) && scope_options.searchlogic_arg_type) || :string
             
             eval <<-"end_eval"
@@ -94,8 +68,27 @@ module Searchlogic
           end
         end
         
+        # Used to match the new scopes parameters to the underlying scope. This way we can disguise the
+        # new scope as best as possible instead of taking the easy way out and using *args.
+        def arity_args(arity)
+          args = []
+          if arity > 0
+            arity.times { |i| args << "arg#{i}" }
+          else
+            positive_arity = arity * -1
+            positive_arity.times do |i|
+              if i == (positive_arity - 1)
+                args << "*arg#{i}"
+              else
+                args << "arg#{i}"
+              end
+            end
+          end
+          args
+        end
+        
         def prepare_named_scope_options(options, association)
-          options.delete(:readonly)
+          options.delete(:readonly) # AR likes to set :readonly to true when using the :joins option, we don't want that
           
           if options[:joins].is_a?(String) || array_of_strings?(options[:joins])
             options[:joins] = [inner_joins(association.name), options[:joins]].flatten

data/lib/searchlogic/named_scopes/association_ordering.rb

@@ -1,21 +1,19 @@
 module Searchlogic
   module NamedScopes
-    # Handles dynamically creating named scopes for associations.
+    # Handles dynamically creating order named scopes for associations:
+    #
+    #   User.has_many :orders
+    #   Order.has_many :line_items
+    #   LineItem
+    #
+    #   User.ascend_by_orders_line_items_id
+    #
+    # See the README for a more detailed explanation.
     module AssociationOrdering
       def condition?(name) # :nodoc:
         super || association_ordering_condition?(name)
       end
       
-      def primary_condition_name(name) # :nodoc
-        if result = super
-          result
-        elsif association_ordering_condition?(name)
-          name.to_sym
-        else
-          nil
-        end
-      end
-      
       private
         def association_ordering_condition?(name)
           !association_ordering_condition_details(name).nil?

data/lib/searchlogic/named_scopes/conditions.rb

@@ -1,6 +1,13 @@
 module Searchlogic
   module NamedScopes
-    # Handles dynamically creating named scopes for columns.
+    # Handles dynamically creating named scopes for columns. It allows you to do things like:
+    #
+    #   User.first_name_like("ben")
+    #   User.id_lt(10)
+    #
+    # Notice the constants in this class, they define which conditions Searchlogic provides.
+    #
+    # See the README for a more detailed explanation.
     module Conditions
       COMPARISON_CONDITIONS = {
         :equals => [:is, :eq],
@@ -40,31 +47,6 @@ module Searchlogic
       PRIMARY_CONDITIONS = CONDITIONS.keys
       ALIAS_CONDITIONS = CONDITIONS.values.flatten
       
-      # Returns the primary condition for the given alias. Ex:
-      #
-      #   primary_condition(:gt) => :greater_than
-      def primary_condition(alias_condition)
-        CONDITIONS.find { |k, v| k == alias_condition.to_sym || v.include?(alias_condition.to_sym) }.first
-      end
-      
-      # Returns the primary name for any condition on a column. You can pass it
-      # a primary condition, alias condition, etc, and it will return the proper
-      # primary condition name. This helps simply logic throughout Searchlogic. Ex:
-      #
-      #   primary_condition_name(:id_gt) => :id_greater_than
-      #   primary_condition_name(:id_greater_than) => :id_greater_than
-      def primary_condition_name(name)
-        if details = condition_details(name)
-          if PRIMARY_CONDITIONS.include?(name.to_sym)
-            name
-          else
-            "#{details[:column]}_#{primary_condition(details[:condition])}".to_sym
-          end
-        else
-          nil
-        end
-      end
-      
       # Is the name of the method a valid condition that can be dynamically created?
       def condition?(name)
         local_condition?(name)
@@ -106,7 +88,7 @@ module Searchlogic
           
           scope_options = case condition.to_s
           when /^equals/
-            scope_options(condition, column_type, "#{table_name}.#{column} = ?")
+            scope_options(condition, column_type, lambda { |a| attribute_condition("#{table_name}.#{column}", a) })
           when /^does_not_equal/
             scope_options(condition, column_type, "#{table_name}.#{column} != ?")
           when /^less_than_or_equal_to/
@@ -148,20 +130,22 @@ module Searchlogic
           when /_(any|all)$/
             searchlogic_lambda(column_type) { |*values|
               return {} if values.empty?
-              values = values.flatten
               
-              values_to_sub = nil
-              if value_modifier.nil?
-                values_to_sub = values
-              else
-                values_to_sub = values.collect { |value| value_with_modifier(value, value_modifier) }
-              end
+              values.collect! { |value| value_with_modifier(value, value_modifier) }
               
               join = $1 == "any" ? " OR " : " AND "
-              {:conditions => [values.collect { |value| sql }.join(join), *values_to_sub]}
+              scope_sql = values.collect { |value| sql.is_a?(Proc) ? sql.call(value) : sql }.join(join)
+              
+              {:conditions => [scope_sql, *expand_range_bind_variables(values)]}
             }
           else
-            searchlogic_lambda(column_type) { |value| {:conditions => [sql, value_with_modifier(value, value_modifier)]} }
+            searchlogic_lambda(column_type) { |*values|
+              values.collect! { |value| value_with_modifier(value, value_modifier) }
+              
+              scope_sql = sql.is_a?(Proc) ? sql.call(*values) : sql
+              
+              {:conditions => [scope_sql, *expand_range_bind_variables(values)]}
+            }
           end
         end
         
@@ -185,6 +169,31 @@ module Searchlogic
           send(primary_name, *args) # go back to method_missing and make sure we create the method
           (class << self; self; end).class_eval { alias_method alias_name, primary_name }
         end
+        
+        # Returns the primary condition for the given alias. Ex:
+        #
+        #   primary_condition(:gt) => :greater_than
+        def primary_condition(alias_condition)
+          CONDITIONS.find { |k, v| k == alias_condition.to_sym || v.include?(alias_condition.to_sym) }.first
+        end
+
+        # Returns the primary name for any condition on a column. You can pass it
+        # a primary condition, alias condition, etc, and it will return the proper
+        # primary condition name. This helps simply logic throughout Searchlogic. Ex:
+        #
+        #   primary_condition_name(:id_gt) => :id_greater_than
+        #   primary_condition_name(:id_greater_than) => :id_greater_than
+        def primary_condition_name(name)
+          if details = condition_details(name)
+            if PRIMARY_CONDITIONS.include?(name.to_sym)
+              name
+            else
+              "#{details[:column]}_#{primary_condition(details[:condition])}".to_sym
+            end
+          else
+            nil
+          end
+        end
     end
   end
 end

data/lib/searchlogic/named_scopes/or_conditions.rb

@@ -0,0 +1,106 @@
+module Searchlogic
+  module NamedScopes
+    # Handles dynamically creating named scopes for 'OR' conditions. Please see the README for a more
+    # detailed explanation.
+    module OrConditions
+      class NoConditionSpecifiedError < StandardError; end
+      class UnknownConditionError < StandardError; end
+      
+      def condition?(name) # :nodoc:
+        super || or_condition?(name)
+      end
+      
+      private
+        def or_condition?(name)
+          !or_conditions(name).nil?
+        end
+        
+        def method_missing(name, *args, &block)
+          if conditions = or_conditions(name)
+            create_or_condition(conditions, args)
+            (class << self; self; end).class_eval { alias_method name, conditions.join("_or_") } if !respond_to?(name)
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        def or_conditions(name)
+          # First determine if we should even work on the name, we want to be as quick as possible
+          # with this.
+          if (parts = split_or_condition(name)).size > 1
+            conditions = interpolate_or_conditions(parts)
+            if conditions.any?
+              conditions
+            else
+              nil
+            end
+          end
+        end
+        
+        def split_or_condition(name)
+          parts = name.to_s.split("_or_")
+          new_parts = []
+          parts.each do |part|
+            if part =~ /^equal_to(_any|_all)?$/
+              new_parts << new_parts.pop + "_or_equal_to"
+            else
+              new_parts << part
+            end
+          end
+          new_parts
+        end
+        
+        # The purpose of this method is to convert the method name parts into actual condition names.
+        #
+        # Example:
+        #
+        #   ["first_name", "last_name_like"]
+        #   => ["first_name_like", "last_name_like"]
+        #
+        #   ["id_gt", "first_name_begins_with", "last_name", "middle_name_like"]
+        #   => ["id_gt", "first_name_begins_with", "last_name_like", "middle_name_like"]
+        #
+        # Basically if a column is specified without a condition the next condition in the list
+        # is what will be used. Once we are able to get a consistent list of conditions we can easily
+        # create a scope for it.
+        def interpolate_or_conditions(parts)
+          conditions = []
+          last_condition = nil
+          
+          parts.reverse.each do |part|
+            if details = condition_details(part)
+              # We are a searchlogic defined scope
+              conditions << "#{details[:column]}_#{details[:condition]}"
+              last_condition = details[:condition]
+            elsif details = association_condition_details(part)
+              # pending, need to find the last condition
+            elsif local_condition?(part)
+              # We are a custom scope
+              conditions << part
+            elsif column_names.include?(part)
+              # we are a column, use the last condition
+              if last_condition.nil?
+                raise NoConditionSpecifiedError.new("The '#{part}' column doesn't know which condition to use, if you use an exact column " +
+                  "name you need to specify a condition sometime after (ex: id_or_created_at_lt), where id would use the 'lt' condition.")
+              end
+              
+              conditions << "#{part}_#{last_condition}"
+            else
+              raise UnknownConditionError.new("The condition '#{part}' is not a valid condition, we could not find any scopes that match this.")
+            end
+          end
+          
+          conditions
+        end
+        
+        def create_or_condition(scopes, args)
+          named_scope scopes.join("_or_"), lambda { |*args|
+            scopes_options = scopes.collect { |scope| send(scope, *args).proxy_options }
+            conditions = scopes_options.reject { |o| o[:conditions].nil? }.collect { |o| sanitize_sql(o[:conditions]) }
+            scopes.inject(scoped({})) { |scope, scope_name| scope.send(scope_name, *args) }.scope(:find).merge(:conditions => "(" + conditions.join(") OR (") + ")")
+          }
+        end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/ordering.rb

@@ -1,21 +1,16 @@
 module Searchlogic
   module NamedScopes
-    # Handles dynamically creating named scopes for orderin by columns.
+    # Handles dynamically creating named scopes for ordering by columns. Example:
+    #
+    #   User.ascend_by_id
+    #   User.descend_by_username
+    #
+    # See the README for a more detailed explanation.
     module Ordering
       def condition?(name) # :nodoc:
         super || ordering_condition?(name)
       end
       
-      def primary_condition_name(name) # :nodoc
-        if result = super
-          result
-        elsif ordering_condition?(name)
-          name.to_sym
-        else
-          nil
-        end
-      end
-      
       private
         def ordering_condition?(name) # :nodoc:
           !ordering_condition_details(name).nil?

data/lib/searchlogic/rails_helpers.rb

@@ -21,7 +21,10 @@ module Searchlogic
     # * <tt>:params_scope</tt> - the name of the params key to scope the order condition by, defaults to :search
     def order(search, options = {}, html_options = {})
       options[:params_scope] ||= :search
-      options[:as] ||= options[:by].to_s.humanize
+      if !options[:as]
+        id = options[:by].to_s.downcase == "id"
+        options[:as] = id ? options[:by].to_s.upcase : options[:by].to_s.humanize
+      end
       options[:ascend_scope] ||= "ascend_by_#{options[:by]}"
       options[:descend_scope] ||= "descend_by_#{options[:by]}"
       ascending = search.order.to_s == options[:ascend_scope]

data/lib/searchlogic/search.rb

@@ -79,20 +79,21 @@ module Searchlogic
     
     private
       def method_missing(name, *args, &block)
-        if name.to_s =~ /(\w+)=$/
-          condition = $1.to_sym
-          scope_name = normalize_scope_name($1)
+        condition_name = condition_name(name)
+        scope_name = scope_name(condition_name)
+        
+        if setter?(name)
           if scope?(scope_name)
-            conditions[condition] = type_cast(args.first, cast_type(scope_name))
+            conditions[condition_name] = type_cast(args.first, cast_type(scope_name))
           else
-            raise UnknownConditionError.new(name)
+            raise UnknownConditionError.new(condition_name)
           end
-        elsif scope?(normalize_scope_name(name))
+        elsif scope?(scope_name)
           if args.size > 0
-            send("#{name}=", *args)
+            send("#{condition_name}=", *args)
             self
           else
-            conditions[name]
+            conditions[condition_name]
           end
         else
           scope = conditions.inject(klass.scoped(current_scope)) do |scope, condition|
@@ -119,6 +120,19 @@ module Searchlogic
         klass.column_names.include?(scope_name.to_s) ? "#{scope_name}_equals".to_sym : scope_name.to_sym
       end
       
+      def setter?(name)
+        !(name.to_s =~ /=$/).nil?
+      end
+      
+      def condition_name(name)
+        condition = name.to_s.match(/(\w+)=?$/)[1]
+        condition ? condition.to_sym : nil
+      end
+      
+      def scope_name(condition_name)
+        condition_name && normalize_scope_name(condition_name)
+      end
+      
       def scope?(scope_name)
         klass.scopes.key?(scope_name) || klass.condition?(scope_name)
       end

data/lib/searchlogic.rb

@@ -7,6 +7,7 @@ require "searchlogic/named_scopes/ordering"
 require "searchlogic/named_scopes/association_conditions"
 require "searchlogic/named_scopes/association_ordering"
 require "searchlogic/named_scopes/alias_scope"
+require "searchlogic/named_scopes/or_conditions"
 require "searchlogic/search"
 
 Proc.send(:include, Searchlogic::CoreExt::Proc)
@@ -14,29 +15,23 @@ Object.send(:include, Searchlogic::CoreExt::Object)
 
 module ActiveRecord # :nodoc: all
   class Base
-    class << self
-      include Searchlogic::ActiveRecord::Consistency
-    end
+    class << self; include Searchlogic::ActiveRecord::Consistency; end
   end
 end
 
 ActiveRecord::Base.extend(Searchlogic::ActiveRecord::NamedScopes)
-
 ActiveRecord::Base.extend(Searchlogic::NamedScopes::Conditions)
 ActiveRecord::Base.extend(Searchlogic::NamedScopes::AssociationConditions)
 ActiveRecord::Base.extend(Searchlogic::NamedScopes::AssociationOrdering)
 ActiveRecord::Base.extend(Searchlogic::NamedScopes::Ordering)
 ActiveRecord::Base.extend(Searchlogic::NamedScopes::AliasScope)
+ActiveRecord::Base.extend(Searchlogic::NamedScopes::OrConditions)
 ActiveRecord::Base.extend(Searchlogic::Search::Implementation)
 
 # Try to use the search method, if it's available. Thinking sphinx and other plugins
 # like to use that method as well.
 if !ActiveRecord::Base.respond_to?(:search)
-  ActiveRecord::Base.class_eval do
-    class << self
-      alias_method :search, :searchlogic
-    end
-  end
+  ActiveRecord::Base.class_eval { class << self; alias_method :search, :searchlogic; end }
 end
 
 if defined?(ActionController)

data/searchlogic.gemspec

@@ -1,13 +1,16 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{searchlogic}
-  s.version = "2.2.3"
+  s.version = "2.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ben Johnson of Binary Logic"]
-  s.date = %q{2009-07-31}
-  s.description = %q{Searchlogic provides common named scopes and object based searching for ActiveRecord.}
+  s.date = %q{2009-08-22}
+  s.description = %q{Searchlogic provides tools that make using ActiveRecord named scopes easier and less repetitive.}
   s.email = %q{bjohnson@binarylogic.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -30,6 +33,7 @@ Gem::Specification.new do |s|
      "lib/searchlogic/named_scopes/association_conditions.rb",
      "lib/searchlogic/named_scopes/association_ordering.rb",
      "lib/searchlogic/named_scopes/conditions.rb",
+     "lib/searchlogic/named_scopes/or_conditions.rb",
      "lib/searchlogic/named_scopes/ordering.rb",
      "lib/searchlogic/rails_helpers.rb",
      "lib/searchlogic/search.rb",
@@ -41,6 +45,7 @@ Gem::Specification.new do |s|
      "spec/named_scopes/association_conditions_spec.rb",
      "spec/named_scopes/association_ordering_spec.rb",
      "spec/named_scopes/conditions_spec.rb",
+     "spec/named_scopes/or_conditions_spec.rb",
      "spec/named_scopes/ordering_spec.rb",
      "spec/search_spec.rb",
      "spec/spec_helper.rb"
@@ -50,7 +55,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{searchlogic}
   s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Searchlogic provides common named scopes and object based searching for ActiveRecord.}
+  s.summary = %q{Searchlogic provides tools that make using ActiveRecord named scopes easier and less repetitive.}
   s.test_files = [
     "spec/core_ext/object_spec.rb",
      "spec/core_ext/proc_spec.rb",
@@ -58,6 +63,7 @@ Gem::Specification.new do |s|
      "spec/named_scopes/association_conditions_spec.rb",
      "spec/named_scopes/association_ordering_spec.rb",
      "spec/named_scopes/conditions_spec.rb",
+     "spec/named_scopes/or_conditions_spec.rb",
      "spec/named_scopes/ordering_spec.rb",
      "spec/search_spec.rb",
      "spec/spec_helper.rb"

data/spec/named_scopes/association_conditions_spec.rb

@@ -15,6 +15,7 @@ describe "Association Conditions" do
   end
   
   it "should allow the use of deep foreign pre-existing named scopes" do
+    pending
     Order.named_scope :big_id, :conditions => "orders.id > 100"
     Company.users_orders_big_id.proxy_options.should == Order.big_id.proxy_options.merge(:joins => {:users => :orders})
   end

data/spec/named_scopes/conditions_spec.rb

@@ -15,6 +15,9 @@ describe "Conditions" do
     it "should have equals" do
       (5..7).each { |age| User.create(:age => age) }
       User.age_equals(6).all.should == User.find_all_by_age(6)
+      User.age_equals(nil).all.should == User.find_all_by_age(nil)
+      User.age_equals(5..6).all.should == User.find_all_by_age(5..6)
+      User.age_equals([5, 7]).all.should == User.find_all_by_age([5, 7])
     end
     
     it "should have does not equal" do

data/spec/named_scopes/or_conditions_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe "Or conditions" do
+  it "should match username or name" do
+    User.username_or_name_like("ben").proxy_options.should == {:conditions => "(users.name LIKE '%ben%') OR (users.username LIKE '%ben%')"}
+  end
+  
+  it "should use the specified condition" do
+    User.username_begins_with_or_name_like("ben").proxy_options.should == {:conditions => "(users.name LIKE '%ben%') OR (users.username LIKE 'ben%')"}
+  end
+  
+  it "should use the last specified condition" do
+    User.username_or_name_like_or_id_or_age_lt(10).proxy_options.should == {:conditions => "(users.age < 10) OR (users.id < 10) OR (users.name LIKE '%10%') OR (users.username LIKE '%10%')"}
+  end
+  
+  it "should raise an error on unknown conditions" do
+    lambda { User.usernme_begins_with_or_name_like("ben") }.should raise_error(Searchlogic::NamedScopes::OrConditions::UnknownConditionError)
+  end
+  
+  it "should play nice with other scopes" do
+    User.username_begins_with("ben").id_gt(10).age_not_nil.username_or_name_ends_with("ben").scope(:find).should ==
+      {:conditions => "((users.name LIKE '%ben') OR (users.username LIKE '%ben')) AND ((users.age IS NOT NULL) AND ((users.id > 10) AND (users.username LIKE 'ben%')))"}
+  end
+end

data/spec/spec_helper.rb

@@ -71,6 +71,7 @@ Spec::Runner.configure do |config|
     class User < ActiveRecord::Base
       belongs_to :company, :counter_cache => true
       has_many :orders, :dependent => :destroy
+      has_many :orders_big, :class_name => 'Order', :conditions => 'total > 100'
     end
     
     class Order < ActiveRecord::Base

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: binarylogic-searchlogic
 version: !ruby/object:Gem::Version 
-  version: 2.2.3
+  version: 2.3.0
 platform: ruby
 authors: 
 - Ben Johnson of Binary Logic
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-31 00:00:00 -07:00
+date: 2009-08-22 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.0.0
     version: 
-description: Searchlogic provides common named scopes and object based searching for ActiveRecord.
+description: Searchlogic provides tools that make using ActiveRecord named scopes easier and less repetitive.
 email: bjohnson@binarylogic.com
 executables: []
 
@@ -48,6 +48,7 @@ files:
 - lib/searchlogic/named_scopes/association_conditions.rb
 - lib/searchlogic/named_scopes/association_ordering.rb
 - lib/searchlogic/named_scopes/conditions.rb
+- lib/searchlogic/named_scopes/or_conditions.rb
 - lib/searchlogic/named_scopes/ordering.rb
 - lib/searchlogic/rails_helpers.rb
 - lib/searchlogic/search.rb
@@ -59,6 +60,7 @@ files:
 - spec/named_scopes/association_conditions_spec.rb
 - spec/named_scopes/association_ordering_spec.rb
 - spec/named_scopes/conditions_spec.rb
+- spec/named_scopes/or_conditions_spec.rb
 - spec/named_scopes/ordering_spec.rb
 - spec/search_spec.rb
 - spec/spec_helper.rb
@@ -88,7 +90,7 @@ rubyforge_project: searchlogic
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Searchlogic provides common named scopes and object based searching for ActiveRecord.
+summary: Searchlogic provides tools that make using ActiveRecord named scopes easier and less repetitive.
 test_files: 
 - spec/core_ext/object_spec.rb
 - spec/core_ext/proc_spec.rb
@@ -96,6 +98,7 @@ test_files:
 - spec/named_scopes/association_conditions_spec.rb
 - spec/named_scopes/association_ordering_spec.rb
 - spec/named_scopes/conditions_spec.rb
+- spec/named_scopes/or_conditions_spec.rb
 - spec/named_scopes/ordering_spec.rb
 - spec/search_spec.rb
 - spec/spec_helper.rb