dcc 0.2.0

data/lib/dcc/v3/quantity.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  # V3 Quantity: declares DCC admin attributes + D-SI v2.x quantity element
+  # references in a single `xml do` block. We avoid `include Dcc::Base::Quantity`
+  # because the second `xml do` block would overwrite the base mappings.
+  class Quantity < CommonElements
+    attribute :id, :string
+    attribute :ref_id, :string
+    attribute :ref_type, :string
+    attribute :name, :text
+    attribute :no_quantity, :string
+    attribute :used_methods, :usedMethods
+    attribute :used_software, :softwareList
+    attribute :influence_conditions, :influenceConditions
+    attribute :measurement_meta_data, :measurementMetaData
+    # D-SI v2 quantity substitutions (Option B)
+    attribute :real, ::Dcc::Si::V2::Real, collection: true
+    attribute :complex, ::Dcc::Si::V2::Complex, collection: true
+    attribute :constant, ::Dcc::Si::V2::Constant, collection: true
+    attribute :hybrid, ::Dcc::Si::V2::Hybrid, collection: true
+    attribute :real_list_xml_list, ::Dcc::Si::V2::RealListXmlList, collection: true
+    attribute :complex_list_xml_list, ::Dcc::Si::V2::ComplexListXmlList, collection: true
+    attribute :list, ::Dcc::Si::V2::SiList, collection: true
+
+    xml do
+      namespace ::Dcc::Namespace::Dcc
+      element "quantity"
+      ordered
+      map_attribute "id", to: :id
+      map_attribute "refId", to: :ref_id
+      map_attribute "refType", to: :ref_type
+      map_element "name", to: :name
+      map_element "noQuantity", to: :no_quantity
+      map_element "usedMethods", to: :used_methods
+      map_element "usedSoftware", to: :used_software
+      map_element "influenceConditions", to: :influence_conditions
+      map_element "measurementMetaData", to: :measurement_meta_data
+      map_element "real", to: :real
+      map_element "complex", to: :complex
+      map_element "constant", to: :constant
+      map_element "hybrid", to: :hybrid
+      map_element "realListXMLList", to: :real_list_xml_list
+      map_element "complexListXMLList", to: :complex_list_xml_list
+      map_element "list", to: :list
+    end
+  end
+  Configuration.register_model(Quantity, id: :quantity)
+end

data/lib/dcc/v3/ref_type_definition.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class RefTypeDefinition < CommonElements
+    include ::Dcc::Base::RefTypeDefinition
+  end
+  Configuration.register_model(RefTypeDefinition, id: :refTypeDefinition)
+end

data/lib/dcc/v3/ref_type_definition_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class RefTypeDefinitionList < CommonElements
+    include ::Dcc::Base::RefTypeDefinitionList
+  end
+  Configuration.register_model(RefTypeDefinitionList, id: :refTypeDefinitions)
+end

data/lib/dcc/v3/resp_person.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class RespPerson < CommonElements
+    include ::Dcc::Base::RespPerson
+  end
+  Configuration.register_model(RespPerson, id: :respPerson)
+end

data/lib/dcc/v3/resp_person_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class RespPersonList < CommonElements
+    include ::Dcc::Base::RespPersonList
+  end
+  Configuration.register_model(RespPersonList, id: :respPersons)
+end

data/lib/dcc/v3/result.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class Result < CommonElements
+    include ::Dcc::Base::Result
+  end
+  Configuration.register_model(Result, id: :result)
+end

data/lib/dcc/v3/result_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class ResultList < CommonElements
+    include ::Dcc::Base::ResultList
+  end
+  Configuration.register_model(ResultList, id: :results)
+end

data/lib/dcc/v3/rich_content.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class RichContent < CommonElements
+    include ::Dcc::Base::RichContent
+  end
+  Configuration.register_model(RichContent, id: :richContent)
+end

data/lib/dcc/v3/software.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class Software < CommonElements
+    include ::Dcc::Base::Software
+  end
+  Configuration.register_model(Software, id: :software)
+end

data/lib/dcc/v3/software_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class SoftwareList < CommonElements
+    include ::Dcc::Base::SoftwareList
+  end
+  Configuration.register_model(SoftwareList, id: :softwareList)
+end

data/lib/dcc/v3/statement.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class Statement < CommonElements
+    include ::Dcc::Base::Statement
+  end
+  Configuration.register_model(Statement, id: :statement)
+end

data/lib/dcc/v3/statement_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class StatementList < CommonElements
+    include ::Dcc::Base::StatementList
+  end
+  Configuration.register_model(StatementList, id: :statements)
+end

data/lib/dcc/v3/string_with_lang.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class StringWithLang < CommonElements
+    include ::Dcc::Base::StringWithLang
+  end
+  Configuration.register_model(StringWithLang, id: :content)
+end

data/lib/dcc/v3/text.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class Text < CommonElements
+    include ::Dcc::Base::Text
+  end
+  Configuration.register_model(Text, id: :text)
+end

data/lib/dcc/v3/used_method.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class UsedMethod < CommonElements
+    include ::Dcc::Base::UsedMethod
+  end
+  Configuration.register_model(UsedMethod, id: :usedMethod)
+end

data/lib/dcc/v3/used_method_list.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class UsedMethodList < CommonElements
+    include ::Dcc::Base::UsedMethodList
+  end
+  Configuration.register_model(UsedMethodList, id: :usedMethods)
+end

data/lib/dcc/v3/xml_blob.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dcc::V3
+  class XmlBlob < CommonElements
+    include ::Dcc::Base::XmlBlob
+  end
+  Configuration.register_model(XmlBlob, id: :xml)
+end

data/lib/dcc/v3.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# `Dcc::V3` hosts all DCC v3.x element wrapper classes. They share the same
+# `lib/dcc/base/*.rb` mapping modules as V2 but live in their own class
+# hierarchy and register in their own type context (`:dcc_v3`), so V2 and V3
+# can coexist in one process without symbol clashes.
+module Dcc
+  module V3
+    autoload :Configuration, "dcc/v3/configuration"
+    autoload :Namespace, "dcc/v3/namespace"
+    autoload :CommonElements, "dcc/v3/common_elements"
+
+    autoload :StringWithLang, "dcc/v3/string_with_lang"
+    autoload :Text, "dcc/v3/text"
+    autoload :ByteData, "dcc/v3/byte_data"
+    autoload :Formula, "dcc/v3/formula"
+    autoload :RichContent, "dcc/v3/rich_content"
+    autoload :XmlBlob, "dcc/v3/xml_blob"
+    autoload :Comment, "dcc/v3/comment"
+    autoload :EquipmentClass, "dcc/v3/equipment_class"
+    autoload :Location, "dcc/v3/location"
+    autoload :Contact, "dcc/v3/contact"
+    autoload :ContactNotStrict, "dcc/v3/contact_not_strict"
+    autoload :HashType, "dcc/v3/hash_type"
+    autoload :Identification, "dcc/v3/identification"
+    autoload :Identifications, "dcc/v3/identifications"
+    autoload :Software, "dcc/v3/software"
+    autoload :SoftwareList, "dcc/v3/software_list"
+    autoload :RefTypeDefinition, "dcc/v3/ref_type_definition"
+    autoload :RefTypeDefinitionList, "dcc/v3/ref_type_definition_list"
+    autoload :CoreData, "dcc/v3/core_data"
+    autoload :Item, "dcc/v3/item"
+    autoload :ItemList, "dcc/v3/item_list"
+    autoload :CalibrationLaboratory, "dcc/v3/calibration_laboratory"
+    autoload :RespPerson, "dcc/v3/resp_person"
+    autoload :RespPersonList, "dcc/v3/resp_person_list"
+    autoload :Statement, "dcc/v3/statement"
+    autoload :StatementList, "dcc/v3/statement_list"
+    autoload :MeasuringEquipment, "dcc/v3/measuring_equipment"
+    autoload :MeasuringEquipmentList, "dcc/v3/measuring_equipment_list"
+    autoload :UsedMethod, "dcc/v3/used_method"
+    autoload :UsedMethodList, "dcc/v3/used_method_list"
+    autoload :Condition, "dcc/v3/condition"
+    autoload :InfluenceCondition, "dcc/v3/influence_condition"
+    autoload :InfluenceConditionList, "dcc/v3/influence_condition_list"
+    autoload :Result, "dcc/v3/result"
+    autoload :ResultList, "dcc/v3/result_list"
+    autoload :Data, "dcc/v3/data"
+    autoload :Quantity, "dcc/v3/quantity"
+    autoload :List, "dcc/v3/list"
+    autoload :MeasurementMetaData, "dcc/v3/measurement_meta_data"
+    autoload :MeasurementMetaDataList, "dcc/v3/measurement_meta_data_list"
+    autoload :MeasurementResult, "dcc/v3/measurement_result"
+    autoload :MeasurementResultList, "dcc/v3/measurement_result_list"
+    autoload :AdministrativeData, "dcc/v3/administrative_data"
+    autoload :DigitalCalibrationCertificate, "dcc/v3/digital_calibration_certificate"
+
+    ROOT_ELEMENT_TAG = "digitalCalibrationCertificate"
+
+    extend ::Dcc::VersionedParser
+
+    # Element wrapper classes that must be loaded before
+    # `Configuration.populate_context!` can register them. Iterating
+    # `constants` triggers each autoload lazily.
+    ELEMENT_CLASSES = %i[
+      StringWithLang Text ByteData Formula RichContent XmlBlob Comment
+      EquipmentClass Location Contact ContactNotStrict HashType
+      Identification Identifications Software SoftwareList
+      RefTypeDefinition RefTypeDefinitionList
+      CoreData Item ItemList CalibrationLaboratory
+      RespPerson RespPersonList Statement StatementList
+      MeasuringEquipment MeasuringEquipmentList
+      UsedMethod UsedMethodList
+      Condition InfluenceCondition InfluenceConditionList
+      Result ResultList Data Quantity List
+      MeasurementMetaData MeasurementMetaDataList
+      MeasurementResult MeasurementResultList
+      AdministrativeData DigitalCalibrationCertificate
+    ].freeze
+
+    # Eagerly load every element wrapper so registrations run, then register
+    # D-SI types in the DCC v3 context so cross-namespace `:real` / `:hybrid`
+    # references inside DCC Quantity's D-SI children resolve cleanly.
+    def self.load_all!
+      ELEMENT_CLASSES.each { |name| const_get(name) }
+      Configuration.populate_context!
+      register_dsi_types!
+      true
+    end
+
+    # Re-export D-SI v2 type registrations into the DCC v3 context. Uses
+    # only the public `register_model` API (no instance_variable access).
+    def self.register_dsi_types!
+      ::Dcc::Si::V2.load_all!
+      ::Dcc::Si::V2::Configuration.registered_model_ids.each do |id|
+        klass = ::Dcc::Si::V2::Configuration.registered_model_class(id)
+        Configuration.register_model(klass, id: id)
+      end
+    end
+
+    # Re-export Mml type registrations into the DCC v3 context so
+    # `Mml::V3::Math` children resolve when formula.mathml is serialized.
+    def self.register_mml_types!
+      ::Mml::V3::Configuration.populate_context!
+      ::Mml::V3::Configuration.registered_model_ids.each do |id|
+        klass = ::Mml::V3::Configuration.registered_model_class(id)
+        Configuration.register_model(klass, id: id)
+      end
+    end
+  end
+end

data/lib/dcc/validate/business_rules.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Validate
+    # Ruby-side semantic checks that go beyond Schematron. Cross-section
+    # consistency, signer coverage, language completeness. Open for
+    # extension via the Registry class.
+    module BusinessRules
+      # Output of running business rules. Same shape as Validate::Result.
+      class Result < ::Dcc::Validate::Result
+      end
+
+      # Registry of all registered business rules. Plugins call
+      # `Dcc::Validate::BusinessRules::Registry.add(rule_class)` to add
+      # new rules without modifying this file (OCP).
+      class Registry
+        @rules = []
+
+        class << self
+          attr_reader :rules
+
+          # @param rule_class [Class] subclass of Rule.
+          def add(rule_class)
+            @rules << rule_class
+            rule_class
+          end
+
+          # @return [Array<Class>]
+          def all
+            @rules
+          end
+
+          def reset!
+            @rules.clear
+          end
+        end
+      end
+
+      # Base class for business rules.
+      class Rule
+        def severity
+          ::Dcc::Validate::Severity::ERROR
+        end
+
+        def code
+          "dcc.business_rule.#{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)
+          []
+        end
+
+        protected
+
+        def issue(severity:, message:, path: nil)
+          ::Dcc::Validate::Issue.build(
+            severity: severity,
+            message: message,
+            code: code,
+            path: path,
+            source: "business_rule",
+          )
+        end
+      end
+
+      # Require exactly one respPerson with mainSigner = true.
+      class MainSignerSingle < Rule
+        def check_on(dcc)
+          return [] unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+
+          admin = dcc.administrative_data
+          return [] unless admin && Dcc::TypeGuards.has_attribute?(admin, :resp_persons) && admin.resp_persons
+
+          resp_persons = Array(admin.resp_persons.resp_person)
+          main_signers = resp_persons.select { |p| Dcc::TypeGuards.has_attribute?(p, :main_signer) && p.main_signer }
+          return [] if main_signers.size == 1
+
+          [
+            issue(
+              severity: :error,
+              message: "Expected exactly one mainSigner respPerson, found #{main_signers.size}",
+            ),
+          ]
+        end
+      end
+
+      # Require non-empty uniqueIdentifier.
+      class UniqueIdentifierPresent < Rule
+        def check_on(dcc)
+          return [] unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+
+          core = dcc.administrative_data&.core_data
+          return [issue(severity: :error, message: "coreData is missing")] unless core
+
+          id = core.unique_identifier
+          return [] if id && !id.to_s.empty?
+
+          [issue(severity: :error, message: "uniqueIdentifier is missing or empty")]
+        end
+      end
+
+      Registry.add(MainSignerSingle)
+      Registry.add(UniqueIdentifierPresent)
+
+      class << self
+        # @param dcc [Lutaml::Model::Serializable]
+        # @return [Dcc::Validate::BusinessRules::Result]
+        def call(dcc)
+          issues = Registry.all.flat_map { |rule_class| rule_class.new.check_on(dcc) }
+          Result.new(
+            issues: issues,
+            schema_version: Dcc::TypeGuards.has_attribute?(dcc, :schema_version) ? dcc.schema_version.to_s : nil,
+            source: "business_rule",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/dcc/validate/issue.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Dcc
+  module Validate
+    # A single validation issue (XSD error, Schematron failed assert, or
+    # business-rule violation). Carries enough metadata for both human and
+    # machine reporting.
+    class Issue < Lutaml::Model::Serializable
+      attribute :severity, :symbol
+      attribute :code, :string
+      attribute :message, :string
+      attribute :line, :integer
+      attribute :column, :integer
+      attribute :path, :string
+      attribute :source, :string
+
+      # Convenience constructor used by validators.
+      # @param severity [Symbol, String] see `Dcc::Validate::Severity.normalize`.
+      # @param message [String] human-readable description.
+      # @param code [String, nil] validator-specific code (e.g. "dcc.date-range").
+      # @param line [Integer, nil] XML line number if known.
+      # @param column [Integer, nil] XML column number if known.
+      # @param path [String, nil] XPath / element path if known.
+      # @param source [String, nil] validator name (e.g. "xsd", "schematron").
+      def self.build(severity:, message:, code: nil, line: nil, column: nil, path: nil, source: nil)
+        new(
+          severity: ::Dcc::Validate::Severity.normalize(severity),
+          message: message,
+          code: code,
+          line: line,
+          column: column,
+          path: path,
+          source: source,
+        )
+      end
+
+      # @return [Boolean] whether this issue fails validation (severity == error).
+      def failing?
+        severity == ::Dcc::Validate::Severity::ERROR
+      end
+
+      def to_s
+        loc = []
+        loc << "line #{line}" if line
+        loc << "col #{column}" if column
+        loc << path if path
+        loc_str = loc.empty? ? "" : " [#{loc.join(' ')}]"
+        code_str = code ? "(#{code}) " : ""
+        src_str = source ? "#{source}: " : ""
+        "#{src_str}#{severity.upcase} #{code_str}#{message}#{loc_str}"
+      end
+    end
+  end
+end

data/lib/dcc/validate/result.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Dcc
+  module Validate
+    # Result of running one or more validators. Tracks the list of issues
+    # and the schema version (when relevant). Renderable as text, JSON, or
+    # YAML via `to_s` / `to_json` / `to_yaml`.
+    class Result < Lutaml::Model::Serializable
+      attribute :issues, ::Dcc::Validate::Issue, collection: true
+      attribute :schema_version, :string
+      attribute :source, :string
+
+      # @param issues [Array<Dcc::Validate::Issue>] validation issues found.
+      # @param schema_version [String, nil] DCC schema version validated against.
+      # @param source [String, nil] validator name (xsd, schematron, business_rules, all).
+      def initialize(issues: [], schema_version: nil, source: nil)
+        super()
+        self.issues = issues
+        self.schema_version = schema_version
+        self.source = source
+      end
+
+      # @return [Boolean] true when there are no failing (error) issues.
+      def ok?
+        issues.none?(&:failing?)
+      end
+
+      # @return [Array<Dcc::Validate::Issue>] only the errors.
+      def errors
+        issues.select(&:failing?)
+      end
+
+      # @return [Array<Dcc::Validate::Issue>] only the warnings.
+      def warnings
+        issues.select { |i| i.severity == ::Dcc::Validate::Severity::WARNING }
+      end
+
+      # @return [Array<Dcc::Validate::Issue>] only informational issues.
+      def infos
+        issues.select { |i| i.severity == ::Dcc::Validate::Severity::INFO }
+      end
+
+      # Merge another Result into this one (mutating). Returns self.
+      # @param other [Dcc::Validate::Result]
+      # @return [Dcc::Validate::Result]
+      def merge!(other)
+        self.issues = issues + other.issues
+        self
+      end
+
+      # Non-mutating merge.
+      # @return [Dcc::Validate::Result]
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def to_s
+        if ok?
+          "OK: no errors found#{schema_version ? " (schemaVersion #{schema_version})" : ''}"
+        else
+          header = "#{errors.size} error(s), #{warnings.size} warning(s)"
+          header += " (schemaVersion #{schema_version})" if schema_version
+          body = errors.map(&:to_s).unshift(header).join("\n")
+          body
+        end
+      end
+
+      def to_json(*_args)
+        require "json"
+        payload = {
+          ok: ok?,
+          source: source,
+          schema_version: schema_version,
+          error_count: errors.size,
+          warning_count: warnings.size,
+          info_count: infos.size,
+          issues: issues.map do |i|
+            {
+              severity: i.severity.to_s,
+              code: i.code,
+              message: i.message,
+              line: i.line,
+              column: i.column,
+              path: i.path,
+              source: i.source,
+            }
+          end,
+        }
+        ::JSON.pretty_generate(payload)
+      end
+
+      def to_yaml(*_args)
+        require "yaml"
+        {
+          ok: ok?,
+          source: source,
+          schema_version: schema_version,
+          issues: issues.map { |i| [i.severity.to_s, i.message, i.line, i.path] },
+        }.to_yaml
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+
+module Dcc
+  module Validate
+    module Schematron
+      # `Dcc::Validate::Schematron::Profile` aggregates the 14 PTB Schematron
+      # rules and runs them against a parsed DCC object tree. Each rule is a
+      # `Lutaml::Model::Validation::Rule` subclass that walks the parsed tree.
+      #
+      # @example
+      #   result = Dcc::Validate::Schematron.call(dcc)
+      #   result.ok?           # => true
+      #   result.issues.size   # => 0
+      class Profile
+        attr_reader :dcc, :rules
+
+        def initialize(dcc)
+          @dcc = dcc
+          @rules = [
+            Rules::UsedMethodsPlacement,
+            Rules::UsedSoftwarePlacement,
+            Rules::InfluenceConditionsPlacement,
+            Rules::SchemaVersionCheck,
+            Rules::IdRefIdLinking,
+            Rules::IsoCodeValidation,
+            Rules::DateRangeCheck,
+            Rules::ReleaseFormatCheck,
+            Rules::UncertaintyConsistency,
+            Rules::UnitFormatCheck,
+            Rules::NonSiDeclaration,
+            Rules::LanguageCodeDedup,
+            Rules::XmlListSpacing,
+          ]
+        end
+
+        # Run all rules and return a `Dcc::Validate::Result`.
+        def call
+          issues = []
+          rules.each do |rule_class|
+            issues.concat(rule_class.new.check_on(dcc))
+          end
+
+          ::Dcc::Validate::Result.new(
+            issues: issues,
+            schema_version: Dcc::TypeGuards.has_attribute?(dcc, :schema_version) ? dcc.schema_version.to_s : nil,
+            source: "schematron",
+          )
+        end
+
+        class << self
+          # Convenience class method.
+          # @param dcc [Lutaml::Model::Serializable]
+          # @return [Dcc::Validate::Result]
+          def call(dcc)
+            new(dcc).call
+          end
+        end
+      end
+    end
+  end
+end