lutaml-xsd 1.2.94 → 1.2.96

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81113f3b383bfa48715846b5c216add5e652c0c7b70e587d6182b95633b1a49f
-  data.tar.gz: ffea6cdeeed2c00c883dbc64b7e7f6edd614ee9553311ab552a765f853070726
+  metadata.gz: b47e6206406d15078ca3896061eb50d415a599a3a6fe62df9a59d191c31f410a
+  data.tar.gz: d60605597341f39c26d19ac3bb8d88e6a0ff06d4f7ad03c9504d6903fc6a6ca9
 SHA512:
-  metadata.gz: 36438665084751f73c476788ce845587526c6f043233542aa214e73a60561b79d6a0b34fe637ace8978b0a4efccbfcbc597be31cc3de98418c6a8c5c0cbdcd40
-  data.tar.gz: 95f5077418bd7a008c394a9d559029ca7d7f31947b0be1ecb3dd09967bf6fe804375f87b26dca50b79b612d35049f7d4c401be9bb7c45a45a4aff918f0cb152e
+  metadata.gz: 231da0fb555d2591583462fa173efef19ee7835938aab19b52a3dc637a2e1c62a2e97f428fe492bea6b7b6891da3af45602a8ebf7112c1733d914098e32a3c38
+  data.tar.gz: baa25447cd81057253277cf53348399487b15a2d8b5735e3531a57f6f87d7dec4dc12bfe0a3e2c87f80a20f9580c094b823616b093c5764f95789a1b0724d373

data/TODO.conformance.md

@@ -526,7 +526,51 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   STACK IS PINNED BACK to the known-good 1.9.406.0/0.6.2/0.8.161
   (98.28% restored, zero regressions vs the 406 baseline). The
   407 wins ride again when #47 and #529 land. NET: no score
+- ID-VALUE-CONSTRAINT ROUND (2026-11-07): +1 IC (idZ011; suite
+  4619->4620 = 98.38%, zero regressions, rspec green). Value
+  constraints (fixed/default) are FORBIDDEN on attribute declarations
+  typed xs:ID or derived from it (XSD 1.0 §3.2.6) — the schema is
+  uncompilable, so every instance reached is invalid regardless of
+  instance use. The attribute rule's declaration-scoped step 1c
+  checks the builtin-prefixed reference, ref-resolved declarations,
+  and the inline/named restriction base chain (depth 6); the
+  idZ011_a companion (xs:STRING default) stays clean. Family probes:
+  Attribute 113/113 clean, AttributeGroup 14 = the parked moxml#522
+  set unchanged. PROBE LESSON (repeat): single-process family probes
+  CRAWL after ~50 engine-heavy cases (engine-state accumulation;
+  enumeration order is unstable so the hang point moves) — the case
+  runs alone in <1s; batched methodology or the full measure is the
+  only reliable family signal at this scale. Remaining IC
+  singletons: idZ012 (IDREFS default references no ID), idZ015 (a
+  skip-wildcard-governed attribute supplies no IC field value).
+
   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

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

@@ -106,6 +106,13 @@ module Lutaml
                                            xml_attributes, collector,
                                            wildcards: wildcards)
 
+            # Step 1c: an xs:ID declaration cannot carry a value
+            # constraint — the schema itself is uncompilable, so the
+            # instance is invalid wherever the declaration is reached
+            # (XSD 1.0 §3.2.6, idZ011).
+            validate_id_value_constraints(schema_attributes, collector,
+                                          xml_element, repository)
+
             # Step 2: Validate attribute values
             validate_attribute_values(xml_element, resolved_attributes,
                                       xml_attributes, collector,
@@ -436,6 +443,73 @@ module Lutaml
             end
           end
 
+          # An xs:ID declaration with fixed or default is an illegal
+          # value constraint (XSD 1.0 §3.2.6): the type definition is
+          # or is derived from xs:ID. Declaration-scoped — fires on the
+          # element's type regardless of instance use (idZ011).
+          #
+          # @return [void]
+          def validate_id_value_constraints(schema_attrs, collector,
+                                            xml_element, repository)
+            schema_attrs.each do |schema_attr|
+              next if schema_attr.fixed.to_s.empty? &&
+                schema_attr.default.to_s.empty?
+              next unless id_typed_attribute?(schema_attr, repository)
+
+              report_error(
+                collector,
+                code: "id_value_constraint_violation",
+                message: "Attribute '#{schema_attr.name}' is typed " \
+                         "xs:ID (or derived from it) and cannot carry " \
+                         "a fixed or default value constraint",
+                location: xml_element.xpath,
+                context: { attribute: schema_attr.name },
+              )
+            end
+          end
+
+          # Whether the declaration's type is xs:ID or derives from it:
+          # a builtin-prefixed reference, or a restriction base chain
+          # (inline or named) whose terminal is xs:ID.
+          #
+          # @return [Boolean]
+          def id_typed_attribute?(schema_attr, repository)
+            return true if builtin_id_type?(schema_attr.type)
+
+            ref = schema_attr.ref.to_s
+            if ref.match?(/\S/) && repository
+              resolved = repository.resolve_attribute(ref.split(":").last,
+                                                      nil)
+              return true if resolved && builtin_id_type?(resolved.type)
+            end
+
+            named = schema_attr.type.to_s.split(":").last
+            chain = schema_attr.simple_type ||
+              (named && repository&.resolve_named_type(named))
+            id_derived_chain?(chain, repository, 0)
+          end
+
+          # @return [Boolean]
+          def builtin_id_type?(reference)
+            parts = reference.to_s.split(":")
+            %w[xs xsd].include?(parts.first) && parts.last == "ID"
+          end
+
+          # @param type [Lutaml::Xml::Schema::Xsd::SimpleType, nil]
+          # @return [Boolean]
+          def id_derived_chain?(type, repository, depth)
+            return false if depth > 6 || type.nil?
+
+            base = type.restriction&.base.to_s
+            return true if builtin_id_type?(base)
+            return false if base.empty?
+
+            id_derived_chain?(
+              repository&.resolve_named_type(base.split(":").last),
+              repository, depth + 1
+            )
+          end
+
           # Check if attribute is required
           #
           # @param schema_attr [Lutaml::Xsd::Attribute] Schema attribute

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

@@ -62,7 +62,8 @@ module Lutaml
             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
@@ -71,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
@@ -83,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(
@@ -107,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(
@@ -138,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
@@ -292,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|
@@ -347,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.94"
+    VERSION = "1.2.96"
   end
 end

metadata

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