blacklight 5.7.2 → 5.8.0

data/lib/blacklight/configuration.rb

@@ -5,6 +5,7 @@ module Blacklight
   class Configuration < OpenStructWithHashAccess
 
     require 'blacklight/configuration/view_config'
+    require 'blacklight/configuration/tool_config'
     # XXX this isn't very pretty, but it works.
     require 'blacklight/configuration/fields'
     require 'blacklight/configuration/solr_field'
@@ -31,6 +32,7 @@ module Blacklight
           :default_solr_params => {},
           # the model to load solr response documents into; set below in #initialize_default_values
           :solr_document_model => nil,
+          :solr_response_model => nil,
           # The solr rqeuest handler to use when requesting only a single document 
           :document_solr_request_handler => 'document',
           # THe path to send single document requests to solr
@@ -56,6 +58,8 @@ module Blacklight
             :display_type_field => 'format',
             # partials to render for each document(see #render_document_partials)
             :partials => [:index_header, :thumbnail, :index],
+            :document_actions => NestedOpenStructWithHashAccess.new(ToolConfig),
+            :collection_actions => NestedOpenStructWithHashAccess.new(ToolConfig),
             # what field, if any, to use to render grouped results
             :group => false,
             # additional response formats for search results
@@ -69,8 +73,10 @@ module Blacklight
             # current controller.
             route: nil,
             # partials to render for each document(see #render_document_partials) 
-            partials: [:show_header, :show]
+            partials: [:show_header, :show],
+            document_actions: NestedOpenStructWithHashAccess.new(ToolConfig)
           ),
+          :navbar => OpenStructWithHashAccess.new(partials: { }),
           # Configurations for specific types of index views
           :view => NestedOpenStructWithHashAccess.new(ViewConfig, 'list'),
           # Maxiumum number of spelling suggestions to offer
@@ -137,6 +143,10 @@ module Blacklight
       super || SolrDocument
     end
 
+    def solr_response_model
+      super || Blacklight::SolrResponse
+    end
+
     ##
     # DSL helper
     def configure
@@ -226,10 +236,16 @@ module Blacklight
     # Provide a 'deep copy' of Blacklight::Configuration that can be modifyed without affecting
     # the original Blacklight::Configuration instance.
     #
-    def deep_copy
-      Marshal.load(Marshal.dump(self))
+    # The Rails 3.x version only copies hashes, and ignores arrays and similar structures
+    if ::Rails.version < "4.0"
+      def deep_copy
+        Marshal.load(Marshal.dump(self))
+      end
+      alias_method :inheritable_copy, :deep_copy
+    else
+      alias_method :deep_copy, :deep_dup
+      alias_method :inheritable_copy, :deep_dup
     end
-    alias_method :inheritable_copy, :deep_copy
 
     ##
     # Get a view configuration for the given view type
@@ -241,5 +257,67 @@ module Blacklight
         self.index.merge view.fetch(view_type, {})
       end
     end
+
+    ##
+    # Add a partial to the tools when rendering a document.
+    # @param partial [String] the name of the document partial
+    # @param opts [Hash]
+    # @option opts [Symbol,Proc] :if render this action if the method identified by the symbol or the proc evaluates to true.
+    #                             The proc will receive the action configuration and the document or documents for the action.
+    # @option opts [Symbol,Proc] :unless render this action unless the method identified by the symbol or the proc evaluates to true
+    #                             The proc will receive the action configuration and the document or documents for the action.
+    def add_show_tools_partial(name, opts = {})
+      opts[:partial] ||= 'document_action'
+      add_action(show.document_actions, name, opts)
+    end
+
+    ##
+    # Add a tool for the search result list itself
+    # @param partial [String] the name of the document partial
+    # @param opts [Hash]
+    # @option opts [Symbol,Proc] :if render this action if the method identified by the symbol or the proc evaluates to true.
+    #                             The proc will receive the action configuration and the document or documents for the action.
+    # @option opts [Symbol,Proc] :unless render this action unless the method identified by the symbol or the proc evaluates to true
+    #                             The proc will receive the action configuration and the document or documents for the action.
+    def add_results_collection_tool(name, opts = {})
+      add_action(index.collection_actions, name, opts)
+    end
+
+    ##
+    # Add a partial to the tools for each document in the search results.
+    # @param partial [String] the name of the document partial
+    # @param opts [Hash]
+    # @option opts [Symbol,Proc] :if render this action if the method identified by the symbol or the proc evaluates to true.
+    #                             The proc will receive the action configuration and the document or documents for the action.
+    # @option opts [Symbol,Proc] :unless render this action unless the method identified by the symbol or the proc evaluates to true
+    #                             The proc will receive the action configuration and the document or documents for the action.
+    def add_results_document_tool(name, opts = {})
+      add_action(index.document_actions, name, opts)
+    end
+
+    ##
+    # Add a partial to the header navbar
+    # @param partial [String] the name of the document partial
+    # @param opts [Hash]
+    # @option opts [Symbol,Proc] :if render this action if the method identified by the symbol or the proc evaluates to true.
+    #                             The proc will receive the action configuration and the document or documents for the action.
+    # @option opts [Symbol,Proc] :unless render this action unless the method identified by the symbol or the proc evaluates to true
+    #                             The proc will receive the action configuration and the document or documents for the action.
+    def add_nav_action name, opts = {}
+      add_action(navbar.partials, name, opts)
+    end
+
+    private
+
+      def add_action config_hash, name, opts
+        config = Blacklight::Configuration::ToolConfig.new opts
+        config.name = name
+
+        if block_given?
+          yield config
+        end
+
+        config_hash[name] = config
+      end
   end
 end

data/lib/blacklight/configuration/tool_config.rb

@@ -0,0 +1,4 @@
+module Blacklight
+  class Configuration::ToolConfig < OpenStructWithHashAccess
+  end
+end

data/lib/blacklight/controller.rb

@@ -23,7 +23,7 @@ module Blacklight::Controller
     # extra head content
     helper_method :has_user_authentication_provider?
     helper_method :blacklight_config
-    helper_method :search_action_url, :search_action_path
+    helper_method :search_action_url, :search_action_path, :search_facet_url
 
 
     # This callback runs when a user first logs in
@@ -59,6 +59,10 @@ module Blacklight::Controller
       search_action_url *args
     end
 
+    def search_facet_url options = {}
+      url_for params.merge(action: "facet").merge(options).except(:page)
+    end
+
     # Returns a list of Searches from the ids in the user's history.
     def searches_from_history
       session[:history].blank? ? Search.none : Search.where(:id => session[:history]).order("updated_at desc")

data/lib/blacklight/document_presenter.rb

@@ -2,6 +2,7 @@ module Blacklight
   class DocumentPresenter
     include ActionView::Helpers::OutputSafetyHelper
     include ActionView::Helpers::TagHelper
+    extend Deprecation
 
     # @param [SolrDocument] document
     # @param [ActionController::Base] controller scope for linking and generating urls
@@ -55,17 +56,25 @@ module Blacklight
     ##
     # Render the document index heading
     #
-    # @param [Hash] opts
+    # @param [Hash] opts (Deprecated)
     # @option opts [Symbol] :label Render the given field from the document
     # @option opts [Proc] :label Evaluate the given proc
     # @option opts [String] :label Render the given string
-    def render_document_index_label opts = {}
-      label = nil
-      label ||= @document.get(opts[:label], :sep => nil) if opts[:label].instance_of? Symbol
-      label ||= opts[:label].call(@document, opts) if opts[:label].instance_of? Proc
-      label ||= opts[:label] if opts[:label].is_a? String
-      label ||= @document.id
-      render_field_value label
+    # @param [Symbol, Proc, String] field Render the given field or evaluate the proc or render the given string
+    def render_document_index_label field, opts ={}
+      if field.kind_of? Hash
+        Deprecation.warn DocumentPresenter, "Calling render_document_index_label with a hash is deprecated"
+        field = field[:label]
+      end
+      label = case field
+      when Symbol
+        @document.get(field, :sep => nil)
+      when Proc
+        field.call(@document, opts)
+      when String
+        field
+      end
+      render_field_value label || @document.id
     end
 
     ##

data/lib/blacklight/request_builders.rb

@@ -6,6 +6,8 @@ module Blacklight
   #
   module RequestBuilders
     extend ActiveSupport::Concern
+    extend Deprecation
+    self.deprecation_horizon = 'blacklight 6.0'
 
     included do
       # We want to install a class-level place to keep 
@@ -21,7 +23,11 @@ module Blacklight
       # CatalogController.include ModuleDefiningNewMethod
       # CatalogController.solr_search_params_logic += [:new_method]
       # CatalogController.solr_search_params_logic.delete(:we_dont_want)
-      self.solr_search_params_logic = [:default_solr_parameters , :add_query_to_solr, :add_facet_fq_to_solr, :add_facetting_to_solr, :add_solr_fields_to_query, :add_paging_to_solr, :add_sorting_to_solr, :add_group_config_to_solr ]
+      self.solr_search_params_logic = [:default_solr_parameters, :add_query_to_solr, :add_facet_fq_to_solr, :add_facetting_to_solr, :add_solr_fields_to_query, :add_paging_to_solr, :add_sorting_to_solr, :add_group_config_to_solr ]
+
+      if self.respond_to?(:helper_method)
+        helper_method(:facet_limit_for)
+      end
     end
 
     # @returns a params hash for searching solr.
@@ -47,6 +53,86 @@ module Blacklight
       end
     end
     
+    ##
+    # Retrieve the results for a list of document ids
+    def solr_document_ids_params(ids = [])
+      solr_documents_by_field_values_params blacklight_config.solr_document_model.unique_key, ids
+    end
+
+    ##
+    # Retrieve the results for a list of document ids
+    # @deprecated
+    def solr_documents_by_field_values_params(field, values)
+      q = if Array(values).empty?
+        "{!lucene}NOT *:*"
+      else
+        "{!lucene}#{field}:(#{ Array(values).map { |x| solr_param_quote(x) }.join(" OR ")})"
+      end
+
+      { q: q, spellcheck: 'false', fl: "*" }
+    end
+
+    ##
+    # Retrieve a facet's paginated values.
+    def solr_facet_params(facet_field, user_params=params || {}, extra_controller_params={})
+      input = user_params.deep_merge(extra_controller_params)
+      facet_config = blacklight_config.facet_fields[facet_field]
+
+      solr_params = {}
+
+      # Now override with our specific things for fetching facet values
+      solr_params[:"facet.field"] = with_ex_local_param((facet_config.ex if facet_config.respond_to?(:ex)), facet_field)
+
+      limit = if respond_to?(:facet_list_limit)
+          facet_list_limit.to_s.to_i
+        elsif solr_params["facet.limit"]
+          solr_params["facet.limit"].to_i
+        else
+          20
+        end
+
+      # Need to set as f.facet_field.facet.* to make sure we
+      # override any field-specific default in the solr request handler.
+      solr_params[:"f.#{facet_field}.facet.limit"]  = limit + 1
+      solr_params[:"f.#{facet_field}.facet.offset"] = ( input.fetch(Blacklight::Solr::FacetPaginator.request_keys[:page] , 1).to_i - 1 ) * ( limit )
+      solr_params[:"f.#{facet_field}.facet.sort"] = input[  Blacklight::Solr::FacetPaginator.request_keys[:sort] ] if  input[  Blacklight::Solr::FacetPaginator.request_keys[:sort] ]
+      solr_params[:rows] = 0
+
+      solr_params
+    end
+
+    ##
+    # Opensearch autocomplete parameters for plucking a field's value from the results
+    def solr_opensearch_params(field=nil)
+      if field.nil?
+        Deprecation.warn(Blacklight::RequestBuilders, "Calling Blacklight::RequestBuilders#solr_opensearch_params without a field name is deprecated and will be required in Blacklight 6.0.")
+      end
+
+      solr_params = {}
+      solr_params[:rows] ||= 10
+      solr_params[:fl] = field || blacklight_config.view_config('opensearch').title_field
+      solr_params
+    end
+
+    ##
+    # Pagination parameters for selecting the previous and next documents
+    # out of a result set.
+    def previous_and_next_document_params(index, window = 1)
+      solr_params = {}
+
+      if index > 0
+        solr_params[:start] = index - window # get one before
+        solr_params[:rows] = 2*window + 1 # and one after
+      else
+        solr_params[:start] = 0 # there is no previous doc
+        solr_params[:rows] = 2*window # but there should be one after
+      end
+
+      solr_params[:fl] = '*'
+      solr_params[:facet] = false
+      solr_params
+    end
+
     ####
     # Start with general defaults from BL config. Need to use custom
     # merge to dup values, to avoid later mutating the original by mistake.
@@ -55,7 +141,7 @@ module Blacklight
         solr_parameters[key] = value.dup rescue value
       end
     end
-    
+
     ##
     # Take the user-entered query, and put it in the solr params, 
     # including config's "search field" params for current search field. 
@@ -71,7 +157,7 @@ module Blacklight
       # rspec'd. 
       solr_parameters[:qt] = user_parameters[:qt] if user_parameters[:qt]
       
-      search_field_def = search_field_def_for_key(user_parameters[:search_field])
+      search_field_def = blacklight_config.search_fields[user_parameters[:search_field]]
       if (search_field_def)     
         solr_parameters[:qt] = search_field_def.qt
         solr_parameters.merge!( search_field_def.solr_parameters) if search_field_def.solr_parameters
@@ -253,8 +339,55 @@ module Blacklight
       end
     end
 
+
+    DEFAULT_FACET_LIMIT = 10
+
+    # Look up facet limit for given facet_field. Will look at config, and
+    # if config is 'true' will look up from Solr @response if available. If
+    # no limit is avaialble, returns nil. Used from #solr_search_params
+    # to supply f.fieldname.facet.limit values in solr request (no @response
+    # available), and used in display (with @response available) to create
+    # a facet paginator with the right limit.
+    def facet_limit_for(facet_field)
+      facet = blacklight_config.facet_fields[facet_field]
+      return if facet.blank?
+
+      if facet.limit and @response and @response.facet_by_field_name(facet_field)
+        limit = @response.facet_by_field_name(facet_field).limit
+
+        if limit.nil? # we didn't get or a set a limit, so infer one.
+          facet.limit if facet.limit != true
+        elsif limit == -1 # limit -1 is solr-speak for unlimited
+          nil
+        else
+          limit.to_i - 1 # we added 1 to find out if we needed to paginate
+        end
+      elsif facet.limit
+        facet.limit == true ? DEFAULT_FACET_LIMIT : facet.limit
+      end
+    end
+
+    ##
+    # A helper method used for generating solr LocalParams, put quotes
+    # around the term unless it's a bare-word. Escape internal quotes
+    # if needed.
+    def solr_param_quote(val, options = {})
+      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]
+      end
+      return val
+    end
+
     private
 
+    def should_add_to_solr field_name, field
+      field.include_in_request || (field.include_in_request.nil? && blacklight_config.add_field_configuration_to_solr_request)
+    end
+
     ##
     # Convert a facet/value pair into a solr fq parameter
     def facet_value_to_fq_string(facet_field, value) 
@@ -284,7 +417,6 @@ module Blacklight
           "{!raw f=#{facet_field}#{(" " + local_params.join(" ")) unless local_params.empty?}}#{value}"
       end
 
-
     end
   end
 end

data/lib/blacklight/routes.rb

@@ -61,6 +61,11 @@ module Blacklight
       def bookmarks(_)
         add_routes do |options|
           delete "bookmarks/clear", :to => "bookmarks#clear", :as => "clear_bookmarks"
+          get "bookmarks/email", :as => "email_bookmarks"
+          post "bookmarks/email"
+          get "bookmarks/sms", :as => "sms_bookmarks"
+          post "bookmarks/sms"
+          get "bookmarks/citation", :as => "citation_bookmarks"
           resources :bookmarks
         end
       end

data/lib/blacklight/solr_helper.rb

@@ -47,65 +47,30 @@
 module Blacklight::SolrHelper
   extend ActiveSupport::Concern
   extend Deprecation
-  include Blacklight::SearchFields
-  include Blacklight::Facet
-  include ActiveSupport::Benchmarkable
+  self.deprecation_horizon = 'blacklight 6.0'
 
-  included do
-    if self.respond_to?(:helper_method)
-      helper_method(:facet_limit_for)
-    end
-
-    include Blacklight::RequestBuilders
-
-  end
+  include Blacklight::RequestBuilders
 
   ##
   # Execute a solr query
-  # @see [RSolr::Client#send_and_receive]
-  # @overload find(solr_path, params)
-  #   Execute a solr query at the given path with the parameters
-  #   @param [String] solr path (defaults to blacklight_config.solr_path)
-  #   @param [Hash] parameters for RSolr::Client#send_and_receive
-  # @overload find(params)
-  #   @param [Hash] parameters for RSolr::Client#send_and_receive
+  # @see [Blacklight::SolrRepository#send_and_receive]
   # @return [Blacklight::SolrResponse] the solr response object
-  def find(*args)
-    # In later versions of Rails, the #benchmark method can do timing
-    # better for us. 
-    benchmark("Solr fetch", level: :debug) do
-      solr_params = args.extract_options!
-      path = args.first || blacklight_config.solr_path
-      solr_params[:qt] ||= blacklight_config.qt
-      # delete these parameters, otherwise rsolr will pass them through.
-      key = blacklight_config.http_method == :post ? :data : :params
-      res = blacklight_solr.send_and_receive(path, {key=>solr_params.to_hash, method:blacklight_config.http_method})
-      
-      solr_response = Blacklight::SolrResponse.new(res, solr_params, solr_document_model: blacklight_config.solr_document_model)
-
-      Rails.logger.debug("Solr query: #{solr_params.inspect}")
-      Rails.logger.debug("Solr response: #{solr_response.inspect}") if defined?(::BLACKLIGHT_VERBOSE_LOGGING) and ::BLACKLIGHT_VERBOSE_LOGGING
-      solr_response
-    end
-  rescue Errno::ECONNREFUSED => e
-    raise Blacklight::Exceptions::ECONNREFUSED.new("Unable to connect to Solr instance using #{blacklight_solr.inspect}")
+  def find *args
+    solr_params = args.extract_options!
+    path = args.first || blacklight_config.solr_path
+
+    solr_params[:qt] ||= blacklight_config.qt
+
+    solr_repository.send_and_receive path, solr_params
   end
-    
-  
-  # A helper method used for generating solr LocalParams, put quotes
-  # around the term unless it's a bare-word. Escape internal quotes
-  # if needed. 
-  def solr_param_quote(val, options = {})
-    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]
-    end
-    return val
+  deprecation_deprecate :find
+
+  # returns a params hash for finding a single solr document (CatalogController #show action)
+  def solr_doc_params(id=nil)
+    default_solr_doc_params(id)
   end
-    
+  deprecation_deprecate :solr_doc_params
+
   # a solr query method
   # given a user query, return a solr response containing both result docs and facets
   # - mixes in the Blacklight::Solr::SpellingSuggestions module
@@ -132,111 +97,66 @@ module Blacklight::SolrHelper
   def query_solr(user_params = params || {}, extra_controller_params = {})
     solr_params = self.solr_search_params(user_params).merge(extra_controller_params)
 
-    find(solr_params)
+    solr_repository.search(solr_params)
   end
-  
-  # returns a params hash for finding a single solr document (CatalogController #show action)
-  # If the id arg is nil, then the value is fetched from params[:id]
-  # This method is primary called by the get_solr_response_for_doc_id method.
-  def solr_doc_params(id=nil)
-    id ||= params[:id]
 
-    # add our document id to the document_unique_id_param query parameter
-    p = blacklight_config.default_document_solr_params.merge({
-      # this assumes the request handler will map the unique id param
-      # to the unique key field using either solr local params, the 
-      # real-time get handler, etc.
-      blacklight_config.document_unique_id_param => id
-    })
-
-    p[:qt] ||= blacklight_config.document_solr_request_handler
-
-    p
-  end
-  
   # a solr query method
   # retrieve a solr document, given the doc id
   # @return [Blacklight::SolrResponse, Blacklight::SolrDocument] the solr response object and the first document
   def get_solr_response_for_doc_id(id=nil, extra_controller_params={})
-    solr_params = solr_doc_params(id).merge(extra_controller_params)
-    solr_response = find(blacklight_config.document_solr_path, solr_params)
-    raise Blacklight::Exceptions::InvalidSolrID.new if solr_response.documents.empty?
+    if id.nil?
+      Deprecation.warn Blacklight::SolrHelper, "Calling #get_solr_response_for_doc_id without an explicit id argument is deprecated"
+      id ||= params[:id]
+    end
+
+    old_solr_doc_params = Deprecation.silence(Blacklight::SolrHelper) do
+      solr_doc_params(id)
+    end
+
+    if default_solr_doc_params(id) != old_solr_doc_params
+      Deprecation.warn Blacklight::SolrHelper, "The #solr_doc_params method is deprecated. Instead, you should provide a custom SolrRepository implementation for the additional behavior you're offering"
+      extra_controller_params = extra_controller_params.merge(old_solr_doc_params)
+    end
+
+    solr_response = solr_repository.find id, extra_controller_params
     [solr_response, solr_response.documents.first]
   end
   
-  def get_solr_response_for_document_ids(ids=[], extra_solr_params = {})
-    get_solr_response_for_field_values(blacklight_config.solr_document_model.unique_key, ids, extra_solr_params)
-  end
-  
-  # given a field name and array of values, get the matching SOLR documents
-  # @return [Blacklight::SolrResponse, Array<Blacklight::SolrDocument>] the solr response object and a list of solr documents
-  def get_solr_response_for_field_values(field, values, extra_solr_params = {})
-    q = if Array(values).empty?
-      "NOT *:*"
+  ##
+  # Retrieve a set of documents by id
+  # @overload get_solr_response_for_document_ids(ids, extra_controller_params)
+  # @overload get_solr_response_for_document_ids(ids, user_params, extra_controller_params)
+  def get_solr_response_for_document_ids(ids=[], *args)
+    # user_params = params || {}, extra_controller_params = {}
+    if args.length == 1
+      user_params = params
+      extra_controller_params = args.first || {}
     else
-      "#{field}:(#{ Array(values).map { |x| solr_param_quote(x)}.join(" OR ")})"
+      user_params, extra_controller_params = args
+      user_params ||= params
+      extra_controller_params ||= {}
     end
 
-    solr_params = {
-      :defType => "lucene",   # need boolean for OR
-      :q => q,
-      # not sure why fl * is neccesary, why isn't default solr_search_params
-      # sufficient, like it is for any other search results solr request? 
-      # But tests fail without this. I think because some functionality requires
-      # this to actually get solr_doc_params, not solr_search_params. Confused
-      # semantics again. 
-      :fl => "*",  
-      :facet => 'false',
-      :spellcheck => 'false'
-    }.merge(extra_solr_params)
-    
-    solr_response = find(self.solr_search_params().merge(solr_params) )
+    solr_response = query_solr(user_params, extra_controller_params.merge(solr_document_ids_params(ids)))
+
     [solr_response, solr_response.documents]
   end
-  
-  # returns a params hash for a single facet field solr query.
-  # used primary by the get_facet_pagination method.
-  # Looks up Facet Paginator request params from current request
-  # params to figure out sort and offset.
-  # Default limit for facet list can be specified by defining a controller
-  # method facet_list_limit, otherwise 20. 
-  def solr_facet_params(facet_field, user_params=params || {}, extra_controller_params={})
-    input = user_params.deep_merge(extra_controller_params)
-    facet_config = blacklight_config.facet_fields[facet_field]
-
-    # First start with a standard solr search params calculations,
-    # for any search context in our request params. 
-    solr_params = solr_search_params(user_params).merge(extra_controller_params)
-    
-    # Now override with our specific things for fetching facet values
-    solr_params[:"facet.field"] = with_ex_local_param((facet_config.ex if facet_config.respond_to?(:ex)), facet_field)
-
-    limit =  
-      if respond_to?(:facet_list_limit)
-        facet_list_limit.to_s.to_i
-      elsif solr_params["facet.limit"] 
-        solr_params["facet.limit"].to_i
-      else
-        20
-      end
-
-    # Need to set as f.facet_field.facet.* to make sure we
-    # override any field-specific default in the solr request handler. 
-    solr_params[:"f.#{facet_field}.facet.limit"]  = limit + 1
-    solr_params[:"f.#{facet_field}.facet.offset"] = ( input.fetch(Blacklight::Solr::FacetPaginator.request_keys[:page] , 1).to_i - 1 ) * ( limit )
-    solr_params[:"f.#{facet_field}.facet.sort"] = input[  Blacklight::Solr::FacetPaginator.request_keys[:sort] ] if  input[  Blacklight::Solr::FacetPaginator.request_keys[:sort] ]   
-    solr_params[:rows] = 0
-
-    return solr_params
+
+  # given a field name and array of values, get the matching SOLR documents
+  # @return [Blacklight::SolrResponse, Array<Blacklight::SolrDocument>] the solr response object and a list of solr documents
+  def get_solr_response_for_field_values(field, values, extra_controller_params = {})
+    solr_response = query_solr(params, extra_controller_params.merge(solr_documents_by_field_values_params(field, values)))
+
+    [solr_response, solr_response.documents]
   end
-  
+  deprecation_deprecate :get_solr_response_for_field_values
+
   ##
   # Get the solr response when retrieving only a single facet field
   # @return [Blacklight::SolrResponse] the solr response
   def get_facet_field_response(facet_field, user_params = params || {}, extra_controller_params = {})
     solr_params = solr_facet_params(facet_field, user_params, extra_controller_params)
-    # Make the solr call
-    find(solr_params)
+    query_solr(user_params, extra_controller_params.merge(solr_facet_params(facet_field, user_params, extra_controller_params)))
   end
 
   # a solr query method
@@ -251,28 +171,28 @@ module Blacklight::SolrHelper
     # Actually create the paginator!
     # NOTE: The sniffing of the proper sort from the solr response is not
     # currently tested for, tricky to figure out how to test, since the
-    # default setup we test against doesn't use this feature. 
-    return     Blacklight::Solr::FacetPaginator.new(response.facets.first.items, 
-      :offset => response.params[:"f.#{facet_field}.facet.offset"], 
+    # default setup we test against doesn't use this feature.
+    return     Blacklight::Solr::FacetPaginator.new(response.facets.first.items,
+      :offset => response.params[:"f.#{facet_field}.facet.offset"],
       :limit => limit,
       :sort => response.params[:"f.#{facet_field}.facet.sort"] || response.params["facet.sort"]
     )
   end
   deprecation_deprecate :get_facet_pagination
-  
+
   # a solr query method
-  # this is used when selecting a search result: we have a query and a 
+  # this is used when selecting a search result: we have a query and a
   # position in the search results and possibly some facets
   # Pass in an index where 1 is the first document in the list, and
-  # the Blacklight app-level request params that define the search. 
+  # the Blacklight app-level request params that define the search.
   # @return [Blacklight::SolrDocument, nil] the found document or nil if not found
   def get_single_doc_via_search(index, request_params)
     solr_params = solr_search_params(request_params)
 
-    solr_params[:start] = (index - 1) # start at 0 to get 1st doc, 1 to get 2nd.    
+    solr_params[:start] = (index - 1) # start at 0 to get 1st doc, 1 to get 2nd.
     solr_params[:rows] = 1
     solr_params[:fl] = '*'
-    solr_response = find(solr_params)
+    solr_response = solr_repository.search(solr_params)
     solr_response.documents.first
   end
   deprecation_deprecate :get_single_doc_via_search
@@ -281,19 +201,7 @@ module Blacklight::SolrHelper
   # @return [Blacklight::SolrResponse, Array<Blacklight::SolrDocument>] the solr response and a list of the first and last document
   def get_previous_and_next_documents_for_search(index, request_params, extra_controller_params={})
 
-    solr_params = solr_search_params(request_params).merge(extra_controller_params)
-
-    if index > 0
-      solr_params[:start] = index - 1 # get one before
-      solr_params[:rows] = 3 # and one after
-    else
-      solr_params[:start] = 0 # there is no previous doc
-      solr_params[:rows] = 2 # but there should be one after
-    end
-
-    solr_params[:fl] = '*'
-    solr_params[:facet] = false
-    solr_response = find(solr_params)
+    solr_response = query_solr(request_params, extra_controller_params.merge(previous_and_next_document_params(index)))
 
     document_list = solr_response.documents
 
@@ -303,16 +211,6 @@ module Blacklight::SolrHelper
 
     [solr_response, [prev_doc, next_doc]]
   end
-    
-  # returns a solr params hash
-  # the :fl (solr param) is set to the "field" value.
-  # per_page is set to 10
-  def solr_opensearch_params(field=nil)
-    solr_params = solr_search_params
-    solr_params[:per_page] = 10
-    solr_params[:fl] = field || blacklight_config.view_config('opensearch').title_field
-    solr_params
-  end
   
   # a solr query method
   # does a standard search but returns a simplified object.
@@ -320,38 +218,12 @@ module Blacklight::SolrHelper
   # the second item is an other array. This second array contains
   # all of the field values for each of the documents...
   # where the field is the "field" argument passed in.
-  def get_opensearch_response(field=nil, extra_controller_params={})
-    solr_params = solr_opensearch_params().merge(extra_controller_params)
-    response = find(solr_params)
-    a = [solr_params[:q]]
-    a << response.documents.map {|doc| doc[solr_params[:fl]].to_s }
-  end
-  
-  DEFAULT_FACET_LIMIT = 10
-
-  # Look up facet limit for given facet_field. Will look at config, and
-  # if config is 'true' will look up from Solr @response if available. If
-  # no limit is avaialble, returns nil. Used from #solr_search_params
-  # to supply f.fieldname.facet.limit values in solr request (no @response
-  # available), and used in display (with @response available) to create
-  # a facet paginator with the right limit. 
-  def facet_limit_for(facet_field)
-    facet = blacklight_config.facet_fields[facet_field]
-    return if facet.blank?
-
-    if facet.limit and @response and @response.facet_by_field_name(facet_field)
-      limit = @response.facet_by_field_name(facet_field).limit
-
-      if limit.nil? # we didn't get or a set a limit, so infer one.
-        facet.limit if facet.limit != true
-      elsif limit == -1 # limit -1 is solr-speak for unlimited
-        nil
-      else
-        limit.to_i - 1 # we added 1 to find out if we needed to paginate
-      end
-    elsif facet.limit
-      facet.limit == true ? DEFAULT_FACET_LIMIT : facet.limit
-    end
+  def get_opensearch_response(field=nil, request_params = params || {}, extra_controller_params={})
+    field ||= blacklight_config.view_config('opensearch').title_field
+
+    response = query_solr(request_params, solr_opensearch_params(field).merge(extra_controller_params))
+
+    [response.params[:q], response.documents.flat_map {|doc| doc[field] }.uniq]
   end
 
   ##
@@ -360,18 +232,28 @@ module Blacklight::SolrHelper
     blacklight_config.index.group
   end
 
-  def blacklight_solr
-    @solr ||=  RSolr.connect(blacklight_solr_config)
-  end
-
-  def blacklight_solr_config
-    Blacklight.solr_config
+  def solr_repository
+    @solr_repository ||= Blacklight::SolrRepository.new(blacklight_config)
   end
 
   private
 
-  def should_add_to_solr field_name, field
-    field.include_in_request || (field.include_in_request.nil? && blacklight_config.add_field_configuration_to_solr_request)
+  ##
+  # @deprecated
+  def default_solr_doc_params(id=nil)
+    id ||= params[:id]
+
+    # add our document id to the document_unique_id_param query parameter
+    p = blacklight_config.default_document_solr_params.merge({
+      # this assumes the request handler will map the unique id param
+      # to the unique key field using either solr local params, the
+      # real-time get handler, etc.
+      blacklight_config.document_unique_id_param => id
+    })
+
+    p[:qt] ||= blacklight_config.document_solr_request_handler
+
+    p
   end
 
 end