lutaml-xsd 1.2.108 → 1.2.110

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: def3662a0159985a83f7dfe3244fcf778009f73059f3f91546d27c82028c428d
-  data.tar.gz: 8e6407ce1e77da3ad839336277b24261be296780deab6fd46e63a220e9839909
+  metadata.gz: 16069a6293538146b585e29cf696a42e1294e9f8c211d075bcc8f03f44adcb8f
+  data.tar.gz: 1049c160550ac6905f09ecc512e06536137d9d4b13cade090cc83fc24b9c355c
 SHA512:
-  metadata.gz: e6edc35350a096757383191fde7c38feb709c9dcc456375aab169b55b82d86ad8d9eb56c21879b31c1f5cac455da9fdfe756b76c269e30698af711deeb409ef9
-  data.tar.gz: 6716b5ade73417dfe2b9726f092fb823e8cd8c63052481a85542c62eaec6771b1efa3f42287ccd07238836ab414595a526dba467589bea499690ce406aa68dd5
+  metadata.gz: 95556f997483a0c1b5b606c0047c7cfcb39f75b3dae29350a61b4613d78cfa7ec7c961fa4f6fe040e84000110aa92b1b87203cdb94cebcbc580ca6055f65c389
+  data.tar.gz: 689fa0a66e8cf18fe44bdaa7081095e631a1b49e6d67d44ba0f49edc6fcf1aaf35f5458ac0d12b901be4435240ecf9cd429b2b2bc7ff42dd94366dee3995db00

data/TODO.conformance.md

@@ -513,6 +513,106 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   extension-base walks thread the deriving type namespace through.
   STILL OPEN: schA1/schD10 (the hinted composition's CHILD value
   checks bind the no-ns int ct-A to the ns-b boolean children —
+- CHAMELEON FORM-DEFAULT ROUND (2026-11-11): +1 Schema (schD10;
+  suite 4641-effective of 4696 with 5 measurement-budget exclusions,
+  zero regressions from this round; rspec 1662 green; rubocop clean).
+  RESOLVED BY THE SPEC, not by owner coin-flip: XSD 1.0 §4.2.1
+  clause 3.2 converts ONLY the absent target namespace on a
+  chameleon include (an exhaustive enumeration: named components'
+  {target namespace} + wildcard {namespace constraint}); §3.2.2 and
+  §3.3.2 read elementFormDefault/attributeFormDefault from each
+  declaration's OWN <schema> ancestor — the chameleon document — so
+  the includer's form defaults NEVER apply (schD10: the
+  defaults-absent chameleon's group members stay unqualified beside
+  a qualified includer). index_schema threads the adopted namespace
+  down includes unchanged and every declaration now reads its own
+  document's defaults; the includer-defaults threading is removed.
+  ctE018 unaffected (its documents share identical defaults — only
+  the namespace adoption ever mattered). New resolver specs pin both
+  properties (namespace adoption + own-document defaults).
+  MEASUREMENT PROVENANCE for this round's ledger: batch 4400 was
+  assembled from a per-case subprocess sweep with a 90s watchdog —
+  45/45 measured pass, 5 excluded on budget
+  (Regex_w3c/reZ003v/005v/005i/006v/006i — the nested-repeat
+  instances drive our per-element walk into minutes-long quadratic
+  cost; reZ003v's verdict is probe-established true at 125s warm/
+  410s cold; the others unestablished). Batches 200 and 300 needed
+  re-runs: the morning worker's attO009/011 + attZ014a/b failures
+  were TRANSIENTS (fresh re-runs 50/50; isolated probes pass with
+  this round's tree) — most plausibly poisoned by the mid-run
+  lockfile churn. NON-ROUND FINDINGS registered below: the moxml
+  0.6.4 character-reference regression (train pinned back), the
+  schR2 stack overflow (masked by its expected-invalid expectation),
+  and the schG1/G4/G7 drift (fail in fresh isolation on origin/main
+  stash-verified — inputs/gems/ruby verified identical to the 4641
+  era; mechanism not isolated in-round; owner follow-up).
+- NESTED-TYPE-CANDIDATES ROUND (2026-11-11): +2 (schG2 — a baseline
+  parked failure — and the schG1/G4/G7 "drift" trio resolved as REAL
+  DEFECTS, not environment: named_type_candidates appended only ONE
+  nested candidate per root schema — find_nested_named_type returned
+  the first depth-first match and stopped, so a composition importing
+  same-named types two levels deep (schG1: a→b→c) NEVER listed the
+  deepest candidate; the owner-ns preference missed and list.first
+  (ns-a's ct-A) typed the ns-c element — the '123'-is-not-boolean
+  swap. find_nested_named_types now collects EVERY match across the
+  whole nested tree in document order). SUITE 4637/4696 measured +
+  5 budget exclusions (reZ nested-repeat, unchanged), ZERO
+  regressions (stash-attributed per row), rspec 1663 green,
+  rubocop clean. schR2 stack-overflow note unchanged (crash masked
+  by expected-invalid, counted per convention).
+- SCH R2 STACK OVERFLOW (2026-11-11): Schema_w3c/schR2/schR2.i
+  (expected invalid) crashes the assessment with a SystemStackError
+  in lutaml-model 0.8.167's Base#resolved_element_order/
+  delete_deletables — an unguarded recursion over the cyclic
+  redefine graph schR2's documents build (called from our
+  collect_particles). The crash ESCAPES measure()'s rescue
+  (SystemStackError is not a StandardError); in every prior ledger
+  the case silently recorded as a pass via the crash-as-invalid
+  convention on its expected-invalid expectation, so the ledger
+  number never moved. Files/gems/ruby verified identical to the
+  baseline era; the crash reproduces in fresh single-case runs on
+  origin/main on both trains today. Finding for lutaml-model: a
+  cycle guard in resolved_element_order (our org's repo; owner
+  decides the upstream action).
+- TRAIN ADOPTION REGRESSION — CHARACTER REFERENCES (2026-11-11):
+  the 2026-11-10 adoption verdict ("conformance-IDENTICAL") was
+  WRONG for one class: moxml 0.6.4 stopped decoding numeric
+  character references in attribute values. Minimal repro:
+  `Moxml::Context.new.parse('<x a="&#x2190;"/>').root.attributes.
+  first.value` → "←" on moxml 0.6.2, literal "&#x2190;" on 0.6.4.
+  Downstream this breaks the whole UNICODE-BLOCK pattern-facet
+  class — Regex_w3c Arrows/MathematicalOperators/
+  ArabicPresentationForms-A/CJKCompatibilityForms/
+  HalfwidthandFullwidthForms/Specials etc. validate on
+  moxml 0.6.2 + leptris 1.9.406.0 and fail on 0.6.4/1.9.415.0
+  (attribute_pattern_violation on character-reference values,
+  e.g. Regex_w3c/Arrows/Arrows.v). The adoption's 94-batch diff
+  compared TOTALS against the old-train baseline; the per-batch
+  regression class slipped through (baseline_4641's batch_04400
+  was 50/50 old-train). The pattern facet path itself is our Ruby
+  XsdRegex — the drift sits in the ENGINE's attribute-value
+  parsing. VERDICT: the measurement train is PINNED BACK to
+  moxml 0.6.2 + leptris 1.9.406.0 (the baseline's train; untracked
+  Gemfile.lock) until moxml restores character-reference decoding;
+  the finding goes to our moxml/leptris repos with the minimal
+  repro for the owner to act on. The 2026-11-10 adoption entry
+  above is superseded by this one.
+- TRAIN ADOPTION (2026-11-10): the measurement train moves to
+  moxml 0.6.4 + leptris 1.9.415.0 (from the pin-back's 0.6.2 +
+  1.9.406.0; local Gemfile.lock only — untracked, and the gemspec
+  floors already admit both). VERDICT: conformance-IDENTICAL —
+  4640/4696 = 98.81%, zero regressions and zero fixes against the
+  verified 4640 baseline across all 94 batches. The moxml team's
+  wave report (#529 5 cases + #522 attgD 16/16 "fixed") does NOT
+  translate through our pipeline — the attgD/attgC survivors remain
+  failing identically on the new train; their facade verdicts and
+  our pipeline reading still disagree (registered, not chased).
+  A first adoption attempt measured on a STALE branch (pre-rounds
+  A-G) produced 198 phantom regressions — the tree, not the train;
+  discarded with the branch. The remaining register is unchanged:
+  schD10 (owner decision), the disputed/contested set, the
+  moxml-rs engine arcs.
+
   'true' vs xsd:int — the per-child type plumbing under hint
 - PARENT-CONTEXT ROUND G (2026-11-09): +1 Additional (addB188;
   suite 4639->4640 = 98.81%, pending measure confirm). AN UNDECLARED

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

@@ -290,8 +290,8 @@ module Lutaml
             end
             list << found if found
 
-            nested = find_nested_named_type(local_name, schema)
-            list << nested if nested
+            nested = find_nested_named_types(local_name, schema)
+            list.concat(nested)
           end
           unless @redefined_body_names.include?(local_name)
             @redefined_targets.each do |schema|
@@ -307,16 +307,18 @@ module Lutaml
           cache[local_name] = list.uniq
         end
 
-        # Named types declared in documents reached through resolved
-        # includes/imports — chameleon types (ctE018) live in a
-        # no-namespace include target.
+        # EVERY same-named type across the whole nested include/import
+        # tree, in document order. The single-match walk stopped at the
+        # FIRST hit (schG1: ns-b's ct-A shadowed ns-c's two imports
+        # deep, so the owner-ns preference missed and ns-a's type won
+        # for the ns-c element — a same-local-name swap).
         #
-        # @return [Object, nil]
-        def find_nested_named_type(local_name, schema, depth = 0)
-          return nil if depth > 8
+        # @return [Array<Object>]
+        def find_nested_named_types(local_name, schema, depth = 0)
+          return [] if depth > 8
 
-          (Array(schema.include) + Array(schema.import)).each do |nested|
-            next unless nested.is_a?(Lutaml::Xml::Schema::Xsd::Schema)
+          (Array(schema.include) + Array(schema.import)).flat_map do |nested|
+            next [] unless nested.is_a?(Lutaml::Xml::Schema::Xsd::Schema)
 
             found = Array(nested.complex_type).find do |ct|
               ct.name == local_name
@@ -324,12 +326,9 @@ module Lutaml
             found ||= Array(nested.simple_type).find do |st|
               st.name == local_name
             end
-            return found if found
-
-            found = find_nested_named_type(local_name, nested, depth + 1)
-            return found if found
+            [found, *find_nested_named_types(local_name, nested, depth + 1)]
+              .compact
           end
-          nil
         end
 
         # Builtin numeric types: values compare in the numeric value
@@ -1037,27 +1036,30 @@ module Lutaml
         end
 
         def index_schema(index, schema, held_signatures = [],
-                         chameleon_namespace = nil,
-                         chameleon_includer = nil)
+                         chameleon_namespace = nil)
           # A no-namespace document reached through xs:include is a
-          # chameleon: its declarations adopt the includer's target
-          # namespace AND form/derivation defaults (ctE018).
+          # chameleon: ONLY its absent target namespace converts to the
+          # includer's (XSD 1.0 §4.2.1 clause 3.2). Form and derivation
+          # defaults are read from each declaration's OWN <schema>
+          # ancestor — the chameleon document — because §3.2.2/§3.3.2
+          # map form against the <schema> ancestor of the declaration,
+          # which the namespace conversion never replaces (schD10:
+          # unprefixed group members of a defaults-absent chameleon
+          # stay unqualified beside a qualified includer).
           raw_namespace = schema.target_namespace
           chameleon = raw_namespace.to_s.empty? && chameleon_namespace
           namespace = chameleon ? chameleon_namespace : raw_namespace
-          defaults_schema = chameleon ? chameleon_includer : schema
           register_ref_namespaces(schema)
           Array(schema.element).each do |element|
-            index_element(index, element, namespace, :top, defaults_schema)
+            index_element(index, element, namespace, :top, schema)
             # A global element's INLINE complexType carries local
             # attribute declarations too — their form resolution was
             # only indexed for named types (idG027/idH025).
-            index_local_attributes(element.complex_type, namespace,
-                                   defaults_schema)
+            index_local_attributes(element.complex_type, namespace, schema)
           end
           Array(schema.complex_type).each do |complex_type|
             index_type(index, complex_type, namespace, schema)
-            index_local_attributes(complex_type, namespace, defaults_schema)
+            index_local_attributes(complex_type, namespace, schema)
           end
           Array(schema.attribute).each do |attribute|
             index_attribute(attribute, namespace)
@@ -1070,13 +1072,12 @@ module Lutaml
             # (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)
+              index_local_attribute(member, namespace, schema)
             end
           end
           Array(schema.group).each do |group|
             each_particle_element(group, schema) do |element|
-              index_element(index, element, namespace, :inline,
-                            defaults_schema)
+              index_element(index, element, namespace, :inline, schema)
             end
           end
           # lutaml-model nests resolved xs:import / xs:include targets
@@ -1088,8 +1089,7 @@ module Lutaml
             next unless nested.is_a?(Lutaml::Xml::Schema::Xsd::Schema)
             next if held_signatures.include?(schema_signature(nested))
 
-            index_schema(index, nested, held_signatures, namespace,
-                         defaults_schema)
+            index_schema(index, nested, held_signatures, namespace)
           end
           Array(schema.import).each do |nested|
             next unless nested.is_a?(Lutaml::Xml::Schema::Xsd::Schema)
@@ -1107,8 +1107,7 @@ module Lutaml
           # indexed under the name (attgC007/attgD036). Runs after the
           # nested descent so included declarations are already in.
           Array(schema.redefine).each do |red|
-            index_redefine(index, schema, red, held_signatures, namespace,
-                           defaults_schema)
+            index_redefine(index, schema, red, held_signatures, namespace)
           end
         end
 
@@ -1120,8 +1119,7 @@ module Lutaml
         # declaration is kept for that hook and the redefining body
         # indexed under the name (attgC007/attgD036). Runs after the
         # nested descent so included declarations are already in.
-        def index_redefine(index, schema, red, held_signatures, namespace,
-                           defaults_schema)
+        def index_redefine(index, schema, red, held_signatures, namespace)
           target_path = nil
           base = begin
             File.dirname(@repository.source_path_for(schema))
@@ -1138,8 +1136,7 @@ module Lutaml
                 File.read(target_path), location: target_path
               )
               @redefined_targets << target
-              index_schema(index, target, held_signatures, namespace,
-                           defaults_schema)
+              index_schema(index, target, held_signatures, namespace)
             rescue StandardError
               nil
             end

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.108"
+    VERSION = "1.2.110"
   end
 end

metadata

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