jnewland-scoped_search 0.7.1

data/lib/scoped_search/query_language_parser.rb

@@ -0,0 +1,100 @@
+module ScopedSearch
+  
+  class QueryLanguageParser
+    
+    def parse_query(query = nil)
+      return build_conditions_tree(tokenize(query))
+    end
+    
+    def self.parse(query)
+      self.new.parse_query(query)
+    end
+    
+    protected
+  
+    def build_conditions_tree(tokens)
+      conditions_tree = []
+    
+      negate = false
+      tokens.each do |item|
+        case item
+          when :not
+            negate = true
+          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
+    
+    def tokenize(query)
+      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 = []
+      matches = query.scan(pattern).flatten.compact
+      matches.each { |match|
+        tokens << :not if match.index('-') == 0
+        # Remove any escaped quotes
+        # Remove any dashes preceded by a space or at the beginning of a token
+        # Remove any additional spaces - more that one.
+        cleaned_token = match.gsub(/"/,'').gsub(/^-| -/,'').gsub(/[ ]{2,}/, ' ')
+        tokens << cleaned_token if cleaned_token.length > 0
+      }
+      return tokens
+    end
+  end
+end

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/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

@@ -0,0 +1,172 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class QueryLanguageTest < Test::Unit::TestCase
+
+  # change this function if you switch to another query language parser
+  def parse_query(query)
+    ScopedSearch::QueryLanguageParser.parse(query)
+  end
+  
+  def test_empty_search_query
+    parsed = parse_query('')
+    assert_equal 0, parsed.length    
+    
+    parsed = parse_query("\t  \n")
+    assert_equal 0, parsed.length    
+  end
+  
+  def test_single_keyword
+    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
+  end
+   
+  def test_multiple_keywords
+    parsed = parse_query('  hallo  willem')
+    assert_equal 2, parsed.length
+    assert_equal 'willem', parsed.last.first
+    
+    parsed = parse_query("  hallo  willem   van\tbergen ")
+    assert_equal 4, parsed.length    
+    assert_equal 'hallo',  parsed[0].first
+    assert_equal 'willem', parsed[1].first
+    assert_equal 'van',    parsed[2].first
+    assert_equal 'bergen', parsed[3].first      
+  end
+  
+  def test_quoted_keywords
+    parsed = parse_query('  "hallo"')    
+    assert_equal 1, parsed.length
+    assert_equal 'hallo', parsed.first.first
+    
+    parsed = parse_query('  "hallo   willem"')
+    assert_equal 1, parsed.length
+    assert_equal 'hallo willem', parsed.first.first
+     
+    parsed = parse_query('  "hallo   willem')
+    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
+    assert_equal 'llem',       parsed[1].first
+  end
+  
+  def test_quote_escaping
+    parsed = parse_query('  "hallo   wi\\"llem"')
+    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 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[0].first
+    assert_equal :not,     parsed[0].last
+
+    parsed = parse_query('hallo-world')
+    assert_equal 1, parsed.length
+    assert_equal 'hallo-world', parsed.first.first
+
+    parsed = parse_query('hallo -world')
+    assert_equal 2, parsed.length
+    assert_equal 'hallo', parsed.first.first
+    assert_equal 'world', parsed.last.first
+    assert_equal :not,     parsed.last.last
+
+    parsed = parse_query('123 -"456 789"')
+    assert_equal 2, parsed.length
+    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_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)
+    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 'Cows OR Frog Toys', parsed[7].first
+    assert_equal :or,   parsed[7].last                  
+  end
+end

data/test/search_for_test.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ScopedSearchTest < Test::Unit::TestCase
+
+  def setup
+    case ENV['DATABASE']
+      when 'mysql'
+        create_mysql_connection
+      when 'postgresql' 
+        create_postgresql_connection
+      else 'sqlite3'     
+        create_sqlite3_connection
+    end
+    InitialSchema.up
+    SearchTestModel.create_corpus!
+    Group.create_corpus!
+    Location.create_corpus!
+    Address.create_corpus!
+    User.create_corpus!
+    Client.create_corpus!
+    Office.create_corpus!
+    Note.create_corpus!
+  end
+
+  def teardown
+    InitialSchema.down
+  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_only_fields
+    SearchTestModel.searchable_on :only => [:string_field, :text_field, :date_field]
+    assert SearchTestModel.respond_to?(:search_for)
+    assert_equal SearchTestModel.scoped_search_fields.size, 3
+    assert SearchTestModel.scoped_search_fields.include?(:string_field)
+    assert SearchTestModel.scoped_search_fields.include?(:text_field)
+    assert SearchTestModel.scoped_search_fields.include?(:date_field)
+  end
+  
+  def test_search_except_fields
+    SearchTestModel.searchable_on :except => [:id, :ignored_field, :created_at, :updated_at]
+    assert SearchTestModel.respond_to?(:search_for)
+    assert_equal SearchTestModel.scoped_search_fields.size, 3
+    assert SearchTestModel.scoped_search_fields.include?(:string_field)
+    assert SearchTestModel.scoped_search_fields.include?(:text_field)
+    assert SearchTestModel.scoped_search_fields.include?(:date_field)
+  end  
+  
+  def test_search_with_only_and_except
+    # :except should be ignored if :only is specified.
+    SearchTestModel.searchable_on({:only => [:text_field], :except => [:text_field]})
+    assert SearchTestModel.respond_to?(:search_for)
+    assert_equal SearchTestModel.scoped_search_fields.size, 1
+    assert SearchTestModel.scoped_search_fields.include?(:text_field), ':except should be ignored if :only is specified'
+  end  
+  
+  def test_search
+    SearchTestModel.searchable_on :string_field, :text_field, :date_field
+  
+    assert_equal SearchTestModel.count, 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 15, SearchTestModel.search_for('o').count    
+    assert_equal 2, SearchTestModel.search_for('-o').count
+    assert_equal 15, 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.  
+    # Since it is just a date being searched for it will also
+    # be searched for in text fields regardless of whether or 
+    # not it is a valid date.
+    assert_equal 0, SearchTestModel.search_for('2/30/1980').count 
+    assert_equal 0, 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 0, SearchTestModel.search_for('hays 2/30/1980').count 
+  
+    assert_equal 1, SearchTestModel.search_for('< 12/01/1980').count    
+    assert_equal 6, SearchTestModel.search_for('> 2006/1/1').count
+  
+    assert_equal 5, SearchTestModel.search_for('< 12/26/2002').count 
+    assert_equal 6, SearchTestModel.search_for('<= 12/26/2002').count   
+  
+    assert_equal 6, SearchTestModel.search_for('> 2/5/2005').count 
+    assert_equal 7, 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 
+       
+    # This should return one with a date of 7/15/2006 found in the text.
+    assert_equal 2, SearchTestModel.search_for('7/15/2006').count
+  end
+  
+  def test_search_belongs_to_association
+    User.searchable_on :first_name, :last_name, :group_name
+      
+    assert_equal User.count, User.search_for('').count        
+    assert_equal 1, User.search_for('Wes').count     
+    assert_equal 2, User.search_for('System Administrator').count
+    assert_equal 2, User.search_for('Managers').count
+  end
+  
+  def test_search_has_many_association
+    User.searchable_on :first_name, :last_name, :notes_title, :notes_content
+  
+    assert_equal User.count, User.search_for('').count        
+    assert_equal 2, User.search_for('Router').count     
+    assert_equal 1, User.search_for('milk').count
+    assert_equal 1, User.search_for('"Spec Tests"').count
+    assert_equal 0, User.search_for('Wes "Spec Tests"').count
+  end  
+  
+  def test_search_has_many_through_association
+    User.searchable_on :first_name, :last_name, :clients_first_name, :clients_last_name
+      
+    assert_equal User.count, User.search_for('').count        
+    assert_equal 2, User.search_for('Smith').count     
+    assert_equal 1, User.search_for('Sam').count
+    assert_equal 1, User.search_for('Johnson').count
+  end  
+  
+  def test_search_has_one_association
+    User.searchable_on :first_name, :last_name, :address_street, :address_city, :address_state, :address_postal_code
+          
+    assert_equal User.count, User.search_for('').count        
+    assert_equal 1, User.search_for('Fernley').count     
+    assert_equal 4, User.search_for('NV').count
+    assert_equal 1, User.search_for('Haskell').count  
+    assert_equal 2, User.search_for('89434').count        
+  end  
+  
+  def test_search_has_and_belongs_to_many_association
+    User.searchable_on :first_name, :last_name, :locations_name
+  
+    assert_equal User.count, User.search_for('').count        
+    assert_equal 2, User.search_for('Office').count     
+    assert_equal 1, User.search_for('Store').count
+    assert_equal 1, User.search_for('John Office').count
+  end  
+
+end
+
+