lutaml-xsd 1.2.99 → 1.2.101

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa20de2fba923a0b6485653e7902c20694898ac8583b90f5e144b11b7ae61fc4
-  data.tar.gz: ccd4a57412cd1095538a9a72988d9b792f8f3ae213d4c644a401391d32cafcbc
+  metadata.gz: 6105bb86be0d4abbb820b3362454d8b05d2323366b35b6d1e6225feafc12dd57
+  data.tar.gz: 639b6495bc87a3d3b6a8ec3edac0dfc4457da4af3dba1bef20e4d2c464628c54
 SHA512:
-  metadata.gz: 421748a4d525018acc64f0a85f0d84b07320f456017bd06c481bb2cb0b97eeb8b394fbbed64a50f8c3e037277a627d8aa322aabbb2eb9983861f798c78126734
-  data.tar.gz: 63b4a57e42b8431ab7cec97f0fd015520c991c1ff8ab4017a7f4210f1d9b3f7f3480c8fca5e4c7ddc11079e818bfe4211030ef30cdeb4e6e04714468ca1015d7
+  metadata.gz: 7da7d36525dd07c46f9b81e9e1219f1faf5882c871cca810026b76b65f712cf8387e92ecee363a8f0a4ad23b75b42e7b5a1bcd41cf6a8b1c2793812b58dfaf1d
+  data.tar.gz: 6475b579cbaa25e35cfcdb497e60c501425337e65676406aec619fbc83a386fb66cf5f94b5e7c4d77a96e79b0ae13bd1818517ca2e10191ae9a31976b5f0fb44

data/TODO.conformance.md

@@ -521,7 +521,46 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   schF1/P2, stE065/066/096) AND a WHOLESALE 407 regex regression:
   ~177 cases — the ENTIRE Unicode-block escape family (~80
   \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
+  regressions, rspec green). THREE defects: (1) attributeGroup refs
+  nested in content parts never contributed their anyAttribute
+  wildcards (wildZ013b — the extension's attG2-51 ref); (2) the
+  derivation wildcard list admitted with plain UNION semantics where
+  same-type wildcards must INTERSECT (wildZ013e: intersection1's
+  ##other + ##local b c give set(b, c) — absent-ns attributes fail
+  ##other) — collect_any_attribute now returns one GROUP per
+  derivation layer: groups union (the extension union, ctH011
+  unchanged), members intersect; (3) the chameleon import's ##other
+  evaluated against the INCLUDER's target namespace — the
+  per-wildcard owner tns (indexed for attributeGroup declarations
+  and redefine bodies now) evaluates a chameleon's ##other against
+  its own ABSENT target (wildZ013c's ##local b c + ##other(not-
+  absent) admit everything the instance carries). Family: Wildcards
+  + Attribute clean; AttributeGroup 14 = the parked moxml#522 set.
+
   cases (addB059/196c/197c, attO009/011) — filed moxml#529. THE
 - REDEFINE-GROUP ROUND (2026-11-07): +2 ModelGroups (mgO006,
   mgO034; suite 4622->4624 = 98.46%, zero regressions, rspec

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

@@ -538,9 +538,14 @@ module Lutaml
 
               xml_attr = xml_attrs.find { |xa| xa.name == attr_name }
               next unless xml_attr
-              next if wildcards.any? do |wildcard|
-                wildcard_permits_attribute?(wildcard, xml_element, xml_attr,
-                                            nil)
+              # A wildcard that admits the attribute shadows the
+              # prohibition (attZ002): any group admitting (union
+              # across layers, intersection within).
+              next if wildcards.any? do |group|
+                group.all? do |wildcard|
+                  wildcard_permits_attribute?(wildcard, xml_element,
+                                              xml_attr, nil)
+                end
               end
 
               report_error(
@@ -648,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
@@ -1042,20 +1049,23 @@ module Lutaml
               next if xml_attr.namespace_uri == XmlBuiltins::NAMESPACE &&
                 XmlBuiltins.attribute(xml_attr.name)
 
-              # The derivation's wildcard UNION admits: any permitting
-              # wildcard covers the attribute, and a strict mode on any
-              # admitting wildcard still demands a declaration in the
-              # attribute's own namespace.
+              # The derivation's wildcard GROUPS admit: ACROSS groups
+              # (derivation layers) any group admits the attribute — the
+              # extension union; WITHIN a group every wildcard must
+              # admit — same-type wildcards intersect (wildZ013b/c/e).
               admitted = false
               strict_undeclared = false
-              wildcards.each do |wildcard|
-                next unless wildcard_permits_attribute?(wildcard,
-                                                        xml_element,
-                                                        xml_attr, repository)
+              wildcards.each do |group|
+                next unless group.all? do |wildcard|
+                  wildcard_permits_attribute?(wildcard, xml_element,
+                                              xml_attr, repository)
+                end
 
                 admitted = true
-                if wildcard_process_mode(wildcard) == "strict" &&
+                group.each do |wildcard|
+                  next unless wildcard_process_mode(wildcard) == "strict" &&
                     !attribute_declared?(xml_attr, repository)
+
                   strict_undeclared = true
                 end
               end
@@ -1106,7 +1116,12 @@ module Lutaml
           # UNION — a base type's wildcard stays in force beside the
           # extension's own (ctH011: ##local base + ##other extension).
           #
-          # @return [Array<AnyAttribute>]
+          # @return [Array<Array<AnyAttribute>>] wildcard GROUPS: one
+          #   group per derivation layer (the base's groups stay beside
+          #   the derived layer — the extension union, wildZ013b/c);
+          #   wildcards INSIDE one group are same-type and intersect
+          #   (wildZ013e: intersection1's two attributeGroup refs give
+          #   set(b, c), rejecting what ##other alone would admit).
           def collect_any_attribute(schema_def, repository = nil,
                                     xml_element = nil)
             if schema_def.is_a?(Lutaml::Xml::Schema::Xsd::Element)
@@ -1122,21 +1137,21 @@ module Lutaml
             end
             return [] unless schema_def
 
-            wildcards = []
+            own = []
             complex_wildcard = schema_def.any_attribute if
               schema_def.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType) &&
                 complex_type_wildcard_support?
-            wildcards << complex_wildcard if complex_wildcard
+            own << complex_wildcard if complex_wildcard
 
             # A wildcard nested in an attributeGroup DECLARATION reaches
             # the type only through the group's resolution — the type's
             # ref particle carries no children of its own (attgD019).
             Array(schema_def.attribute_group).each do |group|
               Array(group.any_attribute).each do |wildcard|
-                wildcards << wildcard
+                own << wildcard
               end
 
-              collect_group_wildcards(group, repository, wildcards, 0)
+              collect_group_wildcards(group, repository, own, 0)
             end
 
             CONTENT_KINDS.each do |content_kind|
@@ -1146,22 +1161,31 @@ module Lutaml
               CONTENT_PART_KINDS.each do |part_kind|
                 Array(content.public_send(part_kind)).each do |part|
                   Array(part.any_attribute).each do |wildcard|
-                    wildcards << wildcard
+                    own << wildcard
+                  end
+                  # An attributeGroup REF inside the derivation body
+                  # carries the wildcard the type presents (wildZ013b:
+                  # the extension's attG2-51 ref).
+                  Array(part.attribute_group).each do |group_ref|
+                    collect_group_wildcards(group_ref, repository, own, 0)
                   end
                 end
               end
             end
 
             # The base type's wildcard flows into the derived type
-            # through extension and restriction alike.
+            # through extension and restriction alike — as its own
+            # layer beside the derived one.
             base = derivation_base(schema_def, repository)
-            wildcards.concat(collect_any_attribute(base, repository)) if base
-
-            wildcards
+            groups = base ? collect_any_attribute(base, repository) : []
+            groups.unshift(own) unless own.empty?
+            groups
           end
 
           # The wildcards of an attributeGroup reference's DECLARATION,
-          # following nested attributeGroup refs (depth-guarded).
+          # following nested attributeGroup refs (depth-guarded). Each
+          # wildcard records its declaring group's effective target
+          # namespace for the ##other evaluation.
           #
           # @return [void]
           def collect_group_wildcards(group, repository, wildcards, depth)
@@ -1175,6 +1199,8 @@ module Lutaml
 
             Array(declaration.any_attribute).each do |wildcard|
               wildcards << wildcard
+              wildcard_owner_tns[wildcard] =
+                repository&.target_namespace_for(declaration)
             end
 
             Array(declaration.attribute_group).each do |nested|
@@ -1214,7 +1240,15 @@ module Lutaml
           def wildcard_permits_attribute?(wildcard, parent, xml_attr,
                                           repository)
             ns = xml_attr.namespace_uri.to_s
-            target = content_target_namespace(parent, repository).to_s
+            # The WILDCARD's own declaration namespace — a chameleon
+            # document's ##other evaluates against its own (absent)
+            # target, not the includer's (wildZ013c).
+            target =
+              if wildcard_owner_tns.key?(wildcard)
+                wildcard_owner_tns[wildcard].to_s
+              else
+                content_target_namespace(parent, repository).to_s
+              end
             case wildcard.namespace.to_s
             when "##any", ""
               true
@@ -1237,6 +1271,16 @@ module Lutaml
             end
           end
 
+          # The effective target namespace of each collected wildcard's
+          # DECLARING attributeGroup (identity-keyed — equal-valued
+          # wildcards eql? together). Untracked wildcards fall back to
+          # the element declaration's namespace.
+          #
+          # @return [Hash]
+          def wildcard_owner_tns
+            @wildcard_owner_tns ||= {}.compare_by_identity
+          end
+
           # Whether a strict-wildcard attribute resolves to a global
           # declaration in the attribute's OWN namespace — the
           # unique-name fallback may not answer for a different

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

@@ -951,6 +951,10 @@ module Lutaml
           Array(schema.attribute_group).each do |group|
             name = group.name.to_s
             @attribute_groups[name] = group unless name.empty?
+            # The group's own effective target namespace — a chameleon
+            # document's wildcards evaluate against the includer's
+            # (wildZ013c), a named document's against its own.
+            @namespaces[group] = namespace unless name.empty?
             Array(group.attribute).each do |member|
               index_local_attribute(member, namespace, defaults_schema)
             end
@@ -1049,6 +1053,7 @@ module Lutaml
             original = @attribute_groups[name]
             @redefined_originals[name] = original if original
             @attribute_groups[name] = group
+            @namespaces[group] = namespace
           end
           Array(red.group).each do |group|
             name = group.name.to_s

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.99"
+    VERSION = "1.2.101"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.2.99
+  version: 1.2.101
 platform: ruby
 authors:
 - Ribose Inc.