cocina-models 0.74.1 → 0.77.0

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

@@ -0,0 +1,381 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps relevant MODS physicalDescription, typeOfResource and genre from descMetadata to cocina form
+        # rubocop:disable Metrics/ClassLength
+        class Form
+          # NOTE: H2 is the first case of structured form (genre/typeOfResource) values we're implementing
+          H2_GENRE_TYPE_PREFIX = 'H2 '
+
+          # @param [Nokogiri::XML::Element] resource_element mods or relatedItem element
+          # @param [Cocina::Models::Mapping::FromMods::DescriptionBuilder] description_builder
+          # @param [String] purl
+          # @return [Hash] a hash that can be mapped to a cocina model
+          def self.build(resource_element:, description_builder:, purl: nil)
+            new(resource_element: resource_element, description_builder: description_builder).build
+          end
+
+          def initialize(resource_element:, description_builder:)
+            @resource_element = resource_element
+            @notifier = description_builder.notifier
+          end
+
+          def build
+            forms = []
+            add_genre(forms)
+            add_types(forms)
+            add_physical_descriptions(forms)
+            add_subject_cartographics(forms)
+            Primary.adjust(forms, 'genre', notifier, match_type: true)
+            Primary.adjust(forms, 'resource type', notifier, match_type: true)
+          end
+
+          private
+
+          attr_reader :resource_element, :notifier
+
+          def add_subject_cartographics(forms)
+            subject_nodes = resource_element.xpath('mods:subject[mods:cartographics]', mods: Description::DESC_METADATA_NS)
+            altrepgroup_subject_nodes, other_subject_nodes = AltRepGroup.split(nodes: subject_nodes)
+
+            forms.concat(
+              altrepgroup_subject_nodes.map do |parallel_subject_nodes|
+                build_parallel_cartographics(parallel_subject_nodes)
+              end +
+              other_subject_nodes.flat_map { |subject_node| build_cartographics(subject_node) }.uniq
+            )
+          end
+
+          def build_parallel_cartographics(parallel_subject_nodes)
+            {
+              parallelValue: parallel_subject_nodes.flat_map { |subject_node| build_cartographics(subject_node) }
+            }
+          end
+
+          def build_cartographics(subject_node)
+            carto_forms = []
+            subject_node.xpath('mods:cartographics[mods:scale]', mods: Description::DESC_METADATA_NS).each do |carto_node|
+              scale_nodes = carto_node.xpath('mods:scale', mods: Description::DESC_METADATA_NS).reject do |scale_node|
+                scale_node.text.blank?
+              end
+              if scale_nodes.size == 1
+                carto_forms << {
+                  value: scale_nodes.first.text,
+                  type: 'map scale'
+                }
+              elsif scale_nodes.size > 1
+                carto_forms << {
+                  groupedValue: scale_nodes.map { |scale_node| { value: scale_node.text } },
+                  type: 'map scale'
+                }
+              end
+            end
+
+            subject_node.xpath('mods:cartographics/mods:projection',
+                               mods: Description::DESC_METADATA_NS).each do |projection_node|
+              next if projection_node.text.blank?
+
+              carto_forms << {
+                value: projection_node.text,
+                type: 'map projection',
+                displayLabel: subject_node['displayLabel'],
+                uri: ValueURI.sniff(subject_node['valueURI'], notifier)
+              }.tap do |attrs|
+                source = {
+                  code: subject_node['authority'],
+                  uri: subject_node['authorityURI']
+                }.compact
+                attrs[:source] = source if source.present?
+              end.compact
+            end
+            carto_forms.uniq
+          end
+
+          def add_genre(forms)
+            add_structured_genre(forms) if structured_genre.any?
+
+            altrepgroup_genres, other_genre = AltRepGroup.split(nodes: basic_genre)
+
+            other_genre.each { |genre| forms << { type: 'genre' }.merge(build_genre(genre)) }
+            altrepgroup_genres.each { |parallel_genres| forms << build_parallel_genre(parallel_genres) }
+          end
+
+          def build_genre(genre)
+            {
+              value: genre.text,
+              displayLabel: genre[:displayLabel],
+              uri: ValueURI.sniff(genre[:valueURI], notifier)
+            }.tap do |attrs|
+              source = {
+                code: Authority.normalize_code(genre[:authority], notifier),
+                uri: Authority.normalize_uri(genre[:authorityURI])
+              }.compact
+              attrs[:source] = source if source.present?
+              attrs[:status] = 'primary' if genre['usage'] == 'primary'
+              language_script = LanguageScript.build(node: genre)
+              attrs[:valueLanguage] = language_script if language_script
+              if genre['type']
+                attrs[:note] = [
+                  {
+                    value: genre['type'],
+                    type: 'genre type'
+                  }
+                ]
+              end
+            end.compact
+          end
+
+          def build_parallel_genre(genres)
+            {
+              parallelValue: genres.map { |genre| build_genre(genre) },
+              type: 'genre'
+            }
+          end
+
+          def add_structured_genre(forms)
+            # The only use case we're supporting for structured forms at the
+            # moment is for H2. Assume these are H2 values.
+            forms << {
+              type: 'resource type',
+              source: {
+                value: Cocina::Models::Mapping::ToMods::Form::H2_SOURCE_LABEL
+              },
+              structuredValue: structured_genre.map do |genre|
+                {
+                  value: genre.text,
+                  type: genre.attributes['type'].value.delete_prefix(H2_GENRE_TYPE_PREFIX)
+                }
+              end
+            }
+          end
+
+          def add_types(forms)
+            type_of_resource.each do |type|
+              forms << resource_type_form(type) if type.text.present?
+
+              forms << manuscript_form if type[:manuscript] == 'yes'
+
+              forms << collection_form if type[:collection] == 'yes'
+            end
+
+            datacite_form = datacite_resource_type
+            forms << datacite_form if datacite_form
+          end
+
+          def resource_type_form(type)
+            {
+              value: type.text,
+              type: 'resource type',
+              uri: type['valueURI'],
+              source: resource_type_form_source(type),
+              displayLabel: type[:displayLabel].presence
+            }.tap do |attrs|
+              attrs[:status] = 'primary' if type['usage'] == 'primary'
+            end.compact
+          end
+
+          def resource_type_form_source(type)
+            {}.tap do |attrs|
+              if type['authorityURI']
+                attrs[:uri] = type['authorityURI']
+              else
+                attrs[:value] = 'MODS resource types'
+              end
+            end
+          end
+
+          def manuscript_form
+            {
+              value: 'manuscript',
+              source: {
+                value: 'MODS resource types'
+              }
+            }
+          end
+
+          def collection_form
+            {
+              value: 'collection',
+              source: {
+                value: 'MODS resource types'
+              }
+            }
+          end
+
+          def add_physical_descriptions(forms)
+            altrepgroup_physical_descr_nodes, other_physical_descr_nodes = AltRepGroup.split(nodes: physical_descriptions)
+            other_physical_descr_nodes.each do |physical_description_node|
+              forms.concat(physical_description_forms_for(physical_description_node))
+            end
+
+            altrepgroup_physical_descr_nodes.each do |altrepgroup_physical_descr_node_group|
+              form = { parallelValue: [] }
+              altrepgroup_physical_descr_node_group.each do |physical_descr_node|
+                form[:parallelValue].concat(physical_description_forms_for(physical_descr_node))
+              end
+              adjust_parallel_value(form, :displayLabel)
+              adjust_parallel_value(form, :type)
+              adjust_parallel_value(form, :source)
+              forms << form
+            end
+          end
+
+          def adjust_parallel_value(form, key)
+            return unless form[:parallelValue].all? do |form_value|
+                            form_value[key] && form_value[key] == form[:parallelValue].first[key]
+                          end
+
+            form[key] = form[:parallelValue].first[key]
+            form[:parallelValue].each { |form_value| form_value.delete(key) }
+          end
+
+          def physical_description_forms_for(physical_description_node)
+            form_values = physical_description_form_values_for(physical_description_node)
+            notes = physical_description_notes_for(physical_description_node)
+            # Depends on how many physicalDescriptions there are or if there is a displayLabel
+            forms = []
+            if physical_descriptions.size == 1 && form_values.size > 1 && physical_description_node['displayLabel'].nil?
+              forms.concat(form_values)
+              forms << { note: notes } if notes.present?
+            elsif form_values.size == 1
+              if form_values.first[:note]&.first&.fetch(:type) == 'unit'
+                forms << form_values.first.compact
+                forms << { note: notes } if notes.present?
+              else
+                forms << form_values.first.merge({
+                  note: notes.presence,
+                  displayLabel: physical_description_node['displayLabel']
+                }.compact)
+              end
+            else
+              forms << {
+                groupedValue: form_values,
+                note: notes.presence,
+                displayLabel: physical_description_node['displayLabel']
+              }.compact
+            end
+            forms
+          end
+
+          def physical_description_form_values_for(physical_description_node)
+            form_values = []
+            add_forms(form_values, physical_description_node)
+            add_reformatting_quality(form_values, physical_description_node)
+            add_media_type(form_values, physical_description_node)
+            add_extent(form_values, physical_description_node)
+            add_digital_origin(form_values, physical_description_node)
+            form_values
+          end
+
+          def physical_description_notes_for(physical_description)
+            physical_description.xpath('mods:note', mods: Description::DESC_METADATA_NS).filter_map do |node|
+              next if node.content.blank?
+
+              {
+                value: node.content,
+                displayLabel: node['displayLabel'],
+                type: node['type']
+              }.compact
+            end
+          end
+
+          def add_digital_origin(forms, physical_description)
+            physical_description.xpath('mods:digitalOrigin', mods: Description::DESC_METADATA_NS).each do |node|
+              forms << {
+                value: node.content,
+                type: 'digital origin',
+                source: { value: 'MODS digital origin terms' }
+              }.compact
+            end
+          end
+
+          def add_extent(forms, physical_description)
+            physical_description.xpath('mods:extent', mods: Description::DESC_METADATA_NS).each do |extent|
+              forms << {
+                value: extent.content,
+                type: 'extent'
+              }.tap do |form_attrs|
+                form_attrs[:note] = [{ type: 'unit', value: extent['unit'] }] if extent['unit']
+              end
+            end
+          end
+
+          def add_media_type(forms, physical_description)
+            physical_description.xpath('mods:internetMediaType', mods: Description::DESC_METADATA_NS).each do |node|
+              forms << {
+                value: node.content,
+                type: 'media type',
+                source: { value: 'IANA media types' }
+              }.compact
+            end
+          end
+
+          def add_reformatting_quality(forms, physical_description)
+            physical_description.xpath('mods:reformattingQuality', mods: Description::DESC_METADATA_NS).each do |node|
+              forms << {
+                value: node.content,
+                type: 'reformatting quality',
+                source: { value: 'MODS reformatting quality terms' }
+              }.compact
+            end
+          end
+
+          def add_forms(forms, physical_description)
+            physical_description.xpath('mods:form', mods: Description::DESC_METADATA_NS).each do |form_content|
+              forms << {
+                value: form_content.content,
+                uri: ValueURI.sniff(form_content['valueURI'], notifier),
+                type: form_content['type'] || 'form',
+                source: source_for(form_content).presence
+              }.compact
+            end
+          end
+
+          def physical_descriptions
+            resource_element.xpath('mods:physicalDescription', mods: Description::DESC_METADATA_NS)
+          end
+
+          def source_for(form)
+            {
+              code: Authority.normalize_code(form['authority'], notifier),
+              uri: Authority.normalize_uri(form['authorityURI'])
+            }.compact
+          end
+
+          def type_of_resource
+            resource_element.xpath('mods:typeOfResource', mods: Description::DESC_METADATA_NS)
+          end
+
+          def datacite_resource_type
+            node = resource_element.xpath('mods:extension[@displayLabel="datacite"]/mods:resourceType',
+                                          mods: Description::DESC_METADATA_NS).first
+            return unless node
+
+            { value: node[:resourceTypeGeneral], type: 'resource type',
+              source: { value: 'DataCite resource types' } }
+          end
+
+          # returns genre at the root and inside subjects excluding structured genres
+          def basic_genre
+            resource_element.xpath("mods:genre[not(@type) or not(starts-with(@type, '#{H2_GENRE_TYPE_PREFIX}'))]",
+                                   mods: Description::DESC_METADATA_NS)
+          end
+
+          def subject_genre
+            resource_element.xpath('mods:subject/mods:genre', mods: Description::DESC_METADATA_NS)
+          end
+
+          # returns structured genres at the root and inside subjects, which are combined to form a single, structured Cocina element
+          def structured_genre
+            resource_element.xpath("mods:genre[@type and starts-with(@type, '#{H2_GENRE_TYPE_PREFIX}')]",
+                                   mods: Description::DESC_METADATA_NS)
+          end
+        end
+        # rubocop:enable Metrics/ClassLength
+      end
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps MODS extension displayLabel geo to cocina descriptive extension
+        # rubocop:disable Metrics/ClassLength
+        class Geographic
+          DUBLIN_CORE_NS = 'http://purl.org/dc/elements/1.1/'
+          RDF_NS = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+          GMD_NS = 'http://www.isotc211.org/2005/gmd'
+          GML_NS = 'http://www.opengis.net/gml/3.2/'
+
+          NAMESPACE = {
+            'mods' => Description::DESC_METADATA_NS,
+            'dc' => DUBLIN_CORE_NS,
+            'rdf' => RDF_NS,
+            'gmd' => GMD_NS,
+            'gml' => GML_NS
+          }.freeze
+
+          # Directional Constants for GEO
+          SOUTH = 'south'
+          WEST = 'west'
+          NORTH = 'north'
+          EAST = 'east'
+
+          # Geo Extention Constants
+          BOUNDING_BOX_COORDS = 'bounding box coordinates'
+          COVERAGE = 'coverage'
+          DATA_FORMAT = 'data format'
+          DCMI_VOCAB = { value: 'DCMI Type Vocabulary' }.freeze
+          DECIMAL_ENCODING = { value: 'decimal' }.freeze
+          FORMAT_DELIM = '; format='
+          IANA_TERMS = { value: 'IANA media type terms' }.freeze
+          LANGUAGE = { code: 'eng' }.freeze
+          MEDIA_TYPE = 'media type'
+          POINT_COORDS = 'point coordinates'
+          TYPE = 'type'
+
+          # @param [Nokogiri::XML::Element] resource_element mods or relatedItem element
+          # @param [Cocina::Models::Mapping::FromMods::DescriptionBuilder] description_builder
+          # @param [String] purl
+          # @return [Hash] a hash that can be mapped to a cocina model
+          def self.build(resource_element:, description_builder:, purl: nil)
+            new(resource_element: resource_element, description_builder: description_builder).build
+          end
+
+          def initialize(resource_element:, description_builder:)
+            @resource_element = resource_element
+            @notifier = description_builder.notifier
+          end
+
+          def build
+            return unless description
+
+            check_purl
+
+            [{}.tap do |extension|
+              extension[:form] = build_form.flatten if build_form
+              extension[:subject] = build_subject
+            end.compact]
+          end
+
+          private
+
+          attr_reader :resource_element, :notifier
+
+          def build_form
+            return unless format
+
+            [].tap do |form|
+              form << { value: format[:text], type: MEDIA_TYPE, source: IANA_TERMS } if format[:text]
+              form << build_type
+            end
+          end
+
+          def build_type
+            type_section =
+              if type == 'Image'
+                { value: type, type: MEDIA_TYPE, source: DCMI_VOCAB }
+              else
+                { value: type, type: TYPE }
+              end
+
+            if format[:format].present?
+              [{ value: format[:format], type: DATA_FORMAT }, type_section]
+            else
+              type_section
+            end
+          end
+
+          def build_subject
+            return [build_subject_for_center_point] unless centerpoint.empty?
+            return build_subject_for_bounding_box unless envelope.empty?
+          end
+
+          def build_subject_for_center_point
+            {
+              structuredValue: [centerpoint_latitude, centerpoint_longitude],
+              type: POINT_COORDS,
+              encoding: DECIMAL_ENCODING
+            }
+          end
+
+          def build_subject_for_bounding_box
+            [].tap do |subject|
+              subject << structure_map
+              coverage_map.map { |block| subject << block } unless coverage.empty?
+            end
+          end
+
+          def structure_map
+            {}.tap do |structure|
+              structure[:structuredValue] = bounding_box_coordinates
+              structure[:type] = BOUNDING_BOX_COORDS
+              structure[:encoding] = DECIMAL_ENCODING
+              structure[:standard] = { code: standard } if standard
+            end
+          end
+
+          def coverage_map
+            coverage.map do |data|
+              title = data.attr('dc:title')
+              uri = data.attr('rdf:resource')
+              {}.tap do |coverage_for|
+                coverage_for[:value] = title if title
+                coverage_for[:type] = COVERAGE
+                coverage_for[:valueLanguage] = LANGUAGE
+                coverage_for[:uri] = uri if uri.present?
+              end
+            end
+          end
+
+          def bounding_box_coordinates
+            [WEST, SOUTH, EAST, NORTH].map { |dir| boundary_position(dir) }
+          end
+
+          def description
+            @description ||= resource_element.xpath('mods:extension/rdf:RDF/rdf:Description', NAMESPACE).first
+          end
+
+          def centerpoint
+            description.xpath('//gmd:centerPoint/gml:Point/gml:pos', NAMESPACE).text.split
+          end
+
+          def centerpoint_latitude
+            { value: centerpoint.first, type: 'latitude' }
+          end
+
+          def centerpoint_longitude
+            { value: centerpoint.last, type: 'longitude' }
+          end
+
+          def coverage
+            description.xpath('//dc:coverage', NAMESPACE)
+          end
+
+          def envelope
+            description.xpath('//gml:boundedBy/gml:Envelope', NAMESPACE)
+          end
+
+          def format
+            return unless description
+
+            text, format = description.xpath('//dc:format', NAMESPACE).text.split(FORMAT_DELIM)
+            @format ||= { text: text, format: format }
+          end
+
+          def lower_left_corner
+            envelope.xpath('//gml:lowerCorner', NAMESPACE).text.split
+          end
+
+          def upper_right_corner
+            envelope.xpath('//gml:upperCorner', NAMESPACE).text.split
+          end
+
+          def boundaries
+            {
+              SOUTH => lower_left_corner.last,
+              WEST => lower_left_corner.first,
+              NORTH => upper_right_corner.last,
+              EAST => upper_right_corner.first
+            }
+          end
+
+          def boundary_position(direction)
+            { value: boundaries[direction], type: direction }
+          end
+
+          def standard
+            envelope.attr('srsName')&.value
+          end
+
+          def type
+            @type ||= normalize_type_text(description.xpath('//dc:type', NAMESPACE).text)
+          end
+
+          def normalize_type_text(text)
+            if text.casecmp('image').zero? && text != 'Image'
+              notifier.warn('dc:type normalized to <dc:type>Image</dc:type>', type: text)
+              'Image'
+            else
+              text
+            end
+          end
+
+          def check_purl
+            return if %r{^https?://purl.stanford.edu/}.match?(description['rdf:about'])
+
+            notifier.warn('rdf:about does not contain a correctly formatted PURL')
+          end
+        end
+        # rubocop:enable Metrics/ClassLength
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/from_mods/hydrus_default_title_builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps titles
+        class HydrusDefaultTitleBuilder
+          # @param [Nokogiri::XML::Element] resource_element mods or relatedItem element
+          # @param [Cocina::Models::Mapping::ErrorNotifier] notifier
+          # @return [Hash] a hash that can be mapped to a cocina model
+          def self.build(resource_element:, notifier:, require_title: nil)
+            titles = resource_element.xpath('mods:titleInfo/mods:title[string-length() > 0]',
+                                            mods: Description::DESC_METADATA_NS)
+
+            if titles.empty?
+              return [{ value: 'Hydrus' }] if resource_element.name != 'relatedItem'
+
+              return []
+            end
+
+            Title.build(resource_element: resource_element, notifier: notifier)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps MODS identifer to cocina identifier
+        class Identifier
+          # @param [Nokogiri::XML::Element] resource_element mods or relatedItem element
+          # @param [Cocina::Models::Mapping::FromMods::DescriptionBuilder] description_builder
+          # @param [String] purl
+          # @return [Hash] a hash that can be mapped to a cocina model
+          def self.build(resource_element:, description_builder: nil, purl: nil)
+            new(resource_element: resource_element).build
+          end
+
+          def initialize(resource_element:)
+            @resource_element = resource_element
+          end
+
+          def build
+            altrepgroup_identifier_nodes, other_identifier_nodes = AltRepGroup.split(nodes: identifiers)
+
+            altrepgroup_identifier_nodes.map { |id_nodes| build_parallel(id_nodes) } +
+              other_identifier_nodes.map do |id_node|
+                IdentifierBuilder.build_from_identifier(identifier_element: id_node)
+              end
+          end
+
+          private
+
+          attr_reader :resource_element
+
+          def build_parallel(identifier_nodes)
+            {
+              parallelValue: identifier_nodes.map do |id_node|
+                               IdentifierBuilder.build_from_identifier(identifier_element: id_node)
+                             end
+            }
+          end
+
+          def identifiers
+            (resource_element.xpath('mods:identifier', mods: Description::DESC_METADATA_NS) +
+              resource_element.xpath('mods:recordIdentifier',
+                                     mods: Description::DESC_METADATA_NS)).reject { |identifier_node| identifier_node.text.blank? && identifier_node.attributes.size.zero? }
+          end
+        end
+      end
+    end
+  end
+end