blacklight 7.5.0 → 7.8.1

data/app/helpers/blacklight/render_constraints_helper_behavior.rb

@@ -6,14 +6,19 @@
 # Includes methods for rendering contraints graphically on the
 # search results page (render_constraints(_*))
 module Blacklight::RenderConstraintsHelperBehavior
+  extend Deprecation
+  self.deprecation_horizon = 'blacklight 8.0'
+
   ##
   # Check if the query has any constraints defined (a query, facet, etc)
   #
   # @param [Hash] localized_params query parameters
   # @return [Boolean]
-  def query_has_constraints?(localized_params = params)
-    !(localized_params[:q].blank? && localized_params[:f].blank?)
+  def query_has_constraints?(params_or_search_state = search_state)
+    search_state = convert_to_search_state(params_or_search_state)
+    search_state.has_constraints?
   end
+  deprecation_deprecate :query_has_constraints?
 
   ##
   # Render the actual constraints, not including header or footer
@@ -21,8 +26,16 @@ module Blacklight::RenderConstraintsHelperBehavior
   #
   # @param [Hash] localized_params query parameters
   # @return [String]
-  def render_constraints(localized_params = params)
-    render_constraints_query(localized_params) + render_constraints_filters(localized_params)
+  def render_constraints(localized_params = params, local_search_state = search_state)
+    params_or_search_state = if localized_params != params
+                               localized_params
+                             else
+                               local_search_state
+                             end
+
+    Deprecation.silence(Blacklight::RenderConstraintsHelperBehavior) do
+      render_constraints_query(params_or_search_state) + render_constraints_filters(params_or_search_state)
+    end
   end
 
   ##
@@ -30,15 +43,20 @@ module Blacklight::RenderConstraintsHelperBehavior
   #
   # @param [ActionController::Parameters] localized_params query parameters
   # @return [String]
-  def render_constraints_query(localized_params = params)
+  def render_constraints_query(params_or_search_state = search_state)
+    search_state = convert_to_search_state(params_or_search_state)
+
     # So simple don't need a view template, we can just do it here.
-    return "".html_safe if localized_params[:q].blank?
+    return "".html_safe if search_state.query_param.blank?
 
-    render_constraint_element(constraint_query_label(localized_params),
-                              localized_params[:q],
-                              classes: ["query"],
-                              remove: remove_constraint_url(localized_params))
+    Deprecation.silence(Blacklight::RenderConstraintsHelperBehavior) do
+      render_constraint_element(constraint_query_label(search_state),
+                                search_state.query_param,
+                                classes: ["query"],
+                                remove: remove_constraint_url(search_state))
+    end
   end
+  deprecation_deprecate :render_constraints_query
 
   ##
   # Provide a url for removing a particular constraint. This can be overriden
@@ -47,52 +65,53 @@ module Blacklight::RenderConstraintsHelperBehavior
   #
   # @param [ActionController::Parameters] localized_params query parameters
   # @return [String]
-  def remove_constraint_url(localized_params)
-    scope = localized_params.delete(:route_set) || self
-
-    unless localized_params.is_a? ActionController::Parameters
-      localized_params = ActionController::Parameters.new(localized_params)
-    end
+  def remove_constraint_url(params_or_search_state = search_state)
+    search_state = convert_to_search_state(params_or_search_state)
 
-    options = localized_params.merge(q: nil, action: 'index')
-    options.permit!
-    scope.url_for(options)
+    search_action_path(search_state.remove_query_params)
   end
+  deprecation_deprecate :remove_constraint_url
 
   ##
   # Render the facet constraints
   # @param [Hash] localized_params query parameters
   # @return [String]
-  def render_constraints_filters(localized_params = params)
-    return "".html_safe unless localized_params[:f]
+  def render_constraints_filters(params_or_search_state = search_state)
+    search_state = convert_to_search_state(params_or_search_state)
 
-    path = controller.search_state_class.new(localized_params, blacklight_config, controller)
-    content = []
-    localized_params[:f].each_pair do |facet, values|
-      content << render_filter_element(facet, values, path)
-    end
+    return "".html_safe if search_state.filter_params.blank?
 
-    safe_join(content.flatten, "\n")
+    Deprecation.silence(Blacklight::RenderConstraintsHelperBehavior) do
+      safe_join(search_state.filter_params.each_pair.map do |facet, values|
+        render_filter_element(facet, values, search_state)
+      end, "\n")
+    end
   end
+  deprecation_deprecate :render_constraints_filters
 
   ##
   # Render a single facet's constraint
   # @param [String] facet field
   # @param [Array<String>] values selected facet values
-  # @param [Blacklight::SearchState] path query parameters
+  # @param [Blacklight::SearchState] path query parameters (unused)
   # @return [String]
-  def render_filter_element(facet, values, path)
+  def render_filter_element(facet, values, search_state)
     facet_config = facet_configuration_for_field(facet)
 
     safe_join(Array(values).map do |val|
       next if val.blank? # skip empty string
 
-      render_constraint_element(facet_field_label(facet_config.key),
-                                facet_display_value(facet, val),
-                                remove: search_action_path(path.remove_facet_params(facet, val)),
-                                classes: ["filter", "filter-" + facet.parameterize])
+      presenter = facet_item_presenter(facet_config, val, facet)
+
+      Deprecation.silence(Blacklight::RenderConstraintsHelperBehavior) do
+        render_constraint_element(facet_field_label(facet_config.key),
+                                  presenter.label,
+                                  remove: presenter.remove_href(search_state),
+                                  classes: ["filter", "filter-" + facet.parameterize])
+      end
     end, "\n")
   end
+  deprecation_deprecate :render_filter_element
 
   # Render a label/value constraint on the screen. Can be called
   # by plugins and such to get application-defined rendering.
@@ -111,4 +130,16 @@ module Blacklight::RenderConstraintsHelperBehavior
   def render_constraint_element(label, value, options = {})
     render(partial: "catalog/constraints_element", locals: { label: label, value: value, options: options })
   end
+  deprecation_deprecate :render_constraint_element
+
+  private
+
+  def convert_to_search_state(params_or_search_state)
+    if params_or_search_state.is_a? Blacklight::SearchState
+      params_or_search_state
+    else
+      # deprecated
+      controller.search_state_class.new(params_or_search_state, blacklight_config, controller)
+    end
+  end
 end

data/app/javascript/blacklight/modal.js

@@ -44,7 +44,7 @@
 
       <div class="modal-body">
         <p>Some message</p>
-        <%= link_to "This result will still be within modal", some_link, data: { blacklight: "preserve" } %>
+        <%= link_to "This result will still be within modal", some_link, data: { blacklight_modal: "preserve" } %>
       </div>
 
 

data/app/models/blacklight/icon.rb

@@ -2,7 +2,7 @@
 
 module Blacklight
   class Icon
-    attr_reader :icon_name, :aria_hidden, :label, :role
+    attr_reader :icon_name, :aria_hidden, :label, :role, :additional_options
     ##
     # @param [String, Symbol] icon_name
     # @param [Hash] options
@@ -10,12 +10,14 @@ module Blacklight
     # @param [Boolean] aria_hidden include aria_hidden attribute
     # @param [Boolean] label include <title> and aria-label as part of svg
     # @param [String] role role attribute to be included in svg
-    def initialize(icon_name, classes: '', aria_hidden: false, label: true, role: 'image')
+    # @param [Hash] additional_options the way forward instead of named arguments
+    def initialize(icon_name, classes: '', aria_hidden: false, label: true, role: 'img', additional_options: {})
       @icon_name = icon_name
       @classes = classes
       @aria_hidden = aria_hidden
       @label = label
       @role = role
+      @additional_options = additional_options
     end
 
     ##
@@ -24,17 +26,17 @@ module Blacklight
     def svg
       svg = ng_xml.at_xpath('svg')
       svg['role'] = role
-      svg['aria-labelled-by'] = unique_id if label
+      svg['aria-labelledby'] = unique_id if label
       svg.add_child("<title id='#{unique_id}'>#{icon_label}</title>") if label
       ng_xml.to_xml
     end
 
     def icon_label
-      I18n.translate("blacklight.icon.#{icon_name}", default: "#{icon_name} icon")
+      I18n.translate("blacklight.icon.#{icon_name_context}", default: "#{icon_name} icon")
     end
 
     def unique_id
-      @unique_id ||= "bl-icon-#{icon_name}-#{SecureRandom.hex(8)}"
+      @unique_id ||= "bl-icon-#{icon_name_context}-#{SecureRandom.hex(8)}"
     end
 
     ##
@@ -66,6 +68,10 @@ module Blacklight
 
     private
 
+    def icon_name_context
+      [icon_name, additional_options[:label_context]].compact.join('_')
+    end
+
     def file
       # Rails.application.assets is `nil` in production mode (where compile assets is enabled).
       # This workaround is based off of this comment: https://github.com/fphilipe/premailer-rails/issues/145#issuecomment-225992564

data/app/models/concerns/blacklight/document/extensions.rb

@@ -32,6 +32,9 @@ module Blacklight::Document::Extensions
   module ClassMethods
     attr_writer :registered_extensions
 
+    # Returns array of hashes of registered extensions. Each hash
+    # has a :module_obj key and a :condition_proc key. Usually this
+    # method is only used internally in #apply_extensions, but if you
     # want to zero out all previously registered extensions you can call:
     # SolrDocument.registered_extensions = nil
     def registered_extensions

data/app/models/concerns/blacklight/document/semantic_fields.rb

@@ -4,10 +4,6 @@ module Blacklight::Document
     extend ActiveSupport::Concern
 
     module ClassMethods
-      # Returns array of hashes of registered extensions. Each hash
-      # has a :module_obj key and a :condition_proc key. Usually this
-      # method is only used internally in #apply_extensions, but if you
-
       # Class-level method for accessing/setting semantic mappings
       # for solr stored fields. Can be set by local app, key is
       # a symbol for a semantic, value is a solr _stored_ field.

data/app/presenters/blacklight/document_presenter.rb

@@ -19,10 +19,14 @@ module Blacklight
 
     # @return [Hash<String,Configuration::Field>]  all the fields for this index view that should be rendered
     def fields_to_render
-      fields.select do |_name, field_config|
-        # rubocop:disable Style/PreferredHashMethods
-        render_field?(field_config) && has_value?(field_config)
-        # rubocop:enable Style/PreferredHashMethods
+      return to_enum(:fields_to_render) unless block_given?
+
+      fields.each do |name, field_config|
+        field_presenter = field_presenter(field_config)
+
+        next unless field_presenter.render_field? && field_presenter.any?
+
+        yield name, field_config, field_presenter
       end
     end
 
@@ -32,11 +36,11 @@ module Blacklight
     #
     # @return [String]
     def heading
-      return field_values(view_config.title_field) if view_config.title_field.is_a? Blacklight::Configuration::Field
+      return field_value(view_config.title_field) if view_config.title_field.is_a? Blacklight::Configuration::Field
 
       fields = Array.wrap(view_config.title_field) + [configuration.document_model.unique_key]
-      f = fields.lazy.map { |field| field_config(field) }.detect { |field_config| retrieve_values(field_config).any? }
-      field_values(f, except_operations: [Rendering::HelperMethod])
+      f = fields.lazy.map { |field| field_config(field) }.detect { |field_config| field_presenter(field_config).any? }
+      field_value(f, except_operations: [Rendering::HelperMethod])
     end
 
     def display_type(base_name = nil, default: nil)
@@ -44,7 +48,7 @@ module Blacklight
       fields += Array.wrap(view_config[:"#{base_name}_display_type_field"]) if base_name && view_config.key?(:"#{base_name}_display_type_field")
       fields += Array.wrap(view_config.display_type_field)
 
-      display_type = fields.lazy.map { |field| retrieve_values(field_config(field)) }.detect(&:any?)
+      display_type = fields.lazy.map { |field| field_presenter(field_config(field)) }.detect(&:any?)&.values
       display_type ||= Array(default) if default
 
       display_type || []
@@ -55,11 +59,11 @@ module Blacklight
     #
     # Allow an extention point where information in the document
     # may drive the value of the field
-    # @param [Configuration::Field] field
+    # @param [Configuration::Field] field_config
     # @param [Hash] options
     # @option options [String] :value
-    def field_value field, options = {}
-      field_values(field, options)
+    def field_value field_config, options = {}
+      field_presenter(field_config, options).render
     end
 
     def thumbnail
@@ -68,41 +72,28 @@ module Blacklight
 
     private
 
-    ##
-    # Check to see if the given field should be rendered in this context
-    # @param [Blacklight::Configuration::Field] field_config
-    # @return [Boolean]
     def render_field?(field_config)
-      view_context.should_render_field?(field_config, document)
+      field_presenter(field_config).render_field?
     end
+    deprecation_deprecate render_field?: 'Use FieldPresenter#render_field?'
 
-    ##
-    # Check if a document has (or, might have, in the case of accessor methods) a value for
-    # the given solr field
-    # @param [Blacklight::Configuration::Field] field_config
-    # @return [Boolean]
     def has_value?(field_config)
-      retrieve_values(field_config).present?
+      field_presenter(field_config).any?
     end
+    deprecation_deprecate has_value?: 'Use FieldPresenter#any?'
 
-    ##
-    # Get the value for a document's field, and prepare to render it.
-    # - highlight_field
-    # - accessor
-    # - solr field
-    #
-    # Rendering:
-    #   - helper_method
-    #   - link_to_facet
-    # @param [Blacklight::Configuration::Field] field_config solr field configuration
-    # @param [Hash] options additional options to pass to the rendering helpers
     def field_values(field_config, options = {})
-      options[:values] ||= retrieve_values(field_config) unless options.key? :value
-      FieldPresenter.new(view_context, document, field_config, options).render
+      field_value(field_config, options)
     end
+    deprecation_deprecate field_values: 'Use #field_value'
 
     def retrieve_values(field_config)
-      FieldRetriever.new(document, field_config).fetch
+      field_presenter(field_config).values
+    end
+    deprecation_deprecate retrieve_values: 'Use FieldPresenter#values'
+
+    def field_presenter(field_config, options = {})
+      FieldPresenter.new(view_context, document, field_config, options)
     end
   end
 end

data/app/presenters/blacklight/facet_field_presenter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Blacklight
+  class FacetFieldPresenter
+    attr_reader :facet_field, :display_facet, :view_context, :search_state
+
+    delegate :key, to: :facet_field
+    delegate :field_name, to: :display_facet
+
+    def initialize(facet_field, display_facet, view_context, search_state = view_context.search_state)
+      @facet_field = facet_field
+      @display_facet = display_facet
+      @view_context = view_context
+      @search_state = search_state
+    end
+
+    def collapsed?
+      Deprecation.silence(Blacklight::FacetsHelperBehavior) do
+        view_context.should_collapse_facet?(facet_field)
+      end
+    end
+
+    def active?
+      Deprecation.silence(Blacklight::FacetsHelperBehavior) do
+        view_context.facet_field_in_params?(key)
+      end
+    end
+
+    def in_modal?
+      search_state.params[:action] == "facet"
+    end
+
+    def modal_path
+      return unless paginator
+
+      view_context.search_facet_path(id: key) unless paginator&.last_page?
+    end
+
+    def label
+      view_context.facet_field_label(key)
+    end
+
+    # @private
+    # @deprecated
+    def html_id
+      Deprecation.silence(Blacklight::FacetsHelperBehavior) do
+        view_context.facet_field_id(facet_field)
+      end
+    end
+
+    def paginator
+      return unless display_facet
+
+      @paginator ||= view_context.facet_paginator(facet_field, display_facet)
+    end
+  end
+end

data/app/presenters/blacklight/facet_item_presenter.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Blacklight
+  class FacetItemPresenter
+    attr_reader :facet_item, :facet_config, :view_context, :search_state, :facet_field
+
+    delegate :hits, to: :facet_item
+
+    def initialize(facet_item, facet_config, view_context, facet_field, search_state = view_context.search_state)
+      @facet_item = facet_item
+      @facet_config = facet_config
+      @view_context = view_context
+      @facet_field = facet_field
+      @search_state = search_state
+    end
+
+    ##
+    # Check if the query parameters have the given facet field with the
+    # given value.
+    def selected?
+      search_state.has_facet? facet_config, value: facet_value
+    end
+
+    ##
+    # Get the displayable version of a facet's value
+    #
+    # @return [String]
+    def label
+      return @view_context.facet_display_value(@facet_field, @facet_item) unless @view_context.method(:facet_display_value).owner == Blacklight::FacetsHelperBehavior
+
+      value = if facet_item.respond_to? :label
+                facet_item.label
+              else
+                facet_value
+              end
+
+      if facet_config.helper_method
+        view_context.public_send(facet_config.helper_method, value)
+      elsif facet_config.query && facet_config.query[value]
+        facet_config.query[value][:label]
+      elsif facet_config.date
+        localization_options = facet_config.date == true ? {} : facet_config.date
+        I18n.l(Time.zone.parse(value), localization_options)
+      else
+        value
+      end
+    end
+
+    def href(path_options = {})
+      if selected?
+        remove_href
+      else
+        add_href(path_options)
+      end
+    end
+
+    # @private
+    def remove_href(path = search_state)
+      view_context.search_action_path(path.remove_facet_params(facet_config.key, facet_item))
+    end
+
+    # @private
+    def add_href(path_options = {})
+      if facet_config.url_method
+        view_context.public_send(facet_config.url_method, facet_config.key, facet_item)
+      else
+        view_context.search_action_path(search_state.add_facet_params_and_redirect(facet_config.key, facet_item).merge(path_options))
+      end
+    end
+
+    private
+
+    def facet_value
+      if facet_item.respond_to? :value
+        facet_item.value
+      else
+        facet_item
+      end
+    end
+  end
+end