lutaml-xsd 1.2.114 → 1.2.115

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36f7c7c0e9d599f7400dac905f372692d9da5d253bd5d67069106d923259a4b3
-  data.tar.gz: 6a2b5a3b8f8db1067381b3e8f924da0f06af636a152626795167b97012510e40
+  metadata.gz: 8361d002b4925f8e9617b1befc010cdf69eda020d9819ad6cb563d5716fd0cb3
+  data.tar.gz: d7ee489b009dbfe0f537b6ec11ea9e68435161619db337801a8b2fe44881b267
 SHA512:
-  metadata.gz: c9467308b09e8249e3e5b87a1b1a2d298f95d55ec4bf466a63a0a376752e813f0f9753b821d25c000e3d39a0c65249e675df39ec1496f47ecadde12b5782d28d
-  data.tar.gz: f147cc2f3ebb9d6ec7ca62601b72573ccc70433bdd36b50cbe46133e815b052ac5a4fec48153e3e2823ab8c6d1f3955f13f1f1714b761b4bfc1310de174b5c20
+  metadata.gz: a67d033744fd14e969811aed1d8b7f7e679a50b2c535a1ea649e670d5e4baf6f5fef3c5b11349cfef519dbfb0cdacdc467270ccf6c3c231d3f6f234b2c7f84b2
+  data.tar.gz: 02fec25f4e6c24ecf8c591e8fff9dfb245acaeacb41a09c36223ae6a1da1cdc8e35a22c215b2a11c137982b1d49c284c568e926faf49d856bcc52f68a13be1a3

data/TODO.conformance.md

@@ -120,7 +120,7 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4658/4696 (99.19%) — first measure above 99 |
+| pipeline | 4664/4696 (99.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) → 4617 (98.32%, ic-ancestor-scope round) → 4637 (parent-context rounds + chameleon round 1.2.109) → 4637 (nested-type-candidates round, 1.2.110) → 4637 (redefine-cycle round, 1.2.111) → 4644 measured (98.96% of measured, train-adoption round: moxml 0.6.6 + leptris 1.9.418.0) → 4649 (98.91%, quadratic-dispatch round — first FULL-denominator measure, the 5 reZ budget exclusions retired) → 4658 (99.19%, remainder-classification round — first measure above 99), +697 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) → 4637 (parent-context rounds + chameleon round 1.2.109) → 4637 (nested-type-candidates round, 1.2.110) → 4637 (redefine-cycle round, 1.2.111) → 4644 measured (98.96% of measured, train-adoption round: moxml 0.6.6 + leptris 1.9.418.0) → 4649 (98.91%, quadratic-dispatch round — first FULL-denominator measure, the 5 reZ budget exclusions retired) → 4658 (99.19%, remainder-classification round — first measure above 99) → 4664 (99.32%, ride-419 round), +703 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
@@ -684,6 +684,38 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   false, which would have flagged every schema-type override
   undervalued; caught by re-reading the -A diff (the standing
   predicate-nil lesson, now with the rename fix applied).
+- RIDE-419 ROUND (2026-11-13, release pending): leptris
+  1.9.419.0 closed BOTH overnight filings — leptris-rs#72
+  (wildZ013b/c: the namespace-less-import wildcard admission
+  restored) and #73 (attZ014a/b: the multi-xs:ID 1.0 reading
+  restored). The ride also surfaced that OUR fixed-value check
+  was lexical-only where the suite demands VALUE-space equality
+  through a union's first-accepting member (§4.1.7): stE050
+  ('true' == fixed '1' as boolean-true) and stE055 (float forms)
+  now pass via ValueSpace.union_member_value_key + the
+  fixed_value_space_equal? comparison in TypeValidationRule
+  (union members split per the established member_types.to_s.
+  split pattern — Array() on the attribute yields ONE
+  space-separated string, which silently never matches; three
+  call sites corrected, including a latent one from the previous
+  round). stE065/066/096 remain ENGINE-bound — filed
+  leptris-rs#74 (the engine's own fixed-value comparison is
+  lexical-only for unions); attgC035-038 remain FACADE-bound —
+  filed moxml#545 (the closed-#522 thread's uncovered legs: the
+  strict re-check false-reports attributeGroup-redefine §4.2.2
+  hook members). SUITE 4664/4696 (99.32%), zero regressions;
+  rspec 1663 green; rubocop clean. INCIDENT (recovered
+  in-round): threading repository: into validate_fixed_content
+  via a bulk gsub landed a call inside validate_builtin_type,
+  whose scope has no repository local — NameError on every
+  builtin-typed element, a 686-case regression wave that
+  briefly looked like a leptris-419 breakage; the pin-back
+  battery exonerated the train (the wave reproduced on 418)
+  and the signature fix recovered the battery. LESSON: when
+  threading a parameter through call sites, verify the RECEIVER
+  method's signature carries it — a mechanical gsub crosses
+  scope boundaries silently, and the crash-as-invalid
+  convention turns the NameError into wholesale false verdicts.
 - 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

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

@@ -127,7 +127,8 @@ module Lutaml
               # A type-less declaration is xs:anyType; its fixed value
               # still constrains the lexical content (isDefault070).
               validate_fixed_content(xml_element, schema_element,
-                                     xml_element.text_content, collector)
+                                     xml_element.text_content, collector,
+                                     repository: repository)
               return
             end
 
@@ -143,14 +144,16 @@ module Lutaml
               # complex walk checks the type's model, this checks the
               # declaration's own fixed content (isDefault077).
               validate_fixed_content(xml_element, schema_element,
-                                     xml_element.text_content, collector)
+                                     xml_element.text_content, collector,
+                                     repository: repository)
               validate_complex_type_content(xml_element, type_def, collector,
                                             repository: repository,
                                             declared: schema_element)
             else
               # Handle built-in types
               validate_builtin_type(xml_element, type_def, collector,
-                                    declared: schema_element)
+                                    declared: schema_element,
+                                    repository: repository)
             end
           end
 
@@ -557,7 +560,7 @@ module Lutaml
           #
           # @return [Boolean]
           def union_member_covers_builtin?(union_type, override, repository)
-            members = Array(union_type.union.member_types)
+            members = union_type.union.member_types.to_s.split(/\s+/)
             members.any? do |member|
               local = member.to_s.split(":").last
               next true if local == override
@@ -592,7 +595,8 @@ module Lutaml
             validate_builtin_type(xml_element,
                                   builtin_override_reference(xml_element),
                                   collector,
-                                  declared: schema_element)
+                                  declared: schema_element,
+                                  repository: repository)
             true
           end
 
@@ -653,12 +657,17 @@ module Lutaml
           end
 
           # XSD 1.0 §3.3.3: a fixed value constrains the element — a
-          # non-empty lexical must equal it in the value space
+          # non-empty lexical must equal it in the VALUE space
           # (elemQ018). Empty content already validates against the
-          # fixed value through effective_text.
+          # fixed value through effective_text. Union/list-typed
+          # declarations map each lexical through the FIRST accepting
+          # member (§4.1.7) — 'true' equals fixed '1' as boolean-true
+          # (stE050), token collapse equates trailing blanks
+          # (stE065/066), float forms compare numerically (stE055).
           #
           # @return [void]
-          def validate_fixed_content(xml_element, declared, value, collector)
+          def validate_fixed_content(xml_element, declared, value, collector,
+                                     repository: nil)
             return unless declared.is_a?(Lutaml::Xml::Schema::Xsd::Element)
 
             fixed = declared.fixed.to_s
@@ -667,6 +676,8 @@ module Lutaml
 
             rule = declared_whitespace_rule(declared)
             return if canonical(value.to_s, rule) == canonical(fixed, rule)
+            return if fixed_value_space_equal?(declared, value.to_s, fixed,
+                                               repository)
 
             report_error(
               collector,
@@ -682,6 +693,76 @@ module Lutaml
             )
           end
 
+          # Value-space equality for union/list-typed declarations:
+          # each side keys through the first accepting member and the
+          # keys must match.
+          #
+          # @return [Boolean]
+          def fixed_value_space_equal?(declared, value, fixed, repository)
+            simple = declared.simple_type
+            return false unless simple
+
+            if simple.union
+              members = simple.union.member_types.to_s.split(/\s+/)
+              return union_keys_equal?(value, fixed, members, repository)
+            end
+            return false unless simple.list
+
+            item_union = inline_item_union(simple.list, repository)
+            return false unless item_union
+
+            left = value.split
+            right = fixed.split
+            return false unless left.size == right.size
+
+            left.zip(right).all? do |a, b|
+              union_keys_equal?(a, b, item_union, repository)
+            end
+          end
+
+          # The member_types array of a list's item type: an inline
+          # union, else the named union resolved through the
+          # repository.
+          #
+          # @return [Array, nil]
+          def inline_item_union(list, repository)
+            inline = Array(list.simple_type).first
+            return inline.union.member_types.to_s.split(/\s+/) if inline&.union
+
+            reference = list.item_type.to_s.split(":").last
+            named = repository&.resolve_named_type(reference)
+            return named.union.member_types.to_s.split(/\s+/) if
+              named.is_a?(Lutaml::Xml::Schema::Xsd::SimpleType) && named.union
+
+            nil
+          end
+
+          # @return [Boolean]
+          def union_keys_equal?(value, fixed, members, repository)
+            a = first_member_key(value, members, repository)
+            b = first_member_key(fixed, members, repository)
+            !a.nil? && !b.nil? && a == b
+          end
+
+          # @return [Object, nil]
+          def first_member_key(lexical, members, repository)
+            members.each do |member|
+              local = member.to_s.split(":").last
+              key = ValueSpace.union_member_value_key(local, lexical)
+              return key unless key.nil?
+
+              named = repository&.resolve_named_type(local)
+              next unless named.is_a?(Lutaml::Xml::Schema::Xsd::SimpleType) &&
+                named.union
+
+              nested = first_member_key(lexical,
+                                        named.union.member_types.to_s.split(/\s+/),
+                                        repository)
+              return nested unless nested.nil?
+            end
+            nil
+          end
+
           # @return [Symbol] :preserve, :replace or :collapse
           def declared_whitespace_rule(declared)
             reference = declared.type.to_s
@@ -730,7 +811,8 @@ module Lutaml
                                            collector, repository: nil,
                                            declared: nil)
             value = effective_text(xml_element, declared)
-            validate_fixed_content(xml_element, declared, value, collector)
+            validate_fixed_content(xml_element, declared, value, collector,
+                                   repository: repository)
 
             # Validate base type if present
             if simple_type.restriction
@@ -1251,7 +1333,8 @@ module Lutaml
                                              declared: declared)
               elsif builtin_base?(raw_base)
                 validate_builtin_type(xml_element, raw_base, collector,
-                                      declared: declared)
+                                      declared: declared,
+                                      repository: repository)
               end
             elsif simple_content.restriction
               # Restriction constrains a simple type
@@ -1273,9 +1356,10 @@ module Lutaml
           # @param collector [ResultCollector] Result collector
           # @return [void]
           def validate_builtin_type(xml_element, type_name, collector,
-                                    declared: nil)
+                                    declared: nil, repository: nil)
             value = effective_text(xml_element, declared)
-            validate_fixed_content(xml_element, declared, value, collector)
+            validate_fixed_content(xml_element, declared, value, collector,
+                                   repository: repository)
             # A simple type has no element content: children under a
             # builtin-typed element are illegal even when the lexical
             # text is fine (dtZ86723 — the xsi:type-overridden root

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

@@ -120,6 +120,71 @@ module Lutaml
           "NOTATION" => %w[QName anySimpleType anyType].freeze,
         }.freeze
 
+        # The VALUE-SPACE key of a lexical under a union member
+        # builtin — nil when the member does not accept the lexical.
+        # A union maps a lexical through its FIRST accepting member
+        # (§4.1.7), so 'true' and '1' are both boolean-true (stE050)
+        # and token collapse equates trailing blanks (stE065/066).
+        #
+        # @param local [String] builtin member local name
+        # @param value [String] the lexical
+        # @return [Object, nil] a comparable value, or nil
+        def self.union_member_value_key(local, value)
+          text = value.to_s
+          case local
+          when "boolean"
+            b = text.strip
+            return nil unless b.match?(/\A(?:true|false|1|0)\z/)
+
+            %w[true 1].include?(b)
+          when *INTEGER_TYPES
+            return nil unless integer_valid?(local, text)
+
+            Integer(text.strip)
+          when "float", "double"
+            return nil unless text.strip.match?(
+              /\A(?:[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?|INF|-INF|NaN)\z/,
+            )
+
+            f = Float(text.strip)
+            f.nan? ? "nan" : f
+          when "decimal"
+            return nil unless text.strip.match?(
+              /\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)\z/,
+            )
+
+            require "bigdecimal"
+            BigDecimal(text.strip)
+          when "string"
+            text
+          when "normalizedString"
+            text.gsub(/[\t\n\r]/, " ")
+          when *COLLAPSED_STRING_TYPES, "language", "Name", "NCName",
+            "ID", "IDREF", "NMTOKEN", "anyURI"
+            text.strip.split(/\s+/).join(" ")
+          when "gYear", "gYearMonth", "gMonth", "gMonthDay", "gDay"
+            return nil unless calendar_lexical_valid?(local, text)
+
+            calendar_key(text)
+          when "date", "dateTime", "time"
+            return nil unless lexical_answer(local, text) == true
+
+            temporal_key(text)
+          when "duration"
+            return nil unless duration_valid?(text)
+
+            duration_key(text)
+          when "hexBinary"
+            return nil unless text.match?(/\A(?:[0-9a-fA-F]{2})*\z/)
+
+            text.upcase
+          when "base64Binary"
+            return nil unless base64_valid?(text)
+
+            text
+          end
+        end
+
         # Whether a builtin override local is validly derived from the
         # declared local: identity or the declared name sits in the
         # override's builtin ancestry. TRI-STATE: nil when the override

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.114"
+    VERSION = "1.2.115"
   end
 end

metadata

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