cocina_display 1.1.3 → 1.2.0

data/lib/cocina_display/identifier.rb

@@ -0,0 +1,101 @@
+module CocinaDisplay
+  # An identifier for an object or a descriptive value.
+  class Identifier
+    attr_reader :cocina
+
+    # Source URI values for common identifiers
+    # If you have the bare ID, you can always add it to these to make a valid URL
+    SOURCE_URIS = {
+      "ORCID" => "https://orcid.org/",
+      "ROR" => "https://ror.org/",
+      "DOI" => "https://doi.org/",
+      "ISNI" => "https://isni.org/"
+    }.freeze
+
+    # Initialize an Identifier from Cocina structured data.
+    # @param cocina [Hash]
+    def initialize(cocina)
+      @cocina = cocina
+    end
+
+    # String representation of the identifier.
+    # Prefers the URI representation where present.
+    # @return [String]
+    def to_s
+      uri || value
+    end
+
+    def ==(other)
+      other.is_a?(Identifier) && other.cocina == cocina
+    end
+
+    # The raw value from the Cocina structured data.
+    # Prefers the URI representation where present.
+    # @return [String, nil]
+    def value
+      cocina["uri"].presence || cocina["value"].presence
+    end
+
+    # The "identifying" part of the identifier.
+    # Tries to parse from the end of the URI.
+    # @example DOI
+    #   10.1234/doi
+    # @return [String, nil]
+    def identifier
+      URI(value).path.delete_prefix("/") if value
+    end
+
+    # The identifier as a URI, if available.
+    # Tries to construct a URI if the parts are available to do so.
+    # @example DOI
+    #   https://doi.org/10.1234/doi
+    # @return [String, nil]
+    def uri
+      cocina["uri"].presence || ([scheme_uri.delete_suffix("/"), identifier].join("/") if scheme_uri && identifier)
+    end
+
+    # The type of the identifier, e.g. "DOI".
+    # @return [String, nil]
+    def type
+      ("DOI" if doi?) || cocina["type"].presence
+    end
+
+    # The declared encoding of the identifier, if any.
+    # @return [String, nil]
+    def code
+      cocina.dig("source", "code").presence
+    end
+
+    # The base URI used to resolve the identifier, if any.
+    # @example DOI
+    #  https://doi.org/
+    # @return [String, nil]
+    def scheme_uri
+      cocina.dig("source", "uri") || SOURCE_URIS[type]
+    end
+
+    # Label used to render the identifier for display.
+    # Uses a displayLabel if available, otherwise tries to look up via type.
+    # Falls back to a generic label for any unknown identifier types.
+    # @return [String]
+    def label
+      cocina["displayLabel"].presence ||
+        I18n.t(label_key, default: :identifier, scope: "cocina_display.field_label.identifier")
+    end
+
+    # Check if the identifier is a DOI.
+    # There are several indicators that could suggest this.
+    # @return [Boolean]
+    def doi?
+      cocina["type"]&.match?(/doi/i) || code == "doi" || cocina["uri"]&.include?("://doi.org")
+    end
+
+    private
+
+    # Key used for i18n lookup of the label, based on the type.
+    # @return [String, nil]
+    def label_key
+      type&.parameterize&.underscore
+    end
+  end
+end

data/lib/cocina_display/json_backed_record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CocinaDisplay
+  class JsonBackedRecord
+    # The parsed Cocina document.
+    # @return [Hash]
+    attr_reader :cocina_doc
+
+    # Initialize a CocinaRecord with a Cocina document hash.
+    # @param cocina_doc [Hash]
+    def initialize(cocina_doc)
+      @cocina_doc = cocina_doc
+    end
+
+    # Evaluate a JSONPath expression against the Cocina document.
+    # @return [Enumerator] An enumerator that yields results matching the expression.
+    # @param path_expression [String] The JSONPath expression to evaluate.
+    # @see https://www.rubydoc.info/gems/janeway-jsonpath/0.6.0/file/README.md
+    # @example Name values for contributors
+    #  record.path("$.description.contributor.*.name.*.value").search #=> ["Smith, John", "ACME Corp."]
+    # @example Filtering nodes using a condition
+    #  record.path("$.description.contributor[?(@.type == 'person')].name.*.value").search #=> ["Smith, John"]
+    def path(path_expression)
+      Janeway.enum_for(path_expression, cocina_doc)
+    end
+  end
+end

data/lib/cocina_display/language.rb

@@ -1,5 +1,4 @@
-require "iso639"
-require_relative "vocabularies/searchworks_languages"
+# frozen_string_literal: true
 
 module CocinaDisplay
   # A language associated with part or all of a Cocina object.
@@ -27,21 +26,20 @@ module CocinaDisplay
     # Decoded name of the language based on the code, if present.
     # @return [String, nil]
     def decoded_value
-      Vocabularies::SEARCHWORKS_LANGUAGES[code] || (Iso639[code] if iso_639?)
+      Vocabularies::SEARCHWORKS_LANGUAGES[code] if searchworks_language?
+    end
+
+    # Display label for this field.
+    # @return [String]
+    def label
+      cocina["displayLabel"].presence || I18n.t("cocina_display.field_label.language")
     end
 
     # True if the language is recognized by Searchworks.
     # @see CocinaDisplay::Vocabularies::SEARCHWORKS_LANGUAGES
     # @return [Boolean]
     def searchworks_language?
-      Vocabularies::SEARCHWORKS_LANGUAGES.value?(to_s)
-    end
-
-    # True if the language has a code sourced from the ISO 639 vocabulary.
-    # @see https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes
-    # @return [Boolean]
-    def iso_639?
-      cocina.dig("source", "code")&.start_with? "iso639"
+      Vocabularies::SEARCHWORKS_LANGUAGES.value?(cocina["value"]) || Vocabularies::SEARCHWORKS_LANGUAGES.key?(code)
     end
   end
 end

data/lib/cocina_display/license.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module CocinaDisplay
+  # A license associated with part or all of a Cocina object.
+  # This is the license entity used for translating a license URL into text
+  # for display.
+  class License
+    LICENSE_FILE_PATH = File.join(__dir__, "..", "..", "config", "licenses.yml").freeze
+
+    attr_reader :description, :uri
+
+    # Raised when the license provided is not valid
+    class LegacyLicenseError < StandardError; end
+
+    # A hash of license URLs to their description attributes
+    # @return [Hash{String => Hash{String => String}}]
+    def self.licenses
+      @licenses || YAML.safe_load(ERB.new(File.read(LICENSE_FILE_PATH)).result)
+    end
+
+    # Initialize a License from a license URL.
+    # @param url [String] The license URL.
+    # @raise [LegacyLicenseError] if the license URL is not in the config
+    def initialize(url:)
+      raise LegacyLicenseError unless License.licenses.key?(url)
+
+      attrs = License.licenses.fetch(url)
+      @uri = url
+      @description = attrs.fetch("description")
+    end
+  end
+end

data/lib/cocina_display/note.rb

@@ -0,0 +1,103 @@
+module CocinaDisplay
+  # A note associated with a cocina record
+  class Note
+    ABSTRACT_TYPES = ["summary", "abstract", "scope and content"].freeze
+    ABSTRACT_DISPLAY_LABEL_REGEX = /Abstract|Summary|Scope and content/i
+    PREFERRED_CITATION_TYPES = ["preferred citation"].freeze
+    PREFERRED_CITATION_DISPLAY_LABEL_REGEX = /Preferred citation/i
+    TOC_TYPES = ["table of contents"].freeze
+    TOC_DISPLAY_LABEL_REGEX = /Table of contents/i
+
+    attr_reader :cocina
+
+    # Initialize a Note from Cocina structured data.
+    # @param cocina [Hash]
+    def initialize(cocina)
+      @cocina = cocina
+    end
+
+    # String representation of the note.
+    # @return [String, nil]
+    def to_s
+      Utils.compact_and_join(values, delimiter: " -- ").presence
+    end
+
+    # The raw values from the Cocina data, flattened if nested.
+    # @return [String]
+    def values
+      Utils.flatten_nested_values(cocina).pluck("value").compact_blank
+    end
+
+    # The raw values from the Cocina data as a hash with type as key.
+    # @return [Hash{String => String}]
+    def values_by_type
+      Utils.flatten_nested_values(cocina).each_with_object({}) do |node, hash|
+        type = node["type"]
+        hash[type] ||= []
+        hash[type] << node["value"]
+      end
+    end
+
+    # The type of the note, e.g. "abstract".
+    # @return [String, nil]
+    def type
+      cocina["type"].presence
+    end
+
+    # The display label set in Cocina
+    # @return [String, nil]
+    def display_label
+      cocina["displayLabel"].presence
+    end
+
+    # Label used to render the note for display.
+    # Uses a displayLabel if available, otherwise tries to look up via type.
+    # Falls back to a default label derived from the type or a generic note label if
+    # no type is set.
+    # @return [String]
+    def label
+      display_label ||
+        I18n.t(type&.parameterize&.underscore, default: default_label, scope: "cocina_display.field_label.note")
+    end
+
+    # Check if the note is an abstract
+    # @return [Boolean]
+    def abstract?
+      display_label&.match?(ABSTRACT_DISPLAY_LABEL_REGEX) ||
+        ABSTRACT_TYPES.include?(type)
+    end
+
+    # Check if the note is a general note (not a table of contents, abstract, preferred citation, or part)
+    # @return [Boolean]
+    def general_note?
+      !table_of_contents? && !abstract? && !preferred_citation? && !part?
+    end
+
+    # Check if the note is a preferred citation
+    # @return [Boolean]
+    def preferred_citation?
+      display_label&.match?(PREFERRED_CITATION_DISPLAY_LABEL_REGEX) ||
+        PREFERRED_CITATION_TYPES.include?(type)
+    end
+
+    # Check if the note is a table of contents
+    # @return [Boolean]
+    def table_of_contents?
+      display_label&.match?(TOC_DISPLAY_LABEL_REGEX) ||
+        TOC_TYPES.include?(type)
+    end
+
+    # Check if the note is a part note
+    # @note These are combined with the title and not displayed separately.
+    # @return [Boolean]
+    def part?
+      type == "part"
+    end
+
+    private
+
+    def default_label
+      type&.capitalize || I18n.t("cocina_display.field_label.note.note")
+    end
+  end
+end

data/lib/cocina_display/related_resource.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module CocinaDisplay
+  # A resource related to the record. See https://github.com/sul-dlss/cocina-models/blob/main/lib/cocina/models/related_resource.rb
+  # @note Related resources have no structural metadata.
+  class RelatedResource < JsonBackedRecord
+    include CocinaDisplay::Concerns::Accesses
+    include CocinaDisplay::Concerns::Events
+    include CocinaDisplay::Concerns::Contributors
+    include CocinaDisplay::Concerns::Identifiers
+    include CocinaDisplay::Concerns::Notes
+    include CocinaDisplay::Concerns::Titles
+    include CocinaDisplay::Concerns::UrlHelpers
+    include CocinaDisplay::Concerns::Subjects
+    include CocinaDisplay::Concerns::Forms
+    include CocinaDisplay::Concerns::Languages
+    include CocinaDisplay::Concerns::Geospatial
+
+    # Description of the relation to the source record.
+    # @return [String]
+    # @example "is part of"
+    # @see https://github.com/sul-dlss/cocina-models/blob/main/docs/description_types.md#relatedresource-types
+    attr_reader :type
+
+    # Restructure the hash so that everything is under "description" key, since
+    # it's all descriptive metadata. This makes most CocinaRecord methods work.
+    def initialize(cocina_doc)
+      @type = cocina_doc["type"]
+      super({"description" => cocina_doc.except("type")})
+    end
+
+    # Label used to group the related resource for display.
+    # @return [String]
+    def label
+      cocina_doc.dig("description", "displayLabel").presence || type_label
+    end
+
+    # String representation of the related resource.
+    # @return [String, nil]
+    def to_s
+      main_title || url
+    end
+
+    # URL to the related resource for link construction.
+    # If there are multiple URLs, uses the first.
+    # @return [String, nil]
+    def url
+      urls.first&.to_s || purl_url
+    end
+
+    # Is this a related resource with a URL?
+    # @return [Boolean]
+    def url?
+      url.present?
+    end
+
+    # Nested display data for the related resource.
+    # Combines titles, contributors, notes, and access information.
+    # @note Used for extended display of citations, e.g. on hp566jq8781.
+    # @return [Array<DisplayData>]
+    def display_data
+      title_display_data + contributor_display_data + general_note_display_data + preferred_citation_display_data + access_display_data
+    end
+
+    private
+
+    # Key used for i18n lookup of the label, based on the type.
+    # Falls back to a generic label for any unknown types.
+    # @return [String]
+    def type_label
+      I18n.t(type&.parameterize&.underscore, default: :related_to, scope: "cocina_display.field_label.related_resource")
+    end
+  end
+end

data/lib/cocina_display/subjects/subject.rb

@@ -1,6 +1,3 @@
-require_relative "../utils"
-require_relative "subject_value"
-
 module CocinaDisplay
   module Subjects
     # Base class for subjects in Cocina structured data.
@@ -27,23 +24,49 @@ module CocinaDisplay
         subject_values.map(&:to_s).compact_blank
       end
 
-      # A string representation of the entire subject, concatenated for display.
+      # The value to use for display.
+      # Genre values are capitalized; other subject values are not.
       # @return [String]
       def to_s
+        (type == "genre") ? display_value&.upcase_first : display_value
+      end
+
+      # A string representation of the entire subject, concatenated for display.
+      # @return [String]
+      def display_value
         Utils.compact_and_join(display_values, delimiter: " > ")
       end
 
+      # Label used to render the subject for display.
+      # Uses a displayLabel if available, otherwise looks up via type.
+      # @return [String]
+      def label
+        cocina["displayLabel"].presence || type_label
+      end
+
       # Individual values composing this subject.
       # Can be multiple if the Cocina featured nested data.
-      # If no type was specified on a value, uses the top-level subject type.
+      # All SubjectValues inherit the type of their parent Subject.
       # @return [Array<SubjectValue>]
       def subject_values
-        @subject_values ||= Utils.flatten_nested_values(cocina, atomic_types: SubjectValue.atomic_types).map do |value|
-          subject_value = SubjectValue.from_cocina(value)
-          subject_value.type ||= type
-          subject_value
+        @subject_values ||= (Array(cocina["parallelValue"]).presence || [cocina]).flat_map do |node|
+          if SubjectValue.atomic_types.include?(type)
+            SubjectValue.from_cocina(node, type: type)
+          else
+            Utils.flatten_nested_values(node, atomic_types: SubjectValue.atomic_types).flat_map do |value|
+              SubjectValue.from_cocina(value, type: value["type"] || type)
+            end
+          end
         end
       end
+
+      private
+
+      # Type-specific label for this subject.
+      # @return [String]
+      def type_label
+        I18n.t(type&.parameterize&.underscore, default: :subject, scope: "cocina_display.field_label.subject")
+      end
     end
   end
 end

data/lib/cocina_display/subjects/subject_value.rb

@@ -1,11 +1,3 @@
-require "geo/coord"
-
-require_relative "subject"
-require_relative "../contributors/name"
-require_relative "../title_builder"
-require_relative "../dates/date"
-require_relative "../geospatial"
-
 module CocinaDisplay
   module Subjects
     # A descriptive value that can be part of a Subject.
@@ -16,11 +8,29 @@ module CocinaDisplay
       # @see https://github.com/sul-dlss/cocina-models/blob/main/docs/description_types.md#subject-part-types-for-structured-value
       attr_accessor :type
 
-      # Create a SubjectValue from Cocina structured data.
+      # Create SubjectValues from Cocina structured data.
+      # Pre-coordinated string values will be split into multiple SubjectValues.
       # @param cocina [Hash] The Cocina structured data for the subject.
-      # @return [SubjectValue]
-      def self.from_cocina(cocina)
-        SUBJECT_VALUE_TYPES.fetch(cocina["type"], SubjectValue).new(cocina)
+      # @param type [String, nil] The type, coming from the parent Subject.
+      # @return [Array<SubjectValue>]
+      def self.from_cocina(cocina, type:)
+        split_pre_coordinated_values(cocina, type: type).map do |value|
+          SUBJECT_VALUE_TYPES.fetch(type, SubjectValue).new(value).tap do |obj|
+            obj.type ||= type
+          end
+        end
+      end
+
+      # Split a pre-coordinated subject value joined with "--" into multiple values.
+      # Ignores the "--" string for coordinate subject types, which use it differently.
+      # @param cocina [Hash] The Cocina structured data for the subject.
+      # @return [Array<Hash>] An array of Cocina hashes, one for each split value
+      def self.split_pre_coordinated_values(cocina, type:)
+        if cocina["value"].is_a?(String) && cocina["value"].include?("--") && !type.include?("coordinates")
+          cocina["value"].split("--").map { |v| cocina.merge("value" => v.strip) }
+        else
+          [cocina]
+        end
       end
 
       # All subject value types that should not be further destructured.
@@ -65,12 +75,20 @@ module CocinaDisplay
 
     # A subject value representing an entity with a title.
     class TitleSubjectValue < SubjectValue
+      attr_reader :title
+
+      # Initialize a TitleSubjectValue object with Cocina structured data.
+      # @param cocina [Hash] The Cocina structured data for the subject.
+      def initialize(cocina)
+        super
+        @title = Title.new(cocina)
+      end
+
       # Construct a title string to use for display.
-      # @see CocinaDisplay::TitleBuilder.build
-      # @note Unclear how often structured title subjects occur "in the wild".
-      # @return [String]
+      # @see CocinaDisplay::Title#to_s
+      # @return [String, nil]
       def to_s
-        TitleBuilder.build([cocina])
+        title.to_s
       end
     end