cocina_display 0.5.0 → 0.7.0

data/lib/cocina_display/concerns/subjects.rb

@@ -1,45 +1,86 @@
-require_relative "../subject"
+require_relative "../subjects/subject"
+require_relative "../subjects/subject_value"
 
 module CocinaDisplay
   module Concerns
     # Methods for extracting and formatting subject information.
     module Subjects
-      # All unique subjects that are topics, formatted as strings for display.
+      # All unique subject values that are topics.
       # @return [Array<String>]
       def subject_topics
-        subjects.filter { |s| s.type == "topic" }.map(&:display_str).uniq
+        subject_values.filter { |s| s.type == "topic" }.map(&:display_str).uniq
       end
 
-      # All unique subjects that are genres, formatted as strings for display.
+      # All unique subject values that are genres.
       # @return [Array<String>]
       def subject_genres
-        subjects.filter { |s| s.type == "genre" }.map(&:display_str).uniq
+        subject_values.filter { |s| s.type == "genre" }.map(&:display_str).uniq
       end
 
-      # All unique subjects that are titles, formatted as strings for display.
+      # All unique subject values that are titles.
       # @return [Array<String>]
       def subject_titles
-        subjects.filter { |s| s.type == "title" }.map(&:display_str).uniq
+        subject_values.filter { |s| s.type == "title" }.map(&:display_str).uniq
       end
 
-      # All unique subjects that are date/time info, formatted as strings for display.
+      # All unique subject values that are date/time info.
       # @return [Array<String>]
       def subject_temporal
-        subjects.filter { |s| s.type == "time" }.map(&:display_str).uniq
+        subject_values.filter { |s| s.type == "time" }.map(&:display_str).uniq
       end
 
-      # All unique subjects that are occupations, formatted as strings for display.
+      # All unique subject values that are occupations.
       # @return [Array<String>]
       def subject_occupations
-        subjects.filter { |s| s.type == "occupation" }.map(&:display_str).uniq
+        subject_values.filter { |s| s.type == "occupation" }.map(&:display_str).uniq
       end
 
-      # All unique subjects that are names of entities, formatted as strings for display.
+      # All unique subject values that are names of entities.
       # @note Multiple types are handled: person, family, organization, conference, etc.
-      # @see CocinaDisplay::NameSubject
+      # @see CocinaDisplay::NameSubjectValue
       # @return [Array<String>]
       def subject_names
-        subjects.filter { |s| s.is_a? NameSubject }.map(&:display_str).uniq
+        subject_values.filter { |s| s.is_a? CocinaDisplay::Subjects::NameSubjectValue }.map(&:display_str).uniq
+      end
+
+      # Combination of all subject values for searching.
+      # @see #subject_topics_other
+      # @see #subject_temporal_genre
+      # @return [Array<String>]
+      def subject_all
+        subject_topics_other + subject_temporal_genre
+      end
+
+      # Combination of topic, occupation, name, and title subject values for searching.
+      # @see #subject_topics
+      # @see #subject_other
+      # @return [Array<String>]
+      def subject_topics_other
+        subject_topics + subject_other
+      end
+
+      # Combination of occupation, name, and title subject values for searching.
+      # @see #subject_occupations
+      # @see #subject_names
+      # @see #subject_titles
+      # @return [Array<String>]
+      def subject_other
+        subject_occupations + subject_names + subject_titles
+      end
+
+      # Combination of temporal and genre subject values for searching.
+      # @see #subject_temporal
+      # @see #subject_genres
+      # @return [Array<String>]
+      def subject_temporal_genre
+        subject_temporal + subject_genres
+      end
+
+      # Combination of all subjects with nested values concatenated for display.
+      # @see Subject#display_str
+      # @return [Array<String>]
+      def subject_all_display
+        subjects.map(&:display_str).uniq
       end
 
       private
@@ -50,8 +91,14 @@ module CocinaDisplay
       def subjects
         @subjects ||= Enumerator::Chain.new(
           path("$.description.subject[*]"),
-          path("$.description.geographic[*].subject[*]")
-        ).map { |s| Subject.from_cocina(s) }
+          path("$.description.geographic.*.subject[*]")
+        ).map { |s| CocinaDisplay::Subjects::Subject.new(s) }
+      end
+
+      # All subject values, flattened from all subjects.
+      # @return [Array<SubjectValue>]
+      def subject_values
+        @subject_values ||= subjects.flat_map(&:subject_values)
       end
     end
   end

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 "vocabularies/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.
@@ -124,10 +129,10 @@ module CocinaDisplay
 
       private
 
-      # The full name as a string, combining all name components.
+      # The full name as a string, combining all name components and terms of address.
       # @return [String]
       def full_name_str
-        Utils.compact_and_join(name_components, delimiter: ", ")
+        Utils.compact_and_join(name_components.push(terms_of_address_str), delimiter: ", ")
       end
 
       # Flattened form of any names explicitly marked as "display name".
@@ -141,7 +146,7 @@ module CocinaDisplay
       # Otherwise, fall back to any names explicitly marked as "name" or untyped.
       # @return [Array<String>]
       def name_components
-        [surname_str, forename_ordinal_str, terms_of_address_str].compact_blank.presence || Array(name_values["name"])
+        [surname_str, forename_ordinal_str].compact_blank.presence || Array(name_values["name"])
       end
 
       # Flatten all forenames and ordinals into a single string.
@@ -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"] || (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"]
+      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.
@@ -62,7 +63,18 @@ module CocinaDisplay
         start&.encoding || stop&.encoding || super
       end
 
-      # Is either date in the range qualified in any way?
+      # The qualifier for the entire range.
+      # If both qualifiers match, uses that qualifier. If both are empty, falls
+      # back to the top level qualifier, if any.
+      # @see CocinaDisplay::Date#qualifier
+      # @return [String, nil]
+      def qualifier
+        if start&.qualifier == stop&.qualifier
+          start&.qualifier || stop&.qualifier || super
+        end
+      end
+
+      # Is either date in the range, or the range itself, qualified?
       # @see CocinaDisplay::Date#qualified?
       # @return [Boolean]
       def qualified?
@@ -83,6 +95,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]
@@ -97,14 +116,15 @@ module CocinaDisplay
       # @see CocinaDisplay::Date#qualified_value
       # @return [String]
       def qualified_value
-        if start&.qualifier == stop&.qualifier
-          qualifier = start&.qualifier || stop&.qualifier
-          date = decoded_value
-          return "[ca. #{date}]" if qualifier == "approximate"
-          return "[#{date}?]" if qualifier == "questionable"
-          return "[#{date}]" if qualifier == "inferred"
-
-          date
+        if qualifier
+          case qualifier
+          when "approximate"
+            "[ca. #{decoded_value}]"
+          when "questionable"
+            "[#{decoded_value}?]"
+          when "inferred"
+            "[#{decoded_value}]"
+          end
         else
           "#{start&.qualified_value} - #{stop&.qualified_value}"
         end

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,100 @@
+# 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.
+    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 "../vocabularies/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
+        Vocabularies::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

data/lib/cocina_display/language.rb

@@ -0,0 +1,47 @@
+require "iso639"
+require_relative "vocabularies/searchworks_languages"
+
+module CocinaDisplay
+  # A language associated with part or all of a Cocina object.
+  class Language
+    attr_reader :cocina
+
+    # Create a Language object from Cocina structured data.
+    # @param cocina [Hash]
+    def initialize(cocina)
+      @cocina = cocina
+    end
+
+    # The language name for display.
+    # @return [String, nil]
+    def display_str
+      cocina["value"] || decoded_value
+    end
+
+    # The language code, e.g. an ISO 639 code like "eng" or "spa".
+    # @return [String, nil]
+    def code
+      cocina["code"]
+    end
+
+    # 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?)
+    end
+
+    # True if the language is recognized by Searchworks.
+    # @see CocinaDisplay::Vocabularies::SEARCHWORKS_LANGUAGES
+    # @return [Boolean]
+    def searchworks_language?
+      Vocabularies::SEARCHWORKS_LANGUAGES.value?(display_str)
+    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"
+    end
+  end
+end

data/lib/cocina_display/subjects/subject.rb

@@ -0,0 +1,63 @@
+require_relative "../utils"
+require_relative "subject_value"
+
+module CocinaDisplay
+  module Subjects
+    # Base class for subjects in Cocina structured data.
+    class Subject
+      attr_reader :cocina
+
+      # Initialize a Subject object with Cocina structured data.
+      # @param cocina [Hash] The Cocina structured data for the subject.
+      def initialize(cocina)
+        @cocina = cocina
+      end
+
+      # The top-level type of the subject.
+      # @see https://github.com/sul-dlss/cocina-models/blob/main/docs/description_types.md#subject-types
+      # @return [String, nil]
+      def type
+        cocina["type"]
+      end
+
+      # Array of display strings for each value in the subject.
+      # Used for search, where each value should be indexed separately.
+      # @return [Array<String>]
+      def display_values
+        subject_values.map(&:display_str).compact_blank
+      end
+
+      # A string representation of the entire subject, formatted for display.
+      # Concatenates the values with an appropriate delimiter.
+      # @return [String]
+      def display_str
+        Utils.compact_and_join(display_values, delimiter: delimiter)
+      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.
+      # @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
+        end
+      end
+
+      private
+
+      # Delimiter to use for joining structured subject values.
+      # LCSH uses a comma (the default); catalog headings use " > ".
+      # @return [String]
+      def delimiter
+        if cocina["displayLabel"]&.downcase == "catalog heading"
+          " > "
+        else
+          ", "
+        end
+      end
+    end
+  end
+end