blacklight 5.9.4 → 5.10.0

data/lib/blacklight/catalog/search_context.rb

@@ -102,7 +102,7 @@ module Blacklight::Catalog::SearchContext
       @next_document = documents.last
     end
   rescue Blacklight::Exceptions::InvalidRequest => e
-    logger.warn "Unable to setup next and previous documents: #{e}"
+    Rails.logger.warn "Unable to setup next and previous documents: #{e}"
   end
 
 end

data/lib/blacklight/configuration.rb

@@ -8,11 +8,14 @@ module Blacklight
     require 'blacklight/configuration/tool_config'
     # XXX this isn't very pretty, but it works.
     require 'blacklight/configuration/fields'
+    require 'blacklight/configuration/field'
     require 'blacklight/configuration/solr_field'
     require 'blacklight/configuration/search_field'
     require 'blacklight/configuration/facet_field'
     require 'blacklight/configuration/sort_field'
     include Fields
+    extend Deprecation
+    self.deprecation_horizon = 'blacklight 6.0'
 
     # Set up Blacklight::Configuration.default_values to contain
     # the basic, required Blacklight fields
@@ -21,52 +24,79 @@ module Blacklight
 
         @default_values ||= begin
           {
+          ##
+          # === Search request configuration
+          ##
           # HTTP method to use when making requests to solr; valid
           # values are :get and :post.
-          :http_method => :get,
+          http_method: :get,
           # The solr request handler ('qt') to use for search requests
-          :qt => 'search',
+          qt: 'search',
           # The path to send requests to solr.
-          :solr_path => 'select',
+          solr_path: 'select',
           # Default values of parameters to send with every search request
-          :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,
+          default_solr_params: {},
+          ## deprecated; use add_facet_field :include_in_request instead;
+          # if this is configured true, all facets will be included in the solr request
+          # unless explicitly disabled.
+          add_facet_fields_to_solr_request: false, 
+          ## deprecated; use add_index_field :include_in_request instead;
+          # if this is configured true, all show and index will be included in the solr request
+          # unless explicitly disabled.
+          add_field_configuration_to_solr_request: false,
+          ##
+          # === Single document request configuration
+          ##
           # The solr rqeuest handler to use when requesting only a single document 
-          :document_solr_request_handler => 'document',
+          document_solr_request_handler: 'document',
           # THe path to send single document requests to solr
-          :document_solr_path => nil,
-          :document_unique_id_param => :id,
+          document_solr_path: nil,
+          document_unique_id_param: :id,
           # Default values of parameters to send when requesting a single document
-          :default_document_solr_params => {
+          default_document_solr_params: {
             ## Blacklight provides these settings in the /document request handler
             ## by default, we just ask for all fields. 
-            #:fl => '*',
+            #fl: '*',
             ## this is a fancy way to say "find the document by id using
             ## the value in the id query parameter"
-            #:q => "{!raw f=#{unique_key} v=$id}",
+            #q: "{!raw f=#{unique_key} v=$id}",
             ## disable features we don't need
-            #:facet => false,
-            #:rows => 1
+            #facet: false,
+            #rows: 1
           },
+          ##
+          # == Response models
+          ## Class for sending and receiving requests from a search index
+          repository_class: nil,
+          ## Class for converting Blacklight parameters to request parameters for the repository_class
+          search_builder_class: nil,
+          # model that maps index responses to the blacklight response model
+          response_model: nil,
+          # the model to use for each response document
+          document_model: nil,
+          # document presenter class used by helpers and views
+          document_presenter_class: nil,
+          ##
+          # == Blacklight view configuration
+          ##
+          navbar: OpenStructWithHashAccess.new(partials: { }),
           # General configuration for all views
-          :index => ViewConfig::Index.new(
+          index: ViewConfig::Index.new(
             # solr field to use to render a document title
-            :title_field => nil,
+            title_field: nil,
             # solr field to use to render format-specific partials
-            :display_type_field => 'format',
+            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),
+            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,
+            group: false,
             # additional response formats for search results
-            :respond_to => OpenStructWithHashAccess.new()
+            respond_to: OpenStructWithHashAccess.new()
             ),
           # Additional configuration when displaying a single document
-          :show => ViewConfig::Show.new(
+          show: ViewConfig::Show.new(
             # default route parameters for 'show' requests
             # set this to a hash with additional arguments to merge into 
             # the route, or set `controller: :current` to route to the 
@@ -76,9 +106,8 @@ module Blacklight
             partials: [:show_header, :show],
             document_actions: NestedOpenStructWithHashAccess.new(ToolConfig)
           ),
-          :navbar => OpenStructWithHashAccess.new(partials: { }),
           # Configurations for specific types of index views
-          :view => NestedOpenStructWithHashAccess.new(ViewConfig,
+          view: NestedOpenStructWithHashAccess.new(ViewConfig,
             'list',
             atom: {
               if: false, # by default, atom should not show up as an alternative view
@@ -88,24 +117,27 @@ module Blacklight
               if: false, # by default, rss should not show up as an alternative view
               partials: [:document]
           }),
+          #
+          # These fields are created and managed below by `defined_field_access`
+          # facet_fields
+          # index_fields
+          # show_fields
+          # sort_fields
+          # search_fields
+          ##
+          # === Blacklight behavior configuration
+          ##
           # Maxiumum number of spelling suggestions to offer
-          :spell_max => 5,
+          spell_max: 5,
           # Maximum number of results to show per page
-          :max_per_page => 100,
+          max_per_page: 100,
           # Options for the user for number of results to show per page
-          :per_page => [10,20,50,100],
-          :default_per_page => nil,
+          per_page: [10,20,50,100],
+          default_per_page: nil,
           # how many searches to save in session history
           # (TODO: move the value into the configuration?)
-          :search_history_window => Blacklight::Catalog::SearchHistoryWindow,
-          ## deprecated; use add_facet_field :include_in_request instead;
-          # if this is configured true, all facets will be included in the solr request
-          # unless explicitly disabled.
-          :add_facet_fields_to_solr_request => false, 
-          ## deprecated; use add_index_field :include_in_request instead;
-          # if this is configured true, all show and index will be included in the solr request
-          # unless explicitly disabled.
-          :add_field_configuration_to_solr_request => false
+          search_history_window: Blacklight::Catalog::SearchHistoryWindow,
+          default_facet_limit: 10
           }
         end
       end
@@ -148,13 +180,43 @@ module Blacklight
       end
     end
     
-    def solr_document_model
+    def document_model
       super || SolrDocument
     end
+    alias_method :solr_document_model, :document_model
+    # only here to support alias_method
+    def document_model= *args
+      super
+    end
+    alias_method :solr_document_model=, :document_model=
+    deprecation_deprecate solr_document_model: :document_model, :solr_document_model= => :document_model=
+
+    def document_presenter_class
+      super || Blacklight::DocumentPresenter
+    end
 
-    def solr_response_model
+    def response_model
       super || Blacklight::SolrResponse
     end
+    alias_method :solr_response_model, :response_model
+    # only here to support alias_method
+    def response_model= *args
+      super
+    end
+    alias_method :solr_response_model=, :response_model=
+    deprecation_deprecate solr_response_model: :response_model, :solr_response_model= => :response_model=
+
+    def repository_class
+      super || Blacklight::SolrRepository
+    end
+
+    def search_builder_class
+      super || Blacklight::Solr::SearchBuilder
+    end
+
+    def default_per_page
+      super || per_page.first
+    end
 
     ##
     # DSL helper
@@ -167,7 +229,7 @@ module Blacklight
     # Returns default search field, used for simpler display in history, etc.
     # if not set, defaults to first defined search field
     def default_search_field
-      field = nil
+      field = super
       field ||= search_fields.values.select { |field| field.default == true }.first
       field ||= search_fields.values.first
 
@@ -178,7 +240,7 @@ module Blacklight
     # Returns default sort field, used for simpler display in history, etc.
     # if not set, defaults to first defined sort field
     def default_sort_field
-      field = nil
+      field = super
       field ||= sort_fields.values.select { |field| field.default == true }.first
       field ||= sort_fields.values.first
 
@@ -186,7 +248,7 @@ module Blacklight
     end
     
     def default_title_field
-      solr_document_model.unique_key || 'id'
+      document_model.unique_key || 'id'
     end
 
     ##
@@ -240,6 +302,7 @@ module Blacklight
                   .reject { |k,v| v[:query] || v[:pivot] }
                   .map { |k,v| v.field }
     end
+    deprecation_deprecate :facet_fields_to_add_to_solr
 
     ##
     # Provide a 'deep copy' of Blacklight::Configuration that can be modifyed without affecting
@@ -257,8 +320,11 @@ module Blacklight
       # too. These model names should not be `#dup`'ed or we might break ActiveModel::Naming.
       def deep_copy
         deep_dup.tap do |copy|
-          copy.solr_response_model = self.solr_response_model
-          copy.solr_document_model = self.solr_document_model
+          copy.repository_class = self.repository_class
+          copy.response_model = self.response_model
+          copy.document_model = self.document_model
+          copy.document_presenter_class = self.document_presenter_class
+          copy.search_builder_class = self.search_builder_class
         end
       end
       alias_method :inheritable_copy, :deep_copy

data/lib/blacklight/configuration/facet_field.rb

@@ -1,18 +1,20 @@
 module Blacklight
-  class Configuration::FacetField < Blacklight::Configuration::SolrField
+  class Configuration::FacetField < Blacklight::Configuration::Field
     def normalize! blacklight_config = nil
       self.query.stringify_keys! if self.query
 
-      if self.single and self.tag.blank? and self.ex.blank?
-        self.tag = "#{self.field}_single"
-        self.ex = "#{self.field}_single"
-      end
-
       self.collapse = true if self.collapse.nil?
       self.show = true if self.show.nil?
-      self.if = self.show if self.if.nil?
+      self.if ||= self.show
 
       super
+      
+      if self.single and self.tag.blank? and self.ex.blank?
+        self.tag = "#{self.key}_single"
+        self.ex = "#{self.key}_single"
+      end
+
+      self
     end
   end
 end

data/lib/blacklight/configuration/field.rb

@@ -0,0 +1,27 @@
+module Blacklight
+  class Configuration::Field < OpenStructWithHashAccess
+    def normalize! blacklight_config = nil
+      self.field ||= self.key
+      self.key ||= self.field
+
+      self.label ||= default_label
+
+      self.if = true if self.if.nil?
+      self.unless = false if self.unless.nil?
+
+      self
+    end
+  
+    def validate!
+      raise ArgumentError.new("Must supply a field name") if self.field.nil?
+    end
+
+    def default_label
+      if self.key.respond_to?(:titleize)
+        self.key.try(:titleize)
+      else
+        self.key.to_s.titleize
+      end
+    end
+  end
+end

data/lib/blacklight/configuration/fields.rb

@@ -4,6 +4,8 @@ module Blacklight
     # solr fields configuration
     module Fields
       extend ActiveSupport::Concern
+      extend Deprecation
+      self.deprecation_horizon = "blacklight 6.0"
 
       module ClassMethods
 
@@ -13,7 +15,7 @@ module Blacklight
 
           self.default_values[key.pluralize.to_sym] = ActiveSupport::OrderedHash.new
 
-          base_class_name = options.fetch(:class, SolrField)
+          base_class_name = options.fetch(:class, Field)
 
           unless self.const_defined? key.camelcase
             class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
@@ -23,7 +25,7 @@ module Blacklight
     
           class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
             def add_#{key}(*args, &block)
-              add_solr_field("#{key}", *args, &block)
+              add_blacklight_field("#{key}", *args, &block)
             end
           END_EVAL
         end
@@ -32,41 +34,41 @@ module Blacklight
       # Add a solr field configuration to the given configuration key
       #
       # The recommended and strongly encouraged format is a field name, configuration pair, e.g.:
-      #     add_solr_field :index_field, 'format', :label => 'Format' 
+      #     add_blacklight_field :index_field, 'format', :label => 'Format' 
       #
       # Alternative formats include:
       #
       # * a field name and block format:
       #
-      #     add_solr_field :index_field, 'format' do |field|
+      #     add_blacklight_field :index_field, 'format' do |field|
       #       field.label = 'Format'
       #     end
       #
       # * a plain block:
       #
-      #     add_solr_field :index_field do |field|
+      #     add_blacklight_field :index_field do |field|
       #       field.field = 'format'
       #       field.label = 'Format'
       #     end
       # 
       # * a configuration hash:
       #
-      #     add_solr_field :index_field, :field => 'format', :label => 'Format'
+      #     add_blacklight_field :index_field, :field => 'format', :label => 'Format'
       #   
       # * a Field instance: 
       #
-      #     add_solr_field :index_field, IndexField.new(:field => 'format', :label => 'Format')
+      #     add_blacklight_field :index_field, IndexField.new(:field => 'format', :label => 'Format')
       #
       # * an array of hashes: 
       #
-      #     add_solr_field :index_field, [{:field => 'format', :label => 'Format'}, IndexField.new(:field => 'date', :label => 'Date')]
+      #     add_blacklight_field :index_field, [{:field => 'format', :label => 'Format'}, IndexField.new(:field => 'date', :label => 'Date')]
       #
       #
       # @param String config_key 
       # @param Array *args 
       # @para
       #
-      def add_solr_field config_key, *args, &block
+      def add_blacklight_field config_key, *args, &block
         field_config = case args.first
           when String
             field_config_from_key_and_hash(config_key, *args)
@@ -81,18 +83,20 @@ module Blacklight
         end
 
         # look up any dynamic fields
-        if field_config.field.to_s =~ /\*/ and luke_fields
+        if (field_config.field || field_config.key).to_s =~ /\*/ and luke_fields
+          wildcard_field = (field_config.field || field_config.key).to_s
           salient_fields = luke_fields.select do |k,v| 
-            k =~ Regexp.new("^" + field_config.field.to_s.gsub('*', '.+') + "$")
+            k =~ Regexp.new("^" + wildcard_field.gsub('*', '.+') + "$")
           end
 
           salient_fields.each do |field, luke_config|
             config = field_config.dup
             config.field = field
-            if self[config_key.pluralize][ config.field ]
-              self[config_key.pluralize][ config.field ] = config.merge(self[config_key.pluralize][ config.field ])
+            config.key = field
+            if self[config_key.pluralize][ config.key ]
+              self[config_key.pluralize][ config.key ] = config.merge(self[config_key.pluralize][ config.key ])
             else
-              add_solr_field(config_key, config, &block)
+              add_blacklight_field(config_key, config, &block)
             end
           end
 
@@ -106,10 +110,12 @@ module Blacklight
         field_config.normalize!(self)
         field_config.validate!
 
-        raise "A #{config_key} with the key #{field_config.field} already exists." if self[config_key.pluralize][field_config.field].present?
+        raise "A #{config_key} with the key #{field_config.key} already exists." if self[config_key.pluralize][field_config.key].present?
 
-        self[config_key.pluralize][ field_config.field ] = field_config            
+        self[config_key.pluralize][ field_config.key ] = field_config            
       end
+      alias_method :add_solr_field, :add_blacklight_field
+      deprecation_deprecate add_solr_field: :add_blacklight_field
 
       protected
       def luke_fields
@@ -129,17 +135,16 @@ module Blacklight
       end
 
       # Add a solr field by a solr field name and hash 
-      def field_config_from_key_and_hash config_key, solr_field, field_or_hash = {}
+      def field_config_from_key_and_hash config_key, field_name, field_or_hash = {}
         field_config = field_config_from_field_or_hash(config_key, field_or_hash)
-        field_config.field = solr_field
-
+        field_config.key = field_name
         field_config
       end
 
       # Add multiple solr fields using a hash or Field instance
       def field_config_from_array config_key, array_of_fields_or_hashes, &block
         array_of_fields_or_hashes.map do |field_or_hash| 
-          add_solr_field(config_key, field_or_hash, &block)
+          add_blacklight_field(config_key, field_or_hash, &block)
         end
       end