lutaml-xsd 1.2.99 → 1.2.100

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa20de2fba923a0b6485653e7902c20694898ac8583b90f5e144b11b7ae61fc4
-  data.tar.gz: ccd4a57412cd1095538a9a72988d9b792f8f3ae213d4c644a401391d32cafcbc
+  metadata.gz: 2fb04a8aef728bbfb826bd9e49561e8a2e4949a0a8da01afb5d3f0306b50a14e
+  data.tar.gz: 438fdfc6d197d4f1aa146232aa5a2d73c77f2181b0925c2d44328631876dd433
 SHA512:
-  metadata.gz: 421748a4d525018acc64f0a85f0d84b07320f456017bd06c481bb2cb0b97eeb8b394fbbed64a50f8c3e037277a627d8aa322aabbb2eb9983861f798c78126734
-  data.tar.gz: 63b4a57e42b8431ab7cec97f0fd015520c991c1ff8ab4017a7f4210f1d9b3f7f3480c8fca5e4c7ddc11079e818bfe4211030ef30cdeb4e6e04714468ca1015d7
+  metadata.gz: 2a7fb730886d8296d8c3daff45401f6b7b1dc817a5030ce1f9a5170914290cc95c6bc532eb6f42eecb9a85026686b0e5ecca47ca2f7d9b0f9b70ba68d5c71413
+  data.tar.gz: dbe58ef59e792eb32eb0b42f6db501a797cc8423fea41656d89e20ec7b79257e279832ad0ef4c2c5e1ede93f142b6e66fdd5fdf09599f5b55fafef6c11d588ce

data/TODO.conformance.md

@@ -522,6 +522,24 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   ~177 cases — the ENTIRE Unicode-block escape family (~80
   \p{Is...} per-block tests) plus the reL/reP/reQ/reR/reS/reT
   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(
@@ -1042,20 +1047,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 +1114,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 +1135,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 +1159,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 +1197,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 +1238,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 +1269,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/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.100"
   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.100
 platform: ruby
 authors:
 - Ribose Inc.