dcc 0.2.0 → 0.2.1

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"

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -9,25 +8,31 @@ module Dcc
         # quantity level). Error if missing.
         class InfluenceConditionsPlacement < Base
           def check_on(dcc)
-            return [] unless Dcc::TypeGuards.has_attribute?(dcc, :measurement_results)
+            return [] unless Dcc::TypeGuards.has_attribute?(dcc,
+                                                            :measurement_results)
 
             mr_list = safe_attr(dcc.measurement_results, :measurement_result)
             return [] if mr_list.empty?
 
             any_present = mr_list.any? do |mr|
-              next false unless Dcc::TypeGuards.has_attribute?(mr, :influence_conditions)
+              next false unless Dcc::TypeGuards.has_attribute?(mr,
+                                                               :influence_conditions)
               next true unless mr.influence_conditions.nil?
 
               Dcc::TypeGuards.has_attribute?(mr, :results) && mr.results &&
                 has_in_descendants?(mr.results)
             end
 
-            any_present ? [] : [
-              issue(
-                severity: :error,
-                message: "dcc:influenceConditions is missing everywhere",
-              ),
-            ]
+            if any_present
+              []
+            else
+              [
+                issue(
+                  severity: :error,
+                  message: "dcc:influenceConditions is missing everywhere",
+                ),
+              ]
+            end
           end
 
           private
@@ -35,13 +40,18 @@ module Dcc
           def has_in_descendants?(node)
             return false unless node.is_a?(::Lutaml::Model::Serializable)
 
-            if Dcc::TypeGuards.has_attribute?(node, :influence_conditions) && !node.influence_conditions.nil?
+            if Dcc::TypeGuards.has_attribute?(node,
+                                              :influence_conditions) && !node.influence_conditions.nil?
               return true
             end
 
             node.class.attributes.each_key do |attr|
               value = node.public_send(attr)
-              Array(value).any? { |c| has_in_descendants?(c) } if value.is_a?(::Array) || value.is_a?(::Lutaml::Model::Serializable)
+              if value.is_a?(::Array) || value.is_a?(::Lutaml::Model::Serializable)
+                Array(value).any? do |c|
+                  has_in_descendants?(c)
+                end
+              end
             end
             false
           end
@@ -55,4 +65,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -10,13 +9,17 @@ module Dcc
         # flag empties that escaped earlier casts.
         class IsoCodeValidation < 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?
 
             issues = []
-            country = Dcc::TypeGuards.has_attribute?(core, :country_code_iso_3166_1) ? core.country_code_iso_3166_1 : nil
+            country = if Dcc::TypeGuards.has_attribute?(core,
+                                                        :country_code_iso_3166_1)
+                        core.country_code_iso_3166_1
+                      end
             if country.nil? || country.to_s.empty?
               issues << issue(
                 severity: :error,
@@ -24,17 +27,31 @@ module Dcc
               )
             end
 
-            used = Dcc::TypeGuards.has_attribute?(core, :used_lang_code_iso_639_1) ? Array(core.used_lang_code_iso_639_1) : []
-            issues << issue(
-              severity: :error,
-              message: "dcc:usedLangCodeISO639_1 must have at least one entry",
-            ) if used.empty?
+            used = if Dcc::TypeGuards.has_attribute?(core,
+                                                     :used_lang_code_iso_639_1)
+                     Array(core.used_lang_code_iso_639_1)
+                   else
+                     []
+                   end
+            if used.empty?
+              issues << issue(
+                severity: :error,
+                message: "dcc:usedLangCodeISO639_1 must have at least one entry",
+              )
+            end
 
-            mandatory = Dcc::TypeGuards.has_attribute?(core, :mandatory_lang_code_iso_639_1) ? Array(core.mandatory_lang_code_iso_639_1) : []
-            issues << issue(
-              severity: :error,
-              message: "dcc:mandatoryLangCodeISO639_1 must have at least one entry",
-            ) if mandatory.empty?
+            mandatory = if Dcc::TypeGuards.has_attribute?(core,
+                                                          :mandatory_lang_code_iso_639_1)
+                          Array(core.mandatory_lang_code_iso_639_1)
+                        else
+                          []
+                        end
+            if mandatory.empty?
+              issues << issue(
+                severity: :error,
+                message: "dcc:mandatoryLangCodeISO639_1 must have at least one entry",
+              )
+            end
 
             issues
           end
@@ -50,4 +67,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -8,14 +7,22 @@ module Dcc
         # Errors on duplicate language codes in `dcc:usedLangCodeISO639_1`.
         class LanguageCodeDedup < 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?
 
-            used = Dcc::TypeGuards.has_attribute?(core, :used_lang_code_iso_639_1) ? Array(core.used_lang_code_iso_639_1) : []
+            used = if Dcc::TypeGuards.has_attribute?(core,
+                                                     :used_lang_code_iso_639_1)
+                     Array(core.used_lang_code_iso_639_1)
+                   else
+                     []
+                   end
             used_strings = used.map(&:to_s)
-            duplicates = used_strings.group_by(&:itself).select { |_k, v| v.size > 1 }.keys
+            duplicates = used_strings.group_by(&:itself).select do |_k, v|
+              v.size > 1
+            end.keys
 
             duplicates.map do |dup|
               issue(
@@ -36,4 +43,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -36,7 +36,10 @@ module Dcc
             node.class.attributes.each_key do |attr_name|
               value = node.public_send(attr_name)
               Array(value).each do |child|
-                declared += collect_declared_non_si_units(child, visited) if child.is_a?(::Lutaml::Model::Serializable)
+                if child.is_a?(::Lutaml::Model::Serializable)
+                  declared += collect_declared_non_si_units(child,
+                                                            visited)
+                end
               end
             end
             declared
@@ -57,7 +60,9 @@ module Dcc
             extract_non_si_unit(node, accumulator)
             node.class.attributes.each_key do |attr_name|
               value = node.public_send(attr_name)
-              Array(value).each { |child| walk_for_used_units(child, accumulator, visited) }
+              Array(value).each do |child|
+                walk_for_used_units(child, accumulator, visited)
+              end
             end
           end
 
@@ -78,5 +83,3 @@ module Dcc
     end
   end
 end
-
-require "set"

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -11,13 +10,17 @@ 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)
 
             software_list = safe_attr(dcc.administrative_data, :dcc_software)
             return issues if software_list.nil?
 
             Array(safe_attr(software_list, :software)).each do |sw|
-              release = Dcc::TypeGuards.has_attribute?(sw, :release) ? sw.release : nil
+              release = if Dcc::TypeGuards.has_attribute?(sw,
+                                                          :release)
+                          sw.release
+                        end
               next if release.nil? || release.empty?
               next if release.match?(PATTERN)
 
@@ -41,4 +44,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -12,20 +11,25 @@ module Dcc
           end
 
           def check_on(dcc)
-            return [] unless Dcc::TypeGuards.has_attribute?(dcc, :schema_version)
+            return [] unless Dcc::TypeGuards.has_attribute?(dcc,
+                                                            :schema_version)
 
             current = dcc.schema_version.to_s
             latest = ::Dcc::Schema::Version::DCC_LATEST
 
-            current == latest ? [] : [
-              issue(
-                severity: :warning,
-                message: "schemaVersion '#{current}' is not the latest release (#{latest})",
-              ),
-            ]
+            if current == latest
+              []
+            else
+              [
+                issue(
+                  severity: :warning,
+                  message: "schemaVersion '#{current}' is not the latest release (#{latest})",
+                ),
+              ]
+            end
           end
         end
       end
     end
   end
-end
+end

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

@@ -5,9 +5,16 @@ module Dcc
     module Schematron
       module Rules
         # Validates that for every `si:realListXMLList` paired with an
-        # `si:expandedUncXMLList`, the count of values matches the count
-        # of uncertainty entries.
+        # `si:expandedUncXMLList`, each uncertainty list holds either one
+        # entry per value or a single entry broadcast across all of them.
         class UncertaintyConsistency < Base
+          UNCERTAINTY_LISTS = {
+            uncertainty_xml_list: "uncertaintyXMLList",
+            coverage_factor_xml_list: "coverageFactorXMLList",
+            coverage_probability_xml_list: "coverageProbabilityXMLList",
+            distribution_xml_list: "distributionXMLList",
+          }.freeze
+
           def check_on(dcc)
             issues = []
             return issues unless dcc.is_a?(::Lutaml::Model::Serializable)
@@ -24,7 +31,10 @@ module Dcc
 
             visited << node.object_id
 
-            check_node(node, issues) if node.class.name.end_with?("::RealListXmlList")
+            if node.class.name.end_with?("::RealListXmlList")
+              check_node(node,
+                         issues)
+            end
             descend(node, issues, visited)
           end
 
@@ -33,16 +43,37 @@ module Dcc
             unc = list_node.expanded_unc_xml_list
             return unless unc && values
 
-            unc_count = Array(unc.uncertainty_xml_list).size
-            value_count = Array(values).size
-            return if unc_count == value_count || unc_count.zero?
+            value_count = entry_count(values)
+            UNCERTAINTY_LISTS.each do |attribute, xml_name|
+              count = entry_count(unc.public_send(attribute))
+              next if consistent?(count, value_count)
+
+              issues << count_mismatch(xml_name, count, value_count)
+            end
+          end
 
-            issues << issue(
+          def count_mismatch(xml_name, count, value_count)
+            issue(
               severity: :error,
-              message: "valueXMLList count (#{value_count}) does not match expandedUncertaintyXMLList count (#{unc_count})",
+              message: "valueXMLList count (#{value_count}) does not " \
+                       "match #{xml_name} count (#{count})",
             )
           end
 
+          # Every list here is an xs:list, so its entries are whitespace
+          # separated whether the attribute holds a string or a decimal list.
+          def entry_count(list)
+            list.to_s.split.size
+          end
+
+          # A list either carries one entry per value or a single entry that
+          # broadcasts across all of them, the way unitXMLList does. Siblings
+          # decide independently: PTB ships documents pairing nine
+          # uncertainties with one shared coverage factor.
+          def consistent?(count, value_count)
+            count.zero? || count == 1 || count == value_count
+          end
+
           def descend(node, issues, visited)
             node.class.attributes.each_key do |attr_name|
               value = node.public_send(attr_name)
@@ -54,5 +85,3 @@ module Dcc
     end
   end
 end
-
-require "set"

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

@@ -29,7 +29,8 @@ module Dcc
           end
 
           def check_single_unit(node, issues)
-            return unless node.class.name.end_with?("::Real", "::Complex", "::Constant")
+            return unless node.class.name.end_with?("::Real", "::Complex",
+                                                    "::Constant")
             return unless node.respond_to?(:unit)
 
             unit = node.unit
@@ -70,5 +71,3 @@ module Dcc
     end
   end
 end
-
-require "set"