arclight 0.0.1 → 0.1.0

data/lib/arclight/normalized_date.rb

@@ -0,0 +1,45 @@
+# 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 [String] `bulk` from the `unitdate`
+    # @param [String] `other` from the `unitdate` when type is not specified
+    def initialize(inclusive, bulk = nil, other = nil)
+      if inclusive.is_a? Array # of YYYY-YYYY for ranges
+        @inclusive = YearRange.new(inclusive.include?('/') ? inclusive : inclusive.map { |v| v.tr('-', '/') }).to_s
+      elsif inclusive.present?
+        @inclusive = inclusive.strip
+      end
+      @bulk = bulk.strip if bulk.present?
+      @other = other.strip if other.present?
+    end
+
+    # @return [String] the normalized title/date
+    def to_s
+      normalize
+    end
+
+    private
+
+    attr_reader :inclusive, :bulk, :other
+
+    # @see http://www2.archivists.org/standards/DACS/part_I/chapter_2/4_date for rules
+    def normalize
+      if inclusive.present?
+        result = inclusive.to_s
+        result << ", bulk #{bulk}" if bulk.present?
+      elsif other.present?
+        result = other.to_s
+      else
+        result = nil
+      end
+      return if result.blank?
+      result.strip
+    end
+  end
+end

data/lib/arclight/normalized_id.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # A simple utility class to normalize identifiers
+  # to be used around the application for linking
+  class NormalizedId
+    def initialize(id)
+      @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,30 @@
+# frozen_string_literal: true
+
+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,91 @@
+# frozen_string_literal: true
+
+module Arclight
+  #
+  # Static information about a given repository identified by a unique `slug`
+  #
+  class Repository
+    include ActiveModel::Conversion # for to_partial_path
+
+    FIELDS = %i[name
+                description
+                visit_note
+                building
+                address1
+                address2
+                city
+                state
+                zip
+                country
+                phone
+                contact_info
+                thumbnail_url
+                google_request_url
+                google_request_mappings
+                collection_count].freeze
+
+    attr_accessor :slug, *FIELDS
+
+    # @param [String] `slug` the unique identifier for the repository
+    # @param [Hash] `data`
+    def initialize(slug, data = {})
+      @slug = slug
+      FIELDS.each do |field|
+        value = data[field.to_s]
+        send("#{field}=", value) if value.present?
+      end
+    end
+
+    # @return [String] handles the formatting of "city, state zip, country"
+    def city_state_zip_country
+      state_zip = state
+      state_zip += " #{zip}" if zip
+      [city, state_zip, country].compact.join(', ')
+    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.keys.each do |slug|
+        repos[slug] = new(slug, data[slug])
+      end
+      repos
+    end
+
+    # Mimics ActiveRecord's `all` behavior
+    #
+    # @return [Array<Repository>]
+    def self.all
+      from_yaml(ENV['REPOSITORY_FILE'] || 'config/repositories.yml').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)
+      if slug
+        all.find { |repo| repo.slug == slug }
+      elsif name
+        all.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!(*args)
+      repository = find_by(*args)
+      raise ActiveRecord::RecordNotFound if repository.blank?
+      repository
+    end
+  end
+end

data/lib/arclight/shared_indexing_behavior.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # A mixin intended to share indexing behavior between
+  # the CustomDocument and CustomComponent classes
+  module SharedIndexingBehavior
+    # @see http://eadiva.com/2/unitdate/
+    # @return [YearRange] all of the years between the given years
+    def unitdate_for_range
+      range = YearRange.new
+      return range if normal_unit_dates.blank?
+      range << range.parse_ranges(normal_unit_dates)
+      range
+    end
+
+    def subjects_array(elements, parent:)
+      xpath_elements = elements.map { |el| "local-name()='#{el}'" }.join(' or ')
+      subjects = search("//#{parent}/controlaccess/*[#{xpath_elements}]").to_a
+      clean_facets_array(subjects.flatten.map(&:text))
+    end
+
+    def names_array(elements, parent:)
+      xpath_elements = elements.map { |el| "local-name()='#{el}'" }.join(' or ')
+      names = search("//#{parent}/controlaccess/*[#{xpath_elements}]").to_a
+      clean_facets_array(names.flatten.map(&:text))
+    end
+
+    # Return a cleaned array of facets without marc subfields
+    #
+    # E.g. clean_facets_array(
+    #        ['FacetValue1 |z FacetValue2','FacetValue3']
+    #      ) => ['FacetValue1 -- FacetValue2', 'FacetValue3']
+    def clean_facets_array(facets_array)
+      Array(facets_array).map { |text| fix_subfield_demarcators(text) }.compact.uniq
+    end
+
+    # Replace MARC style subfield demarcators
+    #
+    # Usage: fix_subfield_demarcators("Subject 1 |z Sub-Subject 2") => "Subject 1 -- Sub-Subject 2"
+    def fix_subfield_demarcators(value)
+      value.gsub(/\|\w{1}/, '--')
+    end
+
+    # Wrap OM's find_by_xpath for convenience
+    def search(path)
+      find_by_xpath(path) # rubocop:disable DynamicFindBy
+    end
+
+    # If a repository slug is provided via an environment variable `REPOSITORY_ID`,
+    # then use that to lookup the name rather than the parsed out name from the EAD
+    # @param [String] `repository` the default repository name
+    def repository_as_configured(repository)
+      slug = ENV['REPOSITORY_ID']
+      if slug.present?
+        begin
+          Arclight::Repository.find_by(slug: slug).name
+        rescue => e
+          raise "The repository slug '#{slug}' was given but it is not found in the Repository configuration data: #{e}"
+        end
+      else
+        repository
+      end
+    end
+
+    def add_digital_content(prefix:, solr_doc:)
+      dao = ng_xml.xpath("#{prefix}/dao").to_a
+      return if dao.blank?
+      field_name = Solrizer.solr_name('digital_objects', :displayable)
+      solr_doc[field_name] = digital_objects(dao)
+    end
+
+    def digital_objects(objects)
+      objects.map do |dao|
+        label = dao.attributes['title'].try(:value) || dao.xpath('daodesc/p').try(:text)
+        href = (dao.attributes['href'] || dao.attributes['xlink:href']).try(:value)
+        Arclight::DigitalObject.new(label: label, href: href).to_json
+      end
+    end
+
+    def add_date_ranges(solr_doc)
+      Solrizer.insert_field(solr_doc, 'date_range', unitdate_for_range.years, :facetable)
+    end
+
+    def add_normalized_title(solr_doc)
+      dates = Arclight::NormalizedDate.new(unitdate_inclusive.first, unitdate_bulk.first, unitdate_other.first).to_s
+      title = Arclight::NormalizedTitle.new(solr_doc['title_ssm'].try(:first), dates).to_s
+      solr_doc['normalized_title_ssm'] = [title]
+      solr_doc['normalized_date_ssm'] = [dates]
+      title
+    end
+
+    def online_content?
+      search('//dao[@href]').present?
+    end
+  end
+end

data/lib/arclight/shared_terminology_behavior.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # An extendable mixin intended to share terminology behavior between
+  # the CustomDocument and CustomComponent classes
+  module SharedTerminologyBehavior
+    def add_unitid(t, prefix)
+      t.unitid(path: prefix + 'did/unitid', index_as: %i[displayable searchable])
+    end
+
+    def add_extent(t, prefix)
+      t.extent(path: prefix + 'did/physdesc/extent', index_as: %i[displayable searchable])
+    end
+
+    # date indexing
+    def add_dates(t, prefix)
+      t.normal_unit_dates(path: prefix + 'did/unitdate/@normal')
+      t.unitdate_bulk(path: prefix + 'did/unitdate[@type=\'bulk\']', index_as: %i[displayable])
+      t.unitdate_inclusive(path: prefix + 'did/unitdate[@type=\'inclusive\']', index_as: %i[displayable])
+      t.unitdate_other(path: prefix + 'did/unitdate[not(@type)]', index_as: %i[displayable])
+      t.unitdate(path: prefix + 'did/unitdate', index_as: %i[displayable])
+    end
+
+    def add_searchable_notes(t, prefix) # rubocop: disable Metrics/MethodLength
+      # various searchable notes
+      %i[
+        accessrestrict
+        accruals
+        acqinfo
+        altformavail
+        appraisal
+        arrangement
+        bibliography
+        bioghist
+        custodhist
+        fileplan
+        note
+        odd
+        originalsloc
+        otherfindaid
+        phystech
+        prefercite
+        processinfo
+        relatedmaterial
+        scopecontent
+        separatedmaterial
+        userestrict
+      ].each do |k|
+        # many of the notes support various markup so we want everything but the heading
+        t.send(k, path: "#{prefix}#{k}/*[local-name()!=\"head\"]", index_as: %i[displayable searchable])
+      end
+
+      # various searchable notes in the did
+      %i[
+        abstract
+        materialspec
+        physloc
+      ].each do |k|
+        t.send(k, path: "#{prefix}did/#{k}", index_as: %i[displayable searchable])
+      end
+      t.did_note(path: "#{prefix}did/note", index_as: %i[displayable searchable]) # conflicts with top-level note
+    end
+  end
+end

data/lib/arclight/solr_ead_indexer_ext.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Arclight
+  ##
+  # An module to extend SolrEad::Indexer behaviors to allow us to add
+  # or override behaviors that require knowledge of the entire XML document.
+  module SolrEadIndexerExt
+    def additional_component_fields(node, addl_fields = {})
+      solr_doc = super
+
+      add_count_of_child_compontents(node, solr_doc)
+      add_ancestral_titles(node, solr_doc)
+      add_ancestral_ids(node, solr_doc)
+
+      add_collection_creator_to_component(node, solr_doc)
+
+      add_self_or_parents_restrictions(node, solr_doc)
+
+      add_self_or_parents_terms(node, solr_doc)
+
+      solr_doc
+    end
+
+    def delete_all
+      solr.delete_by_query('*:*')
+      solr.commit
+    end
+
+    private
+
+    # Note that we need to redo what solr_ead does for ids due to our normalization process
+    def add_ancestral_ids(node, solr_doc)
+      @parent_id_name ||= Solrizer.solr_name('parent', :stored_sortable)
+      @parent_ids_field_name ||= Solrizer.solr_name('parent', :displayable)
+      @parent_ids_search_field_name ||= Solrizer.solr_name('parent', :searchable)
+
+      ids = ancestral_ids(node)
+      solr_doc[@parent_ids_field_name] = ids
+      solr_doc[@parent_ids_search_field_name] = ids
+      solr_doc[@parent_id_name] = ids.last
+    end
+
+    # Note that we need to redo what solr_ead does for titles due to our normalization process
+    def add_ancestral_titles(node, solr_doc)
+      @parent_titles_field_name ||= Solrizer.solr_name('parent_unittitles', :displayable)
+      @parent_titles_search_field_name ||= Solrizer.solr_name('parent_unittitles', :searchable)
+      @collection_facet_name ||= Solrizer.solr_name('collection', :facetable)
+      @collection_name ||= Solrizer.solr_name('collection', :displayable)
+
+      titles = ancestral_titles(node)
+      solr_doc[@parent_titles_field_name] = titles
+      solr_doc[@parent_titles_search_field_name] = titles
+      solr_doc[@collection_name] = [titles.first] # collection is always on top
+      solr_doc[@collection_facet_name] = [titles.first]
+    end
+
+    def add_count_of_child_compontents(node, solr_doc)
+      @child_component_count_name ||= Solrizer.solr_name('child_component_count', type: :integer)
+
+      solr_doc[@child_component_count_name] = node.xpath('count(c)').to_i
+    end
+
+    def ancestral_ids(node)
+      ancestral_visit(node, :normalized_component_id, :normalized_collection_id)
+    end
+
+    def ancestral_titles(node)
+      ancestral_visit(node, :normalized_component_title, :normalized_collection_title)
+    end
+
+    # visit each component's parent and finish with a visit on the collection
+    def ancestral_visit(node, component_fn, collection_fn, results = [])
+      while node.parent && node.parent.name == 'c'
+        parent = node.parent
+        results << send(component_fn, parent)
+        node = parent
+      end
+      results << send(collection_fn, node)
+      results.reverse
+    end
+
+    def normalized_component_title(node)
+      data = extract_title_and_dates(node)
+      normalize_title(data)
+    end
+
+    def normalized_collection_title(node)
+      data = extract_title_and_dates(node, '//archdesc/')
+      normalize_title(data)
+    end
+
+    def normalize_title(data)
+      Arclight::NormalizedTitle.new(
+        data[:title],
+        Arclight::NormalizedDate.new(
+          data[:unitdate_inclusive],
+          data[:unitdate_bulk],
+          data[:unitdate_other]
+        ).to_s
+      ).to_s
+    end
+
+    # TODO: these xpaths should be DRY'd up -- they're in both terminologies
+    def extract_title_and_dates(node, prefix = nil)
+      data = {
+        title:              node.at_xpath("#{prefix}did/unittitle"),
+        unitdate_inclusive: node.at_xpath("#{prefix}did/unitdate[@type=\"inclusive\"]"),
+        unitdate_bulk:      node.at_xpath("#{prefix}did/unitdate[@type=\"bulk\"]"),
+        unitdate_other:     node.at_xpath("#{prefix}did/unitdate[not(@type)]")
+      }
+      data.each do |k, v|
+        data[k] = v.text if v
+      end
+      data
+    end
+
+    def normalized_component_id(node)
+      Arclight::NormalizedId.new(node['id'].to_s).to_s
+    end
+
+    def normalized_collection_id(node)
+      Arclight::NormalizedId.new(node.document.at_xpath('//eadid').text).to_s
+    end
+
+    # This mimics similar behavior in Arclight::CustomDocument
+    def add_collection_creator_to_component(node, solr_doc)
+      field_name = Solrizer.solr_name('collection_creator', :displayable)
+      repository = solr_doc[Solrizer.solr_name('repository', :displayable)]
+      creators = node.xpath('//archdesc/did/origination[@label="creator"]/*/text()').map(&:text)
+      solr_doc[field_name] = creators - [repository]
+    end
+
+    def parent_check_list(node, root_path, element_path, results = [])
+      orginal_node = node
+      results = node.xpath("#{root_path}/#{element_path}").map(&:text)
+      # if current restriction return, else go up to parent and check
+      while node.parent.name == 'c' && results.blank?
+        parent = node.parent
+        results = parent.xpath("#{root_path}/#{element_path}").map(&:text)
+        node = parent
+      end
+      # If no parental results, check the collection
+      results = orginal_node.xpath("//archdesc/#{element_path}").map(&:text) if results.blank?
+      results.flatten # can't use with flatten! because that returns nil
+    end
+
+    def add_self_or_parents_restrictions(node, solr_doc)
+      field_name = Solrizer.solr_name('parent_access_restrict', :displayable)
+      solr_doc[field_name] = parent_check_list(node, './', 'accessrestrict/p/text()')
+      solr_doc[field_name]
+    end
+
+    def add_self_or_parents_terms(node, solr_doc)
+      field_name = Solrizer.solr_name('parent_access_terms', :displayable)
+      solr_doc[field_name] = parent_check_list(node, './', 'userestrict/p/text()')
+      solr_doc[field_name]
+    end
+  end
+end