blacklight 9.0.0 → 9.1.0

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

@@ -5,6 +5,8 @@
 module Blacklight::Controller
   extend ActiveSupport::Concern
 
+  include Blacklight::GuestUser
+
   included do
     include ActiveSupport::Callbacks
 
@@ -17,6 +19,7 @@ module Blacklight::Controller
 
     if respond_to? :helper_method
       helper_method :current_user_session, :current_user, :current_or_guest_user
+      helper_method :blacklight_account_path, :blacklight_login_path, :blacklight_login_url, :blacklight_logout_link_options, :blacklight_logout_path
 
       # extra head content
       helper_method :has_user_authentication_provider?
@@ -28,8 +31,7 @@ module Blacklight::Controller
     # Which class to use for the search state. You can subclass SearchState if you
     # want to override any of the methods (e.g. SearchState#url_for_document)
     # TODO: move to Searchable
-    class_attribute :search_state_class
-    self.search_state_class = Blacklight::SearchState
+    class_attribute :search_state_class, default: Blacklight::SearchState
   end
 
   # @private
@@ -56,7 +58,7 @@ module Blacklight::Controller
   end
 
   # This must be on every controller that uses the layout, because it is used in
-  # the header to draw Blacklight::SearchNavbarComponent (via the shared/header_navbar template)
+  # the header to draw Blacklight::SearchNavbarComponent
   # @return [Blacklight::SearchState] a memoized instance of the parameter state.
   def search_state
     @search_state ||= search_state_class.new(params, blacklight_config, self)
@@ -71,8 +73,8 @@ module Blacklight::Controller
   end
 
   def search_action_path *args
-    if args.first.is_a? Hash
-      args.first[:only_path] = true if args.first[:only_path].nil?
+    if args.first.is_a?(Hash) && args.first[:only_path].nil?
+      args.first[:only_path] = true
     end
 
     search_action_url(*args)
@@ -86,10 +88,10 @@ module Blacklight::Controller
 
   # Here's a stub implementation we'll add if it isn't provided for us
   def current_or_guest_user
-    if defined? super
-      super
+    if defined?(super) && (user = super)
+      user
     elsif has_user_authentication_provider?
-      current_user
+      current_user || guest_user
     end
   end
   alias blacklight_current_or_guest_user current_or_guest_user
@@ -98,13 +100,13 @@ module Blacklight::Controller
   #
   #
   def has_user_authentication_provider?
-    respond_to? :current_user
+    respond_to?(:current_user) || blacklight_login_path.present? || blacklight_logout_path.present?
   end
 
   ##
   # When a user logs in, transfer any saved searches or bookmarks to the current_user
   def transfer_guest_to_user
-    return unless respond_to?(:current_user) && respond_to?(:guest_user) && current_user && guest_user
+    return unless respond_to?(:current_user) && current_user && guest_user
 
     current_user_searches = current_user.searches.pluck(:query_params)
     current_user_bookmarks = current_user.bookmarks.pluck(:document_id)
@@ -134,10 +136,51 @@ module Blacklight::Controller
 
     redirect_to(root_url) && return unless has_user_authentication_provider?
 
-    redirect_to new_user_session_url(referer: request.fullpath)
+    store_location_for_rails_authentication
+    redirect_to(root_url) && return unless blacklight_login_url
+
+    redirect_to blacklight_login_url(referer: request.fullpath)
   end
 
   def determine_layout
     'blacklight'
   end
+
+  def blacklight_login_path(options = {})
+    if respond_to?(:new_user_session_path)
+      new_user_session_path(options)
+    elsif respond_to?(:new_session_path)
+      new_session_path(options)
+    end
+  end
+
+  def blacklight_login_url(options = {})
+    if respond_to?(:new_user_session_url)
+      new_user_session_url(options)
+    elsif respond_to?(:new_session_url)
+      new_session_url(options)
+    end
+  end
+
+  def blacklight_logout_path
+    if respond_to?(:destroy_user_session_path)
+      destroy_user_session_path
+    elsif respond_to?(:session_path)
+      session_path
+    end
+  end
+
+  def blacklight_logout_link_options
+    return {} unless respond_to?(:session_path)
+
+    { data: { turbo_method: :delete } }
+  end
+
+  def blacklight_account_path
+    edit_user_registration_path if respond_to?(:edit_user_registration_path)
+  end
+
+  def store_location_for_rails_authentication
+    session[:return_to_after_authenticating] = request.url if respond_to?(:new_session_url)
+  end
 end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Blacklight
+  # Provides a persisted "guest" user for anonymous visitors so they can
+  # accumulate bookmarks and searches that are transferred to a real account
+  # upon sign-in (see Blacklight::Controller#transfer_guest_to_user).
+  #
+  # This is the fallback used by Rails' built-in authentication. When Devise
+  # together with the +devise-guests+ gem is used, that pair provides its own
+  # +#guest_user+ / +#current_or_guest_user+ (and knows how to build a valid
+  # Devise guest, e.g. skipping password validation). They sit higher in the
+  # ancestor chain than this concern, so +#guest_user+ defers to +super+ when
+  # available and only falls back to the implementation below otherwise. The
+  # helper methods below are intentionally named to avoid colliding with
+  # +devise-guests+' own +#create_guest_user+.
+  module GuestUser
+    extend ActiveSupport::Concern
+
+    # Returns a persisted guest user for the current session, creating one on
+    # first access. Keyed off the session so it survives across requests.
+    # Returns +nil+ if a guest cannot be created (e.g. no user model).
+    def guest_user
+      return super if defined?(super)
+      return @blacklight_guest_user if defined?(@blacklight_guest_user) && @blacklight_guest_user
+
+      @blacklight_guest_user = find_blacklight_guest_user || create_blacklight_guest_user
+    end
+
+    private
+
+    def find_blacklight_guest_user
+      return unless (id = session[:blacklight_guest_user_id])
+
+      blacklight_guest_user_class.find_by(id: id)
+    end
+
+    def create_blacklight_guest_user
+      user = blacklight_guest_user_class.create_guest_user!
+      session[:blacklight_guest_user_id] = user.id
+      user
+    rescue ActiveRecord::RecordInvalid
+      nil
+    end
+
+    # The model class that guest users are created from. Defaults to +User+,
+    # consistent with Blacklight::TokenBasedUser. Override to use another model.
+    def blacklight_guest_user_class
+      ::User
+    end
+  end
+end

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

@@ -25,7 +25,7 @@ module Blacklight::SearchContext
 
   # Returns a list of Searches from the ids in the user's history.
   def searches_from_history
-    session[:history].blank? ? ::Search.none : ::Search.where(id: session[:history]).order("updated_at desc")
+    session[:history].blank? ? ::Search.none : ::Search.where(id: session[:history]).order(updated_at: :desc)
   end
 
   # GET previous and next document json for the document specified by

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

@@ -7,6 +7,8 @@ module Blacklight
     include Blacklight::SearchContext
 
     included do
+      allow_unauthenticated_access raise: false if respond_to?(:allow_unauthenticated_access)
+
       copy_blacklight_config_from(CatalogController)
     end
 
@@ -23,7 +25,7 @@ module Blacklight
         flash[:error] = I18n.t('blacklight.search_history.clear.failure')
       end
 
-      redirect_back fallback_location: blacklight.search_history_path
+      redirect_back_or_to(blacklight.search_history_path)
     end
   end
 end

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

@@ -24,6 +24,24 @@ module Blacklight::Searchable
     search_service_class.new(config: blacklight_config, search_state: search_state, **search_service_context)
   end
 
+  # This method may be overridden to customize search behavior.
+  # @return [Blacklight::Solr::Response] the solr response object
+  def retrieve_search_results
+    search_service.search_results
+  end
+
+  # This method may be overridden to customize search behavior.
+  # @return [Blacklight::Document] the solr document object
+  def retrieve_document(id)
+    search_service.fetch(id)
+  end
+
+  # This method may be overridden to customize search behavior.
+  # @return [Array<Blacklight::Document>] an array of solr document objects
+  def retrieve_documents(ids)
+    search_service.fetch(Array(ids))
+  end
+
   # Override this method on the class that includes Blacklight::Searchable to provide more context to the search service if necessary.
   # For example, if your search builder needs to be aware of the current user, override this method to return a hash including the current user.
   # Then the search builder could use some property about the current user to construct a constraint on the search.

data/app/helpers/blacklight/layout_helper_behavior.rb

@@ -106,5 +106,12 @@ module Blacklight
     def extra_body_classes
       @extra_body_classes ||= ["blacklight-#{controller.controller_name}", "blacklight-#{[controller.controller_name, controller.action_name].join('-')}"]
     end
+
+    ##
+    # True if dark mode support is enabled in the configuration.
+    # @see Blacklight::Configuration#dark_mode_support
+    def dark_mode_support?
+      blacklight_config.dark_mode_support
+    end
   end
 end

data/app/javascript/blacklight-frontend/color_theme_switcher.js

@@ -0,0 +1,85 @@
+/*!
+ * Color mode toggler for Blacklight
+ * Based on Bootstrap's color mode toggler (https://getbootstrap.com/docs/5.3/customize/color-modes/#javascript)
+ */
+
+import Core from 'blacklight-frontend/core'
+
+const ColorThemeSwitcher = (() => {
+  'use strict'
+
+  const getStoredTheme = () => localStorage.getItem('theme')
+  const setStoredTheme = theme => localStorage.setItem('theme', theme)
+
+  const getPreferredTheme = () => {
+    const storedTheme = getStoredTheme()
+    if (storedTheme) {
+      return storedTheme
+    }
+    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'
+  }
+
+  const setTheme = theme => {
+    if (theme === 'auto') {
+      document.documentElement.setAttribute('data-bs-theme', window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light')
+    } else {
+      document.documentElement.setAttribute('data-bs-theme', theme)
+    }
+  }
+
+  const showActiveTheme = (theme, focus = false) => {
+    const themeSwitcher = document.querySelector('#bl-theme-switcher')
+    if (!themeSwitcher) return
+
+    // Reset all dropdown items
+    document.querySelectorAll('[data-bs-theme-value]').forEach(element => {
+      element.classList.remove('active')
+      element.setAttribute('aria-pressed', 'false')
+      const check = element.querySelector('.bl-theme-check')
+      if (check) check.classList.add('d-none')
+    })
+
+    // Activate the selected item
+    const btnToActive = document.querySelector(`[data-bs-theme-value="${theme}"]`)
+    if (btnToActive) {
+      btnToActive.classList.add('active')
+      btnToActive.setAttribute('aria-pressed', 'true')
+      const check = btnToActive.querySelector('.bl-theme-check')
+      if (check) check.classList.remove('d-none')
+    }
+
+    // Swap the toggle button icon
+    themeSwitcher.querySelectorAll('.bl-theme-icon').forEach(icon => icon.classList.add('d-none'))
+    const activeIcon = themeSwitcher.querySelector(`.bl-theme-icon[data-bl-theme-icon="${theme}"]`)
+    if (activeIcon) activeIcon.classList.remove('d-none')
+
+    themeSwitcher.setAttribute('aria-label', `Toggle theme (${theme})`)
+
+    if (focus) {
+      themeSwitcher.focus()
+    }
+  }
+
+  window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
+    const storedTheme = getStoredTheme()
+    if (storedTheme !== 'light' && storedTheme !== 'dark') {
+      setTheme(getPreferredTheme())
+    }
+  })
+
+  document.addEventListener('click', e => {
+    const btn = e.target.closest('[data-bs-theme-value]')
+    if (!btn) return
+
+    const theme = btn.getAttribute('data-bs-theme-value')
+    setStoredTheme(theme)
+    setTheme(theme)
+    showActiveTheme(theme, true)
+  })
+
+  Core.onLoad(() => showActiveTheme(getPreferredTheme()))
+
+  return { setTheme, getPreferredTheme, showActiveTheme }
+})()
+
+export default ColorThemeSwitcher

data/app/javascript/blacklight-frontend/index.js

@@ -1,5 +1,6 @@
 import BookmarkToggle from 'blacklight-frontend/bookmark_toggle'
 import ButtonFocus from 'blacklight-frontend/button_focus'
+import ColorThemeSwitcher from 'blacklight-frontend/color_theme_switcher'
 import FacetSuggest from 'blacklight-frontend/facet_suggest'
 import Modal from 'blacklight-frontend/modal'
 import SearchContext from 'blacklight-frontend/search_context'
@@ -8,6 +9,7 @@ import Core from 'blacklight-frontend/core'
 export default {
   BookmarkToggle,
   ButtonFocus,
+  ColorThemeSwitcher,
   FacetSuggest,
   Modal,
   SearchContext,

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

@@ -36,8 +36,8 @@ module Blacklight::Document::DublinCore
     xml.target!
   end
 
-  alias_method :export_as_xml, :export_as_oai_dc_xml
-  alias_method :export_as_dc_xml, :export_as_oai_dc_xml
+  alias export_as_xml export_as_oai_dc_xml
+  alias export_as_dc_xml export_as_oai_dc_xml
 
   private
 

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

@@ -32,7 +32,7 @@ module Blacklight::Document
   end
 
   attr_reader :response, :_source
-  alias_method :solr_response, :response
+  alias solr_response response
 
   delegate :[], :key?, :keys, :to_h, :as_json, to: :_source
 

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

@@ -2,6 +2,7 @@
 
 module Blacklight::User
   extend ActiveSupport::Concern
+
   # SEE ALSO:  The lib/blacklight/generator/user_generator.rb class for where this
   # is generated into the hosting application.
   included do
@@ -11,6 +12,41 @@ module Blacklight::User
     has_many :searches,  dependent: :destroy, as: :user
   end
 
+  class_methods do
+    # The column that holds the user's login/identifier. Rails' authentication
+    # generator uses +email_address+, while Devise and others use +email+.
+    def blacklight_email_column
+      column_names.include?("email_address") ? :email_address : :email
+    end
+
+    # Create a persisted "guest" user for an anonymous visitor, so they can
+    # accumulate bookmarks and searches that are transferred to a real account
+    # upon sign-in. Works whether the model uses +email+ or +email_address+,
+    # and supplies a random password when the model authenticates with a
+    # password (either +has_secure_password+'s +password_digest+ column or
+    # Devise's +encrypted_password+ column).
+    def create_guest_user!
+      attributes = { blacklight_email_column => "guest_#{Time.current.to_i}_#{SecureRandom.hex(4)}@example.com" }
+
+      if authenticates_with_password?
+        password = SecureRandom.hex(16)
+        attributes[:password] = password
+        attributes[:password_confirmation] = password
+      end
+
+      create!(attributes)
+    end
+
+    # True when the model stores a password (Rails' +has_secure_password+ via
+    # +password_digest+, or Devise's +database_authenticatable+ via
+    # +encrypted_password+). In either case the model exposes a virtual
+    # +password+ / +password_confirmation+ attribute that must be populated to
+    # satisfy validation.
+    def authenticates_with_password?
+      column_names.intersect?(%w[password_digest encrypted_password])
+    end
+  end
+
   def bookmarks_for_documents documents = []
     if documents.any?
       bookmarks.where(document_type: documents.first.class.base_class.to_s, document_id: documents.map(&:id))

data/app/presenters/blacklight/field_presenter.rb

@@ -31,7 +31,7 @@ module Blacklight
 
     attr_reader :view_context, :document, :field_config, :except_operations, :options
 
-    delegate :key, :component, to: :field_config
+    delegate :key, :component, :layout_component, to: :field_config
 
     # @return [Array<String>]
     def render

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

@@ -4,6 +4,7 @@ module Blacklight
   module Rendering
     class Microdata < AbstractStep
       include ActionView::Helpers::TagHelper
+
       def render
         return next_step(values) unless config.itemprop && html?
 

data/app/services/blacklight/bookmarks_search_builder.rb

@@ -6,17 +6,17 @@ module Blacklight
     ##
     # Filters the query to only include the bookmarked items
     #
-    # @param [Hash] solr_parameters
+    # @param [Blacklight::Solr::Request] request_parameters
     #
     # @return [void]
-    def bookmarked(solr_parameters)
-      solr_parameters[:fq] ||= []
+    def bookmarked(request_parameters)
       bookmarks = @scope.context.fetch(:bookmarks)
       return unless bookmarks
 
       document_ids = bookmarks.collect { |b| b.document_id.to_s }
-      solr_parameters[:fq] += ["{!terms f=id}#{document_ids.join(',')}"]
+      request_parameters.append_ids_filter(blacklight_config.document_model.unique_key, document_ids)
     end
+
     self.default_processor_chain += [:bookmarked]
   end
 end

data/app/services/blacklight/search_service.rb

@@ -3,10 +3,16 @@
 # SearchService returns search results from the repository
 module Blacklight
   class SearchService
+    # @params [Blacklight::Configuration] config
+    # @params [Blacklight::SearchState] search_state
+    # @params [Class] search_builder_class a class that inherits from Blacklight::SearchBuilder
+    # @params [Hash] context any data the search builder needs to access. For example, the current user.
     def initialize(config:, search_state:, search_builder_class: config.search_builder_class, **context)
       @blacklight_config = config
       @search_state = search_state
-      @user_params = @search_state.params
+      @user_params = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(@search_state.params,
+                                                                           'Use @search_state.params instead of @user_params',
+                                                                           Blacklight.deprecation)
       @search_builder_class = search_builder_class
       @context = context
     end
@@ -15,11 +21,7 @@ module Blacklight
     attr_reader :blacklight_config, :context
 
     def search_builder
-      search_builder_class.new(self)
-    end
-
-    def search_state_class
-      @search_state.class
+      search_builder_class.new(self, blacklight_config: blacklight_config)
     end
 
     # Fetch query results from solr
@@ -71,11 +73,24 @@ module Blacklight
 
     # Get the previous and next document from a search result
     # @return [Blacklight::Solr::Response, Array<Blacklight::SolrDocument>] the solr response and a list of the first and last document
-    def previous_and_next_documents_for_search(index, request_params, extra_controller_params = {})
-      p = previous_and_next_document_params(index)
-      new_state = request_params.is_a?(Blacklight::SearchState) ? request_params : Blacklight::SearchState.new(request_params, blacklight_config)
-      query = search_builder.with(new_state).start(p.delete(:start)).rows(p.delete(:rows)).merge(extra_controller_params).merge(p)
-      response = repository.search(params: query)
+    def previous_and_next_documents_for_search(index, request_params, params: nil, **extra_controller_params)
+      unless params
+        new_state = request_params.is_a?(Blacklight::SearchState) ? request_params : Blacklight::SearchState.new(request_params, blacklight_config)
+        builder = search_builder.with(new_state)
+
+        search_service_params = Blacklight.deprecation.silence do
+          previous_and_next_document_params(index)
+        end
+
+        builder = if search_service_params.empty?
+                    builder.for_previous_and_next_documents(index).merge(extra_controller_params)
+                  else
+                    Blacklight.deprecation.warn("SearchService#previous_and_next_document_params returned parameters. Implement customizations in SearchBuilder#for_previous_and_next_document instead")
+                    builder.start(search_service_params.delete(:start)).rows(search_service_params.delete(:rows)).merge(extra_controller_params).merge(search_service_params)
+                  end
+      end
+
+      response = repository.search(params: params || builder)
       document_list = response.documents
 
       # only get the previous doc if there is one
@@ -90,14 +105,16 @@ module Blacklight
     # the second item is an other array. This second array contains
     # all of the field values for each of the documents...
     # where the field is the "field" argument passed in.
+    # @deprecated
     def opensearch_response(field = nil, extra_controller_params = {})
       field ||= blacklight_config.view_config(:opensearch).title_field
 
       query = search_builder.with(search_state).merge(solr_opensearch_params(field)).merge(extra_controller_params)
-      response = repository.search(query)
+      response = repository.search(params: query)
 
       [search_state.query_param, response.documents.flat_map { |doc| doc[field] }.uniq]
     end
+    Blacklight.deprecation.deprecate_methods Blacklight::SearchService, opensearch_response: "The opensearch_response method is deprecated without replacement."
 
     private
 
@@ -113,34 +130,20 @@ module Blacklight
 
     ##
     # Opensearch autocomplete parameters for plucking a field's value from the results
+    # @deprecated
     def solr_opensearch_params(field)
       solr_params = {}
       solr_params[:rows] ||= 10
       solr_params[:fl] = field || blacklight_config.view_config(:opensearch).title_field
       solr_params
     end
+    Blacklight.deprecation.deprecate_methods Blacklight::SearchService, solr_opensearch_params: "The solr_opensearch_params method is deprecated without replacement."
 
-    ##
-    # Pagination parameters for selecting the previous and next documents
-    # out of a result set.
-    def previous_and_next_document_params(index, window = 1)
-      solr_params = blacklight_config.document_pagination_params.dup
-
-      if solr_params.empty?
-        solr_params[:fl] = blacklight_config.document_model.unique_key
-      end
-
-      if index > 0
-        solr_params[:start] = index - window # get one before
-        solr_params[:rows] = (2 * window) + 1 # and one after
-      else
-        solr_params[:start] = 0 # there is no previous doc
-        solr_params[:rows] = 2 * window # but there should be one after
-      end
-
-      solr_params[:facet] = false
-      solr_params
+    def previous_and_next_document_params(*, **)
+      {}
     end
+    Blacklight.deprecation.deprecate_methods(Blacklight::SearchService,
+                                             previous_and_next_document_params: "Use SearchBuilder#for_previous_and_next_documents instead of SearchService#previous_and_next_document_params")
 
     ##
     # Retrieve a set of documents by id
@@ -149,11 +152,20 @@ module Blacklight
     def fetch_many(ids, extra_controller_params)
       extra_controller_params ||= {}
 
+      requested_rows = extra_controller_params.delete(:rows)
+      if requested_rows
+        Blacklight.deprecation.warn("Passing :rows to fetch_many is deprecated. Create an issue in blacklight if you see this warning. " \
+                                    "Otherwise, :rows will be ignored in Blackight 10")
+      else
+        requested_rows = ids.count
+      end
+
       query = search_builder
               .with(search_state)
               .where(blacklight_config.document_model.unique_key => ids)
               .merge(blacklight_config.fetch_many_document_params)
               .merge(extra_controller_params)
+      query.rows(requested_rows)
 
       # find_many was introduced in Blacklight 8.4. Before that, we used the
       # regular search method (possibly with a find-many specific `qt` parameter).
@@ -162,7 +174,8 @@ module Blacklight
       solr_response = if repository.respond_to?(:find_many)
                         repository.find_many(query)
                       else
-                        repository.search(query)
+                        Blacklight.deprecation.warn("Repository#find_many is not implemented. Falling back to Repository#search.")
+                        repository.search(params: query)
                       end
 
       solr_response.documents

data/app/values/blacklight/types.rb

@@ -88,7 +88,7 @@ module Blacklight
       def cast(input)
         value = super
 
-        return value unless value.is_a?(String)
+        return value unless value.is_a?(::String)
 
         JSON.parse(value)
       end

data/app/views/catalog/_email_form.html.erb

@@ -6,7 +6,7 @@
 
   <div class="modal-body">
     <%= render '/shared/flash_msg' %>
-    <div class="row">
+    <div class="row mb-3">
       <label class="col-form-label col-sm-2" for="to">
         <%= t('blacklight.email.form.to') %>
       </label>
@@ -15,7 +15,7 @@
       </div>
     </div>
 
-    <div class="row">
+    <div class="row mb-3">
       <label class="col-form-label col-sm-2" for="message">
         <%= t('blacklight.email.form.message') %>
       </label>
@@ -25,7 +25,7 @@
     </div>
 
     <% @documents&.each do |doc| %>
-      <%=hidden_field_tag "id[]", doc.id %>
+      <%= hidden_field_tag "id[]", doc.id %>
     <% end %>
     <%- if params[:sort] -%>
       <%= hidden_field_tag "sort", params[:sort] %>

data/app/views/catalog/_home_text.html.erb

@@ -1,4 +1,4 @@
-<div class="text-center p-5 mb-4 bg-light rounded-3">
+<div class="text-center p-5 mb-4 bg-body-tertiary border rounded-3">
   <h1 class="fw-bold"><%= t('blacklight.welcome') %></h1>
 
   <p class="lead">Blacklight is a multi-institutional open-source collaboration building a better discovery platform framework.</p>