arclight 0.0.1 → 1.6.2

data/app/helpers/arclight/ead_format_helpers.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # A module to add EAD to HTML transformation rules for Arclight
+  module EadFormatHelpers # rubocop:disable Metrics/ModuleLength
+    extend ActiveSupport::Concern
+
+    def render_html_tags(args)
+      values = Array(args[:value])
+      values.map! do |value|
+        transform_ead_to_html(value)
+      end
+      values.map! { |value| wrap_in_paragraph(value) } if values.count > 1
+      safe_join(values.map(&:html_safe))
+    end
+
+    private
+
+    def transform_ead_to_html(value)
+      Loofah.xml_fragment(condense_whitespace(value))
+            .scrub!(ead_to_html_scrubber)
+            .scrub!(:strip).to_html
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def ead_to_html_scrubber
+      Loofah::Scrubber.new do |node|
+        format_render_attributes(node) if node.attr('render').present?
+        convert_to_span(node) if CONVERT_TO_SPAN_TAGS.include? node.name
+        convert_to_br(node) if CONVERT_TO_BR_TAG.include? node.name
+        format_links(node) if %w[extptr extref extrefloc ptr ref].include? node.name
+        format_lists(node) if %w[list chronlist].include? node.name
+        format_indexes(node) if node.name == 'index'
+        format_tables(node) if node.name == 'table'
+        node
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # Tags that should be converted to <span> tags because of formatting conflicts between XML and HTML
+    CONVERT_TO_SPAN_TAGS = ['title'].freeze
+
+    # Tags that should be converted to HTML <br/> tags
+    CONVERT_TO_BR_TAG = ['lb'].freeze
+
+    def convert_to_span(node)
+      node.name = 'span'
+    end
+
+    def convert_to_br(node)
+      node.name = 'br'
+    end
+
+    def condense_whitespace(str)
+      str.squish.strip.gsub(/>[\n\s]+</, '><')
+    end
+
+    def wrap_in_paragraph(value)
+      if value.start_with?('<')
+        value
+      else
+        content_tag(:p, value)
+      end
+    end
+
+    def format_render_attributes(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+      case node.attr('render')
+      when 'altrender'
+        node.name = 'span'
+        node['class'] = node['altrender']
+      when 'bold'
+        node.name = 'strong'
+      when 'bolddoublequote'
+        node.name = 'strong'
+        node.prepend_child '"'
+        node.add_child '"'
+      when 'bolditalic'
+        node.name = 'strong'
+        node.wrap('<em/>')
+      when 'boldsinglequote'
+        node.name = 'strong'
+        node.prepend_child '\''
+        node.add_child '\''
+      when 'boldsmcaps'
+        node.name = 'strong'
+        node.wrap('<small/>')
+        node['class'] = 'text-uppercase'
+      when 'boldunderline'
+        node.name = 'strong'
+        node['class'] = 'text-underline'
+      when 'doublequote'
+        node.name = 'span'
+        node.prepend_child '"'
+        node.add_child '"'
+      when 'italic', 'nonproport'
+        node.name = 'em'
+      when 'singlequote'
+        node.name = 'span'
+        node.prepend_child '\''
+        node.add_child '\''
+      when 'smcaps'
+        node.name = 'small'
+        node['class'] = 'text-uppercase'
+      when 'sub'
+        node.name = 'sub'
+      when 'super'
+        node.name = 'sup'
+      when 'underline'
+        node.name = 'span'
+        node['class'] = 'text-underline'
+      end
+    end
+
+    def format_links(node)
+      node.remove_attribute('target')
+      node.remove_attribute('type')
+      if %w[extptr extref extrefloc].include? node.name
+        node['target'] = '_blank'
+        node['class'] = 'external-link'
+      end
+      node.content = node['title'] if (%w[extptr ptr].include? node.name) && node['title'].present?
+      node.name = 'a' if node['href'].present?
+    end
+
+    def format_lists(node)
+      format_simple_lists(node) if node.name == 'list' && node['type'] != 'deflist'
+      format_deflists(node) if node.name == 'list' && node['type'] == 'deflist'
+      format_chronlists(node) if node.name == 'chronlist'
+    end
+
+    def format_simple_lists(node)
+      node.name = 'ul' if (%w[simple marked].include? node['type']) || node['type'].blank?
+      node.name = 'ol' if node['type'] == 'ordered'
+      node.remove_attribute('type')
+      head_node = node.at_css('head')
+      format_list_head(head_node) if head_node.present?
+      items = node.css('item')
+      items.each { |item_node| item_node.name = 'li' }
+    end
+
+    def format_list_head(node)
+      node['class'] = 'list-head'
+      node.name = 'div'
+      node.parent.previous = node # move it from within the list to above it
+    end
+
+    def format_deflists(node)
+      listhead_node = node.at_css('listhead')
+      labels = node.css('label')
+      items = node.css('item')
+      defitems = node.css('defitem')
+      node.remove_attribute('type')
+
+      if listhead_node.present?
+        format_deflist_as_table(node, labels, items, defitems)
+      else
+        format_deflist_as_dl(node, labels, items, defitems)
+      end
+    end
+
+    def format_deflist_as_table(node, labels, items, defitems)
+      node.name = 'table'
+      node['class'] = 'table deflist'
+      listhead_node = node.at_css('listhead')
+      format_deflist_table_head(listhead_node)
+      node.at_css('thead').next = '<tbody/>'
+      labels.each { |label_node| label_node.name = 'td' }
+      items.each { |item_node| item_node.name = 'td' }
+      defitems.each do |defitem_node|
+        defitem_node.name = 'tr'
+        defitem_node.parent = node.at_css('tbody')
+      end
+    end
+
+    def format_deflist_table_head(listhead_node)
+      listhead_node.at_css('head01').name = 'th'
+      listhead_node.at_css('head02').name = 'th'
+      listhead_node.name = 'tr'
+      listhead_node.wrap('<thead/>')
+    end
+
+    def format_deflist_as_dl(node, labels, items, defitems)
+      node.name = 'dl'
+      node['class'] = 'deflist'
+      labels.each { |label_node| label_node.name = 'dt' }
+      items.each { |item_node| item_node.name = 'dd' }
+      defitems.each { |defitem_node| defitem_node.swap(defitem_node.children) } # unwrap
+    end
+
+    def format_chronlists(node)
+      node.name = 'table'
+      node['class'] = 'table chronlist'
+      eventgrps = node.css('eventgrp')
+      single_events = node.css('chronitem > event')
+      multi_events = node.css('eventgrp > event')
+      format_chronlist_header(node)
+      node.at_css('thead').next = '<tbody/>'
+      format_chronlist_caption(node)
+      format_chronlist_chronitems(node)
+      format_chronlist_dates(node)
+      format_chronlist_events(eventgrps, single_events, multi_events)
+    end
+
+    def format_chronlist_header(node)
+      node.add_child('<thead><tr><th>Date</th><th>Event</th></tr></thead>')
+      table_head = node.at_css('thead')
+      node.children.first.add_previous_sibling(table_head)
+      listhead_node = node.at_css('listhead')
+      return if listhead_node.blank?
+
+      node.at_css('thead tr th:nth-of-type(1)').content = node.at_css('listhead/head01').content
+      node.at_css('thead tr th:nth-of-type(2)').content = node.at_css('listhead/head02').content
+      listhead_node.remove
+    end
+
+    def format_chronlist_caption(node)
+      head_node = node.at_css('head')
+      return if head_node.blank?
+
+      head_node.name = 'caption'
+      head_node['class'] = 'chronlist-head'
+      node.children.first.add_previous_sibling(head_node) # make the caption first
+    end
+
+    def format_chronlist_chronitems(node)
+      chronitems = node.css('chronitem')
+      chronitems.each do |chronitem_node|
+        chronitem_node.name = 'tr'
+        chronitem_node.parent = node.at_css('tbody')
+      end
+    end
+
+    def format_chronlist_dates(node)
+      dates = node.css('date')
+      dates.each do |date_node|
+        date_node.name = 'td'
+        date_node['class'] = 'chronlist-item-date'
+      end
+    end
+
+    def format_chronlist_events(eventgrps, single_events, multi_events)
+      eventgrps.each do |eventgrp_node|
+        eventgrp_node.name = 'td'
+        eventgrp_node['class'] = 'chronlist-item-event'
+      end
+      single_events.each do |event_node|
+        event_node.name = 'td'
+        event_node['class'] = 'chronlist-item-event'
+      end
+      multi_events.each { |event_node| event_node.name = 'div' }
+    end
+
+    # Format EAD <index> elements
+    def format_indexes(node)
+      index_head = node.at_css('head')
+      index_head&.name = 'h3'
+      index_head&.add_class('index-head')
+      index_head['id'] = ['index-', index_head.text].join.parameterize if index_head.present?
+      format_indexentries(node)
+      node.name = 'div'
+    end
+
+    # Grab all of the <indexentry> children as a nodeset, move them into
+    # a <table>, wrap each entry in a <tr> & each value in a <td>.
+    def format_indexentries(node)
+      indexentries = node.css('indexentry')
+      return if indexentries.blank?
+
+      indexentries.first.previous = '<table class="table indexentries" />'
+      indexentries.map do |i|
+        i.parent = node.at_css('table.table.indexentries')
+        i.wrap('<tr/>')
+        i.element_children.map { |c| c.wrap('<td/>') }
+        # Assuming two columns in an index, create a blank cell for entries
+        # with a missing value.
+        i.add_child('<td/>') if i.element_children.count == 1
+      end
+    end
+
+    # Format EAD <table> elements, converting <tgroup> to HTML <table>.
+    # Ignoring <colspec>, @colname, @colwidth complex rendering
+    # logic for now.
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def format_tables(node)
+      node.remove_attribute('frame')
+      node.name = 'div' if node.css('tgroup').present?
+      format_table_head(node)
+      tgroups = node.css('tgroup')
+      tgroups&.map do |t|
+        t.name = 'table'
+        t.remove_attribute('cols')
+        t.add_class('table')
+        t.css('row').map { |r| r.name = 'tr' }
+        t.css('thead entry').map { |e| e.name = 'th' }
+        t.css('tbody entry').map { |e| e.name = 'td' }
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def format_table_head(node)
+      table_head = node.at_css('head')
+      return if table_head.blank?
+
+      table_head.name = 'h3'
+      table_head.add_class('table-head')
+    end
+  end
+end

data/app/helpers/arclight/field_config_helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # A module to add configuration helpers for certain fields used by Arclight
+  module FieldConfigHelpers
+    include Arclight::EadFormatHelpers
+
+    def item_requestable?(document)
+      document.requestable?
+    end
+    Arclight.deprecation.deprecate_methods(self, item_requestable?: 'Call e.g. `document.requestable?` instead')
+
+    def link_to_name_facet(args)
+      options = args[:config]&.separator_options || {}
+      values = args[:value] || []
+
+      values.map do |value|
+        link_to(
+          value,
+          search_action_path(f: { names: [value] })
+        )
+      end.to_sentence(options).html_safe
+    end
+  end
+end

data/app/helpers/arclight_helper.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+##
+# Generic Helpers used in Arclight
+module ArclightHelper
+  include Arclight::EadFormatHelpers
+  include Arclight::FieldConfigHelpers
+  include Blacklight::DocumentHelperBehavior
+  include Blacklight::LayoutHelperBehavior
+
+  def repository_collections_path(repository)
+    search_action_url(
+      f: {
+        repository: [repository.name],
+        level: ['Collection']
+      }
+    )
+  end
+
+  # Returns the i18n-ed string to be used as the h1 in search results
+  def search_results_header_text
+    if (repo = repository_faceted_on).present?
+      t('arclight.search.repository_header', repository: repo.name)
+    elsif collection_active?
+      t('arclight.search.collections_header')
+    else
+      t('blacklight.search.header')
+    end
+  end
+
+  ##
+  # Classes used for customized show page in arclight
+  def show_content_classes
+    'col-12 col-lg-8 show-document order-2'
+  end
+
+  def show_sidebar_classes
+    'col-lg-4 order-1 collection-sidebar'
+  end
+
+  def collection_active?
+    search_state.filter('level').values == ['Collection']
+  end
+
+  def collection_active_class
+    'active' if collection_active?
+  end
+
+  def grouped?
+    respond_to?(:search_state) && search_state&.params_for_search&.dig('group') == 'true'
+  end
+
+  def search_with_group
+    search_state.params_for_search.merge('group' => 'true').except('page')
+  end
+
+  def search_without_group
+    search_state.params_for_search.except('group', 'page')
+  end
+
+  def on_repositories_index?
+    controller_name == 'repositories' && action_name == 'index'
+  end
+
+  # the Repositories menu item is only active on the Repositories index page
+  def repositories_active_class
+    'active' if on_repositories_index?
+  end
+
+  # If we have a facet on the repository, then return the Repository object for it
+  #
+  # @return [Repository]
+  def repository_faceted_on
+    repos = search_state.filter('repository').values
+    return unless repos.one?
+
+    Arclight::Repository.find_by(name: repos.first)
+  end
+
+  # determine which icon to show in search results header
+  # these icon names will need to be updated when the icons are determined
+  def document_or_parent_icon(document)
+    case document.level&.downcase
+    when 'collection'
+      'collection'
+    when 'file'
+      'file'
+    when 'series', 'subseries'
+      'folder'
+    else
+      'container'
+    end
+  end
+
+  ##
+  # Override of BL core https://github.com/projectblacklight/blacklight/blob/v8.1.0/app/helpers/blacklight/document_helper_behavior.rb#L55
+  # Remove document_type check. It isn't a method on arclight documents
+  # Check if the document is in the user's bookmarks
+  # @param [Blacklight::Document] document
+  # @return [Boolean]
+  def bookmarked?(document)
+    current_bookmarks.any? { |x| x.document_id == document.id }
+  end
+
+  def current_context_document
+    @document
+  end
+end

data/app/models/arclight/document_downloads.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # Model the Download links that can be configured (via YAML) for a collection
+  # or container
+  class DocumentDownloads
+    attr_reader :document
+
+    def initialize(document, id = nil)
+      @document = document
+      @id = id
+    end
+
+    # Accessor for the ID
+    # @return [String]
+    def id
+      @id || document.unitid
+    end
+
+    # Factory method for the File objects
+    # @return [Array<Arclight::DocumentDownloads::File>]
+    def files
+      data = self.class.config[id] || self.class.config['default']
+      disabled = data.delete('disabled')
+      return [] if disabled
+
+      @files ||= data.map do |file_type, file_data|
+        self.class.file_class.new(type: file_type, data: file_data, document: document)
+      end.compact
+    end
+
+    class << self
+      def config
+        @config ||= begin
+          YAML.safe_load_file(config_filename)
+        rescue Errno::ENOENT
+          {}
+        end
+      end
+
+      def config_filename
+        Rails.root.join('config/downloads.yml')
+      end
+
+      # Accessor for the File Class
+      # @return [Class]
+      def file_class
+        Arclight::DocumentDownloads::File
+      end
+    end
+
+    ##
+    # Model a single file configured in downloads.yml
+    class File
+      attr_reader :type, :document
+
+      def initialize(type:, data:, document:)
+        @type = type
+        @data = data
+        @document = document
+      end
+
+      def href
+        return data['href'] if data['href']
+
+        format_template
+      end
+
+      def size
+        return data['size'] if data['size']
+
+        document.public_send(data['size_accessor'].to_sym) if data['size_accessor']
+      end
+
+      private
+
+      attr_reader :data
+
+      def format_template
+        return unless template
+
+        template % template_interpolations
+      end
+
+      def template
+        data['template']
+      end
+
+      def template_interpolations
+        escaped_document_interpolations.merge(custom_interpolations).symbolize_keys
+      end
+
+      def custom_interpolations
+        { 'repository_id' => document.repository_config&.slug }
+      end
+
+      def template_variables
+        template.scan(Regexp.union(/%{(\w+)}/, /%<(\w+)>/)).flatten.compact.uniq
+      end
+
+      def escaped_document_interpolations
+        non_custom_template_variables.index_with do |method_name|
+          escape_non_url_doc_value(document.public_send(method_name))
+        end
+      end
+
+      def escape_non_url_doc_value(value)
+        value = Array.wrap(value).first || '' # Handle single values/arrays and nil
+        return value if value.start_with?(/https?:/)
+
+        CGI.escape(value)
+      end
+
+      def non_custom_template_variables
+        template_variables.reject do |v|
+          custom_interpolations.keys.include?(v)
+        end
+      end
+    end
+  end
+end

data/app/models/arclight/parent.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # Logic containing information about Solr_Ead "Parent"
+  # https://github.com/awead/solr_ead/blob/8cf7ffaa66e0e4c9c0b12f5646d6c2e20984cd99/lib/solr_ead/behaviors.rb#L54-L57
+  class Parent
+    attr_reader :id, :label, :eadid, :level
+
+    alias global_id id
+    Arclight.deprecation.deprecate_methods(self, global_id: 'Call `id` instead')
+
+    def initialize(id:, label:, eadid:, level:)
+      @id = id
+      @label = label
+      @eadid = eadid
+      @level = level
+    end
+
+    def collection?
+      level == 'collection'
+    end
+  end
+end

data/app/models/arclight/parents.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # Object for parsing and formalizing Solr_Ead "Parents"
+  # https://github.com/awead/solr_ead/blob/8cf7ffaa66e0e4c9c0b12f5646d6c2e20984cd99/lib/solr_ead/behaviors.rb#L54-L57
+  class Parents
+    attr_reader :ids, :legacy_ids, :labels, :levels
+
+    def initialize(ids:, legacy_ids:, labels:, eadid:, levels:)
+      @ids = ids
+      @legacy_ids = legacy_ids
+      @labels = labels
+      @eadid = eadid
+      @levels = levels
+    end
+
+    def eadid
+      Arclight::NormalizedId.new(@eadid).to_s
+    end
+
+    ##
+    # @return [Array[Arclight::Parent]]
+    def as_parents
+      (ids.presence || legacy_ids).map.with_index { |id, idx| Arclight::Parent.new(id: id, label: labels[idx], eadid: eadid, level: levels[idx]) }
+    end
+
+    ##
+    # @param [SolrDocument] document
+    def self.from_solr_document(document)
+      ids = document.parent_ids
+      legacy_ids = document.legacy_parent_ids.map { |legacy_id| document.root == legacy_id ? legacy_id : "#{document.root}#{legacy_id}" }
+      labels = document.parent_labels
+      eadid = document.eadid
+      levels = document.parent_levels
+      new(ids: ids, legacy_ids: legacy_ids, labels: labels, eadid: eadid, levels: levels)
+    end
+  end
+end

data/app/models/arclight/requests/aeon_external_request.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Arclight
+  module Requests
+    ##
+    # This class should be used to turn configuration into a URL and
+    # POST form specifically aimed at Aeon's external request
+    # endpoint (https://support.atlas-sys.com/hc/en-us/articles/360011820054-External-Request-Endpoint)
+    class AeonExternalRequest
+      def initialize(document, presenter)
+        @document = document
+        @presenter = presenter
+      end
+
+      def config
+        @config ||= @document.repository_config.request_config_for_type('aeon_external_request_endpoint')
+      end
+
+      def url
+        "#{config['request_url']}?#{url_params}"
+      end
+
+      def form_mapping
+        static_mappings.merge(dynamic_mappings)
+      end
+
+      def static_mappings
+        config['request_mappings']['static']
+      end
+
+      def dynamic_mappings
+        config['request_mappings']['accessor'].transform_values do |v|
+          @document.public_send(v.to_sym)
+        end
+      end
+
+      def url_params
+        config['request_mappings']['url_params'].to_query
+      end
+    end
+  end
+end