blacklight 5.3.0 → 5.4.0.rc1

data/lib/blacklight/configuration/facet_field.rb

@@ -10,9 +10,9 @@ module Blacklight
 
       self.collapse = true if self.collapse.nil?
       self.show = true if self.show.nil?
+      self.if ||= self.show
 
       super
     end
   end
 end
-

data/lib/blacklight/configuration/search_field.rb

@@ -1,5 +1,5 @@
 module Blacklight
-  class Configuration::SearchField < OpenStructWithHashAccess
+  class Configuration::SearchField < Blacklight::Configuration::SolrField
     def normalize! blacklight_config = nil
       # Some normalization, calculate display_label from key,
       # and make sure we have a qt from defaults.             
@@ -7,6 +7,8 @@ module Blacklight
       self.field ||= self.key
       self.label ||= self.key.try(:titlecase)
       self.qt ||= blacklight_config.default_solr_params[:qt] if blacklight_config && blacklight_config.default_solr_params
+      self.if ||= self.include_in_simple_select
+      super
     end
 
     def validate!
@@ -14,4 +16,3 @@ module Blacklight
     end
   end
 end
-

data/lib/blacklight/configuration/solr_field.rb

@@ -2,6 +2,8 @@ module Blacklight
   class Configuration::SolrField < OpenStructWithHashAccess
     def normalize! blacklight_config = nil
       self.label ||= default_label
+      self.if = true if self.if.nil?
+      self.unless = false if self.unless.nil?
       self
     end
   
@@ -18,4 +20,3 @@ module Blacklight
     end
   end
 end
-

data/lib/blacklight/configuration/sort_field.rb

@@ -1,5 +1,5 @@
 module Blacklight
-  class Configuration::SortField < OpenStructWithHashAccess
+  class Configuration::SortField < Blacklight::Configuration::SolrField
     def normalize! blacklight_config = nil
       self.sort ||= self.field
 
@@ -8,6 +8,7 @@ module Blacklight
       self.field ||= self.sort
 
       self.key ||= self.field
+      super
     end
 
     def validate!

data/lib/blacklight/engine.rb

@@ -19,6 +19,14 @@ module Blacklight
         end
       end
     end
+    
+    initializer "blacklight.secret_key" do |app|
+      if app.respond_to?(:secrets)
+        Blacklight.secret_key ||= app.secrets.secret_key_base
+      elsif app.config.respond_to?(:secret_key_base)
+        Blacklight.secret_key ||= app.config.secret_key_base
+      end
+    end
 
   end
-end
+end

data/lib/blacklight/exceptions.rb

@@ -9,6 +9,9 @@ module Blacklight
     # is not successful, raise this:
     class InvalidSolrID < RuntimeError
     end
+    
+    class ExpiredSessionToken < Exception
+    end
 
     class ECONNREFUSED < ::Errno::ECONNREFUSED; end
 

data/lib/blacklight/rails/routes.rb

@@ -7,11 +7,23 @@ module ActionDispatch::Routing
     #   blacklight_for :catalog, only: [ :saved_searches, :solr_document ]
     #   blacklight_for :catalog, constraints: {id: /[0-9]+/ }
     def blacklight_for(*resources)
+      raise_no_blacklight_secret_key unless Blacklight.secret_key
       options = resources.extract_options!
       resources.map!(&:to_sym)
 
       Blacklight::Routes.new(self, options.merge(resources: resources)).draw
     
     end
+    
+    private
+    def raise_no_blacklight_secret_key #:nodoc:
+      raise <<-ERROR
+Blacklight.secret_key was not set. Please add the following to an initializer:
+
+Blacklight.secret_key = '#{SecureRandom.hex(64)}'
+
+Please ensure you restarted your application after installing Blacklight or setting the key.
+ERROR
+    end
   end
 end

data/lib/blacklight/request_builders.rb

@@ -201,27 +201,25 @@ module Blacklight
     # app level per_page and page to Solr rows and start. 
     def add_paging_to_solr(solr_params, user_params)
 
-      # Now any over-rides from current URL?
-      solr_params[:rows] = user_params[:rows].to_i  unless user_params[:rows].blank?
-      solr_params[:rows] = user_params[:per_page].to_i  unless user_params[:per_page].blank?
+      # user-provided parameters should override any default row
+      solr_params[:rows] = user_params[:rows].to_i unless user_params[:rows].blank?
+      solr_params[:rows] = user_params[:per_page].to_i unless user_params[:per_page].blank?
+      
+      # configuration defaults should only set a default value, not override a value set elsewhere (e.g. search field parameters)
+      solr_params[:rows] ||= blacklight_config.default_per_page unless blacklight_config.default_per_page.blank?
+      solr_params[:rows] ||= blacklight_config.per_page.first unless blacklight_config.per_page.blank?
+      
+      # set a reasonable default
+      Rails.logger.info "Solr :rows parameter not set (by the user, configuration, or default solr parameters); using 10 rows by default"
+      solr_params[:rows] ||= 10
 
-      # Do we need to translate :page to Solr :start?
+      # ensure we don't excede the max page size
+      solr_params[:rows] = blacklight_config.max_per_page if solr_params[:rows].to_i > blacklight_config.max_per_page
       unless user_params[:page].blank?
-        # already set solr_params["rows"] might not be the one we just set,
-        # could have been from app defaults too. But we need one.
-        # raising is consistent with prior RSolr magic keys behavior.
-        # We could change this to default to 10, or to raise on startup
-        # from config instead of at runtime.
-        if solr_params[:rows].blank?
-          raise Exception.new("To use pagination when no :per_page is supplied in the URL, :rows must be configured in blacklight_config default_solr_params")
-        end
         solr_params[:start] = solr_params[:rows].to_i * (user_params[:page].to_i - 1)
         solr_params[:start] = 0 if solr_params[:start].to_i < 0
       end
 
-      solr_params[:rows] ||= blacklight_config.per_page.first unless blacklight_config.per_page.blank?
-
-      solr_params[:rows] = blacklight_config.max_per_page if solr_params[:rows].to_i > blacklight_config.max_per_page
     end
 
     ###
@@ -270,11 +268,14 @@ module Blacklight
       fq = case
         when (facet_config and facet_config.query)
           facet_config.query[value][:fq]
-        when (facet_config and facet_config.date),
-             (value.is_a?(TrueClass) or value.is_a?(FalseClass) or value == 'true' or value == 'false'),
+        when (facet_config and facet_config.date)
+          # in solr 3.2+, this could be replaced by a !term query
+          "#{prefix}#{facet_field}:#{RSolr.escape(value)}"
+        when (value.is_a?(DateTime) or value.is_a?(Date) or value.is_a?(Time))
+          "#{prefix}#{facet_field}:#{RSolr.escape(value.to_time.utc.strftime("%Y-%m-%dT%H:%M:%SZ"))}"
+        when (value.is_a?(TrueClass) or value.is_a?(FalseClass) or value == 'true' or value == 'false'),
              (value.is_a?(Integer) or (value.to_i.to_s == value if value.respond_to? :to_i)),
              (value.is_a?(Float) or (value.to_f.to_s == value if value.respond_to? :to_f))
-             (value.is_a?(DateTime) or value.is_a?(Date) or value.is_a?(Time))
           "#{prefix}#{facet_field}:#{value}"
         when value.is_a?(Range)
           "#{prefix}#{facet_field}:[#{value.first} TO #{value.last}]"

data/lib/blacklight/search_fields.rb

@@ -38,15 +38,6 @@ module Blacklight::SearchFields
     blacklight_config.search_fields.values
   end
 
-  # Returns suitable argument to options_for_select method, to create
-  # an html select based on #search_field_list. Skips search_fields
-  # marked :include_in_simple_select => false
-  def search_field_options_for_select
-    blacklight_config.search_fields.collect do |key, field_def|
-      [field_def.label,  field_def.key] unless field_def.include_in_simple_select == false
-    end.compact
-  end
-
   # Looks up a search field blacklight_config hash from search_field_list having
   # a certain supplied :key. 
   def search_field_def_for_key(key)

data/lib/blacklight/solr/document.rb

@@ -151,7 +151,14 @@ module Blacklight::Solr::Document
     return @semantic_value_hash
   end
   
+  def destroyed?
+    false
+  end
   
+  def new_record?
+    false
+  end
+
   # Certain class-level methods needed for the document-specific
   # extendability architecture
   module ClassMethods
@@ -160,6 +167,14 @@ module Blacklight::Solr::Document
     def unique_key
       @unique_key ||= 'id' 
     end
+    
+    def primary_key
+      'id'
+    end
+    
+    def base_class
+      self
+    end
 
     # Returns array of hashes of registered extensions. Each hash
     # has a :module_obj key and a :condition_proc key. Usually this

data/lib/blacklight/solr/document/export.rb

@@ -100,4 +100,8 @@ module Blacklight::Solr::Document::Export
   def export_as(short_name)
     send("export_as_#{short_name.to_s}")
   end
+  
+  def exports_as? short_name
+    respond_to? "export_as_#{short_name.to_s}"
+  end
 end

data/lib/blacklight/solr_helper.rb

@@ -46,6 +46,7 @@
 
 module Blacklight::SolrHelper
   extend ActiveSupport::Concern
+  extend Deprecation
   include Blacklight::SearchFields
   include Blacklight::Facet
   include ActiveSupport::Benchmarkable
@@ -59,18 +60,6 @@ module Blacklight::SolrHelper
 
   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
-      value.force_encoding("utf-8")  if value.respond_to?(:force_encoding) 
-    end
-    value
-  end
-  
   ##
   # Execute a solr query
   # @see [RSolr::Client#send_and_receive]
@@ -80,6 +69,7 @@ module Blacklight::SolrHelper
   #   @param [Hash] parameters for RSolr::Client#send_and_receive
   # @overload find(params)
   #   @param [Hash] parameters for RSolr::Client#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. 
@@ -91,7 +81,7 @@ module Blacklight::SolrHelper
       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(force_to_utf8(res), solr_params)
+      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
@@ -131,15 +121,14 @@ module Blacklight::SolrHelper
     when (solr_response.grouped? && solr_response.grouped.length == 1)
       [solr_response.grouped.first, []]
     else
-      document_list = solr_response.docs.collect {|doc| SolrDocument.new(doc, solr_response)} 
-      [solr_response, document_list]
+      [solr_response, solr_response.documents]
     end
   end
 
   	
   # a solr query method
   # given a user query,
-  # Returns a solr response object
+  # @return [Blacklight::SolrResponse] the solr response object
   def query_solr(user_params = params || {}, extra_controller_params = {})
     solr_params = self.solr_search_params(user_params).merge(extra_controller_params)
 
@@ -167,22 +156,25 @@ module Blacklight::SolrHelper
   
   # 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.docs.empty?
-    document = SolrDocument.new(solr_response.docs.first, solr_response)
-    [solr_response, document]
+    raise Blacklight::Exceptions::InvalidSolrID.new if solr_response.documents.empty?
+    [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 = {})
-    values = Array(values) unless values.respond_to? :each
-
-    q = if values.empty?
+    q = if Array(values).empty?
       "NOT *:*"
     else
-      "#{field}:(#{ values.to_a.map { |x| solr_param_quote(x)}.join(" OR ")})"
+      "#{field}:(#{ Array(values).map { |x| solr_param_quote(x)}.join(" OR ")})"
     end
 
     solr_params = {
@@ -199,8 +191,7 @@ module Blacklight::SolrHelper
     }.merge(extra_solr_params)
     
     solr_response = find(self.solr_search_params().merge(solr_params) )
-    document_list = solr_response.docs.collect{|doc| SolrDocument.new(doc, solr_response) }
-    [solr_response,document_list]
+    [solr_response, solr_response.documents]
   end
   
   # returns a params hash for a single facet field solr query.
@@ -241,6 +232,7 @@ module Blacklight::SolrHelper
   
   ##
   # 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
@@ -266,12 +258,14 @@ module Blacklight::SolrHelper
       :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 
   # 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. 
+  # @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)
 
@@ -279,10 +273,12 @@ module Blacklight::SolrHelper
     solr_params[:rows] = 1
     solr_params[:fl] = '*'
     solr_response = find(solr_params)
-    SolrDocument.new(solr_response.docs.first, solr_response) unless solr_response.docs.empty?
+    solr_response.documents.first
   end
+  deprecation_deprecate :get_single_doc_via_search
 
   # Get the previous and next document from a search result
+  # @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)
@@ -299,7 +295,7 @@ module Blacklight::SolrHelper
     solr_params[:facet] = false
     solr_response = find(solr_params)
 
-    document_list = solr_response.docs.collect{|doc| SolrDocument.new(doc, solr_response) }
+    document_list = solr_response.documents
 
     # only get the previous doc if there is one
     prev_doc = document_list.first if index > 0
@@ -328,7 +324,7 @@ module Blacklight::SolrHelper
     solr_params = solr_opensearch_params().merge(extra_controller_params)
     response = find(solr_params)
     a = [solr_params[:q]]
-    a << response.docs.map {|doc| doc[solr_params[:fl]].to_s }
+    a << response.documents.map {|doc| doc[solr_params[:fl]].to_s }
   end
   
   
@@ -377,4 +373,5 @@ module Blacklight::SolrHelper
   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
+
 end

data/lib/blacklight/solr_response.rb

@@ -2,22 +2,26 @@ class Blacklight::SolrResponse < HashWithIndifferentAccess
 
   require  'blacklight/solr_response/pagination_methods'
 
-  autoload :Spelling, 'blacklight/solr_response/spelling'
-  autoload :Facets, 'blacklight/solr_response/facets'
-  autoload :MoreLikeThis, 'blacklight/solr_response/more_like_this'
+  require 'blacklight/solr_response/response'
+  require 'blacklight/solr_response/spelling'
+  require 'blacklight/solr_response/facets'
+  require 'blacklight/solr_response/more_like_this'
   autoload :GroupResponse, 'blacklight/solr_response/group_response'
   autoload :Group, 'blacklight/solr_response/group'
 
   include PaginationMethods
+  include Spelling
+  include Facets
+  include Response
+  include MoreLikeThis
 
   attr_reader :request_params
-  def initialize(data, request_params)
-    super(data)
+  attr_accessor :solr_document_model
+
+  def initialize(data, request_params, options = {})
+    super(force_to_utf8(data))
     @request_params = request_params
-    extend Spelling
-    extend Facets
-    extend Response
-    extend MoreLikeThis
+    self.solr_document_model = options[:solr_document_model] || SolrDocument
   end
 
   def header
@@ -42,9 +46,9 @@ class Blacklight::SolrResponse < HashWithIndifferentAccess
       response['docs'] || []
     end
   end
-
-  def spelling
-    self['spelling']
+  
+  def documents
+    docs.collect{|doc| solr_document_model.new(doc, self) }
   end
 
   def grouped
@@ -72,23 +76,21 @@ class Blacklight::SolrResponse < HashWithIndifferentAccess
     self.has_key? "grouped"
   end
 
-  module 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
+  def export_formats
+    documents.map { |x| x.export_formats.keys }.flatten.uniq
+  end
+
+  private
 
-    def empty?
-      total == 0
+    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
+        value.force_encoding("utf-8")  if value.respond_to?(:force_encoding) 
+      end
+      value
     end
-    
-  end
 end