moxml 0.1.26 → 0.3.0

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

@@ -96,23 +96,30 @@ 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
     end
+
+    describe "duplication" do
+      it "returns an independent deep copy" do
+        doc = context.parse("<root><a id='1'>text</a></root>")
+        original = doc.at_xpath("//a")
+        copy = original.dup
+
+        expect(copy).not_to equal(original)
+        expect(copy.name).to eq("a")
+        expect(copy["id"]).to eq("1")
+        expect(copy.text).to eq("text")
+        copy["id"] = "changed"
+        expect(original["id"]).to eq("1")
+      end
+    end
   end
 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/libxml_internals_spec.rb

@@ -154,7 +154,7 @@ RSpec.describe Moxml::Adapter::Libxml do
     end
   end
 
-  describe Moxml::Adapter::Libxml::EntityRestorer do
+  describe Moxml::Entity::Restorer do
     let(:context) { Moxml.new(:libxml) }
 
     it "restores entities through its public entry point" do

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

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

@@ -11,7 +11,6 @@ RSpec.describe Moxml::Config do
       expect(config.default_encoding).to eq("UTF-8")
       expect(config.default_indent).to eq(2)
       expect(config.default_line_ending).to eq("\n")
-      expect(config.entity_encoding).to eq(:basic)
     end
 
     it "sets default entity_load_mode to :required" do

data/spec/moxml/context_spec.rb

@@ -39,4 +39,26 @@ RSpec.describe Moxml::Context do
       expect(doc.root.name).to eq("root")
     end
   end
+
+  describe "wrapper identity map" do
+    it "hands back the same wrapper for the same native" do
+      doc = context.parse("<root><item id='1'/></root>")
+      first = doc.xpath("//item").first
+      second = doc.xpath("//item").first
+      expect(first).to equal(second)
+
+      again = doc.root.children.last
+      expect(again).to equal(first)
+    end
+
+    it "re-keys when refresh_native! swaps the native" do
+      doc = context.create_document
+      element = doc.create_element("x")
+      doc.add_child(element)
+
+      refreshed = doc.root
+      expect(refreshed.name).to eq("x")
+      expect(context.wrapper_for(refreshed.native)).to equal(refreshed)
+    end
+  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/error_spec.rb

@@ -150,31 +150,6 @@ RSpec.describe "Moxml errors" do
     end
   end
 
-  describe Moxml::SerializationError do
-    it "includes node, adapter, and format information" do
-      error = described_class.new(
-        "Failed to serialize",
-        adapter: "LibXML",
-        format: "xml",
-      )
-      expect(error.adapter).to eq("LibXML")
-      expect(error.format).to eq("xml")
-    end
-
-    it "provides helpful error message" do
-      error = described_class.new(
-        "Failed to serialize",
-        adapter: "Ox",
-        format: "xml",
-      )
-      message = error.to_s
-      expect(message).to include("Failed to serialize")
-      expect(message).to include("Adapter: Ox")
-      expect(message).to include("Format: xml")
-      expect(message).to include("Hint:")
-    end
-  end
-
   describe Moxml::DocumentStructureError do
     it "includes attempted operation and state" do
       error = described_class.new(
@@ -200,31 +175,6 @@ RSpec.describe "Moxml errors" do
     end
   end
 
-  describe Moxml::AttributeError do
-    it "includes attribute name, element, and value" do
-      error = described_class.new(
-        "Invalid attribute",
-        name: "id",
-        value: 123,
-      )
-      expect(error.attribute_name).to eq("id")
-      expect(error.value).to eq(123)
-    end
-
-    it "provides helpful error message" do
-      error = described_class.new(
-        "Invalid attribute name",
-        name: "123invalid",
-        value: "test",
-      )
-      message = error.to_s
-      expect(message).to include("Invalid attribute name")
-      expect(message).to include("Attribute: 123invalid")
-      expect(message).to include("Value: \"test\"")
-      expect(message).to include("Hint:")
-    end
-  end
-
   describe Moxml::NotImplementedError do
     it "includes feature and adapter information" do
       error = described_class.new(