Merge pull request #3597 from projectblacklight/facet-builder

Extract FacetSearchBuilder

Author: jcoyne

app/controllers/concerns/blacklight/catalog.rb

@@ -9,6 +9,7 @@ module Blacklight::Catalog
   include Blacklight::Configurable
   include Blacklight::SearchContext
   include Blacklight::Searchable
+  include Blacklight::Facetable
 
   # The following code is executed when someone includes blacklight::catalog in their
   # own controller.
@@ -84,11 +85,11 @@ def facet
     raise ActionController::RoutingError, 'Not Found' unless @facet
 
     @response = if params[:query_fragment].present?
-                  search_service.facet_suggest_response(@facet.key, params[:query_fragment])
+                  facet_search_service.facet_suggest_response(@facet.key, params[:query_fragment])
                 else
-                  search_service.facet_field_response(@facet.key)
+                  facet_search_service.facet_field_response(@facet.key)
                 end
-    # @display_facet is a Blacklight::Solr::Response::Facets::FacetField
+
     @display_facet = @response.aggregations[@facet.field]
 
     # @presenter is a Blacklight::FacetFieldPresenter

app/controllers/concerns/blacklight/facetable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# The Facetable module can be included onto classes that need to initialize a FacetSearchService.
+# There are two dependencies you must provide on the including class. Typically these
+# would be provided by Blacklight::Controller
+#  1. search_state
+#  2. blacklight_config
+#
+# Additionally, the including class may override the facet_search_service_context method to provide
+# further context to the SearchService. For example you could override this to provide the
+# currently signed in user.
+module Blacklight::Facetable
+  extend ActiveSupport::Concern
+
+  included do
+    # Which class to use for the search service. You can subclass SearchService if you
+    # want to override any of the methods (e.g. SearchService#fetch)
+    class_attribute :facet_search_service_class
+    self.facet_search_service_class = Blacklight::FacetSearchService
+  end
+
+  # @return [Blacklight::FacetSearchService]
+  def facet_search_service
+    facet_search_service_class.new(config: blacklight_config, search_state: search_state, user_params: search_state.to_h, **facet_search_service_context)
+  end
+
+  # Override this method on the class that includes Blacklight::Facetable to provide more context to the search service if necessary.
+  # For example, if your search builder needs to be aware of the current user, override this method to return a hash including the current user.
+  # Then the search builder could use some property about the current user to construct a constraint on the search.
+  # @return [Hash] a hash of context information to pass through to the search service
+  def facet_search_service_context
+    search_service_context
+  end
+end

app/models/facet_search_builder.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class FacetSearchBuilder < Blacklight::FacetSearchBuilder
+  include Blacklight::Solr::FacetSearchBuilderBehavior
+end

app/services/blacklight/facet_search_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# FacetSearchService returns a facet list from the repository. This is for drawing the "more facets" modal
+module Blacklight
+  class FacetSearchService
+    def initialize(config:, search_state:, search_builder_class: config.facet_search_builder_class, **context)
+      @blacklight_config = config
+      @search_state = search_state
+      @user_params = @search_state.params
+      @search_builder_class = search_builder_class
+      @context = context
+    end
+
+    # The blacklight_config + controller are accessed by the search_builder
+    attr_reader :blacklight_config, :context
+
+    def search_builder
+      search_builder_class.new(self)
+    end
+
+    def search_state_class
+      @search_state.class
+    end
+
+    ##
+    # Get the solr response when retrieving only a single facet field
+    # @return [Blacklight::Solr::Response] the solr response
+    def facet_field_response(facet_field, extra_controller_params = {})
+      query = search_builder.with(search_state).facet(facet_field)
+      repository.search(params: query.merge(extra_controller_params))
+    end
+
+    def facet_suggest_response(facet_field, facet_suggestion_query, extra_controller_params = {})
+      query = search_builder.with(search_state).facet(facet_field).facet_suggestion_query(facet_suggestion_query)
+      repository.search(params: query.merge(extra_controller_params))
+    end
+
+    private
+
+    attr_reader :search_builder_class, :search_state
+
+    delegate :repository, to: :blacklight_config
+  end
+end

lib/blacklight/abstract_search_builder.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Blacklight
+  ##
+  # Blacklight's SearchBuilder converts blacklight request parameters into
+  # query parameters appropriate for search index. It does so by evaluating a
+  # chain of processing methods to populate a result hash (see {#to_hash}).
+  class AbstractSearchBuilder
+    class_attribute :default_processor_chain
+    self.default_processor_chain = []
+
+    attr_reader :processor_chain, :search_state, :blacklight_params
+
+    # @overload initialize(scope)
+    #   @param [Object] scope scope the scope where the filter methods reside in.
+    # @overload initialize(processor_chain, scope)
+    #   @param [List<Symbol>,TrueClass] processor_chain options a list of filter methods to run or true, to use the default methods
+    #   @param [Object] scope the scope where the filter methods reside in.
+    def initialize(*options)
+      case options.size
+      when 1
+        @processor_chain = default_processor_chain.dup
+        @scope = options.first
+      when 2
+        @processor_chain, @scope = options
+      else
+        raise ArgumentError, "wrong number of arguments. (#{options.size} for 1..2)"
+      end
+
+      @blacklight_params = {}
+      search_state_class = @scope.try(:search_state_class) || Blacklight::SearchState
+      @search_state = search_state_class.new(@blacklight_params, @scope&.blacklight_config, @scope)
+      @additional_filters = {}
+      @merged_params = {}
+      @reverse_merged_params = {}
+    end
+
+    delegate :blacklight_config, to: :scope
+
+    ##
+    # Set the parameters to pass through the processor chain
+    def with(blacklight_params_or_search_state = {})
+      params_will_change!
+      @search_state = blacklight_params_or_search_state.is_a?(Blacklight::SearchState) ? blacklight_params_or_search_state : @search_state.reset(blacklight_params_or_search_state)
+      @blacklight_params = @search_state.params.dup
+      self
+    end
+
+    # sets the facet that this query pertains to, for the purpose of facet pagination
+    def facet=(value)
+      params_will_change!
+      @facet = value
+    end
+
+    # @param [Object] value
+    def facet(value = nil)
+      if value
+        self.facet = value
+        return self
+      end
+      @facet
+    end
+
+    ##
+    # Merge additional, repository-specific parameters
+    def merge(extra_params, &)
+      if extra_params
+        params_will_change!
+        @merged_params.merge!(extra_params.to_hash, &)
+      end
+      self
+    end
+
+    ##
+    # "Reverse merge" additional, repository-specific parameters
+    def reverse_merge(extra_params, &)
+      if extra_params
+        params_will_change!
+        @reverse_merged_params.reverse_merge!(extra_params.to_hash, &)
+      end
+      self
+    end
+
+    delegate :[], :key?, to: :to_hash
+
+    # a solr query method
+    # @return [Blacklight::Solr::Response] the solr response object
+    def to_hash
+      return @params unless params_need_update?
+
+      @params = processed_parameters
+                .reverse_merge(@reverse_merged_params)
+                .merge(@merged_params)
+                .tap { clear_changes }
+    end
+
+    alias query to_hash
+    alias to_h to_hash
+
+    delegate :search_field, to: :search_state
+
+    private
+
+    attr_reader :scope
+
+    def should_add_field_to_request? _field_name, field
+      field.include_in_request || (field.include_in_request.nil? && blacklight_config.add_field_configuration_to_solr_request)
+    end
+
+    def request
+      Blacklight::Solr::Request.new
+    end
+
+    # The CatalogController #index and #facet actions use this.
+    # Solr parameters can come from a number of places. From lowest
+    # precedence to highest:
+    #  1. General defaults in blacklight config (are trumped by)
+    #  2. defaults for the particular search field identified by  params[:search_field] (are trumped by)
+    #  3. certain parameters directly on input HTTP query params
+    #     * not just any parameter is grabbed willy nilly, only certain ones are allowed by HTTP input)
+    #     * for legacy reasons, qt in http query does not over-ride qt in search field definition default.
+    #  4.  extra parameters passed in as argument.
+    #
+    # spellcheck.q will be supplied with the [:q] value unless specifically
+    # specified otherwise.
+    #
+    # Incoming parameter :f is mapped to :fq solr parameter.
+    #
+    # @return a params hash for searching solr.
+    def processed_parameters
+      request.tap do |request_parameters|
+        processor_chain.each do |method_name|
+          send(method_name, request_parameters)
+        end
+      end
+    end
+
+    def params_will_change!
+      @dirty = true
+    end
+
+    def params_changed?
+      !!@dirty
+    end
+
+    def clear_changes
+      @dirty = false
+    end
+
+    def params_need_update?
+      params_changed? || @params.nil?
+    end
+  end
+end

lib/blacklight/configuration.rb

@@ -99,6 +99,9 @@ def initialized_default_configuration?
       # @!attribute search_builder_class
       # @return [Class] class for converting Blacklight parameters to request parameters for the repository_class
       property :search_builder_class, default: ::SearchBuilder
+      # @!attribute search_builder_class
+      # @return [Class] class for converting Blacklight parameters to request parameters for the repository_class
+      property :facet_search_builder_class, default: ::FacetSearchBuilder
       # @!attribute response_model
       # model that maps index responses to the blacklight response model
       # @return [Class]

lib/blacklight/facet_search_builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Blacklight
+  class FacetSearchBuilder < AbstractSearchBuilder
+    def facet_suggestion_query=(value)
+      params_will_change!
+      @facet_suggestion_query = value
+    end
+
+    def facet_suggestion_query(value = nil)
+      if value
+        self.facet_suggestion_query = value
+        return self
+      end
+      @facet_suggestion_query
+    end
+  end
+end