lutaml-xsd 1.2.101 → 1.2.102

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6105bb86be0d4abbb820b3362454d8b05d2323366b35b6d1e6225feafc12dd57
-  data.tar.gz: 639b6495bc87a3d3b6a8ec3edac0dfc4457da4af3dba1bef20e4d2c464628c54
+  metadata.gz: c1b37fc4af01d8c2f652a899644d9f85f13fec225d6ae0ce393b7d16f19df5bc
+  data.tar.gz: 2b08927d906be739a784888c3e1d9c9fb5a303362cc6dcc565404e0500b4f74d
 SHA512:
-  metadata.gz: 7da7d36525dd07c46f9b81e9e1219f1faf5882c871cca810026b76b65f712cf8387e92ecee363a8f0a4ad23b75b42e7b5a1bcd41cf6a8b1c2793812b58dfaf1d
-  data.tar.gz: 6475b579cbaa25e35cfcdb497e60c501425337e65676406aec619fbc83a386fb66cf5f94b5e7c4d77a96e79b0ae13bd1818517ca2e10191ae9a31976b5f0fb44
+  metadata.gz: 95823a7f86274b2363e65b1a36d0b9aff1078c55196c8f53982d065ec67f0b32b60d1c18436ff8839f65f150373ffa822fa0c4cdaf046f042694ef94279fb0cc
+  data.tar.gz: f85b40f50b7ac8d93bfe7341feb8eaf4442ea4ac3b0fb9f3ea51cbb3f832835ac3f36033f9897e816371ba99ddf206f7c271a81389b3bf32370acc2104670968

data/TODO.conformance.md

@@ -520,6 +520,25 @@ 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).

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/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.101"
+    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.101
+  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