cocina_display 1.1.3 → 1.2.1

data/lib/cocina_display/concerns/accesses.rb

@@ -0,0 +1,78 @@
+module CocinaDisplay
+  module Concerns
+    # Methods for extracting access/location information from a Cocina object.
+    module Accesses
+      # Display data for all access metadata except contact emails
+      # @return [Array<DisplayData>]
+      def access_display_data
+        CocinaDisplay::DisplayData.from_objects(accesses +
+                                                access_contacts.reject(&:contact_email?) +
+                                                purls +
+                                                urls)
+      end
+
+      # Display data for all access contact email metadata
+      # @return [Array<DisplayData>]
+      def contact_email_display_data
+        CocinaDisplay::DisplayData.from_objects(access_contacts.select(&:contact_email?))
+      end
+
+      # Display data for the use and reproduction statement.
+      # Exhibits and EarthWorks handle useAndReproductionStatement like descriptive metadata.
+      # @return [Array<CocinaDisplay::DisplayData>]
+      def use_and_reproduction_display_data
+        CocinaDisplay::DisplayData.from_strings([use_and_reproduction],
+          label: I18n.t("cocina_display.field_label.use_and_reproduction"))
+      end
+
+      # Display data for the copyright statement.
+      # Exhibits and EarthWorks handle copyright like descriptive metadata.
+      # @return [Array<CocinaDisplay::DisplayData>]
+      def copyright_display_data
+        CocinaDisplay::DisplayData.from_strings([copyright],
+          label: I18n.t("cocina_display.field_label.copyright"))
+      end
+
+      def license_display_data
+        CocinaDisplay::DisplayData.from_strings([license_description],
+          label: I18n.t("cocina_display.field_label.license"))
+      end
+
+      # All access metadata except contact emails and URLs
+      # @return [Array<Description::Access>]
+      def accesses
+        @accesses ||= Enumerator::Chain.new(
+          path("$.description.access.physicalLocation.*"),
+          path("$.description.access.digitalLocation.*"),
+          path("$.description.access.digitalRepository.*")
+        ).map { |a| CocinaDisplay::Description::Access.new(a) }
+      end
+
+      # All access contact metadata
+      # @return [Array<Description::AccessContact>]
+      def access_contacts
+        path("$.description.access.accessContact.*").map do |contact|
+          CocinaDisplay::Description::AccessContact.new(contact)
+        end
+      end
+
+      # All access URL metadata
+      # @return [Array<Description::Url>]
+      def urls
+        path("$.description.access.url.*").map do |url|
+          CocinaDisplay::Description::Url.new(url)
+        end
+      end
+
+      private
+
+      # The Purl URL to combine with other access metadata
+      # @return [Array<DescriptiveValue>]
+      def purls
+        return [] unless purl_url.present?
+
+        CocinaDisplay::DisplayData.descriptive_values_from_strings([purl_url], label: I18n.t("cocina_display.field_label.purl"))
+      end
+    end
+  end
+end

data/lib/cocina_display/concerns/contributors.rb

@@ -1,5 +1,3 @@
-require_relative "../contributors/contributor"
-
 module CocinaDisplay
   module Concerns
     # Methods for finding and formatting names for contributors
@@ -20,20 +18,20 @@ module CocinaDisplay
       # @param with_date [Boolean] Include life dates, if present
       # @return [Array<String>]
       def additional_contributor_names(with_date: false)
-        additional_contributors.map { |c| c.display_name(with_date: with_date) }.compact
+        additional_contributors.flat_map { |c| c.display_names(with_date: with_date) }.compact
       end
 
       # All names of publishers, formatted for display.
       # @return [Array<String>]
       def publisher_names
-        publisher_contributors.map(&:display_name).compact
+        publisher_contributors.flat_map(&:display_names).compact
       end
 
       # All names of contributors who are people, formatted for display.
       # @param with_date [Boolean] Include life dates, if present
       # @return [Array<String>]
       def person_contributor_names(with_date: false)
-        contributors.filter(&:person?).map { |c| c.display_name(with_date: with_date) }.compact
+        contributors.filter(&:person?).flat_map { |c| c.display_names(with_date: with_date) }.compact
       end
 
       # All names of non-person contributors, formatted for display.
@@ -41,35 +39,58 @@ module CocinaDisplay
       # @return [Array<String>]
       # @see https://github.com/sul-dlss/cocina-models/blob/main/docs/description_types.md#contributor-types
       def impersonal_contributor_names
-        contributors.reject(&:person?).map(&:display_name).compact
+        contributors.reject(&:person?).flat_map(&:display_names).compact
       end
 
       # All names of contributors that are organizations, formatted for display.
       # @return [Array<String>]
       def organization_contributor_names
-        contributors.filter(&:organization?).map(&:display_name).compact
+        contributors.filter(&:organization?).flat_map(&:display_names).compact
       end
 
       # All names of contributors that are conferences, formatted for display.
       # @return [Array<String>]
       def conference_contributor_names
-        contributors.filter(&:conference?).map(&:display_name).compact
+        contributors.filter(&:conference?).flat_map(&:display_names).compact
       end
 
       # A hash mapping role names to the names of contributors with that role.
       # @param with_date [Boolean] Include life dates, if present
       # @return [Hash<String, Array<String>>]
       def contributor_names_by_role(with_date: false)
-        contributors.each_with_object({}) do |contributor, hash|
-          if (name = contributor.display_name(with_date: with_date)).present?
+        contributors_by_role(with_date: with_date)
+          .transform_values { |contributor_list| contributor_list.flat_map { |contributor| contributor.display_names(with_date: with_date) }.compact_blank }
+          .compact_blank
+      end
+
+      # A hash mapping role names to the names of contributors with that role.
+      # @param with_date [Boolean] Include life dates, if present
+      # @return [Hash<[String,NilClass], Array<Contributor>>]
+      def contributors_by_role(with_date: false)
+        @contributors_by_role ||= contributors.each_with_object({}) do |contributor, hash|
+          if contributor.roles.empty?
+            hash[nil] ||= []
+            hash[nil] << contributor
+          else
             contributor.roles.each do |role|
               hash[role.to_s] ||= []
-              hash[role.to_s] << name
+              hash[role.to_s] << contributor
             end
           end
         end
       end
 
+      # DisplayData for Contributors, one per role.
+      # Contributors with no role are grouped under a default heading.
+      # @return [Array<DisplayData>]
+      def contributor_display_data
+        contributors_by_role.map do |role, contributors|
+          label = I18n.t(role, scope: "cocina_display.contributor.role",
+            default: role&.capitalize || I18n.t("default", scope: "cocina_display.contributor.role"))
+          DisplayData.new(label: label, objects: contributors)
+        end
+      end
+
       # A string value for sorting by contributor that sorts missing values last.
       # Appends the sort title to break ties between contributor names.
       # Ignores punctuation and leading/trailing spaces.

data/lib/cocina_display/concerns/events.rb

@@ -1,8 +1,3 @@
-require_relative "../dates/date"
-require_relative "../dates/date_range"
-require_relative "../events/event"
-require_relative "../events/imprint"
-
 module CocinaDisplay
   module Concerns
     module Events
@@ -86,12 +81,18 @@ module CocinaDisplay
         publication_events.flat_map { |event| event.locations.map(&:to_s) }
       end
 
-      # All events associated with the object.
+      # All root level events associated with the object.
       # @return [Array<CocinaDisplay::Events::Event>]
       def events
         @events ||= path("$.description.event.*").map { |event| CocinaDisplay::Events::Event.new(event) }
       end
 
+      # The adminMetadata creation event (When was it was deposited?)
+      # @return <CocinaDisplay::Events::Event>
+      def admin_creation_event
+        @admin_events ||= path("$.description.adminMetadata.event[?(@.type==\"creation\")]").map { |event| CocinaDisplay::Events::Event.new(event) }.first
+      end
+
       # All events that could be used to select a publication date.
       # Includes publication, creation, and capture events.
       # Considers event types as well as date types if the event is untyped.
@@ -121,6 +122,18 @@ module CocinaDisplay
         @event_dates ||= events.flat_map(&:dates)
       end
 
+      # DisplayData for all notes associated with events.
+      # @return [Array<CocinaDisplay::DisplayData>]
+      def event_note_display_data
+        CocinaDisplay::DisplayData.from_objects(events.flat_map(&:notes))
+      end
+
+      # DisplayData for all dates associated with events.
+      # @return [Array<CocinaDisplay::DisplayData>]
+      def event_date_display_data
+        CocinaDisplay::DisplayData.from_objects(event_dates)
+      end
+
       # The earliest preferred publication date as a CocinaDisplay::Dates::Date object.
       # Considers publication, creation, and capture dates in that order.
       # Prefers dates marked as primary and those with a declared encoding.

data/lib/cocina_display/concerns/forms.rb

@@ -6,18 +6,24 @@ module CocinaDisplay
     module Forms
       # Resource types of the object, expressed in SearchWorks controlled vocabulary.
       # @return [Array<String>]
-      def resource_types
+      def searchworks_resource_types
         mapped_values = resource_type_values.flat_map { |resource_type| searchworks_resource_type(resource_type) }
         mapped_values << "Dataset" if dataset?
         mapped_values.uniq
       end
 
+      # Resource types of the object, expressed in SearchWorks controlled vocabulary.
+      # @return [Array<String>]
+      def mods_resource_types
+        all_resource_types.select { |type| type.mods? }.map(&:to_s)
+      end
+
       # Physical or digital forms of the object.
       # @return [Array<String>]
       # @example GIS dataset (nz187ct8959)
       #   record.forms #=> ["map", "optical disc", "electronic resource"]
       def forms
-        path("$.description.form..[?@.type == 'form'].value").uniq
+        form_forms.map(&:to_s).compact_blank.uniq
       end
 
       # Extent of the object, such as "1 audiotape" or "1 map".
@@ -25,7 +31,7 @@ module CocinaDisplay
       # @example Oral history interview (sw705fr7011)
       #   record.extents #=> ["1 audiotape", "1 transcript"]
       def extents
-        path("$.description.form..[?@.type == 'extent'].value").uniq
+        extent_forms.map(&:to_s).compact_blank.uniq
       end
 
       # Genres of the object, capitalized for display.
@@ -33,7 +39,7 @@ module CocinaDisplay
       # @example GIS dataset (nz187ct8959)
       #   record.genres #=> ["Cartographic dataset", "Geospatial data", "Geographic information systems data"]
       def genres
-        path("$.description.form..[?@.type == 'genre'].value").map(&:upcase_first).uniq
+        genre_forms.map(&:to_s).compact_blank.uniq
       end
 
       # Genres of the object, with additional values added for search/faceting.
@@ -47,6 +53,34 @@ module CocinaDisplay
         end.uniq
       end
 
+      # All form-related data to be rendered for display.
+      # Includes form, extent, resource type, etc. (but not self-deposit resource types).
+      # @return [Array<DisplayData>]
+      def form_display_data
+        CocinaDisplay::DisplayData.from_objects(all_forms - genre_forms - map_forms - media_forms - self_deposit_resource_types)
+      end
+
+      # All genre-related data to be rendered for display.
+      # Includes both form genres, subject genres, and self-deposit resource types.
+      # @return [Array<DisplayData>]
+      def genre_display_data
+        CocinaDisplay::DisplayData.from_objects(genre_forms + genre_subjects + self_deposit_resource_types)
+      end
+
+      # All map-related data to be rendered for display.
+      # Includes map scale, projection info, and geographic coordinate subjects.
+      # @return [Array<DisplayData>]
+      def map_display_data
+        CocinaDisplay::DisplayData.from_objects(map_forms + coordinate_subjects)
+      end
+
+      # All form notes to be rendered for display.
+      # @return [Array<DisplayData>]
+      def form_note_display_data
+        CocinaDisplay::DisplayData.from_cocina(path("$.description.form[*].note[*]"),
+          label: I18n.t("cocina_display.field_label.form.note"))
+      end
+
       # Is the object a periodical or serial?
       # @return [Boolean]
       def periodical?
@@ -73,6 +107,46 @@ module CocinaDisplay
 
       private
 
+      # Collapses all nested form values into an array of {Form} objects.
+      # Preserves resource type without flattening, since it can be structured.
+      # @return [Array<Form>]
+      def all_forms
+        @all_forms ||= path("$.description.form.*")
+          .flat_map { |form| Utils.flatten_nested_values(form, atomic_types: ["resource type"]) }
+          .map { |form| CocinaDisplay::Forms::Form.from_cocina(form) }
+      end
+
+      # {Form} objects with type "form".
+      # @return [Array<Form>]
+      def form_forms
+        all_forms.filter { |form| form.type == "form" }
+      end
+
+      # {Form} objects with type "genre".
+      # @return [Array<Form>]
+      def genre_forms
+        all_forms.filter { |form| form.type == "genre" }
+      end
+
+      # {Form} objects with type "extent".
+      # @return [Array<Form>]
+      def extent_forms
+        all_forms.filter { |form| form.type == "extent" }
+      end
+
+      # {Form} objects with types related to map data.
+      # @return [Array<Form>]
+      def map_forms
+        all_forms.filter { |form| ["map scale", "map projection"].include?(form.type) }
+      end
+
+      # {Form} objects with types that are media-related.
+      # @note These are excluded from the general form display data.
+      # @return [Array<Form>]
+      def media_forms
+        all_forms.filter { |form| ["reformatting quality", "media type"].include?(form.type) }
+      end
+
       # Map a resource type to SearchWorks format value(s).
       # @param resource_type [String] The resource type to map.
       # @return [Array<String>]
@@ -113,21 +187,34 @@ module CocinaDisplay
         values.compact_blank
       end
 
+      # All resource types forms, as {ResourceType}s.
+      # @return [Array<ResourceType>]
+      def all_resource_types
+        all_forms.filter { |form| form.is_a?(CocinaDisplay::Forms::ResourceType) }
+      end
+
+      # {ResourceType} objects that are Stanford self-deposit resource types.
+      # @return [Array<ResourceType>]
+      def self_deposit_resource_types
+        all_resource_types.filter { |resource_type| resource_type.stanford_self_deposit? }
+      end
+
+      # Display values of all resource types.
+      # @return [Array<String>]
+      def resource_type_values
+        all_resource_types.map(&:to_s).uniq
+      end
+
       # Issuance terms for a work, drawn from the event notes.
       # @return [Array<String>]
       def issuance_terms
-        path("$.description.event.*.note[?@.type == 'issuance'].value").map(&:downcase).uniq
+        events.flat_map(&:notes).filter { |note| note.type == "issuance" }.map { |note| note.to_s.downcase }.uniq
       end
 
       # Frequency terms for a periodical, drawn from the event notes.
       # @return [Array<String>]
       def frequency
-        path("$.description.event.*.note[?@.type == 'frequency'].value").map(&:downcase).uniq
-      end
-
-      # Values of the resource type form field prior to mapping.
-      def resource_type_values
-        path("$.description.form..[?@.type == 'resource type'].value").uniq
+        events.flat_map(&:notes).filter { |note| note.type == "frequency" }.map { |note| note.to_s.downcase }.uniq
       end
     end
   end

data/lib/cocina_display/concerns/geospatial.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../subjects/subject_value"
-
 module CocinaDisplay
   module Concerns
     # Methods for extracting geospatial metadata, such as coordinates.
@@ -10,7 +8,7 @@ module CocinaDisplay
       # @return [Array<String>]
       # @example ["34°03′08″N 118°14′37″W"]
       def coordinates
-        coordinate_subjects.map(&:to_s).compact.uniq
+        coordinate_subject_values.map(&:to_s).compact.uniq
       end
 
       # All valid coordinate data formatted for indexing into a Solr RPT field.
@@ -49,15 +47,21 @@ module CocinaDisplay
 
       private
 
+      # {Subject} objects with types that could contain coordinate information.
+      # @return [Array<Subject>]
+      def coordinate_subjects
+        all_subjects.filter { |subject| subject.type&.include? "coordinates" }
+      end
+
       # Parsed coordinate values from the coordinate subject values.
       # @return [Array<Geospatial::Coordinates>]
       def coordinate_objects
-        coordinate_subjects.filter_map(&:coordinates)
+        coordinate_subject_values.filter_map(&:coordinates)
       end
 
       # All subject values that could contain parsed coordinates.
       # @return [Array<Subjects::CoordinatesSubjectValue>]
-      def coordinate_subjects
+      def coordinate_subject_values
         subject_values.filter { |s| s.is_a? CocinaDisplay::Subjects::CoordinatesSubjectValue }
       end
     end

data/lib/cocina_display/concerns/identifiers.rb

@@ -26,11 +26,7 @@ module CocinaDisplay
       # @example
       #   record.doi #=> "10.25740/ppax-bf07"
       def doi
-        doi_id = path("$.identification.doi").first ||
-          path("$.description.identifier[?match(@.type, 'doi|DOI')].value").first ||
-          path("$.description.identifier[?search(@.uri, 'doi.org')].uri").first
-
-        URI(doi_id).path.delete_prefix("/") if doi_id.present?
+        identifiers.find(&:doi?)&.identifier
       end
 
       # The DOI as a URL, if there is one. Any valid DOI should resolve via doi.org.
@@ -66,6 +62,30 @@ module CocinaDisplay
       def searchworks_id
         folio_hrid || bare_druid
       end
+
+      # Identifier objects extracted from the Cocina metadata.
+      # @return [Array<Identifier>]
+      def identifiers
+        @identifiers ||= path("$.description.identifier[*]").map { |id| Identifier.new(id) } + Array(doi_from_identification)
+      end
+
+      # Labelled display data for identifiers.
+      # @return [Array<DisplayData>]
+      def identifier_display_data
+        CocinaDisplay::DisplayData.from_objects(identifiers)
+      end
+
+      private
+
+      # Synthetic Identifier object for a DOI in the identification block.
+      # @return [Array<Identifier>]
+      def doi_from_identification
+        id = path("$.identification.doi").first
+        return if id.blank?
+
+        value_key = id.start_with?("http") ? "uri" : "value"
+        Identifier.new({value_key => id, "type" => "doi"})
+      end
     end
   end
 end

data/lib/cocina_display/concerns/languages.rb

@@ -1,5 +1,3 @@
-require_relative "../language"
-
 module CocinaDisplay
   module Concerns
     # Methods for extracting language information from a Cocina object.
@@ -15,6 +13,12 @@ module CocinaDisplay
       def searchworks_language_names
         languages.filter_map { |lang| lang.to_s if lang.searchworks_language? }.compact_blank.uniq
       end
+
+      # Language information for display.
+      # @return [Array<CocinaDisplay::DisplayData>]
+      def language_display_data
+        CocinaDisplay::DisplayData.from_objects(languages)
+      end
     end
   end
 end

data/lib/cocina_display/concerns/notes.rb

@@ -0,0 +1,36 @@
+module CocinaDisplay
+  module Concerns
+    # Methods for extracting note information from Cocina.
+    module Notes
+      # Note objects associated with the cocina record.
+      # @return [Array<CocinaDisplay::Note>]
+      def notes
+        @notes ||= path("$.description.note.*").map { |note| CocinaDisplay::Note.new(note) }
+      end
+
+      # Abstract metadata for display.
+      # @return [Array<CocinaDisplay::DisplayData>]
+      def abstract_display_data
+        CocinaDisplay::DisplayData.from_objects(notes.select(&:abstract?))
+      end
+
+      # General note metadata for display.
+      # @return [Array<CocinaDisplay::DisplayData>]
+      def general_note_display_data
+        CocinaDisplay::DisplayData.from_objects(notes.select(&:general_note?))
+      end
+
+      # Preferred citation metadata for display.
+      # @return [Array<CocinaDisplay::DisplayData>]
+      def preferred_citation_display_data
+        CocinaDisplay::DisplayData.from_objects(notes.select(&:preferred_citation?))
+      end
+
+      # Table of contents metadata for display.
+      # @return [Array<CocinaDisplay::DisplayData>]
+      def table_of_contents_display_data
+        CocinaDisplay::DisplayData.from_objects(notes.select(&:table_of_contents?))
+      end
+    end
+  end
+end

data/lib/cocina_display/concerns/related_resources.rb

@@ -0,0 +1,20 @@
+module CocinaDisplay
+  module Concerns
+    # Methods for extracting and formatting related resources from Cocina records.
+    module RelatedResources
+      # Resources related to the object.
+      # @return [Array<CocinaDisplay::RelatedResource>]
+      def related_resources
+        @related_resources ||= path("$.description.relatedResource[*]").map { |res| RelatedResource.new(res) }
+      end
+
+      # Display data for related resources.
+      # @note Related resources also have their own nested display data.
+      # @see CocinaDisplay::RelatedResource#display_data
+      # @return [Array<DisplayData>]
+      def related_resource_display_data
+        DisplayData.from_objects(related_resources)
+      end
+    end
+  end
+end

data/lib/cocina_display/concerns/subjects.rb

@@ -1,6 +1,3 @@
-require_relative "../subjects/subject"
-require_relative "../subjects/subject_value"
-
 module CocinaDisplay
   module Concerns
     # Methods for extracting and formatting subject information.
@@ -87,25 +84,45 @@ module CocinaDisplay
       # @see Subject#to_s
       # @return [Array<String>]
       def subject_all_display
-        subjects.map(&:to_s).uniq
+        all_subjects.map(&:to_s).uniq
+      end
+
+      # Subject data to be rendered for display.
+      # Uses the concatenated form for structured subject values.
+      # @see Subject#to_s
+      # @return [Array<DisplayData>]
+      def subject_display_data
+        CocinaDisplay::DisplayData.from_objects(all_subjects - classification_subjects - genre_subjects - coordinate_subjects)
       end
 
       private
 
-      # All subjects, accessible as Subject objects.
+      # All subjects, accessible as {Subject} objects.
       # Checks both description.subject and description.geographic.subject.
       # @return [Array<Subject>]
-      def subjects
-        @subjects ||= Enumerator::Chain.new(
+      def all_subjects
+        @all_subjects ||= Enumerator::Chain.new(
           path("$.description.subject[*]"),
           path("$.description.geographic.*.subject[*]")
         ).map { |s| CocinaDisplay::Subjects::Subject.new(s) }
       end
 
+      # {Subject} objects with type "genre".
+      # @return [Array<Subject>]
+      def genre_subjects
+        all_subjects.filter { |subject| subject.type == "genre" }
+      end
+
+      # {Subject} objects with type "classification".
+      # @return [Array<Subject>]
+      def classification_subjects
+        all_subjects.filter { |subject| subject.type == "classification" }
+      end
+
       # All subject values, flattened from all subjects.
       # @return [Array<SubjectValue>]
       def subject_values
-        @subject_values ||= subjects.flat_map(&:subject_values)
+        @subject_values ||= all_subjects.flat_map(&:subject_values)
       end
 
       # All subject values that are named places.