moxml 0.1.6 → 0.1.8

data/spec/moxml/adapter/headed_ox_spec.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Ensure HeadedOx adapter is loaded
+Moxml::Adapter.load(:headed_ox)
+
+RSpec.describe Moxml::Adapter::HeadedOx do
+  let(:adapter) { described_class }
+  let(:xml) do
+    <<~XML
+      <root>
+        <book price="10">
+          <title>Book 1</title>
+          <author>Author A</author>
+        </book>
+        <book price="20">
+          <title>Book 2</title>
+          <author>Author B</author>
+        </book>
+        <book price="30">
+          <title>Book 3</title>
+          <author>Author C</author>
+        </book>
+      </root>
+    XML
+  end
+
+  describe ".parse" do
+    it "parses XML using Ox" do
+      doc = adapter.parse(xml)
+
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root.name).to eq("root")
+    end
+  end
+
+  describe ".xpath" do
+    let(:doc) { adapter.parse(xml) }
+
+    it "executes simple XPath queries" do
+      result = adapter.xpath(doc, "/root/book")
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(3)
+    end
+
+    it "executes XPath with numeric predicates" do
+      result = adapter.xpath(doc, "//book[@price < 25]")
+
+      expect(result.size).to eq(2)
+    end
+
+    it "executes XPath with string predicates" do
+      result = adapter.xpath(doc, "//book[@price='20']")
+
+      expect(result.size).to eq(1)
+    end
+
+    it "executes XPath with functions" do
+      result = adapter.xpath(doc, "count(//book)")
+
+      expect(result).to eq(3.0)
+    end
+
+    it "executes complex XPath with paths" do
+      result = adapter.xpath(doc, "//book[@price < 25]/title")
+
+      expect(result.size).to eq(2)
+      expect(result.map(&:text)).to contain_exactly("Book 1", "Book 2")
+    end
+
+    it "supports XPath string functions in predicates" do
+      skip "HeadedOx limitation: Text content access from nested elements needs investigation. See docs/HEADED_OX_LIMITATIONS.md"
+      result = adapter.xpath(doc, "//book[contains(title, '2')]")
+
+      expect(result.size).to eq(1)
+      expect(result.first.xpath("title").first.text).to eq("Book 2")
+    end
+
+    it "supports XPath position functions" do
+      skip "HeadedOx limitation: Text content access from nested elements needs investigation. See docs/HEADED_OX_LIMITATIONS.md"
+      result = adapter.xpath(doc, "//book[position() = 2]")
+
+      expect(result.size).to eq(1)
+      expect(result.first.xpath("title").first.text).to eq("Book 2")
+    end
+
+    it "supports descendant axis" do
+      result = adapter.xpath(doc, "//title")
+
+      expect(result.size).to eq(3)
+    end
+
+    it "supports attribute axis" do
+      result = adapter.xpath(doc, "//book/@price")
+
+      expect(result.size).to eq(3)
+      expect(result.map(&:value)).to contain_exactly("10", "20", "30")
+    end
+
+    it "supports parent axis" do
+      title = adapter.xpath(doc, "//title").first
+      result = adapter.xpath(title, "parent::book")
+
+      expect(result.size).to eq(1)
+      expect(result.first.name).to eq("book")
+    end
+
+    it "handles namespace queries" do
+      ns_xml = '<root xmlns:ns="http://example.com"><ns:item/></root>'
+      ns_doc = adapter.parse(ns_xml)
+
+      result = adapter.xpath(
+        ns_doc,
+        "//ns:item",
+        { "ns" => "http://example.com" },
+      )
+
+      expect(result.size).to eq(1)
+    end
+
+    it "returns non-node values directly" do
+      result = adapter.xpath(doc, "string(//book[1]/title)")
+
+      expect(result).to eq("Book 1")
+    end
+
+    it "handles boolean results" do
+      result = adapter.xpath(doc, "boolean(//book)")
+
+      expect(result).to be true
+    end
+
+    it "wraps error with XPathError" do
+      expect do
+        adapter.xpath(doc, "invalid[[[syntax")
+      end.to raise_error(Moxml::XPathError)
+    end
+  end
+
+  describe ".at_xpath" do
+    let(:doc) { adapter.parse(xml) }
+
+    it "returns first matching node" do
+      result = adapter.at_xpath(doc, "//book")
+
+      expect(result).to be_a(Moxml::Element)
+      expect(result.name).to eq("book")
+    end
+
+    it "returns nil when no match" do
+      result = adapter.at_xpath(doc, "//nonexistent")
+
+      expect(result).to be_nil
+    end
+
+    it "returns scalar values directly" do
+      result = adapter.at_xpath(doc, "count(//book)")
+
+      expect(result).to eq(3.0)
+    end
+  end
+
+  describe ".xpath_supported?" do
+    it "returns true" do
+      expect(adapter.xpath_supported?).to be true
+    end
+  end
+
+  describe ".capabilities" do
+    it "reports full XPath support" do
+      caps = adapter.capabilities
+
+      expect(caps[:xpath_full]).to be true
+      expect(caps[:xpath_axes]).to eq(:partial) # 6 of 13 axes supported
+      expect(caps[:xpath_functions]).to eq(:complete) # All 27 XPath 1.0 functions
+      expect(caps[:xpath_predicates]).to be true
+      expect(caps[:xpath_namespaces]).to be true
+      expect(caps[:xpath_variables]).to be true
+    end
+
+    it "inherits Ox adapter capabilities" do
+      caps = adapter.capabilities
+
+      # Should have parsing capability from Ox
+      expect(caps).to have_key(:parse)
+    end
+  end
+
+  describe "XPath function support" do
+    let(:doc) { adapter.parse(xml) }
+
+    context "string functions" do
+      it "supports string()" do
+        result = adapter.xpath(doc, "string(//book[1]/title)")
+        expect(result).to eq("Book 1")
+      end
+
+      it "supports concat()" do
+        result = adapter.xpath(doc, "concat('Price: ', //book[1]/@price)")
+        expect(result).to eq("Price: 10")
+      end
+
+      it "supports contains()" do
+        result = adapter.xpath(doc, "//book[contains(title, 'Book')]")
+        expect(result.size).to eq(3)
+      end
+
+      it "supports starts-with()" do
+        result = adapter.xpath(doc, "//book[starts-with(title, 'Book')]")
+        expect(result.size).to eq(3)
+      end
+
+      it "supports substring()" do
+        result = adapter.xpath(doc, "substring('Hello World', 7)")
+        expect(result).to eq("World")
+      end
+
+      it "supports string-length()" do
+        result = adapter.xpath(doc, "string-length('Hello')")
+        expect(result).to eq(5.0)
+      end
+
+      it "supports normalize-space()" do
+        result = adapter.xpath(doc, "normalize-space('  hello  world  ')")
+        expect(result).to eq("hello world")
+      end
+    end
+
+    context "numeric functions" do
+      it "supports number()" do
+        result = adapter.xpath(doc, "number(//book[1]/@price)")
+        expect(result).to eq(10.0)
+      end
+
+      it "supports sum()" do
+        result = adapter.xpath(doc, "sum(//book/@price)")
+        expect(result).to eq(60.0)
+      end
+
+      it "supports count()" do
+        result = adapter.xpath(doc, "count(//book)")
+        expect(result).to eq(3.0)
+      end
+
+      it "supports floor()" do
+        result = adapter.xpath(doc, "floor(3.7)")
+        expect(result).to eq(3.0)
+      end
+
+      it "supports ceiling()" do
+        result = adapter.xpath(doc, "ceiling(3.2)")
+        expect(result).to eq(4.0)
+      end
+
+      it "supports round()" do
+        result = adapter.xpath(doc, "round(3.5)")
+        expect(result).to eq(4.0)
+      end
+    end
+
+    context "boolean functions" do
+      it "supports boolean()" do
+        result = adapter.xpath(doc, "boolean(//book)")
+        expect(result).to be true
+      end
+
+      it "supports not()" do
+        result = adapter.xpath(doc, "not(false())")
+        expect(result).to be true
+      end
+
+      it "supports true()" do
+        result = adapter.xpath(doc, "true()")
+        expect(result).to be true
+      end
+
+      it "supports false()" do
+        result = adapter.xpath(doc, "false()")
+        expect(result).to be false
+      end
+    end
+
+    context "node functions" do
+      it "supports name()" do
+        result = adapter.xpath(doc, "name(//book[1])")
+        expect(result).to eq("book")
+      end
+
+      it "supports local-name()" do
+        result = adapter.xpath(doc, "local-name(//book[1])")
+        expect(result).to eq("book")
+      end
+    end
+
+    context "position functions" do
+      it "supports position()" do
+        result = adapter.xpath(doc, "//book[position() = 2]")
+        expect(result.size).to eq(1)
+      end
+
+      it "supports last()" do
+        skip "HeadedOx limitation: Text content access from nested elements needs investigation. See docs/HEADED_OX_LIMITATIONS.md"
+        result = adapter.xpath(doc, "//book[position() = last()]")
+        expect(result.size).to eq(1)
+        expect(result.first.xpath("title").first.text).to eq("Book 3")
+      end
+    end
+  end
+end

data/spec/moxml/adapter/libxml_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "libxml"
+require "moxml/adapter/libxml"
+
+RSpec.describe Moxml::Adapter::Libxml do
+  around do |example|
+    Moxml.with_config(:libxml, true, "UTF-8") do
+      example.run
+    end
+  end
+
+  it_behaves_like "xml adapter"
+end

data/spec/moxml/adapter/ox_spec.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
 
-require "ox"
 require "moxml/adapter/ox"
 
-RSpec.describe Moxml::Adapter::Ox, skip: "Ox will be added later" do
-  before(:all) do
-    Moxml.configure do |config|
-      config.adapter = :ox
-      config.strict_parsing = true
-      config.default_encoding = "UTF-8"
+RSpec.describe Moxml::Adapter::Ox do
+  around do |example|
+    Moxml.with_config(:ox, true, "UTF-8") do
+      example.run
     end
   end
 
@@ -32,7 +29,9 @@ RSpec.describe Moxml::Adapter::Ox, skip: "Ox will be added later" do
   end
 
   describe "xpath support" do
-    let(:doc) { described_class.parse("<root><child id='1'>text</child></root>") }
+    let(:doc) do
+      described_class.parse("<root><child id='1'>text</child></root>").native
+    end
 
     it "supports basic element matching" do
       nodes = described_class.xpath(doc, "//child")
@@ -41,6 +40,8 @@ RSpec.describe Moxml::Adapter::Ox, skip: "Ox will be added later" do
     end
 
     it "supports attribute matching" do
+      pending("Ox does not support attribute value predicates in XPath (documented limitation)")
+
       nodes = described_class.xpath(doc, "//child[@id='1']")
       expect(nodes.size).to eq(1)
       expect(nodes.first.attributes["id"]).to eq("1")

data/spec/{support/shared_examples/xml_adapter.rb → moxml/adapter/shared_examples/adapter_contract.rb}

@@ -26,6 +26,9 @@ RSpec.shared_examples "xml adapter" do
     end
 
     it "handles malformed XML according to strict setting" do
+      if described_class.name.include?("Ox")
+        skip("Ox does not support non-strict parsing mode")
+      end
       malformed = "<root><unclosed>"
 
       expect do
@@ -164,8 +167,18 @@ RSpec.shared_examples "xml adapter" do
     end
 
     it "respects indentation settings" do
-      pending("Oga does not support indentation settings") if described_class.name.include?("Oga")
-      pending("Postponed for Rexml till better times") if described_class.name.include?("Rexml")
+      if described_class.name.include?("Oga")
+        pending("Oga does not support indentation settings")
+      end
+      if described_class.name.include?("Rexml")
+        pending("Postponed for Rexml till better times")
+      end
+      if described_class.name.include?("Libxml")
+        skip("LibXML serialization does not support indentation (documented limitation)")
+      end
+      if described_class.name.include?("Ox")
+        skip("Ox does not support indentation settings (documented limitation)")
+      end
 
       unindented = described_class.serialize(doc, indent: 0)
       indented = described_class.serialize(doc, indent: 2)
@@ -217,7 +230,9 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
-        pending("Rexml does not respect ZPath namespaces") if described_class.name.include?("Rexml")
+        if described_class.name.include?("Rexml")
+          pending("Rexml does not respect ZPath namespaces")
+        end
         # Parse original XML
         doc = described_class.parse(xml).native
 
@@ -229,18 +244,21 @@ RSpec.shared_examples "xml adapter" do
         # Test xpath with namespaces
         namespaces = {
           "svg" => "http://www.w3.org/2000/svg",
-          "xlink" => "http://www.w3.org/1999/xlink"
+          "xlink" => "http://www.w3.org/1999/xlink",
         }
 
         # Find use element and verify xlink:href attribute
         use_elem = described_class.at_xpath(doc, "//svg:use", namespaces)
         expect(use_elem).not_to be_nil
-        expect(described_class.get_attribute_value(use_elem, "xlink:href")).to eq("#myCircle")
+        expect(described_class.get_attribute_value(use_elem,
+                                                   "xlink:href")).to eq("#myCircle")
 
         # Verify circle element exists in defs
-        circle = described_class.at_xpath(doc, "//svg:defs/svg:circle", namespaces)
+        circle = described_class.at_xpath(doc, "//svg:defs/svg:circle",
+                                          namespaces)
         expect(circle).not_to be_nil
-        expect(described_class.get_attribute_value(circle, "id")).to eq("myCircle")
+        expect(described_class.get_attribute_value(circle,
+                                                   "id")).to eq("myCircle")
 
         # Test default SVG namespace
         text = described_class.at_xpath(doc, "//svg:text", namespaces)
@@ -252,7 +270,7 @@ RSpec.shared_examples "xml adapter" do
       let(:xml) do
         <<~XML
           <?xml version="1.0" encoding="UTF-8"?>
-          <rss version="2.0"#{" "}
+          <rss version="2.0"#{' '}
             xmlns:atom="http://www.w3.org/2005/Atom"
             xmlns:dc="http://purl.org/dc/elements/1.1/"
             xmlns:content="http://purl.org/rss/1.0/modules/content/">
@@ -270,6 +288,10 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
+        if described_class.name.include?("Ox")
+          skip("Ox does not support namespace-aware XPath queries (documented limitation)")
+        end
+
         # Parse original XML
         doc = described_class.parse(xml).native
 
@@ -283,7 +305,7 @@ RSpec.shared_examples "xml adapter" do
         namespaces = {
           "atom" => "http://www.w3.org/2005/Atom",
           "dc" => "http://purl.org/dc/elements/1.1/",
-          "content" => "http://purl.org/rss/1.0/modules/content/"
+          "content" => "http://purl.org/rss/1.0/modules/content/",
         }
 
         # Find creator using namespaced xpath
@@ -305,7 +327,7 @@ RSpec.shared_examples "xml adapter" do
       let(:xml) do
         <<~XML
           <?xml version="1.0" encoding="UTF-8"?>
-          <soap:Envelope#{" "}
+          <soap:Envelope#{' '}
             xmlns:soap="http://www.w3.org/2003/05/soap-envelope"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:ns="urn:example:namespace">
@@ -322,6 +344,10 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
+        if described_class.name.include?("Ox")
+          skip("Ox does not support namespace-aware XPath queries (documented limitation)")
+        end
+
         # Parse original XML
         doc = described_class.parse(xml).native
 
@@ -334,7 +360,7 @@ RSpec.shared_examples "xml adapter" do
         # Test xpath with namespaces
         namespaces = {
           "soap" => "http://www.w3.org/2003/05/soap-envelope",
-          "ns" => "urn:example:namespace"
+          "ns" => "urn:example:namespace",
         }
 
         # Find user ID using namespaced xpath
@@ -346,7 +372,8 @@ RSpec.shared_examples "xml adapter" do
         expect(body).not_to be_nil
 
         # Verify attribute with namespace
-        expect(described_class.get_attribute_value(user_id, "xsi:type")).to eq("xsi:string")
+        expect(described_class.get_attribute_value(user_id,
+                                                   "xsi:type")).to eq("xsi:string")
       end
     end
   end

data/spec/moxml/adapter_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Adapter do
+  describe "adapter loading" do
+    it "provides Nokogiri adapter" do
+      expect(described_class::Nokogiri).to be_a(Class)
+      expect(described_class::Nokogiri.ancestors).to include(Moxml::Adapter::Base)
+    end
+
+    it "provides Base adapter class" do
+      expect(described_class::Base).to be_a(Class)
+    end
+  end
+end

data/spec/moxml/attribute_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Attribute do
+  let(:context) { Moxml.new }
+  let(:doc) { context.parse('<root id="123" class="test"/>') }
+  let(:element) { doc.root }
+
+  describe "#name" do
+    it "returns attribute name" do
+      attr = element.attributes.first
+      expect(%w[id class]).to include(attr.name)
+    end
+  end
+
+  describe "#value" do
+    it "returns attribute value" do
+      id_attr = element.attributes.find { |a| a.name == "id" }
+      expect(id_attr.value).to eq("123")
+    end
+  end
+
+  describe "#to_s" do
+    it "returns string representation" do
+      attr = element.attributes.first
+      expect(attr.to_s).to match(/\w+="\w+"/)
+    end
+  end
+end

data/spec/moxml/builder_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Builder do
+  let(:context) { Moxml.new }
+
+  describe "#build" do
+    it "builds a document with DSL" do
+      doc = described_class.new(context).build do
+        element "root" do
+          element "child" do
+            text "text"
+          end
+        end
+      end
+
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root.name).to eq("root")
+    end
+
+    it "creates nested elements" do
+      doc = described_class.new(context).build do
+        element "parent" do
+          element "child1"
+          element "child2"
+        end
+      end
+
+      expect(doc.root.children.length).to eq(2)
+    end
+  end
+end

data/spec/moxml/cdata_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Cdata do
+  let(:context) { Moxml.new }
+  let(:doc) { context.parse("<root><![CDATA[test data]]></root>") }
+
+  describe "#content" do
+    it "returns CDATA content" do
+      cdata = doc.root.children.first
+      expect(cdata).to be_a(described_class)
+      expect(cdata.content).to eq("test data")
+    end
+  end
+
+  describe "#to_xml" do
+    it "serializes to CDATA section" do
+      cdata = doc.root.children.first
+      expect(cdata.to_xml).to eq("<![CDATA[test data]]>")
+    end
+  end
+
+  describe "creation" do
+    it "creates a CDATA node" do
+      cdata = doc.create_cdata("new data")
+      expect(cdata).to be_a(described_class)
+      expect(cdata.content).to eq("new data")
+    end
+  end
+end

data/spec/moxml/comment_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Comment do
+  let(:context) { Moxml.new }
+  let(:doc) { context.parse("<root><!-- test comment --></root>") }
+
+  describe "#content" do
+    it "returns comment content" do
+      comment = doc.root.children.first
+      expect(comment).to be_a(described_class)
+      expect(comment.content).to eq(" test comment ")
+    end
+  end
+
+  describe "#to_xml" do
+    it "serializes to XML comment" do
+      comment = doc.root.children.first
+      expect(comment.to_xml).to eq("<!-- test comment -->")
+    end
+  end
+
+  describe "creation" do
+    it "creates a comment node" do
+      comment = doc.create_comment("new comment")
+      expect(comment).to be_a(described_class)
+      expect(comment.content).to eq("new comment")
+    end
+  end
+end

data/spec/moxml/config_spec.rb

@@ -21,18 +21,18 @@ RSpec.describe Moxml::Config do
     end
 
     it "raises error for invalid adapter" do
-      expect { config.adapter = :invalid }.to raise_error(ArgumentError)
+      expect { config.adapter = :invalid }.to raise_error(Moxml::AdapterError)
     end
 
     it "requires adapter gem" do
       expect { config.adapter = :oga }.not_to raise_error
 
-      expect(defined?(::Oga)).to be_truthy
+      expect(defined?(Oga)).to be_truthy
     end
 
     it "handles missing gems" do
       allow(Moxml::Adapter).to receive(:require).and_raise(LoadError)
-      expect { config.adapter = :nokogiri }.to raise_error(LoadError)
+      expect { config.adapter = :nokogiri }.to raise_error(Moxml::AdapterError)
     end
   end