pg_search 2.3.2 → 2.3.7

data/spec/integration/single_table_inheritance_spec.rb

@@ -6,8 +6,8 @@ describe "a pg_search_scope on an STI subclass" do
   context "with the standard type column" do
     with_model :SuperclassModel do
       table do |t|
-        t.text 'content'
-        t.string 'type'
+        t.text "content"
+        t.string "type"
       end
 
       model do
@@ -46,13 +46,13 @@ describe "a pg_search_scope on an STI subclass" do
   context "with a custom type column" do
     with_model :SuperclassModel do
       table do |t|
-        t.text 'content'
-        t.string 'custom_type'
+        t.text "content"
+        t.string "custom_type"
       end
 
       model do
         include PgSearch::Model
-        self.inheritance_column = 'custom_type'
+        self.inheritance_column = "custom_type"
         pg_search_scope :search_content, against: :content
       end
     end

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

@@ -2,6 +2,7 @@
 
 require "spec_helper"
 
+# standard:disable RSpec/NestedGroups
 describe PgSearch::Configuration::Association do
   with_model :Avatar do
     table do |t|
@@ -21,8 +22,8 @@ describe PgSearch::Configuration::Association do
       has_one :avatar, class_name: "Avatar"
       belongs_to :site
 
-      pg_search_scope :with_avatar, associated_against: { avatar: :url }
-      pg_search_scope :with_site, associated_against: { site: :title }
+      pg_search_scope :with_avatar, associated_against: {avatar: :url}
+      pg_search_scope :with_site, associated_against: {site: :title}
     end
   end
 
@@ -35,11 +36,11 @@ describe PgSearch::Configuration::Association do
       include PgSearch::Model
       has_many :users, class_name: "User"
 
-      pg_search_scope :with_users, associated_against: { users: :name }
+      pg_search_scope :with_users, associated_against: {users: :name}
     end
   end
 
-  context "has_one" do
+  context "with has_one" do
     let(:association) { described_class.new(User, :avatar, :url) }
 
     describe "#table_name" do
@@ -50,13 +51,13 @@ describe PgSearch::Configuration::Association do
 
     describe "#join" do
       let(:expected_sql) do
-        <<-SQL.gsub(/\s+/, ' ').strip
+        <<~SQL.squish
           LEFT OUTER JOIN
             (SELECT model_id AS id,
                     #{column_select} AS #{association.columns.first.alias}
-            FROM \"#{User.table_name}\"
-            INNER JOIN \"#{association.table_name}\"
-            ON \"#{association.table_name}\".\"user_id\" = \"#{User.table_name}\".\"id\") #{association.subselect_alias}
+            FROM "#{User.table_name}"
+            INNER JOIN "#{association.table_name}"
+            ON "#{association.table_name}"."user_id" = "#{User.table_name}"."id") #{association.subselect_alias}
           ON #{association.subselect_alias}.id = model_id
         SQL
       end
@@ -70,7 +71,7 @@ describe PgSearch::Configuration::Association do
     end
   end
 
-  context "belongs_to" do
+  context "with belongs_to" do
     let(:association) { described_class.new(User, :site, :title) }
 
     describe "#table_name" do
@@ -81,13 +82,13 @@ describe PgSearch::Configuration::Association do
 
     describe "#join" do
       let(:expected_sql) do
-        <<-SQL.gsub(/\s+/, ' ').strip
+        <<~SQL.squish
           LEFT OUTER JOIN
             (SELECT model_id AS id,
                     #{column_select} AS #{association.columns.first.alias}
-            FROM \"#{User.table_name}\"
-            INNER JOIN \"#{association.table_name}\"
-            ON \"#{association.table_name}\".\"id\" = \"#{User.table_name}\".\"site_id\") #{association.subselect_alias}
+            FROM "#{User.table_name}"
+            INNER JOIN "#{association.table_name}"
+            ON "#{association.table_name}"."id" = "#{User.table_name}"."site_id") #{association.subselect_alias}
           ON #{association.subselect_alias}.id = model_id
         SQL
       end
@@ -101,7 +102,7 @@ describe PgSearch::Configuration::Association do
     end
   end
 
-  context "has_many" do
+  context "with has_many" do
     let(:association) { described_class.new(Site, :users, :name) }
 
     describe "#table_name" do
@@ -112,13 +113,13 @@ describe PgSearch::Configuration::Association do
 
     describe "#join" do
       let(:expected_sql) do
-        <<-SQL.gsub(/\s+/, ' ').strip
+        <<~SQL.squish
           LEFT OUTER JOIN
             (SELECT model_id AS id,
-                    string_agg(\"#{association.table_name}\".\"name\"::text, ' ') AS #{association.columns.first.alias}
-            FROM \"#{Site.table_name}\"
-            INNER JOIN \"#{association.table_name}\"
-            ON \"#{association.table_name}\".\"site_id\" = \"#{Site.table_name}\".\"id\"
+                    string_agg("#{association.table_name}"."name"::text, ' ') AS #{association.columns.first.alias}
+            FROM "#{Site.table_name}"
+            INNER JOIN "#{association.table_name}"
+            ON "#{association.table_name}"."site_id" = "#{Site.table_name}"."id"
             GROUP BY model_id) #{association.subselect_alias}
           ON #{association.subselect_alias}.id = model_id
         SQL
@@ -138,3 +139,4 @@ describe PgSearch::Configuration::Association do
     end
   end
 end
+# standard:enable RSpec/NestedGroups

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

@@ -7,6 +7,7 @@ describe PgSearch::Configuration::Column do
     with_model :Model do
       table do |t|
         t.string :name
+        t.json :object
       end
     end
 
@@ -14,18 +15,29 @@ describe PgSearch::Configuration::Column do
       column = described_class.new("name", nil, Model)
       expect(column.full_name).to eq(%(#{Model.quoted_table_name}."name"))
     end
+
+    it "returns nested json attributes" do
+      column = described_class.new(Arel.sql("object->>'name'"), nil, Model)
+      expect(column.full_name).to eq(%(object->>'name'))
+    end
   end
 
   describe "#to_sql" do
     with_model :Model do
       table do |t|
         t.string :name
+        t.json :object
       end
     end
 
     it "returns an expression that casts the column to text and coalesces it with an empty string" do
       column = described_class.new("name", nil, Model)
-      expect(column.to_sql).to eq(%{coalesce(#{Model.quoted_table_name}."name"::text, '')})
+      expect(column.to_sql).to eq(%{coalesce((#{Model.quoted_table_name}."name")::text, '')})
+    end
+
+    it "returns an expression that casts the nested json attribute to text and coalesces it with an empty string" do
+      column = described_class.new(Arel.sql("object->>'name'"), nil, Model)
+      expect(column.to_sql).to eq(%{coalesce((object->>'name')::text, '')})
     end
   end
 end

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

@@ -18,16 +18,16 @@ describe PgSearch::Configuration::ForeignColumn do
 
       model do
         include PgSearch::Model
-        belongs_to :another_model, class_name: 'AssociatedModel'
+        belongs_to :another_model, class_name: "AssociatedModel"
 
-        pg_search_scope :with_another, associated_against: { another_model: :title }
+        pg_search_scope :with_another, associated_against: {another_model: :title}
       end
     end
 
     it "returns a consistent string" do
       association = PgSearch::Configuration::Association.new(Model,
-                                                             :another_model,
-                                                             :title)
+        :another_model,
+        :title)
       foreign_column = described_class.new("title", nil, Model, association)
 
       column_alias = foreign_column.alias

data/spec/lib/pg_search/features/dmetaphone_spec.rb

@@ -18,12 +18,12 @@ describe PgSearch::Features::DMetaphone do
         PgSearch::Configuration::Column.new(:content, nil, Model)
       ]
       options = {}
-      config = double(:config, ignore: [])
+      config = instance_double(PgSearch::Configuration, :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.rank.to_sql).to eq(
-        %{(ts_rank((to_tsvector('simple', pg_search_dmetaphone(coalesce(#{Model.quoted_table_name}."name"::text, ''))) || to_tsvector('simple', pg_search_dmetaphone(coalesce(#{Model.quoted_table_name}."content"::text, '')))), (to_tsquery('simple', ''' ' || pg_search_dmetaphone('query') || ' ''')), 0))}
+        %{(ts_rank((to_tsvector('simple', pg_search_dmetaphone(coalesce((#{Model.quoted_table_name}."name")::text, ''))) || to_tsvector('simple', pg_search_dmetaphone(coalesce((#{Model.quoted_table_name}."content")::text, '')))), (to_tsquery('simple', ''' ' || pg_search_dmetaphone('query') || ' ''')), 0))}
       )
     end
   end
@@ -43,12 +43,12 @@ describe PgSearch::Features::DMetaphone do
         PgSearch::Configuration::Column.new(:content, nil, Model)
       ]
       options = {}
-      config = double(:config, ignore: [])
+      config = instance_double(PgSearch::Configuration, :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.conditions.to_sql).to eq(
-        %{((to_tsvector('simple', pg_search_dmetaphone(coalesce(#{Model.quoted_table_name}."name"::text, ''))) || to_tsvector('simple', pg_search_dmetaphone(coalesce(#{Model.quoted_table_name}."content"::text, '')))) @@ (to_tsquery('simple', ''' ' || pg_search_dmetaphone('query') || ' ''')))}
+        %{((to_tsvector('simple', pg_search_dmetaphone(coalesce((#{Model.quoted_table_name}."name")::text, ''))) || to_tsvector('simple', pg_search_dmetaphone(coalesce((#{Model.quoted_table_name}."content")::text, '')))) @@ (to_tsquery('simple', ''' ' || pg_search_dmetaphone('query') || ' ''')))}
       )
     end
   end

data/spec/lib/pg_search/features/trigram_spec.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'ostruct'
+require "spec_helper"
+require "ostruct"
 
+# standard:disable RSpec/MultipleMemoizedHelpers, RSpec/NestedGroups
 describe PgSearch::Features::Trigram do
   subject(:feature) { described_class.new(query, options, columns, Model, normalizer) }
-  let(:query) { 'lolwut' }
+
+  let(:query) { "lolwut" }
   let(:options) { {} }
   let(:columns) {
     [
@@ -17,8 +19,10 @@ describe PgSearch::Features::Trigram do
   let(:config) { OpenStruct.new(ignore: []) }
 
   let(:coalesced_columns) do
-    <<-SQL.strip_heredoc.chomp
-      coalesce(#{Model.quoted_table_name}."name"::text, '') || ' ' || coalesce(#{Model.quoted_table_name}."content"::text, '')
+    <<~SQL.squish
+      coalesce((#{Model.quoted_table_name}."name")::text, '')
+        || ' '
+        || coalesce((#{Model.quoted_table_name}."content")::text, '')
     SQL
   end
 
@@ -29,15 +33,15 @@ describe PgSearch::Features::Trigram do
     end
   end
 
-  describe 'conditions' do
-    it 'escapes the search document and query' do
+  describe "conditions" do
+    it "escapes the search document and query" do
       config.ignore = []
       expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_columns}))")
     end
 
-    context 'searching by word_similarity' do
+    context "when searching by word_similarity" do
       let(:options) do
-        { word_similarity: true }
+        {word_similarity: true}
       end
 
       it 'uses the "<%" operator when searching by word_similarity' do
@@ -46,17 +50,17 @@ describe PgSearch::Features::Trigram do
       end
     end
 
-    context 'ignoring accents' do
-      it 'escapes the search document and query, but not the accent function' do
+    context "when ignoring accents" do
+      it "escapes the search document and query, but not the accent function" do
         config.ignore = [:accents]
         expect(feature.conditions.to_sql).to eq("(unaccent('#{query}') % (unaccent(#{coalesced_columns})))")
       end
     end
 
-    context 'when a threshold is specified' do
-      context 'searching by similarity' do
+    context "when a threshold is specified" do
+      context "when searching by similarity" do
         let(:options) do
-          { threshold: 0.5 }
+          {threshold: 0.5}
         end
 
         it 'uses a minimum similarity expression instead of the "%" operator' do
@@ -66,9 +70,9 @@ describe PgSearch::Features::Trigram do
         end
       end
 
-      context 'searching by word_similarity' do
+      context "when searching by word_similarity" do
         let(:options) do
-          { threshold: 0.5, word_similarity: true }
+          {threshold: 0.5, word_similarity: true}
         end
 
         it 'uses a minimum similarity expression instead of the "<%" operator' do
@@ -79,30 +83,30 @@ describe PgSearch::Features::Trigram do
       end
     end
 
-    context 'only certain columns are selected' do
-      context 'one column' do
-        let(:options) { { only: :name } }
+    context "when only certain columns are selected" do
+      context "with one column" do
+        let(:options) { {only: :name} }
 
-        it 'only searches against the select column' do
-          options = { only: :name }
-          coalesced_column = "coalesce(#{Model.quoted_table_name}.\"name\"::text, '')"
+        it "only searches against the select column" do
+          coalesced_column = "coalesce((#{Model.quoted_table_name}.\"name\")::text, '')"
           expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_column}))")
         end
       end
-      context 'multiple columns' do
-        let(:options) { { only: %i[name content] } }
 
-        it 'concatenates when multiples columns are selected' do
-          options = { only: %i[name content] }
+      context "with multiple columns" do
+        let(:options) { {only: %i[name content]} }
+
+        it "concatenates when multiples columns are selected" do
           expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_columns}))")
         end
       end
     end
   end
 
-  describe '#rank' do
-    it 'returns an expression using the similarity() function' do
+  describe "#rank" do
+    it "returns an expression using the similarity() function" do
       expect(feature.rank.to_sql).to eq("(similarity('#{query}', (#{coalesced_columns})))")
     end
   end
 end
+# standard:enable RSpec/MultipleMemoizedHelpers, RSpec/NestedGroups

data/spec/lib/pg_search/features/tsearch_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require "active_support/deprecation"
+require "active_support/core_ext/kernel/reporting"
 
 describe PgSearch::Features::TSearch do
   describe "#rank" do
@@ -19,14 +19,32 @@ describe PgSearch::Features::TSearch do
         PgSearch::Configuration::Column.new(:content, nil, Model)
       ]
       options = {}
-      config = double(:config, ignore: [])
+      config = instance_double(PgSearch::Configuration, :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.rank.to_sql).to eq(
-        %{(ts_rank((to_tsvector('simple', coalesce(#{Model.quoted_table_name}."name"::text, '')) || to_tsvector('simple', coalesce(#{Model.quoted_table_name}."content"::text, ''))), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 0))}
+        %{(ts_rank((to_tsvector('simple', coalesce((#{Model.quoted_table_name}."name")::text, '')) || to_tsvector('simple', coalesce((#{Model.quoted_table_name}."content")::text, ''))), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 0))}
       )
     end
+
+    context "with a tsvector column and a custom normalization" do
+      it "works?" do
+        query = "query"
+        columns = [
+          PgSearch::Configuration::Column.new(:name, nil, Model),
+          PgSearch::Configuration::Column.new(:content, nil, Model)
+        ]
+        options = {tsvector_column: :my_tsvector, normalization: 2}
+        config = instance_double(PgSearch::Configuration, :config, ignore: [])
+        normalizer = PgSearch::Normalizer.new(config)
+
+        feature = described_class.new(query, options, columns, Model, normalizer)
+        expect(feature.rank.to_sql).to eq(
+          %{(ts_rank((#{Model.quoted_table_name}."my_tsvector"), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 2))}
+        )
+      end
+    end
   end
 
   describe "#conditions" do
@@ -44,12 +62,12 @@ describe PgSearch::Features::TSearch do
         PgSearch::Configuration::Column.new(:content, nil, Model)
       ]
       options = {}
-      config = double(:config, ignore: [])
+      config = instance_double(PgSearch::Configuration, :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.conditions.to_sql).to eq(
-        %{((to_tsvector('simple', coalesce(#{Model.quoted_table_name}."name"::text, '')) || to_tsvector('simple', coalesce(#{Model.quoted_table_name}."content"::text, ''))) @@ (to_tsquery('simple', ''' ' || 'query' || ' ''')))}
+        %{((to_tsvector('simple', coalesce((#{Model.quoted_table_name}."name")::text, '')) || to_tsvector('simple', coalesce((#{Model.quoted_table_name}."content")::text, ''))) @@ (to_tsquery('simple', ''' ' || 'query' || ' ''')))}
       )
     end
 
@@ -60,13 +78,13 @@ describe PgSearch::Features::TSearch do
           PgSearch::Configuration::Column.new(:name, nil, Model),
           PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
-        options = { negation: true }
-        config = double(:config, ignore: [])
+        options = {negation: true}
+        config = instance_double(PgSearch::Configuration, :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
         expect(feature.conditions.to_sql).to eq(
-          %{((to_tsvector('simple', coalesce(#{Model.quoted_table_name}."name"::text, '')) || to_tsvector('simple', coalesce(#{Model.quoted_table_name}."content"::text, ''))) @@ (to_tsquery('simple', '!' || ''' ' || 'query' || ' ''')))}
+          %{((to_tsvector('simple', coalesce((#{Model.quoted_table_name}."name")::text, '')) || to_tsvector('simple', coalesce((#{Model.quoted_table_name}."content")::text, ''))) @@ (to_tsquery('simple', '!' || ''' ' || 'query' || ' ''')))}
         )
       end
     end
@@ -78,49 +96,49 @@ describe PgSearch::Features::TSearch do
           PgSearch::Configuration::Column.new(:name, nil, Model),
           PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
-        options = { negation: false }
-        config = double(:config, ignore: [])
+        options = {negation: false}
+        config = instance_double(PgSearch::Configuration, :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
         expect(feature.conditions.to_sql).to eq(
-          %{((to_tsvector('simple', coalesce(#{Model.quoted_table_name}."name"::text, '')) || to_tsvector('simple', coalesce(#{Model.quoted_table_name}."content"::text, ''))) @@ (to_tsquery('simple', ''' ' || '!query' || ' ''')))}
+          %{((to_tsvector('simple', coalesce((#{Model.quoted_table_name}."name")::text, '')) || to_tsvector('simple', coalesce((#{Model.quoted_table_name}."content")::text, ''))) @@ (to_tsquery('simple', ''' ' || '!query' || ' ''')))}
         )
       end
     end
 
     context "when options[:tsvector_column] is a string" do
-      it 'uses the tsvector column' do
+      it "uses the tsvector column" do
         query = "query"
         columns = [
           PgSearch::Configuration::Column.new(:name, nil, Model),
           PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
-        options = { tsvector_column: "my_tsvector" }
-        config = double(:config, ignore: [])
+        options = {tsvector_column: "my_tsvector"}
+        config = instance_double(PgSearch::Configuration, :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
         expect(feature.conditions.to_sql).to eq(
-          %{((#{Model.quoted_table_name}.\"my_tsvector\") @@ (to_tsquery('simple', ''' ' || 'query' || ' ''')))}
+          %{((#{Model.quoted_table_name}."my_tsvector") @@ (to_tsquery('simple', ''' ' || 'query' || ' ''')))}
         )
       end
     end
 
     context "when options[:tsvector_column] is an array of strings" do
-      it 'uses the tsvector column' do
+      it "uses the tsvector column" do
         query = "query"
         columns = [
           PgSearch::Configuration::Column.new(:name, nil, Model),
           PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
-        options = { tsvector_column: ["tsvector1", "tsvector2"] }
-        config = double(:config, ignore: [])
+        options = {tsvector_column: ["tsvector1", "tsvector2"]}
+        config = instance_double(PgSearch::Configuration, :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
         expect(feature.conditions.to_sql).to eq(
-          %{((#{Model.quoted_table_name}.\"tsvector1\" || #{Model.quoted_table_name}.\"tsvector2\") @@ (to_tsquery('simple', ''' ' || 'query' || ' ''')))}
+          %{((#{Model.quoted_table_name}."tsvector1" || #{Model.quoted_table_name}."tsvector2") @@ (to_tsquery('simple', ''' ' || 'query' || ' ''')))}
         )
       end
     end
@@ -141,17 +159,18 @@ describe PgSearch::Features::TSearch do
       ]
       options = {}
 
-      config = double(:config, ignore: [])
+      config = instance_double(PgSearch::Configuration, :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.highlight.to_sql).to eq(
-        "(ts_headline('simple', (coalesce(#{Model.quoted_table_name}.\"name\"::text, '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), ''))"
+        "(ts_headline('simple', (coalesce((#{Model.quoted_table_name}.\"name\")::text, '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), ''))"
       )
     end
 
     context "when options[:dictionary] is passed" do
-      it 'uses the provided dictionary' do
+      # standard:disable RSpec/ExampleLength
+      it "uses the provided dictionary" do
         query = "query"
         columns = [
           PgSearch::Configuration::Column.new(:name, nil, Model),
@@ -165,18 +184,20 @@ describe PgSearch::Features::TSearch do
           }
         }
 
-        config = double(:config, ignore: [])
+        config = instance_double(PgSearch::Configuration, :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
 
-        expected_sql = %{(ts_headline('spanish', (coalesce(#{Model.quoted_table_name}."name"::text, '') || ' ' || coalesce(#{Model.quoted_table_name}."content"::text, '')), (to_tsquery('spanish', ''' ' || 'query' || ' ''')), 'StartSel = "<b>", StopSel = "</b>"'))}
+        expected_sql = %{(ts_headline('spanish', (coalesce((#{Model.quoted_table_name}."name")::text, '') || ' ' || coalesce((#{Model.quoted_table_name}."content")::text, '')), (to_tsquery('spanish', ''' ' || 'query' || ' ''')), 'StartSel = "<b>", StopSel = "</b>"'))}
 
         expect(feature.highlight.to_sql).to eq(expected_sql)
       end
+      # standard:enable RSpec/ExampleLength
     end
 
     context "when options[:highlight] has options set" do
+      # standard:disable RSpec/ExampleLength
       it "passes the options to ts_headline" do
         query = "query"
         columns = [
@@ -185,26 +206,28 @@ describe PgSearch::Features::TSearch do
         options = {
           highlight: {
             StartSel: '<start class="search">',
-            StopSel: '<stop>',
+            StopSel: "<stop>",
             MaxWords: 123,
             MinWords: 456,
             ShortWord: 4,
             HighlightAll: true,
             MaxFragments: 3,
-            FragmentDelimiter: '&hellip;'
+            FragmentDelimiter: "&hellip;"
           }
         }
 
-        config = double(:config, ignore: [])
+        config = instance_double(PgSearch::Configuration, :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
 
-        expected_sql = %{(ts_headline('simple', (coalesce(#{Model.quoted_table_name}."name"::text, '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 'StartSel = "<start class=""search"">", StopSel = "<stop>", MaxFragments = 3, MaxWords = 123, MinWords = 456, ShortWord = 4, FragmentDelimiter = "&hellip;", HighlightAll = TRUE'))}
+        expected_sql = %{(ts_headline('simple', (coalesce((#{Model.quoted_table_name}."name")::text, '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 'StartSel = "<start class=""search"">", StopSel = "<stop>", MaxFragments = 3, MaxWords = 123, MinWords = 456, ShortWord = 4, FragmentDelimiter = "&hellip;", HighlightAll = TRUE'))}
 
         expect(feature.highlight.to_sql).to eq(expected_sql)
       end
+      # standard:enable RSpec/ExampleLength
 
+      # standard:disable RSpec/ExampleLength
       it "passes deprecated options to ts_headline" do
         query = "query"
         columns = [
@@ -213,26 +236,27 @@ describe PgSearch::Features::TSearch do
         options = {
           highlight: {
             start_sel: '<start class="search">',
-            stop_sel: '<stop>',
+            stop_sel: "<stop>",
             max_words: 123,
             min_words: 456,
             short_word: 4,
             highlight_all: false,
             max_fragments: 3,
-            fragment_delimiter: '&hellip;'
+            fragment_delimiter: "&hellip;"
           }
         }
 
-        config = double(:config, ignore: [])
+        config = instance_double(PgSearch::Configuration, :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
 
-        highlight_sql = ActiveSupport::Deprecation.silence { feature.highlight.to_sql }
-        expected_sql = %{(ts_headline('simple', (coalesce(#{Model.quoted_table_name}."name"::text, '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 'StartSel = "<start class=""search"">", StopSel = "<stop>", MaxFragments = 3, MaxWords = 123, MinWords = 456, ShortWord = 4, FragmentDelimiter = "&hellip;", HighlightAll = FALSE'))}
+        highlight_sql = silence_warnings { feature.highlight.to_sql }
+        expected_sql = %{(ts_headline('simple', (coalesce((#{Model.quoted_table_name}."name")::text, '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 'StartSel = "<start class=""search"">", StopSel = "<stop>", MaxFragments = 3, MaxWords = 123, MinWords = 456, ShortWord = 4, FragmentDelimiter = "&hellip;", HighlightAll = FALSE'))}
 
         expect(highlight_sql).to eq(expected_sql)
       end
+      # standard:enable RSpec/ExampleLength
     end
   end
 end