cocina-models 0.74.1 → 0.77.0

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Writes MODS XML name elements from cocina contributor
+        class NameWriter # rubocop:disable Metrics/ClassLength
+          # one way mapping:  MODS 'corporate' already maps to Cocina 'organization'
+          NAME_TYPE = Cocina::Models::Mapping::FromMods::Contributor::ROLES.invert.freeze
+          NAME_PART = Cocina::Models::Mapping::FromMods::Contributor::NAME_PART.invert.merge('activity dates' => 'date').freeze
+          UNCITED_DESCRIPTION = 'not included in citation'
+
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Cocina::Models::Contributor] contributor
+          # @params [IdGenerator] id_generator
+          # @params [Hash<Hash, Hash<Hash, Integer>>] name_title_vals_index is a Hash
+          #   the key is a hash representing a single contributor name, with a key of :value or :structuredValue
+          #   the value is a hash, where
+          #      the key is a hash representing a single title value, with a key of :value or :structuredValue
+          #      the value is the nameTitleGroup number as an Integer
+          #   e.g. {{:value=>"James Joyce"}=>{:value=>"Portrait of the artist as a young man"}=>1}
+          def self.write(xml:, contributor:, id_generator:, name_title_vals_index: {})
+            new(xml: xml, contributor: contributor, id_generator: id_generator,
+                name_title_vals_index: name_title_vals_index).write
+          end
+
+          def initialize(xml:, contributor:, id_generator:, name_title_vals_index: {})
+            @xml = xml
+            @contributor = contributor
+            @id_generator = id_generator
+            @name_title_vals_index = name_title_vals_index
+          end
+
+          def write
+            if contributor.type == 'unspecified others'
+              write_etal
+            elsif contributor.name.present?
+              contrib_name = contributor.name.first
+              parallel_values = contrib_name.parallelValue
+              if parallel_values.present?
+                altrepgroup_id = id_generator.next_altrepgroup
+                parallel_values.each do |parallel_contrib_name|
+                  Cocina::Models::Builders::NameTitleGroupBuilder.value_slices(parallel_contrib_name)&.each do |parallel_contrib_name_slice|
+                    if name_title_vals_index[parallel_contrib_name_slice]
+                      name_title_group = name_title_vals_index[parallel_contrib_name_slice]&.values&.first
+                      write_parallel_contributor(contributor, contrib_name, parallel_contrib_name,
+                                                 name_title_group, altrepgroup_id)
+                    else
+                      # TODO:  want a way to notify that we hit a problem - either notifier or HB error (issue #3751)
+                      #  OR validate for semantic correctness upon creation/update so we can't get here.
+                      #  notifier.warn("For contributor name '#{parallel_contrib_name_val}', no title matching '#{title_from_contrib}'")
+                      write_parallel_contributor(contributor, contrib_name, parallel_contrib_name, nil,
+                                                 altrepgroup_id)
+                    end
+                  end
+                end
+              else
+                write_contributor(contributor)
+              end
+            end
+          end
+
+          private
+
+          attr_reader :xml, :contributor, :name_title_vals_index, :id_generator
+
+          def write_etal
+            xml.name do
+              xml.etal
+            end
+          end
+
+          def write_contributor(contributor)
+            name_title_group = nil
+
+            contrib_name_value_slices = Cocina::Models::Builders::NameTitleGroupBuilder.contributor_name_value_slices(contributor)
+            contrib_name_value_slices.each do |contrib_name_value_slice|
+              next if name_title_vals_index.blank?
+
+              name_title_group = name_title_vals_index[contrib_name_value_slice]&.values&.first
+            end
+
+            attributes = name_attributes(contributor, contributor.name.first, name_title_group)
+            type_attr = NAME_TYPE.fetch(contributor.type, name_title_group ? 'personal' : nil)
+            attributes[:type] = type_attr if type_attr
+            xml.name attributes do
+              contributor.name.each do |name|
+                write_name(name)
+              end
+              write_identifier(contributor) if contributor.identifier.present?
+              write_note(contributor)
+              write_roles(contributor)
+              xml.etal if contributor.type == 'unspecified others'
+            end
+          end
+
+          def write_name(name)
+            if name.structuredValue.present?
+              write_structured(name)
+            elsif name.groupedValue.present?
+              write_grouped(name)
+            elsif name.value
+              name.type == 'display' ? write_display_form(name) : write_basic(name)
+            end
+          end
+
+          def write_parallel_contributor(contributor, name, parallel_name, name_title_group, altrepgroup_id)
+            attributes = parallel_name_attributes(name, parallel_name, name_title_group, altrepgroup_id)
+            type_attr = NAME_TYPE.fetch(contributor.type, name_title_group ? 'personal' : nil)
+            attributes[:type] = type_attr if type_attr
+            xml.name attributes do
+              if parallel_name.structuredValue.present?
+                write_structured(parallel_name)
+              else
+                write_basic(parallel_name)
+              end
+              write_identifier(contributor) if contributor.identifier.present?
+              write_note(contributor)
+              write_roles(contributor)
+            end
+          end
+
+          def parallel_name_attributes(name, parallel_name, name_title_group, altrepgroup_id)
+            {
+              nameTitleGroup: name_title_group,
+              altRepGroup: altrepgroup_id,
+              lang: parallel_name.valueLanguage&.code,
+              script: parallel_name.valueLanguage&.valueScript&.code,
+              authority: parallel_name.source&.code,
+              valueURI: parallel_name.uri,
+              authorityURI: parallel_name.source&.uri
+            }.tap do |attributes|
+              attributes[:usage] = 'primary' if parallel_name.status == 'primary'
+              if parallel_name.type == 'transliteration'
+                attributes[:transliteration] =
+                  parallel_name.standard&.value
+              end
+              attributes['xlink:href'] = name.valueAt
+            end.compact
+          end
+
+          def name_attributes(contributor, name, name_title_group)
+            {
+              nameTitleGroup: name_title_group,
+              lang: name.valueLanguage&.code,
+              script: name.valueLanguage&.valueScript&.code,
+              valueURI: name.uri,
+              authority: name.source&.code,
+              authorityURI: name.source&.uri,
+              displayLabel: name.displayLabel
+            }.tap do |attributes|
+              attributes[:usage] = 'primary' if contributor.status == 'primary'
+              attributes['xlink:href'] = name.valueAt
+            end.compact
+          end
+
+          def write_roles(contributor)
+            Array(contributor.role).each do |role|
+              RoleWriter.write(xml: xml, role: role)
+            end
+          end
+
+          def write_basic(name)
+            xml.namePart name.value, name_part_attributes(name)
+          end
+
+          def name_part_attributes(part)
+            {
+              type: NAME_PART[part.type]
+            }.tap do |attributes|
+              attributes['xlink:href'] = part.valueAt
+            end.compact
+          end
+
+          def write_structured(name)
+            Array(name.structuredValue).each do |part|
+              xml.namePart part.value, name_part_attributes(part)
+            end
+          end
+
+          def write_grouped(name)
+            Array(name.groupedValue).each do |part|
+              case part.type
+              when 'pseudonym'
+                xml.alternativeName part.value, name_part_attributes(part).merge({ altType: 'pseudonym' })
+              when 'alternative'
+                xml.alternativeName part.value, name_part_attributes(part)
+              else
+                write_name(part)
+              end
+            end
+          end
+
+          def write_note(contributor)
+            Array(contributor.note).each do |note|
+              case note.type
+              when 'affiliation'
+                xml.affiliation note.value
+              when 'description'
+                xml.description note.value
+              when 'citation status'
+                xml.description UNCITED_DESCRIPTION if note.value == 'false'
+              end
+            end
+          end
+
+          def write_identifier(contributor)
+            contributor.identifier.each do |identifier|
+              id_attributes = {
+                displayLabel: identifier.displayLabel,
+                typeURI: identifier.source&.uri,
+                type: 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.nameIdentifier identifier.value || identifier.uri, id_attributes
+            end
+          end
+
+          def write_display_form(name)
+            xml.displayForm name.value if name.type == 'display'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps notes from cocina to MODS XML
+        class Note
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Array<Cocina::Models::DescriptiveValue>] notes
+          # @params [IdGenerator] id_generator
+          def self.write(xml:, notes:, id_generator:)
+            new(xml: xml, notes: notes, id_generator: id_generator).write
+          end
+
+          # notes with a displayLabel set to any of these values will produce an `abstract` XML node
+          def self.display_label_to_abstract_type
+            ['Content advice', 'Subject', 'Abstract', 'Review', 'Summary', 'Scope and content',
+             'Scope and Content', 'Content Advice']
+          end
+
+          # notes with these types will produce an `abstract` XML node
+          def self.note_type_to_abstract_type
+            ['summary', 'abstract', 'scope and content']
+          end
+
+          def initialize(xml:, notes:, id_generator:)
+            @xml = xml
+            @notes = notes
+            @id_generator = id_generator
+          end
+
+          def write
+            Array(notes).each do |note|
+              if note.type == 'part'
+                PartWriter.write(xml: xml, part_note: note)
+              elsif note.parallelValue.present?
+                write_parallel(note)
+              else
+                write_basic(note)
+              end
+            end
+          end
+
+          private
+
+          attr_reader :xml, :notes, :id_generator
+
+          def tag_name(note)
+            return :abstract if self.class.display_label_to_abstract_type.include? note.displayLabel
+            return :abstract if self.class.note_type_to_abstract_type.include? note.type&.downcase
+
+            case note.type&.downcase
+            when 'table of contents'
+              :tableOfContents
+            when 'target audience'
+              :targetAudience
+            else
+              :note
+            end
+          end
+
+          def tag(note, tag_name, attributes)
+            attributes[:type] = note.type if note.type && note.type != 'abstract' && %i[tableOfContents
+                                                                                        targetAudience].exclude?(tag_name)
+            value = if note.structuredValue.present?
+                      note.structuredValue.map(&:value).join(' -- ')
+                    else
+                      note.value
+                    end
+            xml.public_send tag_name, value, attributes
+          end
+
+          def write_basic(note)
+            tag(note, tag_name(note), note_attributes(note))
+          end
+
+          def write_parallel(note)
+            alt_rep_group = id_generator.next_altrepgroup
+            note.parallelValue.each do |parallel_note|
+              attributes = { altRepGroup: alt_rep_group }.merge(note_attributes(parallel_note))
+
+              tag(parallel_note, tag_name(note), attributes)
+            end
+          end
+
+          def note_attributes(note)
+            {
+              lang: note.valueLanguage&.code,
+              script: note.valueLanguage&.valueScript&.code,
+              displayLabel: note.displayLabel,
+              authority: note.source&.code,
+              'xlink:href' => note.valueAt,
+              ID: id_for(note)
+            }.compact
+          end
+
+          def id_for(note)
+            Array(note.identifier).find { |identifier| identifier.type == 'anchor' }&.value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps parts from cocina to MODS XML
+        class PartWriter
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Array<Cocina::Models::DescriptiveValue>] part_note
+          # @params [IdGenerator] id_generator
+          def self.write(xml:, part_note:)
+            new(xml: xml, part_note: part_note).write
+          end
+
+          def initialize(xml:, part_note:)
+            @xml = xml
+            @note = part_note
+          end
+
+          def write
+            if note.groupedValue.present?
+              write_grouped_value
+            else
+              write_structured_value
+            end
+          end
+
+          private
+
+          attr_reader :xml, :note
+
+          def write_grouped_value
+            xml.part do
+              attrs = {
+                type: find_value(note.groupedValue, 'detail type')
+              }.compact
+
+              detail_values = detail_values_for(note)
+              if detail_values.present?
+                xml.detail attrs do
+                  detail_values.each { |detail_value| write_part_note_value(detail_value) }
+                end
+              end
+              other_note_values_for(note).each { |other_value| write_part_note_value(other_value) }
+              write_extent_for(note)
+            end
+          end
+
+          def write_structured_value
+            xml.part do
+              note.structuredValue.each do |note_value|
+                attrs = {
+                  type: find_value(note_value.groupedValue, 'detail type')
+                }.compact
+
+                detail_values = detail_values_for(note_value)
+                if detail_values.present?
+                  xml.detail attrs do
+                    detail_values.each { |detail_value| write_part_note_value(detail_value) }
+                  end
+                end
+                write_part_note_value(note_value) if other_note?(note_value)
+                write_extent_for(note_value)
+              end
+            end
+          end
+
+          def write_extent_for(note_value)
+            list_value = find_value(note_value.groupedValue, 'list')
+            structured_values = note_value.groupedValue&.find do |value|
+                                  value.structuredValue.present?
+                                end&.structuredValue
+            if structured_values
+              start_value = find_value(structured_values, 'start')
+              end_value = find_value(structured_values, 'end')
+            end
+            return unless list_value || start_value || end_value
+
+            extent_attrs = {
+              unit: find_value(note_value.groupedValue, 'extent unit')
+            }.compact
+
+            xml.extent extent_attrs do
+              xml.list list_value if list_value
+              xml.start start_value if start_value
+              xml.end end_value if end_value
+            end
+          end
+
+          def find_value(values, type)
+            values&.find { |value| value.type == type }&.value
+          end
+
+          def detail_values_for(note_value)
+            note_value.groupedValue&.select { |value| %w[number caption title].include?(value.type) }
+          end
+
+          def other_note_values_for(note_value)
+            note_value.groupedValue&.select { |value| other_note?(value) }
+          end
+
+          def other_note?(value)
+            %w[text date].include?(value.type)
+          end
+
+          def write_part_note_value(value)
+            # One of the tag names is "text". Since this is also a method name, normal magic doesn't work.
+            xml.method_missing value.type, value.value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps relatedResource from cocina to MODS relatedItem
+        class RelatedResource
+          # see https://docs.google.com/spreadsheets/d/1d5PokzgXqNykvQeckG2ND43B6i9_CsjfIVwS_IsphS8/edit#gid=0
+          TYPES = {
+            'has original version' => 'original',
+            'has other format' => 'otherFormat',
+            'has part' => 'constituent',
+            'has version' => 'otherVersion',
+            'in series' => 'series',
+            'part of' => 'host',
+            'preceded by' => 'preceding',
+            'related to' => nil, # 'related to' is a null type by design
+            'reviewed by' => 'reviewOf',
+            'referenced by' => 'isReferencedBy',
+            'references' => 'references',
+            'succeeded by' => 'succeeding'
+          }.freeze
+
+          DETAIL_TYPES = {
+            'location within source' => 'part',
+            'volume' => 'volume',
+            'issue' => 'issue',
+            'chapter' => 'chapter',
+            'section' => 'section',
+            'paragraph' => 'paragraph',
+            'track' => 'track',
+            'marker' => 'marker'
+          }.freeze
+
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Array<Cocina::Models::RelatedResource>] related_resources
+          # @param [string] druid
+          # @param [IdGenerator] id_generator
+          def self.write(xml:, related_resources:, druid:, id_generator:)
+            new(xml: xml, related_resources: related_resources, druid: druid, id_generator: id_generator).write
+          end
+
+          def initialize(xml:, related_resources:, druid:, id_generator:)
+            @xml = xml
+            @related_resources = Array(related_resources)
+            @druid = druid
+            @id_generator = id_generator
+          end
+
+          def write
+            filtered_related_resources.each do |(attributes, new_related, _orig_related)|
+              xml.relatedItem attributes do
+                ModsWriter.write(xml: xml, description: new_related, druid: druid,
+                                 id_generator: id_generator)
+              end
+            end
+
+            related_resources.filter(&:valueAt).each do |related_resource|
+              xml.relatedItem nil, { 'xlink:href' => related_resource.valueAt }
+            end
+          end
+
+          private
+
+          attr_reader :xml, :related_resources, :druid, :id_generator
+
+          def filtered_related_resources
+            related_resources.filter_map do |related|
+              next if related.valueAt
+
+              other_type_note = other_type_note_for(related)
+
+              # Filter notes
+              related_hash = related.to_h
+              new_notes = related_hash.fetch(:note, []).reject { |note| note[:type] == 'other relation type' }
+              related_hash[:note] = new_notes.empty? ? nil : new_notes
+              next if related_hash.empty?
+
+              new_related = Cocina::Models::RelatedResource.new(related_hash.compact)
+
+              [attributes_for(related, other_type_note), new_related, related]
+            end
+          end
+
+          def attributes_for(related, other_type_note)
+            {}.tap do |attrs|
+              attrs[:type] = TYPES.fetch(related.type) if related.type
+              attrs[:displayLabel] = related.displayLabel
+
+              if other_type_note
+                attrs[:otherType] = other_type_note.value
+                attrs[:otherTypeURI] = other_type_note.uri
+                attrs[:otherTypeAuth] = other_type_note.source&.value
+              end
+            end.compact
+          end
+
+          def other_type_note_for(related)
+            return nil if related.note.blank?
+
+            related.note.find { |note| note.type == 'other relation type' }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module ToMods
+        # Maps roles from cocina to MODS XML
+        class RoleWriter
+          # @params [Nokogiri::XML::Builder] xml
+          # @params [Cocina::Models::DescriptiveValue] role
+          def self.write(xml:, role:)
+            new(xml: xml, role: role).write
+          end
+
+          def initialize(xml:, role:)
+            @xml = xml
+            @role = role
+          end
+
+          def write
+            xml.role do
+              attributes = {
+                valueURI: role.uri,
+                authority: role.source&.code,
+                authorityURI: role.source&.uri
+              }.compact
+              if role.value.present?
+                attributes[:type] = 'text'
+                value = if role.source&.value == 'Stanford self-deposit contributor types'
+                          role.value.downcase
+                        else
+                          role.value
+                        end
+                xml.roleTerm value, attributes
+              end
+              if role.code.present?
+                attributes[:type] = 'code'
+                xml.roleTerm role.code, attributes
+              end
+            end
+          end
+
+          private
+
+          attr_reader :xml, :role
+        end
+      end
+    end
+  end
+end