cocina-models 0.74.1 → 0.77.0

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

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps a name
+        class NameBuilder
+          UNCITED_DESCRIPTION = Cocina::Models::Mapping::ToMods::NameWriter::UNCITED_DESCRIPTION
+          TYPE_FOR_ROLES = Cocina::Models::Mapping::FromMods::Contributor::ROLES.merge('event' => 'event').freeze
+
+          # @param [Array<Nokogiri::XML::Element>] name_elements (multiple if parallel)
+          # @param [Cocina::Models::Mapping::ErrorNotifier] notifier
+          # @return [Hash] a hash that can be mapped to a cocina model
+          def self.build(name_elements:, notifier:)
+            new(name_elements: name_elements, notifier: notifier).build
+          end
+
+          def initialize(name_elements:, notifier:)
+            @name_elements = name_elements
+            @notifier = notifier
+          end
+
+          def build
+            if name_elements.size == 1
+              build_name(name_elements.first)
+            else
+              build_parallel
+            end
+          end
+
+          private
+
+          attr_reader :name_elements, :notifier
+
+          def build_parallel
+            names = {
+              parallelValue: name_elements.map { |name_node| build_parallel_name(name_node) },
+              type: type_for(name_elements.first['type']),
+              status: name_elements.filter_map { |name_element| name_element['usage'] }.first
+            }.compact
+            { name: [names] }.tap do |attrs|
+              roles = name_elements.flat_map { |name_node| build_roles(name_node) }.compact.uniq
+              attrs[:role] = roles.presence
+            end.compact
+          end
+
+          def build_parallel_name(name_node)
+            name_attrs = {
+              status: name_node['usage']
+            }.compact.merge(common_lang_script(name_node))
+
+            name_attrs = name_attrs.merge(common_name(name_node, name_attrs[:name]))
+            name_parts = build_name_parts(name_node)
+            notifier.warn('Missing name/namePart element') if name_parts.all?(&:empty?)
+            name_parts.each { |name_part| name_attrs = name_part.merge(name_attrs) }
+            name_attrs.compact
+          end
+
+          # build non-parallel, single name
+          def build_name(name_node)
+            return { type: 'unspecified others' } if name_node.xpath('mods:etal', mods: Description::DESC_METADATA_NS).present?
+
+            name_parts = build_name_parts(name_node)
+            # If there are no name parts, do not map the name
+            if name_parts.all?(&:empty?)
+              notifier.warn('Missing name/namePart element')
+              return {}
+            end
+
+            status = name_node['usage']
+            # NOTE:  this lovely "or" clause for status 'primary' is brought to you by MARC records for our GoogleBooks
+            #  in a perfect world, it should be sure there is no existing 'usage' attribute of primary on any top level name nodes
+            if status.blank? && name_node[:nameTitleGroup].present? && name_node[:type] == 'corporate' &&
+               name_node.parent.node_name == 'mods'
+              xpath_expression = "//mods:mods/mods:name[@usage='primary']"
+              primary_names = name_node.xpath(xpath_expression, mods: Description::DESC_METADATA_NS)
+              status = 'primary' if primary_names.blank?
+            end
+            {
+              name: name_parts,
+              type: name_type(name_node),
+              status: status
+            }.compact.merge(common_name(name_node, name_parts))
+          end
+
+          def common_name(name_node, name)
+            {
+              note: build_notes(name_node),
+              identifier: build_identifier(name_node)
+            }.tap do |attrs|
+              roles = build_roles(name_node)
+              attrs[:role] = roles unless name.nil?
+            end.compact
+          end
+
+          def common_lang_script(name_node)
+            {
+              valueLanguage: LanguageScript.build(node: name_node).presence
+            }.tap do |attrs|
+              if name_node[:transliteration]
+                attrs[:type] = 'transliteration'
+                attrs[:standard] = { value: name_node[:transliteration] }
+              end
+            end.compact
+          end
+
+          def build_name_parts(name_node)
+            name_part_nodes = name_node.xpath('mods:namePart', mods: Description::DESC_METADATA_NS)
+            alternative_name_nodes = name_node.xpath('mods:alternativeName', mods: Description::DESC_METADATA_NS)
+
+            parts = []
+            case name_part_nodes.size
+            when 0
+              parts << { valueAt: name_node['xlink:href'] } if name_node['xlink:href']
+              parts << common_authority(name_node) if name_node['valueURI']
+            when 1
+              parts << build_name_part(name_node, name_part_nodes.first,
+                                       default_type: alternative_name_nodes.present?)
+                       .merge(common_authority(name_node)).merge(common_lang_script(name_node)).presence
+            else
+              vals = name_part_nodes.filter_map do |name_part|
+                build_name_part(name_node, name_part, default_type: name_node['type'] != 'corporate').presence
+              end
+              parts << { structuredValue: vals }.merge(common_authority(name_node)).merge(common_lang_script(name_node))
+            end
+
+            parts = build_alternative_name(alternative_name_nodes, parts) if alternative_name_nodes.present?
+
+            display_form = name_node.xpath('mods:displayForm', mods: Description::DESC_METADATA_NS).first
+            parts << { value: display_form.text, type: 'display' } if display_form
+            parts.compact
+          end
+
+          def build_name_part(name_node, name_part_node, default_type: true)
+            if name_part_node.content.blank? && !name_part_node['xlink:href']
+              notifier.warn('name/namePart missing value')
+              return {}
+            end
+
+            {
+              value: name_part_node.content,
+              type: name_part_type_for(name_part_node, default_type),
+              valueAt: name_part_node['xlink:href'],
+              displayLabel: name_node['displayLabel']
+            }.compact
+          end
+
+          def build_alternative_name(alternative_name_nodes, parts)
+            alternative_name_nodes.each do |alternative_name_node|
+              parts << {
+                type: alternative_name_node['altType'] || 'alternative',
+                value: alternative_name_node.content.presence,
+                valueAt: alternative_name_node['xlink:href']
+              }.compact
+            end
+            [{ groupedValue: parts }]
+          end
+
+          def name_part_type_for(name_part_node, default_type)
+            type = name_part_node['type']
+
+            notifier.warn('Name/namePart type attribute set to ""') if type == ''
+            if type.present? && !Contributor::NAME_PART.key?(type)
+              notifier.warn('namePart has unknown type assigned',
+                            type: type)
+            end
+
+            if activity_date?(name_part_node)
+              'activity dates'
+            elsif Contributor::NAME_PART.key?(type)
+              Contributor::NAME_PART[type]
+            elsif default_type && type.blank?
+              'name'
+            end
+          end
+
+          def name_type(name_node)
+            name_type = type_for(name_node['type'])
+            return name_type if name_type.present?
+
+            role_nodes = name_node.xpath('mods:role', mods: Description::DESC_METADATA_NS)
+            cocina_roles = role_nodes.filter_map { |role_node| role_for(role_node) }.presence
+            return if cocina_roles.blank?
+
+            return 'event' if cocina_roles.first[:value] == 'event'
+          end
+
+          def activity_date?(name_part_node)
+            name_part_node['type'] == 'date' &&
+              name_part_node.content.start_with?('active', 'fl', 'floruit')
+          end
+
+          def common_authority(name_node)
+            {
+              uri: ValueURI.sniff(uri_for(name_node), notifier)
+            }.tap do |attrs|
+              source = {
+                code: Authority.normalize_code(name_node['authority'], notifier),
+                uri: Authority.normalize_uri(name_node['authorityURI'])
+              }.compact
+              attrs[:source] = source unless source.empty?
+              attrs[:valueAt] = name_node['xlink:href'] unless xlink_is_value_uri?(name_node)
+            end.compact
+          end
+
+          def uri_for(name_node)
+            return name_node['valueURI'] if name_node['valueURI']
+
+            return nil unless name_node['xlink:href'] && xlink_is_value_uri?(name_node)
+
+            notifier.warn('Name has an xlink:href property')
+            name_node['xlink:href']
+          end
+
+          def xlink_is_value_uri?(name_node)
+            name_node['authority'] || name_node['authorityURI']
+          end
+
+          def build_identifier(name_node)
+            name_node.xpath('mods:nameIdentifier', mods: Description::DESC_METADATA_NS).map do |identifier|
+              IdentifierBuilder.build_from_name_identifier(identifier_element: identifier)
+            end.presence
+          end
+
+          def build_notes(name_node)
+            [].tap do |parts|
+              name_node.xpath('mods:affiliation', mods: Description::DESC_METADATA_NS).each do |affiliation_node|
+                parts << { value: affiliation_node.text, type: 'affiliation' }
+              end
+
+              description = name_node.xpath('mods:description', mods: Description::DESC_METADATA_NS).first
+              if description
+                parts << if description.text == UNCITED_DESCRIPTION
+                           { value: 'false', type: 'citation status' }
+                         else
+                           { value: description.text, type: 'description' }
+                         end
+              end
+            end.presence
+          end
+
+          def build_roles(name_node)
+            role_nodes = name_node.xpath('mods:role', mods: Description::DESC_METADATA_NS)
+            role_nodes.filter_map { |role_node| role_for(role_node) }.presence
+          end
+
+          # shameless green
+          def role_for(ng_role)
+            code = ng_role.xpath('./mods:roleTerm[@type="code"]', mods: Description::DESC_METADATA_NS).first
+            text = ng_role.xpath('./mods:roleTerm[@type="text"] | ./mods:roleTerm[not(@type)]',
+                                 mods: Description::DESC_METADATA_NS).first
+            return if code.nil? && text.nil?
+
+            authority = ng_role.xpath('./mods:roleTerm/@authority', mods: Description::DESC_METADATA_NS).first&.content
+            authority_uri = ng_role.xpath('./mods:roleTerm/@authorityURI', mods: Description::DESC_METADATA_NS).first&.content
+            authority_value = ng_role.xpath('./mods:roleTerm/@valueURI', mods: Description::DESC_METADATA_NS).first&.content
+
+            check_role_code(code, authority)
+
+            {}.tap do |role|
+              source = {
+                code: Authority.normalize_code(authority, notifier),
+                uri: Authority.normalize_uri(authority_uri)
+              }.compact
+              role[:source] = source if source.present?
+
+              role[:uri] = ValueURI.sniff(authority_value, notifier)
+              role[:code] = code&.content
+              role[:value] = text.content if text
+
+              if role[:code].blank? && role[:value].blank?
+                notifier.warn('name/role/roleTerm missing value')
+                return nil
+              end
+            end.compact
+          end
+
+          def type_for(type)
+            return nil if type.blank?
+
+            unless TYPE_FOR_ROLES.key?(type.downcase)
+              notifier.warn('Name type unrecognized', type: type)
+              return
+            end
+            notifier.warn('Name type incorrectly capitalized', type: type) if type.downcase != type
+
+            TYPE_FOR_ROLES.fetch(type.downcase)
+          end
+
+          def check_role_code(role_code, role_authority)
+            return if role_code.nil? || role_authority
+
+            if role_code.content.present? && role_code.content.size == 3
+              notifier.warn('Contributor role code is missing authority')
+              return
+            end
+
+            notifier.error('Contributor role code has unexpected value', role: role_code.content)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps notes
+        class Note # rubocop:disable Metrics/ClassLength
+          # @param [Nokogiri::XML::Element] resource_element mods or relatedItem element
+          # @param [Cocina::Models::Mapping::FromMods::DescriptionBuilder] description_builder (not used, but passed in by DescriptionBuilder)
+          # @param [String] purl (not used, but passed in by DescriptionBuilder)
+          # @return [Hash] a hash that can be mapped to a cocina model
+          # def self.build(resource_element:, description_builder: nil, purl: nil)
+          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
+            abstracts + notes + table_of_contents + target_audience + parts
+          end
+
+          private
+
+          attr_reader :resource_element
+
+          def abstracts
+            all_abstract_nodes = resource_element.xpath('mods:abstract', mods: Description::DESC_METADATA_NS).select do |node|
+              note_present?(node)
+            end
+            altrepgroup_abstract_nodes, other_abstract_nodes = AltRepGroup.split(nodes: all_abstract_nodes)
+            other_abstract_nodes.map { |node| common_note_for(node).merge(abstract_type(node)) } + \
+              altrepgroup_abstract_nodes.map { |parallel_nodes| parallel_abstract_for(parallel_nodes) }
+          end
+
+          def parallel_abstract_for(abstract_nodes)
+            {
+              type: 'abstract',
+              parallelValue: abstract_nodes.map do |node|
+                               common_note_for(node).merge(abstract_type(node, parallel: true))
+                             end
+            }
+          end
+
+          def common_note_for(node)
+            {
+              value: node.content.presence,
+              displayLabel: display_label(node),
+              type: note_type(node),
+              valueAt: node['xlink:href']
+            }.tap do |attributes|
+              value_language = LanguageScript.build(node: node)
+              attributes[:valueLanguage] = value_language if value_language
+              if node['ID']
+                attributes[:identifier] = [
+                  {
+                    value: node['ID'],
+                    type: 'anchor'
+                  }
+                ]
+              end
+            end.compact
+          end
+
+          def note_type(node)
+            return node['type'].downcase if Cocina::Models::Mapping::ToMods::Note.note_type_to_abstract_type.include?(node['type']&.downcase)
+
+            node['type']
+          end
+
+          def display_label(node)
+            return node[:displayLabel].capitalize if Cocina::Models::Mapping::ToMods::Note.display_label_to_abstract_type.include? node[:displayLabel]
+
+            node[:displayLabel].presence
+          end
+
+          def abstract_type(node, parallel: false)
+            if node['type'].present?
+              { type: node['type'].downcase }
+            elsif Cocina::Models::Mapping::ToMods::Note.display_label_to_abstract_type.exclude?(node['displayLabel']) && !parallel
+              { type: 'abstract' }
+            else
+              {}
+            end
+          end
+
+          def notes
+            all_note_nodes = resource_element.xpath('mods:note', mods: Description::DESC_METADATA_NS).select do |node|
+              note_present?(node) && node[:type] != 'contact'
+            end
+            altrepgroup_note_nodes, other_note_nodes = AltRepGroup.split(nodes: all_note_nodes)
+            other_note_nodes.map { |node| common_note_for(node) } + \
+              altrepgroup_note_nodes.map { |parallel_nodes| parallel_note_for(parallel_nodes) }
+          end
+
+          def note_present?(node)
+            node.text.present? || node['xlink:href']
+          end
+
+          def parallel_note_for(note_nodes)
+            {
+              parallelValue: note_nodes.map { |note_node| common_note_for(note_node) }
+            }
+          end
+
+          def target_audience
+            resource_element.xpath('mods:targetAudience', mods: Description::DESC_METADATA_NS).filter_map do |node|
+              {
+                type: 'target audience',
+                value: node.content,
+                displayLabel: node['displayLabel']
+              }.tap do |attrs|
+                attrs[:source] = { code: node[:authority] } if node[:authority]
+              end.compact
+            end
+          end
+
+          def table_of_contents
+            all_toc_nodes = resource_element.xpath('mods:tableOfContents', mods: Description::DESC_METADATA_NS).select do |node|
+              note_present?(node)
+            end
+            altrepgroup_toc_nodes, other_toc_nodes = AltRepGroup.split(nodes: all_toc_nodes)
+            other_toc_nodes.map { |node| toc_for(node).merge({ type: 'table of contents' }) } + \
+              altrepgroup_toc_nodes.map { |parallel_nodes| parallel_toc_for(parallel_nodes) }
+          end
+
+          def parallel_toc_for(toc_nodes)
+            {
+              type: 'table of contents',
+              parallelValue: toc_nodes.map { |toc_node| toc_for(toc_node) }
+            }
+          end
+
+          def toc_for(node)
+            {
+              displayLabel: node[:displayLabel].presence,
+              valueAt: node['xlink:href']
+            }.tap do |attributes|
+              value_language = LanguageScript.build(node: node)
+              attributes[:valueLanguage] = value_language if value_language
+              value_parts = node.content.split(' -- ')
+              if value_parts.size == 1
+                attributes[:value] = node.content
+              elsif value_parts.present?
+                attributes[:structuredValue] = value_parts.map { |value_part| { value: value_part } }
+              end
+            end.compact
+          end
+
+          def parts
+            resource_element.xpath('mods:part', mods: Description::DESC_METADATA_NS).filter_map do |part_node|
+              PartBuilder.build(part_element: part_node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps parts
+        class PartBuilder # rubocop:disable Metrics/ClassLength
+          # @param [Nokogiri::XML::Element] part_element
+          # @return [Hash] a hash that can be mapped to a cocina model
+          def self.build(part_element:)
+            new(part_element: part_element).build
+          end
+
+          def initialize(part_element:)
+            @part_element = part_element
+          end
+
+          def build
+            structured_value? ? structured_value : grouped_value
+          end
+
+          private
+
+          attr_reader :part_element
+
+          def structured_value?
+            part_element.xpath('mods:detail[@type]', mods: Description::DESC_METADATA_NS).size > 1
+          end
+
+          def grouped_value
+            values = []
+            values.concat(detail_values.flatten)
+            values.concat(extent_values.flatten)
+            values.concat(part_note_value_for(part_element, 'text'))
+            values.concat(part_note_value_for(part_element, 'date'))
+            values.reject!(&:blank?)
+
+            return if values.empty?
+
+            {
+              type: 'part',
+              groupedValue: values
+            }
+          end
+
+          def structured_value
+            values = []
+            values.concat(detail_values)
+            values.concat(extent_values)
+            values.concat(part_note_value_for(part_element, 'text'))
+            values.concat(part_note_value_for(part_element, 'date'))
+            values.reject!(&:blank?)
+
+            return if values.empty?
+
+            {
+              type: 'part',
+              structuredValue: values.filter_map { |value| structured_value_value_for(value) }
+            }
+          end
+
+          def structured_value_value_for(value)
+            if value.is_a?(Hash)
+              value
+            elsif value.empty? # else an array
+              nil
+            else
+              {
+                groupedValue: value
+              }
+            end
+          end
+
+          def detail_values
+            part_element.xpath('mods:detail', mods: Description::DESC_METADATA_NS).filter_map do |detail_node|
+              detail_values_for(detail_node)
+            end
+          end
+
+          def detail_values_for(detail_node)
+            detail_values = []
+            detail_values.concat(part_note_value_for(detail_node, 'number'))
+            detail_values.concat(part_note_value_for(detail_node, 'caption'))
+            detail_values.concat(part_note_value_for(detail_node, 'title'))
+            detail_values.reject!(&:blank?)
+            if detail_values.present?
+              detail_values.concat(part_note_value_for(detail_node, 'detail type',
+                                                       xpath: '@type'))
+            end
+            detail_values
+          end
+
+          def extent_values
+            part_element.xpath('mods:extent', mods: Description::DESC_METADATA_NS).filter_map do |extent_node|
+              extent_values_for(extent_node)
+            end
+          end
+
+          def extent_values_for(extent_node)
+            extent_values = []
+            extent_values.concat(part_note_value_for(extent_node, 'list'))
+            extent_values << pages_for(extent_node)
+            extent_values.reject!(&:blank?)
+            if extent_values.present?
+              extent_values.concat(part_note_value_for(extent_node, 'extent unit',
+                                                       xpath: '@unit'))
+            end
+            extent_values
+          end
+
+          def pages_for(extent_node)
+            values = []
+            values << page_value_for(extent_node, 'start')
+            values << page_value_for(extent_node, 'end')
+            values.compact!
+
+            return nil if values.empty?
+
+            {
+              structuredValue: values
+            }
+          end
+
+          def page_value_for(extent_node, type)
+            page_node = extent_node.xpath("mods:#{type}", mods: Description::DESC_METADATA_NS).first
+            return nil if page_node.nil?
+
+            {
+              value: page_node.content,
+              type: type
+            }
+          end
+
+          def part_note_value_for(node, type, xpath: nil)
+            xpath ||= "mods:#{type}"
+            node.xpath(xpath, mods: Description::DESC_METADATA_NS).filter_map do |value_node|
+              next if value_node.content.blank?
+
+              { type: type, value: value_node.content }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Helper class: checks and fixes status: primary
+        class Primary
+          # @params [Nokogiri::XML::NodeSet] node_set
+          # @params [String] type the value of a node's type attribute we are concerned with
+          def self.adjust(node_set, type, notifier, match_type: false)
+            primary_node_set = node_set.select do |node|
+              node[:status] == 'primary' && (!match_type || node[:type] == type)
+            end
+
+            return node_set if primary_node_set.size < 2
+
+            primary_node_set[1..].each { |node| node.delete(:status) }
+
+            notifier.warn('Multiple marked as primary', { type: type })
+            node_set
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Support for mapping PURLs.
+        class Purl
+          def self.primary_purl_node(resource_element, purl)
+            purl_nodes = resource_element.xpath('mods:location/mods:url',
+                                                mods: Description::DESC_METADATA_NS).select do |url_node|
+              Cocina::Models::Mapping::Purl.purl?(url_node.text)
+            end
+
+            return purl_nodes.find { |purl_node| purl_value(purl_node) == purl } if purl
+
+            # Prefer a primary PURL node
+            primary_purl_node = purl_nodes.find { |purl_node| purl_node[:usage] == 'primary display' }
+
+            primary_purl_node || purl_nodes.first
+          end
+
+          def self.purl_note(purl_node)
+            notes = []
+            if purl_node[:note]
+              notes << {
+                value: purl_node['note'],
+                appliesTo: [{ value: 'purl' }]
+              }
+            end
+            if purl_node['displayLabel']
+              notes << {
+                value: purl_node['displayLabel'],
+                type: 'display label',
+                appliesTo: [{ value: 'purl' }]
+              }
+            end
+            notes
+          end
+
+          def self.primary_purl_value(resource_element, purl)
+            purl_value(primary_purl_node(resource_element, purl))
+          end
+
+          def self.purl_value(purl_node)
+            # Note that normalizing http to https
+            purl_node&.content&.sub(/^https?/, 'https')&.presence
+          end
+        end
+      end
+    end
+  end
+end