cocina_display 0.5.0 → 0.6.0

data/lib/cocina_display/contributor.rb

@@ -5,6 +5,7 @@ require "active_support/core_ext/object/blank"
 require "active_support/core_ext/array/conversions"
 
 require_relative "utils"
+require_relative "marc_relator_codes"
 
 module CocinaDisplay
   # A contributor to a work, such as an author or publisher.
@@ -51,7 +52,13 @@ module CocinaDisplay
     # Does this contributor have a role that indicates they are an author?
     # @return [Boolean]
     def author?
-      roles.any? { |role| role["value"] =~ /(author|creator)/i }
+      roles.any?(&:author?)
+    end
+
+    # Does this contributor have a role that indicates they are a publisher?
+    # @return [Boolean]
+    def publisher?
+      roles.any?(&:publisher?)
     end
 
     # Does this contributor have any roles defined?
@@ -72,11 +79,9 @@ module CocinaDisplay
     # If there are multiple roles, they are joined with commas.
     # @return [String]
     def display_role
-      roles.map { |role| role["value"] }.to_sentence
+      roles.map(&:display_str).to_sentence
     end
 
-    private
-
     # All names in the Cocina as Name objects.
     # @return [Array<Name>]
     def names
@@ -86,7 +91,7 @@ module CocinaDisplay
     # All roles in the Cocina structured data.
     # @return [Array<Hash>]
     def roles
-      Array(cocina["role"])
+      @roles ||= Array(cocina["role"]).map { |role| Role.new(role) }
     end
 
     # A name associated with a contributor.
@@ -181,5 +186,49 @@ module CocinaDisplay
         end.compact_blank
       end
     end
+
+    # A role associated with a contributor.
+    class Role
+      attr_reader :cocina
+
+      # Initialize a Role object with Cocina structured data.
+      # @param cocina [Hash] The Cocina structured data for the role.
+      def initialize(cocina)
+        @cocina = cocina
+      end
+
+      # The name of the role.
+      # Translates the MARC relator code if no value was present.
+      # @return [String, nil]
+      def display_str
+        cocina["value"] || (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"]
+      end
+
+      # Does this role indicate the contributor is an author?
+      # @return [Boolean]
+      def author?
+        display_str =~ /^(author|creator)/i
+      end
+
+      # Does this role indicate the contributor is a publisher?
+      # @return [Boolean]
+      def publisher?
+        display_str =~ /^publisher/i
+      end
+
+      private
+
+      # Does this role have a MARC relator code?
+      # @return [Boolean]
+      def marc_relator?
+        cocina.dig("source", "code") == "marcrelator"
+      end
+    end
   end
 end

data/lib/cocina_display/dates/date.rb

@@ -82,9 +82,14 @@ module CocinaDisplay
 
       attr_reader :cocina, :date
 
+      # The type of this date, if any, such as "creation", "publication", etc.
+      # @return [String, nil]
+      attr_accessor :type
+
       def initialize(cocina)
         @cocina = cocina
         @date = self.class.parse_date(cocina["value"])
+        @type = cocina["type"] unless ["start", "end"].include?(cocina["type"])
       end
 
       # Compare this date to another {Date} or {DateRange} using its {sort_key}.
@@ -98,12 +103,6 @@ module CocinaDisplay
         cocina["value"]
       end
 
-      # The type of this date, if any, such as "creation", "publication", etc.
-      # @return [String, nil]
-      def type
-        cocina["type"]
-      end
-
       # The qualifier for this date, if any, such as "approximate", "inferred", etc.
       # @return [String, nil]
       def qualifier
@@ -132,14 +131,16 @@ module CocinaDisplay
 
       # Is this the start date in a range?
       # @return [Boolean]
+      # @note The Cocina will mark start dates with "type": "start".
       def start?
-        type == "start"
+        cocina["type"] == "start"
       end
 
       # Is this the end date in a range?
       # @return [Boolean]
+      # @note The Cocina will mark end dates with "type": "end".
       def end?
-        type == "end"
+        cocina["type"] == "end"
       end
 
       # Was the date marked as approximate?

data/lib/cocina_display/dates/date_range.rb

@@ -30,6 +30,7 @@ module CocinaDisplay
         @cocina = cocina
         @start = start
         @stop = stop
+        @type = cocina["type"]
       end
 
       # The values of the start and stop dates as an array.
@@ -83,6 +84,13 @@ module CocinaDisplay
         start&.parsed_date? || stop&.parsed_date? || false
       end
 
+      # False if both dates in the range have a known unparsable value like "9999".
+      # @see CocinaDisplay::Date#parsable?
+      # @return [Boolean]
+      def parsable?
+        start&.parsable? || stop&.parsable? || false
+      end
+
       # Decoded version of the range, if it was encoded. Strips leading zeroes.
       # @see CocinaDisplay::Date#decoded_value
       # @return [String]

data/lib/cocina_display/events/event.rb

@@ -0,0 +1,78 @@
+require_relative "location"
+require_relative "../dates/date"
+require_relative "../contributor"
+
+module CocinaDisplay
+  module Events
+    # An event associated with an object, like publication.
+    class Event
+      attr_reader :cocina
+
+      # Initialize the event with Cocina event data.
+      # @param cocina [Hash] Cocina structured data for a single event
+      def initialize(cocina)
+        @cocina = cocina
+      end
+
+      # The declared type of the event, like "publication" or "creation".
+      # @see https://github.com/sul-dlss/cocina-models/blob/main/docs/description_types.md#event-types
+      # @note This can differ from the contained date types.
+      # @return [String, nil]
+      def type
+        cocina["type"]
+      end
+
+      # All types of dates associated with this event.
+      # @see https://github.com/sul-dlss/cocina-models/blob/main/docs/description_types.md#event-date-types
+      # @note This can differ from the top-level event type.
+      # @return [Array<String>]
+      def date_types
+        dates.map(&:type).uniq
+      end
+
+      # True if either the event type or any date type matches the given type.
+      # @param match_type [String] The type to check against
+      # @return [Boolean]
+      def has_type?(match_type)
+        [type, *date_types].compact.include?(match_type)
+      end
+
+      # True if the event or its dates have any of the provided types.
+      # @param match_types [Array<String>] The types to check against
+      # @return [Boolean]
+      def has_any_type?(*match_types)
+        match_types.any? { |type| has_type?(type) }
+      end
+
+      # All dates associated with this event.
+      # Ignores known unparsable date values like "9999".
+      # If the date is untyped, uses this event's type as the date type.
+      # @note The date types may differ from the underlying event type.
+      # @return [Array<CocinaDisplay::Dates::Date>]
+      def dates
+        @dates ||= Array(cocina["date"]).filter_map do |date|
+          CocinaDisplay::Dates::Date.from_cocina(date)
+        end.filter(&:parsable?).map do |date|
+          date.type ||= type
+          date
+        end
+      end
+
+      # All contributors associated with this event.
+      # @return [Array<CocinaDisplay::Contributor>]
+      def contributors
+        @contributors ||= Array(cocina["contributor"]).map do |contributor|
+          CocinaDisplay::Contributor.new(contributor)
+        end
+      end
+
+      # All locations associated with this event.
+      # @return [Array<CocinaDisplay::Events::Location>]
+      def locations
+        @locations ||= Array(cocina["location"]).map do |location|
+          CocinaDisplay::Events::Location.new(location)
+        end
+      end
+    end
+  end
+end

data/lib/cocina_display/events/imprint.rb

@@ -0,0 +1,101 @@
+# 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 "../marc_country_codes"
+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.
+    class Imprint < Event
+      # The entire imprint statement formatted as a string for display.
+      # @return [String]
+      def display_str
+        place_pub = Utils.compact_and_join([place_str, publisher_str], delimiter: " : ")
+        edition_place_pub = Utils.compact_and_join([edition_str, place_pub], delimiter: " - ")
+        Utils.compact_and_join([edition_place_pub, date_str], delimiter: ", ")
+      end
+
+      # Were any of the dates encoded?
+      # Used to detect which event(s) most likely represent the actual imprint(s).
+      def date_encoding?
+        dates.any?(&:encoding?)
+      end
+
+      private
+
+      # The date portion of the imprint statement, comprising all unique dates.
+      # @return [String]
+      def date_str
+        Utils.compact_and_join(unique_dates_for_display.map(&:qualified_value))
+      end
+
+      # The editions portion of the imprint statement, combining all edition notes.
+      # @return [String]
+      def edition_str
+        Utils.compact_and_join(Janeway.enum_for("$.note[?@.type == 'edition'].value", cocina))
+      end
+
+      # The place of publication, combining all location values.
+      # @return [String]
+      def place_str
+        Utils.compact_and_join(locations_for_display, delimiter: " : ")
+      end
+
+      # The publisher information, combining all name values for publishers.
+      # @return [String]
+      def publisher_str
+        Utils.compact_and_join(publishers.map(&:display_name), delimiter: " : ")
+      end
+
+      # All publishers associated with this imprint.
+      # @return [Array<CocinaDisplay::Contributor>]
+      # @see CocinaDisplay::Contributor#publisher?
+      def publishers
+        contributors.filter(&:publisher?)
+      end
+
+      # Filter dates for uniqueness using base value according to predefined rules.
+      # 1. For a group of dates with the same base value, choose a single one
+      # 2. Prefer unencoded dates over encoded ones when choosing a single date
+      # 3. Remove date ranges that duplicate any unencoded non-range dates
+      # @return [Array<CocinaDisplay::Dates::Date>]
+      # @see CocinaDisplay::Dates::Date#base_value
+      # @see https://consul.stanford.edu/display/chimera/MODS+display+rules#MODSdisplayrules-3b.%3CoriginInfo%3E
+      def unique_dates_for_display
+        # Choose a single date for each group with the same base value
+        deduped_dates = dates.group_by(&:base_value).map do |base_value, group|
+          if (unencoded = group.reject(&:encoding?)).any?
+            unencoded.first
+          else
+            group.first
+          end
+        end
+
+        # Remove any ranges that duplicate part of an unencoded non-range date
+        ranges, singles = deduped_dates.partition { |date| date.is_a?(CocinaDisplay::Dates::DateRange) }
+        unencoded_singles_dates = singles.reject(&:encoding?).flat_map(&:to_a)
+        ranges.reject! { |range| unencoded_singles_dates.any? { |date| range.as_interval.include?(date) } }
+
+        (singles + ranges).sort
+      end
+
+      # Filter locations to display according to predefined rules.
+      # 1. Prefer unencoded locations (plain value) over encoded ones
+      # 2. If no unencoded locations but there are MARC country codes, decode them
+      # 3. Keep only unique locations after decoding
+      def locations_for_display
+        unencoded_locs, encoded_locs = locations.partition { |loc| loc.unencoded_value? }
+        locs_for_display = unencoded_locs.presence || encoded_locs
+        locs_for_display.map(&:display_str).compact_blank.uniq
+      end
+    end
+  end
+end

data/lib/cocina_display/events/location.rb

@@ -0,0 +1,56 @@
+require_relative "../marc_country_codes"
+
+module CocinaDisplay
+  module Events
+    # A single location represented in a Cocina event, like a publication place.
+    class Location
+      attr_reader :cocina
+
+      # Initialize a Location object with Cocina structured data.
+      # @param cocina [Hash] The Cocina structured data for the location.
+      def initialize(cocina)
+        @cocina = cocina
+      end
+
+      # The name of the location.
+      # Decodes a MARC country code if present and no value was present.
+      # @return [String, nil]
+      def display_str
+        cocina["value"] || decoded_country
+      end
+
+      # Is there an unencoded value (name) for this location?
+      # @return [Boolean]
+      def unencoded_value?
+        cocina["value"].present?
+      end
+
+      private
+
+      # A code, like a MARC country code, representing the location.
+      # @return [String, nil]
+      def code
+        cocina["code"]
+      end
+
+      # Decoded country name if the location is encoded with a MARC country code.
+      # @return [String, nil]
+      def decoded_country
+        MARC_COUNTRY[code] if marc_country? && valid_country_code?
+      end
+
+      # Is this a decodable country code?
+      # Excludes blank values and "xx" (unknown) and "vp" (various places).
+      # @return [Boolean]
+      def valid_country_code?
+        code.present? && ["xx", "vp"].exclude?(code)
+      end
+
+      # Is this location encoded with a MARC country code?
+      # @return [Boolean]
+      def marc_country?
+        cocina.dig("source", "code") == "marccountry"
+      end
+    end
+  end
+end