pg_search 2.1.2 → 2.3.6

data/spec/integration/associations_spec.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 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|
@@ -12,25 +15,25 @@ describe PgSearch do
       with_model :ModelWithoutAgainst do
         table do |t|
           t.string "title"
-          t.belongs_to :another_model, :index => false
+          t.belongs_to :another_model, index: false
         end
 
         model do
-          include PgSearch
-          belongs_to :another_model, :class_name => 'AssociatedModel'
+          include PgSearch::Model
+          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')
@@ -39,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'
@@ -53,21 +56,21 @@ describe PgSearch do
         end
 
         model do
-          include PgSearch
-          belongs_to :another_model, :class_name => 'AssociatedModel'
+          include PgSearch::Model
+          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')
         expect(results.map(&:title)).to match_array(included.map(&:title))
@@ -75,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'
@@ -89,27 +92,27 @@ describe PgSearch do
         end
 
         model do
-          include PgSearch
-          has_many :other_models, :class_name => 'AssociatedModelWithHasMany', :foreign_key => 'ModelWithHasMany_id'
+          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}
+          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')
@@ -118,14 +121,14 @@ describe PgSearch do
       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')
           ])
         ]
 
@@ -139,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'
@@ -161,42 +164,42 @@ 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
 
         it "returns rows that match the query in either its own columns or the columns of the associated model" do
-          matching_second = SecondAssociatedModel.create!(:title => "foo bar")
-          unmatching_second = SecondAssociatedModel.create!(:title => "uiop")
+          matching_second = SecondAssociatedModel.create!(title: "foo bar")
+          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')
@@ -205,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'
@@ -220,42 +223,42 @@ 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}
+            pg_search_scope :with_associated, against: :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 => [
-              DoublyAssociatedModel.create!(:title => "foo bar")
+            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 => [
-              DoublyAssociatedModel.create!(:title => "uiop")
+            ModelWithDoubleAssociation.create!(title: 'qwerty', thingamabobs: [
+              DoublyAssociatedModel.create!(title: "uiop")
             ])
           ]
 
@@ -266,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'
@@ -280,33 +283,33 @@ describe PgSearch do
         end
 
         model do
-          include PgSearch
-          belongs_to :another_model, :class_name => 'AssociatedModel'
+          include PgSearch::Model
+          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!(
-              :title => "foo",
-              :author => "bar"
+            another_model: AssociatedModel.create!(
+              title: "foo",
+              author: "bar"
             )
           ),
           ModelWithAssociation.create!(
-            :another_model => AssociatedModel.create!(
-              :title => "foo bar",
-              :author => "baz"
+            another_model: AssociatedModel.create!(
+              title: "foo bar",
+              author: "baz"
             )
           )
         ]
         excluded = [
           ModelWithAssociation.create!(
-            :another_model => AssociatedModel.create!(
-              :title => "foo",
-              :author => "baz"
+            another_model: AssociatedModel.create!(
+              title: "foo",
+              author: "baz"
             )
           )
         ]
@@ -319,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'
@@ -333,21 +336,21 @@ 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}
+          pg_search_scope :with_associated, associated_against: { another_model: :number }
         end
       end
 
-      it "should cast the columns to text" do
-        associated = AssociatedModel.create!(:number => 123)
+      it "casts the columns to text" do
+        associated = AssociatedModel.create!(number: 123)
         included = [
-          Model.create!(:number => 123, :another_model => associated),
-          Model.create!(:number => 456, :another_model => associated)
+          Model.create!(number: 123, another_model: associated),
+          Model.create!(number: 456, another_model: associated)
         ]
         excluded = [
-          Model.create!(:number => 123)
+          Model.create!(number: 123)
         ]
 
         results = Model.with_associated('123')
@@ -364,8 +367,8 @@ describe PgSearch do
 
         model do
           has_many :children
-          include PgSearch
-          pg_search_scope :search_name, :against => :name
+          include PgSearch::Model
+          pg_search_scope :search_name, against: :name
         end
       end
 
@@ -381,8 +384,8 @@ 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.to_a
@@ -393,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
@@ -407,27 +410,27 @@ describe PgSearch do
       end
 
       model do
-        include PgSearch
+        include PgSearch::Model
         belongs_to :model_with_association
 
-        pg_search_scope :search_content, :against => :content
+        pg_search_scope :search_content, against: :content
       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]),
-        ModelWithAssociation.create(:associated_models => [included_associated_2, excluded_associated_1])
+        ModelWithAssociation.create(associated_models: [included_associated_1]),
+        ModelWithAssociation.create(associated_models: [included_associated_2, excluded_associated_1])
       ]
 
       excluded = [
-        ModelWithAssociation.create(:associated_models => [excluded_associated_2]),
-        ModelWithAssociation.create(:associated_models => [])
+        ModelWithAssociation.create(associated_models: [excluded_associated_2]),
+        ModelWithAssociation.create(associated_models: [])
       ]
 
       relation = AssociatedModel.search_content("foo")
@@ -439,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
-        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
@@ -494,13 +456,13 @@ describe PgSearch do
       end
 
       model do
-        include PgSearch
-        pg_search_scope :search, :against => :title, :using => %i[tsearch trigram]
+        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
+    it "handles numbers in a trigram query properly" do
       company = Company.create!
       another_company = Company.create!
 
@@ -522,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe "pagination" do
@@ -8,8 +10,8 @@ describe "pagination" do
       end
 
       model do
-        include PgSearch
-        pg_search_scope :search_name, :against => :name
+        include PgSearch::Model
+        pg_search_scope :search_name, against: :name
 
         def self.page(page_number)
           offset = (page_number - 1) * 2
@@ -19,18 +21,18 @@ describe "pagination" do
     end
 
     it "is chainable before a search scope" do
-      better = PaginatedModel.create!(:name => "foo foo bar")
-      best = PaginatedModel.create!(:name => "foo foo foo")
-      good = PaginatedModel.create!(:name => "foo bar bar")
+      better = PaginatedModel.create!(name: "foo foo bar")
+      best = PaginatedModel.create!(name: "foo foo foo")
+      good = PaginatedModel.create!(name: "foo bar bar")
 
       expect(PaginatedModel.page(1).search_name("foo")).to eq([best, better])
       expect(PaginatedModel.page(2).search_name("foo")).to eq([good])
     end
 
     it "is chainable after a search scope" do
-      better = PaginatedModel.create!(:name => "foo foo bar")
-      best = PaginatedModel.create!(:name => "foo foo foo")
-      good = PaginatedModel.create!(:name => "foo bar bar")
+      better = PaginatedModel.create!(name: "foo foo bar")
+      best = PaginatedModel.create!(name: "foo foo foo")
+      good = PaginatedModel.create!(name: "foo bar bar")
 
       expect(PaginatedModel.search_name("foo").page(1)).to eq([best, better])
       expect(PaginatedModel.search_name("foo").page(2)).to eq([good])