moxml 0.5.165 → 0.5.167

data/lib/moxml/xsd/schema_rules.rb

@@ -105,7 +105,9 @@ module Moxml
             when "##defined" then :defined
             when "##definedSibling" then :sibling
             when /\A([^:]+):(.+)\z/
-              uri = prefix_uri(Regexp.last_match(1), element)
+              uri = ::Moxml::XSD::SchemaRules.prefix_uri(
+                Regexp.last_match(1), element
+              )
               "{#{uri}}#{Regexp.last_match(2)}" unless uri.empty?
             else
               "{}#{token}"
@@ -113,23 +115,6 @@ module Moxml
           end
         end
 
-        # node.namespaces is adapter-divergent (some engines return
-        # in-scope bindings, others own-node declarations only), so
-        # the in-scope map is walked out by hand — per-node
-        # definitions merged along the ancestor axis, deeper
-        # overriding shallower, identically on every adapter.
-        def prefix_uri(prefix, element)
-          bindings = {}
-          node = element
-          while node
-            node.namespaces.each do |namespace|
-              bindings[namespace.prefix] = namespace.uri
-            end
-            node = node.parent&.element? ? node.parent : nil
-          end
-          bindings[prefix].to_s
-        end
-
         def entry_covers?(entry, namespace)
           namespace == case entry
                        when "##targetNamespace" then :tns
@@ -140,11 +125,34 @@ module Moxml
       end
 
       ContentModel = Struct.new(:declared_children, :any,
-                                :declared_attributes, :any_attribute)
+                                :declared_attributes, :any_attribute,
+                                :particles, :pure_sequence)
       SchemaIndex = Struct.new(:target_namespace, :element_default,
                                :attribute_default, :elements,
                                :attributes, :contents, :version,
-                               :element_patterns, :attribute_patterns)
+                               :element_patterns, :attribute_patterns,
+                               :substitution_members)
+
+      # Resolves a QName token against an element's in-scope
+      # bindings. node.namespaces is adapter-divergent (some
+      # engines return in-scope bindings, others own-node
+      # declarations only), so the in-scope map is walked out by
+      # hand — per-node definitions merged along the ancestor
+      # axis, deeper overriding shallower, identically on every
+      # adapter. Unresolvable prefixes yield "".
+      module_function
+
+      def prefix_uri(prefix, element)
+        bindings = {}
+        node = element
+        while node
+          node.namespaces.each do |namespace|
+            bindings[namespace.prefix] = namespace.uri
+          end
+          node = node.parent&.element? ? node.parent : nil
+        end
+        bindings[prefix].to_s
+      end
 
       # The XSD 1.1 version-tagging namespace (Structures §C.3):
       # vc:minVersion / vc:maxVersion gate 1.1 constructs.
@@ -243,7 +251,7 @@ module Moxml
             root["targetNamespace"].to_s,
             root["elementFormDefault"] == "qualified",
             root["attributeFormDefault"] == "qualified",
-            {}, {}, {}, schema_version(root), {}, {}
+            {}, {}, {}, schema_version(root), {}, {}, {}
           )
           child_elements(root).each do |decl|
             case decl.name
@@ -339,27 +347,36 @@ module Moxml
           sink[name] = sink.key?(name) ? nil : patterns
         end
 
-        # Dismisses engine lexical findings the source's own
-        # pattern facets refute (#464): an engine that cannot
-        # evaluate a dialect construct rejects every occurrence of
-        # the facet — including values the facet accepts. A
-        # finding is dropped only when every same-named instance
-        # in the document matches; one non-matching value keeps
-        # the engine's answer, so a dismissal can only remove
-        # false rejections, never create false acceptances.
+        # Dismisses engine findings the schema source refutes:
+        #
+        # * lexical findings pattern facets accept (#464) — dropped
+        #   only when every same-named instance matches the facet;
+        # * content-model findings that reject a substitution-group
+        #   member (#466 class 1) — dropped only when the parent's
+        #   content model is a pure sequence, the child sequence
+        #   matches it position-for-position with every particle
+        #   exactly-once, and a substitution member resolves a
+        #   position. One non-vouching instance — or any real
+        #   mismatch — keeps the engine's answer, so a dismissal
+        #   can only remove false rejections, never create false
+        #   acceptances.
         def dismiss(engine_errors, doc, index)
           return engine_errors unless index
 
           vouched = vouch_table(doc, index)
           engine_errors.reject do |error|
-            subject = lexical_subject(error.message)
-            subject && vouched[subject]
+            if (subject = lexical_subject(error.message))
+              vouched[subject]
+            elsif (sequence = content_model_subject(error.message))
+              sequence_vouched?(doc, index, *sequence)
+            end
           end
         end
 
         LEXICAL_MESSAGE = /\A(?:element|attribute) '([^']+)' @\d+:\d+: (element|attribute) '([^']+)': lexical value does not match its type\z/
+        CONTENT_MODEL_MESSAGE = /\Aelement '([^']+)' @\d+:\d+: element '([^']+)': children do not match the content model \(at '([^']+)'\)\z/
 
-        private_constant :LEXICAL_MESSAGE
+        private_constant :LEXICAL_MESSAGE, :CONTENT_MODEL_MESSAGE
 
         def lexical_subject(message)
           match = LEXICAL_MESSAGE.match(message.to_s)
@@ -368,6 +385,81 @@ module Moxml
           [match[2], match[3]]
         end
 
+        def content_model_subject(message)
+          match = CONTENT_MODEL_MESSAGE.match(message.to_s)
+          return unless match
+
+          [match[2], match[3]]
+        end
+
+        # Every same-named element in the document must vouch: a
+        # sequence the finding names could be valid while another
+        # same-named one is not. The root is included — the
+        # engine's finding can name it.
+        def sequence_vouched?(doc, index, name, offender)
+          root = doc.root
+          return false unless root
+
+          witnesses = []
+          yield_self = root.name == name
+          witnesses << sequence_valid?(root, index, offender) if yield_self
+          each_named_element(root, name) do |element|
+            witnesses << sequence_valid?(element, index, offender)
+          end
+          !witnesses.empty? && witnesses.all?
+        end
+
+        def each_named_element(node, name, &block)
+          child_elements(node).each do |child|
+            yield child if child.name == name
+            each_named_element(child, name, &block)
+          end
+        end
+
+        # The airtight witness: child count equals particle count,
+        # every position resolves to its particle's name or a
+        # registered member of it, every particle occurs exactly
+        # once, and the reported offender is a substitution member
+        # realized at some position. Anything else leaves the
+        # engine's answer standing.
+        def sequence_valid?(element, index, offender)
+          model = index.contents[qname(element)]
+          return false unless model&.pure_sequence
+
+          particles = model.particles
+          children = child_elements(element)
+          return false if children.empty? || children.size != particles.size
+
+          resolved = false
+          children.each_with_index do |child, position|
+            particle_name, min, max = particles[position]
+            child_qname = qname(child)
+            return false unless exactly_once?(min, max)
+
+            if child_qname == particle_name
+              next
+            elsif index.substitution_members.fetch(particle_name, [])
+                .include?(child_qname)
+              resolved = true
+            else
+              return false
+            end
+          end
+          resolved && offender_realized?(children, offender, index)
+        end
+
+        def exactly_once?(min, max)
+          min <= 1 && (max == :unbounded || max >= 1)
+        end
+
+        def offender_realized?(children, offender, index)
+          members = index.substitution_members.values.flatten
+          children.any? do |child|
+            child.name == offender &&
+              members.include?(qname(child))
+          end
+        end
+
         def vouch_table(doc, index)
           root = doc.root
           return {} unless root
@@ -434,6 +526,9 @@ module Moxml
           name = decl["name"] or return
           qname = "{#{index.target_namespace}}#{name}"
           index.elements[qname] = { nillable: decl["nillable"] == "true" }
+          if (head = decl["substitutionGroup"])
+            register_substitution(head, decl, qname, index)
+          end
           type_attr = decl.attribute("type")
           model = if type_attr.nil? || type_attr.value.empty?
                     inline_model(decl, index)
@@ -443,6 +538,23 @@ module Moxml
           index.contents[qname] = model if model
         end
 
+        # substitutionGroup is a QName resolved against the global
+        # declaration's in-scope bindings (#466 class 1); the
+        # member's own qname is target-namespace-qualified — global
+        # declarations always are.
+        def register_substitution(head, decl, member_qname, index)
+          if head.include?(":")
+            prefix, _, local = head.partition(":")
+            uri = prefix_uri(prefix, decl)
+            return if uri.empty?
+
+            head_qname = "{#{uri}}#{local}"
+          else
+            head_qname = "{}#{head}"
+          end
+          (index.substitution_members[head_qname] ||= []) << member_qname
+        end
+
         def index_global_attribute(decl, index)
           name = decl["name"] or return
           index.attributes["{#{index.target_namespace}}#{name}"] = true
@@ -468,7 +580,7 @@ module Moxml
         end
 
         def content_model(type_node, index)
-          model = ContentModel.new([], nil, [], nil)
+          model = ContentModel.new([], nil, [], nil, [], true)
           collect_model(type_node, index, model)
           model
         end
@@ -477,36 +589,58 @@ module Moxml
         # choice / all / complexContent wrappers flattened): we only
         # ADD findings for strict-wildcard matches, so flattening
         # can only under-report, never over-report. Cardinality and
-        # order stay the engine's job.
+        # order stay the engine's job — EXCEPT for the substitution
+        # dismissal (#466 class 1), which vouches only for pure
+        # sequences: any choice/all marks the model impure and the
+        # flattened order is then not a validity witness.
         def collect_model(node, index, model)
           child_elements(node).each do |child|
             case child.name
             when "element"
-              add_particle(child, index, model,
-                           model.declared_children)
+              if (qname = particle_qname(child, index))
+                model.declared_children << qname
+                model.particles << [
+                  qname,
+                  occur_value(child, "minOccurs", 1),
+                  occur_value(child, "maxOccurs", 1),
+                ]
+              end
             when "attribute"
-              add_particle(child, index, model,
-                           model.declared_attributes)
+              if (qname = particle_qname(child, index))
+                model.declared_attributes << qname
+              end
             when "any"
               model.any ||= wildcard_from(child)
             when "anyAttribute"
               model.any_attribute ||= wildcard_from(child)
+            when "choice", "all"
+              model.pure_sequence = false
+              collect_model(child, index, model)
             else
               collect_model(child, index, model)
             end
           end
         end
 
-        def add_particle(particle, index, _model, sink)
+        def particle_qname(particle, index)
           ref = particle["ref"]
           name = ref&.split(":")&.last || particle["name"]
           return unless name
 
-          sink << if ref
-                    "{#{index.target_namespace}}#{name}"
-                  else
-                    "{#{form_namespace(particle, index)}}#{name}"
-                  end
+          if ref
+            "{#{index.target_namespace}}#{name}"
+          else
+            "{#{form_namespace(particle, index)}}#{name}"
+          end
+        end
+
+        def occur_value(particle, attribute, default)
+          value = particle[attribute]
+          return :unbounded if value == "unbounded"
+
+          Integer(value || default)
+        rescue ArgumentError
+          default
         end
 
         # Particles declare with form="qualified"/"unqualified",

data/lib/moxml/xsd.rb

@@ -177,15 +177,49 @@ module Moxml
         @context.config.adapter.xsd_declarations(@handle)
       end
 
-      # The effective schema version the source declares (#460 item
-      # 2): "1.1" when the root carries vc:minVersion="1.1", else
-      # "1.0". Consumers (lutaml-xsd) scope 1.0-only checks with
-      # it; the engine's application of 1.1 semantics is the
-      # engine-side program.
+      # The effective schema version (#460 item 2): "1.1" or
+      # "1.0". The engine's answer (root @version) can only
+      # UPGRADE to 1.1 — it never downgrades the source-derived
+      # answer, because vc:minVersion="1.1" selects 1.1 semantics
+      # even when @version is absent, and @version="1.1" alongside
+      # vc:minVersion="1.0" is an authoring contradiction the
+      # source annotation wins.
       def version
+        adapter = @context.config.adapter
+        engine = if adapter.respond_to?(:xsd_version)
+                   adapter.xsd_version(@handle)
+                 end
+        return "1.1" if engine == "1.1"
+
         @rules_index ? @rules_index.version : "1.0"
       end
 
+      # One row per engine finding with the structured fields the
+      # #1843 report carries (moxml#460): kind, component, line,
+      # column, message. Nil when the binding predates the face —
+      # callers keep using #validate/#errors for the flat shape.
+      EngineFinding = Struct.new(:kind, :component, :line, :column,
+                                 :message)
+
+      def structured_errors(node_or_xml)
+        check_released!
+        doc = case node_or_xml
+              when Moxml::Document then node_or_xml
+              when Moxml::Node then node_or_xml.document
+              else @context.parse(node_or_xml.to_s)
+              end
+        adapter = @context.config.adapter
+        rows = if adapter.respond_to?(:xsd_structured_errors)
+                 adapter.xsd_structured_errors(@handle, doc.native)
+               end
+        return nil unless rows
+
+        rows.map do |r|
+          EngineFinding.new(r.kind, r.component, r.line, r.column,
+                            r.message)
+        end
+      end
+
       # Deterministic drop (#362.3): true when the adapter freed
       # the engine-side schema NOW; false when the adapter can only
       # wait for GC (documented per adapter). After a true release

data/spec/consistency/xpath_idioms_spec.rb

@@ -122,6 +122,19 @@ RSpec.describe "XPath idioms across adapters" do
         expect(doc.at_xpath("count(//a)")).to eq(1.0)
       end
 
+      # The parent of an attribute node is its OWNER element
+      # (XPath 1.0 section 2.2) — the load-bearing arm of standoc's
+      # svg id disambiguation (#474).
+      it "answers the parent-of-attribute step with the owner element" do
+        doc = ctx.parse("<r><svg id='s'><use id='u'/></svg></r>")
+        svg = doc.xpath("//*[local-name()='svg']").first
+        expect(svg.xpath("./@id/..").map(&:name)).to eq(["svg"])
+        expect(svg.xpath("./@id/parent::*").map(&:name)).to eq(["svg"])
+        expect(
+          svg.xpath(".//*[@id] | ./@id/..").map(&:name).sort,
+        ).to eq(%w[svg use])
+      end
+
       # The live-tree contract: a sibling inserted after an XPath
       # evaluation must be visible to at_xpath and xpath. leptris's
       # node-set lane caches a document index that sibling insertions

data/spec/moxml/adapter/leptris_crossdoc_replace_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# leptris#1866: a cross-document replace used to hand back the
+# SCRATCH document's wrapper — the adapter's insert deep-copies the
+# subtree into the target, so the returned wrapper's native pointer
+# belonged to the scratch arena. Callers stored it (svg cleanup
+# keeps `new_svg` for id bookkeeping), the scratch was collected,
+# and every later read of the stored wrapper walked freed memory:
+# serializer segfaults and `<use ="">` empty-attribute names in
+# the output.
+RSpec.describe "leptris cross-document replace survival" do
+  let(:context) { Moxml.new(:leptris) }
+
+  it "keeps the installed wrapper valid after the scratch is collected" do
+    host = context.parse(
+      '<root xmlns:xlink="http://www.w3.org/1999/xlink">' \
+      '<svg xmlns="http://www.w3.org/2000/svg" id="s1">' \
+      '<use xlink:href="#a"/><use href="#b"/></svg></root>',
+    )
+    scratch = context.parse(
+      "<svg xmlns=\"http://www.w3.org/2000/svg\" id=\"fresh\">" \
+      "<use xlink:href=\"#fx\"/><use href=\"#b\"/></svg>",
+    )
+    olds = host.root.children.select { |c| c.name == "svg" }
+    olds[0].replace(scratch.root)
+    GC.start(full_mark: true, immediate_sweep: true)
+    out = host.root.to_xml
+    expect(out).not_to include("<use =")
+    # the installed copy's OWN content survives the scratch GC
+    expect(out).to include("fx").and include("#b")
+    # NOTE: pre-existing divergence D-22 (materialized-wrapper
+    # lane) — the UNREPLACED siblings of a cross-doc replace are
+    # dropped; reproduced on the stock adapter before this fix.
+  end
+end

data/spec/moxml/adapter/leptris_native_parent_axis_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# The parent step answers the OWNER element natively on bindings
+# serving the fixed engine (1.9.385: leptris#1869 parent-of-attribute
+# names the owner; the cross-doc adopt keeps its attribute chain) —
+# moxml#474: the reverse-axis gate used to route every parent-axis
+# expression to the Ruby engine, so the fast consumers (standoc's
+# svg id cleanup runs `.//*[@id] | ./@id/..` per styled svg) paid
+# the interpreter. Other reverse axes keep the Ruby lane (their
+# native results are reverse-ordered; document order is the
+# model's contract).
+RSpec.describe "leptris native parent-axis lane" do
+  let(:ctx) { Moxml.new(:leptris) }
+  let(:doc) do
+    ctx.parse('<root><svg id="s"><use id="u"/></svg></root>')
+  end
+  let(:svg) { doc.xpath("//*[local-name()='svg']").first }
+
+  it "routes parent-of-attribute expressions to the native lane" do
+    native = svg.adapter.native_xpath(
+      svg.native, "./@id/..", {}
+    )
+    expect(native).not_to be_nil
+  end
+
+  it "answers the owner element through the facade" do
+    expect(svg.xpath("./@id/..").map(&:name)).to eq(["svg"])
+    expect(svg.xpath("./@id/..").first).to equal(svg)
+  end
+
+  it "serves the two-arm union natively" do
+    expect(
+      svg.xpath(".//*[@id] | ./@id/..").map(&:name).sort,
+    ).to eq(%w[svg use])
+  end
+
+  it "keeps non-parent reverse axes on the Ruby lane" do
+    doc2 = ctx.parse('<r><e a="1" b="2" c="3"/></r>')
+    e = doc2.xpath("//e").first
+    expect(e.xpath("ancestor::*").map(&:name)).to eq(["r"])
+    native = e.adapter.native_xpath(e.native, "ancestor::*", {})
+    expect(native).to be_nil
+  end
+end

data/spec/moxml/xsd_engine_meta_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Processing model §Validation (normative): pinned here.
+# moxml#460 items 1-2: the engine's metadata routes through the
+# facade. On bindings predating the faces the probes answer nil and
+# the facade degrades exactly as before (rules heuristic / flat
+# errors) — the degradation is part of the contract.
+RSpec.describe "Moxml::XSD engine metadata" do
+  let(:context) { Moxml.new(:leptris) }
+
+  describe "degradation on faces-less adapters" do
+    it "answers the source-derived version and nil structured rows" do
+      ctx = Moxml.new(:nokogiri)
+      skip "nokogiri requires an XSD-capable engine" unless
+        Moxml::XSD.supported?(ctx)
+      schema = ctx.xsd(
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" version=\"1.1\"><xs:element name=\"e\" type=\"xs:string\"/></xs:schema>",
+      )
+      expect(schema.version).to eq("1.0")
+      expect(schema.structured_errors("<e/>")).to be_nil
+    end
+  end
+
+  describe "Schema#version" do
+    it "answers 1.1 for a 1.1-tagged schema when the binding serves it" do
+      schema = context.xsd(
+        '<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" ' \
+        'version="1.1">' \
+        '<xs:element name="e" type="xs:string"/></xs:schema>',
+      )
+      v = schema.version
+      expect(v).to eq("1.1").or eq("1.0")
+    end
+
+    it "answers 1.0 for an untagged schema" do
+      schema = context.xsd(
+        '<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">' \
+        '<xs:element name="e" type="xs:string"/></xs:schema>',
+      )
+      expect(schema.version).to eq("1.0")
+    end
+  end
+
+  describe "Schema#structured_errors" do
+    it "returns rows with kind/component when the binding serves it" do
+      schema = context.xsd(
+        '<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">' \
+        '<xs:element name="note">' \
+        "<xs:complexType><xs:sequence>" \
+        '<xs:element name="to" type="xs:string"/>' \
+        "</xs:sequence></xs:complexType>" \
+        "</xs:element></xs:schema>",
+      )
+      # a WRONG child, not an empty instance: pre-1.9.383 engines
+      # false-validate empty instances (leptris#1859) — this keeps
+      # the spec meaningful across both engine generations
+      rows = schema.structured_errors("<note><from>x</from></note>")
+      skip "binding predates the structured report" if rows.nil?
+      expect(rows).not_to be_empty
+      expect(rows.first).to respond_to(:kind)
+      expect(rows.first).to respond_to(:component)
+    end
+  end
+end