blacklight 9.0.0.beta1 → 9.0.0

data/lib/blacklight/configuration/view_config.rb

@@ -8,6 +8,14 @@ class Blacklight::Configuration
     #   @return [Class] document presenter class used by helpers and views
     # @!attribute document_component
     #   @return [Class] component class used to render a document; defaults to Blacklight::DocumentComponent
+    # @!attribute document_title_component
+    #   @return [Class] component class used to render a document title
+    # @!attribute document_metadata_component
+    #   @return [Class] component class used to render the document metadata
+    # @!attribute document_thumbnail_component
+    #   @return [Class] component class used to render a document thumbnail
+    # @!attribute document_embed_component
+    #   @return [Class] component class used to render a document embed
     # @!attribute title_field
     #   @return [String, Symbol] solr field to use to render a document title
     # @!attribute display_type_field
@@ -24,7 +32,7 @@ class Blacklight::Configuration
     #   @return [Class] component class used to render the search bar
     # @!attribute search_header_component
     #   @return [Class] component class used to render the header above the documents
-    def display_label(**options)
+    def display_label(**)
       I18n.t(
         :"blacklight.search.view_title.#{key}",
         default: [
@@ -33,7 +41,7 @@ class Blacklight::Configuration
           title,
           key.to_s.humanize
         ],
-        **options
+        **
       )
     end
 
@@ -46,19 +54,33 @@ class Blacklight::Configuration
       end
     end
 
+    # Provide backwards compatibility with the configuration keys without the document_ prefix
+    def title_component(*) = document_title_component(*)
+    def metadata_component(*) = document_metadata_component(*)
+    def thumbnail_component(*) = document_thumbnail_component(*)
+    def embed_component(*) = document_embed_component(*)
+
+    def title_component=(value)
+      self.document_title_component = value
+    end
+
+    def metadata_component=(value)
+      self.document_metadata_component = value
+    end
+
+    def thumbnail_component=(value)
+      self.document_thumbnail_component = value
+    end
+
+    def embed_component=(value)
+      self.document_embed_component = value
+    end
+
     class Show < ViewConfig
       # @!attribute route
       #   @return [Hash] Default route parameters for 'show' requests.
       #     Set this to a hash with additional arguments to merge into the route,
       #     or set `controller: :current` to route to the current controller.
-
-      def document_presenter_class
-        super || Blacklight::ShowPresenter
-      end
-
-      def to_h
-        super.merge(document_presenter_class: document_presenter_class)
-      end
     end
 
     class Index < ViewConfig
@@ -69,14 +91,6 @@ class Blacklight::Configuration
       #      see Blacklight::Catalog#additional_response_formats for information about the OpenStruct data
       # @!attribute collection_actions
       #   @return [String, Symbol]
-
-      def document_presenter_class
-        super || Blacklight::IndexPresenter
-      end
-
-      def to_h
-        super.merge(document_presenter_class: document_presenter_class)
-      end
     end
   end
 end

data/lib/blacklight/configuration.rb

@@ -47,7 +47,6 @@ module Blacklight
       property :header_component, default: Blacklight::HeaderComponent
       property :full_width_layout, default: false
 
-      # bootstrap_version may be set to 4 or 5
       bootstrap_version = ENV['BOOTSTRAP_VERSION'].presence || "5"
       property :bootstrap_version, default: /(\d)(?:\.\d){0,2}/.match(bootstrap_version)[1].to_i
 
@@ -66,9 +65,6 @@ module Blacklight
 
       # === Single document request configuration
 
-      # @!attribute document_solr_request_handler
-      # @return [String] The solr request handler to use when requesting only a single document
-      property :document_solr_request_handler, default: nil
       # @!attribute document_solr_path
       # @since v5.2.0
       # @return [String] The url path (relative to the solr base url) to use when requesting only a single document
@@ -76,7 +72,8 @@ module Blacklight
       # @!attribute json_solr_path
       # @since v7.34.0
       # @return [String] The url path (relative to the solr base url) to use when using Solr's JSON Query DSL (as with the advanced search)
-      property :json_solr_path, default: 'advanced'
+      # @note You can configure a separate custom 'advanced' requestHandler in solrconfig.xml if desired, but it isn't necessary; the default 'select' handler will work.
+      property :json_solr_path, default: 'select'
       # @!attribute document_unique_id_param
       # @since v5.2.0
       # @return [Symbol] The solr query parameter used for sending the unique identifiers for one or more documents
@@ -101,7 +98,8 @@ module Blacklight
 
       # @!attribute repository_class
       # @return [Class] Class for sending and receiving requests from a search index
-      property :repository_class, default: Blacklight::Solr::Repository
+      #                 defaults to the class configured in blacklight.yml
+      property :repository_class, default: Blacklight.repository_class
       # @!attribute search_builder_class
       # @return [Class] class for converting Blacklight parameters to request parameters for the repository_class
       property :search_builder_class, default: ::SearchBuilder
@@ -146,9 +144,15 @@ module Blacklight
       # @return [Blacklight::Configuration::ViewConfig::Index]
       property :index, default: ViewConfig::Index.new(
         # document presenter class used by helpers and views
-        document_presenter_class: nil,
+        document_presenter_class: Blacklight::IndexPresenter,
+        # document presenter used for json responses
+        json_presenter_class: Blacklight::JsonPresenter,
         # component class used to render a document
         document_component: Blacklight::DocumentComponent,
+        document_embed_component: nil,
+        document_metadata_component: Blacklight::DocumentMetadataComponent,
+        document_thumbnail_component: Blacklight::Document::ThumbnailComponent,
+        document_title_component: Blacklight::DocumentTitleComponent,
         sidebar_component: Blacklight::Search::SidebarComponent,
         dropdown_component: Blacklight::System::DropdownComponent,
         # solr field to use to render a document title
@@ -165,6 +169,10 @@ module Blacklight
         respond_to: OpenStructWithHashAccess.new,
         # component class used to render the facet grouping
         facet_group_component: Blacklight::Response::FacetGroupComponent,
+        # component class used to render the facet search and start at
+        facet_filters_component: Blacklight::Facets::FiltersComponent,
+        # component class used to render the facet pagination
+        facet_pagination_component: Blacklight::FacetFieldPaginationComponent,
         # component class used to render search constraints
         constraints_component: Blacklight::ConstraintsComponent,
         # component class used to render the search bar
@@ -180,8 +188,9 @@ module Blacklight
       # @return [Blacklight::Configuration::ViewConfig::Show]
       property :show, default: ViewConfig::Show.new(
         # document presenter class used by helpers and views
-        document_presenter_class: nil,
+        document_presenter_class: Blacklight::ShowPresenter,
         document_component: Blacklight::DocumentComponent,
+        document_thumbnail_component: nil,
         show_tools_component: Blacklight::Document::ShowToolsComponent,
         show_header_tools_component: nil,
         document_header_component: Blacklight::Document::PageHeaderComponent,
@@ -262,6 +271,10 @@ module Blacklight
       # @since v5.10.0
       # @return [Integer]
       property :default_facet_limit, default: 10
+      # @!attribute default_facet_suggest
+      # @since v9.0.0
+      # @return [Boolean]
+      property :default_facet_suggest, default: true
       # @!attribute default_more_limit
       # @since v7.0.0
       # @return [Integer]
@@ -292,8 +305,13 @@ module Blacklight
 
       # @!attribute advanced_search
       # @since v7.15.0
-      # @return [#enabled]
-      property :advanced_search, default: OpenStruct.new(enabled: false)
+      # @return [OpenStructWithHashAccess] Configuration for advanced search, including:
+      #   enabled: (Boolean) whether advanced search is enabled
+      #   form_solr_parameters: (Hash) optional parameters to send to Solr for the advanced search
+      #                                form; can override values that are set automatically via the
+      #                                #copy_facet_field_config_to_advanced! method
+      property :advanced_search, default: OpenStructWithHashAccess.new(enabled: true,
+                                                                       form_solr_parameters: {})
 
       # @!attribute enable_search_bar_autofocus
       # @since v7.2.0
@@ -450,6 +468,42 @@ module Blacklight
       facet_fields.map { |_facet, opts| opts[:group] }.uniq
     end
 
+    # Use existing search field configs to automatically prepare fields for use
+    # by the advanced search form.
+    def copy_search_field_config_to_advanced!
+      search_fields.each_value do |field|
+        next if field.include_in_advanced_search == false
+        next if field.clause_params
+
+        field.clause_params = {}
+        field.clause_params[:edismax] = field.solr_parameters.dup || {}
+      end
+    end
+
+    # Use existing facet field configs to automatically prepare fields for use
+    # by the advanced search form. If more specific config is needed, e.g., to
+    # set the facet limit for one field to a value other than -1, it can be
+    # expressed in the configuration in advanced_search.form_solr_parameters
+    def copy_facet_field_config_to_advanced!
+      advanced_search.form_solr_parameters ||= {}
+      advanced_search.form_solr_parameters['facet.sort'] ||= 'count'
+      advanced_search.form_solr_parameters['facet.field'] ||= []
+
+      facet_fields.each_value do |field|
+        next if field.include_in_advanced_search == false
+        # Skip query-type and pivot facets that can't be requested via facet.field
+        next if field.query || field.pivot || field.range
+
+        # Add the facet field to the advanced search configuration
+        advanced_search.form_solr_parameters['facet.field'] << field.field unless
+          advanced_search.form_solr_parameters['facet.field'].include?(field.field)
+
+        # Set the facet field's limit to -1 to show ALL values in advanced search
+        advanced_search.form_solr_parameters["f.#{field.field}.facet.limit"] = -1 unless
+          advanced_search.form_solr_parameters["f.#{field.field}.facet.limit"]
+      end
+    end
+
     # Add any configured facet fields to the default solr parameters hash
     # @overload add_facet_fields_to_solr_request!
     #    add all facet fields to the solr request

data/lib/blacklight/nested_open_struct_with_hash_access.rb

@@ -114,7 +114,7 @@ module Blacklight
 
     def set_default_proc!
       self.default_proc = lambda do |hash, key|
-        hash[key] = nested_class.new(key: key)
+        hash[key] = nested_class.new({ key: key })
       end
     end
   end

data/lib/blacklight/open_struct_with_hash_access.rb

@@ -57,7 +57,7 @@ module Blacklight
       self.class.new @table.deep_transform_values(&)
     end
 
-    def try(method_name = nil, *args, &)
+    def try(method_name = nil, *, &)
       if method_name.nil? && block_given?
         if b.arity.zero?
           instance_eval(&)
@@ -65,7 +65,7 @@ module Blacklight
           yield self
         end
       elsif respond_to?(method_name)
-        public_send(method_name, *args, &b)
+        public_send(method_name, *, &b)
       end
     end
   end

data/lib/blacklight/routes/searchable.rb

@@ -18,7 +18,7 @@ module Blacklight
         mapper.get "opensearch"
         mapper.get 'suggest', as: 'suggest_index'
         mapper.get "facet/:id", action: 'facet', as: 'facet'
-        mapper.get "facet_suggest/:id/(:query_fragment)", action: 'facet', as: 'facet_suggest', defaults: { only_values: true }
+        mapper.get "facet_suggest/:id", action: 'facet', as: 'facet_suggest', defaults: { only_values: true }
       end
     end
   end

data/lib/blacklight/search_builder.rb

@@ -12,7 +12,7 @@ module Blacklight
     attr_reader :processor_chain, :search_state, :blacklight_params
 
     # @overload initialize(scope)
-    #   @param [Object] scope scope the scope where the filter methods reside in.
+    #   @param [Object] 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.
@@ -59,6 +59,7 @@ module Blacklight
 
     ##
     # Append additional processor chain directives
+    # This is used in blacklight_range_limit
     def append(*addl_processor_chain)
       params_will_change!
       builder = self.class.new(processor_chain + addl_processor_chain, scope)

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
@@ -145,8 +145,8 @@ module Blacklight
       def permitted_params
         if config.pivot
           {
-            filters_key => config.pivot.each_with_object({}) { |key, filter| filter.merge(key => [], "-#{key}" => []) },
-            inclusive_filters_key => config.pivot.each_with_object({}) { |key, filter| filter.merge(key => []) }
+            filters_key => config.pivot.each_with_object({}) { |key, filter| filter.merge!(key => [], "-#{key}" => []) },
+            inclusive_filters_key => config.pivot.each_with_object({}) { |key, filter| filter.merge!(key => []) }
           }
         else
           {

data/lib/blacklight/search_state/pivot_filter_field.rb

@@ -89,20 +89,20 @@ 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
-          [(queries - existing)]
+          [queries - existing]
         end
       end
 

data/lib/blacklight/search_state.rb

@@ -82,6 +82,8 @@ module Blacklight
       blacklight_config.facet_fields.each_value.map { |value| filter(value) }
     end
 
+    # Return the list of filters (i.e. facets) that have been applied in the current search
+    # @return [Array<FilterField>]
     def filters
       @filters ||= filter_fields.select(&:any?)
     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/field_reflection_search_builder.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Blacklight::Solr
+  class FieldReflectionSearchBuilder < SearchBuilder
+    self.default_processor_chain = [:add_params]
+
+    def add_params(request)
+      request.reverse_merge!({ fl: '*', 'json.nl' => 'map' })
+    end
+  end
+end

data/lib/blacklight/solr/repository.rb

@@ -7,9 +7,7 @@ module Blacklight::Solr
     # @param [String] id document's unique key value
     # @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)
+      doc_params = SingleDocSearchBuilder.new(self, id, params)
 
       solr_response = send_and_receive blacklight_config.document_solr_path || blacklight_config.solr_path, doc_params
       raise Blacklight::Exceptions::RecordNotFound if solr_response.documents.empty?
@@ -25,10 +23,14 @@ module Blacklight::Solr
 
     ##
     # Execute a search query against solr
-    # @param [Hash] params solr query parameters
+    # @param [Hash,Blacklight::SearchBuilder] params solr query parameters
     # @param [String] path solr request handler path
-    def search pos_params = {}, path: nil, params: nil, **kwargs
-      request_params = (params || pos_params).reverse_merge(kwargs).reverse_merge({ qt: blacklight_config.qt })
+    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)
     end
@@ -44,27 +46,27 @@ module Blacklight::Solr
     # Gets a list of available fields
     # @return [Hash]
     def reflect_fields
-      send_and_receive('admin/luke', params: { fl: '*', 'json.nl' => 'map' })['fields']
+      doc_params = FieldReflectionSearchBuilder.new(self)
+      send_and_receive('admin/luke', doc_params)['fields']
     end
 
     ##
     # @return [boolean] true if the repository is reachable
-    def ping
+    def ping?
       response = connection.send_and_receive 'admin/ping', {}
       Blacklight.logger&.info("Ping [#{connection.uri}] returned: '#{response['status']}'")
       response['status'] == "OK"
     end
 
+    alias ping ping?
+    Blacklight.deprecation.deprecate_methods(Repository, ping: 'use Repository#ping? instead')
+
     ##
-    # 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/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/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]