blacklight 8.11.0 → 9.0.0.beta2

data/lib/blacklight/search_builder.rb

@@ -5,45 +5,7 @@ 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 SearchBuilder
-    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
-
-    ##
-    # 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
-
+  class SearchBuilder < AbstractSearchBuilder
     ##
     # Update the :q (query) parameter
     # @param [Hash<Symbol,Object>] conditions the field and values to query on
@@ -93,68 +55,6 @@ module Blacklight
       builder
     end
 
-    ##
-    # Merge additional, repository-specific parameters
-    def merge(extra_params, &block)
-      if extra_params
-        params_will_change!
-        @merged_params.merge!(extra_params.to_hash, &block)
-      end
-      self
-    end
-
-    ##
-    # "Reverse merge" additional, repository-specific parameters
-    def reverse_merge(extra_params, &block)
-      if extra_params
-        params_will_change!
-        @reverse_merged_params.reverse_merge!(extra_params.to_hash, &block)
-      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_method :query, :to_hash
-    alias_method :to_h, :to_hash
-
-    # The CatalogController #index action uses 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
-
-    delegate :blacklight_config, to: :scope
-
     def start=(value)
       params_will_change!
       @start = value.to_i
@@ -209,34 +109,6 @@ module Blacklight
 
     alias per rows
 
-    # 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
-
-    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
-
     # Decode the user provided 'sort' parameter into a sort string that can be
     # passed to the search.  This sanitizes the input by ensuring only
     # configured search values are passed through to the search.
@@ -244,35 +116,5 @@ module Blacklight
     def sort
       search_state.sort_field&.sort
     end
-
-    delegate :search_field, to: :search_state
-
-    private
-
-    def request
-      Blacklight::Solr::Request.new
-    end
-
-    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
-
-    attr_reader :scope
-
-    def params_will_change!
-      @dirty = true
-    end
-
-    def params_changed?
-      !!@dirty
-    end
-
-    def params_need_update?
-      params_changed? || @params.nil?
-    end
-
-    def clear_changes
-      @dirty = false
-    end
   end
 end

data/lib/blacklight/search_state/filter_field.rb

@@ -120,8 +120,8 @@ module Blacklight
       delegate :any?, to: :values
 
       # Appease rubocop rules by implementing #each_value
-      def each_value(except: [], &block)
-        values(except: except).each(&block)
+      def each_value(except: [], &)
+        values(except: except).each(&)
       end
 
       # @param [String,#value] item a filter to remove from the url

data/lib/blacklight/search_state/pivot_filter_field.rb

@@ -89,16 +89,16 @@ module Blacklight
         end
       end
 
-      class QueryBuilder
+      class QueryBuilder < Solr::AbstractFilterQueryBuilder
         # @return [Array] filter_query, subqueries
-        def self.call(search_builder, filter, solr_parameters)
+        def call(filter, solr_parameters)
           existing = solr_parameters['fq']&.dup || []
           queries = []
           filter.values.compact_blank.each do |value|
-            queries << search_builder.send(:facet_value_to_fq_string, filter.pivot.first, value.value)
+            queries << facet_value_to_fq_string(filter.pivot.first, value.value)
             value.fq.each do |entry|
               k, v = entry
-              queries << search_builder.send(:facet_value_to_fq_string, k, v) if v
+              queries << facet_value_to_fq_string(k, v) if v
             end
             queries.uniq!
           end

data/lib/blacklight/solr/abstract_filter_query_builder.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Blacklight::Solr
+  class AbstractFilterQueryBuilder
+    def initialize(blacklight_config:)
+      @blacklight_config = blacklight_config
+    end
+
+    attr_reader :blacklight_config
+
+    private
+
+    def facet_inclusive_value_to_fq_string(facet_field, values)
+      return if values.blank?
+
+      return facet_value_to_fq_string(facet_field, values.first) if values.length == 1
+
+      facet_config = blacklight_config.facet_fields[facet_field]
+
+      local_params = []
+      local_params << "tag=#{facet_config.tag}" if facet_config&.tag
+
+      solr_filters = values.each_with_object({}).with_index do |(v, h), index|
+        h["f_inclusive.#{facet_field}.#{index}"] = facet_value_to_fq_string(facet_field, v, use_local_params: false)
+      end
+
+      filter_query = solr_filters.keys.map do |k|
+        "{!query v=$#{k}}"
+      end.join(' OR ')
+
+      ["{!lucene#{" #{local_params.join(' ')}" unless local_params.empty?}}#{filter_query}", solr_filters]
+    end
+
+    ##
+    # Convert a facet/value pair into a solr fq parameter
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def facet_value_to_fq_string(facet_field, value, use_local_params: true)
+      facet_config = blacklight_config.facet_fields[facet_field]
+
+      solr_field = facet_config.field if facet_config && !facet_config.query
+      solr_field ||= facet_field
+
+      local_params = []
+      local_params << "tag=#{facet_config.tag}" if use_local_params && facet_config&.tag
+
+      if facet_config&.query
+        if facet_config.query[value]
+          facet_config.query[value][:fq]
+        else
+          # exclude all documents if the custom facet key specified was not found
+          '-*:*'
+        end
+      elsif value.is_a?(Range)
+        prefix = "{!#{local_params.join(' ')}}" unless local_params.empty?
+        start = value.begin || '*'
+        finish = value.end || '*'
+        "#{prefix}#{solr_field}:[#{start} TO #{finish}]"
+      elsif value == Blacklight::SearchState::FilterField::MISSING
+        "-#{solr_field}:[* TO *]"
+      else
+        "{!term f=#{solr_field}#{" #{local_params.join(' ')}" unless local_params.empty?}}#{convert_to_term_value(value)}"
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def convert_to_term_value(value)
+      case value
+      when DateTime, Time
+        value.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      when Date
+        value.to_time(:local).strftime("%Y-%m-%dT%H:%M:%SZ")
+      else
+        value.to_s
+      end
+    end
+  end
+end

data/lib/blacklight/solr/default_filter_query_builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Blacklight::Solr
+  class DefaultFilterQueryBuilder < AbstractFilterQueryBuilder
+    def call(filter, _solr_parameters)
+      filter_queries = []
+      all_subqueries = {}
+      filter.values.compact_blank.each do |value|
+        filter_query, subqueries = if value.is_a?(Array)
+                                     facet_inclusive_value_to_fq_string(filter.key, value.compact_blank)
+                                   else
+                                     facet_value_to_fq_string(filter.config.key, value)
+                                   end
+        filter_queries << filter_query
+        all_subqueries.merge!(subqueries) if subqueries
+      end
+      [filter_queries, all_subqueries]
+    end
+  end
+end

data/lib/blacklight/solr/facet_search_builder_behavior.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Blacklight::Solr
+  module FacetSearchBuilderBehavior
+    extend ActiveSupport::Concern
+
+    included do
+      include Blacklight::Solr::SearchBuilderBehavior
+      self.default_processor_chain = [:default_solr_parameters,
+                                      :add_search_field_default_parameters,
+                                      :add_query_to_solr,
+                                      :add_facet_fq_to_solr,
+                                      :add_facetting_to_solr,
+                                      :add_solr_fields_to_query,
+                                      :add_additional_filters,
+                                      :add_facet_paging_to_solr,
+                                      :add_facet_suggestion_parameters]
+    end
+
+    def add_facet_paging_to_solr(solr_params)
+      return if facet.blank?
+
+      facet_config = blacklight_config.facet_fields[facet]
+
+      solr_params[:rows] = 0
+
+      limit = if solr_params["facet.limit"]
+                solr_params["facet.limit"].to_i
+              else
+                facet_config.fetch(:more_limit, blacklight_config.default_more_limit)
+              end
+
+      page = search_state.facet_page
+      sort = search_state.facet_sort
+      prefix = search_state.facet_prefix
+      offset = (page - 1) * limit
+
+      if facet_config.json
+        add_solr_facet_json_params(solr_parameters, facet, facet_config, limit: limit + 1, offset: offset, sort: sort, prefix: prefix)
+        return
+      end
+
+      # Now override with our specific things for fetching facet values
+      facet_ex = facet_config.respond_to?(:ex) ? facet_config.ex : nil
+      solr_params[:'facet.field'] = with_ex_local_param(facet_ex, facet_config.field)
+
+      # Need to set as f.facet_field.facet.* to make sure we
+      # override any field-specific default in the solr request handler.
+      solr_params[:"f.#{facet_config.field}.facet.limit"] = limit + 1
+      solr_params[:"f.#{facet_config.field}.facet.offset"] = offset
+      solr_params[:"f.#{facet_config.field}.facet.sort"] = sort if sort
+      solr_params[:"f.#{facet_config.field}.facet.prefix"] = prefix if prefix
+    end
+
+    def add_facet_suggestion_parameters(solr_params)
+      return if facet.blank? || facet_suggestion_query.blank?
+
+      solr_params[:'facet.contains'] = facet_suggestion_query[0..50]
+      solr_params[:'facet.contains.ignoreCase'] = true
+    end
+  end
+end

data/lib/blacklight/solr/repository.rb

@@ -8,7 +8,6 @@ module Blacklight::Solr
     # @param [Hash] params additional solr query parameters
     def find id, params = {}
       doc_params = params.reverse_merge(blacklight_config.default_document_solr_params)
-                         .reverse_merge(qt: blacklight_config.document_solr_request_handler)
                          .merge(blacklight_config.document_unique_id_param => id)
 
       solr_response = send_and_receive blacklight_config.document_solr_path || blacklight_config.solr_path, doc_params
@@ -27,7 +26,11 @@ module Blacklight::Solr
     # Execute a search query against solr
     # @param [Hash] params solr query parameters
     # @param [String] path solr request handler path
-    def search pos_params = {}, path: nil, params: nil, **kwargs
+    def search pos_params = nil, path: nil, params: nil, **kwargs
+      if pos_params
+        Blacklight.deprecation.warn("Passing positional arguments to search() is deprecated. Use the params kwarg instead.")
+      end
+
       request_params = (params || pos_params).reverse_merge(kwargs).reverse_merge({ qt: blacklight_config.qt })
 
       send_and_receive(path || default_search_path(request_params), request_params)
@@ -56,15 +59,11 @@ module Blacklight::Solr
     end
 
     ##
-    # Execute a solr query
+    # Execute a solr query at the given path with the parameters
     # TODO: Make this private after we have a way to abstract admin/luke and ping
     # @see [RSolr::Client#send_and_receive]
-    # @overload find(solr_path, params)
-    #   Execute a solr query at the given path with the parameters
-    #   @param [String] solr path (defaults to blacklight_config.solr_path)
-    #   @param [Hash] parameters for RSolr::Client#send_and_receive
-    # @overload find(params)
-    #   @param [Hash] parameters for RSolr::Client#send_and_receive
+    # @param [String] path solr path (defaults to blacklight_config.solr_path)
+    # @param [Hash, Blacklight::SearchBuilder] solr_params parameters for RSolr::Client#send_and_receive
     # @return [Blacklight::Solr::Response] the solr response object
     def send_and_receive(path, solr_params = {})
       benchmark("Solr fetch", level: :debug) do

data/lib/blacklight/solr/request.rb

@@ -3,12 +3,6 @@
 class Blacklight::Solr::InvalidParameter < ArgumentError; end
 
 class Blacklight::Solr::Request < ActiveSupport::HashWithIndifferentAccess
-  # @deprecated
-  SINGULAR_KEYS = %w(facet fl q qt rows start spellcheck spellcheck.q sort per_page wt hl group defType)
-
-  # @deprecated
-  ARRAY_KEYS = %w(facet.field facet.query facet.pivot fq hl.fl)
-
   def initialize(constructor = {})
     if constructor.is_a?(Hash)
       super()
@@ -42,7 +36,7 @@ class Blacklight::Solr::Request < ActiveSupport::HashWithIndifferentAccess
     self[:json][:query] ||= { bool: { bool_operator => [] } }
     self[:json][:query][:bool][bool_operator] ||= []
 
-    if self['q']
+    if self['q'].present?
       self[:json][:query][:bool][:must] ||= []
       self[:json][:query][:bool][:must] << self['q']
       delete 'q'

data/lib/blacklight/solr/response/facets.rb

@@ -229,7 +229,7 @@ module Blacklight::Solr::Response::Facets
 
     blacklight_config.facet_fields.select { |_k, v| v.query }.each_with_object({}) do |(field_name, facet_field), hash|
       salient_facet_queries = facet_field.query.map { |_k, x| x[:fq] }
-      items = facet_queries.select { |k, _v| salient_facet_queries.include?(k) }.reject { |_value, hits| hits.zero? }.map do |value, hits|
+      items = facet_queries.slice(*salient_facet_queries).reject { |_value, hits| hits.zero? }.map do |value, hits|
         salient_fields = facet_field.query.select { |_key, val| val[:fq] == value }
         key = ((salient_fields.keys if salient_fields.respond_to? :keys) || salient_fields.first).first
         Blacklight::Solr::Response::Facets::FacetItem.new(value: key, hits: hits, label: facet_field.query[key][:label])
@@ -250,7 +250,7 @@ module Blacklight::Solr::Response::Facets
 
     salient_facet_queries = facet_field.query.map { |_k, x| x[:fq] }
 
-    relevant_facet_data = self['facets'].select { |k, _v| salient_facet_queries.include?(k) }.reject { |_key, data| data['count'].zero? }
+    relevant_facet_data = self['facets'].slice(*salient_facet_queries).reject { |_key, data| data['count'].zero? }
 
     relevant_facet_data.map do |key, data|
       salient_fields = facet_field.query.select { |_key, val| val[:fq] == key }

data/lib/blacklight/solr/response/group_response.rb

@@ -51,9 +51,9 @@ class Blacklight::Solr::Response::GroupResponse
     )
   end
 
-  def method_missing meth, *args, &block
+  def method_missing(meth, *args, &)
     if response.respond_to? meth
-      response.send(meth, *args, &block)
+      response.send(meth, *args, &)
     else
       super
     end

data/lib/blacklight/solr/response/params.rb

@@ -52,10 +52,6 @@ module Blacklight::Solr::Response::Params
 
   private
 
-  def search_builder
-    request_params if request_params.is_a?(Blacklight::SearchBuilder)
-  end
-
   # Extract JSON Request API parameters from the response header or the request itself
   def json_params
     encoded_json_params = header&.dig('params', 'json')

data/lib/blacklight/solr/response.rb

@@ -8,12 +8,16 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
   include MoreLikeThis
   include Params
 
-  attr_reader :request_params
+  attr_reader :request_params, :search_builder
   attr_accessor :blacklight_config, :options
 
   delegate :document_factory, to: :blacklight_config
 
+  # @param [Hash] data
+  # @param [Hash, Blacklight::SearchBuilder] request_params a SearchBuilder or a Hash of parameters
   def initialize(data, request_params, options = {})
+    @search_builder = request_params if request_params.is_a?(Blacklight::SearchBuilder)
+
     super(force_to_utf8(ActiveSupport::HashWithIndifferentAccess.new(data)))
     @request_params = ActiveSupport::HashWithIndifferentAccess.new(request_params)
     self.blacklight_config = options[:blacklight_config]