dcc 0.2.0

data/lib/dcc/validate/schematron/rule.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Dcc
+  module Validate
+    module Schematron
+      # Base class for Schematron rules. Subclasses implement `#check_on(dcc)`
+      # returning an array of `Dcc::Validate::Issue` records.
+      class Rule
+        # @return [Symbol] severity for issues this rule produces.
+        def severity
+          ::Dcc::Validate::Severity::ERROR
+        end
+
+        # @return [String] rule code used in `Issue#code`.
+        def code
+          "dcc.schematron.#{self.class.name.split('::').last.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase}"
+        end
+
+        # @param dcc [Lutaml::Model::Serializable]
+        # @return [Array<Dcc::Validate::Issue>]
+        def check_on(dcc)
+          issues = []
+          walk(dcc, issues)
+          issues
+        end
+
+        protected
+
+        def walk(_node, _issues)
+          # Override in subclasses to traverse the model tree.
+        end
+
+        def issue(severity:, message:, line: nil, column: nil, path: nil, source: "schematron")
+          ::Dcc::Validate::Issue.build(
+            severity: severity,
+            message: message,
+            code: code,
+            line: line,
+            column: column,
+            path: path,
+            source: source,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron/rules/administrative_data_completeness.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Validates that all required sections are present in
+        # `dcc:administrativeData`: dccSoftware, coreData, items,
+        # calibrationLaboratory, respPersons, customer.
+        class AdministrativeDataCompleteness < Base
+          REQUIRED_SECTIONS = {
+            dcc_software: "dccSoftware",
+            core_data: "coreData",
+            items: "items",
+            calibration_laboratory: "calibrationLaboratory",
+            resp_persons: "respPersons",
+            customer: "customer",
+          }.freeze
+
+          def check_on(dcc)
+            issues = []
+            return issues unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+
+            admin = dcc.administrative_data
+            return [issue(severity: :error, message: "administrativeData is missing")] unless admin
+
+            REQUIRED_SECTIONS.each do |attr, label|
+              value = Dcc::TypeGuards.has_attribute?(admin, attr) ? admin.public_send(attr) : nil
+              next unless value.nil? || ((value.is_a?(::String) || value.is_a?(::Array)) && value.empty?)
+
+              issues << issue(
+                severity: :error,
+                message: "dcc:administrativeData/#{label} is missing",
+              )
+            end
+            issues
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron/rules/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Schematron rule base. Concrete rules subclass this and implement
+        # `#check_on(dcc)`. Each subclass declares its `severity`.
+        class Base < ::Dcc::Validate::Schematron::Rule
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron/rules/date_range_check.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Errors if `endPerformanceDate` precedes `beginPerformanceDate`.
+        class DateRangeCheck < Base
+          def check_on(dcc)
+            return [] unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+
+            core = safe_attr(dcc.administrative_data, :core_data)
+            return [] if core.nil?
+
+            begin_d = Dcc::TypeGuards.has_attribute?(core, :begin_performance_date) ? core.begin_performance_date : nil
+            end_d = Dcc::TypeGuards.has_attribute?(core, :end_performance_date) ? core.end_performance_date : nil
+
+            return [] if begin_d.nil? || end_d.nil?
+            return [] unless end_d < begin_d
+
+            [
+              issue(
+                severity: :error,
+                message: "endPerformanceDate (#{end_d}) precedes beginPerformanceDate (#{begin_d})",
+              ),
+            ]
+          end
+
+          private
+
+          def safe_attr(parent, attr)
+            return nil unless parent && parent.is_a?(::Lutaml::Model::Serializable) && parent.class.attributes.key?(attr)
+
+            parent.public_send(attr)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron/rules/id_refid_linking.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Validates that every `@id` on a DCC element has a matching `@refId`
+        # reference and vice versa.
+        class IdRefIdLinking < Base
+          def check_on(dcc)
+            issues = []
+            ids = ::Set.new
+            ref_ids = ::Set.new
+
+            collect(dcc, ids, ref_ids)
+
+            unused_ids = ids - ref_ids
+            unused_ids.each do |id|
+              issues << issue(
+                severity: :warning,
+                message: "@id '#{id}' is never referenced by any @refId",
+              )
+            end
+
+            dangling = ref_ids - ids
+            dangling.each do |rid|
+              issues << issue(
+                severity: :error,
+                message: "@refId '#{rid}' does not match any @id",
+              )
+            end
+
+            issues
+          end
+
+          private
+
+          def collect(node, ids, ref_ids)
+            return unless node.is_a?(::Lutaml::Model::Serializable)
+
+            id = node.respond_to?(:id) ? node.id : nil
+            ids << id if id && !id.empty?
+
+            ref_id = node.respond_to?(:ref_id) ? node.ref_id : nil
+            if ref_id && !ref_id.empty?
+              ref_id.split(/\s+/).each { |r| ref_ids << r }
+            end
+
+            node.class.attributes.each_key do |attr|
+              value = node.public_send(attr)
+              Array(value).each { |c| collect(c, ids, ref_ids) }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require "set"

data/lib/dcc/validate/schematron/rules/influence_conditions_placement.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # `dcc:influenceConditions` must appear somewhere (global, list, or
+        # quantity level). Error if missing.
+        class InfluenceConditionsPlacement < Base
+          def check_on(dcc)
+            return [] unless Dcc::TypeGuards.has_attribute?(dcc, :measurement_results)
+
+            mr_list = safe_attr(dcc.measurement_results, :measurement_result)
+            return [] if mr_list.empty?
+
+            any_present = mr_list.any? do |mr|
+              next false unless Dcc::TypeGuards.has_attribute?(mr, :influence_conditions)
+              next true unless mr.influence_conditions.nil?
+
+              Dcc::TypeGuards.has_attribute?(mr, :results) && mr.results &&
+                has_in_descendants?(mr.results)
+            end
+
+            any_present ? [] : [
+              issue(
+                severity: :error,
+                message: "dcc:influenceConditions is missing everywhere",
+              ),
+            ]
+          end
+
+          private
+
+          def has_in_descendants?(node)
+            return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+            if Dcc::TypeGuards.has_attribute?(node, :influence_conditions) && !node.influence_conditions.nil?
+              return true
+            end
+
+            node.class.attributes.each_key do |attr|
+              value = node.public_send(attr)
+              Array(value).any? { |c| has_in_descendants?(c) } if value.is_a?(::Array) || value.is_a?(::Lutaml::Model::Serializable)
+            end
+            false
+          end
+
+          def safe_attr(parent, attr)
+            return [] unless parent && parent.is_a?(::Lutaml::Model::Serializable) && parent.class.attributes.key?(attr)
+
+            Array(parent.public_send(attr))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron/rules/iso_code_validation.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Validates ISO 3166-1 (country) and ISO 639-1 (language) codes used
+        # in coreData. Custom type casts already enforce format; here we only
+        # flag empties that escaped earlier casts.
+        class IsoCodeValidation < Base
+          def check_on(dcc)
+            return [] unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+
+            core = safe_attr(dcc.administrative_data, :core_data)
+            return [] if core.nil?
+
+            issues = []
+            country = Dcc::TypeGuards.has_attribute?(core, :country_code_iso_3166_1) ? core.country_code_iso_3166_1 : nil
+            if country.nil? || country.to_s.empty?
+              issues << issue(
+                severity: :error,
+                message: "dcc:countryCodeISO3166_1 is missing",
+              )
+            end
+
+            used = Dcc::TypeGuards.has_attribute?(core, :used_lang_code_iso_639_1) ? Array(core.used_lang_code_iso_639_1) : []
+            issues << issue(
+              severity: :error,
+              message: "dcc:usedLangCodeISO639_1 must have at least one entry",
+            ) if used.empty?
+
+            mandatory = Dcc::TypeGuards.has_attribute?(core, :mandatory_lang_code_iso_639_1) ? Array(core.mandatory_lang_code_iso_639_1) : []
+            issues << issue(
+              severity: :error,
+              message: "dcc:mandatoryLangCodeISO639_1 must have at least one entry",
+            ) if mandatory.empty?
+
+            issues
+          end
+
+          private
+
+          def safe_attr(parent, attr)
+            return nil unless parent && parent.is_a?(::Lutaml::Model::Serializable) && parent.class.attributes.key?(attr)
+
+            parent.public_send(attr)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron/rules/language_code_dedup.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Errors on duplicate language codes in `dcc:usedLangCodeISO639_1`.
+        class LanguageCodeDedup < Base
+          def check_on(dcc)
+            return [] unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+
+            core = safe_attr(dcc.administrative_data, :core_data)
+            return [] if core.nil?
+
+            used = Dcc::TypeGuards.has_attribute?(core, :used_lang_code_iso_639_1) ? Array(core.used_lang_code_iso_639_1) : []
+            used_strings = used.map(&:to_s)
+            duplicates = used_strings.group_by(&:itself).select { |_k, v| v.size > 1 }.keys
+
+            duplicates.map do |dup|
+              issue(
+                severity: :error,
+                message: "dcc:usedLangCodeISO639_1 contains duplicate '#{dup}'",
+              )
+            end
+          end
+
+          private
+
+          def safe_attr(parent, attr)
+            return nil unless parent && parent.is_a?(::Lutaml::Model::Serializable) && parent.class.attributes.key?(attr)
+
+            parent.public_send(attr)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron/rules/non_si_declaration.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Validates that non-SI units (prefixed with `|`) are declared
+        # somewhere in the DCC via `dcc:nonSIUnit` and `dcc:nonSIDefinition`
+        # elements inside `dcc:statement`.
+        class NonSiDeclaration < Base
+          def check_on(dcc)
+            issues = []
+            return issues unless dcc.is_a?(::Lutaml::Model::Serializable)
+
+            declared_units = collect_declared_non_si_units(dcc, ::Set.new)
+            used_units = ::Set.new
+            walk_for_used_units(dcc, used_units, ::Set.new)
+
+            (used_units - declared_units).each do |unit|
+              issues << issue(
+                severity: :error,
+                message: "non-SI unit '#{unit}' is used but not declared in dcc:nonSIUnit",
+              )
+            end
+            issues
+          end
+
+          private
+
+          def collect_declared_non_si_units(node, visited)
+            return [].to_set unless node.is_a?(::Lutaml::Model::Serializable)
+            return [].to_set if visited.include?(node.object_id)
+
+            visited << node.object_id
+            declared = collect_from_node(node)
+            node.class.attributes.each_key do |attr_name|
+              value = node.public_send(attr_name)
+              Array(value).each do |child|
+                declared += collect_declared_non_si_units(child, visited) if child.is_a?(::Lutaml::Model::Serializable)
+              end
+            end
+            declared
+          end
+
+          def collect_from_node(node)
+            return [].to_set unless node.respond_to?(:non_si_unit)
+
+            u = node.non_si_unit
+            u.to_s.empty? ? [].to_set : ::Set.new([u.to_s])
+          end
+
+          def walk_for_used_units(node, accumulator, visited)
+            return unless node.is_a?(::Lutaml::Model::Serializable)
+            return if visited.include?(node.object_id)
+
+            visited << node.object_id
+            extract_non_si_unit(node, accumulator)
+            node.class.attributes.each_key do |attr_name|
+              value = node.public_send(attr_name)
+              Array(value).each { |child| walk_for_used_units(child, accumulator, visited) }
+            end
+          end
+
+          def extract_non_si_unit(node, accumulator)
+            %i[unit unit_xml_list].each do |attr|
+              next unless Dcc::TypeGuards.has_attribute?(node, attr)
+
+              v = node.public_send(attr)
+              next if v.nil? || v.to_s.empty?
+
+              v.to_s.split(/\s+/).each do |tok|
+                accumulator << tok if tok.start_with?("|")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require "set"

data/lib/dcc/validate/schematron/rules/release_format_check.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Validates `dcc:release` format: `^[a-zA-Z]{1}(\s)?([0-9]{1,3}\.){0,3}([0-9]{1,3})$`
+        class ReleaseFormatCheck < Base
+          PATTERN = /\A[a-zA-Z]{1} ?([0-9]{1,3}\.){0,3}[0-9]{1,3}\z/
+
+          def check_on(dcc)
+            issues = []
+            return issues unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+
+            software_list = safe_attr(dcc.administrative_data, :dcc_software)
+            return issues if software_list.nil?
+
+            Array(safe_attr(software_list, :software)).each do |sw|
+              release = Dcc::TypeGuards.has_attribute?(sw, :release) ? sw.release : nil
+              next if release.nil? || release.empty?
+              next if release.match?(PATTERN)
+
+              issues << issue(
+                severity: :error,
+                message: "dcc:release '#{release}' does not match the expected format",
+              )
+            end
+
+            issues
+          end
+
+          private
+
+          def safe_attr(parent, attr)
+            return nil unless parent && parent.is_a?(::Lutaml::Model::Serializable) && parent.class.attributes.key?(attr)
+
+            parent.public_send(attr)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron/rules/schema_version_check.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Warn when the schemaVersion is not the latest known release.
+        class SchemaVersionCheck < Base
+          def severity
+            ::Dcc::Validate::Severity::WARNING
+          end
+
+          def check_on(dcc)
+            return [] unless Dcc::TypeGuards.has_attribute?(dcc, :schema_version)
+
+            current = dcc.schema_version.to_s
+            latest = ::Dcc::Schema::Version::DCC_LATEST
+
+            current == latest ? [] : [
+              issue(
+                severity: :warning,
+                message: "schemaVersion '#{current}' is not the latest release (#{latest})",
+              ),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron/rules/uncertainty_consistency.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Validates that for every `si:realListXMLList` paired with an
+        # `si:expandedUncXMLList`, the count of values matches the count
+        # of uncertainty entries.
+        class UncertaintyConsistency < Base
+          def check_on(dcc)
+            issues = []
+            return issues unless dcc.is_a?(::Lutaml::Model::Serializable)
+
+            walk(dcc, issues, ::Set.new)
+            issues
+          end
+
+          private
+
+          def walk(node, issues, visited)
+            return unless node.is_a?(::Lutaml::Model::Serializable)
+            return if visited.include?(node.object_id)
+
+            visited << node.object_id
+
+            check_node(node, issues) if node.class.name.end_with?("::RealListXmlList")
+            descend(node, issues, visited)
+          end
+
+          def check_node(list_node, issues)
+            values = list_node.value_xml_list
+            unc = list_node.expanded_unc_xml_list
+            return unless unc && values
+
+            unc_count = Array(unc.uncertainty_xml_list).size
+            value_count = Array(values).size
+            return if unc_count == value_count || unc_count.zero?
+
+            issues << issue(
+              severity: :error,
+              message: "valueXMLList count (#{value_count}) does not match expandedUncertaintyXMLList count (#{unc_count})",
+            )
+          end
+
+          def descend(node, issues, visited)
+            node.class.attributes.each_key do |attr_name|
+              value = node.public_send(attr_name)
+              Array(value).each { |child| walk(child, issues, visited) }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require "set"

data/lib/dcc/validate/schematron/rules/unit_format_check.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Validates that SI unit expressions contain no whitespace and
+        # that `unitXMLList` element count matches `valueXMLList` count.
+        class UnitFormatCheck < Base
+          def check_on(dcc)
+            issues = []
+            return issues unless dcc.is_a?(::Lutaml::Model::Serializable)
+
+            walk(dcc, issues, ::Set.new)
+            issues
+          end
+
+          private
+
+          def walk(node, issues, visited)
+            return unless node.is_a?(::Lutaml::Model::Serializable)
+            return if visited.include?(node.object_id)
+
+            visited << node.object_id
+
+            check_single_unit(node, issues)
+            check_list_unit(node, issues)
+            descend(node, issues, visited)
+          end
+
+          def check_single_unit(node, issues)
+            return unless node.class.name.end_with?("::Real", "::Complex", "::Constant")
+            return unless node.respond_to?(:unit)
+
+            unit = node.unit
+            return unless unit && unit.to_s.match?(/\s/)
+
+            issues << issue(
+              severity: :error,
+              message: "si:unit '#{unit}' must not contain whitespace",
+            )
+          end
+
+          def check_list_unit(node, issues)
+            return unless node.class.name.end_with?("::RealListXmlList")
+            return unless node.respond_to?(:unit_xml_list)
+
+            unit_list = node.unit_xml_list
+            value_list = node.respond_to?(:value_xml_list) ? node.value_xml_list : nil
+            return unless unit_list && value_list
+
+            unit_count = unit_list.to_s.split(/\s+/).length
+            value_count = Array(value_list).length
+            return if unit_count == value_count || unit_count == 1
+
+            issues << issue(
+              severity: :error,
+              message: "unitXMLList count (#{unit_count}) does not match valueXMLList count (#{value_count})",
+            )
+          end
+
+          def descend(node, issues, visited)
+            node.class.attributes.each_key do |attr_name|
+              value = node.public_send(attr_name)
+              Array(value).each { |child| walk(child, issues, visited) }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require "set"