gbdev-scoped_search 0.2.0 → 0.3.0

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.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/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/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: gbdev-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: []