Merge upstream PR Casecommons#542

Author: ydev-truss

README.md

@@ -1203,6 +1203,19 @@ shirt_brands = ShirtBrand.search_by_name("Penguin")
   .group("shirt_brands.id, #{PgSearch::Configuration.alias('shirt_brands')}.rank")
 ```
 
+#### Scoping search rank subqueries
+
+It may be necessary to limit the scope of a rank subquery for performance reasons.
+The subquery scope relation object is accessed by passing a block to the search
+method.
+
+```ruby
+shirt_manufacturer = ShirtManufacturer.find_by(name: "Hypercolor Sportswear Co")
+shirt_brands = ShirtBrand.search_by_name("Penguin") do |subquery_relation|
+  subquery_relation.where(shirt_manufacturer: shirt_manufacturer)
+end.with_pg_search_rank
+```
+
 ## ATTRIBUTIONS
 
 PgSearch would not have been possible without inspiration from texticle (now renamed

lib/pg_search/model.rb

@@ -14,10 +14,10 @@ def pg_search_scope(name, options)
           raise ArgumentError, "pg_search_scope expects a Hash or Proc"
         end
 
-        define_singleton_method(name) do |*args|
+        define_singleton_method(name) do |*args, &block|
           config = Configuration.new(options_proc.call(*args), self)
           scope_options = ScopeOptions.new(config)
-          scope_options.apply(self)
+          scope_options.apply(self, &block)
         end
       end
 

lib/pg_search/scope_options.rb

@@ -12,12 +12,12 @@ def initialize(config)
       @feature_options = config.feature_options
     end
 
-    def apply(scope)
+    def apply(scope, &block)
       scope = include_table_aliasing_for_rank(scope)
       rank_table_alias = scope.pg_search_rank_table_alias(include_counter: true)
 
       scope
-        .joins(rank_join(rank_table_alias))
+        .joins(rank_join(rank_table_alias, &block))
         .order(Arel.sql("#{rank_table_alias}.rank DESC, #{order_within_rank}"))
         .extend(WithPgSearchRank)
         .extend(WithPgSearchHighlight[feature_for(:tsearch)])
@@ -80,14 +80,16 @@ def increment_counter
     delegate :connection, :quoted_table_name, to: :model
 
     def subquery
-      model
+      relation = model
         .unscoped
         .select("#{primary_key} AS pg_search_id")
         .select("#{rank} AS rank")
         .joins(subquery_join)
         .where(conditions)
         .limit(nil)
         .offset(nil)
+
+      block_given? ? yield(relation) : relation
     end
 
     def conditions
@@ -163,8 +165,8 @@ def rank
       end
     end
 
-    def rank_join(rank_table_alias)
-      "INNER JOIN (#{subquery.to_sql}) AS #{rank_table_alias} ON #{primary_key} = #{rank_table_alias}.pg_search_id"
+    def rank_join(rank_table_alias, &block)
+      "INNER JOIN (#{subquery(&block).to_sql}) AS #{rank_table_alias} ON #{primary_key} = #{rank_table_alias}.pg_search_id"
     end
 
     def include_table_aliasing_for_rank(scope)

spec/integration/pg_search_spec.rb

@@ -439,6 +439,20 @@
         expect(results).to eq([winner, loser])
       end
 
+      it "is filterable in sub-select when sorted by rank" do
+        loser = ModelWithPgSearch.create!(content: "foo", parent_model_id: 1)
+        winner = ModelWithPgSearch.create!(content: "foo foo", parent_model_id: 1)
+        filtered = ModelWithPgSearch.create!(content: "foo foo foo", parent_model_id: 2)
+
+
+        results = ModelWithPgSearch.search_content("foo") do |subquery_relation|
+          subquery_relation.where(parent_model_id: 1)
+        end.with_pg_search_rank
+
+        expect(results).to_not include(filtered)
+        expect(results).to eq([winner, loser])
+      end
+
       it "preserves column selection when with_pg_search_rank is chained after a select()" do
         ModelWithPgSearch.create!(title: "foo", content: "bar")