blacklight 5.7.2 → 5.8.0

data/app/helpers/blacklight/catalog_helper_behavior.rb

@@ -9,6 +9,8 @@ module Blacklight::CatalogHelperBehavior
   # @param [RSolr::Resource] (or other Kaminari-compatible objects)
   # @return [String]
   def page_entries_info(collection, options = {})
+    return unless show_pagination? collection
+
     entry_name = if options[:entry_name]
       options[:entry_name]
     elsif collection.respond_to? :model  # DataMapper
@@ -92,7 +94,17 @@ module Blacklight::CatalogHelperBehavior
   # 
   # @return [String]
   def render_document_class(document = @document)
-    'blacklight-' + document.get(blacklight_config.view_config(document_index_view_type_field).display_type_field).parameterize rescue nil
+    types = document[blacklight_config.view_config(document_index_view_type).display_type_field]
+
+    return if types.blank?
+
+    Array(types).map do |t|
+      document_class_prefix + t.parameterize rescue nil
+    end.join(' ')
+  end
+
+  def document_class_prefix
+    'blacklight-'
   end
 
   ##
@@ -114,6 +126,16 @@ module Blacklight::CatalogHelperBehavior
     !response.empty?
   end
 
+  ##
+  # Should we display the pagination controls?
+  #
+  # @param [Blacklight::SolrResponse]
+  # @return [Boolean]
+  def show_pagination? response = nil
+    response ||= @response
+    response.limit_value > 0
+  end
+
   ##
   # If no search parameters have been given, we should
   # auto-focus the user's cursor into the searchbox
@@ -154,7 +176,7 @@ module Blacklight::CatalogHelperBehavior
       if url_options === false || url_options[:suppress_link]
         value
       else
-        link_to_document document, url_options.merge(:label => value)
+        link_to_document document, value, url_options
       end
     end
   end
@@ -213,4 +235,16 @@ module Blacklight::CatalogHelperBehavior
       render('endnote') + render('refworks')
     end
   end
+
+  def render_refworks_action? config, options = {}
+    options[:document] && options[:document].respond_to?(:export_formats) && options[:document].export_formats.keys.include?(:refworks_marc_txt )
+  end
+
+  def render_endnote_action? config, options = {}
+    options[:document] && options[:document].respond_to?(:export_formats) && options[:document].export_formats.keys.include?(:endnote )
+  end
+
+  def render_librarian_view_control? config, options = {}
+    respond_to? :librarian_view_catalog_path and options[:document] and options[:document].respond_to?(:to_marc)
+  end
 end

data/app/helpers/blacklight/component_helper_behavior.rb

@@ -0,0 +1,77 @@
+module Blacklight
+  module ComponentHelperBehavior
+
+    def document_action_label action, opts
+      t("blacklight.tools.#{action}", default: opts.label || action.to_s.humanize)
+    end
+
+    def document_action_path action_opts, url_opts = nil
+      self.send(action_opts.path ||"#{action_opts.key}_#{controller_name}_path", url_opts)
+    end
+
+    ##
+    # Render "document actions" area for navigation header
+    # (normally renders "Saved Searches", "History", "Bookmarks")
+    #
+    # @param [Hash] options
+    # @return [String]
+    def render_nav_actions(options={}, &block)
+      render_filtered_partials(blacklight_config.navbar.partials, options, &block)
+    end
+
+    ##
+    # Render "document actions" area for search results view
+    # (normally renders next to title in the list view)
+    #
+    # @param [SolrDocument] document
+    # @param [Hash] options
+    # @option options [String] :wrapping_class
+    # @return [String]
+    def render_index_doc_actions(document, options={})
+      wrapping_class = options.delete(:wrapping_class) || "index-document-functions"
+      rendered = render_filtered_partials(blacklight_config.index.document_actions, { document: document }.merge(options))
+      content_tag("div", rendered, class: wrapping_class)
+    end
+
+    ##
+    # Render "collection actions" area for search results view
+    # (normally renders next to pagination at the top of the result set)
+    #
+    # @param [Hash] options
+    # @option options [String] :wrapping_class
+    # @return [String]
+    def render_results_collection_tools(options = {})
+      wrapping_class = options.delete(:wrapping_class) || "search-widgets"
+      rendered = render_filtered_partials(blacklight_config.index.collection_actions, options)
+      content_tag("div", rendered, class: wrapping_class)
+    end
+
+    def render_filtered_partials(partials, options={}, &block)
+      content = []
+      partials.select { |_, config| evaluate_if_unless_configuration config, options }.each do |key, config|
+        config.key ||= key
+        rendered = render(partial: config.partial || key.to_s, locals: { document_action_config: config }.merge(options))
+        if block_given?
+          yield config, rendered
+        else
+          content << rendered
+        end
+      end
+      safe_join(content, "\n") unless block_given?
+    end
+
+    ##
+    # Render "document actions" for the item detail 'show' view.
+    # (this normally renders next to title)
+    #
+    # By default includes 'Bookmarks'
+    #
+    # @param [SolrDocument] document
+    # @param [Hash] options
+    # @return [String]
+    def render_show_doc_actions(document=@document, options={}, &block)
+      render_filtered_partials(blacklight_config.show.document_actions, { document: document }.merge(options), &block)
+    end
+
+  end
+end

data/app/helpers/blacklight/configuration_helper_behavior.rb

@@ -58,36 +58,39 @@ module Blacklight::ConfigurationHelperBehavior
   ##
   # Look up the label for the index field
   def index_field_label document, field
-    label = index_fields(document)[field].label
+    field_config = index_fields(document)[field]
 
     solr_field_label(
-      label, 
       :"blacklight.search.fields.index.#{field}",
-      :"blacklight.search.fields.#{field}"
+      :"blacklight.search.fields.#{field}",
+      (field_config.label if field_config),
+      field.to_s.humanize
     )
   end
 
   ##
   # Look up the label for the show field
   def document_show_field_label document, field
-    label = document_show_fields(document)[field].label
-    
+    field_config = document_show_fields(document)[field]
+
     solr_field_label(
-      label, 
       :"blacklight.search.fields.show.#{field}",
-      :"blacklight.search.fields.#{field}"
+      :"blacklight.search.fields.#{field}",
+      (field_config.label if field_config),
+      field.to_s.humanize
     )
   end
 
   ##
   # Look up the label for the facet field
   def facet_field_label field
-    label = blacklight_config.facet_fields[field].label
+    field_config = blacklight_config.facet_fields[field]
 
     solr_field_label(
-      label, 
       :"blacklight.search.fields.facet.#{field}",
-      :"blacklight.search.fields.#{field}"
+      :"blacklight.search.fields.#{field}",
+      (field_config.label if field_config),
+      field.to_s.humanize
     )
   end
 
@@ -103,15 +106,9 @@ module Blacklight::ConfigurationHelperBehavior
   #     before falling  back to the label
   #   @param [Symbol] any number of additional keys
   #   @param [Symbol] ...
-  def solr_field_label label, *i18n_keys
-    if label.is_a? Symbol
-      return t(label)
-    end
-
+  def solr_field_label *i18n_keys
     first, *rest = i18n_keys
 
-    rest << label
-
     t(first, default: rest)
   end
   
@@ -167,15 +164,27 @@ module Blacklight::ConfigurationHelperBehavior
   ##
   # Determine whether to render a field by evaluating :if and :unless conditions
   #
-  # @param [SolrDocument] document
   # @param [Blacklight::Solr::Configuration::SolrField] solr_field
   # @return [Boolean]
   def should_render_field? field_config, *args
-    return field_config if field_config === true or field_config === false
+    evaluate_if_unless_configuration field_config, *args
+  end
+
+  ##
+  # Evaluate conditionals for a configuration with if/unless attributes
+  #
+  # @param displayable_config [#if,#unless] an object that responds to if/unless
+  # @return [Boolean]
+  def evaluate_if_unless_configuration displayable_config, *args
+    return displayable_config if displayable_config === true or displayable_config === false
     
-    if_value = !field_config.respond_to?(:if) || field_config.if.nil? || evaluate_configuration_conditional(field_config.if, field_config, *args)
+    if_value = !displayable_config.respond_to?(:if) ||
+                    displayable_config.if.nil? ||
+                    evaluate_configuration_conditional(displayable_config.if, displayable_config, *args)
     
-    unless_value = !field_config.respond_to?(:unless) ||  field_config.unless.nil? || !evaluate_configuration_conditional(field_config.unless, field_config, *args)
+    unless_value = !displayable_config.respond_to?(:unless) ||
+                      displayable_config.unless.nil? ||
+                      !evaluate_configuration_conditional(displayable_config.unless, displayable_config, *args)
 
     if_value && unless_value
   end

data/app/helpers/blacklight/render_partials_helper.rb

@@ -0,0 +1,185 @@
+module Blacklight::RenderPartialsHelper
+  ##
+  # Render the document index view
+  #
+  # @param [Array<SolrDocument>] list of documents to render
+  # @param [Hash] locals to pass to the render call
+  # @return [String]
+  def render_document_index documents = nil, locals = {}
+    documents ||= @document_list
+    render_document_index_with_view(document_index_view_type, documents, locals)
+  end
+
+  ##
+  # Render the document index for a grouped response
+  def render_grouped_document_index
+    render 'catalog/group_default'
+  end
+
+  ##
+  # Return the list of partials for a given solr document
+  # @param [SolrDocument]
+  # @return [String]
+  def render_document_partials(doc, partials = [], locals ={})
+    safe_join(partials.map do |action_name|
+      render_document_partial(doc, action_name, locals)
+    end, "\n")
+  end
+
+  ##
+  # Given a doc and a base name for a partial, this method will attempt to render
+  # an appropriate partial based on the document format and view type.
+  #
+  # If a partial that matches the document format is not found,
+  # render a default partial for the base name.
+  #
+  # @see #document_partial_path_templates
+  #
+  # @param [SolrDocument] doc
+  # @param [String] base name for the partial
+  # @param [Hash] locales to pass through to the partials
+  def render_document_partial(doc, base_name, locals = {})
+    format = if method(:document_partial_name).arity == 1
+      Deprecation.warn self, "The #document_partial_name with a single argument is deprecated. Update your override to include a second argument for the 'base name'"
+      document_partial_name(doc)
+    else
+      document_partial_name(doc, base_name)
+    end
+
+    view_type = document_index_view_type
+    template = cached_view ['show', view_type, base_name, format].join('_') do
+      find_document_show_template_with_view(view_type, base_name, format, locals)
+    end
+    if template
+      template.render(self, locals.merge(document: doc))
+    else
+      ''
+    end
+  end
+
+  ##
+  # Render the document index for the given view type with the
+  # list of documents.
+  #
+  # This method will interpolate the list of templates with
+  # the current view, and gracefully handles missing templates.
+  #
+  # @see #document_index_path_templates
+  #
+  # @param [String] view type
+  # @param [Array<SolrDocument>] list of documents to render
+  # @param [Hash] locals to pass to the render call
+  # @return [String]
+  def render_document_index_with_view view, documents, locals = {}
+    template = cached_view ['index', view].join('_') do
+      find_document_index_template_with_view(view, locals)
+    end
+
+    if template
+      template.render(self, locals.merge(documents: documents))
+    else
+      ''
+    end
+  end
+
+  ##
+  # A list of document partial templates to attempt to render
+  #
+  # @see #render_document_index_with_view
+  # @return [Array<String>]
+  def document_index_path_templates
+    # first, the legacy template names for backwards compatbility
+    # followed by the new, inheritable style
+    # finally, a controller-specific path for non-catalog subclasses
+    @document_index_path_templates ||= ["document_%{index_view_type}", "catalog/document_%{index_view_type}", "catalog/document_list"]
+  end
+
+
+  protected
+    ##
+    # Return a partial name for rendering a document
+    # this method can be overridden in order to transform the value
+    #   (e.g. 'PdfBook' => 'pdf_book')
+    #
+    # @param [SolrDocument] document
+    # @param [String, Array] display_type a value suggestive of a partial
+    # @return [String] the name of the partial to render
+    # @example
+    #  type_field_to_partial_name(['a book-article'])
+    #  => 'a_book_article'
+    def type_field_to_partial_name(document, display_type)
+      # using "_" as sep. to more closely follow the views file naming conventions
+      # parameterize uses "-" as the default sep. which throws errors
+      Array(display_type).join(" ").gsub("-","_").parameterize("_")
+    end
+
+    ##
+    # Return a normalized partial name for rendering a single document
+    #
+    # @param [SolrDocument]
+    # @param [Symbol] base name for the partial
+    # @return [String]
+    def document_partial_name(document, base_name = nil)
+      view_config = blacklight_config.view_config(:show)
+
+      display_type = if base_name and view_config.has_key? :"#{base_name}_display_type_field"
+        document[view_config[:"#{base_name}_display_type_field"]]
+      end
+
+      display_type ||= document[view_config.display_type_field]
+
+      display_type ||= 'default'
+
+      type_field_to_partial_name(document, display_type)
+    end
+
+    ##
+    # A list of document partial templates to try to render for a document
+    #
+    # The partial names will be interpolated with the following variables:
+    #   - action_name: (e.g. index, show)
+    #   - index_view_type: (the current view type, e.g. list, gallery)
+    #   - format: the document's format (e.g. book)
+    #
+    # @see #render_document_partial
+    def document_partial_path_templates
+      # first, the legacy template names for backwards compatbility
+      # followed by the new, inheritable style
+      # finally, a controller-specific path for non-catalog subclasses
+      @partial_path_templates ||= ["%{action_name}_%{index_view_type}_%{format}", "%{action_name}_%{index_view_type}_default", "%{action_name}_%{format}", "%{action_name}_default", "catalog/%{action_name}_%{format}", "catalog/_%{action_name}_partials/%{format}", "catalog/_%{action_name}_partials/default"]
+    end
+
+  private
+    def find_document_show_template_with_view view_type, base_name, format, locals
+      document_partial_path_templates.each do |str|
+        partial = str % { action_name: base_name, format: format, index_view_type: view_type }
+        logger.debug "Looking for document partial #{partial}"
+        template = lookup_context.find_all(partial, lookup_context.prefixes + [""], true, locals.keys + [:document], {}).first
+        return template if template
+      end
+      nil
+    end
+
+    def find_document_index_template_with_view view, locals
+      document_index_path_templates.each do |str|
+        partial = str % { index_view_type: view }
+        logger.debug "Looking for document index partial #{partial}"
+        template = lookup_context.find_all(partial, lookup_context.prefixes + [""], true, locals.keys + [:documents], {}).first
+        return template if template
+      end
+      nil
+    end
+
+    ##
+    # @param [Symbol] page the page type, either :index or :show
+    # @param [String] type the type of object
+    # @block the block to evaluate if the cache misses
+    def cached_view key
+      @view_cache ||= {}
+      if @view_cache.key?(key)
+        @view_cache[key]
+      else
+        @view_cache[key] = yield
+      end
+    end
+end

data/app/helpers/blacklight/url_helper_behavior.rb

@@ -19,13 +19,24 @@ module Blacklight::UrlHelperBehavior
     end
   end
 
+  # link_to_document(doc, 'VIEW', :counter => 3)
   # link_to_document(doc, :label=>'VIEW', :counter => 3)
   # Use the catalog_path RESTful route to create a link to the show page for a specific item.
   # catalog_path accepts a HashWithIndifferentAccess object. The solr query params are stored in the session,
   # so we only need the +counter+ param here. We also need to know if we are viewing to document as part of search results.
-  def link_to_document(doc, opts={:label=>nil, :counter => nil})
-    opts[:label] ||= document_show_link_field(doc)
-    label = render_document_index_label doc, opts
+  def link_to_document(doc, field_or_opts = nil, opts={:counter => nil})
+    if field_or_opts.kind_of? Hash
+      opts = field_or_opts
+      if opts[:label]
+        Deprecation.warn self, "The second argument to link_to_document should now be the label."
+        field = opts.delete(:label)
+      end
+    else
+      field = field_or_opts
+    end
+
+    field ||= document_show_link_field(doc)
+    label = presenter(doc).render_document_index_label field, opts
     link_to label, url_for_document(doc), document_link_params(doc, opts)
   end
 
@@ -287,6 +298,16 @@ module Blacklight::UrlHelperBehavior
     "http://www.refworks.com/express/expressimport.asp?vendor=#{CGI.escape(params[:vendor] || application_name)}&filter=#{CGI.escape(params[:filter] || "MARC Format")}&encoding=65001" + (("&url=#{CGI.escape(params[:url])}" if params[:url]) || "")
   end
 
+  def refworks_catalog_path opts = {}
+    if opts[:id]
+      refworks_export_url(url: polymorphic_url(url_for_document(opts[:id]), format: :refworks_marc_txt, only_path: false))
+    end
+  end
+
+  def endnote_catalog_path opts = {}
+    catalog_path(opts.merge(format: 'endnote'))
+  end
+
   if ::Rails.version < "4.0"
     def asset_url *args
       "#{request.protocol}#{request.host_with_port}#{asset_path(*args)}"