blacklight 6.24.0 → 7.0.0.rc1

data/app/assets/stylesheets/blacklight/_icons.scss

@@ -0,0 +1,29 @@
+.blacklight-icons {
+  display: inline-block;
+  height: $font-size-base;
+  vertical-align: text-top;
+  width: $font-size-base;
+}
+
+@each $color, $value in $theme-colors {
+  .btn-#{$color} {
+    .blacklight-icons g {
+      @include stroke-yiq(theme-color($color));
+    }
+  }
+
+  .btn-outline-#{$color} {
+    .blacklight-icons g {
+      stroke: $value;
+    }
+
+    &.hover,
+    &:hover,
+    &:active,
+    &.active {
+      .blacklight-icons g {
+        @include stroke-yiq(theme-color($color));
+      }
+    }
+  }
+}

data/app/assets/stylesheets/blacklight/_layout.scss

@@ -1,11 +1 @@
 /* Generic layout stuff */
-
-.navbar + .navbar {
-  margin-top: -$navbar-margin-bottom;
-}
-
-.navbar-inverse .navbar-toggle {
-  &:focus, &:hover {
-    border-color: $gray-light;
-  }
-}

data/app/assets/stylesheets/blacklight/_mixins.scss

@@ -0,0 +1,15 @@
+// Stroke contrast
+// Ripped off from https://github.com/twbs/bootstrap/commit/c31d52499811d5c68d122db806ce27a112b489bd
+@mixin stroke-yiq($color) {
+  $r: red($color);
+  $g: green($color);
+  $b: blue($color);
+
+  $yiq: (($r * 299) + ($g * 587) + ($b * 114)) / 1000;
+
+  @if ($yiq >= 150) {
+    stroke: #111;
+  } @else {
+    stroke: #fff;
+  }
+}

data/app/assets/stylesheets/blacklight/_modal.scss

@@ -1,29 +1,21 @@
-#ajax-modal {
+.modal-content {
+  @extend .clearfix;
 
-  .modal-content {
-    @extend .clearfix;
-  }
-
-  #email_form {
-    width: auto;
-  }
-
-  .facet_pagination.top {
+  .facet-pagination.top {
   	display: none;
   }
 
-  #sidebar {
+  .page-sidebar {
     display: none;
   }
 
-  button.close {
-	  display: block;
+  .blacklight-modal-close {
+    display: block;
   }
 }
 
-
-/* app/views/catalog/facet.html.erb may be rendered as a modal or a whole page.
-   When it's a whole page, don't show the close button. */
-button.ajax-modal-close.close {
+// app/views/catalog/facet.html.erb may be rendered as a modal or a whole page.
+// When it's a whole page, don't show the close button.
+.blacklight-modal-close {
 	display: none;
 }

data/app/assets/stylesheets/blacklight/_pagination.scss

@@ -1,21 +1,6 @@
-.page_links {
+.page-links {
   display: inline-block;
   border: 1px solid transparent;
-  padding: $padding-base-vertical $padding-base-horizontal;
+  padding: $input-btn-padding-y $input-btn-padding-x;
   padding-left: 0;
 }
-
-.pagination {
-  text-align: center ;
-}
-
-
-.pagination-xs {
-  li {
-    a,
-    span {
-      border: none;
-      padding: $padding-xs-vertical $padding-xs-horizontal;
-    }
-  }
-}

data/app/assets/stylesheets/blacklight/_search_history.scss

@@ -1,20 +1,12 @@
 /* Search History */
-.search_history
-{
-
-  .constraint 
-  {
+.search-history {
+  .constraint {
+    @extend .px-3;
     display: block;
-    text-indent: -$padding-large-horizontal;
-    padding-left: $padding-large-horizontal;
-
+    text-indent: -1 * map-get($spacers, 3);
   }
 
-  .filterName, .filterSeparator
-  {
+  .filter-name, .filter-separator {
     @extend .text-muted;
   }
 }
-
-
-

data/app/assets/stylesheets/blacklight/_search_results.scss

@@ -1,10 +1,10 @@
 // the search results on the index view of the catalog
-#documents {
+.documents-list {
   .document {
-    margin-top: $padding-base-vertical;
-    padding-top: $padding-base-vertical;
-    border-bottom:1px dotted $table-border-color;
     @extend .clearfix;
+    border-bottom: 1px dotted $table-border-color;
+    margin-top: $spacer;
+    padding-top: $spacer;
 
     .document-title-heading {
       @extend h5;
@@ -13,16 +13,17 @@
     // bookmarks checkbox on index, give it some
     // lower margin when it collapses
     .index-document-functions {
-      margin-bottom: ($line-height-computed / 2);
-      @media (min-width: $screen-sm-min) {
+      margin-bottom: ($line-height-base / 2);
+
+      @media (min-width: breakpoint-min(sm)) {
         margin-bottom: 0;
       }
     }
 
     .document-thumbnail {
       float: right;
-      padding-left: $line-height-computed;
-      margin-bottom: $line-height-computed;
+      margin-bottom: $line-height-base;
+      padding-left: $line-height-base;
     }
   }
 }

data/app/assets/stylesheets/blacklight/_twitter_typeahead.scss

@@ -1,6 +1,5 @@
 .twitter-typeahead {
-  float: left;
-  width: 100%;
+  flex-grow: 2;
   z-index: $zindex-typeahead;
 
   input.tt-input.form-control {

data/app/builders/blacklight/action_builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Blacklight
+  # Dynamically creates methods on the given controller (typically CatalogController)
+  # for handling configured show tools
+  class ActionBuilder
+    def initialize(klass, name, opts)
+      @klass = klass
+      @name = name
+      @opts = opts
+    end
+
+    attr_reader :klass, :name, :opts
+
+    # Define a simple action handler for the tool as long as the method
+    # doesn't already exist or the `:define_method` option is not `false`
+    def build
+      return if skip?
+      callback = opts.fetch(:callback, nil).inspect
+      validator = opts.fetch(:validator, nil).inspect
+      klass.class_eval <<EORUBY, __FILE__, __LINE__ + 1
+          def #{name}
+            @response, @documents = action_documents
+
+            if request.post? && #{callback} &&
+               (#{validator}.blank? || send(#{validator}))
+
+              send(#{callback}, @documents)
+
+              flash[:success] ||= I18n.t("blacklight.#{name}.success", default: nil)
+
+              respond_to do |format|
+                format.html do
+                  return render "#{name}_success" if request.xhr?
+                  redirect_to action_success_redirect_path
+                end
+              end
+            else
+              respond_to do |format|
+                format.html do
+                  return render layout: false if request.xhr?
+                  # Otherwise draw the full page
+                end
+              end
+            end
+          end
+EORUBY
+    end
+
+    private
+
+    def skip?
+      klass.method_defined?(name) || opts[:define_method] == false
+    end
+  end
+end

data/app/controllers/bookmarks_controller.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
-class BookmarksController < CatalogController  
+class BookmarksController < CatalogController
   include Blacklight::Bookmarks
-end 
+end

data/app/controllers/catalog_controller.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
-class CatalogController < ApplicationController  
+class CatalogController < ApplicationController
   include Blacklight::Catalog
-end 
+end

data/app/controllers/concerns/blacklight/base.rb

@@ -3,38 +3,5 @@ module Blacklight::Base
   extend ActiveSupport::Concern
 
   include Blacklight::Configurable
-  include Blacklight::SearchHelper
-
   include Blacklight::SearchContext
-
-  included do
-    # When Blacklight::Exceptions::InvalidRequest is raised, the rsolr_request_error method is executed.
-    # The index action will more than likely throw this one.
-    # Example, when the standard query parser is used, and a user submits a "bad" query.
-    rescue_from Blacklight::Exceptions::InvalidRequest, with: :handle_request_error if respond_to? :rescue_from
-  end
-
-  protected
-
-  # when The index throws an error (Blacklight::Exceptions::InvalidRequest), this method is executed.
-  def handle_request_error(exception)
-    if Rails.env.development? || Rails.env.test?
-      raise exception # Rails own code will catch and give usual Rails error page with stack trace
-    else
-
-      flash_notice = I18n.t('blacklight.search.errors.request_error')
-
-      # If there are errors coming from the index page, we want to trap those sensibly
-
-      if flash[:notice] == flash_notice
-        logger.error "Cowardly aborting rsolr_request_error exception handling, because we redirected to a page that raises another exception"
-        raise exception
-      end
-
-      logger.error exception
-
-      flash[:notice] = flash_notice 
-      redirect_to root_path
-    end
-  end
 end

data/app/controllers/concerns/blacklight/bookmarks.rb

@@ -8,7 +8,6 @@ module Blacklight::Bookmarks
     ##
     # Give Bookmarks access to the CatalogController configuration
     include Blacklight::Configurable
-    include Blacklight::SearchHelper
     include Blacklight::TokenBasedUser
 
     copy_blacklight_config_from(CatalogController)
@@ -25,7 +24,7 @@ module Blacklight::Bookmarks
   def action_documents
     bookmarks = token_or_current_or_guest_user.bookmarks
     bookmark_ids = bookmarks.collect { |b| b.document_id.to_s }
-    fetch(bookmark_ids)
+    search_service.fetch(bookmark_ids)
   end
 
   def action_success_redirect_path
@@ -41,13 +40,13 @@ module Blacklight::Bookmarks
   def index
     @bookmarks = token_or_current_or_guest_user.bookmarks
     bookmark_ids = @bookmarks.collect { |b| b.document_id.to_s }
-
-    @response, @document_list = fetch(bookmark_ids)
+    @response, deprecated_document_list = search_service.fetch(bookmark_ids)
+    @document_list = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(deprecated_document_list, "The @document_list instance variable is now deprecated and will be removed in Blacklight 8.0")
 
     respond_to do |format|
-      format.html { }
-      format.rss  { render :layout => false }
-      format.atom { render :layout => false }
+      format.html {}
+      format.rss  { render layout: false }
+      format.atom { render layout: false }
       format.json do
         render json: render_search_results_as_json
       end
@@ -71,7 +70,7 @@ module Blacklight::Bookmarks
   # is simpler.
   def create
     @bookmarks = if params[:bookmarks]
-                   permit_bookmarks[:bookmarks]
+                   params[:bookmarks]
                  else
                    [{ document_id: params[:id], document_type: blacklight_config.document_model.to_s }]
                  end
@@ -79,16 +78,16 @@ module Blacklight::Bookmarks
     current_or_guest_user.save! unless current_or_guest_user.persisted?
 
     success = @bookmarks.all? do |bookmark|
-       current_or_guest_user.bookmarks.where(bookmark).exists? || current_or_guest_user.bookmarks.create(bookmark)
+      current_or_guest_user.bookmarks.where(bookmark).exists? || current_or_guest_user.bookmarks.create(bookmark)
     end
 
     if request.xhr?
-      success ? render(json: { bookmarks: { count: current_or_guest_user.bookmarks.count }}) : render(plain: "", status: "500")
+      success ? render(json: { bookmarks: { count: current_or_guest_user.bookmarks.count } }) : render(plain: "", status: "500")
     else
       if @bookmarks.any? && success
-        flash[:notice] = I18n.t('blacklight.bookmarks.add.success', :count => @bookmarks.length)
+        flash[:notice] = I18n.t('blacklight.bookmarks.add.success', count: @bookmarks.length)
       elsif @bookmarks.any?
-        flash[:error] = I18n.t('blacklight.bookmarks.add.failure', :count => @bookmarks.length)
+        flash[:error] = I18n.t('blacklight.bookmarks.add.failure', count: @bookmarks.length)
       end
 
       if respond_to? :redirect_back
@@ -103,21 +102,11 @@ module Blacklight::Bookmarks
   # Beware, :id is the Solr document_id, not the actual Bookmark id.
   # idempotent, as DELETE is supposed to be.
   def destroy
-    @bookmarks =
-      if params[:bookmarks]
-        permit_bookmarks[:bookmarks]
-      else
-        [{ document_id: params[:id], document_type: blacklight_config.document_model.to_s }]
-      end
-
-    success = @bookmarks.all? do |bookmark|
-      bookmark = current_or_guest_user.bookmarks.find_by(bookmark)
-      bookmark && bookmark.delete && bookmark.destroyed?
-    end
+    bookmark = current_or_guest_user.bookmarks.find_by(document_id: params[:id], document_type: blacklight_config.document_model.to_s)
 
-    if success
+    if bookmark && bookmark.delete && bookmark.destroyed?
       if request.xhr?
-        render(json: { bookmarks: { count: current_or_guest_user.bookmarks.count }})
+        render(json: { bookmarks: { count: current_or_guest_user.bookmarks.count } })
       elsif respond_to? :redirect_back
         redirect_back fallback_location: bookmarks_path, notice: I18n.t('blacklight.bookmarks.remove.success')
       else
@@ -126,11 +115,8 @@ module Blacklight::Bookmarks
       end
     elsif request.xhr?
       head 500 # ajaxy request needs no redirect and should not have flash set
-    elsif respond_to? :redirect_back
-      redirect_back fallback_location: bookmarks_path, flash: { error: I18n.t('blacklight.bookmarks.remove.failure') }
     else
-      # Deprecated in Rails 5.0
-      redirect_to :back, flash: { error: I18n.t('blacklight.bookmarks.remove.failure') }
+      redirect_back fallback_location: bookmarks_path, flash: { error: I18n.t('blacklight.bookmarks.remove.failure') }
     end
   end
 
@@ -140,22 +126,19 @@ module Blacklight::Bookmarks
     else
       flash[:error] = I18n.t('blacklight.bookmarks.clear.failure')
     end
-    redirect_to :action => "index"
+    redirect_to action: "index"
   end
 
-  protected
+  private
 
   def verify_user
-    unless current_or_guest_user or (action == "index" and token_or_current_or_guest_user)
-      flash[:notice] = I18n.t('blacklight.bookmarks.need_login') and raise Blacklight::Exceptions::AccessDenied
+    unless current_or_guest_user || (action == "index" && token_or_current_or_guest_user)
+      flash[:notice] = I18n.t('blacklight.bookmarks.need_login')
+      raise Blacklight::Exceptions::AccessDenied
     end
   end
 
   def start_new_search_session?
     action_name == "index"
   end
-
-  def permit_bookmarks
-    params.permit(bookmarks: [:document_id, :document_type])
-  end
 end

data/app/controllers/concerns/blacklight/catalog.rb

@@ -3,270 +3,311 @@ module Blacklight::Catalog
   extend ActiveSupport::Concern
 
   include Blacklight::Base
-  include Blacklight::DefaultComponentConfiguration
   include Blacklight::Facet
 
   # The following code is executed when someone includes blacklight::catalog in their
   # own controller.
   included do
-    if respond_to? :helper_method
-      helper_method :sms_mappings, :has_search_parameters?
-    end
+    helper_method :sms_mappings, :has_search_parameters?, :facet_limit_for
 
-    helper Blacklight::Facet if respond_to? :helper
+    helper Blacklight::Facet
 
-    # When an action raises Blacklight::Exceptions::RecordNotFound, handle
-    # the exception appropriately.
-    rescue_from Blacklight::Exceptions::RecordNotFound, with: :invalid_document_id_error
+    # The index action will more than likely throw this one.
+    # Example: when the standard query parser is used, and a user submits a "bad" query.
+    rescue_from Blacklight::Exceptions::InvalidRequest, with: :handle_request_error
 
     record_search_parameters
   end
 
-    # get search results from the solr index
-    def index
-      (@response, @document_list) = search_results(params)
-
-      respond_to do |format|
-        format.html { store_preferred_view }
-        format.rss  { render :layout => false }
-        format.atom { render :layout => false }
-        format.json do
-          @presenter = Blacklight::JsonPresenter.new(@response,
-                                                     @document_list,
-                                                     facets_from_request,
-                                                     blacklight_config)
-        end
-        additional_response_formats(format)
-        document_export_formats(format)
-      end
-    end
+  # get search results from the solr index
+  def index
+    (@response, deprecated_document_list) = search_service.search_results
+
+    @document_list = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(deprecated_document_list, 'The @document_list instance variable is deprecated; use @response.documents instead.')
 
-    # get a single document from the index
-    # to add responses for formats other than html or json see _Blacklight::Document::Export_
-    def show
-      @response, @document = fetch params[:id]
-      respond_to do |format|
-        format.html { setup_next_and_previous_documents }
-        format.json { render json: { response: { document: @document } } }
-        additional_export_formats(@document, format)
+    respond_to do |format|
+      format.html { store_preferred_view }
+      format.rss  { render layout: false }
+      format.atom { render layout: false }
+      format.json do
+        @presenter = Blacklight::JsonPresenter.new(@response,
+                                                   facets_from_request,
+                                                   blacklight_config)
       end
+      additional_response_formats(format)
+      document_export_formats(format)
     end
+  end
 
-    # updates the search counter (allows the show view to paginate)
-    def track
-      search_session['counter'] = params[:counter]
-      search_session['id'] = params[:search_id]
-      search_session['per_page'] = params[:per_page]
+  # get a single document from the index
+  # to add responses for formats other than html or json see _Blacklight::Document::Export_
+  def show
+    deprecated_response, @document = search_service.fetch(params[:id])
+    @response = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(deprecated_response, 'The @response instance variable is deprecated; use @document.response instead.')
 
-      if params[:redirect] and (params[:redirect].starts_with?('/') or params[:redirect] =~ URI::DEFAULT_PARSER.make_regexp)
-        uri = URI.parse(params[:redirect])
-        path = uri.query ? "#{uri.path}?#{uri.query}" : uri.path
-        redirect_to path, status: 303
-      else
-        redirect_to blacklight_config.document_model.new(id: params[:id]), status: 303
-      end
+    respond_to do |format|
+      format.html { @search_context = setup_next_and_previous_documents }
+      format.json { render json: { response: { document: @document } } }
+      additional_export_formats(@document, format)
     end
+  end
 
-    # displays values and pagination links for a single facet field
-    def facet
-      @facet = blacklight_config.facet_fields[params[:id]]
-      raise ActionController::RoutingError, 'Not Found' unless @facet
-      @response = get_facet_field_response(@facet.key, params)
-      @display_facet = @response.aggregations[@facet.field]
-      @pagination = facet_paginator(@facet, @display_facet)
-      respond_to do |format|
-        format.html do
-          # Draw the partial for the "more" facet modal window:
-          return render layout: false if request.xhr?
-          # Otherwise draw the facet selector for users who have javascript disabled.
-        end
-        format.json
-      end
+  # updates the search counter (allows the show view to paginate)
+  def track
+    search_session['counter'] = params[:counter]
+    search_session['id'] = params[:search_id]
+    search_session['per_page'] = params[:per_page]
+
+    if params[:redirect] && (params[:redirect].starts_with?('/') || params[:redirect] =~ URI::DEFAULT_PARSER.make_regexp)
+      uri = URI.parse(params[:redirect])
+      path = uri.query ? "#{uri.path}?#{uri.query}" : uri.path
+      redirect_to path, status: 303
+    else
+      redirect_to blacklight_config.document_model.new(id: params[:id]), status: 303
     end
+  end
 
-    # method to serve up XML OpenSearch description and JSON autocomplete response
-    def opensearch
-      respond_to do |format|
-        format.xml { render layout: false }
-        format.json { render json: get_opensearch_response }
+  # displays values and pagination links for a single facet field
+  def facet
+    @facet = blacklight_config.facet_fields[params[:id]]
+    raise ActionController::RoutingError, 'Not Found' unless @facet
+    @response = search_service.facet_field_response(@facet.key)
+    @display_facet = @response.aggregations[@facet.field]
+    @pagination = facet_paginator(@facet, @display_facet)
+    respond_to do |format|
+      format.html do
+        # Draw the partial for the "more" facet modal window:
+        return render layout: false if request.xhr?
+        # Otherwise draw the facet selector for users who have javascript disabled.
       end
+      format.json
     end
+  end
 
-    def action_documents
-      fetch(Array(params[:id]))
-    end
-
-    def action_success_redirect_path
-      search_state.url_for_document(blacklight_config.document_model.new(id: params[:id]))
+  # method to serve up XML OpenSearch description and JSON autocomplete response
+  def opensearch
+    respond_to do |format|
+      format.xml { render layout: false }
+      format.json { render json: search_service.opensearch_response }
     end
+  end
 
-    ##
-    # Check if any search parameters have been set
-    # @return [Boolean]
-    def has_search_parameters?
-      !params[:q].blank? or !params[:f].blank? or !params[:search_field].blank?
+  def suggest
+    respond_to do |format|
+      format.json do
+        render json: suggestions_service.suggestions
+      end
     end
+  end
 
-    protected
+  def action_documents
+    search_service.fetch(Array(params[:id]))
+  end
 
-    #
-    # non-routable methods ->
-    #
+  def action_success_redirect_path
+    search_state.url_for_document(blacklight_config.document_model.new(id: params[:id]))
+  end
 
-    ##
-    # If the params specify a view, then store it in the session. If the params
-    # do not specifiy the view, set the view parameter to the value stored in the
-    # session. This enables a user with a session to do subsequent searches and have
-    # them default to the last used view.
-    def store_preferred_view
-      session[:preferred_view] = params[:view] if params[:view]
-    end
+  ##
+  # Check if any search parameters have been set
+  # @return [Boolean]
+  def has_search_parameters?
+    !params[:q].blank? || !params[:f].blank? || !params[:search_field].blank?
+  end
 
-    ##
-    # Render additional response formats for the index action, as provided by the
-    # blacklight configuration
-    # @param [Hash] format
-    # @note Make sure your format has a well known mime-type or is registered in config/initializers/mime_types.rb
-    # @example
-    #   config.index.respond_to.txt = Proc.new { render plain: "A list of docs." }
-    def additional_response_formats format
-      blacklight_config.index.respond_to.each do |key, config|
-        format.send key do
-          case config
-          when false
-            raise ActionController::RoutingError, 'Not Found'
-          when Hash
-            render config
-          when Proc
-            instance_exec(&config)
-          when Symbol, String
-            send config
-          else
-            render({})
-          end
-        end
+  DEFAULT_FACET_LIMIT = 10
+
+  # Look up facet limit for given facet_field. Will look at config, and
+  # if config is 'true' will look up from Solr @response if available. If
+  # no limit is available, returns nil. Used from #add_facetting_to_solr
+  # to supply f.fieldname.facet.limit values in solr request (no @response
+  # available), and used in display (with @response available) to create
+  # a facet paginator with the right limit.
+  def facet_limit_for(facet_field)
+    facet = blacklight_config.facet_fields[facet_field]
+    return if facet.blank?
+
+    if facet.limit && @response && @response.aggregations[facet.field]
+      limit = @response.aggregations[facet.field].limit
+
+      if limit.nil? # we didn't get or a set a limit, so infer one.
+        facet.limit if facet.limit != true
+      elsif limit == -1 # limit -1 is solr-speak for unlimited
+        nil
+      else
+        limit.to_i - 1 # we added 1 to find out if we needed to paginate
       end
+    elsif facet.limit
+      facet.limit == true ? DEFAULT_FACET_LIMIT : facet.limit
     end
+  end
 
-    ##
-    # Render additional export formats for the show action, as provided by
-    # the document extension framework. See _Blacklight::Document::Export_
-    def additional_export_formats(document, format)
-      document.export_formats.each_key do | format_name |
-        format.send(format_name.to_sym) { render body: document.export_as(format_name), layout: false }
-      end
-    end
+  private
+
+  #
+  # non-routable methods ->
+  #
+
+  def render_sms_action?(_config, _options)
+    sms_mappings.present?
+  end
+
+  def search_service
+    search_service_class.new(blacklight_config, search_state.to_h)
+  end
+
+  ##
+  # If the params specify a view, then store it in the session. If the params
+  # do not specifiy the view, set the view parameter to the value stored in the
+  # session. This enables a user with a session to do subsequent searches and have
+  # them default to the last used view.
+  def store_preferred_view
+    session[:preferred_view] = params[:view] if params[:view]
+  end
 
-    ##
-    # Try to render a response from the document export formats available
-    def document_export_formats format
-      format.any do
-        format_name = params.fetch(:format, '').to_sym
-        if @response.export_formats.include? format_name
-          render_document_export_format format_name
+  ##
+  # Render additional response formats for the index action, as provided by the
+  # blacklight configuration
+  # @param [Hash] format
+  # @note Make sure your format has a well known mime-type or is registered in config/initializers/mime_types.rb
+  # @example
+  #   config.index.respond_to.txt = Proc.new { render plain: "A list of docs." }
+  def additional_response_formats format
+    blacklight_config.index.respond_to.each do |key, config|
+      format.send key do
+        case config
+        when false
+          raise ActionController::RoutingError, 'Not Found'
+        when Hash
+          render config
+        when Proc
+          instance_exec(&config)
+        when Symbol, String
+          send config
         else
-          raise ActionController::UnknownFormat
+          render({})
         end
       end
     end
+  end
 
-    ##
-    # Render the document export formats for a response
-    # First, try to render an appropriate template (e.g. index.endnote.erb)
-    # If that fails, just concatenate the document export responses with a newline.
-    def render_document_export_format format_name
-      render
-    rescue ActionView::MissingTemplate
-      render plain: @response.documents.map { |x| x.export_as(format_name) if x.exports_as? format_name }.compact.join("\n"), layout: false
+  ##
+  # Render additional export formats for the show action, as provided by
+  # the document extension framework. See _Blacklight::Document::Export_
+  def additional_export_formats(document, format)
+    document.export_formats.each_key do |format_name|
+      format.send(format_name.to_sym) { render body: document.export_as(format_name), layout: false }
     end
+  end
 
-    # Overrides the Blacklight::Controller provided #search_action_url.
-    # By default, any search action from a Blacklight::Catalog controller
-    # should use the current controller when constructing the route.
-    def search_action_url options = {}
-      url_for(options.reverse_merge(action: 'index'))
+  ##
+  # Try to render a response from the document export formats available
+  def document_export_formats format
+    format.any do
+      format_name = params.fetch(:format, '').to_sym
+      if @response.export_formats.include? format_name
+        render_document_export_format format_name
+      else
+        raise ActionController::UnknownFormat
+      end
     end
+  end
 
-     # Email Action (this will render the appropriate view on GET requests and process the form and send the email on POST requests)
-     def email_action documents
-       mail = RecordMailer.email_record(documents, {:to => params[:to], :message => params[:message]}, url_options)
-       if mail.respond_to? :deliver_now
-         mail.deliver_now
-       else
-         mail.deliver
-       end
-     end
-
-     # SMS action (this will render the appropriate view on GET requests and process the form and send the email on POST requests)
-     def sms_action documents
-       to = "#{params[:to].gsub(/[^\d]/, '')}@#{params[:carrier]}"
-       mail = RecordMailer.sms_record(documents, { :to => to }, url_options)
-       if mail.respond_to? :deliver_now
-         mail.deliver_now
-       else
-         mail.deliver
-       end
-     end
-
-    def validate_sms_params
-      if params[:to].blank?
-        flash[:error] = I18n.t('blacklight.sms.errors.to.blank')
-      elsif params[:carrier].blank?
-        flash[:error] = I18n.t('blacklight.sms.errors.carrier.blank')
-      elsif params[:to].gsub(/[^\d]/, '').length != 10
-        flash[:error] = I18n.t('blacklight.sms.errors.to.invalid', :to => params[:to])
-      elsif !sms_mappings.values.include?(params[:carrier])
-        flash[:error] = I18n.t('blacklight.sms.errors.carrier.invalid')
-      end
+  ##
+  # Render the document export formats for a response
+  # First, try to render an appropriate template (e.g. index.endnote.erb)
+  # If that fails, just concatenate the document export responses with a newline.
+  def render_document_export_format format_name
+    render
+  rescue ActionView::MissingTemplate
+    render plain: @response.documents.map { |x| x.export_as(format_name) if x.exports_as? format_name }.compact.join("\n"), layout: false
+  end
 
-      flash[:error].blank?
-    end
+  # Overrides the Blacklight::Controller provided #search_action_url.
+  # By default, any search action from a Blacklight::Catalog controller
+  # should use the current controller when constructing the route.
+  def search_action_url options = {}
+    url_for(options.reverse_merge(action: 'index'))
+  end
 
-    def sms_mappings
-      Blacklight::Engine.config.sms_mappings
+  # Email Action (this will render the appropriate view on GET requests and process the form and send the email on POST requests)
+  def email_action documents
+    mail = RecordMailer.email_record(documents, { to: params[:to], message: params[:message] }, url_options)
+    if mail.respond_to? :deliver_now
+      mail.deliver_now
+    else
+      mail.deliver
     end
+  end
 
-    def validate_email_params
-      if params[:to].blank?
-        flash[:error] = I18n.t('blacklight.email.errors.to.blank')
-      elsif !params[:to].match(Blacklight::Engine.config.email_regexp)
-        flash[:error] = I18n.t('blacklight.email.errors.to.invalid', :to => params[:to])
-      end
+  # SMS action (this will render the appropriate view on GET requests and process the form and send the email on POST requests)
+  def sms_action documents
+    to = "#{params[:to].gsub(/[^\d]/, '')}@#{params[:carrier]}"
+    mail = RecordMailer.sms_record(documents, { to: to }, url_options)
+    if mail.respond_to? :deliver_now
+      mail.deliver_now
+    else
+      mail.deliver
+    end
+  end
 
-      flash[:error].blank?
+  def validate_sms_params
+    if params[:to].blank?
+      flash[:error] = I18n.t('blacklight.sms.errors.to.blank')
+    elsif params[:carrier].blank?
+      flash[:error] = I18n.t('blacklight.sms.errors.carrier.blank')
+    elsif params[:to].gsub(/[^\d]/, '').length != 10
+      flash[:error] = I18n.t('blacklight.sms.errors.to.invalid', to: params[:to])
+    elsif !sms_mappings.values.include?(params[:carrier])
+      flash[:error] = I18n.t('blacklight.sms.errors.carrier.invalid')
     end
 
-    ##
-    # when a request for /catalog/BAD_SOLR_ID is made, this method is executed.
-    # Just returns a 404 response, but you can override locally in your own
-    # CatalogController to do something else -- older BL displayed a Catalog#inde
-    # page with a flash message and a 404 status.
-    def invalid_document_id_error(exception)
-      raise exception unless Pathname.new("#{Rails.root}/public/404.html").exist?
-
-      error_info = {
-        "status" => "404",
-        "error"  => "#{exception.class}: #{exception.message}"
-      }
-
-      respond_to do |format|
-        format.xml  { render :xml  => error_info, :status => 404 }
-        format.json { render :json => error_info, :status => 404 }
-
-        # default to HTML response, even for other non-HTML formats we don't
-        # neccesarily know about, seems to be consistent with what Rails4 does
-        # by default with uncaught ActiveRecord::RecordNotFound in production
-        format.any do
-          # use standard, possibly locally overridden, 404.html file. Even for
-          # possibly non-html formats, this is consistent with what Rails does
-          # on raising an ActiveRecord::RecordNotFound. Rails.root IS needed
-          # for it to work under testing, without worrying about CWD.
-          render :file => "#{Rails.root}/public/404.html", :status => 404, :layout => false, :content_type => 'text/html'
-        end
-      end
+    flash[:error].blank?
+  end
+
+  def sms_mappings
+    Blacklight::Engine.config.sms_mappings
+  end
+
+  def validate_email_params
+    if params[:to].blank?
+      flash[:error] = I18n.t('blacklight.email.errors.to.blank')
+    elsif !params[:to].match(Blacklight::Engine.config.email_regexp)
+      flash[:error] = I18n.t('blacklight.email.errors.to.invalid', to: params[:to])
     end
 
-    def start_new_search_session?
-      action_name == "index"
+    flash[:error].blank?
+  end
+
+  def start_new_search_session?
+    action_name == "index"
+  end
+
+  def suggestions_service
+    Blacklight::SuggestSearch.new(params, search_service.repository).suggestions
+  end
+
+  def determine_layout
+    action_name == 'show' ? 'catalog_result' : super
+  end
+
+  # when a method throws a Blacklight::Exceptions::InvalidRequest, this method is executed.
+  def handle_request_error(exception)
+    # Rails own code will catch and give usual Rails error page with stack trace
+    raise exception if Rails.env.development? || Rails.env.test?
+
+    flash_notice = I18n.t('blacklight.search.errors.request_error')
+
+    # If there are errors coming from the index page, we want to trap those sensibly
+
+    if flash[:notice] == flash_notice
+      logger.error "Cowardly aborting rsolr_request_error exception handling, because we redirected to a page that raises another exception"
+      raise exception
     end
+
+    logger.error exception
+
+    flash[:notice] = flash_notice
+    redirect_to search_action_url
+  end
 end