pg_search 2.3.6 → 2.3.8

data/spec/integration/pg_search_spec.rb

@@ -2,18 +2,19 @@
 
 require "spec_helper"
 
-# rubocop:disable RSpec/NestedGroups
+# standard:disable RSpec/NestedGroups
 describe "an Active Record model which includes PgSearch" do
   with_model :ModelWithPgSearch do
     table do |t|
-      t.string 'title'
-      t.text 'content'
-      t.integer 'parent_model_id'
-      t.integer 'importance'
+      t.string "title"
+      t.text "content"
+      t.integer "parent_model_id"
+      t.integer "importance"
     end
 
     model do
       include PgSearch::Model
+
       belongs_to :parent_model
     end
   end
@@ -24,6 +25,7 @@ describe "an Active Record model which includes PgSearch" do
 
     model do
       include PgSearch::Model
+
       has_many :models_with_pg_search
       scope :active, -> { where(active: true) }
     end
@@ -39,26 +41,38 @@ 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")
+        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])
+      end
+    end
 
-        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])
+    context "when passed an invalid argument" do
+      it "builds a dynamic scope" do
+        expect {
+          ModelWithPgSearch.pg_search_scope :search_title_or_content, :some_symbol
+        }.to(
+          raise_exception(ArgumentError).with_message(
+            "pg_search_scope expects a Hash or Proc"
+          )
+        )
       end
     end
 
     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")
@@ -68,7 +82,7 @@ describe "an Active Record model which includes PgSearch" 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")
@@ -80,8 +94,8 @@ 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")
@@ -91,7 +105,7 @@ describe "an Active Record model which includes PgSearch" 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")
@@ -103,8 +117,8 @@ 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")
@@ -114,7 +128,7 @@ describe "an Active Record model which includes PgSearch" 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")
@@ -168,15 +182,15 @@ describe "an Active Record model which includes PgSearch" do
 
       context "when chained after a select() scope" do
         it "honors the select" do
-          included = ModelWithPgSearch.create!(content: 'foo', title: 'bar')
-          excluded = ModelWithPgSearch.create!(content: 'bar', title: 'foo')
+          included = ModelWithPgSearch.create!(content: "foo", title: "bar")
+          excluded = ModelWithPgSearch.create!(content: "bar", title: "foo")
 
-          results = ModelWithPgSearch.select('id, title').search_content('foo')
+          results = ModelWithPgSearch.select("id, title").search_content("foo")
 
           expect(results).to include(included)
           expect(results).not_to include(excluded)
 
-          expect(results.first.attributes.key?('content')).to eq false
+          expect(results.first.attributes.key?("content")).to be false
 
           expect(results.select { |record| record.title == "bar" }).to eq [included]
           expect(results.reject { |record| record.title == "bar" }).to be_empty
@@ -185,15 +199,15 @@ describe "an Active Record model which includes PgSearch" do
 
       context "when chained before a select() scope" do
         it "honors the select" do
-          included = ModelWithPgSearch.create!(content: 'foo', title: 'bar')
-          excluded = ModelWithPgSearch.create!(content: 'bar', title: 'foo')
+          included = ModelWithPgSearch.create!(content: "foo", title: "bar")
+          excluded = ModelWithPgSearch.create!(content: "bar", title: "foo")
 
-          results = ModelWithPgSearch.search_content('foo').select('id, title')
+          results = ModelWithPgSearch.search_content("foo").select("id, title")
 
           expect(results).to include(included)
           expect(results).not_to include(excluded)
 
-          expect(results.first.attributes.key?('content')).to eq false
+          expect(results.first.attributes.key?("content")).to be false
 
           expect(results.select { |record| record.title == "bar" }).to eq [included]
           expect(results.reject { |record| record.title == "bar" }).to be_empty
@@ -202,15 +216,15 @@ describe "an Active Record model which includes PgSearch" do
 
       context "when surrouned by select() scopes" do
         it "honors the select" do
-          included = ModelWithPgSearch.create!(content: 'foo', title: 'bar')
-          excluded = ModelWithPgSearch.create!(content: 'bar', title: 'foo')
+          included = ModelWithPgSearch.create!(content: "foo", title: "bar")
+          excluded = ModelWithPgSearch.create!(content: "bar", title: "foo")
 
-          results = ModelWithPgSearch.select('id').search_content('foo').select('title')
+          results = ModelWithPgSearch.select("id").search_content("foo").select("title")
 
           expect(results).to include(included)
           expect(results).not_to include(excluded)
 
-          expect(results.first.attributes.key?('content')).to eq false
+          expect(results.first.attributes.key?("content")).to be false
 
           expect(results.select { |record| record.title == "bar" }).to eq [included]
           expect(results.reject { |record| record.title == "bar" }).to be_empty
@@ -226,6 +240,7 @@ describe "an Active Record model which includes PgSearch" do
 
           model do
             include PgSearch::Model
+
             belongs_to :person
             pg_search_scope :search_city, against: [:city]
           end
@@ -238,10 +253,11 @@ describe "an Active Record model which includes PgSearch" do
 
           model do
             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))
@@ -285,7 +301,7 @@ describe "an Active Record model which includes PgSearch" do
 
         context "when chaining merged scopes" do
           it "does not raise an exception" do
-            relation = Person.named('foo').house_search_city('bar')
+            relation = Person.named("foo").house_search_city("bar")
 
             expect { relation.to_a }.not_to raise_error
           end
@@ -298,49 +314,49 @@ describe "an Active Record model which includes PgSearch" do
         end
 
         it "does not raise an exception" do
-          relation = ModelWithPgSearch.search_content('foo').search_title('bar')
+          relation = ModelWithPgSearch.search_content("foo").search_title("bar")
 
           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('')
+        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')
+        results = ModelWithPgSearch.search_content("foo")
         expect(results).to include(included)
         expect(results).not_to include(excluded)
       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')
+        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')
+        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")
+        ModelWithPgSearch.create!(content: "bar")
 
-        records_with_only_id = ModelWithPgSearch.search_content('foo').select('id')
+        records_with_only_id = ModelWithPgSearch.search_content("foo").select("id")
         expect(records_with_only_id.length).to eq 1
 
         returned_record = records_with_only_id.first
@@ -349,36 +365,36 @@ 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")
+        ModelWithPgSearch.create!(content: "bar")
 
-        ids = ModelWithPgSearch.search_content('foo').pluck('id')
+        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')
+        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")
+        records = ModelWithPgSearch.search_content("foo")
+          .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')
+        results = ModelWithPgSearch.search_content("foo bar")
         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
         included = [ModelWithPgSearch.create!(content: "foo"),
-                    ModelWithPgSearch.create!(content: "FOO")]
+          ModelWithPgSearch.create!(content: "FOO")]
 
         results = ModelWithPgSearch.search_content("Foo")
         expect(results).to match_array(included)
@@ -397,8 +413,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])
@@ -407,36 +423,36 @@ describe "an Active Record model which includes PgSearch" do
 
       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")]
+        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')
+      it "preserves column selection when with_pg_search_rank is chained after a select()" do
+        ModelWithPgSearch.create!(title: "foo", content: "bar")
 
-        results = ModelWithPgSearch.search_content('bar').select(:content).with_pg_search_rank
+        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')
+        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
+      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]
@@ -445,8 +461,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)
@@ -454,16 +470,16 @@ 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')
+        results = ModelWithPgSearch.search_content("foo bar")
         expect(results).to match_array(included)
         expect(results).not_to include(excluded)
       end
@@ -477,7 +493,7 @@ describe "an Active Record model which includes PgSearch" do
 
       it "accepts non-string queries and calls #to_s on them" do
         foo = ModelWithPgSearch.create!(content: "foo")
-        not_a_string = instance_double("Object", to_s: "foo")
+        not_a_string = instance_double(Object, to_s: "foo")
         expect(ModelWithPgSearch.search_content(not_a_string)).to eq([foo])
       end
 
@@ -493,7 +509,7 @@ describe "an Active Record model which includes PgSearch" do
             # 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
 
@@ -514,15 +530,15 @@ describe "an Active Record model which includes PgSearch" do
 
       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')
+        results = ModelWithPgSearch.search_title_and_content("foo bar")
 
         expect(results).to match_array(included)
         excluded.each do |result|
@@ -531,17 +547,17 @@ 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])
+        results = ModelWithPgSearch.search_title_and_content("foo")
+        expect(results).to contain_exactly(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')
+        included = ModelWithPgSearch.create!(title: "foo", content: nil)
+        results = ModelWithPgSearch.search_title_and_content("foo")
         expect(results).to eq([included])
       end
     end
@@ -552,21 +568,21 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       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')
+        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')
-        results = ModelWithPgSearch.with_trigrams('cdefhijkl')
+        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
@@ -591,16 +607,16 @@ describe "an Active Record model which includes PgSearch" 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
         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])
@@ -608,8 +624,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)
@@ -620,16 +636,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")]
+            ModelWithPgSearch.create!(content: "jumped"),
+            ModelWithPgSearch.create!(content: "jumping")]
 
           results = ModelWithPgSearch.search_content_with_english("jump")
           expect(results).to match_array(included)
@@ -639,14 +655,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! title: 'Just a title', 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
@@ -661,31 +677,31 @@ 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
+          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')
+            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
@@ -714,10 +730,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
@@ -731,8 +747,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
@@ -747,14 +763,14 @@ describe "an Active Record model which includes PgSearch" 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
+          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
           expect(results).to eq([winner, loser])
         end
@@ -763,14 +779,14 @@ describe "an Active Record model which includes PgSearch" 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
+          results = ModelWithPgSearch.search_weighted_by_hash("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
@@ -779,14 +795,14 @@ describe "an Active Record model which includes PgSearch" 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
+          results = ModelWithPgSearch.search_weighted("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
@@ -795,17 +811,17 @@ describe "an Active Record model which includes PgSearch" 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) }
+          %w[one two three four].map { |number| ModelWithPgSearch.create!(title: number) }
 
           results = ModelWithPgSearch.search_title_with_any_word("one two three four")
 
@@ -820,10 +836,10 @@ 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
@@ -847,10 +863,10 @@ 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
@@ -873,38 +889,37 @@ describe "an Active Record model which includes PgSearch" 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)
-        results = ModelWithPgSearch.with_dmetaphones('Jeff')
+        included = ModelWithPgSearch.create!(title: "Geoff", content: nil)
+        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')
-        results = ModelWithPgSearch.with_dmetaphones('Jeff Jorge')
+        included = ModelWithPgSearch.create!(title: "Geoff", content: "George")
+        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)
-        results = ModelWithPgSearch.with_dmetaphones('Wight')
+        included = ModelWithPgSearch.create!(title: "White", content: nil)
+        ModelWithPgSearch.create!(title: "Black", content: nil)
+        results = ModelWithPgSearch.with_dmetaphones("Wight")
         expect(results).to eq([included])
       end
 
       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)
+        ModelWithPgSearch.create!(title: "Black", content: nil)
 
-        results = ModelWithPgSearch.with_dmetaphones('Wight W')
+        # "W" does not have a dmetaphone equivalent
+        results = ModelWithPgSearch.with_dmetaphones("Wight W")
         expect(results).to eq([included])
       end
     end
@@ -912,35 +927,35 @@ describe "an Active Record model which includes PgSearch" 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
@@ -982,24 +997,24 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       context "with feature-specific configuration" do
-        let(:tsearch_config) { { dictionary: 'english' } }
-        let(: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 "passes the custom configuration down to the specified feature" do
           tsearch_feature = instance_double(
-            "PgSearch::Features::TSearch",
+            PgSearch::Features::TSearch,
             conditions: Arel::Nodes::Grouping.new(Arel.sql("1 = 1")),
             rank: Arel::Nodes::Grouping.new(Arel.sql("1.0"))
           )
 
           trigram_feature = instance_double(
-            "PgSearch::Features::Trigram",
+            PgSearch::Features::Trigram,
             conditions: Arel::Nodes::Grouping.new(Arel.sql("1 = 1")),
             rank: Arel::Nodes::Grouping.new(Arel.sql("1.0"))
           )
@@ -1029,18 +1044,19 @@ describe "an Active Record model which includes PgSearch" do
 
       with_model :Post do
         table do |t|
-          t.text 'content'
-          t.tsvector 'content_tsvector'
+          t.text "content"
+          t.tsvector "content_tsvector"
         end
 
         model do
           include PgSearch::Model
+
           has_many :comments
         end
       end
 
-      let!(:expected) { Post.create!(content: 'phooey') }
-      let!(:unexpected) { Post.create!(content: 'longcat is looooooooong') }
+      let!(:expected) { Post.create!(content: "phooey") }
+      let!(:unexpected) { Post.create!(content: "longcat is looooooooong") }
 
       before do
         ActiveRecord::Base.connection.execute <<~SQL.squish
@@ -1048,17 +1064,17 @@ describe "an Active Record model which includes PgSearch" do
           SET content_tsvector = to_tsvector('english'::regconfig, #{Post.quoted_table_name}."content")
         SQL
 
-        expected.comments.create(body: 'commentone')
-        unexpected.comments.create(body: 'commentwo')
+        expected.comments.create!(body: "commentone")
+        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 "finds by the tsvector column" do
@@ -1069,29 +1085,53 @@ describe "an Active Record model which includes PgSearch" do
         expect(Post.search_by_content_with_tsvector("commentone").map(&:id)).to eq([expected.id])
       end
 
-      it 'finds 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
+
+      it "finds by the tsvector column when ordering by an associated table" do
+        # Reference the physical table name that Active Record would normally
+        # leave unaliased. The old string rank join made AliasTracker think the
+        # name was already used and alias this outer join, breaking the order.
+        # https://github.com/Casecommons/pg_search/issues/206
+        results = Post
+          .joins(:comments)
+          .search_by_content_with_tsvector("phooey")
+          .order(Comment.table_name => {id: :asc})
+
+        expect(results).to eq([expected])
+      end
+
+      it "finds by the tsvector column when ordering by an association alias" do
+        results = Post
+          .joins(:comments)
+          .search_by_content_with_tsvector("phooey")
+          .order(comments: {id: :asc})
+
+        expect(results).to eq([expected])
+      end
     end
 
-    context 'when using multiple tsvector columns' do
+    context "when using multiple tsvector columns" do
       with_model :ModelWithTsvector do
+        table
+
         model do
           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
 
-      it 'concats tsvector columns' do
-        expected = "#{ModelWithTsvector.quoted_table_name}.\"content_tsvector\" || "\
+      it "concats tsvector columns" do
+        expected = "#{ModelWithTsvector.quoted_table_name}.\"content_tsvector\" || " \
                    "#{ModelWithTsvector.quoted_table_name}.\"message_tsvector\""
 
         expect(ModelWithTsvector.search_by_multiple_tsvector_columns("something").to_sql).to include(expected)
@@ -1101,17 +1141,17 @@ describe "an Active Record model which includes PgSearch" do
     context "when using a tsvector column with" do
       with_model :ModelWithTsvector do
         table do |t|
-          t.text 'content'
-          t.tsvector 'content_tsvector'
+          t.text "content"
+          t.tsvector "content_tsvector"
         end
 
         model { include PgSearch::Model }
       end
 
-      let!(:expected) { ModelWithTsvector.create!(content: 'tiling is grouty') }
+      let!(:expected) { ModelWithTsvector.create!(content: "tiling is grouty") }
 
       before do
-        ModelWithTsvector.create!(content: 'longcat is looooooooong')
+        ModelWithTsvector.create!(content: "longcat is looooooooong")
 
         ActiveRecord::Base.connection.execute <<~SQL.squish
           UPDATE #{ModelWithTsvector.quoted_table_name}
@@ -1119,13 +1159,13 @@ describe "an Active Record model which includes PgSearch" do
         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 "does not use to_tsvector in the query" do
@@ -1159,8 +1199,8 @@ describe "an Active Record model which includes PgSearch" 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
@@ -1174,11 +1214,16 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       context "when the query includes accents" do
-        it "does not create an erroneous tsquery expression" do
-          included = ModelWithPgSearch.create!(title: "Weird L‘Content")
+        let(:term) { "L#{%w[‘ ’ ʻ ʼ ʹ ʽ ˈ ＇ ʼn].sample}Content" }
+        let(:included) { ModelWithPgSearch.create!(title: "Weird #{term}") }
+        let(:results) { ModelWithPgSearch.search_title_without_accents(term) }
 
-          results = ModelWithPgSearch.search_title_without_accents("L‘Content")
-          expect(results).to eq([included])
+        before do
+          ModelWithPgSearch.create!(title: "FooBar")
+        end
+
+        it "does not create an erroneous tsquery expression" do
+          expect(results).to contain_exactly(included)
         end
       end
     end
@@ -1186,25 +1231,25 @@ describe "an Active Record model which includes PgSearch" do
     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 "returns records with a rank attribute equal to the :ranked_by expression" do
-        ModelWithPgSearch.create!(content: 'foo', importance: 10)
+        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 "substitutes :tsearch with the tsearch rank expression in the :ranked_by expression" do
-        ModelWithPgSearch.create!(content: 'foo', importance: 10)
+        ModelWithPgSearch.create!(content: "foo", importance: 10)
 
         tsearch_result =
           ModelWithPgSearch.search_content_with_default_rank("foo").with_pg_search_rank.first
@@ -1213,8 +1258,8 @@ 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
 
@@ -1223,9 +1268,9 @@ describe "an Active Record model which includes PgSearch" 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")
@@ -1238,32 +1283,32 @@ describe "an Active Record model which includes PgSearch" do
 
           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
             specify "its results respond to #pg_search_rank" do
-              result = ModelWithPgSearch.send(scope_name, 'foo').with_pg_search_rank.first
+              result = ModelWithPgSearch.send(scope_name, "foo").with_pg_search_rank.first
               expect(result).to respond_to(:pg_search_rank)
             end
 
             it "returns the rank when #pg_search_rank is called on a result" do
-              results = ModelWithPgSearch.send(scope_name, 'foo').with_pg_search_rank
+              results = ModelWithPgSearch.send(scope_name, "foo").with_pg_search_rank
               expect(results.first.pg_search_rank).to be_a Float
             end
           end
 
           context "when .with_pg_search_rank is not chained after" do
             specify "its results do not respond to #pg_search_rank" do
-              result = ModelWithPgSearch.send(scope_name, 'foo').first
+              result = ModelWithPgSearch.send(scope_name, "foo").first
               expect(result).not_to respond_to(:pg_search_rank)
             end
 
             it "raises PgSearch::PgSearchRankNotSelected when #pg_search_rank is called on a result" do
-              result = ModelWithPgSearch.send(scope_name, 'foo').first
+              result = ModelWithPgSearch.send(scope_name, "foo").first
               expect {
                 result.pg_search_rank
               }.to raise_exception(PgSearch::PgSearchRankNotSelected)
@@ -1275,14 +1320,14 @@ describe "an Active Record model which includes PgSearch" 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')
+          results = ModelWithPgSearch.search_content_ranked_by_tsearch("foo")
           expect(results.find_index(twice)).to be < results.find_index(once)
         end
       end
@@ -1290,14 +1335,14 @@ describe "an Active Record model which includes PgSearch" 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')
+          results = ModelWithPgSearch.search_content_ranked_by_trigram("abc")
           expect(results.find_index(exact)).to be < results.find_index(close)
         end
       end
@@ -1305,14 +1350,14 @@ describe "an Active Record model which includes PgSearch" 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')
+          results = ModelWithPgSearch.search_content_ranked_by_dmetaphone("foo")
           expect(results.find_index(twice)).to be < results.find_index(once)
         end
       end
@@ -1321,17 +1366,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)"
+          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")
+        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]
@@ -1339,4 +1384,4 @@ describe "an Active Record model which includes PgSearch" do
     end
   end
 end
-# rubocop:enable RSpec/NestedGroups
+# standard:enable RSpec/NestedGroups