cocina_display 1.1.3 → 1.2.1

data/lib/cocina_display/display_data.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module CocinaDisplay
+  # A data structure to be rendered into HTML by the consumer.
+  class DisplayData
+    class << self
+      # Given objects that support #to_s and #label, group them into {DisplayData}.
+      # Groups by each object's +label+ and keeps unique, non-blank values.
+      # @param objects [Array<Object>]
+      # @return [Array<DisplayData>]
+      def from_objects(objects)
+        objects.group_by(&:label)
+          .map { |label, objs| new(label: label, objects: objs) }
+          .reject { |data| data.values.empty? }
+      end
+
+      # Given an array of Cocina hashes, group them into {DisplayData}.
+      # Uses +label+ as the label if provided, but honors +displayLabel+ if set.
+      # Keeps the unique, non-blank values under each label.
+      # @param cocina [Array<Hash>]
+      # @param label [String]
+      # @return [Array<DisplayData>]
+      def from_cocina(cocina, label: nil)
+        from_objects(descriptive_values_from_cocina(cocina, label: label))
+      end
+
+      # Create display data from string values.
+      # @param value [String] The string values to display
+      # @param label [String] The label for the display data
+      # @return [Array<DisplayData>] The display data
+      def from_strings(values, label: nil)
+        from_objects(descriptive_values_from_strings(values, label: label))
+      end
+
+      # Create an array containing a descriptive object from string values.
+      # Can be used to combine a string derived value with other metadata objects.
+      # @param strings [Array<String>] The string values to display
+      # @param label [String] The label for the display data
+      # @return [Array<DescriptiveValue>] The descriptive values
+      def descriptive_values_from_strings(strings, label: nil)
+        strings.map { |string| DescriptiveValue.new(label: label, value: string) }
+      end
+
+      # Take one or several DisplayData and merge into a single hash.
+      # Keys are labels; values are the merged array of values for that label.
+      # @param display_data [DisplayData, Array<DisplayData>]
+      # @return [Hash{String => Array<String>}] The merged hash
+      def to_hash(display_data)
+        Array(display_data).map(&:to_h).reduce(:merge)
+      end
+
+      private
+
+      # Wrap Cocina nodes into {DescriptiveValue} so they are labelled.
+      # Uses +displayLabel+ from the node if present, otherwise uses the provided label.
+      # @param cocina [Array<Hash>]
+      # @param label [String]
+      # @return [Array<DescriptiveValue>]
+      def descriptive_values_from_cocina(cocina, label: nil)
+        cocina.map { |node| DescriptiveValue.new(label: node["displayLabel"] || label, value: node["value"]) }
+      end
+
+      # Wrapper to make Cocina descriptive values respond to #to_s and #label.
+      # @attr [String] label
+      # @attr [String] value
+      DescriptiveValue = Data.define(:label, :value) do
+        def to_s
+          value
+        end
+      end
+    end
+
+    # Create a DisplayData object from a list of objects that share a label
+    # @param label [String]
+    # @param objects [Array<#to_s>]
+    def initialize(label:, objects:)
+      @label = label
+      @objects = objects
+    end
+
+    attr_reader :label, :objects
+
+    # The unique, non-blank values for display
+    # @return [Array<String>]
+    def values
+      objects.flat_map { |object| split_string_on_newlines(object.to_s) }.compact_blank.uniq
+    end
+
+    # Express the display data as a hash mapping the label to its values.
+    # @return [Hash{String => Array<String>}] The label and values
+    def to_h
+      {label => values}
+    end
+
+    private
+
+    # Split a string on newlines (including HTML-encoded newlines) and strip whitespace.
+    # @param string [String] The string to split
+    # @return [Array<String>]
+    def split_string_on_newlines(string)
+      string&.gsub("&#10;", "\n")&.split("\n")&.map(&:strip)
+    end
+  end
+end

data/lib/cocina_display/events/event.rb

@@ -1,7 +1,3 @@
-require_relative "location"
-require_relative "../dates/date"
-require_relative "../contributors/contributor"
-
 module CocinaDisplay
   module Events
     # An event associated with an object, like publication.
@@ -73,6 +69,14 @@ module CocinaDisplay
           CocinaDisplay::Events::Location.new(location)
         end
       end
+
+      # All notes associated with this event.
+      # @return [Array<CocinaDisplay::Events::Note>]
+      def notes
+        @notes ||= Array(cocina["note"]).map do |note|
+          CocinaDisplay::Events::Note.new(note)
+        end
+      end
     end
   end
 end

data/lib/cocina_display/events/imprint.rb

@@ -1,15 +1,5 @@
 # frozen_string_literal: true
 
-require "edtf"
-require "active_support"
-require "active_support/core_ext/enumerable"
-require "active_support/core_ext/object/blank"
-
-require_relative "event"
-require_relative "../utils"
-require_relative "../dates/date"
-require_relative "../dates/date_range"
-
 module CocinaDisplay
   module Events
     # Wrapper for Cocina events used to generate an imprint statement for display.

data/lib/cocina_display/events/location.rb

@@ -1,11 +1,17 @@
-require_relative "../vocabularies/marc_country_codes"
-
 module CocinaDisplay
   module Events
     # A single location represented in a Cocina event, like a publication place.
     class Location
+      MARC_COUNTRIES_FILE_PATH = CocinaDisplay.root / "config" / "marc_countries.yml"
+
       attr_reader :cocina
 
+      # A hash mapping MARC country codes to their names.
+      # @return [Hash{String => String}]
+      def self.marc_countries
+        @marc_countries ||= YAML.safe_load_file(MARC_COUNTRIES_FILE_PATH)
+      end
+
       # Initialize a Location object with Cocina structured data.
       # @param cocina [Hash] The Cocina structured data for the location.
       def initialize(cocina)
@@ -36,7 +42,7 @@ module CocinaDisplay
       # Decoded country name if the location is encoded with a MARC country code.
       # @return [String, nil]
       def decoded_country
-        Vocabularies::MARC_COUNTRY[code] if marc_country? && valid_country_code?
+        Location.marc_countries[code] if marc_country? && valid_country_code?
       end
 
       # Is this a decodable country code?

data/lib/cocina_display/events/note.rb

@@ -0,0 +1,33 @@
+module CocinaDisplay
+  module Events
+    # A single note represented in a Cocina event, like an issuance or edition note.
+    class Note
+      attr_reader :cocina
+
+      # Initialize a Note object with Cocina structured data.
+      # @param cocina [Hash] The Cocina structured data for the note.
+      def initialize(cocina)
+        @cocina = cocina
+      end
+
+      # The value of the note.
+      # @return [String, nil]
+      def to_s
+        cocina["value"].presence
+      end
+
+      # The type of the note, like "issuance" or "edition".
+      # @return [String, nil]
+      def type
+        cocina["type"].presence
+      end
+
+      # The display label for the note.
+      # @return [String]
+      def label
+        cocina["displayLabel"].presence ||
+          I18n.t(type&.parameterize&.underscore, default: :default, scope: "cocina_display.field_label.event.note")
+      end
+    end
+  end
+end

data/lib/cocina_display/forms/form.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module CocinaDisplay
+  # Classes for extracting format/genre information from a Cocina object.
+  module Forms
+    # A form associated with part or all of a Cocina object.
+    class Form
+      attr_reader :cocina
+
+      # Create a Form object from Cocina structured data.
+      # Delegates to subclasses for specific types.
+      # @param cocina [Hash]
+      # @return [Form]
+      def self.from_cocina(cocina)
+        case cocina["type"]
+        when "genre"
+          Genre.new(cocina)
+        when "resource type"
+          ResourceType.new(cocina)
+        else
+          new(cocina)
+        end
+      end
+
+      # Create a Form object from Cocina structured data.
+      # @param cocina [Hash]
+      def initialize(cocina)
+        @cocina = cocina
+      end
+
+      # The value to use for display.
+      # @return [String]
+      def to_s
+        flat_value
+      end
+
+      # Single concatenated string value for the form.
+      # @return [String]
+      def flat_value
+        Utils.compact_and_join(values, delimiter: " > ")
+      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 label to use for display.
+      # Uses a displayLabel if available, otherwise looks up via type.
+      # @return [String]
+      def label
+        cocina["displayLabel"].presence || type_label
+      end
+
+      # The type of form, such as "genre", "extent", etc.
+      # @return [String, nil]
+      def type
+        cocina["type"]
+      end
+
+      private
+
+      # Type-specific label for this form value.
+      # @return [String]
+      def type_label
+        I18n.t(type&.parameterize&.underscore, default: :form, scope: "cocina_display.field_label.form")
+      end
+    end
+  end
+end

data/lib/cocina_display/forms/genre.rb

@@ -0,0 +1,12 @@
+module CocinaDisplay
+  module Forms
+    # A Genre form associated with part or all of a Cocina object.
+    class Genre < Form
+      # Genres are capitalized for display.
+      # @return [String]
+      def to_s
+        super&.upcase_first
+      end
+    end
+  end
+end

data/lib/cocina_display/forms/resource_type.rb

@@ -0,0 +1,38 @@
+module CocinaDisplay
+  module Forms
+    # A Resource Type form associated with part or all of a Cocina object.
+    class ResourceType < Form
+      # Resource types are lowercased for display.
+      # @return [String]
+      def to_s
+        super&.downcase
+      end
+
+      # Is this a Stanford self-deposit resource type?
+      # @note These are handled separately when displayed.
+      # @return [Boolean]
+      def stanford_self_deposit?
+        source == "Stanford self-deposit resource types"
+      end
+
+      # Is this a MODS resource type?
+      # @return [Boolean]
+      def mods?
+        source == "MODS resource types"
+      end
+
+      private
+
+      # @return [String]
+      def source
+        cocina.dig("source", "value")
+      end
+
+      # Stanford self-deposit resource types are labeled "Genre".
+      # @return [String]
+      def type_label
+        (I18n.t("cocina_display.field_label.form.genre") if stanford_self_deposit?) || super
+      end
+    end
+  end
+end

data/lib/cocina_display/geospatial.rb

@@ -1,4 +1,4 @@
-require "geo/coord"
+# frozen_string_literal: true
 
 module CocinaDisplay
   module Geospatial

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,11 +1,18 @@
-require "iso639"
-require_relative "vocabularies/searchworks_languages"
+# frozen_string_literal: true
 
 module CocinaDisplay
   # A language associated with part or all of a Cocina object.
   class Language
+    SEARCHWORKS_LANGUAGES_FILE_PATH = CocinaDisplay.root / "config" / "searchworks_languages.yml"
+
     attr_reader :cocina
 
+    # A hash of language codes to language names recognized by Searchworks.
+    # @return [Hash{String => String}]
+    def self.searchworks_languages
+      @searchworks_languages ||= YAML.safe_load_file(SEARCHWORKS_LANGUAGES_FILE_PATH)
+    end
+
     # Create a Language object from Cocina structured data.
     # @param cocina [Hash]
     def initialize(cocina)
@@ -27,21 +34,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?)
+      Language.searchworks_languages[code] if searchworks_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)
+    # Display label for this field.
+    # @return [String]
+    def label
+      cocina["displayLabel"].presence || I18n.t("cocina_display.field_label.language")
     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
+    # True if the language is recognized by Searchworks.
+    # @see CocinaDisplay::Language.searchworks_languages
     # @return [Boolean]
-    def iso_639?
-      cocina.dig("source", "code")&.start_with? "iso639"
+    def searchworks_language?
+      Language.searchworks_languages.value?(cocina["value"]) || Language.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 = CocinaDisplay.root / "config" / "licenses.yml"
+
+    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_file(LICENSE_FILE_PATH)
+    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