blacklight_range_limit 8.1.0 → 8.2.0

data/app/helpers/range_limit_helper.rb

@@ -1,76 +1,55 @@
-# Additional helper methods used by view templates inside this plugin.
 module RangeLimitHelper
+  extend Deprecation
+
   def range_limit_url(options = {})
     main_app.url_for(search_state.to_h.merge(action: 'range_limit').merge(options))
   end
+  deprecation_deprecate :range_limit_url
 
   def range_limit_panel_url(options = {})
-    main_app.url_for(search_state.to_h.merge(action: 'range_limit_panel').merge(options))
+    search_facet_path(id: options[:id])
   end
+  deprecation_deprecate :range_limit_panel_url
 
   # type is 'begin' or 'end'
   def render_range_input(solr_field, type, input_label = nil, maxlength=4)
-    type = type.to_s
-
-    default = params["range"][solr_field][type] if params["range"] && params["range"][solr_field] && params["range"][solr_field][type]
-
-    html = number_field_tag("range[#{solr_field}][#{type}]", default, :maxlength=>maxlength, :class => "form-control text-center range_#{type}")
-    html += label_tag("range[#{solr_field}][#{type}]", input_label, class: 'sr-only') if input_label.present?
-    html
+    range_form_component(solr_field).render_range_input(type, input_label, maxlength)
   end
+  deprecation_deprecate :render_range_input
 
   # type is 'min' or 'max'
   # Returns smallest and largest value in current result set, if available
   # from stats component response.
   def range_results_endpoint(solr_field, type)
-    stats = stats_for_field(solr_field)
+    presenter = range_facet_field_presenter(solr_field)
 
-    return nil unless stats
-    # StatsComponent returns weird min/max when there are in
-    # fact no values
-    return nil if @response.total == stats["missing"]
-
-    return stats[type].to_s.gsub(/\.0+/, '')
+    case type.to_s
+    when 'min'
+      presenter.min
+    when 'max'
+      presenter.max
+    end
   end
+  deprecation_deprecate :range_results_endpoint
 
   def range_display(solr_field, my_params = params)
-    return "" unless my_params[:range] && my_params[:range][solr_field]
-
-    hash = my_params[:range][solr_field]
-
-    if hash["missing"]
-      return t('blacklight.range_limit.missing')
-    elsif hash["begin"] || hash["end"]
-      if hash["begin"] == hash["end"]
-        return t(
-          'blacklight.range_limit.single_html',
-          begin: format_range_display_value(hash['begin'], solr_field),
-          begin_value: hash['begin']
-        )
-      else
-        return t(
-          'blacklight.range_limit.range_html',
-          begin: format_range_display_value(hash['begin'], solr_field),
-          begin_value: hash['begin'],
-          end: format_range_display_value(hash['end'], solr_field),
-          end_value: hash['end']
-        )
-      end
-    end
+    facet_config = blacklight_config.facet_fields[solr_field]
+    presenter = range_facet_field_presenter(solr_field)
+    return unless presenter.selected_range
 
-    ''
+    facet_item = Blacklight::Solr::Response::Facets::FacetItem.new(value: presenter.selected_range, hits: presenter.response.total)
+
+    facet_config.item_presenter.new(facet_item, facet_config, self, solr_field).label
   end
+  deprecation_deprecate :range_display
 
   ##
   # A method that is meant to be overridden downstream to format how a range
   # label might be displayed to a user. By default it just returns the value
   # as rendered by the presenter
   def format_range_display_value(value, solr_field)
-    if respond_to?(:facet_item_presenter)
-      facet_item_presenter(facet_configuration_for_field(solr_field), value, solr_field).label
-    else
-      facet_display_value(solr_field, value)
-    end
+    Deprecation.warn(RangeLimitHelper, 'Helper #format_range_display_value is deprecated without replacement')
+    facet_item_presenter(facet_configuration_for_field(solr_field), value, solr_field).label
   end
 
   # Show the limit area if:
@@ -79,61 +58,73 @@ module RangeLimitHelper
   # 2) stats show max > min, OR
   # 3) count > 0 if no stats available.
   def should_show_limit(solr_field)
-    stats = stats_for_field(solr_field)
+    presenter = range_facet_field_presenter(solr_field)
 
-    (params["range"] && params["range"][solr_field]) ||
-    (  stats &&
-      stats["max"] > stats["min"]) ||
-    ( !stats  && @response.total > 0 )
+    presenter.selected_range ||
+      (presenter.max && presenter.min && presenter.max > presenter.min) ||
+      @response.total.positive?
   end
 
   def stats_for_field(solr_field)
-    @response["stats"]["stats_fields"][solr_field] if @response["stats"] && @response["stats"]["stats_fields"]
+    range_facet_field_presenter(solr_field).send(:stats_for_field)
   end
+  deprecation_deprecate :stats_for_field
 
   def stats_for_field?(solr_field)
     stats_for_field(solr_field).present?
   end
+  deprecation_deprecate :stats_for_field?
 
   def add_range_missing(solr_field, my_params = params)
-    my_params = Blacklight::SearchState.new(my_params.except(:page), blacklight_config).to_h
-    my_params["range"] ||= {}
-    my_params["range"][solr_field] ||= {}
-    my_params["range"][solr_field]["missing"] = "true"
-
-    my_params
+    Blacklight::SearchState.new(my_params.except(:page), blacklight_config).filter(solr_field).add(Blacklight::SearchState::FilterField::MISSING)
   end
+  deprecation_deprecate :add_range_missing
 
   def add_range(solr_field, from, to, my_params = params)
-    my_params = Blacklight::SearchState.new(my_params.except(:page), blacklight_config).to_h
-    my_params["range"] ||= {}
-    my_params["range"][solr_field] ||= {}
+    Blacklight::SearchState.new(my_params.except(:page), blacklight_config).filter(solr_field).add(from..to)
+  end
+  deprecation_deprecate :add_range
+
+  def has_selected_range_limit?(solr_field)
+    range_facet_field_presenter(solr_field).selected_range.present?
+  end
+  deprecation_deprecate :has_selected_range_limit?
 
-    my_params["range"][solr_field]["begin"] = from
-    my_params["range"][solr_field]["end"] = to
-    my_params["range"][solr_field].delete("missing")
+  def selected_missing_for_range_limit?(solr_field)
+    search_state.filter(solr_field).values.first == Blacklight::SearchState::FilterField::MISSING
+  end
+  deprecation_deprecate :selected_missing_for_range_limit?
 
-    # eliminate temporary range status params that were just
-    # for looking things up
-    my_params.delete("range_field")
-    my_params.delete("range_start")
-    my_params.delete("range_end")
+  def remove_range_param(solr_field, my_params = params)
+    Blacklight::SearchState.new(my_params.except(:page), blacklight_config).filter(solr_field).remove(0..0)
+  end
 
-    return my_params
+  # Looks in the solr @response for ["facet_counts"]["facet_queries"][solr_field], for elements
+  # expressed as "solr_field:[X to Y]", turns them into
+  # a list of hashes with [:from, :to, :count], sorted by
+  # :from. Assumes integers for sorting purposes.
+  def solr_range_queries_to_a(solr_field)
+    range_facet_field_presenter(solr_field).range_queries.map do |item|
+      { from: item.value.first, to: item.value.last, count: item.hits }
+    end
   end
+  deprecation_deprecate :solr_range_queries_to_a
 
-  def has_selected_range_limit?(solr_field)
-    params["range"] &&
-    params["range"][solr_field] &&
-    (
-      params["range"][solr_field]["begin"].present? ||
-      params["range"][solr_field]["end"].present? ||
-      params["range"][solr_field]["missing"]
-    )
+  def range_config(solr_field)
+    BlacklightRangeLimit.range_config(blacklight_config, solr_field)
   end
+  deprecation_deprecate :range_config
 
-  def selected_missing_for_range_limit?(solr_field)
-    params["range"] && params["range"][solr_field] && params["range"][solr_field]["missing"]
+  private
+
+  def range_facet_field_presenter(key)
+    facet_config = blacklight_config.facet_fields[key] || Blacklight::Configuration::FacetField.new(key: key, **BlacklightRangeLimit.default_range_config)
+    facet_field_presenter(facet_config, Blacklight::Solr::Response::Facets::FacetField.new(key, [], response: @response))
   end
 
+  def range_form_component(key)
+    presenter = range_facet_field_presenter(key)
+
+    BlacklightRangeLimit::RangeFormComponent.new(facet_field: presenter)
+  end
 end

data/app/presenters/blacklight_range_limit/facet_field_presenter.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module BlacklightRangeLimit
+  class FacetFieldPresenter < Blacklight::FacetFieldPresenter
+    delegate :response, to: :display_facet
+    delegate :blacklight_config, to: :search_state
+
+    def range_queries
+      return [] unless response.dig('facet_counts', 'facet_queries')
+
+      range_regex = /#{facet_field.field}: *\[ *(-?\d+) *TO *(-?\d+) *\]/
+
+      array = response.dig('facet_counts', 'facet_queries').map do |query, count|
+        if (match = range_regex.match(query))
+          Blacklight::Solr::Response::Facets::FacetItem.new(value: match[1].to_i..match[2].to_i, hits: count)
+        end
+      end
+
+      array.compact.sort_by { |item| item.value.first }
+    end
+
+    def paginator
+      nil
+    end
+
+    def min
+      range_results_endpoint(:min)
+    end
+
+    def max
+      range_results_endpoint(:max)
+    end
+
+    def selected_range
+      search_state.filter(key).values.first
+    end
+
+    def selected_range_facet_item
+      return unless selected_range
+
+      Blacklight::Solr::Response::Facets::FacetItem.new(value: selected_range, hits: response.total)
+    end
+
+    def missing_facet_item
+      return unless missing.positive?
+
+      Blacklight::Solr::Response::Facets::FacetItem.new(
+        value: Blacklight::SearchState::FilterField::MISSING,
+        hits: missing
+      )
+    end
+
+    def missing_selected?
+      selected_range == Blacklight::SearchState::FilterField::MISSING
+    end
+
+    def range_config
+      @facet_field.range_config
+    end
+
+    private
+
+    def missing
+      stats_for_field.fetch('missing', 0)
+    end
+
+    def stats_for_field
+      response.dig('stats', 'stats_fields', facet_field.field) || {}
+    end
+
+    # type is 'min' or 'max'
+    # Returns smallest and largest value in current result set, if available
+    # from stats component response.
+    def range_results_endpoint(type)
+      stats = stats_for_field
+
+      return nil unless stats.key? type
+      # StatsComponent returns weird min/max when there are in
+      # fact no values
+      return nil if response.total == stats['missing']
+
+      stats[type].to_s.gsub(/\.0+/, '')
+    end
+  end
+end

data/app/presenters/blacklight_range_limit/facet_item_presenter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module BlacklightRangeLimit
+  # Override the default item presenter to provide custom labels for
+  # range data.
+  class FacetItemPresenter < Blacklight::FacetItemPresenter
+    def label
+      label_for_range || super
+    end
+
+    private
+
+    def label_for_range
+      return unless value.is_a? Range
+
+      view_context.t(
+        range_limit_label_key,
+        begin: format_range_display_value(value.first),
+        begin_value: value.first,
+        end: format_range_display_value(value.last),
+        end_value: value.last
+      )
+    end
+
+    def range_limit_label_key
+      if value.first == value.last
+        'blacklight.range_limit.single_html'
+      else
+        'blacklight.range_limit.range_html'
+      end
+    end
+
+    ##
+    # A method that is meant to be overridden downstream to format how a range
+    # label might be displayed to a user. By default it just returns the value.
+    def format_range_display_value(value)
+      if view_context.method(:format_range_display_value).owner == RangeLimitHelper
+        value
+      else
+        Deprecation.warn(BlacklightRangeLimit, 'Helper method #format_range_display_value has been overridden; implement a custom FacetItemPresenter instead')
+        view_context.format_range_display_value(value, key)
+      end
+    end
+  end
+end

data/app/presenters/blacklight_range_limit/filter_field.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module BlacklightRangeLimit
+  # Modeling access to filter query parameters
+  class FilterField < Blacklight::SearchState::FilterField
+    # this accessor is unnecessary after Blacklight 7.25.0
+    attr_accessor :filters_key
+
+    def initialize(config, search_state)
+      super
+      @filters_key = :range
+    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
+      params = new_state.params
+
+      value = as_url_parameter(item)
+
+      if value.is_a? Range
+        param_key = filters_key
+        params[param_key] = (params[param_key] || {}).dup
+        params[param_key][config.key] = { begin: value.first, end: value.last }
+        new_state.reset(params)
+      else
+        super
+      end
+    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
+      params = new_state.params
+      value = as_url_parameter(item)
+
+      if value.is_a? Range
+        param_key = filters_key
+        params[param_key] = (params[param_key] || {}).dup
+        params[param_key]&.delete(config.key)
+        new_state.reset(params)
+      else
+        super
+      end
+    end
+
+    # @return [Array] an array of applied filters
+    def values(except: [])
+      params = search_state.params
+      param_key = filters_key
+      return [] unless params.dig(param_key, config.key)
+
+      range = if params.dig(param_key, config.key).is_a? Range
+        params.dig(param_key, config.key)
+      else
+        begins = Array(params.dig(param_key, config.key, :begin)).map(&:to_i)
+        ends = Array(params.dig(param_key, config.key, :end)).map(&:to_i)
+        begins.zip(ends).map { |b_bound, e_bound|  Range.new(b_bound, e_bound) }
+      end
+
+      f = except.include?(:filters) ? [] : Array(range)
+      f_missing = [] if except.include?(:missing)
+      f_missing ||= [Blacklight::SearchState::FilterField::MISSING] if params.dig(filters_key, "-#{key}")&.any? { |v| v == Blacklight::Engine.config.blacklight.facet_missing_param }
+
+      f + (f_missing || [])
+    end
+
+    # @param [String,#value] a filter to remove from the url
+    # @return [Boolean] whether the provided filter is currently applied/selected
+    delegate :include?, to: :values
+
+    # @since Blacklight v7.25.2
+    # normal filter fields demangle when they encounter a hash, which they assume to be a number-indexed map
+    # this filter should allow (expect) hashes if the keys include 'begin' or 'end'
+    def permitted_params
+      {
+        # { begin: [], end: [] } or [:begin, :end]
+        filters_key => { config.key => { begin: [], end: [] }, "-#{config.key}" => [] },
+        inclusive_filters_key => { config.key => { begin: [], end: [] } }
+      }
+    end
+  end
+end

data/app/views/blacklight_range_limit/_range_segments.html.erb

@@ -1,22 +1,8 @@
-<% # must pass in local variable :solr_field
-%>
+<% Deprecation.warn(BlacklightRangeLimit, 'The blacklight_range_limit/range_segments partial is deprecated. Render the RangeSegmentsComponent directly.') %>
 
-<ul class="facet-values list-unstyled">
-  <% solr_range_queries_to_a(solr_field).each do |hash| %>
-    <li>
-        <span class="facet-label">
-            <%= link_to(
-                  t('blacklight.range_limit.range_html',
-                    begin: format_range_display_value(hash[:from], solr_field),
-                    begin_value: hash[:from],
-                    end: format_range_display_value(hash[:to], solr_field),
-                    end_value: hash[:to]
-                  ),
-                  search_action_url(add_range(solr_field, hash[:from], hash[:to]).except(:controller, :action)),
-                  class: 'facet_select'
-              ) %>
-        </span>
-        <%= render_facet_count hash[:count], classes: ['count'] %>
-    </li>
-  <% end %>
-</ul>
+<%
+  facet = blacklight_config.facet_fields[solr_field]
+  display_facet = @response.aggregations[facet.field] || Blacklight::Solr::Response::Facets::FacetField.new(facet.key, [], response: @response)
+  presenter = (facet.presenter || BlacklightRangeLimit::FacetFieldPresenter).new(facet, display_facet, self)
+%>
+<%= render BlacklightRangeLimit::RangeSegmentsComponent.new(facet_field: presenter) %>

data/app/views/blacklight_range_limit/range_segments.html.erb

@@ -1 +1 @@
-<%= render :partial => "blacklight_range_limit/range_segments", :locals => {:solr_field => solr_field} %>
+<%= render BlacklightRangeLimit::RangeSegmentsComponent.new(facet_field: facet_field) %>

data/app/views/catalog/range_limit_panel.html.erb

@@ -0,0 +1 @@
+<%= render template: 'catalog/facet' %>

data/blacklight_range_limit.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
 
   s.license     = 'Apache 2.0'
 
-  s.add_dependency 'blacklight', '~> 7.0'
+  s.add_dependency 'blacklight', '>= 7.22.2', '< 9'
 
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rspec-rails'

data/config/locales/blacklight_range_limit.de.yml

@@ -0,0 +1,13 @@
+de:
+  blacklight:
+    range_limit:
+      range_begin: "%{field_label} Bereichsanfang"
+      range_end: "%{field_label} Bereichsende"
+      submit_limit: 'Anwenden'
+      remove_limit: 'Entfernen'
+      missing: 'Unbekannt'
+      view_distribution: 'Verteilung Anzeigen'
+      view_larger: 'Größer anzeigen »'
+      results_range_html: 'Aktuelle Ergebnisse reichen von <span class="min">%{min}</span> bis <span class="max">%{max}</span>'
+      single_html: '<span class="single" data-blrl-single="%{begin_value}">%{begin}</span>'
+      range_html: '<span class="from" data-blrl-begin="%{begin_value}">%{begin}</span> bis <span class="to" data-blrl-end="%{end_value}">%{end}</span>'

data/config/locales/blacklight_range_limit.it.yml

@@ -0,0 +1,13 @@
+it:
+  blacklight:
+    range_limit:
+      range_begin: "%{field_label} da"
+      range_end: "%{field_label} a"
+      submit_limit: 'Invia'
+      remove_limit: 'cancella'
+      missing: 'Data sconosciuta'
+      view_distribution: 'Visualizzazione della distribuzione'
+      view_larger: 'Visualizza più grande »'
+      results_range_html: 'Risultati attuali vanno da <span class="min">%{min}</span> a <span class="max">%{max}</span>'
+      single_html: '<span class="single" data-blrl-single="%{begin_value}">%{begin}</span>'
+      range_html: '<span class="from" data-blrl-begin="%{begin_value}">%{begin}</span> a <span class="to" data-blrl-end="%{end_value}">%{end}</span>'

data/lib/blacklight_range_limit/controller_override.rb

@@ -4,12 +4,37 @@
 require 'blacklight_range_limit/segment_calculation'
 module BlacklightRangeLimit
   module ControllerOverride
+    extend Deprecation
     extend ActiveSupport::Concern
 
+    RANGE_LIMIT_FIELDS = [:range_end, :range_field, :range_start].freeze
+
     included do
-      helper BlacklightRangeLimit::ViewHelperOverride
-      helper RangeLimitHelper
-      helper_method :has_range_limit_parameters?
+      before_action do
+        template = lookup_context.find_all('blacklight_range_limit/range_limit_panel', lookup_context.prefixes + [""], true, [:field_name], {}).first
+
+        if template
+          fields = blacklight_config.facet_fields.select { |_k, v| v.range && !v.had_existing_component_configuration }
+
+          fields.each_value do |facet_config|
+            Deprecation.warn(BlacklightRangeLimit, 'Found partial blacklight_range_limit/range_limit_panel, so falling back to legacy behavior.') unless facet_config.partial
+            facet_config.partial ||= 'blacklight_range_limit/range_limit_panel'
+            facet_config.component = nil
+          end
+        else
+          fields = blacklight_config.facet_fields.select { |_k, v| v.partial == 'blacklight_range_limit/range_limit_panel' }
+          fields.each_value do |facet_config|
+            Deprecation.warn(BlacklightRangeLimit, 'Ignoring partial configuration for missing blacklight_range_limit/range_limit_panel partial')
+            facet_config.partial = nil
+          end
+        end
+
+        # Blacklight 7.25+: Allow range limit params if necessary
+        if blacklight_config.search_state_fields
+          missing_keys = RANGE_LIMIT_FIELDS - blacklight_config.search_state_fields
+          blacklight_config.search_state_fields.concat(missing_keys)
+        end
+      end
     end
 
     # Action method of our own!
@@ -17,6 +42,9 @@ module BlacklightRangeLimit
     # Used when we need a second Solr query to get range facets, after the
     # first found min/max from result set.
     def range_limit
+      @facet = blacklight_config.facet_fields[params[:range_field]]
+      raise ActionController::RoutingError, 'Not Found' unless @facet&.range
+
       # We need to swap out the add_range_limit_params search param filter,
       # and instead add in our fetch_specific_range_limit filter,
       # to fetch only the range limit segments for only specific
@@ -26,33 +54,22 @@ module BlacklightRangeLimit
       @response, _ = search_service.search_results do |search_builder|
         search_builder.except(:add_range_limit_params).append(:fetch_specific_range_limit)
       end
-      render('blacklight_range_limit/range_segments', :locals => {:solr_field => params[:range_field]}, :layout => !request.xhr?)
-    end
 
-    # over-ride, call super, but make sure our range limits count too
-    def has_search_parameters?
-      super || has_range_limit_parameters?
-    end
+      display_facet = @response.aggregations[@facet.field] || Blacklight::Solr::Response::Facets::FacetField.new(@facet.key, [], response: @response)
 
-    def has_range_limit_parameters?(my_params = params)
-      my_params[:range] &&
-        my_params[:range].to_unsafe_h.any? do |key, v|
-          v.present? && v.respond_to?(:'[]') &&
-          (v["begin"].present? || v["end"].present? || v["missing"].present?)
-        end
+      @presenter = (@facet.presenter || BlacklightRangeLimit::FacetFieldPresenter).new(@facet, display_facet, view_context)
+
+      render 'blacklight_range_limit/range_segments', locals: { facet_field: @presenter }, layout: !request.xhr?
     end
 
     def range_limit_panel
-      @facet = blacklight_config.facet_fields[params[:id]]
-      raise ActionController::RoutingError, 'Not Found' unless @facet
-
-      @response = search_service.search_results.first
+      Deprecation.warn(BlacklightRangeLimit::ControllerOverride, 'range_limit_panel is deprecated; use the normal facet modal route instead')
+      facet
+    end
 
-      respond_to do |format|
-        format.html do
-          # Draw the partial for the "more" facet modal window:
-          return render 'blacklight_range_limit/range_limit_panel', layout: !request.xhr?
-        end
+    class_methods do
+      def default_range_config
+        BlacklightRangeLimit.default_range_config
       end
     end
   end

data/lib/blacklight_range_limit/engine.rb

@@ -15,5 +15,9 @@ module BlacklightRangeLimit
     config.action_dispatch.rescue_responses.merge!(
       "BlacklightRangeLimit::InvalidRange" => :not_acceptable
     )
+
+    config.before_configuration do
+      Blacklight::Configuration::FacetField.prepend BlacklightRangeLimit::FacetFieldConfigOverride
+    end
   end
 end

data/lib/blacklight_range_limit/facet_field_config_override.rb

@@ -0,0 +1,25 @@
+module BlacklightRangeLimit
+  # Override the upstream normalize method to inject range limit defaults
+  module FacetFieldConfigOverride
+    def normalize!(*args)
+      normalize_range! if range
+
+      super
+    end
+
+    def normalize_range!
+      self.had_existing_component_configuration = component.present?
+
+      if range.is_a? Hash
+        self.range_config = range
+        self.range = true
+      end
+
+      if range_config
+        self.range_config = range_config.reverse_merge(BlacklightRangeLimit.default_range_config[:range_config])
+      end
+
+      @table.reverse_merge!(BlacklightRangeLimit.default_range_config)
+    end
+  end
+end