dcc 0.2.0

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # `dcc:usedMethods` must appear somewhere (global, list, or quantity
+        # level). Error if missing everywhere.
+        class UsedMethodsPlacement < Base
+          def check_on(dcc)
+            issues = []
+            return issues unless Dcc::TypeGuards.has_attribute?(dcc, :measurement_results)
+
+            mr_list = safe_attr(dcc.measurement_results, :measurement_result)
+            return issues if mr_list.empty?
+
+            any_used = mr_list.any? do |mr|
+              Dcc::TypeGuards.has_attribute?(mr, :used_methods) && !mr.used_methods.nil? ||
+                mr_has_descendant?(mr, :used_methods)
+            end
+
+            issues << issue(
+              severity: :error,
+              message: "dcc:usedMethods is missing in every measurementResult and its descendants",
+            ) unless any_used
+
+            issues
+          end
+
+          private
+
+          def mr_has_descendant?(mr, attr_name)
+            return false unless Dcc::TypeGuards.has_attribute?(mr, :results) && mr.results
+
+            result = safe_attr(mr.results, :result)
+            result.any? { |r| descendant_has?(r, attr_name) }
+          end
+
+          def descendant_has?(node, attr_name)
+            return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+            if Dcc::TypeGuards.has_attribute?(node, attr_name) && !node.public_send(attr_name).nil?
+              return true
+            end
+
+            node.class.attributes.each_key do |attr|
+              value = node.public_send(attr)
+              next unless value.is_a?(::Array) || value.is_a?(::Lutaml::Model::Serializable)
+
+              Array(value).any? { |child| descendant_has?(child, attr_name) }
+            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/used_software_placement.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # `dcc:usedSoftware` is recommended but only generates a warning.
+        class UsedSoftwarePlacement < Base
+          def severity
+            ::Dcc::Validate::Severity::WARNING
+          end
+
+          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?
+
+            present = mr_list.any? do |mr|
+              Dcc::TypeGuards.has_attribute?(mr, :used_software) && !mr.used_software.nil?
+            end
+
+            present ? [] : [
+              issue(
+                severity: :warning,
+                message: "dcc:usedSoftware is missing on every measurementResult",
+              ),
+            ]
+          end
+
+          private
+
+          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/xml_list_spacing.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        # Validates spacing in `*XMLList` attributes and elements: single
+        # space between tokens, no leading/trailing space.
+        class XmlListSpacing < Base
+          def check_on(dcc)
+            issues = []
+            check_string_list_attribute(dcc, issues, :ref_type, "refType")
+            issues
+          end
+
+          private
+
+          def check_string_list_attribute(node, issues, attr, label)
+            return unless node.is_a?(::Lutaml::Model::Serializable)
+
+            if Dcc::TypeGuards.has_attribute?(node, attr)
+              value = node.public_send(attr)
+              value = value.to_s if value
+              if value && !value.empty? && (value.start_with?(" ") || value.end_with?(" ") || value.match?(/\s\s/))
+                issues << issue(
+                  severity: :error,
+                  message: "#{label} has invalid spacing: '#{value}'",
+                )
+              end
+            end
+
+            node.class.attributes.each_key do |a|
+              v = node.public_send(a)
+              Array(v).each { |child| check_string_list_attribute(child, issues, attr, label) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# `Dcc::Validate::Schematron::Rules` hosts the 14 pure-Ruby PTB Schematron
+# rule classes. Each rule subclasses `Base` and overrides `#check_on(dcc)`.
+#
+# The parent module autoloads every rule lazily — no `require_relative`
+# is used anywhere in this directory (project rule).
+module Dcc
+  module Validate
+    module Schematron
+      module Rules
+        autoload :Base, "dcc/validate/schematron/rules/base"
+        autoload :UsedMethodsPlacement, "dcc/validate/schematron/rules/used_methods_placement"
+        autoload :UsedSoftwarePlacement, "dcc/validate/schematron/rules/used_software_placement"
+        autoload :InfluenceConditionsPlacement, "dcc/validate/schematron/rules/influence_conditions_placement"
+        autoload :SchemaVersionCheck, "dcc/validate/schematron/rules/schema_version_check"
+        autoload :IdRefIdLinking, "dcc/validate/schematron/rules/id_refid_linking"
+        autoload :IsoCodeValidation, "dcc/validate/schematron/rules/iso_code_validation"
+        autoload :DateRangeCheck, "dcc/validate/schematron/rules/date_range_check"
+        autoload :ReleaseFormatCheck, "dcc/validate/schematron/rules/release_format_check"
+        autoload :UncertaintyConsistency, "dcc/validate/schematron/rules/uncertainty_consistency"
+        autoload :UnitFormatCheck, "dcc/validate/schematron/rules/unit_format_check"
+        autoload :NonSiDeclaration, "dcc/validate/schematron/rules/non_si_declaration"
+        autoload :LanguageCodeDedup, "dcc/validate/schematron/rules/language_code_dedup"
+        autoload :XmlListSpacing, "dcc/validate/schematron/rules/xml_list_spacing"
+        autoload :AdministrativeDataCompleteness, "dcc/validate/schematron/rules/administrative_data_completeness"
+      end
+    end
+  end
+end

data/lib/dcc/validate/schematron.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# `Dcc::Validate::Schematron` is the public Schematron validator. Calling
+# `Dcc::Validate::Schematron.call(dcc)` runs the entire PTB rule profile
+# and returns a `Dcc::Validate::Result`.
+module Dcc
+  module Validate
+    module Schematron
+      autoload :Rule, "dcc/validate/schematron/rule"
+      autoload :Profile, "dcc/validate/schematron/profile"
+      autoload :Rules, "dcc/validate/schematron/rules"
+
+      class << self
+        # @param dcc [Lutaml::Model::Serializable]
+        # @return [Dcc::Validate::Result]
+        def call(dcc)
+          Profile.call(dcc)
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/severity.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Validate
+    # Severity levels for validation issues. Matches PTB's Schematron roles
+    # plus the standard error/warning/info distinction.
+    module Severity
+      ERROR = :error
+      WARNING = :warning
+      INFO = :info
+      UNKNOWN = :unknown
+
+      ALL = [ERROR, WARNING, INFO, UNKNOWN].freeze
+
+      class << self
+        # Coerce a string/symbol to a canonical severity symbol.
+        # @return [Symbol]
+        def normalize(value)
+          return value if ALL.include?(value)
+          return UNKNOWN unless value
+
+          sym = value.to_s.downcase.sub(/\A(strict_)?/, "").to_sym
+          case sym
+          when :err then ERROR
+          when :warn then WARNING
+          when :information, :informational then INFO
+          else
+            ALL.include?(sym) ? sym : UNKNOWN
+          end
+        end
+
+        # @return [Boolean] whether issues at this severity fail validation.
+        def failing?(severity)
+          severity == ERROR
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/xsd.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Dcc
+  module Validate
+    # `Dcc::Validate::Xsd` validates DCC XML against one of the 12 bundled DCC
+    # schema versions. Auto-detects the version from the `schemaVersion`
+    # attribute when `version:` is `:auto` or nil.
+    #
+    # @example
+    #   result = Dcc::Validate::Xsd.call(File.read("certificate.xml"))
+    #   result.ok?      # => true
+    #   result.errors   # => []
+    #
+    #   result = Dcc::Validate::Xsd.call(xml, version: "3.3.0")
+    #   result = Dcc::Validate::Xsd.call(xml, version: :auto)
+    module Xsd
+      SCHEMA_CACHE = {} # rubocop:disable Style/MutableConstant -- populated at runtime
+
+      class << self
+        # @param xml [String, IO] DCC XML to validate.
+        # @param version [String, Symbol, nil] DCC version or `:auto` for
+        #   auto-detection. Defaults to `:auto`.
+        # @return [Dcc::Validate::Result]
+        def call(xml, version: :auto)
+          resolved = ::Dcc::Schema::Version.resolve_dcc(version, xml: xml)
+          schema = schema_for(resolved)
+          doc = parse_xml(xml)
+          errors = schema.validate(doc).map { |e| issue_from_nokogiri(e, resolved) }
+
+          ::Dcc::Validate::Result.new(
+            issues: errors,
+            schema_version: resolved,
+            source: "xsd",
+          )
+        end
+
+        private
+
+        def schema_for(version)
+          SCHEMA_CACHE[version] ||= load_schema(version)
+        end
+
+        def load_schema(version)
+          xsd_path = ::Dcc::Schema.path("dcc/v#{version}/dcc.xsd")
+          resolved = resolve_imports(xsd_path)
+          ::Nokogiri::XML::Schema.new(resolved)
+        rescue ::Nokogiri::XML::SyntaxError => e
+          raise ::Dcc::SchemaError,
+                "Failed to load bundled DCC XSD v#{version}: #{e.message}",
+                e.backtrace
+        end
+
+        # Rewrite relative `schemaLocation` imports to absolute file:// URIs
+        # so libxml2 can resolve them regardless of the process CWD. Nokogiri
+        # does not expose a base-URI option for `Schema.new`.
+        def resolve_imports(xsd_path)
+          base_dir = ::File.dirname(xsd_path)
+          content = ::File.read(xsd_path)
+          content.gsub(/schemaLocation\s*=\s*"([^"]+)"/) do |_match|
+            relative = ::Regexp.last_match(1)
+            next %{schemaLocation="#{relative}"} if relative.start_with?("http", "file://")
+
+            absolute = ::File.expand_path(relative, base_dir)
+            %{schemaLocation="file://#{absolute}"}
+          end
+        end
+
+        def parse_xml(xml)
+          xml_string = ::Dcc.read_input(xml)
+          ::Nokogiri::XML(xml_string) { |c| c.strict }
+        end
+
+        def issue_from_nokogiri(nokogiri_error, version)
+          ::Dcc::Validate::Issue.build(
+            severity: classify(nokogiri_error),
+            message: nokogiri_error.message,
+            code: "dcc.xsd.#{version}",
+            line: nokogiri_error.line,
+            column: nokogiri_error.column,
+            source: "xsd",
+          )
+        end
+
+        def classify(nokogiri_error)
+          # libxml2 levels: 1 = WARNING, 2 = ERROR, 3 = FATAL.
+          case nokogiri_error.level
+          when 2, 3 then ::Dcc::Validate::Severity::ERROR
+          when 1 then ::Dcc::Validate::Severity::WARNING
+          else ::Dcc::Validate::Severity::INFO
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# `Dcc::Validate` is the entry-point module for all validation services:
+# XSD, Schematron, and Ruby-side business rules. Each service returns a
+# `Dcc::Validate::Result` model that can be rendered as text, JSON, or YAML.
+module Dcc
+  module Validate
+    autoload :Result, "dcc/validate/result"
+    autoload :Issue, "dcc/validate/issue"
+    autoload :Severity, "dcc/validate/severity"
+    autoload :Xsd, "dcc/validate/xsd"
+    autoload :Schematron, "dcc/validate/schematron"
+    autoload :BusinessRules, "dcc/validate/business_rules"
+  end
+end

data/lib/dcc/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Dcc
+  VERSION = "0.2.0"
+end

data/lib/dcc/versioned_parser.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# `Dcc::VersionedParser` is mixed into each major-version module
+# (`Dcc::V2`, `Dcc::V3`, `Dcc::Si::V1`, `Dcc::Si::V2`) to provide a uniform
+# `.parse(input, context:, register:)` entry point that delegates to
+# `Lutaml::Model::GlobalContext` for type resolution.
+#
+# The version module must:
+# 1. `extend Dcc::VersionedParser`
+# 2. Define `self::ROOT_ELEMENT_TAG` — the XML element name to resolve
+#    (e.g. `"digitalCalibrationCertificate"`).
+# 3. Define `self::Configuration` — a module that extends
+#    `Dcc::ContextConfiguration` and declares `CONTEXT_ID`.
+module Dcc
+  module VersionedParser
+    # Parse an XML document into the version's typed object tree.
+    #
+    # @param input [String, IO] XML string or readable IO.
+    # @param context [Symbol, String, nil] substitution context.
+    # @param register [Symbol, String, nil] deprecated alias for `context`.
+    # @return [Lutaml::Model::Serializable] parsed root element.
+    def parse(input, context: ::Dcc::UNSPECIFIED_CONTEXT, register: nil)
+      context_id = resolve_context_id(context, register)
+      root_class = Lutaml::Model::GlobalContext.resolve_type(
+        root_element_symbol,
+        context_id,
+      )
+
+      xml = ::Dcc.read_input(input)
+      root_class.from_xml(xml, register: context_id)
+    end
+
+    private
+
+    def resolve_context_id(context, register)
+      ::Dcc::ContextOptions.normalize_context_option(
+        context: context,
+        register: register,
+        default_context: self::Configuration.default_context_id,
+        warning_source: "#{name}.parse",
+      )
+    end
+
+    def root_element_symbol
+      self.const_get(:ROOT_ELEMENT_TAG).to_sym
+    end
+  end
+end

data/lib/dcc.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "lutaml/xml"
+require "mml"
+
+Lutaml::Model::Config.xml_adapter_type = :nokogiri
+
+# Top-level namespace for the dcc gem.
+#
+# Dcc provides a fully typed Ruby object model for PTB Digital Calibration
+# Certificates (DCC) and D-SI quantity documents. See README.adoc for an
+# overview and QUICKSTART.
+module Dcc
+  SUPPORTED_VERSIONS = [2, 3].freeze
+
+  # Sentinel value used to distinguish "no context supplied" from "context
+  # supplied as nil". Defined eagerly so callers can reference it without
+  # triggering autoload.
+  UNSPECIFIED_CONTEXT = Object.new.freeze
+
+  autoload :VERSION, "dcc/version"
+  # Errors are eagerly required so `Dcc::ParseError` etc. are always
+  # available without triggering autoload on first reference.
+  require "dcc/error"
+
+  autoload :Namespace, "dcc/namespace"
+  autoload :Type, "dcc/type"
+  autoload :ContextConfiguration, "dcc/context_configuration"
+  autoload :ContextOptions, "dcc/context_options"
+  autoload :VersionedParser, "dcc/versioned_parser"
+  autoload :CommonElements, "dcc/common_elements"
+  autoload :Base, "dcc/base"
+  autoload :Schema, "dcc/schema"
+  autoload :Builder, "dcc/builder"
+  autoload :Convert, "dcc/convert"
+  autoload :Diff, "dcc/diff"
+  autoload :Extract, "dcc/extract"
+  autoload :Inspect, "dcc/inspect"
+  autoload :Migrate, "dcc/migrate"
+  autoload :QuantityFormat, "dcc/quantity_format"
+  autoload :QuantityMath, "dcc/quantity_math"
+  autoload :Signature, "dcc/signature"
+  autoload :Transform, "dcc/transform"
+  autoload :Validate, "dcc/validate"
+  autoload :Server, "dcc/server"
+  autoload :I18n, "dcc/i18n"
+  autoload :Plugin, "dcc/plugin"
+  autoload :TypeGuards, "dcc/type_guards"
+  autoload :Si, "dcc/si"
+
+  autoload :V2, "dcc/v2"
+  autoload :V3, "dcc/v3"
+
+  module Cli
+    autoload :Cli, "dcc/cli/cli"
+  end
+
+  class << self
+    # Parse a DCC XML document and return a typed object tree.
+    #
+    # @param input [String, IO] XML string or readable IO.
+    # @param version [Integer, nil] Major DCC version (2 or 3). Auto-detected
+    #   from the `schemaVersion` attribute when nil.
+    # @param context [Symbol, nil] Substitution context (e.g. `:dcc_v3_4`).
+    # @param register [Symbol, nil] Alias for `context` (mml-compatible API).
+    # @return [Dcc::V2::DigitalCalibrationCertificate, Dcc::V3::DigitalCalibrationCertificate]
+    def parse(input, version: nil, context: nil, register: nil)
+      load_all!
+      resolved = version || detect_version(input)
+      parser_for(resolved).parse(input, context: context, register: register)
+    end
+
+    # Build a new DCC programmatically using the builder DSL.
+    # @yield [Dcc::Builder::Session] builder session
+    # @param version [Integer, nil] major DCC version (default: 3).
+    def build(version: 3, &block)
+      Builder.call(version: version, &block)
+    end
+
+    # Migrate a parsed DCC object from one schema version to another.
+    # @param dcc [Dcc::V2::DigitalCalibrationCertificate, Dcc::V3::DigitalCalibrationCertificate]
+    # @param from [String] source version, e.g. "2.3.0".
+    # @param to [String] target version, e.g. "3.3.0".
+    def migrate(dcc, from:, to:)
+      Migrate.call(dcc, from: from, to: to)
+    end
+
+    # Return the parser module for the given major version.
+    # @param version [Integer] 2 or 3.
+    # @return [Module] Dcc::V2 or Dcc::V3.
+    def parser_for(version)
+      case version.to_i
+      when 2 then V2
+      when 3 then V3
+      else
+        raise UnknownVersionError, "Unsupported DCC version: #{version.inspect} (expected 2 or 3)"
+      end
+    end
+
+    # Detect the DCC major version from an XML document's `schemaVersion` attribute.
+    # @param input [String, IO]
+    # @return [Integer] 2 or 3.
+    def detect_version(input)
+      str = read_input(input)
+      match = str.match(/schemaVersion\s*=\s*["'](\d+)\./)
+      major = match && match[1] ? match[1].to_i : 3
+      major == 2 ? 2 : 3
+    end
+
+    # Read an input that may be a String or an IO-like object.
+    # Uses explicit type checks per project rule (no `respond_to?`).
+    # @param input [String, IO, StringIO, File, Tempfile]
+    # @return [String]
+    def read_input(input)
+      return input.read if io_like?(input)
+
+      input.to_s
+    end
+
+    # @return [Boolean] whether the input is an IO-like stream we support.
+    def io_like?(input)
+      !!(input.is_a?(::IO) ||
+        input.is_a?(::StringIO) ||
+        input.is_a?(::File) ||
+        (defined?(::Tempfile) && input.is_a?(::Tempfile)))
+    end
+
+    # Eager-load every version context (DCC + D-SI) so symbol type
+    # references in the base modules resolve correctly. Called automatically
+    # on first `Dcc.parse`. Safe to call multiple times.
+    # @return [true]
+    def load_all!
+      V2.load_all!
+      V3.load_all!
+      Si::V1.load_all!
+      Si::V2.load_all!
+      true
+    end
+  end
+end