moxml 0.5.148 → 0.5.150

data/spec/moxml/xpath_capabilities_spec.rb

@@ -81,9 +81,7 @@ RSpec.describe "XPath Capabilities" do
         it "supports attribute value matching ([@attr='value'])" do
           doc = Moxml.new.parse(simple_xml)
           programming = doc.xpath("//book[@category='programming']")
-          expect(programming.length).to be >= 0 # May not work on all
-        rescue Moxml::XPathError
-          skip "D-12: Attribute value predicates not supported on #{adapter_name}"
+          expect(programming.length).to eq(1)
         end
       end
 
@@ -96,9 +94,7 @@ RSpec.describe "XPath Capabilities" do
           }
 
           items = doc.xpath("//book:item", namespaces)
-          expect(items.length).to be >= 0
-        rescue Moxml::XPathError, NoMethodError
-          skip "D-12: Namespace XPath not supported on #{adapter_name}"
+          expect(items.length).to eq(2)
         end
 
         it "handles default namespaces" do
@@ -106,9 +102,7 @@ RSpec.describe "XPath Capabilities" do
           namespaces = { "lib" => "http://library.org" }
 
           library = doc.xpath("//lib:library", namespaces)
-          expect(library.length).to be >= 0
-        rescue Moxml::XPathError, NoMethodError
-          skip "D-12: Default namespace XPath not supported on #{adapter_name}"
+          expect(library.length).to eq(1)
         end
       end
 
@@ -116,17 +110,13 @@ RSpec.describe "XPath Capabilities" do
         it "supports numeric positions ([1])" do
           doc = Moxml.new.parse(simple_xml)
           first_book = doc.xpath("//book[1]")
-          expect(first_book.length).to be >= 0
-        rescue Moxml::XPathError
-          skip "D-12: Position predicates not supported on #{adapter_name}"
+          expect(first_book.length).to eq(1)
         end
 
         it "supports position() function" do
           doc = Moxml.new.parse(simple_xml)
           first_books = doc.xpath("//book[position()=1]")
-          expect(first_books.length).to be >= 0
-        rescue Moxml::XPathError
-          skip "D-12: position() function not supported on #{adapter_name}"
+          expect(first_books.length).to eq(1)
         end
       end
 
@@ -134,20 +124,13 @@ RSpec.describe "XPath Capabilities" do
         it "supports count() function, returning the scalar unwrapped" do
           doc = Moxml.new.parse(simple_xml)
           result = doc.xpath("count(//book)")
-          # REXML's XPath has no function support and yields an empty set
-          skip "D-12: count() function not supported on #{adapter_name}" if result.is_a?(Moxml::NodeSet)
-
           expect(result).to eq(2)
-        rescue Moxml::XPathError, NoMethodError
-          skip "D-12: count() function not supported on #{adapter_name}"
         end
 
         it "supports text() node selection" do
           doc = Moxml.new.parse(simple_xml)
           texts = doc.xpath("//title/text()")
-          expect(texts.length).to be >= 0
-        rescue Moxml::XPathError
-          skip "D-12: text() not supported on #{adapter_name}"
+          expect(texts.length).to eq(3)
         end
       end
 
@@ -155,17 +138,13 @@ RSpec.describe "XPath Capabilities" do
         it "supports numeric comparisons ([@attr < value])" do
           doc = Moxml.new.parse(simple_xml)
           cheap_books = doc.xpath("//book[@id < 2]")
-          expect(cheap_books.length).to be >= 0
-        rescue Moxml::XPathError
-          skip "D-12: Numeric predicates not supported on #{adapter_name}"
+          expect(cheap_books.length).to eq(1)
         end
 
         it "supports boolean expressions ([cond1 and cond2])" do
           doc = Moxml.new.parse(simple_xml)
           result = doc.xpath("//book[@id and @category]")
-          expect(result.length).to be >= 0
-        rescue Moxml::XPathError
-          skip "D-12: Boolean expressions not supported on #{adapter_name}"
+          expect(result.length).to eq(2)
         end
       end
 
@@ -173,17 +152,13 @@ RSpec.describe "XPath Capabilities" do
         it "supports child axis" do
           doc = Moxml.new.parse(simple_xml)
           children = doc.xpath("/library/child::book")
-          expect(children.length).to be >= 0
-        rescue Moxml::XPathError
-          skip "D-12: child:: axis not supported on #{adapter_name}"
+          expect(children.length).to eq(2)
         end
 
         it "supports descendant axis" do
           doc = Moxml.new.parse(simple_xml)
           descendants = doc.xpath("//library/descendant::title")
-          expect(descendants.length).to be >= 0
-        rescue Moxml::XPathError
-          skip "D-12: descendant:: axis not supported on #{adapter_name}"
+          expect(descendants.length).to eq(3)
         end
       end
 
@@ -191,9 +166,7 @@ RSpec.describe "XPath Capabilities" do
         it "supports union (|)" do
           doc = Moxml.new.parse(simple_xml)
           items = doc.xpath("//book | //magazine")
-          expect(items.length).to be >= 0
-        rescue Moxml::XPathError
-          skip "D-12: Union operator not supported on #{adapter_name}"
+          expect(items.length).to eq(3)
         end
       end
     end

data/spec/moxml/xsd_spec.rb

@@ -141,4 +141,42 @@ RSpec.describe Moxml::XSD do
         .to eq(Moxml::Adapter::Leptris::NATIVE_XSD)
     end
   end
+
+  describe "content_valid? with C-minted identity children (moxml#410)",
+           if: Moxml::Adapter::Leptris::XSD_SUPPORTED do
+    let(:ctx) { Moxml.new(:leptris) }
+    let(:schema_text) do
+      <<~XML
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+          <xs:element name="person">
+            <xs:complexType>
+              <xs:sequence>
+                <xs:element name="name" type="xs:string"/>
+              </xs:sequence>
+            </xs:complexType>
+          </xs:element>
+        </xs:schema>
+      XML
+    end
+
+    it "answers for identity wrappers minted at create (1.9.374+)" do
+      schema = ctx.xsd(schema_text)
+      doc = ctx.create_document
+      root = doc.create_element("person")
+      doc.root = root
+      name = doc.create_element("name")
+      name.text = "A"
+      root.add_child(name)
+
+      expect(root.native.class.name).to include("Identity")
+      expect(schema.content_valid?("person", root.children.to_a)).to be(true)
+    end
+
+    it "answers for identity children from parse" do
+      schema = ctx.xsd(schema_text)
+      root = ctx.parse("<person><name>A</name></person>").root
+      expect(schema.content_valid?("person", root.children.to_a)).to be(true)
+      expect(schema.content_valid?("person", [])).to be(false)
+    end
+  end
 end

data/spec/support/input_generator.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# Seeded XML input generator (TODO.sota/02): composes the 01
+# taxonomy's vocabulary into fresh inputs, deterministically from a
+# seed. CI legs run a fixed seed — identical cases every run; the
+# nightly fuzz leg passes a random one (MOXML_FUZZ_SEED). Every case
+# id carries its provenance ("gen <seed>/<i> <malform>"), so a
+# failure reproduces at that seed and index.
+module InputGenerator
+  # Generated inputs record the divergence-relevant features they use
+  # so the differential exempts exactly those cells, never silently —
+  # every value is a register ID (docs/_pages/divergences.adoc).
+  FEATURE_EXEMPT = {
+    inter_element_ws: {
+      nodes: { ox: "D-13", headed_ox: "D-13" },
+      text: { ox: "D-13", headed_ox: "D-13" },
+    },
+    pi_in_content: { text: { oga: "D-14" } },
+    pre_root_ws: { nodes: { rexml: "D-15" }, text: { rexml: "D-15" } },
+    adjacent_cdata: {
+      nodes: { oga: "D-19", rexml: "D-19", ox: "D-19", headed_ox: "D-19",
+               leptris: "D-19" },
+    },
+  }.freeze
+
+  # malform is one of the three guaranteed-breaking structural
+  # mutations; oga's strict lane is lexer-strict (D-17) and is
+  # exempted for all of them in the strict-raise property.
+  Case = Struct.new(:id, :xml, :well_formed, :features, :voids, :malform)
+
+  ELEMENTS = %w[a b sec p].freeze
+  VOIDS = %w[br img hr].freeze
+  ATTR_VALUES = [
+    "1", "x y", "a &amp; b", "&lt;tag&gt;", "&#65;&#x42;", "taillé"
+  ].freeze
+  TEXTS = [
+    "plain text", "  spaced  ", "a &amp; b &lt; c", "&#65;&#x42;",
+    "café &#160; NBSP", "word"
+  ].freeze
+  NAMESPACES = [
+    'xmlns="urn:t"', 'xmlns:ns="urn:n"', 'xmlns="urn:r"'
+  ].freeze
+  XML_ATTRS = ['xml:space="preserve"', 'xml:lang="en"'].freeze
+  MALFORMS = %i[unclosed stray attr_quote].freeze
+
+  module_function
+
+  # mode: :fuzz mixes the three structural malformations into roughly
+  # a third of the cases (the strict-raise property consumes those);
+  # :well_formed answers pure compositions.
+  def cases(seed:, count:, mode: :fuzz)
+    rng = Random.new(seed)
+    Array.new(count) do |i|
+      body, features, voids = compose(rng)
+      id = "gen #{seed}/#{i}"
+      if mode == :fuzz && rng.rand(3).zero?
+        malform = MALFORMS[rng.rand(MALFORMS.length)]
+        Case.new("#{id} #{malform}", mutate(body, malform), false,
+                 features, voids, malform)
+      else
+        Case.new(id, body, true, features, voids, nil)
+      end
+    end
+  end
+
+  def compose(rng)
+    features = []
+    voids = []
+    pre = +""
+    draw = rng.rand(6)
+    if draw.zero?
+      pre << "<!--pre-root-->"
+    elsif draw == 1
+      pre << "<?prep root?>"
+    elsif draw == 2
+      pre << "  "
+      features << :pre_root_ws
+    end
+
+    attrs = +'<r id="root"'
+    attrs << " #{NAMESPACES[rng.rand(NAMESPACES.length)]}" if rng.rand(2).zero?
+    attrs << " #{XML_ATTRS[rng.rand(XML_ATTRS.length)]}" if rng.rand(3).zero?
+    attrs << ' ns:x="v"' if rng.rand(3).zero?
+    attrs << ">"
+
+    body = +""
+    depth = 1 + rng.rand(4)
+    (1 + rng.rand(4)).times { body << child(rng, 0, depth, features, voids) }
+    # a whitespace-only run between two constructs is a dropped-text
+    # divergence cell (D-13 on ox/headed_ox)
+    features << :inter_element_ws if body.match?(%r{>\s+<})
+
+    xml = "#{pre}#{attrs}#{body}</r>"
+    # a default-namespace declaration scopes XPath name tests away
+    # from generated a/b elements (XPath 1.0, processing model
+    # "Names and namespaces")
+    features << :default_ns if xml.include?('xmlns="')
+    # adjacent text-like leaves — CDATA next to CDATA/text — coalesce
+    # on the libxml2 lane (D-19)
+    if xml.match?(/]\]>\s*<!\[CDATA\[/) || xml.match?(/]\]>\s*[^<\s]/) ||
+        xml.match?(/[^<\s]\s*<!\[CDATA\[/)
+      features << :adjacent_cdata
+    end
+    [xml, features.uniq, voids.uniq]
+  end
+
+  def child(rng, level, max_depth, features, voids)
+    if level < max_depth && rng.rand(8) < 5
+      inner = +""
+      (1 + rng.rand(3)).times do
+        inner << child(rng, level + 1, max_depth, features, voids)
+      end
+      name = ELEMENTS[rng.rand(ELEMENTS.length)]
+      extra = +""
+      extra << " #{NAMESPACES[rng.rand(NAMESPACES.length)]}" if rng.rand(4).zero?
+      extra << " #{XML_ATTRS[rng.rand(XML_ATTRS.length)]}" if rng.rand(4).zero?
+      extra << " ns:x=\"#{ATTR_VALUES[rng.rand(ATTR_VALUES.length)]}\"" if rng.rand(3).zero?
+      "<#{name}#{extra}>#{inner}</#{name}>"
+    else
+      leaf(rng, features, voids)
+    end
+  end
+
+  def leaf(rng, features, voids)
+    case rng.rand(6)
+    when 0, 1
+      TEXTS[rng.rand(TEXTS.length)]
+    when 2
+      "<!--comment #{rng.rand(9)}-->"
+    when 3
+      features << :pi_in_content
+      "<?inst data-#{rng.rand(9)}?>"
+    when 4
+      "<![CDATA[x < #{rng.rand(9)} & more]]>"
+    else
+      v = VOIDS[rng.rand(VOIDS.length)]
+      voids << v
+      "<#{v}/>"
+    end
+  end
+
+  # Each mutation is guaranteed to break well-formedness (the root
+  # close and the root id attribute always exist in composed bodies).
+  def mutate(xml, malform)
+    case malform
+    when :unclosed
+      xml.sub(%r{</[a-z]+>}, "")
+    when :stray
+      "#{xml}</r>"
+    when :attr_quote
+      xml.sub('id="root"', 'id="root')
+    end
+  end
+end

data/spec/support/input_taxonomy.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+# The canonical input-class taxonomy (TODO.sota/01-totality): every
+# class of input the processing model touches, as shared fixture data
+# the differential suites consume. Adding a class here automatically
+# extends the whole-class differential; a class without a stable
+# cross-adapter answer must cite a registered divergence (D-ID) or a
+# named raise in the consuming suite.
+module InputTaxonomy
+  Input = Struct.new(:id, :klass, :xml, :well_formed, :note) do
+    def well_formed? = well_formed
+  end
+
+  WELL_FORMED = "well-formed"
+  MALFORMED = "malformed"
+
+  def self.all
+    @all ||= inputs.freeze
+  end
+
+  def self.well_formed
+    all.select(&:well_formed?)
+  end
+
+  def self.malformed
+    all.reject(&:well_formed?)
+  end
+
+  def self.by_klass(klass)
+    all.select { |i| i.klass == klass }
+  end
+
+  CLASSES = [
+    "empty/minimal",
+    "deep nesting",
+    "huge text/attributes",
+    "entities",
+    "namespaces",
+    "mixed content",
+    "pi/comment/cdata edges",
+    "malformed",
+  ].freeze
+
+  # Registered per-input exemptions for the cross-adapter
+  # differential: input id => { face => { adapter => D-NN } }. The
+  # values are register IDs (docs/_pages/divergences.adoc) enforced
+  # by the coverage audit.
+  EXEMPT = {
+    "mixed content: whitespace runs" => {
+      nodes: { ox: "D-13", headed_ox: "D-13" },
+      text: { ox: "D-13", headed_ox: "D-13" },
+    },
+    "mixed content: CRLF text normalizes to LF" => {
+      text: { oga: "D-02" },
+    },
+    "mixed content: bare CR text normalizes to LF" => {
+      text: { oga: "D-02" },
+    },
+    "mixed content: character-ref CR survives" => {
+      text: { oga: "D-02", ox: "D-03", headed_ox: "D-03" },
+    },
+    "pi/comment/cdata: pi inside content" => {
+      text: { oga: "D-14" },
+      pi_content: { ox: "D-05", headed_ox: "D-05" },
+    },
+    "pi/comment/cdata: pi multi-space separator" => {
+      text: { oga: "D-14" },
+      pi_content: { ox: "D-05", headed_ox: "D-05" },
+    },
+    "pi/comment/cdata: pi trailing whitespace" => {
+      text: { oga: "D-14" },
+      pi_content: { ox: "D-05", headed_ox: "D-05", rexml: "D-20" },
+    },
+    "huge text with entities" => {
+      text: { rexml: "D-16" },
+      serialize: { rexml: "D-16" },
+    },
+    "pi/comment/cdata: pi before root" => {
+      nodes: { rexml: "D-15" },
+      text: { rexml: "D-15" },
+      pi_content: { ox: "D-05", headed_ox: "D-05" },
+    },
+    "pi/comment/cdata: comment before and after root" => {
+      comment_content: { ox: "D-06", headed_ox: "D-06" },
+    },
+    "pi/comment/cdata: comment inside content" => {
+      comment_content: { ox: "D-06", headed_ox: "D-06" },
+    },
+  }.freeze
+
+  # Engines whose strict lane cannot see a class of malformedness are
+  # registered: oga's strict is lexer-strict, not well-formedness-
+  # strict (D-17). leptris raises through the facade guard (D-18,
+  # leptris-ruby#514) and is therefore verified, not exempt; entity
+  # and prefix classes are engine-variant by design (entity modes,
+  # namespace validation).
+  STRICT_EXEMPT = {
+    "malformed: bad nesting" => { oga: "D-17" },
+    "malformed: invalid utf-8 byte" => { oga: "D-18", ox: "D-18",
+                                         headed_ox: "D-18" },
+  }.freeze
+
+  def self.inputs
+    [
+      # -- empty/minimal --
+      Input.new("empty/minimal: empty string", "empty/minimal", "", false,
+                "no root: parse must fail loudly or per contract"),
+      Input.new("empty/minimal: whitespace only", "empty/minimal", "  \n\t ", false,
+                "whitespace-only: no root"),
+      Input.new("empty/minimal: bare root", "empty/minimal", "<r/>", true, nil),
+      Input.new("empty/minimal: empty paired root", "empty/minimal", "<r></r>", true, nil),
+      Input.new("empty/minimal: declaration only", "empty/minimal",
+                '<?xml version="1.0"?>', false, "declaration without root"),
+
+      # -- deep nesting --
+      Input.new("deep nesting: 200 levels", "deep nesting",
+                "<r>#{'<d>' * 200}leaf#{'</d>' * 200}</r>", true, nil),
+      Input.new("deep nesting: siblings at depth", "deep nesting",
+                "<r>#{'<a><b>' * 50}#{'</b></a>' * 50}</r>", true, nil),
+
+      # -- huge text/attributes --
+      Input.new("huge text: 100k chars", "huge text/attributes",
+                "<r>#{'x' * 100_000}</r>", true, nil),
+      Input.new("huge attribute: 10k chars", "huge text/attributes",
+                %(<r a="#{'y' * 10_000}"/>), true, nil),
+      Input.new("huge text with entities", "huge text/attributes",
+                "<r>#{'&amp;' * 20_000}</r>", true, nil),
+
+      # -- entities: built-in --
+      Input.new("entities: all five built-ins", "entities",
+                "<r>&amp;&lt;&gt;&quot;&apos;</r>", true, nil),
+      # -- entities: numeric --
+      Input.new("entities: decimal numeric", "entities",
+                "<r>&#65;&#233;</r>", true, nil),
+      Input.new("entities: hex numeric", "entities",
+                "<r>&#x41;&#xE9;</r>", true, nil),
+      # -- entities: custom (DTD-declared) --
+      Input.new("entities: custom DTD entity", "entities",
+                '<!DOCTYPE r [<!ENTITY x "expanded">]><r>&x;</r>', true, nil),
+      # -- entities: undefined (disabled context) --
+      Input.new("entities: undefined reference", "entities",
+                "<r>&undefinedEntity;</r>", false,
+                "undefined entity: malformed without a DTD"),
+      Input.new("entities: NBSP char ref", "entities",
+                "<r>&#160;</r>", true, "U+00A0 survives as content"),
+
+      # -- namespaces: default --
+      Input.new("namespaces: default", "namespaces",
+                '<r xmlns="urn:a"><c/></r>', true, nil),
+      # -- namespaces: prefixed --
+      Input.new("namespaces: prefixed", "namespaces",
+                '<r xmlns:p="urn:a"><p:c/></r>', true, nil),
+      # -- namespaces: undeclared prefix --
+      Input.new("namespaces: undeclared prefix", "namespaces",
+                "<p:c/>", false,
+                "undeclared prefix: malformed in strict parsing"),
+      # -- namespaces: redeclared --
+      Input.new("namespaces: redeclared", "namespaces",
+                '<r xmlns:p="urn:a"><s xmlns:p="urn:b"><p:c/></s></r>', true, nil),
+      # -- namespaces: reserved xml --
+      Input.new("namespaces: reserved xml prefix", "namespaces",
+                '<r xml:lang="en"/>', true, nil),
+      # -- namespaces: xmlns attribute --
+      Input.new("namespaces: xmlns declaration attribute", "namespaces",
+                '<r xmlns="urn:a" xmlns:p="urn:b"/>', true, nil),
+
+      # -- mixed content --
+      Input.new("mixed content: text and inline", "mixed content",
+                "<r>text <b>bold</b> tail</r>", true, nil),
+      Input.new("mixed content: whitespace runs", "mixed content",
+                "<r>\n  <b>x</b>\n  <b>y</b>\n</r>", true, nil),
+      Input.new("mixed content: attribute entities in text", "mixed content",
+                '<r a="&lt;&amp;">&lt;tag&gt;</r>', true, nil),
+      Input.new("mixed content: CRLF text normalizes to LF", "mixed content",
+                "<r>a\r\nb</r>", true, "XML 1.0 §2.11"),
+      Input.new("mixed content: bare CR text normalizes to LF", "mixed content",
+                "<r>a\rb</r>", true, "XML 1.0 §2.11"),
+      Input.new("mixed content: character-ref CR survives", "mixed content",
+                "<r>a&#xD;b</r>", true, "&#xD; is not normalized"),
+
+      # -- pi/comment/cdata edges --
+      Input.new("pi/comment/cdata: pi before root", "pi/comment/cdata edges",
+                '<?xml-stylesheet href="a"?> <r/>', true, nil),
+      Input.new("pi/comment/cdata: comment before and after root", "pi/comment/cdata edges",
+                "<!-- lead --><r/><!-- trail -->", true, nil),
+      Input.new("pi/comment/cdata: cdata with markup", "pi/comment/cdata edges",
+                "<r><![CDATA[<notmarkup> & raw]]></r>", true, nil),
+      Input.new("pi/comment/cdata: empty cdata", "pi/comment/cdata edges",
+                "<r><![CDATA[]]></r>", true, nil),
+      Input.new("pi/comment/cdata: comment inside content", "pi/comment/cdata edges",
+                "<r>a<!-- mid -->b</r>", true, nil),
+      Input.new("pi/comment/cdata: pi inside content", "pi/comment/cdata edges",
+                "<r>a<?pi data?>b</r>", true,
+                "PI content must not contribute to text (D-14 on oga)"),
+      Input.new("pi/comment/cdata: pi multi-space separator", "pi/comment/cdata edges",
+                "<r><?pi   data?></r>", true,
+                "separator whitespace is not PI content (uniform)"),
+      Input.new("pi/comment/cdata: pi trailing whitespace", "pi/comment/cdata edges",
+                "<r><?pi data   ?></r>", true,
+                "trailing whitespace is PI data (D-20 on rexml)"),
+      Input.new("pi/comment/cdata: empty pi", "pi/comment/cdata edges",
+                "<r><?pi?></r>", true, nil),
+
+      # -- malformed: unclosed --
+      Input.new("malformed: unclosed element", "malformed", "<r><c>", false, nil),
+      # -- malformed: bad nest --
+      Input.new("malformed: bad nesting", "malformed", "<r><a><b></a></b></r>", false, nil),
+      # -- malformed: bad attribute --
+      Input.new("malformed: unterminated attribute", "malformed",
+                '<r a="x>', false, nil),
+      # -- malformed: stray closing --
+      Input.new("malformed: stray closing tag", "malformed", "</r>", false, nil),
+      # -- malformed: invalid encoding bytes --
+      Input.new("malformed: invalid utf-8 byte", "malformed",
+                "<r>\xC3\x28</r>", false,
+                "0xC3 0x28 is not valid UTF-8"),
+    ].freeze
+  end
+end