scoped_search 2.2.0 → 2.2.1

data/README.rdoc

@@ -10,24 +10,6 @@ and build a query based on the search string they enter. If you want to build a
 more complex search form with multiple fields, searchlogic (see
 http://github.com/binarylogic/searchlogic) may be a good choice for you.
 
-=== Usage
-
-If you include a :profile parameter in scoped_search, the fields specified will only
-be search when you pass :profile into the search_for command:
-
-  class User < ActiveRecord::Base
-    scoped_search :on => :public_information
-    scoped_search :on => :private_information, :profile => :members
-  end
-  
-This will only search the :public_information column:
-
-  User.search_for('blah blah blah')
-  
-And this will only search the :private_information column:
-
-  User.search_for('blah blah blah', :profile => :members)
-
 == Installing
 
 The recommended method to enable scoped search in your project is adding the
@@ -54,7 +36,7 @@ Scoped search requires you to define the fields you want to search in:
 
 For more information about options and using fields from relations, see the
 project wiki on search definitions:
-http://wiki.github.com/wvanbergen/scoped_search/search-definition
+http://github.com/wvanbergen/scoped_search/wiki/search-definition
 
 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
@@ -73,8 +55,28 @@ actually chain the call with other scopes, or with will_paginate. An example:
   # using chained named_scopes and will_paginate in your controller
   Project.public.search_for(params[:q]).paginate(:page => params[:page], :include => :tasks)
 
+=== Search profiles
+
+If you include a :profile option to the scoped_searchcall, the fields specified will only
+be searched when you include this :profile into the search_for command as well:
+
+  class User < ActiveRecord::Base
+    scoped_search :on => :public_information
+    scoped_search :on => :private_information, :profile => :members
+  end
+
+This will only search the :public_information column:
+
+  User.search_for('blah blah blah')
+  
+And this will only search the :private_information column:
+
+  User.search_for('blah blah blah', :profile => :members)
+
+=== More information
+
 More information about usage can be found in the project wiki:
-http://wiki.github.com/wvanbergen/scoped_search/usage
+http://github.com/wvanbergen/scoped_search/wiki/usage
 
 == Query language
 
@@ -108,12 +110,13 @@ nickname:
 
   ("Ruby" OR "Rails") -cobol, age >= 18, updated_at > 2009-01-01 && nickname !~ l33t
 
-For more info, see the the project wiki: http://wiki.github.com/wvanbergen/scoped_search/query-language
+For more info, see the the project wiki: http://github.com/wvanbergen/scoped_search/wiki/query-language
 
 == Additional resources
 
 * Source code: http://github.com/wvanbergen/scoped_search/tree
-* Project wiki: http://wiki.github.com/wvanbergen/scoped_search
+* Project wiki: http://github.com/wvanbergen/scoped_search/wiki
+* Issue tracker: http://github.com/wvanbergen/scoped_search/issues
 * RDoc documentation: http://rdoc.info/projects/wvanbergen/scoped_search
 * wvanbergen's blog posts: http://techblog.floorplanner.com/tag/scoped_search
 

data/lib/scoped_search.rb

@@ -12,7 +12,7 @@ module ScopedSearch
 
   # The current scoped_search version. Do not change thisvalue by hand,
   # because it will be updated automatically by the gem release script.
-  VERSION = "2.2.0"
+  VERSION = "2.2.1"
 
   # The ClassMethods module will be included into the ActiveRecord::Base class
   # to add the <tt>ActiveRecord::Base.scoped_search</tt> method and the

data/lib/scoped_search/query_language/parser.rb

@@ -18,6 +18,7 @@ module ScopedSearch::QueryLanguage::Parser
   # Start the parsing process by parsing an expression sequence
   def parse
     @tokens = tokenize
+    @tokens.delete_at(@tokens.size - 1) if @tokens.last.is_a?(Symbol)
     parse_expression_sequence(true).simplify
   end
 

data/scoped_search.gemspec

@@ -3,30 +3,35 @@ Gem::Specification.new do |s|
   
   # Do not change the version and date fields by hand. This will be done
   # automatically by the gem release script.
-  s.version = "2.2.0"
-  s.date    = "2010-05-26"
+  s.version = "2.2.1"
+  s.date    = "2010-11-09"
 
   s.summary = "Easily search you ActiveRecord models with a simple query language using a named scope."
   s.description = <<-EOS
     Scoped search makes it easy to search your ActiveRecord-based models.
+    
     It will create a named scope :search_for that can be called with a query string. It will build an SQL query using
     the provided query string and a definition that specifies on what fields to search. Because the functionality is
     built on named_scope, the result of the search_for call can be used like any other named_scope, so it can be
-    chained with another scope or combined with will_paginate."
+    chained with another scope or combined with will_paginate.
+    
+    Because it uses standard SQL, it does not require any setup, indexers or daemons. This makes scoped_search
+    suitable to quickly add basic search functionality to your application with little hassle. On the other hand,
+    it may not be the best choice if it is going to be used on very large datasets or by a large user base.
   EOS
 
   s.authors  = ['Willem van Bergen', 'Wes Hays']
   s.email    = ['willem@railsdoctors.com', 'weshays@gbdev.com']
-  s.homepage = 'http://wiki.github.com/wvanbergen/scoped_search'
+  s.homepage = 'http://github.com/wvanbergen/scoped_search/wiki'
 
   s.add_runtime_dependency('activerecord', '>= 2.1.0')
-  s.add_development_dependency('rspec', '>= 1.1.4')
+  s.add_development_dependency('rspec', '~> 2.0')
 
   s.rdoc_options << '--title' << s.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
   s.extra_rdoc_files = ['README.rdoc']
 
   # Do not change the files and test_files fields by hand. This will be done
   # automatically by the gem release script.
-  s.files      = %w(spec/spec_helper.rb spec/integration/string_querying_spec.rb lib/scoped_search/definition.rb spec/lib/mocks.rb scoped_search.gemspec lib/scoped_search/query_language/parser.rb spec/lib/matchers.rb .gitignore LICENSE spec/unit/ast_spec.rb spec/database.yml init.rb Rakefile spec/unit/tokenizer_spec.rb spec/unit/parser_spec.rb spec/integration/api_spec.rb lib/scoped_search/query_language/ast.rb lib/scoped_search/query_language.rb lib/scoped_search/query_builder.rb README.rdoc spec/unit/definition_spec.rb spec/lib/database.rb spec/integration/profile_querying_spec.rb tasks/github-gem.rake spec/unit/query_builder_spec.rb lib/scoped_search.rb spec/integration/relation_querying_spec.rb spec/integration/ordinal_querying_spec.rb lib/scoped_search/query_language/tokenizer.rb)
-  s.test_files = %w(spec/integration/string_querying_spec.rb spec/unit/ast_spec.rb spec/unit/tokenizer_spec.rb spec/unit/parser_spec.rb spec/integration/api_spec.rb spec/unit/definition_spec.rb spec/integration/profile_querying_spec.rb spec/unit/query_builder_spec.rb spec/integration/relation_querying_spec.rb spec/integration/ordinal_querying_spec.rb)
+  s.files      = %w(.gitignore LICENSE README.rdoc Rakefile init.rb lib/scoped_search.rb lib/scoped_search/definition.rb lib/scoped_search/query_builder.rb lib/scoped_search/query_language.rb lib/scoped_search/query_language/ast.rb lib/scoped_search/query_language/parser.rb lib/scoped_search/query_language/tokenizer.rb scoped_search.gemspec spec/database.yml spec/integration/api_spec.rb spec/integration/ordinal_querying_spec.rb spec/integration/profile_querying_spec.rb spec/integration/relation_querying_spec.rb spec/integration/string_querying_spec.rb spec/lib/database.rb spec/lib/matchers.rb spec/lib/mocks.rb spec/spec_helper.rb spec/unit/ast_spec.rb spec/unit/definition_spec.rb spec/unit/parser_spec.rb spec/unit/query_builder_spec.rb spec/unit/tokenizer_spec.rb tasks/github-gem.rake)
+  s.test_files = %w(spec/integration/api_spec.rb spec/integration/ordinal_querying_spec.rb spec/integration/profile_querying_spec.rb spec/integration/relation_querying_spec.rb spec/integration/string_querying_spec.rb spec/unit/ast_spec.rb spec/unit/definition_spec.rb spec/unit/parser_spec.rb spec/unit/query_builder_spec.rb spec/unit/tokenizer_spec.rb)
 end

data/spec/integration/api_spec.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
+require 'spec_helper'
 
 describe ScopedSearch, "API" do
 
@@ -14,11 +14,11 @@ describe ScopedSearch, "API" do
   # be changed for new major releases.
 
   before(:all) do
-    ScopedSearch::Spec::Database.establish_connection
+    ScopedSearch::RSpec::Database.establish_connection
   end
 
   after(:all) do
-    ScopedSearch::Spec::Database.close_connection
+    ScopedSearch::RSpec::Database.close_connection
   end
 
   context 'for unprepared ActiveRecord model' do
@@ -31,13 +31,13 @@ describe ScopedSearch, "API" do
   context 'for a prepared ActiveRecord model' do
 
     before(:all) do
-      @class = ScopedSearch::Spec::Database.create_model(:field => :string) do |klass|
+      @class = ScopedSearch::RSpec::Database.create_model(:field => :string) do |klass|
         klass.scoped_search :on => :field
       end
     end
 
     after(:all) do
-      ScopedSearch::Spec::Database.drop_model(@class)
+      ScopedSearch::RSpec::Database.drop_model(@class)
     end
 
     it "should respond to :search_for to perform searches" do
@@ -62,7 +62,7 @@ describe ScopedSearch, "API" do
   context 'having backwards compatibility' do
 
     before(:each) do
-      class Foo < ActiveRecord::Base
+      class ::Foo < ActiveRecord::Base
         belongs_to :bar
       end
     end

data/spec/integration/ordinal_querying_spec.rb

@@ -1,23 +1,23 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
+require '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.
-ScopedSearch::Spec::Database.test_databases.each do |db|
+ScopedSearch::RSpec::Database.test_databases.each do |db|
   
   describe ScopedSearch, "using a #{db} database" do
 
     before(:all) do
-      ScopedSearch::Spec::Database.establish_named_connection(db)
+      ScopedSearch::RSpec::Database.establish_named_connection(db)
 
-      @class = ScopedSearch::Spec::Database.create_model(:int => :integer, :timestamp => :datetime, :date => :date, :unindexed => :integer) do |klass|
+      @class = ScopedSearch::RSpec::Database.create_model(:int => :integer, :timestamp => :datetime, :date => :date, :unindexed => :integer) do |klass|
         klass.scoped_search :on => [:int, :timestamp]
         klass.scoped_search :on => :date, :only_explicit => true
       end
     end
 
     after(:all) do
-      ScopedSearch::Spec::Database.drop_model(@class)
-      ScopedSearch::Spec::Database.close_connection
+      ScopedSearch::RSpec::Database.drop_model(@class)
+      ScopedSearch::RSpec::Database.close_connection
     end
 
     context 'quering numerical fields' do

data/spec/integration/profile_querying_spec.rb

@@ -1,15 +1,15 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
+require '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.
-ScopedSearch::Spec::Database.test_databases.each do |db|
+ScopedSearch::RSpec::Database.test_databases.each do |db|
 
   describe ScopedSearch, "using a #{db} database" do
 
     before(:all) do
-      ScopedSearch::Spec::Database.establish_named_connection(db)
+      ScopedSearch::RSpec::Database.establish_named_connection(db)
     
-      @class = ScopedSearch::Spec::Database.create_model(:public => :string, :private => :string, :useless => :string) do |klass|
+      @class = ScopedSearch::RSpec::Database.create_model(:public => :string, :private => :string, :useless => :string) do |klass|
         klass.scoped_search :on => :public
         klass.scoped_search :on => :private, :profile => :private_profile
         klass.scoped_search :on => :useless, :profile => :another_profile
@@ -21,8 +21,8 @@ ScopedSearch::Spec::Database.test_databases.each do |db|
     end
 
     after(:all) do
-      ScopedSearch::Spec::Database.drop_model(@class)
-      ScopedSearch::Spec::Database.close_connection
+      ScopedSearch::RSpec::Database.drop_model(@class)
+      ScopedSearch::RSpec::Database.close_connection
     end
 
     context "searching without profile specified" do

data/spec/integration/relation_querying_spec.rb

@@ -1,262 +1,265 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
+require '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.
-ScopedSearch::Spec::Database.test_databases.each do |db|
+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|
 
-  describe ScopedSearch, "using a #{db} database" do
+    describe ScopedSearch, "using a #{db} database" do
 
-    before(:all) do
-      ScopedSearch::Spec::Database.establish_named_connection(db)
-    end
+      before(:all) do
+        ScopedSearch::RSpec::Database.establish_named_connection(db)
+      end
 
-    after(:all) do
-      ScopedSearch::Spec::Database.close_connection
-    end
+      after(:all) do
+        ScopedSearch::RSpec::Database.close_connection
+      end
 
-    context 'querying a :belongs_to relation' do
+      context 'querying a :belongs_to relation' do
 
-      before(:all) do
+        before(:all) do
+
+          # The related class
+          ActiveRecord::Migration.create_table(:bars) { |t| t.string :related }
+          class ::Bar < ActiveRecord::Base; has_many :foos; 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
 
-        # The related class
-        ActiveRecord::Migration.create_table(:bars) { |t| t.string :related }
-        class Bar < ActiveRecord::Base; has_many :foos; end
+          @bar_record = Bar.create!(:related => 'bar')
 
-        # 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
+          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')
         end
 
-        @bar_record = Bar.create!(:related => 'bar')
+        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
 
-        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')
-      end
+        it "should find all records with a related bar record containing bar" do
+          Foo.search_for('bar').should have(3).items
+        end
 
-      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
+        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
 
-      it "should find all records with a related bar record containing bar" do
-        Foo.search_for('bar').should have(3).items
+        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
       end
 
-      it "should find all records with a related bar record having an exact value of bar" do
-        Foo.search_for('= bar').should have(2).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
-         Foo.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
-        Foo.search_for('null? related').should have(1).items
-      end
-    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
 
-    context 'querying a :has_many relation' do
+          # 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
 
-      before(:all) do
+          @foo_1 = Foo.create!(:foo => 'foo')
+          @foo_2 = Foo.create!(:foo => 'foo too')
+          @foo_3 = Foo.create!(:foo => 'foo three')
 
-        # The related class
-        ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id }
-        class Bar < ActiveRecord::Base; belongs_to :foo; end
+          Bar.create!(:related => 'bar',         :foo => @foo_1)
+          Bar.create!(:related => 'another bar', :foo => @foo_1)
+          Bar.create!(:related => 'other bar',   :foo => @foo_2)
+        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
+        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
 
-        @foo_1 = Foo.create!(:foo => 'foo')
-        @foo_2 = Foo.create!(:foo => 'foo too')
-        @foo_3 = Foo.create!(:foo => 'foo three')
+        it "should find all records with at least one bar record containing 'bar'" do
+          Foo.search_for('bar').should have(2).items
+        end
 
-        Bar.create!(:related => 'bar',         :foo => @foo_1)
-        Bar.create!(:related => 'another bar', :foo => @foo_1)
-        Bar.create!(:related => 'other bar',   :foo => @foo_2)
-      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
 
-      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
+        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
 
-      it "should find all records with at least one bar record containing 'bar'" do
-        Foo.search_for('bar').should have(2).items
-      end
+        it "should find all records for which none related bar records exist" do
+          Foo.search_for('null? related').should have(1).items
+        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
 
-      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
+      context 'querying a :has_one relation' do
 
-      it "should find all records for which none related bar records exist" do
-        Foo.search_for('null? related').should have(1).items
-      end
+        before(:all) do
 
-    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
 
-    context 'querying a :has_one relation' do
+          # 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
 
-      before(:all) do
+          @foo_1 = ::Foo.create!(:foo => 'foo')
+          @foo_2 = ::Foo.create!(:foo => 'foo too')
+          @foo_3 = ::Foo.create!(:foo => 'foo three')
 
-        # The related class
-        ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id }
-        class Bar < ActiveRecord::Base; belongs_to :foo; end
+          ::Bar.create!(:related => 'bar',         :foo => @foo_1)
+          ::Bar.create!(:related => 'other bar',   :foo => @foo_2)
+        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
+        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
 
-        @foo_1 = Foo.create!(:foo => 'foo')
-        @foo_2 = Foo.create!(:foo => 'foo too')
-        @foo_3 = Foo.create!(:foo => 'foo three')
+        it "should find all records with a bar record containing 'bar" do
+          ::Foo.search_for('bar').should have(2).items
+        end
 
-        Bar.create!(:related => 'bar',         :foo => @foo_1)
-        Bar.create!(:related => 'other bar',   :foo => @foo_2)
-      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
 
-      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
+        it "should find all records for which the related bar record exists" do
+          ::Foo.search_for('set? related').should have(2).items
+        end
 
-      it "should find all records with a bar record containing 'bar" do
-        Foo.search_for('bar').should have(2).items
+        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
       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
+      context 'querying a :has_and_belongs_to_many relation' do
 
-      it "should find all records for which the related bar record exists" do
-        Foo.search_for('set? related').should have(2).items
-      end
+        before(:all) do
 
-      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
-    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 }
 
-    context 'querying a :has_and_belongs_to_many relation' do
+          # The related class
+          class ::Bar < ActiveRecord::Base; end
 
-      before(:all) do
+          # 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
 
-        # 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 }
+          @foo_1 = ::Foo.create!(:foo => 'foo')
+          @foo_2 = ::Foo.create!(:foo => 'foo too')
+          @foo_3 = ::Foo.create!(:foo => 'foo three')
 
-        # The related class
-        class Bar < ActiveRecord::Base; end
+          @bar_1 = ::Bar.create!(:related => 'bar')
+          @bar_2 = ::Bar.create!(:related => 'other bar')
+          @bar_3 = ::Bar.create!(:related => 'last bar')
 
-        # The class on which to call search_for
-        class Foo < ActiveRecord::Base
-          has_and_belongs_to_many :bars
-          scoped_search :in => :bars, :on => :related
+          @foo_1.bars << @bar_1 << @bar_2
+          @foo_2.bars << @bar_2 << @bar_3
         end
 
-        @foo_1 = Foo.create!(:foo => 'foo')
-        @foo_2 = Foo.create!(:foo => 'foo too')
-        @foo_3 = Foo.create!(:foo => 'foo three')
+        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
+        end
 
-        @bar_1 = Bar.create!(:related => 'bar')
-        @bar_2 = Bar.create!(:related => 'other bar')
-        @bar_3 = Bar.create!(:related => 'last bar')
+        it "should find all records with at least one associated bar record containing 'bar'" do
+          ::Foo.search_for('bar').should have(2).items
+        end
 
-        @foo_1.bars << @bar_1 << @bar_2
-        @foo_2.bars << @bar_2 << @bar_3
-      end
+        it "should find record which is related to @bar_1" do
+          ::Foo.search_for('= bar').should have(1).items
+        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
-      end
+        it "should find the only record related to @bar_3" do
+          ::Foo.search_for('last').should have(1).items
+        end
 
-      it "should find all records with at least one associated bar record containing 'bar'" do
-        Foo.search_for('bar').should have(2).items
+        it "should find all records that are related to @bar_2" do
+          ::Foo.search_for('other').should have(2).items
+        end
       end
 
-      it "should find record which is related to @bar_1" do
-        Foo.search_for('= bar').should have(1).items
-      end
+      context 'querying a :has_many => :through relation' do
 
-      it "should find the only record related to @bar_3" do
-        Foo.search_for('last').should have(1).items
-      end
+        before(:all) do
 
-      it "should find all records that are related to @bar_2" do
-        Foo.search_for('other').should have(2).items
-      end
-    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 }
 
-    context 'querying a :has_many => :through relation' do
+          # The related classes
+          class ::Bar < ActiveRecord::Base; belongs_to :baz; belongs_to :foo; end
+          class ::Baz < ActiveRecord::Base; has_many :bars; end
 
-      before(:all) do
+          # The class on which to call search_for
+          class ::Foo < ActiveRecord::Base
+            has_many :bars
+            has_many :bazs, :through => :bars
 
-        # 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 }
+            scoped_search :in => :bazs, :on => :related
+          end
 
-        # The related classes
-        class Bar < ActiveRecord::Base; belongs_to :baz; belongs_to :foo; end
-        class Baz < ActiveRecord::Base; has_many :bars; end
+          @foo_1 = ::Foo.create!(:foo => 'foo')
+          @foo_2 = ::Foo.create!(:foo => 'foo too')
+          @foo_3 = ::Foo.create!(:foo => 'foo three')
 
-        # The class on which to call search_for
-        class Foo < ActiveRecord::Base
-          has_many :bars
-          has_many :bazs, :through => :bars
+          @baz_1 = ::Baz.create(:related => 'baz')
+          @baz_2 = ::Baz.create(:related => 'baz too!')
 
-          scoped_search :in => :bazs, :on => :related
+          @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
 
-        @foo_1 = Foo.create!(:foo => 'foo')
-        @foo_2 = Foo.create!(:foo => 'foo too')
-        @foo_3 = Foo.create!(:foo => 'foo three')
-
-        @baz_1 = Baz.create(:related => 'baz')
-        @baz_2 = Baz.create(:related => 'baz too!')
-
-        @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
-
-      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
-      end
+        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
+        end
 
-      it "should find the two records that are related to a baz record" do
-        Foo.search_for('baz').should have(2).items
+        it "should find the two records that are related to a baz record" do
+          ::Foo.search_for('baz').should have(2).items
+        end
       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