cocina-models 0.119.0 → 0.121.0

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

@@ -435,7 +435,7 @@ module Cocina
               new_node = node.deep_dup
               new_node.remove_attribute('encoding') if common_attribs[:encoding].present? || node[:encoding]&.empty?
               new_node.remove_attribute('qualifier') if common_attribs[:qualifier].present? || node[:qualifier]&.empty?
-              build_date(new_node)
+              build_date(new_node, encoding: common_attribs.dig(:encoding, :code))
             end
             { structuredValue: dates }.merge(common_attribs).compact
           end
@@ -462,9 +462,11 @@ module Cocina
             attribs.compact
           end
 
-          def build_date(date_node)
+          def build_date(date_node, encoding: nil)
+            effective_encoding = date_node['encoding'] || encoding
             {}.tap do |date|
-              date[:value] = clean_date(date_node.text) if date_node.text.present?
+              raw_value = clean_date(date_node.text)
+              date[:value] = effective_encoding == 'edtf' ? pad_edtf_year(raw_value) : raw_value if date_node.text.present?
               date[:encoding] = { code: date_node['encoding'] } if date_node['encoding']
               date[:status] = 'primary' if date_node['keyDate']
               date[:note] = build_date_note(date_node)
@@ -489,6 +491,13 @@ module Cocina
             date.delete_suffix('.')
           end
 
+          # Pads a 1-3 digit year to 4 digits, handling modifiers like ~,-.
+          def pad_edtf_year(value)
+            value.sub(%r{\A(-?)(\d{1,3})(?=[~?%/-]|\z)}) do
+              "#{::Regexp.last_match(1)}#{::Regexp.last_match(2).rjust(4, '0')}"
+            end
+          end
+
           # NOTE: Do any eventType/displayLabel transformations before determining role (i.e. with LEGACY_EVENT_TYPES_2_TYPE)
           def role_for(event)
             case event[:type]

data/lib/cocina/models/related_resource.rb

@@ -14,7 +14,7 @@ module Cocina
       # The preferred display label to use for the related resource in access systems.
       attribute? :displayLabel, Types::Strict::String.optional
       # Titles of the related resource.
-      attribute :title, Types::Strict::Array.of(DescriptiveValue).default([].freeze)
+      attribute :title, Types::Strict::Array.of(Title).default([].freeze)
       # Agents contributing in some way to the creation and history of the related resource.
       attribute :contributor, Types::Strict::Array.of(Contributor).default([].freeze)
       # Events in the history of the related resource.

data/lib/cocina/models/validators/base_description_visitor_validator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Validators
+      # Super class for description validators that use a visitor pattern.
+      class BaseDescriptionVisitorValidator
+        def visit_hash(hash:, path:); end
+
+        def visit_array(array:, path:); end
+
+        def visit_obj(obj:, path:); end
+
+        # @raise [ValidationError] if validation fails
+        def validate!; end
+
+        def path_to_s(path)
+          # This matches the format used by descriptive spreadsheets
+          path_str = ''
+          path.each_with_index do |part, index|
+            if part.is_a?(Integer)
+              path_str += (part + 1).to_s
+            else
+              path_str += '.' if index.positive?
+              path_str += part.to_s
+            end
+          end
+          path_str
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/validators/base_structural_visitor_validator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Validators
+      # Super class for structural validators that use a visitor pattern.
+      class BaseStructuralVisitorValidator
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        def visit_file(file_hash:); end
+
+        # @raise [ValidationError] if validation fails
+        def validate!; end
+
+        private
+
+        attr_reader :attributes
+      end
+    end
+  end
+end

data/lib/cocina/models/validators/composite_description_validator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Validators
+      # Composite validator for description that uses a visitor pattern to validate in a single pass.
+      class CompositeDescriptionValidator
+        VALIDATORS = [
+          DescriptionTypesVisitorValidator,
+          DescriptionValuesVisitorValidator,
+          DescriptionDateTimeVisitorValidator
+        ].freeze
+
+        def self.validate(clazz, attributes)
+          new(clazz, attributes).validate
+        end
+
+        def initialize(clazz, attributes, validators: VALIDATORS)
+          @clazz = clazz
+          @attributes = attributes
+          @validators = validators.map(&:new)
+        end
+
+        def validate
+          return unless meets_preconditions?
+
+          validate_obj(obj: attributes, path: [])
+
+          validators.each(&:validate!)
+        end
+
+        private
+
+        attr_reader :clazz, :attributes, :validators
+
+        def meets_preconditions?
+          [Cocina::Models::Description, Cocina::Models::RequestDescription].include?(clazz)
+        end
+
+        def validate_hash(hash:, path:)
+          validators.each { |validator| validator.visit_hash(hash:, path:) }
+          hash.each do |key, obj|
+            validate_obj(obj:, path: path + [key])
+          end
+        end
+
+        def validate_array(array:, path:)
+          validators.each { |validator| validator.visit_array(array:, path:) }
+          array.each_with_index do |obj, index|
+            validate_obj(obj:, path: path + [index])
+          end
+        end
+
+        def validate_obj(obj:, path:)
+          validators.each { |validator| validator.visit_obj(obj:, path:) }
+          validate_hash(hash: obj, path: path) if obj.is_a?(Hash)
+          validate_array(array: obj, path: path) if obj.is_a?(Array)
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/validators/composite_structural_validator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Validators
+      # Composite validator for structural metadata that uses a visitor pattern to validate files in a single pass.
+      class CompositeStructuralValidator
+        VALIDATORS = [
+          DarkVisitorValidator,
+          LanguageTagVisitorValidator,
+          ReservedFilenameVisitorValidator
+        ].freeze
+
+        def self.validate(clazz, attributes)
+          new(clazz, attributes).validate
+        end
+
+        def initialize(clazz, attributes, validators: VALIDATORS)
+          @clazz = clazz
+          @attributes = attributes
+          @validators = validators.map { |v| v.new(attributes) }
+        end
+
+        def validate
+          return unless meets_preconditions?
+
+          Array(attributes.dig(:structural, :contains)).each do |fileset_hash|
+            Array(fileset_hash.dig(:structural, :contains)).each do |file_hash|
+              validators.each { |validator| validator.visit_file(file_hash:) }
+            end
+          end
+
+          validators.each(&:validate!)
+        end
+
+        private
+
+        attr_reader :clazz, :attributes, :validators
+
+        def meets_preconditions?
+          clazz::TYPES.intersect?(DRO::TYPES)
+        rescue NameError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/validators/dark_visitor_validator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Validators
+      # Validates that shelve and publish file attributes are set to false for dark DRO objects.
+      class DarkVisitorValidator < BaseStructuralVisitorValidator
+        def visit_file(file_hash:)
+          return unless dark_object?
+
+          invalid_files << file_hash if invalid?(file_hash)
+        end
+
+        def validate!
+          return if invalid_files.empty?
+
+          filenames = invalid_files.map { |file| file[:filename] || file[:label] }
+          raise ValidationError, 'Not all files have dark access and/or are unshelved ' \
+                                 "when object access is dark: #{filenames}"
+        end
+
+        private
+
+        def invalid_files
+          @invalid_files ||= []
+        end
+
+        def dark_object?
+          # Checking for nil to account for default being dark.
+          @dark_object ||= ['dark', nil].include?(attributes.dig(:access, :view))
+        end
+
+        def invalid?(file)
+          # Ignore if a WARC
+          return false if file[:hasMimeType] == 'application/warc'
+
+          return true if file.dig(:administrative, :shelve)
+          # Checking for nil to account for default being dark.
+          return true if ['dark', nil].exclude?(file.dig(:access, :view))
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/validators/description_date_time_visitor_validator.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'edtf'
+
+module Cocina
+  module Models
+    module Validators
+      # Validates that dates of known types are type-valid using the visitor pattern.
+      class DescriptionDateTimeVisitorValidator < BaseDescriptionVisitorValidator
+        VALIDATABLE_TYPES = %w[edtf iso8601 w3cdtf].freeze
+
+        def visit_hash(hash:, path:) # rubocop:disable Metrics/CyclomaticComplexity
+          # Only dates nested under a `date` key are subject to validation.
+          # For example, event.date is in scope but event.note is not.
+          return unless in_date_path?(path)
+
+          # A hash with a validatable encoding.code "owns" the encoding for its
+          # entire subtree.  For example, the outer hash below owns iso8601 for
+          # both structuredValue children even though those children carry no
+          # encoding themselves:
+          #
+          #   date: [{
+          #     structuredValue: [
+          #       { value: '1996', type: 'start' },
+          #       { value: '1998', type: 'end' }
+          #     ],
+          #     encoding: { code: 'iso8601' }   # ← registered at path [:date, 0]
+          #   }]
+          #
+          # We record the path before visiting children because
+          # CompositeDescriptionValidator calls visit_hash on a parent before
+          # recursing into its children, so the encoding is always registered
+          # before any child value hashes are visited.
+          code = hash.dig(:encoding, :code)
+          encoding_paths[path.dup] = code if code && VALIDATABLE_TYPES.include?(code)
+
+          value = hash[:value]
+          return unless value.is_a?(String)
+
+          # Resolve which encoding governs this value by finding the longest
+          # registered encoding path that is a prefix of the current path.
+          # Longest-prefix wins so that a more-specific inner encoding overrides
+          # a less-specific outer one.  For example, given:
+          #
+          #   date: [{
+          #     parallelValue: [
+          #       { value: '1996', encoding: { code: 'edtf' } },  # path [:date,0,:parallelValue,0]
+          #       { value: '一九九六' }                              # path [:date,0,:parallelValue,1]
+          #     ],
+          #     encoding: { code: 'iso8601' }                      # path [:date,0]
+          #   }]
+          #
+          # The value '1996' at [:date,0,:parallelValue,0] matches both [:date,0]
+          # (iso8601) and [:date,0,:parallelValue,0] (edtf); the longer prefix wins
+          # and it is validated as edtf.  The value '一九九六' at
+          # [:date,0,:parallelValue,1] only matches [:date,0] (iso8601).
+          encoding_path, code = find_encoding_for(path)
+          return unless code
+
+          invalid_groups[encoding_path] ||= []
+          invalid_groups[encoding_path] << value unless valid_value?(value, code)
+        end
+
+        def validate!
+          return if invalid_groups.empty?
+
+          invalid_dates = invalid_groups.filter_map do |path, values|
+            next if values.empty?
+
+            [*values, encoding_paths[path]]
+          end
+
+          return if invalid_dates.empty?
+
+          raise ValidationError, "Invalid date(s) in description: #{invalid_dates}"
+        end
+
+        private
+
+        def encoding_paths
+          @encoding_paths ||= {}
+        end
+
+        def invalid_groups
+          @invalid_groups ||= {}
+        end
+
+        def in_date_path?(path)
+          path.any? { |part| part.to_s == 'date' }
+        end
+
+        def find_encoding_for(path)
+          encoding_paths
+            .select { |prefix, _| path.first(prefix.length) == prefix }
+            .max_by { |prefix, _| prefix.length }
+        end
+
+        def valid_value?(value, code)
+          send(:"valid_#{code}?", value)
+        end
+
+        def valid_edtf?(value)
+          return false if value == 'XXXX'
+
+          Date.edtf!(value)
+          true
+        rescue StandardError
+          # NOTE: the upstream EDTF implementation in the `edtf` gem does not
+          #       allow a valid pattern that we use (possibly because only level
+          #       0 of the spec was implemented?):
+          #
+          # * Y-20555
+          #
+          # So we catch the false positives from the upstream gem and allow
+          # this pattern to validate
+          /\AY-?\d{5,}\Z/.match?(value)
+        end
+
+        def valid_iso8601?(value)
+          DateTime.iso8601(value)
+          true
+        rescue StandardError
+          false
+        end
+
+        def valid_w3cdtf?(value)
+          W3cdtfValidator.validate(value)
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/validators/{description_types_validator.rb → description_types_visitor_validator.rb}

@@ -4,54 +4,22 @@ module Cocina
   module Models
     module Validators
       # Validates types for description against description_types.yml.
-      class DescriptionTypesValidator
-        def self.validate(clazz, attributes)
-          new(clazz, attributes).validate
-        end
-
-        def initialize(clazz, attributes)
-          @clazz = clazz
-          @attributes = attributes
-          @error_paths = []
-        end
-
-        def validate
-          return unless meets_preconditions?
-
-          validate_obj(attributes, [])
-
+      class DescriptionTypesVisitorValidator < BaseDescriptionVisitorValidator
+        def validate!
           return if error_paths.empty?
 
           raise ValidationError, "Unrecognized types in description: #{error_paths.join(', ')}"
         end
 
-        private
-
-        attr_reader :clazz, :attributes, :error_paths
-
-        def meets_preconditions?
-          [Cocina::Models::Description, Cocina::Models::RequestDescription].include?(clazz)
-        end
-
-        def validate_hash(hash, path)
-          hash.each do |key, obj|
-            if key.to_sym == :type
-              validate_type(obj, path)
-            else
-              validate_obj(obj, path + [key])
-            end
-          end
+        def visit_hash(hash:, path:)
+          type = hash[:type]
+          validate_type(type, path) if type
         end
 
-        def validate_array(array, path)
-          array.each_with_index do |obj, index|
-            validate_obj(obj, path + [index])
-          end
-        end
+        private
 
-        def validate_obj(obj, path)
-          validate_hash(obj, path) if obj.is_a?(Hash)
-          validate_array(obj, path) if obj.is_a?(Array)
+        def error_paths
+          @error_paths ||= []
         end
 
         def validate_type(type, path)
@@ -73,7 +41,7 @@ module Cocina
         # Some part of the path are ignored for the purpose of matching.
         def clean_path(path)
           new_path = path.reject do |part|
-            part.is_a?(Integer) || %i[parallelValue parallelContributor parallelEvent].include?(part.to_sym)
+            part.is_a?(Integer) || %i[parallelValue parallelEvent].include?(part.to_sym)
           end.map(&:to_sym)
           # This needs to happen after parallelValue is removed
           # to handle structuredValue > parallelValue > structuredValue
@@ -100,20 +68,6 @@ module Cocina
         def types_yaml
           YAML.load_file(::File.expand_path('../../../../description_types.yml', __dir__))
         end
-
-        def path_to_s(path)
-          # This matches the format used by descriptive spreadsheets
-          path_str = ''
-          path.each_with_index do |part, index|
-            if part.is_a?(Integer)
-              path_str += (part + 1).to_s
-            else
-              path_str += '.' if index.positive?
-              path_str += part.to_s
-            end
-          end
-          path_str
-        end
       end
     end
   end

data/lib/cocina/models/validators/{description_values_validator.rb → description_values_visitor_validator.rb}

@@ -3,25 +3,16 @@
 module Cocina
   module Models
     module Validators
-      # Validates that there is only one of value, groupedValue, structuredValue, or parallelValue.
-      class DescriptionValuesValidator
-        def self.validate(clazz, attributes)
-          new(clazz, attributes).validate
-        end
-
-        def initialize(clazz, attributes)
-          @clazz = clazz
-          @attributes = attributes
-          @error_paths_multiple = []
-          @error_paths_blank = []
-          @error_paths_missing_title_type = []
+      # Validates that there is only one of value, groupedValue, structuredValue, or parallelValue,
+      # that values are not blank, and that title structuredValue entries have a type.
+      class DescriptionValuesVisitorValidator < BaseDescriptionVisitorValidator
+        def visit_hash(hash:, path:)
+          validate_values_for_blanks(hash, path)
+          validate_values_for_multiples(hash, path)
+          validate_title_type(hash, path)
         end
 
-        def validate
-          return unless meets_preconditions?
-
-          validate_obj(attributes, [])
-
+        def validate!
           unless error_paths_multiple.empty?
             raise ValidationError,
                   "Multiple value, groupedValue, structuredValue, and parallelValue in description: #{error_paths_multiple.join(', ')}"
@@ -38,30 +29,16 @@ module Cocina
 
         private
 
-        attr_reader :clazz, :attributes, :error_paths_blank, :error_paths_multiple, :error_paths_missing_title_type
-
-        def meets_preconditions?
-          [Cocina::Models::Description, Cocina::Models::RequestDescription].include?(clazz)
-        end
-
-        def validate_hash(hash, path)
-          validate_values_for_blanks(hash, path)
-          validate_values_for_multiples(hash, path)
-          validate_title_type(hash, path)
-          hash.each do |key, obj|
-            validate_obj(obj, path + [key])
-          end
+        def error_paths_multiple
+          @error_paths_multiple ||= []
         end
 
-        def validate_array(array, path)
-          array.each_with_index do |obj, index|
-            validate_obj(obj, path + [index])
-          end
+        def error_paths_blank
+          @error_paths_blank ||= []
         end
 
-        def validate_obj(obj, path)
-          validate_hash(obj, path) if obj.is_a?(Hash)
-          validate_array(obj, path) if obj.is_a?(Array)
+        def error_paths_missing_title_type
+          @error_paths_missing_title_type ||= []
         end
 
         def validate_values_for_blanks(hash, path)
@@ -98,20 +75,6 @@ module Cocina
           structured_value_path = path[2] == 'structuredValue' || (path[2] == 'parallelValue' && path[4] == 'structuredValue')
           path.first == 'title' && structured_value_path
         end
-
-        def path_to_s(path)
-          # This matches the format used by descriptive spreadsheets
-          path_str = ''
-          path.each_with_index do |part, index|
-            if part.is_a?(Integer)
-              path_str += (part + 1).to_s
-            else
-              path_str += '.' if index.positive?
-              path_str += part.to_s
-            end
-          end
-          path_str
-        end
       end
     end
   end