moxml 0.1.25 → 0.2.0

data/spec/moxml/c14n/namespace_edge_cases_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+# Edge cases for namespace rendering per W3C C14N 1.0 §2.3 / 1.1 §2.3.
+# These cover the bugs that historically plague C14N implementations.
+RSpec.describe "C14N namespace rendering" do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  describe "default namespace" do
+    it "renders xmlns= declaration when default ns is set" do
+      doc = ctx.parse(%(<root xmlns="urn:foo"/>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result).to eq('<root xmlns="urn:foo"></root>')
+    end
+
+    it "renders xmlns='' when transitioning to empty default" do
+      doc = ctx.parse(%(<a xmlns="urn:foo"><b xmlns=""><c/></b></a>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      # <b> has empty default; <a> has urn:foo → xmlns="" appears
+      expect(result).to include('xmlns=""')
+    end
+
+    it "does not render xmlns when default ns is empty everywhere" do
+      doc = ctx.parse(%(<root><child/></root>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result).to eq("<root><child></child></root>")
+    end
+  end
+
+  describe "prefix redeclaration" do
+    it "renders both declarations when URI changes" do
+      doc = ctx.parse(%(<a xmlns:x="urn:1"><b xmlns:x="urn:2"/></a>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result.scan("xmlns:x=").length).to eq(2)
+    end
+
+    it "renders only once when URI is unchanged" do
+      doc = ctx.parse(%(<a xmlns:x="urn:1"><b xmlns:x="urn:1"/></a>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result.scan("xmlns:x=").length).to eq(1)
+    end
+  end
+
+  describe "xml namespace" do
+    it "does not render xmlns:xml declaration" do
+      doc = ctx.parse(%(<root xmlns:xml="http://www.w3.org/XML/1998/namespace"/>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result).not_to include("xmlns:xml=")
+    end
+  end
+
+  describe "namespace sorting" do
+    it "sorts xmlns declarations by prefix" do
+      doc = ctx.parse(%(<root xmlns:z="urn:z" xmlns:a="urn:a"/>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      # a should appear before z
+      expect(result.index("xmlns:a=")).to be < result.index("xmlns:z=")
+    end
+
+    it "renders default namespace first" do
+      doc = ctx.parse(%(<root xmlns="urn:default" xmlns:a="urn:a"/>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      # Default (xmlns=) before prefixed
+      expect(result.index("xmlns=")).to be < result.index("xmlns:a=")
+    end
+  end
+
+  describe "deeply nested inheritance" do
+    it "renders each prefix at the level it is first declared" do
+      xml = <<~XML.strip
+        <root xmlns:a="urn:a">
+          <level1 xmlns:b="urn:b">
+            <level2 xmlns:c="urn:c">
+              <apex/>
+            </level2>
+          </level1>
+        </root>
+      XML
+      doc = ctx.parse(xml)
+      result = Moxml::C14n.canonicalize(doc.root)
+      # Inclusive: all in-scope ns render on apex. But we're canonicalizing
+      # the whole tree, so each ns renders at its declaration point.
+      expect(result.scan("xmlns:").length).to eq(3)
+    end
+  end
+end

data/spec/moxml/c14n/xml_attributes_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+# xml:lang and xml:space are "simple inheritable" attributes per W3C C14N
+# 1.1 §2.4. When an element is in the node-set but an ancestor is not,
+# the canonical form inherits these attributes from the nearest ancestor
+# in which they were declared.
+#
+# These specs exercise the inclusive behavior at full-document
+# canonicalization (where everything is in the set, so inheritance
+# doesn't trigger). For subset scenarios, see TODO.c14n/07.
+RSpec.describe "C14N xml:* inheritable attributes" do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  it "renders xml:lang attribute" do
+    doc = ctx.parse(%(<root xml:lang="en">hello</root>))
+    expect(Moxml::C14n.canonicalize(doc.root))
+      .to eq(%(<root xml:lang="en">hello</root>))
+  end
+
+  it "renders xml:space attribute" do
+    doc = ctx.parse(%(<root xml:space="preserve">data</root>))
+    expect(Moxml::C14n.canonicalize(doc.root))
+      .to eq(%(<root xml:space="preserve">data</root>))
+  end
+
+  it "renders xml:lang on descendant that declares its own" do
+    doc = ctx.parse(%(<a xml:lang="en"><b xml:lang="fr"/></a>))
+    result = Moxml::C14n.canonicalize(doc.root)
+    expect(result).to include('<b xml:lang="fr">')
+  end
+
+  it "renders xml:id attribute" do
+    doc = ctx.parse(%(<root xml:id="foo"/>))
+    expect(Moxml::C14n.canonicalize(doc.root))
+      .to eq(%(<root xml:id="foo"></root>))
+  end
+
+  it "renders xml:base attribute" do
+    doc = ctx.parse(%(<root xml:base="http://example.com/"/>))
+    expect(Moxml::C14n.canonicalize(doc.root))
+      .to eq(%(<root xml:base="http://example.com/"></root>))
+  end
+
+  it "sorts xml:* attributes by namespace URI then local name" do
+    doc = ctx.parse(%(<root xml:space="default" xml:lang="en" xml:id="x"/>))
+    result = Moxml::C14n.canonicalize(doc.root)
+    # All in XML namespace; sort by local name: id < lang < space
+    expect(result.index("xml:id=")).to be < result.index("xml:lang=")
+    expect(result.index("xml:lang=")).to be < result.index("xml:space=")
+  end
+end

data/spec/moxml/doctype_spec.rb

@@ -48,7 +48,7 @@ RSpec.describe Moxml::Doctype do
   end
 
   describe "parsing" do
-    %i[nokogiri oga rexml ox].each do |adapter_name|
+    %i[nokogiri oga rexml ox libxml].each do |adapter_name|
       context "with #{adapter_name} adapter" do
         let(:ctx) { Moxml.new(adapter_name) }
 

data/spec/moxml/entity_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Entity do
+  describe ".preprocess_entities" do
+    it "marks non-standard entities and leaves the five standard ones" do
+      marked = described_class.preprocess_entities("a © b & c <")
+      expect(marked).to include("#{described_class::MARKER}copy;")
+      expect(marked).to include("&")
+      expect(marked).to include("<")
+    end
+
+    it "returns the input untouched when it contains no ampersand" do
+      input = "plain text"
+      expect(described_class.preprocess_entities(input)).to equal(input)
+    end
+
+    it "always returns UTF-8" do
+      binary = "caf\xC3\xA9 ©".b
+      result = described_class.preprocess_entities(binary)
+      expect(result.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "returns an empty string for nil" do
+      expect(described_class.preprocess_entities(nil)).to eq("")
+    end
+  end
+
+  describe ".decode_entities" do
+    it "decodes numeric and standard named references in one pass" do
+      expect(described_class.decode_entities("AB&<"))
+        .to eq("AB&<")
+    end
+
+    it "preserves invalid numeric codepoints verbatim" do
+      expect(described_class.decode_entities("&#0;&#xD800;")).to eq("&#0;&#xD800;")
+    end
+
+    it "skips strings without ampersands" do
+      input = "plain"
+      expect(described_class.decode_entities(input)).to equal(input)
+    end
+  end
+
+  describe ".restore_entities" do
+    it "maps markers back to named references" do
+      restored = described_class.restore_entities(
+        "a#{described_class::MARKER}copy;b",
+      )
+      expect(restored).to eq("a&copy;b")
+    end
+
+    it "restores markers a native serializer rendered as character references" do
+      expect(described_class.restore_entities("a&#xFFFC;&#xFEFF;copy;b"))
+        .to eq("a&copy;b")
+    end
+
+    it "returns marker-free strings without a regex pass" do
+      input = "no markers here"
+      expect(described_class.restore_entities(input)).to equal(input)
+    end
+  end
+
+  describe Moxml::Entity::Reference do
+    it "round-trips as a serialized entity reference" do
+      expect(described_class.new("copy").to_xml).to eq("&copy;")
+    end
+
+    it "compares by name" do
+      reference = described_class.new("copy")
+      expect(reference).to eq(described_class.new("copy"))
+      expect(reference).not_to eq(described_class.new("nbsp"))
+    end
+  end
+end

data/spec/moxml/node_spec.rb

@@ -92,4 +92,108 @@ RSpec.describe Moxml::Node do
       expect(child.content).to eq("text")
     end
   end
+
+  describe "#ancestors" do
+    let(:doc) { context.parse("<library><section><book><title>Book 1</title></book></section></library>") }
+    let(:title) { doc.at_xpath("//title") }
+
+    it "returns ancestors from parent up to and including the document" do
+      ancestors = title.ancestors
+      expect(ancestors).to be_a(Moxml::NodeSet)
+      expect(ancestors.select(&:element?).map(&:name)).to eq(["book", "section", "library"])
+      expect(ancestors[3]).to be_a(Moxml::Document)
+    end
+
+    it "returns empty for the document" do
+      expect(doc.ancestors).to be_empty
+    end
+
+    it "returns the document for the root element" do
+      ancestors = doc.root.ancestors
+      expect(ancestors.size).to eq(1)
+      expect(ancestors.first).to be_a(Moxml::Document)
+    end
+  end
+
+  describe "#descendants" do
+    let(:doc) { context.parse("<section><book><title>Book 1</title></book></section>") }
+    let(:section) { doc.at_xpath("//section") }
+
+    it "returns all descendants excluding self" do
+      descendants = section.descendants
+      expect(descendants).to be_a(Moxml::NodeSet)
+      element_names = descendants.select(&:element?).map(&:name)
+      expect(element_names).to eq(["book", "title"])
+    end
+
+    it "includes text nodes" do
+      expect(section.descendants.any?(&:text?)).to be true
+    end
+
+    it "returns no elements for a leaf element" do
+      expect(doc.at_xpath("//title").descendants.select(&:element?)).to be_empty
+    end
+  end
+
+  describe "#path" do
+    %i[nokogiri oga rexml ox libxml].each do |adapter_name|
+      context "with #{adapter_name} adapter" do
+        let(:ctx) { Moxml.new(adapter_name) }
+        let(:doc) do
+          ctx.parse("<library><section><book id='1'/><book id='2'><title>Book 2</title></book></section></library>")
+        end
+        let(:first_book) { doc.root.children.find(&:element?).children.find { |c| c.element? && c.name == "book" && c["id"] == "1" } }
+        let(:second_book) { doc.root.children.find(&:element?).children.find { |c| c.element? && c.name == "book" && c["id"] == "2" } }
+        let(:title) { second_book.children.find(&:element?) }
+
+        it "builds the path without a predicate for uniquely named elements" do
+          expect(title.path).to eq("/library/section/book[2]/title")
+        end
+
+        it "adds a positional predicate for same-named siblings" do
+          expect(first_book.path).to eq("/library/section/book[1]")
+          expect(second_book.path).to eq("/library/section/book[2]")
+        end
+
+        it "locates the node via its path" do
+          # Ox translates only a limited XPath subset (no positional predicates)
+          skip "ox xpath translation does not support positional predicates" if adapter_name == :ox
+
+          expect(doc.at_xpath(title.path)).to eq(title)
+        end
+
+        it "returns / for the document" do
+          expect(doc.path).to eq("/")
+        end
+      end
+    end
+
+    it "raises for node types without a path representation" do
+      text = doc.root.children.first.children.first
+      expect { text.path }.to raise_error(Moxml::NotImplementedError, /element and document/)
+    end
+  end
+
+  describe "#line_number" do
+    %i[nokogiri oga rexml ox libxml].each do |adapter_name|
+      tracks_source_lines = adapter_name.eql?(:nokogiri) || adapter_name.eql?(:libxml)
+      context "with #{adapter_name} adapter" do
+        let(:ctx) { Moxml.new(adapter_name) }
+        let(:doc) do
+          ctx.parse("<?xml version='1.0'?>\n<library>\n  <book>\n    <title>Book 1</title>\n  </book>\n</library>\n")
+        end
+        let(:title) { doc.root.children.find(&:element?).children.find(&:element?) }
+
+        if tracks_source_lines
+          it "returns the 1-based source line" do
+            expect(title.line_number).to eq(4)
+          end
+        else
+          it "returns nil when the adapter does not track lines" do
+            expect(title.line_number).to be_nil
+          end
+        end
+      end
+    end
+  end
 end