scoped_search 2.2.1 → 2.3.0

data/spec/integration/ordinal_querying_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../spec_helper"
 
 # These specs will run on all databases that are defined in the spec/database.yml file.
 # Comment out any databases that you do not have available for testing purposes if needed.
@@ -20,7 +20,7 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       ScopedSearch::RSpec::Database.close_connection
     end
 
-    context 'quering numerical fields' do
+    context 'querying numerical fields' do
 
       before(:all) do
         @record = @class.create!(:int =>  9)
@@ -102,17 +102,19 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         @class.search_for('date = 09-01-02').should have(1).item
       end
 
-      it "should accept MM/DD/YY as date format" do
-        @class.search_for('date = 01/02/09').should have(1).item
-      end
+      if RUBY_VERSION.to_f == 1.8
+        it "should accept MM/DD/YY as date format" do
+          @class.search_for('date = 01/02/09').should have(1).item
+        end
 
+        it "should accept MM/DD/YYYY as date format" do
+          @class.search_for('date = 01/02/2009').should have(1).item
+        end
+      end  
+      
       it "should accept YYYY/MM/DD as date format" do
         @class.search_for('date = 2009/01/02').should have(1).item
-      end
-
-      it "should accept MM/DD/YYYY as date format" do
-        @class.search_for('date = 01/02/2009').should have(1).item
-      end
+      end      
 
       it "should ignore an invalid date and thus return all records" do
         @class.search_for('>= 2009-14-57').should have(2).items
@@ -153,6 +155,99 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       it "should find no record with a timestamp later than today" do
         @class.search_for('> 2009-01-02').should have(0).item
       end
+
+    end
+    context 'humenized date and time query' do
+
+      before(:all) do
+        @curent_record = @class.create!(:timestamp => Time.current, :date => Date.current)
+        @hour_ago_record = @class.create!(:timestamp => Time.current - 1.hour, :date => Date.current)
+        @day_ago_record = @class.create!(:timestamp => Time.current - 1.day, :date => Date.current - 1.day)
+        @month_ago_record = @class.create!(:timestamp => Time.current - 1.month, :date => Date.current - 1.month)
+        @year_ago_record = @class.create!(:timestamp => Time.current - 1.year, :date => Date.current - 1.year)
+      end
+
+      after(:all) do
+        @curent_record.destroy
+        @hour_ago_record.destroy
+        @day_ago_record.destroy
+        @month_ago_record.destroy
+        @year_ago_record.destroy
+      end
+
+      it "should accept Today as date format" do
+        @class.search_for('date = Today').should have(2).item
+      end
+
+      it "should accept Yesterday as date format" do
+        @class.search_for('date = yesterday').should have(1).item
+      end
+
+      it "should find all timestamps and date from today using the = operator" do
+        @class.search_for('= Today').should have(2).item
+      end
+
+      it "should find all timestamps and date from today no operator" do
+        @class.search_for('Today').should have(2).item
+      end
+
+      it "should accept 2 days ago as date format" do
+        @class.search_for('date < "2 days ago"').should have(2).item
+      end
+
+       it "should accept 3 hours ago as date format" do
+        @class.search_for('timestamp > "3 hours ago"').should have(2).item
+       end
+
+       it "should accept 1 month ago as date format" do
+        @class.search_for('date > "1 month ago"').should have(3).item
+       end
+
+      it "should accept 1 year ago as date format" do
+        @class.search_for('date > "1 year ago"').should have(4).item
+      end
+
+    end
+
+       context 'querying bitwize fields' do
+
+      before(:all) do
+        @foo = ScopedSearch::RSpec::Database.create_model(:int => :integer) do |klass|
+          klass.scoped_search :on => :int, :offset => 0, :word_size => 8, :rename => :first
+          klass.scoped_search :on => :int, :offset => 1, :word_size => 8, :rename => :sec
+        end
+        # 1026 => is first = 2 and sec = 4
+        @record = @foo.create!(:int =>  1026)
+      end
+
+      after(:all) do
+        ScopedSearch::RSpec::Database.drop_model(@foo)
+        @record.destroy
+      end
+
+      it "should not find any record because first equal = 2" do
+        @foo.search_for('first = 4').should have(0).item
+      end
+
+      it "should find the record" do
+        @foo.search_for('first = 2').should have(1).item
+      end
+
+      it "should not find any record with a grater than operator" do
+        @foo.search_for('first > 9').should have(0).item
+      end
+
+      it "should find the record with an >= operator" do
+        @foo.search_for('sec >= 4').should have(1).item
+      end
+
+      it "should find the record with AND operator is used" do
+        @foo.search_for('sec <= 8 and first = 2').should have(1).item
+      end
+
+      it "should return the record in if one predicate is true and OR is used as operator" do
+        @foo.search_for('sec <= 8 || first > 8').should have(1).item
+      end
     end
   end
 end

data/spec/integration/profile_querying_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../spec_helper"
 
 # These specs will run on all databases that are defined in the spec/database.yml file.
 # Comment out any databases that you do not have available for testing purposes if needed.

data/spec/integration/relation_querying_spec.rb

@@ -1,265 +1,257 @@
-require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../spec_helper"
 
-if ActiveRecord::VERSION::MAJOR == 2
-  # These specs will run on all databases that are defined in the spec/database.yml file.
-  # Comment out any databases that you do not have available for testing purposes if needed.
-  ScopedSearch::RSpec::Database.test_databases.each do |db|
+# These specs will run on all databases that are defined in the spec/database.yml file.
+# Comment out any databases that you do not have available for testing purposes if needed.
+ScopedSearch::RSpec::Database.test_databases.each do |db|
 
-    describe ScopedSearch, "using a #{db} database" do
+  describe ScopedSearch, "using a #{db} database" do
 
-      before(:all) do
-        ScopedSearch::RSpec::Database.establish_named_connection(db)
-      end
-
-      after(:all) do
-        ScopedSearch::RSpec::Database.close_connection
-      end
-
-      context 'querying a :belongs_to relation' do
-
-        before(:all) do
+    before(:all) do
+      ScopedSearch::RSpec::Database.establish_named_connection(db)
+    end
 
-          # The related class
-          ActiveRecord::Migration.create_table(:bars) { |t| t.string :related }
-          class ::Bar < ActiveRecord::Base; has_many :foos; end
+    after(:all) do
+      ScopedSearch::RSpec::Database.close_connection
+    end
 
-          # The class on which to call search_for
-          ::Foo = ScopedSearch::Spec::Database.create_model(:foo => :string, :bar_id => :integer) do |klass|
-            klass.belongs_to :bar
-            klass.scoped_search :in => :bar, :on => :related
-          end
+    context 'querying a :belongs_to relation' do
 
-          @bar_record = Bar.create!(:related => 'bar')
+      before do
+        
+        # The related class
+        ActiveRecord::Migration.create_table(:hars) { |t| t.string :related }
+        class Har < ActiveRecord::Base; has_many :loos; end
 
-          Foo.create!(:foo => 'foo',       :bar => @bar_record)
-          Foo.create!(:foo => 'foo too',   :bar => @bar_record)
-          Foo.create!(:foo => 'foo three', :bar => Bar.create!(:related => 'another bar'))
-          Foo.create!(:foo => 'foo four')
+        # The class on which to call search_for
+        ActiveRecord::Migration.create_table(:loos) { |t| t.string :foo; t.integer :har_id }
+        class Loo < ActiveRecord::Base
+          belongs_to :har
+          scoped_search :in => :har, :on => :related
         end
 
-        after(:all) do
-          ScopedSearch::RSpec::Database.drop_model(Bar)
-          ScopedSearch::RSpec::Database.drop_model(Foo)
-          Object.send :remove_const, :Foo
-          Object.send :remove_const, :Bar
-        end
+        @har_record = Har.create!(:related => 'bar')
 
-        it "should find all records with a related bar record containing bar" do
-          Foo.search_for('bar').should have(3).items
-        end
+        Loo.create!(:foo => 'foo',       :har => @har_record)
+        Loo.create!(:foo => 'foo too',   :har => @har_record)
+        Loo.create!(:foo => 'foo three', :har => Har.create!(:related => 'another bar'))
+        Loo.create!(:foo => 'foo four')
+      end
 
-        it "should find all records with a related bar record having an exact value of bar with an explicit field" do
-           Foo.search_for('related = bar').should have(2).items
-         end
+      after do
+        ScopedSearch::RSpec::Database.drop_model(Har)
+        ScopedSearch::RSpec::Database.drop_model(Loo)
+      end
 
-        it "should find records for which the bar relation is not set using null?" do
-          Foo.search_for('null? related').should have(1).items
-        end
+      it "should find all records with a related bar record containing bar" do
+        Loo.search_for('bar').should have(3).items
       end
 
-      context 'querying a :has_many relation' do
+      it "should find all records with a related bar record having an exact value of bar with an explicit field" do
+        Loo.search_for('related = bar').should have(2).items
+      end
 
-        before(:all) do
+      it "should find records for which the bar relation is not set using null?" do
+        Loo.search_for('null? related').should have(1).items
+      end
 
-          # The related class
-          ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id }
-          class ::Bar < ActiveRecord::Base; belongs_to :foo; end
+      it "should find records for which the bar relation is not set using null?" do
+        Loo.search_for('',:order => 'related asc').first.foo.should eql('foo four')
+      end
 
-          # The class on which to call search_for
-          ::Foo = ScopedSearch::Spec::Database.create_model(:foo => :string, :bar_id => :integer) do |klass|
-            klass.has_many :bars
-            klass.scoped_search :in => :bars, :on => :related
-          end
+    end
 
-          @foo_1 = Foo.create!(:foo => 'foo')
-          @foo_2 = Foo.create!(:foo => 'foo too')
-          @foo_3 = Foo.create!(:foo => 'foo three')
+    context 'querying a :has_many relation' do
 
-          Bar.create!(:related => 'bar',         :foo => @foo_1)
-          Bar.create!(:related => 'another bar', :foo => @foo_1)
-          Bar.create!(:related => 'other bar',   :foo => @foo_2)
-        end
+      before do
 
-        after(:all) do
-          ScopedSearch::Spec::Database.drop_model(Bar)
-          ScopedSearch::Spec::Database.drop_model(Foo)
-          Object.send :remove_const, :Foo
-          Object.send :remove_const, :Bar
-        end
+        # The related class
+        ActiveRecord::Migration.create_table(:jars) { |t| t.string :related; t.integer :goo_id }
+        class Jar < ActiveRecord::Base; belongs_to :goo; end
 
-        it "should find all records with at least one bar record containing 'bar'" do
-          Foo.search_for('bar').should have(2).items
+        # The class on which to call search_for
+        ActiveRecord::Migration.create_table(:goos) { |t| t.string :foo }
+        class Goo < ActiveRecord::Base
+          has_many :jars
+          scoped_search :in => :jars, :on => :related
         end
 
-        it "should find the only record with at least one bar record having the exact value 'bar'" do
-          Foo.search_for('= bar').should have(1).item
-        end
+        @foo_1 = Goo.create!(:foo => 'foo')
+        @foo_2 = Goo.create!(:foo => 'foo too')
+        @foo_3 = Goo.create!(:foo => 'foo three')
 
-        it "should find all records for which at least one related bar record exists" do
-          Foo.search_for('set? related').should have(2).items
-        end
+        Jar.create!(:related => 'bar',         :goo => @foo_1)
+        Jar.create!(:related => 'another bar', :goo => @foo_1)
+        Jar.create!(:related => 'other bar',   :goo => @foo_2)
+      end
 
-        it "should find all records for which none related bar records exist" do
-          Foo.search_for('null? related').should have(1).items
-        end
+      after do
+        ScopedSearch::RSpec::Database.drop_model(Jar)
+        ScopedSearch::RSpec::Database.drop_model(Goo)
+      end
 
+      it "should find all records with at least one bar record containing 'bar'" do
+        ::Goo.search_for('bar').should have(2).items
       end
 
-      context 'querying a :has_one relation' do
+      it "should find the only record with at least one bar record having the exact value 'bar'" do
+        ::Goo.search_for('= bar').should have(1).item
+      end
 
-        before(:all) do
+      it "should find all records for which at least one related bar record exists" do
+        ::Goo.search_for('set? related').should have(2).items
+      end
 
-          # The related class
-          ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id }
-          class ::Bar < ActiveRecord::Base; belongs_to :foo; end
+      it "should find all records for which none related bar records exist" do
+        ::Goo.search_for('null? related').should have(1).items
+      end
 
-          # The class on which to call search_for
-          ::Foo = ScopedSearch::Spec::Database.create_model(:foo => :string) do |klass|
-            klass.has_one :bar
-            klass.scoped_search :in => :bar, :on => :related
-          end
+    end
 
-          @foo_1 = ::Foo.create!(:foo => 'foo')
-          @foo_2 = ::Foo.create!(:foo => 'foo too')
-          @foo_3 = ::Foo.create!(:foo => 'foo three')
+    context 'querying a :has_one relation' do
 
-          ::Bar.create!(:related => 'bar',         :foo => @foo_1)
-          ::Bar.create!(:related => 'other bar',   :foo => @foo_2)
-        end
+      before do
 
-        after(:all) do
-          ScopedSearch::Spec::Database.drop_model(::Bar)
-          ScopedSearch::Spec::Database.drop_model(::Foo)
-          Object.send :remove_const, :Foo
-          Object.send :remove_const, :Bar
-        end
+        # The related class
+        ActiveRecord::Migration.drop_table(:cars) rescue nil
+        ActiveRecord::Migration.create_table(:cars) { |t| t.string :related; t.integer :hoo_id }
+        class Car < ActiveRecord::Base; belongs_to :hoo; end
 
-        it "should find all records with a bar record containing 'bar" do
-          ::Foo.search_for('bar').should have(2).items
+        # The class on which to call search_for
+        ActiveRecord::Migration.create_table(:hoos) { |t| t.string :foo }
+        class Hoo < ActiveRecord::Base
+          has_one :car
+          scoped_search :on => :foo
+          scoped_search :in => :car, :on => :related
         end
 
-        it "should find the only record with the bar record has the exact value 'bar" do
-          ::Foo.search_for('= bar').should have(1).item
-        end
+        @hoo_1 = Hoo.create!(:foo => 'foo')
+        @hoo_2 = Hoo.create!(:foo => 'foo too')
+        @hoo_3 = Hoo.create!(:foo => 'foo three')
 
-        it "should find all records for which the related bar record exists" do
-          ::Foo.search_for('set? related').should have(2).items
-        end
+        Car.create!(:related => 'bar',         :hoo => @hoo_1)
+        Car.create!(:related => 'other bar',   :hoo => @hoo_2)
+      end
 
-        it "should find all records for which the related bar record does not exist" do
-          ::Foo.search_for('null? related').should have(1).items
-        end
+      after do
+        ScopedSearch::RSpec::Database.drop_model(Car)
+        ScopedSearch::RSpec::Database.drop_model(Hoo)
       end
 
-      context 'querying a :has_and_belongs_to_many relation' do
+      it "should find all records with a car record containing 'bar" do
+        Hoo.search_for('bar').should have(2).items
+      end
 
-        before(:all) do
+      it "should find the only record with the bar record has the exact value 'bar" do
+        Hoo.search_for('= bar').should have(1).item
+      end
 
-          # Create some tables
-          ActiveRecord::Migration.create_table(:bars) { |t| t.string :related }
-          ActiveRecord::Migration.create_table(:bars_foos, :id => false) { |t| t.integer :foo_id; t.integer :bar_id }
-          ActiveRecord::Migration.create_table(:foos) { |t| t.string :foo }
+      it "should find all records for which the related bar record exists" do
+        Hoo.search_for('set? related').should have(2).items
+      end
 
-          # The related class
-          class ::Bar < ActiveRecord::Base; end
+      it "should find all records for which the related bar record does not exist" do
+        Hoo.search_for('null? related').should have(1).items
+      end
+    end
 
-          # The class on which to call search_for
-          class ::Foo < ActiveRecord::Base
-            has_and_belongs_to_many :bars
-            scoped_search :in => :bars, :on => :related
-          end
+    context 'querying a :has_and_belongs_to_many relation' do
 
-          @foo_1 = ::Foo.create!(:foo => 'foo')
-          @foo_2 = ::Foo.create!(:foo => 'foo too')
-          @foo_3 = ::Foo.create!(:foo => 'foo three')
+      before do
 
-          @bar_1 = ::Bar.create!(:related => 'bar')
-          @bar_2 = ::Bar.create!(:related => 'other bar')
-          @bar_3 = ::Bar.create!(:related => 'last bar')
+        # Create some tables
+        ActiveRecord::Migration.create_table(:dars) { |t| t.string :related }
+        ActiveRecord::Migration.create_table(:dars_joos, :id => false) { |t| t.integer :joo_id; t.integer :dar_id }
+        ActiveRecord::Migration.create_table(:joos) { |t| t.string :foo }
 
-          @foo_1.bars << @bar_1 << @bar_2
-          @foo_2.bars << @bar_2 << @bar_3
-        end
+        # The related class
+        class Dar < ActiveRecord::Base; end
 
-        after(:all) do
-          ActiveRecord::Migration.drop_table(:bars_foos)
-          ActiveRecord::Migration.drop_table(:bars)
-          ActiveRecord::Migration.drop_table(:foos)
-          Object.send :remove_const, :Foo
-          Object.send :remove_const, :Bar
+        # The class on which to call search_for
+        class Joo < ActiveRecord::Base
+          has_and_belongs_to_many :dars
+          scoped_search :in => :dars, :on => :related
         end
 
-        it "should find all records with at least one associated bar record containing 'bar'" do
-          ::Foo.search_for('bar').should have(2).items
-        end
+        @joo_1 = Joo.create!(:foo => 'foo')
+        @joo_2 = Joo.create!(:foo => 'foo too')
+        @joo_3 = Joo.create!(:foo => 'foo three')
 
-        it "should find record which is related to @bar_1" do
-          ::Foo.search_for('= bar').should have(1).items
-        end
+        @dar_1 = Dar.create!(:related => 'bar')
+        @dar_2 = Dar.create!(:related => 'other bar')
+        @dar_3 = Dar.create!(:related => 'last bar')
 
-        it "should find the only record related to @bar_3" do
-          ::Foo.search_for('last').should have(1).items
-        end
+        @joo_1.dars << @dar_1 << @dar_2
+        @joo_2.dars << @dar_2 << @dar_3
+      end
 
-        it "should find all records that are related to @bar_2" do
-          ::Foo.search_for('other').should have(2).items
-        end
+      after do
+        ActiveRecord::Migration.drop_table(:dars_joos)
+        ActiveRecord::Migration.drop_table(:dars)
+        ActiveRecord::Migration.drop_table(:joos)
       end
 
-      context 'querying a :has_many => :through relation' do
+      it "should find all records with at least one associated bar record containing 'bar'" do
+        Joo.search_for('bar').should have(2).items
+      end
 
-        before(:all) do
+      it "should find record which is related to @bar_1" do
+        Joo.search_for('= bar').should have(1).items
+      end
 
-          # Create some tables
-          ActiveRecord::Migration.create_table(:bars) { |t| t.integer :foo_id; t.integer :baz_id }
-          ActiveRecord::Migration.create_table(:bazs) { |t| t.string :related }
-          ActiveRecord::Migration.create_table(:foos) { |t| t.string :foo }
+      it "should find the only record related to @bar_3" do
+        Joo.search_for('last').should have(1).items
+      end
 
-          # The related classes
-          class ::Bar < ActiveRecord::Base; belongs_to :baz; belongs_to :foo; end
-          class ::Baz < ActiveRecord::Base; has_many :bars; end
+      it "should find all records that are related to @bar_2" do
+        Joo.search_for('other').should have(2).items
+      end
+    end
 
-          # The class on which to call search_for
-          class ::Foo < ActiveRecord::Base
-            has_many :bars
-            has_many :bazs, :through => :bars
+    context 'querying a :has_many => :through relation' do
 
-            scoped_search :in => :bazs, :on => :related
-          end
+      before do
 
-          @foo_1 = ::Foo.create!(:foo => 'foo')
-          @foo_2 = ::Foo.create!(:foo => 'foo too')
-          @foo_3 = ::Foo.create!(:foo => 'foo three')
+        # Create some tables
+        ActiveRecord::Migration.create_table(:mars) { |t| t.integer :koo_id; t.integer :baz_id }
+        ActiveRecord::Migration.create_table(:bazs) { |t| t.string :related }
+        ActiveRecord::Migration.create_table(:koos) { |t| t.string :foo }
 
-          @baz_1 = ::Baz.create(:related => 'baz')
-          @baz_2 = ::Baz.create(:related => 'baz too!')
+        # The related classes
+        class Mar < ActiveRecord::Base; belongs_to :baz; belongs_to :koo; end
+        class Baz < ActiveRecord::Base; has_many :mars; end
 
-          @bar_1 = ::Bar.create!(:foo => @foo_1, :baz => @baz_1)
-          @bar_2 = ::Bar.create!(:foo => @foo_1)
-          @bar_3 = ::Bar.create!(:foo => @foo_2, :baz => @baz_1)
-          @bar_3 = ::Bar.create!(:foo => @foo_2, :baz => @baz_2)
-          @bar_3 = ::Bar.create!(:foo => @foo_2, :baz => @baz_2)
-          @bar_4 = ::Bar.create!(:foo => @foo_3)
-        end
+        # The class on which to call search_for
+        class Koo < ActiveRecord::Base
+          has_many :mars
+          has_many :bazs, :through => :mars
 
-        after(:all) do
-          ActiveRecord::Migration.drop_table(:bazs)
-          ActiveRecord::Migration.drop_table(:bars)
-          ActiveRecord::Migration.drop_table(:foos)
-          Object.send :remove_const, :Foo
-          Object.send :remove_const, :Bar
-          Object.send :remove_const, :Baz
+          scoped_search :in => :bazs, :on => :related
         end
 
-        it "should find the two records that are related to a baz record" do
-          ::Foo.search_for('baz').should have(2).items
-        end
+        @koo_1 = Koo.create!(:foo => 'foo')
+        @koo_2 = Koo.create!(:foo => 'foo too')
+        @koo_3 = Koo.create!(:foo => 'foo three')
+
+        @baz_1 = Baz.create(:related => 'baz')
+        @baz_2 = Baz.create(:related => 'baz too!')
+
+        @bar_1 = Mar.create!(:koo => @koo_1, :baz => @baz_1)
+        @bar_2 = Mar.create!(:koo => @koo_1)
+        @bar_3 = Mar.create!(:koo => @koo_2, :baz => @baz_1)
+        @bar_3 = Mar.create!(:koo => @koo_2, :baz => @baz_2)
+        @bar_3 = Mar.create!(:koo => @koo_2, :baz => @baz_2)
+        @bar_4 = Mar.create!(:koo => @koo_3)
+      end
+
+      after do
+        ActiveRecord::Migration.drop_table(:bazs)
+        ActiveRecord::Migration.drop_table(:mars)
+        ActiveRecord::Migration.drop_table(:koos)
+      end
+
+      it "should find the two records that are related to a baz record" do
+        Koo.search_for('baz').should have(2).items
       end
     end
   end
-else
-  puts
-  puts "WARNING:"
-  puts "Currently, relationships querying is only 100% supported on Rails 2.x. Use at your own risk when using Rails 3."
-  puts
 end