pg_search 2.3.2 → 2.3.7

data/spec/integration/associations_spec.rb

@@ -2,8 +2,9 @@
 
 require "spec_helper"
 
-describe PgSearch do
-  context "joining to another table" do
+# standard: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|
@@ -19,162 +20,162 @@ describe PgSearch 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 rows that match the query in the columns of the associated model only" do
-        associated = AssociatedModel.create!(title: 'abcdef')
+        associated = AssociatedModel.create!(title: "abcdef")
         included = [
-          ModelWithoutAgainst.create!(title: 'abcdef', another_model: associated),
-          ModelWithoutAgainst.create!(title: 'ghijkl', another_model: associated)
+          ModelWithoutAgainst.create!(title: "abcdef", another_model: associated),
+          ModelWithoutAgainst.create!(title: "ghijkl", another_model: associated)
         ]
         excluded = [
-          ModelWithoutAgainst.create!(title: 'abcdef')
+          ModelWithoutAgainst.create!(title: "abcdef")
         ]
 
-        results = ModelWithoutAgainst.with_another('abcdef')
+        results = ModelWithoutAgainst.with_another("abcdef")
         expect(results.map(&:title)).to match_array(included.map(&:title))
         expect(results).not_to include(excluded)
       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'
+          t.string "title"
         end
       end
 
       with_model :ModelWithBelongsTo do
         table do |t|
-          t.string 'title'
-          t.belongs_to 'another_model', index: false
+          t.string "title"
+          t.belongs_to "another_model", index: false
         end
 
         model do
           include PgSearch::Model
-          belongs_to :another_model, class_name: 'AssociatedModel'
+          belongs_to :another_model, class_name: "AssociatedModel"
 
-          pg_search_scope :with_associated, against: :title, associated_against: { another_model: :title }
+          pg_search_scope :with_associated, against: :title, associated_against: {another_model: :title}
         end
       end
 
       it "returns rows that match the query in either its own columns or the columns of the associated model" do
-        associated = AssociatedModel.create!(title: 'abcdef')
+        associated = AssociatedModel.create!(title: "abcdef")
         included = [
-          ModelWithBelongsTo.create!(title: 'ghijkl', another_model: associated),
-          ModelWithBelongsTo.create!(title: 'abcdef')
+          ModelWithBelongsTo.create!(title: "ghijkl", another_model: associated),
+          ModelWithBelongsTo.create!(title: "abcdef")
         ]
-        excluded = ModelWithBelongsTo.create!(title: 'mnopqr',
-                                              another_model: AssociatedModel.create!(title: 'stuvwx'))
+        excluded = ModelWithBelongsTo.create!(title: "mnopqr",
+          another_model: AssociatedModel.create!(title: "stuvwx"))
 
-        results = ModelWithBelongsTo.with_associated('abcdef')
+        results = ModelWithBelongsTo.with_associated("abcdef")
         expect(results.map(&:title)).to match_array(included.map(&:title))
         expect(results).not_to include(excluded)
       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'
-          t.belongs_to 'ModelWithHasMany', index: false
+          t.string "title"
+          t.belongs_to "ModelWithHasMany", index: false
         end
       end
 
       with_model :ModelWithHasMany do
         table do |t|
-          t.string 'title'
+          t.string "title"
         end
 
         model do
           include PgSearch::Model
-          has_many :other_models, class_name: 'AssociatedModelWithHasMany', foreign_key: 'ModelWithHasMany_id'
+          has_many :other_models, class_name: "AssociatedModelWithHasMany", foreign_key: "ModelWithHasMany_id"
 
-          pg_search_scope :with_associated, against: [:title], associated_against: { other_models: :title }
+          pg_search_scope :with_associated, against: [:title], associated_against: {other_models: :title}
         end
       end
 
       it "returns rows that match the query in either its own columns or the columns of the associated model" do
         included = [
-          ModelWithHasMany.create!(title: 'abcdef', other_models: [
-            AssociatedModelWithHasMany.create!(title: 'foo'),
-            AssociatedModelWithHasMany.create!(title: 'bar')
+          ModelWithHasMany.create!(title: "abcdef", other_models: [
+            AssociatedModelWithHasMany.create!(title: "foo"),
+            AssociatedModelWithHasMany.create!(title: "bar")
           ]),
-          ModelWithHasMany.create!(title: 'ghijkl', other_models: [
-            AssociatedModelWithHasMany.create!(title: 'foo bar'),
-            AssociatedModelWithHasMany.create!(title: 'mnopqr')
+          ModelWithHasMany.create!(title: "ghijkl", other_models: [
+            AssociatedModelWithHasMany.create!(title: "foo bar"),
+            AssociatedModelWithHasMany.create!(title: "mnopqr")
           ]),
-          ModelWithHasMany.create!(title: 'foo bar')
+          ModelWithHasMany.create!(title: "foo bar")
         ]
-        excluded = ModelWithHasMany.create!(title: 'stuvwx', other_models: [
-          AssociatedModelWithHasMany.create!(title: 'abcdef')
+        excluded = ModelWithHasMany.create!(title: "stuvwx", other_models: [
+          AssociatedModelWithHasMany.create!(title: "abcdef")
         ])
 
-        results = ModelWithHasMany.with_associated('foo bar')
+        results = ModelWithHasMany.with_associated("foo bar")
         expect(results.map(&:title)).to match_array(included.map(&:title))
         expect(results).not_to include(excluded)
       end
 
       it "uses an unscoped relation of the associated model" do
-        excluded = ModelWithHasMany.create!(title: 'abcdef', other_models: [
-          AssociatedModelWithHasMany.create!(title: 'abcdef')
+        excluded = ModelWithHasMany.create!(title: "abcdef", other_models: [
+          AssociatedModelWithHasMany.create!(title: "abcdef")
         ])
 
         included = [
-          ModelWithHasMany.create!(title: 'abcdef', other_models: [
-            AssociatedModelWithHasMany.create!(title: 'foo'),
-            AssociatedModelWithHasMany.create!(title: 'bar')
+          ModelWithHasMany.create!(title: "abcdef", other_models: [
+            AssociatedModelWithHasMany.create!(title: "foo"),
+            AssociatedModelWithHasMany.create!(title: "bar")
           ])
         ]
 
         results = ModelWithHasMany
-                  .limit(1)
-                  .order(Arel.sql("#{ModelWithHasMany.quoted_table_name}.id ASC"))
-                  .with_associated('foo bar')
+          .limit(1)
+          .order(Arel.sql("#{ModelWithHasMany.quoted_table_name}.id ASC"))
+          .with_associated("foo bar")
 
         expect(results.map(&:title)).to match_array(included.map(&:title))
         expect(results).not_to include(excluded)
       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'
-            t.belongs_to 'ModelWithManyAssociations', index: false
+            t.string "title"
+            t.belongs_to "ModelWithManyAssociations", index: false
           end
         end
 
         with_model :SecondAssociatedModel do
           table do |t|
-            t.string 'title'
+            t.string "title"
           end
         end
 
         with_model :ModelWithManyAssociations do
           table do |t|
-            t.string 'title'
-            t.belongs_to 'model_of_second_type', index: false
+            t.string "title"
+            t.belongs_to "model_of_second_type", index: false
           end
 
           model do
             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
 
@@ -183,113 +184,113 @@ describe PgSearch do
           unmatching_second = SecondAssociatedModel.create!(title: "uiop")
 
           included = [
-            ModelWithManyAssociations.create!(title: 'abcdef', models_of_first_type: [
-              FirstAssociatedModel.create!(title: 'foo'),
-              FirstAssociatedModel.create!(title: 'bar')
+            ModelWithManyAssociations.create!(title: "abcdef", models_of_first_type: [
+              FirstAssociatedModel.create!(title: "foo"),
+              FirstAssociatedModel.create!(title: "bar")
             ]),
-            ModelWithManyAssociations.create!(title: 'ghijkl', models_of_first_type: [
-              FirstAssociatedModel.create!(title: 'foo bar'),
-              FirstAssociatedModel.create!(title: 'mnopqr')
+            ModelWithManyAssociations.create!(title: "ghijkl", models_of_first_type: [
+              FirstAssociatedModel.create!(title: "foo bar"),
+              FirstAssociatedModel.create!(title: "mnopqr")
             ]),
-            ModelWithManyAssociations.create!(title: 'foo bar'),
-            ModelWithManyAssociations.create!(title: 'qwerty', model_of_second_type: matching_second)
+            ModelWithManyAssociations.create!(title: "foo bar"),
+            ModelWithManyAssociations.create!(title: "qwerty", model_of_second_type: matching_second)
           ]
           excluded = [
-            ModelWithManyAssociations.create!(title: 'stuvwx', models_of_first_type: [
-              FirstAssociatedModel.create!(title: 'abcdef')
+            ModelWithManyAssociations.create!(title: "stuvwx", models_of_first_type: [
+              FirstAssociatedModel.create!(title: "abcdef")
             ]),
-            ModelWithManyAssociations.create!(title: 'qwerty', model_of_second_type: unmatching_second)
+            ModelWithManyAssociations.create!(title: "qwerty", model_of_second_type: unmatching_second)
           ]
 
-          results = ModelWithManyAssociations.with_associated('foo bar')
+          results = ModelWithManyAssociations.with_associated("foo bar")
           expect(results.map(&:title)).to match_array(included.map(&:title))
           excluded.each { |object| expect(results).not_to include(object) }
         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'
-            t.belongs_to 'ModelWithDoubleAssociation', index: false
-            t.belongs_to 'ModelWithDoubleAssociation_again', index: false
+            t.string "title"
+            t.belongs_to "ModelWithDoubleAssociation", index: false
+            t.belongs_to "ModelWithDoubleAssociation_again", index: false
           end
         end
 
         with_model :ModelWithDoubleAssociation do
           table do |t|
-            t.string 'title'
+            t.string "title"
           end
 
           model do
             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 }
+              associated_against: {things: :title, thingamabobs: :title}
           end
         end
 
         it "returns rows that match the query in either its own columns or the columns of the associated model" do
           included = [
-            ModelWithDoubleAssociation.create!(title: 'abcdef', things: [
-              DoublyAssociatedModel.create!(title: 'foo'),
-              DoublyAssociatedModel.create!(title: 'bar')
+            ModelWithDoubleAssociation.create!(title: "abcdef", things: [
+              DoublyAssociatedModel.create!(title: "foo"),
+              DoublyAssociatedModel.create!(title: "bar")
             ]),
-            ModelWithDoubleAssociation.create!(title: 'ghijkl', things: [
-              DoublyAssociatedModel.create!(title: 'foo bar'),
-              DoublyAssociatedModel.create!(title: 'mnopqr')
+            ModelWithDoubleAssociation.create!(title: "ghijkl", things: [
+              DoublyAssociatedModel.create!(title: "foo bar"),
+              DoublyAssociatedModel.create!(title: "mnopqr")
             ]),
-            ModelWithDoubleAssociation.create!(title: 'foo bar'),
-            ModelWithDoubleAssociation.create!(title: 'qwerty', thingamabobs: [
+            ModelWithDoubleAssociation.create!(title: "foo bar"),
+            ModelWithDoubleAssociation.create!(title: "qwerty", thingamabobs: [
               DoublyAssociatedModel.create!(title: "foo bar")
             ])
           ]
           excluded = [
-            ModelWithDoubleAssociation.create!(title: 'stuvwx', things: [
-              DoublyAssociatedModel.create!(title: 'abcdef')
+            ModelWithDoubleAssociation.create!(title: "stuvwx", things: [
+              DoublyAssociatedModel.create!(title: "abcdef")
             ]),
-            ModelWithDoubleAssociation.create!(title: 'qwerty', thingamabobs: [
+            ModelWithDoubleAssociation.create!(title: "qwerty", thingamabobs: [
               DoublyAssociatedModel.create!(title: "uiop")
             ])
           ]
 
-          results = ModelWithDoubleAssociation.with_associated('foo bar')
+          results = ModelWithDoubleAssociation.with_associated("foo bar")
           expect(results.map(&:title)).to match_array(included.map(&:title))
           excluded.each { |object| expect(results).not_to include(object) }
         end
       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'
-          t.text 'author'
+          t.string "title"
+          t.text "author"
         end
       end
 
       with_model :ModelWithAssociation do
         table do |t|
-          t.belongs_to 'another_model', index: false
+          t.belongs_to "another_model", index: false
         end
 
         model do
           include PgSearch::Model
-          belongs_to :another_model, class_name: 'AssociatedModel'
+          belongs_to :another_model, class_name: "AssociatedModel"
 
-          pg_search_scope :with_associated, associated_against: { another_model: %i[title author] }
+          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!(
@@ -313,7 +314,7 @@ describe PgSearch do
           )
         ]
 
-        results = ModelWithAssociation.with_associated('foo bar')
+        results = ModelWithAssociation.with_associated("foo bar")
 
         expect(results.to_sql.scan("INNER JOIN #{AssociatedModel.quoted_table_name}").length).to eq(1)
         included.each { |object| expect(results).to include(object) }
@@ -321,28 +322,28 @@ 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'
+          t.integer "number"
         end
       end
 
       with_model :Model do
         table do |t|
-          t.integer 'number'
-          t.belongs_to 'another_model', index: false
+          t.integer "number"
+          t.belongs_to "another_model", index: false
         end
 
         model do
           include PgSearch::Model
-          belongs_to :another_model, class_name: 'AssociatedModel'
+          belongs_to :another_model, class_name: "AssociatedModel"
 
-          pg_search_scope :with_associated, associated_against: { another_model: :number }
+          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),
@@ -352,7 +353,7 @@ describe PgSearch do
           Model.create!(number: 123)
         ]
 
-        results = Model.with_associated('123')
+        results = Model.with_associated("123")
         expect(results.map(&:number)).to match_array(included.map(&:number))
         expect(results).not_to include(excluded)
       end
@@ -383,10 +384,10 @@ describe PgSearch do
 
       # https://github.com/Casecommons/pg_search/issues/14
       it "supports queries with periods" do
-        included = Parent.create!(name: 'bar.foo')
-        excluded = Parent.create!(name: 'foo.bar')
+        included = Parent.create!(name: "bar.foo")
+        excluded = Parent.create!(name: "foo.bar")
 
-        results = Parent.search_name('bar.foo').includes(:children)
+        results = Parent.search_name("bar.foo").includes(:children)
         results.to_a
 
         expect(results).to include(included)
@@ -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
@@ -416,11 +417,11 @@ describe PgSearch do
       end
     end
 
-    it "should find 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")
-      excluded_associated_2 = AssociatedModel.create(content: "baz bar")
+    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")
+      excluded_associated_2 = AssociatedModel.create!(content: "baz bar")
 
       included = [
         ModelWithAssociation.create(associated_models: [included_associated_1]),
@@ -441,48 +442,7 @@ describe PgSearch do
     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::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
+  context "when chained onto a has_many association" do
     with_model :Company do
       model do
         has_many :positions
@@ -502,7 +462,7 @@ describe PgSearch do
     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!
 
@@ -517,10 +477,11 @@ describe PgSearch do
         Position.create!(company_id: company.id, title: "penn 1")
       ]
 
-      results = company.positions.search('teller 1')
+      results = company.positions.search("teller 1")
 
       expect(results).to include(*included)
       expect(results).not_to include(*excluded)
     end
   end
 end
+# standard:enable RSpec/NestedGroups

data/spec/integration/deprecation_spec.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "active_support/core_ext/kernel/reporting"
 
 describe "Including the deprecated PgSearch module" do
   with_model :SomeModel do
     model do
-      ActiveSupport::Deprecation.silence do
+      silence_warnings do
         include PgSearch
       end
     end
@@ -18,16 +19,14 @@ describe "Including the deprecated PgSearch module" do
   end
 
   it "prints a deprecation message" do
-    allow(ActiveSupport::Deprecation).to receive(:warn)
+    allow(PgSearch).to receive(:warn)
 
     AnotherModel.include(PgSearch)
 
-    expect(ActiveSupport::Deprecation).to have_received(:warn).with(
-      <<-MESSAGE.strip_heredoc
-        Directly including `PgSearch` into an Active Record model is deprecated and will be removed in pg_search 3.0.
+    expect(PgSearch).to have_received(:warn).with(<<~MESSAGE, category: :deprecated, uplevel: 1)
+      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
-    )
+      Please replace `include PgSearch` with `include PgSearch::Model`.
+    MESSAGE
   end
 end