searchgasm 0.9.6 → 0.9.7

data/lib/searchgasm/search/condition_types/contains_condition.rb

@@ -1,26 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class ContainsCondition < Condition
-          class << self
-            def name_for_column(column)
-              return unless string_column?(column)
-              super
-            end
-            
-            def aliases_for_column(column)
-              ["#{column.name}_like", "#{column.name}_has"]
-            end
-          end
-          
-          def to_conditions(value)
-            ["#{quoted_table_name}.#{quoted_column_name} LIKE ?", "%#{value}%"]
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::ContainsCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/descendant_of_condition.rb

@@ -1,30 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class DescendantOfCondition < TreeCondition
-          def to_conditions(value)
-            # Wish I knew how to do this in SQL
-            root = (value.is_a?(klass) ? value : klass.find(value)) rescue return
-            strs = []
-            subs = []
-            all_children_ids(root).each do |child_id|
-              strs << "#{quoted_table_name}.#{quote_column_name(klass.primary_key)} = ?"
-              subs << child_id
-            end
-            [strs.join(" OR "), *subs]
-          end
-          
-          private
-            def all_children_ids(record)
-              ids = record.children.collect { |child| child.send(klass.primary_key) }
-              record.children.each { |child| ids += all_children_ids(child) }
-              ids
-            end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::DescendantOfCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/does_not_equal_condition.rb

@@ -1,34 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class DoesNotEqualCondition < Condition
-          class << self
-            def aliases_for_column(column)
-              ["#{column.name}_is_not", "#{column.name}_not"]
-            end
-          end
-          
-          def ignore_blanks?
-            false
-          end
-          
-          def to_conditions(value)
-            # Delegate to equals and then change
-            condition = EqualsCondition.new(klass, column)
-            condition.value = value
-            
-            sql = condition.sanitize
-            sql.gsub!(/ IS /, " IS NOT ")
-            sql.gsub!(/ BETWEEN /, " NOT BETWEEN ")
-            sql.gsub!(/ IN /, " NOT IN ")
-            sql.gsub!(/=/, "!=")
-            sql
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::DoesNotEqualCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/ends_with_condition.rb

@@ -1,26 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class EndsWithCondition < Condition
-          class << self
-            def name_for_column(column)
-              return unless string_column?(column)
-              super
-            end
-            
-            def aliases_for_column(column)
-              ["#{column.name}_ew", "#{column.name}_ends", "#{column.name}_end"]
-            end
-          end
-          
-          def to_conditions(value)
-            ["#{quoted_table_name}.#{quoted_column_name} LIKE ?", "%#{value}"]
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::EndsWithCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/equals_condition.rb

@@ -1,26 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class EqualsCondition < Condition
-          class << self
-            def aliases_for_column(column)
-              ["#{column.name}", "#{column.name}_is"]
-            end
-          end
-          
-          def ignore_blanks?
-            false
-          end
-          
-          def to_conditions(value)
-            # Let ActiveRecord handle this
-            klass.send(:sanitize_sql_hash_for_conditions, {column.name => value})
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::EqualsCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/greater_than_condition.rb

@@ -1,31 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class GreaterThanCondition < Condition
-          class << self
-            def name_for_column(column)
-              return unless comparable_column?(column)
-              super
-            end
-            
-            def aliases_for_column(column)
-              column_names = [column.name]
-              column_names << column.name.gsub(/_at$/, "") if [:datetime, :timestamp, :time, :date].include?(column.type) && column.name =~ /_at$/
-              
-              aliases = []
-              column_names.each { |column_name| aliases += ["#{column_name}_gt", "#{column_name}_after"] }
-              aliases
-            end
-          end
-          
-          def to_conditions(value)
-            ["#{quoted_table_name}.#{quoted_column_name} > ?", value]
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::GreaterThanCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/greater_than_or_equal_to_condition.rb

@@ -1,26 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class GreaterThanOrEqualToCondition < Condition
-          class << self
-            def name_for_column(column)
-              return unless comparable_column?(column)
-              super
-            end
-            
-            def aliases_for_column(column)
-              ["#{column.name}_gte", "#{column.name}_at_least"]
-            end
-          end
-          
-          def to_conditions(value)
-            ["#{quoted_table_name}.#{quoted_column_name} >= ?", value]
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::GreaterThanOrEqualToCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/inclusive_descendant_of_condition.rb

@@ -1,19 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class InclusiveDescendantOfCondition < TreeCondition
-          include Search::Utilities
-          
-          def to_conditions(value)
-            condition = DescendantOfCondition.new(klass, column)
-            condition.value = value
-            merge_conditions(["#{quoted_table_name}.#{quote_column_name(klass.primary_key)} = ?", (value.is_a?(klass) ? value.send(klass.primary_key) : value)], condition.sanitize, :any => true)
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::InclusiveDescendantOfCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/keywords_condition.rb

@@ -1,39 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class KeywordsCondition < Condition
-          BLACKLISTED_WORDS = ('a'..'z').to_a + ["about", "an", "are", "as", "at", "be", "by", "com", "de", "en", "for", "from", "how", "in", "is", "it", "la", "of", "on", "or", "that", "the", "the", "this", "to", "und", "was", "what", "when", "where", "who", "will", "with", "www"] # from ranks.nl        
-          
-          class << self
-            def name_for_column(column)
-              return unless string_column?(column)
-              super
-            end
-            
-            def aliases_for_column(column)
-              ["#{column.name}_kwords", "#{column.name}_kw"]
-            end
-          end
-          
-          def to_conditions(value)
-            strs = []
-            subs = []
-            
-            search_parts = value.gsub(/,/, " ").split(/ /).collect { |word| word.downcase.gsub(/[^[:alnum:]]/, ''); }.uniq.select { |word| !BLACKLISTED_WORDS.include?(word.downcase) && !word.blank? }
-            return if search_parts.blank?
-            
-            search_parts.each do |search_part|
-              strs << "#{quoted_table_name}.#{quoted_column_name} LIKE ?"
-              subs << "%#{search_part}%"
-            end
-            
-            [strs.join(" AND "), *subs]
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::KeywordsCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/less_than_condition.rb

@@ -1,31 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class LessThanCondition < Condition
-          class << self
-            def name_for_column(column)
-              return unless comparable_column?(column)
-              super
-            end
-            
-            def aliases_for_column(column)
-              column_names = [column.name]
-              column_names << column.name.gsub(/_at$/, "") if [:datetime, :timestamp, :time, :date].include?(column.type) && column.name =~ /_at$/
-              
-              aliases = []
-              column_names.each { |column_name| aliases += ["#{column_name}_lt", "#{column_name}_before"] }
-              aliases
-            end
-          end
-          
-          def to_conditions(value)
-            ["#{quoted_table_name}.#{quoted_column_name} < ?", value]
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::LessThanCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/less_than_or_equal_to_condition.rb

@@ -1,26 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class LessThanOrEqualToCondition < Condition
-          class << self
-            def name_for_column(column)
-              return unless comparable_column?(column)
-              super
-            end
-            
-            def aliases_for_column(column)
-              ["#{column.name}_lte", "#{column.name}_at_most"]
-            end
-          end
-          
-          def to_conditions(value)
-            ["#{quoted_table_name}.#{quoted_column_name} <= ?", value]
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::LessThanOrEqualToCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/sibling_of_condition.rb

@@ -1,22 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class SiblingOfCondition < TreeCondition
-          include Search::Utilities
-          
-          def to_conditions(value)
-            parent_association = klass.reflect_on_association(:parent)
-            foreign_key_name = (parent_association && parent_association.options[:foreign_key]) || "parent_id"
-            parent_id = (value.is_a?(klass) ? value : klass.find(value)).send(foreign_key_name)
-            condition = ChildOfCondition.new(klass, column)
-            condition.value = parent_id
-            merge_conditions(["#{quoted_table_name}.#{quote_column_name(klass.primary_key)} != ?", (value.is_a?(klass) ? value.send(klass.primary_key) : value)], condition.sanitize)
-          end
-        end
-      end
-      
-      Conditions.register_condition(ConditionTypes::SiblingOfCondition)
-    end
-  end
-end

data/lib/searchgasm/search/condition_types/tree_condition.rb

@@ -1,20 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module ConditionTypes
-        class TreeCondition < Condition
-          class << self
-            def name_for_column(column)
-              nil
-            end
-            
-            def name_for_klass(klass)
-              return unless klass.reflect_on_association(:parent) && klass.reflect_on_association(:children)
-              condition_name
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/searchgasm/search/utilities.rb

@@ -1,34 +0,0 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      module Utilities
-        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].flatten
-              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
-      end
-    end
-  end
-end

data/test/test_searchgasm_base.rb

@@ -1,185 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-class TestSearchgasmBase < Test::Unit::TestCase
-  fixtures :accounts, :users, :orders
-  
-  def setup
-    setup_db
-    load_fixtures
-  end
-  
-  def teardown
-    teardown_db
-  end
-  
-  def test_needed
-    assert BinaryLogic::Searchgasm::Search::Base.needed?(Account, :page => 2, :conditions => {:name => "Ben"})
-    assert !BinaryLogic::Searchgasm::Search::Base.needed?(Account, :conditions => {:name => "Ben"})
-    assert BinaryLogic::Searchgasm::Search::Base.needed?(Account, :limit => 2, :conditions => {:name_contains => "Ben"})
-    assert !BinaryLogic::Searchgasm::Search::Base.needed?(Account, :limit => 2)
-    assert BinaryLogic::Searchgasm::Search::Base.needed?(Account, :per_page => 2)
-  end
-  
-  def test_initialize
-    assert_nothing_raised { BinaryLogic::Searchgasm::Search::Base.new(Account) }
-    search = BinaryLogic::Searchgasm::Search::Base.new(Account, :conditions => {:name_like => "binary"}, :page => 2, :limit => 10, :readonly => true)
-    assert_equal Account, search.klass
-    assert_equal "binary", search.conditions.name_like
-    assert_equal 2, search.page
-    assert_equal 10, search.limit
-    assert_equal true, search.readonly
-  end
-  
-  def test_setting_first_level_options
-    search = BinaryLogic::Searchgasm::Search::Base.new(Account)
-    
-    search.include = :users
-    assert_equal :users, search.include
-    
-    search.joins = "test"
-    assert_equal "test", search.joins
-    
-    search.page = 5
-    assert_equal 1, search.page # haven't set a limit yet
-    assert_equal nil, search.offset
-    
-    search.limit = 20
-    assert_equal search.limit, 20
-    assert_equal search.per_page, 20
-    assert_equal search.page, 5
-    assert_equal search.offset, 100
-    
-    search.offset = 50
-    assert_equal search.offset, 50
-    assert_equal search.page, 3
-    
-    search.per_page = 2
-    assert_equal search.per_page, 2
-    assert_equal search.limit, 2
-    assert_equal search.page, 25
-    assert_equal search.offset, 50
-    
-    search.order = "name ASC"
-    assert_equal search.order, "name ASC"
-    
-    search.select = "name"
-    assert_equal search.select, "name"
-    
-    search.readonly = true
-    assert_equal search.readonly, true
-    
-    search.group = "name"
-    assert_equal search.group, "name"
-    
-    search.from = "accounts"
-    assert_equal search.from, "accounts"
-    
-    search.lock = true
-    assert_equal search.lock, true
-  end
-  
-  def test_conditions
-    search = BinaryLogic::Searchgasm::Search::Base.new(Account)
-    assert_kind_of BinaryLogic::Searchgasm::Search::Conditions, search.conditions
-    assert_equal search.conditions.klass, Account
-    
-    search.conditions = {:name_like => "Binary"}
-    assert_kind_of BinaryLogic::Searchgasm::Search::Conditions, search.conditions
-    
-    conditions = BinaryLogic::Searchgasm::Search::Conditions.new(Account, :id_greater_than => 8)
-    search.conditions = conditions
-    assert_equal conditions, search.conditions
-  end
-  
-  def test_include
-    
-  end
-  
-  def test_limit
-    
-  end
-  
-  def test_options
-    
-  end
-  
-  def test_order_as
-    
-  end
-  
-  def test_order_by
-    
-  end
-  
-  def test_page
-    
-  end
-  
-  def test_sanitize
-    search = BinaryLogic::Searchgasm::Search::Base.new(Account)
-    search.per_page = 2
-    search.conditions.name_like = "Binary"
-    search.conditions.users.id_greater_than = 2
-    search.page = 3
-    search.readonly = true
-    assert_equal search.sanitize, {:include => :users, :offset => 6, :readonly => true, :conditions => ["(\"accounts\".\"name\" LIKE ?) AND (\"users\".\"id\" > ?)", "%Binary%", 2], :limit => 2 }
-  end
-  
-  def test_scope
-    
-  end
-  
-  def test_searching
-    search = BinaryLogic::Searchgasm::Search::Base.new(Account)
-    search.conditions.name_like = "Binary"
-    assert_equal search.all, [Account.find(1), Account.find(3)]
-    assert_equal search.find(:all), [Account.find(1), Account.find(3)]
-    assert_equal search.first, Account.find(1)
-    assert_equal search.find(:first), Account.find(1)
-    
-    search.per_page = 20
-    search.page = 2
-    
-    assert_equal search.all, []
-    assert_equal search.find(:all), []
-    assert_equal search.first, nil
-    assert_equal search.find(:first), nil
-        
-    search.per_page = 0
-    search.page = nil
-    search.conditions.users.first_name_contains = "Ben"
-    search.conditions.users.orders.description_keywords = "products, &*ap#ple $%^&*"
-    assert_equal search.all, [Account.find(1)]
-    assert_equal search.find(:all), [Account.find(1)]
-    assert_equal search.first, Account.find(1)
-    assert_equal search.find(:first), Account.find(1)
-  end
-  
-  def test_calculations
-    search = BinaryLogic::Searchgasm::Search::Base.new(Account)
-    search.conditions.name_like = "Binary"
-    assert_equal 2, search.average('id')
-    assert_equal 2, search.calculate(:avg, 'id')
-    assert_equal 3, search.calculate(:max, 'id')
-    assert_equal 2, search.count
-    assert_equal 3, search.maximum('id')
-    assert_equal 1, search.minimum('id')
-    assert_equal 4, search.sum('id')
-  end
-  
-  def test_protection
-    assert_raise(ArgumentError) { Account.build_search(:conditions => "(DELETE FROM users)", :page => 2, :per_page => 15) }
-    BinaryLogic::Searchgasm::Search::Base::VULNERABLE_OPTIONS.each { |option| assert_raise(ArgumentError) { Account.build_search(option => "(DELETE FROM users)") } }
-    
-    assert_nothing_raised { Account.build_search!(:conditions => "(DELETE FROM users)", :page => 2, :per_page => 15) }
-    BinaryLogic::Searchgasm::Search::Base::VULNERABLE_OPTIONS.each { |option| assert_nothing_raised { Account.build_search!(option => "(DELETE FROM users)") } }
-    
-    account = Account.first
-    
-    assert_raise(ArgumentError) { account.users.build_search(:conditions => "(DELETE FROM users)", :page => 2, :per_page => 15) }
-    BinaryLogic::Searchgasm::Search::Base::VULNERABLE_OPTIONS.each { |option| assert_raise(ArgumentError) { account.users.build_search(option => "(DELETE FROM users)") } }
-    
-    assert_nothing_raised { account.users.build_search!(:conditions => "(DELETE FROM users)", :page => 2, :per_page => 15) }
-    BinaryLogic::Searchgasm::Search::Base::VULNERABLE_OPTIONS.each { |option| assert_nothing_raised { account.users.build_search!(option => "(DELETE FROM users)") } }
-  end
-end