wvanbergen-scoped_search 0.1.3 → 0.2.0

data/TODO

@@ -3,12 +3,18 @@ TODO items for named_scope
 Contact willem AT vanbergen DOT org if you want to help out
 
 
-New functionality:
-- Search model associations as well
-- Allow OR-queries
+New features:
+- Search fields of associations as well
+- Allow other search operators than %LIKE% 
 
 Refactoring:
-- Better separation of query building and query string parser
+- 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.
 
-Testing:
-- More tests for the query string parser
+Documentation & testing:
+- Put something useful in the wiki
+- Add rdoc en comments to code

data/lib/scoped_search/query_language_parser.rb

@@ -18,63 +18,53 @@ module ScopedSearch
       negate = false
       tokens.each do |item|
         case item
-        when :not
-          negate = true
-        else
-          conditions_tree << (negate ? [item, :not] : [item, :like])
-          negate = false
+          when :not
+            negate = true
+          else
+            if /^.+[ ]OR[ ].+$/ =~ item
+              conditions_tree << [item, :or]
+            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)
-      tokens = []
-      current_token = ""
-      quoted_string_openend = false
-    
-      query.each_char do |char|
-      
-        case char
-        when /\s/
-          if quoted_string_openend
-            current_token << char
-          elsif current_token.length > 0
-            tokens << current_token
-            current_token = ""
-          end
-      
-        when '-'
-          if quoted_string_openend || current_token.length > 0
-            current_token << char
-          else
-            tokens << :not
-          end
-        
-        when '"'
-          if quoted_string_openend
-            if current_token.length > 0
-              if current_token[-1,1] == "\\"
-                current_token[-1] = char
-              else
-                tokens << current_token
-                current_token = ""
-                quoted_string_openend = false
-              end
-            else 
-              quoted_string_openend = false
-            end
-
-          else
-            quoted_string_openend = true
-          end
-        
-        else
-          current_token << char
-        end
+      pattern = ['([\w]+[ ]OR[ ][\w]+)',
+                 '([\w]+[ ]OR[ ]["][\w ]+["])',
+                 '(["][\w ]+["][ ]OR[ ][\w]+)',
+                 '(["][\w ]+["][ ]OR[ ]["][\w ]+["])',
+                 '([-]?[\w]+)',
+                 '([-]?["][\w ]+["])']
+      pattern = Regexp.new(pattern.join('|'))
       
-      end
-      tokens << current_token if current_token.length > 0
+      tokens = []
+      matches = query.scan(pattern).flatten.compact
+      matches.each { |match|
+        tokens << :not unless match.index('-').nil?
+        # Remove any escaped quotes and any dashes - the dash usually the first character.
+        # Remove any additional spaces - more that one.
+        tokens << match.gsub(/[-"]/,'').gsub(/[ ]{2,}/, ' ')
+      }
       return tokens
     end
   end

data/lib/scoped_search.rb

@@ -34,17 +34,31 @@ module ScopedSearch
               "(#{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
+          end       
         end
       
         # all keywords must be matched, so join the conditions with AND
-        return { :conditions => [conditions.join(' AND '), query_params] } 
+        return { :conditions => [conditions.join(' AND '), query_params] }
       end
     end
   end

data/test/query_language_test.rb

@@ -19,7 +19,7 @@ class QueryLanguageTest < Test::Unit::TestCase
     parsed = parse_query('hallo')
     assert_equal 1, parsed.length
     assert_equal 'hallo', parsed.first.first
-
+  
     parsed = parse_query('  hallo  ')
     assert_equal 1, parsed.length
     assert_equal 'hallo', parsed.first.first
@@ -45,40 +45,96 @@ class QueryLanguageTest < Test::Unit::TestCase
     
     parsed = parse_query('  "hallo   willem"')
     assert_equal 1, parsed.length
-    assert_equal 'hallo   willem', parsed.first.first
-    
+    assert_equal 'hallo willem', parsed.first.first
+     
     parsed = parse_query('  "hallo   willem')
-    assert_equal 1, parsed.length
-    assert_equal 'hallo   willem', parsed.first.first
-    
+    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.first.first
-    assert_equal 'llem', parsed.last.first
+    assert_equal 'hallo wi', parsed[0].first
+    assert_equal 'llem',       parsed[1].first
   end
   
   def test_quote_escaping
     parsed = parse_query('  "hallo   wi\\"llem"')
-    assert_equal 1, parsed.length
-    assert_equal 'hallo   wi"llem', parsed.first.first
+    assert_equal 3, parsed.length  
+    assert_equal 'hallo', parsed[0].first
+    assert_equal 'wi',    parsed[1].first
+    assert_equal 'llem',  parsed[2].first
   
     parsed = parse_query('"\\"hallo willem\\""')
-    assert_equal 1, parsed.length
-    assert_equal '"hallo willem"', parsed.first.first
+    assert_equal 2, parsed.length
+    assert_equal 'hallo',  parsed[0].first
+    assert_equal 'willem', parsed[1].first
   end
-
+  
   def test_negation
     parsed = parse_query('-willem')
     assert_equal 1, parsed.length
-    assert_equal 'willem', parsed.first.first
-    assert_equal :not, parsed.first.last
+    assert_equal 'willem', parsed[0].first
+    assert_equal :not,     parsed[0].last
   
     parsed = parse_query('123 -"456 789"')
     assert_equal 2, parsed.length
-    assert_equal '123', parsed.first.first
-    assert_equal :like, parsed.first.last    
+    assert_equal '123', parsed[0].first
+    assert_equal :like, parsed[0].last    
+    
+    assert_equal '456 789', parsed[1].first
+    assert_equal :not,      parsed[1].last
+  end
+  
+  def test_or
+    parsed = parse_query('Wes OR Hays')
+    assert_equal 1, parsed.length
+    assert_equal 'Wes OR Hays', parsed[0][0]
+    assert_equal :or, 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)
+    assert_equal 8, parsed.length
+    
+    assert_equal 'Wes', parsed[0].first
+    assert_equal :like,   parsed[0].last
+    
+    assert_equal 'Hays', parsed[1].first
+    assert_equal :not,   parsed[1].last
+    
+    assert_equal 'Hello World', parsed[2].first
+    assert_equal :like, parsed[2].last
+    
+    assert_equal 'Goodnight Moon', parsed[3].first
+    assert_equal :not, parsed[3].last      
+    
+    assert_equal 'Bob OR Wes', parsed[4].first
+    assert_equal :or,   parsed[4].last    
+    
+    assert_equal 'Happy cow OR Sad Frog', parsed[5].first
+    assert_equal :or,   parsed[5].last
+    
+    assert_equal 'Man made OR Dogs', parsed[6].first
+    assert_equal :or,   parsed[6].last
     
-    assert_equal '456 789', parsed.last.first
-    assert_equal :not, parsed.last.last
+    assert_equal 'Cows OR Frog Toys', parsed[7].first
+    assert_equal :or,   parsed[7].last                  
   end
 end

data/test/search_for_test.rb

@@ -23,16 +23,19 @@ class ScopedSearchTest < Test::Unit::TestCase
   def test_search
     SearchTestModel.searchable_on :string_field, :text_field
     
-    assert_equal 3, SearchTestModel.search_for('123').count
-    assert_equal 3, SearchTestModel.search_for('haLL').count
-    assert_equal 1, SearchTestModel.search_for('456').count    
-    assert_equal 2, SearchTestModel.search_for('ha 23').count        
-    assert_equal 0, SearchTestModel.search_for('wi').count 
-    
-    assert_equal 1, SearchTestModel.search_for('-hallo').count
-    assert_equal 4, SearchTestModel.search_for('-wi').count
-    assert_equal 3, SearchTestModel.search_for('-789').count    
-    assert_equal 2, SearchTestModel.search_for('123 -456').count
+    assert_equal 15, 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 2, SearchTestModel.search_for('-o').count
+    assert_equal 13, 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   
   end
 
 end

data/test/test_helper.rb

@@ -22,9 +22,20 @@ end
 
 class SearchTestModel < ActiveRecord::Base
   def self.create_corpus!
-    create!(:string_field => "123", :text_field => "Hallo",     :ignored_field => "123 willem")
-    create!(:string_field => "456", :text_field => "Hallo 123", :ignored_field => "123")
-    create!(:string_field => "789", :text_field => "HALLO",     :ignored_field => "123456");
-    create!(:string_field => "123", :text_field => nil,         :ignored_field => "123456");
+    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") 
   end
 end

metadata

@@ -1,20 +1,23 @@
 --- !ruby/object:Gem::Specification 
 name: wvanbergen-scoped_search
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors: 
 - Willem van Bergen
+- Wes Hays
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-09-06 00:00:00 -07:00
+date: 2008-09-13 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
 description: Scoped search makes it easy to search your ActiveRecord-based models. It will create a named scope according to a provided query string. The named_scope can be used like any other named_scope, so it can be cchained or combined with will_paginate.
-email: willem@vanbergen.org
+email: 
+- willem@vanbergen.org
+- weshays@gbdev.com
 executables: []
 
 extensions: []