moxml 0.5.148 → 0.5.149

data/spec/consistency/xpath_idioms_spec.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# Processing model §Names and namespaces (normative): pinned here.
+# Processing model §XPath evaluation (normative): pinned here.
+
 require "spec_helper"
 
 # Cross-adapter XPath idioms that nokogiri consumers rely on:
@@ -107,6 +110,14 @@ RSpec.describe "XPath idioms across adapters" do
         expect(doc.at_xpath("/*")&.name).to eq("r")
         expect(doc.at_xpath("/r")&.name).to eq("r")
       end
+
+      it "answers scalar XPath functions unwrapped and uniform" do
+        doc = ctx.parse(plain_xml)
+        expect(doc.xpath("count(//a)")).to eq(1.0)
+        expect(doc.xpath("string(//a/@id)")).to eq("x")
+        expect(doc.xpath("boolean(//b)")).to be(true)
+        expect(doc.at_xpath("count(//a)")).to eq(1.0)
+      end
     end
   end
 end

data/spec/consistency/xslt_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §XSLT (normative): pinned here.
+
 require "spec_helper"
 require "moxml/c14n"
 

data/spec/moxml/adapter/leptris_attribute_snapshot_spec.rb

@@ -5,10 +5,13 @@ require "spec_helper"
 # moxml#375 — element hydration through the binding's
 # attributes_snapshot face (libleptris 1.9.353, engine
 # leptris#1689): one crossing for every attribute instead of one
-# per attribute. The output contract is stride-identical to the
-# binding's per-attribute face: qualified names, document order,
-# fresh values.
+# per attribute. The facade listing face is bare names (uniform with
+# every adapter, and with Attribute#name), document order, fresh
+# values.
 RSpec.describe "leptris element-attribute snapshot hydration" do
+  def bare(pairs)
+    pairs.map { |(name, value)| [name.split(":", 2).last, value] }
+  end
   let(:ctx) { Moxml.new(:leptris) }
 
   context "when the snapshot face is armed (>= 1.9.353.0)" do
@@ -23,11 +26,11 @@ RSpec.describe "leptris element-attribute snapshot hydration" do
         '<root a="1" xml:lang="en" xmlns:ns="urn:u" ns:p="v"/>',
       )
       binding_element = Moxml::Adapter::Leptris.to_binding(doc.root)
-      expected = binding_element.attribute_pairs
+      expected = bare(binding_element.attribute_pairs)
 
       expect(doc.root.attribute_pairs).to eq(expected)
       expect(doc.root.attribute_pairs).to eq(
-        [["a", "1"], ["xml:lang", "en"], ["ns:p", "v"]],
+        [["a", "1"], ["lang", "en"], ["p", "v"]],
       )
     end
 
@@ -36,7 +39,7 @@ RSpec.describe "leptris element-attribute snapshot hydration" do
         '<root z="9" xmlns:m="urn:m" m:x="8" k="7"/>',
       )
       expect(doc.root.attribute_pairs.map(&:first)).to eq(
-        %w[z m:x k],
+        %w[z x k],
       )
     end
 
@@ -71,7 +74,7 @@ RSpec.describe "leptris element-attribute snapshot hydration" do
       )
       binding_element = Moxml::Adapter::Leptris.to_binding(doc.root)
       expect(doc.root.attribute_pairs).to eq(
-        binding_element.attribute_pairs,
+        bare(binding_element.attribute_pairs),
       )
     end
   end

data/spec/moxml/adapter/ox_spec.rb

@@ -94,7 +94,7 @@ RSpec.describe Moxml::Adapter::Ox do
 
       it "fails loudly on ox_mode: :hash (the adapter walks a tree, not a Hash)" do
         expect { described_class.parse("<r><t> x </t></r>", ox_mode: :hash) }
-          .to raise_error(RuntimeError, /must be a String or Ox::Node/)
+          .to raise_error(Moxml::ParseError, /must be a String or Ox::Node/)
       end
 
       it "surfaces an invalid ox_skip as Moxml::ParseError" do

data/spec/moxml/attribute_resolver_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Access semantics (normative): pinned here.
+
 require "spec_helper"
 
 RSpec.describe Moxml::AttributeResolver do

data/spec/moxml/c14n/adapter_delegation_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Canonicalization (normative): pinned here.
+
 require "spec_helper"
 require "moxml/c14n"
 

data/spec/moxml/doctype_spec.rb

@@ -84,6 +84,13 @@ RSpec.describe Moxml::Doctype do
           expect(doctype.external_id).to be_nil
           expect(doctype.system_id).to be_nil
         end
+
+        it "preserves a DOCTYPE internal subset on serialization" do
+          xml = '<!DOCTYPE r [<!ENTITY x "v">]><r>&x;</r>'
+          parsed = ctx.parse(xml)
+
+          expect(parsed.to_xml(indent: 0)).to include('<!ENTITY x "v">')
+        end
       end
     end
   end

data/spec/moxml/document_parse_diagnostics_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Parsing (normative): pinned here.
+
 require "spec_helper"
 
 # Document#parse_diagnostics (issue #271, option A — additive):

data/spec/moxml/entity_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Parsing (normative): pinned here.
+
 require "spec_helper"
 
 RSpec.describe Moxml::Entity do

data/spec/moxml/plan_conformance_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Materialization (normative): pinned here.
+
 require "spec_helper"
 
 # Moxml::Plan adapter-contract conformance (leptris follow-up to

data/spec/moxml/processing_instruction_spec.rb

@@ -21,6 +21,15 @@ RSpec.describe Moxml::ProcessingInstruction do
       expect(pi.content).to include("type=")
       expect(pi.content).to include("href=")
     end
+
+    it "answers the empty string for a PI with no data on every adapter" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |name|
+        parsed = Moxml.new(name).parse("<r><?pi?></r>")
+        pi = parsed.children.first.children
+          .find { |n| n.is_a?(described_class) }
+        expect(pi.content).to eq(""), "empty PI content on #{name}"
+      end
+    end
   end
 
   describe "creation" do

data/spec/moxml/reference_opal_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# The engine-free lane (TODO.sota/03): the reference is pure Ruby and
+# answers the model where no native engine exists. This spec proves it
+# transpiles and runs under Opal.
+RSpec.describe "Moxml::Reference under Opal", if: RUBY_ENGINE == "opal" do
+  it "parses, answers faces, and writes without a native engine" do
+    document = Moxml::Reference.parse(
+      '<r a="1"><b>t&amp;u</b><![CDATA[c]]><?pi d?></r>',
+    )
+    expect(Moxml::Reference.element_names(document)).to eq(%w[r b])
+    expect(Moxml::Reference.child_element_names(document)).to eq([["b"], []])
+    element = document.root.children.find(&:element?)
+    expect(element.children.map(&:kind)).to eq([:text])
+    expect(element.children.first.data).to eq("t&u")
+    expect(document.root.text).to eq("t&uc")
+    expect(Moxml::Reference.processing_instructions(document))
+      .to eq([["pi", "d"]])
+    expect(Moxml::Reference.to_xml(document))
+      .to include("<r a=\"1\">", "<b>t&amp;u</b>", "<![CDATA[c]]>")
+  end
+
+  it "raises a named ParseError for malformed input" do
+    expect { Moxml::Reference.parse("<r><c></r>") }
+      .to raise_error(Moxml::ParseError)
+  end
+end

data/spec/moxml/reference_spec.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/input_taxonomy"
+require "support/xml_generator"
+
+# The executable reference (TODO.sota/03): a pure-Ruby reader,
+# writer, and normalizer that answer the processing model with no
+# engine involved. The differential suite tests adapters against it;
+# these specs pin the reference itself.
+RSpec.describe Moxml::Reference do
+  describe "parsing" do
+    it "reads the object model, declaration, and document parts" do
+      doc = described_class.parse(
+        '<?xml version="1.0" encoding="UTF-8"?><!--lead--><r a="1"><b>t</b></r>',
+      )
+      expect(doc.declaration[:version]).to eq("1.0")
+      expect(doc.declaration[:encoding]).to eq("UTF-8")
+      expect(described_class.element_names(doc)).to eq(%w[r b])
+      expect(doc.root.attribute_pairs).to eq([["a", "1"]])
+      expect(described_class.comments(doc)).to eq(["lead"])
+    end
+
+    it "answers bare local names for prefixed sources" do
+      doc = described_class.parse('<r xmlns:p="urn:a"><p:c p:x="1"/></r>')
+      expect(described_class.element_names(doc)).to eq(%w[r c])
+      expect(described_class.child_element_names(doc)).to eq([["c"], []])
+      expect(doc.root.children.first.attribute_pairs).to eq([["x", "1"]])
+    end
+
+    it "expands built-in and numeric references, never comments or PI data" do
+      doc = described_class.parse(
+        "<r>&amp;&#65;&#x42;<![CDATA[<raw>]]><!-- c --><?pi d?></r>",
+      )
+      expect(doc.root.text).to eq("&AB<raw>")
+      expect(described_class.processing_instructions(doc)).to eq([["pi", "d"]])
+    end
+
+    it "preserves DTD-declared general entities lexically (uniform lane)" do
+      doc = described_class.parse(
+        '<!DOCTYPE r [<!ENTITY x "expanded">]><r>&x;</r>',
+      )
+      expect(doc.root.text).to eq("&x;")
+    end
+
+    it "normalizes literal line endings but not character references" do
+      doc = described_class.parse("<r>a\r\nb\rc&#xD;d</r>")
+      expect(doc.root.text).to eq("a\nb\nc\rd")
+    end
+
+    it "normalizes literal attribute whitespace" do
+      doc = described_class.parse(%(<r a="x\ty\nz"/>))
+      expect(doc.root.attribute_pairs).to eq([["a", "x y z"]])
+    end
+
+    it "drops the PI separator from PI data" do
+      doc = described_class.parse("<r><?pi   data  ?></r>")
+      expect(described_class.processing_instructions(doc))
+        .to eq([["pi", "data  "]])
+    end
+
+    it "answers the empty string for PI with no data" do
+      doc = described_class.parse("<r><?pi?></r>")
+      expect(described_class.processing_instructions(doc)).to eq([["pi", ""]])
+    end
+  end
+
+  describe "totality over the input taxonomy" do
+    it "parses every well-formed taxonomy fixture" do
+      InputTaxonomy.well_formed.each do |input|
+        expect { described_class.parse(input.xml) }
+          .not_to raise_error, "#{input.id} must parse in the reference"
+      end
+    end
+
+    it "raises a named ParseError for every malformed taxonomy fixture" do
+      InputTaxonomy.malformed.each do |input|
+        expect { described_class.parse(input.xml) }
+          .to raise_error(Moxml::ParseError),
+              "#{input.id} must raise in the reference"
+      end
+    end
+
+    it "parses every generated document" do
+      (1..10).each do |seed|
+        expect { described_class.parse(XmlGenerator.generate(seed)) }
+          .not_to raise_error
+      end
+    end
+  end
+
+  describe "writers" do
+    let(:doc) do
+      described_class.parse(
+        '<r a="&lt;&amp;&quot;"><b/>t<!--c--><![CDATA[x<y]]></r>',
+      )
+    end
+
+    it "emits XML that re-parses to the same information set" do
+      xml = described_class.to_xml(doc)
+      again = described_class.parse(xml)
+      expect(described_class.element_names(again))
+        .to eq(described_class.element_names(doc))
+      expect(again.root.attribute_pairs).to eq(doc.root.attribute_pairs)
+      expect(again.root.text).to eq(doc.root.text)
+    end
+
+    it "emits the canonical facade escaping" do
+      expect(described_class.to_xml(doc))
+        .to include('<r a="&lt;&amp;&quot;">')
+      expect(described_class.to_xml(doc)).to include("<![CDATA[x<y]]>")
+      expect(described_class.to_xml(doc)).to include("<b/>")
+    end
+
+    it "splits a CDATA end sequence" do
+      document = Moxml::Reference::Document.new
+      root = Moxml::Reference::Node.new(kind: :element, name: "r")
+      root.children << Moxml::Reference::Node.new(kind: :cdata, data: "a]]>b")
+      document.children << root
+      expect(described_class.to_xml(document)).to include("]]]]><![CDATA[>")
+    end
+
+    it "leaves void elements unclosed in HTML and self-closed in XHTML" do
+      html_doc = described_class.parse("<html><body>a<br/>b</body></html>")
+      expect(described_class.to_html(html_doc)).to include("<br>")
+      expect(described_class.to_xhtml(html_doc)).to include("<br/>")
+    end
+
+    it "emits raw text inside HTML script and style, escaped in XHTML" do
+      html_doc = described_class.parse("<html><script>a &lt; b</script></html>")
+      expect(described_class.to_html(html_doc))
+        .to include("<script>a < b</script>")
+      expect(described_class.to_xhtml(html_doc))
+        .to include("<script>a &lt; b</script>")
+    end
+
+    it "emits no XML declaration unless the source had one" do
+      expect(described_class.to_html(described_class.parse("<r/>")))
+        .to eq("<r></r>")
+      with_declaration = described_class.parse('<?xml version="1.0"?><r/>')
+      expect(described_class.to_xml(with_declaration))
+        .to start_with('<?xml version="1.0"?>')
+    end
+  end
+
+  describe "normalizer" do
+    it "normalizes CRLF and bare CR to LF" do
+      expect(Moxml::Reference::Normalizer.normalize_eol("a\r\nb\rc"))
+        .to eq("a\nb\nc")
+    end
+
+    it "expands built-ins and numeric references" do
+      expect(Moxml::Reference::Normalizer.expand_entities("&lt;&#65;"))
+        .to eq("<A")
+    end
+
+    it "raises for an undefined reference" do
+      expect { Moxml::Reference::Normalizer.expand_entities("&nope;") }
+        .to raise_error(Moxml::ParseError)
+    end
+  end
+end

data/spec/moxml/sax_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §SAX (normative): pinned here.
+
 require "spec_helper"
 
 RSpec.describe Moxml::SAX do

data/spec/moxml/text_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Access semantics (normative): pinned here.
+
 require "spec_helper"
 
 RSpec.describe Moxml::Text do

data/spec/moxml/to_html_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Serialization (normative): pinned here.
+
 require "spec_helper"
 
 # Document#to_html (issue #354): HTML-method serialization with the

data/spec/moxml/xhtml_output_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Serialization (normative): pinned here.
+
 require "spec_helper"
 
 # Issue #390: XHTML-shaped serialization — void elements self-closed

data/spec/moxml/xpath/axes_spec.rb

@@ -217,11 +217,11 @@ RSpec.describe "XPath Axes" do
       end
 
       it "selects ancestors with ancestor::" do
-        expect(select("//c/ancestor::*")).to eq(%w[parent root])
+        expect(select("//c/ancestor::*")).to eq(%w[root parent])
       end
 
       it "includes the context node with ancestor-or-self::" do
-        expect(select("//c/ancestor-or-self::*")).to eq(%w[c parent root])
+        expect(select("//c/ancestor-or-self::*")).to eq(%w[root parent c])
       end
 
       it "selects following siblings" do

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