pg_search 2.1.4 → 2.1.5

data/Rakefile

@@ -11,8 +11,4 @@ RuboCop::RakeTask.new do |t|
   t.options = %w[--display-cop-names]
 end
 
-task :codeclimate do
-  sh 'bin/codeclimate-test-reporter' if ENV['CODECLIMATE_REPO_TOKEN']
-end
-
-task :default => %w[spec codeclimate rubocop]
+task default: %w[spec rubocop]

data/lib/pg_search.rb

@@ -27,7 +27,7 @@ module PgSearch
       options_proc = if options.respond_to?(:call)
                        options
                      elsif options.respond_to?(:merge)
-                       ->(query) { { :query => query }.merge(options) }
+                       ->(query) { { query: query }.merge(options) }
                      else
                        raise ArgumentError, 'pg_search_scope expects a Hash or Proc'
                      end

data/lib/pg_search/configuration.rb

@@ -80,7 +80,7 @@ module PgSearch
     attr_reader :options
 
     def default_options
-      { :using => :tsearch }
+      { using: :tsearch }
     end
 
     VALID_KEYS = %w[
@@ -88,7 +88,7 @@ module PgSearch
     ].map(&:to_sym)
 
     VALID_VALUES = {
-      :ignoring => [:accents]
+      ignoring: [:accents]
     }.freeze
 
     def assert_valid_options(options)

data/lib/pg_search/document.rb

@@ -7,7 +7,7 @@ module PgSearch
     include PgSearch
 
     self.table_name = 'pg_search_documents'
-    belongs_to :searchable, :polymorphic => true
+    belongs_to :searchable, polymorphic: true
 
     # The logger might not have loaded yet.
     # https://github.com/Casecommons/pg_search/issues/26
@@ -19,10 +19,10 @@ module PgSearch
       options = if PgSearch.multisearch_options.respond_to?(:call)
                   PgSearch.multisearch_options.call(*args)
                 else
-                  { :query => args.first }.merge(PgSearch.multisearch_options)
+                  { query: args.first }.merge(PgSearch.multisearch_options)
                 end
 
-      { :against => :content }.merge(options)
+      { against: :content }.merge(options)
     }
   end
 end

data/lib/pg_search/features/dmetaphone.rb

@@ -5,7 +5,7 @@ module PgSearch
     class DMetaphone
       def initialize(query, options, columns, model, normalizer)
         dmetaphone_normalizer = Normalizer.new(normalizer)
-        options = (options || {}).merge(:dictionary => 'simple')
+        options = (options || {}).merge(dictionary: 'simple')
         @tsearch = TSearch.new(query, options, columns, model, dmetaphone_normalizer)
       end
 

data/lib/pg_search/features/feature.rb

@@ -10,7 +10,7 @@ module PgSearch
         %i[only sort_only]
       end
 
-      delegate :connection, :quoted_table_name, :to => :'@model'
+      delegate :connection, :quoted_table_name, to: :'@model'
 
       def initialize(query, options, all_columns, model, normalizer)
         @query = query

data/lib/pg_search/migration/templates/create_pg_search_documents.rb.erb

@@ -3,7 +3,7 @@ class CreatePgSearchDocuments < ActiveRecord::Migration<%= migration_version %>
     say_with_time("Creating table for pg_search multisearch") do
       create_table :pg_search_documents do |t|
         t.text :content
-        t.belongs_to :searchable, :polymorphic => true, :index => true
+        t.belongs_to :searchable, polymorphic: true, index: true
         t.timestamps null: false
       end
     end

data/lib/pg_search/multisearch.rb

@@ -7,7 +7,7 @@ module PgSearch
     class << self
       def rebuild(model, clean_up = true)
         model.transaction do
-          PgSearch::Document.where(:searchable_type => model.base_class.name).delete_all if clean_up
+          PgSearch::Document.where(searchable_type: model.base_class.name).delete_all if clean_up
           Rebuilder.new(model).rebuild
         end
       end

data/lib/pg_search/multisearchable.rb

@@ -7,12 +7,12 @@ module PgSearch
     def self.included(mod)
       mod.class_eval do
         has_one :pg_search_document,
-          :as => :searchable,
-          :class_name => "PgSearch::Document",
-          :dependent => :delete
+          as: :searchable,
+          class_name: "PgSearch::Document",
+          dependent: :delete
 
         after_save :update_pg_search_document,
-          :if => -> { PgSearch.multisearch_enabled? }
+          if: -> { PgSearch.multisearch_enabled? }
       end
     end
 

data/lib/pg_search/scope_options.rb

@@ -69,7 +69,7 @@ module PgSearch
       def pg_search_rank_table_alias(include_counter = false)
         components = [arel_table.name]
         if include_counter
-          count = pg_search_scope_application_count_plus_plus
+          count = increment_counter
           components << count if count > 0
         end
 
@@ -78,22 +78,16 @@ module PgSearch
 
       private
 
-      attr_writer :pg_search_scope_application_count
-
-      def pg_search_scope_application_count
-        @pg_search_scope_application_count ||= 0
-      end
-
-      def pg_search_scope_application_count_plus_plus
-        count = pg_search_scope_application_count
-        self.pg_search_scope_application_count = pg_search_scope_application_count + 1
-        count
+      def increment_counter
+        @counter ||= 0
+      ensure
+        @counter += 1
       end
     end
 
     private
 
-    delegate :connection, :quoted_table_name, :to => :model
+    delegate :connection, :quoted_table_name, to: :model
 
     def subquery
       model
@@ -107,19 +101,10 @@ module PgSearch
     end
 
     def conditions
-      conditions = config.features.reject do |_feature_name, feature_options|
-        feature_options && feature_options[:sort_only]
-      end
-
-      conditions.map! do |feature_name, _feature_options|
-        feature_for(feature_name).conditions
-      end
-
-      conditions = conditions.inject do |accumulator, expression|
-        Arel::Nodes::Or.new(accumulator, expression)
-      end
-
-      conditions.to_sql
+      config.features
+            .reject { |_feature_name, feature_options| feature_options && feature_options[:sort_only] }
+            .map { |feature_name, _feature_options| feature_for(feature_name).conditions }
+            .inject { |accumulator, expression| Arel::Nodes::Or.new(accumulator, expression) }
     end
 
     def order_within_rank
@@ -139,9 +124,9 @@ module PgSearch
     end
 
     FEATURE_CLASSES = {
-      :dmetaphone => Features::DMetaphone,
-      :tsearch => Features::TSearch,
-      :trigram => Features::Trigram
+      dmetaphone: Features::DMetaphone,
+      tsearch: Features::TSearch,
+      trigram: Features::Trigram
     }.freeze
 
     def feature_for(feature_name)

data/lib/pg_search/version.rb

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

data/pg_search.gemspec

@@ -21,7 +21,6 @@ Gem::Specification.new do |s|
   s.add_dependency 'activerecord', '>= 4.2'
   s.add_dependency 'activesupport', '>= 4.2'
 
-  s.add_development_dependency 'codeclimate-test-reporter'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '>= 3.3'
@@ -29,5 +28,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'with_model', '>= 1.2'
 
-  s.required_ruby_version = '>= 2.3'
+  s.required_ruby_version = '>= 2.4'
 end

data/spec/integration/associations_spec.rb

@@ -14,25 +14,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'
+          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')
@@ -56,20 +56,20 @@ describe PgSearch do
 
         model do
           include PgSearch
-          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')
         expect(results.map(&:title)).to match_array(included.map(&:title))
@@ -92,26 +92,26 @@ describe PgSearch do
 
         model do
           include PgSearch
-          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')
@@ -120,14 +120,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')
           ])
         ]
 
@@ -166,39 +166,39 @@ describe PgSearch do
             include PgSearch
 
             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')
@@ -225,39 +225,39 @@ describe PgSearch do
             include PgSearch
 
             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")
             ])
           ]
 
@@ -283,32 +283,32 @@ describe PgSearch do
 
         model do
           include PgSearch
-          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
         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"
             )
           )
         ]
@@ -343,13 +343,13 @@ describe PgSearch do
       end
 
       it "should cast the columns to text" do
-        associated = AssociatedModel.create!(:number => 123)
+        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')
@@ -367,7 +367,7 @@ describe PgSearch do
         model do
           has_many :children
           include PgSearch
-          pg_search_scope :search_name, :against => :name
+          pg_search_scope :search_name, against: :name
         end
       end
 
@@ -383,8 +383,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
@@ -412,24 +412,24 @@ describe PgSearch do
         include PgSearch
         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")
+      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")
@@ -456,7 +456,7 @@ describe PgSearch do
 
       model do
         include PgSearch
-        pg_search_scope :search, :against => :title, :using => %i[tsearch trigram]
+        pg_search_scope :search, against: :title, using: %i[tsearch trigram]
       end
     end
 
@@ -466,13 +466,13 @@ describe PgSearch do
       another_company = Company.create!
 
       included = [
-        Position.create!(:company_id => company.id, :title => "teller 1")
+        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")
+        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')
@@ -497,7 +497,7 @@ describe PgSearch do
 
       model do
         include PgSearch
-        pg_search_scope :search, :against => :title, :using => %i[tsearch trigram]
+        pg_search_scope :search, against: :title, using: %i[tsearch trigram]
       end
     end