lutaml-xsd 1.2.96 → 1.2.98

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b47e6206406d15078ca3896061eb50d415a599a3a6fe62df9a59d191c31f410a
-  data.tar.gz: d60605597341f39c26d19ac3bb8d88e6a0ff06d4f7ad03c9504d6903fc6a6ca9
+  metadata.gz: e129470c8c939e17b19e748ffaebf593f7f3909876fbe05e1b733e1129f448ba
+  data.tar.gz: '03015085efe53c4dca6dec3bc5115d9081b42a24c2f758b19c4c3424b672521f'
 SHA512:
-  metadata.gz: 231da0fb555d2591583462fa173efef19ee7835938aab19b52a3dc637a2e1c62a2e97f428fe492bea6b7b6891da3af45602a8ebf7112c1733d914098e32a3c38
-  data.tar.gz: baa25447cd81057253277cf53348399487b15a2d8b5735e3531a57f6f87d7dec4dc12bfe0a3e2c87f80a20f9580c094b823616b093c5764f95789a1b0724d373
+  metadata.gz: 4e1be4de4f925cb152fa5f69e2cb57fb42d9337ab37628b71314ab0e3bc7a5d10da9cf829173a78303c0e8e495682286bb9ecf4bde0d72056324d6e572d309cc
+  data.tar.gz: ae47a5ca4b9bc803c7e7c35aaeb0a9e8a35e9610bddacdd82d14b269310863f91d64a9f59f1cd9f0014ea72dd0040f975098feccd30914fc6e7cf053845a9b91

data/TODO.conformance.md

@@ -524,7 +524,42 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   series — filed leptris-rs#47; moxml 0.6.3 regressed 5 attribute
   cases (addB059/196c/197c, attO009/011) — filed moxml#529. THE
   STACK IS PINNED BACK to the known-good 1.9.406.0/0.6.2/0.8.161
+- SKIP-WILDCARD-FIELD ROUND (2026-11-07): +1 IC (idZ015; suite
+  4621->4622 = 98.42%, zero regressions, rspec green). THE LAST IC
+  SINGLETON — the idK/idZ family is now CLEAN (all six roots fixed
+  across the four rounds). An attribute admitted by a
+  processContents=skip wildcard is NOT ASSESSED, so it supplies no
+  identity-constraint field value: the field treats it as absent and
+  a key whose fields do not all evaluate is violated (idZ015: foo's
+  ##any skip anyAttribute + key field @bar; xmllint: "Not all fields
+  of key identity-constraint evaluate to a node"). The skip check
+  walks the selector node's declaration anyAttribute wildcards
+  (own + content parts + attributeGroup members, depth 3) and the
+  namespace constraint reads the attribute's URI from the MOXML
+  element wrapper — xpath result attributes are ADAPTER objects
+  (leptris ResultAttr carries no namespace). GOTCHA: the first
+  implementation read node.namespace and CRASHED under leptris —
+  the suite probe "passed" as CRASH-AS-INVALID, caught by writing
+  the rule-level spec FIRST (rule_execution_error instead of the
+  finding). Suite verdicts from crashes are not fixes; assert the
+  finding code.
+
   (98.28% restored, zero regressions vs the 406 baseline). The
+- IDREF-RESOLUTION ROUND (2026-11-07): +1 IC (idZ012; suite
+  4620->4621 = 98.40%, zero regressions, rspec green). Every
+  IDREF/IDREFS value must match an ID in the document (XSD 1.0
+  §3.3.3) — the check did not exist at all. IdrefResolutionRule
+  (identity category, root-scoped two-phase scan beside
+  IdUniquenessRule) collects every document ID (element text +
+  attributes), then checks IDREF/IDREFS values from instance
+  attributes, element text, AND the declaration's fixed/default
+  supply when the instance omits the attribute — a defaulted IDREFS
+  still references (idZ012: drefs type="xs:IDREFS" default="abc"
+  against a document with no ID). IDREFS tokenizes; every token must
+  resolve; the two-phase order makes forward references valid.
+  Remaining IC singleton: idZ015 (a skip-wildcard-governed attribute
+  supplies no IC field value).
+
   407 wins ride again when #47 and #529 land. NET: no score
 - ID-VALUE-CONSTRAINT ROUND (2026-11-07): +1 IC (idZ011; suite
   4619->4620 = 98.38%, zero regressions, rspec green). Value

data/lib/lutaml/xsd/validation/rule_registry.rb

@@ -8,6 +8,7 @@ require_relative "rules/occurrence_validation_rule"
 require_relative "rules/content_model_validation_rule"
 require_relative "rules/identity_constraints_rule"
 require_relative "rules/id_uniqueness_rule"
+require_relative "rules/idref_resolution_rule"
 
 module Lutaml
   module Xsd
@@ -63,6 +64,7 @@ module Lutaml
           if config.feature_enabled?(:validate_identity_constraints)
             registry.register(Rules::IdentityConstraintsRule.new)
             registry.register(Rules::IdUniquenessRule.new)
+            registry.register(Rules::IdrefResolutionRule.new)
           end
           registry
         end

data/lib/lutaml/xsd/validation/rules/identity_constraints_rule.rb

@@ -128,6 +128,14 @@ module Lutaml
               ambiguous = true if matched.size > 1
               values << if matched.first.nil?
                           field_supply_value(node, field, repository)
+                        elsif !matched.first.is_a?(Moxml::Element) &&
+                            skip_governed_attribute?(node, matched.first,
+                                                     repository)
+                          # A skip-wildcard-governed attribute is not
+                          # assessed, so it supplies no identity-
+                          # constraint value: the field treats it as
+                          # absent (idZ015).
+                          nil
                         elsif matched.first.is_a?(Moxml::Element) &&
                             field_node_non_simple?(
                               matched.first, constraint, raws[index],
@@ -337,6 +345,104 @@ module Lutaml
             repository.declared_attribute_supply(parent_type, attr_local)
           end
 
+          # Whether the instance attribute is governed by a SKIP
+          # wildcard on the selector node's declaration: a skip-
+          # governed attribute is not assessed, so it supplies no
+          # identity-constraint field value (idZ015).
+          #
+          # @return [Boolean]
+          def skip_governed_attribute?(element_node, attribute_node,
+                                       repository)
+            declaration = repository&.resolve(element_node.name,
+                                              element_node.namespace_uri)
+            return false unless declaration
+
+            type = declaration.complex_type ||
+              repository.resolve_type(declaration)
+            return false unless type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
+
+            target_ns = repository.target_namespace_for(declaration)
+            attribute_ns = attribute_namespace(element_node, attribute_node)
+            attribute_skip_wildcards(type, repository, 0).any? do |wildcard|
+              wildcard_process_mode(wildcard) == "skip" &&
+                wildcard_admits_namespace?(wildcard, attribute_ns, target_ns)
+            end
+          end
+
+          # The attribute's namespace URI: the xpath result nodes are
+          # adapter objects (leptris ResultAttr carries no namespace),
+          # so the name-matched attribute on the MOXML element wrapper
+          # resolves it.
+          #
+          # @return [String]
+          def attribute_namespace(element_node, attribute_node)
+            found = element_node.attributes.find do |candidate|
+              candidate.name == attribute_node.name
+            end
+            found&.namespace&.uri.to_s
+          end
+
+          # The anyAttribute wildcards reachable from the type: its own,
+          # content-part bodies, and attributeGroup members (nested
+          # refs depth-guarded).
+          #
+          # @return [Array<Lutaml::Xml::Schema::Xsd::AnyAttribute>]
+          def attribute_skip_wildcards(type, repository, depth)
+            return [] if depth > 3
+
+            wildcards = Array(type.any_attribute)
+            Array(type.attribute_group).each do |group|
+              wildcards.concat(Array(group.any_attribute))
+              local = (group.ref || group.name).to_s.split(":").last
+              declaration = local && repository.resolve_attribute_group(local)
+              if declaration
+                wildcards.concat(attribute_skip_wildcards(declaration,
+                                                          repository,
+                                                          depth + 1))
+              end
+            end
+            content_kinds = %i[complex_content simple_content]
+            part_kinds = %i[extension restriction]
+            content_kinds.each do |content_kind|
+              content = type.public_send(content_kind)
+              next unless content
+
+              part_kinds.each do |part_kind|
+                Array(content.public_send(part_kind)).each do |part|
+                  wildcards.concat(Array(part.any_attribute))
+                end
+              end
+            end
+            wildcards
+          end
+
+          # Whether the wildcard's namespace constraint admits the
+          # attribute's namespace (mirrors WildcardScope#wildcard_permits?
+          # for attribute nodes, against the declaration's target
+          # namespace).
+          #
+          # @return [Boolean]
+          def wildcard_admits_namespace?(wildcard, uri, target_ns)
+            case wildcard.namespace.to_s
+            when "##any", ""
+              true
+            when "##other"
+              !uri.empty? && uri != target_ns.to_s
+            when "##local"
+              uri.empty?
+            when "##targetNamespace"
+              uri == target_ns.to_s
+            else
+              wildcard.namespace.to_s.split(/\s+/).any? do |entry|
+                case entry
+                when "##local" then uri.empty?
+                when "##targetNamespace" then uri == target_ns.to_s
+                else entry == uri
+                end
+              end
+            end
+          end
+
           # Whether an element field's node supplies no identity value:
           # it has element children, is declared non-simple (complex
           # content or xsd:anyType — the typeless default), or carries a

data/lib/lutaml/xsd/validation/rules/idref_resolution_rule.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require_relative "../validation_rule"
+
+module Lutaml
+  module Xsd
+    module Validation
+      module Rules
+        # IdrefResolutionRule enforces built-in xs:IDREF(S) resolution
+        #
+        # XSD 1.0 §3.3.3: every IDREF/IDREFS value must match the value
+        # of some ID in the document. Values come from instance
+        # attributes, element text typed IDREF(S), AND a declaration's
+        # fixed/default supply when the instance omits the attribute —
+        # a defaulted IDREFS still references (idZ012: drefs
+        # type="xs:IDREFS" default="abc" against a document declaring
+        # no ID). IDREFS values tokenize on whitespace; every token
+        # must resolve. The scan is two-phase (all IDs first, then all
+        # references), so forward references resolve.
+        class IdrefResolutionRule < ValidationRule
+          def category
+            :identity
+          end
+
+          def description
+            "Validates built-in xs:IDREF(S) values resolve to document IDs"
+          end
+
+          def validate(xml_element, schema_element, collector,
+                       repository: nil)
+            return unless repository
+            return unless
+              schema_element.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+
+            # The walk invokes the rule per element and per category;
+            # the document is scanned exactly once, from the first
+            # (root) invocation — element wrappers are not
+            # identity-stable across passes.
+            return if @scanned
+
+            @scanned = true
+            ids = collect_ids(xml_element, repository)
+            check_references(xml_element, ids, collector, repository)
+          end
+
+          private
+
+          # Phase 1: every ID value in the document (element text and
+          # attributes). Mirrors IdUniquenessRule's walk — IDs come
+          # from instances only; a declaration cannot supply an ID that
+          # the document does not contain.
+          #
+          # @return [Set<String>]
+          def collect_ids(element, repository)
+            ids = []
+            declaration = repository.resolve(element.name,
+                                             element.namespace_uri)
+            if declaration
+              collect_element_ids(element, declaration, ids, repository)
+              collect_attribute_ids(element, declaration, ids, repository)
+            end
+
+            element.children.each do |child|
+              ids.concat(collect_ids(child, repository))
+            end
+            ids.compact
+          end
+
+          # @return [void]
+          def collect_element_ids(element, declaration, ids, repository)
+            return unless builtin_typed?(declaration, repository, "ID")
+
+            # ID/IDREF(S) collapse whitespace (token derivation) — the
+            # value space is the collapsed form, never the raw lexical
+            # (dtZ107447: " John " both sides).
+            ids.concat(element.text_content.to_s.split)
+          end
+
+          # @return [void]
+          def collect_attribute_ids(element, declaration, ids, repository)
+            typed_attributes(declaration, repository, "ID").each do |attr|
+              instance = element.attributes.find do |candidate|
+                candidate.name == attr.name
+              end
+              ids.concat(instance.value.to_s.split) if instance
+            end
+          end
+
+          # Phase 2: every IDREF(S) value the document carries or its
+          # declarations SUPPLY, each token matched against the IDs.
+          #
+          # @return [void]
+          def check_references(element, ids, collector, repository)
+            declaration = repository.resolve(element.name,
+                                             element.namespace_uri)
+            if declaration
+              check_element_reference(element, declaration, ids, collector,
+                                      repository)
+              check_attribute_references(element, declaration, ids,
+                                         collector, repository)
+            end
+
+            element.children.each do |child|
+              check_references(child, ids, collector, repository)
+            end
+          end
+
+          # @return [void]
+          def check_element_reference(element, declaration, ids, collector,
+                                      repository)
+            return unless
+              builtin_typed?(declaration, repository, "IDREF") ||
+                builtin_typed?(declaration, repository, "IDREFS")
+
+            reference_values(element.text_content.to_s).each do |value|
+              next if ids.include?(value)
+
+              report_unresolved(value, element, collector, "element")
+            end
+          end
+
+          # Instance values, then the declaration's fixed/default supply
+          # for ABSENT attributes — a defaulted IDREFS still references
+          # (idZ012).
+          #
+          # @return [void]
+          def check_attribute_references(element, declaration, ids, collector,
+                                         repository)
+            typed_attributes(declaration, repository, "IDREF").each do |attr|
+              report_tokens(element, attr, ids, collector,
+                            instance_value(element, attr))
+            end
+            typed_attributes(declaration, repository, "IDREFS").each do |attr|
+              report_tokens(element, attr, ids, collector,
+                            instance_value(element, attr))
+            end
+          end
+
+          # @return [String, nil]
+          def instance_value(element, attr)
+            instance = element.attributes.find do |candidate|
+              candidate.name == attr.name
+            end
+            instance&.value || attr.fixed || attr.default
+          end
+
+          # @return [void]
+          def report_tokens(element, attr, ids, collector, supplied)
+            reference_values(supplied).each do |value|
+              next if ids.include?(value)
+
+              report_unresolved(value, element, collector,
+                                "attribute '#{attr.name}'")
+            end
+          end
+
+          # IDREF is a single value; IDREFS tokenizes on whitespace.
+          #
+          # @return [Array<String>]
+          def reference_values(supplied)
+            supplied.to_s.strip.empty? ? [] : supplied.to_s.split
+          end
+
+          # @return [void]
+          def report_unresolved(value, xml_element, collector, subject)
+            report_error(
+              collector,
+              code: "idref_violation",
+              message: "#{subject} has IDREF value '#{value}' that " \
+                       "does not match any ID in the document",
+              location: xml_element.xpath,
+              context: { value: value },
+            )
+          end
+
+          # Whether the declaration's type is the named builtin — a
+          # direct reference or an inline restriction of it.
+          #
+          # @return [Boolean]
+          def builtin_typed?(declaration, _repository, name)
+            builtin_reference?(declaration.type.to_s, name) ||
+              builtin_reference?(
+                declaration.simple_type&.restriction&.base.to_s, name
+              )
+          end
+
+          # @return [Boolean]
+          def builtin_reference?(reference, name)
+            parts = reference.split(":")
+            parts.size == 2 && %w[xs xsd].include?(parts.first) &&
+              parts.last == name
+          end
+
+          # The declaration's own attribute particles typed the builtin:
+          # direct attributes, refs resolved to their declarations, and
+          # attributeGroup members.
+          #
+          # @return [Array<Lutaml::Xml::Schema::Xsd::Attribute>]
+          def typed_attributes(schema_element, repository, name)
+            type = schema_element.complex_type ||
+              repository.resolve_type(schema_element)
+            return [] unless type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
+
+            particles = Array(type.attribute)
+            Array(type.attribute_group).each do |group|
+              declaration = repository.resolve_attribute_group(
+                (group.ref || group.name).to_s.split(":").last,
+              )
+              particles.concat(Array(declaration&.attribute))
+            end
+
+            particles.filter_map do |particle|
+              resolved = particle
+              unless particle.ref.to_s.empty?
+                resolved = repository.resolve_attribute(
+                  particle.ref.split(":").last, nil
+                )
+              end
+              next nil unless resolved && builtin_typed?(resolved, repository,
+                                                         name)
+
+              resolved
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.96"
+    VERSION = "1.2.98"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.2.96
+  version: 1.2.98
 platform: ruby
 authors:
 - Ribose Inc.
@@ -578,6 +578,7 @@ files:
 - lib/lutaml/xsd/validation/rules/element_structure_rule.rb
 - lib/lutaml/xsd/validation/rules/id_uniqueness_rule.rb
 - lib/lutaml/xsd/validation/rules/identity_constraints_rule.rb
+- lib/lutaml/xsd/validation/rules/idref_resolution_rule.rb
 - lib/lutaml/xsd/validation/rules/occurrence_validation_rule.rb
 - lib/lutaml/xsd/validation/rules/type_validation_rule.rb
 - lib/lutaml/xsd/validation/schema_definition_resolver.rb