lutaml-xsd 1.2.102 → 1.2.104

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1b37fc4af01d8c2f652a899644d9f85f13fec225d6ae0ce393b7d16f19df5bc
-  data.tar.gz: 2b08927d906be739a784888c3e1d9c9fb5a303362cc6dcc565404e0500b4f74d
+  metadata.gz: 18b2cd97c729aae1ceb8836fe492b36d0ea829de0e6e47f4f7a992e142d2e7c8
+  data.tar.gz: 365431275056d9a6bf80a2d4bb256b0c144e52183ca62ca3fcab51822486cc84
 SHA512:
-  metadata.gz: 95823a7f86274b2363e65b1a36d0b9aff1078c55196c8f53982d065ec67f0b32b60d1c18436ff8839f65f150373ffa822fa0c4cdaf046f042694ef94279fb0cc
-  data.tar.gz: f85b40f50b7ac8d93bfe7341feb8eaf4442ea4ac3b0fb9f3ea51cbb3f832835ac3f36033f9897e816371ba99ddf206f7c271a81389b3bf32370acc2104670968
+  metadata.gz: cd1b6f0609b6bde57f1947856b7d63e277044ad8d27076d7a6bcc0251ccfc82de133e3226f2795dca5f105fb747c0aebfcc4457832f30ab5c86adb39320609fc
+  data.tar.gz: e9c1d309c0c544b83c469a2c8fccf13ada15daa5fd401821f1dc71c51a8a49ed4ceff35d928ff0b792fd565c4ecb4e64d34e53fbf7276fdf23061e9c703e8a33

data/TODO.conformance.md

@@ -518,7 +518,45 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
 - RIDE-407 PIN-BACK (2026-11-05): the leptris 1.9.407.0 + moxml
   0.6.3 + lutaml-model 0.8.166 train carried fixes (the FULL #45
   stE legs, the #522 attgC four + attgD mostly + attJ018 +
+- PARENT-CONTEXT ROUND C (2026-11-08): +1 Additional (addB065;
+  suite 4630->4631 = 98.61%, pending measure confirm). A declaration
+  carrying a FIXED value constraint rejects xsi:nil=true outright
+  (XSD 1.0 §4.2.3 as the errata reads it; xmllint: "cannot be
+  'nilled' because there is a fixed value constraint defined for
+  it") — the nil-true branch now reports xsi_nil_with_fixed and
+  treats the element as nilled-handled. PARKED same-day: addB188
+  (an undeclared root anchored by xsi:type must assess against the
+  named type — the override-type dispatch was TRIED and reverted:
+  constraint-category rules assume Element schema_defs and crash on
+  ComplexType; the fix needs a per-rule ComplexType-capability
+  audit, a sibling of the parent-context charter). addB187's valid
+  twin re-verified after the revert.
+
   schF1/P2, stE065/066/096) AND a WHOLESALE 407 regex regression:
+- PARENT-CONTEXT ROUND B (2026-11-08): +1 Additional (isDefault079;
+  suite 4629->4630 = 98.59%, zero regressions, rspec green).
+  POSITIONAL BINDING for duplicate same-named locals: a model with
+  two regvalueop locals carrying DIFFERENT fixed values never bound
+  the second child to the second particle — the name-only dispatch
+  always hit the first. The engine computes each child's same-name
+  sibling index (on the RAW moxml nodes — wrapper objects are not
+  identity-stable across accessor calls, the IdUniquenessRule
+  lesson) and dispatches the positionally-bound declaration when
+  (a) the parent's model holds MORE THAN ONE same-named particle,
+  (b) every particle is INDEXED (attempt-3's starvation guard: raw
+  parent-model particles carry none of the form/ns metadata the
+  rules assume — resolver positional_children returns [] otherwise),
+  and (c) the candidate's expected namespace AGREES with the child's
+  (particlesQ016's global/local namesake guard). The ordered walk
+  keeps a PER-CALL visited set — the resolver's
+  each_particle_element memoizes on the instance and would poison
+  repeats. LESSON: scripted line-surgery on lib files dropped a
+  class end and leaked methods to top level (runtime-only
+  uninitialized-constant failures, caught by sentinel probes) —
+  structural edits go through the Edit tool only. Remaining parked
+  (matcher-assignment + root-assessment shapes): QFE1700c1,
+  addB065, addB188, schA1/D10 + the lax-wildcard six.
+
   ~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

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

@@ -65,6 +65,25 @@ module Lutaml
             schema_def = resolver.resolve(
               xml_element.name, xml_element.namespace_uri
             )
+            if parent
+              parent_declaration =
+                resolver.resolve(parent.name, parent.namespace_uri)
+              candidates = resolver.positional_children(parent_declaration,
+                                                        xml_element.name)
+              positional = candidates[same_name_sibling_index(xml_element,
+                                                              parent)]
+              # The binding must agree with the child's OWN namespace:
+              # an unqualified ref's global namesake never serves a
+              # qualified local namesake (particlesQ016).
+              child_ns = xml_element.namespace_uri.to_s
+              expected_ns =
+                resolver.expected_namespace_for(positional).to_s
+              if positional &&
+                  ((child_ns.empty? && expected_ns.empty?) ||
+                   child_ns == expected_ns)
+                schema_def = positional
+              end
+            end
             rules.each do |rule|
               argument = rule.schema_argument(schema_def, repository: resolver)
               next if argument.nil? && !rule.runs_without_schema?
@@ -204,6 +223,23 @@ module Lutaml
           end
         end
 
+        # The child's position among its same-named siblings — the index
+        # the positional binding (duplicate same-named declarations,
+        # isDefault079) binds to. Computed on the RAW moxml nodes: the
+        # wrapper objects are not identity-stable across accessor calls
+        # (the IdUniquenessRule lesson).
+        #
+        # @return [Integer]
+        def same_name_sibling_index(element, parent)
+          raw_children = Array(parent.moxml_element.elements)
+          position = raw_children.index do |node|
+            node.equal?(element.moxml_element)
+          end
+          return 0 if position.nil?
+
+          raw_children.take(position).count { |node| node.name == element.name }
+        end
+
         # Whether the parent's content model holds a processContents
         # skip wildcard whose namespace range admits the child — the
         # child subtree then escapes assessment entirely (addB125).

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

@@ -333,6 +333,22 @@ module Lutaml
                 return true
               end
 
+              # A fixed value constraint forbids nilled elements
+              # outright (addB065; xmllint: "cannot be 'nilled' because
+              # there is a fixed value constraint").
+              unless schema_element.fixed.to_s.empty?
+                report_error(
+                  collector,
+                  code: "xsi_nil_with_fixed",
+                  message: "Element '#{xml_element.name}' cannot be " \
+                           "nilled because there is a fixed value " \
+                           "constraint defined for it",
+                  location: xml_element.xpath,
+                  context: { element: xml_element.name },
+                )
+                return true
+              end
+
               if xml_element.children.empty? &&
                   xml_element.text_content.to_s.strip.empty?
                 return true

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

@@ -587,8 +587,92 @@ module Lutaml
           element_declaration_simple?(field_decl)
         end
 
+        # The ordered same-named inline particles of the parent's
+        # content model — the POSITIONAL binding for duplicate
+        # declarations (isDefault079: two regvalueop locals with
+        # different fixed values; the second child binds to the second
+        # particle). Returns [] unless the name appears MORE THAN ONCE
+        # and every particle is INDEXED (attempt-3's starvation: raw
+        # particles carry none of the form/ns metadata the rules
+        # assume). The walk keeps its own cycle guard — the resolver's
+        # each_particle_element memoizes visited nodes on the instance
+        # and would poison repeated walks.
+        #
+        # @param parent_declaration [Lutaml::Xml::Schema::Xsd::Element, nil]
+        # @param local_name [String]
+        # @return [Array<Lutaml::Xml::Schema::Xsd::Element>]
+        def positional_children(parent_declaration, local_name)
+          type = parent_declaration&.complex_type ||
+            resolve_type(parent_declaration)
+          return [] unless type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
+
+          particles = []
+          collect_named_particles(particle_for_type(type), local_name,
+                                  particles, {}.compare_by_identity, 0)
+          return [] if particles.length < 2
+          return [] unless particles.all? { |p| @namespaces.key?(p) }
+
+          particles
+        end
+
         private
 
+        # Depth-first ordered collection of same-named element
+        # particles; per-call visited set (identity-keyed), group refs
+        # expanded.
+        #
+        # @return [void]
+        def collect_named_particles(node, local_name, out, visited, depth)
+          return if node.nil? || depth > 24
+
+          if node.is_a?(Array)
+            node.each do |child|
+              collect_named_particles(child, local_name, out, visited,
+                                      depth + 1)
+            end
+            return
+          end
+          return if visited[node]
+
+          visited[node] = true
+
+          if node.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+            if node.name.to_s.split(":").last == local_name
+              out << node
+            elsif node.ref.to_s.match?(/\S/) &&
+                node.ref.to_s.split(":").last == local_name
+              global = resolve_global(node.ref.to_s.split(":").last, nil)
+              out << global if global
+            end
+            return
+          end
+
+          nested = CONTAINER_NESTED_KINDS[node.class]
+          nested&.each do |kind|
+            collect_named_particles(Array(node.public_send(kind)),
+                                    local_name, out, visited, depth + 1)
+          end
+          (CONTAINER_LEAF_KINDS[node.class] || []).each do |kind|
+            Array(node.public_send(kind)).each do |leaf|
+              next unless leaf
+
+              if leaf.is_a?(Lutaml::Xml::Schema::Xsd::Group)
+                resolved = if leaf.ref
+                             resolve_group(leaf.ref.to_s
+                                             .split(":").last)
+                           else
+                             leaf
+                           end
+                collect_named_particles(resolved, local_name, out, visited,
+                                        depth + 1)
+              elsif leaf.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+                collect_named_particles(leaf, local_name, out, visited,
+                                        depth + 1)
+              end
+            end
+          end
+        end
+
         # Whether a TYPE carries an identity value for a field bound to
         # the selector node itself (a "." field): a simple type or a
         # complex type with simple content does; complex content does not.

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.102"
+    VERSION = "1.2.104"
   end
 end

metadata

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