moxml 0.1.0 → 0.1.1

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "XPath Examples" do
+  let(:context) { Moxml.new }
+
+  describe "XPath querying" do
+    let(:doc) do
+      context.parse(<<~XML)
+        <root xmlns:dc="http://purl.org/dc/elements/1.1/">
+          <book id="1">
+            <dc:title>First</dc:title>
+          </book>
+          <book id="2">
+            <dc:title>Second</dc:title>
+          </book>
+        </root>
+      XML
+    end
+
+    it "finds nodes by XPath" do
+      books = doc.xpath("//book")
+      expect(books.size).to eq(2)
+      expect(books.map { |b| b["id"] }).to eq(%w[1 2])
+    end
+
+    it "finds nodes with namespaces" do
+      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
+      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")
+    end
+  end
+end

data/spec/support/shared_examples/integration.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml Integration" do
+  let(:context) { Moxml.new }
+
+  describe "complete document workflow" do
+    let(:doc) { context.create_document }
+    before do
+      # Create document with declaration
+      doc.add_child(doc.create_declaration("1.0", "UTF-8"))
+
+      # Add root with namespaces
+      root = doc.create_element("root")
+      root.add_namespace(nil, "http://example.org")
+      root.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+      doc.add_child(root)
+
+      # Add processing instruction
+      style_pi = doc.create_processing_instruction("xml-stylesheet", 'type="text/xsl" href="style.xsl"')
+      root.add_previous_sibling(style_pi)
+
+      # Add mixed content
+      root.add_child(doc.create_comment(" Mixed content example "))
+
+      text_node = doc.create_element("text")
+      text_node.add_child("Some text ")
+      text_node.add_child(doc.create_cdata("<with><markup/>"))
+      text_node.add_child(" and more text")
+      root.add_child(text_node)
+
+      # Add element with attributes
+      item = doc.create_element("item")
+      item["id"] = "123"
+      item["xs:type"] = "custom"
+      root.add_child(item)
+    end
+
+    it "has correct xml elements" do
+      # Verify structure
+      expected_xml_tags = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<?xml-stylesheet type="text/xsl" href="style.xsl"?>',
+        '<root xmlns="http://example.org" xmlns:xs="http://www.w3.org/2001/XMLSchema">',
+        "<!-- Mixed content example -->",
+        "<text>Some text <![CDATA[<with><markup/>]]> and more text</text>",
+        '<item id="123" xs:type="custom"></item>',
+        "</root>"
+      ]
+
+      expected_xml_tags.each do |expected_xml|
+        # include(*expected_xml_tags) is shorter but worse for debugging
+        expect(doc.to_xml).to include(expected_xml)
+      end
+    end
+
+    it "handles xpath queries" do
+      # Test XPath queries
+      #
+      # XPath with a default namespace is a problem
+      # Nokogiri:
+      # https://timnew.me/blog/2012/10/25/pitfall-in-nokogiri-xpath-and-namespace/
+      # Oga:
+      # https://www.rubydoc.info/gems/oga/0.3.3#namespace-support
+      expect(doc.xpath('//xmlns:item[@id="123"]')).not_to be_empty
+      expect(doc.at_xpath("//xmlns:text").text).to include("Some text")
+    end
+  end
+
+  describe "namespace handling" do
+    it "handles complex namespace scenarios" do
+      xml = <<~XML
+        <root xmlns="http://default.org" xmlns:a="http://a.org" xmlns:b="http://b.org">
+          <child>
+            <a:element b:attr="value">
+              <deeper xmlns="http://other.org"/>
+            </a:element>
+          </child>
+        </root>
+      XML
+
+      doc = context.parse(xml)
+
+      # Test root namespace
+      root = doc.root
+      expect(root.namespace.prefix).to be_nil
+      expect(root.namespace.uri).to eq("http://default.org")
+
+      # Test namespace inheritance
+      child = doc.at_xpath("//xmlns:child")
+      expect(child.namespace.uri).to eq("http://default.org")
+
+      # Test namespace prefix resolution
+      a_element = doc.at_xpath("//a:element", "a" => "http://a.org")
+      expect(a_element).not_to be_nil
+      expect(a_element.namespace.prefix).to eq("a")
+
+      # Test attribute namespace
+      attr = a_element["b:attr"]
+      expect(attr).to eq("value")
+
+      # Test namespace override
+      deeper = a_element.children.first
+      expect(deeper.namespace.uri).to eq("http://other.org")
+    end
+  end
+
+  describe "document modification" do
+    let(:doc) { context.parse("<root><a>1</a><b>2</b></root>") }
+
+    it "handles complex modifications" do
+      # Move nodes
+      b_node = doc.at_xpath("//b")
+      a_node = doc.at_xpath("//a")
+      b_node.add_previous_sibling(a_node)
+
+      # Add nodes
+      c_node = doc.create_element("c")
+      c_node.add_child("3")
+      b_node.add_next_sibling(c_node)
+
+      # Modify attributes
+      doc.root["id"] = "main"
+
+      # Add mixed content
+      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.to_xml).to include(
+        '<root id="main">',
+        "<b>2<!-- comment --><![CDATA[<tag>]]></b>"
+      )
+    end
+  end
+end

data/spec/support/shared_examples/namespace.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Namespace" do
+  describe Moxml::Namespace do
+    let(:context) { Moxml.new }
+    let(:doc) { context.create_document }
+    let(:element) { doc.create_element("test") }
+
+    describe "creation" do
+      it "creates namespace with prefix" do
+        element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+        ns = element.namespaces.first
+
+        expect(ns).to be_namespace
+        expect(ns.prefix).to eq("xs")
+        expect(ns.uri).to eq("http://www.w3.org/2001/XMLSchema")
+      end
+
+      it "creates default namespace" do
+        element.add_namespace(nil, "http://example.org")
+        ns = element.namespaces.first
+
+        expect(ns.prefix).to be_nil
+        expect(ns.uri).to eq("http://example.org")
+      end
+
+      it "validates URI" do
+        expect do
+          element.add_namespace("xs", "invalid uri")
+        end.to raise_error(Moxml::NamespaceError, "Invalid URI: invalid uri")
+      end
+    end
+
+    describe "string representation" do
+      it "formats prefixed namespace" do
+        element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+        expect(element.namespaces.first.to_s).to eq('xmlns:xs="http://www.w3.org/2001/XMLSchema"')
+      end
+
+      it "formats default namespace" do
+        element.add_namespace(nil, "http://example.org")
+        expect(element.namespaces.first.to_s).to eq('xmlns="http://example.org"')
+      end
+    end
+
+    describe "equality" do
+      let(:ns1) { element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema").namespaces.last }
+      let(:ns2) { element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema").namespaces.last }
+      let(:ns3) { element.add_namespace("xsi", "http://www.w3.org/2001/XMLSchema-instance").namespaces.last }
+
+      it "compares namespaces" do
+        expect(ns1).to eq(ns2)
+        expect(ns1).not_to eq(ns3)
+      end
+
+      it "compares with different elements" do
+        other_element = doc.create_element("other")
+        other_ns = other_element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema").namespaces.first
+        expect(ns1).to eq(other_ns)
+      end
+    end
+
+    describe "inheritance" do
+      it "does not inherit parent namespaces" do
+        # https://stackoverflow.com/a/67347081
+        root = doc.create_element("root")
+        root.namespace = { "xs" => "http://www.w3.org/2001/XMLSchema" }
+        child = doc.create_element("child")
+        root.add_child(child)
+
+        expect(child.namespace).to be_nil
+      end
+
+      it "inherits default parent namespaces" do
+        root = doc.create_element("root")
+        root.namespace = { nil => "http://www.w3.org/2001/XMLSchema" }
+        child = doc.create_element("child")
+        root.add_child(child)
+
+        expect(child.namespace.prefix).to be_nil
+        expect(child.namespace.uri).to eq("http://www.w3.org/2001/XMLSchema")
+      end
+
+      it "overrides parent namespace" do
+        root = doc.create_element("root")
+        root.namespace = { "ns" => "http://example.org/1" }
+        child = doc.create_element("child")
+        child.namespace = { "ns" => "http://example.org/2" }
+        root.add_child(child)
+
+        expect(root.namespace.uri).to eq("http://example.org/1")
+        expect(child.namespace.uri).to eq("http://example.org/2")
+      end
+    end
+  end
+end

data/spec/support/shared_examples/node.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Node" do
+  describe Moxml::Node do
+    let(:context) { Moxml.new }
+    let(:doc) { context.parse("<root><child>text</child></root>") }
+    let(:root) { doc.root }
+    let(:child) { root.children.first }
+
+    describe "#document" do
+      it "returns containing document" do
+        expect(root.document).to eq(doc)
+        expect(child.document).to eq(doc)
+      end
+    end
+
+    describe "#parent" do
+      it "returns parent node" do
+        expect(child.parent).to eq(root)
+        expect(root.parent).to be_a(Moxml::Document)
+      end
+    end
+
+    describe "#children" do
+      it "returns node set of children" do
+        expect(root.children).to be_a(Moxml::NodeSet)
+        expect(root.children.size).to eq(1)
+      end
+    end
+
+    describe "sibling access" do
+      let(:doc) { context.parse("<root><a/>text<b/></root>") }
+      let(:first) { doc.root.children[0] }
+      let(:middle) { doc.root.children[1] }
+      let(:last) { doc.root.children[2] }
+
+      it "navigates between siblings" do
+        expect(first.next_sibling).to eq(middle)
+        expect(middle.next_sibling).to eq(last)
+        expect(last.previous_sibling).to eq(middle)
+        expect(middle.previous_sibling).to eq(first)
+      end
+    end
+
+    describe "node manipulation" do
+      it "adds child" do
+        new_child = doc.create_element("new")
+        root.add_child(new_child)
+        expect(root.children.last).to eq(new_child)
+      end
+
+      it "adds previous sibling" do
+        new_node = doc.create_element("new")
+        child.add_previous_sibling(new_node)
+        expect(root.children.first).to eq(new_node)
+      end
+
+      it "adds next sibling" do
+        new_node = doc.create_element("new")
+        child.add_next_sibling(new_node)
+        expect(root.children.last).to eq(new_node)
+      end
+
+      it "removes node" do
+        child.remove
+        expect(root.children).to be_empty
+      end
+
+      it "replaces node" do
+        new_node = doc.create_element("new")
+        child.replace(new_node)
+        expect(root.children.first).to eq(new_node)
+      end
+    end
+
+    describe "#to_xml" do
+      let(:context) { Moxml.new }
+      let(:doc) { context.parse("<root><child>text</child></root>") }
+
+      it "uses native serialization" do
+        expect(context.config.adapter).to receive(:serialize)
+          .with(doc.native, hash_including(indent: 2))
+
+        doc.to_xml(indent: 2)
+      end
+
+      it "passes through serialization options" do
+        expect(context.config.adapter).to receive(:serialize)
+          .with(doc.native, hash_including(encoding: "UTF-8", indent: 4))
+
+        doc.to_xml(encoding: "UTF-8", indent: 4)
+      end
+    end
+
+    describe "XPath support" do
+      let(:doc) { context.parse("<root><a><b>1</b></a><a><b>2</b></a></root>") }
+
+      it "finds nodes by xpath" do
+        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
+        node = doc.at_xpath("//b")
+        expect(node.text).to eq("1")
+      end
+    end
+  end
+end

data/spec/support/shared_examples/node_set.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::NodeSet" do
+  describe Moxml::NodeSet do
+    let(:context) { Moxml.new }
+    let(:xml) do
+      <<~XML
+        <root>
+          <child>First</child>
+          <child>Second</child>
+          <child>Third</child>
+        </root>
+      XML
+    end
+    let(:doc) { context.parse(xml) }
+    let(:nodes) { doc.xpath("//child") }
+
+    it "implements Enumerable" do
+      expect(nodes).to be_a(Enumerable)
+    end
+
+    it "is a NodeSet" do
+      expect(nodes).to be_a(described_class)
+    end
+
+    describe "enumeration" do
+      it "iterates over nodes" do
+        texts = []
+        nodes.each { |node| texts << node.text }
+        expect(texts).to eq(%w[First Second Third])
+      end
+
+      it "maps nodes" do
+        texts = nodes.map(&:text)
+        expect(texts).to eq(%w[First Second Third])
+      end
+
+      it "selects nodes" do
+        selected = nodes.select { |node| node.text.include?("i") }
+        expect(selected.size).to eq(2)
+        expect(selected.map(&:text)).to eq(%w[First Third])
+      end
+    end
+
+    describe "access methods" do
+      it "accesses by index" do
+        expect(nodes[0].text).to eq("First")
+        expect(nodes[1].text).to eq("Second")
+        expect(nodes[-1].text).to eq("Third")
+      end
+
+      it "accesses by range" do
+        subset = nodes[0..1]
+        expect(subset).to be_a(described_class)
+        expect(subset.size).to eq(2)
+        expect(subset.map(&:text)).to eq(%w[First Second])
+      end
+
+      it "provides first and last" do
+        expect(nodes.first.text).to eq("First")
+        expect(nodes.last.text).to eq("Third")
+      end
+    end
+
+    describe "modification methods" do
+      it "removes all nodes" do
+        nodes.remove
+        expect(doc.xpath("//child")).to be_empty
+      end
+
+      it "preserves document structure after removal" do
+        nodes.remove
+        expect(doc.root).not_to be_nil
+        expect(doc.root.name).to eq("root")
+      end
+    end
+
+    describe "concatenation" do
+      it "combines node sets" do
+        other_doc = context.parse("<root><item>Fourth</item></root>")
+        other_nodes = other_doc.xpath("//item")
+        combined = nodes + other_nodes
+
+        expect(combined).to be_a(described_class)
+        expect(combined.size).to eq(4)
+        expect(combined.map(&:text)).to eq(%w[First Second Third Fourth])
+      end
+    end
+  end
+end

data/spec/support/shared_examples/processing_instruction.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::ProcessingInstruction" do
+  let(:context) { Moxml.new }
+  let(:doc) { context.create_document }
+  let(:pi) { doc.create_processing_instruction("xml-stylesheet", 'href="style.xsl" type="text/xsl"') }
+
+  it "identifies as processing instruction node" do
+    expect(pi).to be_processing_instruction
+  end
+
+  describe "target manipulation" do
+    it "gets target" do
+      expect(pi.target).to eq("xml-stylesheet")
+    end
+
+    it "sets target" do
+      pi.target = "new-target"
+      expect(pi.target).to eq("new-target")
+    end
+
+    it "handles nil target" do
+      pi.target = nil
+      expect(pi.target).to eq("")
+    end
+  end
+
+  describe "content manipulation" do
+    it "gets content" do
+      expect(pi.content).to eq('href="style.xsl" type="text/xsl"')
+    end
+
+    it "sets content" do
+      pi.content = 'href="new.xsl"'
+      expect(pi.content).to eq('href="new.xsl"')
+    end
+
+    it "handles nil content" do
+      pi.content = nil
+      expect(pi.content).to eq("")
+    end
+  end
+
+  describe "serialization" do
+    it "formats processing instruction" do
+      expect(pi.to_xml).to eq('<?xml-stylesheet href="style.xsl" type="text/xsl"?>')
+    end
+
+    it "handles special characters" do
+      pi.content = '< > & " \''
+      expect(pi.to_xml).to include('< > & " \'')
+    end
+  end
+
+  describe "node operations" do
+    let(:element) { doc.create_element("test") }
+
+    it "adds to element" do
+      element.add_child(pi)
+      expect(element.to_xml).to include("<?xml-stylesheet")
+    end
+
+    it "removes from element" do
+      element.add_child(pi)
+      pi.remove
+      expect(element.children).to be_empty
+    end
+
+    it "replaces with another node" do
+      element.add_child(pi)
+      text = doc.create_text("replacement")
+      pi.replace(text)
+      expect(element.text).to eq("replacement")
+    end
+  end
+
+  describe "common use cases" do
+    it "creates stylesheet instruction" do
+      pi = doc.create_processing_instruction("xml-stylesheet", 'type="text/xsl" href="style.xsl"')
+      expect(pi.to_xml).to eq('<?xml-stylesheet type="text/xsl" href="style.xsl"?>')
+    end
+
+    it "creates PHP instruction" do
+      pi = doc.create_processing_instruction("php", 'echo "Hello";')
+      expect(pi.to_xml).to eq('<?php echo "Hello";?>')
+    end
+  end
+end

data/spec/support/shared_examples/text.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Text" do
+  let(:context) { Moxml.new }
+  let(:doc) { context.create_document }
+  let(:text) { doc.create_text("content") }
+
+  it "identifies as text node" do
+    expect(text).to be_text
+  end
+
+  describe "content manipulation" do
+    it "gets content" do
+      expect(text.content).to eq("content")
+    end
+
+    it "sets content" do
+      text.content = "new content"
+      expect(text.content).to eq("new content")
+    end
+
+    it "handles nil content" do
+      text.content = nil
+      expect(text.content).to eq("")
+    end
+
+    it "converts non-string content" do
+      text.content = 123
+      expect(text.content).to eq("123")
+    end
+  end
+
+  describe "special characters" do
+    it "encodes basic XML entities" do
+      text.content = "< > & \" '"
+      expect(text.to_xml).to eq("&lt; &gt; &amp; \" '")
+    end
+
+    it "preserves whitespace" do
+      text.content = "  spaced  content\n\t"
+      expect(text.content).to eq("  spaced  content\n\t")
+    end
+  end
+
+  describe "node operations" do
+    let(:element) { doc.create_element("test") }
+
+    it "adds to element" do
+      element.add_child(text)
+      expect(element.text).to eq("content")
+    end
+
+    it "removes from element" do
+      element.add_child(text)
+      text.remove
+      expect(element.text).to eq("")
+    end
+
+    it "replaces with another node" do
+      element.add_child(text)
+      new_text = doc.create_text("replacement")
+      text.replace(new_text)
+      expect(element.text).to eq("replacement")
+    end
+  end
+end