wvanbergen-scoped_search 1.2.0 → 2.0.0

data/lib/scoped_search/reg_tokens.rb

@@ -1,51 +0,0 @@
-# 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/tasks/documentation.rake

@@ -1,33 +0,0 @@
-require 'rubygems'
-require 'rake/rdoctask'
-
-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('LICENSE',
-                          'lib/')
-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/integration/api_test.rb

@@ -1,53 +0,0 @@
-require "#{File.dirname(__FILE__)}/../test_helper.rb"
-
-class ScopedSearch::Test::API < Test::Unit::TestCase
-
-  def self.const_missing(const)
-    ScopedSearch::Test::Models.const_get(const)
-  end
-
-  def setup
-    ScopedSearch::Test::establish_connection
-    ScopedSearch::Test::DatabaseSchema.up
-  end
-
-  def teardown
-      ScopedSearch::Test::DatabaseSchema.down    
-  end
-  
-  def test_enabling
-    assert !Foo.respond_to?(:search_for)
-    Foo.searchable_on :string_field, :text_field, :date_field
-    assert Foo.respond_to?(:search_for)
-      
-    assert_equal ActiveRecord::NamedScope::Scope, Foo.search_for('test').class
-  end  
-  
-  def test_search_only_fields
-    Foo.searchable_on :only => [:string_field, :text_field, :date_field]
-    assert Foo.respond_to?(:search_for)
-    assert_equal Foo.scoped_search_fields.size, 3
-    assert Foo.scoped_search_fields.include?(:string_field)
-    assert Foo.scoped_search_fields.include?(:text_field)
-    assert Foo.scoped_search_fields.include?(:date_field)
-  end
-  
-  def test_search_except_fields
-    Foo.searchable_on :except => [:id, :ignored_field, :created_at, :updated_at]
-    assert Foo.respond_to?(:search_for)
-    assert_equal Foo.scoped_search_fields.size, 4
-    assert Foo.scoped_search_fields.include?(:string_field)
-    assert Foo.scoped_search_fields.include?(:text_field)
-    assert Foo.scoped_search_fields.include?(:date_field)
-    assert Foo.scoped_search_fields.include?(:some_int_field)
-  end  
-  
-  def test_search_with_only_and_except
-    # :except should be ignored if :only is specified.
-    Foo.searchable_on({:only => [:text_field], :except => [:text_field]})
-    assert Foo.respond_to?(:search_for)
-    assert_equal Foo.scoped_search_fields.size, 1
-    assert Foo.scoped_search_fields.include?(:text_field), ':except should be ignored if :only is specified'
-  end  
-  
-end

data/test/lib/test_models.rb

@@ -1,148 +0,0 @@
-module ScopedSearch::Test::Models
-    
-  class Foo < ActiveRecord::Base
-    def self.create_corpus!
-      create!(:string_field => "Programmer 123", :text_field => nil,              :ignored_field => "123456",  :some_int_field => 111, :date_field => '2000-01-01')    
-      create!(:string_field => "Jim",            :text_field => "Henson",         :ignored_field => "123456a", :some_int_field => 222, :date_field => '2001-04-15')   
-      create!(:string_field => "Jim",            :text_field => "Bush",           :ignored_field => "123456b", :some_int_field => 333, :date_field => '2001-04-17')    
-      create!(:string_field => "Wes",            :text_field => "Hays",           :ignored_field => "123456c", :some_int_field => 444, :date_field => '1980-09-27')  
-      create!(:string_field => "Bob",            :text_field => "Hays",           :ignored_field => "123456d", :some_int_field => 555, :date_field => '2002-11-09')  
-      create!(:string_field => "Dogs",           :text_field => "Pit Bull",       :ignored_field => "123456e", :some_int_field => 666, :date_field => '2002-12-26') 
-      create!(:string_field => "Dogs",           :text_field => "Eskimo",         :ignored_field => "123456f", :some_int_field => 777, :date_field => '2003-03-19')
-      create!(:string_field => "Cows",           :text_field => "Farms",          :ignored_field => "123456g", :some_int_field => 888, :date_field => '2004-05-01')
-      create!(:string_field => "Hello World",    :text_field => "Hello Moon",     :ignored_field => "123456h", :some_int_field => 999, :date_field => '2004-07-11')   
-      create!(:string_field => "Hello World",    :text_field => "Goodnight Moon", :ignored_field => "123456i", :some_int_field => 100, :date_field => '2004-09-12')
-      create!(:string_field => "Happy Cow",      :text_field => "Sad Cow",        :ignored_field => "123456j", :some_int_field => 200, :date_field => '2005-02-05')
-      create!(:string_field => "Happy Frog",     :text_field => "Sad Frog",       :ignored_field => "123456k", :some_int_field => 300, :date_field => '2006-03-09')
-      create!(:string_field => "Excited Frog",   :text_field => "Sad Frog",       :ignored_field => "123456l", :some_int_field => 400, :date_field => '2006-07-15')    
-      create!(:string_field => "Man made",       :text_field => "Woman made",     :ignored_field => "123456m", :some_int_field => 500, :date_field => '2007-06-13')
-      create!(:string_field => "Cat Toys",       :text_field => "Frog Toys",      :ignored_field => "123456n", :some_int_field => 600, :date_field => '2008-03-04') 
-      create!(:string_field => "Happy Toys",     :text_field => "Sad Toys",       :ignored_field => "123456n", :some_int_field => 700, :date_field => '2008-05-12') 
-
-      create!(:string_field => "My son was born on 7/15/2006 and weighed 5.5 lbs",     
-              :text_field => "Sad Toys",       
-              :ignored_field => "123456n", 
-              :date_field => '2008-09-22')
-    end
-  end
-
-  class User < ActiveRecord::Base
-    belongs_to :group
-    belongs_to :address
-    has_many :notes
-    has_and_belongs_to_many :locations
-  
-    has_many :offices, :dependent => :destroy
-    has_many :clients, :through => :offices
-    
-    def self.create_corpus!
-      create!(:first_name => 'Willem',  :last_name => 'Van Bergen', :login => 'wvanbergen', :age => 25, :group_id => 1, :address_id => 1) 
-      create!(:first_name => 'Wes',     :last_name => 'Hays',       :login => 'weshays',    :age => 26, :group_id => 1, :address_id => 2) 
-      create!(:first_name => 'John',    :last_name => 'Dell',       :login => 'jdell',      :age => 27, :group_id => 2, :address_id => 3) 
-      create!(:first_name => 'Ray',     :last_name => 'York',       :login => 'ryork',      :age => 28, :group_id => 3, :address_id => 4) 
-      create!(:first_name => 'Anna',    :last_name => 'Landis',     :login => 'alandis',    :age => 29, :group_id => 4, :address_id => 5) 
-    
-      user = self.find_by_first_name('Willem')
-      user.locations << ScopedSearch::Test::Models::Location.find_by_name('Office')
-    
-      user = self.find_by_first_name('Wes')
-      user.locations << ScopedSearch::Test::Models::Location.find_by_name('Store')
-    
-      user = self.find_by_first_name('John')
-      user.locations << ScopedSearch::Test::Models::Location.find_by_name('Office')
-    
-      user = self.find_by_first_name('Ray')
-      user.locations << ScopedSearch::Test::Models::Location.find_by_name('Home')
-    
-      user = self.find_by_first_name('Anna')
-      user.locations << ScopedSearch::Test::Models::Location.find_by_name('Beach')                
-    end
-  end
-
-  class Client < ActiveRecord::Base
-    has_many :offices, :dependent => :destroy
-    has_many :users, :through => :offices
-    def self.create_corpus!
-      create!(:first_name => 'Bob',    :last_name => 'Smith') 
-      create!(:first_name => 'Sam',    :last_name => 'Lovett')
-      create!(:first_name => 'Sally',  :last_name => 'May')
-      create!(:first_name => 'Mary',   :last_name => 'Smith')
-      create!(:first_name => 'Darren', :last_name => 'Johnson')
-    end
-  end
-
-  class Office < ActiveRecord::Base
-    belongs_to :client
-    belongs_to :user
-    def self.create_corpus!
-      create!(:name => 'California Office', :user_id => 1, :client_id => 1)
-      create!(:name => 'California Office', :user_id => 2, :client_id => 2)
-      create!(:name => 'California Office', :user_id => 3, :client_id => 3)
-      create!(:name => 'Reno Office',       :user_id => 4, :client_id => 4)
-      create!(:name => 'Reno Office',       :user_id => 5, :client_id => 5)        
-    end
-  end
-
-  class Group < ActiveRecord::Base
-    has_many :users
-    def self.create_corpus!
-      create!(:name => 'System Administrator') 
-      create!(:name => 'Software Managers')    
-      create!(:name => 'Office Managers')      
-      create!(:name => 'Accounting')           
-    end
-  end
-
-  class Location < ActiveRecord::Base
-    has_and_belongs_to_many :users
-    def self.create_corpus!
-      create!(:name => 'Home')   
-      create!(:name => 'Office') 
-      create!(:name => 'Store')  
-      create!(:name => 'Beach')  
-    end
-  end
-
-  class Note < ActiveRecord::Base
-    belongs_to :user
-    def self.create_corpus!
-      wes  = ScopedSearch::Test::Models::User.find_by_first_name('Wes')
-      john = ScopedSearch::Test::Models::User.find_by_first_name('John')
-    
-      create!(:user_id => wes.id,         
-              :title   => 'Purchases', 
-              :content => "1) Linksys Router. 2) Network Cable")   
-            
-      create!(:user_id => wes.id,         
-              :title  => 'Tasks',
-              :content => 'Clean my car, walk the dog and mow the yard buy milk') 
-            
-      create!(:user_id => wes.id,         
-              :title   => 'Grocery List',
-              :content => 'milk, gum, apples')  
-            
-      create!(:user_id => wes.id,         
-              :title   => 'Stocks to watch',
-              :content => 'MA, AAPL, V and SSO.  Straddle MA at 200 with JAN 09 options')            
-    
-      create!(:user_id => john.id,        
-              :title   => 'Spec Tests',
-              :content => 'Spec Tests... Spec Tests... Spec Tests!!')   
-            
-      create!(:user_id => john.id,        
-              :title   => 'Things To Do',
-              :content => '1) Did I mention Spec Tests!!!, 2) Buy Linksys Router WRT160N')
-    end
-  end
-
-  class Address < ActiveRecord::Base
-    has_one :user
-    def self.create_corpus!
-      create!(:street => '800 Haskell St',     :city => 'Reno',       :state => 'NV', :postal_code => '89509') 
-      create!(:street => '2499 Dorchester Rd', :city => 'Charleston', :state => 'SC', :postal_code => '29414')
-      create!(:street => '474 Mallard Way',    :city => 'Fernley',    :state => 'NV', :postal_code => '89408')
-      create!(:street => '1600 Montero Ct',    :city => 'Sparks',     :state => 'NV', :postal_code => '89434')
-      create!(:street => '200 4th St',         :city => 'Sparks',     :state => 'NV', :postal_code => '89434')
-    end
-  end
-end

data/test/lib/test_schema.rb

@@ -1,68 +0,0 @@
-ActiveRecord::Migration.verbose = false unless ENV.has_key?('DEBUG')
-
-class ScopedSearch::Test::DatabaseSchema < ActiveRecord::Migration
-
-  def self.up
-    
-    create_table :foos do |t|
-      t.string :string_field
-      t.text :text_field
-      t.string :ignored_field
-      t.integer :some_int_field
-      t.date :date_field
-      t.timestamps
-    end
-    
-    create_table :users do |t|
-      t.string :first_name, :last_name, :login
-      t.integer :age
-      t.integer :group_id
-      t.integer :address_id
-    end   
-    
-    create_table :clients do |t|
-      t.string :first_name, :last_name
-    end     
-    
-    create_table :offices do |t|
-      t.string :name
-      t.integer :user_id, :client_id
-    end    
-    
-    create_table :groups do |t|
-      t.string :name
-    end    
-    
-    create_table :locations do |t|
-      t.string :name
-    end   
-    
-    create_table :locations_users, :id => false, :force => true do |t|
-      t.integer :user_id
-      t.integer :location_id
-    end 
-    
-    create_table :notes do |t|
-      t.string :title
-      t.text :content
-      t.integer :user_id
-    end      
-    
-    create_table :addresses do |t|
-      t.string :street, :city, :state, :postal_code
-    end    
-  end
-
-  def self.down
-    drop_table :foos    
-    drop_table :users     
-    drop_table :clients     
-    drop_table :offices     
-    drop_table :groups     
-    drop_table :locations     
-    drop_table :locations_users    
-    drop_table :notes     
-    drop_table :addresses
-  end
-
-end

data/test/test_helper.rb

@@ -1,44 +0,0 @@
-$:.reject! { |e| e.include? 'TextMate' }
-
-require 'test/unit'
-require 'rubygems'
-require 'active_record'
-require 'ruby-debug'
-
-require "#{File.dirname(__FILE__)}/../lib/scoped_search"
-
-module ScopedSearch::Test
-  
-  def self.establish_connection
-    if ENV['DATABASE']
-      ScopedSearch::Test.establish_named_connection(ENV['DATABASE'])
-    else
-      ScopedSearch::Test.establish_default_connection
-    end  
-  end
-  
-  def self.establish_named_connection(name)
-    @database_connections ||= YAML.load(File.read("#{File.dirname(__FILE__)}/database.yml"))
-    raise "#{name} database not configured" if @database_connections[name.to_s].nil?
-    ActiveRecord::Base.establish_connection(@database_connections[name.to_s])
-  end
-  
-  def self.establish_default_connection
-    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-  end
-  
-  def self.create_corpus!
-    ScopedSearch::Test::Models::Foo.create_corpus!
-    ScopedSearch::Test::Models::Location.create_corpus!
-    ScopedSearch::Test::Models::User.create_corpus!        
-    ScopedSearch::Test::Models::Note.create_corpus!
-    ScopedSearch::Test::Models::Group.create_corpus!    
-    ScopedSearch::Test::Models::Office.create_corpus!    
-    ScopedSearch::Test::Models::Client.create_corpus!    
-    ScopedSearch::Test::Models::Address.create_corpus!        
-  end  
-end
-
-# Load helpers
-require "#{File.dirname(__FILE__)}/lib/test_schema"
-require "#{File.dirname(__FILE__)}/lib/test_models"

data/test/unit/query_conditions_builder_test.rb

@@ -1,410 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class ScopedSearch::Test::QueryConditionsBuilder < 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
-  
-  # ** 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
-  
-  def test_like_search_condition_with_integer
-    search_conditions = [["26", :like]]
-    query_fields = {'some_table.age' => :integer}    
-    conditions = build_query(search_conditions, query_fields) 
-  
-    assert_equal '(some_table.age = :keyword_0_26)', conditions.first
-    assert_equal 26, conditions.last[:keyword_0_26]
-  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_or_search_condition_with_integer
-    search_conditions = [["Wes OR 26", :or]]
-    query_fields = {'some_table.first_name' => :string, 'some_table.age' => :integer}    
-    conditions = build_query(search_conditions, query_fields) 
-    regExs = build_regex_for_or(['first_name', 'age'], 'keyword_0')
-    assert_match /^#{regExs}$/, conditions.first
-    assert_equal '%Wes%', conditions.last[:keyword_0a]
-    assert_equal 26, conditions.last[:keyword_0_26]       
-  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 **
-  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.(first_name|age) (LIKE|=) :keyword_0[a-zA-Z0-9_]+ OR )?some_table.(first_name|age) (LIKE|=) :keyword_0[a-zA-Z0-9_]+)[)]" 
-               }.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