cocina-models 0.74.1 → 0.77.0

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps adminMetadata from cocina to MODS XML recordInfo
+        class AdminMetadata
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Cocina::Models::DescriptiveAdminMetadata] admin_metadata
+          def self.write(xml:, admin_metadata:)
+            new(xml: xml, admin_metadata: admin_metadata).write
+          end
+
+          def initialize(xml:, admin_metadata:)
+            @xml = xml
+            @admin_metadata = admin_metadata
+          end
+
+          def write
+            return unless admin_metadata
+
+            xml.recordInfo do
+              build_language
+              build_content_source
+              build_description_standard
+              build_record_origin
+              build_record_info_notes
+              build_event
+              build_identifier
+            end
+          end
+
+          private
+
+          attr_reader :xml, :admin_metadata
+
+          def build_record_origin
+            Array(admin_metadata.note).select { |note| note.type == 'record origin' }.each do |note|
+              xml.recordOrigin note.value
+            end
+          end
+
+          def build_record_info_notes
+            record_info_notes = Array(admin_metadata.note)
+            # return unless record_info_notes
+            return if record_info_notes.empty?
+
+            record_info_notes.each do |info_note|
+              if info_note.valueAt.present?
+                xml.recordInfoNote nil, { 'xlink:href' => info_note.valueAt }
+              elsif info_note.type == 'record information'
+                xml.recordInfoNote info_note.value
+              end
+            end
+          end
+
+          def build_content_source
+            Array(admin_metadata.contributor).each do |contributor|
+              source = contributor.name.first
+              xml.recordContentSource source.code || source.value, with_uri_info(source)
+            end
+          end
+
+          def build_description_standard
+            return if admin_metadata.metadataStandard.blank?
+
+            admin_metadata.metadataStandard.each do |standard|
+              xml.descriptionStandard standard.code || standard.value, with_uri_info(standard)
+            end
+          end
+
+          def build_event
+            build_event_for('creation', 'recordCreationDate')
+            build_event_for('modification', 'recordChangeDate')
+          end
+
+          def build_event_for(type, tag)
+            Array(admin_metadata.event).select { |note| note.type == type }.each do |event|
+              event.date.each do |date|
+                attributes = {}.tap do |attrs|
+                  attrs[:encoding] = date.encoding&.code
+                end.compact
+
+                xml.public_send(tag, date.value, attributes)
+              end
+            end
+          end
+
+          def build_identifier
+            Array(admin_metadata.identifier).each do |identifier|
+              id_attributes = {
+                displayLabel: identifier.displayLabel,
+                source: identifier.uri ? 'uri' : Cocina::Models::Mapping::FromMods::IdentifierType.mods_type_for_cocina_type(identifier.type)
+              }.tap do |attrs|
+                attrs[:invalid] = 'yes' if identifier.status == 'invalid'
+              end.compact
+              xml.recordIdentifier identifier.value || identifier.uri, id_attributes
+            end
+          end
+
+          def build_language
+            Array(admin_metadata.language).each do |language|
+              language_of_cataloging_attrs = {}
+              language_of_cataloging_attrs[:usage] = language.status if language.status
+              xml.languageOfCataloging language_of_cataloging_attrs do
+                language_attrs = with_uri_info(language, {})
+                xml.languageTerm language.value, language_attrs.merge(type: 'text') if language.value
+                xml.languageTerm language.code, language_attrs.merge(type: 'code') if language.code
+                if language.script
+                  script_attrs = with_uri_info(language.script, {})
+                  xml.scriptTerm language.script.value, script_attrs.merge(type: 'text')
+                  xml.scriptTerm language.script.code, script_attrs.merge(type: 'code')
+                end
+              end
+            end
+          end
+
+          def with_uri_info(cocina, xml_attrs = {})
+            xml_attrs[:valueURI] = cocina.uri
+            xml_attrs[:authorityURI] = cocina.source&.uri
+            xml_attrs[:authority] = cocina.source&.code
+            xml_attrs.compact
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps contributors from cocina to MODS XML
+        class Contributor
+          # one way mapping:  MODS 'corporate' already maps to Cocina 'organization'
+          NAME_TYPE = Cocina::Models::Mapping::FromMods::Contributor::ROLES.invert.merge('event' => 'corporate').freeze
+          NAME_PART = Cocina::Models::Mapping::FromMods::Contributor::NAME_PART.invert.freeze
+
+          # NOTE: contributors in nameTitleGroups are output as part of Title.
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Array<Cocina::Models::Contributor>] contributors
+          # @params [Array<Cocina::Models::Title>] titles
+          # @params [IdGenerator] id_generator
+          def self.write(xml:, contributors:, titles:, id_generator:)
+            new(xml: xml, contributors: contributors, titles: titles, id_generator: id_generator).write
+          end
+
+          def initialize(xml:, contributors:, titles:, id_generator:)
+            @xml = xml
+            @contributors = contributors
+            @titles = titles
+            @id_generator = id_generator
+          end
+
+          # NOTE: contributors in nameTitleGroups are output as part of Title.
+          def write
+            Array(contributors)
+              .reject do |contributor|
+              NameTitleGroup.in_name_title_group?(contributor: contributor,
+                                                  titles: titles)
+            end
+              .each do |contributor|
+              NameWriter.write(xml: xml, contributor: contributor,
+                               id_generator: id_generator)
+            end
+          end
+
+          private
+
+          attr_reader :xml, :contributors, :titles, :id_generator
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # This transforms the DRO.description schema to MODS xml
+        class Description
+          # @param [Cocina::Models::Description] description
+          # @param [string] druid
+          # @return [Nokogiri::XML::Document]
+          def self.transform(description, druid)
+            new(description, druid).transform
+          end
+
+          def initialize(description, druid)
+            @description = description
+            @druid = druid
+          end
+
+          # @return [Nokogiri::XML::Document]
+          def transform
+            Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+              xml.mods(mods_attributes) do
+                ModsWriter.write(xml: xml, description: description, druid: druid)
+              end
+            end.doc
+          end
+
+          private
+
+          attr_reader :description, :druid
+
+          def mods_version
+            @mods_version ||= begin
+              notes = description.adminMetadata&.note || []
+              notes.select { |note| note.type == 'record origin' }.each do |note|
+                match = /MODS version (\d\.\d)/.match(note.value)
+                return match[1] if match
+              end
+              '3.7'
+            end
+          end
+
+          def mods_attributes
+            {
+              'xmlns' => 'http://www.loc.gov/mods/v3',
+              'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+              'xmlns:rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+              'xmlns:xlink' => 'http://www.w3.org/1999/xlink',
+              'version' => mods_version,
+              'xsi:schemaLocation' => "http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-#{mods_version.sub(
+                '.', '-'
+              )}.xsd"
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps events from cocina to MODS XML
+        class Event # rubocop:disable Metrics/ClassLength
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Array<Cocina::Models::Event>] events
+          # @params [IdGenerator] id_generator
+          def self.write(xml:, events:, id_generator:)
+            new(xml: xml, events: events, id_generator: id_generator).write
+          end
+
+          def initialize(xml:, events:, id_generator:)
+            @xml = xml
+            @events = events
+            @id_generator = id_generator
+          end
+
+          def write
+            Array(events).each do |event|
+              if event.parallelEvent.present?
+                write_parallel(event, id_generator.next_altrepgroup)
+              else
+                write_basic(event, event.type)
+              end
+            end
+          end
+
+          private
+
+          attr_reader :xml, :events, :id_generator
+
+          def write_basic(event, event_type)
+            names = Array(event.contributor).map { |contributor| contributor.name.first }
+            attributes = {
+              displayLabel: event.displayLabel,
+              eventType: event_type,
+              script: event.valueLanguage&.valueScript&.code,
+              lang: event.valueLanguage&.code
+            }.compact
+
+            write_event(event.type, event.date, event.location, names, event.note, attributes)
+          end
+
+          def write_parallel(event, alt_rep_group)
+            event.parallelEvent.each do |parallel_event|
+              attributes = {}.tap do |attrs|
+                attrs[:script] = parallel_event.valueLanguage&.valueScript&.code
+                attrs[:lang] = parallel_event.valueLanguage&.code
+                attrs[:altRepGroup] = alt_rep_group
+                attrs[:eventType] = event.type || parallel_event.type
+                attrs[:displayLabel] = event.displayLabel || parallel_event.displayLabel
+              end.compact
+
+              names = Array(parallel_event.contributor).map(&:name).flatten
+              write_event(parallel_event.type,
+                          parallel_event.date,
+                          parallel_event.location,
+                          names,
+                          parallel_event.note,
+                          attributes)
+            end
+          end
+
+          # rubocop:disable Metrics/ParameterLists
+          def write_event(cocina_event_type, dates, locations, names, notes, attributes, is_parallel: false)
+            return if dates.blank? && locations.blank? && names.blank? && notes.blank?
+
+            xml.originInfo attributes do
+              Array(dates).each do |date|
+                write_basic_date(date, cocina_event_type)
+              end
+              Array(locations).each do |loc|
+                write_location(loc)
+              end
+              Array(names).each do |name|
+                xml.publisher name.value, name_attributes(name)
+              end
+              Array(notes).each do |note|
+                write_note(note)
+              end
+            end
+          end
+          # rubocop:enable Metrics/ParameterLists
+
+          def write_note(note)
+            attributes = {}
+            attributes[:authority] = note.source.code if note&.source&.code
+            xml.send(note_tag_for(note), note.value, attributes)
+          end
+
+          def note_tag_for(note)
+            return 'copyrightDate' if note.type == 'copyright statement'
+            return note.type if note.type
+
+            'edition'
+          end
+
+          def write_location(location)
+            place_attrs = {}.tap do |attrs|
+              attrs[:supplied] = 'yes' if location.type == 'supplied'
+            end
+            xml.place place_attrs do
+              placeterm_attrs = {}
+              placeterm_attrs[:authority] = location.source.code if location.source&.code
+              placeterm_attrs[:authorityURI] = location.source.uri if location.source&.uri
+              placeterm_attrs[:valueURI] = location.uri if location.uri
+
+              placeterm_text_attrs = placeterm_attrs.merge({ type: 'text' })
+              xml.placeTerm location.value, placeterm_text_attrs if location.value
+
+              placeterm_code_attrs = placeterm_attrs.merge({ type: 'code' })
+              xml.placeTerm location.code, placeterm_code_attrs if location.code
+            end
+          end
+
+          def write_basic_date(date, cocina_event_type)
+            if date.structuredValue.present?
+              structured_val_attribs = {
+                encoding: date.encoding,
+                qualifier: date.qualifier,
+                type: date.type
+              }
+              date_type = cocina_event_type
+              date_type = date.type if date.type.present?
+              date_range(date.structuredValue, date_type, structured_val_attribs)
+            else
+              write_date_element(date, cocina_event_type)
+            end
+          end
+
+          # @param [Hash] structured_val_attribs - populated when structuredValue parent has attributes for individual date elements
+          def write_date_element(date, cocina_event_type, structured_val_attribs = {})
+            value = date.value
+            element_name = date_element_name(date, cocina_event_type, structured_val_attribs[:type])
+            attributes = {}.tap do |attrs|
+              attrs[:encoding] = date.encoding&.code || structured_val_attribs[:encoding]&.code
+              attrs[:qualifier] = date.qualifier || structured_val_attribs[:qualifier]
+              attrs[:keyDate] = 'yes' if date.status == 'primary'
+              attrs[:type] = date_type_attr(date, element_name)
+              attrs[:calendar] = calendar_attr(date)
+              attrs[:point] = date.type if %w[start end].include?(date.type)
+            end.compact
+            xml.public_send(element_name, value, attributes)
+          end
+
+          def date_element_name(date, cocina_event_type, structured_val_type)
+            el_name = Cocina::Models::Mapping::FromMods::Event::DATE_ELEMENTS_2_TYPE.key(structured_val_type)
+            return el_name if el_name.present?
+
+            el_name = Cocina::Models::Mapping::FromMods::Event::DATE_ELEMENTS_2_TYPE.key(date.type)
+            return el_name if el_name.present?
+
+            # the date type overrides the eventType for choosing date flavor, even if it ends up with dateOther
+            return 'dateOther' if date.type.present?
+
+            if cocina_event_type.present?
+              el_name = Cocina::Models::Mapping::FromMods::Event::DATE_ELEMENTS_2_TYPE.key(cocina_event_type)
+              return el_name if el_name.present?
+            end
+
+            'dateOther'
+          end
+
+          # MODS only allows a type attr on dateOther; no other date flavors
+          def date_type_attr(cocina_date, date_element_name)
+            return unless date_element_name == 'dateOther'
+
+            cocina_date.type if cocina_date.type.present? && %w[start end].exclude?(cocina_date.type)
+          end
+
+          def calendar_attr(cocina_date)
+            return if cocina_date.note.blank?
+
+            cocina_date.note.each do |note|
+              return note.value if note.type == 'calendar'
+            end
+          end
+
+          def date_range(dates, cocina_event_type, structured_val_attribs)
+            dates.each do |date|
+              write_date_element(date, cocina_event_type, structured_val_attribs)
+            end
+          end
+
+          def name_attributes(cocina_name)
+            {
+              lang: cocina_name&.valueLanguage&.code,
+              script: cocina_name&.valueLanguage&.valueScript&.code,
+              transliteration: cocina_name&.standard&.value
+            }.compact
+          end
+        end
+      end
+    end
+  end
+end