cocina_display 1.1.3 → 1.2.0

data/lib/cocina_display/contributors/name.rb

@@ -1,24 +1,30 @@
 # frozen_string_literal: true
 
-require_relative "../utils"
-
 module CocinaDisplay
   module Contributors
     # A name associated with a contributor.
     class Name
+      # The underlying Cocina structured data for the name.
+      # @return [Hash]
       attr_reader :cocina
 
+      # The type of name, if any (e.g., "personal", "corporate", etc.).
+      # @return [String, nil]
+      attr_accessor :type
+
+      # The status of the name, if any (e.g., "primary").
+      # @return [String, nil]
+      attr_accessor :status
+
       # Initialize a Name object with Cocina structured data.
       # @param cocina [Hash] The Cocina structured data for the name.
       def initialize(cocina)
         @cocina = cocina
+        @type = cocina["type"]
+        @status = cocina["status"]
       end
 
       # The display string for the name, optionally including life dates.
-      # Uses these values in order, if present:
-      # 1. Unstructured value
-      # 2. Any structured/parallel values marked as "display"
-      # 3. Joined structured values, optionally with life dates
       # @param with_date [Boolean] Include life dates, if present
       # @return [String]
       # @example no dates
@@ -28,8 +34,6 @@ module CocinaDisplay
       def to_s(with_date: false)
         if cocina["value"].present?
           cocina["value"]
-        elsif display_name_str.present?
-          display_name_str
         elsif dates_str.present? && with_date
           Utils.compact_and_join([full_name_str, dates_str], delimiter: ", ")
         else
@@ -43,12 +47,6 @@ module CocinaDisplay
         Utils.compact_and_join(name_components.push(terms_of_address_str), delimiter: ", ")
       end
 
-      # Flattened form of any names explicitly marked as "display name".
-      # @return [String]
-      def display_name_str
-        Utils.compact_and_join(Array(name_values["display"]), delimiter: ", ")
-      end
-
       # List of all name components.
       # If any of forename, surname, or term of address are present, those are used.
       # Otherwise, fall back to any names explicitly marked as "name" or untyped.
@@ -81,6 +79,12 @@ module CocinaDisplay
         Utils.compact_and_join(Array(name_values["life dates"]) + Array(name_values["activity dates"]), delimiter: ", ")
       end
 
+      # Is this a primary name for the contributor?
+      # @return [Boolean]
+      def primary?
+        status == "primary"
+      end
+
       private
 
       # A hash mapping destructured name types to their values.

data/lib/cocina_display/contributors/role.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../vocabularies/marc_relator_codes"
-
 module CocinaDisplay
   module Contributors
     # A role associated with a contributor.
@@ -16,37 +14,46 @@ module CocinaDisplay
 
       # The name of the role.
       # Translates the MARC relator code if no value was present.
-      # @return [String, nil]
+      # @return [String, nil] A nil role is typically displayed in the UI as an "Associated with" relationship
       def to_s
-        cocina["value"] || (Vocabularies::MARC_RELATOR[code] if marc_relator?)
-      end
-
-      # A code associated with the role, e.g. a MARC relator code.
-      # @return [String, nil]
-      def code
-        cocina["code"]
+        cocina.fetch("value") { marc_value }
       end
 
       # Does this role indicate the contributor is an author?
       # @return [Boolean]
       def author?
-        to_s =~ /^(author|creator|primary investigator)/i
+        /^(author|creator|primary investigator)/i.match? to_s
       end
 
       # Does this role indicate the contributor is a publisher?
       # @return [Boolean]
       def publisher?
-        to_s =~ /^publisher/i
+        /^publisher/i.match? to_s
       end
 
       # Does this role indicate the contributor is a funder?
       # @return [Boolean]
       def funder?
-        to_s =~ /^funder/i
+        /^funder/i.match? to_s
       end
 
       private
 
+      # The name of the MARC relator role
+      # @raises [KeyError] if the role is not valid
+      # @return [String, nil]
+      def marc_value
+        return unless marc_relator?
+
+        Vocabularies::MARC_RELATOR.fetch(code)
+      end
+
+      # A code associated with the role, e.g. a MARC relator code.
+      # @return [String, nil]
+      def code
+        cocina["code"]
+      end
+
       # Does this role have a MARC relator code?
       # @return [Boolean]
       def marc_relator?

data/lib/cocina_display/dates/date.rb

@@ -11,6 +11,10 @@ module CocinaDisplay
       # List of values that we shouldn't even attempt to parse.
       UNPARSABLE_VALUES = ["0000-00-00", "9999", "uuuu", "[uuuu]"].freeze
 
+      def self.notifier
+        CocinaDisplay.notifier
+      end
+
       # Construct a Date from parsed Cocina data.
       # @param cocina [Hash] Cocina date data
       # @return [CocinaDisplay::Date]
@@ -75,6 +79,11 @@ module CocinaDisplay
       # @param value [String] the date value to modify
       # @return [String]
       def self.normalize_to_edtf(value)
+        unless value
+          notifier&.notify("Invalid date value: #{value}")
+          return
+        end
+
         sanitized = value.gsub(/^[\[]+/, "").gsub(/[\.\]]+$/, "")
         sanitized = value.rjust(4, "0") if /^\d{3}$/.match?(value)
 
@@ -110,6 +119,18 @@ module CocinaDisplay
         cocina["value"]
       end
 
+      # The string representation of the date for display.
+      # @return [String]
+      def to_s
+        qualified_value
+      end
+
+      # Label used to group the date for display.
+      # @return [String]
+      def label
+        cocina["displayLabel"].presence || type_label
+      end
+
       # The qualifier for this date, if any, such as "approximate", "inferred", etc.
       # @return [String, nil]
       def qualifier
@@ -183,14 +204,18 @@ module CocinaDisplay
       # @return [Symbol] :year, :month, :day, :decade, :century, or :unknown
       def precision
         return :unknown unless date_range || date
-
         if date_range.is_a? EDTF::Century
-          :century
+          return :century
         elsif date_range.is_a? EDTF::Decade
-          :decade
-        elsif date.is_a? EDTF::Season
+          return :decade
+        end
+
+        case date
+        when EDTF::Season
           :month
-        elsif date.is_a? EDTF::Interval
+        when EDTF::Unknown
+          :unknown
+        when EDTF::Interval
           date.precision
         else
           case date.precision
@@ -265,11 +290,11 @@ module CocinaDisplay
 
       # Decoded version of the date with "BCE" or "CE". Strips leading zeroes.
       # @param allowed_precisions [Array<Symbol>] List of allowed precisions for the output.
-      #   Defaults to [:day, :month, :year, :decade, :century].
+      #   Defaults to [:day, :month, :year, :decade, :century, :unknown].
       # @param ignore_unparseable [Boolean] Return nil instead of the original value if it couldn't be parsed
       # @param display_original_value [Boolean] Return the original value if it was not encoded
       # @return [String]
-      def decoded_value(allowed_precisions: [:day, :month, :year, :decade, :century], ignore_unparseable: false, display_original_value: true)
+      def decoded_value(allowed_precisions: [:day, :month, :year, :decade, :century, :unknown], ignore_unparseable: false, display_original_value: true)
         return if ignore_unparseable && !parsed_date?
         return value.strip unless parsed_date?
 
@@ -340,12 +365,13 @@ module CocinaDisplay
         # @param date [Date] The date to format.
         # @param precision [Symbol] The precision to format the date at, e.g. :month
         # @param allowed_precisions [Array<Symbol>] List of allowed precisions for the output.
-        #   Options are [:day, :month, :year, :decade, :century].
+        #   Options are [:day, :month, :year, :decade, :century, :unknown].
         # @note allowed_precisions should be ordered by granularity, with most specific first.
         def format_date(date, precision, allowed_precisions)
           precision = allowed_precisions.first unless allowed_precisions.include?(precision)
-
           case precision
+          when :unknown
+            "Unknown"
           when :day
             date.strftime("%B %e, %Y")
           when :month
@@ -378,8 +404,6 @@ module CocinaDisplay
         return nil if date.nil?
 
         case date_range
-        when EDTF::Unknown
-          nil
         when EDTF::Epoch, EDTF::Interval, EDTF::Season
           date_range.min
         when EDTF::Set
@@ -400,8 +424,6 @@ module CocinaDisplay
         return nil if date.nil?
 
         case date_range
-        when EDTF::Unknown
-          nil
         when EDTF::Epoch, EDTF::Interval, EDTF::Season
           date_range.max
         when EDTF::Set
@@ -439,18 +461,37 @@ module CocinaDisplay
           [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month]
         end
       end
+
+      # Label for the date based on its type.
+      # @example "publication" becomes "Publication date"
+      # @return [String]
+      def type_label
+        I18n.t(
+          type || "untyped",
+          scope: "cocina_display.field_label.event.date",
+          type: type&.capitalize,
+          default: [:default]
+        )
+      end
     end
 
     # Strict ISO8601-encoded date parser.
     class Iso8601Format < Date
       def self.parse_date(value)
         ::Date.parse(normalize_to_edtf(value))
+      rescue ::Date::Error
+        notifier&.notify("Invalid date value \"#{value}\" for iso8601 encoding")
+        nil
       end
     end
 
     # Less strict W3CDTF-encoded date parser.
     class W3cdtfFormat < Date
       def self.normalize_to_edtf(value)
+        unless value
+          notifier&.notify("Invalid date value: #{value}")
+          return
+        end
         super.gsub("-00", "")
       end
     end
@@ -503,7 +544,7 @@ module CocinaDisplay
     # Base class for date formats that match using a regex.
     class ExtractorDateFormat < Date
       def self.supports?(value)
-        value.match self::REGEX
+        self::REGEX.match?(value)
       end
     end
 

data/lib/cocina_display/dates/date_range.rb

@@ -1,5 +1,3 @@
-require_relative "date"
-
 module CocinaDisplay
   module Dates
     # A date range parsed from Cocina structuredValues.

data/lib/cocina_display/description/access.rb

@@ -0,0 +1,41 @@
+module CocinaDisplay
+  module Description
+    # Access information for a Cocina object.
+    class Access
+      attr_reader :cocina
+
+      # Create an Access object from Cocina structured data.
+      # @param cocina [Hash]
+      def initialize(cocina)
+        @cocina = cocina
+      end
+
+      # String representation of the access metadata.
+      # @return [String, nil]
+      def to_s
+        cocina["value"].presence
+      end
+
+      # The type of the access metadata, e.g. "repository".
+      # @return [String, nil]
+      def type
+        cocina["type"].presence
+      end
+
+      # The display label for the access metadata.
+      # @return [String]
+      def label
+        cocina["displayLabel"].presence ||
+          I18n.t(type&.parameterize&.underscore, default: :access, scope: "cocina_display.field_label.access")
+      end
+
+      # Whether the access info is a contact email.
+      # Always false, see CocinaDisplay::Description::AccessContact
+      # for cases when this is true
+      # @return [Boolean]
+      def contact_email?
+        false
+      end
+    end
+  end
+end

data/lib/cocina_display/description/access_contact.rb

@@ -0,0 +1,11 @@
+module CocinaDisplay
+  module Description
+    class AccessContact < Access
+      # Whether the access contact info is a contact email.
+      # @return [Boolean]
+      def contact_email?
+        type == "email"
+      end
+    end
+  end
+end

data/lib/cocina_display/description/url.rb

@@ -0,0 +1,17 @@
+module CocinaDisplay
+  module Description
+    class Url < Access
+      # The display label for the URL access metadata.
+      # @return [String]
+      def label
+        I18n.t(:url, scope: "cocina_display.field_label.access")
+      end
+
+      # The link text for the URL access metadata.
+      # @return [String, nil]
+      def link_text
+        cocina["displayLabel"].presence
+      end
+    end
+  end
+end

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 a string value.
+      # @param value [String] The string value to display
+      # @param label [String] The label for the display data
+      # @return [Array<DisplayData>] The display data
+      def from_string(value, label: nil)
+        from_objects(descriptive_values_from_string(value, label: label))
+      end
+
+      # Create an array containing a descriptive object from a string value.
+      # Can be used to combine a string derived value with other metadata objects.
+      # @param string [String] The string value to display
+      # @param label [String] The label for the display data
+      # @return [Array<DescriptiveValue>] The descriptive values
+      def descriptive_values_from_string(string, label: nil)
+        [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<Object>]
+    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,5 +1,3 @@
-require_relative "../vocabularies/marc_country_codes"
-
 module CocinaDisplay
   module Events
     # A single location represented in a Cocina event, like a publication place.

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