moxml 0.1.26 → 0.2.0

data/spec/integration/sax_parity_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# SAX event parity across adapters: every bridge must translate its
+# native SAX stream into the same Moxml event sequence — same element
+# names (qualified), same attribute/declaration split (nil key = the
+# default namespace), same characters.
+RSpec.describe "SAX parity across adapters" do
+  let(:xml) do
+    <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <root xmlns="http://d.org" xmlns:p="http://p.org" kind="a"><p:child id="1">text</p:child></root>
+    XML
+  end
+
+  def recorded_events(adapter_name)
+    events = []
+    handler = Class.new(Moxml::SAX::Handler) do
+      define_method(:track) { |*event| events << event }
+      define_method(:on_start_document) { track(:start_document) }
+      define_method(:on_end_document) { track(:end_document) }
+      define_method(:on_start_element) { |n, a, ns| track(:start_element, n, a, ns) }
+      define_method(:on_end_element) { |n| track(:end_element, n) }
+      define_method(:on_characters) { |t| track(:characters, t) }
+    end
+    Moxml.new(adapter_name).sax_parse(xml, handler.new)
+    events
+  end
+
+  def assert_parity(adapter_name)
+    # REXML and Oga report document-level whitespace (between the
+    # declaration and the root) as characters; parity is over the
+    # meaningful event stream.
+    events = recorded_events(adapter_name)
+      .reject { |event| event[0] == :characters && event[1].to_s.strip.empty? }
+
+    expect(events.first).to eq([:start_document])
+    expect(events[1]).to eq(
+      [:start_element, "root",
+       { "kind" => "a" },
+       { nil => "http://d.org", "p" => "http://p.org" }],
+    )
+    expect(events[2]).to eq([:start_element, "p:child", { "id" => "1" }, {}])
+    expect(events).to include([:characters, "text"])
+    expect(events).to include([:end_element, "p:child"])
+    expect(events).to include([:end_element, "root"])
+    expect(events.last).to eq([:end_document])
+  end
+
+  adapters = %i[nokogiri oga rexml ox headed_ox libxml]
+  adapters << :leptris if Object.const_defined?(:Leptris) &&
+    Leptris::XML::Document.respond_to?(:create)
+
+  adapters.each do |adapter_name|
+    it "emits the same event stream via #{adapter_name}" do
+      assert_parity(adapter_name)
+    end
+  end
+end

data/spec/integration/shared_examples/edge_cases.rb

@@ -80,9 +80,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
   describe "namespace edge cases" do
     it "handles default namespace changes" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
       end
@@ -106,9 +103,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
     end
 
     it "handles recursive namespace definitions" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
       end
@@ -132,10 +126,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace-prefixed attribute access needs Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
       end
-      if context.config.adapter_name == :ox
-        skip "Ox doesn't have a native XPath"
-      end
-
       xml = <<~XML
         <root xmlns:a="http://a.org" xmlns:b="http://b.org">
           <element a:id="1" b:id="2"/>

data/spec/integration/shared_examples/integration_workflows.rb

@@ -56,9 +56,6 @@ RSpec.shared_examples "Moxml Integration" do
     end
 
     it "handles xpath queries" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't support namespace-aware XPath with predicates"
-      end
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace-aware XPath with predicates needs investigation. See docs/_pages/headed-ox-limitations.adoc"
       end
@@ -76,9 +73,6 @@ RSpec.shared_examples "Moxml Integration" do
 
   describe "namespace handling" do
     it "handles complex namespace scenarios" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
       end
@@ -125,10 +119,6 @@ RSpec.shared_examples "Moxml Integration" do
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Parent setter not implemented. Requires Ox node reparenting API. See docs/_pages/headed-ox-limitations.adoc"
       end
-      if context.config.adapter_name == :ox
-        skip "Ox doesn't have a native XPath"
-      end
-
       # Move nodes
       b_node = doc.at_xpath("//b")
       a_node = doc.at_xpath("//a")

data/spec/integration/shared_examples/node_wrappers/attribute_behavior.rb

@@ -65,6 +65,65 @@ RSpec.shared_examples "Moxml::Attribute" do
         expect(attribute.namespace.prefix).to eq("other")
         expect(attribute.to_s).to eq('other:attr="value"')
       end
+
+      it "replaces by expanded name across prefix spellings" do
+        element["ns:attr"] = "first"
+        element.add_namespace("alias", "http://example.org")
+        element["alias:attr"] = "second"
+
+        expect(element["ns:attr"]).to eq("second")
+        expect(element.attributes.size).to eq(1)
+      end
+    end
+
+    describe "expanded-name writes (AttributeResolver)" do
+      before do
+        element.add_namespace("p", "http://x.org")
+        element.add_namespace("q", "http://x.org")
+        element["q:type"] = "namespaced"
+        element["type"] = "bare"
+      end
+
+      it "does not clobber a namespaced attribute sharing the local name" do
+        element["type"] = "changed"
+
+        expect(element["type"]).to eq("changed")
+        expect(element["q:type"]).to eq("namespaced")
+      end
+
+      it "overwrites by expanded name regardless of prefix spelling" do
+        element["p:type"] = "overwritten"
+
+        expect(element["q:type"]).to eq("overwritten")
+        expect(element.attributes.size).to eq(2)
+      end
+
+      it "stores writes through undeclared prefixes raw for later resolution" do
+        element["z:type"] = "value"
+
+        # No declaration in scope: the read resolves to nothing, but
+        # the attribute is stored (detached builds attach under the
+        # declaring ancestor later).
+        expect(element["z:type"]).to be_nil
+        expect(element.attributes.size).to eq(3)
+
+        element.add_namespace("z", "http://z.org")
+        expect(element["z:type"]).to eq("value")
+      end
+
+      it "removes the bare attribute without touching the namespaced one" do
+        element.remove_attribute("type")
+
+        expect(element["type"]).to be_nil
+        expect(element["q:type"]).to eq("namespaced")
+      end
+
+      it "removes by expanded name regardless of prefix spelling" do
+        element.remove_attribute("p:type")
+
+        expect(element["q:type"]).to be_nil
+        expect(element["type"]).to eq("bare")
+      end
     end
 
     describe "manipulation" do
@@ -162,4 +221,43 @@ RSpec.shared_examples "Moxml::Attribute" do
       end
     end
   end
+
+  describe "unified XML-correct name resolution" do
+    let(:context) { Moxml.new }
+    let(:doc) do
+      context.parse(
+        %(<root xmlns:p="urn:1"><child xmlns:q="urn:1" q:type="v" type="plain" xml:lang="en"/></root>),
+      )
+    end
+    let(:child) { doc.root.children.find(&:element?) }
+
+    it "matches prefixed lookups by expanded name across redeclared prefixes" do
+      # p and q both bind urn:1; the attribute is written q:type
+      expect(child["p:type"]).to eq("v")
+      expect(child["q:type"]).to eq("v")
+    end
+
+    it "keeps bare and namespaced attributes distinct" do
+      expect(child["type"]).to eq("plain")
+      expect(child[:type]).to eq("plain")
+    end
+
+    it "resolves the prebound xml prefix without any declaration" do
+      expect(child["xml:lang"]).to eq("en")
+    end
+
+    it "returns nil for undeclared prefixes — no prefix-string fallback" do
+      expect(child["undeclared:type"]).to be_nil
+    end
+
+    it "never treats namespace declarations as attributes" do
+      expect(child["xmlns:q"]).to be_nil
+      expect(child["xmlns"]).to be_nil
+    end
+
+    it "attribute(name) agrees with []" do
+      expect(child.attribute("p:type").value).to eq("v")
+      expect(child.attribute("undeclared:type")).to be_nil
+    end
+  end
 end

data/spec/integration/shared_examples/node_wrappers/namespace_behavior.rb

@@ -170,6 +170,32 @@ RSpec.shared_examples "Moxml::Namespace" do
         expect(prefixes).to include("xs")
       end
 
+      it "sees ancestor declarations made after a first read (cache invalidation)" do
+        root = doc.create_element("root")
+        root.add_namespace("a", "http://a.org")
+        child = doc.create_element("child")
+        root.add_child(child)
+        child.in_scope_namespaces # materialize the scope cache
+
+        root.add_namespace("b", "http://b.org")
+
+        expect(child.in_scope_namespaces.map(&:prefix)).to include("b")
+      end
+
+      it "recomputes the scope after the subtree is reparented" do
+        source = doc.create_element("source")
+        source.add_namespace("s", "http://s.org")
+        child = doc.create_element("child")
+        source.add_child(child)
+        child.in_scope_namespaces # materialize the scope cache
+
+        target = doc.create_element("target")
+        child.remove
+        target.add_child(child)
+
+        expect(child.in_scope_namespaces.map(&:prefix)).not_to include("s")
+      end
+
       it "collects namespaces from multiple ancestor levels" do
         root = doc.create_element("root")
         root.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")

data/spec/integration/shared_examples/node_wrappers/node_behavior.rb

@@ -96,20 +96,12 @@ RSpec.shared_examples "Moxml::Node" do
       let(:doc) { context.parse("<root><a><b>1</b></a><a><b>2</b></a></root>") }
 
       it "finds nodes by xpath" do
-        if context.config.adapter_name == :ox
-          pending "Ox doesn't have a native XPath"
-        end
-
         nodes = doc.xpath("//b")
         expect(nodes.size).to eq(2)
         expect(nodes.map(&:text)).to eq(%w[1 2])
       end
 
       it "finds first node by xpath" do
-        if context.config.adapter_name == :ox
-          pending "Ox doesn't have a native XPath"
-        end
-
         node = doc.at_xpath("//b")
         expect(node.text).to eq("1")
       end

data/spec/moxml/adapter/leptris_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+begin
+  require "leptris"
+rescue LoadError
+  # Leptris gem not available - skip all specs in this file
+  return
+end
+
+# Programmatic document construction relies on the C API added for the
+# Moxml integration (leptris_document_create / leptris_document_set_root,
+# exposed as Leptris::XML::Document.create / #root=). Released leptris
+# 1.1.x does not ship it yet; skip instead of failing until the binding
+# release catches up.
+unless Leptris::XML::Document.respond_to?(:create)
+  # String form: the adapter constant is not loaded in this branch —
+  # resolving it would raise NameError before the skip applies.
+  RSpec.describe "Moxml::Adapter::Leptris" do
+    it "waits for a leptris release with programmatic document construction" do
+      skip "requires leptris with Leptris::XML::Document.create (unreleased C API)"
+    end
+  end
+
+  return
+end
+
+require "moxml/adapter/leptris"
+
+RSpec.describe Moxml::Adapter::Leptris do
+  around do |example|
+    Moxml.with_config(:leptris, true, "UTF-8") do
+      example.run
+    end
+  end
+
+  it_behaves_like "xml adapter"
+
+  describe "native xpath dispatch" do
+    let(:ctx) { Moxml.new(:leptris) }
+    let(:doc) do
+      ctx.parse(<<~XML)
+        <root xmlns:p="http://x.org">
+          <item id="1" p:kind="a">alpha</item>
+          <item id="2">beta</item>
+        </root>
+      XML
+    end
+
+    it "evaluates document-context queries on the native engine" do
+      expect(doc.xpath("//item[@id='2']").map(&:text)).to eq(["beta"])
+      expect(doc.xpath("count(//item)")).to eq(2.0)
+      expect(doc.xpath("//item[@p:kind='a']").map { |n| n["id"] }).to eq(["1"])
+    end
+
+    it "falls back to the Ruby engine for attribute-node results" do
+      attrs = doc.xpath("//item/@id")
+      expect(attrs.map(&:name)).to eq(%w[id id])
+      expect(attrs.map(&:value)).to eq(%w[1 2])
+    end
+
+    it "falls back to the Ruby engine for element-context queries" do
+      expect(doc.root.xpath(".//item").size).to eq(2)
+    end
+
+    it "falls back to the Ruby engine for the xmlns: reserved prefix" do
+      expect(doc.xpath("//xmlns:item").size).to eq(0)
+      prefixed = ctx.parse('<r xmlns="http://d.org"><item/></r>')
+      expect(prefixed.xpath("//xmlns:item").size).to eq(1)
+    end
+
+    it "raises Moxml::XPathError for invalid expressions" do
+      expect { doc.xpath("//item[") }.to raise_error(Moxml::XPathError)
+    end
+  end
+end

data/spec/moxml/adapter/ox_spec.rb

@@ -38,21 +38,35 @@ RSpec.describe Moxml::Adapter::Ox do
 
   describe "xpath support" do
     let(:doc) do
-      described_class.parse("<root><child id='1'>text</child></root>").native
+      described_class.parse("<root><child id='1'>text</child><child id='2'>more</child></root>").native
     end
 
     it "supports basic element matching" do
       nodes = described_class.xpath(doc, "//child")
-      expect(nodes.size).to eq(1)
+      expect(nodes.size).to eq(2)
       expect(nodes.first.name).to eq("child")
     end
 
-    it "supports attribute matching" do
-      pending("Ox does not support attribute value predicates in XPath (documented limitation)")
-
+    it "supports attribute value predicates" do
       nodes = described_class.xpath(doc, "//child[@id='1']")
       expect(nodes.size).to eq(1)
-      expect(nodes.first.attributes["id"]).to eq("1")
+      expect(nodes.first.attributes[:id]).to eq("1")
+    end
+
+    it "supports logical operators" do
+      nodes = described_class.xpath(doc, "//child[@id='1' or @id='2']")
+      expect(nodes.size).to eq(2)
+    end
+
+    it "supports position predicates" do
+      nodes = described_class.xpath(doc, "//child[2]")
+      expect(nodes.size).to eq(1)
+      expect(nodes.first.attributes[:id]).to eq("2")
+    end
+
+    it "supports XPath functions" do
+      count = described_class.xpath(doc, "count(//child)")
+      expect(count).to eq(2)
     end
   end
 end

data/spec/moxml/adapter/platform_spec.rb

@@ -75,9 +75,22 @@ RSpec.describe Moxml::Adapter do
   end
 
   describe "default adapter / available list invariants" do
-    it "DEFAULT_ADAPTER is a member of AVAILABLE_ADAPTERS" do
+    it "PREFERRED and FALLBACK adapters are members of AVAILABLE_ADAPTERS" do
       expect(Moxml::Adapter::AVAILABLE_ADAPTERS)
-        .to include(Moxml::Config::DEFAULT_ADAPTER)
+        .to include(Moxml::Config::PREFERRED_ADAPTER, Moxml::Config::FALLBACK_ADAPTER)
+    end
+
+    it "the resolved runtime default adapter is loadable" do
+      expect(Moxml::Adapter::AVAILABLE_ADAPTERS)
+        .to include(Moxml::Config.default_adapter)
+    end
+
+    it "prefers leptris only when the installed gem supports document construction" do
+      if Moxml::Config.leptris_preferred_available?
+        expect(Moxml::Config.runtime_default_adapter).to eq(:leptris)
+      else
+        expect(Moxml::Config.runtime_default_adapter).not_to eq(:leptris)
+      end
     end
 
     it "OPAL_DEFAULT_ADAPTER is a member of OPAL_AVAILABLE_ADAPTERS" do

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