wvanbergen-scoped_search 0.2.0 → 0.3.0

data/CHANGELOG

@@ -0,0 +1,12 @@
+scoped_search 0.3.0
+===================
+- Detection of column types so they can be handled properly
+- Date based queries supported on date and time fields
+
+scoped_search 0.2.0
+===================
+- OR keyword supported in query language
+
+scoped_search 0.1.0
+===================
+- Initial version

data/TODO

@@ -5,15 +5,12 @@ Contact willem AT vanbergen DOT org if you want to help out
 
 New features:
 - Search fields of associations as well
-- Allow other search operators than %LIKE% 
+- Allow smart searches.  Example: "90 days ago", "Yesterday", "10 days from now" 
 
 Refactoring:
-- Create a separate class to build the actual SQL queries.
 - For searchable_on(*fields) make it so that instead of fields it accepts options (a hash) where 
   :only and :except can be values.  That way it is possible for all fields to be loaded except 
   the ones specified with :except.
-- Add checks for field types because the latest version of PostgreSQL (version 8.3.3) is more 
-  strict about searching for strings in columns that are not string types.
 
 Documentation & testing:
 - Put something useful in the wiki

data/lib/scoped_search/query_conditions_builder.rb

@@ -0,0 +1,158 @@
+module ScopedSearch
+  
+  class QueryConditionsBuilder
+
+    # Build the query
+    def self.build_query(search_conditions, query_fields)
+      self.new.build(search_conditions, query_fields)
+    end
+
+    def initialize
+      @query_fields = nil 
+      @query_params = {}
+    end 
+
+
+    # Build the query
+    # 
+    # Hash query_options : A hash of fields and field types.
+    #
+    # Exampe: 
+    # search_conditions = [["Wes", :like], ["Hays", :not], ["Hello World", :like], ["Goodnight Moon", :not], 
+    #                     ["Bob OR Wes", :or], ["Happy cow OR Sad Frog", :or], ["Man made OR Dogs", :or], 
+    #                     ["Cows OR Frog Toys", :or], ['9/28/1980, :datetime]]
+    # query_fields = {:first_name => :string, :created_at => :datetime}
+    # 
+    # Exceptons : 
+    #   1) If urlParams does not contain a :controller key.      
+    def build(search_conditions, query_fields) 
+      raise 'search_conditions must be a hash' unless search_conditions.class.to_s == 'Array'
+      raise 'query_fields must be a hash' unless query_fields.class.to_s == 'Hash'
+      @query_fields = query_fields
+
+      conditions = []
+      
+      search_conditions.each_with_index do |search_condition, index|
+        keyword_name = "keyword_#{index}".to_sym
+        conditions << case search_condition.last
+                        #when :integer: integer_conditions(keyword_name, search_condition.first)
+          
+                        when :like: like_condition(keyword_name, search_condition.first)
+                        when :not: not_like_condition(keyword_name, search_condition.first)
+            
+                        when :or: or_condition(keyword_name, search_condition.first)
+      
+                        when :less_than_date: less_than_date(keyword_name, search_condition.first)      
+                        when :less_than_or_equal_to_date: less_than_or_equal_to_date(keyword_name, search_condition.first)   
+                        when :as_of_date: as_of_date(keyword_name, search_condition.first)      
+                        when :greater_than_date: greater_than_date(keyword_name, search_condition.first) 
+                        when :greater_than_or_equal_to_date: greater_than_or_equal_to_date(keyword_name, search_condition.first)   
+                        
+                        when :between_dates: between_dates(keyword_name, search_condition.first)                                                        
+                      end          
+      end
+
+      [conditions.compact.join(' AND '), @query_params] 
+    end    
+    
+    
+    private 
+    
+    # def integer_condition(keyword_name, value)
+    # end    
+    
+    def like_condition(keyword_name, value)
+      @query_params[keyword_name] = "%#{value}%"
+      retVal = []
+      @query_fields.each do |field, field_type|  #|key,value| 
+        if field_type == :string or field_type == :text
+          retVal << "#{field} LIKE :#{keyword_name.to_s}"
+        end
+      end
+      "(#{retVal.join(' OR ')})"
+    end
+    
+    def not_like_condition(keyword_name, value)
+      @query_params[keyword_name] = "%#{value}%"
+      retVal = []
+      @query_fields.each do |field, field_type|  #|key,value| 
+        if field_type == :string or field_type == :text
+          retVal << "(#{field} NOT LIKE :#{keyword_name.to_s} OR #{field} IS NULL)"
+        end
+      end
+      "(#{retVal.join(' AND ')})"
+    end
+    
+    def or_condition(keyword_name, value)
+      retVal = []
+      word1, word2 = value.split(' OR ')
+      keyword_name_a = "#{keyword_name.to_s}a".to_sym
+      keyword_name_b = "#{keyword_name.to_s}b".to_sym
+      @query_params[keyword_name_a] = "%#{word1}%"
+      @query_params[keyword_name_b] = "%#{word2}%"      
+      @query_fields.each do |field, field_type|  #|key,value| 
+        if field_type == :string or field_type == :text
+          retVal << "(#{field} LIKE :#{keyword_name_a.to_s} OR #{field} LIKE :#{keyword_name_b.to_s})"
+        end
+      end 
+      "(#{retVal.join(' OR ')})"     
+    end
+    
+    def less_than_date(keyword_name, value)
+      helper_date_operation('<', keyword_name, value)     
+    end
+    
+    def less_than_or_equal_to_date(keyword_name, value)
+      helper_date_operation('<=', keyword_name, value)     
+    end    
+    
+    def as_of_date(keyword_name, value)
+      helper_date_operation('=', keyword_name, value)
+    end
+    
+    def greater_than_date(keyword_name, value)
+      helper_date_operation('>', keyword_name, value)
+    end
+    
+    def greater_than_or_equal_to_date(keyword_name, value)
+      helper_date_operation('>=', keyword_name, value)
+    end    
+    
+    def between_dates(keyword_name, value)
+      date1, date2 = value.split(' TO ')      
+      dt1 = Date.parse(date1) # This will throw an exception if it is not valid
+      dt2 = Date.parse(date2) # This will throw an exception if it is not valid
+      keyword_name_a = "#{keyword_name.to_s}a".to_sym
+      keyword_name_b = "#{keyword_name.to_s}b".to_sym 
+      @query_params[keyword_name_a] = dt1.to_s
+      @query_params[keyword_name_b] = dt2.to_s           
+
+      retVal = []
+      @query_fields.each do |field, field_type|  #|key,value| 
+        if field_type == :date or field_type == :datetime or field_type == :timestamp
+          retVal << "(#{field} BETWEEN :#{keyword_name_a.to_s} AND :#{keyword_name_b.to_s})"
+        end
+      end
+      "(#{retVal.join(' OR ')})"  
+    rescue
+      # The date is not valid so just ignore it
+      return nil      
+    end  
+    
+
+    def helper_date_operation(operator, keyword_name, value)
+      dt = Date.parse(value) # This will throw an exception if it is not valid
+      @query_params[keyword_name] = dt.to_s
+      retVal = []
+      @query_fields.each do |field, field_type|  #|key,value| 
+        if field_type == :date or field_type == :datetime or field_type == :timestamp
+          retVal << "#{field} #{operator} :#{keyword_name.to_s}"
+        end
+      end
+      "(#{retVal.join(' OR ')})"  
+    rescue
+      # The date is not valid so just ignore it
+      return nil      
+    end
+  end
+end

data/lib/scoped_search/query_language_parser.rb

@@ -23,38 +23,65 @@ module ScopedSearch
           else
             if /^.+[ ]OR[ ].+$/ =~ item
               conditions_tree << [item, :or]
+            elsif /^#{RegTokens::BetweenDateFormatMMDDYYYY}$/ =~ item or
+                  /^#{RegTokens::BetweenDateFormatYYYYMMDD}$/ =~ item or
+                  /^#{RegTokens::BetweenDatabaseFormat}$/ =~ item
+              conditions_tree << [item, :between_dates]              
+            elsif /^#{RegTokens::GreaterThanOrEqualToDateFormatMMDDYYYY}$/ =~ item or
+                  /^#{RegTokens::GreaterThanOrEqualToDateFormatYYYYMMDD}$/ =~ item or
+                  /^#{RegTokens::GreaterThanOrEqualToDatabaseFormat}$/ =~ item
+              conditions_tree << [item, :greater_than_or_equal_to_date] 
+            elsif /^#{RegTokens::LessThanOrEqualToDateFormatMMDDYYYY}$/ =~ item or
+                  /^#{RegTokens::LessThanOrEqualToDateFormatYYYYMMDD}$/ =~ item or
+                  /^#{RegTokens::LessThanOrEqualToDatabaseFormat}$/ =~ item
+              conditions_tree << [item, :less_than_or_equal_to_date]              
+            elsif /^#{RegTokens::GreaterThanDateFormatMMDDYYYY}$/ =~ item or
+                  /^#{RegTokens::GreaterThanDateFormatYYYYMMDD}$/ =~ item or
+                  /^#{RegTokens::GreaterThanDatabaseFormat}$/ =~ item
+              conditions_tree << [item, :greater_than_date] 
+            elsif /^#{RegTokens::LessThanDateFormatMMDDYYYY}$/ =~ item or
+                  /^#{RegTokens::LessThanDateFormatYYYYMMDD}$/ =~ item or
+                  /^#{RegTokens::LessThanDatabaseFormat}$/ =~ item
+              conditions_tree << [item, :less_than_date]                           
+            elsif /^#{RegTokens::DateFormatMMDDYYYY}$/ =~ item or
+                  /^#{RegTokens::DateFormatYYYYMMDD}$/ =~ item or
+                  /^#{RegTokens::DatabaseFormat}$/ =~ item
+              conditions_tree << [item, :as_of_date]
             else
               conditions_tree << (negate ? [item, :not] : [item, :like])
               negate = false
             end
         end
       end
+      
       return conditions_tree
     end
-  
-    # **Patterns**
-    # Each pattern is sperated by a "|".  With regular expressions the order of the expression does matter.
-    #
-    # ([\w]+[ ]OR[ ][\w]+)
-    # ([\w]+[ ]OR[ ]["][\w ]+["])
-    # (["][\w ]+["][ ]OR[ ][\w]+)
-    # (["][\w ]+["][ ]OR[ ]["][\w ]+["])
-    #   Any two combinations of letters, numbers and underscores that are seperated by " OR " (a single space must 
-    #   be on each side of the "OR"). 
-    #   THESE COULD BE COMBINED BUT BECAUSE OF THE WAY PARSING WORKS THIS IS NOT DONE ON PURPOSE!!
-    #
-    # ([-]?[\w]+) 
-    #   Any combination of letters, numbers and underscores that may or may not have a dash in front.
-    # 
-    # ([-]?["][\w ]+["])
-    #   Any combination of letters, numbers, underscores and spaces within double quotes that may or may not have a dash in front.
+    
     def tokenize(query)
-      pattern = ['([\w]+[ ]OR[ ][\w]+)',
-                 '([\w]+[ ]OR[ ]["][\w ]+["])',
-                 '(["][\w ]+["][ ]OR[ ][\w]+)',
-                 '(["][\w ]+["][ ]OR[ ]["][\w ]+["])',
-                 '([-]?[\w]+)',
-                 '([-]?["][\w ]+["])']
+      pattern = [RegTokens::BetweenDateFormatMMDDYYYY,
+                 RegTokens::BetweenDateFormatYYYYMMDD,
+                 RegTokens::BetweenDatabaseFormat,
+                 RegTokens::GreaterThanOrEqualToDateFormatMMDDYYYY,
+                 RegTokens::GreaterThanOrEqualToDateFormatYYYYMMDD,
+                 RegTokens::GreaterThanOrEqualToDatabaseFormat,
+                 RegTokens::LessThanOrEqualToDateFormatMMDDYYYY,
+                 RegTokens::LessThanOrEqualToDateFormatYYYYMMDD,
+                 RegTokens::LessThanOrEqualToDatabaseFormat,
+                 RegTokens::GreaterThanDateFormatMMDDYYYY,
+                 RegTokens::GreaterThanDateFormatYYYYMMDD,
+                 RegTokens::GreaterThanDatabaseFormat,
+                 RegTokens::LessThanDateFormatMMDDYYYY,
+                 RegTokens::LessThanDateFormatYYYYMMDD,
+                 RegTokens::LessThanDatabaseFormat,
+                 RegTokens::DateFormatMMDDYYYY,
+                 RegTokens::DateFormatYYYYMMDD,
+                 RegTokens::DatabaseFormat,           
+                 RegTokens::WordOrWord,
+                 RegTokens::WordOrString,
+                 RegTokens::StringOrWord,
+                 RegTokens::StringOrString,
+                 RegTokens::PossiblyNegatedWord,
+                 RegTokens::PossiblyNegatedString]               
       pattern = Regexp.new(pattern.join('|'))
       
       tokens = []

data/lib/scoped_search/reg_tokens.rb

@@ -0,0 +1,51 @@
+# Regular expression tokens to be used for parsing.
+module RegTokens
+   
+  WORD = '[\w]+'
+  SPACE = '[ ]'
+  STRING = '["][\w ]+["]'
+  OR = 'OR'
+  POSSIBLY_NEGATED = '[-]?'
+  MONTH = '[\d]{1,2}'
+  DAY = '[\d]{1,2}'
+  FULL_YEAR = '[\d]{4}'
+  LESS_THAN = '[<][ ]'
+  GREATER_THAN = '[>][ ]'
+  LESS_THAN_OR_EQUAL_TO = '[<][=][ ]'
+  GREATER_THAN_OR_EQUAL_TO = '[>][=][ ]'
+  TO = 'TO'
+
+  WordOrWord = "(#{WORD}#{SPACE}#{OR}#{SPACE}#{WORD})"
+  WordOrString = "(#{WORD}#{SPACE}#{OR}#{SPACE}#{STRING})"
+  StringOrWord = "(#{STRING}#{SPACE}#{OR}#{SPACE}#{WORD})"
+  StringOrString = "(#{STRING}#{SPACE}#{OR}#{SPACE}#{STRING})"
+  PossiblyNegatedWord = "(#{POSSIBLY_NEGATED}#{WORD})"
+  PossiblyNegatedString = "(#{POSSIBLY_NEGATED}#{STRING})"
+  
+  DateFormatMMDDYYYY = "(#{MONTH}/#{DAY}/#{FULL_YEAR})"  # This would be the same for DD/MM/YYYY
+  DateFormatYYYYMMDD = "(#{FULL_YEAR}/#{MONTH}/#{DAY})" 
+  DatabaseFormat = "(#{FULL_YEAR}-#{MONTH}-#{DAY})"
+  
+  LessThanDateFormatMMDDYYYY = "(#{LESS_THAN}#{MONTH}/#{DAY}/#{FULL_YEAR})" 
+  LessThanDateFormatYYYYMMDD = "(#{LESS_THAN}#{FULL_YEAR}/#{MONTH}/#{DAY})" 
+  LessThanDatabaseFormat = "(#{LESS_THAN}#{FULL_YEAR}-#{MONTH}-#{DAY})"  
+  
+  GreaterThanDateFormatMMDDYYYY = "(#{GREATER_THAN}#{MONTH}/#{DAY}/#{FULL_YEAR})"  
+  GreaterThanDateFormatYYYYMMDD = "(#{GREATER_THAN}#{FULL_YEAR}/#{MONTH}/#{DAY})" 
+  GreaterThanDatabaseFormat = "(#{GREATER_THAN}#{FULL_YEAR}-#{MONTH}-#{DAY})"  
+  
+  LessThanOrEqualToDateFormatMMDDYYYY = "(#{LESS_THAN_OR_EQUAL_TO}#{MONTH}/#{DAY}/#{FULL_YEAR})" 
+  LessThanOrEqualToDateFormatYYYYMMDD = "(#{LESS_THAN_OR_EQUAL_TO}#{FULL_YEAR}/#{MONTH}/#{DAY})" 
+  LessThanOrEqualToDatabaseFormat = "(#{LESS_THAN_OR_EQUAL_TO}#{FULL_YEAR}-#{MONTH}-#{DAY})"  
+  
+  GreaterThanOrEqualToDateFormatMMDDYYYY = "(#{GREATER_THAN_OR_EQUAL_TO}#{MONTH}/#{DAY}/#{FULL_YEAR})"  
+  GreaterThanOrEqualToDateFormatYYYYMMDD = "(#{GREATER_THAN_OR_EQUAL_TO}#{FULL_YEAR}/#{MONTH}/#{DAY})" 
+  GreaterThanOrEqualToDatabaseFormat = "(#{GREATER_THAN_OR_EQUAL_TO}#{FULL_YEAR}-#{MONTH}-#{DAY})"  
+  
+  BetweenDateFormatMMDDYYYY = "(#{MONTH}/#{DAY}/#{FULL_YEAR}#{SPACE}#{TO}#{SPACE}#{MONTH}/#{DAY}/#{FULL_YEAR})"
+  BetweenDateFormatYYYYMMDD = "(#{FULL_YEAR}/#{MONTH}/#{DAY}#{SPACE}#{TO}#{SPACE}#{FULL_YEAR}/#{MONTH}/#{DAY})" 
+  BetweenDatabaseFormat = "(#{FULL_YEAR}-#{MONTH}-#{DAY}#{SPACE}#{TO}#{SPACE}#{FULL_YEAR}-#{MONTH}-#{DAY})"
+end
+      
+      
+      

data/lib/scoped_search.rb

@@ -3,7 +3,9 @@ module ScopedSearch
   module ClassMethods
   
     def self.extended(base)
+      require 'scoped_search/reg_tokens'
       require 'scoped_search/query_language_parser'
+      require 'scoped_search/query_conditions_builder'
     end
   
     # Creates a named scope in the class it was called upon
@@ -16,49 +18,19 @@ module ScopedSearch
     # Build a hash that is used for the named_scope search_for.
     # This function will split the search_string into keywords, and search for all the keywords
     # in the fields that were provided to searchable_on
-    def build_scoped_search_conditions(search_string)
+    def build_scoped_search_conditions(search_string)    
       if search_string.nil? || search_string.strip.blank?
-        return { :conditions => nil }
-      else
-        conditions = []
-        query_params = {}
-      
-        QueryLanguageParser.parse(search_string).each_with_index do |search_condition, index|
-          keyword_name = "keyword_#{index}".to_sym
-          query_params[keyword_name] = "%#{search_condition.first}%" 
-
-          # a keyword may be found in any of the provided fields, so join the conitions with OR
-          if search_condition.length == 2 && search_condition.last == :not
-            keyword_conditions = self.scoped_search_fields.map do |field| 
-              field_name = connection.quote_table_name(table_name) + "." + connection.quote_column_name(field)
-              "(#{field_name} NOT LIKE :#{keyword_name.to_s} OR #{field_name} IS NULL)"
-            end
-            conditions << "(#{keyword_conditions.join(' AND ')})" 
-          elsif search_condition.length == 2 && search_condition.last == :or
-            word1, word2 = query_params[keyword_name].split(' OR ')
-            
-            query_params.delete(keyword_name)
-            keyword_name_a = "#{keyword_name.to_s}a".to_sym
-            keyword_name_b = "#{keyword_name.to_s}b".to_sym
-            query_params[keyword_name_a] = word1
-            query_params[keyword_name_b] = word2
-            
-            keyword_conditions = self.scoped_search_fields.map do |field| 
-              field_name = connection.quote_table_name(table_name) + "." + connection.quote_column_name(field)
-              "(#{field_name} LIKE :#{keyword_name_a.to_s} OR #{field_name} LIKE :#{keyword_name_b.to_s})"
-            end
-            conditions << "(#{keyword_conditions.join(' OR ')})"            
-          else
-            keyword_conditions = self.scoped_search_fields.map do |field| 
-              field_name = connection.quote_table_name(table_name) + "." + connection.quote_column_name(field)
-              "#{field_name} LIKE :#{keyword_name.to_s}"
-            end
-            conditions << "(#{keyword_conditions.join(' OR ')})"
-          end       
+        return {:conditions => nil}
+      else        
+        query_fields = {}
+        self.scoped_search_fields.each do |field| 
+          field_name = connection.quote_table_name(table_name) + "." + connection.quote_column_name(field)
+          query_fields[field_name] = self.columns_hash[field.to_s].type
         end
-      
-        # all keywords must be matched, so join the conditions with AND
-        return { :conditions => [conditions.join(' AND '), query_params] }
+        
+        search_conditions = QueryLanguageParser.parse(search_string) 
+        conditions = QueryConditionsBuilder.build_query(search_conditions, query_fields) 
+        return {:conditions => conditions}
       end
     end
   end

data/test/query_conditions_builder_test.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class QueryConditionsBuilderTest < Test::Unit::TestCase
+
+  # change this function if you switch to another query language parser
+  def build_query(search_conditions, query_fields)    
+    ScopedSearch::QueryConditionsBuilder.build_query(search_conditions, query_fields)
+  end
+  
+  # ** Single query search tests **
+  def test_like_search_condition
+    search_conditions = [["Wes", :like]]
+    query_fields = {'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+    
+    assert_equal '(some_table.first_name LIKE :keyword_0)', conditions.first
+    assert_equal '%Wes%', conditions.last[:keyword_0]
+  end
+  
+  def test_not_like_search_condition
+    search_conditions = [["Wes", :not]]
+    query_fields = {'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '((some_table.first_name NOT LIKE :keyword_0 OR some_table.first_name IS NULL))', conditions.first
+    assert_equal '%Wes%', conditions.last[:keyword_0]
+  end  
+  
+  def test_or_search_condition
+    search_conditions = [["Wes OR Hays", :or]]
+    query_fields = {'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+    regExs = build_regex_for_or(['first_name'], 'keyword_0')
+    assert_match /^#{regExs}$/, conditions.first
+    assert_equal '%Wes%', conditions.last[:keyword_0a]
+    assert_equal '%Hays%', conditions.last[:keyword_0b]
+  end
+  
+  # def test_date_search_condition
+  #   search_conditions = [["09/27/1980", :as_of_date]]
+  #   query_fields = {'some_table.event_date' => :datetime}    
+  #   conditions = build_query(search_conditions, query_fields) 
+  #   regExs = build_regex_for_date(['event_date'], 'keyword_0')
+  #   assert_match /^#{regExs}$/, conditions.first
+  #   assert_equal '09/27/1980', conditions.last[:keyword_0a]
+  # end  
+  
+    
+  # ** Multi query search tests **
+  def test_like_two_search_condition
+    search_conditions = [["Wes", :like],["Hays", :like]]
+    query_fields = {'some_table.first_name' => :string,'some_table.last_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    fields = ['first_name','last_name']
+    regExs = [build_regex_for_like(fields,'keyword_0'), 
+              build_regex_for_like(fields,'keyword_1')].join('[ ]AND[ ]')
+  
+    assert_match /^#{regExs}$/, conditions.first
+    assert_equal '%Wes%', conditions.last[:keyword_0]
+    assert_equal '%Hays%', conditions.last[:keyword_1]
+  end  
+  
+  def test_like_two_search_conditions_with_one_not
+    search_conditions = [["Wes", :like],["Hays", :not]]
+    query_fields = {'some_table.first_name' => :string,'some_table.last_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    fields = ['first_name','last_name']
+    regExs = [build_regex_for_like(fields,'keyword_0'), 
+              build_regex_for_not_like(fields,'keyword_1')].join('[ ]AND[ ]')
+  
+    assert_match /^#{regExs}$/, conditions.first
+    assert_equal '%Wes%', conditions.last[:keyword_0]
+    assert_equal '%Hays%', conditions.last[:keyword_1]
+  end  
+  
+  
+  
+  # ** Helper methods **
+  def build_regex_for_like(fields,keyword)
+    orFields = fields.join('|')
+    regParts = fields.collect { |field| 
+                 "some_table.(#{orFields}) LIKE :#{keyword}" 
+               }.join('[ ]OR[ ]')  
+    "[\(]#{regParts}[\)]"  
+  end
+  
+  def build_regex_for_not_like(fields,keyword)
+    orFields = fields.join('|')
+    regParts = fields.collect { |field| 
+                 "[\(]some_table.(#{orFields}) NOT LIKE :#{keyword} OR some_table.(#{orFields}) IS NULL[\)]" 
+               }.join('[ ]AND[ ]')
+    
+    "[\(]#{regParts}[\)]"
+  end  
+  
+  def build_regex_for_or(fields,keyword)
+    orFields = fields.join('|')
+    regParts = fields.collect { |field| 
+                 "[\(]some_table.(#{orFields}) LIKE :#{keyword}a OR some_table.(#{orFields}) LIKE :#{keyword}b[\)]" 
+               }.join('[ ]OR[ ]')
+    
+    "[\(]#{regParts}[\)]"
+  end  
+  
+  def build_regex_for_date(fields,keyword)
+    orFields = fields.join('|')
+    regParts = fields.collect { |field| 
+                 "some_table.(#{orFields}) = :#{keyword}" 
+               }.join('[ ]OR[ ]')  
+    "[\(]#{regParts}[\)]"  
+  end  
+end

data/test/query_language_test.rb

@@ -51,7 +51,7 @@ class QueryLanguageTest < Test::Unit::TestCase
     assert_equal 2, parsed.length
     assert_equal 'hallo',  parsed[0].first
     assert_equal 'willem', parsed[1].first
-
+  
     parsed = parse_query('  "hallo   wi"llem"')
     assert_equal 2, parsed.length
     assert_equal 'hallo wi', parsed[0].first
@@ -108,6 +108,28 @@ class QueryLanguageTest < Test::Unit::TestCase
     assert_equal :or, parsed[0][1]        
   end 
   
+  def test_as_of_date
+    # parsed = parse_query('9/27/1980')
+    # assert_equal 1, parsed.length
+    # assert_equal '9/27/1980', parsed[0][0]
+    # assert_equal :as_of, parsed[0][1]
+   
+    # parsed = parse_query('"Man made" OR Dogs')
+    # assert_equal 1, parsed.length
+    # assert_equal 'Man made OR Dogs', parsed[0][0]
+    # assert_equal :or, parsed[0][1]    
+    # 
+    # parsed = parse_query('Cows OR "Frog Toys"')
+    # assert_equal 1, parsed.length
+    # assert_equal 'Cows OR Frog Toys', parsed[0][0]
+    # assert_equal :or, parsed[0][1]
+    # 
+    # parsed = parse_query('"Happy cow" OR "Sad Frog"')
+    # assert_equal 1, parsed.length
+    # assert_equal 'Happy cow OR Sad Frog', parsed[0][0]
+    # assert_equal :or, parsed[0][1]        
+  end  
+  
   def test_long_string
     str = 'Wes -Hays "Hello World" -"Goodnight Moon" Bob OR Wes "Happy cow" OR "Sad Frog" "Man made" OR Dogs Cows OR "Frog Toys"'
     parsed = parse_query(str)

data/test/search_for_test.rb

@@ -11,31 +11,55 @@ class ScopedSearchTest < Test::Unit::TestCase
     teardown_db
   end
   
-  def test_enabling
-    assert !SearchTestModel.respond_to?(:search_for)
-    SearchTestModel.searchable_on :string_field, :text_field
-    assert SearchTestModel.respond_to?(:search_for)
-    
-    assert_equal ActiveRecord::NamedScope::Scope, SearchTestModel.search_for('test').class
-    
-  end
-  
+  # def test_enabling
+  #   assert !SearchTestModel.respond_to?(:search_for)
+  #   SearchTestModel.searchable_on :string_field, :text_field, :date_field
+  #   assert SearchTestModel.respond_to?(:search_for)
+  #   
+  #   assert_equal ActiveRecord::NamedScope::Scope, SearchTestModel.search_for('test').class
+  # end
+  # 
   def test_search
-    SearchTestModel.searchable_on :string_field, :text_field
+    SearchTestModel.searchable_on :string_field, :text_field, :date_field
     
-    assert_equal 15, SearchTestModel.search_for('').count
+    assert_equal 16, SearchTestModel.search_for('').count
     assert_equal 0, SearchTestModel.search_for('456').count   
     assert_equal 2, SearchTestModel.search_for('hays').count 
     assert_equal 1, SearchTestModel.search_for('hay ob').count        
-    assert_equal 13, SearchTestModel.search_for('o').count    
+    assert_equal 14, SearchTestModel.search_for('o').count    
     assert_equal 2, SearchTestModel.search_for('-o').count
-    assert_equal 13, SearchTestModel.search_for('-Jim').count
+    assert_equal 14, SearchTestModel.search_for('-Jim').count
     assert_equal 1, SearchTestModel.search_for('Jim -Bush').count
     assert_equal 1, SearchTestModel.search_for('"Hello World" -"Goodnight Moon"').count    
     assert_equal 2, SearchTestModel.search_for('Wes OR Bob').count
     assert_equal 3, SearchTestModel.search_for('"Happy cow" OR "Sad Frog"').count
     assert_equal 3, SearchTestModel.search_for('"Man made" OR Dogs').count
     assert_equal 2, SearchTestModel.search_for('Cows OR "Frog Toys"').count   
+    
+    # ** DATES **   
+    #
+    # The next two dates are invalid therefore it will be ignored.  
+    # Thus it would be the same as searching for an empty string
+    assert_equal 16, SearchTestModel.search_for('2/30/1980').count 
+    assert_equal 16, SearchTestModel.search_for('99/99/9999').count
+
+    assert_equal 1, SearchTestModel.search_for('9/27/1980').count
+    assert_equal 1, SearchTestModel.search_for('hays 9/27/1980').count
+    assert_equal 2, SearchTestModel.search_for('hays 2/30/1980').count    
+    assert_equal 1, SearchTestModel.search_for('2006/07/15').count
+    
+    assert_equal 1, SearchTestModel.search_for('< 12/01/1980').count    
+    assert_equal 5, SearchTestModel.search_for('> 1/1/2006').count
+    
+    assert_equal 5, SearchTestModel.search_for('< 12/26/2002').count 
+    assert_equal 6, SearchTestModel.search_for('<= 12/26/2002').count   
+    
+    assert_equal 5, SearchTestModel.search_for('> 2/5/2005').count 
+    assert_equal 6, SearchTestModel.search_for('>= 2/5/2005').count   
+    
+    assert_equal 3, SearchTestModel.search_for('1/1/2005 TO 1/1/2007').count 
+
+    assert_equal 2, SearchTestModel.search_for('Happy 1/1/2005 TO 1/1/2007').count 
   end
 
 end

data/test/test_helper.rb

@@ -1,6 +1,7 @@
 require 'test/unit'
 require 'rubygems'
 require 'active_record'
+require 'ruby-debug'
 
 require "#{File.dirname(__FILE__)}/../lib/scoped_search"
 
@@ -11,6 +12,7 @@ def setup_db
       t.string :string_field
       t.text :text_field
       t.string :ignored_field
+      t.date :date_field
       t.timestamps
     end
   end
@@ -22,20 +24,21 @@ end
 
 class SearchTestModel < ActiveRecord::Base
   def self.create_corpus!
-    create!(:string_field => "Programmer 123", :text_field => nil,               :ignored_field => "123456")    
-    create!(:string_field => "Jim",            :text_field => "Henson",          :ignored_field => "123456a")   
-    create!(:string_field => "Jim",            :text_field => "Bush",            :ignored_field => "123456b")    
-    create!(:string_field => "Wes",            :text_field => "Hays",            :ignored_field => "123456c")  
-    create!(:string_field => "Bob",            :text_field => "Hays",            :ignored_field => "123456d")  
-    create!(:string_field => "Dogs",           :text_field => "Pit Bull",        :ignored_field => "123456e") 
-    create!(:string_field => "Dogs",           :text_field => "Eskimo",          :ignored_field => "123456f")
-    create!(:string_field => "Cows",           :text_field => "Farms",           :ignored_field => "123456g")
-    create!(:string_field => "Hello World",    :text_field => "Hello Moon",      :ignored_field => "123456h")   
-    create!(:string_field => "Hello World",    :text_field => "Goodnight Moon",  :ignored_field => "123456i")
-    create!(:string_field => "Happy Cow",      :text_field => "Sad Cow",         :ignored_field => "123456j")
-    create!(:string_field => "Happy Frog",     :text_field => "Sad Frog",        :ignored_field => "123456k")
-    create!(:string_field => "Excited Frog",   :text_field => "Sad Frog",        :ignored_field => "123456l")    
-    create!(:string_field => "Man made",       :text_field => "Woman made",      :ignored_field => "123456m")
-    create!(:string_field => "Cat Toys",       :text_field => "Frog Toys",       :ignored_field => "123456n") 
+    create!(:string_field => "Programmer 123", :text_field => nil,              :ignored_field => "123456",  :date_field => '2000-01-01')    
+    create!(:string_field => "Jim",            :text_field => "Henson",         :ignored_field => "123456a", :date_field => '2001-04-15')   
+    create!(:string_field => "Jim",            :text_field => "Bush",           :ignored_field => "123456b", :date_field => '2001-04-17')    
+    create!(:string_field => "Wes",            :text_field => "Hays",           :ignored_field => "123456c", :date_field => '1980-09-27')  
+    create!(:string_field => "Bob",            :text_field => "Hays",           :ignored_field => "123456d", :date_field => '2002-11-09')  
+    create!(:string_field => "Dogs",           :text_field => "Pit Bull",       :ignored_field => "123456e", :date_field => '2002-12-26') 
+    create!(:string_field => "Dogs",           :text_field => "Eskimo",         :ignored_field => "123456f", :date_field => '2003-03-19')
+    create!(:string_field => "Cows",           :text_field => "Farms",          :ignored_field => "123456g", :date_field => '2004-05-01')
+    create!(:string_field => "Hello World",    :text_field => "Hello Moon",     :ignored_field => "123456h", :date_field => '2004-07-11')   
+    create!(:string_field => "Hello World",    :text_field => "Goodnight Moon", :ignored_field => "123456i", :date_field => '2004-09-12')
+    create!(:string_field => "Happy Cow",      :text_field => "Sad Cow",        :ignored_field => "123456j", :date_field => '2005-02-05')
+    create!(:string_field => "Happy Frog",     :text_field => "Sad Frog",       :ignored_field => "123456k", :date_field => '2006-03-09')
+    create!(:string_field => "Excited Frog",   :text_field => "Sad Frog",       :ignored_field => "123456l", :date_field => '2006-07-15')    
+    create!(:string_field => "Man made",       :text_field => "Woman made",     :ignored_field => "123456m", :date_field => '2007-06-13')
+    create!(:string_field => "Cat Toys",       :text_field => "Frog Toys",      :ignored_field => "123456n", :date_field => '2008-03-04') 
+    create!(:string_field => "Happy Toys",     :text_field => "Sad Toys",       :ignored_field => "123456n", :date_field => '2008-05-12')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wvanbergen-scoped_search
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-13 00:00:00 -07:00
+date: 2008-09-21 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,6 +25,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- CHANGELOG
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -33,8 +34,11 @@ files:
 - lib
 - lib/scoped_search
 - lib/scoped_search.rb
+- lib/scoped_search/query_conditions_builder.rb
 - lib/scoped_search/query_language_parser.rb
+- lib/scoped_search/reg_tokens.rb
 - test
+- test/query_conditions_builder_test.rb
 - test/query_language_test.rb
 - test/search_for_test.rb
 - test/tasks.rake
@@ -66,5 +70,6 @@ signing_key:
 specification_version: 2
 summary: A Rails plugin to search your models using a named_scope
 test_files: 
+- test/query_conditions_builder_test.rb
 - test/query_language_test.rb
 - test/search_for_test.rb