cocina-models 0.75.0 → 0.76.0

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Helper class: normalizes Authorities
+        class Authority
+          NORMALIZE_AUTHORITY_URIS = [
+            'http://id.loc.gov/authorities/names',
+            'http://id.loc.gov/authorities/subjects',
+            'http://id.loc.gov/vocabulary/relators',
+            'http://id.loc.gov/vocabulary/countries',
+            'http://id.loc.gov/authorities/genreForms',
+            'http://id.loc.gov/vocabulary/descriptionConventions'
+          ].freeze
+
+          def self.normalize_uri(uri)
+            return "#{uri}/" if NORMALIZE_AUTHORITY_URIS.include?(uri)
+
+            uri.presence
+          end
+
+          def self.normalize_code(code, notifier)
+            if code == 'lcnaf'
+              notifier.warn('lcnaf authority code')
+              return 'naf'
+            end
+
+            if code == 'tgm'
+              notifier.warn('tgm authority code (should be lctgm)')
+              return 'lctgm'
+            end
+
+            if code == '#N/A'
+              notifier.warn('"#N/A" authority code')
+              return nil
+            end
+
+            if code == 'marcountry'
+              notifier.warn('marcountry authority code (should be marccountry)')
+              return 'marccountry'
+            end
+
+            code.presence
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps contributors
+        class Contributor # rubocop:disable Metrics/ClassLength
+          # key: MODS, value: cocina
+          ROLES = {
+            'personal' => 'person',
+            'corporate' => 'organization',
+            'family' => 'family',
+            'conference' => 'conference'
+          }.freeze
+
+          NAME_PART = {
+            'family' => 'surname',
+            'given' => 'forename',
+            'termsOfAddress' => 'term of address',
+            'date' => 'life dates'
+          }.freeze
+
+          # @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
+            grouped_altrepgroup_name_nodes, other_name_nodes = AltRepGroup.split(nodes: deduped_name_nodes)
+            check_altrepgroup_type_inconsistency(grouped_altrepgroup_name_nodes)
+            contributors = grouped_altrepgroup_name_nodes.map { |name_nodes| build_name_nodes(name_nodes) } + \
+                           other_name_nodes.map { |name_node| build_name_nodes([name_node]) }
+            contrib_level_type_and_status(contributors)
+            adjust_primary(contributors.compact).presence
+          end
+
+          private
+
+          attr_reader :resource_element, :notifier
+
+          def deduped_name_nodes
+            # In addition, to plain-old dupes, need to get rid of names that are dupes where
+            #   e.g., one has a nameTitleGroup and one does not
+            # Need to retain nameTitleGroups, so sorting so those first. (Array.uniq takes first.)
+            name_nodes = resource_element.xpath('mods:name', mods: Description::DESC_METADATA_NS)
+            nametitle_nodes, other_nodes = name_nodes.partition { |name_node| name_node['nameTitleGroup'] }
+            ordered_name_nodes = nametitle_nodes + other_nodes
+            uniq_name_nodes = uniq_name_nodes(ordered_name_nodes)
+
+            notifier.warn('Duplicate name entry') if name_nodes.size != uniq_name_nodes.size
+
+            include_all_uniq_roles(uniq_name_nodes)
+          end
+
+          # uniq retains the first value, so sort input with that in mind.
+          # @param [Array<Nokogiri::XML::Node>]
+          # @return [Array<Nokogiri::XML::Node>] (yes, Johnny, this returns array of nodes, not comparitors)
+          def uniq_name_nodes(name_nodes)
+            name_nodes.uniq do |name_node|
+              name_node_comparitor(name_node)
+            end
+          end
+
+          # remove usage and nameTitleGroup attributes and role nodes for uniqueness comparison
+          # @return [String] a string to be used by Array.uniq for .eql? comparisons
+          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: Description::DESC_METADATA_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)
+            names_to_roles = name_comparitor_2_role_nodes # 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: Description::DESC_METADATA_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
+            result = {}
+
+            # we must do this outside the loop in case of duplicate name nodes
+            all_role_nodes = resource_element.xpath('mods:name/mods:role', mods: Description::DESC_METADATA_NS)
+            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 check_altrepgroup_type_inconsistency(grouped_altrepgroup_name_nodes)
+            grouped_altrepgroup_name_nodes.each do |altrepgroup_name_nodes|
+              altrepgroup_name_types = altrepgroup_name_nodes.group_by { |name_node| name_node['type'] }.keys
+              next unless altrepgroup_name_types.size > 1
+
+              notifier.error('Multiple types for same altRepGroup', { types: altrepgroup_name_types })
+            end
+          end
+
+          def build_name_nodes(name_nodes)
+            NameBuilder.build(name_elements: name_nodes, notifier: notifier).presence
+          end
+
+          def adjust_primary(contributors)
+            Primary.adjust(contributors, 'contributor', notifier)
+            contributors.each do |contributor|
+              Array(contributor[:name]).each do |name|
+                Primary.adjust(name[:parallelValue], 'name', notifier) if name[:parallelValue]
+              end
+            end
+            contributors
+          end
+
+          # 'type' and 'status' are generated in name_builder on the name level object,
+          #   but we want them at the contributor level object.
+          def contrib_level_type_and_status(contributors)
+            contributors.each do |contributor|
+              next if contributor.blank?
+
+              Array(contributor[:name]).each do |name|
+                if name[:status] == 'primary'
+                  contributor[:status] = 'primary'
+                  name.delete(:status)
+                end
+                if name[:type].present? && ROLES.value?(name[:type])
+                  contributor[:type] = name[:type].presence
+                  name.delete(:type)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Creates Cocina Description objects from MODS xml
+        class Description
+          DESC_METADATA_NS = 'http://www.loc.gov/mods/v3'
+          XLINK_NS = 'http://www.w3.org/1999/xlink'
+
+          # @param [Nokogiri::XML] mods
+          # @param [String] druid
+          # @oaram [String] label
+          # @param [TitleBuilder] title_builder - defaults to Title class
+          # @param [Cocina::Models::Mapping::ErrorNotifier] notifier
+          # @return [Hash] a hash that can be mapped to a cocina descriptive model
+          # @raises [Cocina::Mapper::InvalidDescMetadata] if some assumption about descMetadata is violated
+          def self.props(mods:, druid:, label:, title_builder: Title, notifier: nil)
+            new(title_builder: title_builder, mods: mods, druid: druid, label: label, notifier: notifier).props
+          end
+
+          def initialize(title_builder:, mods:, label:, druid:, notifier:)
+            @title_builder = title_builder
+            @ng_xml = mods
+            @notifier = notifier || ErrorNotifier.new(druid: druid)
+            @druid = druid
+            @label = label
+          end
+
+          # @return [Hash] a hash that can be mapped to a cocina descriptive model
+          # @raises [Cocina::Mapper::InvalidDescMetadata] if some assumption about descMetadata is violated
+          def props
+            return nil if ng_xml.root.nil?
+
+            check_altrepgroups
+            check_version
+            props = DescriptionBuilder.build(title_builder: title_builder,
+                                             resource_element: ng_xml.root,
+                                             notifier: notifier,
+                                             purl: druid ? Cocina::Models::Mapping::Purl.for(druid: druid) : nil)
+            props[:title] = [{ value: label }] unless props.key?(:title)
+            props
+          end
+
+          private
+
+          attr_reader :title_builder, :ng_xml, :notifier, :druid, :label
+
+          def check_altrepgroups
+            ng_xml.xpath('//mods:*[@altRepGroup]', mods: DESC_METADATA_NS)
+                  .group_by { |node| node['altRepGroup'] }
+                  .values
+                  .select { |nodes| nodes.size > 1 }
+                  .each do |nodes|
+              notifier.warn('Unpaired altRepGroup') if altrepgroup_error?(nodes)
+            end
+          end
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def altrepgroup_error?(nodes)
+            return true if nodes.map(&:name).uniq.size != 1
+
+            # For subjects, script/lang may be in child so looking in both locations.
+            scripts = nodes.map do |node|
+              node['script'].presence || node.elements.first&.attribute('script')&.presence
+            end.uniq
+            # Every node has a different script.
+            return false if scripts.size == nodes.size
+
+            langs = nodes.map do |node|
+              node['lang'].presence || node.elements.first&.attribute('lang')&.presence
+            end.uniq
+            # Every node has a different lang.
+            return false if langs.size == nodes.size
+
+            # No scripts or langs
+            return false if scripts.compact.empty? && langs.compact.empty?
+
+            # altRepGroups can have the same script, e.g. Latn for English and French
+            return false if scripts.size == 1
+
+            true
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          def check_version
+            match = /MODS version (\d\.\d)/.match(ng_xml.root.at('//mods:recordInfo/mods:recordOrigin',
+                                                                 mods: DESC_METADATA_NS)&.content)
+
+            return unless match
+
+            notifier.warn('MODS version mismatch') if match[1] != ng_xml.root['version']
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Creates Cocina Description objects from MODS resource element.
+        class DescriptionBuilder
+          attr_reader :notifier
+
+          BUILDERS = {
+            note: Note,
+            language: Language,
+            contributor: Contributor,
+            event: Event,
+            subject: Subject,
+            form: Form,
+            identifier: Identifier,
+            adminMetadata: AdminMetadata,
+            relatedResource: RelatedResource,
+            geographic: Geographic,
+            access: Access
+          }.freeze
+
+          # @param [Nokogiri::XML::Element] resource_element mods or relatedItem element
+          # @param [Cocina::Models::Mapping::ErrorNotifier] notifier
+          # @param [TitleBuilder] title_builder - defaults to Title class
+          # @param [String] purl
+          # @return [Hash] a hash that can be mapped to a cocina description model
+          def self.build(resource_element:, notifier:, title_builder: Title, purl: nil)
+            new(title_builder: title_builder, notifier: notifier).build(resource_element: resource_element,
+                                                                        purl: purl)
+          end
+
+          def initialize(notifier:, title_builder: Title)
+            @title_builder = title_builder
+            @notifier = notifier
+          end
+
+          # @return [Hash] a hash that can be mapped to a cocina description model
+          def build(resource_element:, purl: nil, require_title: true)
+            cocina_description = {}
+            title_result = @title_builder.build(resource_element: resource_element, require_title: require_title,
+                                                notifier: notifier)
+            cocina_description[:title] = title_result if title_result.present?
+
+            purl_value = purl || Purl.primary_purl_value(resource_element, purl)
+            cocina_description[:purl] = purl_value if purl_value
+
+            BUILDERS.each do |description_property, builder|
+              result = builder.build(resource_element: resource_element, description_builder: self,
+                                     purl: purl_value)
+              cocina_description.merge!(description_property => result) if result.present?
+            end
+            cocina_description
+          end
+        end
+      end
+    end
+  end
+end