moxml 0.1.3 → 0.1.6

data/lib/moxml/node.rb

@@ -7,11 +7,17 @@ module Moxml
   class Node
     include XmlUtils
 
+    TYPES = %i[
+      element text cdata comment processing_instruction document
+      declaration doctype namespace attribute unknown
+    ].freeze
+
     attr_reader :native, :context
 
     def initialize(native, context)
-      @native = native
       @context = context
+      # @native = adapter.patch_node(native)
+      @native = native
     end
 
     def document
@@ -23,7 +29,10 @@ module Moxml
     end
 
     def children
-      NodeSet.new(adapter.children(@native), context)
+      NodeSet.new(
+        adapter.children(@native).map { adapter.patch_node(_1, @native) },
+        context
+      )
     end
 
     def next_sibling
@@ -79,6 +88,12 @@ module Moxml
       self.class == other.class && @native == other.native
     end
 
+    TYPES.each do |node_type|
+      define_method "#{node_type}?" do
+        adapter.node_type(native) == node_type
+      end
+    end
+
     def self.wrap(node, context)
       return nil if node.nil?
 

data/lib/moxml/node_set.rb

@@ -42,7 +42,6 @@ module Moxml
     def size
       nodes.size
     end
-
     alias length size
 
     def to_a
@@ -53,6 +52,14 @@ module Moxml
       self.class.new(nodes + other.nodes, context)
     end
 
+    def ==(other)
+      self.class == other.class &&
+        length == other.length &&
+        nodes.each_with_index.all? do |node, index|
+          Node.wrap(node, context) == other[index]
+        end
+    end
+
     def text
       map(&:text).join
     end

data/lib/moxml/processing_instruction.rb

@@ -17,9 +17,5 @@ module Moxml
     def content=(new_content)
       adapter.set_processing_instruction_content(@native, new_content.to_s)
     end
-
-    def processing_instruction?
-      true
-    end
   end
 end

data/lib/moxml/text.rb

@@ -9,9 +9,5 @@ module Moxml
     def content=(text)
       adapter.set_text_content(@native, normalize_xml_value(text))
     end
-
-    def text?
-      true
-    end
   end
 end

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.1.3"
+  VERSION = "0.1.6"
 end

data/lib/ox/node.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "ox/node"
+
+module Ox
+  class Node
+    attr_accessor :parent
+  end
+end

data/spec/fixtures/small.xml

@@ -0,0 +1 @@
+<root><item>data</item></root>

data/spec/moxml/adapter/rexml_spec.rb

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

data/spec/moxml/all_with_adapters_spec.rb

@@ -25,12 +25,11 @@ RSpec.describe "Test all shared examples" do
     "README Examples",
     "XPath Examples",
     "Memory Usage Examples",
-    "Thread Safety Examples"
+    "Thread Safety Examples",
+    "Performance Examples"
   ]
 
   Moxml::Adapter::AVALIABLE_ADAPTERS.each do |adapter_name|
-    # [:nokogiri].each do |adapter_name|
-    # [:oga].each do |adapter_name|
     context "with #{adapter_name}" do
       around do |example|
         Moxml.with_config(adapter_name) do

data/spec/support/shared_examples/builder.rb

@@ -5,8 +5,8 @@ RSpec.shared_examples "Moxml::Builder" do
   let(:builder) { Moxml::Builder.new(context) }
 
   describe "#document" do
-    it "creates a well-formed document" do
-      doc = builder.build do
+    let(:doc) do
+      builder.build do
         declaration version: "1.0", encoding: "UTF-8"
         element "root" do
           element "child", id: "1" do
@@ -14,12 +14,29 @@ RSpec.shared_examples "Moxml::Builder" do
           end
         end
       end
+    end
 
+    it "creates a well-formed document" do
       xml = doc.to_xml
       expect(xml).to include('<?xml version="1.0" encoding="UTF-8"?>')
       expect(xml).to include("<root>")
       expect(xml).to include('<child id="1">content</child>')
       expect(xml).to include("</root>")
     end
+
+    it "creates the same document through direct manipulation" do
+      doc2 = context.create_document
+      doc2.add_child(doc2.create_declaration("1.0", "UTF-8"))
+      root = doc2.create_element("root")
+      child = doc2.create_element("child")
+      child["id"] = "1"
+      text = doc2.create_text("content")
+
+      child.add_child(text)
+      root.add_child(child)
+      doc2.add_child(root)
+
+      expect(doc.to_xml).to eq(doc2.to_xml)
+    end
   end
 end

data/spec/support/shared_examples/cdata.rb

@@ -23,6 +23,11 @@ RSpec.shared_examples "Moxml::Cdata" do
       cdata.content = nil
       expect(cdata.content).to eq("")
     end
+
+    it "preserves whitespace" do
+      cdata.content = "  spaced  content\n\t"
+      expect(cdata.content).to eq("  spaced  content\n\t")
+    end
   end
 
   describe "serialization" do
@@ -31,6 +36,8 @@ RSpec.shared_examples "Moxml::Cdata" do
     end
 
     it "escapes CDATA end marker" do
+      # pending for Ox: https://github.com/ohler55/ox/issues/377
+      pending "Ox doesn't escape the end token" if context.config.adapter_name == :ox
       cdata.content = "content]]>more"
       expect(cdata.to_xml).to eq("<![CDATA[content]]]]><![CDATA[>more]]>")
     end
@@ -39,11 +46,6 @@ RSpec.shared_examples "Moxml::Cdata" do
       cdata.content = "< > & \" '"
       expect(cdata.to_xml).to include("< > & \" '")
     end
-
-    it "preserves whitespace" do
-      cdata.content = "  spaced  content\n\t"
-      expect(cdata.content).to eq("  spaced  content\n\t")
-    end
   end
 
   describe "node operations" do

data/spec/support/shared_examples/declaration.rb

@@ -36,6 +36,7 @@ RSpec.shared_examples "Moxml::Declaration" do
     end
 
     it "normalizes encoding" do
+      pending("Rexml Encoding upcases the string") if Moxml.new.config.adapter.name.include?("Rexml")
       declaration.encoding = "utf-8"
       expect(declaration.encoding).to eq("utf-8")
     end
@@ -64,17 +65,26 @@ RSpec.shared_examples "Moxml::Declaration" do
 
   describe "serialization" do
     it "formats complete declaration" do
-      expect(declaration.to_xml).to eq('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>')
+      doc.add_child(declaration)
+      expect(doc.to_xml.strip).to end_with('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>')
     end
 
     it "formats minimal declaration with empty encoding" do
       decl = doc.create_declaration("1.0", nil)
-      expect(decl.to_xml).to eq('<?xml version="1.0"?>')
+      if context.config.adapter_name == :rexml
+        # REXML sets a default encoding when a declaration is added to the document
+        expect(decl.to_xml.strip).to eq('<?xml version="1.0"?>')
+      else
+        # Ox cannot serialize standalone declaration
+        doc.add_child(decl)
+        expect(doc.to_xml.strip).to end_with('<?xml version="1.0"?>')
+      end
     end
 
     it "formats declaration with encoding only" do
       decl = doc.create_declaration("1.0", "UTF-8")
-      expect(decl.to_xml).to eq('<?xml version="1.0" encoding="UTF-8"?>')
+      doc.add_child(decl)
+      expect(doc.to_xml.strip).to end_with('<?xml version="1.0" encoding="UTF-8"?>')
     end
   end
 
@@ -84,7 +94,10 @@ RSpec.shared_examples "Moxml::Declaration" do
       expect(doc.to_xml).to start_with("<?xml")
     end
 
-    it "removes from document", skip: "The document contains a default declaration" do
+    it "removes from document" do
+      if Moxml.new.config.adapter.name.match?(/Nokogiri|Rexml|Ox/)
+        pending("The document contains a default declaration")
+      end
       doc.add_child(declaration)
       declaration.remove
       expect(doc.to_xml).not_to include("<?xml")

data/spec/support/shared_examples/doctype.rb

@@ -17,7 +17,8 @@ RSpec.shared_examples "Moxml::Doctype" do
 
   describe "serialization" do
     it "wraps content in doctype markers" do
-      expect(doctype.to_xml).to eq(
+      doc.add_child(doctype)
+      expect(doc.to_xml.strip).to end_with(
         '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
       )
     end

data/spec/support/shared_examples/document.rb

@@ -106,5 +106,15 @@ RSpec.shared_examples "Moxml::Document" do
         "</root>"
       )
     end
+
+    it "prevents multiple roots" do
+      xml =
+        <<~XML
+          <?xml version="1.0" encoding="UTF-8"?>
+          <root/><another_root/>
+        XML
+
+      expect { context.parse(xml) }.to raise_error(Moxml::Error)
+    end
   end
 end

data/spec/support/shared_examples/edge_cases.rb

@@ -31,6 +31,7 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
   describe "malformed content handling" do
     it "handles CDATA with nested markers" do
+      pending "Ox doesn't escape the end token" if context.config.adapter_name == :ox
       cdata_text = "]]>]]>]]>"
       doc = context.create_document
       cdata = doc.create_cdata(cdata_text)
@@ -76,6 +77,7 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
   describe "namespace edge cases" do
     it "handles default namespace changes" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
       xml = <<~XML
         <root xmlns="http://default1.org">
           <child xmlns="http://default2.org">
@@ -86,10 +88,12 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
       doc = context.parse(xml)
       grandchild = doc.at_xpath("//xmlns:grandchild", "xmlns" => "")
-      expect(grandchild.namespace.uri).to eq("")
+      expect(grandchild.namespaces.first.uri).to eq("")
     end
 
     it "handles recursive namespace definitions" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
+
       xml = <<~XML
         <root xmlns:a="http://a.org">
           <a:child xmlns:a="http://b.org">
@@ -106,6 +110,8 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
   describe "attribute edge cases" do
     it "handles attributes with same local name but different namespaces" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
+
       xml = <<~XML
         <root xmlns:a="http://a.org" xmlns:b="http://b.org">
           <element a:id="1" b:id="2"/>
@@ -143,13 +149,13 @@ RSpec.shared_examples "Moxml Edge Cases" do
       current = doc.create_element("root")
       doc.add_child(current)
 
-      1000.times do |i|
+      10.times do |i|
         nested = doc.create_element("nested#{i}")
         current.add_child(nested)
         current = nested
       end
 
-      expect(doc.to_xml).to include("<nested999>")
+      expect(doc.to_xml).to include("<nested9>")
     end
 
     it "handles large number of siblings" do

data/spec/support/shared_examples/element.rb

@@ -6,6 +6,10 @@ RSpec.shared_examples "Moxml::Element" do
     let(:doc) { context.create_document }
     let(:element) { doc.create_element("test") }
 
+    it "identifies as element node" do
+      expect(element).to be_element
+    end
+
     describe "name handling" do
       it "gets name" do
         expect(element.name).to eq("test")
@@ -55,7 +59,7 @@ RSpec.shared_examples "Moxml::Element" do
       end
 
       it "sets namespace" do
-        ns = element.add_namespace("x", "http://example.org").namespace
+        ns = element.add_namespace("x", "http://example.org").namespaces.first
         element.namespace = ns
         expect(element.namespace).to eq(ns)
       end

data/spec/support/shared_examples/examples/benchmark_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "benchmark/ips"
+
+RSpec.shared_examples "Performance Examples" do
+  let(:context) { Moxml.new }
+
+  let(:large_xml) do
+    xml = "<root>\n"
+    1000.times do |i|
+      xml += "<item id='#{i}'><name>Test #{i}</name><value>#{i}</value></item>\n"
+    end
+    xml += "</root>"
+    xml
+  end
+
+  it "measures parsing performance" do
+    doc = nil
+
+    report = Benchmark.ips do |x|
+      x.config(time: 5, warmup: 2)
+
+      x.report("Parser") do
+        doc = context.parse(large_xml)
+      end
+
+      x.report("Serializer") do
+        _ = doc.to_xml
+      end
+
+      x.compare!
+    end
+
+    # first - parser, second - serializer
+    thresholds = {
+      nokogiri: [18, 1200],
+      oga: [12, 110],
+      rexml: [0, 60],
+      ox: [2, 2000]
+    }
+
+    report.entries.each_with_index do |entry, index|
+      puts "#{entry.label} performance: #{entry.ips.round(2)} ips"
+      threshold = thresholds[context.config.adapter_name][index]
+      message = "#{entry.label} performance below threshold: " \
+                "got #{entry.ips.round(2)} ips, expected >= #{threshold} ips"
+      expect(entry.ips).to be >= threshold, message
+    end
+  end
+end

data/spec/support/shared_examples/examples/memory.rb

@@ -29,26 +29,39 @@ RSpec.shared_examples "Memory Usage Examples" do
       expect(doc.xpath("//large-node")).to be_empty
     end
 
-    it "handles streaming processing" do
-      # Create temp file
-      file = Tempfile.new(["test", ".xml"])
-      begin
-        file.write("<root><item>data</item></root>")
-        file.close
+    it "handles deeply nested nodes", skip: "Very flaky tests" do
+      doc = context.create_document
+      parent = doc
+
+      1000.times do |i|
+        node = doc.create_element("el_#{i}")
+        node.add_child(doc.create_text("Content #{i}"))
+        parent.add_child(node)
+        parent = node
+      end
+
+      # Process and remove nodes
+      memory_before = GetProcessMem.new.bytes
+      doc = nil
+      GC.start # Oga fails without it
+      memory_after = GetProcessMem.new.bytes
+
+      expect(memory_after).to be <= memory_before
+      expect(doc).to be_nil
+    end
 
-        # Process file
+    it "handles streaming processing" do
+      pending "Ox has a load_file method, but nothing about a stream" if context.config.adapter_name == :ox
+      # Process file
+      doc = nil
+      File.open("spec/fixtures/small.xml") do |f|
+        doc = context.parse(f)
+        expect(doc.at_xpath("//item").text).to eq("data")
         doc = nil
-        File.open(file.path) do |f|
-          doc = context.parse(f)
-          expect(doc.at_xpath("//item").text).to eq("data")
-          doc = nil
-        end
-        GC.start
-
-        expect(doc).to be_nil
-      ensure
-        file.unlink
       end
+      GC.start
+
+      expect(doc).to be_nil
     end
   end
 end

data/spec/support/shared_examples/examples/readme_examples.rb

@@ -110,6 +110,7 @@ RSpec.shared_examples "README Examples" do
   describe "Error handling example" do
     it "handles errors as shown in README" do
       context = Moxml.new
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
 
       expect do
         context.parse("<invalid>")
@@ -145,6 +146,10 @@ RSpec.shared_examples "README Examples" do
         def process(xml)
           @mutex.synchronize do
             doc = @context.parse(xml)
+            # Modify document
+            element = doc.create_element("test")
+            doc.root.add_child(element)
+            doc.root.children.first.remove
             doc.to_xml
           end
         end

data/spec/support/shared_examples/examples/thread_safety.rb

@@ -20,6 +20,8 @@ RSpec.shared_examples "Thread Safety Examples" do
     end
 
     it "handles concurrent processing" do
+      pending "Ox doesn't have a native XPath" if Moxml.new.config.adapter_name == :ox
+
       processor = processor_class.new
       threads = []
       results = Queue.new

data/spec/support/shared_examples/examples/xpath.rb

@@ -18,22 +18,53 @@ RSpec.shared_examples "XPath Examples" do
     end
 
     it "finds nodes by XPath" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
+
       books = doc.xpath("//book")
       expect(books.size).to eq(2)
-      expect(books.map { |b| b["id"] }).to eq(%w[1 2])
+      expect(books.map { _1["id"] }).to eq(%w[1 2])
     end
 
     it "finds nodes with namespaces" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
+
       titles = doc.xpath("//dc:title",
                          "dc" => "http://purl.org/dc/elements/1.1/")
       expect(titles.map(&:text)).to eq(%w[First Second])
     end
 
     it "finds nodes by attributes" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
+
       book = doc.at_xpath('//book[@id="2"]')
       expect(book).not_to be_nil
-      expect(book.at_xpath(".//dc:title",
-                           "dc" => "http://purl.org/dc/elements/1.1/").text).to eq("Second")
+      title = book.at_xpath(".//dc:title",
+                            "dc" => "http://purl.org/dc/elements/1.1/")
+      expect(title.text).to eq("Second")
+    end
+
+    it "finds nested attributes efficiently" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
+      # More efficient - specific path
+      titles1 = doc.xpath("//book/dc:title")
+
+      # Less efficient - requires full document scan
+      titles2 = doc.xpath("//dc:title")
+
+      # Most efficient - direct child access
+      titles3 = doc.root.xpath("./*/dc:title", "dc" => "http://purl.org/dc/elements/1.1/")
+
+      # Chain queries
+      nodes = doc.xpath("//book").map do |book|
+        # Each book is a mapped Moxml::Element
+        book.at_xpath(".//dc:title", "dc" => "http://purl.org/dc/elements/1.1/").native
+      end
+      titles4 = ::Moxml::NodeSet.new(nodes, doc.context)
+
+      expect(titles1.count).to eq(2)
+      expect(titles1).to eq(titles2)
+      expect(titles1).to eq(titles3)
+      expect(titles1).to eq(titles4)
     end
   end
 end

data/spec/support/shared_examples/integration.rb

@@ -54,6 +54,7 @@ RSpec.shared_examples "Moxml Integration" do
     end
 
     it "handles xpath queries" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
       # Test XPath queries
       #
       # XPath with a default namespace is a problem
@@ -68,6 +69,7 @@ RSpec.shared_examples "Moxml Integration" do
 
   describe "namespace handling" do
     it "handles complex namespace scenarios" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
       xml = <<~XML
         <root xmlns="http://default.org" xmlns:a="http://a.org" xmlns:b="http://b.org">
           <child>
@@ -108,10 +110,12 @@ RSpec.shared_examples "Moxml Integration" do
     let(:doc) { context.parse("<root><a>1</a><b>2</b></root>") }
 
     it "handles complex modifications" do
+      pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
+
       # Move nodes
       b_node = doc.at_xpath("//b")
       a_node = doc.at_xpath("//a")
-      b_node.add_previous_sibling(a_node)
+      a_node.add_previous_sibling(b_node)
 
       # Add nodes
       c_node = doc.create_element("c")
@@ -125,7 +129,7 @@ RSpec.shared_examples "Moxml Integration" do
       b_node.add_child(doc.create_comment(" comment "))
       b_node.add_child(doc.create_cdata("<tag>"))
 
-      expect(doc.root.children.map(&:name)).to eq(%w[a b c])
+      expect(doc.root.children.map(&:name)).to eq(%w[b c a])
       expect(doc.to_xml).to include(
         '<root id="main">',
         "<b>2<!-- comment --><![CDATA[<tag>]]></b>"

data/spec/support/shared_examples/namespace.rb

@@ -41,6 +41,22 @@ RSpec.shared_examples "Moxml::Namespace" do
         element.add_namespace(nil, "http://example.org")
         expect(element.namespaces.first.to_s).to eq('xmlns="http://example.org"')
       end
+
+      it "renders the same xml - a readme example" do
+        # chainable operations
+        element
+          .add_namespace("dc", "http://purl.org/dc/elements/1.1/")
+          .add_child(doc.create_text("content"))
+
+        # clear node type checking
+        node = doc.create_element("test")
+        if node.element?
+          node.add_namespace("dc", "http://purl.org/dc/elements/1.1/")
+          node.add_child(doc.create_text("content"))
+        end
+
+        expect(element.to_xml).to eq(node.to_xml)
+      end
     end
 
     describe "equality" do

data/spec/support/shared_examples/node.rb

@@ -96,12 +96,16 @@ 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
+        pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
+
         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
+        pending "Ox doesn't have a native XPath" if context.config.adapter_name == :ox
+
         node = doc.at_xpath("//b")
         expect(node.text).to eq("1")
       end