lib/searchlogic/conditions/any_or_all.rb lib/searchlogic/conditions/groups.rb lib/searchlogic/conditions/magic_methods.rb test/condition_tests/keywords_test.rb test/conditions_tests/any_or_all_test.rb test/conditions_tests/groups_test.rb test/conditions_tests/magic_methods_test.rb @@ -1,3 +1,10 @@ +== 1.5.6 released 2008-11-17 + +* 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 CHANGELOG.rdoc @@ -1,6 +1,6 @@ = Searchlogic -Searchlogic is object based ActiveRecord searching, ordering, and pagination all in one. +Searchlogic is object based ActiveRecord searching, ordering, and pagination all in one. It's a simple, quick, all inclusive package for displaying data in your application. == Helpful links @@ -178,17 +178,84 @@ Any of the options used in the above example can be used in these, but for the s search.per_page = 20 search.all + search = User.new_search(:conditions => {:age_gt => 18}) do |s| + s.conditions.first_name_contains = "Ben" + s.per_page = 20 + end + search.all + == Match ANY or ALL of the conditions As you saw above, the nice thing about Searchlogic is it's integration with forms. I designed the "any" option so that forms can set this as well, just like a condition. - @search = User.new_search(:conditions => {:age_gt => 18}) do |search| - search.conditions.first_name_contains = "Ben" - search.conditions.any = true # can set this to "true" or "1" or "yes" - search.all # will join all conditions with "or" instead of "and" - end + @search = User.new_search(:conditions => {:age_gt => 18}) + @search.conditions.first_name_contains = "Ben" + @search.conditions.any = true # can set this to "true" or "1" or "yes" + @search.all # will join all conditions with "or" instead of "and" # ... all operations above are available +What if you want to mix and match? + + @search = User.new_search(:conditions => {:age_gt => 18}) + @search.conditions.or_first_name_contains = "Ben" + @search.conditions.or_last_name_contains = "Johnson" + @search.conditions.and_id_gt = 5 # the and_ is optional, calling just id_gt is the same thing + @search.all # will join conditions in the orders they were set with their specified join condition + # => age > 17 OR first_name like '%Ben%' OR lsat_name like '%Johnson%' AND id > 5 + +The order the conditions is set is relevant, as the SQL will be built in the same order. + +== Grouping conditions + +In more complex searching situations you might want to group conditions. Just like you use parenthesis in raw SQL. Searchlogic's "group" function is basically a way to implement parenthesis in your conditions. It's simple: + +Group off an object: + + search = User.new_search + search.id_gt = 2 + group1 = search.conditions.group + group.first_name_like = "Ben" + group2 = search.conditions.group + group.last_name_like = "Johnson" + group21 = group2.group + group21.email_ends_with = "binarylogic.com" + # => id > 2 AND (first_name like '%Ben%') AND (last_name like '%Johnson%' AND (email like '%binarylogic.com')) + +Group with a block: + + search = User.new_search + search.id_gt = 2 + search.conditions.group do |group| + group.first_name_like = "Ben" + end + search.conditions.group do |group| + group.last_name_like = "Johnson" + group.group do |sub_group| + sub_group.email_ends_with = "binarylogic.com" + end + end + # => id > 2 AND (first_name like '%Ben%') AND (last_name like '%Johnson%' AND (email like '%binarylogic.com')) + +Group with a hash: + + search = User.new_search(:conditions => { + :id_gt => 2, + :group => [ + {:first_name_like => "Ben"}, + { + :last_name_like => "Johnson", + :group => {:email_ends_with => "binarylogic.com"} + } + ] + }) + # => id > 2 AND (first_name like '%Ben%') AND (last_name like '%Johnson%' AND (email like '%binarylogic.com')) + +I want to end this by saying Searchlog was never meant to replace SQL, name_scopes, etc. If you need to perform complex searching there is nothing wrong with resorting to a named scope or using the traditional search methods. In fact, search logic plays nice with named_scopes anyways, so you can combine the 2 if needed: + + @search = User.my_awesome_scope.another_cool_scope.new_search + +The only reason I added this was to allow searchlogic to extend a little further into those advanced searches. If you need to scope conditions by using parenthesis, etc. you should resort to named_scopes or the traditional search method. + == Scoped searching @current_user.orders.find(:all, :conditions => {:total_lte => 500}) README.rdoc @@ -1,14 +1,19 @@ require 'rubygems' -require 'echoe' - require File.dirname(__FILE__) << "/lib/searchlogic/version" -Echoe.new 'searchlogic' do |p| - p.version = Searchlogic::Version::STRING - p.author = "Ben Johnson of Binary Logic" - p.email = 'bjohnson@binarylogic.com' - p.project = 'searchlogic' - p.summary = "Object based ActiveRecord searching, ordering, pagination, and more!" - p.url = "http://github.com/binarylogic/searchlogic" - p.dependencies = %w(activerecord activesupport) +begin + require 'echoe' + + Echoe.new 'searchlogic' do |p| + p.version = Searchlogic::Version::STRING + p.author = "Ben Johnson of Binary Logic" + p.email = 'bjohnson@binarylogic.com' + p.project = 'searchlogic' + p.summary = "Object based ActiveRecord searching, ordering, pagination, and more!" + p.url = "http://github.com/binarylogic/searchlogic" + p.dependencies = %w(activerecord activesupport) + end +rescue LoadError => boom + puts "You are missing a dependency required for meta-operations on this gem." + puts "#{boom.to_s.capitalize}." end \ No newline at end of file Rakefile @@ -38,6 +38,9 @@ require "searchlogic/search/base" require "searchlogic/search/protection" # Conditions +require "searchlogic/conditions/any_or_all" +require "searchlogic/conditions/groups" +require "searchlogic/conditions/magic_methods" require "searchlogic/conditions/protection" require "searchlogic/conditions/base" @@ -76,6 +79,9 @@ module Searchlogic module Conditions class Base + include AnyOrAll + include Groups + include MagicMethods include Protection end lib/searchlogic.rb @@ -7,7 +7,7 @@ module Searchlogic class Base include Shared::Utilities - attr_accessor :column, :column_for_type_cast, :column_sql, :column_sql_format, :klass, :table_name + attr_accessor :any, :column, :column_for_type_cast, :column_sql, :column_sql_format, :klass, :object_name, :table_name class_inheritable_accessor :handle_array_value, :ignore_meaningless_value, :join_arrays_with_or, :value_type self.ignore_meaningless_value = true @@ -61,6 +61,10 @@ module Searchlogic end end + def any? # :nodoc: + any == true + end + # Substitutes string vars with table and column name. Allows us to switch the column and table on the fly and have the condition update appropriately. # The table name could be variable depending on the condition. Take STI and more than one child model is used in the condition, the first gets the parent table name, the rest get aliases. def column_sql lib/searchlogic/condition/base.rb @@ -8,33 +8,9 @@ module Searchlogic include Shared::Utilities include Shared::VirtualClasses - attr_accessor :any, :relationship_name + attr_accessor :object_name class << self - attr_accessor :added_klass_conditions, :added_column_equals_conditions, :added_associations - - def column_details # :nodoc: - return @column_details if @column_details - - @column_details = [] - - klass.columns.each do |column| - column_detail = {:column => column} - column_detail[:aliases] = case column.type - when :datetime, :time, :timestamp - [column.name.gsub(/_at$/, "")] - when :date - [column.name.gsub(/_at$/, "")] - else - [] - end - - @column_details << column_detail - end - - @column_details - end - # Registers a condition as an available condition for a column or a class. MySQL supports a "sounds like" function. I want to use it, so let's add it. # # === Example @@ -44,7 +20,7 @@ module Searchlogic # class SoundsLike < Searchlogic::Condition::Base # # The name of the conditions. By default its the name of the class, if you want alternate or alias conditions just add them on. # # If you don't want to add aliases you don't even need to define this method - # def self.condition_names_for_column(column) + # def self.condition_names_for_column # super + ["similar_to", "sounds"] # end # @@ -119,16 +95,6 @@ module Searchlogic @@modifiers ||= [] end - # A list of all associations created, used for caching and performance - def association_names - @association_names ||= [] - end - - # A list of all conditions available, users for caching and performance - def condition_names - @condition_names ||= [] - end - def needed?(model_class, conditions) # :nodoc: return false if conditions.blank? @@ -147,82 +113,49 @@ module Searchlogic end end + # Initializes a conditions object, accepts a hash of conditions as the single parameter def initialize(init_conditions = {}) - add_associations! - add_column_equals_conditions! self.conditions = init_conditions end - # Determines if we should join the conditions with "AND" or "OR". - # - # === Examples - # - # search.conditions.any = true # will join all conditions with "or", you can also set this to "true", "1", or "yes" - # search.conditions.any = false # will join all conditions with "and" - def any=(value) - associations.each { |name, association| association.any = value } - @any = value - end - - def any # :nodoc: - any? - end - - # Convenience method for determining if we should join the conditions with "AND" or "OR". - def any? - ["true", "1", "yes"].include? @any.to_s - end - - # Sets the conditions to be searched by "or" - def any! - any = true - end - - def all # :nodoc: - not any? - end - - # Sets the conditions to be searched by "and" - def all! - any = false - end - # A list of joins to use when searching, includes relationships def auto_joins j = [] - associations.each do |name, association| + association_objects.each do |association| next if association.conditions.blank? association_joins = association.auto_joins - j << (association_joins.blank? ? name : {name => association_joins}) + j << (association_joins.blank? ? association.object_name : {association.object_name => association_joins}) end j.blank? ? nil : (j.size == 1 ? j.first : j) end + # Provides a much more informative and easier to understand inspection of the object def inspect "#<#{klass}Conditions#{conditions.blank? ? "" : " #{conditions.inspect}"}>" end # Sanitizes the conditions down into conditions that ActiveRecord::Base.find can understand. def sanitize - return @conditions if @conditions - merge_conditions(*(objects.collect { |name, object| object.sanitize } << {:any => any})) + return @conditions if @conditions # return the conditions if the user set them with a string, aka sql conditions + joined_conditions = nil + objects.each { |object| joined_conditions = merge_conditions(joined_conditions, object.class == self.class ? scope_condition(object.sanitize) : object.sanitize, :any => object.any?, :scope => false) } + joined_conditions end # Allows you to set the conditions via a hash. def conditions=(value) case value when Hash - assert_valid_conditions(value) remove_conditions_from_protected_assignement(value).each do |condition, condition_value| + next if [:conditions].include?(condition.to_sym) # protect sensitive methods # delete all blanks from mass assignments, forms submit blanks, blanks are meaningless # equals condition thinks everything is meaningful, and arrays can be pased new_condition_value = nil case condition_value when Array - new_condition_value = [] - condition_value.each { |v| new_condition_value << v unless v == "" } - next if new_condition_value.size == 0 + new_condition_value = condition_value.reject { |v| v == "" } + next if new_condition_value.empty? new_condition_value = new_condition_value.first if new_condition_value.size == 1 else next if condition_value == "" @@ -232,7 +165,7 @@ module Searchlogic send("#{condition}=", new_condition_value) end else - reset_objects! + reset! @conditions = value end end @@ -240,249 +173,40 @@ module Searchlogic # All of the active conditions (conditions that have been set) def conditions return @conditions if @conditions - return if objects.blank? conditions_hash = {} - objects.each do |name, object| - if object.class < Searchlogic::Conditions::Base - relationship_conditions = object.conditions - next if relationship_conditions.blank? - conditions_hash[name] = relationship_conditions - else - next if object.value_is_meaningless? - conditions_hash[name] = object.value - end - end - conditions_hash - end - - private - def add_associations! - return true if self.class.added_associations - - klass.reflect_on_all_associations.each do |association| - self.class.association_names << association.name.to_s - - self.class.class_eval <<-"end_eval", __FILE__, __LINE__ - def #{association.name} - if objects[:#{association.name}].nil? - objects[:#{association.name}] = Searchlogic::Conditions::Base.create_virtual_class(#{association.class_name}).new - objects[:#{association.name}].relationship_name = "#{association.name}" - objects[:#{association.name}].protect = protect - end - objects[:#{association.name}] - end - - def #{association.name}=(conditions); @conditions = nil; #{association.name}.conditions = conditions; end - def reset_#{association.name}!; objects.delete(:#{association.name}); end - end_eval - end - - self.class.added_associations = true - end - def add_column_equals_conditions! - return true if self.class.added_column_equals_conditions - klass.column_names.each { |name| setup_condition(name) } - self.class.added_column_equals_conditions = true + association_objects.each do |association_object| + relationship_conditions = association_object.conditions + next if relationship_conditions.blank? + conditions_hash[association_object.object_name] = relationship_conditions end - def extract_column_and_condition_from_method_name(name) - name_parts = name.gsub("=", "").split("_") - - condition_parts = [] - column = nil - while column.nil? && name_parts.size > 0 - possible_column_name = name_parts.join("_") - - self.class.column_details.each do |column_detail| - if column_detail[:column].name == possible_column_name || column_detail[:aliases].include?(possible_column_name) - column = column_detail - break - end - end - - condition_parts << name_parts.pop if !column - end - - return if column.nil? - - condition_name = condition_parts.reverse.join("_") - condition = nil - - # Find the real condition - self.class.conditions.each do |condition_klass| - if condition_klass.condition_names_for_column.include?(condition_name) - condition = condition_klass - break - end - end - - [column, condition] + condition_objects.each do |condition_object| + next if condition_object.value_is_meaningless? + conditions_hash[condition_object.object_name] = condition_object.value end - def breakdown_method_name(name) - column_detail, condition_klass = extract_column_and_condition_from_method_name(name) - if !column_detail.nil? && !condition_klass.nil? - # There were no modifiers - return [[], column_detail, condition_klass] - else - # There might be modifiers - name_parts = name.split("_of_") - column_detail, condition_klass = extract_column_and_condition_from_method_name(name_parts.pop) - if !column_detail.nil? && !condition_klass.nil? - # There were modifiers, lets get their real names - modifier_klasses = [] - name_parts.each do |modifier_name| - size_before = modifier_klasses.size - self.class.modifiers.each do |modifier_klass| - if modifier_klass.modifier_names.include?(modifier_name) - modifier_klasses << modifier_klass - break - end - end - return if modifier_klasses.size == size_before # there was an invalid modifer, return nil for everything and let it act as a nomethoderror - end - - return [modifier_klasses, column_detail, condition_klass] - end - end - - nil - end - - def build_method_name(modifier_klasses, column_name, condition_name) - modifier_name_parts = [] - modifier_klasses.each { |modifier_klass| modifier_name_parts << modifier_klass.modifier_names.first } - method_name_parts = [] - method_name_parts << modifier_name_parts.join("_of_") + "_of" unless modifier_name_parts.blank? - method_name_parts << column_name - method_name_parts << condition_name unless condition_name.blank? - method_name_parts.join("_").underscore - end - - def method_missing(name, *args, &block) - if setup_condition(name) - send(name, *args, &block) - else - super - end - end - - def setup_condition(name) - modifier_klasses, column_detail, condition_klass = breakdown_method_name(name.to_s) - if !column_detail.nil? && !condition_klass.nil? - method_name = build_method_name(modifier_klasses, column_detail[:column].name, condition_klass.condition_names_for_column.first) - - if !added_condition?(method_name) - column_type = column_sql = nil - if !modifier_klasses.blank? - # Find the column type - column_type = modifier_klasses.first.return_type - - # Build the column sql - column_sql = "{table}.{column}" - modifier_klasses.each do |modifier_klass| - next unless klass.connection.respond_to?(modifier_klass.adapter_method_name) - column_sql = klass.connection.send(modifier_klass.adapter_method_name, column_sql) - end - end - - add_condition!(condition_klass, method_name, :column => column_detail[:column], :column_type => column_type, :column_sql_format => column_sql) - - ([column_detail[:column].name] + column_detail[:aliases]).each do |column_name| - condition_klass.condition_names_for_column.each do |condition_name| - alias_method_name = build_method_name(modifier_klasses, column_name, condition_name) - add_condition_alias!(alias_method_name, method_name) unless added_condition?(alias_method_name) - end - end - end - - alias_method_name = name.to_s.gsub("=", "") - add_condition_alias!(alias_method_name, method_name) unless added_condition?(alias_method_name) - - return true - end - - false - end - - def add_condition!(condition, name, options = {}) - self.class.condition_names << name - options[:column] = options[:column].name - - self.class.class_eval <<-"end_eval", __FILE__, __LINE__ - def #{name}_object - if objects[:#{name}].nil? - options = {} - objects[:#{name}] = #{condition.name}.new(klass, #{options.inspect}) - end - objects[:#{name}] - end - - def #{name}; #{name}_object.value; end - - def #{name}=(value) - @conditions = nil - - #{name}_object.value = value - reset_#{name}! if #{name}_object.value_is_meaningless? - value - end - - def reset_#{name}!; objects.delete(:#{name}); end - end_eval - end - - def added_condition?(name) - respond_to?("#{name}_object") && respond_to?(name) && respond_to?("#{name}=") && respond_to?("reset_#{name}!") - end - - def add_condition_alias!(alias_name, name) - self.class.condition_names << alias_name - - self.class.class_eval do - alias_method "#{alias_name}_object", "#{name}_object" - alias_method alias_name, name - alias_method "#{alias_name}=", "#{name}=" - alias_method "reset_#{alias_name}!", "reset_#{name}!" - end - end - - def assert_valid_conditions(conditions) - conditions.each do |condition, value| - next if (self.class.condition_names + self.class.association_names + ["any"]).include?(condition.to_s) - - go_to_next = false - self.class.column_details.each do |column_detail| - if column_detail[:column].name == condition.to_s || column_detail[:aliases].include?(condition.to_s) - go_to_next = true - break - end - end - next if go_to_next - - next unless respond_to?(condition) - - raise(ArgumentError, "The #{condition} condition is not a valid condition") - end + conditions_hash + end + + # Resets all of the conditions, including conditions set on associations + def reset! + objects.each { |object| eval("@#{object.object_name} = nil") } + objects.clear + end + + private + def association_objects + objects.select { |object| object.class < Base && object.class != self.class } end - def associations - associations = {} - objects.each do |name, object| - associations[name] = object if object.class < ::Searchlogic::Conditions::Base - end - associations + def condition_objects + objects.select { |object| object.class < Condition::Base } end def objects - @objects ||= {} - end - - def reset_objects! - objects.each { |name, object| eval("@#{name} = nil") } - objects.clear + @objects ||= [] end def remove_conditions_from_protected_assignement(conditions) lib/searchlogic/conditions/base.rb @@ -23,7 +23,7 @@ module Searchlogic end def protect=(value) - associations.each { |name, obj| obj.protect = value } + association_objects.each { |obj| obj.protect = value } @protect = value end lib/searchlogic/conditions/protection.rb @@ -70,7 +70,7 @@ module Searchlogic when String, Symbol args.unshift(search_object).unshift(first) else - name = search_object.is_a?(Conditions::Base) ? (search_object.relationship_name || :conditions) : :search + name = search_object.is_a?(Conditions::Base) ? (search_object.object_name || :conditions) : :search args.unshift(search_object).unshift(name) end lib/searchlogic/helpers/form.rb @@ -7,6 +7,7 @@ module Searchlogic conditions.delete_if { |condition| condition.blank? } return if conditions.blank? return conditions.first if conditions.size == 1 + options[:scope] = true unless options.key?(:scope) conditions_strs = [] conditions_subs = [] @@ -20,14 +21,20 @@ module Searchlogic return if conditions_strs.blank? - join = options[:any] ? "OR" : "AND" - conditions_str = "(#{conditions_strs.join(") #{join} (")})" + join = options[:any] ? " OR " : " AND " + conditions_str = options[:scope] ? "(#{conditions_strs.join(")#{join}(")})" : conditions_strs.join(join) return conditions_str if conditions_subs.blank? [conditions_str, *conditions_subs] end + def scope_condition(condition) + arr_condition = condition.is_a?(Array) ? condition : [condition] + arr_condition[0] = "(#{arr_condition[0]})" + arr_condition.size == 1 ? arr_condition.first : arr_condition + end + def merge_joins(*joins) joins.delete_if { |join| join.blank? } return if joins.blank? lib/searchlogic/shared/utilities.rb @@ -67,7 +67,7 @@ module Searchlogic MAJOR = 1 MINOR = 5 - TINY = 5 + TINY = 6 # The current version as a Version instance CURRENT = new(MAJOR, MINOR, TINY) lib/searchlogic/version.rb @@ -6,7 +6,7 @@ module ActiveRecordTests binary_logic = accounts(:binary_logic) neco = accounts(:neco) binary_fun = accounts(:binary_fun) - + assert_equal [binary_logic, binary_fun, neco], Account.all assert_equal binary_logic, Account.first @@ -19,7 +19,7 @@ module ActiveRecordTests assert_equal [binary_logic, binary_fun, neco], Account.find(:all, {}) assert_equal [binary_logic, binary_fun, neco], Account.find(:all, :select => "id, name") end - + def test_standard_calculations binary_logic = accounts(:binary_logic) neco = accounts(:neco) @@ -35,12 +35,12 @@ module ActiveRecordTests assert_equal neco.id, Account.maximum("id") assert_equal binary_logic.id, Account.minimum("id") end - + def test_valid_ar_options assert_equal [:conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group, :from, :lock], ActiveRecord::Base.valid_find_options assert_equal [:conditions, :joins, :order, :select, :group, :having, :distinct, :limit, :offset, :include, :from], ActiveRecord::Base.valid_calculations_options end - + def test_build_search search = Account.new_search(:conditions => {:name_keywords => "awesome"}, :page => 2, :per_page => 15) assert_kind_of Searchlogic::Search::Base, search @@ -50,7 +50,7 @@ module ActiveRecordTests assert_equal 2, search.page assert_equal 15, search.per_page end - + def test_searchlogic_searching binary_logic = accounts(:binary_logic) neco = accounts(:neco) @@ -60,27 +60,27 @@ module ActiveRecordTests assert_equal [binary_logic], Account.all(:conditions => {:name_contains => "Binary", :users => {:first_name_starts_with => "Ben"}}) assert_equal [], Account.all(:conditions => {:name_contains => "Binary", :users => {:first_name_starts_with => "Ben", :last_name => "Mills"}}) assert_equal [binary_logic, neco], Account.all(:conditions => {:users => {:id_gt => 0}}, :include => :users) - + read_only_accounts = Account.all(:conditions => {:name_contains => "Binary"}, :readonly => true) assert read_only_accounts.first.readonly? - + assert_equal [binary_logic, binary_fun], Account.all(:conditions => {:name_contains => "Binary"}, :page => 2) assert_equal [], Account.all(:conditions => {:name_contains => "Binary"}, :page => 2, :per_page => 20) - + assert_equal [binary_logic], Account.scope1.all(:conditions => {:users => {:first_name_starts_with => "Ben"}}) end - + def test_searchlogic_counting assert_equal 2, Account.count(:conditions => {:name_contains => "Binary"}) assert_equal 1, Account.count(:conditions => {:name_contains => "Binary", :users => {:first_name_contains => "Ben"}}) assert_equal 1, Account.count(:conditions => {:name_contains => "Binary", :users => {:first_name_contains => "Ben"}}, :limit => 10, :offset => 10, :order_by => "id", :group => "id") end - + def test_scoping assert_equal({:conditions => {:name => "Binary"}, :limit => 10, :readonly => true}, Account.send(:with_scope, :find => {:conditions => {:name => "Binary"}, :limit => 10, :readonly => true}) { Account.send(:scope, :find) }) assert_equal({:conditions => ["\"accounts\".\"name\" LIKE ?", "%Binary%"], :limit => 10, :offset => 20}, Account.send(:with_scope, :find => {:conditions => {:name_contains => "Binary"}, :per_page => 10, :page => 3}) { Account.send(:scope, :find) }) end - + def test_accessible_conditions Account.conditions_accessible :name_contains assert_equal Set.new(["name_contains"]), Account.accessible_conditions @@ -90,7 +90,7 @@ module ActiveRecordTests assert_equal Set.new(["id_gt", "name_contains"]), Account.accessible_conditions Account.send(:write_inheritable_attribute, :conditions_accessible, nil) end - + def test_protected_conditions Account.conditions_protected :name_contains assert_equal Set.new(["name_contains"]), Account.protected_conditions @@ -100,7 +100,7 @@ module ActiveRecordTests assert_equal Set.new(["id_gt", "name_contains"]), Account.protected_conditions Account.send(:write_inheritable_attribute, :conditions_protected, nil) end - + def test_includes assert_nothing_raised { Account.all(:conditions => {:users => {:first_name_like => "Ben"}}, :include => :users) } end test/active_record_tests/base_test.rb @@ -2,23 +2,22 @@ require File.dirname(__FILE__) + '/../test_helper.rb' module ConditionsTests class BaseTest < ActiveSupport::TestCase - def test_register_conditions + def test_register_condition Searchlogic::Conditions::Base.register_condition(Searchlogic::Condition::Keywords) assert [Searchlogic::Condition::Keywords], Searchlogic::Conditions::Base.conditions - + Searchlogic::Conditions::Base.register_condition(Searchlogic::Condition::Like) assert [Searchlogic::Condition::Keywords, Searchlogic::Condition::Like], Searchlogic::Conditions::Base.conditions end - - def test_association_names - ["dogs", "children", "user_groups", "orders", "account", "parent", "cats"].each do |name| - assert Searchlogic::Cache::UserConditions.association_names.include? name - end - ["admin", "orders", "users"].each do |name| - Searchlogic::Cache::AccountConditions.association_names.include? name - end + + def test_register_modifier + Searchlogic::Conditions::Base.register_modifier(Searchlogic::Modifiers::Absolute) + assert [Searchlogic::Modifiers::Absolute], Searchlogic::Conditions::Base.modifiers + + Searchlogic::Conditions::Base.register_modifier(Searchlogic::Modifiers::Cos) + assert [Searchlogic::Modifiers::Absolute, Searchlogic::Modifiers::Cos], Searchlogic::Conditions::Base.modifiers end - + def test_needed assert (not Searchlogic::Conditions::Base.needed?(User, {})) assert (not Searchlogic::Conditions::Base.needed?(User, {:first_name => "Ben"})) @@ -32,24 +31,6 @@ module ConditionsTests assert_equal conditions.name_contains, "Binary" end - def test_any - conditions = Searchlogic::Cache::AccountConditions.new - assert (not conditions.any?) - conditions = Searchlogic::Cache::AccountConditions.new(:any => true) - assert conditions.any? - conditions.any = "false" - assert (not conditions.any?) - conditions = Searchlogic::Cache::AccountConditions.new - conditions.name_contains = "Binary" - assert_equal_sql ["\"accounts\".\"name\" LIKE ?", "%Binary%"], conditions.sanitize - conditions.id = 1 - assert_equal_sql ["(\"accounts\".\"id\" = ?) AND (\"accounts\".\"name\" LIKE ?)", 1, "%Binary%"], conditions.sanitize - conditions.any = true - assert_equal_sql ["(\"accounts\".\"id\" = ?) OR (\"accounts\".\"name\" LIKE ?)", 1, "%Binary%"], conditions.sanitize - conditions.any = false - assert_equal_sql ["(\"accounts\".\"id\" = ?) AND (\"accounts\".\"name\" LIKE ?)", 1, "%Binary%"], conditions.sanitize - end - def test_auto_joins conditions = Searchlogic::Cache::AccountConditions.new assert_equal conditions.auto_joins, nil @@ -75,18 +56,29 @@ module ConditionsTests conditions.id_gt = 5 now = Time.now conditions.created_after = now - assert_equal_sql ["(\"accounts\".\"created_at\" > ?) AND (\"accounts\".\"id\" > ?) AND (\"accounts\".\"name\" LIKE ?)", now, 5, "%Binary%"], conditions.sanitize + assert_equal ["\"accounts\".\"name\" LIKE ? AND \"accounts\".\"id\" > ? AND \"accounts\".\"created_at\" > ?", "%Binary%", 5, now], conditions.sanitize # test out associations conditions.users.first_name_like = "Ben" conditions.users.id_gt = 10 conditions.users.orders.total_lt = 500 - assert_equal_sql ["(\"accounts\".\"created_at\" > ?) AND (\"accounts\".\"id\" > ?) AND (\"accounts\".\"name\" LIKE ?) AND ((\"users\".\"first_name\" LIKE ?) AND (\"users\".\"id\" > ?) AND (\"orders\".\"total\" < ?))", now, 5, "%Binary%", "%Ben%", 10, 500], conditions.sanitize + assert_equal ["\"accounts\".\"name\" LIKE ? AND \"accounts\".\"id\" > ? AND \"accounts\".\"created_at\" > ? AND \"users\".\"first_name\" LIKE ? AND \"users\".\"id\" > ? AND \"orders\".\"total\" < ?", "%Binary%", 5, now, "%Ben%", 10, 500], conditions.sanitize # test that raw sql is returned conditions.conditions = "awesome" assert_equal "awesome", conditions.sanitize end + + def test_sanitize_with_and_or_any + conditions = Searchlogic::Cache::AccountConditions.new + conditions.name_contains = "Binary" + conditions.or_id_gt = 5 + assert conditions.id_gt_object.any? + assert_equal ["\"accounts\".\"name\" LIKE ? OR \"accounts\".\"id\" > ?", "%Binary%", 5], conditions.sanitize + now = Time.now + conditions.created_at_after = now + assert_equal ["\"accounts\".\"name\" LIKE ? OR \"accounts\".\"id\" > ? AND \"accounts\".\"created_at\" > ?", "%Binary%", 5, now], conditions.sanitize + end def test_conditions conditions = Searchlogic::Cache::AccountConditions.new @@ -94,52 +86,40 @@ module ConditionsTests v = {:name_like => "Binary", :created_at_greater_than => now} conditions.conditions = v assert_equal v, conditions.conditions - + sql = "id in (1,2,3,4)" conditions.conditions = sql assert_equal sql, conditions.conditions - assert_equal({}, conditions.send(:objects)) - + assert_equal [], conditions.send(:objects) + v2 = {:id_less_than => 5, :name_begins_with => "Beginning of string"} conditions.conditions = v2 assert_equal v2, conditions.conditions - + v = {:name_like => "Binary", :created_at_greater_than => now} conditions.conditions = v assert_equal v2.merge(v), conditions.conditions - + sql2 = "id > 5 and name = 'Test'" conditions.conditions = sql2 assert_equal sql2, conditions.conditions - assert_equal({}, conditions.send(:objects)) - + assert_equal [], conditions.send(:objects) + conditions.name_contains = "awesome" assert_equal({:name_like => "awesome"}, conditions.conditions) - + now = Time.now conditions.conditions = {:id_gt => "", :id => "", :name => ["", "", ""], :created_at => ["", now], :name_starts_with => "Ben"} assert_equal({:name_like => "awesome", :name_begins_with => "Ben", :created_at_equals => now}, conditions.conditions) end - - # Other general usage tests, need to clean these up - - def test_setting_conditions - [Account, User, Order].each do |klass| - conditions = "Searchlogic::Cache::#{klass}Conditions".constantize.new - conditions.class.condition_names.each do |condition_name| - conditions.send("#{condition_name}=", 1) - assert_equal 1, conditions.send(condition_name) - end - end - end - - def test_accessible_protected_conditions + + def test_conditions_with_protected_assignments Account.conditions_accessible << :name_contains conditions = Searchlogic::Cache::AccountConditions.new conditions.conditions = {:created_after => Time.now, :name_contains => "Binary"} assert({:name_contains => "Binary"}, conditions.conditions) Account.send(:write_inheritable_attribute, :conditions_accessible, nil) - + Account.conditions_protected << :name_contains conditions = Searchlogic::Cache::AccountConditions.new now = Time.now @@ -147,14 +127,14 @@ module ConditionsTests assert({:created_after => now}, conditions.conditions) Account.send(:write_inheritable_attribute, :conditions_protected, nil) end - - def test_assert_valid_values + + def test_conditions_unknown conditions = Searchlogic::Cache::UserConditions.new assert_raise(NoMethodError) { conditions.conditions = {:unknown => "blah"} } assert_nothing_raised { conditions.conditions = {:first_name => "blah"} } assert_nothing_raised { conditions.conditions = {:first_name_contains => "blah"} } end - + def test_setting_associations conditions = Searchlogic::Cache::AccountConditions.new(:users => {:first_name_like => "Ben"}) assert_equal conditions.users.first_name_like, "Ben" @@ -162,30 +142,7 @@ module ConditionsTests conditions.users.last_name_begins_with = "Ben" assert_equal conditions.users.last_name_begins_with, "Ben" end - - def test_virtual_columns - conditions = Searchlogic::Cache::AccountConditions.new - conditions.hour_of_created_gt = 2 - assert_equal_sql ["strftime('%H', \"accounts\".\"created_at\") > ?", 2], conditions.sanitize - conditions.dow_of_created_at_most = 5 - assert_equal_sql ["(strftime('%w', \"accounts\".\"created_at\") <= ?) AND (strftime('%H', \"accounts\".\"created_at\") > ?)", 5, 2], conditions.sanitize - conditions.month_of_created_at_nil = true - assert_equal_sql ["(strftime('%w', \"accounts\".\"created_at\") <= ?) AND (strftime('%H', \"accounts\".\"created_at\") > ?) AND (strftime('%m', \"accounts\".\"created_at\") IS NULL)", 5, 2], conditions.sanitize - conditions.min_of_hour_of_month_of_created_at_nil = true - assert_equal_sql ["(strftime('%w', \"accounts\".\"created_at\") <= ?) AND (strftime('%H', \"accounts\".\"created_at\") > ?) AND (strftime('%m', strftime('%H', strftime('%M', \"accounts\".\"created_at\"))) IS NULL) AND (strftime('%m', \"accounts\".\"created_at\") IS NULL)", 5, 2], conditions.sanitize - end - - def test_objects - conditions = Searchlogic::Cache::AccountConditions.new - assert_equal({}, conditions.send(:objects)) - conditions.name_contains = "Binary" - assert_equal 1, conditions.send(:objects).size - - conditions.users.first_name_contains = "Ben" - assert_equal 2, conditions.send(:objects).size - end - def test_reset conditions = Searchlogic::Cache::AccountConditions.new @@ -194,13 +151,13 @@ module ConditionsTests conditions.reset_name_like! conditions.reset_name_contains! # should set up aliases for reset - assert_equal({}, conditions.send(:objects)) + assert_equal [], conditions.send(:objects) conditions.users.first_name_like = "Ben" assert_equal 1, conditions.send(:objects).size conditions.reset_users! - assert_equal({}, conditions.send(:objects)) + assert_equal [], conditions.send(:objects) conditions.name_begins_with ="Binary" conditions.users.orders.total_gt = 200 @@ -210,12 +167,12 @@ module ConditionsTests assert_equal 1, conditions.send(:objects).size conditions.reset_users! - assert_equal({}, conditions.send(:objects)) - end - - def test_method_conflicts - conditions = Searchlogic::Cache::AccountConditions.new - assert_nil conditions.id + assert_equal [], conditions.send(:objects) + + conditions.name_begins_with ="Binary" + assert_equal 1, conditions.send(:objects).size + conditions.reset! + assert_equal [], conditions.send(:objects) end end end \ No newline at end of file test/conditions_tests/base_test.rb @@ -142,7 +142,7 @@ module SearchTests search.conditions.users.id_greater_than = 2 search.page = 3 search.readonly = true - assert_equal_find_options({:joins => :users, :offset => 4, :readonly => true, :conditions => ["(\"accounts\".\"name\" LIKE ?) AND (\"users\".\"id\" > ?)", "%Binary%", 2], :limit => 2 }, search.sanitize) + assert_equal({:joins => :users, :offset => 4, :readonly => true, :conditions => ["\"accounts\".\"name\" LIKE ? AND \"users\".\"id\" > ?", "%Binary%", 2], :limit => 2 }, search.sanitize) end def test_scope @@ -151,7 +151,7 @@ module SearchTests conditions = search.conditions assert_equal "some sql", search.conditions.conditions search.conditions = nil - assert_nil search.conditions.conditions + assert_equal({}, search.conditions.conditions) search.conditions = "some sql" assert_equal "some sql", search.conditions.conditions search.conditions = "some sql" @@ -217,7 +217,7 @@ module SearchTests search = Account.new_search(:conditions => {:users => {:orders => {:id_gt => bens_order.id}}}) assert_equal 1, search.count - + search = Order.new_search(:conditions => {:user => {:account => {:id_gt => binary_logic.id}}}) assert_equal 1, search.count @@ -233,5 +233,9 @@ module SearchTests def test_sti end + + def test_include_in_relationships + + end end end \ No newline at end of file test/search_tests/base_test.rb @@ -49,6 +49,13 @@ ActiveRecord::Schema.define(:version => 1) do t.binary :receipt end + create_table :line_items do |t| + t.datetime :created_at + t.datetime :updated_at + t.integer :order_id + t.string :name + end + create_table :animals do |t| t.datetime :created_at t.datetime :updated_at @@ -81,6 +88,11 @@ end class Order < ActiveRecord::Base belongs_to :user + has_many :line_items +end + +class LineItem < ActiveRecord::Base + belongs_to :order end # STI @@ -99,32 +111,4 @@ class Test::Unit::TestCase self.use_instantiated_fixtures = false self.pre_loaded_fixtures = true fixtures :all - - private - def assert_equal_find_options(find_options, result) - find_options_conditions = find_options.delete(:conditions) - result_conditions = result.delete(:conditions) - - assert_equal find_options, result - if find_options_conditions.blank? || result_conditions.blank? - assert_equal find_options_conditions, result_conditions - else - assert_equal_sql find_options_conditions, result_conditions - end - end - - def assert_equal_sql(sql, result) - sql_parts = breakdown_sql(sql) - result_parts = breakdown_sql(sql) - - assert_equal sql_parts.size, result_parts.size - sql_parts.each { |part| assert result_parts.include?(part) } - end - - def breakdown_sql(sql) - sanitized_sql = ActiveRecord::Base.send(:sanitize_sql, sql) - sanitized_sql.gsub!(/(\(|\))/, "") - sql_parts = sanitized_sql.split(/or/i) - sql_parts.collect { |part| part.split(/ and /i) }.flatten - end end \ No newline at end of file test/test_helper.rb test/condition_tests/keyswords_test.rb 678c4445018e8ecc00ce35a0610a4490f20fdc8c binarylogic bjohnson@binarylogic.com http://github.com/binarylogic/searchlogic/commit/585e1459eaf69c71d0896a4c7b47529ad47b9960 585e1459eaf69c71d0896a4c7b47529ad47b9960 2008-11-29T15:14:31-08:00 2008-11-29T15:14:31-08:00 Release v1.5.6 (see changelog) 463ed6f40da2e2523cb44f3848b669871bf81dac binarylogic bjohnson@binarylogic.com