blacklight 6.21.0 → 7.3.0

data/app/models/concerns/blacklight/document/extensions.rb

@@ -24,8 +24,8 @@ module Blacklight::Document::Extensions
   # Needs to be called in initializer of class including this module, to
   # apply all registered extensions on a per-document basis
   def apply_extensions
-    self.class.registered_extensions.each do | registration|
-      self.extend( registration[:module_obj] ) if registration[:condition_proc].nil? || registration[:condition_proc].call( self )
+    self.class.registered_extensions.each do |registration|
+      extend(registration[:module_obj]) if registration[:condition_proc].nil? || registration[:condition_proc].call(self)
     end
   end
 
@@ -43,15 +43,15 @@ module Blacklight::Document::Extensions
     end
 
     # Register an extension module with the class. A block taking one
-    # parameter can be supplied; the block will be passed an instance of 
+    # parameter can be supplied; the block will be passed an instance of
     # a Document, and the extension will be applied only if the block
     # evaluates as true. If no condition is given, the extension will
     # be applied to every instance of the class.
     #
     # SolrDocument.use_extension( SomeExtensionModule ) { | document | should_apply_some_extension?(document) }
     # SolrDocument.use_extension( SomeExtensionModule) # will be applied to all docs
-    def use_extension( module_obj, &condition )
-      registered_extensions << {module_obj: module_obj, condition_proc: condition}    
+    def use_extension(module_obj, &condition)
+      registered_extensions << { module_obj: module_obj, condition_proc: condition }
     end
   end
 end

data/app/models/concerns/blacklight/document/semantic_fields.rb

@@ -7,7 +7,7 @@ module Blacklight::Document
       # Returns array of hashes of registered extensions. Each hash
       # has a :module_obj key and a :condition_proc key. Usually this
       # method is only used internally in #apply_extensions, but if you
-   
+
       # Class-level method for accessing/setting semantic mappings
       # for solr stored fields. Can be set by local app, key is
       # a symbol for a semantic, value is a solr _stored_ field.
@@ -17,22 +17,22 @@ module Blacklight::Document
       #
       # Currently documented semantic tokens, not all may be
       # used by core BL, but some may be used by plugins present
-      # or future. 
-      # :title, :author, :year, :language => User-presentable strings. 
+      # or future.
+      # :title, :author, :year, :language => User-presentable strings.
       def field_semantics
         @field_semantics ||= {}
-      end  
+      end
     end
-    
+
     # Returns a hash keyed by semantic tokens, value is an array of
     # strings. (Array to handle multi-value fields). If no value(s)
-    # available, empty array is returned. 
+    # available, empty array is returned.
     #
     # Default implementation here uses field_semantics
-    # to just take values from Solr stored fields. 
+    # to just take values from Solr stored fields.
     # Extensions can over-ride this method to provide better/different lookup,
     # but extensions should call super and modify hash returned, to avoid
-    # unintentionally erasing values provided by other extensions. 
+    # unintentionally erasing values provided by other extensions.
     def to_semantic_values
       @semantic_value_hash ||= self.class.field_semantics.each_with_object(Hash.new([])) do |(key, field_names), hash|
         ##
@@ -45,6 +45,6 @@ module Blacklight::Document
       end
 
       @semantic_value_hash ||= {}
-    end    
+    end
   end
 end

data/app/models/concerns/blacklight/document/sms.rb

@@ -3,10 +3,10 @@
 module Blacklight::Document::Sms
   # Return a text string that will be the body of the email
   def to_sms_text
-    semantics = self.to_semantic_values
+    semantics = to_semantic_values
     body = []
-    body << I18n.t('blacklight.sms.text.title', value: semantics[:title].first) unless semantics[:title].blank?
-    body << I18n.t('blacklight.sms.text.author', value: semantics[:author].first) unless semantics[:author].blank?
+    body << I18n.t('blacklight.sms.text.title', value: semantics[:title].first) if semantics[:title].present?
+    body << I18n.t('blacklight.sms.text.author', value: semantics[:author].first) if semantics[:author].present?
     return body.join unless body.empty?
   end
 end

data/app/models/concerns/blacklight/user.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 module Blacklight::User
   # This gives us an is_blacklight_user method that can be included in
-  # the containing applications models. 
-  # SEE ALSO:  The /lib/blacklight/engine.rb class for how when this 
+  # the containing applications models.
+  # SEE ALSO:  The /lib/blacklight/engine.rb class for how when this
   # is injected into the hosting application through ActiveRecord::Base extend
   def self.included(base)
     return unless base.respond_to? :has_many
-    base.send :has_many, :bookmarks, :dependent => :destroy, :as => :user
-    base.send :has_many, :searches,  :dependent => :destroy, :as => :user
+
+    base.send :has_many, :bookmarks, dependent: :destroy, as: :user
+    base.send :has_many, :searches,  dependent: :destroy, as: :user
   end
 
   def bookmarks_for_documents documents = []
@@ -21,9 +22,9 @@ module Blacklight::User
   def document_is_bookmarked?(document)
     bookmarks_for_documents([document]).any?
   end
-    
+
   # returns a Bookmark object if there is one for document_id, else
-  # nil. 
+  # nil.
   def existing_bookmark_for(document)
     bookmarks_for_documents([document]).first
   end

data/app/models/record_mailer.rb

@@ -1,25 +1,27 @@
 # frozen_string_literal: true
-# Only works for documents with a #to_marc right now. 
+# Only works for documents with a #to_marc right now.
 class RecordMailer < ActionMailer::Base
   def email_record(documents, details, url_gen_params)
-        
     title = begin
               documents.first.to_semantic_values[:title]
             rescue
               I18n.t('blacklight.email.text.default_title')
             end
-    subject = I18n.t('blacklight.email.text.subject', :count => documents.length, :title => title )
+
+    subject = I18n.t('blacklight.email.text.subject',
+                     count: documents.length,
+                     title: Array(title).first)
 
     @documents      = documents
     @message        = details[:message]
     @url_gen_params = url_gen_params
 
-    mail(:to => details[:to],  :subject => subject)
+    mail(to: details[:to],  subject: subject)
   end
-  
+
   def sms_record(documents, details, url_gen_params)
     @documents      = documents
     @url_gen_params = url_gen_params
-    mail(:to => details[:to], :subject => "")
+    mail(to: details[:to], subject: "")
   end
 end

data/app/models/search.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
-class Search < ActiveRecord::Base
-  belongs_to_arguments = { optional: true } if Rails.version >= '5.0.0'
 
-  belongs_to :user, belongs_to_arguments
+class Search < ApplicationRecord
+  belongs_to :user, optional: true
 
   serialize :query_params
 
-  attr_accessible :query_params if Blacklight::Utils.needs_attr_accessible?
-
   # A Search instance is considered a saved search if it has a user_id.
   def saved?
-    self.user_id?
+    user_id?
   end
 
   # delete old, unsaved searches
   def self.delete_old_searches(days_old)
     raise ArgumentError, 'days_old is expected to be a number' unless days_old.is_a?(Numeric)
     raise ArgumentError, 'days_old is expected to be greater than 0' if days_old <= 0
-    self.where(['created_at < ? AND user_id IS NULL', Time.zone.today - days_old]).destroy_all
+
+    where(['created_at < ? AND user_id IS NULL', Time.zone.today - days_old]).delete_all
   end
 end

data/app/presenters/blacklight/document_presenter.rb

@@ -1,153 +1,38 @@
 # frozen_string_literal: true
+
 module Blacklight
-  # @deprecated
+  # An abstract class that the view presenters for SolrDocuments descend from
   class DocumentPresenter
-    extend Deprecation
-    self.deprecation_horizon = 'Blacklight version 7.0.0'
-
-    # @param [SolrDocument] document
-    # @param [ActionController::Base] controller scope for linking and generating urls
-    # @param [Blacklight::Configuration] configuration
-    def initialize(document, controller, configuration = controller.blacklight_config)
-      @document = document
-      @configuration = configuration
-      @controller = controller
-    end
-
-    ##
-    # Get the value of the document's "title" field, or a placeholder
-    # value (if empty)
-    #
-    # @return [String]
-    # @deprecated use ShowPresenter#heading instead
-    def document_heading
-      show_presenter.heading
-    end
-    deprecation_deprecate document_heading: "use ShowPresenter#heading instead"
-
-    ##
-    # Create <link rel="alternate"> links from a documents dynamically
-    # provided export formats. Returns empty string if no links available.
-    #
-    # @param [Hash] options
-    # @option options [Boolean] :unique ensures only one link is output for every
-    #     content type, e.g. as required by atom
-    # @option options [Array<String>] :exclude array of format shortnames to not include in the output
-    # @deprecated moved to ShowPresenter#link_rel_alternates
-    def link_rel_alternates(options = {})
-      show_presenter.link_rel_alternates(options)
-    end
-    deprecation_deprecate link_rel_alternates: "use ShowPresenter#link_rel_alternates instead"
-
-    ##
-    # Get the document's "title" to display in the <title> element.
-    # (by default, use the #document_heading)
-    #
-    # @see #document_heading
-    # @return [String]
-    # @deprecated use ShowPresenter#html_title instead
-    def document_show_html_title
-      show_presenter.html_title
-    end
-    deprecation_deprecate document_show_html_title: "use ShowPresenter#html_title instead"
-
-    ##
-    # Render the document index heading
-    #
-    # @overload render_document_index_label(field, opts)
-    #   @param [Symbol, Proc, String] field Render the given field or evaluate the proc or render the given string
-    #   @param [Hash] opts
-    # @deprecated use IndexPresenter#label instead
-    def render_document_index_label(*args)
-      index_presenter.label(*args)
-    end
-    deprecation_deprecate render_document_index_label: "use IndexPresenter#label instead"
-
-    ##
-    # Render the index field label for a document
-    #
-    # Allow an extention point where information in the document
-    # may drive the value of the field
-    # @overload render_index_field_value(field, opts)
-    #   @param [String] field
-    #   @param [Hash] opts
-    #   @option opts [String] :value
-    # @deprecated use IndexPresenter#field_value instead
-    def render_index_field_value *args
-      index_presenter.field_value(*args)
+    attr_reader :document, :configuration, :view_context
+
+    # @return [Hash<String,Configuration::Field>]  all the fields for this index view that should be rendered
+    def fields_to_render
+      fields.select do |_name, field_config|
+        # rubocop:disable Style/PreferredHashMethods
+        render_field?(field_config) && has_value?(field_config)
+        # rubocop:enable Style/PreferredHashMethods
+      end
     end
-    deprecation_deprecate render_index_field_value: "use IndexPresenter#field_value instead"
 
-    ##
-    # Render the show field value for a document
-    #
-    #   Allow an extention point where information in the document
-    #   may drive the value of the field
-    #
-    # @overload render_index_field_value(field, options)
-    #   @param [String] field
-    #   @param [Hash] options
-    #   @option options [String] :value
-    #   @deprecated use ShowPresenter#field_value
-    def render_document_show_field_value *args
-      show_presenter.field_value(*args)
-    end
-    deprecation_deprecate render_document_show_field_value: "use ShowPresenter#field_value instead"
+    private
 
     ##
-    # Get the value for a document's field, and prepare to render it.
-    # - highlight_field
-    # - accessor
-    # - solr field
-    #
-    # Rendering:
-    #   - helper_method
-    #   - link_to_search
-    # @param [String] _field name
-    # @param [Blacklight::Configuration::Field] field_config solr field configuration
-    # @param [Hash] options additional options to pass to the rendering helpers
-    # @deprecated
-    def get_field_values _field, field_config, options = {}
-      field_values(field_config, options)
+    # Check to see if the given field should be rendered in this context
+    # @param [Blacklight::Configuration::Field] field_config
+    # @return [Boolean]
+    def render_field?(field_config)
+      view_context.should_render_field?(field_config, document)
     end
-    deprecation_deprecate get_field_values: 'Use field_values instead'
 
     ##
-    # Get the value for a document's field, and prepare to render it.
-    # - highlight_field
-    # - accessor
-    # - solr field
-    #
-    # Rendering:
-    #   - helper_method
-    #   - link_to_search
-    # @param [Blacklight::Configuration::Field] field_config solr field configuration
-    # @param [Hash] options additional options to pass to the rendering helpers
-    def field_values(field_config, options={})
-      FieldPresenter.new(@controller, @document, field_config, options).render
-    end
-    deprecation_deprecate field_values: 'Use ShowPresenter or IndexPresenter field_values instead'
-
-    # @deprecated
-    def render_field_value(values, field_config = Configuration::NullField.new)
-      field_values(field_config, value: Array(values))
+    # Check if a document has (or, might have, in the case of accessor methods) a value for
+    # the given solr field
+    # @param [Blacklight::Configuration::Field] field_config
+    # @return [Boolean]
+    def has_value? field_config
+      document.has?(field_config.field) ||
+        (document.has_highlight_field? field_config.field if field_config.highlight) ||
+        field_config.accessor
     end
-    deprecation_deprecate render_field_value: 'Use FieldPresenter instead'
-
-    # @deprecated
-    def render_values(values, field_config = Configuration::NullField.new)
-      field_values(field_config, value: Array(values))
-    end
-    deprecation_deprecate render_values: 'Use FieldPresenter instead'
-
-    private
-
-      def index_presenter
-        @controller.index_presenter(@document)
-      end
-
-      def show_presenter
-        @controller.show_presenter(@document)
-      end
   end
 end

data/app/presenters/blacklight/field_presenter.rb

@@ -1,6 +1,14 @@
+# frozen_string_literal: true
+
 module Blacklight
-  # Renders a field and handles link_to_search or helper_method if supplied
+  # Renders a field and handles link_to_facet or helper_method if supplied
   class FieldPresenter
+    # @param controller [Object] the context in which to execute helper methods
+    # @param document [SolrDocument] the document
+    # @param field_config [Blacklight::Configuration::Field] the field's configuration
+    # @param options [Hash]
+    # @option options [Object] :value when this is provided, we don't want the pipeline to deal with helper methods.
+    #                                 this happens when drawing the label for the document
     def initialize(controller, document, field_config, options)
       @controller = controller
       @document = document
@@ -9,23 +17,20 @@ module Blacklight
     end
 
     attr_reader :controller, :document, :field_config, :options
-    
+
     def render
-      if options[:value]
-        # This prevents helper methods from drawing.
-        config = Configuration::NullField.new(field_config.to_h.except(:helper_method))
-        values = Array.wrap(options[:value])
-      else
-        config = field_config
-        values = retrieve_values
-      end
-      Rendering::Pipeline.render(values, config, document, controller, options)
+      return Rendering::Pipeline.render(retrieve_values, field_config, document, controller, options) unless options[:value]
+
+      values = Array.wrap(options[:value])
+      # Prevents helper methods from drawing.
+      steps = Rendering::Pipeline.operations - [Rendering::HelperMethod]
+      Rendering::Pipeline.new(values, field_config, document, controller, steps, options).render
     end
 
     private
 
-      def retrieve_values
-        FieldRetriever.new(document, field_config).fetch
-      end
+    def retrieve_values
+      FieldRetriever.new(document, field_config).fetch
+    end
   end
 end

data/app/presenters/blacklight/index_presenter.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 module Blacklight
-  class IndexPresenter
-    extend Deprecation
-    self.deprecation_horizon = 'Blacklight version 7.0.0'
+  class IndexPresenter < DocumentPresenter
+    class_attribute :thumbnail_presenter
+    self.thumbnail_presenter = ThumbnailPresenter
 
-    attr_reader :document, :configuration, :view_context
+    attr_reader :view_config
 
     # @param [SolrDocument] document
     # @param [ActionView::Base] view_context scope for linking and generating urls
@@ -13,10 +13,12 @@ module Blacklight
       @document = document
       @view_context = view_context
       @configuration = configuration
+      @view_config = configuration.view_config(view_context.document_index_view_type)
     end
 
     ##
-    # Render the document index heading
+    # Render the document index heading. This is used when making a link to a
+    # document, where we don't want any HTML markup added from the pipeline.
     #
     # @param [Symbol, Proc, String] field_or_string_or_proc Render the given field or evaluate the proc or render the given string
     # @param [Hash] opts
@@ -24,93 +26,63 @@ module Blacklight
     def label(field_or_string_or_proc, opts = {})
       config = Configuration::NullField.new
       value = case field_or_string_or_proc
-      when Symbol
-        config = field_config(field_or_string_or_proc)
-        document[field_or_string_or_proc]
-      when Proc
-        field_or_string_or_proc.call(document, opts)
-      when String
-        field_or_string_or_proc
-      end
+                when Symbol
+                  config = field_config(field_or_string_or_proc)
+                  document[field_or_string_or_proc]
+                when Proc
+                  Deprecation.warn(self, "calling IndexPresenter.label with a Proc is deprecated. " \
+                                         "First argument must be a symbol. This will be removed in Blacklight 8")
+                  field_or_string_or_proc.call(document, opts)
+                when String
+                  Deprecation.warn(self, "calling IndexPresenter.label with a String is deprecated. " \
+                                         "First argument must be a symbol. This will be removed in Blacklight 8")
+                  field_or_string_or_proc
+              end
 
       value ||= document.id
       field_values(config, value: value)
     end
 
-    # @deprecated
-    def render_document_index_label(*args)
-      label(*args)
-    end
-    deprecation_deprecate render_document_index_label: 'Use #label instead'
-
     ##
     # Render the index field label for a document
     #
     # Allow an extention point where information in the document
     # may drive the value of the field
-    # @param [Configuration::Field, String] field_or_name
+    # @param [Configuration::Field] field
     # @param [Hash] options
     # @option options [String] :value
-    def field_value field_or_name, options = {}
-      field = case field_or_name
-              when Blacklight::Configuration::Field
-                field_or_name
-              when String, Symbol
-                Deprecation.warn(self, "You provided a #{field_or_name.class} value to IndexPresenter#field_value " \
-                "Provide a Blacklight::Configuration::Field instead. This behavior is deprecated in Blacklight 7")
-                field_config(field_or_name)
-              else
-                Deprecation.warn(self, "You provided a #{field_or_name.class} value to IndexPresenter#field_value. " \
-                "This will be silently ignored and will be an error in Blacklight 7.")
-
-                Configuration::NullField.new
-              end
+    def field_value field, options = {}
       field_values(field, options)
     end
 
-    # @deprecated
-    def render_index_field_value(*args)
-      field_value(*args)
+    def thumbnail
+      @thumbnail ||= thumbnail_presenter.new(document, view_context, view_config)
     end
-    deprecation_deprecate render_index_field_value: 'replaced by #field_value'
 
-    # @deprecated
-    def get_field_values(field_config, options={})
-      field_values(field_config, options)
-    end
-    deprecation_deprecate get_field_values: "replaced by #field_value"
+    private
 
-    # @deprecated
-    def render_field_values(values, field_config = Configuration::NullField.new)
-      field_values(field_config, value: Array(values))
+    # @return [Hash<String,Configuration::Field>] all the fields for this index view
+    def fields
+      configuration.index_fields_for(document)
     end
-    deprecation_deprecate render_field_values: "replaced by #field_value"
 
-    # @deprecated
-    def render_values(values, field_config = Configuration::NullField.new)
-      field_values(field_config, value: Array(values))
+    ##
+    # Get the value for a document's field, and prepare to render it.
+    # - highlight_field
+    # - accessor
+    # - solr field
+    #
+    # Rendering:
+    #   - helper_method
+    #   - link_to_facet
+    # @param [Blacklight::Configuration::Field] field_config solr field configuration
+    # @param [Hash] options additional options to pass to the rendering helpers
+    def field_values(field_config, options = {})
+      FieldPresenter.new(view_context, document, field_config, options).render
     end
-    deprecation_deprecate render_values: "replaced by #field_value"
-
-    private
-
-      ##
-      # Get the value for a document's field, and prepare to render it.
-      # - highlight_field
-      # - accessor
-      # - solr field
-      #
-      # Rendering:
-      #   - helper_method
-      #   - link_to_search
-      # @param [Blacklight::Configuration::Field] field_config solr field configuration
-      # @param [Hash] options additional options to pass to the rendering helpers
-      def field_values(field_config, options={})
-        FieldPresenter.new(view_context, document, field_config, options).render
-      end
 
-      def field_config(field)
-        configuration.index_fields.fetch(field) { Configuration::NullField.new(field) }
-      end
+    def field_config(field)
+      configuration.index_fields.fetch(field) { Configuration::NullField.new(field) }
+    end
   end
 end