moxml 0.1.25 → 0.2.0

data/spec/moxml/adapter/shared_examples/adapter_contract.rb

@@ -125,6 +125,186 @@ RSpec.shared_examples "xml adapter" do
       value = attr.respond_to?(:to_xml) ? attr&.to_xml : attr.to_s
       expect(value).to match(/< > & ("|") ('|')/)
     end
+
+    it "keeps attributes that share a local name across namespaces (issues #94/#95)" do
+      collision = described_class.parse(
+        '<probe xmlns:xmi="http://www.example.com/xmi" ' \
+        'xmi:type="uml:Parameter" type="EAnone_void"/>',
+      ).native
+      probe = described_class.root(collision)
+
+      attrs = described_class.attributes(probe)
+      expect(attrs.size).to eq(2)
+      expect(attrs.map(&:value).sort).to eq(["EAnone_void", "uml:Parameter"])
+
+      reversed = described_class.parse(
+        '<probe type="EAnone_void" ' \
+        'xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter"/>',
+      ).native
+      expect(described_class.attributes(described_class.root(reversed)).size).to eq(2)
+
+      # Bare name resolves to the namespace-less attribute; the
+      # prefixed name to the namespaced one — on every adapter.
+      expect(described_class.get_attribute_value(probe, "type"))
+        .to eq("EAnone_void")
+      expect(described_class.get_attribute_value(probe, "xmi:type"))
+        .to eq("uml:Parameter")
+      expect(described_class.get_attribute_value(probe, "bogus:missing"))
+        .to be_nil
+    end
+  end
+
+  describe "mutation return contract" do
+    let(:doc) { described_class.parse(xml).native }
+    let(:element) { described_class.children(described_class.root(doc)).first }
+
+    it "returns the native to track from set_attribute_name" do
+      native = described_class.attributes(element).first
+      tracked = described_class.set_attribute_name(native, "renamed")
+      expect(tracked).to be_a(native.class)
+      expect(described_class.attribute_name(tracked)).to eq("renamed")
+    end
+
+    it "returns the native to track from set_namespace on an attribute" do
+      native = described_class.attributes(element).first
+      ns = described_class.namespace_definitions(
+        described_class.root(doc),
+      ).last
+      tracked = described_class.set_namespace(native, ns)
+      expect(tracked).to be_a(native.class)
+    end
+
+    it "returns the native to track from set_attribute_value" do
+      native = described_class.attributes(element).first
+      tracked = described_class.set_attribute_value(native, "updated")
+      expect(tracked).to be_a(native.class)
+      expect(tracked.value).to eq("updated")
+    end
+  end
+
+  describe "tree mutation" do
+    let(:doc) { described_class.parse(xml).native }
+    let(:root) { described_class.root(doc) }
+
+    def names_of(node)
+      described_class.children(node)
+        .map { |child| described_class.node_name(child) }
+    end
+
+    it "inserts previous and next siblings" do
+      target = described_class.children(root)[1]
+      described_class.add_previous_sibling(
+        target, described_class.create_element("before")
+      )
+      described_class.add_next_sibling(
+        target, described_class.create_element("after")
+      )
+
+      expect(names_of(root)).to eq(%w[child before child after special])
+    end
+
+    it "removes nodes from the tree" do
+      described_class.remove(described_class.children(root)[1])
+      expect(names_of(root)).to eq(%w[child special])
+    end
+
+    it "replaces a node in place" do
+      described_class.replace(
+        described_class.children(root)[1],
+        described_class.create_element("replacement"),
+      )
+      expect(names_of(root)).to eq(%w[child replacement special])
+    end
+
+    it "replaces all children" do
+      described_class.replace_children(
+        root, [described_class.create_element("only")]
+      )
+      expect(names_of(root)).to eq(%w[only])
+    end
+  end
+
+  describe "content accessors" do
+    let(:doc) { described_class.parse(xml).native }
+    let(:root) { described_class.root(doc) }
+
+    it "reads inner text from direct text children" do
+      child = described_class.children(root)[0]
+      expect(described_class.inner_text(child)).to eq("Text")
+    end
+
+    it "writes text content" do
+      element = described_class.create_element("scratch")
+      described_class.set_text_content(element, "written")
+      expect(described_class.inner_text(element)).to eq("written")
+    end
+
+    it "reads and writes comment content" do
+      comment = described_class.create_comment("note")
+      expect(described_class.comment_content(comment)).to eq("note")
+      described_class.set_comment_content(comment, "changed")
+      expect(described_class.comment_content(comment)).to eq("changed")
+    end
+
+    it "reads and writes CDATA content" do
+      cdata = described_class.create_cdata("<raw>")
+      expect(described_class.cdata_content(cdata)).to eq("<raw>")
+      described_class.set_cdata_content(cdata, "<new>")
+      expect(described_class.cdata_content(cdata)).to eq("<new>")
+    end
+  end
+
+  describe "auxiliary node creation" do
+    it "creates doctypes with external identifiers" do
+      doctype = described_class.create_doctype("cfg", "pub", "sys")
+      expect(described_class.node_type(doctype)).to eq(:doctype)
+      expect(described_class.doctype_name(doctype)).to eq("cfg")
+      expect(described_class.doctype_external_id(doctype)).to eq("pub")
+      expect(described_class.doctype_system_id(doctype)).to eq("sys")
+    end
+
+    it "creates declarations with version, encoding and standalone" do
+      declaration = described_class.create_declaration("1.0", "UTF-8", "yes")
+      expect(described_class.declaration_attribute(declaration, "version"))
+        .to eq("1.0")
+      expect(described_class.declaration_attribute(declaration, "standalone"))
+        .to eq("yes")
+    end
+
+    it "creates entity references by name" do
+      reference = described_class.create_entity_reference("copy")
+      expect(described_class.node_type(reference)).to eq(:entity_reference)
+      expect(described_class.entity_reference_name(reference)).to eq("copy")
+    end
+
+    it "duplicates nodes with their names" do
+      element = described_class.create_element("original")
+      duplicate = described_class.duplicate_node(element)
+      expect(described_class.node_name(duplicate)).to eq("original")
+      expect(duplicate).not_to equal(element)
+    end
+  end
+
+  describe "in-scope namespaces" do
+    let(:doc) { described_class.parse(xml).native }
+    let(:special) { described_class.children(described_class.root(doc)).last }
+
+    it "returns the ancestor-declared prefixes" do
+      prefixes = described_class.in_scope_namespaces(special)
+        .map { |ns| described_class.namespace_prefix(ns) }
+      # The default declaration is reported as a nil prefix everywhere
+      # except Ox, which spells it "xmlns"
+      expect(prefixes).to include("x")
+      expect(prefixes.size).to eq(2)
+    end
+  end
+
+  describe "line numbers" do
+    it "returns a 1-based position or nil" do
+      doc = described_class.parse(xml).native
+      line = described_class.line_number(described_class.root(doc))
+      expect(line.nil? || (line.is_a?(Integer) && line >= 1)).to be(true)
+    end
   end
 
   describe "namespaces" do

data/spec/moxml/attribute_resolver_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::AttributeResolver do
+  let(:context) { Moxml.new }
+  let(:doc) do
+    context.parse(<<~XML)
+      <root xmlns:p="http://x.org" xmlns:q="http://x.org">
+        <e q:type="namespaced" type="bare"/>
+      </root>
+    XML
+  end
+  let(:element) { doc.root.children.find(&:element?) }
+
+  describe ".resolve" do
+    it "matches bare names against no-namespace attributes only" do
+      expect(described_class.resolve(element, "type")&.value).to eq("bare")
+    end
+
+    it "matches prefixed names by expanded name" do
+      expect(described_class.resolve(element, "p:type")&.value)
+        .to eq("namespaced")
+      expect(described_class.resolve(element, "q:type")&.value)
+        .to eq("namespaced")
+    end
+
+    it "returns nil for undeclared prefixes and declarations" do
+      expect(described_class.resolve(element, "z:type")).to be_nil
+      expect(described_class.resolve(element, "xmlns:q")).to be_nil
+    end
+  end
+
+  describe ".assign" do
+    it "delegates xmlns declarations to the adapter" do
+      described_class.assign(element, "xmlns:r", "http://r.org")
+      expect(doc.to_xml).to include('xmlns:r="http://r.org"')
+    end
+
+    it "replaces the matching attribute in place" do
+      described_class.assign(element, "p:type", "rewritten")
+      expect(element["q:type"]).to eq("rewritten")
+      expect(element.attributes.size).to eq(2)
+    end
+
+    it "stores undeclared prefixes raw until they come into scope" do
+      described_class.assign(element, "z:type", "value")
+      expect(element["z:type"]).to be_nil
+
+      element.add_namespace("z", "http://z.org")
+      expect(element["z:type"]).to eq("value")
+    end
+  end
+
+  describe ".remove" do
+    it "removes by expanded name and returns the attribute" do
+      removed = described_class.remove(element, "p:type")
+      expect(removed.value).to eq("namespaced")
+      expect(element["q:type"]).to be_nil
+      expect(element["type"]).to eq("bare")
+    end
+
+    it "returns nil when nothing matches" do
+      expect(described_class.remove(element, "z:type")).to be_nil
+    end
+  end
+
+  describe ".attribute_test?" do
+    let(:attributes) { element.attributes }
+
+    it "applies Namespaces 1.0 §5.2 to bare names" do
+      bare = attributes.find { |a| a.value == "bare" }
+      namespaced = attributes.find { |a| a.value == "namespaced" }
+      expect(described_class.attribute_test?(element, bare, nil, "type"))
+        .to be(true)
+      expect(described_class.attribute_test?(element, namespaced, nil, "type"))
+        .to be(false)
+    end
+
+    it "matches prefixed tests by URI and accepts any local for nil" do
+      namespaced = attributes.find { |a| a.value == "namespaced" }
+      expect(described_class.attribute_test?(element, namespaced, "p", "type"))
+        .to be(true)
+      expect(described_class.attribute_test?(element, namespaced, "p", nil))
+        .to be(true)
+      expect(described_class.attribute_test?(element, namespaced, "z", "type"))
+        .to be(false)
+    end
+
+    it "treats :any as any namespace including none" do
+      bare = attributes.find { |a| a.value == "bare" }
+      expect(described_class.attribute_test?(element, bare, :any, "type"))
+        .to be(true)
+    end
+  end
+
+  describe ".attribute_test_uri?" do
+    it "matches the compile-time URI regardless of document prefixes" do
+      namespaced = element.attributes.find { |a| a.value == "namespaced" }
+      expect(described_class.attribute_test_uri?(
+               element, namespaced, "http://x.org", "type"
+             )).to be(true)
+      expect(described_class.attribute_test_uri?(
+               element, namespaced, "http://other.org", "type"
+             )).to be(false)
+    end
+  end
+end

data/spec/moxml/c14n/api_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+RSpec.describe "Moxml::C14n API" do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  describe ".canonicalize (algorithm selector)" do
+    it "defaults to inclusive C14N 1.0" do
+      doc = ctx.parse("<root xmlns:foo='urn:foo'><foo:a/></root>")
+      default_result = Moxml::C14n.canonicalize(doc.root)
+      incl10_result = Moxml::C14n.canonicalize(doc.root, algorithm: :inclusive10)
+      expect(default_result).to eq(incl10_result)
+    end
+
+    it "raises ArgumentError for unknown algorithm" do
+      expect do
+        Moxml::C14n.canonicalize("<x/>", algorithm: :bogus)
+      end.to raise_error(ArgumentError, /unknown C14N algorithm/)
+    end
+
+    it "accepts inclusive_11 algorithm" do
+      doc = ctx.parse("<root/>")
+      result = Moxml::C14n.canonicalize(doc.root, algorithm: :inclusive11)
+      expect(result).to eq("<root></root>")
+    end
+
+    it "accepts exclusive_10 algorithm" do
+      doc = ctx.parse("<root xmlns:foo='urn:foo'><foo:a/></root>")
+      result = Moxml::C14n.canonicalize(doc.root, algorithm: :exclusive10)
+      # Exclusive renders ns where visibly used (on foo:a), not on root
+      expect(result).to include('<foo:a xmlns:foo="urn:foo">')
+    end
+  end
+
+  describe ".equivalent?" do
+    it "returns true for byte-identical inputs" do
+      expect(Moxml::C14n).to be_equivalent("<root>x</root>", "<root>x</root>")
+    end
+
+    it "returns true when only attribute whitespace differs" do
+      # Whitespace inside the tag is not significant — both parse identically.
+      a = %(<root attr="value"/>)
+      b = %(<root  attr="value" />)
+      expect(Moxml::C14n).to be_equivalent(a, b)
+    end
+
+    it "returns false when text whitespace differs (text IS significant)" do
+      a = "<root><child>a</child> </root>"
+      b = "<root> <child>a</child></root>"
+      expect(Moxml::C14n).not_to be_equivalent(a, b)
+    end
+
+    it "returns true when only attribute order differs" do
+      a = %(<root a="1" b="2"/>)
+      b = %(<root b="2" a="1"/>)
+      expect(Moxml::C14n).to be_equivalent(a, b)
+    end
+
+    it "returns true when only namespace prefix differs" do
+      a = "<root xmlns:foo='urn:foo'><foo:a/></root>"
+      b = "<root xmlns:bar='urn:foo'><bar:a/></root>"
+      # Inclusive canonical form: prefix is part of qname → not equivalent
+      expect(Moxml::C14n).not_to be_equivalent(a, b)
+    end
+
+    it "returns false for different content" do
+      expect(Moxml::C14n).not_to be_equivalent("<root>a</root>", "<root>b</root>")
+    end
+
+    it "respects algorithm argument" do
+      a = "<root xmlns:foo='urn:foo'><foo:a/></root>"
+      b = "<root><a xmlns:foo='urn:foo'/></root>"
+      # Inclusive: ns on root vs on child → different
+      expect(Moxml::C14n).not_to be_equivalent(a, b, algorithm: :inclusive10)
+    end
+
+    it "accepts Moxml::Node inputs" do
+      doc1 = ctx.parse("<root/>")
+      doc2 = ctx.parse("<root></root>")
+      expect(Moxml::C14n).to be_equivalent(doc1.root, doc2.root)
+    end
+  end
+
+  describe "convenience methods" do
+    it ".canonicalize_inclusive10 matches default" do
+      doc = ctx.parse("<root/>")
+      expect(Moxml::C14n.canonicalize_inclusive10(doc.root))
+        .to eq(Moxml::C14n.canonicalize(doc.root))
+    end
+
+    it ".canonicalize_inclusive11 produces output" do
+      doc = ctx.parse("<root/>")
+      expect(Moxml::C14n.canonicalize_inclusive11(doc.root)).to eq("<root></root>")
+    end
+
+    it ".canonicalize_exclusive accepts inclusive_namespaces" do
+      doc = ctx.parse("<root xmlns:foo='urn:foo'/>")
+      result = Moxml::C14n.canonicalize_exclusive(doc.root, inclusive_namespaces: ["foo"])
+      # Even though foo is not visibly used, inclusive list forces render
+      expect(result).to include('xmlns:foo="urn:foo"')
+    end
+  end
+
+  describe "escape helpers (backward compat)" do
+    it ".escape_text escapes & < >" do
+      expect(Moxml::C14n.escape_text("a & b < c > d"))
+        .to eq("a &amp; b &lt; c &gt; d")
+    end
+
+    it ".escape_attribute escapes quotes and whitespace" do
+      expect(Moxml::C14n.escape_attribute(%(a"b\tc\nd)))
+        .to eq(%(a&quot;b&#x9;c&#xA;d))
+    end
+  end
+end

data/spec/moxml/c14n/c14n_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+
+RSpec.describe "Moxml C14N engine" do
+  describe Moxml::C14n::Exclusive do
+    let(:ctx) { Moxml.new(:nokogiri) }
+    let(:canon) { described_class.new }
+
+    it "renders a simple element without namespaces" do
+      doc = ctx.parse("<root>hello</root>")
+      expect(canon.canonicalize(doc.root)).to eq("<root>hello</root>")
+    end
+
+    it "preserves nested element structure" do
+      doc = ctx.parse("<root><child>text</child></root>")
+      expect(canon.canonicalize(doc.root)).to eq("<root><child>text</child></root>")
+    end
+
+    it "renders declared namespaces" do
+      doc = ctx.parse(<<~XML.strip)
+        <root xmlns:foo="http://example.com/foo"><foo:child>x</foo:child></root>
+      XML
+      result = canon.canonicalize(doc.root)
+      # Exclusive C14N renders the namespace on the element where it's visibly
+      # used (foo:child), not on ancestors that don't use it.
+      expect(result).to include('<foo:child xmlns:foo="http://example.com/foo">')
+      expect(result).to include("</foo:child>")
+    end
+
+    it "excludes ancestor-inherited namespaces when not visibly used (exclusive)" do
+      doc = ctx.parse(<<~XML.strip)
+        <outer xmlns:unused="http://example.com/unused"><inner>text</inner></outer>
+      XML
+      inner = doc.at_xpath("//inner")
+      result = canon.canonicalize(inner)
+      expect(result).to eq("<inner>text</inner>")
+    end
+
+    it "escapes special characters in text content" do
+      doc = ctx.parse("<root>a&lt;b&gt;c&amp;d</root>")
+      expect(canon.canonicalize(doc.root)).to eq("<root>a&lt;b&gt;c&amp;d</root>")
+    end
+
+    it "escapes special characters in attribute values" do
+      doc = ctx.parse(%(<root attr="a&amp;b&quot;c"/>))
+      expect(canon.canonicalize(doc.root))
+        .to include(%(attr="a&amp;b&quot;c"))
+    end
+
+    it "sorts attributes by namespace URI then local name" do
+      doc = ctx.parse(%(<root b="2" a="1" c="3"/>))
+      result = canon.canonicalize(doc.root)
+      expect(result).to include('a="1" b="2" c="3"')
+    end
+
+    it "omits comments by default" do
+      doc = ctx.parse("<root>a<!-- comment -->b</root>")
+      expect(canon.canonicalize(doc.root)).to eq("<root>ab</root>")
+    end
+
+    it "includes comments when with_comments is true" do
+      doc = ctx.parse("<root>a<!-- comment -->b</root>")
+      expect(canon.canonicalize(doc.root, with_comments: true))
+        .to eq("<root>a<!-- comment -->b</root>")
+    end
+  end
+
+  describe ".escape_text" do
+    it "escapes &, <, >" do
+      expect(Moxml::C14n.escape_text("a & b < c > d"))
+        .to eq("a &amp; b &lt; c &gt; d")
+    end
+
+    it "escapes bare CR as &#xD;" do
+      expect(Moxml::C14n.escape_text("a\rb"))
+        .to eq("a&#xD;b")
+    end
+  end
+
+  describe ".escape_attribute" do
+    it "escapes quotes and tabs/newlines" do
+      expect(Moxml::C14n.escape_attribute(%(a"b\tc\nd)))
+        .to eq(%(a&quot;b&#x9;c&#xA;d))
+    end
+  end
+end

data/spec/moxml/c14n/comments_pis_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+# Edge cases for comment and processing-instruction handling per
+# W3C C14N 1.0 §2.6, §2.7.
+RSpec.describe "C14N comments and PIs" do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  describe "comments inside elements" do
+    it "omits comments by default" do
+      doc = ctx.parse("<root>a<!-- c -->b</root>")
+      expect(Moxml::C14n.canonicalize(doc.root)).to eq("<root>ab</root>")
+    end
+
+    it "includes comments when with_comments: true" do
+      doc = ctx.parse("<root>a<!-- c -->b</root>")
+      expect(Moxml::C14n.canonicalize(doc.root, with_comments: true))
+        .to eq("<root>a<!-- c -->b</root>")
+    end
+
+    it "preserves comment content verbatim" do
+      doc = ctx.parse("<root><!-- &amp; <stuff> --></root>")
+      expect(Moxml::C14n.canonicalize(doc.root, with_comments: true))
+        .to eq("<root><!-- &amp; <stuff> --></root>")
+    end
+  end
+
+  describe "processing instructions" do
+    it "always renders PIs (not affected by with_comments)" do
+      doc = ctx.parse("<root><?pi data?>x</root>")
+      expect(Moxml::C14n.canonicalize(doc.root))
+        .to eq("<root><?pi data?>x</root>")
+    end
+
+    it "renders PI without data when data is empty" do
+      doc = ctx.parse("<root><?pi?>x</root>")
+      expect(Moxml::C14n.canonicalize(doc.root))
+        .to eq("<root><?pi?>x</root>")
+    end
+
+    it "preserves PI target and data verbatim" do
+      doc = ctx.parse(%(<root><?xml-stylesheet href="a.css" type="text/css"?>x</root>))
+      expect(Moxml::C14n.canonicalize(doc.root))
+        .to include(%(<?xml-stylesheet href="a.css" type="text/css"?>))
+    end
+  end
+
+  describe "PIs at document level" do
+    # TODO.c14n/09: Document-level PIs (outside the document element) are
+    # not yet rendered correctly. The moxml PI parser mis-parses document-level
+    # PIs, and the DataModel.from_document path drops them. Fixing requires
+    # adapter-level work and is tracked separately.
+    it "renders PIs outside the document element (KNOWN LIMITATION)" do
+      skip "document-level PI rendering not yet implemented"
+    end
+  end
+
+  describe "comments at document level" do
+    it "renders document-level comments when with_comments: true (KNOWN LIMITATION)" do
+      skip "document-level comment rendering not yet implemented"
+    end
+  end
+end

data/spec/moxml/c14n/inclusive10_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+
+RSpec.describe Moxml::C14n::Inclusive10 do
+  let(:ctx) { Moxml.new(:nokogiri) }
+  let(:canon) { described_class.new }
+
+  it "renders a simple element" do
+    doc = ctx.parse("<root>hello</root>")
+    expect(canon.canonicalize(doc.root)).to eq("<root>hello</root>")
+  end
+
+  it "attracts ancestor namespaces at the apex (the key inclusive behavior)" do
+    xml = <<~XML.strip
+      <outer xmlns:foo="http://example.com/foo" xmlns:bar="http://example.com/bar">
+        <inner x="1"><foo:child>hello</foo:child></inner>
+      </outer>
+    XML
+    doc = ctx.parse(xml)
+    inner = doc.at_xpath("//*[local-name()='inner']")
+    result = canon.canonicalize(inner)
+    # Both inherited namespaces are rendered on <inner>, even though
+    # <inner> itself does not visibly use them. This is the inclusive
+    # "ancestor attraction" behavior.
+    expect(result).to include('xmlns:bar="http://example.com/bar"')
+    expect(result).to include('xmlns:foo="http://example.com/foo"')
+  end
+
+  it "renders each namespace declaration only once per chain" do
+    xml = <<~XML.strip
+      <root xmlns:a="http://example.com/a">
+        <child xmlns:a="http://example.com/a"><grand/></child>
+      </root>
+    XML
+    doc = ctx.parse(xml)
+    result = canon.canonicalize(doc.root)
+    expect(result.scan('xmlns:a="http://example.com/a"').count).to eq(1)
+  end
+
+  it "re-renders a namespace when re-declared with a different URI" do
+    xml = <<~XML.strip
+      <root xmlns:a="http://example.com/a">
+        <child xmlns:a="http://example.com/other"><grand/></child>
+      </root>
+    XML
+    doc = ctx.parse(xml)
+    result = canon.canonicalize(doc.root)
+    expect(result.scan("xmlns:a=").count).to eq(2)
+  end
+
+  it "renders the default namespace at apex when inherited" do
+    xml = '<outer xmlns="http://example.com"><inner/></outer>'
+    doc = ctx.parse(xml)
+    inner = doc.at_xpath("//*[local-name()='inner']")
+    result = canon.canonicalize(inner)
+    expect(result).to include('xmlns="http://example.com"')
+  end
+end