blacklight 6.25.0 → 7.0.0.rc1

data/lib/blacklight/search_state.rb

@@ -46,9 +46,9 @@ module Blacklight
     # to provide more interesting routing to
     # documents
     def url_for_document(doc, options = {})
-      if respond_to?(:blacklight_config) and
-          blacklight_config.show.route and
-          (!doc.respond_to?(:to_model) or doc.to_model.is_a? SolrDocument)
+      if respond_to?(:blacklight_config) &&
+          blacklight_config.show.route &&
+          (!doc.respond_to?(:to_model) || doc.to_model.is_a?(SolrDocument))
         route = blacklight_config.show.route.merge(action: :show, id: doc).merge(options)
         route[:controller] = params[:controller] if route[:controller] == :current
         route
@@ -66,7 +66,7 @@ module Blacklight
 
       add_facet_param(p, field, item)
 
-      if item and item.respond_to?(:fq) and item.fq
+      if item && item.respond_to?(:fq) && item.fq
         Array(item.fq).each do |f, v|
           add_facet_param(p, f, v)
         end
@@ -132,7 +132,7 @@ module Blacklight
     # @param [Hash] params_to_merge to merge into above
     # @return [ActionController::Parameters] the current search parameters after being sanitized by Blacklight::Parameters.sanitize
     # @yield [params] The merged parameters hash before being sanitized
-    def params_for_search(params_to_merge={}, &block)
+    def params_for_search(params_to_merge = {})
       # params hash we'll return
       my_params = params.dup.merge(self.class.new(params_to_merge, blacklight_config, controller))
 
@@ -140,7 +140,7 @@ module Blacklight
         yield my_params
       end
 
-      if my_params[:page] and (my_params[:per_page] != params[:per_page] or my_params[:sort] != params[:sort] )
+      if my_params[:page] && (my_params[:per_page] != params[:per_page] || my_params[:sort] != params[:sort])
         my_params[:page] = 1
       end
 
@@ -165,7 +165,7 @@ module Blacklight
         item
       end
     end
-    
+
     def add_facet_param(p, field, item)
       if item.respond_to? :field
         field = item.field
@@ -180,7 +180,7 @@ module Blacklight
       p[:f] = (p[:f] || {}).dup # the command above is not deep in rails3, !@#$!@#$
       p[:f][url_field] = (p[:f][url_field] || []).dup
 
-      if facet_config.single and p[:f][url_field].present?
+      if facet_config.single && p[:f][url_field].present?
         p[:f][url_field] = []
       end
 

data/lib/blacklight/solr/repository.rb

@@ -22,31 +22,8 @@ module Blacklight::Solr
       send_and_receive blacklight_config.solr_path, params.reverse_merge(qt: blacklight_config.qt)
     end
 
-    # @param [Hash] params
-    # @return [Blacklight::Suggest::Response]
-    def suggestions(request_params)
-      suggest_results = connection.send_and_receive(suggest_handler_path, params: request_params)
-      Blacklight::Suggest::Response.new suggest_results, request_params, suggest_handler_path, suggester_name
-    end
-
-    ##
-    # Gets a list of available fields
-    # @return [Hash]
-    def reflect_fields
-      send_and_receive('admin/luke', params: { fl: '*', 'json.nl' => 'map' })['fields']
-    end
-
-    ##
-    # @return [boolean] true if the repository is reachable
-    def ping
-      response = connection.send_and_receive 'admin/ping', {}
-      Blacklight.logger.info("Ping [#{connection.uri}] returned: '#{response['status']}'")
-      response['status'] == "OK"
-    end
-
     ##
     # Execute a solr query
-    # 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
@@ -58,12 +35,12 @@ module Blacklight::Solr
     def send_and_receive(path, solr_params = {})
       benchmark("Solr fetch", level: :debug) do
         key = blacklight_config.http_method == :post ? :data : :params
-        res = connection.send_and_receive(path, {key=>solr_params.to_hash, method: blacklight_config.http_method})
+        res = connection.send_and_receive(path, { key => solr_params.to_hash, method: blacklight_config.http_method })
 
         solr_response = blacklight_config.response_model.new(res, solr_params, document_model: blacklight_config.document_model, blacklight_config: blacklight_config)
 
         Blacklight.logger.debug("Solr query: #{blacklight_config.http_method} #{path} #{solr_params.to_hash.inspect}")
-        Blacklight.logger.debug("Solr response: #{solr_response.inspect}") if defined?(::BLACKLIGHT_VERBOSE_LOGGING) and ::BLACKLIGHT_VERBOSE_LOGGING
+        Blacklight.logger.debug("Solr response: #{solr_response.inspect}") if defined?(::BLACKLIGHT_VERBOSE_LOGGING) && ::BLACKLIGHT_VERBOSE_LOGGING
         solr_response
       end
     rescue Errno::ECONNREFUSED => e
@@ -72,17 +49,7 @@ module Blacklight::Solr
       raise Blacklight::Exceptions::InvalidRequest, e.message
     end
 
-    protected
-
-    ##
-    # @return [String]
-    def suggest_handler_path
-      blacklight_config.autocomplete_path
-    end
-
-    def suggester_name
-      blacklight_config.autocomplete_suggester
-    end
+    private
 
     def build_connection
       RSolr.connect(connection_config.merge(adapter: connection_config[:http_adapter]))

data/lib/blacklight/solr/request.rb

@@ -38,6 +38,6 @@ class Blacklight::Solr::Request < ActiveSupport::HashWithIndifferentAccess
   end
 
   def to_hash
-    reject {|key, value| ARRAY_KEYS.include?(key) && value.blank?}
+    reject { |key, value| ARRAY_KEYS.include?(key) && value.blank? }
   end
 end

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

@@ -13,7 +13,7 @@ module Blacklight::Solr::Response::Facets
 
       options[:value] = value if value
       options[:hits] = hits if hits
-      
+
       super(options)
     end
 
@@ -25,7 +25,7 @@ module Blacklight::Solr::Response::Facets
       table.as_json(props)
     end
   end
-  
+
   # represents a facet; which is a field and its values
   class FacetField
     attr_reader :name, :items
@@ -58,14 +58,14 @@ module Blacklight::Solr::Response::Facets
     def count?
       sort == 'count'
     end
-    
+
     private
 
     # Per https://wiki.apache.org/solr/SimpleFacetParameters#facet.limit
     def solr_default_limit
       100
     end
-    
+
     # Per https://wiki.apache.org/solr/SimpleFacetParameters#facet.sort
     def solr_default_sort
       if limit > 0
@@ -74,7 +74,7 @@ module Blacklight::Solr::Response::Facets
         'index'
       end
     end
-    
+
     # Per https://wiki.apache.org/solr/SimpleFacetParameters#facet.offset
     def solr_default_offset
       0
@@ -86,7 +86,7 @@ module Blacklight::Solr::Response::Facets
   end
 
   ##
-  # Get all the Solr facet data (fields, queries, pivots) as a hash keyed by 
+  # 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)
@@ -114,7 +114,7 @@ module Blacklight::Solr::Response::Facets
   def facet_queries
     @facet_queries ||= facet_counts['facet_queries'] || {}
   end
-  
+
   # Returns all of the facet queries
   def facet_pivot
     @facet_pivot ||= facet_counts['facet_pivot'] || {}
@@ -123,7 +123,7 @@ module Blacklight::Solr::Response::Facets
   private
 
   ##
-  # Convert Solr responses of various json.nl flavors to 
+  # Convert Solr responses of various json.nl flavors to
   def list_as_hash solr_list
     # map
     if solr_list.values.first.is_a? Hash
@@ -131,12 +131,12 @@ module Blacklight::Solr::Response::Facets
     else
       solr_list.each_with_object({}) do |(key, values), hash|
         hash[key] = if values.first.is_a? Array
-          # arrarr
-          Hash[values]
-        else
-          # flat
-          Hash[values.each_slice(2).to_a]
-        end
+                      # arrarr
+                      Hash[values]
+                    else
+                      # flat
+                      Hash[values.each_slice(2).to_a]
+                    end
       end
     end
   end
@@ -164,9 +164,9 @@ module Blacklight::Solr::Response::Facets
                                               options)
 
       # alias all the possible blacklight config names..
-      blacklight_config.facet_fields.select { |k,v| v.field == facet_field_name }.each do |key,_|
+      blacklight_config.facet_fields.select { |_k, v| v.field == facet_field_name }.each_key do |key|
         hash[key] = hash[facet_field_name]
-      end if blacklight_config and !blacklight_config.facet_fields[facet_field_name]
+      end if blacklight_config && !blacklight_config.facet_fields[facet_field_name]
     end
   end
 
@@ -193,36 +193,36 @@ module Blacklight::Solr::Response::Facets
   def facet_query_aggregations
     return {} unless blacklight_config
 
-    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|
-          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])
-        end
+    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|
+        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])
+      end
 
-        hash[field_name] = Blacklight::Solr::Response::Facets::FacetField.new field_name, items
+      hash[field_name] = Blacklight::Solr::Response::Facets::FacetField.new field_name, items
     end
   end
 
   ##
-  # Convert Solr's facet_pivot response into 
+  # Convert Solr's facet_pivot response into
   # a hash of Blacklight::Solr::Response::Facet::FacetField objects
   def facet_pivot_aggregations
     facet_pivot.each_with_object({}) do |(field_name, values), hash|
-      next unless blacklight_config and !blacklight_config.facet_fields[field_name]
+      next unless blacklight_config && !blacklight_config.facet_fields[field_name]
 
       items = values.map do |lst|
         construct_pivot_field(lst)
       end
 
       # alias all the possible blacklight config names..
-      blacklight_config.facet_fields.select { |k,v| v.pivot and v.pivot.join(",") == field_name }.each do |key, _|
+      blacklight_config.facet_fields.select { |_k, v| v.pivot && v.pivot.join(",") == field_name }.each_key do |key|
         hash[key] = Blacklight::Solr::Response::Facets::FacetField.new key, items
       end
     end
   end
-  
+
   ##
   # Recursively parse the pivot facet response to build up the full pivot tree
   def construct_pivot_field lst, parent_fq = {}
@@ -232,6 +232,4 @@ module Blacklight::Solr::Response::Facets
 
     Blacklight::Solr::Response::Facets::FacetItem.new(value: lst[:value], hits: lst[:count], field: lst[:field], items: items, fq: parent_fq)
   end
-  
-  
-end # end Facets
+end

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

@@ -3,7 +3,7 @@ class Blacklight::Solr::Response::Group
   include Blacklight::Solr::Response::PaginationMethods
 
   attr_reader :key, :group, :response
-  
+
   def initialize key, group, response
     @key = key
     @group = group
@@ -18,13 +18,13 @@ class Blacklight::Solr::Response::Group
   def total
     doclist[:numFound].to_s.to_i
   end
-    
+
   def start
     doclist[:start].to_s.to_i
   end
 
   def docs
-    doclist[:docs].map {|doc| SolrDocument.new(doc, response)}
+    doclist[:docs].map { |doc| SolrDocument.new(doc, response) }
   end
 
   def field

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

@@ -27,7 +27,7 @@ class Blacklight::Solr::Response::GroupResponse
     # fall back on the number of facet items for that field?
     (group["ngroups"] || (response.aggregations[key] || []).length).to_s.to_i
   end
-    
+
   def start
     params[:start].to_s.to_i
   end

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

@@ -2,14 +2,14 @@
 module Blacklight::Solr::Response::MoreLikeThis
   def more_like document
     mlt = more_like_this[document.id]
-    return [] unless mlt and mlt['docs']
+    return [] unless mlt && mlt['docs']
 
     mlt['docs']
   end
 
   def more_like_this
     return {} unless self[:moreLikeThis]
-        
+
     self[:moreLikeThis]
   end
 end

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

@@ -3,12 +3,12 @@ module Blacklight::Solr::Response::Response
   def response
     self[:response] || {}
   end
-  
+
   # short cut to response['numFound']
   def total
     response[:numFound].to_s.to_i
   end
-  
+
   def start
     response[:start].to_s.to_i
   end

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

@@ -24,7 +24,7 @@ module Blacklight::Solr::Response::Spelling
     def words
       @words ||= begin
         word_suggestions = []
-        spellcheck = self.response[:spellcheck]
+        spellcheck = response[:spellcheck]
         if spellcheck && spellcheck[:suggestions]
           suggestions = spellcheck[:suggestions]
           unless suggestions.nil?
@@ -43,7 +43,7 @@ module Blacklight::Solr::Response::Spelling
               suggestions = Hash[*suggestions].except('correctlySpelled', 'collation')
             end
 
-            suggestions.each do |_, term_info|
+            suggestions.each_value do |term_info|
               # term_info is a hash:
               #   numFound =>
               #   startOffset =>
@@ -69,7 +69,7 @@ module Blacklight::Solr::Response::Spelling
 
     def collation
       # FIXME: DRY up with words
-      spellcheck = self.response[:spellcheck]
+      spellcheck = response[:spellcheck]
       return unless spellcheck && spellcheck[:suggestions]
       suggestions = spellcheck[:suggestions]
 

data/lib/blacklight/solr/response.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
-  extend Deprecation
-
-  # Using required_dependency to work around Rails autoloading
-  # problems when developing blacklight. Without this, any change
-  # to this class breaks other classes in this namespace
-  require_dependency 'blacklight/solr/response/pagination_methods'
-  require_dependency 'blacklight/solr/response/response'
-  require_dependency 'blacklight/solr/response/spelling'
-  require_dependency 'blacklight/solr/response/facets'
-  require_dependency 'blacklight/solr/response/more_like_this'
-  require_dependency 'blacklight/solr/response/group_response'
-  require_dependency 'blacklight/solr/response/group'
+  extend ActiveSupport::Autoload
+  eager_autoload do
+    autoload :PaginationMethods
+    autoload :Response
+    autoload :Spelling
+    autoload :Facets
+    autoload :MoreLikeThis
+    autoload :GroupResponse
+    autoload :Group
+  end
 
   include PaginationMethods
   include Spelling
@@ -20,13 +18,14 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
   include MoreLikeThis
 
   attr_reader :request_params
-  attr_accessor :document_model, :blacklight_config
+  attr_accessor :blacklight_config, :options
+  delegate :document_factory, to: :blacklight_config
 
   def initialize(data, request_params, options = {})
     super(force_to_utf8(ActiveSupport::HashWithIndifferentAccess.new(data)))
     @request_params = ActiveSupport::HashWithIndifferentAccess.new(request_params)
-    self.document_model = options[:solr_document_model] || options[:document_model] || SolrDocument
     self.blacklight_config = options[:blacklight_config]
+    self.options = options
   end
 
   def header
@@ -50,7 +49,7 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
   end
 
   def documents
-    @documents ||= (response['docs'] || []).collect{|doc| document_model.new(doc, self) }
+    @documents ||= (response['docs'] || []).collect { |doc| document_factory.build(doc, self, options) }
   end
   alias_method :docs, :documents
 
@@ -76,7 +75,7 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
   end
 
   def grouped?
-    self.key? "grouped"
+    key? "grouped"
   end
 
   def export_formats
@@ -85,20 +84,20 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
 
   private
 
-    def force_to_utf8(value)
-      case value
-      when Hash
-        value.each { |k, v| value[k] = force_to_utf8(v) }
-      when Array
-        value.each { |v| force_to_utf8(v) }
-      when String
-        if value.encoding != Encoding::UTF_8
-          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
+  def force_to_utf8(value)
+    case value
+    when Hash
+      value.each { |k, v| value[k] = force_to_utf8(v) }
+    when Array
+      value.each { |v| force_to_utf8(v) }
+    when String
+      if value.encoding != Encoding::UTF_8
+        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
-      value
     end
+    value
+  end
 end

data/lib/blacklight/solr/search_builder_behavior.rb

@@ -18,12 +18,12 @@ module Blacklight::Solr
     def default_solr_parameters(solr_parameters)
       blacklight_config.default_solr_params.each do |key, value|
         solr_parameters[key] = if value.respond_to? :deep_dup
-          value.deep_dup
-        elsif value.respond_to? :dup and value.duplicable?
-          value.dup
-        else
-          value
-        end
+                                 value.deep_dup
+                               elsif value.respond_to?(:dup) && value.duplicable?
+                                 value.dup
+                               else
+                                 value
+                               end
       end
     end
 
@@ -44,7 +44,7 @@ module Blacklight::Solr
 
       if search_field
         solr_parameters[:qt] = search_field.qt
-        solr_parameters.merge!( search_field.solr_parameters) if search_field.solr_parameters
+        solr_parameters.merge!(search_field.solr_parameters) if search_field.solr_parameters
       end
 
       ##
@@ -54,7 +54,7 @@ module Blacklight::Solr
       ##
       if search_field && search_field.solr_local_parameters.present?
         local_params = search_field.solr_local_parameters.map do |key, val|
-          key.to_s + "=" + solr_param_quote(val, :quote => "'")
+          key.to_s + "=" + solr_param_quote(val, quote: "'")
         end.join(" ")
         solr_parameters[:q] = "{!#{local_params}}#{blacklight_params[:q]}"
 
@@ -66,13 +66,13 @@ module Blacklight::Solr
       elsif blacklight_params[:q].is_a? Hash
         q = blacklight_params[:q]
         solr_parameters[:q] = if q.values.any?(&:blank?)
-          # if any field parameters are empty, exclude _all_ results
-          "{!lucene}NOT *:*"
-        else
-          "{!lucene}" + q.map do |field, values|
-            "#{field}:(#{Array(values).map { |x| solr_param_quote(x) }.join(' OR ')})"
-          end.join(" AND ")
-        end
+                                # if any field parameters are empty, exclude _all_ results
+                                "{!lucene}NOT *:*"
+                              else
+                                "{!lucene}" + q.map do |field, values|
+                                  "#{field}:(#{Array(values).map { |x| solr_param_quote(x) }.join(' OR ')})"
+                                end.join(" AND ")
+                              end
 
         solr_parameters[:defType] = 'lucene'
         solr_parameters[:spellcheck] = 'false'
@@ -113,7 +113,7 @@ module Blacklight::Solr
         if facet.pivot
           solr_parameters.append_facet_pivot with_ex_local_param(facet.ex, facet.pivot.join(","))
         elsif facet.query
-          solr_parameters.append_facet_query facet.query.map { |k, x| with_ex_local_param(facet.ex, x[:fq]) }
+          solr_parameters.append_facet_query facet.query.values.map { |x| with_ex_local_param(facet.ex, x[:fq]) }
         else
           solr_parameters.append_facet_fields with_ex_local_param(facet.ex, facet.field)
         end
@@ -134,13 +134,13 @@ module Blacklight::Solr
     end
 
     def add_solr_fields_to_query solr_parameters
-      blacklight_config.show_fields.select(&method(:should_add_field_to_request?)).each do |field_name, field|
+      blacklight_config.show_fields.select(&method(:should_add_field_to_request?)).each_value do |field|
         field.solr_params.each do |k, v|
           solr_parameters[:"f.#{field.field}.#{k}"] = v
         end if field.solr_params
       end
 
-      blacklight_config.index_fields.select(&method(:should_add_field_to_request?)).each do |field_name, field|
+      blacklight_config.index_fields.select(&method(:should_add_field_to_request?)).each_value do |field|
         if field.highlight
           solr_parameters[:hl] = true
           solr_parameters.append_highlight_field field.field
@@ -171,7 +171,7 @@ module Blacklight::Solr
 
     # Remove the group parameter if we've faceted on the group field (e.g. for the full results for a group)
     def add_group_config_to_solr solr_parameters
-      if blacklight_params[:f] and blacklight_params[:f][grouped_key_for_results]
+      if blacklight_params[:f] && blacklight_params[:f][grouped_key_for_results]
         solr_parameters[:group] = false
       end
     end
@@ -185,11 +185,7 @@ module Blacklight::Solr
       facet_ex = facet_config.respond_to?(:ex) ? facet_config.ex : nil
       solr_params[:"facet.field"] = with_ex_local_param(facet_ex, facet_config.field)
 
-      limit = if scope.respond_to?(:facet_list_limit)
-                Deprecation.warn(self, "The use of facet_list_limit is deprecated and will be removed in 7.0. " \
-                  "Consider using the 'more_limit' option in the field configuration or 'default_more_limit' instead.")
-                scope.facet_list_limit.to_s.to_i
-              elsif solr_params["facet.limit"]
+      limit = if solr_params["facet.limit"]
                 solr_params["facet.limit"].to_i
               else
                 facet_config.fetch(:more_limit, blacklight_config.default_more_limit)
@@ -274,15 +270,15 @@ module Blacklight::Solr
     def facet_value_to_fq_string(facet_field, value)
       facet_config = blacklight_config.facet_fields[facet_field]
 
-      solr_field = facet_config.field if facet_config and !facet_config.query
+      solr_field = facet_config.field if facet_config && !facet_config.query
       solr_field ||= facet_field
 
       local_params = []
-      local_params << "tag=#{facet_config.tag}" if facet_config and facet_config.tag
+      local_params << "tag=#{facet_config.tag}" if facet_config && facet_config.tag
 
       prefix = "{!#{local_params.join(' ')}}" unless local_params.empty?
 
-      if facet_config and facet_config.query
+      if facet_config && facet_config.query
         if facet_config.query[value]
           facet_config.query[value][:fq]
         else
@@ -297,7 +293,7 @@ module Blacklight::Solr
     end
 
     def convert_to_term_value(value)
-      if value.is_a?(DateTime) or value.is_a?(Time)
+      if value.is_a?(DateTime) || value.is_a?(Time)
         value.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
       elsif value.is_a?(Date)
         value.to_time(:local).strftime("%Y-%m-%dT%H:%M:%SZ")
@@ -313,7 +309,7 @@ module Blacklight::Solr
     end
 
     def facet_fields_to_include_in_request
-      blacklight_config.facet_fields.select do |field_name,facet|
+      blacklight_config.facet_fields.select do |_field_name, facet|
         facet.include_in_request || (facet.include_in_request.nil? && blacklight_config.add_facet_fields_to_solr_request)
       end
     end

data/lib/blacklight/version.rb

@@ -5,6 +5,6 @@ module Blacklight
       @version ||= File.read(File.join(File.dirname(__FILE__), '..', '..', 'VERSION')).chomp
     end
 
-    VERSION = self.version
+    VERSION = version
   end
 end

data/lib/blacklight.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 require 'kaminari'
 require 'deprecation'
-require 'blacklight/utils'
-require 'active_support/hash_with_indifferent_access'
-require 'jbuilder'
+require 'blacklight/open_struct_with_hash_access'
+require 'blacklight/nested_open_struct_with_hash_access'
 
 module Blacklight
   autoload :AbstractRepository, 'blacklight/abstract_repository'
@@ -84,7 +83,7 @@ module Blacklight
     end
 
     begin
-      @blacklight_yml = YAML.load(blacklight_erb)
+      @blacklight_yml = YAML.safe_load(blacklight_erb)
     rescue => e
       raise("#{blacklight_config_file} was found, but could not be parsed.\n#{e.inspect}")
     end
@@ -98,7 +97,7 @@ module Blacklight
 
   def self.logger
     @logger ||= begin
-      ::Rails.logger if defined? Rails and Rails.respond_to? :logger
+      ::Rails.logger if defined? Rails && Rails.respond_to?(:logger)
     end
   end