dcc 0.2.0 → 0.2.1

data/lib/dcc/type/decimal_xml_list.rb

@@ -1,19 +1,86 @@
 # frozen_string_literal: true
 
 require "bigdecimal"
+require "forwardable"
 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.
+    # a `Values` list of BigDecimal.
+    #
+    # `cast` deliberately does not return a plain Array: lutaml-model treats an
+    # Array-valued attribute as a collection and would emit one element per
+    # decimal instead of a single space-separated list.
     class DecimalXmlList < Lutaml::Model::Type::Value
+      # An ordered list of BigDecimals that renders as space-separated text and
+      # compares equal to the equivalent Array.
+      class Values
+        include Enumerable
+        extend Forwardable
+
+        def_delegators :@decimals, :size, :length, :empty?, :last, :[]
+
+        def initialize(decimals)
+          @decimals = decimals
+        end
+
+        def each(&)
+          return to_enum(:each) unless block_given?
+
+          @decimals.each(&)
+          self
+        end
+
+        # Implicit conversion, so `Array#==` delegates back here instead of
+        # returning false and making equality asymmetric.
+        def to_ary
+          @decimals.dup
+        end
+
+        # Joined over the serialized decimals, not the raw BigDecimals, so it
+        # cannot disagree with `to_s` by emitting "0.72e-1" for "0.072".
+        def join(separator = " ")
+          map { |decimal| DecimalXmlList.serialize_one(decimal) }.join(separator)
+        end
+
+        def to_s
+          DecimalXmlList.serialize(self)
+        end
+
+        # Dumped as its wire form, so YAML matches JSON rather than leaking a
+        # `!ruby/object:` tag that `safe_load` refuses to read back.
+        def encode_with(coder)
+          coder.represent_scalar(nil, to_s)
+        end
+
+        def ==(other)
+          case other
+          when Values then to_a == other.to_a
+          when ::Array then to_a == other
+          else false
+          end
+        end
+
+        # Stricter than `==`, which accepts a plain Array. Hash lookup pairs
+        # `eql?` with `hash`, and an Array keyed alongside us would hash the
+        # same while comparing equal in only one direction.
+        def eql?(other)
+          other.is_a?(Values) && to_a == other.to_a
+        end
+
+        def hash
+          to_a.hash
+        end
+      end
+
       def self.cast(value)
-        return [] if value.nil?
-        return value.map { |v| cast_one(v) } if value.is_a?(::Array)
+        return value if value.is_a?(Values)
+        return Values.new([]) if value.nil?
 
-        value.to_s.split(/\s+/).reject(&:empty?).map { |s| cast_one(s) }
+        tokens = value.is_a?(::Array) ? value : value.to_s.split
+        Values.new(tokens.map { |token| cast_one(token) })
       end
 
       def self.serialize(value)
@@ -22,24 +89,43 @@ module Dcc
         Array(value).map { |v| serialize_one(v) }.join(" ")
       end
 
+      # One decimal in the notation D-SI writes, e.g. 0.072 rather than
+      # BigDecimal's own "0.72e-1". `to_s("F")` renders every BigDecimal,
+      # finite or not, and `sub` only trims a trailing ".0". That is what
+      # lets `NaN` through, which D-SI admits in every decimal type
+      # (SI_Format.xsd:1195).
+      def self.serialize_one(value)
+        reject_infinite!(value)
+
+        case value
+        when ::BigDecimal then value.to_s("F").sub(/\.0\z/, "")
+        when ::Float then format("%.15g", value)
+        else value.to_s
+        end
+      end
+
       class << self
         private
 
         def cast_one(token)
-          return token if token.is_a?(::BigDecimal)
-
-          BigDecimal(token.to_s)
+          decimal = token.is_a?(::BigDecimal) ? token : BigDecimal(token.to_s)
+          reject_infinite!(decimal)
+          decimal
         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
+        # Called from `cast_one` and from the public `serialize_one`, since
+        # `serialize` takes a raw BigDecimal and casting is not the only way in.
+        def reject_infinite!(value)
+          return unless value.is_a?(::BigDecimal) && value.infinite?
+
+          raise Lutaml::Model::Type::InvalidValueError.new(
+            value,
+            "infinity is not a D-SI decimal: SI_Format.xsd:1195 admits " \
+            "numbers and NaN only",
+          )
         end
       end
     end

data/lib/dcc/type/iso_country_code.rb

@@ -7,13 +7,14 @@ module Dcc
     # 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
+      PATTERN = /\A[A-Z]{2}\z/
 
       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}")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "invalid ISO 3166-1 alpha-2 country code: #{value.inspect}")
         end
 
         value

data/lib/dcc/type/iso_language_code.rb

@@ -7,13 +7,14 @@ module Dcc
     # 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
+      PATTERN = /\A[a-z]{2}\z/
 
       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}")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "invalid ISO 639-1 language code: #{value.inspect}")
         end
 
         value

data/lib/dcc/type/schema_version.rb

@@ -12,13 +12,14 @@ module Dcc
         (?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)
         (?:-(?<pre>[0-9A-Za-z.-]+))?
         (?:\+(?<build>[0-9A-Za-z.-]+))?
-      \z/x.freeze
+      \z/x
 
       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")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "invalid schemaVersion")
         end
 
         value

data/lib/dcc/type/si_unit.rb

@@ -10,13 +10,14 @@ module Dcc
     # 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
+      NO_WHITESPACE_PATTERN = /\A\S+\z/
 
       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}")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "invalid SI unit expression (whitespace not allowed): #{value.inspect}")
         end
 
         value

data/lib/dcc/type_guards.rb

@@ -130,11 +130,11 @@ module Dcc
     end
 
     # Safe method call: invokes the method if the node's class declares it.
-    def call_if_present(node, method_name, *args)
+    def call_if_present(node, method_name, *)
       return nil unless node.is_a?(::Lutaml::Model::Serializable)
       return nil unless node.class.attributes.key?(method_name)
 
-      node.public_send(method_name, *args)
+      node.public_send(method_name, *)
     end
   end
-end
+end

data/lib/dcc/v2/calibration_laboratory.rb

@@ -4,5 +4,6 @@ module Dcc::V2
   class CalibrationLaboratory < CommonElements
     include ::Dcc::Base::CalibrationLaboratory
   end
-  Configuration.register_model(CalibrationLaboratory, id: :calibrationLaboratory)
+  Configuration.register_model(CalibrationLaboratory,
+                               id: :calibrationLaboratory)
 end

data/lib/dcc/v2/condition.rb

@@ -1,8 +1,29 @@
 # frozen_string_literal: true
 
 module Dcc::V2
+  # v2 calls the influence condition's state element `state`; v3 renamed it to
+  # `status`, which the shared base module carries.
   class Condition < CommonElements
-    include ::Dcc::Base::Condition
+    attribute :id, :string
+    attribute :ref_id, :string
+    attribute :ref_type, :string
+    attribute :name, :text
+    attribute :description, :text
+    attribute :status, :string
+    attribute :data, :data, collection: true
+
+    xml do
+      namespace ::Dcc::Namespace::Dcc
+      element "influenceCondition"
+      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 "description", to: :description
+      map_element "state", to: :status
+      map_element "data", to: :data
+    end
   end
   Configuration.register_model(Condition, id: :influenceCondition)
 end

data/lib/dcc/v2/configuration.rb

@@ -10,7 +10,7 @@ module Dcc
       # 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]
+        %i[dsi_v1 dsi_v2 default]
       end
     end
   end

data/lib/dcc/v2/digital_calibration_certificate.rb

@@ -4,5 +4,6 @@ module Dcc::V2
   class DigitalCalibrationCertificate < CommonElements
     include ::Dcc::Base::DigitalCalibrationCertificate
   end
-  Configuration.register_model(DigitalCalibrationCertificate, id: :digitalCalibrationCertificate)
+  Configuration.register_model(DigitalCalibrationCertificate,
+                               id: :digitalCalibrationCertificate)
 end

data/lib/dcc/v2/identification.rb

@@ -1,8 +1,21 @@
 # frozen_string_literal: true
 
 module Dcc::V2
+  # v2 calls the identification's third child `description`; v3 renamed it to
+  # `name`, which the shared base module carries.
   class Identification < CommonElements
-    include ::Dcc::Base::Identification
+    attribute :issuer, :string
+    attribute :value, :string
+    attribute :description, :text
+
+    xml do
+      namespace ::Dcc::Namespace::Dcc
+      element "identification"
+      ordered
+      map_element "issuer", to: :issuer
+      map_element "value", to: :value
+      map_element "description", to: :description
+    end
   end
   Configuration.register_model(Identification, id: :identification)
 end

data/lib/dcc/v2/mathml.rb

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

data/lib/dcc/v2/measurement_meta_data_list.rb

@@ -4,5 +4,6 @@ module Dcc::V2
   class MeasurementMetaDataList < CommonElements
     include ::Dcc::Base::MeasurementMetaDataList
   end
-  Configuration.register_model(MeasurementMetaDataList, id: :measurementMetaData)
+  Configuration.register_model(MeasurementMetaDataList,
+                               id: :measurementMetaData)
 end

data/lib/dcc/v2/quantity.rb

@@ -19,8 +19,10 @@ module Dcc::V2
     attribute :complex, ::Dcc::Si::V1::Complex, collection: true
     attribute :constant, ::Dcc::Si::V1::Constant, collection: true
     attribute :hybrid, ::Dcc::Si::V1::Hybrid, collection: true
-    attribute :real_list_xml_list, ::Dcc::Si::V1::RealListXmlList, collection: true
-    attribute :complex_list_xml_list, ::Dcc::Si::V1::ComplexListXmlList, collection: true
+    attribute :real_list_xml_list, ::Dcc::Si::V1::RealListXmlList,
+              collection: true
+    attribute :complex_list_xml_list, ::Dcc::Si::V1::ComplexListXmlList,
+              collection: true
     attribute :list, ::Dcc::Si::V1::SiList, collection: true
 
     xml do

data/lib/dcc/v2.rb

@@ -14,6 +14,7 @@ module Dcc
     autoload :Text, "dcc/v2/text"
     autoload :ByteData, "dcc/v2/byte_data"
     autoload :Formula, "dcc/v2/formula"
+    autoload :Mathml, "dcc/v2/mathml"
     autoload :RichContent, "dcc/v2/rich_content"
     autoload :XmlBlob, "dcc/v2/xml_blob"
     autoload :Comment, "dcc/v2/comment"
@@ -53,14 +54,15 @@ module Dcc
     autoload :MeasurementResult, "dcc/v2/measurement_result"
     autoload :MeasurementResultList, "dcc/v2/measurement_result_list"
     autoload :AdministrativeData, "dcc/v2/administrative_data"
-    autoload :DigitalCalibrationCertificate, "dcc/v2/digital_calibration_certificate"
+    autoload :DigitalCalibrationCertificate,
+             "dcc/v2/digital_calibration_certificate"
 
     ROOT_ELEMENT_TAG = "digitalCalibrationCertificate"
 
     extend ::Dcc::VersionedParser
 
     ELEMENT_CLASSES = %i[
-      StringWithLang Text ByteData Formula RichContent XmlBlob Comment
+      StringWithLang Text ByteData Mathml Formula RichContent XmlBlob Comment
       EquipmentClass Location Contact ContactNotStrict HashType
       Identification Identifications Software SoftwareList
       RefTypeDefinition RefTypeDefinitionList

data/lib/dcc/v3/calibration_laboratory.rb

@@ -4,5 +4,6 @@ module Dcc::V3
   class CalibrationLaboratory < CommonElements
     include ::Dcc::Base::CalibrationLaboratory
   end
-  Configuration.register_model(CalibrationLaboratory, id: :calibrationLaboratory)
+  Configuration.register_model(CalibrationLaboratory,
+                               id: :calibrationLaboratory)
 end

data/lib/dcc/v3/configuration.rb

@@ -10,7 +10,7 @@ module Dcc
       # V3 DCC imports D-SI v2.x for quantity expressions. Returned as
       # instance method (becomes class method via `extend`).
       def fallback_contexts
-        [:dsi_v2, :default]
+        %i[dsi_v2 default]
       end
     end
   end

data/lib/dcc/v3/digital_calibration_certificate.rb

@@ -4,5 +4,6 @@ module Dcc::V3
   class DigitalCalibrationCertificate < CommonElements
     include ::Dcc::Base::DigitalCalibrationCertificate
   end
-  Configuration.register_model(DigitalCalibrationCertificate, id: :digitalCalibrationCertificate)
+  Configuration.register_model(DigitalCalibrationCertificate,
+                               id: :digitalCalibrationCertificate)
 end

data/lib/dcc/v3/mathml.rb

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

data/lib/dcc/v3/measurement_meta_data_list.rb

@@ -4,5 +4,6 @@ module Dcc::V3
   class MeasurementMetaDataList < CommonElements
     include ::Dcc::Base::MeasurementMetaDataList
   end
-  Configuration.register_model(MeasurementMetaDataList, id: :measurementMetaData)
+  Configuration.register_model(MeasurementMetaDataList,
+                               id: :measurementMetaData)
 end

data/lib/dcc/v3/quantity.rb

@@ -19,8 +19,10 @@ module Dcc::V3
     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 :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

data/lib/dcc/v3.rb

@@ -14,6 +14,7 @@ module Dcc
     autoload :Text, "dcc/v3/text"
     autoload :ByteData, "dcc/v3/byte_data"
     autoload :Formula, "dcc/v3/formula"
+    autoload :Mathml, "dcc/v3/mathml"
     autoload :RichContent, "dcc/v3/rich_content"
     autoload :XmlBlob, "dcc/v3/xml_blob"
     autoload :Comment, "dcc/v3/comment"
@@ -53,7 +54,8 @@ module Dcc
     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"
+    autoload :DigitalCalibrationCertificate,
+             "dcc/v3/digital_calibration_certificate"
 
     ROOT_ELEMENT_TAG = "digitalCalibrationCertificate"
 
@@ -63,7 +65,7 @@ module Dcc
     # `Configuration.populate_context!` can register them. Iterating
     # `constants` triggers each autoload lazily.
     ELEMENT_CLASSES = %i[
-      StringWithLang Text ByteData Formula RichContent XmlBlob Comment
+      StringWithLang Text ByteData Mathml Formula RichContent XmlBlob Comment
       EquipmentClass Location Contact ContactNotStrict HashType
       Identification Identifications Software SoftwareList
       RefTypeDefinition RefTypeDefinitionList
@@ -90,9 +92,17 @@ module Dcc
 
     # Re-export D-SI v2 type registrations into the DCC v3 context. Uses
     # only the public `register_model` API (no instance_variable access).
+    #
+    # Ids DCC already owns are skipped: `register_model` overwrites on
+    # duplicate, and both DCC and D-SI define a `list` element, so without this
+    # the D-SI one would displace `Dcc::V3::List` and every `dcc:list` would
+    # parse as an empty `si:list`.
     def self.register_dsi_types!
       ::Dcc::Si::V2.load_all!
+      own_ids = Configuration.registered_model_ids
       ::Dcc::Si::V2::Configuration.registered_model_ids.each do |id|
+        next if own_ids.include?(id)
+
         klass = ::Dcc::Si::V2::Configuration.registered_model_class(id)
         Configuration.register_model(klass, id: id)
       end

data/lib/dcc/validate/business_rules.rb

@@ -43,7 +43,9 @@ module Dcc
         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}"
+          "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]
@@ -68,10 +70,12 @@ module Dcc
       # Require exactly one respPerson with mainSigner = true.
       class MainSignerSingle < Rule
         def check_on(dcc)
-          return [] unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+          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
+          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 }
@@ -89,15 +93,20 @@ module Dcc
       # Require non-empty uniqueIdentifier.
       class UniqueIdentifierPresent < Rule
         def check_on(dcc)
-          return [] unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+          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
+          unless core
+            return [issue(severity: :error,
+                          message: "coreData is missing")]
+          end
 
           id = core.unique_identifier
           return [] if id && !id.to_s.empty?
 
-          [issue(severity: :error, message: "uniqueIdentifier is missing or empty")]
+          [issue(severity: :error,
+                 message: "uniqueIdentifier is missing or empty")]
         end
       end
 
@@ -108,14 +117,19 @@ module Dcc
         # @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) }
+          issues = Registry.all.flat_map do |rule_class|
+            rule_class.new.check_on(dcc)
+          end
           Result.new(
             issues: issues,
-            schema_version: Dcc::TypeGuards.has_attribute?(dcc, :schema_version) ? dcc.schema_version.to_s : nil,
+            schema_version: if Dcc::TypeGuards.has_attribute?(dcc,
+                                                              :schema_version)
+                              dcc.schema_version.to_s
+                            end,
             source: "business_rule",
           )
         end
       end
     end
   end
-end
+end

data/lib/dcc/validate/issue.rb

@@ -24,7 +24,8 @@ module Dcc
       # @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)
+      def self.build(severity:, message:, code: nil, line: nil, column: nil,
+                     path: nil, source: nil)
         new(
           severity: ::Dcc::Validate::Severity.normalize(severity),
           message: message,

data/lib/dcc/validate/result.rb

@@ -58,12 +58,12 @@ module Dcc
 
       def to_s
         if ok?
-          "OK: no errors found#{schema_version ? " (schemaVersion #{schema_version})" : ''}"
+          "OK: no errors found#{" (schemaVersion #{schema_version})" if 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
+          errors.map(&:to_s).unshift(header).join("\n")
+
         end
       end
 
@@ -97,7 +97,9 @@ module Dcc
           ok: ok?,
           source: source,
           schema_version: schema_version,
-          issues: issues.map { |i| [i.severity.to_s, i.message, i.line, i.path] },
+          issues: issues.map do |i|
+            [i.severity.to_s, i.message, i.line, i.path]
+          end,
         }.to_yaml
       end
     end