blacklight 9.0.0.beta8 → 9.1.0

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

@@ -9,11 +9,12 @@ module Blacklight::Catalog
   include Blacklight::Configurable
   include Blacklight::SearchContext
   include Blacklight::Searchable
-  include Blacklight::Facetable
 
   # The following code is executed when someone includes blacklight::catalog in their
   # own controller.
   included do
+    allow_unauthenticated_access raise: false if respond_to?(:allow_unauthenticated_access)
+
     if respond_to? :helper_method
       helper_method :sms_mappings, :has_search_parameters?
     end
@@ -38,7 +39,7 @@ module Blacklight::Catalog
   # get a single document from the index
   # to add responses for formats other than html or json see _Blacklight::Document::Export_
   def show
-    @document = search_service.fetch(params[:id])
+    @document = retrieve_document(params[:id])
 
     respond_to do |format|
       format.html { @search_context = setup_next_and_previous_documents }
@@ -55,7 +56,7 @@ module Blacklight::Catalog
   def raw
     raise(ActionController::RoutingError, 'Not Found') unless blacklight_config.raw_endpoint.enabled
 
-    @document = search_service.fetch(params[:id])
+    @document = retrieve_document(params[:id])
     render json: @document
   end
 
@@ -82,11 +83,11 @@ module Blacklight::Catalog
     raise ActionController::RoutingError, 'Not Found' unless @facet
 
     @response = if params[:query_fragment].present?
-                  facet_search_service.facet_suggest_response(@facet.key, params[:query_fragment])
+                  search_service.facet_suggest_response(@facet.key, params[:query_fragment])
                 else
-                  facet_search_service.facet_field_response(@facet.key)
+                  search_service.facet_field_response(@facet.key)
                 end
-
+    # @display_facet is a Blacklight::Solr::Response::Facets::FacetField
     @display_facet = @response.aggregations[@facet.field]
 
     # @presenter is a Blacklight::FacetFieldPresenter
@@ -108,7 +109,10 @@ module Blacklight::Catalog
   def opensearch
     respond_to do |format|
       format.xml { render layout: false }
-      format.json { render json: search_service.opensearch_response }
+      format.json do
+        @response = retrieve_search_results
+        @presenter = json_presenter(@response)
+      end
     end
   end
 
@@ -121,7 +125,7 @@ module Blacklight::Catalog
   # @return [Array] first value is a Blacklight::Solr::Response and the second
   #                 is a list of documents
   def action_documents
-    @documents = search_service.fetch(Array(params[:id]))
+    @documents = retrieve_documents(params[:id])
     raise Blacklight::Exceptions::RecordNotFound if @documents.blank?
 
     @documents
@@ -146,12 +150,6 @@ module Blacklight::Catalog
     blacklight_config.index.json_presenter_class.new(repository_response, blacklight_config)
   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
-
   #
   # non-routable methods ->
   #

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/checkbox_submit.js

@@ -10,7 +10,7 @@
        attribute (HTML5-style doc-*) that contains the id/primary key
        of the object in question -- used by plugin for a unique value for
        DOM id's.
-  Uses HTML for a checkbox compatible with Bootstrap 4.
+  Uses HTML for a checkbox compatible with Bootstrap.
    new CheckboxSubmit(document.querySelector('form.something')).render()
 */
 export default class CheckboxSubmit {
@@ -36,7 +36,7 @@ export default class CheckboxSubmit {
     }).then((json) => {
       this.labelTarget.removeAttribute('disabled')
       this.checkboxTarget.removeAttribute('disabled')
-      // For accessibility return keyboard focus 
+      // For accessibility return keyboard focus
       // back to the checkbox after form submission
       this.checkboxTarget.focus()
       this.updateStateFor(!this.checked)

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/facet_suggest.js

@@ -16,10 +16,13 @@ const FacetSuggest = async (e) => {
 
     // Drop facet.page so a filtered suggestion list will always start on page 1
     url.searchParams.delete('facet.page');
+    // add our queryFragment for facet filtering
+    url.searchParams.append('query_fragment', queryFragment);
+
     const facetSearchParams = url.searchParams.toString();
     const basePathComponent = url.pathname.split('/')[1];
 
-    const urlToFetch = `/${basePathComponent}/facet_suggest/${facetField}/${queryFragment}?${facetSearchParams}`;
+    const urlToFetch = `/${basePathComponent}/facet_suggest/${facetField}?${facetSearchParams}`;
 
     const response = await fetch(urlToFetch);
     if (response.ok) {

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