lutaml-xsd 1.2.79 → 1.2.80

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc71d86940b282e842650b924ddfbef4c92dbb7d39645dec6e57cf80c5edbd81
-  data.tar.gz: e7643e86eb653d99ac2a72c39792b828994c1203a0fbbc89042856456ba59855
+  metadata.gz: 0aed69846e615ba0095fd9030ca3c7d870fe590c855694797393e669a57085ec
+  data.tar.gz: abcb15e8a7482e4589d08bbb886529f6aff6462db5c56e4626c9610dcb25777f
 SHA512:
-  metadata.gz: 65b97ebeb74d183e3347e801b4d67fc183dec70698e501dd60fffcedcafbcc9a33f97d830aab3449a9ab72c8ca5ab0699aa41a5aafbbbd731512134408afcade
-  data.tar.gz: a4ae99c07f652e26102f6bae1f6a3d1c241d032436e2c424f4e03f06921b6feb0ef46798febf19598ec005fbbf6757829638c543e557ab399e6c2ffb785264b2
+  metadata.gz: 928180700fa58c7965b7f57729b681a1580f18c5da136c6b7729a013426ca5bfeaad44b686ce0e28c2eb1247dd3e73ca1a1e34c81b61c37030165bf4f297ae62
+  data.tar.gz: 50441ce2cda522fed7e3df0acd8843ef3824a72b685bf663e21ade1d9c5a2366fbb2af244b4f83d839dbdb4e2c41faf3cf1eb14f3376bef8c0ef15f03de9fb98

data/TODO.conformance.md

@@ -120,22 +120,29 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4569/4696 (97.3%) |
+| pipeline | 4563/4696 (97.17%) |
 
-(2026-11-02, bundled-stack measurement on main with the escape,
+(2026-11-02, bundled-stack measurement with the escape,
 hint-following, pattern-alternative, identity-crash, engine-set,
 engine-refresh, IC value-space, IC field-resolution, facade-silence,
 regex-semantics, redefine-refresh, gmonth-refresh, digit-vintage,
-stgh-refresh, group-ref, attribute-group-redefine and
-notation-length rounds; moxml
-0.6.1 (gemspec floor `~> 0.6.0` per the owner — the 0.6 line drops
-the Opal surface; measured conformance-neutral), lutaml-model
-0.8.155, engine leptris 1.9.401.0.) Same-stack comparison: 1.2.43
+stgh-refresh, group-ref, attribute-group-redefine,
+notation-length and ref-namespace rounds; moxml
+0.6.2 (gemspec floor `~> 0.6.0` per the owner — the 0.6 line drops
+the Opal surface), lutaml-model
+0.8.157 (gemspec floor `~> 0.8.156` per the owner; the lockfile is
+no longer committed — measurements resolve fresh), engine leptris
+1.9.402.0. The 1.9.402/0.6.2/0.8.157 ride costs 8 net: engine
+fixed+EMPTY content regressions (9 cases, filed leptris-rs#25 —
+empty content satisfies the fixed facet per §3.12.2/§4.3.1.2),
+reU6 we-accept, MINUS two drift fixes (RegexTest_234, stE063).)
+Same-stack comparison: 1.2.43
 baseline 3961 (84.3%) → 4039 (86.0%) → 4090 (87.1%) → 4360 (92.8%,
 lockfile refresh) → 4411 (93.9%) → 4430 (94.3%) → 4435 (94.4%) →
 4436 (94.5%) → 4439 (94.5%) → 4454 (94.9%) → 4495 (95.7%) → 4524
 (96.3%) → 4534 (96.6%) → 4540 (96.7%) → 4542 (96.7%) → 4546 (96.8%)
-→ 4557 (97.0%) → 4565 (97.2%) → 4569 (97.3%), +608 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
+→ 4557 (97.0%) → 4565 (97.2%) → 4569 (97.3%) → 4562 (drift raw) →
+4563 (97.17%, ref-namespace round), +602 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
 \w/\W/\s to their XSD value spaces) collapses Regex 120→69;
 same-step pattern facets now behave as alternatives and
 whitespace-only text reaches the facets intact (PR #200), Regex
@@ -230,6 +237,8 @@ corners.
 | Built-in lexical tables reject valid forms (char-reference shapes; gMonth FIXED 1.9.398, \d legacy-Nd FIXED 1.9.399, stG/stH list lexicals FIXED 1.9.400/401) | ~5 | leptris#1936 |
 | Automaton size cap surfaces as an instance error instead of engine-inert silence | 0 — FIXED in leptris 1.9.398 | moxml#514 (follow-up to #473) |
 | Regex dialect remainder (engine `\d` vintage, `\p{Is...}` blocks, char-reference shapes) | ~30 | engine-side of leptris#1936 |
+| Empty content against a fixed element value rejected (1.9.402.0 regression — isDefault001/002/076, ctZ013a, elemQ019, stE065/066/096, particlesZ040) | 9 | leptris-rs#25 |
+| Unresolvable include/import/redefine schemaLocation raises at parse instead of warning (anyURI_a001/a002, schD7, schG8) | 4 | lutaml-model#1087 |
 | Strict wildcard/attribute admission on further compositions | ~5 | moxml#510 thread |
 | Ruby-side under-detections (Group 16, DataTypes 7, IC 6, Attribute 5, Additional 4, Particles 4, SimpleType 4, Element 1, Wildcards 1 — minus what the regex round banked) | ~60 | OURS — the remaining Ruby work queue |
 
@@ -388,6 +397,31 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   duration/dateTime/gMonthDay/gYear corners (engine-bound and
   contested-highlight), gMonth_pattern001 (bugzilla 6901 — do not
   chase), double018 (disputed reading).
+- REF-NAMESPACE ROUND (2026-11-02): +2 Particles (13→11, particlesDb001/
+  Db006). A ref particle names a declaration in ONE namespace, but the
+  match path resolved it against the CHILD's namespace first — a global
+  declaration duplicated across an imported namespace satisfied the ref
+  and foreign substitutes were accepted. The ref branch now prefers the
+  declaration in the content-model OWNER schema's target namespace
+  (threaded through the match chain), then the child's, then the
+  unique-name fallback; parsed particles carry no prefix map
+  (lutaml-model discards xmlns), so the owner namespace is the
+  strongest signal available. The engine — fed documents one at a
+  time — admits the substitute, so a targeted scan on the engine-accept
+  path reports the foreign child (scan_cross_namespace_refs). NIL
+  owner namespace means UNKNOWN, not "no namespace": resolve(local,
+  nil) only matches no-namespace declarations and a hint-loaded
+  document can supply a foreign namesake (idH021 regression caught
+  and fixed in-round). Zero regressions on the drifted stack.
+- STACK DRIFT (2026-11-02, same day): the lockfile is no longer
+  committed (owner chore) — measurements resolve fresh and rode
+  moxml 0.6.1→0.6.2, leptris 1.9.401.0→1.9.402.0, lutaml-model
+  0.8.155→0.8.157 at once. TWO fixes rode in (RegexTest_234,
+  stE063); the fixed+EMPTY engine regression cost 9 (leptris-rs#25)
+  and reU6 flipped to we-accept (regex class, untriaged). Suite
+  4569→4562 raw; 4563 with this round. NET -6 documented, not
+  chased — the fixed-empty leg reverses the moment leptris-rs#25
+  lands.
 - REGEX SEMANTICS ROUND (2026-10-31, PR #208): \w/\W now carry their
   Appendix F complements (\w = [^\p{P}\p{Z}\p{C}], class interiors
   via the exact positive partition L/M/N/S), \I/\C complements added

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

@@ -94,8 +94,9 @@ module Lutaml
 
             # The engine does not check abstract-element usage; scan for
             # it regardless of whether the engine answered.
+            owner_ns = repository&.target_namespace_for(schema_def)
             scan_abstract_usage(xml_element, particles, collector,
-                                repository)
+                                repository, owner_ns)
 
             handled = if occurrence_guard(repository).particles_safe?(particles)
                         engine_content_check(xml_element,
@@ -107,10 +108,14 @@ module Lutaml
                         # (particlesZ034_b); the Ruby matcher decides those.
                         false
                       end
-            return if handled
+            if handled
+              scan_cross_namespace_refs(xml_element, particles, collector,
+                                        repository, owner_ns)
+              return
+            end
 
             validate_particle_sequence(xml_element, particles, collector,
-                                       repository)
+                                       repository, owner_ns)
           end
 
           private
@@ -133,14 +138,14 @@ module Lutaml
           #
           # @return [void]
           def validate_particle_sequence(xml_element, particles, collector,
-                                         repository)
+                                         repository, owner_ns = nil)
             return if particles.empty?
 
             children = Array(xml_element.children)
             matcher = ContentModelMatcher.new(
               particles,
               element_match: ->(child, particle) do
-                element_matches?(child, particle, repository)
+                element_matches?(child, particle, repository, owner_ns)
               end,
               wildcard_match: ->(child, wildcard) do
                 wildcard_permits?(wildcard, xml_element, child, repository)
@@ -155,13 +160,13 @@ module Lutaml
             result = matcher.match(children)
             if result.matched
               scan_wildcard_strict_usage(xml_element, particles, collector,
-                                         repository)
+                                         repository, owner_ns)
               return
             end
 
             known = collector.errors.size
             walk_sequence_diagnostics(xml_element, particles, collector,
-                                      repository)
+                                      repository, owner_ns)
             return if collector.errors.size > known
 
             report_matcher_failure(result, children, xml_element, collector)
@@ -317,15 +322,16 @@ module Lutaml
           # instances. Containers flatten to their leaf declarations —
           # the walk keeps them whole, the scan needs the leaves.
           def scan_abstract_usage(xml_element, particles, collector,
-                                  repository)
+                                  repository, owner_ns = nil)
             leaves = leaf_particles(particles, repository)
             xml_element.children.each do |child|
               leaves.each do |particle|
                 next unless particle.is_a?(Lutaml::Xsd::Element)
                 next unless particle_matches?(child, particle, repository,
-                                              parent: xml_element)
+                                              parent: xml_element,
+                                              owner_ns: owner_ns)
                 next unless element_declaration_abstract?(particle, child,
-                                                          repository)
+                                                          repository, owner_ns)
 
                 report_error(
                   collector,
@@ -360,7 +366,7 @@ module Lutaml
           #
           # @return [void]
           def scan_wildcard_strict_usage(xml_element, particles, collector,
-                                         repository)
+                                         repository, owner_ns = nil)
             leaves = leaf_particles(particles, repository)
             wildcards = leaves.select { |p| p.is_a?(Lutaml::Xsd::Any) }
             return if wildcards.empty?
@@ -370,7 +376,7 @@ module Lutaml
             end
             xml_element.children.each do |child|
               next if element_leaves.any? do |p|
-                element_matches?(child, p, repository)
+                element_matches?(child, p, repository, owner_ns)
               end
 
               wildcards.each do |wildcard|
@@ -391,7 +397,7 @@ module Lutaml
           #
           # @return [void]
           def walk_sequence_diagnostics(xml_element, particles, collector,
-                                         repository)
+                                        repository, owner_ns = nil)
             return if particles.empty?
 
             children = xml_element.children
@@ -418,13 +424,15 @@ module Lutaml
                 child = children[child_index]
 
                 break unless particle_matches?(child, particle, repository,
-                                               parent: xml_element)
+                                               parent: xml_element,
+                                               owner_ns: owner_ns)
 
                 if particle.is_a?(Lutaml::Xsd::Any)
                   check_strict_wildcard_child(child, particle, collector,
                                               repository)
                 elsif particle.is_a?(Lutaml::Xsd::Element) &&
-                    element_declaration_abstract?(particle, child, repository)
+                    element_declaration_abstract?(particle, child, repository,
+                                                  owner_ns)
                   report_error(
                     collector,
                     code: "abstract_element_used",
@@ -489,19 +497,74 @@ module Lutaml
           # declarations cannot appear directly in instances (substitution
           # members remain legal). Direct declarations carry their own
           # abstract flag; references resolve to the global declaration.
-          def element_declaration_abstract?(particle, child, repository)
-            declaration = declaration_for(particle, child, repository)
+          def element_declaration_abstract?(particle, child, repository,
+                                            owner_ns = nil)
+            declaration = declaration_for(particle, child, repository,
+                                          owner_ns)
             return false unless declaration
 
             truthy?(declaration.abstract) && child.name == declaration.name
           end
 
-          def declaration_for(particle, child, repository)
+          # A qualified ref names a declaration in ONE namespace.
+          # Global names duplicated across namespaces (import + main)
+          # resolve against the child's namespace today; when the owner
+          # schema's target namespace declares the same local name, a
+          # foreign child is an unexpected element (the engine — fed
+          # the documents one at a time — admits the substitute, so
+          # this runs on the engine-accept path). Wildcard territory
+          # is exempt.
+          #
+          # @return [void]
+          def scan_cross_namespace_refs(xml_element, particles, collector,
+                                        repository, owner_ns)
+            return if owner_ns.nil?
+
+            refs = leaf_particles(particles, repository).select do |p|
+              p.is_a?(Lutaml::Xml::Schema::Xsd::Element) &&
+                p.ref.to_s.match?(/\S/)
+            end
+            return if refs.empty?
+
+            xml_element.children.each do |child|
+              next if child.namespace_uri.to_s == owner_ns
+              next unless refs.any? do |r|
+                r.ref.to_s.split(":").last == child.name
+              end
+              next unless repository.resolve(child.name, owner_ns)
+              next if wildcard_covers_child?(xml_element, particles, child,
+                                             repository)
+
+              report_error(
+                collector,
+                code: "unexpected_element_in_sequence",
+                message: "Unexpected element '#{child.qualified_name}' " \
+                         "in sequence — the reference names the same " \
+                         "declaration in #{owner_ns}",
+                location: child.xpath,
+                context: { element: child.qualified_name },
+                suggestion: "Use the declaration's namespace or rename " \
+                            "the duplicate",
+              )
+            end
+          end
+
+          def wildcard_covers_child?(xml_element, particles, child,
+                                     repository)
+            leaf_particles(particles, repository).any? do |p|
+              next false unless p.is_a?(Lutaml::Xsd::Any)
+
+              wildcard_permits?(p, xml_element, child, repository)
+            end
+          end
+
+          def declaration_for(particle, child, repository, owner_ns = nil)
             return particle if particle.name.to_s.match?(/\S/)
             return nil unless repository
 
             local = particle.ref.to_s.split(":").last
-            repository.resolve(local, child.namespace_uri) ||
+            (owner_ns && repository.resolve(local, owner_ns)) ||
+              repository.resolve(local, child.namespace_uri) ||
               repository.resolve(local, nil)
           end
 
@@ -649,10 +712,11 @@ module Lutaml
           #   wildcard namespace constraints scoped to the target namespace
           # @return [Boolean]
           def particle_matches?(xml_element, particle, repository = nil,
-                                parent: nil, group_depth: 0)
+                                parent: nil, group_depth: 0, owner_ns: nil)
             particle_matches_child?(xml_element, particle, repository,
                                     parent: parent,
-                                    group_depth: group_depth)
+                                    group_depth: group_depth,
+                                    owner_ns: owner_ns)
           end
 
           # Check if XML element matches schema element.
@@ -663,9 +727,10 @@ module Lutaml
           # @param schema_element [Lutaml::Xsd::Element] The schema element
           # @param repository [SchemaDefinitionResolver, nil]
           # @return [Boolean]
-          def element_matches?(xml_element, schema_element, repository = nil)
+          def element_matches?(xml_element, schema_element, repository = nil,
+                               owner_ns = nil)
             particle_matches_declaration?(xml_element, schema_element,
-                                          repository) ||
+                                          repository, owner_ns) ||
               substitution_member?(xml_element, schema_element, repository)
           end
 

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

@@ -227,14 +227,18 @@ module Lutaml
 
         # Whether an instance child matches a content-model particle.
         # Direct declarations compare name and expected namespace; ref
-        # particles take the name and namespace of the global declaration
-        # they reference, resolved against the child's namespace.
+        # particles name a qualified declaration — the owner schema's
+        # target namespace is preferred, then the child's, then the
+        # unique-name fallback (parsed particles carry no prefix map).
         #
         # @param child [XmlElement]
         # @param particle [Lutaml::Xsd::Element]
         # @param repository [SchemaDefinitionResolver, nil]
+        # @param owner_ns [String, nil] target namespace of the schema
+        #   owning the content model
         # @return [Boolean]
-        def particle_matches_declaration?(child, particle, repository)
+        def particle_matches_declaration?(child, particle, repository,
+                                          owner_ns = nil)
           ref = particle.ref.to_s
           if ref.empty?
             name = particle.name.to_s
@@ -245,7 +249,13 @@ module Lutaml
                                                          repository))
           else
             local = ref.split(":").last
-            declaration = repository&.resolve(local, child.namespace_uri) ||
+            # owner_ns nil means UNKNOWN (the caller has no owner
+            # context), not "no namespace" — resolve(local, nil) only
+            # matches no-namespace declarations, and a hint-loaded
+            # document can supply a foreign namesake.
+            declaration =
+              (owner_ns && repository&.resolve(local, owner_ns)) ||
+              repository&.resolve(local, child.namespace_uri) ||
               repository&.resolve(local, nil)
             return false unless declaration
 
@@ -413,10 +423,12 @@ module Lutaml
         # @param group_depth [Integer] recursion guard for group refs
         # @return [Boolean]
         def particle_matches_child?(child, particle, repository,
-                                    parent: nil, group_depth: 0)
+                                    parent: nil, group_depth: 0,
+                                    owner_ns: nil)
           case particle
           when Lutaml::Xsd::Element
-            particle_matches_declaration?(child, particle, repository) ||
+            particle_matches_declaration?(child, particle, repository,
+                                          owner_ns) ||
               substitution_member?(child, particle, repository)
           when Lutaml::Xsd::Any
             wildcard_permits?(particle, parent || child, child, repository)
@@ -425,13 +437,15 @@ module Lutaml
                                    group_depth).any? do |container|
               particle_matches_child?(child, container, repository,
                                       parent: parent,
-                                      group_depth: group_depth + 1)
+                                      group_depth: group_depth + 1,
+                                      owner_ns: owner_ns)
             end
           when Lutaml::Xsd::Sequence, Lutaml::Xsd::Choice, Lutaml::Xsd::All
             collect_content_particles(particle).any? do |leaf|
               particle_matches_child?(child, leaf, repository,
                                       parent: parent,
-                                      group_depth: group_depth)
+                                      group_depth: group_depth,
+                                      owner_ns: owner_ns)
             end
           else
             false

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.79"
+    VERSION = "1.2.80"
   end
 end

metadata

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