lutaml-xsd 1.2.100 → 1.2.102

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fb04a8aef728bbfb826bd9e49561e8a2e4949a0a8da01afb5d3f0306b50a14e
-  data.tar.gz: 438fdfc6d197d4f1aa146232aa5a2d73c77f2181b0925c2d44328631876dd433
+  metadata.gz: c1b37fc4af01d8c2f652a899644d9f85f13fec225d6ae0ce393b7d16f19df5bc
+  data.tar.gz: 2b08927d906be739a784888c3e1d9c9fb5a303362cc6dcc565404e0500b4f74d
 SHA512:
-  metadata.gz: 2a7fb730886d8296d8c3daff45401f6b7b1dc817a5030ce1f9a5170914290cc95c6bc532eb6f42eecb9a85026686b0e5ecca47ca2f7d9b0f9b70ba68d5c71413
-  data.tar.gz: dbe58ef59e792eb32eb0b42f6db501a797cc8423fea41656d89e20ec7b79257e279832ad0ef4c2c5e1ede93f142b6e66fdd5fdf09599f5b55fafef6c11d588ce
+  metadata.gz: 95823a7f86274b2363e65b1a36d0b9aff1078c55196c8f53982d065ec67f0b32b60d1c18436ff8839f65f150373ffa822fa0c4cdaf046f042694ef94279fb0cc
+  data.tar.gz: f85b40f50b7ac8d93bfe7341feb8eaf4442ea4ac3b0fb9f3ea51cbb3f832835ac3f36033f9897e816371ba99ddf206f7c271a81389b3bf32370acc2104670968

data/TODO.conformance.md

@@ -520,7 +520,47 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   stE legs, the #522 attgC four + attgD mostly + attJ018 +
   schF1/P2, stE065/066/096) AND a WHOLESALE 407 regex regression:
   ~177 cases — the ENTIRE Unicode-block escape family (~80
+- PARENT-CONTEXT ROUND A (2026-11-08): +1 Errata10 (errC007; suite
+  4628->4629 = 98.57%, zero regressions, rspec green). The
+  parent-context redesign opens with an ENGINE-LEVEL win: anyType
+  content is LAX — a child validates only against a declaration in
+  its OWN namespace, so a strictly-unresolvable child of an anyType
+  element (including one the namespace fallback would have served
+  from a targeted schema) is lax-undeclared and its subtree escapes
+  assessment (the suppression rides the existing skip-wildcard walk,
+  hereditary like QFE1700a1). The resolver gains resolve_strict
+  (exact-namespace only) and the shared anyType reference check.
+  errC007's contract is now enforced WITHOUT the namespace-fallback
+  narrowing that regressed five substitution/import shapes — those
+  lookups never touch this path. Round B (next): positional binding
+  for duplicate same-named particles (isDefault079) — ordered
+  per-call walk (the resolver's visited_particle? memoizes on the
+  instance and would poison repeats), gated on >1 same-named
+  particles AND all indexed (@namespaces.key? — the attempt-3
+  starvation guard).
+
   \p{Is...} per-block tests) plus the reL/reP/reQ/reR/reS/reT
+- ANYSIMPLETYPE-WHITESPACE ROUND (2026-11-07): +1 Additional
+  (test93160; suite 4627->4628 = 98.55%, pending measure confirm).
+  xs:anySimpleType's whiteSpace is PRESERVE — the ur-simple type
+  canonicalizes nothing — but the fixed-compare whitespace rule fell
+  through to collapse, so whitespace-padded text equaled the fixed
+  value. The element- and attribute-side whitespace maps now send
+  anySimpleType to preserve; the fixed compare is a RAW-LEXICAL
+  compare (xmllint: the padded actual does not match the fixed).
+  PARKED same-day classifications (the per-position binding wall —
+  the parent-context redesign charter): isDefault079 (two same-named
+  locals with DIFFERENT fixed values — the second child binds to the
+  second particle; we mis-bind to the first; xmllint validates),
+  QFE1700c1 (skip-suppression must follow the matcher's DETERMINISTIC
+  assignment — the ref particle takes its e2 and validates its
+  content, not the skip-wildcard hereditary escape), addB065
+  (xsi:nil=true on non-nillable silent), addB188 (xsi:type-assessed
+  undeclared root skips the attribute check). errC007's namespace
+  fallback narrowing REVERTED after 5 regressions (addB132/ctZ007/
+  elemZ021b/f/elemZ023 lean on the lenient fallback for
+  substitution/import shapes) — parked with the same charter.
+
   series — filed leptris-rs#47; moxml 0.6.3 regressed 5 attribute
 - WILDCARD-LAYERING ROUND (2026-11-07): +3 Wildcards (wildZ013b/c
   valid, wildZ013e invalid; suite 4624->4627 = 98.57%, zero

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

@@ -58,7 +58,8 @@ module Lutaml
             # empty xs:int child escapes assessment too).
             next true if subtree_suppressed
 
-            skip_here = skip_wildcard_subtree?(parent, xml_element, resolver)
+            skip_here = skip_wildcard_subtree?(parent, xml_element, resolver) ||
+              lax_any_type_child?(parent, xml_element, resolver)
             next true if skip_here
 
             schema_def = resolver.resolve(
@@ -223,6 +224,40 @@ module Lutaml
           end
         end
 
+        # A child of an ANYTYPE element validates only against a
+        # declaration in its OWN namespace (anyType content is lax —
+        # errC007's contract); a child with no exact-namespace
+        # declaration is lax-undeclared and its subtree escapes
+        # assessment. The namespace fallback never serves this
+        # decision: a targeted schema's global is a DIFFERENT element
+        # than the unqualified child.
+        #
+        # @return [Boolean]
+        def lax_any_type_child?(parent, child, resolver)
+          return false unless parent
+
+          declaration = resolver.resolve(parent.name, parent.namespace_uri)
+          return false unless any_type_declaration?(declaration, resolver)
+
+          resolver.resolve_strict(child.name, child.namespace_uri).nil?
+        end
+
+        # Whether the declaration's effective type is xs:anyType:
+        # declared by reference, or the implicit default for a typeless
+        # declaration.
+        #
+        # @return [Boolean]
+        def any_type_declaration?(declaration, resolver)
+          return false unless
+            declaration.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+
+          return true if resolver.builtin_any_type?(declaration.type.to_s)
+
+          declaration.type.to_s.empty? &&
+            declaration.complex_type.nil? &&
+            declaration.simple_type.nil?
+        end
+
         # Handle errors that occur during rule execution
         #
         # @param rule [ValidationRule] The rule that failed

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

@@ -653,7 +653,9 @@ module Lutaml
             return :preserve unless builtin_type_name?(reference)
 
             local = reference.split(":").last
-            return :preserve if local == "string"
+            # anySimpleType's whiteSpace is PRESERVE — the ur-simple
+            # type canonicalizes nothing.
+            return :preserve if ["string", "anySimpleType"].include?(local)
             return :replace if local == "normalizedString"
 
             :collapse

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

@@ -488,7 +488,10 @@ module Lutaml
               end
 
             case local
-            when "string"
+            when "string", "anySimpleType"
+              # anySimpleType's whiteSpace is PRESERVE (the ur-simple
+              # type canonicalizes nothing) — a fixed compare against
+              # it compares the raw lexical (test93160).
               :preserve
             when "normalizedString"
               :replace

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

@@ -159,10 +159,14 @@ module Lutaml
           @expected_namespaces[element]
         end
 
+        # The namespace-EXACT resolution — no unique-name fallback. The
+        # lax anyType-content decision (errC007) and other
+        # namespace-strict consumers use it.
+        #
         # @param name [String] local element name
         # @param namespace_uri [String, nil] instance element namespace
         # @return [Lutaml::Xml::Schema::Xsd::Element, nil]
-        def resolve(name, namespace_uri)
+        def resolve_strict(name, namespace_uri)
           return nil if name.nil? || name.empty?
 
           candidates = @elements[name]
@@ -171,13 +175,33 @@ module Lutaml
           exact = candidates.find do |_element, namespace, _kind|
             namespace_matches?(namespace, namespace_uri)
           end
-          return exact&.first if exact
+          exact&.first
+        end
+
+        # Whether the type reference names xs:anyType.
+        #
+        # @param reference [String]
+        # @return [Boolean]
+        def builtin_any_type?(reference)
+          parts = reference.to_s.split(":")
+          %w[xs xsd].include?(parts.first) && parts.last == "anyType"
+        end
+
+        # @param name [String] local element name
+        # @param namespace_uri [String, nil] instance element namespace
+        # @return [Lutaml::Xml::Schema::Xsd::Element, nil]
+        def resolve(name, namespace_uri)
+          exact = resolve_strict(name, namespace_uri)
+          return exact if exact
 
           # Unique-name fallback for instances that omit namespaces even
           # though the schema declares one. A foreign namespace never
           # falls back.
           return nil unless namespace_uri.to_s.empty?
 
+          candidates = @elements[name]
+          return nil if candidates.empty?
+
           candidates.length == 1 ? candidates.first.first : nil
         end
 

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.100"
+    VERSION = "1.2.102"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.2.100
+  version: 1.2.102
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-07 00:00:00.000000000 Z
+date: 2026-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid