lutaml-xsd 1.2.96 → 1.2.97

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b47e6206406d15078ca3896061eb50d415a599a3a6fe62df9a59d191c31f410a
-  data.tar.gz: d60605597341f39c26d19ac3bb8d88e6a0ff06d4f7ad03c9504d6903fc6a6ca9
+  metadata.gz: 74cc0c3c59a0cb1a80968d340ccf4d8be8b7d9ce9d1257c7e59044ebd85bc5b0
+  data.tar.gz: 453526a2baaeb84186acb8f3d84b573ddaeb988af120acf601bd2e621cd159e2
 SHA512:
-  metadata.gz: 231da0fb555d2591583462fa173efef19ee7835938aab19b52a3dc637a2e1c62a2e97f428fe492bea6b7b6891da3af45602a8ebf7112c1733d914098e32a3c38
-  data.tar.gz: baa25447cd81057253277cf53348399487b15a2d8b5735e3531a57f6f87d7dec4dc12bfe0a3e2c87f80a20f9580c094b823616b093c5764f95789a1b0724d373
+  metadata.gz: 67c01245e71827ab4682e6dda886b296586d96960b5e814b1b1e9ccbdee53d4fc33ee95ed705b90730e636f0f2c0ea5a7f325809072a7e0a0bd79d0928b91a79
+  data.tar.gz: 3246ef0bfd177d2019fa3fd08b01409647d2d2d71c4bb8757e108a55c9374f72684f258e46419bece176a03f94a24a3c44c11ec484b38f9fe60e4114099f022e

data/TODO.conformance.md

@@ -525,6 +525,21 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   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
   (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/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.97"
   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.97
 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