blacklight 7.41.0 → 8.0.0.beta1

data/lib/blacklight/search_state.rb

@@ -1,21 +1,17 @@
 # frozen_string_literal: true
 
-require 'blacklight/deprecations/search_state_normalization'
 require 'blacklight/search_state/filter_field'
+require 'blacklight/search_state/pivot_filter_field'
 
 module Blacklight
   # This class encapsulates the search state as represented by the query
   # parameters namely: :f, :q, :page, :per_page and, :sort
   class SearchState
-    extend Deprecation
-    include Blacklight::Deprecations::SearchStateNormalization
-
     attr_reader :blacklight_config # Must be called blacklight_config, because Blacklight::Facet calls blacklight_config.
-    attr_reader :params
 
     # This method is never accessed in this class, but may be used by subclasses that need
     # to access the url_helpers
-    attr_reader :controller
+    attr_reader :controller, :params
 
     delegate :facet_configuration_for_field, to: :blacklight_config
 
@@ -33,34 +29,8 @@ module Blacklight
     end
     alias to_h to_hash
 
-    def to_unsafe_h
-      Deprecation.warn(self.class, 'Use SearchState#to_h instead of SearchState#to_unsafe_h')
-      to_hash
-    end
-
-    def method_missing(method_name, *arguments, &block)
-      if @params.respond_to?(method_name)
-        Deprecation.warn(self.class, "Calling `#{method_name}` on Blacklight::SearchState " \
-          'is deprecated and will be removed in Blacklight 8. Call #to_h first if you ' \
-          ' need to use hash methods (or, preferably, use your own SearchState implementation)')
-        @params.public_send(method_name, *arguments, &block)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      @params.respond_to?(method_name, include_private) || super
-    end
-
-    # Tiny shim to make it easier to migrate raw params access to using this class
-    delegate :[], to: :params
-    deprecation_deprecate :[]
-
     def has_constraints?
-      Deprecation.silence(Blacklight::SearchState) do
-        !(query_param.blank? && filter_params.blank? && filters.blank? && clause_params.blank?)
-      end
+      !(query_param.blank? && filters.blank? && clause_params.blank?)
     end
 
     def query_param
@@ -71,11 +41,6 @@ module Blacklight
       params[:clause] || {}
     end
 
-    def filter_params
-      params[:f] || {}
-    end
-    deprecation_deprecate filter_params: 'Use #filters instead'
-
     # @return [Blacklight::SearchState]
     def reset(params = nil)
       self.class.new(params || {}, blacklight_config, controller)
@@ -91,15 +56,20 @@ module Blacklight
     # to provide more interesting routing to
     # documents
     def url_for_document(doc, options = {})
-      if respond_to?(:blacklight_config) &&
-          blacklight_config.view_config(:show).route &&
-          (!doc.respond_to?(:to_model) || doc.to_model.is_a?(SolrDocument))
-        route = blacklight_config.view_config(:show).route.merge(action: :show, id: doc).merge(options)
-        route[:controller] = params[:controller] if route[:controller] == :current
-        route
-      else
-        doc
-      end
+      return doc unless routable?(doc)
+
+      route = blacklight_config.view_config(:show).route.merge(action: :show, id: doc).merge(options)
+      route[:controller] = params[:controller] if route[:controller] == :current
+      route
+    end
+
+    # To build a show route, we must have a blacklight_config that has
+    # configured show views, and the doc must appropriate to the config
+    # @return [Boolean]
+    def routable?(doc)
+      return false unless respond_to?(:blacklight_config) && blacklight_config.view_config(:show).route
+
+      doc.is_a? routable_model_for(blacklight_config)
     end
 
     def remove_query_params
@@ -116,6 +86,7 @@ module Blacklight
       @filters ||= filter_fields.select(&:any?)
     end
 
+    # @return [FilterField]
     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]
@@ -124,15 +95,6 @@ module Blacklight
       (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)
-      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
     # search constraints. Remove any paginator-specific request
@@ -141,9 +103,7 @@ 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 = Deprecation.silence(self.class) do
-        add_facet_params(field, item).to_h.with_indifferent_access
-      end
+      new_params = filter(field).add(item).to_h
 
       # Delete any request params from facet-specific action, needed
       # to redir to index action properly.
@@ -153,26 +113,6 @@ module Blacklight
       new_params
     end
 
-    # copies the current params (or whatever is passed in as the 3rd arg)
-    # removes the field value from params[:f]
-    # removes the field if there are no more values in params[:f][field]
-    # removes additional params (page, id, etc..)
-    # @param [String] field
-    # @param [String] item
-    def remove_facet_params(field, item)
-      filter(field).remove(item).params
-    end
-    deprecation_deprecate remove_facet_params: 'Use filter(field).remove(item) instead'
-
-    def has_facet?(config, value: nil)
-      if value
-        filter(config).include?(value)
-      else
-        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
     # @return [ActionController::Parameters] the current search parameters after being sanitized by Blacklight::Parameters.sanitize
@@ -230,6 +170,10 @@ module Blacklight
 
     private
 
+    def routable_model_for(blacklight_config)
+      blacklight_config.document_model || ::SolrDocument
+    end
+
     def search_field_key
       params[:search_field]
     end

data/lib/blacklight/solr/document.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 ##
 ##
 # = Introduction

data/lib/blacklight/solr/facet_paginator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight::Solr
   # Pagination for facet values -- works by setting the limit to max
   # displayable. You have to ask Solr for limit+1, to get enough

data/lib/blacklight/solr/repository.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight::Solr
   class Repository < Blacklight::AbstractRepository
     ##
@@ -16,20 +17,11 @@ module Blacklight::Solr
       solr_response
     end
 
-    # Find multiple documents by their ids
-    # @param [Hash] _params query parameters
-    def find_many(params)
-      search(params: params, path: blacklight_config.fetch_many_documents_path)
-    end
-
     ##
     # Execute a search query against solr
     # @param [Hash] 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 })
-
-      send_and_receive(path || default_search_path(request_params), request_params)
+    def search params = {}
+      send_and_receive blacklight_config.solr_path, params.reverse_merge(qt: blacklight_config.qt)
     end
 
     # @param [Hash] request_params
@@ -86,7 +78,7 @@ module Blacklight::Solr
     # @return [Hash]
     # @!visibility private
     def build_solr_request(solr_params)
-      if uses_json_query_dsl?(solr_params)
+      if solr_params[:json].present?
         {
           data: { params: solr_params.to_hash.except(:json) }.merge(solr_params[:json]).to_json,
           method: :post,
@@ -130,17 +122,5 @@ module Blacklight::Solr
         []
       end
     end
-
-    # @return [String]
-    def default_search_path(solr_params)
-      return blacklight_config.json_solr_path if blacklight_config.json_solr_path && uses_json_query_dsl?(solr_params)
-
-      blacklight_config.solr_path
-    end
-
-    # @return [Boolean]
-    def uses_json_query_dsl?(solr_params)
-      solr_params[:json].present?
-    end
   end
 end

data/lib/blacklight/solr/request.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class Blacklight::Solr::InvalidParameter < ArgumentError; end
 
 class Blacklight::Solr::Request < ActiveSupport::HashWithIndifferentAccess

data/lib/blacklight/solr/response/facets.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'ostruct'
 
 module Blacklight::Solr::Response::Facets
@@ -109,7 +110,7 @@ module Blacklight::Solr::Response::Facets
   # Get all the Solr facet data (fields, queries, pivots) as a hash keyed by
   # both the Solr field name and/or by the blacklight field name
   def aggregations
-    @aggregations ||= {}.merge(facet_field_aggregations).merge(facet_query_aggregations).merge(facet_pivot_aggregations).merge(json_facet_aggregations)
+    @aggregations ||= default_aggregations.merge(facet_field_aggregations).merge(facet_query_aggregations).merge(facet_pivot_aggregations).merge(json_facet_aggregations)
   end
 
   def facet_counts
@@ -123,7 +124,7 @@ module Blacklight::Solr::Response::Facets
 
       # this is some old solr (1.4? earlier?) serialization of facet fields
       if val.is_a? Array
-        Hash[val]
+        val.to_h
       else
         val
       end
@@ -151,6 +152,21 @@ module Blacklight::Solr::Response::Facets
 
   private
 
+  # @return [Hash] establish a null object pattern for facet data look-up, allowing
+  #   the response and applied parameters to get passed through even if there was no
+  #   facet data in the response
+  def default_aggregations
+    @default_aggregations ||= begin
+      h = Hash.new { |key| null_facet_field_object(key) }
+      h.with_indifferent_access
+    end
+  end
+
+  # @return [Blacklight::Solr::Response::FacetField] a "null object" facet field
+  def null_facet_field_object(key)
+    Blacklight::Solr::Response::FacetField.new(key, [], facet_field_aggregation_options(key).merge(response: self))
+  end
+
   ##
   # Convert Solr responses of various json.nl flavors to
   def list_as_hash solr_list
@@ -161,10 +177,10 @@ module Blacklight::Solr::Response::Facets
       solr_list.transform_values do |values|
         if values.first.is_a? Array
           # arrarr
-          Hash[values]
+          values.to_h
         else
           # flat
-          Hash[values.each_slice(2).to_a]
+          values.each_slice(2).to_a.to_h
         end
       end
     end
@@ -180,7 +196,7 @@ module Blacklight::Solr::Response::Facets
 
         # legacy solr facet.missing serialization
         if value.nil?
-          i.label = I18n.t(:"blacklight.search.fields.facet.missing.#{facet_field_name}", default: [:"blacklight.search.facets.missing"])
+          i.label = I18n.t(:"blacklight.search.fields.facet.missing.#{facet_field_name}", default: [:'blacklight.search.facets.missing'])
           i.fq = "-#{facet_field_name}:[* TO *]" # this explicit fq is deprecated; the missing attribute below is a better thing to check for this case
           i.value = Blacklight::SearchState::FilterField::MISSING
           i.missing = true

data/lib/blacklight/solr/response/group.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class Blacklight::Solr::Response::Group
   include Blacklight::Solr::Response::PaginationMethods
 

data/lib/blacklight/solr/response/group_response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class Blacklight::Solr::Response::GroupResponse
   include Blacklight::Solr::Response::PaginationMethods
 

data/lib/blacklight/solr/response/more_like_this.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight::Solr::Response::MoreLikeThis
   def more_like document
     mlt = more_like_this[document.id]

data/lib/blacklight/solr/response/pagination_methods.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
+
 module Blacklight::Solr::Response::PaginationMethods
   include Kaminari::PageScopeMethods
   include Kaminari::ConfigurationMethods::ClassMethods
 
-  def limit_value #:nodoc:
+  def limit_value # :nodoc:
     rows
   end
 
-  def offset_value #:nodoc:
+  def offset_value # :nodoc:
     start
   end
 
-  def total_count #:nodoc:
+  def total_count # :nodoc:
     total
   end
 

data/lib/blacklight/solr/response/params.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight::Solr::Response::Params
   # From https://solr.apache.org/guide/8_8/json-request-api.html#supported-properties-and-syntax
   QUERY_PARAMETER_TO_JSON_PARAMETER_MAPPING = {
@@ -29,9 +30,9 @@ module Blacklight::Solr::Response::Params
   def facet_field_aggregation_options(facet_field_name)
     defaults = {
       sort: single_valued_param(:'facet.sort'),
-      limit: single_valued_param(:"facet.limit")&.to_i || 100,
-      offset: single_valued_param(:"facet.offset")&.to_i || 0,
-      prefix: single_valued_param(:"facet.prefix")
+      limit: single_valued_param(:'facet.limit')&.to_i || 100,
+      offset: single_valued_param(:'facet.offset')&.to_i || 0,
+      prefix: single_valued_param(:'facet.prefix')
     }
 
     json_facet = json_params.dig('facet', facet_field_name)&.slice(:limit, :offset, :prefix, :sort)&.symbolize_keys || {}
@@ -41,7 +42,7 @@ module Blacklight::Solr::Response::Params
       limit: single_valued_param(:"f.#{facet_field_name}.facet.limit")&.to_i,
       offset: single_valued_param(:"f.#{facet_field_name}.facet.offset")&.to_i,
       prefix: single_valued_param(:"f.#{facet_field_name}.facet.prefix")
-    }.reject { |_k, v| v.nil? }
+    }.compact
 
     options = defaults.merge(json_facet).merge(param_facet)
     options[:sort] ||= options[:limit].positive? ? 'count' : 'index'

data/lib/blacklight/solr/response/response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight::Solr::Response::Response
   def response
     self[:response] || {}

data/lib/blacklight/solr/response/spelling.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # A mixin for making access to the spellcheck component data easy.
 #
 # response.spelling.words

data/lib/blacklight/solr/response.rb

@@ -1,5 +1,18 @@
 # frozen_string_literal: true
+
 class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
+  extend ActiveSupport::Autoload
+  eager_autoload do
+    autoload :PaginationMethods
+    autoload :Response
+    autoload :Spelling
+    autoload :Facets
+    autoload :MoreLikeThis
+    autoload :GroupResponse
+    autoload :Group
+    autoload :Params
+  end
+
   include PaginationMethods
   include Spelling
   include Facets
@@ -66,11 +79,11 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
     when Array
       value.each { |v| force_to_utf8(v) }
     when String
-      if value.encoding != Encoding::UTF_8
+      if value.encoding == Encoding::UTF_8
+        value
+      else
         Blacklight.logger&.warn "Found a non utf-8 value in Blacklight::Solr::Response. \"#{value}\" Encoding is #{value.encoding}"
         value.dup.force_encoding('UTF-8')
-      else
-        value
       end
     end
     value

data/lib/blacklight/solr/search_builder_behavior.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight::Solr
   module SearchBuilderBehavior
     extend ActiveSupport::Concern
@@ -30,16 +31,6 @@ module Blacklight::Solr
     end
 
     def add_search_field_default_parameters(solr_parameters)
-      ###
-      # 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.
-      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
@@ -55,11 +46,6 @@ 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)
-      unless processor_chain.include?(:add_search_field_default_parameters)
-        Deprecation.warn(Blacklight::Solr::SearchBuilderBehavior, 'Please include :add_search_field_default_parameters in your process chain')
-        add_search_field_default_parameters(solr_parameters)
-      end
-
       ##
       # Create Solr 'q' including the user-entered q, prefixed by any
       # solr LocalParams in config, using solr LocalParams syntax.
@@ -71,12 +57,7 @@ module Blacklight::Solr
         add_search_field_with_json_query_parameters(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
-        if search_state.query_param == @additional_filters && !processor_chain.include?(:add_additional_filters)
-          Deprecation.warn(Blacklight::Solr::SearchBuilderBehavior, 'Expecting to see the processor step add_additional_filters; falling back to legacy query handling')
-          add_additional_filters(solr_parameters, search_state.query_param)
-        end
-      elsif search_state.query_param
+      elsif !search_state&.query_param.is_a?(Hash)
         solr_parameters.append_query search_state.query_param
       end
     end
@@ -102,10 +83,7 @@ module Blacklight::Solr
     end
 
     def add_search_field_with_json_query_parameters(solr_parameters)
-      return unless search_state.query_param
-
       bool_query = search_field.clause_params.transform_values { |v| v.merge(query: search_state.query_param) }
-      solr_parameters["spellcheck.q"] ||= search_state.query_param
 
       solr_parameters.append_boolean_query(:must, bool_query)
     end
@@ -154,9 +132,9 @@ module Blacklight::Solr
           end
           solr_parameters.merge!(subqueries) if subqueries
         else
-          filter.values.reject(&:blank?).each do |value|
+          filter.values.compact_blank.each do |value|
             filter_query, subqueries = if value.is_a?(Array)
-                                         facet_inclusive_value_to_fq_string(filter.key, value.reject(&:blank?))
+                                         facet_inclusive_value_to_fq_string(filter.key, value.compact_blank)
                                        else
                                          facet_value_to_fq_string(filter.config.key, value)
                                        end
@@ -285,7 +263,7 @@ module Blacklight::Solr
 
       # Now override with our specific things for fetching facet values
       facet_ex = facet_config.respond_to?(:ex) ? facet_config.ex : nil
-      solr_params[:"facet.field"] = with_ex_local_param(facet_ex, facet_config.field)
+      solr_params[:'facet.field'] = with_ex_local_param(facet_ex, facet_config.field)
 
       # Need to set as f.facet_field.facet.* to make sure we
       # override any field-specific default in the solr request handler.
@@ -342,9 +320,9 @@ module Blacklight::Solr
       options[:quote] ||= '"'
       unless val =~ /^[a-zA-Z0-9$_\-\^]+$/
         val = options[:quote] +
-          # Yes, we need crazy escaping here, to deal with regexp esc too!
-          val.gsub("'", "\\\\\'").gsub('"', "\\\\\"") +
-          options[:quote]
+              # Yes, we need crazy escaping here, to deal with regexp esc too!
+              val.gsub("'", "\\\\\'").gsub('"', "\\\\\"") +
+              options[:quote]
       end
       val
     end
@@ -353,6 +331,7 @@ module Blacklight::Solr
 
     ##
     # Convert a facet/value pair into a solr fq parameter
+    # rubocop:disable Metrics/PerceivedComplexity
     def facet_value_to_fq_string(facet_field, value, use_local_params: true)
       facet_config = blacklight_config.facet_fields[facet_field]
 
@@ -375,9 +354,10 @@ module Blacklight::Solr
       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)}"
+        "{!term f=#{solr_field}#{" #{local_params.join(' ')}" unless local_params.empty?}}#{convert_to_term_value(value)}"
       end
     end
+    # rubocop:enable Metrics/PerceivedComplexity
 
     def facet_inclusive_value_to_fq_string(facet_field, values)
       return if values.blank?
@@ -397,13 +377,14 @@ module Blacklight::Solr
         "{!query v=$#{k}}"
       end.join(' OR ')
 
-      ["{!lucene#{(' ' + local_params.join(' ')) unless local_params.empty?}}#{filter_query}", solr_filters]
+      ["{!lucene#{" #{local_params.join(' ')}" unless local_params.empty?}}#{filter_query}", solr_filters]
     end
 
     def convert_to_term_value(value)
-      if value.is_a?(DateTime) || value.is_a?(Time)
+      case value
+      when DateTime, Time
         value.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
-      elsif value.is_a?(Date)
+      when Date
         value.to_time(:local).strftime("%Y-%m-%dT%H:%M:%SZ")
       else
         value.to_s
@@ -437,7 +418,7 @@ module Blacklight::Solr
 
     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: "'")
+        "#{key}=#{solr_param_quote(val, quote: "'")}"
       end.join(" ")
       solr_parameters.append_query "{!#{local_params}}#{search_state.query_param}"
 

data/lib/blacklight/solr.rb

@@ -1,5 +1,12 @@
 # frozen_string_literal: true
+
 module Blacklight
   module Solr
+    autoload :Document, 'blacklight/solr/document'
+    autoload :FacetPaginator, 'blacklight/solr/facet_paginator'
+    autoload :Repository, 'blacklight/solr/repository'
+    autoload :Request, 'blacklight/solr/request'
+    autoload :Response, 'blacklight/solr/response'
+    autoload :SearchBuilderBehavior, 'blacklight/solr/search_builder_behavior'
   end
 end

data/lib/blacklight/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Blacklight
   unless Blacklight.const_defined? :VERSION
     def self.version

data/lib/blacklight.rb

@@ -1,14 +1,23 @@
 # frozen_string_literal: true
+
 require 'kaminari'
-require 'deprecation'
+require 'blacklight/open_struct_with_hash_access'
+require 'blacklight/nested_open_struct_with_hash_access'
 require 'jbuilder'
-require "zeitwerk"
-loader = Zeitwerk::Loader.for_gem
-loader.ignore("#{__dir__}/generators")
-loader.setup
 
 module Blacklight
-  extend Deprecation
+  autoload :AbstractRepository, 'blacklight/abstract_repository'
+  autoload :Component, 'blacklight/component'
+  autoload :Configuration, 'blacklight/configuration'
+  autoload :Exceptions,  'blacklight/exceptions'
+  autoload :Parameters,  'blacklight/parameters'
+  autoload :Routes,      'blacklight/routes'
+  autoload :RuntimeRegistry, 'blacklight/runtime_registry'
+  autoload :SearchBuilder, 'blacklight/search_builder'
+  autoload :SearchState, 'blacklight/search_state'
+  autoload :Solr, 'blacklight/solr'
+
+  require 'blacklight/version'
   require 'blacklight/engine' if defined?(Rails)
 
   def self.blacklight_config_file
@@ -58,9 +67,6 @@ module Blacklight
 
   def defaults_version
     @defaults_version ||= blacklight_yml['load_defaults'] ||
-                          # this config parameter was introduced in Blacklight 7.11, so to be safe,
-                          # we pin any 7.x app to the 7.10 behavior
-                          (Blacklight::VERSION.starts_with?('7') && '7.10.0') ||
                           Blacklight::VERSION
 
     @defaults_version == 'latest' ? Blacklight::VERSION : @defaults_version
@@ -76,13 +82,17 @@ module Blacklight
     end
 
     begin
-      blacklight_erb = ERB.new(IO.read(blacklight_config_file)).result(binding)
+      blacklight_erb = ERB.new(File.read(blacklight_config_file)).result(binding)
     rescue StandardError, SyntaxError => e
       raise("#{blacklight_config_file} was found, but could not be parsed with ERB. \n#{e.inspect}")
     end
 
     begin
-      @blacklight_yml = YAML.safe_load(blacklight_erb, aliases: true)
+      @blacklight_yml = if RUBY_VERSION > '2.6'
+                          YAML.safe_load(blacklight_erb, aliases: true)
+                        else
+                          YAML.safe_load(blacklight_erb, [], [], true)
+                        end
     rescue => e
       raise("#{blacklight_config_file} was found, but could not be parsed.\n#{e.inspect}")
     end
@@ -99,9 +109,7 @@ module Blacklight
   end
 
   def self.logger
-    @logger ||= begin
-      ::Rails.logger if defined? Rails && Rails.respond_to?(:logger)
-    end
+    @logger ||= (::Rails.logger if defined? Rails && Rails.respond_to?(:logger))
   end
 
   def self.logger= logger
@@ -120,4 +128,8 @@ module Blacklight
   def self.root
     @root ||= File.expand_path(File.dirname(File.dirname(__FILE__)))
   end
+
+  def self.deprecation
+    @deprecation ||= ActiveSupport::Deprecation.new('9.0', 'Blacklight')
+  end
 end