lutaml-xsd 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c78737c6dd26a5aa2ab915675b5fc5ce6316590d776d9ef6d5947988ef804adf
-  data.tar.gz: 56dd63144161aa1f7065067fcc74cf434bf9d40e1e1059c7e48e3cd99da00124
+  metadata.gz: a22b97347b4ad22fc7698a047a1037f4b16c5a6bad3ed0154701908f0052ea29
+  data.tar.gz: 0a3d2bd48d987524cbdc427adefcdc128ebcd089a2ed5e25203c28ff27ba4416
 SHA512:
-  metadata.gz: 89fe169405a033ca52e85b7017e65075167766a5bfba5b2c779483b7ff9ca0ea0a568daa799fdee61009e1e385af0c584b91e7e4af1bbcd578da67501e626107
-  data.tar.gz: b18d6e86f3ee582dbe52ace10581e2ea015681f6742bee4601b5a202e9ebc5e16e1878af8763cee247b2c452a18fe817d4e585cd067b403f5667ef52243c2ae9
+  metadata.gz: 304b7555580c9bd6b79464b3b2d9ff73d9c69177790fbcd8bb97b9b0438fdc96b19ce19bdbaba4a9a3c2c6446402e81ee457614cd3e33c3dac35e02b2c948d74
+  data.tar.gz: 39593e00b27fb41c0fe4e374b682c4172dabcf56cd8250e2917f76c135e9f6421e1c65eaca4c0c3896a7d03bae1395fa18c8a1b6f8e38bb3e23cbfa4e195ef6a

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    lutaml-xsd (1.2.0)
+    lutaml-xsd (1.2.1)
       liquid (>= 4.0, < 6.0)
-      lutaml-model (~> 0.8.114)
+      lutaml-model (~> 0.8.123)
       lutaml-store (~> 0.3)
       moxml (~> 0.5.147)
       paint (~> 2.3)
@@ -264,7 +264,7 @@ CHECKSUMS
   liquid (5.14.0) sha256=e1020c2b2ee58c7a4d3bfdc7a331537bd27a783353748bff0bf27c6ac0c17065
   lutaml-model (0.8.123) sha256=475f391371965f5baee2a9d018a7c9da8361c3774d3802749aa8805ee1253fde
   lutaml-store (0.3.2) sha256=9c455dbab32b4c635c48a27213f6f56fda191731c4574eb6187184ba0588a672
-  lutaml-xsd (1.2.0)
+  lutaml-xsd (1.2.1)
   memo_wise (1.13.0) sha256=30220c38c4cef410849bc73553c58664dc2c91c6379e4a1df22aea02358b716b
   moxml (0.5.153) sha256=561c6df843edd4a3b7f4c6785f9cfd6fef61050df7f1113fdcd45d8495704fc2
   nokogiri (1.19.4-aarch64-linux-gnu) sha256=1269fb644a6de405057a53dd5c762b1209b43ca7424f839454d3dbc677c31a8f

data/TODO.conformance.md

@@ -89,7 +89,13 @@ Remaining engine-mode gaps (tracked, moxml/leptris-side):
       resolution (unknown-type rejection; content walk follows the
       override); the engine's valid-derived false positive is fixed in
       leptris 1.9.380.2 (moxml#433)
-- [ ] Particle checking: UPA detection — DEFERRED (engine covers the
-      tier-1 subset; UPA is schema-side checking)
+- [x] Particle checking: UPA detection (2026-10-22) —
+      `UniqueParticleAttribution` schema-side checker: first-set
+      computation over sequence/choice/all with wildcard/element
+      overlap, choice-alternative and sequence-junction conflict rules,
+      container occurrence folding. Standalone API
+      (`findings` → upa_violation findings); zero findings on the
+      conformance corpus schemas (no false positives). Deferred depth:
+      xs:group expansion, substitution-group-aware first-sets
 - [ ] XSD 1.1 constructs behind a version flag — DEFERRED: 1.1 strategy
       decision needed (see TODO.som.md)

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

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    module Validation
+      # Schema-side Unique Particle Attribution checking (XSD 1.0 §3.8.6).
+      #
+      # Reports content models where an instance element could match more
+      # than one particle, making a valid document's interpretation
+      # ambiguous:
+      # - xs:choice: overlapping first-sets between alternatives
+      # - xs:sequence: a nullable or repeatable particle followed by a
+      #   particle matching the same first element
+      # - element vs wildcard and wildcard vs wildcard overlaps at the
+      #   same junctions
+      #
+      # First-sets are computed recursively over nested
+      # sequence/choice/all containers; xs:group references are treated
+      # as opaque (not descended) and contribute no names.
+      #
+      #     findings = UniqueParticleAttribution.new(schema).findings
+      #     findings.each { |f| puts "#{f.code}: #{f.message}" }
+      class UniqueParticleAttribution
+        Finding = Struct.new(:code, :message, :path, keyword_init: true)
+
+        FirstSet = Struct.new(:names, :wildcards, :nullable, :repeatable) do
+          def merge(other)
+            FirstSet.new(
+              names | other.names,
+              wildcards | other.wildcards,
+              nullable || other.nullable,
+            )
+          end
+
+          def overlaps?(other)
+            names.intersect?(other.names) ||
+              wildcards.any? { |w| other.wildcards.any? { |o| wildcard_overlap?(w, o) } } ||
+              wildcards.any? { |w| other.names.any? { |name| wildcard_admits?(w, name) } } ||
+              other.wildcards.any? { |w| names.any? { |name| wildcard_admits?(w, name) } }
+          end
+
+          private
+
+          # Conservative wildcard-pair overlap: ##any overlaps everything;
+          # distinct constraints are treated as overlapping only when
+          # identical (##local, ##other, lists, single namespaces).
+          def wildcard_overlap?(left, right)
+            left == right || left == "##any" || right == "##any"
+          end
+
+          def wildcard_admits?(wildcard, (namespace, _name))
+            case wildcard
+            when "##any", "" then true
+            when "##local" then namespace.empty?
+            when "##other" then !namespace.empty?
+            when "##targetNamespace" then false
+            else wildcard.split(/\s+/).include?(namespace)
+            end
+          end
+        end
+
+        EMPTY_FIRST = FirstSet.new([].freeze, [].freeze, true).freeze
+
+        # @param schema [Lutaml::Xml::Schema::Xsd::Schema] parsed schema
+        def initialize(schema)
+          @schema = schema
+          @seen = {}.compare_by_identity
+        end
+
+        # @return [Array<Finding>] UPA violations, empty when deterministic
+        def findings
+          compute! unless @computed
+          @findings
+        end
+
+        private
+
+        def compute!
+          @findings = []
+          Array(@schema.element).each do |element|
+            check_type(element.complex_type, "/#{element.name}") if
+              element.complex_type
+          end
+          Array(@schema.complex_type).each do |complex_type|
+            check_type(complex_type, complex_type.name.to_s)
+          end
+          @computed = true
+        end
+
+        def check_type(type, path)
+          return unless type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
+
+          container = type.sequence || type.choice || type.all
+          check_container(container, path) if container
+        end
+
+        # Walks a container: checks its own junctions, then descends.
+        def check_container(container, path)
+          return unless container
+          return if @seen[container]
+
+          @seen[container] = true
+
+          particles = ordered_particles(container)
+          check_junctions(particles, container, path)
+          particles.each do |particle|
+            case particle
+            when Lutaml::Xsd::Sequence, Lutaml::Xsd::Choice, Lutaml::Xsd::All
+              check_container(particle, "#{path}/#{particle_name(particle)}")
+            end
+          end
+        end
+
+        def check_junctions(particles, container, path)
+          firsts = particles.map { |p| first_set(p) }
+
+          if container.is_a?(Lutaml::Xsd::Choice)
+            check_choice_overlap(particles, firsts, path)
+          else
+            check_sequence_junctions(particles, firsts, path)
+          end
+        end
+
+        def check_choice_overlap(particles, firsts, path)
+          firsts.each_with_index do |first, i|
+            firsts[(i + 1)..].each_with_index do |other, j|
+              next unless first.overlaps?(other)
+
+              report(
+                path,
+                "ambiguous choice: '#{particle_name(particles[i])}' and " \
+                "'#{particle_name(particles[i + 1 + j])}' can match the " \
+                "same element",
+              )
+            end
+          end
+        end
+
+        def check_sequence_junctions(particles, firsts, path)
+          firsts.each_with_index do |first, i|
+            next if i.zero?
+
+            previous = firsts[i - 1]
+            next unless previous.nullable || previous.repeatable
+            next unless first.overlaps?(previous)
+
+            report(
+              path,
+              "ambiguous sequence: '#{particle_name(particles[i - 1])}' " \
+              "can be followed by '#{particle_name(particles[i])}' — both " \
+              "match the same first element",
+            )
+          end
+        end
+
+        def report(path, message)
+          @findings << Finding.new(
+            code: "upa_violation",
+            message: message,
+            path: path,
+          )
+        end
+
+        # First-set of a particle: the element names and wildcards it can
+        # match first, and whether it can be absent. Repeatable marks
+        # particles whose occurrence permits more than one match.
+        def first_set(particle)
+          case particle
+          when Lutaml::Xml::Schema::Xsd::Element
+            FirstSet.new([element_key(particle)].compact, [].freeze,
+                         parse_min(particle).zero?).tap do |first|
+              first.repeatable = parse_max(particle) != 1
+            end
+          when Lutaml::Xsd::Any
+            FirstSet.new([].freeze, [wildcard_spec(particle)].compact,
+                         parse_min(particle).zero?).tap do |first|
+              first.repeatable = parse_max(particle) != 1
+            end
+          when Lutaml::Xsd::Sequence
+            apply_occurrence(sequence_first(particle), particle)
+          when Lutaml::Xsd::Choice, Lutaml::Xsd::All
+            apply_occurrence(choice_first(particle), particle)
+          else
+            EMPTY_FIRST
+          end
+        end
+
+        # A container particle's own occurrence widens its computed
+        # first-set: minOccurs="0" makes it nullable, max≠1 repeatable.
+        def apply_occurrence(first, particle)
+          first.nullable ||= parse_min(particle).zero?
+          first.repeatable ||= parse_max(particle) != 1
+          first
+        end
+
+        # Leading names until the first required, exactly-once particle;
+        # nullable only when every particle can be absent.
+        def sequence_first(sequence)
+          names = []
+          wildcards = []
+          nullable = true
+          repeatable = false
+          ordered_particles(sequence).each do |particle|
+            first = first_set(particle)
+            names |= first.names
+            wildcards |= first.wildcards
+            repeatable ||= first.repeatable
+            unless first.nullable
+              nullable = false
+              break
+            end
+          end
+          FirstSet.new(names, wildcards, nullable).tap do |first|
+            first.repeatable = repeatable
+          end
+        end
+
+        def choice_first(choice)
+          names = []
+          wildcards = []
+          nullable = false
+          repeatable = false
+          ordered_particles(choice).each do |particle|
+            first = first_set(particle)
+            names |= first.names
+            wildcards |= first.wildcards
+            nullable ||= first.nullable
+            repeatable ||= first.repeatable
+          end
+          FirstSet.new(names, wildcards, nullable).tap do |first|
+            first.repeatable = repeatable
+          end
+        end
+
+        # Particles in declaration order — resolved_element_order preserves
+        # the source sequence including xs:any, which attribute-style
+        # accessor reads would reorder.
+        def ordered_particles(container)
+          ordered = container.resolved_element_order
+          return ordered.to_a if ordered.to_a.any?
+
+          case container
+          when Lutaml::Xml::Schema::Xsd::Sequence,
+               Lutaml::Xml::Schema::Xsd::Choice
+            %i[element any sequence choice].flat_map do |kind|
+              Array(container.public_send(kind))
+            end.compact
+          when Lutaml::Xml::Schema::Xsd::All
+            Array(container.element).compact
+          else
+            []
+          end
+        end
+
+        def element_key(element)
+          name = element.name || element.ref
+          return nil if name.to_s.empty?
+
+          namespace = if element.name
+                        element.target_namespace.to_s
+                      else
+                        @schema.target_namespace.to_s
+                      end
+          [namespace, name.to_s]
+        end
+
+        def wildcard_spec(any_particle)
+          any_particle.namespace.to_s
+        end
+
+        def parse_min(particle)
+          value = particle.min_occurs.to_s
+          value.empty? ? 1 : value.to_i
+        rescue StandardError
+          1
+        end
+
+        def parse_max(particle)
+          value = particle.max_occurs.to_s
+          return Float::INFINITY if value == "unbounded"
+          return 1 if value.empty?
+
+          value.to_i
+        rescue StandardError
+          1
+        end
+
+        def particle_name(particle)
+          case particle
+          when Lutaml::Xml::Schema::Xsd::Element
+            particle.name || particle.ref || "element"
+          when Lutaml::Xsd::Any then "any"
+          when Lutaml::Xsd::Choice then "choice"
+          when Lutaml::Xsd::Sequence then "sequence"
+          when Lutaml::Xsd::All then "all"
+          else particle.class.name.split("::").last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.1"
+    VERSION = "1.2.2"
   end
 end

data/lutaml-xsd.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   end
 
   spec.add_dependency "liquid", ">= 4.0", "< 6.0"
-  spec.add_dependency "lutaml-model", "~> 0.8.114"
+  spec.add_dependency "lutaml-model", "~> 0.8.123"
   spec.add_dependency "lutaml-store", "~> 0.3"
   spec.add_dependency "moxml", "~> 0.5.147"
   spec.add_dependency "paint", "~> 2.3"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-22 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -36,14 +36,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.114
+        version: 0.8.123
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.114
+        version: 0.8.123
 - !ruby/object:Gem::Dependency
   name: lutaml-store
   requirement: !ruby/object:Gem::Requirement
@@ -576,6 +576,7 @@ files:
 - lib/lutaml/xsd/validation/schema_definition_resolver.rb
 - lib/lutaml/xsd/validation/schema_location_extractor.rb
 - lib/lutaml/xsd/validation/schema_resolver.rb
+- lib/lutaml/xsd/validation/unique_particle_attribution.rb
 - lib/lutaml/xsd/validation/validation_configuration.rb
 - lib/lutaml/xsd/validation/validation_error.rb
 - lib/lutaml/xsd/validation/validation_job.rb