lutaml-xsd 1.2.93 → 1.2.95

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ad03adc4f701faa3d3c132f2704c5dc7e01033e7403750352156cbe7a2333a9
-  data.tar.gz: b861d33acb72791876fee6e23ba03bc94a662d570b127056803a75de319a2a4a
+  metadata.gz: a752804ef8cfcbbe98845ffcfcbd8830d2c37020d392d34524795f645351cef9
+  data.tar.gz: 467cd19ffcc587cbdc4007e614b02f2f299a26917c684e997138fa5116686a7b
 SHA512:
-  metadata.gz: 1d64f1ba11d11333972f2cbdbe32c083d423effecefea95b3aca7b99200c0edc314a0861502129ec0a7f58c77a0e7e34474473f2600fd91e6314d25fb83c2949
-  data.tar.gz: 3e1f6cfbda1193da0844c8e25c6579503c1ceab084acb5d00674e1682c344326167ff00e5f07881655c898a21fed46f9c0e316174a63d3f4491341085cf4126a
+  metadata.gz: 904b2740eaa42225aa419c6a27586cc115fbcba3efaa4e4fe987b979f7139bd00e5e96007f094f65b5631a8383bdd12d0e50eaef82482733662d2dcda8658507
+  data.tar.gz: 545c68eb6ce9cda1d4b834d3bf608974d3da82e774fee7465918ba39d5c2d7183892c0a314c3314d15f68e8f20a6af27e264fb752f5023008db7a5cfa84be512

data/TODO.conformance.md

@@ -120,7 +120,7 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4614/4696 (98.25%) |
+| pipeline | 4617/4696 (98.32%) |
 
 (2026-11-02, bundled-stack measurement with the escape,
 hint-following, pattern-alternative, identity-crash, engine-set,
@@ -144,7 +144,7 @@ lockfile refresh) → 4411 (93.9%) → 4430 (94.3%) → 4435 (94.4%) →
 → 4557 (97.0%) → 4565 (97.2%) → 4569 (97.3%) → 4562 (drift raw) →
 4563 (97.17%, ref-namespace round) → 4573 (97.38%, group-content
 round) → 4578 (97.49%, attribute-prohibition round) → 4585 (97.64%,
-multi-document round) → 4588 (97.7%, type-binding round) → 4592 (97.79%, model-161 ride) → 4611 (98.19%, engine-406 ride) → 4613 (98.23%, temporal-enumeration round) → 4614 (98.25%, simple-type-children round), +653 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
+multi-document round) → 4588 (97.7%, type-binding round) → 4592 (97.79%, model-161 ride) → 4611 (98.19%, engine-406 ride) → 4613 (98.23%, temporal-enumeration round) → 4614 (98.25%, simple-type-children round) → 4617 (98.32%, ic-ancestor-scope round), +656 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
@@ -527,6 +527,47 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   (98.28% restored, zero regressions vs the 406 baseline). The
   407 wins ride again when #47 and #529 land. NET: no score
   change; the pin protects the register.
+- NON-SIMPLE-FIELD ROUND (2026-11-07): +2 IC (idK012, idZ010; suite
+  4617->4619 = 98.36%, zero regressions, rspec green). An identity
+  field takes a value only from a SIMPLE-typed node: a field hitting
+  an element with element children (idK012's pid, complexContent
+  restriction of anyType) or one DECLARED non-simple — complex
+  content, or xsd:anyType as the typeless-local default (idZ010's
+  A3/A22, the cross-namespace import shape) — previously contributed
+  its concatenated text as a clean row. The rule consults the field's
+  declaration via SchemaDefinitionResolver#field_declaration_simple:
+  the IC owner's content model descends the raw selector path, the
+  selector element's own type descends the raw field path (base
+  chains included; refs resolve to the global declaration). THREE
+  guards keep it sound: a resolvable xsi:type override governs the
+  INSTANCE value space (idF-class overrides stay simple, idL090
+  decimal/string fields untouched); unresolvable descents yield nil
+  = no determination (the lenient path is untouched); unresolvable
+  named types are simple only when builtin-prefixed. LESSON: the
+  tri-state verdicts live in NON-predicate methods — rubocop -A
+  rewrites `return nil` guards in `?`-methods to `return false`,
+  which silently hardened the lenient path twice before the probes
+  caught it. The remaining three IC singletons have DIFFERENT roots
+  (next rounds): idZ011 (schema-side xs:ID value-constraint
+  prohibition, §3.2.6), idZ012 (IDREFS default "abc" references no
+  ID), idZ015 (a skip-wildcard-governed attribute supplies no IC
+  field value).
+
+
+- IC ANCESTOR-SCOPE ROUND (2026-11-05): +1 IC (idZ008; suite
+  4614->4617 = 98.32% with the prefix-resolution and
+  temporal-enumeration riders on main, zero regressions, rspec
+  green). A keyref whose `refer` names a key declared on an
+  ANCESTOR element resolved against an empty table — the
+  collected-keys map reset per element (idZ008: the key KeyAAA on
+  A, the keyref QQQ on the descendant A2, selector "."). The map
+  now accumulates across the walk; instance document order
+  guarantees ancestors process before descendants. The other five
+  IC singletons (idK012, idZ010/011/012/015) have DIFFERENT roots
+  (cross-namespace keyrefs, IDREF defaults) — next rounds. NOTE:
+  the PREFIX-RESOLUTION round (+1, particlesQ032 via the 1131
+  xmlns-declarations retention in lutaml-model 0.8.167 — pinned)
+  is also on main; the score line carries both.
 
 - SIMPLE-TYPE-CHILDREN ROUND (2026-11-05, third attempt — the first
   two regressed 15 at scale): +1 DataTypes (dtZ86723; suite

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

@@ -52,12 +52,18 @@ module Lutaml
             # schema's target namespace (the suite's single-namespace shapes).
             target_ns = repository&.target_namespace_for(schema_element).to_s
 
-            collected = {}
+            # Key tables accumulate across the walk: a keyref whose
+            # `refer` names a key declared on an ANCESTOR resolves
+            # against the ancestor's rows (idZ008 — the key on A, the
+            # keyref on the descendant A2). Instance document order
+            # guarantees ancestors are processed before descendants.
+            collected = @collected_keys ||= {}
 
             Array(schema_element.key).each do |constraint|
               evaluated_constraints << constraint.name.to_s if constraint.name
               values = collect_values(xml_element, constraint, collector,
-                                      repository, target_ns, :key)
+                                      repository, target_ns, :key,
+                                      schema_element)
               report_duplicates(collector, xml_element, constraint, values,
                                 "duplicate_key_violation")
               collected[constraint.name] = values if constraint.name
@@ -66,7 +72,8 @@ module Lutaml
             Array(schema_element.unique).each do |constraint|
               evaluated_constraints << constraint.name.to_s if constraint.name
               values = collect_values(xml_element, constraint, collector,
-                                      repository, target_ns, :unique)
+                                      repository, target_ns, :unique,
+                                      schema_element)
               report_duplicates(collector, xml_element, constraint, values,
                                 "duplicate_unique_violation")
               collected[constraint.name] = values if constraint.name
@@ -78,7 +85,8 @@ module Lutaml
               next if referred.nil?
 
               collect_values(xml_element, constraint, collector,
-                             repository, target_ns, :keyref).each do |value|
+                             repository, target_ns, :keyref,
+                             schema_element).each do |value|
                 next if referred.include?(value)
 
                 report_error(
@@ -102,24 +110,53 @@ module Lutaml
 
           private
 
+          # Field values (and violation flags) for ONE selector-matched
+          # node: per field, the supply value, the node's text/attr
+          # value, or a non-simple verdict.
+          #
+          # @return [Array(Array, Boolean, Boolean)] [values, ambiguous,
+          #   non_simple]
+          def evaluate_field_row(node, fields, raws, constraint,
+                                 owner_element, repository)
+            values = []
+            ambiguous = false
+            non_simple = false
+            fields.each_with_index do |field, index|
+              matched = field_nodes(node, field)
+              # A field evaluating to a node-set with more than one
+              # member violates the constraint (XSD 1.0 §3.11.4).
+              ambiguous = true if matched.size > 1
+              values << if matched.first.nil?
+                          field_supply_value(node, field, repository)
+                        elsif matched.first.is_a?(Moxml::Element) &&
+                            field_node_non_simple?(
+                              matched.first, constraint, raws[index],
+                              owner_element, repository
+                            )
+                          # An element field hitting an element with
+                          # ELEMENT children (complex content), or one
+                          # DECLARED non-simple (complex content or
+                          # xsd:anyType — the typeless default), supplies
+                          # no identity value: the field "does evaluate
+                          # to a node of non-simple type" (idK012/idZ010).
+                          non_simple = true
+                          nil
+                        else
+                          field_node_value(matched.first)
+                        end
+            end
+            [values, ambiguous, non_simple]
+          end
+
           def collect_values(xml_element, constraint, collector, repository,
-                             target_namespace, kind)
+                             target_namespace, kind, owner_element)
             fields = field_xpaths(constraint, target_namespace)
+            raws = raw_fields(constraint)
             selector_xpaths(constraint, target_namespace).flat_map do |selector|
               Array(xml_element.moxml_element.xpath(selector)).map do |node|
-                values = []
-                ambiguous = false
-                fields.each do |field|
-                  matched = field_nodes(node, field)
-                  # A field evaluating to a node-set with more than one
-                  # member violates the constraint (XSD 1.0 §3.11.4).
-                  ambiguous = true if matched.size > 1
-                  values << if matched.first
-                              field_node_value(matched.first)
-                            else
-                              field_supply_value(node, field, repository)
-                            end
-                end
+                values, ambiguous, non_simple =
+                  evaluate_field_row(node, fields, raws, constraint,
+                                     owner_element, repository)
 
                 if ambiguous
                   report_error(
@@ -133,6 +170,19 @@ module Lutaml
                   next
                 end
 
+                if non_simple
+                  report_error(
+                    collector,
+                    code: "field_non_simple_type_violation",
+                    message: "Field #{fields.join(', ')} of #{kind} " \
+                             "'#{constraint.name}' evaluates to a node of " \
+                             "non-simple type in '#{node.name}'",
+                    location: xml_element.xpath,
+                    context: { constraint: constraint.name },
+                  )
+                  next
+                end
+
                 # A qualified node has every field present; an absent
                 # field means the node does not contribute a row —
                 # except for xs:KEY, where a selected node whose fields
@@ -287,6 +337,67 @@ module Lutaml
             repository.declared_attribute_supply(parent_type, attr_local)
           end
 
+          # Whether an element field's node supplies no identity value:
+          # it has element children, is declared non-simple (complex
+          # content or xsd:anyType — the typeless default), or carries a
+          # resolvable xsi:type override to a non-simple type — the
+          # override governs the INSTANCE value space, so a simple
+          # override keeps the field simple no matter what the schema
+          # declares (idF-class).
+          #
+          # @param matched [Moxml::Element]
+          # @return [Boolean]
+          def field_node_non_simple?(matched, constraint, raw_field,
+                                     owner_element, repository)
+            override = override_governs_simple(matched, repository)
+            return !override unless override.nil?
+
+            matched.elements.any? ||
+              declared_field_non_simple?(constraint, raw_field,
+                                         owner_element, repository)
+          end
+
+          # The simple/non-simple verdict of the field node's xsi:type
+          # override, or nil when the node has no resolvable override.
+          #
+          # @return [Boolean, nil]
+          def override_governs_simple(node, repository)
+            override = node.attributes.find do |candidate|
+              candidate.name == "type" &&
+                candidate.namespace&.uri == XSI_NAMESPACE
+            end
+            return unless override
+
+            parts = override.value.to_s.split(":")
+            local = parts.last
+            return if local.nil? || local.empty?
+            return local != "anyType" if %w[xs xsd].include?(parts.first)
+
+            case repository&.resolve_named_type(local)
+            when Lutaml::Xml::Schema::Xsd::SimpleType then true
+            when Lutaml::Xml::Schema::Xsd::ComplexType then false
+            end
+          end
+
+          # Whether the field's element declaration — reached by
+          # descending the IC owner's content model through the raw
+          # selector path, then the raw field step — is non-simple
+          # (complex content or xsd:anyType). Unresolvable paths allow
+          # no determination.
+          #
+          # @return [Boolean]
+          def declared_field_non_simple?(constraint, raw_field,
+                                         owner_element, repository)
+            return false unless repository && owner_element
+
+            owner_type = owner_element.complex_type ||
+              repository.resolve_type(owner_element)
+            raw_selectors(constraint).any? do |selector_raw|
+              repository.field_declaration_simple(owner_type, selector_raw,
+                                                  raw_field) == false
+            end
+          end
+
           def report_duplicates(collector, xml_element, constraint, values,
                                 code)
             values.group_by(&:itself).each do |value, group|
@@ -342,6 +453,20 @@ module Lutaml
             end
           end
 
+          # The selector steps as WRITTEN (unions split the same way the
+          # adapted list splits) — the declared-field determination
+          # descends the schema through these.
+          #
+          # @return [Array<String>]
+          def raw_selectors(constraint)
+            raw = if constraint.selector.is_a?(Lutaml::Xml::Schema::Xsd::Selector)
+                    constraint.selector.xpath
+                  else
+                    constraint.selector
+                  end
+            raw.to_s.split(/\s*\|\s*/).reject(&:empty?)
+          end
+
           # The field steps as WRITTEN (unions split the same way the
           # adapted list splits) — the absent-row decision reads the
           # step's own namespace governance from these.

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

@@ -527,8 +527,228 @@ module Lutaml
           particle_for_type(resolve_named_type(local_name))
         end
 
+        # Whether the element declaration an identity-constraint field
+        # binds to is SIMPLE-typed. A field may take an identity value
+        # only from a simple-typed node: a complex type with complex
+        # content (element children, idK012) or xsd:anyType — the
+        # default for a typeless local declaration (idZ010's A3/A22) —
+        # supplies no identity value. The declaration is reached by
+        # descending the IC owner's content model through the raw
+        # selector path, then the selector element's own type through
+        # the raw field path.
+        #
+        # @param owner_type [Lutaml::Xml::Schema::Xsd::ComplexType, nil]
+        # @param selector_raw [String] the selector XPath as written
+        # @param field_raw [String] the field XPath as written
+        # @return [Boolean, nil] nil when unresolvable (no determination)
+        def field_declaration_simple(owner_type, selector_raw, field_raw)
+          sel_type = path_bound_type(owner_type, selector_raw)
+          bound = sel_type && path_bound_with_decl(sel_type, field_raw)
+          return unless bound
+
+          field_type, field_decl, owner_self = bound
+          return type_supplies_identity_value?(field_type) if owner_self
+          return unless field_decl
+
+          element_declaration_simple?(field_decl)
+        end
+
         private
 
+        # 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.
+        #
+        # @param type [Object]
+        # @return [Boolean, nil]
+        def type_supplies_identity_value?(type)
+          case type
+          when Lutaml::Xml::Schema::Xsd::SimpleType then true
+          when Lutaml::Xml::Schema::Xsd::ComplexType
+            !type.simple_content.nil?
+          end
+        end
+
+        # The type an identity-constraint XPath (selector or field)
+        # binds to, descended through the content model from +type+.
+        # A bare "." binds +type+ itself; each named step locates the
+        # child element declaration and descends into its type.
+        #
+        # @param type [Object, nil]
+        # @param raw_path [String] the XPath as written
+        # @return [Object, nil]
+        def path_bound_type(type, raw_path, depth = 0)
+          path_bound_with_decl(type, raw_path, depth)&.first
+        end
+
+        # The bound type AND the final element declaration of an
+        # identity-constraint XPath. The declaration is nil when the
+        # path is a bare "." (the bound node IS the starting element).
+        #
+        # @param type [Object, nil]
+        # @param raw_path [String] the XPath as written
+        # @return [Array(Object, Object, Boolean), nil] [type, decl,
+        #   owner_self] — nil when unresolvable
+        def path_bound_with_decl(type, raw_path, depth = 0)
+          return nil if type.nil? || depth > 8
+
+          steps = raw_path.to_s.split("/").reject do |step|
+            step.empty? || step == "."
+          end
+          current = type
+          decl = nil
+          steps.each_with_index do |step, index|
+            local = step.split(":").last
+            return nil if step.start_with?("@") || local.nil? || local == "*"
+
+            decl = declared_child_element(current, local, depth)
+            return nil unless decl
+
+            current = declared_element_type(decl, depth)
+            # A nil type mid-path (typeless or unresolvable named)
+            # cannot descend further; a nil type on the FINAL step
+            # still binds its declaration — typeless defaults to
+            # xsd:anyType, which the caller's predicate decides.
+            return nil if current.nil? && index < steps.length - 1
+          end
+          [current, decl, steps.empty?]
+        end
+
+        # The element declaration for +local_name+ in the content model
+        # of +type+: its own particles first, then the derivation base
+        # chain (derived types inherit the base's particles).
+        #
+        # @param type [Object, nil]
+        # @param local_name [String]
+        # @param depth [Integer] recursion guard
+        # @return [Lutaml::Xml::Schema::Xsd::Element, nil]
+        def declared_child_element(type, local_name, depth = 0)
+          return nil if depth > 8
+          return nil unless type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
+
+          found = find_particle_element(particle_for_type(type), local_name,
+                                        depth)
+          return found if found
+
+          content = type.complex_content
+          part = content && (Array(content.extension).first ||
+            Array(content.restriction).first)
+          return nil unless part
+
+          declared_child_element(
+            resolve_named_type(part.base.to_s.split(":").last),
+            local_name, depth + 1
+          )
+        end
+
+        # Depth-first search for an Element particle named +local_name+.
+        # A ref particle binds the GLOBAL declaration (the descent needs
+        # its type); prefix-insensitive, the same trade the adapted
+        # XPath evaluation makes.
+        #
+        # @param node [Object, Array, nil]
+        # @param local_name [String]
+        # @param depth [Integer] recursion guard
+        # @return [Lutaml::Xml::Schema::Xsd::Element, nil]
+        def find_particle_element(node, local_name, depth = 0)
+          return nil if node.nil? || depth > 24
+
+          if node.is_a?(Array)
+            node.each do |child|
+              found = find_particle_element(child, local_name, depth + 1)
+              return found if found
+            end
+            return nil
+          end
+
+          if node.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+            return node if node.name.to_s.split(":").last == local_name
+
+            ref_local = node.ref.to_s.split(":").last
+            return nil unless ref_local == local_name
+
+            return resolve_global(ref_local, nil)
+          end
+
+          nested = CONTAINER_NESTED_KINDS[node.class]
+          nested&.each do |kind|
+            found = find_particle_element(Array(node.public_send(kind)),
+                                          local_name, depth + 1)
+            return found if found
+          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
+                found = find_particle_element(resolved, local_name,
+                                              depth + 1)
+                return found if found
+              elsif leaf.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+                found = find_particle_element(leaf, local_name, depth + 1)
+                return found if found
+              end
+            end
+          end
+          nil
+        end
+
+        # The TYPE a bound element declaration carries: its inline
+        # complexType or simpleType, else the named type its +type+
+        # attribute resolves to.
+        #
+        # @param element_decl [Lutaml::Xml::Schema::Xsd::Element]
+        # @param depth [Integer] recursion guard
+        # @return [Object, nil]
+        def declared_element_type(element_decl, _depth = 0)
+          return element_decl.complex_type if element_decl.complex_type
+          return element_decl.simple_type if element_decl.simple_type
+
+          name = element_decl.type.to_s
+          return nil if name.empty?
+
+          resolve_named_type(name.split(":").last)
+        end
+
+        # Whether a bound element declaration's type is SIMPLE: an
+        # inline simpleType, a simple-named type, or a complex type
+        # with SIMPLE content (text value carries the identity value).
+        # Complex content — including xsd:anyType, the default for a
+        # typeless declaration — is NOT simple.
+        #
+        # @param element_decl [Lutaml::Xml::Schema::Xsd::Element]
+        # @return [Boolean, nil] nil when the named type is unresolvable
+        def element_declaration_simple?(element_decl)
+          return true if element_decl.simple_type
+
+          complex = element_decl.complex_type
+          return !complex.simple_content.nil? if complex
+
+          name = element_decl.type.to_s
+          return false if name.empty?
+
+          parts = name.split(":")
+          return false if parts.last == "anyType"
+
+          resolved = resolve_named_type(parts.last)
+          case resolved
+          when Lutaml::Xml::Schema::Xsd::SimpleType then true
+          when Lutaml::Xml::Schema::Xsd::ComplexType
+            !resolved.simple_content.nil?
+          else
+            # Unresolvable but builtin-prefixed (xs:/xsd: both bind the
+            # schema namespace) is simple; unresolvable otherwise allows
+            # no determination.
+            parts.first.to_s.match?(/\Axs(d)?\z/) || nil
+          end
+        end
+
         def particle_for_type(type)
           case type
           when Lutaml::Xml::Schema::Xsd::ComplexType

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.93"
+    VERSION = "1.2.95"
   end
 end

metadata

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