pg_search 2.1.7 → 2.3.3

data/spec/integration/single_table_inheritance_spec.rb

@@ -11,7 +11,7 @@ describe "a pg_search_scope on an STI subclass" do
       end
 
       model do
-        include PgSearch
+        include PgSearch::Model
         pg_search_scope :search_content, against: :content
       end
     end
@@ -51,7 +51,7 @@ describe "a pg_search_scope on an STI subclass" do
       end
 
       model do
-        include PgSearch
+        include PgSearch::Model
         self.inheritance_column = 'custom_type'
         pg_search_scope :search_content, against: :content
       end

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

@@ -2,6 +2,7 @@
 
 require "spec_helper"
 
+# rubocop:disable RSpec/NestedGroups
 describe PgSearch::Configuration::Association do
   with_model :Avatar do
     table do |t|
@@ -17,7 +18,7 @@ describe PgSearch::Configuration::Association do
     end
 
     model do
-      include PgSearch
+      include PgSearch::Model
       has_one :avatar, class_name: "Avatar"
       belongs_to :site
 
@@ -32,14 +33,14 @@ describe PgSearch::Configuration::Association do
     end
 
     model do
-      include PgSearch
+      include PgSearch::Model
       has_many :users, class_name: "User"
 
       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,7 +51,7 @@ 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}
@@ -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,7 +82,7 @@ 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}
@@ -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,7 +113,7 @@ 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}
@@ -138,3 +139,4 @@ describe PgSearch::Configuration::Association do
     end
   end
 end
+# rubocop:enable RSpec/NestedGroups

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

@@ -17,7 +17,7 @@ describe PgSearch::Configuration::ForeignColumn 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 }
@@ -26,8 +26,8 @@ describe PgSearch::Configuration::ForeignColumn do
 
     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,7 +18,7 @@ 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)
@@ -43,7 +43,7 @@ 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)

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

@@ -3,8 +3,10 @@
 require 'spec_helper'
 require 'ostruct'
 
+# rubocop:disable RSpec/MultipleMemoizedHelpers, RSpec/NestedGroups
 describe PgSearch::Features::Trigram do
   subject(:feature) { described_class.new(query, options, columns, Model, normalizer) }
+
   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
 
@@ -32,44 +36,68 @@ describe PgSearch::Features::Trigram do
   describe 'conditions' do
     it 'escapes the search document and query' do
       config.ignore = []
-      expect(feature.conditions.to_sql).to eq("((#{coalesced_columns}) % '#{query}')")
+      expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_columns}))")
+    end
+
+    context 'when searching by word_similarity' do
+      let(:options) do
+        { word_similarity: true }
+      end
+
+      it 'uses the "<%" operator when searching by word_similarity' do
+        config.ignore = []
+        expect(feature.conditions.to_sql).to eq("('#{query}' <% (#{coalesced_columns}))")
+      end
     end
 
-    context 'ignoring accents' 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(#{coalesced_columns})) % unaccent('#{query}'))")
+        expect(feature.conditions.to_sql).to eq("(unaccent('#{query}') % (unaccent(#{coalesced_columns})))")
       end
     end
 
     context 'when a threshold is specified' do
-      let(:options) do
-        { threshold: 0.5 }
+      context 'when searching by similarity' do
+        let(:options) do
+          { threshold: 0.5 }
+        end
+
+        it 'uses a minimum similarity expression instead of the "%" operator' do
+          expect(feature.conditions.to_sql).to eq(
+            "(similarity('#{query}', (#{coalesced_columns})) >= 0.5)"
+          )
+        end
       end
 
-      it 'uses a minimum similarity expression instead of the "%" operator' do
-        expect(feature.conditions.to_sql).to eq(
-          "(similarity((#{coalesced_columns}), '#{query}') >= 0.5)"
-        )
+      context 'when searching by word_similarity' do
+        let(:options) do
+          { threshold: 0.5, word_similarity: true }
+        end
+
+        it 'uses a minimum similarity expression instead of the "<%" operator' do
+          expect(feature.conditions.to_sql).to eq(
+            "(word_similarity('#{query}', (#{coalesced_columns})) >= 0.5)"
+          )
+        end
       end
     end
 
-    context 'only certain columns are selected' do
-      context 'one column' do
+    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, '')"
-          expect(feature.conditions.to_sql).to eq("((#{coalesced_column}) % '#{query}')")
+          expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_column}))")
         end
       end
-      context 'multiple columns' do
+
+      context 'with multiple columns' do
         let(:options) { { only: %i[name content] } }
 
         it 'concatenates when multiples columns are selected' do
-          options = { only: %i[name content] }
-          expect(feature.conditions.to_sql).to eq("((#{coalesced_columns}) % '#{query}')")
+          expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_columns}))")
         end
       end
     end
@@ -77,7 +105,8 @@ describe PgSearch::Features::Trigram do
 
   describe '#rank' do
     it 'returns an expression using the similarity() function' do
-      expect(feature.rank.to_sql).to eq("(similarity((#{coalesced_columns}), '#{query}'))")
+      expect(feature.rank.to_sql).to eq("(similarity('#{query}', (#{coalesced_columns})))")
     end
   end
 end
+# rubocop:enable RSpec/MultipleMemoizedHelpers, RSpec/NestedGroups

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

@@ -19,7 +19,7 @@ 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)
@@ -44,7 +44,7 @@ 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)
@@ -61,7 +61,7 @@ describe PgSearch::Features::TSearch do
           PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
         options = { negation: true }
-        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)
@@ -79,7 +79,7 @@ describe PgSearch::Features::TSearch do
           PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
         options = { negation: false }
-        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)
@@ -97,7 +97,7 @@ describe PgSearch::Features::TSearch do
           PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
         options = { tsvector_column: "my_tsvector" }
-        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)
@@ -115,7 +115,7 @@ describe PgSearch::Features::TSearch do
           PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
         options = { tsvector_column: ["tsvector1", "tsvector2"] }
-        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)
@@ -141,7 +141,7 @@ 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)
@@ -151,6 +151,7 @@ describe PgSearch::Features::TSearch do
     end
 
     context "when options[:dictionary] is passed" do
+      # rubocop:disable RSpec/ExampleLength
       it 'uses the provided dictionary' do
         query = "query"
         columns = [
@@ -165,7 +166,7 @@ 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)
@@ -174,9 +175,11 @@ describe PgSearch::Features::TSearch do
 
         expect(feature.highlight.to_sql).to eq(expected_sql)
       end
+      # rubocop:enable RSpec/ExampleLength
     end
 
     context "when options[:highlight] has options set" do
+      # rubocop:disable RSpec/ExampleLength
       it "passes the options to ts_headline" do
         query = "query"
         columns = [
@@ -195,7 +198,7 @@ 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)
@@ -204,7 +207,9 @@ describe PgSearch::Features::TSearch do
 
         expect(feature.highlight.to_sql).to eq(expected_sql)
       end
+      # rubocop:enable RSpec/ExampleLength
 
+      # rubocop:disable RSpec/ExampleLength
       it "passes deprecated options to ts_headline" do
         query = "query"
         columns = [
@@ -223,7 +228,7 @@ 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)
@@ -233,6 +238,7 @@ describe PgSearch::Features::TSearch do
 
         expect(highlight_sql).to eq(expected_sql)
       end
+      # rubocop:enable RSpec/ExampleLength
     end
   end
 end

data/spec/lib/pg_search/multisearch/rebuilder_spec.rb

@@ -2,20 +2,16 @@
 
 require "spec_helper"
 
-def has_microsecond_precision?
-  (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR >= 1) ||
-    (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR == 0 && ActiveRecord::VERSION::TINY >= 1)
-end
-
+# rubocop:disable RSpec/NestedGroups
 describe PgSearch::Multisearch::Rebuilder do
-  with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
+  with_table "pg_search_documents", &DOCUMENTS_SCHEMA
 
   describe 'when initialized with a model that is not multisearchable' do
     with_model :not_multisearchable
 
     it 'raises an exception' do
       expect {
-        PgSearch::Multisearch::Rebuilder.new(NotMultisearchable)
+        described_class.new(NotMultisearchable)
       }.to raise_exception(
         PgSearch::Multisearch::ModelNotMultisearchable,
         "NotMultisearchable is not multisearchable. See PgSearch::ClassMethods#multisearchable"
@@ -25,10 +21,10 @@ describe PgSearch::Multisearch::Rebuilder do
 
   describe "#rebuild" do
     context "when the model defines .rebuild_pg_search_documents" do
-      context "and multisearchable is not conditional" do
+      context "when multisearchable is not conditional" do
         with_model :Model do
           model do
-            include PgSearch
+            include PgSearch::Model
             multisearchable
 
             def rebuild_pg_search_documents
@@ -36,14 +32,18 @@ describe PgSearch::Multisearch::Rebuilder do
           end
         end
 
-        it "should call .rebuild_pg_search_documents" do
-          rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
-          expect(Model).to receive(:rebuild_pg_search_documents)
-          rebuilder.rebuild
+        it "calls .rebuild_pg_search_documents" do
+          rebuilder = described_class.new(Model)
+
+          without_partial_double_verification do
+            allow(Model).to receive(:rebuild_pg_search_documents)
+            rebuilder.rebuild
+            expect(Model).to have_received(:rebuild_pg_search_documents)
+          end
         end
       end
 
-      context "and multisearchable is conditional" do
+      context "when multisearchable is conditional" do
         %i[if unless].each do |conditional_key|
           context "via :#{conditional_key}" do
             with_model :Model do
@@ -52,7 +52,7 @@ describe PgSearch::Multisearch::Rebuilder do
               end
 
               model do
-                include PgSearch
+                include PgSearch::Model
                 multisearchable conditional_key => :active?
 
                 def rebuild_pg_search_documents
@@ -60,10 +60,14 @@ describe PgSearch::Multisearch::Rebuilder do
               end
             end
 
-            it "should call .rebuild_pg_search_documents" do
-              rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
-              expect(Model).to receive(:rebuild_pg_search_documents)
-              rebuilder.rebuild
+            it "calls .rebuild_pg_search_documents" do
+              rebuilder = described_class.new(Model)
+
+              without_partial_double_verification do
+                allow(Model).to receive(:rebuild_pg_search_documents)
+                rebuilder.rebuild
+                expect(Model).to have_received(:rebuild_pg_search_documents)
+              end
             end
           end
         end
@@ -71,7 +75,7 @@ describe PgSearch::Multisearch::Rebuilder do
     end
 
     context "when the model does not define .rebuild_pg_search_documents" do
-      context "and multisearchable is not conditional" do
+      context "when multisearchable is not conditional" do
         context "when :against only includes columns" do
           with_model :Model do
             table do |t|
@@ -79,13 +83,13 @@ describe PgSearch::Multisearch::Rebuilder do
             end
 
             model do
-              include PgSearch
+              include PgSearch::Model
               multisearchable against: :name
             end
           end
 
-          it "should not call :rebuild_pg_search_documents" do
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+          it "does not call :rebuild_pg_search_documents" do
+            rebuilder = described_class.new(Model)
 
             # stub respond_to? to return false since should_not_receive defines the method
             original_respond_to = Model.method(:respond_to?)
@@ -97,28 +101,28 @@ describe PgSearch::Multisearch::Rebuilder do
               end
             end
 
-            expect(Model).not_to receive(:rebuild_pg_search_documents)
-            rebuilder.rebuild
+            without_partial_double_verification do
+              allow(Model).to receive(:rebuild_pg_search_documents)
+              rebuilder.rebuild
+              expect(Model).not_to have_received(:rebuild_pg_search_documents)
+            end
           end
 
-          it "should execute the default SQL" do
+          # rubocop:disable RSpec/ExampleLength
+          it "executes the default SQL" do
             time = Time.utc(2001, 1, 1, 0, 0, 0)
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model, -> { time })
-
-            # Handle change in precision of Time objects in SQL in Active Record 4.0.1
-            # https://github.com/rails/rails/commit/17f5d8e062909f1fcae25351834d8e89967b645e
-            expected_timestamp = has_microsecond_precision? ? "2001-01-01 00:00:00.000000" : "2001-01-01 00:00:00"
-
-            expected_sql = <<-SQL.strip_heredoc
-            INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
-              SELECT 'Model' AS searchable_type,
-                     #{Model.quoted_table_name}.#{Model.primary_key} AS searchable_id,
-                     (
-                       coalesce(#{Model.quoted_table_name}."name"::text, '')
-                     ) AS content,
-                     '#{expected_timestamp}' AS created_at,
-                     '#{expected_timestamp}' AS updated_at
-              FROM #{Model.quoted_table_name}
+            rebuilder = described_class.new(Model, -> { time })
+
+            expected_sql = <<~SQL.squish
+              INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
+                SELECT 'Model' AS searchable_type,
+                       #{Model.quoted_table_name}.#{Model.primary_key} AS searchable_id,
+                       (
+                         coalesce(#{Model.quoted_table_name}."name"::text, '')
+                       ) AS content,
+                       '2001-01-01 00:00:00' AS created_at,
+                       '2001-01-01 00:00:00' AS updated_at
+                FROM #{Model.quoted_table_name}
             SQL
 
             executed_sql = []
@@ -133,56 +137,54 @@ describe PgSearch::Multisearch::Rebuilder do
             expect(executed_sql.length).to eq(1)
             expect(executed_sql.first.strip).to eq(expected_sql.strip)
           end
+          # rubocop:enable RSpec/ExampleLength
 
-          context "for a model with a camel case column" do
+          context "with a model with a camel case column" do
             with_model :ModelWithCamelCaseColumn do
               table do |t|
                 t.string :camelName
               end
 
               model do
-                include PgSearch
+                include PgSearch::Model
                 multisearchable against: :name
               end
             end
 
             it "creates search document without PG error" do
               time = Time.utc(2001, 1, 1, 0, 0, 0)
-              rebuilder = PgSearch::Multisearch::Rebuilder.new(Model, -> { time })
+              rebuilder = described_class.new(Model, -> { time })
               rebuilder.rebuild
             end
           end
 
-          context "for a model with a non-standard primary key" do
+          context "with a model with a non-standard primary key" do
             with_model :ModelWithNonStandardPrimaryKey do
               table primary_key: :non_standard_primary_key do |t|
                 t.string :name
               end
 
               model do
-                include PgSearch
+                include PgSearch::Model
                 multisearchable against: :name
               end
             end
 
+            # rubocop:disable RSpec/ExampleLength
             it "generates SQL with the correct primary key" do
               time = Time.utc(2001, 1, 1, 0, 0, 0)
-              rebuilder = PgSearch::Multisearch::Rebuilder.new(ModelWithNonStandardPrimaryKey, -> { time })
-
-              # Handle change in precision of Time objects in SQL in Active Record 4.0.1
-              # https://github.com/rails/rails/commit/17f5d8e062909f1fcae25351834d8e89967b645e
-              expected_timestamp = has_microsecond_precision? ? "2001-01-01 00:00:00.000000" : "2001-01-01 00:00:00"
-
-              expected_sql = <<-SQL.strip_heredoc
-              INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
-                SELECT 'ModelWithNonStandardPrimaryKey' AS searchable_type,
-                       #{ModelWithNonStandardPrimaryKey.quoted_table_name}.non_standard_primary_key AS searchable_id,
-                       (
-                         coalesce(#{ModelWithNonStandardPrimaryKey.quoted_table_name}."name"::text, '')
-                       ) AS content,
-                       '#{expected_timestamp}' AS created_at,
-                       '#{expected_timestamp}' AS updated_at
-                FROM #{ModelWithNonStandardPrimaryKey.quoted_table_name}
+              rebuilder = described_class.new(ModelWithNonStandardPrimaryKey, -> { time })
+
+              expected_sql = <<~SQL.squish
+                INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
+                  SELECT 'ModelWithNonStandardPrimaryKey' AS searchable_type,
+                         #{ModelWithNonStandardPrimaryKey.quoted_table_name}.non_standard_primary_key AS searchable_id,
+                         (
+                           coalesce(#{ModelWithNonStandardPrimaryKey.quoted_table_name}."name"::text, '')
+                         ) AS content,
+                         '2001-01-01 00:00:00' AS created_at,
+                         '2001-01-01 00:00:00' AS updated_at
+                  FROM #{ModelWithNonStandardPrimaryKey.quoted_table_name}
               SQL
 
               executed_sql = []
@@ -197,6 +199,7 @@ describe PgSearch::Multisearch::Rebuilder do
               expect(executed_sql.length).to eq(1)
               expect(executed_sql.first.strip).to eq(expected_sql.strip)
             end
+            # rubocop:enable RSpec/ExampleLength
           end
         end
 
@@ -206,7 +209,7 @@ describe PgSearch::Multisearch::Rebuilder do
             end
 
             model do
-              include PgSearch
+              include PgSearch::Model
               multisearchable against: [:foo]
 
               def foo
@@ -215,10 +218,11 @@ describe PgSearch::Multisearch::Rebuilder do
             end
           end
 
+          # rubocop:disable RSpec/ExampleLength
           it "calls update_pg_search_document on each record" do
             record = Model.create!
 
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+            rebuilder = described_class.new(Model)
 
             # stub respond_to? to return false since should_not_receive defines the method
             original_respond_to = Model.method(:respond_to?)
@@ -229,16 +233,49 @@ describe PgSearch::Multisearch::Rebuilder do
                 original_respond_to.call(method_name, *args)
               end
             end
-            expect(Model).not_to receive(:rebuild_pg_search_documents)
 
-            rebuilder.rebuild
+            without_partial_double_verification do
+              allow(Model).to receive(:rebuild_pg_search_documents)
+
+              rebuilder.rebuild
+
+              expect(Model).not_to have_received(:rebuild_pg_search_documents)
+            end
 
             expect(record.pg_search_document).to be_present
           end
+          # rubocop:enable RSpec/ExampleLength
+        end
+
+        context "when only additional_attributes is set" do
+          with_model :Model do
+            table do |t|
+              t.string :name
+            end
+
+            model do
+              include PgSearch::Model
+              multisearchable against: :name,
+                              additional_attributes: ->(obj) { { additional_attribute_column: "#{obj.class}::#{obj.id}" } }
+            end
+          end
+
+          it "calls update_pg_search_document on each record" do
+            record_1 = Model.create!(name: "record_1", id: 1)
+            record_2 = Model.create!(name: "record_2", id: 2)
+
+            PgSearch::Document.delete_all
+
+            rebuilder = described_class.new(Model)
+            rebuilder.rebuild
+
+            expect(record_1.reload.pg_search_document.additional_attribute_column).to eq("Model::1")
+            expect(record_2.reload.pg_search_document.additional_attribute_column).to eq("Model::2")
+          end
         end
       end
 
-      context "and multisearchable is conditional" do
+      context "when multisearchable is conditional" do
         context "via :if" do
           with_model :Model do
             table do |t|
@@ -246,16 +283,17 @@ describe PgSearch::Multisearch::Rebuilder do
             end
 
             model do
-              include PgSearch
+              include PgSearch::Model
               multisearchable if: :active?
             end
           end
 
+          # rubocop:disable RSpec/ExampleLength
           it "calls update_pg_search_document on each record" do
             record_1 = Model.create!(active: true)
             record_2 = Model.create!(active: false)
 
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+            rebuilder = described_class.new(Model)
 
             # stub respond_to? to return false since should_not_receive defines the method
             original_respond_to = Model.method(:respond_to?)
@@ -266,13 +304,17 @@ describe PgSearch::Multisearch::Rebuilder do
                 original_respond_to.call(method_name, *args)
               end
             end
-            expect(Model).not_to receive(:rebuild_pg_search_documents)
 
-            rebuilder.rebuild
+            without_partial_double_verification do
+              allow(Model).to receive(:rebuild_pg_search_documents)
+              rebuilder.rebuild
+              expect(Model).not_to have_received(:rebuild_pg_search_documents)
+            end
 
             expect(record_1.pg_search_document).to be_present
             expect(record_2.pg_search_document).not_to be_present
           end
+          # rubocop:enable RSpec/ExampleLength
         end
 
         context "via :unless" do
@@ -282,16 +324,17 @@ describe PgSearch::Multisearch::Rebuilder do
             end
 
             model do
-              include PgSearch
+              include PgSearch::Model
               multisearchable unless: :inactive?
             end
           end
 
+          # rubocop:disable RSpec/ExampleLength
           it "calls update_pg_search_document on each record" do
             record_1 = Model.create!(inactive: true)
             record_2 = Model.create!(inactive: false)
 
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+            rebuilder = described_class.new(Model)
 
             # stub respond_to? to return false since should_not_receive defines the method
             original_respond_to = Model.method(:respond_to?)
@@ -302,15 +345,20 @@ describe PgSearch::Multisearch::Rebuilder do
                 original_respond_to.call(method_name, *args)
               end
             end
-            expect(Model).not_to receive(:rebuild_pg_search_documents)
 
-            rebuilder.rebuild
+            without_partial_double_verification do
+              allow(Model).to receive(:rebuild_pg_search_documents)
+              rebuilder.rebuild
+              expect(Model).not_to have_received(:rebuild_pg_search_documents)
+            end
 
             expect(record_1.pg_search_document).not_to be_present
             expect(record_2.pg_search_document).to be_present
           end
+          # rubocop:enable RSpec/ExampleLength
         end
       end
     end
   end
 end
+# rubocop:enable RSpec/NestedGroups