pg_search 2.1.2 → 2.3.6

data/spec/lib/pg_search/normalizer_spec.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
+# rubocop:disable RSpec/NestedGroups
 describe PgSearch::Normalizer do
   describe "#add_normalization" do
     context "when config[:ignore] includes :accents" do
       context "when passed an Arel node" do
         it "wraps the expression in unaccent()" do
-          config = double("config", :ignore => [:accents])
+          config = instance_double("PgSearch::Configuration", "config", ignore: [:accents])
           node = Arel::Nodes::NamedFunction.new("foo", [Arel::Nodes.build_quoted("bar")])
 
-          normalizer = PgSearch::Normalizer.new(config)
+          normalizer = described_class.new(config)
           expect(normalizer.add_normalization(node)).to eq("unaccent(foo('bar'))")
         end
 
@@ -17,9 +20,9 @@ describe PgSearch::Normalizer do
             allow(PgSearch).to receive(:unaccent_function).and_return("my_unaccent")
             node = Arel::Nodes::NamedFunction.new("foo", [Arel::Nodes.build_quoted("bar")])
 
-            config = double("config", :ignore => [:accents])
+            config = instance_double("PgSearch::Configuration", "config", ignore: [:accents])
 
-            normalizer = PgSearch::Normalizer.new(config)
+            normalizer = described_class.new(config)
             expect(normalizer.add_normalization(node)).to eq("my_unaccent(foo('bar'))")
           end
         end
@@ -27,9 +30,9 @@ describe PgSearch::Normalizer do
 
       context "when passed a String" do
         it "wraps the expression in unaccent()" do
-          config = double("config", :ignore => [:accents])
+          config = instance_double("PgSearch::Configuration", "config", ignore: [:accents])
 
-          normalizer = PgSearch::Normalizer.new(config)
+          normalizer = described_class.new(config)
           expect(normalizer.add_normalization("foo")).to eq("unaccent(foo)")
         end
 
@@ -37,9 +40,9 @@ describe PgSearch::Normalizer do
           it "wraps the expression in that function" do
             allow(PgSearch).to receive(:unaccent_function).and_return("my_unaccent")
 
-            config = double("config", :ignore => [:accents])
+            config = instance_double("PgSearch::Configuration", "config", ignore: [:accents])
 
-            normalizer = PgSearch::Normalizer.new(config)
+            normalizer = described_class.new(config)
             expect(normalizer.add_normalization("foo")).to eq("my_unaccent(foo)")
           end
         end
@@ -48,11 +51,12 @@ describe PgSearch::Normalizer do
 
     context "when config[:ignore] does not include :accents" do
       it "passes the expression through" do
-        config = double("config", :ignore => [])
+        config = instance_double("PgSearch::Configuration", "config", ignore: [])
 
-        normalizer = PgSearch::Normalizer.new(config)
+        normalizer = described_class.new(config)
         expect(normalizer.add_normalization("foo")).to eq("foo")
       end
     end
   end
 end
+# rubocop:enable RSpec/NestedGroups

data/spec/lib/pg_search_spec.rb

@@ -1,69 +1,73 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
-# For AR 5 and greater, the association reflection's cache needs be cleared
+# For Active Record 5.x, the association reflection's cache needs be cleared
 # because we're stubbing the related constants.
-class << PgSearch::Document
-  if ActiveRecord::VERSION::MAJOR >= 5
-    def clear_searchable_cache
-      reflect_on_association(:searchable).clear_association_scope_cache
-    end
-  else
-    def clear_searchable_cache
-    end
+if ActiveRecord::VERSION::MAJOR == 5
+  def clear_searchable_cache
+    PgSearch::Document.reflect_on_association(:searchable).clear_association_scope_cache
+  end
+else
+  def clear_searchable_cache
   end
 end
 
+# rubocop:disable RSpec/NestedGroups
 describe PgSearch do
   describe ".multisearch" do
-    with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
+    with_table "pg_search_documents", &DOCUMENTS_SCHEMA
 
     describe "delegation to PgSearch::Document.search" do
-      subject { PgSearch.multisearch(query) }
+      subject { described_class.multisearch(query) }
+
+      let(:query) { instance_double("String", "query") }
+      let(:relation) { instance_double("ActiveRecord::Relation", "relation") }
 
-      let(:query) { double(:query) }
-      let(:relation) { double(:relation) }
       before do
-        expect(PgSearch::Document).to receive(:search).with(query).and_return(relation)
+        allow(PgSearch::Document).to receive(:search).with(query).and_return(relation)
       end
 
       it { is_expected.to eq(relation) }
     end
 
     context "with PgSearch.multisearch_options set to a Hash" do
-      before { allow(PgSearch).to receive(:multisearch_options).and_return(:using => :dmetaphone) }
       subject do
-        PgSearch::Document.clear_searchable_cache
-        PgSearch.multisearch(query).map(&:searchable)
+        clear_searchable_cache
+        described_class.multisearch(query).map(&:searchable)
       end
 
+      before { allow(described_class).to receive(:multisearch_options).and_return(using: :dmetaphone) }
+
       with_model :MultisearchableModel do
         table do |t|
           t.string :title
         end
         model do
-          include PgSearch
-          multisearchable :against => :title
+          include PgSearch::Model
+          multisearchable against: :title
         end
       end
 
-      let!(:soundalike_record) { MultisearchableModel.create!(:title => 'foning') }
+      let!(:soundalike_record) { MultisearchableModel.create!(title: 'foning') }
       let(:query) { "Phoning" }
+
       it { is_expected.to include(soundalike_record) }
     end
 
     context "with PgSearch.multisearch_options set to a Proc" do
       subject do
-        PgSearch::Document.clear_searchable_cache
-        PgSearch.multisearch(query, soundalike).map(&:searchable)
+        clear_searchable_cache
+        described_class.multisearch(query, soundalike).map(&:searchable)
       end
 
       before do
-        allow(PgSearch).to receive(:multisearch_options) do
+        allow(described_class).to receive(:multisearch_options) do
           lambda do |query, soundalike|
             if soundalike
-              {:using => :dmetaphone, :query => query}
+              { using: :dmetaphone, query: query }
             else
-              {:query => query}
+              { query: query }
             end
           end
         end
@@ -74,26 +78,28 @@ describe PgSearch do
           t.string :title
         end
         model do
-          include PgSearch
-          multisearchable :against => :title
+          include PgSearch::Model
+          multisearchable against: :title
         end
       end
 
-      let!(:soundalike_record) { MultisearchableModel.create!(:title => 'foning') }
+      let!(:soundalike_record) { MultisearchableModel.create!(title: 'foning') }
       let(:query) { "Phoning" }
 
       context "with soundalike true" do
         let(:soundalike) { true }
+
         it { is_expected.to include(soundalike_record) }
       end
 
       context "with soundalike false" do
         let(:soundalike) { false }
+
         it { is_expected.not_to include(soundalike_record) }
       end
     end
 
-    context "on an STI subclass" do
+    context "when on an STI subclass" do
       context "with standard type column" do
         with_model :SuperclassModel do
           table do |t|
@@ -104,8 +110,8 @@ describe PgSearch do
 
         before do
           searchable_subclass_model = Class.new(SuperclassModel) do
-            include PgSearch
-            multisearchable :against => :content
+            include PgSearch::Model
+            multisearchable against: :content
           end
           stub_const("SearchableSubclassModel", searchable_subclass_model)
           stub_const("AnotherSearchableSubclassModel", searchable_subclass_model)
@@ -113,43 +119,44 @@ describe PgSearch do
         end
 
         it "returns only results for that subclass" do
-          included = SearchableSubclassModel.create!(:content => "foo bar")
+          included = SearchableSubclassModel.create!(content: "foo bar")
 
-          SearchableSubclassModel.create!(:content => "baz")
-          SuperclassModel.create!(:content => "foo bar")
-          SuperclassModel.create!(:content => "baz")
-          NonSearchableSubclassModel.create!(:content => "foo bar")
-          NonSearchableSubclassModel.create!(:content => "baz")
+          SearchableSubclassModel.create!(content: "baz")
+          SuperclassModel.create!(content: "foo bar")
+          SuperclassModel.create!(content: "baz")
+          NonSearchableSubclassModel.create!(content: "foo bar")
+          NonSearchableSubclassModel.create!(content: "baz")
 
           expect(SuperclassModel.count).to be 6
           expect(SearchableSubclassModel.count).to be 2
 
           expect(PgSearch::Document.count).to be 2
 
-          results = PgSearch.multisearch("foo bar")
+          results = described_class.multisearch("foo bar")
 
           expect(results).to eq [included.pg_search_document]
         end
 
         it "updates an existing STI model does not create a new pg_search document" do
-          model = SearchableSubclassModel.create!(:content => "foo bar")
+          model = SearchableSubclassModel.create!(content: "foo bar")
           expect(SearchableSubclassModel.count).to eq(1)
           # We fetch the model from the database again otherwise
           # the pg_search_document from the cache is used.
           model = SearchableSubclassModel.find(model.id)
           model.content = "foo"
           model.save!
-          results = PgSearch.multisearch("foo")
+          results = described_class.multisearch("foo")
           expect(results.size).to eq(SearchableSubclassModel.count)
         end
 
-        it "reindexing works" do
-          NonSearchableSubclassModel.create!(:content => "foo bar")
-          NonSearchableSubclassModel.create!(:content => "baz")
-          expected = SearchableSubclassModel.create!(:content => "baz")
-          SuperclassModel.create!(:content => "foo bar")
-          SuperclassModel.create!(:content => "baz")
-          SuperclassModel.create!(:content => "baz2")
+        # rubocop:disable RSpec/MultipleExpectations
+        specify "reindexing works" do
+          NonSearchableSubclassModel.create!(content: "foo bar")
+          NonSearchableSubclassModel.create!(content: "baz")
+          expected = SearchableSubclassModel.create!(content: "baz")
+          SuperclassModel.create!(content: "foo bar")
+          SuperclassModel.create!(content: "baz")
+          SuperclassModel.create!(content: "baz2")
 
           expect(SuperclassModel.count).to be 6
           expect(NonSearchableSubclassModel.count).to be 2
@@ -159,22 +166,23 @@ describe PgSearch do
 
           PgSearch::Multisearch.rebuild(SearchableSubclassModel)
 
-          PgSearch::Document.clear_searchable_cache
+          clear_searchable_cache
           expect(PgSearch::Document.count).to be 1
           expect(PgSearch::Document.first.searchable.class).to be SearchableSubclassModel
           expect(PgSearch::Document.first.searchable).to eq expected
         end
+        # rubocop:enable RSpec/MultipleExpectations
 
         it "reindexing searchable STI doesn't clobber other related STI models" do
-          SearchableSubclassModel.create!(:content => "baz")
-          AnotherSearchableSubclassModel.create!(:content => "baz")
+          SearchableSubclassModel.create!(content: "baz")
+          AnotherSearchableSubclassModel.create!(content: "baz")
 
           expect(PgSearch::Document.count).to be 2
           PgSearch::Multisearch.rebuild(SearchableSubclassModel)
           expect(PgSearch::Document.count).to be 2
 
-          PgSearch::Document.clear_searchable_cache
-          classes = PgSearch::Document.all.collect {|d| d.searchable.class }
+          clear_searchable_cache
+          classes = PgSearch::Document.all.collect { |d| d.searchable.class }
           expect(classes).to include SearchableSubclassModel
           expect(classes).to include AnotherSearchableSubclassModel
         end
@@ -194,8 +202,8 @@ describe PgSearch do
 
         before do
           searchable_subclass_model = Class.new(SuperclassModel) do
-            include PgSearch
-            multisearchable :against => :content
+            include PgSearch::Model
+            multisearchable against: :content
           end
           stub_const("SearchableSubclassModel", searchable_subclass_model)
           stub_const("AnotherSearchableSubclassModel", searchable_subclass_model)
@@ -203,20 +211,20 @@ describe PgSearch do
         end
 
         it "returns only results for that subclass" do
-          included = SearchableSubclassModel.create!(:content => "foo bar")
+          included = SearchableSubclassModel.create!(content: "foo bar")
 
-          SearchableSubclassModel.create!(:content => "baz")
-          SuperclassModel.create!(:content => "foo bar")
-          SuperclassModel.create!(:content => "baz")
-          NonSearchableSubclassModel.create!(:content => "foo bar")
-          NonSearchableSubclassModel.create!(:content => "baz")
+          SearchableSubclassModel.create!(content: "baz")
+          SuperclassModel.create!(content: "foo bar")
+          SuperclassModel.create!(content: "baz")
+          NonSearchableSubclassModel.create!(content: "foo bar")
+          NonSearchableSubclassModel.create!(content: "baz")
 
           expect(SuperclassModel.count).to be 6
           expect(SearchableSubclassModel.count).to be 2
 
           expect(PgSearch::Document.count).to be 2
 
-          results = PgSearch.multisearch("foo bar")
+          results = described_class.multisearch("foo bar")
 
           expect(results).to eq [included.pg_search_document]
         end
@@ -225,57 +233,62 @@ describe PgSearch do
   end
 
   describe ".disable_multisearch" do
-    it "should temporarily disable multisearch" do
-      @multisearch_enabled_before = PgSearch.multisearch_enabled?
-      PgSearch.disable_multisearch do
-        @multisearch_enabled_inside = PgSearch.multisearch_enabled?
+    it "disables multisearch temporarily" do
+      multisearch_enabled_before = described_class.multisearch_enabled?
+      multisearch_enabled_inside = nil
+      described_class.disable_multisearch do
+        multisearch_enabled_inside = described_class.multisearch_enabled?
       end
-      @multisearch_enabled_after = PgSearch.multisearch_enabled?
+      multisearch_enabled_after = described_class.multisearch_enabled?
 
-      expect(@multisearch_enabled_before).to be(true)
-      expect(@multisearch_enabled_inside).to be(false)
-      expect(@multisearch_enabled_after).to be(true)
+      expect(multisearch_enabled_before).to be(true)
+      expect(multisearch_enabled_inside).to be(false)
+      expect(multisearch_enabled_after).to be(true)
     end
 
-    it "should reenable multisearch after an error" do
-      @multisearch_enabled_before = PgSearch.multisearch_enabled?
+    it "reenables multisearch after an error" do
+      multisearch_enabled_before = described_class.multisearch_enabled?
+      multisearch_enabled_inside = nil
       begin
-        PgSearch.disable_multisearch do
-          @multisearch_enabled_inside = PgSearch.multisearch_enabled?
+        described_class.disable_multisearch do
+          multisearch_enabled_inside = described_class.multisearch_enabled?
           raise
         end
       rescue StandardError
       end
+      multisearch_enabled_after = described_class.multisearch_enabled?
 
-      @multisearch_enabled_after = PgSearch.multisearch_enabled?
-
-      expect(@multisearch_enabled_before).to be(true)
-      expect(@multisearch_enabled_inside).to be(false)
-      expect(@multisearch_enabled_after).to be(true)
+      expect(multisearch_enabled_before).to be(true)
+      expect(multisearch_enabled_inside).to be(false)
+      expect(multisearch_enabled_after).to be(true)
     end
 
-    it "should not disable multisearch on other threads" do
+    # rubocop:disable RSpec/ExampleLength
+    it "does not disable multisearch on other threads" do
       values = Queue.new
       sync = Queue.new
       Thread.new do
-        values.push PgSearch.multisearch_enabled?
+        values.push described_class.multisearch_enabled?
         sync.pop # wait
-        values.push PgSearch.multisearch_enabled?
+        values.push described_class.multisearch_enabled?
         sync.pop # wait
-        values.push PgSearch.multisearch_enabled?
+        values.push described_class.multisearch_enabled?
       end
 
-      @multisearch_enabled_before = values.pop
-      PgSearch.disable_multisearch do
+      multisearch_enabled_before = values.pop
+      multisearch_enabled_inside = nil
+      described_class.disable_multisearch do
         sync.push :go
-        @multisearch_enabled_inside = values.pop
+        multisearch_enabled_inside = values.pop
       end
       sync.push :go
-      @multisearch_enabled_after = values.pop
+      multisearch_enabled_after = values.pop
 
-      expect(@multisearch_enabled_before).to be(true)
-      expect(@multisearch_enabled_inside).to be(true)
-      expect(@multisearch_enabled_after).to be(true)
+      expect(multisearch_enabled_before).to be(true)
+      expect(multisearch_enabled_inside).to be(true)
+      expect(multisearch_enabled_after).to be(true)
     end
+    # rubocop:enable RSpec/ExampleLength
   end
 end
+# rubocop:enable RSpec/NestedGroups

data/spec/spec_helper.rb

@@ -1,16 +1,32 @@
+# frozen_string_literal: true
+
+require 'warning'
+# Ignore Ruby 2.7 warnings from Active Record
+Warning.ignore :keyword_separation
+
+# https://github.com/grodowski/undercover#setting-up-required-lcov-reporting
 require 'simplecov'
-SimpleCov.start
+require 'simplecov-lcov'
+SimpleCov::Formatter::LcovFormatter.config.report_with_single_file = true
+SimpleCov.formatter = SimpleCov::Formatter::LcovFormatter
+SimpleCov.start do
+  add_filter(%r{^/spec/})
+  enable_coverage(:branch)
+end
+require 'undercover'
 
 require "bundler/setup"
 require "pg_search"
 
 RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
+  config.expect_with :rspec do |expects|
+    expects.syntax = :expect
   end
 
-  config.mock_with :rspec do |c|
-    c.syntax = :expect
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles = true
   end
 
   config.example_status_persistence_file_path = 'tmp/examples.txt'
@@ -20,7 +36,10 @@ require 'support/database'
 require 'support/with_model'
 
 DOCUMENTS_SCHEMA = lambda do |t|
-  t.belongs_to :searchable, :polymorphic => true, :index => true
+  t.belongs_to :searchable, polymorphic: true, index: true
   t.text :content
   t.timestamps null: false
+
+  # Used to test additional_attributes setup
+  t.text :additional_attribute_column
 end

data/spec/support/database.rb

@@ -1,27 +1,24 @@
-if defined? JRUBY_VERSION
+# frozen_string_literal: true
+
+case RUBY_PLATFORM
+when "java"
   require "activerecord-jdbc-adapter"
-  error_classes = [ActiveRecord::JDBCError]
+  ERROR_CLASS = ActiveRecord::JDBCError
 else
   require "pg"
-  error_classes = [PG::Error]
+  ERROR_CLASS = PG::Error
 end
 
-error_classes << ActiveRecord::NoDatabaseError if defined? ActiveRecord::NoDatabaseError
-
 begin
-  database_user = if ENV["TRAVIS"]
-                    "postgres"
-                  else
-                    ENV["USER"]
-                  end
-
-  ActiveRecord::Base.establish_connection(:adapter => 'postgresql',
-                                          :database => 'pg_search_test',
-                                          :username => database_user,
-                                          :min_messages => 'warning')
+  connection_options = { adapter: 'postgresql', database: 'pg_search_test', min_messages: 'warning' }
+  if ENV["CI"]
+    connection_options[:username] = 'postgres'
+    connection_options[:password] = 'postgres'
+  end
+  ActiveRecord::Base.establish_connection(connection_options)
   connection = ActiveRecord::Base.connection
   connection.execute("SELECT 1")
-rescue *error_classes => exception
+rescue ERROR_CLASS, ActiveRecord::NoDatabaseError => e
   at_exit do
     puts "-" * 80
     puts "Unable to connect to database.  Please run:"
@@ -29,31 +26,32 @@ rescue *error_classes => exception
     puts "    createdb pg_search_test"
     puts "-" * 80
   end
-  raise exception
+  raise e
 end
 
 if ENV["LOGGER"]
   require "logger"
-  ActiveRecord::Base.logger = Logger.new(STDOUT)
+  ActiveRecord::Base.logger = Logger.new($stdout)
 end
 
 def install_extension(name)
   connection = ActiveRecord::Base.connection
   extension = connection.execute "SELECT * FROM pg_catalog.pg_extension WHERE extname = '#{name}';"
   return unless extension.none?
+
   connection.execute "CREATE EXTENSION #{name};"
-rescue StandardError => exception
+rescue StandardError => e
   at_exit do
     puts "-" * 80
     puts "Please install the #{name} extension"
     puts "-" * 80
   end
-  raise exception
+  raise e
 end
 
 def install_extension_if_missing(name, query, expected_result)
   result = ActiveRecord::Base.connection.select_value(query)
-  raise "Unexpected output for #{query}: #{result.inspect}" unless result.downcase == expected_result.downcase
+  raise "Unexpected output for #{query}: #{result.inspect}" unless result.casecmp(expected_result).zero?
 rescue StandardError
   install_extension(name)
 end

data/spec/support/with_model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "with_model"
 
 RSpec.configure do |config|