cocina-models 0.74.0 → 0.76.0

data/lib/cocina/models/file_access.rb

@@ -5,15 +5,15 @@ module Cocina
     class FileAccess < Struct
       # Access level.
       # Validation of this property is relaxed. See the openapi for full validation.
-      attribute :view, Types::Strict::String.optional.default('dark').meta(omittable: true)
+      attribute? :view, Types::Strict::String.optional.default('dark')
       # Download access level.
       # Validation of this property is relaxed. See the openapi for full validation.
-      attribute :download, Types::Strict::String.optional.default('none').meta(omittable: true)
+      attribute? :download, Types::Strict::String.optional.default('none')
       # Not used for this access type, must be null.
       # Validation of this property is relaxed. See the openapi for full validation.
-      attribute :location, Types::Strict::String.optional.meta(omittable: true)
+      attribute? :location, Types::Strict::String.optional
       # Validation of this property is relaxed. See the openapi for full validation.
-      attribute :controlledDigitalLending, Types::Strict::Bool.optional.meta(omittable: true)
+      attribute? :controlledDigitalLending, Types::Strict::Bool.optional.default(false)
     end
   end
 end

data/lib/cocina/models/identification.rb

@@ -4,11 +4,11 @@ module Cocina
   module Models
     class Identification < Struct
       # A barcode
-      attribute :barcode, Types::Nominal::Any.meta(omittable: true)
+      attribute? :barcode, Types::Nominal::Any
       attribute :catalogLinks, Types::Strict::Array.of(CatalogLink).default([].freeze)
       # Digital Object Identifier (https://www.doi.org)
       # example: 10.25740/bc123df4567
-      attribute :doi, Types::Strict::String.meta(omittable: true)
+      attribute? :doi, Types::Strict::String
       # Unique identifier in some other system. This is because a large proportion of what is deposited in SDR, historically and currently, are representations of objects that are also represented in other systems. For example, digitized paper and A/V collections have physical manifestations, and those physical objects are managed in systems that have their own identifiers. Similarly, books have barcodes, archival materials have collection numbers and physical locations, etc. The sourceId allows determining if an item has been deposited before and where to look for the original item if you're looking at its SDR representation. The format is: "namespace:identifier"
 
       # example: sul:PC0170_s3_Fiesta_Bowl_2012-01-02_210609_2026

data/lib/cocina/models/language.rb

@@ -5,28 +5,28 @@ module Cocina
     class Language < Struct
       attribute :appliesTo, Types::Strict::Array.of(DescriptiveBasicValue).default([].freeze)
       # Code value of the descriptive element.
-      attribute :code, Types::Strict::String.meta(omittable: true)
+      attribute? :code, Types::Strict::String
       # The preferred display label to use for the descriptive element in access systems.
-      attribute :displayLabel, Types::Strict::String.meta(omittable: true)
-      attribute :encoding, Standard.optional.meta(omittable: true)
+      attribute? :displayLabel, Types::Strict::String
+      attribute? :encoding, Standard.optional
       attribute :groupedValue, Types::Strict::Array.of(DescriptiveValue).default([].freeze)
       attribute :note, Types::Strict::Array.of(DescriptiveValue).default([].freeze)
       attribute :parallelValue, Types::Strict::Array.of(DescriptiveValue).default([].freeze)
       # present for mapping to additional schemas in the future and for consistency but not otherwise used
-      attribute :qualifier, Types::Strict::String.meta(omittable: true)
-      attribute :script, DescriptiveValue.optional.meta(omittable: true)
-      attribute :source, Source.optional.meta(omittable: true)
+      attribute? :qualifier, Types::Strict::String
+      attribute? :script, DescriptiveValue.optional
+      attribute? :source, Source.optional
       # Status of the language relative to other parallel language elements (e.g. the primary language)
-      attribute :status, Types::Strict::String.enum('primary').meta(omittable: true)
-      attribute :standard, Standard.optional.meta(omittable: true)
+      attribute? :status, Types::Strict::String.enum('primary')
+      attribute? :standard, Standard.optional
       attribute :structuredValue, Types::Strict::Array.of(DescriptiveValue).default([].freeze)
       # URI value of the descriptive element.
-      attribute :uri, Types::Strict::String.meta(omittable: true)
+      attribute? :uri, Types::Strict::String
       # Value of the descriptive element.
-      attribute :value, Types::Strict::String.meta(omittable: true)
+      attribute? :value, Types::Strict::String
       # URL or other pointer to the location of the language information.
-      attribute :valueAt, Types::Strict::String.meta(omittable: true)
-      attribute :valueLanguage, DescriptiveValueLanguage.optional.meta(omittable: true)
+      attribute? :valueAt, Types::Strict::String
+      attribute? :valueLanguage, DescriptiveValueLanguage.optional
     end
   end
 end

data/lib/cocina/models/location_based_access.rb

@@ -9,7 +9,7 @@ module Cocina
       attribute :download, Types::Strict::String.enum('location-based', 'none')
       # If access or download is "location-based", which location should have access.
       attribute :location, Types::Strict::String.enum('spec', 'music', 'ars', 'art', 'hoover', 'm&m')
-      attribute :controlledDigitalLending, Types::Strict::Bool.enum(false).meta(omittable: true)
+      attribute? :controlledDigitalLending, Types::Strict::Bool.default(false).enum(false)
     end
   end
 end

data/lib/cocina/models/location_based_download_access.rb

@@ -9,7 +9,7 @@ module Cocina
       attribute :download, Types::Strict::String.enum('location-based')
       # Which location should have download access.
       attribute :location, Types::Strict::String.enum('spec', 'music', 'ars', 'art', 'hoover', 'm&m')
-      attribute :controlledDigitalLending, Types::Strict::Bool.enum(false).meta(omittable: true)
+      attribute? :controlledDigitalLending, Types::Strict::Bool.default(false).enum(false)
     end
   end
 end

data/lib/cocina/models/mapping/error_notifier.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      # Notifies when a data error is encountered. Notification is performed with Honeybadger.
+      class ErrorNotifier
+        # In addition, it distinguishes between warnings and errors, even if both are notified the same.
+        # The determination of warn / error is currently made by the metadata team.
+
+        # @param [String] druid
+        def initialize(druid:)
+          @druid = druid
+        end
+
+        # Notify for a non-critical data error.
+        # @param [String] message
+        # @param [Hash<String, String>] context to add to warning context
+        def warn(message, _context = {})
+          Kernel.warn "[WARN] #{message}"
+        end
+
+        # Notify for a critical data error.
+        # @param [String] message
+        # @param [Hash<String, String>] context to add to error context
+        def error(message, _context = {})
+          Kernel.warn "[ERROR] #{message}"
+        end
+
+        private
+
+        attr_reader :druid
+      end
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps access conditions
+        class Access # rubocop:disable Metrics/ClassLength
+          ACCESS_CONDITION_TYPES = {
+            'restriction on access' => 'access restriction',
+            'restrictionOnAccess' => 'access restriction',
+            'restrictionsOnAccess' => 'access restriction',
+            'useAndReproduction' => 'use and reproduction'
+          }.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, purl: purl).build
+          end
+
+          def initialize(resource_element:, description_builder:, purl:)
+            @resource_element = resource_element
+            @notifier = description_builder.notifier
+            @purl = purl
+          end
+
+          def build
+            {}.tap do |access|
+              physical_locations = physical_location + shelf_location + xlink_location
+              access[:physicalLocation] = physical_locations.presence
+              access[:digitalLocation] = digital_location.presence
+              access[:accessContact] = access_contact.presence
+              access[:url] = url.presence
+              access[:note] = (note + purl_note).presence
+            end.compact.presence
+          end
+
+          private
+
+          attr_reader :resource_element, :notifier, :add_sdr, :purl
+
+          # Hydrus is known to create location nodes with no children.
+          def location_nodes
+            resource_element.xpath('mods:location[*]', mods: Description::DESC_METADATA_NS)
+          end
+
+          def physical_location
+            descriptive_value_for(resource_element.xpath(
+                                    "mods:location/mods:physicalLocation[not(@type='repository')][not(@type='discovery')]", mods: Description::DESC_METADATA_NS
+                                  ))
+          end
+
+          def digital_location
+            descriptive_value_for(resource_element.xpath(
+                                    "mods:location/mods:physicalLocation[(@type='discovery')]", mods: Description::DESC_METADATA_NS
+                                  ))
+          end
+
+          def xlink_location
+            resource_element.xpath('mods:location/mods:physicalLocation[@xlink:href]', mods: Description::DESC_METADATA_NS,
+                                                                                       xlink: Description::XLINK_NS).map do |node|
+              {
+                valueAt: node['xlink:href']
+              }
+            end
+          end
+
+          def access_contact
+            descriptive_value_for(resource_element.xpath("mods:location/mods:physicalLocation[@type='repository']",
+                                                         mods: Description::DESC_METADATA_NS)) +
+              descriptive_value_for(resource_element.xpath("mods:note[@type='contact']", mods: Description::DESC_METADATA_NS),
+                                    type: 'email')
+          end
+
+          def shelf_location
+            resource_element.xpath('mods:location/mods:shelfLocator',
+                                   mods: Description::DESC_METADATA_NS).filter_map do |shelf_locator_elem|
+              next if shelf_locator_elem.content.blank?
+
+              {
+                value: shelf_locator_elem.content,
+                type: 'shelf locator'
+              }
+            end
+          end
+
+          def url
+            url_nodes.filter_map do |url_node|
+              {
+                value: url_node.text.presence,
+                displayLabel: url_node[:displayLabel]
+              }.tap do |attrs|
+                attrs[:status] = 'primary' if url_node == primary_url_node
+                attrs[:note] = [{ value: url_node[:note] }] if url_node[:note]
+              end.compact.presence
+            end
+          end
+
+          def primary_url_node
+            all_primary_purl_nodes.first || all_primary_url_nodes.first || this_purl_node || all_purl_nodes.first
+          end
+
+          def this_purl_node
+            purl ? all_purl_nodes.find { |purl_node| purl_node.content == purl } : nil
+          end
+
+          def all_primary_url_nodes
+            @all_primary_url_nodes ||= all_url_nodes.select { |url_node| url_node[:usage] == 'primary display' }
+          end
+
+          def all_primary_purl_nodes
+            @all_primary_purl_nodes ||= all_purl_nodes.select { |purl_node| purl_node[:usage] == 'primary display' }
+          end
+
+          def all_purl_nodes
+            @all_purl_nodes ||= all_url_nodes.select { |url_node| Cocina::Models::Mapping::Purl.purl?(url_node.text) }
+          end
+
+          def all_url_nodes
+            @all_url_nodes ||= resource_element.xpath('mods:location/mods:url', mods: Description::DESC_METADATA_NS)
+          end
+
+          def primary_purl_node
+            @primary_purl_node ||= Purl.primary_purl_node(resource_element, purl)
+          end
+
+          def url_nodes
+            @url_nodes ||= all_url_nodes.reject { |url_node| Cocina::Models::Mapping::Purl.purl?(url_node.text) }
+          end
+
+          def purl_note
+            return [] unless primary_purl_node
+
+            Purl.purl_note(primary_purl_node)
+          end
+
+          def note
+            resource_element.xpath('mods:accessCondition', mods: Description::DESC_METADATA_NS).map do |access_elem|
+              {
+                value: access_elem.text.presence,
+                type: ACCESS_CONDITION_TYPES.fetch(access_elem['type'], access_elem['type']),
+                displayLabel: access_elem['displayLabel'],
+                valueAt: access_elem['xlink:href']
+              }.compact
+            end
+          end
+
+          def descriptive_value_for(nodes, type: nil)
+            nodes.filter_map do |node|
+              next nil if node.text.blank?
+
+              {}.tap do |attrs|
+                if %w[marcorg oclcorg].include?(node[:authority])
+                  attrs[:code] = node.text
+                else
+                  attrs[:value] = node.text
+                end
+                attrs[:uri] = ValueURI.sniff(node[:valueURI], notifier)
+                source = {
+                  code: Authority.normalize_code(node[:authority], notifier),
+                  uri: Authority.normalize_uri(node[:authorityURI])
+                }.compact
+                attrs[:source] = source unless source.empty?
+                attrs[:type] = type || node[:type]
+                attrs[:displayLabel] = node[:displayLabel]
+                attrs[:valueLanguage] = LanguageScript.build(node: node)
+              end.compact
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Maps MODS recordInfo to cocina
+        class AdminMetadata # rubocop:disable Metrics/ClassLength
+          # @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
+            @description_builder = description_builder
+            @notifier = description_builder.notifier
+          end
+
+          def build
+            return nil if record_info.nil?
+
+            {}.tap do |admin_metadata|
+              admin_metadata[:language] = build_language
+              admin_metadata[:contributor] = build_contributor
+              admin_metadata[:metadataStandard] = build_standard
+              admin_metadata[:note] = build_note
+              admin_metadata[:identifier] = build_identifier
+              admin_metadata[:event] = build_events
+            end.compact
+          end
+
+          private
+
+          attr_reader :resource_element, :notifier, :description_builder
+
+          def build_events
+            events = []
+            events << build_event_for(creation_event, 'creation') if creation_event
+            modification_events.each do |event|
+              events << build_event_for(event, 'modification')
+            end
+            return nil if events.empty?
+
+            events
+          end
+
+          def build_event_for(node, type)
+            event_code = node['encoding']
+            encoding = { code: event_code } if event_code
+            {
+              type: type,
+              date: [
+                {
+                  value: node.text,
+                  encoding: encoding
+                }.compact
+              ]
+            }
+          end
+
+          def build_identifier
+            identifiers = record_identifiers.map do |identifier|
+              IdentifierBuilder.build_from_record_identifier(identifier_element: identifier)
+            end
+
+            return nil if identifiers.empty?
+
+            identifiers
+          end
+
+          def build_note
+            notes = []
+            record_origins.each do |record_origin|
+              notes << {
+                type: 'record origin',
+                value: record_origin.text
+              }
+            end
+            record_info_notes.each do |info_note|
+              notes << if info_note['xlink:href']
+                         { valueAt: info_note['xlink:href'] }
+                       else
+                         {
+                           type: 'record information',
+                           value: info_note.text
+                         }
+                       end
+            end
+            notes.presence
+          end
+
+          def build_standard
+            return unless description_standards
+
+            description_standards.map do |description_standard|
+              source = {
+                uri: Authority.normalize_uri(description_standard['authorityURI']),
+                code: description_standard['authority']
+              }.compact
+              {
+                uri: ValueURI.sniff(description_standard['valueURI'], notifier),
+                source: source.presence
+              }.tap do |attrs|
+                if description_standard.text.present?
+                  if description_standard.text == description_standard.text.downcase
+                    attrs[:code] = description_standard.text
+                  else
+                    attrs[:value] = description_standard.text
+                  end
+                end
+              end.compact
+            end.presence
+          end
+
+          def build_contributor
+            record_content_sources.map do |record_content_source|
+              if record_content_source['authority'] == 'marcorg'
+                build_contributor_code(record_content_source)
+              else
+                build_contributor_value(record_content_source)
+              end
+            end.presence
+          end
+
+          def build_contributor_value(record_content_source)
+            {
+              name: [
+                {
+                  value: record_content_source.text,
+                  uri: ValueURI.sniff(record_content_source['valueURI'], notifier),
+                  source: source_for(record_content_source)
+
+                }.compact
+              ]
+            }
+          end
+
+          def build_contributor_code(record_content_source)
+            {
+              name: [
+                {
+                  code: record_content_source.text,
+                  uri: ValueURI.sniff(record_content_source['valueURI'], notifier),
+                  source: source_for(record_content_source)
+                }.compact
+              ],
+              type: 'organization',
+              role: [
+                {
+                  value: 'original cataloging agency'
+                }
+              ]
+            }
+          end
+
+          def source_for(record_content_source)
+            {
+              code: record_content_source['authority'],
+              uri: record_content_source['authorityURI']
+            }.compact.presence
+          end
+
+          def build_language
+            return if language_of_cataloging.empty?
+
+            language_of_cataloging.map do |lang_node|
+              Cocina::Models::Mapping::FromMods::LanguageTerm.build(
+                language_element: lang_node,
+                notifier: notifier
+              )
+            end
+          end
+
+          def record_info
+            @record_info ||= resource_element.xpath('mods:recordInfo[1]', mods: Description::DESC_METADATA_NS).first
+          end
+
+          def language_of_cataloging
+            @language_of_cataloging ||= record_info.xpath('mods:languageOfCataloging', mods: Description::DESC_METADATA_NS)
+          end
+
+          def record_content_sources
+            @record_content_sources ||= record_info.xpath('mods:recordContentSource', mods: Description::DESC_METADATA_NS)
+          end
+
+          def description_standards
+            @description_standards ||= record_info.xpath('mods:descriptionStandard', mods: Description::DESC_METADATA_NS)
+          end
+
+          def record_origins
+            @record_origins ||= record_info.xpath('mods:recordOrigin', mods: Description::DESC_METADATA_NS)
+          end
+
+          def record_info_notes
+            @record_info_notes ||= record_info.xpath('mods:recordInfoNote', mods: Description::DESC_METADATA_NS)
+          end
+
+          def creation_event
+            @creation_event ||= record_info.xpath('mods:recordCreationDate', mods: Description::DESC_METADATA_NS).first
+          end
+
+          def modification_events
+            @modification_events ||= record_info.xpath('mods:recordChangeDate', mods: Description::DESC_METADATA_NS)
+          end
+
+          def record_identifiers
+            @record_identifiers ||= record_info.xpath('mods:recordIdentifier', mods: Description::DESC_METADATA_NS)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Mapping
+      module FromMods
+        # Helper class: splits nodes by altRepGroup ids
+        class AltRepGroup
+          # @param [Array<Nokogiri::XML::Element>] nodes to split
+          # @return [Array<Array<Nokogiri::XML::Element>>, Array<Nokogiri::XML::Element>] nodes grouped by altRepGroup, other nodes
+          def self.split(nodes:)
+            all_nodes_with_altrepgroup = nodes.reject { |node| node[:altRepGroup].blank? }
+            grouped_altrepgroup_nodes = all_nodes_with_altrepgroup
+                                        .group_by { |node| node[:altRepGroup] }
+                                        .values
+                                        .reject { |group_nodes| group_nodes.size == 1 }
+
+            other_nodes = nodes.reject { |node| grouped_altrepgroup_nodes.flatten.include?(node) }
+
+            [grouped_altrepgroup_nodes, other_nodes]
+          end
+        end
+      end
+    end
+  end
+end

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