dcc 0.2.0

data/lib/dcc/si/v1/real.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V1
+  class Real < CommonElements
+    include ::Dcc::Si::Base::Real
+  end
+  Configuration.register_model(Real, id: :real)
+end

data/lib/dcc/si/v1/real_list_xml_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V1
+  class RealListXmlList < CommonElements
+    include ::Dcc::Si::Base::RealListXmlList
+  end
+  Configuration.register_model(RealListXmlList, id: :realListXMLList)
+end

data/lib/dcc/si/v1/si_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V1
+  class SiList < CommonElements
+    include ::Dcc::Si::Base::SiList
+  end
+  Configuration.register_model(SiList, id: :list)
+end

data/lib/dcc/si/v1/standard_mu.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V1
+  class StandardMU < CommonElements
+    include ::Dcc::Si::Base::StandardMU
+  end
+  Configuration.register_model(StandardMU, id: :standardMU)
+end

data/lib/dcc/si/v1.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# `Dcc::Si::V1` hosts D-SI v1.x element wrappers registered in the
+# `:dsi_v1` context. Mirrors the V2 structure but additionally supports
+# the deprecated `expandedUnc` type that v2 replaced with `expandedMU`.
+module Dcc
+  module Si
+    module V1
+      autoload :Configuration, "dcc/si/v1/configuration"
+      autoload :CommonElements, "dcc/si/v1/common_elements"
+      autoload :Namespace, "dcc/si/v1/namespace"
+
+      autoload :Real, "dcc/si/v1/real"
+      autoload :Complex, "dcc/si/v1/complex"
+      autoload :Constant, "dcc/si/v1/constant"
+      autoload :RealListXmlList, "dcc/si/v1/real_list_xml_list"
+      autoload :ComplexListXmlList, "dcc/si/v1/complex_list_xml_list"
+      autoload :Hybrid, "dcc/si/v1/hybrid"
+      autoload :SiList, "dcc/si/v1/si_list"
+      autoload :List, "dcc/si/v1/si_list"
+      autoload :StandardMU, "dcc/si/v1/standard_mu"
+      autoload :ExpandedMU, "dcc/si/v1/expanded_mu"
+      autoload :CoverageIntervalMU, "dcc/si/v1/coverage_interval_mu"
+      autoload :ExpandedUnc, "dcc/si/v1/expanded_unc"
+      autoload :ExpandedUncXmlList, "dcc/si/v1/expanded_unc_xml_list"
+      autoload :MeasurementUncertaintyUnivariate, "dcc/si/v1/measurement_uncertainty_univariate"
+
+      ROOT_ELEMENT_TAG = "real"
+
+      extend ::Dcc::VersionedParser
+
+      ELEMENT_CLASSES = %i[
+        Real Complex Constant
+        RealListXmlList ComplexListXmlList Hybrid SiList
+        StandardMU ExpandedMU CoverageIntervalMU
+        ExpandedUnc ExpandedUncXmlList MeasurementUncertaintyUnivariate
+      ].freeze
+
+      def self.load_all!
+        ELEMENT_CLASSES.each { |name| const_get(name) }
+        Configuration.populate_context!
+        true
+      end
+    end
+  end
+end

data/lib/dcc/si/v2/common_elements.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Si
+    module V2
+      class CommonElements < ::Dcc::Si::CommonElements
+        def self.lutaml_default_register
+          :dsi_v2
+        end
+      end
+    end
+  end
+end

data/lib/dcc/si/v2/complex.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class Complex < CommonElements
+    include ::Dcc::Si::Base::Complex
+  end
+  Configuration.register_model(Complex, id: :complex)
+end

data/lib/dcc/si/v2/complex_list_xml_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class ComplexListXmlList < CommonElements
+    include ::Dcc::Si::Base::ComplexListXmlList
+  end
+  Configuration.register_model(ComplexListXmlList, id: :complexListXMLList)
+end

data/lib/dcc/si/v2/configuration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Si
+    module V2
+      module Configuration
+        extend ::Dcc::ContextConfiguration
+
+        CONTEXT_ID = :dsi_v2
+      end
+    end
+  end
+end

data/lib/dcc/si/v2/constant.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class Constant < CommonElements
+    include ::Dcc::Si::Base::Constant
+  end
+  Configuration.register_model(Constant, id: :constant)
+end

data/lib/dcc/si/v2/coverage_interval_mu.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class CoverageIntervalMU < CommonElements
+    include ::Dcc::Si::Base::CoverageIntervalMU
+  end
+  Configuration.register_model(CoverageIntervalMU, id: :coverageIntervalMU)
+end

data/lib/dcc/si/v2/coverage_interval_mu_xml_list.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# XML-list variant of coverageIntervalMU.
+module Dcc::Si::V2
+  class CoverageIntervalMUXMLList < CommonElements
+    attribute :value_standard_mu_xml_list, ::Dcc::Type::DecimalXmlList
+    attribute :interval_min_xml_list, ::Dcc::Type::DecimalXmlList
+    attribute :interval_max_xml_list, ::Dcc::Type::DecimalXmlList
+    attribute :coverage_probability_xml_list, :string
+    attribute :distribution_xml_list, :string
+
+    xml do
+      namespace ::Dcc::Namespace::Si
+      element "coverageIntervalMUXMLList"
+      ordered
+      map_element "valueStandardMUXMLList", to: :value_standard_mu_xml_list
+      map_element "intervalMinXMLList", to: :interval_min_xml_list
+      map_element "intervalMaxXMLList", to: :interval_max_xml_list
+      map_element "coverageProbabilityXMLList", to: :coverage_probability_xml_list
+      map_element "distributionXMLList", to: :distribution_xml_list
+    end
+  end
+  Configuration.register_model(CoverageIntervalMUXMLList, id: :coverageIntervalMUXMLList)
+end

data/lib/dcc/si/v2/expanded_mu.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class ExpandedMU < CommonElements
+    include ::Dcc::Si::Base::ExpandedMU
+  end
+  Configuration.register_model(ExpandedMU, id: :expandedMU)
+end

data/lib/dcc/si/v2/expanded_mu_xml_list.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# XML-list variant of expandedMU. Stores space-separated decimals.
+module Dcc::Si::V2
+  class ExpandedMUXMLList < CommonElements
+    attribute :value_expanded_mu_xml_list, ::Dcc::Type::DecimalXmlList
+    attribute :coverage_factor_xml_list, :string
+    attribute :coverage_probability_xml_list, :string
+    attribute :distribution_xml_list, :string
+
+    xml do
+      namespace ::Dcc::Namespace::Si
+      element "expandedMUXMLList"
+      ordered
+      map_element "valueExpandedMUXMLList", to: :value_expanded_mu_xml_list
+      map_element "coverageFactorXMLList", to: :coverage_factor_xml_list
+      map_element "coverageProbabilityXMLList", to: :coverage_probability_xml_list
+      map_element "distributionXMLList", to: :distribution_xml_list
+    end
+  end
+  Configuration.register_model(ExpandedMUXMLList, id: :expandedMUXMLList)
+end

data/lib/dcc/si/v2/expanded_unc_xml_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class ExpandedUncXmlList < CommonElements
+    include ::Dcc::Si::Base::ExpandedUncXmlList
+  end
+  Configuration.register_model(ExpandedUncXmlList, id: :expandedUncXMLList)
+end

data/lib/dcc/si/v2/hybrid.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class Hybrid < CommonElements
+    include ::Dcc::Si::Base::Hybrid
+  end
+  Configuration.register_model(Hybrid, id: :hybrid)
+end

data/lib/dcc/si/v2/measurement_uncertainty_univariate.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class MeasurementUncertaintyUnivariate < CommonElements
+    include ::Dcc::Si::Base::MeasurementUncertaintyUnivariate
+  end
+  Configuration.register_model(MeasurementUncertaintyUnivariate, id: :measurementUncertaintyUnivariate)
+end

data/lib/dcc/si/v2/namespace.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Si
+    module V2
+      Namespace = ::Dcc::Namespace::Si
+    end
+  end
+end

data/lib/dcc/si/v2/real.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class Real < CommonElements
+    include ::Dcc::Si::Base::Real
+  end
+  Configuration.register_model(Real, id: :real)
+end

data/lib/dcc/si/v2/real_list_xml_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class RealListXmlList < CommonElements
+    include ::Dcc::Si::Base::RealListXmlList
+  end
+  Configuration.register_model(RealListXmlList, id: :realListXMLList)
+end

data/lib/dcc/si/v2/si_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class SiList < CommonElements
+    include ::Dcc::Si::Base::SiList
+  end
+  Configuration.register_model(SiList, id: :list)
+end

data/lib/dcc/si/v2/standard_mu.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::Si::V2
+  class StandardMU < CommonElements
+    include ::Dcc::Si::Base::StandardMU
+  end
+  Configuration.register_model(StandardMU, id: :standardMU)
+end

data/lib/dcc/si/v2/standard_mu_xml_list.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# XML-list variant of standard_mu. Stores space-separated decimals.
+module Dcc::Si::V2
+  class StandardMUXMLList < CommonElements
+    attribute :value_standard_mu_xml_list, ::Dcc::Type::DecimalXmlList
+    attribute :distribution_xml_list, :string
+
+    xml do
+      namespace ::Dcc::Namespace::Si
+      element "standardMUXMLList"
+      ordered
+      map_element "valueStandardMUXMLList", to: :value_standard_mu_xml_list
+      map_element "distributionXMLList", to: :distribution_xml_list
+    end
+  end
+  Configuration.register_model(StandardMUXMLList, id: :standardMUXMLList)
+end

data/lib/dcc/si/v2.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# `Dcc::Si::V2` hosts D-SI v2.x element wrappers registered in the `:dsi_v2`
+# context. They share the same `lib/dcc/si/base/*.rb` mapping modules as V1
+# but live in their own class hierarchy so the two versions can coexist.
+module Dcc
+  module Si
+    module V2
+      autoload :Configuration, "dcc/si/v2/configuration"
+      autoload :CommonElements, "dcc/si/v2/common_elements"
+      autoload :Namespace, "dcc/si/v2/namespace"
+
+      autoload :Real, "dcc/si/v2/real"
+      autoload :Complex, "dcc/si/v2/complex"
+      autoload :Constant, "dcc/si/v2/constant"
+      autoload :RealListXmlList, "dcc/si/v2/real_list_xml_list"
+      autoload :ComplexListXmlList, "dcc/si/v2/complex_list_xml_list"
+      autoload :Hybrid, "dcc/si/v2/hybrid"
+      autoload :SiList, "dcc/si/v2/si_list"
+      autoload :StandardMU, "dcc/si/v2/standard_mu"
+      autoload :StandardMUXMLList, "dcc/si/v2/standard_mu_xml_list"
+      autoload :ExpandedMU, "dcc/si/v2/expanded_mu"
+      autoload :ExpandedMUXMLList, "dcc/si/v2/expanded_mu_xml_list"
+      autoload :CoverageIntervalMU, "dcc/si/v2/coverage_interval_mu"
+      autoload :CoverageIntervalMUXMLList, "dcc/si/v2/coverage_interval_mu_xml_list"
+      autoload :ExpandedUncXmlList, "dcc/si/v2/expanded_unc_xml_list"
+      autoload :MeasurementUncertaintyUnivariate, "dcc/si/v2/measurement_uncertainty_univariate"
+
+      ROOT_ELEMENT_TAG = "real"
+
+      extend ::Dcc::VersionedParser
+
+      ELEMENT_CLASSES = %i[
+        Real Complex Constant
+        RealListXmlList ComplexListXmlList Hybrid SiList
+        StandardMU StandardMUXMLList
+        ExpandedMU ExpandedMUXMLList
+        CoverageIntervalMU CoverageIntervalMUXMLList
+        ExpandedUncXmlList MeasurementUncertaintyUnivariate
+      ].freeze
+
+      def self.load_all!
+        ELEMENT_CLASSES.each { |name| const_get(name) }
+        Configuration.populate_context!
+        true
+      end
+    end
+  end
+end

data/lib/dcc/si.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# `Dcc::Si` is the D-SI quantity sub-namespace. It hosts the per-major-version
+# wrapper hierarchies (`Dcc::Si::V1`, `Dcc::Si::V2`) that model the D-SI
+# schema. Each version has its own type registry and configuration, mirroring
+# the DCC pattern.
+module Dcc
+  module Si
+    SUPPORTED_VERSIONS = [1, 2].freeze
+    UNSPECIFIED_CONTEXT = ::Dcc::UNSPECIFIED_CONTEXT
+
+    autoload :Namespace, "dcc/si/namespace"
+    autoload :CommonElements, "dcc/si/common_elements"
+    autoload :Base, "dcc/si/base"
+    autoload :V1, "dcc/si/v1"
+    autoload :V2, "dcc/si/v2"
+
+    module_function
+
+    def parse(input, version: 2, context: UNSPECIFIED_CONTEXT, register: nil)
+      parser_for(version).parse(input, context: context, register: register)
+    end
+
+    def parser_for(version)
+      case version.to_i
+      when 1 then V1
+      when 2 then V2
+      else
+        raise ::Dcc::UnknownVersionError,
+              "Unsupported D-SI version: #{version.inspect} (expected 1 or 2)"
+      end
+    end
+  end
+end

data/lib/dcc/signature/result.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Signature
+    # Outcome of a signature verification. Carries the verified certificate,
+    # validity flag, and the signed XML subtree (the only trustable part).
+    class Result
+      attr_reader :valid, :certificate_pem, :signed_xml
+
+      def initialize(valid:, certificate_pem: nil, signed_xml: nil)
+        @valid = valid
+        @certificate_pem = certificate_pem
+        @signed_xml = signed_xml
+      end
+
+      def valid?
+        !!@valid
+      end
+
+      def to_s
+        if valid?
+          "Signature valid#{certificate_pem ? " (cert: #{certificate_pem.lines.first&.strip})" : ''}"
+        else
+          "Signature INVALID"
+        end
+      end
+
+      def to_json(*_args)
+        require "json"
+        ::JSON.pretty_generate(
+          valid: valid?,
+          certificate_pem: certificate_pem,
+          signed_xml_length: signed_xml&.length,
+        )
+      end
+
+      def to_yaml(*_args)
+        require "yaml"
+        { valid: valid?, certificate_pem: certificate_pem }.to_yaml
+      end
+    end
+  end
+end

data/lib/dcc/signature/signer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Signature
+    # `Dcc::Signature::Signer` wraps an enveloped XMLDSig signature over a
+    # DCC document using RSA-SHA-256. Requires the `xmldsig` gem.
+    module Signer
+      class << self
+        # @param xml_or_dcc [String, Lutaml::Model::Serializable] the DCC.
+        # @param cert_pem [String] PEM-encoded signing certificate.
+        # @param key_pem [String] PEM-encoded private key.
+        # @return [String] the signed XML document.
+        def call(xml_or_dcc, cert_pem:, key_pem:)
+          ensure_xmldsig!
+          xml = xml_or_dcc.is_a?(::String) ? xml_or_dcc : xml_or_dcc.to_xml
+          document = Xmldsig::XMLDoc.new(xml)
+          document.sign(
+            OpenSSL::PKey::RSA.new(key_pem),
+            cert_pem,
+          ).to_xml
+        end
+
+        private
+
+        def ensure_xmldsig!
+          return if defined?(::Xmldsig)
+
+          require "xmldsig"
+        rescue ::LoadError
+          raise ::Dcc::MissingDependencyError.new(gem_name: "xmldsig", feature: "Dcc::Signature"),
+                "xmldsig is required for XMLDSig signing"
+        end
+      end
+    end
+  end
+end

data/lib/dcc/signature/verifier.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Signature
+    # `Dcc::Signature::Verifier` validates a signed DCC against a CA
+    # certificate. The signed XML subtree is extracted so callers can
+    # extract the trustworthy content.
+    module Verifier
+      class << self
+        # @param xml [String] signed DCC XML.
+        # @param ca_cert_pem [String] PEM-encoded CA certificate.
+        # @return [Dcc::Signature::Result]
+        def call(xml, ca_cert_pem:)
+          ensure_xmldsig!
+          document = Xmldsig::XMLDoc.new(xml)
+          signed_xml = nil
+          is_valid = document.validate(ca_cert_pem) do |signed_node|
+            signed_xml = signed_node.to_xml
+            true
+          end
+          ::Dcc::Signature::Result.new(
+            valid: is_valid,
+            certificate_pem: ca_cert_pem,
+            signed_xml: signed_xml,
+          )
+        end
+
+        private
+
+        def ensure_xmldsig!
+          return if defined?(::Xmldsig)
+
+          require "xmldsig"
+        rescue ::LoadError
+          raise ::Dcc::MissingDependencyError.new(gem_name: "xmldsig", feature: "Dcc::Signature"),
+                "xmldsig is required for XMLDSig verification"
+        end
+      end
+    end
+  end
+end

data/lib/dcc/signature.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# `Dcc::Signature` provides XMLDSig sign/verify using the `xmldsig` gem as
+# a soft dependency. If the gem is not installed, attempting to use the
+# signer or verifier raises `Dcc::MissingDependencyError` with installation
+# instructions.
+module Dcc
+  module Signature
+    autoload :Signer, "dcc/signature/signer"
+    autoload :Verifier, "dcc/signature/verifier"
+    autoload :Result, "dcc/signature/result"
+  end
+end

data/lib/dcc/transform/result.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Transform
+    # Output of an XSLT transform.
+    class Result
+      attr_reader :payload, :engine
+
+      def initialize(payload:, engine:)
+        @payload = payload
+        @engine = engine
+      end
+
+      def to_s
+        @payload
+      end
+
+      def to_json(*_args)
+        require "json"
+        ::JSON.pretty_generate(engine: @engine, payload: @payload)
+      end
+    end
+  end
+end

data/lib/dcc/transform/xslt.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Dcc
+  module Transform
+    # `Dcc::Transform::Xslt` applies an XSLT stylesheet to a DCC XML document.
+    #
+    # Nokogiri is OFFICIALLY banned outside validation, so we shell out to
+    # the system `xsltproc` (libxslt) for XSLT 1.0 transforms. For XSLT
+    # 2.0/3.0, set `ENV["SAXON_JAR"]` to point at saxon-he.jar.
+    module Xslt
+      class << self
+        # @param xml [String, Lutaml::Model::Serializable]
+        # @param stylesheet [String] path to XSLT file or raw XSLT.
+        # @param engine [Symbol] :xsltproc (default) or :saxon.
+        # @return [Dcc::Transform::Result]
+        def call(xml, stylesheet, engine: :xsltproc)
+          xml_string = xml.is_a?(::String) ? xml : xml.to_xml
+          output = case engine
+                   when :xsltproc then run_xsltproc(xml_string, stylesheet)
+                   when :saxon then run_saxon(xml_string, stylesheet)
+                   else
+                     raise ::ArgumentError, "unknown XSLT engine: #{engine.inspect}"
+                   end
+          ::Dcc::Transform::Result.new(payload: output, engine: engine)
+        end
+
+        private
+
+        def run_xsltproc(xml, stylesheet)
+          ensure_tool!("xsltproc")
+          xsl_path = stylesheet_path(stylesheet)
+          out, status = ::Open3.capture2("xsltproc", xsl_path, "-", stdin_data: xml)
+          raise ::Dcc::TransformError, "xsltproc failed: #{status}" unless status.success?
+
+          out
+        end
+
+        def run_saxon(xml, stylesheet)
+          jar = ENV["SAXON_JAR"]
+          raise ::Dcc::MissingDependencyError.new(gem_name: "saxon-he",
+                                                  feature: "XSLT 2.0/3.0"),
+                "SAXON_JAR env var is required for the :saxon engine" unless jar
+
+          xsl_path = stylesheet_path(stylesheet)
+          cmd = ["java", "-jar", jar, "-s:-", "-xsl:#{xsl_path}"]
+          out, status = ::Open3.capture2(*cmd, stdin_data: xml)
+          raise ::Dcc::TransformError, "saxon failed: #{status}" unless status.success?
+
+          out
+        end
+
+        def stylesheet_path(stylesheet)
+          return stylesheet if File.exist?(stylesheet)
+
+          Tempfile.create(["dcc-transform", ".xsl"]) do |f|
+            f.write(stylesheet)
+            f.path
+          end
+        end
+
+        def ensure_tool!(name)
+          return if system("which #{name} > /dev/null 2>&1")
+
+          raise ::Dcc::MissingDependencyError.new(gem_name: name, feature: "Dcc::Transform"),
+                "#{name} CLI not available on PATH"
+        end
+      end
+    end
+  end
+end

data/lib/dcc/transform.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# `Dcc::Transform` provides XSLT transformations. We cannot use Nokogiri
+# for this per project rule (only validation may touch Nokogiri); instead
+# we shell out to the system `xsltproc` CLI for XSLT 1.0, or to
+# `java -jar saxon-he.jar` for XSLT 2.0/3.0 when SAXON_JAR is set.
+module Dcc
+  module Transform
+    autoload :Xslt, "dcc/transform/xslt"
+    autoload :Result, "dcc/transform/result"
+  end
+end