dcc 0.2.0 → 0.2.2

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"

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -10,20 +9,24 @@ module Dcc
         class UsedMethodsPlacement < Base
           def check_on(dcc)
             issues = []
-            return issues unless Dcc::TypeGuards.has_attribute?(dcc, :measurement_results)
+            return issues unless Dcc::TypeGuards.has_attribute?(dcc,
+                                                                :measurement_results)
 
             mr_list = safe_attr(dcc.measurement_results, :measurement_result)
             return issues if mr_list.empty?
 
             any_used = mr_list.any? do |mr|
-              Dcc::TypeGuards.has_attribute?(mr, :used_methods) && !mr.used_methods.nil? ||
+              (Dcc::TypeGuards.has_attribute?(mr,
+                                              :used_methods) && !mr.used_methods.nil?) ||
                 mr_has_descendant?(mr, :used_methods)
             end
 
-            issues << issue(
-              severity: :error,
-              message: "dcc:usedMethods is missing in every measurementResult and its descendants",
-            ) unless any_used
+            unless any_used
+              issues << issue(
+                severity: :error,
+                message: "dcc:usedMethods is missing in every measurementResult and its descendants",
+              )
+            end
 
             issues
           end
@@ -31,7 +34,8 @@ module Dcc
           private
 
           def mr_has_descendant?(mr, attr_name)
-            return false unless Dcc::TypeGuards.has_attribute?(mr, :results) && mr.results
+            return false unless Dcc::TypeGuards.has_attribute?(mr,
+                                                               :results) && mr.results
 
             result = safe_attr(mr.results, :result)
             result.any? { |r| descendant_has?(r, attr_name) }
@@ -40,7 +44,8 @@ module Dcc
           def descendant_has?(node, attr_name)
             return false unless node.is_a?(::Lutaml::Model::Serializable)
 
-            if Dcc::TypeGuards.has_attribute?(node, attr_name) && !node.public_send(attr_name).nil?
+            if Dcc::TypeGuards.has_attribute?(node,
+                                              attr_name) && !node.public_send(attr_name).nil?
               return true
             end
 
@@ -62,4 +67,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -12,21 +11,27 @@ module Dcc
           end
 
           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?
 
             present = mr_list.any? do |mr|
-              Dcc::TypeGuards.has_attribute?(mr, :used_software) && !mr.used_software.nil?
+              Dcc::TypeGuards.has_attribute?(mr,
+                                             :used_software) && !mr.used_software.nil?
             end
 
-            present ? [] : [
-              issue(
-                severity: :warning,
-                message: "dcc:usedSoftware is missing on every measurementResult",
-              ),
-            ]
+            if present
+              []
+            else
+              [
+                issue(
+                  severity: :warning,
+                  message: "dcc:usedSoftware is missing on every measurementResult",
+                ),
+              ]
+            end
           end
 
           private
@@ -40,4 +45,4 @@ module Dcc
       end
     end
   end
-end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Dcc
   module Validate
     module Schematron
@@ -32,11 +31,13 @@ module Dcc
 
             node.class.attributes.each_key do |a|
               v = node.public_send(a)
-              Array(v).each { |child| check_string_list_attribute(child, issues, attr, label) }
+              Array(v).each do |child|
+                check_string_list_attribute(child, issues, attr, label)
+              end
             end
           end
         end
       end
     end
   end
-end
+end

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

@@ -10,20 +10,34 @@ module Dcc
     module Schematron
       module Rules
         autoload :Base, "dcc/validate/schematron/rules/base"
-        autoload :UsedMethodsPlacement, "dcc/validate/schematron/rules/used_methods_placement"
-        autoload :UsedSoftwarePlacement, "dcc/validate/schematron/rules/used_software_placement"
-        autoload :InfluenceConditionsPlacement, "dcc/validate/schematron/rules/influence_conditions_placement"
-        autoload :SchemaVersionCheck, "dcc/validate/schematron/rules/schema_version_check"
-        autoload :IdRefIdLinking, "dcc/validate/schematron/rules/id_refid_linking"
-        autoload :IsoCodeValidation, "dcc/validate/schematron/rules/iso_code_validation"
-        autoload :DateRangeCheck, "dcc/validate/schematron/rules/date_range_check"
-        autoload :ReleaseFormatCheck, "dcc/validate/schematron/rules/release_format_check"
-        autoload :UncertaintyConsistency, "dcc/validate/schematron/rules/uncertainty_consistency"
-        autoload :UnitFormatCheck, "dcc/validate/schematron/rules/unit_format_check"
-        autoload :NonSiDeclaration, "dcc/validate/schematron/rules/non_si_declaration"
-        autoload :LanguageCodeDedup, "dcc/validate/schematron/rules/language_code_dedup"
-        autoload :XmlListSpacing, "dcc/validate/schematron/rules/xml_list_spacing"
-        autoload :AdministrativeDataCompleteness, "dcc/validate/schematron/rules/administrative_data_completeness"
+        autoload :UsedMethodsPlacement,
+                 "dcc/validate/schematron/rules/used_methods_placement"
+        autoload :UsedSoftwarePlacement,
+                 "dcc/validate/schematron/rules/used_software_placement"
+        autoload :InfluenceConditionsPlacement,
+                 "dcc/validate/schematron/rules/influence_conditions_placement"
+        autoload :SchemaVersionCheck,
+                 "dcc/validate/schematron/rules/schema_version_check"
+        autoload :IdRefIdLinking,
+                 "dcc/validate/schematron/rules/id_refid_linking"
+        autoload :IsoCodeValidation,
+                 "dcc/validate/schematron/rules/iso_code_validation"
+        autoload :DateRangeCheck,
+                 "dcc/validate/schematron/rules/date_range_check"
+        autoload :ReleaseFormatCheck,
+                 "dcc/validate/schematron/rules/release_format_check"
+        autoload :UncertaintyConsistency,
+                 "dcc/validate/schematron/rules/uncertainty_consistency"
+        autoload :UnitFormatCheck,
+                 "dcc/validate/schematron/rules/unit_format_check"
+        autoload :NonSiDeclaration,
+                 "dcc/validate/schematron/rules/non_si_declaration"
+        autoload :LanguageCodeDedup,
+                 "dcc/validate/schematron/rules/language_code_dedup"
+        autoload :XmlListSpacing,
+                 "dcc/validate/schematron/rules/xml_list_spacing"
+        autoload :AdministrativeDataCompleteness,
+                 "dcc/validate/schematron/rules/administrative_data_completeness"
       end
     end
   end

data/lib/dcc/validate/schematron.rb

@@ -19,4 +19,4 @@ module Dcc
       end
     end
   end
-end
+end

data/lib/dcc/validate/xsd.rb

@@ -27,7 +27,9 @@ module Dcc
           resolved = ::Dcc::Schema::Version.resolve_dcc(version, xml: xml)
           schema = schema_for(resolved)
           doc = parse_xml(xml)
-          errors = schema.validate(doc).map { |e| issue_from_nokogiri(e, resolved) }
+          errors = schema.validate(doc).map do |e|
+            issue_from_nokogiri(e, resolved)
+          end
 
           ::Dcc::Validate::Result.new(
             issues: errors,
@@ -60,10 +62,14 @@ module Dcc
           content = ::File.read(xsd_path)
           content.gsub(/schemaLocation\s*=\s*"([^"]+)"/) do |_match|
             relative = ::Regexp.last_match(1)
-            next %{schemaLocation="#{relative}"} if relative.start_with?("http", "file://")
+            next %{schemaLocation="#{relative}"} if relative.start_with?(
+              "http", "file://"
+            )
 
             absolute = ::File.expand_path(relative, base_dir)
-            %{schemaLocation="file://#{absolute}"}
+            uri_path = absolute.gsub(::File::ALT_SEPARATOR || "\\", "/")
+            uri_path = "/#{uri_path}" unless uri_path.start_with?("/")
+            %{schemaLocation="file://#{uri_path}"}
           end
         end
 

data/lib/dcc/validate.rb

@@ -12,4 +12,4 @@ module Dcc
     autoload :Schematron, "dcc/validate/schematron"
     autoload :BusinessRules, "dcc/validate/business_rules"
   end
-end
+end

data/lib/dcc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dcc
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/lib/dcc/versioned_parser.rb

@@ -42,7 +42,7 @@ module Dcc
     end
 
     def root_element_symbol
-      self.const_get(:ROOT_ELEMENT_TAG).to_sym
+      const_get(:ROOT_ELEMENT_TAG).to_sym
     end
   end
 end