cocina-models 0.75.0 → 0.78.0

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps titles
+        class Title # rubocop:disable Metrics/ClassLength
+          TYPES = {
+            'nonSort' => 'nonsorting characters',
+            'title' => 'main title',
+            'subTitle' => 'subtitle',
+            'partNumber' => 'part number',
+            'partName' => 'part name',
+            'date' => 'life dates',
+            'given' => 'forename',
+            'family' => 'surname',
+            'uniform' => 'title'
+          }.freeze
+
+          PERSON_TYPE = 'name'
+
+          NAME_TYPES = ['person', 'forename', 'surname', 'life dates'].freeze
+
+          # @param [Nokogiri::XML::Element] resource_element mods or relatedItem element
+          # @param [boolean] require_title notify if true and title is missing.
+          # @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: true)
+            new(resource_element: resource_element, notifier: notifier).build(require_title: require_title)
+          end
+
+          def initialize(resource_element:, notifier:)
+            @resource_element = resource_element
+            @notifier = notifier
+          end
+
+          def build(require_title: true)
+            altrepgroup_title_info_nodes, other_title_info_nodes = AltRepGroup.split(nodes: resource_element.xpath(
+              'mods:titleInfo', mods: Description::DESC_METADATA_NS
+            ))
+
+            result = altrepgroup_title_info_nodes.map { |title_info_nodes| parallel(title_info_nodes) } \
+              + simple_or_structured(other_title_info_nodes)
+            Primary.adjust(result, 'title', notifier)
+
+            notifier.error('Missing title') if result.empty? && require_title
+
+            result
+          end
+
+          private
+
+          attr_reader :resource_element, :notifier
+
+          # @param [Nokogiri::XML::NodeSet] node_set the titleInfo elements in the parallel grouping
+          def parallel(node_set)
+            {
+              parallelValue: simple_or_structured(node_set, display_types: display_types?(node_set))
+            }.tap do |result|
+              type = parallel_type(node_set)
+              result[:type] = type if type && type != 'parallel'
+            end
+          end
+
+          def display_types?(node_set)
+            return false if node_set.all? { |node| node['type'] == 'uniform' }
+
+            true
+          end
+
+          def parallel_type(node_set)
+            # If both uniform, then uniform
+            return 'uniform' if node_set.all? { |node| node[:type] == 'uniform' }
+            # If none of these nodes are marked as primary or don't have a type, set the type to parallel
+            return 'parallel' unless node_set.any? { |node| node['usage'] || !node['type'] }
+
+            nil
+          end
+
+          def simple_or_structured(node_set, display_types: true)
+            node_set.filter_map do |node|
+              if node['primary']
+                structured_name(node: node, display_types: display_types)
+              else
+                attrs = TitleBuilder.build(title_info_element: node, notifier: notifier)
+                if attrs.present?
+                  attrs.merge(common_attributes(node,
+                                                display_types: display_types)).merge(associated_name_note(node))
+                end
+              end
+            end
+          end
+
+          def structured_name(node:, display_types: true)
+            name_node = resource_element.xpath("mods:name[@nameTitleGroup='#{node['nameTitleGroup']}']",
+                                               mods: Description::DESC_METADATA_NS).first
+
+            structured_values = if name_node.nil?
+                                  notifier.warn('Name not found for title group')
+                                  []
+                                else
+                                  NameBuilder.build(name_elements: [name_node], notifier: notifier)[:name]
+                                end
+            structured_values.each { |structured_value| structured_value[:type] = 'name' }
+            title = TitleBuilder.build(title_info_element: node, notifier: notifier)
+            structured_values.unshift({ type: 'title' }.merge(title)) if title
+            { structuredValue: structured_values }.merge(common_attributes(node, display_types: display_types))
+          end
+
+          # @param [Hash<Symbol,String>] value
+          # @param [Nokogiri::XML::Element] title_info the titleInfo node
+          # @param [Bool] display_types this is set to false in the case that it's a parallelValue and all are translations
+          def common_attributes(title_info, display_types: true)
+            {}.tap do |attrs|
+              attrs[:status] = 'primary' if title_info['usage'] == 'primary'
+              attrs[:type] = title_info['type'] if display_types && title_info['type']
+              attrs[:type] = 'transliterated' if title_info['transliteration']
+              attrs[:type] = 'supplied' if title_info['supplied'] == 'yes'
+
+              source = {
+                code: Authority.normalize_code(title_info[:authority], notifier),
+                uri: Authority.normalize_uri(title_info[:authorityURI])
+              }.compact
+              attrs[:source] = source if source.present?
+              attrs[:uri] = ValueURI.sniff(title_info[:valueURI], notifier)
+
+              value_language = LanguageScript.build(node: title_info)
+              attrs[:valueLanguage] = value_language if value_language
+              attrs[:standard] = { value: title_info['transliteration'] } if title_info['transliteration']
+              attrs[:displayLabel] = title_info['displayLabel']
+            end.compact
+          end
+
+          def associated_name_note(title_info_node)
+            name_title_group_num = title_info_node['nameTitleGroup']
+            return {} if name_title_group_num.blank?
+
+            xpath_expression = "../mods:name[@nameTitleGroup='#{name_title_group_num}']"
+            matching_name_elements = title_info_node.xpath(xpath_expression, mods: Description::DESC_METADATA_NS)
+            if matching_name_elements.blank?
+              notifier.warn("For title '#{title_info_node.text.strip}', no name matching nameTitleGroup #{name_title_group_num}.")
+              {}
+            else
+              name = NameBuilder.build(name_elements: [matching_name_elements.first], notifier: notifier)
+              desired_name_attrs = name[:name].first.slice(:value, :structuredValue)
+              {
+                note: [
+                  {
+                    type: 'associated name'
+                  }.merge(desired_name_attrs).compact
+                ]
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps titles
+        class TitleBuilder
+          # @param [Nokogiri::XML::Element] title_info_element titleInfo element
+          # @param [Cocina::Models::Mapping::ErrorNotifier] notifier
+          # @return [Hash] a hash that can be mapped to a cocina model
+          def self.build(title_info_element:, notifier:)
+            new(title_info_element: title_info_element, notifier: notifier).build
+          end
+
+          def initialize(title_info_element:, notifier:)
+            @title_info_element = title_info_element
+            @notifier = notifier
+          end
+
+          def build
+            return { valueAt: title_info_element['xlink:href'] } if title_info_element['xlink:href']
+
+            # Find all the child nodes that have text
+            return nil if title_info_element.children.empty?
+
+            children = title_info_element.xpath('./*[child::node()[self::text()]]')
+            if children.empty?
+              notifier.warn('Empty title node')
+              return nil
+            end
+
+            notifier.warn('Title with type') if children_with_type?(children)
+
+            # If a displayLabel only with no title text element
+            # Note: this is an error condition,
+            # exceptions documented at: https://github.com/sul-dlss-labs/cocina-descriptive-metadata/blob/master/mods_cocina_mappings/mods_to_cocina_value_dependencies.txt
+            return {} if children.map(&:name) == []
+
+            # Is this a basic title or a title with parts
+            return simple_value(title_info_element) if simple_title?(children)
+
+            structured_value(children)
+          end
+
+          private
+
+          attr_reader :title_info_element, :notifier
+
+          def children_with_type?(children)
+            children.any? do |child|
+              child.name == 'title' && child[:type].present?
+            end
+          end
+
+          def simple_title?(children)
+            children.size == 1 && children.first.name == 'title'
+          end
+
+          # @param [Nokogiri::XML::Element] node the titleInfo node
+          def simple_value(node)
+            value = node.xpath('./mods:title', mods: Description::DESC_METADATA_NS).text
+
+            { value: clean_title(value, node.name) }
+          end
+
+          # @param [Nokogiri::XML::NodeSet] child_nodes the children of the titleInfo
+          def structured_value(child_nodes)
+            values = child_nodes.map do |node|
+              { value: clean_title(node.text, node.name), type: Title::TYPES[node.name] }
+            end
+            {
+              structuredValue: values,
+              note: note(child_nodes)
+            }.compact
+          end
+
+          def clean_title(title, tag)
+            if %w[title titleInfo].include?(tag)
+              title.delete_suffix(',')
+            elsif tag == 'nonSort'
+              title.sub(/ +$/, '')
+            else
+              title
+            end
+          end
+
+          def note(child_nodes)
+            unsortable = child_nodes.select { |node| node.name == 'nonSort' }
+            return nil if unsortable.empty?
+
+            count = unsortable.sum do |node|
+              last_character = node.text.slice(-1, 1)
+              add = ['-', "'", ' '].include?(last_character) ? 0 : 1
+              node.text.size + add
+            end
+            [{
+              value: count.to_s,  # cast to String until cocina-models 0.40.0 is used. See https://github.com/sul-dlss/cocina-models/pull/146
+              type: 'nonsorting character count'
+            }]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Decides how to build a title based on whether this is a registered Hydrus object or not.
+        class TitleBuilderStrategy
+          # @param [String] label
+          # @return [#build] a class that can build a title
+          def self.find(label:)
+            # Some hydrus items don't have titles, so using label. See https://github.com/sul-dlss/hydrus/issues/421
+            label == 'Hydrus' ? HydrusDefaultTitleBuilder : Title
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Sniffs value URIs
+        class ValueURI
+          SUPPORTED_PREFIXES = [
+            'http'
+          ].freeze
+
+          def self.sniff(uri, notifier)
+            if uri.present? && !uri.starts_with?(*SUPPORTED_PREFIXES)
+              notifier.warn('Value URI has unexpected value',
+                            { uri: uri })
+            end
+
+            uri.presence
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/normalizers/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module Normalizers
+        # Shared methods available to normalizer class instances
+        module Base
+          def regenerate_ng_xml(xml)
+            @ng_xml = Nokogiri::XML(xml) { |config| config.default_xml.noblanks }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/normalizers/mods/geo_extension_normalizer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module Normalizers
+        module Mods
+          # Normalizes a Fedora MODS document for geo extension elements.
+          class GeoExtensionNormalizer
+            # @param [Nokogiri::Document] mods_ng_xml MODS to be normalized
+            # @param [String] druid
+            # @return [Nokogiri::Document] normalized MODS
+            def self.normalize(mods_ng_xml:, druid:)
+              new(mods_ng_xml: mods_ng_xml, druid: druid).normalize
+            end
+
+            def initialize(mods_ng_xml:, druid:)
+              @ng_xml = mods_ng_xml.dup
+              @ng_xml.encoding = 'UTF-8'
+              @druid = druid
+            end
+
+            def normalize
+              normalize_geo_purl
+              normalize_dc_image
+              normalize_gml_id
+              normalize_empty_resource
+              ng_xml
+            end
+
+            private
+
+            attr_reader :ng_xml, :druid
+
+            def normalize_geo_purl
+              ng_xml.root.xpath('//mods:extension[@displayLabel="geo"]//rdf:Description',
+                                mods: ModsNormalizer::MODS_NS,
+                                rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#').each do |node|
+                node['rdf:about'] = "http://purl.stanford.edu/#{druid.delete_prefix('druid:')}"
+              end
+            end
+
+            def normalize_dc_image
+              ng_xml.root.xpath('//mods:extension[@displayLabel="geo"]//dc:type[text() = "image"]',
+                                mods: ModsNormalizer::MODS_NS,
+                                dc: 'http://purl.org/dc/elements/1.1/').each do |node|
+                node.content = 'Image'
+              end
+            end
+
+            def normalize_gml_id
+              ng_xml.root.xpath("//gml:Point[@gml:id='ID']", gml: 'http://www.opengis.net/gml/3.2/').each do |point_node|
+                point_node.delete('id')
+              end
+            end
+
+            def normalize_empty_resource
+              ng_xml.root.xpath('//dc:coverage[@rdf:resource = ""]',
+                                dc: 'http://purl.org/dc/elements/1.1/',
+                                rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#').each do |coverage_node|
+                coverage_node.delete('resource')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/mapping/normalizers/mods/name_normalizer.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module Normalizers
+        module Mods
+          # Normalizes a Fedora MODS document for name elements.
+          class NameNormalizer # rubocop:disable Metrics/ClassLength
+            # @param [Nokogiri::Document] mods_ng_xml MODS to be normalized
+            # @return [Nokogiri::Document] normalized MODS
+            def self.normalize(mods_ng_xml:)
+              new(mods_ng_xml: mods_ng_xml).normalize
+            end
+
+            def initialize(mods_ng_xml:)
+              @ng_xml = mods_ng_xml.dup
+              @ng_xml.encoding = 'UTF-8'
+            end
+
+            def normalize
+              normalize_parallel_name_role
+              normalize_text_role_term
+              normalize_role_term
+              normalize_role # must be after normalize_role_term
+              normalize_name
+              normalize_corporate_needing_primary
+              normalize_dupes
+              normalize_type
+              normalize_name_part_type
+              ng_xml
+            end
+
+            private
+
+            attr_reader :ng_xml
+
+            def normalize_parallel_name_role
+              # For parallel names, all should have the same roles.
+              name_nodes = ng_xml.root.xpath('//mods:name[@altRepGroup]', mods: ModsNormalizer::MODS_NS)
+              grouped_name_nodes = name_nodes.group_by { |name_node| name_node['altRepGroup'] }.values.reject { |name_node_group| name_node_group.size == 1 }
+              grouped_name_nodes.each do |name_node_group|
+                name_node_with_role = name_node_group.find { |name_node| role_node_for(name_node) }
+                next unless name_node_with_role
+
+                name_node_group.each do |name_node|
+                  next if name_node == name_node_with_role
+
+                  existing_role_node = role_node_for(name_node)
+                  existing_role_node&.remove
+
+                  name_node << role_node_for(name_node_with_role).dup
+                end
+              end
+            end
+
+            def role_node_for(name_node)
+              name_node.xpath('mods:role', mods: ModsNormalizer::MODS_NS).first
+            end
+
+            def normalize_text_role_term
+              # Add the type="text" attribute to roleTerms that don't have a type (seen in MODS 3.3 druid:yy910cj7795)
+              ng_xml.root.xpath('//mods:roleTerm[not(@type)]', mods: ModsNormalizer::MODS_NS).each do |role_term_node|
+                role_term_node['type'] = 'text'
+              end
+            end
+
+            def normalize_name
+              ng_xml.root.xpath('//mods:namePart[not(text())]', mods: ModsNormalizer::MODS_NS).each(&:remove)
+              ng_xml.root.xpath('//mods:name[not(mods:namePart) and not(@xlink:href) and not(mods:etal) and not(@valueURI)]',
+                                mods: ModsNormalizer::MODS_NS, xlink: ModsNormalizer::XLINK_NS).each(&:remove)
+
+              # Some MODS 3.3 items have xlink:href attributes. See https://argo.stanford.edu/view/druid:yy910cj7795
+              # Move them only when there are children.
+              ng_xml.xpath('//mods:name[@xlink:href and mods:*]', mods: ModsNormalizer::MODS_NS, xlink: ModsNormalizer::XLINK_NS).each do |node|
+                node['valueURI'] = node.remove_attribute('href').value
+              end
+            end
+
+            # assign usage="primary" to a single corporate name with nameTitleGroup if there is no other "primary" usage designation
+            def normalize_corporate_needing_primary
+              existing_primary_name = ng_xml.root.xpath('//mods:mods/mods:name[@usage="primary"]', mods: ModsNormalizer::MODS_NS)
+              return if existing_primary_name.present?
+
+              name_title_group_names = ng_xml.root.xpath('//mods:mods/mods:name[@nameTitleGroup][@type="corporate"]', mods: ModsNormalizer::MODS_NS)
+              return unless name_title_group_names.size == 1
+
+              name_title_group_names.first['usage'] = 'primary'
+            end
+
+            def normalize_dupes
+              normalize_dupes_for(ng_xml.root)
+              ng_xml.root.xpath('mods:relatedItem', mods: ModsNormalizer::MODS_NS).each { |related_item_node| normalize_dupes_for(related_item_node) }
+            end
+
+            def normalize_dupes_for(base_node)
+              name_nodes = base_node.xpath('mods:name', mods: ModsNormalizer::MODS_NS)
+              dupe_name_nodes_groups = name_nodes.group_by { |name_node| name_node_comparitor(name_node) }
+              dupe_name_nodes_groups.each_value do |grouped_name_nodes|
+                if grouped_name_nodes.size == 1
+                  include_all_uniq_roles(grouped_name_nodes, base_node)
+                else
+                  # If there is a name with nameTitleGroup, prefer retaining it.
+                  nametitle_names, other_names = grouped_name_nodes.partition { |name_node| name_node['nameTitleGroup'] }
+                  ordered_name_nodes = nametitle_names + other_names
+
+                  uniq_name_nodes = ordered_name_nodes.uniq { |name_node| name_node_comparitor(name_node) }
+                  include_all_uniq_roles(uniq_name_nodes, base_node)
+
+                  ordered_name_nodes[1..].each(&:remove)
+                end
+              end
+            end
+
+            def name_node_comparitor(name_node)
+              dup_name_node = name_node.dup
+              dup_name_node.delete('usage')
+              dup_name_node.delete('nameTitleGroup')
+              dup_name_node.xpath('mods:role', mods: ModsNormalizer::MODS_NS).each(&:unlink)
+              dup_name_node.to_s.strip.gsub(/\s+/, ' ')
+            end
+
+            # ensure all roles for each uniq name node are present
+            # @return [Array<Nokogiri::XML::Node] the uniq name nodes with all roles present
+            def include_all_uniq_roles(uniq_name_nodes, base_node)
+              names_to_roles = name_comparitor_2_role_nodes(base_node) # compute this once
+              uniq_name_nodes.each do |uniq_name_node|
+                role_nodes = names_to_roles[name_node_comparitor(uniq_name_node)]
+                next if role_nodes.blank?
+
+                uniq_name_node.xpath('mods:role', mods: ModsNormalizer::MODS_NS).each(&:unlink)
+                role_nodes.each { |role_node| uniq_name_node.add_child(role_node) }
+              end
+              uniq_name_nodes
+            end
+
+            # @return [Hash<String, Array[Nokogiri::XML::Node]] key is the string comparitor for a name node;
+            #   value is an Array of uniq role nodes
+            def name_comparitor_2_role_nodes(base_node)
+              result = {}
+
+              # we must do this outside the loop in case of duplicate name nodes
+              all_role_nodes = base_node.xpath('mods:name/mods:role', mods: 'http://www.loc.gov/mods/v3')
+              all_role_nodes.each do |role_node|
+                name_comparitor = name_node_comparitor(role_node.parent)
+                result[name_comparitor] = if result[name_comparitor]
+                                            result[name_comparitor] << role_node
+                                          else
+                                            [role_node]
+                                          end
+              end
+              result.each { |_k, role_nodes| role_nodes.uniq! { |role_node| name_node_comparitor(role_node) } }
+            end
+
+            def normalize_type
+              ng_xml.root.xpath('//mods:name[@type]', mods: ModsNormalizer::MODS_NS).each do |name_node_w_type|
+                raw_type = name_node_w_type['type']
+                next if Cocina::Models::Mapping::FromMods::Contributor::ROLES.key?(raw_type)
+
+                if Cocina::Models::Mapping::FromMods::Contributor::ROLES.key?(raw_type.downcase)
+                  name_node_w_type['type'] = raw_type.downcase
+                else
+                  name_node_w_type.remove_attribute('type')
+                end
+              end
+            end
+
+            def normalize_name_part_type
+              ng_xml.root.xpath('//mods:namePart[(@type)]', mods: ModsNormalizer::MODS_NS).each do |name_part_node|
+                raw_type = name_part_node['type']
+                next if Cocina::Models::Mapping::FromMods::Contributor::NAME_PART.key?(raw_type)
+
+                name_part_node.remove_attribute('type')
+              end
+            end
+
+            # remove the roleTerm when there is no text value and no valueURI or URI attribute
+            def normalize_role_term
+              ng_xml.root.xpath('//mods:roleTerm[not(text()) and not(@valueURI) and not(@authorityURI)]', mods: ModsNormalizer::MODS_NS).each(&:remove)
+            end
+
+            # remove the role when there are no child elements and no attributes
+            def normalize_role
+              ng_xml.root.xpath('//mods:role[not(mods:*) and not(@*)]', mods: ModsNormalizer::MODS_NS).each(&:remove)
+            end
+          end
+        end
+      end
+    end
+  end
+end