binarylogic-searchlogic 2.0.0 → 2.0.1

data/CHANGELOG.rdoc

@@ -0,0 +1,321 @@
+== 2.0.1
+
+* Allow the chaining of conditions off of a search object. Ex: search.username_like("bjohnson").age_gt(20).all
+* Split out left outer join creation into its own method, allowing you to use it in your own named scopes.
+* Make sure the search objects clone properly.
+* named_scope_options should return the proper options for existing named scopes with an arity greater than 0
+
+== 2.0.0
+
+* Everything, completely rewritten.
+
+== 1.6.6
+
+* Fixed time zone issues when searching.
+
+== 1.6.5 released 2009-04-2
+
+* Skip all associations defined with the :finder_sql option, since conditions can not be chained to them, etc.
+* Fixed bug when using non string values for the keywords condition.
+* Fixed undefined methods link_options error.
+* Return blank conditions when trying to scope blank conditions. Fixes the issue with groups that return a blank SQL string.
+* Fixed issue with blank condition comparing boolean values to non boolean columns.
+* Add utf-8 magic comment for ruby 1.9
+
+== 1.6.4 released 2009-01-22
+
+* Fixed calling attribute_condition with newer versions of rails.
+
+== 1.6.3 released 2008-12-13
+
+* Added in avg, count, and sum modifiers for SQLite and Postgres.
+* Added ne for not_equal condition.
+* Ignore :include option for calculations since we don't need it and AR throws an error for polymorphic relationships.
+* Removed sum and count since they can not be in the WHERE statement, but must be in the HAVING statement
+* Added in auto joins for groups so that the joins don't have to be manually specified.
+* Use first column in column_names as the default column for calculations, since a column is required when using DISTINCT and some tables can have more than one primary key.
+* On associations see what the first conditions "any" status is to determine if to join with "ANY" or "AND"
+
+== 1.6.2 released 2008-12-13
+
+* Remove duplicate joins at a lower level for a cleaner and less brittle approach.
+
+== 1.6.1 released 2008-12-8
+
+* Group multi faceted conditions since we allow for the mix of "and" and "or"
+* Blank arrays are not meaningful values for conditions
+* Add in a unique identifier for the auto-generated hidden fields so that multiple forms do no present a problem.
+
+== 1.6.0 released 2008-12-8
+
+* Converted all tree conditions to nested set conditions for performance reasons. A nested set data structure is now required instead of a tree
+* Added DISTINCT to select if you are not provided a select, searching, and have joins.
+* Included :not_like in the list of conditions to be required upon initialization.
+
+== 1.5.10 released 2008-12-8
+
+* Create class level conditions upon instantiation to avoid conflicts.
+
+== 1.5.9 released 2008-12-3
+
+* Added metaclass object extension for older version of ActiveSupport.
+* Added average, count, and sum modifiers.
+
+== 1.5.8 released 2008-12-3
+
+* Removed array support for groups, arrays will set conditions, not create multiple groups. If you need to create multiple groups you will have to pass an array with multiple {:group => my_groups} hashes.
+* Fixed issues with using name spaced models.
+* Added support for multiparameter conditions to support date_select helpers.
+
+== 1.5.7 released 2008-11-30
+
+* Fixed how grouping works, you can now specify "and_group" and "or_group", just like you can with conditions.
+* Specifying a join type will take priority. So "and_name_like" will ALWAYS join with AND, even is any = true for the search.
+
+== 1.5.6 released 2008-11-29
+
+* The order conditions are set is now relevant and will be reflected in the SQL. Setting a condition first will make it first in the SQL, setting a condition last will make it last in the SQL.
+* The above allows for prefixing any condition with and_ or or_. Thus letting you create somewhat more complex queries, since the order matters.
+* Added ability to group conditions to mimic parenthesis in raw SQL.
+* Major clean up in the Searchlogic::Conditions name space: faster, smaller, cleaner, and modular.
+
+== 1.5.5 released 2008-11-17
+
+* Cleaned up class_name configuration for helpers, so that setting them to nil disables the class name
+* Added page_links_div_wrapper and page_links_div_wrapper_class_name configuration option to add an wrapping div around page_links
+* Added page_links_act_like_will_paginate configuration option to help with the transition from will_paginate
+
+== 1.5.4 released 2008-11-16
+
+* Removed subclass requirement for adding conditions in Conditions::Base
+* Removed DISTINCT in the select clause, instead called uniq! on the results. PostgreSQL complains about DISTINCT and AR uses uniq! when using :includes, so this is the best option.
+* Converted the return for SQLite's strftime to integer from string. This way day of month, day of year, etc works as expected.
+
+== 1.5.3 released 2008-10-30
+
+* Removed ilike conditions and let the like condition determine if it should use like or ilike depending on the connection adapter.
+* Fixed bug where the keywords condition was removing foreign characters.
+* Added configuration option for specifying your javascript library, to cut down on the javascript Searchlogic adds into the form helpers
+* Fixed bug with "not" conditions to use sanitize method, like it should, instead of to_conditions.
+* Only pass :distinct option for the count calculation
+* Fixed not_nil and not_blank conditions to use boolean values configuration option.
+
+== 1.5.2 released 2008-10-21
+
+* Added ilike conditions
+* Removed configatron dependency (was accidentally added)
+
+== 1.5.1 released 2008-10-20
+
+* Fixed bug with per_page_links
+* Added "ordering_by" class for per_page_links
+
+== 1.5.0 released 2008-10-20
+
+* Merge array of conditions with or or and where it makes sense. Begins with condition does not make sense to join with and, so instead join with or.
+* Cleaned up html validity so it will pass W3C validators
+* Restructure configuration to be more organized and allow for more configuration options.
+* Added more configuration options, especially for class names.
+
+== 1.4.1 released 2008-10-15
+
+* Extracted english text into configuration to support alternate languages. I18n support.
+* Improved method detection in add_joins to use respond_to? with the private method option set to true
+
+== 1.4.0 released 2008-10-15
+
+* Fixed bug when duping or cloning to copy over instance vars instead of method values
+* Fixed bug with older versions of ActiveRecord and creating an alias method chain on find in AssociationCollection
+* Added modifiers: upper, lower, trim, ltrim, rtrim
+* Added not_nil and not_blank conditions
+* Modified conditions so that table name is a variable, this allows table name to be switched on the fly.
+* Modified auto joins to return symbols instead of SQL. This allows AR to properly merge the joins and ultimately result in proper SQL when performing multiple complex scopes.
+* Fixed conflicts between includes and joins, duplicate joins are not added. Includes are prioritized. This also makes ActiveRecord much more flexible. Now you can cherry pick included associations. And not have to worry about conflicting with joins.
+* Modified ActiveRecord's default behavior to use inner joins with the :joins option. Inner joins impose limitations. When providing this as a "convenience", inner joins do not make sense. The don't allow OR conditions to be across associations, nor does it properly order when an ordering by an association attribute when that association is optional.
+
+== 1.3.5 released 2008-10-08
+
+* Since joins are now strings, AR doesn't know how to merge them properly. So searchlogic now checks which joins to skip over to avoid conflicts.
+
+== 1.3.4 released 2008-10-07
+
+* Fixed method names creation for conditions with modifiers
+* Create local column conditions, incase there are method conflicts. Such as "id".
+* All joins are switched to left outer joins. When search with *any* conditions, inner joins return incorrect results. Also when ordering by an association that allows for blanks, inner joins exclude the records with blank values. Only option is left outer joins.
+* If joins is manually set with a string, treat it as SQL, just like ActiveRecord
+
+== 1.3.3 released 2008-10-03
+
+* Fixed modifiers being double escaped on equals condition
+* Fixed bug when merging conditions with array substitutions
+* Updated blank condition to check if the values is false or not
+* Fixed type for the year modifier in the mysql adapter
+
+== 1.3.2 released 2008-10-03
+
+* Fixed condition to type cast all values in an array
+* Fixed bug to properly set the type for the type cast column
+* Fixed bug to allow conditions on local columns
+* Apparently ActiveRecord 2.2 doesnt remove duplicates on all joins, need to enforce this for ALL versions of ActiveRecord
+* Fixed bug when passing a symbol as the SQL type for condition return types
+* Moved duplicate removal to only apply when searching or calculating from a search object. Anything done in a normal ActiveRecord method should remain untouched and let ActiveRecord handle it. Just like in ActiveRecord if you do a User.all search and pass some :joins, you might get duplicate records. Searchlogic should not change that behavior, unless called from a searchlogic object.
+* Discard meaningless array values when setting a condition.
+* Delete blank strings from mass assignments on conditions.
+
+== 1.3.1 released 2008-10-02
+
+* Fixed bug when requiring a connection adapter that is not present
+* Fixes bug in "not" conditions
+
+== 1.3.0 released 2008-10-02
+
+* Added modifiers into the mix: hour_of_created_at_less_than = 10, etc.
+* Changed how the Searchlogic::Conditions::Base class works. Instead of predefining all methods for all conditions upon instantiation, they are defined as needed via method_missing. Similar to
+  ActiveRecord's dynamic finders: User.find_by_name_and_email(name, email). Once the are defined they never hit method_missing again, acts like a cache.
+* Altered how values are handled for each condition, meaningless values are ignored completely.
+* Added in more "not" conditions: not_like, not_begin_with, not_have_keywords, etc
+
+== 1.2.2 released 2008-09-29
+
+* Fixed bug when reverse engineering order to order_by, assumed ASC and DESC would always be present when they are not.
+* False is a meaningful value for some conditions, and false.blank? == true. So instead of using value.blank? to ignore conditions we use meaningless?(value), which returns false if it is false.
+* Fixed aliases for lt, lte, gt, and gte.
+* Fixed bug when writing conditions on associations via a hash with string keys
+* Added Config.remove_duplicates to turn off the "automatic" removing of duplicates if desired.
+* Updated searchlogic_state helper to insert the entire state all at once.
+* Added CSS class "ordering" to order_by_link if the search is being ordered by that.
+
+== 1.2.1 released 2008-09-25
+
+* Fixed problem when determining if an order_by_link is currently being ordered. Just "stringified" both comparable values.
+* Removed default order_by and order_as. They will ONLY have values if you specify how to order, otherwise they are nil.
+* Removed order_as requirement. order_as is optional.
+* Added in deep_merge methods for hash, copied over from ActiveSupport 2.1
+* Improved order by auto joins to be based off of what order_by returns instead of setting it when setting order_by.
+* Added priority_order_by. Useful if you want to order featured products first and then order as usual. See documentation in Searchlogic::Search::Ordering for more info.
+* Added in base64 support for order_by and priority_order_by so that it's value is safe in the URL
+* Added priority_order_by_link
+
+== 1.2.0 released 2008-09-24
+
+* Added searchlogic_params and searchlogic_url helper to use outside of the control type helpers.
+* Added dup and clone methods that work properly for searchlogic objects
+* Fixed bug to remove nil scope values, HABTM likes to add :limit => nil
+* Removed unnecessary build_search methods for associations
+* Removed support for searching with conditions only. This just made things much more complicated when you can accomplish the same thing by starting a new search and only setting conditions.
+* Fixed bug when searching with *any* conditions to use left outer joins instead of inner joins.
+
+== 1.1.3 released 2008-09-23
+
+* Setting a condition to nil removes it if the condition is set to ignore blanks
+* Setting search.conditions = "some sql" will reset ALL conditions. Alternatively search.conditions => {:first_name_contains => "Ben"} will overwrite "some sql". The same goes with search.conditions.first_name_contains = "Ben".
+* Fixed bug with inspect
+* Other small performance enhancements with memoized attributes
+
+== 1.1.2 released 2008-09-22
+
+* Fixed bug with select control types not using :search_obj to determine its select values.
+* Added is_nil and is_blank condition types.
+* "memoized" various attributes for performance enhancements
+* Removed the :order option from calculation options when :order is useless and just slows down query.
+* Switched from using :include to :joins, big performance increase
+
+== 1.1.1 released 2008-09-19
+
+* Fixed typo in "next page" button.
+* Updated valid options for searching and performing calculations, fixed some bugs when searching and performing calculations with advanced options.
+* Fixed bug in ordering where table name was assumed by the hash. Now assumed by the reflection.
+* Added default for per_page, so pagination comes implemented by default
+* On mass assignments blank strings for *any* conditions are ignored. Sometimes blank strings are meaningful for "equals" and "does not equal", those only takes effect if you explicitly call these conditions: search.conditions.name = "". User.new_search(:conditions => {:name => ""}) will be ignored. Also, Searchlogic should never change how ActiveRecord behaves by default. So User.all(:conditions => {:name => ""}) will NOT be ignored.
+
+== 1.1.0 released 2008-09-18
+
+* Added the options :inner_spread and :outer_spread to the page_links helper. Also added various config options for setting page_links defaults.
+* Updated calculation methods to ignore :limit and :offset. AR returns 0 or nil on calculations that provide an offset.
+* Added support to allow for "any" of the conditions, instead of all of them. Joins conditions with "or" instead of "and". See Searchlogic::Conditions::Base or the readme
+
+== 1.0.4 released 2008-09-18
+
+* Fixed bugs when performing calculations and searches on has_many through relationships.
+* Instead of merging the find_options myself, I delegated that to AR's with_scope function, which already does this. Much more solid, less intrusive.
+
+== 1.0.3 released 2008-09-18
+
+* Updated inspect to show the current options for your search. Plays nicer in the console.
+* Made sure protection state is persistent among relationship conditions.
+* Fixed bug with backwards compatibility of rails. concat requires a proc in older version.
+* Defaulted remote control types to use GET requests instead of POST.
+* Completely reengineered integration with ActiveRecord. Searchlogic is properly using scopes letting you do use serachgasm where scope are implemented. @current_users.orders.new_search, etc. If your search is scoped and you want a search object, that search object will represent a new search in the context of those scopes, meaning the scopes get merged into Searchlogic as options.
+* Dropped support for Searchlogic functionality when defining relationships: has_many :order, :conditions => {:total_gt => 100}, will not work anymore. It's a chicken and the egg thing. Searchlogic needs AR constants, some models get loaded before others, therefore the Order model may not have been loaded yet, causing an unknown constant error.
+* Clean up redundant code and moved it into the Searchlogic::Shared namespace.
+
+== 1.0.2 released 2008-09-12
+
+* Moved cached searchers out of the global namespace and into the Searchlogic::Cache namespce.
+* Various changes to improve performance through profiling / benchmarking. http://pastie.org/271936
+* Config.per_page works with new_search & new_search! only. Where as before it was only working if the search was protected.
+
+== 1.0.1 released 2008-09-11
+
+* Cached "searchers" so when a new search object is instantiated it doesn't go through all of the meta programming and method creation. Helps a lot with performance. You will see the speed benefits after the first instantiation.
+* Added in new options for page_links.
+* Fixed minor bugs when doing page_links.
+* Updated documentation to be more detailed and inclusive.
+
+== 1.0.0 released 2008-09-08
+
+* Major changes in the helpers, they were completely re-engineered. Hence the new version. I established a pattern between all helpers giving you complete flexibility as to how they are used. All helpers are called differently now (see documentation).
+
+== 0.9.10 released 2008-09-08
+
+* Fixed bug with setting the per_page configuration to only take effect on protected searches, thus staying out of the way of normal searching.
+* Hardened more tests
+
+== 0.9.9 released 2008-09-07
+
+* Fixed setting per_page to nil, false, or ''. This is done to "show all" results.
+
+== 0.9.8 released 2008-09-06
+
+* Fixed order_by helper bug when guessing the text with arrays. Should use the first value instead of last.
+* Added in per_page config option.
+
+== 0.9.7 released 2008-09-06
+
+* Complete class restructure. Moved the 3 main components into their own base level class: Search, Conditions, Condition
+* Split logic and functionality into their own modules, implemented via alias_chain_method
+* Added in helpers for using in a rails app
+* Added link to documentation and live example in README
+* Various small bug fixes
+* Hardened tests
+
+== 0.9.6 released 2008-09-04
+
+* Fixed bug when instantiating with nil options
+
+== 0.9.5 released 2008-09-03
+
+* Enhanced searching with conditions only, added in search methods and calculations
+* Updated README to include examples
+
+== 0.9.4 released 2008-09-03
+
+* Cleaned up search methods
+* Removed reset! method for both searching and searching by conditions
+
+== 0.9.3 released 2008-09-02
+
+* Changed structure of conditions to have their own class
+* Added API for adding your own conditions.
+
+== 0.9.2 released 2008-09-02
+
+* Enhanced protection from SQL injections (made more efficient)
+
+== 0.9.1 released 2008-09-02
+
+* Added aliases for datetime, date, time, and timestamp attrs. You could call created_at_after, now you can also call created_after. Just removed the "at" requirement.
+
+== 0.9.0 released 2008-09-01
+
+* First release

data/README.rdoc

@@ -1,10 +1,10 @@
 = Searchlogic
 
-<b>Searchlogic has been <em>completely</em> rewritten for v2. It is much simpler and has taken an entirely new approach. To give you an idea, v1 had ~2300 lines of code, v2 has ~350 lines of code.</b>
+<b>Searchlogic has been <em>completely</em> rewritten for v2. It is much simpler and has taken an entirely new approach. To give you an idea, v1 had ~2300 lines of code, v2 has ~420 lines of code.</b>
 
-<b>Attention v1 users. v2 breaks backwards compatibility. Please make sure your gem declaration for searchlogic looks like this so that you app does not break when the gem is updated: config.gem "searchlogic", :version => "~> 1.6.6"</b>
+<b>Attention v1 users. To start using v2 you must use the binarylogic-searchlogic gem. I have decided to start using github to host my gems. See below for installation instructions.</b>
 
-Searchlogic provides common named scopes and object based searching.
+Searchlogic provides common named scopes and object based searching for ActiveRecord.
 
 == Helpful links
 
@@ -25,7 +25,7 @@ In your rails project:
   config.gem "binarylogic-searchlogic", 
     :lib     => 'searchlogic', 
     :source  => 'http://gems.github.com', 
-    :version => '0.6.6'
+    :version => '~> 2.0.0'
 
 Then install the gem:
 
@@ -68,7 +68,7 @@ Any named scope Searchlogic creates is dynamic and created via method_missing. M
 
 That's all pretty standard, but here's where Searchlogic starts to get interesting...
 
-== Search using conditions on association columns
+== Search using conditions on associated columns
 
 You also get named scopes for any of your associations:
 
@@ -101,15 +101,27 @@ If you want to use the :include option, just specify it:
 
 Obviously, only do this if you want to actually use the included objects.
 
+Lastly, because we are using ActiveRecord, named scopes, combining conditions, and ordering based on associated columns, the decision was made to use left outer joins instead of inner joins. This allows us to be consistent, include optional associations when ordering, and avoid duplicate joins when eager loading associations. If we use an inner join and combine any of these things we will get an "ambiguous name" sql error for the table being joined twice. Just like anything, be mindful of the SQL being produced in your application. If you are joining beyond 4 or 5 levels deep then you might consider looking at the query and optimizing it. Part of that optimization may require the use of inner joins depending on the query.
+
 == 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? Just do this...
+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...
 
-  User.search(:username_like => "bjohnson", :age_less_than => 20)
+  search = User.search(:username_like => "bjohnson", :age_less_than => 20)
+  search.all
 
 The above is equivalent to:
 
-  User.username_like("bjohnson").age_less_than(20)
+  User.username_like("bjohnson").age_less_than(20).all
+
+You can set, read, and chain conditions off of your search too:
+
+  search.username_like                              => "bjohnson"
+  search.age_gt = 2                                 => 2
+  search.id_gt(10).email_begins_with("bjohnson")    => <#Searchlogic::Search...>
+  search.all                                        => An array of users
+  search.count                                      => integer
+  # .. etc
 
 All that the search method does is chain named scopes together for you. What's so great about that? It keeps your controllers extremely simple:
 
@@ -159,9 +171,9 @@ What's great about this is that you can do just about anything you want. If Sear
 
 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 those strings in their username
-  User.username_like_all("bjohnson", "thunt")   # will return any users that have all of those string in their username
-  User.username_like_any(["bjohnson", "thunt"]) # also accept an array
+  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.
 
@@ -180,7 +192,7 @@ Before I use a library in my application I like to glance at the source and try
 
 Searchlogic utilizes method_missing to create all of these named scopes. When it hits method_missing it creates a named scope to ensure it will never hit method missing for that named scope again. Sort of a caching mechanism. It works in the same fashion as ActiveRecord's "find_by_*" methods. This way only the named scopes you need are created and nothing more.
 
-That's about it, the named scope options are pretty bare bones and created just like you would manually.
+That's about it, the named scope options are pretty bare bones and created just like you would manually. The only big difference being the use of LEFT OUTER JOINS on associated conditions instead of INNER JOINS.
 
 == Credit
 

data/Rakefile

@@ -5,9 +5,9 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "searchlogic"
-    gem.summary = "Searchlogic provides common named scopes and object based searching."
+    gem.summary = "Searchlogic provides common named scopes and object based searching for ActiveRecord."
     gem.email = "bjohnson@binarylogic.com"
-    gem.homepage = "http://github.com/binarylogic/search"
+    gem.homepage = "http://github.com/binarylogic/searchlogic"
     gem.authors = ["Ben Johnson of Binary Logic"]
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION.yml

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

data/lib/searchlogic/named_scopes/associations.rb

@@ -29,6 +29,24 @@ module Searchlogic
         !association_alias_condition_details(name).nil?
       end
       
+      # Leverages ActiveRecord's JoinDependency class to create a left outer join. Searchlogic uses left outer joins so that
+      # records with no associations are included in the result when the association is optional. You can use this method
+      # internally when creating your own named scopes that need joins. You need to do this because then ActiveRecord will
+      # remove any duplicate joins for you when you chain named scopes that require the same join. If you are using a
+      # LEFT OUTER JOIN and an INNER JOIN, ActiveRecord will add both to the query, causing SQL errors.
+      #
+      # Bottom line, this is convenience method that you can use when creating your own named scopes. Ex:
+      #
+      #   named_scope :orders_line_items_price_expensive, :joins => left_out_joins(:orders => :line_items), :conditions => "line_items.price > 100"
+      #
+      # Now your joins are consistent with Searchlogic allowing you to avoid SQL errors with duplicate joins.
+      def left_outer_joins(association_name)
+        ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, association_name, nil).join_associations.collect do |assoc|
+          sql = assoc.association_join.strip
+          sql.split(/LEFT OUTER JOIN/).delete_if { |join| join.strip.blank? }.collect { |join| "LEFT OUTER JOIN #{join.strip}"}
+        end.flatten
+      end
+      
       private
         def method_missing(name, *args, &block)
           if details = association_condition_details(name)
@@ -135,9 +153,9 @@ module Searchlogic
         #
         # The code below was extracted out of AR's add_joins! method and then modified.
         def add_left_outer_joins(options, association)
-          join = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, association.name, nil).join_associations.collect { |assoc| assoc.association_join }.join.strip
+          joins = left_outer_joins(association.name)
           options[:joins] ||= []
-          options[:joins].unshift(join)
+          options[:joins] = joins + options[:joins]
         end
     end
   end

data/lib/searchlogic/named_scopes/conditions.rb

@@ -46,7 +46,7 @@ module Searchlogic
       # ActiveRecord hides this internally, so we have to try and pull it out with this
       # method.
       def named_scope_options(name)
-        key = primary_condition_name(name)
+        key = scopes.key?(name.to_sym) ? name.to_sym : primary_condition_name(name)
         
         if key
           eval("options", scopes[key])

data/lib/searchlogic/search.rb

@@ -46,6 +46,10 @@ module Searchlogic
       self.conditions = conditions if conditions.is_a?(Hash)
     end
     
+    def clone
+      self.class.new(klass, current_scope.clone, conditions.clone)
+    end
+    
     # Returns a hash of the current conditions set.
     def conditions
       @conditions ||= {}
@@ -71,7 +75,12 @@ module Searchlogic
             raise UnknownConditionError.new(name)
           end
         elsif scope?(normalize_scope_name(name))
-          conditions[name]
+          if args.size > 0
+            send("#{name}=", *args)
+            self
+          else
+            conditions[name]
+          end
         else
           scope = conditions.inject(klass.scoped(current_scope)) do |scope, condition|
             scope_name, value = condition

data/searchlogic.gemspec

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{searchlogic}
+  s.version = "2.0.1"
+
+  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-06-20}
+  s.email = %q{bjohnson@binarylogic.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG.rdoc",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "init.rb",
+     "lib/searchlogic.rb",
+     "lib/searchlogic/core_ext/object.rb",
+     "lib/searchlogic/core_ext/proc.rb",
+     "lib/searchlogic/named_scopes/associations.rb",
+     "lib/searchlogic/named_scopes/conditions.rb",
+     "lib/searchlogic/named_scopes/ordering.rb",
+     "lib/searchlogic/rails_helpers.rb",
+     "lib/searchlogic/search.rb",
+     "rails/init.rb",
+     "searchlogic.gemspec",
+     "spec/core_ext/object_spec.rb",
+     "spec/core_ext/proc_spec.rb",
+     "spec/named_scopes/associations_spec.rb",
+     "spec/named_scopes/conditions_spec.rb",
+     "spec/named_scopes/ordering_spec.rb",
+     "spec/search_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/binarylogic/searchlogic}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Searchlogic provides common named scopes and object based searching for ActiveRecord.}
+  s.test_files = [
+    "spec/core_ext/object_spec.rb",
+     "spec/core_ext/proc_spec.rb",
+     "spec/named_scopes/associations_spec.rb",
+     "spec/named_scopes/conditions_spec.rb",
+     "spec/named_scopes/ordering_spec.rb",
+     "spec/search_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/named_scopes/associations_spec.rb

@@ -119,6 +119,6 @@ describe "Associations" do
     company = Company.create
     user = company.users.create(:username => "bjohnson")
     order = user.orders.create(:total => 20, :taxes => 3)
-    Company.ascend_by_users_orders_total.users_orders_taxes_lt(50).all(:include => {:users => :orders}).should == Company.all
+    Company.users_orders_taxes_lt(50).ascend_by_users_orders_total.all(:include => {:users => :orders}).should == Company.all
   end
 end

data/spec/search_spec.rb

@@ -29,6 +29,17 @@ describe "Search" do
     end
   end
   
+  it "should clone properly" do
+    company = Company.create
+    user1 = company.users.create(:age => 5)
+    user2 = company.users.create(:age => 25)
+    search1 = company.users.search(:age_gt => 10)
+    search2 = search1.clone
+    search2.age_gt = 1
+    search2.all.should == User.all
+    search1.all.should == [user2]
+  end
+  
   context "conditions" do
     it "should set the conditions and be accessible individually" do
       search = User.search
@@ -68,6 +79,14 @@ describe "Search" do
       search.username_gt.should == "bjohnson"
     end
     
+    it "should allow chainging conditions" do
+      user = User.create(:username => "bjohnson", :age => 20)
+      User.create(:username => "bjohnson", :age => 5)
+      search = User.search
+      search.username_equals("bjohnson").age_gt(10)
+      search.all.should == [user]
+    end
+    
     it "should allow setting association conditions" do
       search = User.search
       search.orders_total_gt = 10
@@ -92,13 +111,20 @@ describe "Search" do
       search.username_gt.should == "bjohnson2"
     end
     
-    it "should allow setting custom conditions individually" do
+    it "should allow setting custom conditions individually with an arity of 0" do
       User.named_scope(:four_year_olds, :conditions => {:age => 4})
       search = User.search
       search.four_year_olds = true
       search.four_year_olds.should == true
     end
     
+    it "should allow setting custom conditions individually with an arity of 1" do
+      User.named_scope(:username_should_be, lambda { |u| {:conditions => {:username => u}} })
+      search = User.search
+      search.username_should_be = "bjohnson"
+      search.username_should_be.should == "bjohnson"
+    end
+    
     it "should not allow setting conditions that are not scopes" do
       search = User.search
       lambda { search.unknown = true }.should raise_error(Searchlogic::Search::UnknownConditionError)

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: binarylogic-searchlogic
 version: !ruby/object:Gem::Version 
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors: 
-- binarylogic
+- Ben Johnson of Binary Logic
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-06-15 00:00:00 -07:00
+date: 2009-06-20 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -24,6 +24,7 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .gitignore
+- CHANGELOG.rdoc
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -38,6 +39,7 @@ files:
 - lib/searchlogic/rails_helpers.rb
 - lib/searchlogic/search.rb
 - rails/init.rb
+- searchlogic.gemspec
 - spec/core_ext/object_spec.rb
 - spec/core_ext/proc_spec.rb
 - spec/named_scopes/associations_spec.rb
@@ -66,11 +68,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: test
+rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 3
-summary: TODO
+summary: Searchlogic provides common named scopes and object based searching for ActiveRecord.
 test_files: 
 - spec/core_ext/object_spec.rb
 - spec/core_ext/proc_spec.rb