pg_search 2.1.2 → 2.3.6

data/spec/integration/pg_search_spec.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
+# rubocop:disable RSpec/NestedGroups
 describe "an Active Record model which includes PgSearch" do
   with_model :ModelWithPgSearch do
     table do |t|
@@ -10,7 +13,7 @@ describe "an Active Record model which includes PgSearch" do
     end
 
     model do
-      include PgSearch
+      include PgSearch::Model
       belongs_to :parent_model
     end
   end
@@ -20,7 +23,7 @@ describe "an Active Record model which includes PgSearch" do
     end
 
     model do
-      include PgSearch
+      include PgSearch::Model
       has_many :models_with_pg_search
       scope :active, -> { where(active: true) }
     end
@@ -28,7 +31,7 @@ describe "an Active Record model which includes PgSearch" do
 
   describe ".pg_search_scope" do
     it "builds a chainable scope" do
-      ModelWithPgSearch.pg_search_scope "matching_query", :against => []
+      ModelWithPgSearch.pg_search_scope "matching_query", against: []
       scope = ModelWithPgSearch.where("1 = 1").matching_query("foo").where("1 = 1")
       expect(scope).to be_an ActiveRecord::Relation
     end
@@ -36,15 +39,15 @@ describe "an Active Record model which includes PgSearch" do
     context "when passed a lambda" do
       it "builds a dynamic scope" do
         ModelWithPgSearch.pg_search_scope :search_title_or_content,
-          lambda { |query, pick_content|
-            {
-              :query => query.gsub("-remove-", ""),
-              :against => pick_content ? :content : :title
-            }
-          }
+                                          lambda { |query, pick_content|
+                                            {
+                                              query: query.gsub("-remove-", ""),
+                                              against: pick_content ? :content : :title
+                                            }
+                                          }
 
-        included = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
-        excluded = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
+        included = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
+        excluded = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
 
         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])
@@ -54,18 +57,18 @@ describe "an Active Record model which includes PgSearch" do
     context "when an unknown option is passed in" do
       it "raises an exception when invoked" do
         ModelWithPgSearch.pg_search_scope :with_unknown_option,
-          :against => :content,
-          :foo => :bar
+                                          against: :content,
+                                          foo: :bar
 
         expect {
           ModelWithPgSearch.with_unknown_option("foo")
         }.to raise_error(ArgumentError, /foo/)
       end
 
-      context "dynamically" do
+      context "with a lambda" do
         it "raises an exception when invoked" do
           ModelWithPgSearch.pg_search_scope :with_unknown_option,
-            ->(*) { {:against => :content, :foo => :bar} }
+                                            ->(*) { { against: :content, foo: :bar } }
 
           expect {
             ModelWithPgSearch.with_unknown_option("foo")
@@ -77,18 +80,18 @@ describe "an Active Record model which includes PgSearch" do
     context "when an unknown :using is passed" do
       it "raises an exception when invoked" do
         ModelWithPgSearch.pg_search_scope :with_unknown_using,
-          :against => :content,
-          :using => :foo
+                                          against: :content,
+                                          using: :foo
 
         expect {
           ModelWithPgSearch.with_unknown_using("foo")
         }.to raise_error(ArgumentError, /foo/)
       end
 
-      context "dynamically" do
+      context "with a lambda" do
         it "raises an exception when invoked" do
           ModelWithPgSearch.pg_search_scope :with_unknown_using,
-            ->(*) { {:against => :content, :using => :foo} }
+                                            ->(*) { { against: :content, using: :foo } }
 
           expect {
             ModelWithPgSearch.with_unknown_using("foo")
@@ -100,18 +103,18 @@ describe "an Active Record model which includes PgSearch" do
     context "when an unknown :ignoring is passed" do
       it "raises an exception when invoked" do
         ModelWithPgSearch.pg_search_scope :with_unknown_ignoring,
-          :against => :content,
-          :ignoring => :foo
+                                          against: :content,
+                                          ignoring: :foo
 
         expect {
           ModelWithPgSearch.with_unknown_ignoring("foo")
         }.to raise_error(ArgumentError, /ignoring.*foo/)
       end
 
-      context "dynamically" do
+      context "with a lambda" do
         it "raises an exception when invoked" do
           ModelWithPgSearch.pg_search_scope :with_unknown_ignoring,
-            ->(*) { {:against => :content, :ignoring => :foo} }
+                                            ->(*) { { against: :content, ignoring: :foo } }
 
           expect {
             ModelWithPgSearch.with_unknown_ignoring("foo")
@@ -128,23 +131,39 @@ describe "an Active Record model which includes PgSearch" do
           }.to raise_error(ArgumentError, /against/)
         end
 
-        context "dynamically" do
+        context "with a lambda" do
           it "raises an exception when invoked" do
-            ModelWithPgSearch.pg_search_scope :with_unknown_ignoring, ->(*){ {} }
+            ModelWithPgSearch.pg_search_scope :with_unknown_ignoring, ->(*) { {} }
 
             expect {
               ModelWithPgSearch.with_unknown_ignoring("foo")
             }.to raise_error(ArgumentError, /against/)
           end
         end
+
+        context "when a tsvector column is specified" do
+          it "does not raise an exception when invoked" do
+            ModelWithPgSearch.pg_search_scope :with_unknown_ignoring, {
+              using: {
+                tsearch: {
+                  tsvector_column: "tsv"
+                }
+              }
+            }
+
+            expect {
+              ModelWithPgSearch.with_unknown_ignoring("foo")
+            }.not_to raise_error
+          end
+        end
       end
     end
   end
 
   describe "a search scope" do
-    context "against a single column" do
+    context "when against a single column" do
       before do
-        ModelWithPgSearch.pg_search_scope :search_content, :against => :content
+        ModelWithPgSearch.pg_search_scope :search_content, against: :content
       end
 
       context "when chained after a select() scope" do
@@ -155,7 +174,7 @@ describe "an Active Record model which includes PgSearch" do
           results = ModelWithPgSearch.select('id, title').search_content('foo')
 
           expect(results).to include(included)
-          expect(results).to_not include(excluded)
+          expect(results).not_to include(excluded)
 
           expect(results.first.attributes.key?('content')).to eq false
 
@@ -172,7 +191,7 @@ describe "an Active Record model which includes PgSearch" do
           results = ModelWithPgSearch.search_content('foo').select('id, title')
 
           expect(results).to include(included)
-          expect(results).to_not include(excluded)
+          expect(results).not_to include(excluded)
 
           expect(results.first.attributes.key?('content')).to eq false
 
@@ -189,7 +208,7 @@ describe "an Active Record model which includes PgSearch" do
           results = ModelWithPgSearch.select('id').search_content('foo').select('title')
 
           expect(results).to include(included)
-          expect(results).to_not include(excluded)
+          expect(results).not_to include(excluded)
 
           expect(results.first.attributes.key?('content')).to eq false
 
@@ -198,7 +217,7 @@ describe "an Active Record model which includes PgSearch" do
         end
       end
 
-      context "chained to a cross-table scope" do
+      context "when chained to a cross-table scope" do
         with_model :House do
           table do |t|
             t.references :person
@@ -206,7 +225,7 @@ describe "an Active Record model which includes PgSearch" do
           end
 
           model do
-            include PgSearch
+            include PgSearch::Model
             belongs_to :person
             pg_search_scope :search_city, against: [:city]
           end
@@ -218,11 +237,11 @@ describe "an Active Record model which includes PgSearch" do
           end
 
           model do
-            include PgSearch
+            include PgSearch::Model
             has_many :houses
             pg_search_scope :named, against: [:name]
             scope :with_house_in_city, lambda { |city|
-              joins(:houses).where(House.table_name.to_sym => {city: city})
+              joins(:houses).where(House.table_name.to_sym => { city: city })
             }
             scope :house_search_city, lambda { |query|
               joins(:houses).merge(House.search_city(query))
@@ -268,7 +287,7 @@ describe "an Active Record model which includes PgSearch" do
           it "does not raise an exception" do
             relation = Person.named('foo').house_search_city('bar')
 
-            expect { relation.to_a }.to_not raise_error
+            expect { relation.to_a }.not_to raise_error
           end
         end
       end
@@ -281,20 +300,20 @@ describe "an Active Record model which includes PgSearch" do
         it "does not raise an exception" do
           relation = ModelWithPgSearch.search_content('foo').search_title('bar')
 
-          expect { relation.to_a }.to_not raise_error
+          expect { relation.to_a }.not_to raise_error
         end
       end
 
       it "returns an empty array when a blank query is passed in" do
-        ModelWithPgSearch.create!(:content => 'foo')
+        ModelWithPgSearch.create!(content: 'foo')
 
         results = ModelWithPgSearch.search_content('')
         expect(results).to eq([])
       end
 
       it "returns rows where the column contains the term in the query" do
-        included = ModelWithPgSearch.create!(:content => 'foo')
-        excluded = ModelWithPgSearch.create!(:content => 'bar')
+        included = ModelWithPgSearch.create!(content: 'foo')
+        excluded = ModelWithPgSearch.create!(content: 'bar')
 
         results = ModelWithPgSearch.search_content('foo')
         expect(results).to include(included)
@@ -302,24 +321,24 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns the correct count" do
-        ModelWithPgSearch.create!(:content => 'foo')
-        ModelWithPgSearch.create!(:content => 'bar')
+        ModelWithPgSearch.create!(content: 'foo')
+        ModelWithPgSearch.create!(content: 'bar')
 
         results = ModelWithPgSearch.search_content('foo')
         expect(results.count).to eq 1
       end
 
       it "returns the correct count(:all)" do
-        ModelWithPgSearch.create!(:content => 'foo')
-        ModelWithPgSearch.create!(:content => 'bar')
+        ModelWithPgSearch.create!(content: 'foo')
+        ModelWithPgSearch.create!(content: 'bar')
 
         results = ModelWithPgSearch.search_content('foo')
         expect(results.count(:all)).to eq 1
       end
 
       it "supports #select" do
-        record = ModelWithPgSearch.create!(:content => 'foo')
-        other_record = ModelWithPgSearch.create!(:content => 'bar')
+        record = ModelWithPgSearch.create!(content: 'foo')
+        other_record = ModelWithPgSearch.create!(content: 'bar')
 
         records_with_only_id = ModelWithPgSearch.search_content('foo').select('id')
         expect(records_with_only_id.length).to eq 1
@@ -330,27 +349,27 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "supports #pluck" do
-        record = ModelWithPgSearch.create!(:content => 'foo')
-        other_record = ModelWithPgSearch.create!(:content => 'bar')
+        record = ModelWithPgSearch.create!(content: 'foo')
+        other_record = ModelWithPgSearch.create!(content: 'bar')
 
         ids = ModelWithPgSearch.search_content('foo').pluck('id')
         expect(ids).to eq [record.id]
       end
 
       it "supports adding where clauses using the pg_search.rank" do
-        once = ModelWithPgSearch.create!(:content => 'foo bar')
-        twice = ModelWithPgSearch.create!(:content => 'foo foo')
+        once = ModelWithPgSearch.create!(content: 'foo bar')
+        twice = ModelWithPgSearch.create!(content: 'foo foo')
 
         records = ModelWithPgSearch.search_content('foo')
-                  .where("#{PgSearch::Configuration.alias(ModelWithPgSearch.table_name)}.rank > 0.07")
+                                   .where("#{PgSearch::Configuration.alias(ModelWithPgSearch.table_name)}.rank > 0.07")
 
         expect(records).to eq [twice]
       end
 
       it "returns rows where the column contains all the terms in the query in any order" do
-        included = [ModelWithPgSearch.create!(:content => 'foo bar'),
-                    ModelWithPgSearch.create!(:content => 'bar foo')]
-        excluded = ModelWithPgSearch.create!(:content => 'foo')
+        included = [ModelWithPgSearch.create!(content: 'foo bar'),
+                    ModelWithPgSearch.create!(content: 'bar foo')]
+        excluded = ModelWithPgSearch.create!(content: 'foo')
 
         results = ModelWithPgSearch.search_content('foo bar')
         expect(results).to match_array(included)
@@ -358,8 +377,8 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns rows that match the query but not its case" do
-        included = [ModelWithPgSearch.create!(:content => "foo"),
-                    ModelWithPgSearch.create!(:content => "FOO")]
+        included = [ModelWithPgSearch.create!(content: "foo"),
+                    ModelWithPgSearch.create!(content: "FOO")]
 
         results = ModelWithPgSearch.search_content("Foo")
         expect(results).to match_array(included)
@@ -369,8 +388,8 @@ describe "an Active Record model which includes PgSearch" do
         # \303\241 is a with acute accent
         # \303\251 is e with acute accent
 
-        included = ModelWithPgSearch.create!(:content => "abcd\303\251f")
-        excluded = ModelWithPgSearch.create!(:content => "\303\241bcdef")
+        included = ModelWithPgSearch.create!(content: "abcd\303\251f")
+        excluded = ModelWithPgSearch.create!(content: "\303\241bcdef")
 
         results = ModelWithPgSearch.search_content("abcd\303\251f")
         expect(results).to eq([included])
@@ -378,8 +397,8 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns rows that match the query but not rows that are prefixed by the query" do
-        included = ModelWithPgSearch.create!(:content => 'pre')
-        excluded = ModelWithPgSearch.create!(:content => 'prefix')
+        included = ModelWithPgSearch.create!(content: 'pre')
+        excluded = ModelWithPgSearch.create!(content: 'prefix')
 
         results = ModelWithPgSearch.search_content("pre")
         expect(results).to eq([included])
@@ -387,28 +406,37 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns rows that match the query exactly and not those that match the query when stemmed by the default english dictionary" do
-        included = ModelWithPgSearch.create!(:content => "jumped")
-        excluded = [ModelWithPgSearch.create!(:content => "jump"),
-                    ModelWithPgSearch.create!(:content => "jumping")]
+        included = ModelWithPgSearch.create!(content: "jumped")
+        excluded = [ModelWithPgSearch.create!(content: "jump"),
+                    ModelWithPgSearch.create!(content: "jumping")]
 
         results = ModelWithPgSearch.search_content("jumped")
         expect(results).to eq([included])
       end
 
       it "returns rows that match sorted by rank" do
-        loser = ModelWithPgSearch.create!(:content => 'foo')
-        winner = ModelWithPgSearch.create!(:content => 'foo foo')
+        loser = ModelWithPgSearch.create!(content: 'foo')
+        winner = ModelWithPgSearch.create!(content: 'foo foo')
 
         results = ModelWithPgSearch.search_content("foo").with_pg_search_rank
         expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
         expect(results).to eq([winner, loser])
       end
 
+      it 'preserves column selection when with_pg_search_rank is chained after a select()' do
+        loser = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
+
+        results = ModelWithPgSearch.search_content('bar').select(:content).with_pg_search_rank
+
+        expect(results.length).to be 1
+        expect(results.first.as_json.keys).to contain_exactly('id', 'content', 'pg_search_rank')
+      end
+
       it 'allows pg_search_rank along with a join' do
         parent_1 = ParentModel.create!(id: 98)
         parent_2 = ParentModel.create!(id: 99)
-        loser = ModelWithPgSearch.create!(:content => 'foo', parent_model: parent_2)
-        winner = ModelWithPgSearch.create!(:content => 'foo foo', parent_model: parent_1)
+        loser = ModelWithPgSearch.create!(content: 'foo', parent_model: parent_2)
+        winner = ModelWithPgSearch.create!(content: 'foo foo', parent_model: parent_1)
 
         results = ModelWithPgSearch.joins(:parent_model).merge(ParentModel.active).search_content("foo").with_pg_search_rank
         expect(results.map(&:id)).to eq [winner.id, loser.id]
@@ -417,8 +445,8 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns results that match sorted by primary key for records that rank the same" do
-        sorted_results = [ModelWithPgSearch.create!(:content => 'foo'),
-                          ModelWithPgSearch.create!(:content => 'foo')].sort_by(&:id)
+        sorted_results = [ModelWithPgSearch.create!(content: 'foo'),
+                          ModelWithPgSearch.create!(content: 'foo')].sort_by(&:id)
 
         results = ModelWithPgSearch.search_content("foo")
         expect(results).to eq(sorted_results)
@@ -426,13 +454,13 @@ describe "an Active Record model which includes PgSearch" do
 
       it "returns results that match a query with multiple space-separated search terms" do
         included = [
-          ModelWithPgSearch.create!(:content => 'foo bar'),
-          ModelWithPgSearch.create!(:content => 'bar foo'),
-          ModelWithPgSearch.create!(:content => 'bar foo baz'),
+          ModelWithPgSearch.create!(content: 'foo bar'),
+          ModelWithPgSearch.create!(content: 'bar foo'),
+          ModelWithPgSearch.create!(content: 'bar foo baz')
         ]
         excluded = [
-          ModelWithPgSearch.create!(:content => 'foo'),
-          ModelWithPgSearch.create!(:content => 'foo baz')
+          ModelWithPgSearch.create!(content: 'foo'),
+          ModelWithPgSearch.create!(content: 'foo baz')
         ]
 
         results = ModelWithPgSearch.search_content('foo bar')
@@ -441,15 +469,15 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns rows that match a query with characters that are invalid in a tsquery expression" do
-        included = ModelWithPgSearch.create!(:content => "(:Foo.) Bar?, \\")
+        included = ModelWithPgSearch.create!(content: "(:Foo.) Bar?, \\")
 
         results = ModelWithPgSearch.search_content("foo :bar .,?() \\")
         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")
+        foo = ModelWithPgSearch.create!(content: "foo")
+        not_a_string = instance_double("Object", to_s: "foo")
         expect(ModelWithPgSearch.search_content(not_a_string)).to eq([foo])
       end
 
@@ -460,12 +488,12 @@ describe "an Active Record model which includes PgSearch" do
           end
 
           model do
-            include PgSearch
+            include PgSearch::Model
 
             # WARNING: searching timestamps is not something PostgreSQL
             # full-text search is good at. Use at your own risk.
             pg_search_scope :search_timestamps,
-              :against => %i[created_at updated_at]
+                            against: %i[created_at updated_at]
           end
         end
 
@@ -479,19 +507,19 @@ describe "an Active Record model which includes PgSearch" do
       end
     end
 
-    context "against multiple columns" do
+    context "when against multiple columns" do
       before do
-        ModelWithPgSearch.pg_search_scope :search_title_and_content, :against => %i[title content]
+        ModelWithPgSearch.pg_search_scope :search_title_and_content, against: %i[title content]
       end
 
       it "returns rows whose columns contain all of the terms in the query across columns" do
         included = [
-          ModelWithPgSearch.create!(:title => 'foo', :content => 'bar'),
-          ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
+          ModelWithPgSearch.create!(title: 'foo', content: 'bar'),
+          ModelWithPgSearch.create!(title: 'bar', content: 'foo')
         ]
         excluded = [
-          ModelWithPgSearch.create!(:title => 'foo', :content => 'foo'),
-          ModelWithPgSearch.create!(:title => 'bar', :content => 'bar')
+          ModelWithPgSearch.create!(title: 'foo', content: 'foo'),
+          ModelWithPgSearch.create!(title: 'bar', content: 'bar')
         ]
 
         results = ModelWithPgSearch.search_title_and_content('foo bar')
@@ -503,8 +531,8 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns rows where at one column contains all of the terms in the query and another does not" do
-        in_title = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
-        in_content = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
+        in_title = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
+        in_content = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
 
         results = ModelWithPgSearch.search_title_and_content('foo')
         expect(results).to match_array([in_title, in_content])
@@ -512,39 +540,39 @@ describe "an Active Record model which includes PgSearch" do
 
       # 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)
+        included = ModelWithPgSearch.create!(title: 'foo', content: nil)
         results  = ModelWithPgSearch.search_title_and_content('foo')
         expect(results).to eq([included])
       end
     end
 
-    context "using trigram" do
+    context "when using trigram" do
       before do
-        ModelWithPgSearch.pg_search_scope :with_trigrams, :against => %i[title content], :using => :trigram
+        ModelWithPgSearch.pg_search_scope :with_trigrams, against: %i[title content], using: :trigram
       end
 
       it "returns rows where one searchable column and the query share enough trigrams" do
-        included = ModelWithPgSearch.create!(:title => 'abcdefghijkl', :content => nil)
+        included = ModelWithPgSearch.create!(title: 'abcdefghijkl', content: nil)
         results = ModelWithPgSearch.with_trigrams('cdefhijkl')
         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')
+        included = ModelWithPgSearch.create!(title: 'abcdef', content: 'ghijkl')
         results = ModelWithPgSearch.with_trigrams('cdefhijkl')
         expect(results).to eq([included])
       end
 
       context "when a threshold is specified" do
         before do
-          ModelWithPgSearch.pg_search_scope :with_strict_trigrams, :against => %i[title content], :using => {trigram: {threshold: 0.5}}
-          ModelWithPgSearch.pg_search_scope :with_permissive_trigrams, :against => %i[title content], :using => {trigram: {threshold: 0.1}}
+          ModelWithPgSearch.pg_search_scope :with_strict_trigrams, against: %i[title content], using: { trigram: { threshold: 0.5 } }
+          ModelWithPgSearch.pg_search_scope :with_permissive_trigrams, against: %i[title content], using: { trigram: { threshold: 0.1 } }
         end
 
         it "uses the threshold in the trigram expression" do
-          low_similarity = ModelWithPgSearch.create!(:title => "a")
-          medium_similarity = ModelWithPgSearch.create!(:title => "abc")
-          high_similarity = ModelWithPgSearch.create!(:title => "abcdefghijkl")
+          low_similarity = ModelWithPgSearch.create!(title: "a")
+          medium_similarity = ModelWithPgSearch.create!(title: "abc")
+          high_similarity = ModelWithPgSearch.create!(title: "abcdefghijkl")
 
           results = ModelWithPgSearch.with_strict_trigrams("abcdefg")
           expect(results).to include(high_similarity)
@@ -560,19 +588,19 @@ describe "an Active Record model which includes PgSearch" do
       end
     end
 
-    context "using tsearch" do
+    context "when using tsearch" do
       before do
         ModelWithPgSearch.pg_search_scope :search_title_with_prefixes,
-          :against => :title,
-          :using => {
-            :tsearch => {:prefix => true}
-          }
+                                          against: :title,
+                                          using: {
+                                            tsearch: { prefix: true }
+                                          }
       end
 
-      context "with :prefix => true" do
+      context "with prefix: true" do
         it "returns rows that match the query and that are prefixed by the query" do
-          included = ModelWithPgSearch.create!(:title => 'prefix')
-          excluded = ModelWithPgSearch.create!(:title => 'postfix')
+          included = ModelWithPgSearch.create!(title: 'prefix')
+          excluded = ModelWithPgSearch.create!(title: 'postfix')
 
           results = ModelWithPgSearch.search_title_with_prefixes("pre")
           expect(results).to eq([included])
@@ -580,8 +608,8 @@ describe "an Active Record model which includes PgSearch" do
         end
 
         it "returns rows that match the query when the query has a hyphen" do
-          included = ModelWithPgSearch.create!(:title => 'foo-bar')
-          excluded = ModelWithPgSearch.create!(:title => 'foo bar')
+          included = ModelWithPgSearch.create!(title: 'foo-bar')
+          excluded = ModelWithPgSearch.create!(title: 'foo bar')
 
           results = ModelWithPgSearch.search_title_with_prefixes("foo-bar")
           expect(results).to include(included)
@@ -592,16 +620,16 @@ describe "an Active Record model which includes PgSearch" do
       context "with the english dictionary" do
         before do
           ModelWithPgSearch.pg_search_scope :search_content_with_english,
-            :against => :content,
-            :using => {
-              :tsearch => {:dictionary => :english}
-            }
+                                            against: :content,
+                                            using: {
+                                              tsearch: { dictionary: :english }
+                                            }
         end
 
         it "returns rows that match the query when stemmed by the english dictionary" do
-          included = [ModelWithPgSearch.create!(:content => "jump"),
-                      ModelWithPgSearch.create!(:content => "jumped"),
-                      ModelWithPgSearch.create!(:content => "jumping")]
+          included = [ModelWithPgSearch.create!(content: "jump"),
+                      ModelWithPgSearch.create!(content: "jumped"),
+                      ModelWithPgSearch.create!(content: "jumping")]
 
           results = ModelWithPgSearch.search_content_with_english("jump")
           expect(results).to match_array(included)
@@ -611,14 +639,14 @@ describe "an Active Record model which includes PgSearch" do
       describe "highlighting" do
         before do
           ["Strip Down", "Down", "Down and Out", "Won't Let You Down"].each do |name|
-            ModelWithPgSearch.create! :content => name
+            ModelWithPgSearch.create! title: 'Just a title', content: name
           end
         end
 
         context "with highlight turned on" do
           before do
             ModelWithPgSearch.pg_search_scope :search_content,
-              :against => :content
+                                              against: :content
           end
 
           it "adds a #pg_search_highlight method to each returned model record" do
@@ -632,26 +660,32 @@ describe "an Active Record model which includes PgSearch" do
 
             expect(result.pg_search_highlight).to eq("Won't <b>Let</b> You Down")
           end
+
+          it 'preserves column selection when with_pg_search_highlight is chained after a select()' do
+            result = ModelWithPgSearch.search_content("Let").select(:content).with_pg_search_highlight.first
+
+            expect(result.as_json.keys).to contain_exactly('id', 'content', 'pg_search_highlight')
+          end
         end
 
         context "with custom highlighting options" do
           before do
-            ModelWithPgSearch.create! :content => "#{'text ' * 2}Let #{'text ' * 2}Let #{'text ' * 2}"
+            ModelWithPgSearch.create! content: "#{'text ' * 2}Let #{'text ' * 2}Let #{'text ' * 2}"
 
             ModelWithPgSearch.pg_search_scope :search_content,
-              :against => :content,
-              :using => {
-                :tsearch => {
-                  :highlight => {
-                    :StartSel => '<mark class="highlight">',
-                    :StopSel => '</mark>',
-                    :FragmentDelimiter => '<delim class="my_delim">',
-                    :MaxFragments => 2,
-                    :MaxWords => 2,
-                    :MinWords => 1
-                  }
-                }
-              }
+                                              against: :content,
+                                              using: {
+                                                tsearch: {
+                                                  highlight: {
+                                                    StartSel: '<mark class="highlight">',
+                                                    StopSel: '</mark>',
+                                                    FragmentDelimiter: '<delim class="my_delim">',
+                                                    MaxFragments: 2,
+                                                    MaxWords: 2,
+                                                    MinWords: 1
+                                                  }
+                                                }
+                                              }
           end
 
           it "applies the options to the excerpts" do
@@ -665,12 +699,12 @@ describe "an Active Record model which includes PgSearch" do
       describe "ranking" do
         before do
           ["Strip Down", "Down", "Down and Out", "Won't Let You Down"].each do |name|
-            ModelWithPgSearch.create! :content => name
+            ModelWithPgSearch.create! content: name
           end
         end
 
         it "adds a #pg_search_rank method to each returned model record" do
-          ModelWithPgSearch.pg_search_scope :search_content, :against => :content
+          ModelWithPgSearch.pg_search_scope :search_content, against: :content
 
           result = ModelWithPgSearch.search_content("Strip Down").with_pg_search_rank.first
 
@@ -680,10 +714,10 @@ describe "an Active Record model which includes PgSearch" do
         context "with a normalization specified" do
           before do
             ModelWithPgSearch.pg_search_scope :search_content_with_normalization,
-              :against => :content,
-              :using => {
-                :tsearch => {:normalization => 2}
-              }
+                                              against: :content,
+                                              using: {
+                                                tsearch: { normalization: 2 }
+                                              }
           end
 
           it "ranks the results for documents with less text higher" do
@@ -697,8 +731,8 @@ describe "an Active Record model which includes PgSearch" do
         context "with no normalization" do
           before do
             ModelWithPgSearch.pg_search_scope :search_content_without_normalization,
-              :against => :content,
-              :using => :tsearch
+                                              against: :content,
+                                              using: :tsearch
           end
 
           it "ranks the results equally" do
@@ -710,15 +744,15 @@ describe "an Active Record model which includes PgSearch" do
         end
       end
 
-      context "against columns ranked with arrays" do
+      context "when against columns ranked with arrays" do
         before do
           ModelWithPgSearch.pg_search_scope :search_weighted_by_array_of_arrays,
-            :against => [[:content, 'B'], [:title, 'A']]
+                                            against: [[:content, 'B'], [:title, 'A']]
         end
 
         it "returns results sorted by weighted rank" do
-          loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
+          loser = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
+          winner = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
 
           results = ModelWithPgSearch.search_weighted_by_array_of_arrays('foo').with_pg_search_rank
           expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
@@ -726,15 +760,15 @@ describe "an Active Record model which includes PgSearch" do
         end
       end
 
-      context "against columns ranked with a hash" do
+      context "when against columns ranked with a hash" do
         before do
           ModelWithPgSearch.pg_search_scope :search_weighted_by_hash,
-            :against => {:content => 'B', :title => 'A'}
+                                            against: { content: 'B', title: 'A' }
         end
 
         it "returns results sorted by weighted rank" do
-          loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
+          loser = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
+          winner = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
 
           results = ModelWithPgSearch.search_weighted_by_hash('foo').with_pg_search_rank
           expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
@@ -742,15 +776,15 @@ describe "an Active Record model which includes PgSearch" do
         end
       end
 
-      context "against columns of which only some are ranked" do
+      context "when against columns of which only some are ranked" do
         before do
           ModelWithPgSearch.pg_search_scope :search_weighted,
-            :against => [:content, [:title, 'A']]
+                                            against: [:content, [:title, 'A']]
         end
 
         it "returns results sorted by weighted rank using an implied low rank for unranked columns" do
-          loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
+          loser = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
+          winner = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
 
           results = ModelWithPgSearch.search_weighted('foo').with_pg_search_rank
           expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
@@ -758,20 +792,20 @@ describe "an Active Record model which includes PgSearch" do
         end
       end
 
-      context "searching any_word option" do
+      context "when searching any_word option" do
         before do
           ModelWithPgSearch.pg_search_scope :search_title_with_any_word,
-            :against => :title,
-            :using => {
-              :tsearch => {:any_word => true}
-            }
+                                            against: :title,
+                                            using: {
+                                              tsearch: { any_word: true }
+                                            }
 
           ModelWithPgSearch.pg_search_scope :search_title_with_all_words,
-            :against => :title
+                                            against: :title
         end
 
         it "returns all results containing any word in their title" do
-          numbers = %w[one two three four].map { |number| ModelWithPgSearch.create!(:title => number) }
+          numbers = %w[one two three four].map { |number| ModelWithPgSearch.create!(title: number) }
 
           results = ModelWithPgSearch.search_title_with_any_word("one two three four")
 
@@ -786,21 +820,21 @@ describe "an Active Record model which includes PgSearch" do
       context "with :negation" do
         before do
           ModelWithPgSearch.pg_search_scope :search_with_negation,
-            :against => :title,
-            :using => {
-              :tsearch => {:negation => true}
-            }
+                                            against: :title,
+                                            using: {
+                                              tsearch: { negation: true }
+                                            }
         end
 
         it "doesn't return results that contain terms prepended with '!'" do
           included = [
-            ModelWithPgSearch.create!(:title => "one fish"),
-            ModelWithPgSearch.create!(:title => "two fish")
+            ModelWithPgSearch.create!(title: "one fish"),
+            ModelWithPgSearch.create!(title: "two fish")
           ]
 
           excluded = [
-            ModelWithPgSearch.create!(:title => "red fish"),
-            ModelWithPgSearch.create!(:title => "blue fish")
+            ModelWithPgSearch.create!(title: "red fish"),
+            ModelWithPgSearch.create!(title: "blue fish")
           ]
 
           results = ModelWithPgSearch.search_with_negation("fish !red !blue")
@@ -813,19 +847,19 @@ describe "an Active Record model which includes PgSearch" do
       context "without :negation" do
         before do
           ModelWithPgSearch.pg_search_scope :search_without_negation,
-            :against => :title,
-            :using => {
-              :tsearch => {}
-            }
+                                            against: :title,
+                                            using: {
+                                              tsearch: {}
+                                            }
         end
 
         it "return results that contain terms prepended with '!'" do
           included = [
-            ModelWithPgSearch.create!(:title => "!bang")
+            ModelWithPgSearch.create!(title: "!bang")
           ]
 
           excluded = [
-            ModelWithPgSearch.create!(:title => "?question")
+            ModelWithPgSearch.create!(title: "?question")
           ]
 
           results = ModelWithPgSearch.search_without_negation("!bang")
@@ -836,30 +870,30 @@ describe "an Active Record model which includes PgSearch" do
       end
     end
 
-    context "using dmetaphone" do
+    context "when using dmetaphone" do
       before do
         ModelWithPgSearch.pg_search_scope :with_dmetaphones,
-          :against => %i[title content],
-          :using => :dmetaphone
+                                          against: %i[title content],
+                                          using: :dmetaphone
       end
 
       it "returns rows where one searchable column and the query share enough dmetaphones" do
-        included = ModelWithPgSearch.create!(:title => 'Geoff', :content => nil)
-        excluded = ModelWithPgSearch.create!(:title => 'Bob', :content => nil)
+        included = ModelWithPgSearch.create!(title: 'Geoff', content: nil)
+        excluded = ModelWithPgSearch.create!(title: 'Bob', content: nil)
         results = ModelWithPgSearch.with_dmetaphones('Jeff')
         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')
+        included = ModelWithPgSearch.create!(title: 'Geoff', content: 'George')
+        excluded = ModelWithPgSearch.create!(title: 'Bob', content: 'Jones')
         results = ModelWithPgSearch.with_dmetaphones('Jeff Jorge')
         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)
+        included = ModelWithPgSearch.create!(title: 'White', content: nil)
+        excluded = ModelWithPgSearch.create!(title: 'Black', content: nil)
         results = ModelWithPgSearch.with_dmetaphones('Wight')
         expect(results).to eq([included])
       end
@@ -867,50 +901,50 @@ describe "an Active Record model which includes PgSearch" do
       it "can handle terms that do not have a dmetaphone equivalent" do
         term_with_blank_metaphone = "w"
 
-        included = ModelWithPgSearch.create!(:title => 'White', :content => nil)
-        excluded = ModelWithPgSearch.create!(:title => 'Black', :content => nil)
+        included = ModelWithPgSearch.create!(title: 'White', content: nil)
+        excluded = ModelWithPgSearch.create!(title: 'Black', content: nil)
 
         results = ModelWithPgSearch.with_dmetaphones('Wight W')
         expect(results).to eq([included])
       end
     end
 
-    context "using multiple features" do
+    context "when using multiple features" do
       before do
         ModelWithPgSearch.pg_search_scope :with_tsearch,
-          :against => :title,
-          :using => [
-            [:tsearch, {:dictionary => 'english'}]
-          ]
+                                          against: :title,
+                                          using: [
+                                            [:tsearch, { dictionary: 'english' }]
+                                          ]
 
         ModelWithPgSearch.pg_search_scope :with_trigram,
-          :against => :title,
-          :using => :trigram
+                                          against: :title,
+                                          using: :trigram
 
         ModelWithPgSearch.pg_search_scope :with_trigram_and_ignoring_accents,
-          :against => :title,
-          :ignoring => :accents,
-          :using => :trigram
+                                          against: :title,
+                                          ignoring: :accents,
+                                          using: :trigram
 
         ModelWithPgSearch.pg_search_scope :with_tsearch_and_trigram,
-          :against => :title,
-          :using => [
-            [:tsearch, {:dictionary => 'english'}],
-            :trigram
-          ]
+                                          against: :title,
+                                          using: [
+                                            [:tsearch, { dictionary: 'english' }],
+                                            :trigram
+                                          ]
 
         ModelWithPgSearch.pg_search_scope :complex_search,
-          :against => %i[content title],
-          :ignoring => :accents,
-          :using => {
-            :tsearch => {:dictionary => 'english'},
-            :dmetaphone => {},
-            :trigram => {}
-          }
+                                          against: %i[content title],
+                                          ignoring: :accents,
+                                          using: {
+                                            tsearch: { dictionary: 'english' },
+                                            dmetaphone: {},
+                                            trigram: {}
+                                          }
       end
 
       it "returns rows that match using any of the features" do
-        record = ModelWithPgSearch.create!(:title => "tiling is grouty")
+        record = ModelWithPgSearch.create!(title: "tiling is grouty")
 
         # matches trigram only
         trigram_query = "ling is grouty"
@@ -948,33 +982,40 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       context "with feature-specific configuration" do
-        before do
-          @tsearch_config = tsearch_config = {:dictionary => 'english'}
-          @trigram_config = trigram_config = {:foo => 'bar'}
+        let(:tsearch_config) { { dictionary: 'english' } }
+        let(:trigram_config) { { foo: 'bar' } }
 
+        before do
           ModelWithPgSearch.pg_search_scope :with_tsearch_and_trigram_using_hash,
-            :against => :title,
-            :using => {
-              :tsearch => tsearch_config,
-              :trigram => trigram_config
-            }
+                                            against: :title,
+                                            using: { tsearch: tsearch_config, trigram: trigram_config }
         end
 
-        it "should pass the custom configuration down to the specified feature" do
-          stub_feature = double(
-            :conditions => Arel::Nodes::Grouping.new(Arel.sql("1 = 1")),
-            :rank => Arel::Nodes::Grouping.new(Arel.sql("1.0"))
+        it "passes the custom configuration down to the specified feature" do
+          tsearch_feature = instance_double(
+            "PgSearch::Features::TSearch",
+            conditions: Arel::Nodes::Grouping.new(Arel.sql("1 = 1")),
+            rank: Arel::Nodes::Grouping.new(Arel.sql("1.0"))
           )
 
-          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)
+          trigram_feature = instance_double(
+            "PgSearch::Features::Trigram",
+            conditions: Arel::Nodes::Grouping.new(Arel.sql("1 = 1")),
+            rank: Arel::Nodes::Grouping.new(Arel.sql("1.0"))
+          )
+
+          allow(PgSearch::Features::TSearch).to receive(:new).with(anything, tsearch_config, anything, anything, anything).and_return(tsearch_feature)
+          allow(PgSearch::Features::Trigram).to receive(:new).with(anything, trigram_config, anything, anything, anything).and_return(trigram_feature)
 
           ModelWithPgSearch.with_tsearch_and_trigram_using_hash("foo")
+
+          expect(PgSearch::Features::TSearch).to have_received(:new).with(anything, tsearch_config, anything, anything, anything).at_least(:once)
+          expect(PgSearch::Features::Trigram).to have_received(:new).with(anything, trigram_config, anything, anything, anything).at_least(:once)
         end
       end
     end
 
-    context "using a tsvector column and an association" do
+    context "when using a tsvector column and an association" do
       with_model :Comment do
         table do |t|
           t.integer :post_id
@@ -993,7 +1034,7 @@ describe "an Active Record model which includes PgSearch" do
         end
 
         model do
-          include PgSearch
+          include PgSearch::Model
           has_many :comments
         end
       end
@@ -1002,7 +1043,7 @@ describe "an Active Record model which includes PgSearch" do
       let!(:unexpected) { Post.create!(content: 'longcat is looooooooong') }
 
       before do
-        ActiveRecord::Base.connection.execute <<-SQL.strip_heredoc
+        ActiveRecord::Base.connection.execute <<~SQL.squish
           UPDATE #{Post.quoted_table_name}
           SET content_tsvector = to_tsvector('english'::regconfig, #{Post.quoted_table_name}."content")
         SQL
@@ -1011,41 +1052,41 @@ describe "an Active Record model which includes PgSearch" do
         unexpected.comments.create(body: 'commentwo')
 
         Post.pg_search_scope :search_by_content_with_tsvector,
-          :associated_against => {comments: [:body]},
-          :using => {
-            :tsearch => {
-              :tsvector_column => 'content_tsvector',
-              :dictionary => 'english'
-            }
-          }
+                             associated_against: { comments: [:body] },
+                             using: {
+                               tsearch: {
+                                 tsvector_column: 'content_tsvector',
+                                 dictionary: 'english'
+                               }
+                             }
       end
 
-      it "should find by the tsvector column" do
+      it "finds by the tsvector column" do
         expect(Post.search_by_content_with_tsvector("phooey").map(&:id)).to eq([expected.id])
       end
 
-      it "should find by the associated record" do
+      it "finds by the associated record" do
         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
+      it 'finds by a combination of the two' do
         expect(Post.search_by_content_with_tsvector("phooey commentone").map(&:id)).to eq([expected.id])
       end
     end
 
-    context 'using multiple tsvector columns' do
+    context 'when using multiple tsvector columns' do
       with_model :ModelWithTsvector do
         model do
-          include PgSearch
+          include PgSearch::Model
 
           pg_search_scope :search_by_multiple_tsvector_columns,
-            :against => ['content', 'message'],
-            :using => {
-              :tsearch => {
-                :tsvector_column => ['content_tsvector', 'message_tsvector'],
-                :dictionary => 'english'
-              }
-            }
+                          against: ['content', 'message'],
+                          using: {
+                            tsearch: {
+                              tsvector_column: ['content_tsvector', 'message_tsvector'],
+                              dictionary: 'english'
+                            }
+                          }
         end
       end
 
@@ -1057,40 +1098,41 @@ describe "an Active Record model which includes PgSearch" do
       end
     end
 
-    context "using a tsvector column with" do
+    context "when using a tsvector column with" do
       with_model :ModelWithTsvector do
         table do |t|
           t.text 'content'
           t.tsvector 'content_tsvector'
         end
 
-        model { include PgSearch }
+        model { include PgSearch::Model }
       end
 
-      let!(:expected) { ModelWithTsvector.create!(:content => 'tiling is grouty') }
-      let!(:unexpected) { ModelWithTsvector.create!(:content => 'longcat is looooooooong') }
+      let!(:expected) { ModelWithTsvector.create!(content: 'tiling is grouty') }
 
       before do
-        ActiveRecord::Base.connection.execute <<-SQL.strip_heredoc
+        ModelWithTsvector.create!(content: 'longcat is looooooooong')
+
+        ActiveRecord::Base.connection.execute <<~SQL.squish
           UPDATE #{ModelWithTsvector.quoted_table_name}
           SET content_tsvector = to_tsvector('english'::regconfig, #{ModelWithTsvector.quoted_table_name}."content")
         SQL
 
         ModelWithTsvector.pg_search_scope :search_by_content_with_tsvector,
-          :against => :content,
-          :using => {
-            :tsearch => {
-              :tsvector_column => 'content_tsvector',
-              :dictionary => 'english'
-            }
-          }
+                                          against: :content,
+                                          using: {
+                                            tsearch: {
+                                              tsvector_column: 'content_tsvector',
+                                              dictionary: 'english'
+                                            }
+                                          }
       end
 
-      it "should not use to_tsvector in the query" do
+      it "does not use to_tsvector in the query" do
         expect(ModelWithTsvector.search_by_content_with_tsvector("tiles").to_sql).not_to match(/to_tsvector/)
       end
 
-      it "should find the expected result" do
+      it "finds the expected result" do
         expect(ModelWithTsvector.search_by_content_with_tsvector("tiles").map(&:id)).to eq([expected.id])
       end
 
@@ -1106,7 +1148,7 @@ describe "an Active Record model which includes PgSearch" do
           ModelWithTsvector.has_many :another_models
         end
 
-        it "should refer to the tsvector column in the query unambiguously" do
+        it "refers to the tsvector column in the query unambiguously" do
           expect {
             ModelWithTsvector.joins(:another_models).search_by_content_with_tsvector("test").to_a
           }.not_to raise_exception
@@ -1114,46 +1156,55 @@ describe "an Active Record model which includes PgSearch" do
       end
     end
 
-    context "ignoring accents" do
+    context "when ignoring accents" do
       before do
         ModelWithPgSearch.pg_search_scope :search_title_without_accents,
-          :against => :title,
-          :ignoring => :accents
+                                          against: :title,
+                                          ignoring: :accents
       end
 
       it "returns rows that match the query but not its accents" do
         # \303\241 is a with acute accent
         # \303\251 is e with acute accent
 
-        included = ModelWithPgSearch.create!(:title => "\303\241bcdef")
+        included = ModelWithPgSearch.create!(title: "\303\241bcdef")
 
         results = ModelWithPgSearch.search_title_without_accents("abcd\303\251f")
         expect(results).to eq([included])
       end
+
+      context "when the query includes accents" do
+        it "does not create an erroneous tsquery expression" do
+          included = ModelWithPgSearch.create!(title: "Weird L‘Content")
+
+          results = ModelWithPgSearch.search_title_without_accents("L‘Content")
+          expect(results).to eq([included])
+        end
+      end
     end
 
     context "when passed a :ranked_by expression" do
       before do
         ModelWithPgSearch.pg_search_scope :search_content_with_default_rank,
-          :against => :content
+                                          against: :content
 
         ModelWithPgSearch.pg_search_scope :search_content_with_importance_as_rank,
-          :against => :content,
-          :ranked_by => "importance"
+                                          against: :content,
+                                          ranked_by: "importance"
 
         ModelWithPgSearch.pg_search_scope :search_content_with_importance_as_rank_multiplier,
-          :against => :content,
-          :ranked_by => ":tsearch * importance"
+                                          against: :content,
+                                          ranked_by: ":tsearch * importance"
       end
 
-      it "should return records with a rank attribute equal to the :ranked_by expression" do
-        ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
+      it "returns 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").with_pg_search_rank
         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
-        ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
+      it "substitutes :tsearch with the tsearch rank expression in the :ranked_by expression" do
+        ModelWithPgSearch.create!(content: 'foo', importance: 10)
 
         tsearch_result =
           ModelWithPgSearch.search_content_with_default_rank("foo").with_pg_search_rank.first
@@ -1162,19 +1213,19 @@ describe "an Active Record model which includes PgSearch" do
 
         multiplied_result =
           ModelWithPgSearch.search_content_with_importance_as_rank_multiplier("foo")
-            .with_pg_search_rank
-            .first
+                           .with_pg_search_rank
+                           .first
 
         multiplied_rank = multiplied_result.pg_search_rank
 
         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
+      it "returns results in descending order of the value of the rank expression" do
         records = [
-          ModelWithPgSearch.create!(:content => 'foo', :importance => 1),
-          ModelWithPgSearch.create!(:content => 'foo', :importance => 3),
-          ModelWithPgSearch.create!(:content => 'foo', :importance => 2)
+          ModelWithPgSearch.create!(content: 'foo', importance: 1),
+          ModelWithPgSearch.create!(content: 'foo', importance: 3),
+          ModelWithPgSearch.create!(content: 'foo', importance: 2)
         ]
 
         results = ModelWithPgSearch.search_content_with_importance_as_rank("foo")
@@ -1184,12 +1235,13 @@ describe "an Active Record model which includes PgSearch" do
       %w[tsearch trigram dmetaphone].each do |feature|
         context "using the #{feature} ranking algorithm" do
           let(:scope_name) { :"search_content_ranked_by_#{feature}" }
+
           before do
             ModelWithPgSearch.pg_search_scope scope_name,
-              :against => :content,
-              :ranked_by => ":#{feature}"
+                                              against: :content,
+                                              ranked_by: ":#{feature}"
 
-            ModelWithPgSearch.create!(:content => 'foo')
+            ModelWithPgSearch.create!(content: 'foo')
           end
 
           context "when .with_pg_search_rank is chained after" do
@@ -1220,45 +1272,45 @@ describe "an Active Record model which includes PgSearch" do
         end
       end
 
-      context "using the tsearch ranking algorithm" do
+      context "when using the tsearch ranking algorithm" do
         it "sorts results by the tsearch rank" do
           ModelWithPgSearch.pg_search_scope :search_content_ranked_by_tsearch,
-            :using => :tsearch,
-            :against => :content,
-            :ranked_by => ":tsearch"
+                                            using: :tsearch,
+                                            against: :content,
+                                            ranked_by: ":tsearch"
 
-          once = ModelWithPgSearch.create!(:content => 'foo bar')
-          twice = ModelWithPgSearch.create!(:content => 'foo foo')
+          once = ModelWithPgSearch.create!(content: 'foo bar')
+          twice = ModelWithPgSearch.create!(content: 'foo foo')
 
           results = ModelWithPgSearch.search_content_ranked_by_tsearch('foo')
           expect(results.find_index(twice)).to be < results.find_index(once)
         end
       end
 
-      context "using the trigram ranking algorithm" do
+      context "when using the trigram ranking algorithm" do
         it "sorts results by the trigram rank" do
           ModelWithPgSearch.pg_search_scope :search_content_ranked_by_trigram,
-            :using => :trigram,
-            :against => :content,
-            :ranked_by => ":trigram"
+                                            using: :trigram,
+                                            against: :content,
+                                            ranked_by: ":trigram"
 
-          close = ModelWithPgSearch.create!(:content => 'abcdef')
-          exact = ModelWithPgSearch.create!(:content => 'abc')
+          close = ModelWithPgSearch.create!(content: 'abcdef')
+          exact = ModelWithPgSearch.create!(content: 'abc')
 
           results = ModelWithPgSearch.search_content_ranked_by_trigram('abc')
           expect(results.find_index(exact)).to be < results.find_index(close)
         end
       end
 
-      context "using the dmetaphone ranking algorithm" do
+      context "when using the dmetaphone ranking algorithm" do
         it "sorts results by the dmetaphone rank" do
           ModelWithPgSearch.pg_search_scope :search_content_ranked_by_dmetaphone,
-            :using => :dmetaphone,
-            :against => :content,
-            :ranked_by => ":dmetaphone"
+                                            using: :dmetaphone,
+                                            against: :content,
+                                            ranked_by: ":dmetaphone"
 
-          once = ModelWithPgSearch.create!(:content => 'Phoo Bar')
-          twice = ModelWithPgSearch.create!(:content => 'Phoo Fu')
+          once = ModelWithPgSearch.create!(content: 'Phoo Bar')
+          twice = ModelWithPgSearch.create!(content: 'Phoo Fu')
 
           results = ModelWithPgSearch.search_content_ranked_by_dmetaphone('foo')
           expect(results.find_index(twice)).to be < results.find_index(once)
@@ -1269,17 +1321,17 @@ describe "an Active Record model which includes PgSearch" do
     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")
+                                          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]
@@ -1287,3 +1339,4 @@ describe "an Active Record model which includes PgSearch" do
     end
   end
 end
+# rubocop:enable RSpec/NestedGroups