cocina-models 0.74.1 → 0.77.0

data/lib/cocina/models/mapping/to_mods/form.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps forms from cocina to MODS XML
+        class Form # rubocop:disable Metrics/ClassLength
+          # NOTE: H2 is the first case of structured form values we're implementing
+          H2_SOURCE_LABEL = 'Stanford self-deposit resource types'
+          PHYSICAL_DESCRIPTION_TAG = {
+            'reformatting quality' => :reformattingQuality,
+            'form' => :form,
+            'media type' => :internetMediaType,
+            'extent' => :extent,
+            'digital origin' => :digitalOrigin,
+            'media' => :form,
+            'carrier' => :form,
+            'material' => :form,
+            'technique' => :form
+          }.freeze
+
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Array<Cocina::Models::DescriptiveValue>] forms
+          # @params [IdGenerator] id_generator
+          def self.write(xml:, forms:, id_generator:)
+            new(xml: xml, forms: forms, id_generator: id_generator).write
+          end
+
+          def initialize(xml:, forms:, id_generator:)
+            @xml = xml
+            @forms = forms
+            @id_generator = id_generator
+          end
+
+          def write
+            other_forms = Array(forms).reject do |form|
+              physical_description?(form) || manuscript?(form) || collection?(form)
+            end
+            is_manuscript = Array(forms).any? { |form| manuscript?(form) }
+            is_collection = Array(forms).any? { |form| collection?(form) }
+
+            if other_forms.present?
+              write_other_forms(other_forms, is_manuscript, is_collection)
+            else
+              write_attributes_only(is_manuscript, is_collection)
+            end
+
+            write_physical_descriptions
+          end
+
+          private
+
+          attr_reader :xml, :forms, :id_generator
+
+          def physical_description?(form, type: nil)
+            (form.note.present? && form.type != 'genre') ||
+              PHYSICAL_DESCRIPTION_TAG.key?(type) ||
+              PHYSICAL_DESCRIPTION_TAG.key?(form.type) ||
+              PHYSICAL_DESCRIPTION_TAG.key?(form.groupedValue&.first&.type) ||
+              (form.parallelValue.present? && physical_description?(form.parallelValue.first))
+          end
+
+          def manuscript?(form)
+            form.value == 'manuscript' && form.source&.value == 'MODS resource types'
+          end
+
+          def collection?(form)
+            form.value == 'collection' && form.source&.value == 'MODS resource types'
+          end
+
+          def write_other_forms(forms, is_manuscript, is_collection)
+            forms.each do |form|
+              if form.parallelValue.present?
+                write_parallel_forms(form, is_manuscript, is_collection)
+              else
+                write_form(form, is_manuscript, is_collection)
+              end
+            end
+          end
+
+          def write_parallel_forms(form, is_manuscript, is_collection)
+            alt_rep_group = id_generator.next_altrepgroup
+            form.parallelValue.each do |form_value|
+              write_form(form_value, is_manuscript, is_collection, alt_rep_group: alt_rep_group)
+            end
+          end
+
+          def write_form(form, is_manuscript, is_collection, alt_rep_group: nil)
+            if form.structuredValue.present?
+              write_structured(form)
+            elsif form.value
+              write_basic(form, is_manuscript: is_manuscript, is_collection: is_collection,
+                                alt_rep_group: alt_rep_group)
+            end
+          end
+
+          def write_physical_descriptions
+            parallel_physical_descr_forms, other_physical_descr_forms = Array(forms).select do |form|
+                                                                          physical_description?(form)
+                                                                        end.partition { |form| form.parallelValue.present? }
+            write_physical_description(other_physical_descr_forms)
+
+            parallel_physical_descr_forms.each do |parallel_physical_descr_form|
+              alt_rep_group = id_generator.next_altrepgroup
+              write_physical_description(parallel_physical_descr_form.parallelValue, alt_rep_group: alt_rep_group,
+                                                                                     display_label: parallel_physical_descr_form.displayLabel,
+                                                                                     form: parallel_physical_descr_form)
+            end
+          end
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def write_physical_description(physical_descr_forms, alt_rep_group: nil, display_label: nil, form: nil)
+            grouped_forms = []
+            # Each of these are its own physicalDescription
+            simple_forms = []
+            # These all get grouped together to form a single physicalDescription.
+            other_forms = []
+            other_notes = []
+            Array(physical_descr_forms).select do |physical_descr_form|
+              physical_description?(physical_descr_form, type: form&.type)
+            end.each do |physical_descr_form|
+              if physical_descr_form.groupedValue.present?
+                grouped_forms << physical_descr_form
+              elsif merge_form?(physical_descr_form, display_label) || alt_rep_group
+                simple_forms << physical_descr_form
+              else
+                other_notes << physical_descr_form if physical_descr_form.note.present?
+                other_forms << physical_descr_form if physical_descr_form.value
+              end
+            end
+
+            if other_forms.present?
+              write_basic_physical_description(other_forms, other_notes, alt_rep_group: alt_rep_group, form: form)
+            else
+              other_notes.each do |other_note|
+                write_basic_physical_description([], [other_note], alt_rep_group: alt_rep_group, form: form)
+              end
+            end
+            simple_forms.each do |simple_form|
+              write_basic_physical_description([simple_form], [simple_form], alt_rep_group: alt_rep_group,
+                                                                             form: form)
+            end
+            grouped_forms.each do |grouped_form|
+              write_grouped_physical_description(grouped_form, alt_rep_group: alt_rep_group, form: form)
+            end
+          end
+
+          # rubocop:enable Metrics/CyclomaticComplexity
+          def merge_form?(form, display_label)
+            form.value && (Array(form.note).any? do |note|
+                             note.type != 'unit'
+                           end || form.displayLabel || display_label)
+          end
+
+          def write_basic_physical_description(forms, note_forms, alt_rep_group: nil, form: nil)
+            physical_description_attrs = {
+              displayLabel: forms.first&.displayLabel || form&.displayLabel,
+              altRepGroup: alt_rep_group
+            }.compact
+
+            xml.physicalDescription physical_description_attrs do
+              write_physical_description_form_values(forms, form: form)
+              note_forms.each { |note_form| write_notes(note_form) if note_form.present? }
+            end
+          end
+
+          def write_grouped_physical_description(grouped_form, alt_rep_group: nil, form: nil)
+            physical_description_attrs = {
+              displayLabel: grouped_form.displayLabel || form&.displayLabel,
+              altRepGroup: alt_rep_group
+            }.compact
+
+            xml.physicalDescription physical_description_attrs do
+              write_physical_description_form_values(grouped_form.groupedValue, form: form)
+              write_notes(grouped_form)
+            end
+          end
+
+          def write_physical_description_form_values(form_values, form: nil)
+            form_values.each do |form_value|
+              form_type = form_value.type || form&.type
+              attributes = {
+                unit: unit_for(form_value)
+              }.tap do |attrs|
+                if PHYSICAL_DESCRIPTION_TAG.fetch(form_type) == :form && form_type != 'form'
+                  attrs[:type] =
+                    form_type
+                end
+              end.compact
+
+              xml.public_send PHYSICAL_DESCRIPTION_TAG.fetch(form_type), form_value.value,
+                              attributes.merge(uri_attrs(form_value)).merge(uri_attrs(form))
+            end
+          end
+
+          def write_notes(form)
+            Array(form.note).reject { |note| note.type == 'unit' }.each do |note|
+              attributes = {
+                displayLabel: note.displayLabel,
+                type: note.type
+              }.compact
+              xml.note note.value, attributes
+            end
+          end
+
+          def write_basic(form, is_manuscript: false, is_collection: false, alt_rep_group: nil)
+            return write_datacite(form) if form.source&.value == 'DataCite resource types'
+
+            attributes = form_attributes(form, alt_rep_group)
+
+            case form.type
+            when 'resource type'
+              attributes[:manuscript] = 'yes' if is_manuscript
+              attributes[:collection] = 'yes' if is_collection
+              xml.typeOfResource form.value, attributes
+            when 'map scale', 'map projection'
+              # do nothing, these end up in subject/cartographics
+            else # genre
+              xml.genre form.value, attributes.merge({ type: genre_type_for(form) }.compact)
+            end
+          end
+
+          def write_datacite(form)
+            xml.extension displayLabel: 'datacite' do
+              xml.resourceType(datacite_resource_type, resourceTypeGeneral: form.value)
+            end
+          end
+
+          def datacite_resource_type
+            self_deposit_types = forms.find do |candidate|
+              candidate.source.value == 'Stanford self-deposit resource types'
+            end
+            return unless self_deposit_types
+
+            parts = self_deposit_types.structuredValue.select do |val|
+              val.type == 'subtype'
+            end.presence || self_deposit_types.structuredValue
+            parts.map(&:value).join('; ')
+          end
+
+          def unit_for(form)
+            Array(form.note).find { |note| note.type == 'unit' }&.value
+          end
+
+          def genre_type_for(form)
+            Array(form.note).find { |note| note.type == 'genre type' }&.value
+          end
+
+          def form_attributes(form, alt_rep_group)
+            {
+              altRepGroup: alt_rep_group,
+              displayLabel: form.displayLabel,
+              usage: form.status,
+              lang: form.valueLanguage&.code,
+              script: form.valueLanguage&.valueScript&.code
+            }.merge(uri_attrs(form)).compact
+          end
+
+          def write_attributes_only(is_manuscript, is_collection)
+            return unless is_manuscript || is_collection
+
+            attributes = {}
+            attributes[:manuscript] = 'yes' if is_manuscript
+            attributes[:collection] = 'yes' if is_collection
+            xml.typeOfResource(nil, attributes)
+          end
+
+          def write_structured(form)
+            # The only use case we're supporting for structured forms at the
+            # moment is for H2. Short-circuit if that's not what we get.
+            return if form.source.value != H2_SOURCE_LABEL
+
+            form.structuredValue.each do |genre|
+              xml.genre genre.value, type: "H2 #{genre.type}"
+            end
+          end
+
+          def uri_attrs(form)
+            return {} if form.nil?
+
+            {
+              valueURI: form.uri,
+              authorityURI: form.source&.uri,
+              authority: form.source&.code
+            }.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/to_mods/geographic.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps geo extension from cocina to MODS
+        class Geographic # rubocop:disable Metrics/ClassLength
+          TYPE_REGEX = /^type$/.freeze
+          MEDIA_REGEX = /^media type$/.freeze
+          DATA_FORMAT_REGEX = /^data format$/.freeze
+
+          ABOUT_URI_PREFIX = 'http://purl.stanford.edu/'
+
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Array<Cocina::Models::DescriptiveValue>] geos
+          def self.write(xml:, geos:, druid:)
+            new(xml: xml, geos: geos, druid: druid).write
+          end
+
+          def initialize(xml:, geos:, druid:)
+            @xml = xml
+            @geos = geos
+            @druid = druid
+          end
+
+          def write
+            return if geos.blank?
+
+            geos.map do |geo|
+              attributes = {}
+              attributes[:displayLabel] = 'geo'
+              xml.extension attributes do
+                xml['rdf'].RDF(format_namespace(geo)) do
+                  xml['rdf'].Description('rdf:about' => about(druid)) do
+                    add_format(extract_format(geo))
+                    add_type(extract_type(geo))
+                    add_content(geo)
+                  end
+                end
+              end
+            end
+          end
+
+          private
+
+          attr_reader :xml, :geos, :druid
+
+          def format_namespace(geo)
+            namespace = {
+              'xmlns:gml' => 'http://www.opengis.net/gml/3.2/',
+              'xmlns:dc' => 'http://purl.org/dc/elements/1.1/'
+            }
+
+            if geo.subject&.first&.type&.include? 'point coordinates'
+              namespace['xmlns:gmd'] =
+                'http://www.isotc211.org/2005/gmd'
+            end
+
+            namespace
+          end
+
+          def extract_format(geo)
+            media_type = geo.form.find { |form| form.type.match(MEDIA_REGEX) && form[:value] != 'Image' }
+            data_format = geo.form.find { |form| form.type.match(DATA_FORMAT_REGEX) }
+
+            return "#{media_type.value}; format=#{data_format.value}" if data_format && media_type
+
+            media_type&.value
+          end
+
+          def extract_type(geo)
+            type = geo[:form].find do |form|
+              form[:type].match(TYPE_REGEX) || (form[:type].match(MEDIA_REGEX) && form[:value] == 'Image')
+            end
+            return type[:value] if type
+
+            nil
+          end
+
+          def about(druid)
+            "#{ABOUT_URI_PREFIX}#{druid.delete_prefix('druid:')}"
+          end
+
+          def add_format(data)
+            xml['dc'].format data if data
+          end
+
+          def add_type(type)
+            xml['dc'].type type if type
+          end
+
+          def add_content(geo)
+            type = geo.subject&.first&.type
+            case type
+            when 'point coordinates'
+              add_centerpoint(geo)
+            when 'bounding box coordinates'
+              add_bounding_box(geo)
+              add_coverage(geo)
+            end
+          end
+
+          def add_centerpoint(geo)
+            lat = geo.subject.first.structuredValue.find { |point| point.type.include? 'latitude' }.value
+            long = geo.subject.first.structuredValue.find { |point| point.type.include? 'longitude' }.value
+            xml['gmd'].centerPoint do
+              xml['gml'].Point do
+                xml['gml'].pos "#{lat} #{long}"
+              end
+            end
+          end
+
+          def add_bounding_box(geo)
+            standard_tag = {}
+            standard = geo.subject.first.standard
+            standard_tag = { 'gml:srsName' => standard[:code] } if standard
+            xml['gml'].boundedBy do
+              xml['gml'].Envelope(standard_tag) do
+                bounding_box_coordinates = bounding_box_coordinates_for(geo)
+                xml['gml'].lowerCorner "#{bounding_box_coordinates[:west]} #{bounding_box_coordinates[:south]}"
+                xml['gml'].upperCorner "#{bounding_box_coordinates[:east]} #{bounding_box_coordinates[:north]}"
+              end
+            end
+          end
+
+          def bounding_box_coordinates_for(geo)
+            {}.tap do |coords|
+              geo.subject.first.structuredValue.each do |direction|
+                coords[direction.type.to_sym] = direction.value
+              end
+            end
+          end
+
+          def add_coverage(geo)
+            coverage = geo[:subject].find_all { |sub| sub[:type].include? 'coverage' }
+            return nil if coverage.empty?
+
+            coverage.map do |data|
+              coverage_attributes = {}
+              coverage_attributes['rdf:resource'] = data.uri if data.uri
+              coverage_attributes['dc:language'] = data.valueLanguage.code if data.valueLanguage&.code
+              coverage_attributes['dc:title'] = data.value if data.value
+              xml['dc'].coverage coverage_attributes
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/to_mods/id_generator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Helper class - generates altRepGroup and nameTitleGroup ids.
+        class IdGenerator
+          def initialize
+            @alt_rep_group = 0
+            @name_title_group = 0
+          end
+
+          def next_altrepgroup
+            @alt_rep_group += 1
+          end
+
+          def next_nametitlegroup
+            @name_title_group += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/to_mods/identifier.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps identifiers from cocina to MODS XML
+        class Identifier
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Array<Cocina::Models::DescriptiveValue>] identifiers
+          # @params [IdGenerator] id_generator
+          def self.write(xml:, identifiers:, id_generator:)
+            new(xml: xml, identifiers: identifiers, id_generator: id_generator).write
+          end
+
+          def initialize(xml:, identifiers:, id_generator:)
+            @xml = xml
+            @identifiers = identifiers
+            @id_generator = id_generator
+          end
+
+          def write
+            Array(identifiers).each do |identifier|
+              if identifier.parallelValue.present?
+                write_parallel(identifier)
+              else
+                write_identifier(identifier)
+              end
+            end
+          end
+
+          private
+
+          attr_reader :xml, :identifiers, :id_generator
+
+          def write_parallel(parallel_identifier)
+            altrepgroup_id = id_generator.next_altrepgroup
+            parallel_identifier.parallelValue.each do |identifier|
+              write_identifier(identifier, altrepgroup_id: altrepgroup_id)
+            end
+          end
+
+          def write_identifier(identifier, altrepgroup_id: nil)
+            id_attributes = {
+              displayLabel: identifier.displayLabel,
+              type: identifier.uri ? 'uri' : Cocina::Models::Mapping::FromMods::IdentifierType.mods_type_for_cocina_type(identifier.type),
+              altRepGroup: altrepgroup_id
+            }.tap do |attrs|
+              attrs[:invalid] = 'yes' if identifier.status == 'invalid'
+            end.compact
+            xml.identifier identifier.value || identifier.uri, id_attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/to_mods/language.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps languages from cocina to MODS XML
+        class Language
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Array<Cocina::Models::Language>] languages
+          def self.write(xml:, languages:)
+            new(xml: xml, languages: languages).write
+          end
+
+          def initialize(xml:, languages:)
+            @xml = xml
+            @languages = languages
+          end
+
+          def write
+            Array(languages).each do |language|
+              write_basic(language)
+            end
+          end
+
+          private
+
+          attr_reader :xml, :languages
+
+          # rubocop:disable Metrics/AbcSize
+          def write_basic(language)
+            top_attributes = {}
+            top_attributes[:displayLabel] = language.displayLabel if language.displayLabel
+            applies_to = applies_to_first_value(language.appliesTo)
+            top_attributes[:objectPart] = applies_to if applies_to
+            top_attributes[:usage] = language.status if language.status
+            xml.language top_attributes do
+              attributes = {}
+              attributes[:valueURI] = language.uri if language.uri
+              attributes[:authorityURI] = language.source.uri if language.source&.uri
+              attributes[:authority] = language.source.code if language.source&.code
+
+              if language.value
+                attributes[:type] = 'text'
+                xml.languageTerm language.value, attributes
+              end
+
+              if language.code
+                attributes[:type] = 'code'
+                xml.languageTerm language.code, attributes
+              end
+
+              write_script(language.script) if language.script
+            end
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def write_script(script)
+            attributes = {}
+            attributes[:authority] = script.source.code if script.source&.code
+
+            if script.value
+              attributes[:type] = 'text'
+              xml.scriptTerm script.value, attributes
+            end
+
+            return unless script.code
+
+            attributes[:type] = 'code'
+            xml.scriptTerm script.code, attributes
+          end
+
+          # NOTE: appliesTo is an array in cocina model, but it is an xml attribute (thus single value) in MODS ...
+          # get value from DescriptiveBasicValue
+          def applies_to_first_value(applies_to)
+            applies_to&.first&.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/to_mods/mods_writer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps description resource from cocina to MODS XML
+        class ModsWriter
+          # @params [Nokogiri::XML::Builder] xml
+          # @param [Cocina::Models::Description] description
+          # @param [string] druid
+          def self.write(xml:, description:, druid:, id_generator: IdGenerator.new)
+            # ID Generator makes sure that different writers create unique altRepGroups and nameTitleGroups.
+            if description.title
+              Title.write(xml: xml, titles: description.title, contributors: description.contributor,
+                          id_generator: id_generator)
+            end
+            Contributor.write(xml: xml, contributors: description.contributor, titles: description.title,
+                              id_generator: id_generator)
+            Form.write(xml: xml, forms: description.form, id_generator: id_generator)
+            Language.write(xml: xml, languages: description.language)
+            Note.write(xml: xml, notes: description.note, id_generator: id_generator)
+            Subject.write(xml: xml, subjects: description.subject, forms: description.form,
+                          id_generator: id_generator)
+            Event.write(xml: xml, events: description.event, id_generator: id_generator)
+            Identifier.write(xml: xml, identifiers: description.identifier, id_generator: id_generator)
+            Access.write(xml: xml, access: description.access,
+                         purl: description.respond_to?(:purl) ? description.purl : nil)
+            AdminMetadata.write(xml: xml, admin_metadata: description.adminMetadata)
+            RelatedResource.write(xml: xml, related_resources: description.relatedResource, druid: druid,
+                                  id_generator: id_generator)
+            Geographic.write(xml: xml, geos: description.geographic, druid: druid) if description.respond_to?(:geographic)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/to_mods/name_title_group.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Helpers for MODS nameTitleGroups.
+        class NameTitleGroup
+          # @params [Cocina::Models::Contributor] contributor
+          # @params [Array<Cocina::Models::Title>] titles
+          # @return [boolean] true if contributor part of name title group
+          def self.in_name_title_group?(contributor:, titles:)
+            return false if contributor&.name.blank? || titles.blank?
+
+            contrib_name_value_slices = Cocina::Models::Builders::NameTitleGroupBuilder.contributor_name_value_slices(contributor)
+            Array(titles).each do |title|
+              name_title_group_names = Cocina::Models::Builders::NameTitleGroupBuilder.build_title_values_to_contributor_name_values(title)&.values
+              name_title_group_names.each do |name|
+                return true if contrib_name_value_slices.include?(name)
+              end
+            end
+
+            false
+          end
+        end
+      end
+    end
+  end
+end