blacklight 7.12.1 → 7.13.0

data/lib/blacklight/search_state.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'blacklight/search_state/filter_field'
+
 module Blacklight
   # This class encapsulates the search state as represented by the query
   # parameters namely: :f, :q, :page, :per_page and, :sort
@@ -78,7 +81,9 @@ module Blacklight
     deprecation_deprecate :[]
 
     def has_constraints?
-      !(query_param.blank? && filter_params.blank?)
+      Deprecation.silence(Blacklight::SearchState) do
+        !(query_param.blank? && filter_params.blank? && filters.blank?)
+      end
     end
 
     def query_param
@@ -88,11 +93,18 @@ module Blacklight
     def filter_params
       params[:f] || {}
     end
+    deprecation_deprecate filter_params: 'Use #filters instead'
 
+    # @return [Blacklight::SearchState]
     def reset(params = nil)
       self.class.new(params || ActionController::Parameters.new, blacklight_config, controller)
     end
 
+    # @return [Blacklight::SearchState]
+    def reset_search(additional_params = {})
+      reset(reset_search_params.merge(additional_params))
+    end
+
     ##
     # Extension point for downstream applications
     # to provide more interesting routing to
@@ -115,23 +127,30 @@ module Blacklight
       p
     end
 
+    def filters
+      @filters ||= blacklight_config.facet_fields.each_value.map do |value|
+        f = filter(value)
+
+        f if f.any?
+      end.compact
+    end
+
+    def filter(field_key_or_field)
+      field = field_key_or_field if field_key_or_field.is_a? Blacklight::Configuration::Field
+      field ||= blacklight_config.facet_fields[field_key_or_field]
+      field ||= Blacklight::Configuration::NullField.new(key: field_key_or_field)
+
+      (field.filter_class || FilterField).new(field, self)
+    end
+
     # adds the value and/or field to params[:f]
     # Does NOT remove request keys and otherwise ensure that the hash
     # is suitable for a redirect. See
     # add_facet_params_and_redirect
     def add_facet_params(field, item)
-      p = reset_search_params
-
-      add_facet_param(p, field, item)
-
-      if item && item.respond_to?(:fq) && item.fq
-        Array(item.fq).each do |f, v|
-          add_facet_param(p, f, v)
-        end
-      end
-
-      p
+      filter(field).add(item).params
     end
+    deprecation_deprecate add_facet_params: 'Use filter(field).add(item) instead'
 
     # Used in catalog/facet action, facets.rb view, for a click
     # on a facet value. Add on the facet params to existing
@@ -141,7 +160,9 @@ module Blacklight
     # Change the action to 'index' to send them back to
     # catalog/index with their new facet choice.
     def add_facet_params_and_redirect(field, item)
-      new_params = add_facet_params(field, item)
+      new_params = Deprecation.silence(self.class) do
+        add_facet_params(field, item)
+      end
 
       # Delete any request params from facet-specific action, needed
       # to redir to index action properly.
@@ -158,45 +179,18 @@ module Blacklight
     # @param [String] field
     # @param [String] item
     def remove_facet_params(field, item)
-      if item.respond_to? :field
-        field = item.field
-      end
-
-      facet_config = facet_configuration_for_field(field)
-
-      url_field = facet_config.key
-
-      value = facet_value_for_facet_item(item)
-
-      p = reset_search_params
-      # need to dup the facet values too,
-      # if the values aren't dup'd, then the values
-      # from the session will get remove in the show view...
-      p[:f] = (p[:f] || {}).dup
-      p[:f][url_field] = (p[:f][url_field] || []).dup
-
-      collection = p[:f][url_field]
-      # collection should be an array, because we link to ?f[key][]=value,
-      # however, Facebook (and maybe some other PHP tools) tranform that parameters
-      # into ?f[key][0]=value, which Rails interprets as a Hash.
-      if collection.is_a? Hash
-        collection = collection.values
-      end
-      p[:f][url_field] = collection - [value]
-      p[:f].delete(url_field) if p[:f][url_field].empty?
-      p.delete(:f) if p[:f].empty?
-      p
+      filter(field).remove(item).params
     end
+    deprecation_deprecate remove_facet_params: 'Use filter(field).remove(item) instead'
 
     def has_facet?(config, value: nil)
-      facet = params&.dig(:f, config.key)
-
       if value
-        (facet || []).include? value
+        filter(config).include?(value)
       else
-        facet.present?
+        filter(config).any?
       end
     end
+    deprecation_deprecate has_facet?: 'Use filter(field).include?(value) or .any? instead'
 
     # Merge the source params with the params_to_merge hash
     # @param [Hash] params_to_merge to merge into above
@@ -217,44 +211,62 @@ module Blacklight
       Parameters.sanitize(my_params)
     end
 
-    private
+    def page
+      [params[:page].to_i, 1].max
+    end
 
-    ##
-    # Reset any search parameters that store search context
-    # and need to be reset when e.g. constraints change
-    # @return [ActionController::Parameters]
-    def reset_search_params
-      Parameters.sanitize(params).except(:page, :counter)
+    def per_page
+      params[:rows].presence&.to_i ||
+        params[:per_page].presence&.to_i ||
+        blacklight_config.default_per_page
     end
 
-    # TODO: this code is duplicated in Blacklight::FacetsHelperBehavior
-    def facet_value_for_facet_item item
-      if item.respond_to? :value
-        item.value
+    def sort_field
+      if sort_field_key.blank?
+        # no sort param provided, use default
+        blacklight_config.default_sort_field
       else
-        item
+        # check for sort field key
+        blacklight_config.sort_fields[sort_field_key]
       end
     end
 
-    def add_facet_param(p, field, item)
-      if item.respond_to? :field
-        field = item.field
-      end
+    def search_field
+      blacklight_config.search_fields[search_field_key]
+    end
 
-      facet_config = facet_configuration_for_field(field)
+    def facet_page
+      [params[facet_request_keys[:page]].to_i, 1].max
+    end
 
-      url_field = facet_config.key
+    def facet_sort
+      params[facet_request_keys[:sort]]
+    end
 
-      value = facet_value_for_facet_item(item)
+    def facet_prefix
+      params[facet_request_keys[:prefix]]
+    end
 
-      p[:f] = (p[:f] || {}).dup # the command above is not deep in rails3, !@#$!@#$
-      p[:f][url_field] = (p[:f][url_field] || []).dup
+    private
 
-      if facet_config.single && p[:f][url_field].present?
-        p[:f][url_field] = []
-      end
+    def search_field_key
+      params[:search_field]
+    end
+
+    def sort_field_key
+      params[:sort]
+    end
+
+    def facet_request_keys
+      blacklight_config.facet_paginator_class.request_keys
+    end
 
-      p[:f][url_field].push(value)
+    ##
+    # Reset any search parameters that store search context
+    # and need to be reset when e.g. constraints change
+    # @return [ActionController::Parameters]
+    def reset_search_params
+      Parameters.sanitize(params).except(:page, :counter)
     end
   end
 end

data/lib/blacklight/search_state/filter_field.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Blacklight
+  class SearchState
+    # Modeling access to filter query parameters
+    class FilterField
+      # @param [Blacklight::Configuration::FacetField] config
+      attr_reader :config
+
+      # @param [Blacklight::SearchState] search_state
+      attr_reader :search_state
+
+      # @return [String,Symbol]
+      delegate :key, to: :config
+
+      # @param [Blacklight::Configuration::FacetField] config
+      # @param [Blacklight::SearchState] search_state
+      def initialize(config, search_state)
+        @config = config
+        @search_state = search_state
+      end
+
+      # @param [String,#value] a filter item to add to the url
+      # @return [Blacklight::SearchState] new state
+      def add(item)
+        new_state = search_state.reset_search
+
+        if item.respond_to?(:fq)
+          Array(item.fq).each do |f, v|
+            new_state = new_state.filter(f).add(v)
+          end
+        end
+
+        if item.respond_to?(:field) && item.field != key
+          return new_state.filter(item.field).add(item)
+        end
+
+        params = new_state.params
+        value = as_url_parameter(item)
+
+        # value could be a string
+        params[param] = (params[param] || {}).dup
+
+        if config.single
+          params[param][key] = [value]
+        else
+          params[param][key] = Array(params[param][key] || []).dup
+          params[param][key].push(value)
+        end
+
+        new_state.reset(params)
+      end
+
+      # @param [String,#value] a filter to remove from the url
+      # @return [Blacklight::SearchState] new state
+      def remove(item)
+        new_state = search_state.reset_search
+        if item.respond_to?(:field) && item.field != key
+          return new_state.filter(item.field).remove(item)
+        end
+
+        params = new_state.params
+        value = as_url_parameter(item)
+
+        # need to dup the facet values too,
+        # if the values aren't dup'd, then the values
+        # from the session will get remove in the show view...
+        params[param] = (params[param] || {}).dup
+        params[param][key] = (params[param][key] || []).dup
+
+        collection = params[param][key]
+        # collection should be an array, because we link to ?f[key][]=value,
+        # however, Facebook (and maybe some other PHP tools) tranform that parameters
+        # into ?f[key][0]=value, which Rails interprets as a Hash.
+        if collection.is_a? Hash
+          Deprecation.warn(self, 'Normalizing parameters in FilterField#remove is deprecated')
+          collection = collection.values
+        end
+        params[param][key] = collection - Array(value)
+        params[param].delete(key) if params[param][key].empty?
+        params.delete(param) if params[param].empty?
+
+        new_state.reset(params)
+      end
+
+      # @return [Array] an array of applied filters
+      def values
+        params = search_state.params
+        Array(params.dig(param, key)) || []
+      end
+      delegate :any?, to: :values
+
+      # @param [String,#value] a filter to remove from the url
+      # @return [Boolean] whether the provided filter is currently applied/selected
+      def include?(item)
+        if item.respond_to?(:field) && item.field != key
+          return search_state.filter(item.field).selected?(item)
+        end
+
+        value = as_url_parameter(item)
+        params = search_state.params
+
+        (params.dig(param, key) || []).include?(value)
+      end
+
+      private
+
+      def param
+        :f
+      end
+
+      # TODO: this code is duplicated in Blacklight::FacetsHelperBehavior
+      def as_url_parameter(item)
+        if item.respond_to? :value
+          item.value
+        else
+          item
+        end
+      end
+    end
+  end
+end

data/lib/blacklight/solr/search_builder_behavior.rb

@@ -32,18 +32,22 @@ module Blacklight::Solr
     # including config's "search field" params for current search field.
     # also include setting spellcheck.q.
     def add_query_to_solr(solr_parameters)
-      ###
-      # Merge in search field configured values, if present, over-writing general
-      # defaults
       ###
       # legacy behavior of user param :qt is passed through, but over-ridden
       # by actual search field config if present. We might want to remove
       # this legacy behavior at some point. It does not seem to be currently
       # rspec'd.
-      solr_parameters[:qt] = blacklight_params[:qt] if blacklight_params[:qt]
+      if search_state.params[:qt]
+        Deprecation.warn(Blacklight::Solr::SearchBuilderBehavior, 'Passing the Solr qt as a parameter is deprecated.')
+        solr_parameters[:qt] = blacklight_params[:qt]
+      end
+
+      ###
+      # Merge in search field configured values, if present, over-writing general
+      # defaults
 
       if search_field
-        solr_parameters[:qt] = search_field.qt
+        solr_parameters[:qt] = search_field.qt if search_field.qt
         solr_parameters.merge!(search_field.solr_parameters) if search_field.solr_parameters
       end
 
@@ -52,32 +56,14 @@ module Blacklight::Solr
       # solr LocalParams in config, using solr LocalParams syntax.
       # http://wiki.apache.org/solr/LocalParams
       ##
-      if search_field && search_field.solr_local_parameters.present?
-        local_params = search_field.solr_local_parameters.map do |key, val|
-          key.to_s + "=" + solr_param_quote(val, quote: "'")
-        end.join(" ")
-        solr_parameters[:q] = "{!#{local_params}}#{blacklight_params[:q]}"
-
-        ##
-        # Set Solr spellcheck.q to be original user-entered query, without
-        # our local params, otherwise it'll try and spellcheck the local
-        # params!
-        solr_parameters["spellcheck.q"] ||= blacklight_params[:q]
-      elsif blacklight_params[:q].is_a? Hash
-        q = blacklight_params[:q]
-        solr_parameters[:q] = if q.values.any?(&:blank?)
-                                # if any field parameters are empty, exclude _all_ results
-                                "{!lucene}NOT *:*"
-                              else
-                                "{!lucene}" + q.map do |field, values|
-                                  "#{field}:(#{Array(values).map { |x| solr_param_quote(x) }.join(' OR ')})"
-                                end.join(" AND ")
-                              end
-
-        solr_parameters[:defType] = 'lucene'
-        solr_parameters[:spellcheck] = 'false'
+      if search_field&.query_builder.present?
+        add_search_field_query_builder_params(solr_parameters)
+      elsif search_field&.solr_local_parameters.present?
+        add_search_field_with_local_parameters(solr_parameters)
+      elsif search_state.query_param.is_a? Hash
+        add_multifield_search_query(solr_parameters)
       elsif blacklight_params[:q]
-        solr_parameters[:q] = blacklight_params[:q]
+        solr_parameters[:q] = search_state.query_param
       end
     end
 
@@ -90,13 +76,17 @@ module Blacklight::Solr
         solr_parameters[:fq] = [solr_parameters[:fq]]
       end
 
-      # :fq, map from :f.
-      if blacklight_params[:f]
-        f_request_params = blacklight_params[:f]
+      search_state.filters.each do |filter|
+        if filter.config.filter_query_builder
+          filter_query, subqueries = filter.config.filter_query_builder.call(self, filter, solr_parameters)
 
-        f_request_params.each_pair do |facet_field, value_list|
-          Array(value_list).reject(&:blank?).each do |value|
-            solr_parameters.append_filter_query facet_value_to_fq_string(facet_field, value)
+          solr_parameters.append_filter_query(filter_query)
+          solr_parameters.merge!(subqueries) if subqueries
+        else
+          filter.values.reject(&:blank?).each do |value|
+            filter_query, subqueries = facet_value_to_fq_string(filter.config.key, value)
+            solr_parameters.append_filter_query(filter_query)
+            solr_parameters.merge!(subqueries) if subqueries
           end
         end
       end
@@ -171,9 +161,7 @@ module Blacklight::Solr
 
     # Remove the group parameter if we've faceted on the group field (e.g. for the full results for a group)
     def add_group_config_to_solr solr_parameters
-      if blacklight_params[:f] && blacklight_params[:f][grouped_key_for_results]
-        solr_parameters[:group] = false
-      end
+      solr_parameters[:group] = false if search_state.filter(grouped_key_for_results).any?
     end
 
     def add_facet_paging_to_solr(solr_params)
@@ -191,22 +179,17 @@ module Blacklight::Solr
                 facet_config.fetch(:more_limit, blacklight_config.default_more_limit)
               end
 
-      page = blacklight_params.fetch(request_keys[:page], 1).to_i
+      page = search_state.facet_page
+      sort = search_state.facet_sort
+      prefix = search_state.facet_prefix
       offset = (page - 1) * limit
 
-      sort = blacklight_params[request_keys[:sort]]
-      prefix = blacklight_params[request_keys[:prefix]]
-
       # 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
-      if blacklight_params[request_keys[:sort]]
-        solr_params[:"f.#{facet_config.field}.facet.sort"] = sort
-      end
-      if blacklight_params[request_keys[:prefix]]
-        solr_params[:"f.#{facet_config.field}.facet.prefix"] = prefix
-      end
+      solr_params[:"f.#{facet_config.field}.facet.sort"] = sort if sort
+      solr_params[:"f.#{facet_config.field}.facet.prefix"] = prefix if prefix
       solr_params[:rows] = 0
     end
 
@@ -314,8 +297,45 @@ module Blacklight::Solr
       end
     end
 
-    def request_keys
-      blacklight_config.facet_paginator_class.request_keys
+    def search_state
+      return super if defined?(super)
+
+      @search_state ||= Blacklight::SearchState.new(blacklight_params, blacklight_config)
+    end
+
+    def add_search_field_query_builder_params(solr_parameters)
+      q, additional_parameters = search_field.query_builder.call(self, search_field, solr_parameters)
+
+      solr_parameters[:q] = q
+      solr_parameters.merge!(additional_parameters) if additional_parameters
+    end
+
+    def add_search_field_with_local_parameters(solr_parameters)
+      local_params = search_field.solr_local_parameters.map do |key, val|
+        key.to_s + "=" + solr_param_quote(val, quote: "'")
+      end.join(" ")
+      solr_parameters[:q] = "{!#{local_params}}#{search_state.query_param}"
+
+      ##
+      # Set Solr spellcheck.q to be original user-entered query, without
+      # our local params, otherwise it'll try and spellcheck the local
+      # params!
+      solr_parameters["spellcheck.q"] ||= search_state.query_param
+    end
+
+    def add_multifield_search_query(solr_parameters)
+      q = search_state.query_param
+      solr_parameters[:q] = if q.values.any?(&:blank?)
+                              # if any field parameters are empty, exclude _all_ results
+                              "{!lucene}NOT *:*"
+                            else
+                              "{!lucene}" + q.map do |field, values|
+                                "#{field}:(#{Array(values).map { |x| solr_param_quote(x) }.join(' OR ')})"
+                              end.join(" AND ")
+                            end
+
+      solr_parameters[:defType] = 'lucene'
+      solr_parameters[:spellcheck] = 'false'
     end
   end
 end