pg_search 0.7.4 → 0.7.5

data/spec/integration/pg_search_spec.rb

@@ -17,7 +17,7 @@ describe "an Active Record model which includes PgSearch" do
     it "builds a chainable scope" do
       ModelWithPgSearch.pg_search_scope "matching_query", :against => []
       scope = ModelWithPgSearch.where("1 = 1").matching_query("foo").where("1 = 1")
-      scope.should be_an ActiveRecord::Relation
+      expect(scope).to be_an ActiveRecord::Relation
     end
 
     context "when passed a lambda" do
@@ -33,8 +33,8 @@ describe "an Active Record model which includes PgSearch" do
         included = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
         excluded = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
 
-        ModelWithPgSearch.search_title_or_content('fo-remove-o', false).should == [included]
-        ModelWithPgSearch.search_title_or_content('b-remove-ar', true).should == [included]
+        expect(ModelWithPgSearch.search_title_or_content('fo-remove-o', false)).to eq([included])
+        expect(ModelWithPgSearch.search_title_or_content('b-remove-ar', true)).to eq([included])
       end
     end
 
@@ -139,7 +139,7 @@ describe "an Active Record model which includes PgSearch" do
         ModelWithPgSearch.create!(:content => 'foo')
 
         results = ModelWithPgSearch.search_content('')
-        results.should == []
+        expect(results).to eq([])
       end
 
       it "returns rows where the column contains the term in the query" do
@@ -147,8 +147,8 @@ describe "an Active Record model which includes PgSearch" do
         excluded = ModelWithPgSearch.create!(:content => 'bar')
 
         results = ModelWithPgSearch.search_content('foo')
-        results.should include(included)
-        results.should_not include(excluded)
+        expect(results).to include(included)
+        expect(results).not_to include(excluded)
       end
 
       it "returns the correct count" do
@@ -165,8 +165,8 @@ describe "an Active Record model which includes PgSearch" do
         excluded = ModelWithPgSearch.create!(:content => 'foo')
 
         results = ModelWithPgSearch.search_content('foo bar')
-        results.should =~ included
-        results.should_not include(excluded)
+        expect(results).to match_array(included)
+        expect(results).not_to include(excluded)
       end
 
       it "returns rows that match the query but not its case" do
@@ -174,7 +174,7 @@ describe "an Active Record model which includes PgSearch" do
                     ModelWithPgSearch.create!(:content => "FOO")]
 
         results = ModelWithPgSearch.search_content("Foo")
-        results.should =~ included
+        expect(results).to match_array(included)
       end
 
       it "returns rows that match the query only if their accents match" do
@@ -185,8 +185,8 @@ describe "an Active Record model which includes PgSearch" do
         excluded = ModelWithPgSearch.create!(:content => "\303\241bcdef")
 
         results = ModelWithPgSearch.search_content("abcd\303\251f")
-        results.should == [included]
-        results.should_not include(excluded)
+        expect(results).to eq([included])
+        expect(results).not_to include(excluded)
       end
 
       it "returns rows that match the query but not rows that are prefixed by the query" do
@@ -194,8 +194,8 @@ describe "an Active Record model which includes PgSearch" do
         excluded = ModelWithPgSearch.create!(:content => 'prefix')
 
         results = ModelWithPgSearch.search_content("pre")
-        results.should == [included]
-        results.should_not include(excluded)
+        expect(results).to eq([included])
+        expect(results).not_to include(excluded)
       end
 
       it "returns rows that match the query exactly and not those that match the query when stemmed by the default english dictionary" do
@@ -204,7 +204,7 @@ describe "an Active Record model which includes PgSearch" do
                     ModelWithPgSearch.create!(:content => "jumping")]
 
         results = ModelWithPgSearch.search_content("jumped")
-        results.should == [included]
+        expect(results).to eq([included])
       end
 
       it "returns rows that match sorted by rank" do
@@ -212,8 +212,8 @@ describe "an Active Record model which includes PgSearch" do
         winner = ModelWithPgSearch.create!(:content => 'foo foo')
 
         results = ModelWithPgSearch.search_content("foo")
-        results[0].pg_search_rank.should > results[1].pg_search_rank
-        results.should == [winner, loser]
+        expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
+        expect(results).to eq([winner, loser])
       end
 
       it "returns results that match sorted by primary key for records that rank the same" do
@@ -221,7 +221,7 @@ describe "an Active Record model which includes PgSearch" do
                           ModelWithPgSearch.create!(:content => 'foo')].sort_by(&:id)
 
         results = ModelWithPgSearch.search_content("foo")
-        results.should == sorted_results
+        expect(results).to eq(sorted_results)
       end
 
       it "returns results that match a query with multiple space-separated search terms" do
@@ -236,21 +236,21 @@ describe "an Active Record model which includes PgSearch" do
         ]
 
         results = ModelWithPgSearch.search_content('foo bar')
-        results.should =~ included
-        results.should_not include(excluded)
+        expect(results).to match_array(included)
+        expect(results).not_to include(excluded)
       end
 
       it "returns rows that match a query with characters that are invalid in a tsquery expression" do
         included = ModelWithPgSearch.create!(:content => "(:Foo.) Bar?, \\")
 
         results = ModelWithPgSearch.search_content("foo :bar .,?() \\")
-        results.should == [included]
+        expect(results).to eq([included])
       end
 
       it "accepts non-string queries and calls #to_s on them" do
         foo = ModelWithPgSearch.create!(:content => "foo")
         not_a_string = double(:to_s => "foo")
-        ModelWithPgSearch.search_content(not_a_string).should == [foo]
+        expect(ModelWithPgSearch.search_content(not_a_string)).to eq([foo])
       end
 
       context "when the column is not text" do
@@ -274,7 +274,7 @@ describe "an Active Record model which includes PgSearch" do
 
           query = record.created_at.strftime("%Y-%m-%d")
           results = ModelWithTimestamps.search_timestamps(query)
-          results.should == [record]
+          expect(results).to eq([record])
         end
       end
     end
@@ -296,9 +296,9 @@ describe "an Active Record model which includes PgSearch" do
 
         results = ModelWithPgSearch.search_title_and_content('foo bar')
 
-        results.should =~ included
+        expect(results).to match_array(included)
         excluded.each do |result|
-          results.should_not include(result)
+          expect(results).not_to include(result)
         end
       end
 
@@ -307,14 +307,14 @@ describe "an Active Record model which includes PgSearch" do
         in_content = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
 
         results  = ModelWithPgSearch.search_title_and_content('foo')
-        results.should =~ [in_title, in_content]
+        expect(results).to match_array([in_title, in_content])
       end
 
       # Searching with a NULL column will prevent any matches unless we coalesce it.
       it "returns rows where at one column contains all of the terms in the query and another is NULL" do
         included = ModelWithPgSearch.create!(:title => 'foo', :content => nil)
         results  = ModelWithPgSearch.search_title_and_content('foo')
-        results.should == [included]
+        expect(results).to eq([included])
       end
     end
 
@@ -326,13 +326,13 @@ describe "an Active Record model which includes PgSearch" do
       it "returns rows where one searchable column and the query share enough trigrams" do
         included = ModelWithPgSearch.create!(:title => 'abcdefghijkl', :content => nil)
         results = ModelWithPgSearch.with_trigrams('cdefhijkl')
-        results.should == [included]
+        expect(results).to eq([included])
       end
 
       it "returns rows where multiple searchable columns and the query share enough trigrams" do
         included = ModelWithPgSearch.create!(:title => 'abcdef', :content => 'ghijkl')
         results = ModelWithPgSearch.with_trigrams('cdefhijkl')
-        results.should == [included]
+        expect(results).to eq([included])
       end
 
       context "when a threshold is specified" do
@@ -382,8 +382,8 @@ describe "an Active Record model which includes PgSearch" do
             excluded = ModelWithPgSearch.create!(:title => 'postfix')
 
             results = ModelWithPgSearch.search_title_with_prefixes("pre")
-            results.should == [included]
-            results.should_not include(excluded)
+            expect(results).to eq([included])
+            expect(results).not_to include(excluded)
           end
 
           it "returns rows that match the query when the query has a hyphen" do
@@ -391,8 +391,8 @@ describe "an Active Record model which includes PgSearch" do
             excluded = ModelWithPgSearch.create!(:title => 'foo bar')
 
             results = ModelWithPgSearch.search_title_with_prefixes("foo-bar")
-            results.should include(included)
-            results.should_not include(excluded)
+            expect(results).to include(included)
+            expect(results).not_to include(excluded)
           end
         end
       end
@@ -412,7 +412,7 @@ describe "an Active Record model which includes PgSearch" do
                       ModelWithPgSearch.create!(:content => "jumping")]
 
           results = ModelWithPgSearch.search_content_with_english("jump")
-          results.should =~ included
+          expect(results).to match_array(included)
         end
       end
 
@@ -428,7 +428,7 @@ describe "an Active Record model which includes PgSearch" do
 
           result = ModelWithPgSearch.search_content("Strip Down").first
 
-          result.pg_search_rank.should be_a(Float)
+          expect(result.pg_search_rank).to be_a(Float)
         end
 
         context "with a normalization specified" do
@@ -443,8 +443,8 @@ describe "an Active Record model which includes PgSearch" do
           it "ranks the results for documents with less text higher" do
             results = ModelWithPgSearch.search_content_with_normalization("down")
 
-            results.map(&:content).should == ["Down", "Strip Down", "Down and Out", "Won't Let You Down"]
-            results.first.pg_search_rank.should be > results.last.pg_search_rank
+            expect(results.map(&:content)).to eq(["Down", "Strip Down", "Down and Out", "Won't Let You Down"])
+            expect(results.first.pg_search_rank).to be > results.last.pg_search_rank
           end
         end
 
@@ -458,8 +458,8 @@ describe "an Active Record model which includes PgSearch" do
           it "ranks the results equally" do
             results = ModelWithPgSearch.search_content_without_normalization("down")
 
-            results.map(&:content).should == ["Strip Down", "Down", "Down and Out", "Won't Let You Down"]
-            results.first.pg_search_rank.should == results.last.pg_search_rank
+            expect(results.map(&:content)).to eq(["Strip Down", "Down", "Down and Out", "Won't Let You Down"])
+            expect(results.first.pg_search_rank).to eq(results.last.pg_search_rank)
           end
         end
       end
@@ -475,8 +475,8 @@ describe "an Active Record model which includes PgSearch" do
           winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
           results = ModelWithPgSearch.search_weighted_by_array_of_arrays('foo')
-          results[0].pg_search_rank.should > results[1].pg_search_rank
-          results.should == [winner, loser]
+          expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
+          expect(results).to eq([winner, loser])
         end
       end
 
@@ -491,8 +491,8 @@ describe "an Active Record model which includes PgSearch" do
           winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
           results = ModelWithPgSearch.search_weighted_by_hash('foo')
-          results[0].pg_search_rank.should > results[1].pg_search_rank
-          results.should == [winner, loser]
+          expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
+          expect(results).to eq([winner, loser])
         end
       end
 
@@ -507,8 +507,8 @@ describe "an Active Record model which includes PgSearch" do
           winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
           results = ModelWithPgSearch.search_weighted('foo')
-          results[0].pg_search_rank.should > results[1].pg_search_rank
-          results.should == [winner, loser]
+          expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
+          expect(results).to eq([winner, loser])
         end
       end
 
@@ -529,11 +529,11 @@ describe "an Active Record model which includes PgSearch" do
 
           results = ModelWithPgSearch.search_title_with_any_word("one two three four")
 
-          results.map(&:title).should == %w(one two three four)
+          expect(results.map(&:title)).to eq(%w(one two three four))
 
           results = ModelWithPgSearch.search_title_with_all_words("one two three four")
 
-          results.map(&:title).should == []
+          expect(results.map(&:title)).to eq([])
         end
       end
     end
@@ -549,21 +549,21 @@ describe "an Active Record model which includes PgSearch" do
         included = ModelWithPgSearch.create!(:title => 'Geoff', :content => nil)
         excluded = ModelWithPgSearch.create!(:title => 'Bob', :content => nil)
         results = ModelWithPgSearch.with_dmetaphones('Jeff')
-        results.should == [included]
+        expect(results).to eq([included])
       end
 
       it "returns rows where multiple searchable columns and the query share enough dmetaphones" do
         included = ModelWithPgSearch.create!(:title => 'Geoff', :content => 'George')
         excluded = ModelWithPgSearch.create!(:title => 'Bob', :content => 'Jones')
         results = ModelWithPgSearch.with_dmetaphones('Jeff Jorge')
-        results.should == [included]
+        expect(results).to eq([included])
       end
 
       it "returns rows that match dmetaphones that are English stopwords" do
         included = ModelWithPgSearch.create!(:title => 'White', :content => nil)
         excluded = ModelWithPgSearch.create!(:title => 'Black', :content => nil)
         results = ModelWithPgSearch.with_dmetaphones('Wight')
-        results.should == [included]
+        expect(results).to eq([included])
       end
 
       it "can handle terms that do not have a dmetaphone equivalent" do
@@ -573,7 +573,7 @@ describe "an Active Record model which includes PgSearch" do
         excluded = ModelWithPgSearch.create!(:title => 'Black', :content => nil)
 
         results = ModelWithPgSearch.with_dmetaphones('Wight W')
-        results.should == [included]
+        expect(results).to eq([included])
       end
     end
 
@@ -616,37 +616,37 @@ describe "an Active Record model which includes PgSearch" do
 
         # matches trigram only
         trigram_query = "ling is grouty"
-        ModelWithPgSearch.with_trigram(trigram_query).should include(record)
-        ModelWithPgSearch.with_trigram_and_ignoring_accents(trigram_query).should include(record)
-        ModelWithPgSearch.with_tsearch(trigram_query).should_not include(record)
-        ModelWithPgSearch.with_tsearch_and_trigram(trigram_query).should == [record]
-        ModelWithPgSearch.complex_search(trigram_query).should include(record)
+        expect(ModelWithPgSearch.with_trigram(trigram_query)).to include(record)
+        expect(ModelWithPgSearch.with_trigram_and_ignoring_accents(trigram_query)).to include(record)
+        expect(ModelWithPgSearch.with_tsearch(trigram_query)).not_to include(record)
+        expect(ModelWithPgSearch.with_tsearch_and_trigram(trigram_query)).to eq([record])
+        expect(ModelWithPgSearch.complex_search(trigram_query)).to include(record)
 
         # matches accent
         # \303\266 is o with diaeresis
         # \303\272 is u with acute accent
         accent_query = "gr\303\266\303\272ty"
-        ModelWithPgSearch.with_trigram(accent_query).should_not include(record)
-        ModelWithPgSearch.with_trigram_and_ignoring_accents(accent_query).should include(record)
-        ModelWithPgSearch.with_tsearch(accent_query).should_not include(record)
-        ModelWithPgSearch.with_tsearch_and_trigram(accent_query).count(:all).should == 0
-        ModelWithPgSearch.complex_search(accent_query).should include(record)
+        expect(ModelWithPgSearch.with_trigram(accent_query)).not_to include(record)
+        expect(ModelWithPgSearch.with_trigram_and_ignoring_accents(accent_query)).to include(record)
+        expect(ModelWithPgSearch.with_tsearch(accent_query)).not_to include(record)
+        expect(ModelWithPgSearch.with_tsearch_and_trigram(accent_query).count(:all)).to eq(0)
+        expect(ModelWithPgSearch.complex_search(accent_query)).to include(record)
 
         # matches tsearch only
         tsearch_query = "tiles"
-        ModelWithPgSearch.with_tsearch(tsearch_query).should include(record)
-        ModelWithPgSearch.with_trigram(tsearch_query).should_not include(record)
-        ModelWithPgSearch.with_trigram_and_ignoring_accents(tsearch_query).should_not include(record)
-        ModelWithPgSearch.with_tsearch_and_trigram(tsearch_query).should == [record]
-        ModelWithPgSearch.complex_search(tsearch_query).should include(record)
+        expect(ModelWithPgSearch.with_tsearch(tsearch_query)).to include(record)
+        expect(ModelWithPgSearch.with_trigram(tsearch_query)).not_to include(record)
+        expect(ModelWithPgSearch.with_trigram_and_ignoring_accents(tsearch_query)).not_to include(record)
+        expect(ModelWithPgSearch.with_tsearch_and_trigram(tsearch_query)).to eq([record])
+        expect(ModelWithPgSearch.complex_search(tsearch_query)).to include(record)
 
         # matches dmetaphone only
         dmetaphone_query = "tyling"
-        ModelWithPgSearch.with_tsearch(dmetaphone_query).should_not include(record)
-        ModelWithPgSearch.with_trigram(dmetaphone_query).should_not include(record)
-        ModelWithPgSearch.with_trigram_and_ignoring_accents(dmetaphone_query).should_not include(record)
-        ModelWithPgSearch.with_tsearch_and_trigram(dmetaphone_query).should_not include(record)
-        ModelWithPgSearch.complex_search(dmetaphone_query).should include(record)
+        expect(ModelWithPgSearch.with_tsearch(dmetaphone_query)).not_to include(record)
+        expect(ModelWithPgSearch.with_trigram(dmetaphone_query)).not_to include(record)
+        expect(ModelWithPgSearch.with_trigram_and_ignoring_accents(dmetaphone_query)).not_to include(record)
+        expect(ModelWithPgSearch.with_tsearch_and_trigram(dmetaphone_query)).not_to include(record)
+        expect(ModelWithPgSearch.complex_search(dmetaphone_query)).to include(record)
       end
 
       context "with feature-specific configuration" do
@@ -668,8 +668,8 @@ describe "an Active Record model which includes PgSearch" do
             :rank => Arel::Nodes::Grouping.new(Arel.sql("1.0"))
           )
 
-          PgSearch::Features::TSearch.should_receive(:new).with(anything, @tsearch_config, anything, anything, anything).at_least(:once).and_return(stub_feature)
-          PgSearch::Features::Trigram.should_receive(:new).with(anything, @trigram_config, anything, anything, anything).at_least(:once).and_return(stub_feature)
+          expect(PgSearch::Features::TSearch).to receive(:new).with(anything, @tsearch_config, anything, anything, anything).at_least(:once).and_return(stub_feature)
+          expect(PgSearch::Features::Trigram).to receive(:new).with(anything, @trigram_config, anything, anything, anything).at_least(:once).and_return(stub_feature)
 
           ModelWithPgSearch.with_tsearch_and_trigram_using_hash("foo")
         end
@@ -723,15 +723,15 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "should find by the tsvector column" do
-        Post.search_by_content_with_tsvector("phooey").map(&:id).should == [expected.id]
+        expect(Post.search_by_content_with_tsvector("phooey").map(&:id)).to eq([expected.id])
       end
 
       it "should find by the associated record" do
-        Post.search_by_content_with_tsvector("commentone").map(&:id).should == [expected.id]
+        expect(Post.search_by_content_with_tsvector("commentone").map(&:id)).to eq([expected.id])
       end
 
       it 'should find by a combination of the two' do
-        Post.search_by_content_with_tsvector("phooey commentone").map(&:id).should == [expected.id]
+        expect(Post.search_by_content_with_tsvector("phooey commentone").map(&:id)).to eq([expected.id])
       end
     end
 
@@ -765,11 +765,11 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "should not use to_tsvector in the query" do
-        ModelWithTsvector.search_by_content_with_tsvector("tiles").to_sql.should_not =~ /to_tsvector/
+        expect(ModelWithTsvector.search_by_content_with_tsvector("tiles").to_sql).not_to match(/to_tsvector/)
       end
 
       it "should find the expected result" do
-        ModelWithTsvector.search_by_content_with_tsvector("tiles").map(&:id).should == [expected.id]
+        expect(ModelWithTsvector.search_by_content_with_tsvector("tiles").map(&:id)).to eq([expected.id])
       end
 
       context "when joining to a table with a column of the same name" do
@@ -813,7 +813,7 @@ describe "an Active Record model which includes PgSearch" do
           included = ModelWithPgSearch.create!(:title => "\303\241bcdef")
 
           results = ModelWithPgSearch.search_title_without_accents("abcd\303\251f")
-          results.should == [included]
+          expect(results).to eq([included])
         end
       end
     end
@@ -835,7 +835,7 @@ describe "an Active Record model which includes PgSearch" do
       it "should return records with a rank attribute equal to the :ranked_by expression" do
         ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
         results = ModelWithPgSearch.search_content_with_importance_as_rank("foo")
-        results.first.pg_search_rank.should == 10
+        expect(results.first.pg_search_rank).to eq(10)
       end
 
       it "should substitute :tsearch with the tsearch rank expression in the :ranked_by expression" do
@@ -844,7 +844,7 @@ describe "an Active Record model which includes PgSearch" do
         tsearch_rank = ModelWithPgSearch.search_content_with_default_rank("foo").first.pg_search_rank
         multiplied_rank = ModelWithPgSearch.search_content_with_importance_as_rank_multiplier("foo").first.pg_search_rank
 
-        multiplied_rank.should be_within(0.001).of(tsearch_rank * 10)
+        expect(multiplied_rank).to be_within(0.001).of(tsearch_rank * 10)
       end
 
       it "should return results in descending order of the value of the rank expression" do
@@ -855,7 +855,7 @@ describe "an Active Record model which includes PgSearch" do
         ]
 
         results = ModelWithPgSearch.search_content_with_importance_as_rank("foo")
-        results.should == records.sort_by(&:importance).reverse
+        expect(results).to eq(records.sort_by(&:importance).reverse)
       end
 
       %w[tsearch trigram dmetaphone].each do |feature|
@@ -870,7 +870,7 @@ describe "an Active Record model which includes PgSearch" do
             ModelWithPgSearch.create!(:content => 'foo')
 
             results = ModelWithPgSearch.send(scope_name, 'foo')
-            results.first.pg_search_rank.should be_a Float
+            expect(results.first.pg_search_rank).to be_a Float
           end
         end
       end
@@ -887,7 +887,7 @@ describe "an Active Record model which includes PgSearch" do
           twice = ModelWithPgSearch.create!(:content => 'foo foo')
 
           results = ModelWithPgSearch.search_content_ranked_by_tsearch('foo')
-          results.index(twice).should be < results.index(once)
+          expect(results.index(twice)).to be < results.index(once)
         end
       end
 
@@ -902,7 +902,7 @@ describe "an Active Record model which includes PgSearch" do
           exact = ModelWithPgSearch.create!(:content => 'abc')
 
           results = ModelWithPgSearch.search_content_ranked_by_trigram('abc')
-          results.index(exact).should be < results.index(close)
+          expect(results.index(exact)).to be < results.index(close)
         end
       end
 
@@ -917,7 +917,7 @@ describe "an Active Record model which includes PgSearch" do
           twice = ModelWithPgSearch.create!(:content => 'Phoo Fu')
 
           results = ModelWithPgSearch.search_content_ranked_by_dmetaphone('foo')
-          results.index(twice).should be < results.index(once)
+          expect(results.index(twice)).to be < results.index(once)
         end
       end
     end
@@ -956,27 +956,47 @@ describe "an Active Record model which includes PgSearch" do
           AnotherSubclassModel.create!(:content => "baz")
         ]
 
-        SuperclassModel.count.should == 6
-        SubclassModel.count.should == 2
+        expect(SuperclassModel.count).to eq(6)
+        expect(SubclassModel.count).to eq(2)
 
         results = SubclassModel.search_content("foo bar")
 
-        results.should include(*included)
-        results.should_not include(*excluded)
+        expect(results).to include(*included)
+        expect(results).not_to include(*excluded)
+      end
+    end
+
+    context "when there is a sort only feature" do
+      it "excludes that feature from the conditions, but uses it in the sorting" do
+        ModelWithPgSearch.pg_search_scope :search_content_ranked_by_dmetaphone,
+          :against => :content,
+          :using => {
+            :tsearch => { :any_word => true, :prefix => true },
+            :dmetaphone => { :any_word => true, :prefix => true, :sort_only => true }
+          },
+          :ranked_by => ":tsearch + (0.5 * :dmetaphone)"
+
+        exact = ModelWithPgSearch.create!(:content => "ash hines")
+        one_exact_one_close = ModelWithPgSearch.create!(:content => "ash heinz")
+        one_exact = ModelWithPgSearch.create!(:content => "ash smith")
+        one_close = ModelWithPgSearch.create!(:content => "leigh heinz")
+
+        results = ModelWithPgSearch.search_content_ranked_by_dmetaphone("ash hines")
+        expect(results).to eq [exact, one_exact_one_close, one_exact]
       end
     end
   end
 
   describe ".multisearchable" do
     it "should include the Multisearchable module" do
-      ModelWithPgSearch.should_receive(:include).with(PgSearch::Multisearchable)
+      expect(ModelWithPgSearch).to receive(:include).with(PgSearch::Multisearchable)
       ModelWithPgSearch.multisearchable
     end
 
     it "should set pg_search_multisearchable_options on the class" do
       options = double(:options)
       ModelWithPgSearch.multisearchable(options)
-      ModelWithPgSearch.pg_search_multisearchable_options.should == options
+      expect(ModelWithPgSearch.pg_search_multisearchable_options).to eq(options)
     end
   end
 
@@ -989,14 +1009,14 @@ describe "an Active Record model which includes PgSearch" do
       let(:query) { double(:query) }
       let(:relation) { double(:relation) }
       before do
-        PgSearch::Document.should_receive(:search).with(query).and_return(relation)
+        expect(PgSearch::Document).to receive(:search).with(query).and_return(relation)
       end
 
       it { should == relation }
     end
 
     context "with PgSearch.multisearch_options set to a Hash" do
-      before { PgSearch.stub(:multisearch_options).and_return({:using => :dmetaphone}) }
+      before { allow(PgSearch).to receive(:multisearch_options).and_return({:using => :dmetaphone}) }
       subject { PgSearch.multisearch(query).map(&:searchable) }
 
       with_model :MultisearchableModel do
@@ -1018,7 +1038,7 @@ describe "an Active Record model which includes PgSearch" do
       subject { PgSearch.multisearch(query, soundalike).map(&:searchable) }
 
       before do
-        PgSearch.stub(:multisearch_options).and_return do
+        allow(PgSearch).to receive(:multisearch_options) do
           lambda do |query, soundalike|
             if soundalike
               {:using => :dmetaphone, :query => query}
@@ -1105,9 +1125,9 @@ describe "an Active Record model which includes PgSearch" do
       end
       @multisearch_enabled_after = PgSearch.multisearch_enabled?
 
-      @multisearch_enabled_before.should be(true)
-      @multisearch_enabled_inside.should be(false)
-      @multisearch_enabled_after.should be(true)
+      expect(@multisearch_enabled_before).to be(true)
+      expect(@multisearch_enabled_inside).to be(false)
+      expect(@multisearch_enabled_after).to be(true)
     end
 
     it "should reenable multisearch after an error" do
@@ -1122,9 +1142,9 @@ describe "an Active Record model which includes PgSearch" do
 
       @multisearch_enabled_after = PgSearch.multisearch_enabled?
 
-      @multisearch_enabled_before.should be(true)
-      @multisearch_enabled_inside.should be(false)
-      @multisearch_enabled_after.should be(true)
+      expect(@multisearch_enabled_before).to be(true)
+      expect(@multisearch_enabled_inside).to be(false)
+      expect(@multisearch_enabled_after).to be(true)
     end
 
     it "should not disable multisearch on other threads" do
@@ -1146,9 +1166,9 @@ describe "an Active Record model which includes PgSearch" do
       sync.push :go
       @multisearch_enabled_after = values.pop
 
-      @multisearch_enabled_before.should be(true)
-      @multisearch_enabled_inside.should be(true)
-      @multisearch_enabled_after.should be(true)
+      expect(@multisearch_enabled_before).to be(true)
+      expect(@multisearch_enabled_inside).to be(true)
+      expect(@multisearch_enabled_after).to be(true)
     end
   end
 end

data/spec/lib/pg_search/configuration/column_spec.rb

@@ -10,7 +10,7 @@ describe PgSearch::Configuration::Column do
 
     it "returns the fully-qualified table and column name" do
       column = described_class.new("name", nil, Model)
-      column.full_name.should == %Q{#{Model.quoted_table_name}."name"}
+      expect(column.full_name).to eq(%Q{#{Model.quoted_table_name}."name"})
     end
   end
 
@@ -23,7 +23,7 @@ describe PgSearch::Configuration::Column do
 
     it "returns an expression that casts the column to text and coalesces it with an empty string" do
       column = described_class.new("name", nil, Model)
-      column.to_sql.should == %Q{coalesce(#{Model.quoted_table_name}."name"::text, '')}
+      expect(column.to_sql).to eq(%Q{coalesce(#{Model.quoted_table_name}."name"::text, '')})
     end
   end
 end