lutaml-xsd 1.2.95 → 1.2.97

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a752804ef8cfcbbe98845ffcfcbd8830d2c37020d392d34524795f645351cef9
-  data.tar.gz: 467cd19ffcc587cbdc4007e614b02f2f299a26917c684e997138fa5116686a7b
+  metadata.gz: 74cc0c3c59a0cb1a80968d340ccf4d8be8b7d9ce9d1257c7e59044ebd85bc5b0
+  data.tar.gz: 453526a2baaeb84186acb8f3d84b573ddaeb988af120acf601bd2e621cd159e2
 SHA512:
-  metadata.gz: 904b2740eaa42225aa419c6a27586cc115fbcba3efaa4e4fe987b979f7139bd00e5e96007f094f65b5631a8383bdd12d0e50eaef82482733662d2dcda8658507
-  data.tar.gz: 545c68eb6ce9cda1d4b834d3bf608974d3da82e774fee7465918ba39d5c2d7183892c0a314c3314d15f68e8f20a6af27e264fb752f5023008db7a5cfa84be512
+  metadata.gz: 67c01245e71827ab4682e6dda886b296586d96960b5e814b1b1e9ccbdee53d4fc33ee95ed705b90730e636f0f2c0ea5a7f325809072a7e0a0bd79d0928b91a79
+  data.tar.gz: 3246ef0bfd177d2019fa3fd08b01409647d2d2d71c4bb8757e108a55c9374f72684f258e46419bece176a03f94a24a3c44c11ec484b38f9fe60e4114099f022e

data/TODO.conformance.md

@@ -525,7 +525,40 @@ 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
+  constraints (fixed/default) are FORBIDDEN on attribute declarations
+  typed xs:ID or derived from it (XSD 1.0 §3.2.6) — the schema is
+  uncompilable, so every instance reached is invalid regardless of
+  instance use. The attribute rule's declaration-scoped step 1c
+  checks the builtin-prefixed reference, ref-resolved declarations,
+  and the inline/named restriction base chain (depth 6); the
+  idZ011_a companion (xs:STRING default) stays clean. Family probes:
+  Attribute 113/113 clean, AttributeGroup 14 = the parked moxml#522
+  set unchanged. PROBE LESSON (repeat): single-process family probes
+  CRAWL after ~50 engine-heavy cases (engine-state accumulation;
+  enumeration order is unstable so the hang point moves) — the case
+  runs alone in <1s; batched methodology or the full measure is the
+  only reliable family signal at this scale. Remaining IC
+  singletons: idZ012 (IDREFS default references no ID), idZ015 (a
+  skip-wildcard-governed attribute supplies no IC field value).
+
   change; the pin protects the register.
 - NON-SIMPLE-FIELD ROUND (2026-11-07): +2 IC (idK012, idZ010; suite
   4617->4619 = 98.36%, zero regressions, rspec green). An identity

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/attribute_validation_rule.rb

@@ -106,6 +106,13 @@ module Lutaml
                                            xml_attributes, collector,
                                            wildcards: wildcards)
 
+            # Step 1c: an xs:ID declaration cannot carry a value
+            # constraint — the schema itself is uncompilable, so the
+            # instance is invalid wherever the declaration is reached
+            # (XSD 1.0 §3.2.6, idZ011).
+            validate_id_value_constraints(schema_attributes, collector,
+                                          xml_element, repository)
+
             # Step 2: Validate attribute values
             validate_attribute_values(xml_element, resolved_attributes,
                                       xml_attributes, collector,
@@ -436,6 +443,73 @@ module Lutaml
             end
           end
 
+          # An xs:ID declaration with fixed or default is an illegal
+          # value constraint (XSD 1.0 §3.2.6): the type definition is
+          # or is derived from xs:ID. Declaration-scoped — fires on the
+          # element's type regardless of instance use (idZ011).
+          #
+          # @return [void]
+          def validate_id_value_constraints(schema_attrs, collector,
+                                            xml_element, repository)
+            schema_attrs.each do |schema_attr|
+              next if schema_attr.fixed.to_s.empty? &&
+                schema_attr.default.to_s.empty?
+              next unless id_typed_attribute?(schema_attr, repository)
+
+              report_error(
+                collector,
+                code: "id_value_constraint_violation",
+                message: "Attribute '#{schema_attr.name}' is typed " \
+                         "xs:ID (or derived from it) and cannot carry " \
+                         "a fixed or default value constraint",
+                location: xml_element.xpath,
+                context: { attribute: schema_attr.name },
+              )
+            end
+          end
+
+          # Whether the declaration's type is xs:ID or derives from it:
+          # a builtin-prefixed reference, or a restriction base chain
+          # (inline or named) whose terminal is xs:ID.
+          #
+          # @return [Boolean]
+          def id_typed_attribute?(schema_attr, repository)
+            return true if builtin_id_type?(schema_attr.type)
+
+            ref = schema_attr.ref.to_s
+            if ref.match?(/\S/) && repository
+              resolved = repository.resolve_attribute(ref.split(":").last,
+                                                      nil)
+              return true if resolved && builtin_id_type?(resolved.type)
+            end
+
+            named = schema_attr.type.to_s.split(":").last
+            chain = schema_attr.simple_type ||
+              (named && repository&.resolve_named_type(named))
+            id_derived_chain?(chain, repository, 0)
+          end
+
+          # @return [Boolean]
+          def builtin_id_type?(reference)
+            parts = reference.to_s.split(":")
+            %w[xs xsd].include?(parts.first) && parts.last == "ID"
+          end
+
+          # @param type [Lutaml::Xml::Schema::Xsd::SimpleType, nil]
+          # @return [Boolean]
+          def id_derived_chain?(type, repository, depth)
+            return false if depth > 6 || type.nil?
+
+            base = type.restriction&.base.to_s
+            return true if builtin_id_type?(base)
+            return false if base.empty?
+
+            id_derived_chain?(
+              repository&.resolve_named_type(base.split(":").last),
+              repository, depth + 1
+            )
+          end
+
           # Check if attribute is required
           #
           # @param schema_attr [Lutaml::Xsd::Attribute] Schema attribute

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.95"
+    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.95
+  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