moxml 0.5.147 → 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/leptris_contract_reads_spec.rb

@@ -130,4 +130,33 @@ RSpec.describe "leptris Identity contract reads" do
       expect(el.text).to eq("v")
     end
   end
+
+  describe "children" do
+    it "answers without the adapter children crossing (children_read)" do
+      unless Leptris::XML::NativeNode.method_defined?(:children_read)
+        skip "binding #{Leptris::VERSION} has no children_read face"
+      end
+      doc = ctx.parse("<root><item>v</item></root>")
+      el = doc.root.children.first
+
+      singleton = Moxml::Adapter::Leptris.singleton_class
+      singleton.send(:alias_method, :children_without_walk, :children)
+      singleton.send(:define_method, :children) { |*| raise "adapter children crossing" }
+      begin
+        kids = el.children
+        expect(kids.to_a.map(&:name)).to eq(["text"])
+      ensure
+        singleton.send(:alias_method, :children, :children_without_walk)
+        singleton.send(:remove_method, :children_without_walk)
+      end
+    end
+
+    it "returns a NodeSet carrying the contract wrappers" do
+      doc = ctx.parse("<root><item>v</item></root>")
+      kids = doc.root.children.first.children
+      expect(kids).to be_a(Moxml::NodeSet)
+      expect(kids.to_a.first.name).to eq("text")
+      expect(kids.to_a.first.content).to eq("v")
+    end
+  end
 end

data/spec/moxml/adapter/leptris_detached_text_spec.rb

@@ -10,13 +10,20 @@ require "spec_helper"
 RSpec.describe "detached text content= names the cause" do
   let(:ctx) { Moxml.new(:leptris) }
 
-  it "raises a named Moxml error for a removed text node" do
+  it "answers removed text nodes: mutable on fixed engines (1.9.374+), named error before" do
     doc = ctx.parse("<r><a>x</a><b>y</b></r>")
     text = doc.root.children[0].children[0]
     text.remove
 
-    expect { text.content = "z" }
-      .to raise_error(Moxml::Error, /detached \(parentless\).*issue #401/)
+    if Gem::Version.new(Leptris::VERSION) >= Gem::Version.new("1.9.374")
+      # leptris/leptris#1785 fixed the engine root cause: detached
+      # text resolves its owning document, so the mutation succeeds.
+      text.content = "z"
+      expect(text.content).to eq("z")
+    else
+      expect { text.content = "z" }
+        .to raise_error(Moxml::Error, /detached \(parentless\).*issue #401/)
+    end
   end
 
   it "keeps created-unattached nodes mutable" do

data/spec/moxml/adapter/leptris_parse_lint_spec.rb

@@ -23,6 +23,18 @@ RSpec.describe "parse_html collect_errors forwarding" do
     expect(diags.first).to have_key(:message)
   end
 
+  # Issue #408: the #1771 reader fields ride the diag hash — the
+  # token code and position canon's HtmlValidator maps onto
+  # validation errors (nil where the engine has no token code).
+  it "carries the token code and position (issue #408)" do
+    doc = ctx.parse_html(src, collect_errors: true)
+    eof = doc.parse_diagnostics.find { |d| d[:message].include?("EOF") }
+    expect(eof).not_to be_nil
+    expect(eof[:code]).to eq("eof-in-tag")
+    expect(eof[:line]).to eq(1)
+    expect(eof[:column]).to eq(1)
+  end
+
   it "keeps the default lane silent (no option, no diagnostics)" do
     doc = ctx.parse_html(src)
     expect(doc.parse_diagnostics).to be_empty

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