dcc 0.2.0

data/lib/dcc/type/base64_binary.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "base64"
+require "lutaml/model"
+
+module Dcc
+  module Type
+    # Base64-encoded binary data, used by `dcc:dataBase64` in
+    # `dcc:byteDataType`.
+    #
+    # The wire format is base64 text (`VGVzdAo=`). We pass it through
+    # unchanged on `cast` so that round-trip serialization is byte-identical.
+    # Callers that need the decoded binary bytes call `.decode`.
+    class Base64Binary < Lutaml::Model::Type::Value
+      def self.cast(value)
+        return nil if value.nil? || value == ""
+        unless value.is_a?(::String)
+          raise Lutaml::Model::Type::InvalidValueError.new(value, "expected binary String")
+        end
+
+        value
+      end
+
+      def self.serialize(value)
+        return nil if value.nil?
+
+        unless value.is_a?(::String)
+          raise Lutaml::Model::Type::InvalidValueError.new(value, "expected binary String")
+        end
+
+        value
+      end
+
+      # Convenience: decode the base64 string to binary bytes.
+      # @param value [String, nil]
+      # @return [String] binary ASCII-8BIT string, or `""` if invalid.
+      def self.decode(value)
+        return "" unless value && !value.to_s.empty?
+
+        ::Base64.strict_decode64(value.to_s).b
+      rescue ::ArgumentError
+        ""
+      end
+
+      # Convenience: encode binary bytes to base64 text.
+      # @param value [String, nil]
+      # @return [String, nil]
+      def self.encode(value)
+        return nil if value.nil?
+
+        ::Base64.strict_encode64(value)
+      end
+    end
+  end
+end

data/lib/dcc/type/decimal_xml_list.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "lutaml/model"
+
+module Dcc
+  module Type
+    # Space-separated list of decimals, as used by D-SI `*XMLList` elements
+    # (e.g. `<si:valueXMLList>306 373 448</si:valueXMLList>`). Parses to/from
+    # an Array of BigDecimal values.
+    class DecimalXmlList < Lutaml::Model::Type::Value
+      def self.cast(value)
+        return [] if value.nil?
+        return value.map { |v| cast_one(v) } if value.is_a?(::Array)
+
+        value.to_s.split(/\s+/).reject(&:empty?).map { |s| cast_one(s) }
+      end
+
+      def self.serialize(value)
+        return "" if value.nil?
+
+        Array(value).map { |v| serialize_one(v) }.join(" ")
+      end
+
+      class << self
+        private
+
+        def cast_one(token)
+          return token if token.is_a?(::BigDecimal)
+
+          BigDecimal(token.to_s)
+        rescue ::ArgumentError => e
+          raise Lutaml::Model::Type::InvalidValueError.new(token,
+                                                           "invalid decimal in XML list: #{e.message}")
+        end
+
+        def serialize_one(value)
+          case value
+          when ::BigDecimal then value.to_i.to_s == value.to_s("F") ? value.to_i.to_s : value.to_s("F").sub(/\.0\z/, "")
+          when ::Float then format("%.15g", value)
+          else value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/type/iso_country_code.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Dcc
+  module Type
+    # ISO 3166-1 alpha-2 country code (two uppercase letters, e.g. `"DE"`).
+    # Used by `dcc:countryCodeISO3166_1`.
+    class IsoCountryCode < Lutaml::Model::Type::String
+      PATTERN = /\A[A-Z]{2}\z/.freeze
+
+      def self.cast(value)
+        return nil unless value.is_a?(::String) && value != ""
+
+        unless PATTERN.match?(value)
+          raise Lutaml::Model::Type::InvalidValueError.new(value, "invalid ISO 3166-1 alpha-2 country code: #{value.inspect}")
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/dcc/type/iso_language_code.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Dcc
+  module Type
+    # ISO 639-1 language code (two lowercase letters, e.g. `"en"`).
+    # Used by `dcc:usedLangCodeISO639_1` and `dcc:mandatoryLangCodeISO639_1`.
+    class IsoLanguageCode < Lutaml::Model::Type::String
+      PATTERN = /\A[a-z]{2}\z/.freeze
+
+      def self.cast(value)
+        return nil unless value.is_a?(::String) && value != ""
+
+        unless PATTERN.match?(value)
+          raise Lutaml::Model::Type::InvalidValueError.new(value, "invalid ISO 639-1 language code: #{value.inspect}")
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/dcc/type/schema_version.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Dcc
+  module Type
+    # DCC `schemaVersion` attribute (e.g. `"3.3.0"`, `"3.4.0-rc.2"`).
+    # Validates the format on cast. Use `Dcc::Schema::Version.major(v)` to
+    # extract the major number from any version string.
+    class SchemaVersion < Lutaml::Model::Type::String
+      PATTERN = /\A
+        (?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)
+        (?:-(?<pre>[0-9A-Za-z.-]+))?
+        (?:\+(?<build>[0-9A-Za-z.-]+))?
+      \z/x.freeze
+
+      def self.cast(value)
+        return nil unless value.is_a?(::String) && value != ""
+
+        unless PATTERN.match?(value)
+          raise Lutaml::Model::Type::InvalidValueError.new(value, "invalid schemaVersion")
+        end
+
+        value
+      end
+
+      def major
+        self.class.extract_major(to_s)
+      end
+
+      def self.extract_major(value)
+        m = PATTERN.match(value.to_s)
+        m && Integer(m[:major])
+      end
+    end
+  end
+end

data/lib/dcc/type/si_unit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Dcc
+  module Type
+    # D-SI unit expression in siunitx notation (e.g. `"\kelvin"`,
+    # `"\meter\per\second\squared"`). The full siunitx grammar is enforced by
+    # the D-SI ontology's SHACL profile; here we apply a lightweight syntactic
+    # check: the string must not contain whitespace (Schematron rule), and the
+    # non-SI declaration prefix (`|unit`) is allowed.
+    class SiUnit < Lutaml::Model::Type::String
+      NO_WHITESPACE_PATTERN = /\A\S+\z/.freeze
+
+      def self.cast(value)
+        return nil unless value.is_a?(::String) && value != ""
+
+        unless NO_WHITESPACE_PATTERN.match?(value)
+          raise Lutaml::Model::Type::InvalidValueError.new(value, "invalid SI unit expression (whitespace not allowed): #{value.inspect}")
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/dcc/type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# `Dcc::Type` hosts the gem's custom `Lutaml::Model::Type::Value` subclasses.
+# These encode XML-level constraints (ISO code patterns, siunitx unit grammar,
+# base64 binary, space-separated decimal lists) that the framework's built-in
+# types do not cover.
+module Dcc
+  module Type
+    autoload :IsoCountryCode, "dcc/type/iso_country_code"
+    autoload :IsoLanguageCode, "dcc/type/iso_language_code"
+    autoload :SiUnit, "dcc/type/si_unit"
+    autoload :DecimalXmlList, "dcc/type/decimal_xml_list"
+    autoload :Base64Binary, "dcc/type/base64_binary"
+    autoload :SchemaVersion, "dcc/type/schema_version"
+  end
+end

data/lib/dcc/type_guards.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# `Dcc::TypeGuards` provides type-safe introspection helpers that replace
+# `respond_to?` (banned per project rule) with explicit `is_a?` checks.
+# Each helper returns true/false without raising.
+module Dcc
+  module TypeGuards
+    module_function
+
+    # True if `node` is any version of DCC root.
+    def digital_calibration_certificate?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::DigitalCalibrationCertificate")
+    end
+
+    # True if `node` has an `administrative_data` attribute (DCC root only).
+    def has_administrative_data?(node)
+      digital_calibration_certificate?(node)
+    end
+
+    # True if `node` is a `MeasurementResultList` (any version).
+    def measurement_result_list?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::MeasurementResultList")
+    end
+
+    # True if `node` is an `AdministrativeData` (any version).
+    def administrative_data?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::AdministrativeData")
+    end
+
+    # True if `node` is a `CoreData` (any version).
+    def core_data?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::CoreData")
+    end
+
+    # True if `node` is a `RespPersonList` (any version).
+    def resp_person_list?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::RespPersonList")
+    end
+
+    # True if `node` is a `RespPerson` (any version).
+    def resp_person?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::RespPerson")
+    end
+
+    # True if `node` is a `SoftwareList` (any version).
+    def software_list?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::SoftwareList")
+    end
+
+    # True if `node` is a `Software` (any version).
+    def software?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::Software")
+    end
+
+    # True if `node` is a `RealListXmlList` (any version).
+    def real_list_xml_list?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::RealListXmlList")
+    end
+
+    # True if `node` is a `Text` (any version).
+    def text?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::Text")
+    end
+
+    # True if `node` is a `MeasurementResult` (any version).
+    def measurement_result?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::MeasurementResult")
+    end
+
+    # True if `node` is a `ByteData` (any version).
+    def byte_data?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::ByteData")
+    end
+
+    # True if `node` is a `Quantity` (any version).
+    def quantity?(node)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.name.end_with?("::Quantity")
+    end
+
+    # Safe attribute reader: returns the value or nil if the node doesn't
+    # have the attribute. Uses explicit class introspection rather than
+    # `respond_to?`.
+    def read_attribute(node, name)
+      return nil unless node.is_a?(::Lutaml::Model::Serializable)
+      return nil unless node.class.attributes.key?(name)
+
+      node.public_send(name)
+    end
+
+    # Safe predicate: true if the node has the declared attribute.
+    # Replaces `node.respond_to?(:name)`.
+    def has_attribute?(node, name)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.attributes.key?(name)
+    end
+
+    # Safe predicate: true if the node has a writer for the attribute.
+    # Replaces `node.respond_to?(:name=)`.
+    def has_writer?(node, name)
+      return false unless node.is_a?(::Lutaml::Model::Serializable)
+
+      node.class.attributes.key?(name)
+    end
+
+    # Safe method call: invokes the method if the node's class declares it.
+    def call_if_present(node, method_name, *args)
+      return nil unless node.is_a?(::Lutaml::Model::Serializable)
+      return nil unless node.class.attributes.key?(method_name)
+
+      node.public_send(method_name, *args)
+    end
+  end
+end

data/lib/dcc/v2/administrative_data.rb

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

data/lib/dcc/v2/byte_data.rb

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

data/lib/dcc/v2/calibration_laboratory.rb

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

data/lib/dcc/v2/comment.rb

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

data/lib/dcc/v2/common_elements.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Dcc
+  module V2
+    # V2 base class. All V2 element wrappers inherit from this so they get
+    # `lutaml_default_register` returning `:dcc_v2` automatically.
+    class CommonElements < ::Dcc::CommonElements
+      def self.lutaml_default_register
+        :dcc_v2
+      end
+    end
+  end
+end

data/lib/dcc/v2/condition.rb

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

data/lib/dcc/v2/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Dcc
+  module V2
+    module Configuration
+      extend ::Dcc::ContextConfiguration
+
+      CONTEXT_ID = :dcc_v2
+
+      # V2 DCC imports D-SI v1.x (registered as :dsi_v1). We also fall back
+      # to :dsi_v2 for forward-compatible parsing.
+      def self.fallback_contexts
+        [:dsi_v1, :dsi_v2, :default]
+      end
+    end
+  end
+end

data/lib/dcc/v2/contact.rb

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

data/lib/dcc/v2/contact_not_strict.rb

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

data/lib/dcc/v2/core_data.rb

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

data/lib/dcc/v2/data.rb

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

data/lib/dcc/v2/digital_calibration_certificate.rb

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

data/lib/dcc/v2/equipment_class.rb

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

data/lib/dcc/v2/formula.rb

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

data/lib/dcc/v2/hash_type.rb

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

data/lib/dcc/v2/identification.rb

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

data/lib/dcc/v2/identifications.rb

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

data/lib/dcc/v2/influence_condition.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dcc::V2
+  class InfluenceCondition < CommonElements
+    include ::Dcc::Base::InfluenceCondition
+  end
+end

data/lib/dcc/v2/influence_condition_list.rb

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

data/lib/dcc/v2/item.rb

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

data/lib/dcc/v2/item_list.rb

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

data/lib/dcc/v2/list.rb

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

data/lib/dcc/v2/location.rb

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

data/lib/dcc/v2/measurement_meta_data.rb

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

data/lib/dcc/v2/measurement_meta_data_list.rb

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

data/lib/dcc/v2/measurement_result.rb

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

data/lib/dcc/v2/measurement_result_list.rb

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

data/lib/dcc/v2/measuring_equipment.rb

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

data/lib/dcc/v2/measuring_equipment_list.rb

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