wvanbergen-scoped_search 0.7.3 → 1.0.0

data/README

@@ -0,0 +1,60 @@
+= scoped_search[http://github.com/wvanbergen/scoped_search/tree/master]
+
+This simple plugin will make it easy to search your ActiveRecord models. Searching is performed using a query string, which should be passed to the named_scope *search_for* that uses SQL %LIKE% conditions for searching (ILIKE for Postgres). You can specify what fields should be used for searching.
+
+
+== Installing
+
+	gem install wvanbergen-scoped_search
+
+
+== Usage
+
+First, you have to specify in what columns should be searched:
+
+	class User < ActiveRecord::Base
+	  searchable_on :first_name, :last_name
+	end
+
+
+Now, the <b>search_for</b> scope is available for queries. You should pass a query string to the scope. 
+This can be empty or nil, in which case all no search conditions are set (and all records will be returned).
+
+	User.search_for(params[:q]).each { |project| ... }
+
+
+You can also search on associate models.  This works with <b>belongs_to</b>, <b>has_one</b>, <b>has_many</b>, 
+<b>has_many :through</b>, and <b>HABTM</b>.  For example if a User <b>has_many</b> Notes (title, content, created_at, updated_at)
+
+	class User < ActiveRecord::Base
+	  has_many: notes
+	  searchable_on :first_name, :last_name, :notes_title, :notes_content
+	end
+
+
+The search query language is simple. It supports these constructs:
+* <b>words:</b> some search keywords
+* <b>phrases:</b> "a single search phrase"
+* <b>negation:</b> "look for this" -"but do not look for this phrase and this" -word
+* <b>OR words/phrases:</b> word/phrase OR word/phrase.  Example: "Hello World" OR "Hello Moon"
+* <b>dates:</b> mm/dd/yyyy, dd/mm/yyyy, yyyy/mm/dd, yyyy-mm-dd
+* <b>date ranges:</b> > date, >= date, < date, <= date, date TO date.  Examples: > mm/dd/yyyy, < yyyy-mm-dd
+
+This functionality is build on named_scope. The searchable_on statement creates 
+a named_scope *search_for*. Because of this, you can actually chain the call with
+other scopes. For example, this can be very useful if you only want to search in 
+projects that are accessible by a given user.
+
+	class Project < ActiveRecord::Base
+	  searchable_on :name, :description
+	  named_scope :accessible_by, lambda { |user| ... }
+	end
+  
+	# using chained named_scopes and will_paginate
+	Project.accessible_by(current_user).search_for(params[:q]).paginate(:page => params[:page], :include => :tasks)
+
+
+== License
+
+This plugin is released under the MIT license. Please contact (willem AT vanbergen DOT org) if you have any suggestions or remarks. 
+

data/Rakefile

@@ -1,6 +1,25 @@
 require 'rubygems'
+require 'rake/rdoctask'
 
 Dir['tasks/*.rake'].each { |file| load(file) }
  
 desc 'Default: run unit tests.'
-task :default => :test
+task :default => [:test]
+
+##############################################
+# Build RDocs
+##############################################
+desc 'Generate documentation for the acts_as_callback_logger plugin.'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc/html'
+  rdoc.title    = 'scoped_search'  
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.main = 'README'
+  rdoc.rdoc_files.include('README',
+                          'CHANGELOG',
+                          'LICENSE',
+                          'TODO',
+                          'lib/')
+end
+##############################################
+

data/lib/scoped_search/query_conditions_builder.rb

@@ -1,13 +1,13 @@
 module ScopedSearch
   
   class QueryConditionsBuilder
-    ## ActiveRecord::Base.connection.adapter_name
 
-    # Build the query
+    # Builds the query string by calling the build method on a new instances of QueryConditionsBuilder.
     def self.build_query(search_conditions, query_fields)
       self.new.build(search_conditions, query_fields)
     end
 
+    # Initializes the default class variables.
     def initialize
       @query_fields = nil 
       @query_params = {}
@@ -20,29 +20,32 @@ module ScopedSearch
     end 
 
 
-    # Build the query
+    # Build the query based on the search conditions and the fields to 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}
-    # 
+    # Example: 
+    #
+    #   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.      
+    #   1) If search_conditions is not an array
+    #   2) If query_fields is not a Hash    
     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)
+                        # Still thinking about this one
+                        # 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)
@@ -66,6 +69,7 @@ module ScopedSearch
     private 
     
     # def integer_condition(keyword_name, value)
+      # Still thinking about this one
     # end    
     
     def like_condition(keyword_name, value)
@@ -125,20 +129,25 @@ module ScopedSearch
         end
       rescue
         # do not search on any date columns since the date is invalid
+        retVal = [] # Reset just in case
       end
       
       # Search the text fields for the date as well as it could be in text.
       # Also still search on the text columns for an invalid date as it could
       # have a different meaning.
-      keyword_name_b = "#{keyword_name}b".to_sym
-      @query_params[keyword_name_b] = "%#{value}%"
+      found_text_fields_to_search = false
+      keyword_name_b = "#{keyword_name}b".to_sym      
       @query_fields.each do |field, field_type|  #|key,value| 
         if field_type == :string or field_type == :text
+          found_text_fields_to_search = true
           retVal << "#{field} #{@sql_like} :#{keyword_name_b.to_s}"
         end
       end
+      if found_text_fields_to_search
+        @query_params[keyword_name_b] = "%#{value}%"
+      end
 
-      "(#{retVal.join(' OR ')})"      
+      retVal.empty? ? '' : "(#{retVal.join(' OR ')})"      
     end
     
     def greater_than_date(keyword_name, value)

data/lib/scoped_search/query_language_parser.rb

@@ -1,17 +1,33 @@
 module ScopedSearch
   
+  # Used to parse and build the conditions tree for the search.
   class QueryLanguageParser
     
-    def parse_query(query = nil)
-      return build_conditions_tree(tokenize(query))
-    end
-    
+    # Parses the query string by calling the parse_query method on a new instances of QueryLanguageParser.
+    #
+    # query:: The query string to parse.  If nil the all values will be returned (default is nil)
+    #         If the query string is longer then 300 characters then it will be truncated to a 
+    #         length of 300.
     def self.parse(query)
       self.new.parse_query(query)
+    end    
+    
+    # Parse the query string.
+    #
+    # query:: The query string to parse.  If nil the all values will be returned (default is nil)
+    #         If the query string is longer then 300 characters then it will be truncated to a 
+    #         length of 300.
+    def parse_query(query = nil)
+      # truncate query string at 300 characters
+      query = query[0...300] if query.length > 300
+      return build_conditions_tree(tokenize(query))
     end
     
     protected
   
+    # Build the conditions tree based on the tokens found.
+    #
+    # tokens:: An array of tokens.
     def build_conditions_tree(tokens)
       conditions_tree = []
     
@@ -57,6 +73,7 @@ module ScopedSearch
       return conditions_tree
     end
     
+    # Tokenize the query based on the different RegTokens.
     def tokenize(query)
       pattern = [RegTokens::BetweenDateFormatMMDDYYYY,
                  RegTokens::BetweenDateFormatYYYYMMDD,

data/lib/scoped_search.rb

@@ -1,30 +1,51 @@
 module ScopedSearch
   
   module ClassMethods
-  
-    def self.extended(base)
+    
+    def self.extended(base) # :nodoc:
       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
+    # Creates a named scope in the class it was called upon.
+    #
+    # fields:: The fields to search on.
     def searchable_on(*fields)
       # Make sure that the table to be searched actually exists
       if self.table_exists?
+        
+        # Get a collection of fields to be searched on.
         if fields.first.class.to_s == 'Hash'
           if fields.first.has_key?(:only)
+            # only search on these fields.
             fields = fields.first[:only]
           elsif fields.first.has_key?(:except)
-            fields = self.column_names.collect { |column| 
-                     fields.first[:except].include?(column.to_sym) ? nil : column.to_sym }.compact
+            # Get all the fields and remove any that are in the -except- list.
+            fields = self.column_names.collect { |column| fields.first[:except].include?(column.to_sym) ? nil : column.to_sym }.compact
           end
         end
         
-        assoc_models = self.reflections.collect { |m| m[0] }
+        # Get an array of associate modules.
+        assoc_models = self.reflections.collect { |key,value| key }
+        
+        # Subtract out the fields to be searched on that are part of *this* model.
+        # Any thing left will be associate module fields to be searched on.
         assoc_fields = fields - self.column_names.collect { |column| column.to_sym }
+        
+        # Subtraced out the associated fields from the fields so that you are only left
+        # with fields in *this* model.
         fields -= assoc_fields
         
+        # Loop through each of the associate models and group accordingly each
+        # associate model field to search.  Assuming the following relations:
+        # has_many :clients
+        # has_many :notes,
+        # belongs_to :user_type 
+        # assoc_groupings will look like
+        # assoc_groupings = {:clients => [:first_name, :last_name],
+        #                    :notes => [:descr],
+        #                    :user_type => [:identifier]}
         assoc_groupings = {}
         assoc_models.each do |assoc_model|
           assoc_groupings[assoc_model] = []
@@ -34,9 +55,11 @@ module ScopedSearch
             end
           end
         end
-        
+    
+        # If a grouping does not contain any fields to be searched on then remove it.
         assoc_groupings = assoc_groupings.delete_if {|group, field_group| field_group.empty?}
         
+        # Set the appropriate class attributes. 
         self.cattr_accessor :scoped_search_fields, :scoped_search_assoc_groupings
         self.scoped_search_fields = fields
         self.scoped_search_assoc_groupings = assoc_groupings
@@ -46,7 +69,9 @@ 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
+    # in the fields that were provided to searchable_on.
+    #
+    # search_string:: The search string to parse.
     def build_scoped_search_conditions(search_string)    
       if search_string.nil? || search_string.strip.blank?
         return {:conditions => nil}
@@ -57,18 +82,20 @@ module ScopedSearch
           query_fields[field_name] = self.columns_hash[field.to_s].type
         end
         
+        assoc_model_indx = 0
+        assoc_fields_indx = 1
         assoc_models_to_include = []
-        self.scoped_search_assoc_groupings.each do |group|
-          assoc_models_to_include << group[0]
-          group[1].each do |group_field|
-            field_name = connection.quote_table_name(group[0].to_s.pluralize) + "." + connection.quote_column_name(group_field)
-            query_fields[field_name] = self.reflections[group[0]].klass.columns_hash[group_field.to_s].type
+        self.scoped_search_assoc_groupings.each do |group|  
+          assoc_models_to_include << group[assoc_model_indx]
+          group[assoc_fields_indx].each do |group_field|
+            field_name = connection.quote_table_name(group[assoc_model_indx].to_s.pluralize) + "." + connection.quote_column_name(group_field)
+            query_fields[field_name] = self.reflections[group[assoc_model_indx]].klass.columns_hash[group_field.to_s].type
           end
         end
         
         search_conditions = QueryLanguageParser.parse(search_string) 
         conditions = QueryConditionsBuilder.build_query(search_conditions, query_fields) 
-        
+ 
         retVal = {:conditions => conditions}
         retVal[:include] = assoc_models_to_include unless assoc_models_to_include.empty?
 

data/tasks/github-gem.rake

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'rubyforge'
 require 'rake'
 require 'rake/tasklib'
 require 'date'
@@ -24,23 +25,16 @@ module Rake
       namespace(:gem) do
         desc "Updates the file lists for this gem"
         task(:manifest) { manifest_task }
-        
-        desc "Builds a ruby gem for #{@name}"
-        task(:build => [:manifest]) { build_task }
-        
-        desc "Installs the ruby gem for #{@name} locally"
-        task(:install => [:build]) { install_task }
-        
-        desc "Uninstalls the ruby gem for #{@name} locally"
-        task(:uninstall) { uninstall_task }             
+
+        desc "Builds a .gem package for #{@name}"
+        task(:build) { build_task } 
         
         desc "Releases a new version of #{@name}"
         task(:release) { release_task } 
-      end
+        
+      end    
     end
     
-
-    
     protected 
 
     def reload_gemspec!
@@ -135,7 +129,7 @@ module Rake
       spec = File.read(gemspec_file)
       spec.gsub! /^(\s* s.(test_)?files \s* = \s* )( \[ [^\]]* \] | %w\( [^)]* \) )/mx do
         assignment = $1
-        bunch = $2 ? list.grep(/^test.*_test\.rb$/) : list
+        bunch = $2 ? list.grep(/^(test.*_test\.rb|spec.*_spec.rb)$/) : list
         '%s%%w(%s)' % [assignment, bunch.join(' ')]
       end
 
@@ -145,15 +139,17 @@ module Rake
     
     def build_task
       sh "gem build #{gemspec_file}"
+      Dir.mkdir('pkg') unless File.exist?('pkg')
+      sh "mv #{name}-#{specification.version}.gem pkg/#{name}-#{specification.version}.gem" 
     end
     
     def install_task
-      raise "#{name} .gem file not found" unless File.exist?("#{name}-#{specification.version}.gem")
-      sh "gem install #{name}-#{specification.version}.gem"
+      raise "#{name} .gem file not found" unless File.exist?("pkg/#{name}-#{specification.version}.gem")
+      sh "gem install pkg/#{name}-#{specification.version}.gem"
     end
     
     def uninstall_task
-      raise "#{name} .gem file not found" unless File.exist?("#{name}-#{specification.version}.gem")
+      raise "#{name} .gem file not found" unless File.exist?("pkg/#{name}-#{specification.version}.gem")
       sh "gem uninstall #{name}"
     end    
     

data/tasks/test.rake

@@ -10,4 +10,23 @@ Rake::TestTask.new(:test) do |t|
   # is sqlite3 if not specified or if the parameter is invalid.
   # If DATABASE is mysql then the MYSQLSOCKET can also be set if needed.
   ENV['DATABASE'] = ENV['DATABASE'].nil? ? 'sqlite3' : ENV['DATABASE'].downcase
-end
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.test_files = Dir[ "test/*_test.rb" ]
+  end
+rescue LoadError
+  nil
+end
+
+begin
+  require 'rcov/rcovtask'
+  desc 'Runs spec:rcov and then displays the coverage/index.html file in the browswer.' 
+  task :rcov_display => [:clobber_rcov, :rcov] do 
+    system("open coverage/index.html")
+  end
+rescue LoadError
+  nil
+end

data/test/query_conditions_builder_test.rb

@@ -7,12 +7,30 @@ class QueryConditionsBuilderTest < Test::Unit::TestCase
     ScopedSearch::QueryConditionsBuilder.build_query(search_conditions, query_fields)
   end
   
+  # ** Invalid search conditions **
+  def test_search_with_invalid_search_conditions
+    search_conditions = ''
+    query_fields = {'some_table.first_name' => :string}   
+    assert_raise(RuntimeError, 'search_conditions must be a hash') {
+      build_query(search_conditions, query_fields) 
+    }
+  end  
+  
+  def test_search_with_invalid_query_fields
+    search_conditions = [["Wes", :like]]
+    query_fields = ''    
+    assert_raise(RuntimeError, 'query_fields must be a hash') {
+      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
@@ -36,14 +54,273 @@ class QueryConditionsBuilderTest < Test::Unit::TestCase
     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  
+  # ** less_than_date **
+  def test_less_than_date_search_condition_with_only_a_date_field_to_search 
+    search_conditions = [['< 09/27/1980', :less_than_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.event_date < :keyword_0)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]
+  end  
+  
+  def test_less_than_date_search_condition_with_invalid_date 
+    search_conditions = [['< 2/30/1980', :less_than_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  def test_less_than_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['< 09/27/1980', :less_than_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.event_date < :keyword_0)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]  
+  end  
+  
+  def test_less_than_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['< 2/30/1980', :less_than_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert conditions.first.empty?
+    assert conditions.last.empty?   
+  end  
+  
+  
+  # ** less_than_or_equal_to_date **
+  def test_less_than_or_equal_to_date_search_condition_with_only_a_date_field_to_search 
+    search_conditions = [['<= 09/27/1980', :less_than_or_equal_to_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.event_date <= :keyword_0)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]
+  end  
+  
+  def test_less_than_or_equal_to_date_search_condition_with_invalid_date 
+    search_conditions = [['<= 2/30/1980', :less_than_or_equal_to_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  def test_less_than_or_equal_to_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['<= 09/27/1980', :less_than_or_equal_to_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.event_date <= :keyword_0)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]  
+  end  
+  
+  def test_less_than_or_equal_to_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['<= 2/30/1980', :less_than_or_equal_to_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert conditions.first.empty?
+    assert conditions.last.empty?   
+  end
+  
+  
+  # ** as_of_date **
+  def test_as_of_date_search_condition_with_only_a_date_field_to_search 
+    search_conditions = [['09/27/1980', :as_of_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+   
+    assert_equal '(some_table.event_date = :keyword_0)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]
+  end  
+  
+  def test_as_of_date_search_condition_with_invalid_date 
+    search_conditions = [['2/30/1980', :as_of_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  def test_as_of_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['09/27/1980', :as_of_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.event_date = :keyword_0 OR some_table.first_name LIKE :keyword_0b)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]
+    assert_equal '%09/27/1980%', conditions.last[:keyword_0b]    
+  end  
+  
+  def test_as_of_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['2/30/1980', :as_of_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.first_name LIKE :keyword_0b)', conditions.first
+    assert_equal '%2/30/1980%', conditions.last[:keyword_0b]    
+  end
+  
+  
+  # ** greater_than_date **
+  def test_less_than_or_equal_to_date_search_condition_with_only_a_date_field_to_search 
+    search_conditions = [['> 09/27/1980', :greater_than_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.event_date > :keyword_0)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]
+  end  
+  
+  def test_less_than_or_equal_to_date_search_condition_with_invalid_date 
+    search_conditions = [['> 2/30/1980', :greater_than_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  def test_less_than_or_equal_to_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['> 09/27/1980', :greater_than_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.event_date > :keyword_0)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]  
+  end  
+  
+  def test_less_than_or_equal_to_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['> 2/30/1980', :greater_than_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert conditions.first.empty?
+    assert conditions.last.empty?   
+  end
+  
+  
+  # ** greater_than_or_equal_to_date **
+  def test_less_than_or_equal_to_date_search_condition_with_only_a_date_field_to_search 
+    search_conditions = [['>= 09/27/1980', :greater_than_or_equal_to_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.event_date >= :keyword_0)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]
+  end  
+  
+  def test_less_than_or_equal_to_date_search_condition_with_invalid_date 
+    search_conditions = [['>= 2/30/1980', :greater_than_or_equal_to_date]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  def test_less_than_or_equal_to_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['>= 09/27/1980', :greater_than_or_equal_to_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert_equal '(some_table.event_date >= :keyword_0)', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0]  
+  end  
+  
+  def test_less_than_or_equal_to_date_search_condition_with_a_date_field_and_a_text_field
+    search_conditions = [['>= 2/30/1980', :greater_than_or_equal_to_date]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+  
+    assert conditions.first.empty?
+    assert conditions.last.empty?   
+  end    
+  
+  
+  
+  # ** between_dates **
+  def test_between_dates_search_condition_two_valid_dates 
+    search_conditions = [['09/27/1980 TO 10/15/1980', :between_dates]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+
+    assert_equal '((some_table.event_date BETWEEN :keyword_0a AND :keyword_0b))', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0a]
+    assert_equal '1980-10-15', conditions.last[:keyword_0b]
+  end  
+  
+  def test_between_dates_search_condition_with_a_valid_date_first_and_an_invalid_date_second
+    search_conditions = [['09/27/1980 TO 2/30/1981', :between_dates]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  def test_between_dates_search_condition_with_an_invalid_date_first_and_a_valid_date_second
+    search_conditions = [['02/30/1980 TO 09/27/1980', :between_dates]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  def test_between_dates_search_condition_with_two_invalid_dates
+    search_conditions = [['02/30/1980 TO 02/30/1981', :between_dates]]
+    query_fields = {'some_table.event_date' => :datetime}    
+    conditions = build_query(search_conditions, query_fields) 
+
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  
+  def test_between_dates_search_condition_two_valid_dates_and_a_text_field
+    search_conditions = [['09/27/1980 TO 10/15/1980', :between_dates]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+
+    assert_equal '((some_table.event_date BETWEEN :keyword_0a AND :keyword_0b))', conditions.first
+    assert_equal '1980-09-27', conditions.last[:keyword_0a]
+    assert_equal '1980-10-15', conditions.last[:keyword_0b]
+  end  
+  
+  def test_between_dates_search_condition_with_a_valid_date_first_and_an_invalid_date_second_and_a_text_field
+    search_conditions = [['09/27/1980 TO 2/30/1981', :between_dates]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  def test_between_dates_search_condition_with_an_invalid_date_first_and_a_valid_date_second_and_a_text_field
+    search_conditions = [['02/30/1980 TO 09/27/1980', :between_dates]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
+  
+  def test_between_dates_search_condition_with_two_invalid_dates_and_a_text_field
+    search_conditions = [['02/30/1980 TO 02/30/1981', :between_dates]]
+    query_fields = {'some_table.event_date' => :datetime, 'some_table.first_name' => :string}    
+    conditions = build_query(search_conditions, query_fields) 
+
+    assert conditions.first.empty?
+    assert conditions.last.empty?
+  end  
   
     
   # ** Multi query search tests **
@@ -76,7 +353,6 @@ class QueryConditionsBuilderTest < Test::Unit::TestCase
   end  
   
   
-  
   # ** Helper methods **
   def build_regex_for_like(fields,keyword)
     orFields = fields.join('|')

data/test/query_language_test.rb

@@ -118,28 +118,6 @@ 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

@@ -153,6 +153,13 @@ class ScopedSearchTest < Test::Unit::TestCase
     assert_equal 1, User.search_for('Store').count
     assert_equal 1, User.search_for('John Office').count
   end  
+  
+  def test_search_with_very_long_query
+    User.searchable_on :first_name, :last_name, :address_street, :address_city, :address_state, :address_postal_code
+    really_long_string = ''
+    10000.times {really_long_string << 'really long string'}
+    assert_equal 0, User.search_for(really_long_string).count
+  end
 
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wvanbergen-scoped_search
 version: !ruby/object:Gem::Version 
-  version: 0.7.3
+  version: 1.0.0
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-24 00:00:00 -08:00
+date: 2009-01-15 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -27,9 +27,11 @@ extra_rdoc_files: []
 files: 
 - CHANGELOG
 - LICENSE
+- README
 - README.textile
 - Rakefile
 - TODO
+- coverage
 - init.rb
 - lib
 - lib/scoped_search