thinking-sphinx 3.2.0 → 3.3.0

data/spec/thinking_sphinx/active_record/database_adapters/postgresql_adapter_spec.rb

@@ -8,57 +8,57 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter do
 
   describe '#boolean_value' do
     it "returns 'TRUE' for true" do
-      adapter.boolean_value(true).should == 'TRUE'
+      expect(adapter.boolean_value(true)).to eq('TRUE')
     end
 
     it "returns 'FALSE' for false" do
-      adapter.boolean_value(false).should == 'FALSE'
+      expect(adapter.boolean_value(false)).to eq('FALSE')
     end
   end
 
   describe '#cast_to_string' do
     it "casts the clause to characters" do
-      adapter.cast_to_string('foo').should == 'foo::varchar'
+      expect(adapter.cast_to_string('foo')).to eq('foo::varchar')
     end
   end
 
   describe '#cast_to_timestamp' do
     it "converts to int unix timestamps" do
-      adapter.cast_to_timestamp('created_at').
-        should == 'extract(epoch from created_at)::int'
+      expect(adapter.cast_to_timestamp('created_at')).
+        to eq('extract(epoch from created_at)::int')
     end
 
     it "converts to bigint unix timestamps" do
       ThinkingSphinx::Configuration.instance.settings['64bit_timestamps'] = true
 
-      adapter.cast_to_timestamp('created_at').
-        should == 'extract(epoch from created_at)::bigint'
+      expect(adapter.cast_to_timestamp('created_at')).
+        to eq('extract(epoch from created_at)::bigint')
     end
   end
 
   describe '#concatenate' do
     it "concatenates with the given separator" do
-      adapter.concatenate('foo, bar, baz', ',').
-        should == "COALESCE(foo, '') || ',' || COALESCE(bar, '') || ',' || COALESCE(baz, '')"
+      expect(adapter.concatenate('foo, bar, baz', ',')).
+        to eq("COALESCE(foo, '') || ',' || COALESCE(bar, '') || ',' || COALESCE(baz, '')")
     end
   end
 
   describe '#convert_nulls' do
     it "translates arguments to a COALESCE SQL call" do
-      adapter.convert_nulls('id', 5).should == 'COALESCE(id, 5)'
+      expect(adapter.convert_nulls('id', 5)).to eq('COALESCE(id, 5)')
     end
   end
 
   describe '#convert_blank' do
     it "translates arguments to a COALESCE NULLIF SQL call" do
-      adapter.convert_blank('id', 5).should == "COALESCE(NULLIF(id, ''), 5)"
+      expect(adapter.convert_blank('id', 5)).to eq("COALESCE(NULLIF(id, ''), 5)")
     end
   end
 
   describe '#group_concatenate' do
     it "group concatenates the clause with the given separator" do
-      adapter.group_concatenate('foo', ',').
-        should == "array_to_string(array_agg(DISTINCT foo), ',')"
+      expect(adapter.group_concatenate('foo', ',')).
+        to eq("array_to_string(array_agg(DISTINCT foo), ',')")
     end
   end
 end

data/spec/thinking_sphinx/active_record/database_adapters_spec.rb

@@ -5,21 +5,21 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
 
   describe '.adapter_for' do
     it "returns a MysqlAdapter object for :mysql" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        stub(:adapter_type_for => :mysql)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive_messages(:adapter_type_for => :mysql)
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model).
-        should be_a(
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)).
+        to be_a(
           ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter
         )
     end
 
     it "returns a PostgreSQLAdapter object for :postgresql" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        stub(:adapter_type_for => :postgresql)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive_messages(:adapter_type_for => :postgresql)
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model).
-        should be_a(
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)).
+        to be_a(
           ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter
         )
     end
@@ -29,21 +29,21 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
       adapter_instance = double('adapter instance')
 
       ThinkingSphinx::ActiveRecord::DatabaseAdapters.default = adapter_class
-      adapter_class.stub!(:new => adapter_instance)
+      allow(adapter_class).to receive_messages(:new => adapter_instance)
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model).
-        should == adapter_instance
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)).
+        to eq(adapter_instance)
 
       ThinkingSphinx::ActiveRecord::DatabaseAdapters.default = nil
     end
 
     it "raises an exception for other responses" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        stub(:adapter_type_for => :sqlite)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive_messages(:adapter_type_for => :sqlite)
 
-      lambda {
+      expect {
         ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)
-      }.should raise_error
+      }.to raise_error(ThinkingSphinx::InvalidDatabaseAdapter)
     end
   end
 
@@ -53,74 +53,74 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
     let(:model)      { double('model', :connection => connection) }
 
     it "translates a normal MySQL adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :mysql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
     end
 
     it "translates a MySQL2 adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :mysql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
     end
 
     it "translates a normal PostgreSQL adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :postgresql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:postgresql)
     end
 
     it "translates a JDBC MySQL adapter to MySQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcmysql'})
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbcmysql'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :mysql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
     end
 
     it "translates a JDBC PostgreSQL adapter to PostgreSQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcpostgresql'})
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbcpostgresql'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :postgresql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:postgresql)
     end
 
     it "translates a JDBC adapter with MySQL connection string to MySQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbc',
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbc',
                                   :url => 'jdbc:mysql://127.0.0.1:3306/sphinx'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :mysql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
     end
 
     it "translates a JDBC adapter with PostgresSQL connection string to PostgresSQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbc',
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbc',
                                   :url => 'jdbc:postgresql://127.0.0.1:3306/sphinx'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :postgresql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:postgresql)
     end
 
     it "returns other JDBC adapters without translation" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcmssql'})
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbcmssql'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == 'jdbcmssql'
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq('jdbcmssql')
     end
 
     it "returns other unknown adapters without translation" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).
-        should == 'ActiveRecord::ConnectionAdapters::FooAdapter'
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).
+        to eq('ActiveRecord::ConnectionAdapters::FooAdapter')
     end
   end
 end

data/spec/thinking_sphinx/active_record/field_spec.rb

@@ -7,16 +7,16 @@ describe ThinkingSphinx::ActiveRecord::Field do
   let(:model)        { double('model') }
 
   before :each do
-    column.stub! :to_a => [column]
+    allow(column).to receive_messages :to_a => [column]
   end
 
   describe '#columns' do
     it 'returns the provided Column object' do
-      field.columns.should == [column]
+      expect(field.columns).to eq([column])
     end
 
     it 'translates symbols to Column objects' do
-      ThinkingSphinx::ActiveRecord::Column.should_receive(:new).with(:title).
+      expect(ThinkingSphinx::ActiveRecord::Column).to receive(:new).with(:title).
         and_return(column)
 
       ThinkingSphinx::ActiveRecord::Field.new model, :title
@@ -25,25 +25,25 @@ describe ThinkingSphinx::ActiveRecord::Field do
 
   describe '#file?' do
     it "defaults to false" do
-      field.should_not be_file
+      expect(field).not_to be_file
     end
 
     it "is true if file option is set" do
       field = ThinkingSphinx::ActiveRecord::Field.new model, column,
         :file => true
-      field.should be_file
+      expect(field).to be_file
     end
   end
 
   describe '#with_attribute?' do
     it "defaults to false" do
-      field.should_not be_with_attribute
+      expect(field).not_to be_with_attribute
     end
 
     it "is true if the field is sortable" do
       field = ThinkingSphinx::ActiveRecord::Field.new model, column,
         :sortable => true
-      field.should be_with_attribute
+      expect(field).to be_with_attribute
     end
   end
 end

data/spec/thinking_sphinx/active_record/filter_reflection_spec.rb

@@ -12,12 +12,12 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     let(:initialize_method)   { double :arity => 4 }
 
     before :each do
-      reflection.active_record.stub_chain(:connection, :quote_column_name).
+      allow(reflection.active_record).to receive_message_chain(:connection, :quote_column_name).
         and_return('"foo_type"')
     end
 
     it "uses the existing reflection's macro" do
-      reflection_klass.should_receive(:new).
+      expect(reflection_klass).to receive(:new).
         with(:has_some, anything, anything, anything)
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -27,10 +27,10 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
 
     it "uses the supplied name" do
       if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new).
+        expect(reflection_klass).to receive(:new).
           with('foo_bar', anything, anything, anything)
       else
-        reflection_klass.should_receive(:new).
+        expect(reflection_klass).to receive(:new).
           with(anything, 'foo_bar', anything, anything)
       end
 
@@ -41,10 +41,10 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
 
     it "uses the existing reflection's parent" do
       if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new).
+        expect(reflection_klass).to receive(:new).
           with(anything, anything, anything, reflection.active_record)
       else
-        reflection_klass.should_receive(:new).
+        expect(reflection_klass).to receive(:new).
           with(anything, anything, anything, reflection.active_record)
       end
 
@@ -55,12 +55,12 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
 
     it "removes the polymorphic setting from the options" do
       if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new) do |name, scope, options, parent|
-          options[:polymorphic].should be_nil
+        expect(reflection_klass).to receive(:new) do |name, scope, options, parent|
+          expect(options[:polymorphic]).to be_nil
         end
       else
-        reflection_klass.should_receive(:new) do |macro, name, options, parent|
-          options[:polymorphic].should be_nil
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:polymorphic]).to be_nil
         end
       end
 
@@ -71,12 +71,12 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
 
     it "adds the class name option" do
       if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new) do |name, scope, options, parent|
-          options[:class_name].should == 'Bar'
+        expect(reflection_klass).to receive(:new) do |name, scope, options, parent|
+          expect(options[:class_name]).to eq('Bar')
         end
       else
-        reflection_klass.should_receive(:new) do |macro, name, options, parent|
-          options[:class_name].should == 'Bar'
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:class_name]).to eq('Bar')
         end
       end
 
@@ -87,12 +87,12 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
 
     it "sets the foreign key if necessary" do
       if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new) do |name, scope, options, parent|
-          options[:foreign_key].should == 'baz_id'
+        expect(reflection_klass).to receive(:new) do |name, scope, options, parent|
+          expect(options[:foreign_key]).to eq('baz_id')
         end
       else
-        reflection_klass.should_receive(:new) do |macro, name, options, parent|
-          options[:foreign_key].should == 'baz_id'
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:foreign_key]).to eq('baz_id')
         end
       end
 
@@ -105,12 +105,12 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
       options[:foreign_key] = 'qux_id'
 
       if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new) do |name, scope, options, parent|
-          options[:foreign_key].should == 'qux_id'
+        expect(reflection_klass).to receive(:new) do |name, scope, options, parent|
+          expect(options[:foreign_key]).to eq('qux_id')
         end
       else
-        reflection_klass.should_receive(:new) do |macro, name, options, parent|
-          options[:foreign_key].should == 'qux_id'
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:foreign_key]).to eq('qux_id')
         end
       end
 
@@ -120,8 +120,8 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     end
 
     it "sets conditions if there are none" do
-      reflection_klass.should_receive(:new) do |macro, name, options, parent|
-        options[:conditions].should == "::ts_join_alias::.\"foo_type\" = 'Bar'"
+      expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+        expect(options[:conditions]).to eq("::ts_join_alias::.\"foo_type\" = 'Bar'")
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -132,8 +132,8 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     it "appends to the conditions array" do
       options[:conditions] = ['existing']
 
-      reflection_klass.should_receive(:new) do |macro, name, options, parent|
-        options[:conditions].should == ['existing', "::ts_join_alias::.\"foo_type\" = 'Bar'"]
+      expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+        expect(options[:conditions]).to eq(['existing', "::ts_join_alias::.\"foo_type\" = 'Bar'"])
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -144,8 +144,8 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     it "extends the conditions hash" do
       options[:conditions] = {:x => :y}
 
-      reflection_klass.should_receive(:new) do |macro, name, options, parent|
-        options[:conditions].should == {:x => :y, :foo_type => 'Bar'}
+      expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+        expect(options[:conditions]).to eq({:x => :y, :foo_type => 'Bar'})
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -156,8 +156,8 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     it "appends to the conditions string" do
       options[:conditions] = 'existing'
 
-      reflection_klass.should_receive(:new) do |macro, name, options, parent|
-        options[:conditions].should == "existing AND ::ts_join_alias::.\"foo_type\" = 'Bar'"
+      expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+        expect(options[:conditions]).to eq("existing AND ::ts_join_alias::.\"foo_type\" = 'Bar'")
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -166,9 +166,9 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     end unless defined?(ActiveRecord::Reflection::MacroReflection)
 
     it "returns the new reflection" do
-      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+      expect(ThinkingSphinx::ActiveRecord::FilterReflection.call(
         reflection, 'foo_bar', 'Bar'
-      ).should == filtered_reflection
+      )).to eq(filtered_reflection)
     end
   end
 end

data/spec/thinking_sphinx/active_record/index_spec.rb

@@ -2,12 +2,11 @@ require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Index do
   let(:index)        { ThinkingSphinx::ActiveRecord::Index.new :user }
-  let(:indices_path) { double('indices path', :join => '') }
   let(:config)       { double('config', :settings => {},
-    :indices_location => indices_path, :next_offset => 8) }
+    :indices_location => 'location', :next_offset => 8) }
 
   before :each do
-    ThinkingSphinx::Configuration.stub :instance => config
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
   end
 
   describe '#append_source' do
@@ -15,32 +14,32 @@ describe ThinkingSphinx::ActiveRecord::Index do
     let(:source) { double('source') }
 
     before :each do
-      ActiveSupport::Inflector.stub(:constantize => model)
-      ThinkingSphinx::ActiveRecord::SQLSource.stub :new => source
-      config.stub :next_offset => 17
+      allow(ActiveSupport::Inflector).to receive_messages(:constantize => model)
+      allow(ThinkingSphinx::ActiveRecord::SQLSource).to receive_messages :new => source
+      allow(config).to receive_messages :next_offset => 17
     end
 
     it "adds a source to the index" do
-      index.sources.should_receive(:<<).with(source)
+      expect(index.sources).to receive(:<<).with(source)
 
       index.append_source
     end
 
     it "creates the source with the index's offset" do
-      ThinkingSphinx::ActiveRecord::SQLSource.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
         with(model, hash_including(:offset => 17)).and_return(source)
 
       index.append_source
     end
 
     it "returns the new source" do
-      index.append_source.should == source
+      expect(index.append_source).to eq(source)
     end
 
     it "defaults to the model's primary key" do
-      model.stub :primary_key => :sphinx_id
+      allow(model).to receive_messages :primary_key => :sphinx_id
 
-      ThinkingSphinx::ActiveRecord::SQLSource.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
         with(model, hash_including(:primary_key => :sphinx_id)).
         and_return(source)
 
@@ -48,9 +47,9 @@ describe ThinkingSphinx::ActiveRecord::Index do
     end
 
     it "uses a custom column when set" do
-      model.stub :primary_key => :sphinx_id
+      allow(model).to receive_messages :primary_key => :sphinx_id
 
-      ThinkingSphinx::ActiveRecord::SQLSource.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
         with(model, hash_including(:primary_key => :custom_sphinx_id)).
         and_return(source)
 
@@ -60,9 +59,9 @@ describe ThinkingSphinx::ActiveRecord::Index do
     end
 
     it "defaults to id if no primary key is set" do
-      model.stub :primary_key => nil
+      allow(model).to receive_messages :primary_key => nil
 
-      ThinkingSphinx::ActiveRecord::SQLSource.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
         with(model, hash_including(:primary_key => :id)).
         and_return(source)
 
@@ -72,12 +71,12 @@ describe ThinkingSphinx::ActiveRecord::Index do
 
   describe '#delta?' do
     it "defaults to false" do
-      index.should_not be_delta
+      expect(index).not_to be_delta
     end
 
     it "reflects the delta? option" do
       index = ThinkingSphinx::ActiveRecord::Index.new :user, :delta? => true
-      index.should be_delta
+      expect(index).to be_delta
     end
   end
 
@@ -88,16 +87,16 @@ describe ThinkingSphinx::ActiveRecord::Index do
       index = ThinkingSphinx::ActiveRecord::Index.new :user,
         :delta_processor => processor_class
 
-      index.delta_processor.should == processor
+      expect(index.delta_processor).to eq(processor)
     end
   end
 
   describe '#document_id_for_key' do
     it "calculates the document id based on offset and number of indices" do
-      config.stub_chain(:indices, :count).and_return(5)
-      config.stub :next_offset => 7
+      allow(config).to receive_message_chain(:indices, :count).and_return(5)
+      allow(config).to receive_messages :next_offset => 7
 
-      index.document_id_for_key(123).should == 622
+      expect(index.document_id_for_key(123)).to eq(622)
     end
   end
 
@@ -109,14 +108,14 @@ describe ThinkingSphinx::ActiveRecord::Index do
     end
 
     it "interprets the definition block" do
-      ThinkingSphinx::ActiveRecord::Interpreter.should_receive(:translate!).
+      expect(ThinkingSphinx::ActiveRecord::Interpreter).to receive(:translate!).
         with(index, block)
 
       index.interpret_definition!
     end
 
     it "only interprets the definition block once" do
-      ThinkingSphinx::ActiveRecord::Interpreter.should_receive(:translate!).
+      expect(ThinkingSphinx::ActiveRecord::Interpreter).to receive(:translate!).
         once
 
       index.interpret_definition!
@@ -128,13 +127,13 @@ describe ThinkingSphinx::ActiveRecord::Index do
     let(:model)  { double('model') }
 
     it "translates symbol references to model class" do
-      ActiveSupport::Inflector.stub(:constantize => model)
+      allow(ActiveSupport::Inflector).to receive_messages(:constantize => model)
 
-      index.model.should == model
+      expect(index.model).to eq(model)
     end
 
     it "memoizes the result" do
-      ActiveSupport::Inflector.should_receive(:constantize).with('User').once.
+      expect(ActiveSupport::Inflector).to receive(:constantize).with('User').once.
         and_return(model)
 
       index.model
@@ -145,7 +144,7 @@ describe ThinkingSphinx::ActiveRecord::Index do
   describe '#morphology' do
     context 'with a render' do
       before :each do
-        FileUtils.stub :mkdir_p => true
+        allow(FileUtils).to receive_messages :mkdir_p => true
       end
 
       it "defaults to nil" do
@@ -154,7 +153,7 @@ describe ThinkingSphinx::ActiveRecord::Index do
         rescue Riddle::Configuration::ConfigurationError
         end
 
-        index.morphology.should be_nil
+        expect(index.morphology).to be_nil
       end
 
       it "reads from the settings file if provided" do
@@ -165,7 +164,7 @@ describe ThinkingSphinx::ActiveRecord::Index do
         rescue Riddle::Configuration::ConfigurationError
         end
 
-        index.morphology.should == 'stem_en'
+        expect(index.morphology).to eq('stem_en')
       end
     end
   end
@@ -173,26 +172,26 @@ describe ThinkingSphinx::ActiveRecord::Index do
   describe '#name' do
     it "uses the core suffix by default" do
       index = ThinkingSphinx::ActiveRecord::Index.new :user
-      index.name.should == 'user_core'
+      expect(index.name).to eq('user_core')
     end
 
     it "uses the delta suffix when delta? is true" do
       index = ThinkingSphinx::ActiveRecord::Index.new :user, :delta? => true
-      index.name.should == 'user_delta'
+      expect(index.name).to eq('user_delta')
     end
   end
 
   describe '#offset' do
     before :each do
-      config.stub :next_offset => 4
+      allow(config).to receive_messages :next_offset => 4
     end
 
     it "uses the next offset value from the configuration" do
-      index.offset.should == 4
+      expect(index.offset).to eq(4)
     end
 
     it "uses the reference to get a unique offset" do
-      config.should_receive(:next_offset).with(:user).and_return(2)
+      expect(config).to receive(:next_offset).with(:user).and_return(2)
 
       index.offset
     end
@@ -200,11 +199,11 @@ describe ThinkingSphinx::ActiveRecord::Index do
 
   describe '#render' do
     before :each do
-      FileUtils.stub :mkdir_p => true
+      allow(FileUtils).to receive_messages :mkdir_p => true
     end
 
     it "interprets the provided definition" do
-      index.should_receive(:interpret_definition!).at_least(:once)
+      expect(index).to receive(:interpret_definition!).at_least(:once)
 
       begin
         index.render