moxml 0.1.0 → 0.1.2

data/spec/support/shared_examples/edge_cases.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml Edge Cases" do
+  let(:context) { Moxml.new }
+
+  describe "special characters handling" do
+    it "handles all kinds of whitespace", skip: "carriege returns are troublesome" do
+      # Nokogiri can't handle carriege returns properly
+      # https://github.com/sparklemotion/nokogiri/issues/1356
+      xml = "<root>\u0020\u0009 \u000D\u000A \u000D</root>"
+      doc = context.parse(xml)
+      expect(doc.root.text).to eq(" \t \r\n \r")
+    end
+
+    it "handles unicode characters" do
+      text = "Hello 世界 🌍"
+      doc = context.create_document
+      element = doc.create_element("test")
+      element.text = text
+      expect(element.text).to eq(text)
+    end
+
+    it "handles zero-width characters" do
+      text = "test\u200B\u200Ctest"
+      doc = context.create_document
+      element = doc.create_element("test")
+      element.text = text
+      expect(element.text).to eq(text)
+    end
+  end
+
+  describe "malformed content handling" do
+    it "handles CDATA with nested markers" do
+      cdata_text = "]]>]]>]]>"
+      doc = context.create_document
+      cdata = doc.create_cdata(cdata_text)
+      expect(cdata.to_xml).to include(
+        "]]]]><![CDATA[>]]]]><![CDATA[>]]]]><![CDATA[>"
+      )
+    end
+
+    it "handles invalid processing instruction content" do
+      content = "?> invalid"
+      doc = context.create_document
+      pi = doc.create_processing_instruction("test", content)
+      expect(pi.to_xml).not_to include("?>?>")
+    end
+
+    it "rejects comments with double hyphens" do
+      doc = context.create_document
+      expect do
+        doc.create_comment("-- test -- comment --")
+      end.to raise_error(Moxml::ValidationError, "XML comment cannot start or end with a hyphen")
+    end
+
+    it "rejects comments starting with hyphen" do
+      doc = context.create_document
+      expect do
+        doc.create_comment("-starting with hyphen")
+      end.to raise_error(Moxml::ValidationError, "XML comment cannot start or end with a hyphen")
+    end
+
+    it "rejects comments ending with hyphen" do
+      doc = context.create_document
+      expect do
+        doc.create_comment("ending with hyphen-")
+      end.to raise_error(Moxml::ValidationError, "XML comment cannot start or end with a hyphen")
+    end
+
+    it "accepts valid comments" do
+      doc = context.create_document
+      comment = doc.create_comment("valid - comment")
+      expect(comment.content).to eq("valid - comment")
+    end
+  end
+
+  describe "namespace edge cases" do
+    it "handles default namespace changes" do
+      xml = <<~XML
+        <root xmlns="http://default1.org">
+          <child xmlns="http://default2.org">
+            <grandchild xmlns=""/>
+          </child>
+        </root>
+      XML
+
+      doc = context.parse(xml)
+      grandchild = doc.at_xpath("//xmlns:grandchild", "xmlns" => "")
+      expect(grandchild.namespace.uri).to eq("")
+    end
+
+    it "handles recursive namespace definitions" do
+      xml = <<~XML
+        <root xmlns:a="http://a.org">
+          <a:child xmlns:a="http://b.org">
+            <a:grandchild/>
+          </a:child>
+        </root>
+      XML
+
+      doc = context.parse(xml)
+      grandchild = doc.at_xpath("//a:grandchild", "a" => "http://b.org")
+      expect(grandchild.namespace.uri).to eq("http://b.org")
+    end
+  end
+
+  describe "attribute edge cases" do
+    it "handles attributes with same local name but different namespaces" do
+      xml = <<~XML
+        <root xmlns:a="http://a.org" xmlns:b="http://b.org">
+          <element a:id="1" b:id="2"/>
+        </root>
+      XML
+
+      doc = context.parse(xml)
+      element = doc.at_xpath("//element")
+      expect(element["a:id"]).to eq("1")
+      expect(element["b:id"]).to eq("2")
+    end
+
+    it "handles special attribute values" do
+      doc = context.create_document
+      element = doc.create_element("test")
+
+      special_values = {
+        "empty" => "",
+        "space" => " ",
+        "tabs_newlines" => "\t\n",
+        "unicode" => "⚡",
+        "entities" => "<&>'\""
+      }
+
+      special_values.each do |name, value|
+        element[name] = value
+        expect(element[name]).to eq(value)
+      end
+    end
+  end
+
+  describe "document structure edge cases" do
+    it "handles deeply nested elements" do
+      doc = context.create_document
+      current = doc.create_element("root")
+      doc.add_child(current)
+
+      1000.times do |i|
+        nested = doc.create_element("nested#{i}")
+        current.add_child(nested)
+        current = nested
+      end
+
+      expect(doc.to_xml).to include("<nested999>")
+    end
+
+    it "handles large number of siblings" do
+      doc = context.create_document
+      root = doc.create_element("root")
+      doc.add_child(root)
+
+      1000.times do |i|
+        child = doc.create_element("child")
+        child.text = i.to_s
+        root.add_child(child)
+      end
+
+      expect(root.children.size).to eq(1000)
+    end
+
+    it "handles mixed content with all node types" do
+      doc = context.create_document
+      root = doc.create_element("root")
+      doc.add_child(root)
+
+      root.add_child("text1")
+      root.add_child(doc.create_comment("comment"))
+      root.add_child("text2")
+      root.add_child(doc.create_cdata("<tag>"))
+      root.add_child(doc.create_element("child"))
+      root.add_child("text3")
+      root.add_child(doc.create_processing_instruction("pi", "data"))
+
+      expect(root.children.size).to eq(7)
+    end
+  end
+end

data/spec/support/shared_examples/element.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Element" do
+  describe Moxml::Element do
+    let(:context) { Moxml.new }
+    let(:doc) { context.create_document }
+    let(:element) { doc.create_element("test") }
+
+    describe "name handling" do
+      it "gets name" do
+        expect(element.name).to eq("test")
+      end
+
+      it "sets name" do
+        element.name = "new_name"
+        expect(element.name).to eq("new_name")
+      end
+    end
+
+    describe "attributes" do
+      before { element["id"] = "123" }
+
+      it "sets attribute" do
+        expect(element["id"]).to eq("123")
+      end
+
+      it "gets attribute" do
+        expect(element.attribute("id")).to be_a(Moxml::Attribute)
+        expect(element.attribute("id").value).to eq("123")
+      end
+
+      it "gets all attributes" do
+        element["class"] = "test"
+        expect(element.attributes.size).to eq(2)
+        expect(element.attributes.map(&:name)).to contain_exactly("id", "class")
+      end
+
+      it "removes attribute" do
+        element.remove_attribute("id")
+        expect(element["id"]).to be_nil
+      end
+
+      it "handles special characters" do
+        element["special"] = '< > & " \''
+        expect(element.to_xml).to include('special="&lt; &gt; &amp; &quot; \'')
+      end
+    end
+
+    describe "namespaces" do
+      it "adds namespace" do
+        element.add_namespace("x", "http://example.org")
+        expect(element.namespaces.size).to eq(1)
+        expect(element.namespaces.first.prefix).to eq("x")
+        expect(element.namespaces.first.uri).to eq("http://example.org")
+      end
+
+      it "sets namespace" do
+        ns = element.add_namespace("x", "http://example.org").namespace
+        element.namespace = ns
+        expect(element.namespace).to eq(ns)
+      end
+
+      it "adds default namespace" do
+        element.add_namespace(nil, "http://example.org")
+        expect(element.namespace.prefix).to be_nil
+        expect(element.namespace.uri).to eq("http://example.org")
+      end
+    end
+
+    describe "content manipulation" do
+      it "sets text content" do
+        element.text = "content"
+        expect(element.text).to eq("content")
+      end
+
+      it "appends text" do
+        element.text = "first"
+        element.add_child("second")
+        expect(element.text).to eq("firstsecond")
+      end
+
+      it "sets inner HTML" do
+        element.inner_html = "<child>text</child>"
+        expect(element.children.size).to eq(1)
+        expect(element.children.first.name).to eq("child")
+        expect(element.children.first.text).to eq("text")
+      end
+    end
+
+    describe "node manipulation" do
+      it "adds child element" do
+        child = doc.create_element("child")
+        element.add_child(child)
+        expect(element.children.first).to eq(child)
+      end
+
+      it "adds child text" do
+        element.add_child("text")
+        expect(element.text).to eq("text")
+      end
+
+      it "adds mixed content" do
+        element.add_child("text")
+        element.add_child(doc.create_element("child"))
+        element.add_child("more")
+        expect(element.to_xml).to include("text<child></child>more")
+      end
+    end
+
+    describe "complex element structures" do
+      it "creates nested paragraphs without namespaces" do
+        outer_p = doc.create_element("p")
+        inner_p = doc.create_element("p")
+        inner_p.add_child("Some text inside paragraph")
+        outer_p.add_child(inner_p)
+
+        expect(outer_p.to_xml).to include("<p>Some text inside paragraph</p>")
+      end
+
+      it "does not return text of child elements in root text" do
+        outer_p = doc.create_element("p")
+        inner_p = doc.create_element("p")
+        inner_p.add_child("Some text inside paragraph")
+        outer_p.add_child(inner_p)
+        expect(outer_p.inner_text).to eq("")
+        expect(inner_p.text).to include("Some text inside paragraph")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Attribute Examples" do
+  let(:context) { Moxml.new }
+  let(:doc) { context.create_document }
+
+  describe "Attribute manipulation" do
+    it "handles basic attributes" do
+      element = doc.create_element("test")
+      element["id"] = "123"
+      element["class"] = "main"
+
+      expect(element.to_xml).to include('id="123"')
+      expect(element.to_xml).to include('class="main"')
+    end
+
+    it "handles namespaced attributes" do
+      element = doc.create_element("test")
+      element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+      element["xs:type"] = "string"
+
+      expect(element.to_xml).to include('xs:type="string"')
+    end
+
+    it "handles special characters in attributes" do
+      element = doc.create_element("test")
+      element["special"] = '< > & " \''
+
+      expect(element.to_xml).to include(
+        'special="&lt; &gt; &amp; &quot; \''
+      )
+    end
+
+    it "removes attributes" do
+      element = doc.create_element("test")
+      element["temp"] = "value"
+      element.remove_attribute("temp")
+
+      expect(element.to_xml).not_to include("temp")
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Basic Usage Examples" do
+  let(:context) { Moxml.new }
+
+  describe "Document creation" do
+    it "creates basic document" do
+      doc = context.create_document
+      root = doc.create_element("book")
+      doc.add_child(root)
+
+      expect(doc.to_xml).to include("<book></book>")
+    end
+
+    it "creates document with declaration" do
+      doc = context.create_document
+      doc.add_child(doc.create_declaration("1.0", "UTF-8"))
+      root = doc.create_element("book")
+      doc.add_child(root)
+
+      expect(doc.to_xml).to include(
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        "<book></book>"
+      )
+    end
+
+    it "creates document with processing instructions" do
+      doc = context.create_document
+      pi = doc.create_processing_instruction("xml-stylesheet",
+                                             'type="text/xsl" href="style.xsl"')
+      doc.add_child(pi)
+      doc.add_child(doc.create_element("root"))
+
+      expect(doc.to_xml).to include(
+        '<?xml-stylesheet type="text/xsl" href="style.xsl"?>',
+        "<root></root>"
+      )
+    end
+  end
+
+  describe "Node creation" do
+    let(:doc) { context.create_document }
+
+    it "creates different node types" do
+      element = doc.create_element("test")
+      text = doc.create_text("content")
+      cdata = doc.create_cdata("<xml>data</xml>")
+      comment = doc.create_comment("note")
+      pi = doc.create_processing_instruction("target", "data")
+
+      root = doc.create_element("root")
+      doc.add_child(root)
+      root.add_child(element)
+      root.add_child(text)
+      root.add_child(cdata)
+      root.add_child(comment)
+      root.add_child(pi)
+
+      xml = doc.to_xml
+      expect(xml).to include("<test></test>")
+      expect(xml).to include("content")
+      expect(xml).to include("<![CDATA[<xml>data</xml>]]>")
+      expect(xml).to include("<!--note-->")
+      expect(xml).to include("<?target data?>")
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "get_process_mem"
+require "tempfile"
+
+RSpec.shared_examples "Memory Usage Examples" do
+  let(:context) { Moxml.new }
+
+  describe "Memory efficient processing" do
+    it "processes large documents efficiently", skip: "Oga fails this test" do
+      # Create large document
+      doc = context.create_document
+      root = doc.create_element("root")
+      doc.add_child(root)
+
+      1000.times do |i|
+        node = doc.create_element("large-node")
+        node.add_child(doc.create_text("Content #{i}"))
+        root.add_child(node)
+      end
+
+      # Process and remove nodes
+      memory_before = GetProcessMem.new.bytes
+      doc.xpath("//large-node").each(&:remove)
+      GC.start
+      memory_after = GetProcessMem.new.bytes
+
+      expect(memory_after).to be <= memory_before
+      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
+
+        # Process file
+        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
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Namespace Examples" do
+  let(:context) { Moxml.new }
+
+  describe "Namespace handling" do
+    it "handles default namespace" do
+      doc = context.create_document
+      root = doc.create_element("root")
+      root.add_namespace(nil, "http://example.org")
+      doc.add_child(root)
+
+      expect(doc.to_xml).to include('xmlns="http://example.org"')
+    end
+
+    it "handles prefixed namespaces" do
+      doc = context.create_document
+      root = doc.create_element("root")
+      root.add_namespace("dc", "http://purl.org/dc/elements/1.1/")
+      doc.add_child(root)
+
+      title = doc.create_element("dc:title")
+      title.add_child(doc.create_text("Test"))
+      root.add_child(title)
+
+      expect(doc.to_xml).to include(
+        'xmlns:dc="http://purl.org/dc/elements/1.1/"',
+        "<dc:title>Test</dc:title>"
+      )
+    end
+
+    it "handles namespace inheritance" do
+      doc = context.create_document
+      root = doc.create_element("root")
+      root.add_namespace("ns", "http://example.org")
+      doc.add_child(root)
+
+      child = doc.create_element("ns:child")
+      root.add_child(child)
+      grandchild = doc.create_element("ns:grandchild")
+      child.add_child(grandchild)
+
+      expect(doc.to_xml).to include(
+        "<ns:child>",
+        "<ns:grandchild>"
+      )
+    end
+
+    it "handles namespace overriding" do
+      doc = context.create_document
+      root = doc.create_element("root")
+      root.add_namespace("ns", "http://example.org/1")
+      doc.add_child(root)
+
+      child = doc.create_element("child")
+      child.add_namespace("ns", "http://example.org/2")
+      root.add_child(child)
+
+      expect(doc.to_xml).to include(
+        'xmlns:ns="http://example.org/1"',
+        'xmlns:ns="http://example.org/2"'
+      )
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "README Examples" do
+  describe "Quick Start example" do
+    it "builds document as shown in README" do
+      context = Moxml.new
+      doc = context.create_document
+
+      root = doc.create_element("book")
+      doc.add_child(root)
+
+      root.add_namespace("dc", "http://purl.org/dc/elements/1.1/")
+      title = doc.create_element("dc:title")
+      title.add_child(doc.create_text("XML Processing with Ruby"))
+      root.add_child(title)
+
+      expect(doc.to_xml).to include(
+        '<book xmlns:dc="http://purl.org/dc/elements/1.1/">',
+        "<dc:title>XML Processing with Ruby</dc:title>",
+        "</book>"
+      )
+    end
+  end
+
+  describe "Complex document example" do
+    it "builds document with all features" do
+      doc = Moxml.new.create_document
+
+      # Add declaration
+      doc.add_child(doc.create_declaration("1.0", "UTF-8"))
+
+      # Create root with namespace
+      root = doc.create_element("library")
+      root.add_namespace(nil, "http://example.org/library")
+      root.add_namespace("dc", "http://purl.org/dc/elements/1.1/")
+      doc.add_child(root)
+
+      # Add books
+      %w[Ruby XML].each do |title|
+        book = doc.create_element("book")
+
+        # Add metadata
+        dc_title = doc.create_element("dc:title")
+        dc_title.add_child(doc.create_text(title))
+        book.add_child(dc_title)
+
+        # Add description
+        desc = doc.create_element("description")
+        desc.add_child(doc.create_cdata("About #{title}..."))
+        book.add_child(desc)
+
+        root.add_child(book)
+      end
+
+      xml = doc.to_xml
+      expect(xml).to include('<?xml version="1.0" encoding="UTF-8"?>')
+      expect(xml).to include('<library xmlns="http://example.org/library" xmlns:dc="http://purl.org/dc/elements/1.1/">')
+      expect(xml).to include("<dc:title>Ruby</dc:title>")
+      expect(xml).to include("<![CDATA[About Ruby...]]>")
+      expect(xml).to include("<dc:title>XML</dc:title>")
+      expect(xml).to include("<![CDATA[About XML...]]>")
+    end
+  end
+
+  describe "Error handling example" do
+    it "handles errors as shown in README" do
+      context = Moxml.new
+
+      expect do
+        context.parse("<invalid>")
+      end.to raise_error(Moxml::ParseError)
+
+      doc = context.parse("<root/>")
+      expect do
+        doc.xpath("///")
+      end.to raise_error(Moxml::XPathError)
+    end
+  end
+
+  describe "Thread safety example" do
+    it "processes XML in thread-safe manner" do
+      processor = Class.new do
+        def initialize
+          @mutex = Mutex.new
+          @context = Moxml.new
+        end
+
+        def process(xml)
+          @mutex.synchronize do
+            doc = @context.parse(xml)
+            doc.to_xml
+          end
+        end
+      end.new
+
+      result = processor.process("<root/>")
+      expect(result).to include("<root></root>")
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Thread Safety Examples" do
+  describe "Thread-safe processing" do
+    let(:processor_class) do
+      Class.new do
+        def initialize
+          @mutex = Mutex.new
+          @context = Moxml.new
+        end
+
+        def process(xml)
+          @mutex.synchronize do
+            doc = @context.parse(xml)
+            yield doc if block_given?
+            doc.to_xml
+          end
+        end
+      end
+    end
+
+    it "handles concurrent processing" do
+      processor = processor_class.new
+      threads = []
+      results = Queue.new
+
+      10.times do |i|
+        threads << Thread.new do
+          xml = "<root><id>#{i}</id></root>"
+          result = processor.process(xml) do |doc|
+            # Simulate some work
+            sleep(rand * 0.1)
+            doc.at_xpath("//id").text
+          end
+          results << result
+        end
+      end
+
+      threads.each(&:join)
+      expect(results.size).to eq(10)
+    end
+  end
+end