blacklight 6.2.0 → 6.3.0

data/app/presenters/blacklight/field_presenter.rb

@@ -0,0 +1,31 @@
+module Blacklight
+  # Renders a field and handles link_to_search or helper_method if supplied
+  class FieldPresenter
+    def initialize(controller, document, field_config, options)
+      @controller = controller
+      @document = document
+      @field_config = field_config
+      @options = options
+    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)
+    end
+
+    private
+
+      def retrieve_values
+        FieldRetriever.new(document, field_config).fetch
+      end
+  end
+end

data/app/presenters/blacklight/index_presenter.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module Blacklight
+  class IndexPresenter
+    # @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
+
+    ##
+    # Render the document index heading
+    #
+    # @param [Symbol, Proc, String] field Render the given field or evaluate the proc or render the given string
+    # @param [Hash] opts
+    # TODO: the default field should be `document_show_link_field(doc)'
+    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
+
+      value ||= @document.id
+      field_values(config, value: value)
+    end
+
+    ##
+    # 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 [String] field
+    # @param [Hash] opts
+    # @options opts [String] :value
+    def field_value field, options = {}
+      field_config = field_config(field)
+      field_values(field_config, options)
+    end
+
+    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] 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
+
+      def field_config(field)
+        @configuration.index_fields.fetch(field) { Configuration::NullField.new(field) }
+      end
+  end
+end

data/app/presenters/blacklight/link_alternate_presenter.rb

@@ -0,0 +1,29 @@
+module Blacklight
+  # Create <link rel="alternate"> links from a documents dynamically
+  class LinkAlternatePresenter
+    include ActionView::Helpers::OutputSafetyHelper
+    include ActionView::Helpers::TagHelper
+
+    def initialize(controller, document, options)
+      @controller = controller
+      @document = document
+      @options = { unique: false, exclude: [] }.merge(options)
+    end
+
+    attr_reader :controller, :document, :options
+
+    # Renders links to alternate representations 
+    # provided by export formats. Returns empty string if no links available.
+    def render
+      seen = Set.new
+
+      safe_join(document.export_formats.map do |format, spec|
+        next if options[:exclude].include?(format) || (options[:unique] && seen.include?(spec[:content_type]))
+
+        seen.add(spec[:content_type])
+
+        tag(:link, rel: "alternate", title: format, type: spec[:content_type], href: controller.polymorphic_url(document, format: format))
+      end.compact, "\n")
+    end
+  end
+end

data/app/presenters/blacklight/rendering/abstract_step.rb

@@ -0,0 +1,24 @@
+module Blacklight
+  module Rendering
+    class AbstractStep
+      def initialize(values, config, document, context, options, stack)
+        @values = values
+        @config = config
+        @document = document
+        @context = context
+        @options = options
+        @stack = stack
+      end
+
+      attr_reader :values, :config, :document, :context, :options, :stack
+
+      protected
+
+        def next_step(output_values)
+          first, *rest = *stack
+          first.new(output_values, config, document, context, options, rest).render
+        end
+    end
+  end
+end
+

data/app/presenters/blacklight/rendering/helper_method.rb

@@ -0,0 +1,23 @@
+module Blacklight
+  module Rendering
+    class HelperMethod < AbstractStep
+      def render
+        return next_step(values) unless config.helper_method
+        return render_helper # short circut the rest of the steps
+      end
+
+      private
+
+        def render_helper
+          context.send(config.helper_method,
+                       options.merge(document: document,
+                                     field: config.field,
+                                     config: config,
+                                     value: values))
+        end
+    end
+  end
+end
+
+
+

data/app/presenters/blacklight/rendering/join.rb

@@ -0,0 +1,16 @@
+module Blacklight
+  module Rendering
+    class Join < AbstractStep
+      def render
+        options = config.separator_options || {}
+        next_step(values.map { |x| html_escape(x) }.to_sentence(options).html_safe)
+      end
+
+      private
+
+        def html_escape(*args)
+          ERB::Util.html_escape(*args)
+        end
+    end
+  end
+end

data/app/presenters/blacklight/rendering/link_to_facet.rb

@@ -0,0 +1,35 @@
+module Blacklight
+  module Rendering
+    class LinkToFacet < AbstractStep
+      def render
+        # TODO: We should rename the config variable, because it creates a link to a facet.
+        return next_step(values) unless config.link_to_search
+        next_step(render_link)
+      end
+
+      private
+
+        # This allows the link to wrap an itemprop
+        def render_link
+          values.map { |v| link(link_field, v) }
+        end
+
+        def link_field
+          return config.key if config.link_to_search === true
+          config.link_to_search
+        end
+
+        def link(field, v)
+          context.link_to v, search_path(field, v)
+        end
+
+        def search_path(field, v)
+          context.search_action_path(facet_params(field, v))
+        end
+
+        def facet_params(field, v)
+          context.search_state.reset.add_facet_params(field, v)
+        end
+    end
+  end
+end

data/app/presenters/blacklight/rendering/microdata.rb

@@ -0,0 +1,17 @@
+module Blacklight
+  module Rendering
+    class Microdata < AbstractStep
+      include ActionView::Helpers::TagHelper
+      def render
+        return next_step(values) unless config.itemprop
+        next_step(values.map { |x| itemprop(x, config.itemprop) })
+      end
+
+      private
+
+        def itemprop(val, itemprop)
+          content_tag :span, val, itemprop: itemprop
+        end
+    end
+  end
+end

data/app/presenters/blacklight/rendering/pipeline.rb

@@ -0,0 +1,32 @@
+module Blacklight
+  module Rendering
+    # The field rendering pipeline
+    class Pipeline
+      def initialize(values, config, document, context, options)
+        @values = values
+        @config = config
+        @document = document
+        @context = context
+        @options = options
+      end
+
+      attr_reader :values, :config, :document, :context, :options
+
+      def self.render(values, config, document, context, options)
+        new(values, config, document, context, options).render
+      end
+
+      def render
+        first, *rest = *stack
+        first.new(values, config, document, context, options, rest).render
+      end
+
+      protected
+
+        # Ordered list of operations, Terminator must be at the end.
+        def stack
+          [HelperMethod, LinkToFacet, Microdata, Join, Terminator]
+        end
+    end
+  end
+end

data/app/presenters/blacklight/rendering/terminator.rb

@@ -0,0 +1,9 @@
+module Blacklight
+  module Rendering
+    class Terminator < AbstractStep
+      def render
+        values
+      end
+    end
+  end
+end

data/app/presenters/blacklight/show_presenter.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+module Blacklight
+  class ShowPresenter
+    # @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
+
+    ##
+    # Create <link rel="alternate"> links from a documents dynamically
+    # provided export formats. Returns empty string if no links available.
+    #
+    # @params [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 = {})
+      LinkAlternatePresenter.new(@controller, @document, options).render
+    end
+
+    ##
+    # Get the document's "title" to display in the <title> element.
+    # (by default, use the #document_heading)
+    #
+    # @see #document_heading
+    # @return [String]
+    def html_title
+      if view_config.html_title_field
+        fields = Array.wrap(view_config.html_title_field)
+        f = fields.detect { |field| @document.has? field }
+        f ||= 'id'
+        field_values(field_config(f))
+      else
+        heading
+      end
+    end
+
+    ##
+    # Get the value of the document's "title" field, or a placeholder
+    # value (if empty)
+    #
+    # @param [SolrDocument] document
+    # @return [String]
+    def heading
+      fields = Array.wrap(view_config.title_field)
+      f = fields.detect { |field| @document.has? field }
+      f ||= @configuration.document_model.unique_key
+      field_values(field_config(f), value: @document[f])
+    end
+
+    ##
+    # Render the show field value for a document
+    #
+    # Allow an extention point where information in the document
+    # may drive the value of the field
+    # @param [String] field
+    # @param [Hash] options
+    # @options opts [String] :value
+    def field_value field, options={}
+      field_values(field_config(field), options)
+    end
+
+    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] 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
+
+      def view_config
+        @configuration.view_config(:show)
+      end
+
+      def field_config(field)
+        @configuration.show_fields.fetch(field) { Configuration::NullField.new(field) }
+      end
+  end
+end

data/app/services/blacklight/field_retriever.rb

@@ -0,0 +1,58 @@
+module Blacklight
+  class FieldRetriever
+    # @param [SolrDocument] document
+    # @param [Blacklight::Configuration::Field] field_config solr field configuration
+    def initialize(document, field_config)
+      @document = document
+      @field_config = field_config
+    end
+
+    attr_reader :document, :field_config
+    delegate :field, to: :field_config
+    
+    # @return [Array]
+    def fetch
+      Array.wrap(
+        case    
+          when field_config.highlight
+            retrieve_highlight
+          when field_config.accessor
+            retieve_using_accessor
+          when field_config
+            retrieve_simple
+        end
+      )
+    end
+
+    private
+
+      def retrieve_simple
+        # regular document field
+        if field_config.default and field_config.default.is_a? Proc
+          document.fetch(field_config.field, &field_config.default)
+        else
+          document.fetch(field_config.field, field_config.default)
+        end
+      end
+
+      def retieve_using_accessor
+        # implicit method call
+        if field_config.accessor === true
+          document.send(field)
+        # arity-1 method call (include the field name in the call)
+        elsif !field_config.accessor.is_a?(Array) && document.method(field_config.accessor).arity != 0
+          document.send(field_config.accessor, field)
+        # chained method calls
+        else
+          Array(field_config.accessor).inject(document) do |result, method|
+            result.send(method)
+          end
+        end
+      end
+
+      def retrieve_highlight
+        # retrieve the document value from the highlighting response
+        document.highlight_field(field_config.field).map(&:html_safe) if document.has_highlight_field? field_config.field
+      end
+  end
+end