pg_search 2.1.7 → 2.3.3

data/lib/pg_search/tasks.rb

@@ -7,11 +7,12 @@ namespace :pg_search do
   namespace :multisearch do
     desc "Rebuild PgSearch multisearch records for a given model"
     task :rebuild, %i[model schema] => :environment do |_task, args|
-      raise ArgumentError, <<-MESSAGE.strip_heredoc unless args.model
+      raise ArgumentError, <<~MESSAGE unless args.model
 
         You must pass a model as an argument.
         Example: rake pg_search:multisearch:rebuild[BlogPost]
       MESSAGE
+
       model_class = args.model.classify.constantize
       connection = PgSearch::Document.connection
       original_schema_search_path = connection.schema_search_path

data/lib/pg_search/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgSearch
-  VERSION = '2.1.7'
+  VERSION = '2.3.3'
 end

data/pg_search.gemspec

@@ -3,7 +3,7 @@
 $LOAD_PATH.push File.expand_path('lib', __dir__)
 require 'pg_search/version'
 
-Gem::Specification.new do |s|
+Gem::Specification.new do |s| # rubocop:disable Metrics/BlockLength
   s.name        = 'pg_search'
   s.version     = PgSearch::VERSION
   s.platform    = Gem::Platform::RUBY
@@ -18,16 +18,21 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.require_paths = ['lib']
 
-  s.add_dependency 'activerecord', '>= 4.2'
-  s.add_dependency 'activesupport', '>= 4.2'
+  s.add_dependency 'activerecord', '>= 5.2'
+  s.add_dependency 'activesupport', '>= 5.2'
 
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '>= 3.3'
-  s.add_development_dependency 'rubocop', '>= 0.67.2'
+  s.add_development_dependency 'rubocop', '>= 0.90.0'
   s.add_development_dependency 'rubocop-performance'
+  s.add_development_dependency 'rubocop-rails'
+  s.add_development_dependency 'rubocop-rake'
+  s.add_development_dependency 'rubocop-rspec'
+  s.add_development_dependency 'rubocop-thread_safety', '>= 0.4.1'
   s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'warning'
   s.add_development_dependency 'with_model', '>= 1.2'
 
-  s.required_ruby_version = '>= 2.4'
+  s.required_ruby_version = '>= 2.5'
 end

data/spec/.rubocop.yml

@@ -1,10 +1,10 @@
 inherit_from:
   - ../.rubocop.yml
 
-Metrics/LineLength:
+Layout/LineLength:
   Enabled: false
 
-Lint/HandleExceptions:
+Lint/SuppressedException:
   Enabled: false
 
 Lint/UselessAssignment:

data/spec/integration/.rubocop.yml

@@ -0,0 +1,11 @@
+inherit_from:
+  - ../.rubocop.yml
+
+RSpec/DescribeClass:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false

data/spec/integration/associations_spec.rb

@@ -2,8 +2,9 @@
 
 require "spec_helper"
 
-describe PgSearch do
-  context "joining to another table" do
+# rubocop:disable RSpec/NestedGroups
+describe "a pg_search_scope" do
+  context "when joining to another table" do
     context "without an :against" do
       with_model :AssociatedModel do
         table do |t|
@@ -18,7 +19,7 @@ describe PgSearch do
         end
 
         model do
-          include PgSearch
+          include PgSearch::Model
           belongs_to :another_model, class_name: 'AssociatedModel'
 
           pg_search_scope :with_another, associated_against: { another_model: :title }
@@ -41,7 +42,7 @@ describe PgSearch do
       end
     end
 
-    context "through a belongs_to association" do
+    context "via a belongs_to association" do
       with_model :AssociatedModel do
         table do |t|
           t.string 'title'
@@ -55,7 +56,7 @@ describe PgSearch do
         end
 
         model do
-          include PgSearch
+          include PgSearch::Model
           belongs_to :another_model, class_name: 'AssociatedModel'
 
           pg_search_scope :with_associated, against: :title, associated_against: { another_model: :title }
@@ -77,7 +78,7 @@ describe PgSearch do
       end
     end
 
-    context "through a has_many association" do
+    context "via a has_many association" do
       with_model :AssociatedModelWithHasMany do
         table do |t|
           t.string 'title'
@@ -91,7 +92,7 @@ describe PgSearch do
         end
 
         model do
-          include PgSearch
+          include PgSearch::Model
           has_many :other_models, class_name: 'AssociatedModelWithHasMany', foreign_key: 'ModelWithHasMany_id'
 
           pg_search_scope :with_associated, against: [:title], associated_against: { other_models: :title }
@@ -141,8 +142,8 @@ describe PgSearch do
       end
     end
 
-    context "across multiple associations" do
-      context "on different tables" do
+    context "when across multiple associations" do
+      context "when on different tables" do
         with_model :FirstAssociatedModel do
           table do |t|
             t.string 'title'
@@ -163,18 +164,18 @@ describe PgSearch do
           end
 
           model do
-            include PgSearch
+            include PgSearch::Model
 
             has_many :models_of_first_type,
-              class_name: 'FirstAssociatedModel',
-              foreign_key: 'ModelWithManyAssociations_id'
+                     class_name: 'FirstAssociatedModel',
+                     foreign_key: 'ModelWithManyAssociations_id'
 
             belongs_to :model_of_second_type,
-              class_name: 'SecondAssociatedModel'
+                       class_name: 'SecondAssociatedModel'
 
             pg_search_scope :with_associated,
-              against: :title,
-              associated_against: { models_of_first_type: :title, model_of_second_type: :title }
+                            against: :title,
+                            associated_against: { models_of_first_type: :title, model_of_second_type: :title }
           end
         end
 
@@ -207,7 +208,7 @@ describe PgSearch do
         end
       end
 
-      context "on the same table" do
+      context "when on the same table" do
         with_model :DoublyAssociatedModel do
           table do |t|
             t.string 'title'
@@ -222,15 +223,15 @@ describe PgSearch do
           end
 
           model do
-            include PgSearch
+            include PgSearch::Model
 
             has_many :things,
-              class_name: 'DoublyAssociatedModel',
-              foreign_key: 'ModelWithDoubleAssociation_id'
+                     class_name: 'DoublyAssociatedModel',
+                     foreign_key: 'ModelWithDoubleAssociation_id'
 
             has_many :thingamabobs,
-              class_name: 'DoublyAssociatedModel',
-              foreign_key: 'ModelWithDoubleAssociation_again_id'
+                     class_name: 'DoublyAssociatedModel',
+                     foreign_key: 'ModelWithDoubleAssociation_again_id'
 
             pg_search_scope :with_associated, against: :title,
                                               associated_against: { things: :title, thingamabobs: :title }
@@ -268,7 +269,7 @@ describe PgSearch do
       end
     end
 
-    context "against multiple attributes on one association" do
+    context "when against multiple attributes on one association" do
       with_model :AssociatedModel do
         table do |t|
           t.string 'title'
@@ -282,14 +283,14 @@ describe PgSearch do
         end
 
         model do
-          include PgSearch
+          include PgSearch::Model
           belongs_to :another_model, class_name: 'AssociatedModel'
 
           pg_search_scope :with_associated, associated_against: { another_model: %i[title author] }
         end
       end
 
-      it "should only do one join" do
+      it "joins only once" do
         included = [
           ModelWithAssociation.create!(
             another_model: AssociatedModel.create!(
@@ -321,7 +322,7 @@ describe PgSearch do
       end
     end
 
-    context "against non-text columns" do
+    context "when against non-text columns" do
       with_model :AssociatedModel do
         table do |t|
           t.integer 'number'
@@ -335,14 +336,14 @@ describe PgSearch do
         end
 
         model do
-          include PgSearch
+          include PgSearch::Model
           belongs_to :another_model, class_name: 'AssociatedModel'
 
           pg_search_scope :with_associated, associated_against: { another_model: :number }
         end
       end
 
-      it "should cast the columns to text" do
+      it "casts the columns to text" do
         associated = AssociatedModel.create!(number: 123)
         included = [
           Model.create!(number: 123, another_model: associated),
@@ -366,7 +367,7 @@ describe PgSearch do
 
         model do
           has_many :children
-          include PgSearch
+          include PgSearch::Model
           pg_search_scope :search_name, against: :name
         end
       end
@@ -395,7 +396,7 @@ describe PgSearch do
     end
   end
 
-  context "merging a pg_search_scope into another model's scope" do
+  context "when merging a pg_search_scope into another model's scope" do
     with_model :ModelWithAssociation do
       model do
         has_many :associated_models
@@ -409,14 +410,14 @@ describe PgSearch do
       end
 
       model do
-        include PgSearch
+        include PgSearch::Model
         belongs_to :model_with_association
 
         pg_search_scope :search_content, against: :content
       end
     end
 
-    it "should find records of the other model" do
+    it "finds records of the other model" do
       included_associated_1 = AssociatedModel.create(content: "foo bar")
       included_associated_2 = AssociatedModel.create(content: "foo baz")
       excluded_associated_1 = AssociatedModel.create(content: "baz quux")
@@ -441,7 +442,7 @@ describe PgSearch do
     end
   end
 
-  context "chained onto a has_many association" do
+  context "when chained onto a has_many association" do
     with_model :Company do
       model do
         has_many :positions
@@ -455,54 +456,13 @@ describe PgSearch do
       end
 
       model do
-        include PgSearch
+        include PgSearch::Model
         pg_search_scope :search, against: :title, using: %i[tsearch trigram]
       end
     end
 
     # https://github.com/Casecommons/pg_search/issues/106
-    it "should handle numbers in a trigram query properly" do
-      company = Company.create!
-      another_company = Company.create!
-
-      included = [
-        Position.create!(company_id: company.id, title: "teller 1")
-      ]
-
-      excluded = [
-        Position.create!(company_id: nil, title: "teller 1"),
-        Position.create!(company_id: another_company.id, title: "teller 1"),
-        Position.create!(company_id: company.id, title: "penn 1")
-      ]
-
-      results = company.positions.search('teller 1')
-
-      expect(results).to include(*included)
-      expect(results).not_to include(*excluded)
-    end
-  end
-
-  context "chained onto a has_many association" do
-    with_model :Company do
-      model do
-        has_many :positions
-      end
-    end
-
-    with_model :Position do
-      table do |t|
-        t.string :title
-        t.belongs_to :company
-      end
-
-      model do
-        include PgSearch
-        pg_search_scope :search, against: :title, using: %i[tsearch trigram]
-      end
-    end
-
-    # https://github.com/Casecommons/pg_search/issues/106
-    it "should handle numbers in a trigram query properly" do
+    it "handles numbers in a trigram query properly" do
       company = Company.create!
       another_company = Company.create!
 
@@ -524,3 +484,4 @@ describe PgSearch do
     end
   end
 end
+# rubocop:enable RSpec/NestedGroups

data/spec/integration/deprecation_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe "Including the deprecated PgSearch module" do
+  with_model :SomeModel do
+    model do
+      ActiveSupport::Deprecation.silence do
+        include PgSearch
+      end
+    end
+  end
+
+  with_model :AnotherModel
+
+  it "includes PgSearch::Model" do
+    expect(SomeModel.ancestors).to include PgSearch::Model
+  end
+
+  it "prints a deprecation message" do
+    allow(ActiveSupport::Deprecation).to receive(:warn)
+
+    AnotherModel.include(PgSearch)
+
+    expect(ActiveSupport::Deprecation).to have_received(:warn).with(
+      <<~MESSAGE
+        Directly including `PgSearch` into an Active Record model is deprecated and will be removed in pg_search 3.0.
+
+        Please replace `include PgSearch` with `include PgSearch::Model`.
+      MESSAGE
+    )
+  end
+end

data/spec/integration/pagination_spec.rb

@@ -10,7 +10,7 @@ describe "pagination" do
       end
 
       model do
-        include PgSearch
+        include PgSearch::Model
         pg_search_scope :search_name, against: :name
 
         def self.page(page_number)

data/spec/integration/pg_search_spec.rb

@@ -2,6 +2,7 @@
 
 require "spec_helper"
 
+# rubocop:disable RSpec/NestedGroups
 describe "an Active Record model which includes PgSearch" do
   with_model :ModelWithPgSearch do
     table do |t|
@@ -12,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
@@ -22,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
@@ -38,12 +39,12 @@ 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')
@@ -56,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")
@@ -79,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")
@@ -102,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")
@@ -130,7 +131,7 @@ 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, ->(*) { {} }
 
@@ -144,7 +145,7 @@ describe "an Active Record model which includes PgSearch" do
   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
       end
@@ -157,7 +158,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
 
@@ -174,7 +175,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
 
@@ -191,7 +192,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
 
@@ -200,7 +201,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
@@ -208,7 +209,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
@@ -220,7 +221,7 @@ 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|
@@ -270,7 +271,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
@@ -283,7 +284,7 @@ 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
 
@@ -451,7 +452,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 = double(to_s: "foo")
+        not_a_string = instance_double("Object", to_s: "foo")
         expect(ModelWithPgSearch.search_content(not_a_string)).to eq([foo])
       end
 
@@ -462,12 +463,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
 
@@ -481,7 +482,7 @@ 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]
       end
@@ -520,7 +521,7 @@ describe "an Active Record model which includes PgSearch" do
       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
       end
@@ -562,13 +563,13 @@ 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
@@ -594,10 +595,10 @@ 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
@@ -620,7 +621,7 @@ describe "an Active Record model which includes PgSearch" do
         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
@@ -641,19 +642,19 @@ describe "an Active Record model which includes PgSearch" do
             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
@@ -682,10 +683,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
@@ -699,8 +700,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
@@ -712,10 +713,10 @@ 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
@@ -728,10 +729,10 @@ 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
@@ -744,10 +745,10 @@ 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
@@ -760,16 +761,16 @@ 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
@@ -788,10 +789,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
@@ -815,10 +816,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
@@ -838,11 +839,11 @@ 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
@@ -877,38 +878,38 @@ describe "an Active Record model which includes PgSearch" do
       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
@@ -950,33 +951,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(
+        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"))
+          )
+
+          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"))
           )
 
-          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)
+          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
@@ -995,7 +1003,7 @@ describe "an Active Record model which includes PgSearch" do
         end
 
         model do
-          include PgSearch
+          include PgSearch::Model
           has_many :comments
         end
       end
@@ -1004,7 +1012,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
@@ -1013,41 +1021,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
 
@@ -1059,40 +1067,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') }
 
       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
 
@@ -1108,7 +1117,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
@@ -1116,11 +1125,11 @@ 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
@@ -1146,24 +1155,24 @@ 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 "should return records with a rank attribute equal to the :ranked_by expression" do
+      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
+      it "substitutes :tsearch with the tsearch rank expression in the :ranked_by expression" do
         ModelWithPgSearch.create!(content: 'foo', importance: 10)
 
         tsearch_result =
@@ -1181,7 +1190,7 @@ describe "an Active Record model which includes PgSearch" do
         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),
@@ -1195,10 +1204,11 @@ 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')
           end
@@ -1231,12 +1241,12 @@ 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')
@@ -1246,12 +1256,12 @@ describe "an Active Record model which includes PgSearch" do
         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')
@@ -1261,12 +1271,12 @@ describe "an Active Record model which includes PgSearch" do
         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')
@@ -1280,12 +1290,12 @@ 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")
@@ -1298,3 +1308,4 @@ describe "an Active Record model which includes PgSearch" do
     end
   end
 end
+# rubocop:enable RSpec/NestedGroups