dcc 0.2.0 → 0.2.2

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

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

@@ -15,37 +15,92 @@ module Dcc
       #   result.ok?           # => true
       #   result.issues.size   # => 0
       class Profile
+        # The rules shipped with the gem, in execution order.
+        DEFAULT_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,
+        ].freeze
+        private_constant :DEFAULT_RULES
+
         attr_reader :dcc, :rules
 
+        # Plugin validators are read here, not at class-definition time, so
+        # a plugin loaded after this class still takes effect. Frozen because
+        # `attr_reader :rules` hands the array straight to callers.
         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,
-          ]
+          @plugin_rules = ::Dcc::Plugin.all(:validators).freeze
+          @rules = (DEFAULT_RULES + @plugin_rules).freeze
         end
 
         # Run all rules and return a `Dcc::Validate::Result`.
+        #
+        # Built-in rules fail fast: a crash there is a bug in this gem. A
+        # plugin rule is third-party code, so its failure is contained and
+        # reported as an error issue naming the rule class — one broken
+        # plugin must not cost the caller every built-in finding.
         def call
           issues = []
           rules.each do |rule_class|
-            issues.concat(rule_class.new.check_on(dcc))
+            issues.concat(
+              if @plugin_rules.include?(rule_class)
+                run_plugin_rule(rule_class)
+              else
+                rule_class.new.check_on(dcc)
+              end,
+            )
           end
 
           ::Dcc::Validate::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: "schematron",
+          )
+        end
+
+        private
+
+        # Run one plugin-supplied rule with fault isolation. Instantiation
+        # and #check_on both run inside the rescue, and a non-Array return
+        # (nil included) is reported rather than passed to Array#concat.
+        #
+        # @param rule_class [Class]
+        # @return [Array<Dcc::Validate::Issue>]
+        def run_plugin_rule(rule_class)
+          result = rule_class.new.check_on(dcc)
+          return result if result.is_a?(::Array)
+
+          [plugin_failure_issue(
+            rule_class,
+            "returned #{result.inspect} instead of an Array of issues",
+          )]
+        rescue ::StandardError => e
+          [plugin_failure_issue(rule_class, "raised #{e.class}: #{e.message}")]
+        end
+
+        # @param rule_class [Class]
+        # @param detail [String]
+        # @return [Dcc::Validate::Issue]
+        def plugin_failure_issue(rule_class, detail)
+          name = rule_class.name || rule_class.inspect
+          ::Dcc::Validate::Issue.build(
+            severity: ::Dcc::Validate::Severity::ERROR,
+            message: "plugin validator #{name} #{detail}",
+            code: "dcc.schematron.plugin_failure",
             source: "schematron",
           )
         end
@@ -61,4 +116,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -13,9 +13,18 @@ module Dcc
           ::Dcc::Validate::Severity::ERROR
         end
 
+        # A plugin can register an anonymous rule class, whose `name` is nil.
+        # Falling back keeps one such rule from taking the whole run down and
+        # losing every issue the built-in rules already found.
+        #
         # @return [String] rule code used in `Issue#code`.
         def code
-          "dcc.schematron.#{self.class.name.split('::').last.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase}"
+          class_name = self.class.name
+          return "dcc.schematron.anonymous" unless class_name
+
+          "dcc.schematron.#{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]
@@ -32,7 +41,8 @@ module Dcc
           # Override in subclasses to traverse the model tree.
         end
 
-        def issue(severity:, message:, line: nil, column: nil, path: nil, source: "schematron")
+        def issue(severity:, message:, line: nil, column: nil, path: nil,
+                  source: "schematron")
           ::Dcc::Validate::Issue.build(
             severity: severity,
             message: message,
@@ -46,4 +56,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -19,13 +19,20 @@ module Dcc
 
           def check_on(dcc)
             issues = []
-            return issues unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+            return issues unless Dcc::TypeGuards.has_attribute?(dcc,
+                                                                :administrative_data)
 
             admin = dcc.administrative_data
-            return [issue(severity: :error, message: "administrativeData is missing")] unless admin
+            unless admin
+              return [issue(severity: :error,
+                            message: "administrativeData is missing")]
+            end
 
             REQUIRED_SECTIONS.each do |attr, label|
-              value = Dcc::TypeGuards.has_attribute?(admin, attr) ? admin.public_send(attr) : nil
+              value = if Dcc::TypeGuards.has_attribute?(admin,
+                                                        attr)
+                        admin.public_send(attr)
+                      end
               next unless value.nil? || ((value.is_a?(::String) || value.is_a?(::Array)) && value.empty?)
 
               issues << issue(
@@ -39,4 +46,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -12,4 +11,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -8,13 +7,20 @@ module Dcc
         # Errors if `endPerformanceDate` precedes `beginPerformanceDate`.
         class DateRangeCheck < Base
           def check_on(dcc)
-            return [] unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data)
+            return [] unless Dcc::TypeGuards.has_attribute?(dcc,
+                                                            :administrative_data)
 
             core = safe_attr(dcc.administrative_data, :core_data)
             return [] if core.nil?
 
-            begin_d = Dcc::TypeGuards.has_attribute?(core, :begin_performance_date) ? core.begin_performance_date : nil
-            end_d = Dcc::TypeGuards.has_attribute?(core, :end_performance_date) ? core.end_performance_date : nil
+            begin_d = if Dcc::TypeGuards.has_attribute?(core,
+                                                        :begin_performance_date)
+                        core.begin_performance_date
+                      end
+            end_d = if Dcc::TypeGuards.has_attribute?(core,
+                                                      :end_performance_date)
+                      core.end_performance_date
+                    end
 
             return [] if begin_d.nil? || end_d.nil?
             return [] unless end_d < begin_d
@@ -38,4 +44,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -57,5 +56,3 @@ module Dcc
     end
   end
 end
-
-require "set"