blacklight 6.14.0 → 7.0.0

data/lib/blacklight/search_builder.rb

@@ -5,34 +5,27 @@ module Blacklight
   # query parameters appropriate for search index. It does so by evaluating a
   # chain of processing methods to populate a result hash (see {#to_hash}).
   class SearchBuilder
-    extend Deprecation
     class_attribute :default_processor_chain
     self.default_processor_chain = []
 
     attr_reader :processor_chain, :blacklight_params
 
-    
     # @overload initialize(scope)
-    #   @param [Object] scope scope the scope where the filter methods reside in.    
+    #   @param [Object] scope scope the scope where the filter methods reside in.
     # @overload initialize(processor_chain, scope)
     #   @param [List<Symbol>,TrueClass] processor_chain options a list of filter methods to run or true, to use the default methods
-    #   @param [Object] scope scope the scope where the filter methods reside in.
+    #   @param [Object] scope the scope where the filter methods reside in.
     def initialize(*options)
-      @scope = case options.size
+      case options.size
       when 1
-        options.first
+        @processor_chain = default_processor_chain.dup
+        @scope = options.first
       when 2
-        if options.first == true
-          Deprecation.warn Blacklight::SearchBuilder, "SearchBuilder#initialize now takes only one parameter, the scope. Passing `true' will be removed in Blacklight 7"
-        else
-          @processor_chain = options.first
-        end
-        options.last
+        @processor_chain, @scope = options
       else
         raise ArgumentError, "wrong number of arguments. (#{options.size} for 1..2)"
       end
 
-      @processor_chain ||= default_processor_chain.dup
       @blacklight_params = {}
       @merged_params = {}
       @reverse_merged_params = {}
@@ -116,10 +109,11 @@ module Blacklight
     # @return [Blacklight::Solr::Response] the solr response object
     def to_hash
       return @params unless params_need_update?
-      @params = processed_parameters.
-                  reverse_merge(@reverse_merged_params).
-                  merge(@merged_params).
-                  tap { self.clear_changes }
+
+      @params = processed_parameters
+                  .reverse_merge(@reverse_merged_params)
+                  .merge(@merged_params)
+                  .tap { clear_changes }
     end
 
     alias_method :query, :to_hash
@@ -197,7 +191,7 @@ module Blacklight
       end
       @rows ||= begin
         # user-provided parameters should override any default row
-        r = [:rows, :per_page].map {|k| blacklight_params[k] }.reject(&:blank?).first
+        r = [:rows, :per_page].map { |k| blacklight_params[k] }.reject(&:blank?).first
         r ||= blacklight_config.default_per_page
         # ensure we don't excede the max page size
         r.nil? ? nil : [r, blacklight_config.max_per_page].map(&:to_i).min
@@ -221,36 +215,35 @@ module Blacklight
       @facet
     end
 
+    # Decode the user provided 'sort' parameter into a sort string that can be
+    # passed to the search.  This sanitizes the input by ensuring only
+    # configured search values are passed through to the search.
+    # @return [String] the field/fields to sort by
     def sort
       sort_field = if blacklight_params[:sort].blank?
-        # no sort param provided, use default
-        blacklight_config.default_sort_field
-      else
-        # check for sort field key
-        blacklight_config.sort_fields[blacklight_params[:sort]]
-      end
-
-      field = if sort_field.present?
-        sort_field.sort
-      else
-        # just pass the key through
-        blacklight_params[:sort]
-      end
-
-      field unless field.blank?
+                     # no sort param provided, use default
+                     blacklight_config.default_sort_field
+                   else
+                     # check for sort field key
+                     blacklight_config.sort_fields[blacklight_params[:sort]]
+                   end
+      return sort_field.sort if sort_field.present?
+
+      Blacklight.logger.warn "Invalid sort field: '#{blacklight_params[:sort]}' was provided."
+      nil
     end
 
     def search_field
       blacklight_config.search_fields[blacklight_params[:search_field]]
     end
 
-    protected
+    private
 
     def request
       Blacklight::Solr::Request.new
     end
 
-    def should_add_field_to_request? field_name, field
+    def should_add_field_to_request? _field_name, field
       field.include_in_request || (field.include_in_request.nil? && blacklight_config.add_field_configuration_to_solr_request)
     end
 

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
@@ -97,6 +97,8 @@ module Blacklight
     # 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)
       if item.respond_to? :field
         field = item.field
@@ -132,7 +134,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 +142,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 +167,7 @@ module Blacklight
         item
       end
     end
-    
+
     def add_facet_param(p, field, item)
       if item.respond_to? :field
         field = item.field
@@ -180,7 +182,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

@@ -12,6 +12,7 @@ module Blacklight::Solr
 
       solr_response = send_and_receive blacklight_config.document_solr_path || blacklight_config.solr_path, doc_params
       raise Blacklight::Exceptions::RecordNotFound if solr_response.documents.empty?
+
       solr_response
     end
 
@@ -22,8 +23,31 @@ 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
@@ -35,12 +59,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
@@ -49,10 +73,20 @@ module Blacklight::Solr
       raise Blacklight::Exceptions::InvalidRequest, e.message
     end
 
-    protected
+    private
 
-      def build_connection
-        RSolr.connect(connection_config.merge(adapter: connection_config[:http_adapter]))
-      end
+    ##
+    # @return [String]
+    def suggest_handler_path
+      blacklight_config.autocomplete_path
+    end
+
+    def suggester_name
+      blacklight_config.autocomplete_suggester
+    end
+
+    def build_connection
+      RSolr.connect(connection_config.merge(adapter: connection_config[:http_adapter]))
+    end
   end
 end

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,8 +69,9 @@ 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]
 
       if suggestions.is_a?(Array) && suggestions.index("collation")

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