pg_search 1.0.4 → 1.0.5

data/lib/pg_search/multisearchable.rb

@@ -2,7 +2,7 @@ require "active_support/core_ext/class/attribute"
 
 module PgSearch
   module Multisearchable
-    def self.included mod
+    def self.included(mod)
       mod.class_eval do
         has_one :pg_search_document,
           :as => :searchable,
@@ -10,11 +10,11 @@ module PgSearch
           :dependent => :delete
 
         after_save :update_pg_search_document,
-          :if => lambda { PgSearch.multisearch_enabled? }
+          :if => -> { PgSearch.multisearch_enabled? }
       end
     end
 
-    def update_pg_search_document
+    def update_pg_search_document # rubocop:disable Metrics/AbcSize
       if_conditions = Array(pg_search_multisearchable_options[:if])
       unless_conditions = Array(pg_search_multisearchable_options[:unless])
 

data/lib/pg_search/normalizer.rb

@@ -4,7 +4,7 @@ module PgSearch
       @config = config
     end
 
-    def add_normalization(sql_expression)
+    def add_normalization(sql_expression) # rubocop:disable Metrics/AbcSize
       return sql_expression unless config.ignore.include?(:accents)
 
       if config.postgresql_version < 90000

data/lib/pg_search/scope_options.rb

@@ -13,22 +13,12 @@ module PgSearch
     end
 
     def apply(scope)
-      unless scope.instance_variable_get(:@pg_search_scope_applied_count)
-        scope = if ::ActiveRecord::VERSION::STRING < "4.0.0"
-                  scope.scoped
-                else
-                  scope.all.spawn
-                end
-      end
-
-      alias_id = scope.instance_variable_get(:@pg_search_scope_applied_count) || 0
-      scope.instance_variable_set(:@pg_search_scope_applied_count, alias_id + 1)
-
-      aka = pg_search_alias scope, alias_id
+      scope = include_table_aliasing_for_rank(scope)
+      rank_table_alias = scope.pg_search_rank_table_alias(:include_counter)
 
       scope
-        .joins(rank_join(aka))
-        .order("#{aka}.rank DESC, #{order_within_rank}")
+        .joins(rank_join(rank_table_alias))
+        .order("#{rank_table_alias}.rank DESC, #{order_within_rank}")
         .extend(DisableEagerLoading)
         .extend(WithPgSearchRank)
     end
@@ -43,11 +33,33 @@ module PgSearch
     module WithPgSearchRank
       def with_pg_search_rank
         scope = self
-        scope = scope.select("*") unless scope.select_values.any?
-        arel_table = scope.instance_variable_get(:@table)
-        aka = "pg_search_#{arel_table.name}"
+        scope = scope.select("#{table_name}.*") unless scope.select_values.any?
+        scope.select("#{pg_search_rank_table_alias}.rank AS pg_search_rank")
+      end
+    end
 
-        scope.select("#{aka}.rank AS pg_search_rank")
+    module PgSearchRankTableAliasing
+      def pg_search_rank_table_alias(include_counter = false)
+        components = [arel_table.name]
+        if include_counter
+          count = pg_search_scope_application_count_plus_plus
+          components << count if count > 0
+        end
+
+        Configuration.alias(components)
+      end
+
+      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
       end
     end
 
@@ -67,13 +79,19 @@ module PgSearch
     end
 
     def conditions
-      config.features.reject do |feature_name, feature_options|
+      conditions = config.features.reject do |_feature_name, feature_options|
         feature_options && feature_options[:sort_only]
-      end.map do |feature_name, feature_options|
+      end
+
+      conditions.map! do |feature_name, _feature_options|
         feature_for(feature_name).conditions
-      end.inject do |accumulator, expression|
+      end
+
+      conditions = conditions.inject do |accumulator, expression|
         Arel::Nodes::Or.new(accumulator, expression)
-      end.to_sql
+      end
+
+      conditions.to_sql
     end
 
     def order_within_rank
@@ -85,7 +103,7 @@ module PgSearch
     end
 
     def subquery_join
-      if config.associations.any?
+      if config.associations.any? # rubocop:disable Style/GuardClause
         config.associations.map do |association|
           association.join(primary_key)
         end.join(' ')
@@ -98,7 +116,7 @@ module PgSearch
       :trigram => Features::Trigram
     }
 
-    def feature_for(feature_name)
+    def feature_for(feature_name) # rubocop:disable Metrics/AbcSize
       feature_name = feature_name.to_sym
       feature_class = FEATURE_CLASSES[feature_name]
 
@@ -121,15 +139,18 @@ module PgSearch
       end
     end
 
-    def pg_search_alias(scope, n)
-      arel_table = scope.instance_variable_get(:@table)
-      prefix = "pg_search_#{arel_table.name}"
-
-      0 == n ? prefix : "#{prefix}_#{n}"
+    def rank_join(rank_table_alias)
+      "INNER JOIN (#{subquery.to_sql}) AS #{rank_table_alias} ON #{primary_key} = #{rank_table_alias}.pg_search_id"
     end
 
-    def rank_join(aka)
-      "INNER JOIN (#{subquery.to_sql}) #{aka} ON #{primary_key} = #{aka}.pg_search_id"
+    def include_table_aliasing_for_rank(scope)
+      if scope.included_modules.include?(PgSearchRankTableAliasing)
+        scope
+      else
+        (::ActiveRecord::VERSION::MAJOR < 4 ? scope.scoped : scope.all.spawn).tap do |new_scope|
+          new_scope.class_eval { include PgSearchRankTableAliasing }
+        end
+      end
     end
   end
 end

data/lib/pg_search/tasks.rb

@@ -4,7 +4,7 @@ require 'pg_search'
 namespace :pg_search do
   namespace :multisearch do
     desc "Rebuild PgSearch multisearch records for a given model"
-    task :rebuild, [:model,:schema] => :environment do |task, args|
+    task :rebuild, [:model,:schema] => :environment do |_task, args|
       raise ArgumentError, <<-MESSAGE.strip_heredoc unless args.model
         You must pass a model as an argument.
         Example: rake pg_search:multisearch:rebuild[BlogPost]

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "1.0.4".freeze
+  VERSION = "1.0.5".freeze
 end

data/pg_search.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Grant Hutchins", "Case Commons, LLC"]
   s.email       = ["gems@nertzy.com", "casecommons-dev@googlegroups.com"]
   s.homepage    = "https://github.com/Casecommons/pg_search"
-  s.summary     = %q{PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search}
-  s.description = %q{PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search}
+  s.summary     = %q(PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search)
+  s.description = %q(PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search)
   s.licenses    = ["MIT"]
 
   s.files         = `git ls-files`.split("\n")
@@ -23,7 +23,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'pry'
-  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'rspec', '>= 3.3'
   s.add_development_dependency 'with_model', '>= 1.2'
   s.add_development_dependency 'rubocop', '>= 0.30.0'
 

data/spec/.rubocop.yml

@@ -0,0 +1,14 @@
+inherit_from:
+  - ../.rubocop.yml
+
+Metrics/LineLength:
+  Enabled: false
+
+Lint/HandleExceptions:
+  Enabled: false
+
+Lint/UselessAssignment:
+  Enabled: false
+
+Style/BlockDelimiters:
+  Enabled: false

data/spec/integration/associations_spec.rb

@@ -67,7 +67,7 @@ describe PgSearch do
           ModelWithBelongsTo.create!(:title => 'abcdef')
         ]
         excluded = ModelWithBelongsTo.create!(:title => 'mnopqr',
-                                                 :another_model => AssociatedModel.create!(:title => 'stuvwx'))
+                                              :another_model => AssociatedModel.create!(:title => 'stuvwx'))
 
         results = ModelWithBelongsTo.with_associated('abcdef')
         expect(results.map(&:title)).to match_array(included.map(&:title))
@@ -99,17 +99,17 @@ describe PgSearch do
       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')
-        ]),
+            AssociatedModelWithHasMany.create!(:title => 'foo'),
+            AssociatedModelWithHasMany.create!(:title => 'bar')
+          ]),
           ModelWithHasMany.create!(:title => 'ghijkl', :other_models => [
-                                      AssociatedModelWithHasMany.create!(:title => 'foo bar'),
-                                      AssociatedModelWithHasMany.create!(:title => 'mnopqr')
-        ]),
+            AssociatedModelWithHasMany.create!(:title => 'foo bar'),
+            AssociatedModelWithHasMany.create!(:title => 'mnopqr')
+          ]),
           ModelWithHasMany.create!(:title => 'foo bar')
         ]
         excluded = ModelWithHasMany.create!(:title => 'stuvwx', :other_models => [
-                                               AssociatedModelWithHasMany.create!(:title => 'abcdef')
+          AssociatedModelWithHasMany.create!(:title => 'abcdef')
         ])
 
         results = ModelWithHasMany.with_associated('foo bar')
@@ -137,7 +137,6 @@ describe PgSearch do
         expect(results.map(&:title)).to match_array(included.map(&:title))
         expect(results).not_to include(excluded)
       end
-
     end
 
     context "across multiple associations" do
@@ -165,10 +164,16 @@ describe PgSearch do
 
           model do
             include PgSearch
-            has_many :models_of_first_type, :class_name => 'FirstAssociatedModel', :foreign_key => 'ModelWithManyAssociations_id'
-            belongs_to :model_of_second_type, :class_name => 'SecondAssociatedModel'
 
-            pg_search_scope :with_associated, :against => :title,
+            has_many :models_of_first_type,
+              :class_name => 'FirstAssociatedModel',
+              :foreign_key => 'ModelWithManyAssociations_id'
+
+            belongs_to :model_of_second_type,
+              :class_name => 'SecondAssociatedModel'
+
+            pg_search_scope :with_associated,
+              :against => :title,
               :associated_against => {:models_of_first_type => :title, :model_of_second_type => :title}
           end
         end
@@ -179,20 +184,20 @@ describe PgSearch do
 
           included = [
             ModelWithManyAssociations.create!(:title => 'abcdef', :models_of_first_type => [
-                                              FirstAssociatedModel.create!(:title => 'foo'),
-                                              FirstAssociatedModel.create!(:title => 'bar')
-          ]),
+              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')
-          ]),
+              FirstAssociatedModel.create!(:title => 'foo bar'),
+              FirstAssociatedModel.create!(:title => 'mnopqr')
+            ]),
             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')
-          ]),
+              FirstAssociatedModel.create!(:title => 'abcdef')
+            ]),
             ModelWithManyAssociations.create!(:title => 'qwerty', :model_of_second_type => unmatching_second)
           ]
 
@@ -219,36 +224,42 @@ describe PgSearch do
 
           model do
             include PgSearch
-            has_many :things, :class_name => 'DoublyAssociatedModel', :foreign_key => 'ModelWithDoubleAssociation_id'
-            has_many :thingamabobs, :class_name => 'DoublyAssociatedModel', :foreign_key => 'ModelWithDoubleAssociation_again_id'
+
+            has_many :things,
+              :class_name => 'DoublyAssociatedModel',
+              :foreign_key => 'ModelWithDoubleAssociation_id'
+
+            has_many :thingamabobs,
+              :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')
-          ]),
+              DoublyAssociatedModel.create!(:title => 'foo'),
+              DoublyAssociatedModel.create!(:title => 'bar')
+            ]),
             ModelWithDoubleAssociation.create!(:title => 'ghijkl', :things => [
-                                                  DoublyAssociatedModel.create!(:title => 'foo bar'),
-                                                  DoublyAssociatedModel.create!(:title => 'mnopqr')
-          ]),
+              DoublyAssociatedModel.create!(:title => 'foo bar'),
+              DoublyAssociatedModel.create!(:title => 'mnopqr')
+            ]),
             ModelWithDoubleAssociation.create!(:title => 'foo bar'),
             ModelWithDoubleAssociation.create!(:title => 'qwerty', :thingamabobs => [
-                                                  DoublyAssociatedModel.create!(:title => "foo bar")
-          ])
+              DoublyAssociatedModel.create!(:title => "foo bar")
+            ])
           ]
           excluded = [
             ModelWithDoubleAssociation.create!(:title => 'stuvwx', :things => [
-                                                  DoublyAssociatedModel.create!(:title => 'abcdef')
-          ]),
+              DoublyAssociatedModel.create!(:title => 'abcdef')
+            ]),
             ModelWithDoubleAssociation.create!(:title => 'qwerty', :thingamabobs => [
-                                                  DoublyAssociatedModel.create!(:title => "uiop")
-          ])
+              DoublyAssociatedModel.create!(:title => "uiop")
+            ])
           ]
 
           results = ModelWithDoubleAssociation.with_associated('foo bar')
@@ -309,7 +320,6 @@ describe PgSearch do
         included.each { |object| expect(results).to include(object) }
         excluded.each { |object| expect(results).not_to include(object) }
       end
-
     end
 
     context "against non-text columns" do
@@ -414,13 +424,13 @@ describe PgSearch do
       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")

data/spec/integration/pg_search_spec.rb

@@ -5,11 +5,24 @@ describe "an Active Record model which includes PgSearch" do
     table do |t|
       t.string 'title'
       t.text 'content'
+      t.integer 'parent_model_id'
       t.integer 'importance'
     end
 
     model do
       include PgSearch
+      belongs_to :parent_model
+    end
+  end
+  with_model :ParentModel do
+    table do |t|
+      t.boolean :active, default: true
+    end
+
+    model do
+      include PgSearch
+      has_many :models_with_pg_search
+      scope :active, -> { where(active: true) }
     end
   end
 
@@ -52,7 +65,7 @@ describe "an Active Record model which includes PgSearch" do
       context "dynamically" do
         it "raises an exception when invoked" do
           ModelWithPgSearch.pg_search_scope :with_unknown_option,
-            lambda { |*| {:against => :content, :foo => :bar} }
+            ->(*) { {:against => :content, :foo => :bar} }
 
           expect {
             ModelWithPgSearch.with_unknown_option("foo")
@@ -75,7 +88,7 @@ describe "an Active Record model which includes PgSearch" do
       context "dynamically" do
         it "raises an exception when invoked" do
           ModelWithPgSearch.pg_search_scope :with_unknown_using,
-            lambda { |*| {:against => :content, :using => :foo} }
+            ->(*) { {:against => :content, :using => :foo} }
 
           expect {
             ModelWithPgSearch.with_unknown_using("foo")
@@ -98,7 +111,7 @@ describe "an Active Record model which includes PgSearch" do
       context "dynamically" do
         it "raises an exception when invoked" do
           ModelWithPgSearch.pg_search_scope :with_unknown_ignoring,
-            lambda { |*| {:against => :content, :ignoring => :foo} }
+            ->(*) { {:against => :content, :ignoring => :foo} }
 
           expect {
             ModelWithPgSearch.with_unknown_ignoring("foo")
@@ -117,8 +130,7 @@ describe "an Active Record model which includes PgSearch" do
 
         context "dynamically" do
           it "raises an exception when invoked" do
-            ModelWithPgSearch.pg_search_scope :with_unknown_ignoring,
-              lambda { |*| {} }
+            ModelWithPgSearch.pg_search_scope :with_unknown_ignoring, ->(*){ {} }
 
             expect {
               ModelWithPgSearch.with_unknown_ignoring("foo")
@@ -209,10 +221,10 @@ describe "an Active Record model which includes PgSearch" do
             include PgSearch
             has_many :houses
             pg_search_scope :named, against: [:name]
-            scope :with_house_in_city, ->(city) {
+            scope :with_house_in_city, lambda { |city|
               joins(:houses).where(House.table_name.to_sym => {city: city})
             }
-            scope :house_search_city, ->(query) {
+            scope :house_search_city, lambda { |query|
               joins(:houses).merge(House.search_city(query))
             }
           end
@@ -314,7 +326,7 @@ describe "an Active Record model which includes PgSearch" do
 
         returned_record = records_with_only_id.first
 
-        expect(returned_record.attributes).to eq({"id" => record.id})
+        expect(returned_record.attributes).to eq("id" => record.id)
       end
 
       unless ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 2
@@ -332,7 +344,7 @@ describe "an Active Record model which includes PgSearch" do
         twice = ModelWithPgSearch.create!(:content => 'foo foo')
 
         records = ModelWithPgSearch.search_content('foo')
-                  .where("pg_search_#{ModelWithPgSearch.table_name}.rank > 0.07")
+                  .where("#{PgSearch::Configuration.alias(ModelWithPgSearch.table_name)}.rank > 0.07")
 
         expect(records).to eq [twice]
       end
@@ -394,6 +406,18 @@ describe "an Active Record model which includes PgSearch" do
         expect(results).to eq([winner, loser])
       end
 
+      it 'allows pg_search_rank along with a join' do
+        parent1 = ParentModel.create!(id: 98)
+        parent2 = ParentModel.create!(id: 99)
+        loser = ModelWithPgSearch.create!(:content => 'foo', parent_model: parent2)
+        winner = ModelWithPgSearch.create!(:content => 'foo foo', parent_model: parent1)
+
+        results = ModelWithPgSearch.joins(:parent_model).merge(ParentModel.active).search_content("foo").with_pg_search_rank
+        expect(results.map(&:id)).to eq [winner.id, loser.id]
+        expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
+        expect(results).to eq([winner, loser])
+      end
+
       it "returns results that match sorted by primary key for records that rank the same" do
         sorted_results = [ModelWithPgSearch.create!(:content => 'foo'),
                           ModelWithPgSearch.create!(:content => 'foo')].sort_by(&:id)
@@ -484,7 +508,7 @@ describe "an Active Record model which includes PgSearch" do
         in_title = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
         in_content = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
 
-        results  = ModelWithPgSearch.search_title_and_content('foo')
+        results = ModelWithPgSearch.search_title_and_content('foo')
         expect(results).to match_array([in_title, in_content])
       end
 
@@ -541,10 +565,10 @@ describe "an Active Record model which includes PgSearch" do
     context "using tsearch" do
       before do
         ModelWithPgSearch.pg_search_scope :search_title_with_prefixes,
-                                          :against => :title,
-                                          :using => {
-                                            :tsearch => {:prefix => true}
-                                          }
+          :against => :title,
+          :using => {
+            :tsearch => {:prefix => true}
+          }
       end
 
       if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
@@ -698,16 +722,16 @@ describe "an Active Record model which includes PgSearch" do
               :tsearch => {:any_word => true}
             }
 
-            ModelWithPgSearch.pg_search_scope :search_title_with_all_words,
-              :against => :title
+          ModelWithPgSearch.pg_search_scope :search_title_with_all_words,
+            :against => :title
         end
 
         it "returns all results containing any word in their title" do
-          numbers = %w(one two three four).map{|number| ModelWithPgSearch.create!(:title => number)}
+          numbers = %w[one two three four].map{|number| ModelWithPgSearch.create!(:title => number)}
 
           results = ModelWithPgSearch.search_title_with_any_word("one two three four")
 
-          expect(results.map(&:title)).to eq(%w(one two three four))
+          expect(results.map(&:title)).to eq(%w[one two three four])
 
           results = ModelWithPgSearch.search_title_with_all_words("one two three four")
 
@@ -1167,7 +1191,6 @@ describe "an Active Record model which includes PgSearch" do
             :against => :content,
             :ranked_by => ":tsearch"
 
-
           once = ModelWithPgSearch.create!(:content => 'foo bar')
           twice = ModelWithPgSearch.create!(:content => 'foo foo')
 
@@ -1227,17 +1250,4 @@ describe "an Active Record model which includes PgSearch" do
       end
     end
   end
-
-  describe ".multisearchable" do
-    it "should include the Multisearchable module" do
-      expect(ModelWithPgSearch).to receive(:include).with(PgSearch::Multisearchable)
-      ModelWithPgSearch.multisearchable
-    end
-
-    it "should set pg_search_multisearchable_options on the class" do
-      options = double(:options)
-      ModelWithPgSearch.multisearchable(options)
-      expect(ModelWithPgSearch.pg_search_multisearchable_options).to eq(options)
-    end
-  end
 end