arclight 0.0.1 → 1.4.0

data/lib/arclight/digital_object.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # Plain ruby class to model serializing/deserializing digital object data
+  class DigitalObject
+    attr_reader :label, :href
+
+    def initialize(label:, href:)
+      @label = label.presence || href
+      @href = href
+    end
+
+    def to_json(*)
+      { label: label, href: href }.to_json
+    end
+
+    def self.from_json(json)
+      object_data = JSON.parse(json)
+      new(label: object_data['label'], href: object_data['href'])
+    end
+
+    def ==(other)
+      href == other.href && label == other.label
+    end
+  end
+end

data/lib/arclight/engine.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'blacklight'
+require 'traject'
+require 'active_model'
+require 'arclight/exceptions'
+require 'arclight/normalized_date'
+require 'arclight/normalized_id'
+require 'arclight/normalized_title'
+require 'arclight/digital_object'
+require 'gretel'
+
+module Arclight
+  ##
+  # This is the defining class for the Arclight Rails Engine
+  class Engine < ::Rails::Engine
+    config.oembed_resource_exclude_patterns = [/\.pdf$/, /\.ppt$/]
+
+    Arclight::Engine.config.catalog_controller_group_query_params = {
+      group: true,
+      'group.field': '_root_',
+      'group.ngroups': true,
+      'group.limit': 3,
+      fl: '*,collection:[subquery]',
+      'collection.q': '{!terms f=id v=$row._root_}',
+      'collection.defType': 'lucene',
+      'collection.fl': '*',
+      'collection.rows': 1
+    }
+
+    initializer 'arclight.helpers' do
+      config.after_initialize do
+        ActiveSupport.on_load(:action_view) { include ArclightHelper }
+      end
+    end
+
+    initializer 'arclight.assets', before: 'assets' do |app|
+      app.config.assets.precompile << 'arclight/arclight.js'
+      app.config.assets.precompile << 'arclight/oembed_controller.js'
+      app.config.assets.precompile << 'arclight/truncate_controller.js'
+    end
+
+    initializer 'arclight.importmap', before: 'importmap' do |app|
+      app.config.importmap.paths << Engine.root.join('config/importmap.rb') if app.config.respond_to?(:importmap)
+    end
+  end
+end

data/lib/arclight/exceptions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Arclight
+  module Exceptions
+    # Id's must be present on all documents and components
+    class IDNotFound < StandardError
+      def message
+        'id must be present for all documents and components'
+      end
+    end
+
+    # Unittitle or unitdate must be present on all documents and components
+    class TitleNotFound < StandardError
+      def message
+        '<unittitle/> or <unitdate/> must be present for all documents and components'
+      end
+    end
+  end
+end

data/lib/arclight/hash_absolute_xpath.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Arclight
+  ##
+  # Take a Nokogiri node and get its absolute path (inserting our own indexes for component levels)
+  # and hash that outout. This is intended as a potential strategy for handling missing IDs in EADs.
+  class HashAbsoluteXpath
+    class << self
+      attr_writer :hash_algorithm
+
+      def hash_algorithm
+        return Digest::SHA1 unless defined? @hash_algorithm
+
+        @hash_algorithm
+      end
+    end
+
+    COMPONENT_NODE_NAME_REGEX = /^c\d{,2}$/
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+
+    def to_hexdigest
+      self.class.hash_algorithm.hexdigest(absolute_xpath).prepend('al_')
+    end
+
+    def absolute_xpath
+      ancestor_tree = node.ancestors.map do |ancestor|
+        ancestor_name_and_index(ancestor)
+      end
+
+      "#{[ancestor_tree.reverse, node.name].flatten.join('/')}#{current_index}"
+    end
+
+    private
+
+    def current_index
+      siblings.index(node)
+    end
+
+    def component_siblings_for_node(xml_node)
+      xml_node.parent.children.select { |n| n.name =~ COMPONENT_NODE_NAME_REGEX }
+    end
+
+    def siblings
+      @siblings ||= component_siblings_for_node(node)
+    end
+
+    def ancestor_name_and_index(ancestor)
+      if ancestor.name =~ COMPONENT_NODE_NAME_REGEX
+        index = component_siblings_for_node(ancestor).index(ancestor)
+        "#{ancestor.name}#{index}"
+      else
+        ancestor.name
+      end
+    end
+  end
+end

data/lib/arclight/level_label.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # A utility class to return a human-readable label for an EAD @level code.
+  # Can use the value from @otherlevel if provided.
+  # Examples from @level: recordgrp = "Record Group"
+  #                       collection = "Collection"
+  #                       subseries = "Subseries"
+  #                       otherlevel = (text provided in @otherlevel)
+  class LevelLabel
+    # @param [String] `level` from the collection or component @level
+    # @param [String] `other_level` from the collection or component @otherlevel
+    def initialize(level, other_level = nil)
+      @level = level
+      @other_level = other_level if other_level.present?
+    end
+
+    # @return [String] the human-readable label
+    def to_s
+      human_readable_level
+    end
+
+    private
+
+    attr_reader :level, :other_level
+
+    CUSTOM_LEVEL_LABELS = {
+      recordgrp: 'Record Group',
+      subgrp: 'Subgroup'
+    }.freeze
+
+    def human_readable_level
+      if level == 'otherlevel'
+        alternative_level
+      elsif level.present?
+        CUSTOM_LEVEL_LABELS.fetch(level.to_sym, level.capitalize).to_s
+      end
+    end
+
+    def alternative_level
+      alternative_level = other_level if other_level
+      alternative_level.present? ? alternative_level.capitalize : 'Other'
+    end
+  end
+end

data/lib/arclight/missing_id_strategy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'arclight/hash_absolute_xpath'
+
+module Arclight
+  ##
+  # A class to configure a selected MissingIdStrategy.
+  # Defaults to Arclight::HashAbsoluteXpath
+  # This can be updated in an initializer to be any other class
+  class MissingIdStrategy
+    class << self
+      attr_writer :selected
+
+      def selected
+        return Arclight::HashAbsoluteXpath unless defined? @selected
+
+        @selected
+      end
+    end
+  end
+end

data/lib/arclight/normalized_date.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # A utility class to normalize dates, typically by joining inclusive and bulk dates
+  # e.g., "1990-2000, bulk 1990-1999"
+  # @see http://www2.archivists.org/standards/DACS/part_I/chapter_2/4_date
+  class NormalizedDate
+    # @param [String | Array<String>] `inclusive` from the `unitdate`
+    # @param [Array<String>] `bulk` from the `unitdate`
+    # @param [Array<String>] `other` from the `unitdate` when type is not specified
+    def initialize(inclusive, bulk = [], other = [])
+      @inclusive = (inclusive || []).map do |inclusive_text|
+        if inclusive_text.is_a? Array # of YYYY-YYYY for ranges
+          # NOTE: This code is not routable AFAICT in actual indexing.
+          # We pass arrays of strings (or xml nodes) here, and never a multidimensional array
+          year_range(inclusive_text)
+        elsif inclusive_text.present?
+          inclusive_text.strip
+        end
+      end&.join(', ')
+
+      @bulk = Array.wrap(bulk).compact.map(&:strip).join(', ')
+      @other = Array.wrap(other).compact.map(&:strip).join(', ')
+    end
+
+    # @return [String] the normalized title/date
+    def to_s
+      normalize
+    end
+
+    private
+
+    attr_reader :inclusive, :bulk, :other
+
+    def year_range(date_array)
+      YearRange.new(date_array.include?('/') ? date_array : date_array.map { |v| v.tr('-', '/') }).to_s
+    end
+
+    # @see http://www2.archivists.org/standards/DACS/part_I/chapter_2/4_date for rules
+    def normalize
+      result = []
+      result << inclusive if inclusive.present?
+      result << other if other.present?
+      result << "bulk #{bulk}" if bulk.present?
+      result.compact.map(&:strip).join(', ').presence
+    end
+  end
+end

data/lib/arclight/normalized_id.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'arclight/exceptions'
+
+module Arclight
+  ##
+  # A simple utility class to normalize identifiers
+  class NormalizedId
+    # Accepts unused kwargs from the ead2_config.rb id to_field directive
+    # (:title and :repository) so that applications can provide a custom
+    # id_normalizer class to traject to form the collection id from these attributes.
+    def initialize(id, **_kwargs)
+      @id = id
+    end
+
+    def to_s
+      normalize
+    end
+
+    private
+
+    attr_reader :id
+
+    def normalize
+      raise Arclight::Exceptions::IDNotFound if id.blank?
+
+      id.strip.tr('.', '-')
+    end
+  end
+end

data/lib/arclight/normalized_title.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'arclight/exceptions'
+
+module Arclight
+  ##
+  # A utility class to normalize titles, typically by joining
+  # the title and date, e.g., "My Title, 1990-2000"
+  class NormalizedTitle
+    # @param [String] `title` from the `unittitle`
+    # @param [String] `date` from the `unitdate`
+    def initialize(title, date = nil)
+      @title = title.gsub(/\s*,\s*$/, '').strip if title.present?
+      @date = date.strip if date.present?
+    end
+
+    # @return [String] the normalized title/date
+    def to_s
+      normalize
+    end
+
+    private
+
+    attr_reader :title, :date, :default
+
+    def normalize
+      result = [title, date].compact.join(', ')
+      raise Arclight::Exceptions::TitleNotFound if result.blank?
+
+      result
+    end
+  end
+end

data/lib/arclight/repository.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Arclight
+  # Static information about a given repository identified by a unique `slug`.
+  # These data are loaded from config/repositories.yml
+  class Repository
+    include ActiveModel::Model
+    DEFAULTS = {
+      request_types: {},
+      contact_html: '',
+      location_html: '',
+      visit_note: nil
+    }.freeze
+
+    def initialize(attributes = {})
+      @attributes = DEFAULTS.merge(attributes).with_indifferent_access
+    end
+
+    attr_reader :attributes
+    attr_accessor :collection_count
+
+    def method_missing(field, *args, &block)
+      return attributes[field] if attributes.include?(field)
+
+      super
+    end
+
+    def respond_to_missing?(field, *args)
+      attributes.include?(field) || super
+    end
+
+    # rubocop:disable Rails/OutputSafety
+    def contact
+      contact_html.html_safe
+    end
+
+    def location
+      location_html.html_safe
+    end
+    # rubocop:enable Rails/OutputSafety
+
+    def request_config_present?
+      request_configs = request_types.values || []
+      request_configs.dig(0, 'request_url').present? &&
+        request_configs.dig(0, 'request_mappings').present?
+    end
+
+    def request_config_present_for_type?(type)
+      config = request_config_for_type(type)
+
+      config['request_url'].present? &&
+        config['request_mappings'].present?
+    end
+
+    def request_config_for_type(type)
+      request_types.fetch(type, {})
+    end
+
+    def available_request_types
+      return [] unless request_types.present?
+
+      request_types.keys
+    end
+
+    # Load repository information from a YAML file
+    #
+    # @param [String] `filename`
+    # @return [Hash<Slug,Repository>]
+    def self.from_yaml(file)
+      repos = {}
+      data = YAML.safe_load(File.read(file))
+      data.each_key do |slug|
+        repos[slug] = new(data[slug].merge(slug: slug))
+      end
+      repos
+    end
+
+    # Mimics ActiveRecord's `all` behavior
+    #
+    # @return [Array<Repository>]
+    def self.all(yaml_file = nil)
+      yaml_file = ENV['REPOSITORY_FILE'] || 'config/repositories.yml' if yaml_file.nil?
+      from_yaml(yaml_file).values
+    end
+
+    # Mimics ActiveRecord dynamic `find_by` behavior for the slug or name
+    #
+    # @param [String] `slug` or `name`
+    # @return [Repository]
+    def self.find_by(slug: nil, name: nil, yaml_file: nil)
+      if slug
+        all(yaml_file).find { |repo| repo.slug == slug }
+      elsif name
+        all(yaml_file).find { |repo| repo.name == name }
+      else
+        raise ArgumentError, 'Requires either slug or name parameters to find_by'
+      end
+    end
+
+    # Mimics ActiveRecord dynamic `find_by!` behavior for the slug or name
+    #
+    # @param [String] `slug` or `name` -- same as `find_by`
+    # @return [Repository]
+    # @raise [ActiveRecord::RecordNotFound] if cannot find repository
+    def self.find_by!(**kwargs)
+      repository = find_by(**kwargs)
+      raise ActiveRecord::RecordNotFound if repository.blank?
+
+      repository
+    end
+  end
+end

data/lib/arclight/routes/hierarchy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Arclight
+  module Routes
+    # Inject a hierarchy route for displaying the
+    # components in the collection context
+    class Hierarchy
+      def initialize(defaults = {})
+        @defaults = defaults
+      end
+
+      def call(mapper, _options = {})
+        mapper.member do
+          mapper.get 'hierarchy'
+        end
+      end
+    end
+  end
+end

data/lib/arclight/routes.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arclight
+  # Custom routes for Arclight
+  module Routes
+    require 'arclight/routes/hierarchy'
+  end
+end