moxml 0.5.148 → 0.5.150

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/element_indent_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Element-level indentation is a declared capability (model, Serialization;
+# D-09): engines that cannot honor the knob raise the named AdapterError
+# instead of answering unindented output. indent: 0 and the no-option
+# path stay common — consumers use them for canonical shapes.
+RSpec.describe "element-level serialization indentation" do
+  it "honors a positive indent on engines that support it" do
+    %i[nokogiri rexml].each do |name|
+      doc = Moxml.new(name).parse("<r><a/></r>")
+      expect(doc.root.to_xml(indent: 2)).to include("\n"),
+                                            "#{name}: indent not honored"
+    end
+  end
+
+  it "raises the named AdapterError on engines that ignore the knob" do
+    %i[oga ox headed_ox libxml leptris].each do |name|
+      doc = Moxml.new(name).parse("<r><a/></r>")
+      expect { doc.root.to_xml(indent: 2) }
+        .to raise_error(Moxml::AdapterError, /indentation/),
+            "#{name}: silent unindented answer"
+    end
+  end
+
+  it "keeps indent: 0 and the no-option path common on every adapter" do
+    Moxml::Adapter::AVAILABLE_ADAPTERS.each do |name|
+      doc = Moxml.new(name).parse("<r><a/></r>")
+      expect(doc.root.to_xml(indent: 0)).to include("<a")
+      expect(doc.root.to_xml).to include("<a")
+    end
+  end
+end

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/node_spec.rb

@@ -156,9 +156,6 @@ RSpec.describe Moxml::Node do
         end
 
         it "locates the node via its path" do
-          # Ox translates only a limited XPath subset (no positional predicates)
-          skip "D-12: ox xpath translation does not support positional predicates" if adapter_name == :ox
-
           expect(doc.at_xpath(title.path)).to eq(title)
         end
 

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/relax_ng_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tempfile"
+
+# RELAX NG facade (TODO.sota/05): engines with an RNG validator
+# answer valid?/validate/validate_errors; engines without one raise
+# the named NotImplementedError at compile and answer supported?
+# without raising.
+RSpec.describe Moxml::RelaxNG do
+  RNG_SCHEMA = <<~RNG # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+    <element name="r" xmlns="http://relaxng.org/ns/structure/1.0">
+      <attribute name="a"><text/></attribute>
+    </element>
+  RNG
+
+  let(:valid_doc) { Moxml.new(:leptris).parse('<r a="x"/>') }
+  let(:invalid_doc) { Moxml.new(:leptris).parse("<r/>") }
+
+  it "answers supported? without raising on every adapter" do
+    Moxml::Adapter::AVAILABLE_ADAPTERS.each do |name|
+      ctx = Moxml.new(name)
+      expect { described_class.supported?(ctx) }.not_to raise_error
+    end
+  end
+
+  it "validates against a compiled schema and reports findings" do
+    ctx = Moxml.new(:leptris)
+    skip "leptris binding has no RNG face" unless described_class.supported?(ctx)
+
+    schema = ctx.relaxng(RNG_SCHEMA)
+    expect(schema.valid?(valid_doc)).to be(true)
+    expect(schema.validate(valid_doc)).to eq([])
+    expect(schema.valid?(invalid_doc)).to be(false)
+    error = schema.validate_errors(invalid_doc).first
+    expect(error[:message]).to include("missing required attribute")
+    expect(error[:line]).to eq(1)
+  end
+
+  it "compiles a schema from a file" do
+    ctx = Moxml.new(:leptris)
+    skip "leptris binding has no RNG face" unless described_class.supported?(ctx)
+
+    Tempfile.create(["schema", ".rng"]) do |file|
+      file.write(RNG_SCHEMA)
+      file.flush
+      schema = ctx.relaxng_file(file.path)
+      expect(schema.valid?(valid_doc)).to be(true)
+      expect(schema.valid?(invalid_doc)).to be(false)
+    end
+  end
+
+  it "raises a named NotImplementedError on engines without an RNG validator" do
+    ctx = Moxml.new(:nokogiri)
+    expect(described_class.supported?(ctx)).to be(false)
+    expect { ctx.relaxng(RNG_SCHEMA) }
+      .to raise_error(Moxml::NotImplementedError, /RELAX NG/)
+  end
+
+  it "names a malformed schema as a ValidationError" do
+    ctx = Moxml.new(:leptris)
+    skip "leptris binding has no RNG face" unless described_class.supported?(ctx)
+
+    expect { ctx.relaxng("<not-a-schema/>") }
+      .to raise_error(Moxml::ValidationError, /RELAX NG/)
+  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
@@ -410,50 +412,39 @@ RSpec.describe Moxml::SAX do
       expect(handler.error_message).to match(/invalid|unclosed|premature|mismatch|not closed/i)
     end
 
-    it "documents CDATA limitation" do
-      # Ox SAX does not have separate CDATA events
-      # All CDATA content is delivered as text() events
-      skip "D-10: Ox SAX does not support separate CDATA events"
-
-      xml_with_cdata = "<root><![CDATA[special content]]></root>"
-
-      cdata_found = false
-      context.sax_parse(xml_with_cdata) do
-        cdata { |_text| cdata_found = true }
-      end
-
-      # This will fail because Ox doesn't support separate CDATA events
-      expect(cdata_found).to be true
+    it "declares CDATA event subscriptions loudly (D-10)" do
+      # Ox SAX has no separate CDATA events; a subscriber gets the
+      # named error rather than an incomplete stream.
+      expect do
+        context.sax_parse("<root><![CDATA[special content]]></root>") do
+          cdata { |_text| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /cdata/)
     end
 
-    it "documents comment limitation" do
-      # Ox SAX does not have separate comment events
-      skip "D-10: Ox SAX does not support separate comment events"
-
-      xml_with_comment = "<root><!-- comment --><data>content</data></root>"
-
-      comment_found = false
-      context.sax_parse(xml_with_comment) do
-        comment { |_text| comment_found = true }
-      end
-
-      # This will fail because Ox doesn't support comment events
-      expect(comment_found).to be true
+    it "declares comment event subscriptions loudly (D-10)" do
+      expect do
+        context.sax_parse("<root><!-- comment --><data>content</data></root>") do
+          comment { |_text| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /comment/)
     end
 
-    it "documents processing instruction limitation" do
-      # Ox SAX does not have separate PI events
-      skip "D-10: Ox SAX does not support separate processing instruction events"
-
-      xml_with_pi = '<?xml-stylesheet type="text/xsl" href="style.xsl"?><root/>'
+    it "declares PI event subscriptions loudly (D-10)" do
+      expect do
+        context.sax_parse('<?xml-stylesheet type="text/xsl" href="style.xsl"?><root/>') do
+          processing_instruction { |_target, _data| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /processing_instruction/)
+    end
 
-      pi_found = false
-      context.sax_parse(xml_with_pi) do
-        processing_instruction { |_target, _data| pi_found = true }
-      end
+    it "declares unsupported families loudly for class handlers too" do
+      handler = Class.new(Moxml::SAX::Handler) do
+        def on_cdata(_text); end
+      end.new
 
-      # This will fail because Ox doesn't support PI events
-      expect(pi_found).to be true
+      expect { context.sax_parse("<root/>", handler) }
+        .to raise_error(Moxml::NotImplementedError, /cdata/)
     end
   end
 
@@ -1022,46 +1013,28 @@ RSpec.describe Moxml::SAX do
       expect(handler.error_message).to match(/invalid|unclosed|premature|mismatch|not closed/i)
     end
 
-    it "documents CDATA limitation (inherited from Ox)" do
-      # HeadedOx inherits Ox's SAX implementation, which does not have separate CDATA events
-      skip "D-10: HeadedOx SAX (inherited from Ox) does not support separate CDATA events"
-
-      xml_with_cdata = "<root><![CDATA[special content]]></root>"
-
-      cdata_found = false
-      context.sax_parse(xml_with_cdata) do
-        cdata { |_text| cdata_found = true }
-      end
-
-      expect(cdata_found).to be true
+    it "declares CDATA event subscriptions loudly (inherited from Ox, D-10)" do
+      expect do
+        context.sax_parse("<root><![CDATA[special content]]></root>") do
+          cdata { |_text| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /cdata/)
     end
 
-    it "documents comment limitation (inherited from Ox)" do
-      # HeadedOx inherits Ox's SAX implementation, which does not have separate comment events
-      skip "D-10: HeadedOx SAX (inherited from Ox) does not support separate comment events"
-
-      xml_with_comment = "<root><!-- comment --><data>content</data></root>"
-
-      comment_found = false
-      context.sax_parse(xml_with_comment) do
-        comment { |_text| comment_found = true }
-      end
-
-      expect(comment_found).to be true
+    it "declares comment event subscriptions loudly (inherited from Ox, D-10)" do
+      expect do
+        context.sax_parse("<root><!-- comment --><data>content</data></root>") do
+          comment { |_text| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /comment/)
     end
 
-    it "documents processing instruction limitation (inherited from Ox)" do
-      # HeadedOx inherits Ox's SAX implementation, which does not have separate PI events
-      skip "D-10: HeadedOx SAX (inherited from Ox) does not support separate processing instruction events"
-
-      xml_with_pi = '<?xml-stylesheet type="text/xsl" href="style.xsl"?><root/>'
-
-      pi_found = false
-      context.sax_parse(xml_with_pi) do
-        processing_instruction { |_target, _data| pi_found = true }
-      end
-
-      expect(pi_found).to be true
+    it "declares PI event subscriptions loudly (inherited from Ox, D-10)" do
+      expect do
+        context.sax_parse('<?xml-stylesheet type="text/xsl" href="style.xsl"?><root/>') do
+          processing_instruction { |_target, _data| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /processing_instruction/)
     end
   end
 end

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