searchlogic 1.6.6 → 2.1.0

data/lib/searchlogic/search/searching.rb

@@ -1,32 +0,0 @@
-module Searchlogic
-  module Search
-    # = Searchlogic Searching
-    #
-    # Implements searching functionality for searchlogic. Searchlogic::Search::Base and Searchlogic::Conditions::Base can both search and include
-    # this module.
-    module Searching
-      # Use these methods just like you would in ActiveRecord
-      SEARCH_METHODS = [:all, :find, :first]
-      CALCULATION_METHODS = [:average, :calculate, :count, :maximum, :minimum, :sum]
-      
-      (SEARCH_METHODS + CALCULATION_METHODS).each do |method|
-        class_eval <<-"end_eval", __FILE__, __LINE__
-          def #{method}(*args)
-            find_options = {}
-            options = args.extract_options! # can't pass options, your options are in the search
-            klass.send(:with_scope, :find => acting_as_filter? ? {} : scope) do
-              options = sanitize(#{SEARCH_METHODS.include?(method)})
-              if #{CALCULATION_METHODS.include?(method)}
-                options[:distinct] = true if #{method == :count} && !joins.blank? && Config.search.remove_duplicates?
-                args[0] = klass.column_names.first if [nil, :all].include?(args[0])
-              end
-              args << options
-              results = klass.#{method}(*args)
-              results
-            end
-          end
-        end_eval
-      end
-    end
-  end
-end

data/lib/searchlogic/shared/utilities.rb

@@ -1,57 +0,0 @@
-module Searchlogic
-  module Shared
-    module Utilities # :nodoc:
-      private
-        def merge_conditions(*conditions)
-          options = conditions.extract_options!
-          conditions.delete_if { |condition| condition.blank? }
-          return if conditions.blank?
-          return conditions.first if conditions.size == 1
-        
-          conditions_strs = []
-          conditions_subs = []
-        
-          conditions.each do |condition|
-            next if condition.blank?
-            arr_condition = condition.is_a?(Array) ? condition : [condition]
-            conditions_strs << arr_condition.first
-            conditions_subs += arr_condition[1..-1]
-          end
-        
-          return if conditions_strs.blank?
-        
-          join = options[:any] ? " OR " : " AND "
-          conditions_str = conditions_strs.join(join)
-        
-          return conditions_str if conditions_subs.blank?
-        
-          [conditions_str, *conditions_subs]
-        end
-        
-        def scope_condition(condition)
-          return condition if condition.blank?
-          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?
-          return joins.first if joins.size == 1
-          
-          new_joins = []
-          joins.each do |join|
-            case join
-            when Array
-              new_joins += join
-            else
-              new_joins << join
-            end
-          end
-          
-          new_joins.compact.uniq
-        end
-    end
-  end
-end

data/lib/searchlogic/shared/virtual_classes.rb

@@ -1,39 +0,0 @@
-module Searchlogic
-  module Shared
-    # = Searchlogic Virtual Classes
-    #
-    # Creates virtual classes for each model, to implementing a type of caching. So that object instantiation for searchlogic searches is cached. This is lazy, meaning
-    # it will only cache when it needs. So the first instantion will be much slow than the following ones. This is cached in the RAM, so if the process is restarted the caching is cleared.
-    module VirtualClasses
-      def self.included(klass)
-        klass.extend ClassMethods
-      end
-      
-      module ClassMethods
-        # Creates virtual classes for the class passed to it. This is a neccesity for keeping dynamically created method
-        # names specific to models. It provides caching and helps a lot with performance.
-        def create_virtual_class(model_class)
-          class_search_name = "::Searchlogic::Cache::#{model_class.name.gsub("::", "")}" + name.split(/::/)[1]
-  
-          begin
-            eval(class_search_name)
-          rescue NameError
-            eval <<-end_eval
-              class #{class_search_name} < ::#{name}
-                def self.klass
-                  #{model_class.name}
-                end
-        
-                def klass
-                  #{model_class.name}
-                end
-              end
-      
-              #{class_search_name}
-            end_eval
-          end
-        end
-      end
-    end
-  end
-end

data/lib/searchlogic/version.rb

@@ -1,79 +0,0 @@
-# (The MIT License)
-# 
-# Copyright (c) 2008 Jamis Buck <jamis@37signals.com>,
-#               with modifications by Bruce Williams <bruce@fiveruns.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# 'Software'), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-# 
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-module Searchlogic
-  # = Version
-  #
-  # A class for describing the current version of a library. The version
-  # consists of three parts: the +major+ number, the +minor+ number, and the
-  # +tiny+ (or +patch+) number.
-  class Version
-    
-    include Comparable
-  
-    # A convenience method for instantiating a new Version instance with the
-    # given +major+, +minor+, and +tiny+ components.
-    def self.[](major, minor, tiny)
-      new(major, minor, tiny)
-    end
-
-    attr_reader :major, :minor, :tiny
-
-    # Create a new Version object with the given components.
-    def initialize(major, minor, tiny)
-      @major, @minor, @tiny = major, minor, tiny
-    end
-
-    # Compare this version to the given +version+ object.
-    def <=>(version)
-      to_i <=> version.to_i
-    end
-
-    # Converts this version object to a string, where each of the three
-    # version components are joined by the '.' character. E.g., 2.0.0.
-    def to_s
-      @to_s ||= [@major, @minor, @tiny].join(".")
-    end
-
-    # Converts this version to a canonical integer that may be compared
-    # against other version objects.
-    def to_i
-      @to_i ||= @major * 1_000_000 + @minor * 1_000 + @tiny
-    end
-    
-    def to_a
-      [@major, @minor, @tiny]
-    end
-
-    MAJOR = 1
-    MINOR = 6
-    TINY  = 6
-
-    # The current version as a Version instance
-    CURRENT = new(MAJOR, MINOR, TINY)
-    # The current version as a String
-    STRING = CURRENT.to_s
-    
-  end
-  
-end

data/test/active_record_tests/associations_test.rb

@@ -1,94 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module ActiveRecordTests
-  class AssociationsTest < ActiveSupport::TestCase
-    def test_has_many
-      binary_logic = accounts(:binary_logic)
-      ben = users(:ben)
-      jennifer = users(:jennifer)
-      
-      search = binary_logic.users.new_search
-      assert_kind_of Searchlogic::Search::Base, search
-      assert_equal User, search.klass
-      assert_equal({:conditions => "\"users\".account_id = #{binary_logic.id}"}, search.scope)
-      
-      assert_equal [ben, jennifer], search.all
-      assert_equal ben, search.first
-      assert_equal ((ben.id + jennifer.id) / 2.0), search.average("id")
-      assert_equal 2, search.count
-    
-      search.conditions.first_name_contains = "Ben"
-    
-      assert_equal [ben], search.all
-      assert_equal ben, search.first
-      assert_equal ben.id, search.average("id")
-      assert_equal 1, search.count
-    
-      assert_equal 2, binary_logic.users.count
-      assert_equal 1, binary_logic.users.all(:conditions => {:first_name_contains => "Ben"}).size
-      assert_equal 0, binary_logic.users.all(:conditions => {:first_name_contains => "No one"}).size
-      assert_equal ben.id, binary_logic.users.sum("id", :conditions => {:first_name_contains => "Ben"})
-      assert_equal 0, binary_logic.users.sum("id", :conditions => {:first_name_contains => "No one"})
-      assert_equal ben.id, binary_logic.users.average("id", :conditions => {:first_name_contains => "Ben"})
-    end
-  
-    def test_has_many_through
-      binary_logic = accounts(:binary_logic)
-      
-      search = binary_logic.orders.new_search
-      assert_kind_of Searchlogic::Search::Base, search
-      assert_equal Order, search.klass
-      assert_equal({:conditions => "(\"users\".account_id = 431064614)", :joins => "INNER JOIN \"users\" ON \"orders\".user_id = \"users\".id   "}, search.scope)
-      
-      bens_order = orders(:bens_order)
-      assert_equal [bens_order], search.all
-      assert_equal bens_order, search.first
-      assert_equal bens_order.id, search.average("id")
-      assert_equal 1, search.count
-    
-      search.conditions.total_gt = 100
-    
-      assert_equal [bens_order], search.all
-      assert_equal bens_order, search.first
-      assert_equal bens_order.id, search.average("id")
-      assert_equal 1, search.count
-    
-      assert_equal 1, binary_logic.orders.count
-      assert_equal 1, binary_logic.orders.all(:conditions => {:total_gt => 100}).size
-      assert_equal 0, binary_logic.orders.all(:conditions => {:total_gt => 1000}).size
-      assert_equal bens_order.id, binary_logic.orders.sum("id", :conditions => {:total_gt => 100})
-      assert_equal 0, binary_logic.orders.sum("id", :conditions => {:total_gt => 1000})
-      assert_equal bens_order.id, binary_logic.orders.average("id", :conditions => {:total_gt => 100})
-    end
-  
-    def test_habtm
-      neco = user_groups(:neco)
-      ben = users(:ben)
-      drew = users(:drew)
-      
-      search = neco.users.new_search
-      assert_kind_of Searchlogic::Search::Base, search
-      assert_equal User, search.klass
-      assert_equal({:conditions => "\"user_groups_users\".user_group_id = #{neco.id} ", :joins => "INNER JOIN \"user_groups_users\" ON \"users\".id = \"user_groups_users\".user_id"}, search.scope)
-      assert_equal [drew, ben], search.all
-      
-      assert_equal drew, search.first
-      assert_equal ((ben.id + drew.id) / 2.0).to_s, search.average("id").to_s
-      assert_equal 2, search.count
-    
-      search.conditions.first_name_contains = "Ben"
-
-      assert_equal [ben], search.all
-      assert_equal ben, search.first
-      assert_equal ben.id, search.average("id")
-      assert_equal 1, search.count
-    
-      assert_equal 2, neco.users.count
-      assert_equal 1, neco.users.all(:conditions => {:first_name_contains => "Ben"}).size
-      assert_equal 0, neco.users.all(:conditions => {:first_name_contains => "No one"}).size
-      assert_equal ben.id, neco.users.sum("id", :conditions => {:first_name_contains => "Ben"})
-      assert_equal 0, neco.users.sum("id", :conditions => {:first_name_contains => "No one"})
-      assert_equal ben.id, neco.users.average("id", :conditions => {:first_name_contains => "Ben"})
-    end
-  end
-end

data/test/active_record_tests/base_test.rb

@@ -1,115 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module ActiveRecordTests
-  class BaseTest < ActiveSupport::TestCase
-    def test_standard_find
-      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
-      
-      assert_equal [binary_logic, binary_fun, neco], Account.find(:all)
-      assert_equal [binary_logic], Account.find(:all, :conditions => {:name => "Binary Logic"})
-      assert_equal [binary_logic], Account.find(:all, :conditions => ["name = ?", "Binary Logic"])
-      assert_equal [binary_logic], Account.find(:all, :conditions => "name = 'Binary Logic'")
-      assert_equal binary_logic, Account.find(:first)
-      assert_equal [binary_logic, binary_fun, neco], Account.find(:all, nil)
-      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)
-      binary_fun = accounts(:binary_fun)
-      
-      assert_equal 3, Account.count({})
-      assert_equal 3, Account.count(nil)
-      assert_equal 3, Account.count(:limit => 1)
-      assert_equal 0, Account.count(:limit => 10, :offset => 10)
-      assert_equal binary_logic.id + neco.id + binary_fun.id, Account.sum("id")
-      assert_equal binary_logic.id + neco.id + binary_fun.id, Account.sum("id", {})
-      assert_equal (binary_logic.id + neco.id + binary_fun.id) / 3.0, Account.average("id")
-      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, :having, :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
-      assert_equal({}, search.scope)
-      assert_equal Account, search.klass
-      assert_equal "awesome", search.conditions.name_keywords
-      assert_equal 2, search.page
-      assert_equal 15, search.per_page
-    end
-    
-    def test_searchlogic_searching
-      binary_logic = accounts(:binary_logic)
-      neco = accounts(:neco)
-      binary_fun = accounts(:binary_fun)
-      
-      assert_equal [binary_logic, binary_fun], Account.all(:conditions => {:name_contains => "Binary"})
-      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 => "accounts.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
-      Account.conditions_accessible :id_gt
-      assert_equal Set.new(["id_gt", "name_contains"]), Account.accessible_conditions
-      Account.conditions_accessible :id_gt, :name_contains
-      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
-      Account.conditions_protected :id_gt
-      assert_equal Set.new(["id_gt", "name_contains"]), Account.protected_conditions
-      Account.conditions_protected :id_gt, :name_contains
-      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
-    
-    def test_remove_duplicate_joins
-      query = "SELECT DISTINCT `ticket_groups`.* FROM `ticket_groups` INNER JOIN tickets ON ticket_groups.id = tickets.ticket_group_id     LEFT OUTER JOIN `tickets` ON tickets.ticket_group_id = ticket_groups.id  WHERE (`tickets`.`id` = 2) AND ((`tickets`.event_id = 810802042))  LIMIT 20"
-      cleaned_query = ActiveRecord::Base.send(:remove_duplicate_joins, query)
-      expected_query = "SELECT DISTINCT `ticket_groups`.* FROM `ticket_groups` INNER JOIN tickets ON ticket_groups.id = tickets.ticket_group_id WHERE (`tickets`.`id` = 2) AND ((`tickets`.event_id = 810802042)) LIMIT 20"
-      assert_equal expected_query, cleaned_query
-    end
-  end
-end

data/test/condition_tests/base_test.rb

@@ -1,62 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module ConditionTests
-  class BaseTest < ActiveSupport::TestCase
-    def test_condition_type_name
-      assert_equal "equals", Searchlogic::Condition::Equals.condition_type_name
-      assert_equal "keywords", Searchlogic::Condition::Keywords.condition_type_name
-      assert_equal "greater_than_or_equal_to", Searchlogic::Condition::GreaterThanOrEqualTo.condition_type_name
-    end
-  
-    def test_ignore_meaningless_value?
-      assert !Searchlogic::Condition::Equals.ignore_meaningless_value?
-      assert Searchlogic::Condition::Keywords.ignore_meaningless_value?
-      assert !Searchlogic::Condition::NotEqual.ignore_meaningless_value?
-    end
-  
-    def test_value_type
-      assert_nil Searchlogic::Condition::Equals.value_type
-      assert_nil Searchlogic::Condition::Keywords.value_type
-      assert_equal :boolean, Searchlogic::Condition::Nil.value_type
-      assert_equal :boolean, Searchlogic::Condition::Blank.value_type
-      assert_nil Searchlogic::Condition::GreaterThan.value_type
-    end
-  
-    def test_initialize
-      condition = Searchlogic::Condition::Keywords.new(Account, :column => Account.columns_hash["name"])
-      assert_equal condition.klass, Account
-      assert_equal Account.columns_hash["name"], condition.column
-    
-      condition = Searchlogic::Condition::GreaterThan.new(Account, :column => "id")
-      assert_equal Account.columns_hash["id"], condition.column
-    
-      condition = Searchlogic::Condition::GreaterThan.new(Account, :column => "id", :column_type => :string, :column_sql_format => "some sql")
-      assert_equal Account.columns_hash["id"], condition.column
-      condition.value = "awesome"
-      assert_equal ["some sql > ?", "awesome"], condition.sanitize
-    end
-  
-    def test_explicitly_set_value
-      condition = Searchlogic::Condition::Keywords.new(Account, :column => Account.columns_hash["name"])
-      assert !condition.explicitly_set_value?
-      condition.value = "test"
-      assert condition.explicitly_set_value?
-    end
-  
-    def test_sanitize
-      # This is tested thoroughly in test_condition_types
-    end
-  
-    def test_value
-      # This is tested thoroughly in test_condition_types
-    end 
-    
-    #http://binarylogic.lighthouseapp.com/projects/16601-searchlogic/tickets/60-text-dates-are-incorrectly-converted-into-utc#ticket-60-11
-    def test_string_to_date                     
-      condition = Searchlogic::Condition::GreaterThan.new(Account, :column => "created_at")
-      condition.value = "03/02/2009"   
-      assert_equal Time.parse("03/02/2009", 0), condition.value
-    end
-
-  end
-end