thinking-sphinx 1.5.0 → 2.0.0.rc1

data/spec/thinking_sphinx/association_spec.rb

@@ -44,30 +44,12 @@ describe ThinkingSphinx::Association do
     end
     
     it "should generate non-polymorphic 'casted' associations for each polymorphic possibility" do
-      Person.stub!(:reflect_on_association).exactly(3).times.
-        and_return(@poly_reflection, nil, nil)
+      Person.stub!(:reflect_on_association => @poly_reflection)
       ThinkingSphinx::Association.should_receive(:casted_options).with(
         Person, @poly_reflection
       ).twice
       ::ActiveRecord::Reflection::AssociationReflection.should_receive(:new).
-        with(:has_many, :polly_Person, {:casted => :options}, "AR").twice.
-        and_return(@non_poly_reflection)
-      ThinkingSphinx::Association.should_receive(:new).with(
-        nil, @non_poly_reflection
-      ).twice
-      
-      ThinkingSphinx::Association.children(Person, :assoc)
-    end
-    
-    it "should use existing non-polymorphic 'casted' associations" do
-      Person.stub!(:reflect_on_association).exactly(3).times.
-        and_return(@poly_reflection, nil, @non_poly_reflection)
-      ThinkingSphinx::Association.should_receive(:casted_options).with(
-        Person, @poly_reflection
-      ).once
-      ::ActiveRecord::Reflection::AssociationReflection.should_receive(:new).
-        with(:has_many, :polly_Person, {:casted => :options}, "AR").once.
-        and_return(@non_poly_reflection)
+        with(:has_many, :polly_Person, {:casted => :options}, "AR").twice
       ThinkingSphinx::Association.should_receive(:new).with(
         nil, @non_poly_reflection
       ).twice

data/spec/thinking_sphinx/attribute_spec.rb

@@ -68,22 +68,13 @@ describe ThinkingSphinx::Attribute do
       
       attribute.to_select_sql.should == "CONCAT_WS(' ', IFNULL(`cricket_teams`.`name`, ''), IFNULL(`football_teams`.`name`, ''), IFNULL(`football_teams`.`league`, '')) AS `team`"
     end
-    
-    it "should return nil if polymorphic association data does not exist" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:source, :id)],
-        :as => :source_id, :type => :integer
-      )
-      
-      attribute.to_select_sql.should be_nil
-    end
   end
   
   describe '#is_many?' do
     before :each do
-      @assoc_a = ThinkingSphinx::Association.new(nil, nil)
-      @assoc_b = ThinkingSphinx::Association.new(nil, nil)
-      @assoc_c = ThinkingSphinx::Association.new(nil, nil)
+      @assoc_a = stub('assoc', :is_many? => true)
+      @assoc_b = stub('assoc', :is_many? => true)
+      @assoc_c = stub('assoc', :is_many? => true)
       
       @attribute = ThinkingSphinx::Attribute.new(
         @source, [ThinkingSphinx::Index::FauxColumn.new(:col_name)]
@@ -91,9 +82,6 @@ describe ThinkingSphinx::Attribute do
       @attribute.associations = {
         :a => @assoc_a, :b => @assoc_b, :c => @assoc_c
       }
-      @attribute.associations.values.each { |assoc|
-        assoc.stub!(:is_many? => true)
-      }
     end
     
     it "should return true if all associations return true to is_many?" do
@@ -298,176 +286,184 @@ describe ThinkingSphinx::Attribute do
   end
   
   describe "MVA with source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-      :as => :tag_ids, :source => :query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+        :as => :tag_ids, :source => :query
+      )
+    end
     
     it "should use a query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query = attribute.config_value.split('; ')
+      declaration, query = @attribute.config_value.split('; ')
       declaration.should == "uint tag_ids from query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags`"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags`"
     end
   end
   
   describe "MVA with source query for a delta source" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-      :as => :tag_ids, :source => :query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+        :as => :tag_ids, :source => :query
+      )
+    end
     
     it "should use a query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query = attribute.config_value(nil, true).split('; ')
+      declaration, query = @attribute.config_value(nil, true).split('; ')
       declaration.should == "uint tag_ids from query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
     end
   end
   
   describe "MVA via a HABTM association with a source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
-      :as => :link_ids, :source => :query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
+        :as => :link_ids, :source => :query
+      )
+    end
     
     it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query = attribute.config_value.split('; ')
+      declaration, query = @attribute.config_value.split('; ')
       declaration.should == "uint link_ids from query"
-      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people`"
+      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people`"
     end
   end
   
   describe "MVA with ranged source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-      :as => :tag_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+        :as => :tag_ids, :source => :ranged_query
+      )
+    end
     
     it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = attribute.config_value.split('; ')
+      declaration, query, range_query = @attribute.config_value.split('; ')
       declaration.should == "uint tag_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
     end
   end
   
   describe "MVA with ranged source query for a delta source" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-      :as => :tag_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+        :as => :tag_ids, :source => :ranged_query
+      )
+    end
     
     it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = attribute.config_value(nil, true).split('; ')
+      declaration, query, range_query = @attribute.config_value(nil, true).split('; ')
       declaration.should == "uint tag_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end AND `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end AND `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
       range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
     end
   end
   
   describe "MVA via a has-many :through with a ranged source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:football_teams, :id)],
-      :as => :football_team_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:football_teams, :id)],
+        :as => :football_team_ids, :source => :ranged_query
+      )
+    end
     
     it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = attribute.config_value.split('; ')
+      declaration, query, range_query = @attribute.config_value.split('; ')
       declaration.should == "uint football_team_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`football_team_id` AS `football_team_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`football_team_id` AS `football_team_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
     end
   end
   
   describe "MVA via a has-many :through using a foreign key with a ranged source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:friends, :id)],
-      :as => :friend_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:friends, :id)],
+        :as => :friend_ids, :source => :ranged_query
+      )
+    end
     
     it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = attribute.config_value.split('; ')
+      declaration, query, range_query = @attribute.config_value.split('; ')
       declaration.should == "uint friend_ids from ranged-query"
-      query.should       == "SELECT `friendships`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `friendships`.`friend_id` AS `friend_ids` FROM `friendships` WHERE `friendships`.`person_id` >= $start AND `friendships`.`person_id` <= $end"
+      query.should       == "SELECT `friendships`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `friendships`.`friend_id` AS `friend_ids` FROM `friendships` WHERE `friendships`.`person_id` >= $start AND `friendships`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`friendships`.`person_id`), MAX(`friendships`.`person_id`) FROM `friendships`"
     end
   end
   
   describe "MVA via a HABTM with a ranged source query" do
-    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
-      [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
-      :as => :link_ids, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
+        :as => :link_ids, :source => :ranged_query
+      )
+    end
     
     it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = attribute.config_value.split('; ')
+      declaration, query, range_query = @attribute.config_value.split('; ')
       declaration.should == "uint link_ids from ranged-query"
-      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people` WHERE `links_people`.`person_id` >= $start AND `links_people`.`person_id` <= $end"
+      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people` WHERE `links_people`.`person_id` >= $start AND `links_people`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`links_people`.`person_id`), MAX(`links_people`.`person_id`) FROM `links_people`"
     end
   end
   
   describe "MVA via two has-many associations with a ranged source query" do
-    let(:index)     { ThinkingSphinx::Index.new(Alpha) }
-    let(:source)    { ThinkingSphinx::Source.new(index) }
-    let(:attribute) { ThinkingSphinx::Attribute.new(source,
-      [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
-      :as => :gamma_values, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
+    before :each do
+      @index  = ThinkingSphinx::Index.new(Alpha)
+      @source = ThinkingSphinx::Source.new(@index)
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
+        :as => :gamma_values, :source => :ranged_query
+      )
+    end
     
     it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = attribute.config_value.split('; ')
+      declaration, query, range_query = @attribute.config_value.split('; ')
       declaration.should == "uint gamma_values from ranged-query"
-      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON gammas.beta_id = betas.id WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end"
+      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON `gammas`.`beta_id` = `betas`.`id` WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end"
       range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
     end
   end
   
   describe "MVA via two has-many associations with a ranged source query for a delta source" do
-    let(:index)     { ThinkingSphinx::Index.new(Alpha) }
-    let(:source)    { ThinkingSphinx::Source.new(index) }
-    let(:attribute) { ThinkingSphinx::Attribute.new(source,
-      [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
-      :as => :gamma_values, :source => :ranged_query)
-    }
-    let(:adapter)   { attribute.send(:adapter) }
-      
     before :each do
-      index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new index, index.local_options
+      @index  = ThinkingSphinx::Index.new(Alpha)
+      @source = ThinkingSphinx::Source.new(@index)
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
+        :as => :gamma_values, :source => :ranged_query
+      )
+      
+      @index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new @index, @index.local_options
     end
     
     it "should use a ranged query" do
-      attribute.type_to_config.should == :sql_attr_multi
+      @attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = attribute.config_value(nil, true).split('; ')
+      declaration, query, range_query = @attribute.config_value(nil, true).split('; ')
       declaration.should == "uint gamma_values from ranged-query"
-      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON gammas.beta_id = betas.id WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end AND `betas`.`alpha_id` IN (SELECT `id` FROM `alphas` WHERE `alphas`.`delta` = 1)"
+      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON `gammas`.`beta_id` = `betas`.`id` WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end AND `betas`.`alpha_id` IN (SELECT `id` FROM `alphas` WHERE `alphas`.`delta` = 1)"
       range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
     end
   end

data/spec/thinking_sphinx/auto_version_spec.rb

@@ -5,97 +5,33 @@ describe ThinkingSphinx::AutoVersion do
     before :each do
       @config = ThinkingSphinx::Configuration.instance
     end
-
+    
     it "should require 0.9.8 if that is the detected version" do
       ThinkingSphinx::AutoVersion.should_receive(:require).
         with('riddle/0.9.8')
-
+      
       @config.stub!(:version => '0.9.8')
       ThinkingSphinx::AutoVersion.detect
     end
-
+    
     it "should require 0.9.9 if that is the detected version" do
       ThinkingSphinx::AutoVersion.should_receive(:require).
         with('riddle/0.9.9')
-
+      
       @config.stub!(:version => '0.9.9')
       ThinkingSphinx::AutoVersion.detect
     end
-
-    it "should require 1.10-beta if that is the detected version" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/1.10')
-
-      @config.stub!(:version => '1.10-beta')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 1.10-beta if using 1.10-beta compiled with id64 support" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/1.10')
-
-      @config.stub!(:version => '1.10-id64-beta')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.0.1 if using Sphinx 2.0.1 beta" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.0.1')
-
-      @config.stub!(:version => '2.0.1-beta')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.0.1 if using Sphinx 2.0.2 dev" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.0.1')
-
-      @config.stub!(:version => '2.0.2-dev')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.1.0 if using Sphinx 2.0.3" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.1.0')
-
-      @config.stub!(:version => '2.0.3-release')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.1.0 if using Sphinx 2.0.3" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.1.0')
-
-      @config.stub!(:version => '2.0.4-release')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.1.0 if using Sphinx 2.0.3" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.1.0')
-
-      @config.stub!(:version => '2.0.5-release')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.1.0 if using Sphinx 2.1.0 dev" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.1.0')
-
-      @config.stub!(:version => '2.1.0-dev')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should output a warning if the detected version is unsupported" do
-      STDERR.should_receive(:puts).with(/unsupported/i)
-
+    
+    it "should output a warning if the detected version is something else" do
+      STDERR.should_receive(:puts)
+      
       @config.stub!(:version => '0.9.7')
       ThinkingSphinx::AutoVersion.detect
     end
-
+    
     it "should output a warning if the version cannot be determined" do
-      STDERR.should_receive(:puts).at_least(:once)
-
+      STDERR.should_receive(:puts)
+      
       @config.stub!(:version => nil)
       ThinkingSphinx::AutoVersion.detect
     end

data/spec/thinking_sphinx/configuration_spec.rb

@@ -3,33 +3,22 @@ require 'spec_helper'
 describe ThinkingSphinx::Configuration do
   describe "environment class method" do
     before :each do
-      ThinkingSphinx::Configuration.reset_environment
-
+      Thread.current[:thinking_sphinx_environment] = nil
+      
       ENV["RAILS_ENV"] = nil
     end
 
-    it "should use the Merb environment value if set" do
-      unless defined?(Merb)
-        module ::Merb; end
-      end
-
-      ThinkingSphinx::Configuration.stub!(:defined? => true)
-      Merb.stub!(:environment => "merb_production")
-      ThinkingSphinx::Configuration.environment.should == "merb_production"
-
-      Object.send :remove_const, :Merb
-    end
-
-    it "should use RAILS_ENV if set" do
-      RAILS_ENV = 'global_rails'
-
+    it "should use Rails.env if set" do
+      was = Rails.env
+      Rails.env = 'global_rails'
+      
       ThinkingSphinx::Configuration.environment.should == 'global_rails'
-
-      Object.send :remove_const, :RAILS_ENV
+      
+      Rails.env = was
     end
 
     it "should use the Rails environment value if set" do
-      ENV["RAILS_ENV"] = "rails_production"
+      Rails.stub!(:env => "rails_production")
       ThinkingSphinx::Configuration.environment.should == "rails_production"
     end
 
@@ -37,31 +26,31 @@ describe ThinkingSphinx::Configuration do
       ThinkingSphinx::Configuration.environment.should == "development"
     end
   end
-
+  
   describe '#version' do
     before :each do
       @config = ThinkingSphinx::Configuration.instance
       @config.reset
     end
-
+    
     it "should use the given version from sphinx.yml if there is one" do
-      open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
+      open("#{Rails.root}/config/sphinx.yml", "w") do |f|
         f.write  YAML.dump({'development' => {'version' => '0.9.7'}})
       end
       @config.reset
-
+      
       @config.version.should == '0.9.7'
-
-      FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
+      
+      FileUtils.rm "#{Rails.root}/config/sphinx.yml"
     end
-
+    
     it "should detect the version from Riddle otherwise" do
       controller = @config.controller
       controller.stub!(:sphinx_version => '0.9.6')
-
+      
       Riddle::Controller.stub!(:new => controller)
       @config.reset
-
+      
       @config.version.should == '0.9.6'
     end
   end
@@ -92,7 +81,7 @@ describe ThinkingSphinx::Configuration do
         }
       }
 
-      open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
+      open("#{Rails.root}/config/sphinx.yml", "w") do |f|
         f.write  YAML.dump(@settings)
       end
     end
@@ -108,7 +97,7 @@ describe ThinkingSphinx::Configuration do
     end
 
     after :each do
-      FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
+      FileUtils.rm "#{Rails.root}/config/sphinx.yml"
     end
   end
 
@@ -118,8 +107,6 @@ describe ThinkingSphinx::Configuration do
         config.app_root = "/here/somewhere"
       end
       ThinkingSphinx::Configuration.instance.app_root.should == "/here/somewhere"
-
-      ThinkingSphinx::Configuration.instance.reset
     end
   end
 
@@ -135,14 +122,14 @@ describe ThinkingSphinx::Configuration do
         }
       }
 
-      open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
+      open("#{Rails.root}/config/sphinx.yml", "w") do |f|
         f.write  YAML.dump(@settings)
       end
 
       ThinkingSphinx::Configuration.instance.send(:parse_config)
       ThinkingSphinx::Configuration.instance.bin_path.should match(/\/$/)
 
-      FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
+      FileUtils.rm "#{Rails.root}/config/sphinx.yml"
     end
   end
 
@@ -152,7 +139,7 @@ describe ThinkingSphinx::Configuration do
         "development" => {"disable_range" => true}
       }
 
-      open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
+      open("#{Rails.root}/config/sphinx.yml", "w") do |f|
         f.write  YAML.dump(@settings)
       end
 
@@ -165,13 +152,13 @@ describe ThinkingSphinx::Configuration do
     end
 
     after :each do
-      FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
+      FileUtils.rm "#{Rails.root}/config/sphinx.yml"
     end
   end
 
   it "should insert set index options into the configuration file" do
     config = ThinkingSphinx::Configuration.instance
-
+    
     ThinkingSphinx::Configuration::IndexOptions.each do |option|
       config.reset
       config.index_options[option.to_sym] = "something"
@@ -187,7 +174,7 @@ describe ThinkingSphinx::Configuration do
   it "should insert set source options into the configuration file" do
     config = ThinkingSphinx::Configuration.instance
     config.reset
-
+    
     config.source_options[:sql_query_pre] = ["something"]
     ThinkingSphinx::Configuration::SourceOptions.each do |option|
       config.source_options[option.to_sym] ||= "something"
@@ -198,25 +185,27 @@ describe ThinkingSphinx::Configuration do
 
       config.source_options.delete option.to_sym
     end
-
-    config.source_options[:sql_query_pre] = nil
+    
+    config.source_options[:sql_query_pre] = nil  
   end
-
+  
   it "should not blow away delta or utf options if sql pre is specified in config" do
     config = ThinkingSphinx::Configuration.instance
     config.reset
-
+    
     config.source_options[:sql_query_pre] = ["a pre query"]
     config.build
     file = open(config.config_file) { |f| f.read }
-
+    
     file.should match(/sql_query_pre = a pre query\n\s*sql_query_pre = UPDATE `\w+` SET `delta` = 0 WHERE `delta` = 1/im)
     file.should match(/sql_query_pre = a pre query\n\s*sql_query_pre = \n/im)
-
+    
     config.source_options[:sql_query_pre] = nil
   end
 
   it "should set any explicit prefixed or infixed fields" do
+    ThinkingSphinx::Configuration.instance.build
+    
     file = open(ThinkingSphinx::Configuration.instance.config_file) { |f|
       f.read
     }
@@ -225,38 +214,48 @@ describe ThinkingSphinx::Configuration do
   end
 
   it "should not have prefix fields in indexes where nothing is set" do
+    ThinkingSphinx::Configuration.instance.build
+    
     file = open(ThinkingSphinx::Configuration.instance.config_file) { |f|
       f.read
     }
     file.should_not match(/index alpha_core\s+\{\s+[^\}]*prefix_fields\s+=[^\}]*\}/m)
   end
-
-  describe '#generate' do
-    let(:config) { ThinkingSphinx::Configuration.instance }
-
-    it "should set all sphinx_internal_id attributes to bigints if one is" do
-      config.reset
-      config.generate
-
-      config.configuration.indices.each do |index|
-        next if index.is_a? Riddle::Configuration::DistributedIndex
-
-        index.sources.each do |source|
-          source.sql_attr_bigint.should include(:sphinx_internal_id)
-        end
-      end
+  
+  describe '#client' do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @config.address     = 'domain.url'
+      @config.port        = 3333
+      @config.configuration.searchd.max_matches = 100
+    end
+    
+    it "should return an instance of Riddle::Client" do
+      @config.client.should be_a(Riddle::Client)
+    end
+    
+    it "should use the configuration address" do
+      @config.client.server.should == 'domain.url'
+    end
+    
+    it "should use the configuration port" do
+      @config.client.port.should == 3333
+    end
+    
+    it "should use the configuration max matches" do
+      @config.client.max_matches.should == 100
     end
   end
-
+  
   describe '#models_by_crc' do
     before :each do
       @config = ThinkingSphinx::Configuration.instance
     end
-
+    
     it "should return a hash" do
       @config.models_by_crc.should be_a(Hash)
     end
-
+    
     it "should pair class names to their crc codes" do
       @config.models_by_crc[Person.to_crc32].should == 'Person'
       @config.models_by_crc[Alpha.to_crc32].should  == 'Alpha'