blacklight 7.41.0 → 8.0.0.beta1

data/lib/blacklight/engine.rb

@@ -1,30 +1,11 @@
 # frozen_string_literal: true
-require 'blacklight/deprecations/engine_configuration'
+
 require 'view_component'
 
 module Blacklight
   class Engine < Rails::Engine
     engine_name "blacklight"
 
-    config.before_configuration do
-      # see https://github.com/fxn/zeitwerk#for_gem
-      # Blacklight puts a generator into LOCAL APP lib/generators, so tell
-      # zeitwerk to ignore the whole directory? If we're using zeitwerk
-      #
-      # https://github.com/cbeer/engine_cart/issues/117
-      if Rails.try(:autoloaders).try(:main).respond_to?(:ignore)
-        Rails.autoloaders.main.ignore(Rails.root.join('lib/generators'))
-      end
-    end
-
-    # BlacklightHelper is needed by all helpers, so we inject it
-    # into action view base here.
-    initializer 'blacklight.helpers' do
-      config.after_initialize do
-        ActionView::Base.include BlacklightHelper
-      end
-    end
-
     config.after_initialize do
       Blacklight::Configuration.initialize_default_configuration
     end
@@ -39,7 +20,9 @@ module Blacklight
     end
 
     initializer "blacklight.assets.precompile" do
-      PRECOMPILE_ASSETS = %w(favicon.ico blacklight/blacklight.js blacklight/blacklight.js.map).freeze
+      # rubocop:disable Lint/ConstantDefinitionInBlock
+      PRECOMPILE_ASSETS = %w(favicon.ico blacklight/blacklight.js blacklight/blacklight.js.map blacklight/blacklight.esm.js blacklight/blacklight.esm.js.map).freeze
+      # rubocop:enable Lint/ConstantDefinitionInBlock
 
       # When Rails has been generated in API mode, it does not have sprockets available
       if Rails.application.config.respond_to?(:assets)
@@ -47,6 +30,10 @@ module Blacklight
       end
     end
 
+    initializer "blacklight.importmap", before: "importmap" do |app|
+      app.config.importmap.paths << Engine.root.join("config/importmap.rb") if app.config.respond_to?(:importmap)
+    end
+
     bl_global_config = OpenStructWithHashAccess.new
 
     bl_global_config.sms_mappings = {
@@ -81,9 +68,6 @@ module Blacklight
     # Blacklight specific stuff in this single struct:
     Blacklight::Engine.config.blacklight = bl_global_config
 
-    # Deprecate top-level access to legacy engine configuration
-    Blacklight::Deprecations::EngineConfiguration.deprecate_in(Blacklight::Engine.config)
-
     config.action_dispatch.rescue_responses["Blacklight::Exceptions::RecordNotFound"] = :not_found
   end
 end

data/lib/blacklight/exceptions.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight
   module Exceptions
     class AccessDenied < StandardError
@@ -15,8 +16,7 @@ module Blacklight
 
     class ECONNREFUSED < ::Errno::ECONNREFUSED; end
 
-    # NOTE: In Blacklight 8, the parent class will be Timeout::Error
-    class RepositoryTimeout < InvalidRequest; end
+    class RepositoryTimeout < Timeout::Error; end
 
     class IconNotFound < StandardError
     end

data/lib/blacklight/nested_open_struct_with_hash_access.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
+
 require 'ostruct'
 module Blacklight
   ##
   # An OpenStruct refinement that converts any hash-keys into
   # additional instances of NestedOpenStructWithHashAccess
   class NestedOpenStructWithHashAccess < OpenStructWithHashAccess
-    extend Deprecation
-    self.deprecation_horizon = 'blacklight 8.0'
-
     attr_reader :nested_class
 
     delegate :default_proc=, to: :to_h
@@ -66,8 +64,8 @@ module Blacklight
       self.class.new nested_class, @table.deep_dup
     end
 
-    def select *args, &block
-      self.class.new nested_class, to_h.select(*args, &block)
+    def select(...)
+      self.class.new nested_class, to_h.select(...)
     end
 
     ##
@@ -100,15 +98,11 @@ module Blacklight
               m = mid[0...-1].to_sym
               new_ostruct_member!(m)
               @table[m] = args.first
-            elsif len.zero? && kwargs.blank? && !block
-              Deprecation.warn(Blacklight::NestedOpenStructWithHashAccess,
-                               "Initializing a #{nested_class} implicitly (by calling #{mid}) is deprecated. Call it as #{mid}! or pass initialize arguments")
-
-              new_ostruct_member!(mid)
-              @table[mid]
-            else
+            elsif len.positive? || kwargs.any? || block
               new_ostruct_member!(mid)
               @table[mid] = nested_class.new(key: mid, **(args.first || {}), **kwargs)
+            else
+              @table[mid]
             end
 
       block&.call(res)
@@ -120,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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'ostruct'
 module Blacklight
   ##
@@ -15,16 +16,16 @@ module Blacklight
       @table
     end
 
-    def select *args, &block
-      self.class.new to_h.select(*args, &block)
+    def select(...)
+      self.class.new to_h.select(...)
     end
 
-    def sort_by *args, &block
-      self.class.new Hash[to_h.sort_by(*args, &block)]
+    def sort_by(...)
+      self.class.new to_h.sort_by(...).to_h
     end
 
-    def sort_by! *args, &block
-      replace Hash[to_h.sort_by(*args, &block)]
+    def sort_by!(...)
+      replace to_h.sort_by(...).to_h
       self
     end
 
@@ -51,5 +52,21 @@ module Blacklight
     def deep_dup
       self.class.new @table.deep_dup
     end
+
+    def deep_transform_values(&method)
+      self.class.new @table.deep_transform_values(&method)
+    end
+
+    def try(method_name = nil, *args, &block)
+      if method_name.nil? && block_given?
+        if b.arity.zero?
+          instance_eval(&block)
+        else
+          yield self
+        end
+      elsif respond_to?(method_name)
+        public_send(method_name, *args, &b)
+      end
+    end
   end
 end

data/lib/blacklight/parameters.rb

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-require 'hashdiff'
-
 module Blacklight
   class Parameters
-    extend Deprecation
-
     ##
     # Sanitize the search parameters by removing unnecessary parameters
     # from the provided parameters.
     # @param [Hash] params parameters
     def self.sanitize params
-      params.reject { |_k, v| v.nil? }
+      params.reject { |_k, v| v.nil? } # rubocop:disable Style/CollectionCompact not available in Rails 6.0
             .except(:action, :controller, :id, :commit, :utf8)
     end
 
@@ -30,7 +26,7 @@ module Blacklight
       complex_params_from_b, scalar_params_from_b = b.flatten.uniq.partition { |x| x.is_a? Hash }
       complex_params_from_b = complex_params_from_b.inject({}) { |tmp, h| _deep_merge_permitted_param_hashes(h, tmp) }
 
-      (scalar_params_from_a + scalar_params_from_b + [_deep_merge_permitted_param_hashes(complex_params_from_a, complex_params_from_b)]).reject(&:blank?).uniq
+      (scalar_params_from_a + scalar_params_from_b + [_deep_merge_permitted_param_hashes(complex_params_from_a, complex_params_from_b)]).compact_blank.uniq
     end
 
     private_class_method def self._deep_merge_permitted_param_hashes(h1, h2)
@@ -74,33 +70,23 @@ module Blacklight
       if blacklight_config.filter_search_state_fields
         params.permit(*permitted_params)
       else
-        warn_about_deprecated_parameter_handling(params, permitted_params)
         params.deep_dup.permit!
       end
     end
 
     private
 
-    def warn_about_deprecated_parameter_handling(params, permitted_params)
-      diff = Hashdiff.diff(params.to_unsafe_h, params.permit(*permitted_params).to_h)
-      return if diff.empty?
-
-      Deprecation.warn(Blacklight::Parameters, "Blacklight 8 will filter out non-search parameter, including: #{diff.map { |_op, key, *| key }.to_sentence}")
-    end
-
     # Facebook's crawler turns array query parameters into a hash with numeric keys. Once we know
     # the expected parameter structure, we can unmangle those parameters to match our expected values.
     def deep_unmangle_params!(params, permitted_params)
       permitted_params.select { |p| p.is_a?(Hash) }.each do |permission|
         permission.each do |key, permitted_value|
-          if params[key].is_a?(ActionController::Parameters) && permitted_value.is_a?(Hash)
+          next unless params[key].is_a?(ActionController::Parameters)
+
+          if permitted_value.is_a?(Hash)
             deep_unmangle_params!(params[key], [permitted_value])
-          elsif permitted_value.is_a?(Array) && permitted_value.empty?
-            if params[key].is_a?(ActionController::Parameters) && params[key]&.keys&.all? { |k| k.to_s =~ /\A\d+\z/ }
-              params[key] = params[key].values
-            elsif params[key].is_a?(String)
-              params[key] = Array(params[key])
-            end
+          elsif permitted_value.is_a?(Array) && permitted_value.empty? && params[key]&.keys&.all? { |k| k.to_s =~ /\A\d+\z/ }
+            params[key] = params[key].values
           end
         end
       end

data/lib/blacklight/routes/exportable.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight
   module Routes
     class Exportable

data/lib/blacklight/routes/searchable.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight
   module Routes
     class Searchable
@@ -14,7 +15,7 @@ module Blacklight
         mapper.get ":id/raw", action: 'raw', as: 'raw', defaults: { format: 'json' }
 
         mapper.get "opensearch"
-        mapper.get 'suggest', as: 'suggest_index', defaults: { format: 'json' }
+        mapper.get 'suggest', as: 'suggest_index'
         mapper.get "facet/:id", action: 'facet', as: 'facet'
       end
     end

data/lib/blacklight/routes.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight
   module Routes
     require 'blacklight/routes/exportable'

data/lib/blacklight/search_builder.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight
   ##
   # Blacklight's SearchBuilder converts blacklight request parameters into
@@ -49,7 +50,6 @@ module Blacklight
     # @example
     #    search_builder.where(id: [1,2,3]) # produces: q:"{!lucene}id:(1 OR 2 OR 3)"
     def where(conditions)
-      Deprecation.warn(Blacklight::SearchBuilder, "SearchBuilder#where must be called with a hash, received #{conditions.inspect}.") unless conditions.is_a? Hash
       params_will_change!
       @search_state = @search_state.reset(@search_state.params.merge(q: conditions))
       @blacklight_params = @search_state.params
@@ -62,9 +62,9 @@ module Blacklight
     def append(*addl_processor_chain)
       params_will_change!
       builder = self.class.new(processor_chain + addl_processor_chain, scope)
-          .with(search_state)
-          .merge(@merged_params)
-          .reverse_merge(@reverse_merged_params)
+                    .with(search_state)
+                    .merge(@merged_params)
+                    .reverse_merge(@reverse_merged_params)
 
       builder.start = @start if @start
       builder.rows  = @rows if @rows
@@ -82,9 +82,9 @@ module Blacklight
     # chain are ignored as no-ops, rather than raising.
     def except(*except_processor_chain)
       builder = self.class.new(processor_chain - except_processor_chain, scope)
-          .with(search_state)
-          .merge(@merged_params)
-          .reverse_merge(@reverse_merged_params)
+                    .with(search_state)
+                    .merge(@merged_params)
+                    .reverse_merge(@reverse_merged_params)
 
       builder.start = @start if @start
       builder.rows  = @rows if @rows
@@ -121,9 +121,9 @@ module Blacklight
       return @params unless params_need_update?
 
       @params = processed_parameters
-                  .reverse_merge(@reverse_merged_params)
-                  .merge(@merged_params)
-                  .tap { clear_changes }
+                .reverse_merge(@reverse_merged_params)
+                .merge(@merged_params)
+                .tap { clear_changes }
     end
 
     alias_method :query, :to_hash

data/lib/blacklight/search_state/filter_field.rb

@@ -8,19 +8,13 @@ module Blacklight
 
       # @!attribute config
       #   @return [Blacklight::Configuration::FacetField]
-      attr_reader :config
-
       # @!attribute search_state
       #   @return [Blacklight::SearchState]
-      attr_reader :search_state
-
       # @!attribute param
       #   @return [String,Symbol]
-      attr_reader :filters_key
-
       # @!attribute inclusive_param
       #   @return [String,Symbol]
-      attr_reader :inclusive_filters_key
+      attr_reader :config, :search_state, :filters_key, :inclusive_filters_key
 
       # @return [String,Symbol]
       delegate :key, to: :config
@@ -47,9 +41,7 @@ module Blacklight
           end
         end
 
-        if item.respond_to?(:field) && item.field != key
-          return new_state.filter(item.field).add(item)
-        end
+        return new_state.filter(item.field).add(item) if item.respond_to?(:field) && item.field != key
 
         url_key = key
         params = new_state.params
@@ -82,9 +74,8 @@ module Blacklight
       # @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
+
+        return new_state.filter(item.field).remove(item) if item.respond_to?(:field) && item.field != key
 
         url_key = config.key
         params = new_state.params
@@ -106,13 +97,6 @@ module Blacklight
         params[param][url_key] = (params[param][url_key] || []).dup
 
         collection = params[param][url_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][url_key] = collection - Array(value)
         params[param].delete(url_key) if params[param][url_key].empty?
@@ -143,16 +127,15 @@ module Blacklight
       # @param [String,#value] item 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
+        return search_state.filter(item.field).selected?(item) if item.respond_to?(:field) && item.field != key
 
         value = as_url_parameter(item)
         params = search_state.params
 
-        if value.is_a?(Array)
+        case value
+        when Array
           (params.dig(inclusive_filters_key, key) || []).to_set == value.to_set
-        elsif value == Blacklight::SearchState::FilterField::MISSING
+        when Blacklight::SearchState::FilterField::MISSING
           (params.dig(filters_key, "-#{key}") || []).include?(Blacklight::Engine.config.blacklight.facet_missing_param)
         else
           (params.dig(filters_key, key) || []).include?(value)

data/lib/blacklight/search_state/pivot_filter_field.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Blacklight
+  class SearchState
+    # Modeling access to filter query parameters
+    class PivotFilterField < FilterField
+      STOP_VALUE = [:stop].freeze
+
+      # @return [Array]
+      delegate :pivot, to: :config
+
+      # @param [String,#value] item a filter item to add to the url
+      # @return [Blacklight::SearchState] new state
+      def add(item)
+        item = wrap_item(item)
+        new_state = search_state.reset_search
+        return new_state if include?(item)
+
+        pivot_values = pivot_fq(item).merge(pivot[0].to_sym => as_url_parameter(item))
+        pivot_values.inject(new_state) do |memo_state, entry|
+          url_key, value = entry
+          field_facade = FilterField.new(null_field(url_key), memo_state)
+          next memo_state if value.nil? || field_facade.include?(value)
+
+          field_facade.add(value)
+        end
+      end
+
+      # @param [String,#value] item a filter to remove from the url
+      # @return [Blacklight::SearchState] new state
+      def remove(item)
+        item = wrap_item(item)
+        new_state = search_state.reset_search
+        pivot_values = pivot_fq(item).merge(pivot[0].to_sym => as_url_parameter(item))
+        pivot_values.inject(new_state) do |memo_state, entry|
+          url_key, value = entry
+          next memo_state if value.nil?
+
+          FilterField.new(null_field(url_key), memo_state).remove(value)
+        end
+      end
+
+      # Matrix the values of the pivoted fields
+      # @return [Array] an array of applied filters
+      # rubocop:disable Lint/UnusedMethodArgument
+      def values(except: [])
+        return nil unless pivot.is_a?(Array) && pivot.present?
+
+        params = search_state.params
+        # values should have at most one terminal blank pivot
+        pivot_values = pivot.map { |k| Array(params.dig(:f, k)) || STOP_VALUE }
+        pivot_values = pivot_values[0..(pivot_values.index(STOP_VALUE) || -1)]
+        # put an explicit nil in for the matrix
+        pivot_values[-1] = [nil] if pivot_values.last == STOP_VALUE
+        top_level_values = pivot_values.shift
+        return [] if top_level_values.first.blank?
+
+        pivot_values.each { |pivot_value| pivot_value[0] ||= nil }
+        matrix_values = top_level_values.product(*pivot_values)
+        matrix_values.map do |vals|
+          PivotValue.new(value: vals.shift, fq: pivot[1..].map(&:to_sym).zip(vals).to_h)
+        end
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      # @param [String, #value #fq] item a filter may represent in the url
+      # @return [Boolean] whether the provided filter is currently applied/selected
+      def include?(item)
+        return false unless pivot.is_a?(Array) && pivot.present?
+
+        params = search_state.params
+        item = wrap_item(item)
+        pivot_values = pivot_fq(item).merge(pivot[0].to_sym => as_url_parameter(item))
+        pivot_values.inject(true) do |m, entry|
+          k, v = entry
+          m && params.dig(:f, k)&.include?(as_url_parameter(v))
+        end
+      end
+
+      class PivotValue
+        attr_accessor :value, :fq
+
+        delegate :blank?, :present?, to: :value
+        alias empty? blank?
+
+        def initialize(value: nil, fq: {}, **_args) # rubocop:disable Naming/MethodParameterName
+          @value = value
+          @fq = fq
+        end
+      end
+
+      class QueryBuilder
+        # @return [Array] filter_query, subqueries
+        def self.call(search_builder, 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)
+            value.fq.each do |entry|
+              k, v = entry
+              queries << search_builder.send(:facet_value_to_fq_string, k, v) if v
+            end
+            queries.uniq!
+          end
+          [(queries - existing)]
+        end
+      end
+
+      private
+
+      def null_field(key)
+        Blacklight::Configuration::NullField.new(key: key)
+      end
+
+      def pivot_fq(item = nil)
+        fq_keys = pivot[1..].map(&:to_sym)
+        null_values = fq_keys.index_with(nil)
+        return null_values unless item.respond_to?(:fq)
+
+        item_fq = item.fq.to_h.symbolize_keys.slice(*fq_keys)
+        null_values.merge item_fq
+      end
+
+      def wrap_item(item)
+        item = invert_item(item) if item.respond_to?(:field) && item.field.to_sym != pivot.first.to_sym
+        return item if item.respond_to? :value
+        return PivotValue.new(**item) if item.is_a? Hash
+
+        PivotValue.new(value: item, fq: pivot_fq)
+      end
+
+      # the parsed Blacklight::Solr::Response::Facets::FacetItem objects are inverted -
+      # the subordinate value is at the top, and the other values are in fq - to permit
+      # easier value labeling in the UI. To manage the search links, they need to be
+      # reinverted.
+      def invert_item(item)
+        item_fq = item.fq.symbolize_keys
+        item_value = item_fq.delete(pivot[0].to_sym)
+        item_fq = item_fq.merge(item.field.to_sym => item.value).slice(*pivot.map(&:to_sym))
+        PivotValue.new(value: item_value, fq: item_fq)
+      end
+    end
+  end
+end