moxml 0.1.0 → 0.1.1

data/spec/support/shared_examples/attribute.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Attribute" do
+  describe Moxml::Attribute do
+    let(:context) { Moxml.new }
+    let(:doc) { context.create_document }
+    let(:element) { doc.create_element("test") }
+
+    describe "creation and access" do
+      before do
+        element["test"] = "value"
+      end
+
+      let(:attribute) { element.attributes.first }
+
+      it "creates attribute" do
+        expect(attribute).to be_a(described_class)
+        expect(attribute).to be_attribute
+      end
+
+      it "gets name" do
+        expect(attribute.name).to eq("test")
+      end
+
+      it "gets value" do
+        expect(attribute.value).to eq("value")
+      end
+
+      it "sets name" do
+        attribute.name = "new_name"
+        expect(attribute.name).to eq("new_name")
+        expect(element["new_name"]).to eq("value")
+        expect(element["test"]).to be_nil
+      end
+
+      it "sets value" do
+        attribute.value = "new_value"
+        expect(attribute.value).to eq("new_value")
+        expect(element["test"]).to eq("new_value")
+      end
+    end
+
+    describe "namespaces" do
+      before do
+        element.add_namespace("ns", "http://example.org")
+      end
+
+      it "handles namespaced attributes" do
+        element["ns:attr"] = "value"
+        attribute = element.attributes.first
+
+        expect(attribute.namespace).not_to be_nil
+        expect(attribute.namespace.prefix).to eq("ns")
+        expect(attribute.namespace.uri).to eq("http://example.org")
+      end
+
+      it "changes attribute namespace" do
+        element["attr"] = "value"
+        attribute = element.attributes.first
+
+        element.add_namespace("other", "http://other.org")
+        new_ns = element.namespaces.last
+        attribute.namespace = new_ns
+
+        expect(attribute.namespace.prefix).to eq("other")
+        expect(attribute.to_s).to eq('other:attr="value"')
+      end
+    end
+
+    describe "manipulation" do
+      before do
+        element["test"] = "value"
+      end
+
+      let(:attribute) do
+        element.attributes.first
+      end
+
+      it "removes attribute" do
+        attribute.remove
+        expect(element["test"]).to be_nil
+        expect(element.attributes).to be_empty
+      end
+
+      it "handles special characters in values" do
+        attribute.value = "< & > ' \""
+        expect(attribute.to_s).to eq('test="< & > \' ""')
+      end
+    end
+
+    describe "#to_s" do
+      it "formats regular attribute" do
+        element["test"] = "value"
+        expect(element.attributes.first.to_s).to eq('test="value"')
+      end
+
+      it "formats namespaced attribute" do
+        element.add_namespace("ns", "http://example.org")
+        element["ns:test"] = "value"
+        expect(element.attributes.first.to_s).to eq('ns:test="value"')
+      end
+    end
+
+    describe "equality" do
+      it "compares attributes" do
+        element["test"] = "value"
+        attr1 = element.attributes.first
+
+        element2 = doc.create_element("other")
+        element2["test"] = "value"
+        attr2 = element2.attributes.first
+
+        element3 = doc.create_element("other")
+        element3["test"] = "different"
+        attr3 = element3.attributes.first
+
+        expect(attr1).to eq(attr2)
+        expect(attr1).not_to eq(attr3)
+      end
+
+      it "compares attributes with namespaces" do
+        element.add_namespace("ns", "http://example.org")
+        element["ns:test"] = "value"
+        attr1 = element.attributes.first
+
+        element2 = doc.create_element("other")
+        element2.add_namespace("ns", "http://example.org")
+        element2["ns:test"] = "value"
+        attr2 = element2.attributes.first
+
+        expect(attr1).to eq(attr2)
+      end
+    end
+
+    describe "edge cases" do
+      it "handles empty values" do
+        element["empty"] = ""
+        attribute = element.attributes.first
+        expect(attribute.value).to eq("")
+        expect(attribute.to_s).to eq('empty=""')
+      end
+
+      it "handles nil values" do
+        element["nil"] = nil
+        attribute = element.attributes.first
+        expect(attribute.value).to eq("")
+        expect(attribute.to_s).to eq('nil=""')
+      end
+
+      it "handles numeric values" do
+        element["num"] = 123
+        attribute = element.attributes.first
+        expect(attribute.value).to eq("123")
+        expect(attribute.to_s).to eq('num="123"')
+      end
+
+      it "handles boolean values" do
+        element["bool"] = true
+        attribute = element.attributes.first
+        expect(attribute.value).to eq("true")
+        expect(attribute.to_s).to eq('bool="true"')
+      end
+    end
+  end
+end

data/spec/support/shared_examples/builder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Builder" do
+  let(:context) { Moxml.new }
+  let(:builder) { Moxml::Builder.new(context) }
+
+  describe "#document" do
+    it "creates a well-formed document" do
+      doc = builder.build do
+        declaration version: "1.0", encoding: "UTF-8"
+        element "root" do
+          element "child", id: "1" do
+            text "content"
+          end
+        end
+      end
+
+      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
+  end
+end

data/spec/support/shared_examples/cdata.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Cdata" do
+  let(:context) { Moxml.new }
+  let(:doc) { context.create_document }
+  let(:cdata) { doc.create_cdata("<content>") }
+
+  it "identifies as CDATA node" do
+    expect(cdata).to be_cdata
+  end
+
+  describe "content manipulation" do
+    it "gets content" do
+      expect(cdata.content).to eq("<content>")
+    end
+
+    it "sets content" do
+      cdata.content = "new <content>"
+      expect(cdata.content).to eq("new <content>")
+    end
+
+    it "handles nil content" do
+      cdata.content = nil
+      expect(cdata.content).to eq("")
+    end
+  end
+
+  describe "serialization" do
+    it "wraps content in CDATA section" do
+      expect(cdata.to_xml).to eq("<![CDATA[<content>]]>")
+    end
+
+    it "escapes CDATA end marker" do
+      cdata.content = "content]]>more"
+      expect(cdata.to_xml).to eq("<![CDATA[content]]]]><![CDATA[>more]]>")
+    end
+
+    it "handles special characters" 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
+    let(:element) { doc.create_element("test") }
+
+    it "adds to element" do
+      element.add_child(cdata)
+      expect(element.to_xml).to include("<![CDATA[<content>]]>")
+    end
+
+    it "removes from element" do
+      element.add_child(cdata)
+      cdata.remove
+      expect(element.children).to be_empty
+    end
+
+    it "replaces with another node" do
+      element.add_child(cdata)
+      text = doc.create_text("replacement")
+      cdata.replace(text)
+      expect(element.text).to eq("replacement")
+    end
+  end
+end

data/spec/support/shared_examples/comment.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Comment" do
+  let(:context) { Moxml.new }
+  let(:doc) { context.create_document }
+  let(:comment) { doc.create_comment("test comment") }
+
+  it "identifies as comment node" do
+    expect(comment).to be_comment
+  end
+
+  describe "content manipulation" do
+    it "gets content" do
+      expect(comment.content).to eq("test comment")
+    end
+
+    it "sets content" do
+      comment.content = "new comment"
+      expect(comment.content).to eq("new comment")
+    end
+
+    it "handles nil content" do
+      comment.content = nil
+      expect(comment.content).to eq("")
+    end
+  end
+
+  describe "serialization" do
+    it "wraps content in comment markers" do
+      expect(comment.to_xml).to eq("<!--test comment-->")
+    end
+
+    it "raises an error on double hyphens" do
+      expect { comment.content = "test -- comment" }
+        .to raise_error(Moxml::ValidationError, "XML comment cannot contain double hyphens (--)")
+    end
+
+    it "handles special characters" do
+      comment.content = "< > & \" '"
+      expect(comment.to_xml).to eq("<!--< > & \" '-->")
+    end
+  end
+
+  describe "node operations" do
+    let(:element) { doc.create_element("test") }
+
+    it "adds to element" do
+      element.add_child(comment)
+      expect(element.to_xml).to include("<!--test comment-->")
+    end
+
+    it "removes from element" do
+      element.add_child(comment)
+      comment.remove
+      expect(element.children).to be_empty
+    end
+
+    it "replaces with another node" do
+      element.add_child(comment)
+      text = doc.create_text("replacement")
+      comment.replace(text)
+      expect(element.text).to eq("replacement")
+    end
+  end
+end

data/spec/support/shared_examples/context.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Context" do
+  let(:context) { Moxml::Context.new }
+
+  describe "#parse" do
+    it "returns a Moxml::Document" do
+      doc = context.parse("<root/>")
+      expect(doc).to be_a(Moxml::Document)
+    end
+
+    it "builds complete document model" do
+      doc = context.parse("<root><child>text</child></root>")
+      expect(doc.root).to be_a(Moxml::Element)
+      expect(doc.root.children.first).to be_a(Moxml::Element)
+      expect(doc.root.children.first.children.first).to be_a(Moxml::Text)
+    end
+
+    it "maintains document structure", skip: "Nokogiri doesn't consider the declaration as a child node" do
+      xml = <<~XML
+        <?xml version="1.0"?>
+        <!-- comment -->
+        <root>
+          <![CDATA[data]]>
+          <?pi target?>
+        </root>
+      XML
+      doc = context.parse(xml)
+
+      expect(doc.children[1]).to be_a(Moxml::Comment)
+      expect(doc.at_xpath("//root").children[0]).to be_a(Moxml::Cdata)
+      expect(doc.at_xpath("//root").children[1]).to be_a(Moxml::ProcessingInstruction)
+    end
+  end
+end

data/spec/support/shared_examples/declaration.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Declaration" do
+  let(:context) { Moxml.new }
+  let(:doc) { context.create_document }
+  let(:declaration) { doc.create_declaration("1.0", "UTF-8", "yes") }
+
+  it "identifies as declaration node" do
+    expect(declaration).to be_declaration
+  end
+
+  describe "version handling" do
+    it "gets version" do
+      expect(declaration.version).to eq("1.0")
+    end
+
+    it "sets version" do
+      declaration.version = "1.1"
+      expect(declaration.version).to eq("1.1")
+    end
+
+    it "validates version" do
+      expect { declaration.version = "2.0" }
+        .to raise_error(Moxml::ValidationError, "Invalid XML version: 2.0")
+    end
+  end
+
+  describe "encoding handling" do
+    it "gets encoding" do
+      expect(declaration.encoding).to eq("UTF-8")
+    end
+
+    it "sets encoding" do
+      declaration.encoding = "ISO-8859-1"
+      expect(declaration.encoding).to eq("ISO-8859-1")
+    end
+
+    it "normalizes encoding" do
+      declaration.encoding = "utf-8"
+      expect(declaration.encoding).to eq("utf-8")
+    end
+  end
+
+  describe "standalone handling" do
+    it "gets standalone" do
+      expect(declaration.standalone).to eq("yes")
+    end
+
+    it "sets standalone" do
+      declaration.standalone = "no"
+      expect(declaration.standalone).to eq("no")
+    end
+
+    it "validates standalone value" do
+      expect { declaration.standalone = "maybe" }
+        .to raise_error(Moxml::ValidationError, "Invalid standalone value: maybe")
+    end
+
+    it "allows nil standalone" do
+      declaration.standalone = nil
+      expect(declaration.standalone).to be_nil
+    end
+  end
+
+  describe "serialization" do
+    it "formats complete declaration" do
+      expect(declaration.to_xml).to eq('<?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"?>')
+    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"?>')
+    end
+  end
+
+  describe "node operations" do
+    it "adds to document" do
+      doc.add_child(declaration)
+      expect(doc.to_xml).to start_with("<?xml")
+    end
+
+    it "removes from document", skip: "The document contains a default declaration" do
+      doc.add_child(declaration)
+      declaration.remove
+      expect(doc.to_xml).not_to include("<?xml")
+    end
+  end
+end

data/spec/support/shared_examples/doctype.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Doctype" do
+  let(:context) { Moxml.new }
+  let(:doc) { context.create_document }
+  let(:doctype) do
+    doc.create_doctype(
+      "html",
+      "-//W3C//DTD HTML 4.01 Transitional//EN",
+      "http://www.w3.org/TR/html4/loose.dtd"
+    )
+  end
+
+  it "identifies as doctype node" do
+    expect(doctype).to be_doctype
+  end
+
+  describe "serialization" do
+    it "wraps content in doctype markers" do
+      expect(doctype.to_xml).to eq(
+        '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
+      )
+    end
+  end
+end

data/spec/support/shared_examples/document.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::Document" do
+  let(:context) { Moxml.new }
+  let(:xml) do
+    <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <!DOCTYPE html>
+      <root xmlns="http://example.org" xmlns:x="http://example.org/x">
+        <child id="1">Text</child>
+        <child id="2"/>
+        <x:special>
+          <![CDATA[Some <special> text]]>
+          <!-- A comment -->
+          <?pi target?>
+        </x:special>
+      </root>
+    XML
+  end
+
+  describe "#parse" do
+    let(:doc) { context.parse(xml) }
+
+    it "parses XML string" do
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root.name).to eq("root")
+    end
+
+    it "preserves XML declaration" do
+      expect(doc.to_xml).to include('<?xml version="1.0" encoding="UTF-8"?>')
+    end
+
+    it "handles namespaces" do
+      expect(doc.root.namespaces.size).to eq(2)
+    end
+
+    it "preserves DOCTYPE" do
+      expect(doc.to_xml).to include("<!DOCTYPE html>")
+    end
+
+    it "raises error for invalid XML when strict" do
+      context.config.strict_parsing = true
+      expect { context.parse("<invalid>") }.to raise_error(Moxml::ParseError)
+    end
+  end
+
+  describe "node creation" do
+    let(:doc) { context.create_document }
+
+    it "creates element" do
+      element = doc.create_element("test")
+      expect(element).to be_a(Moxml::Element)
+      expect(element.name).to eq("test")
+    end
+
+    it "creates text" do
+      text = doc.create_text("content")
+      expect(text).to be_a(Moxml::Text)
+      expect(text.content).to eq("content")
+    end
+
+    it "creates CDATA" do
+      cdata = doc.create_cdata("<content>")
+      expect(cdata).to be_a(Moxml::Cdata)
+      expect(cdata.content).to eq("<content>")
+    end
+
+    it "creates comment" do
+      comment = doc.create_comment("comment")
+      expect(comment).to be_a(Moxml::Comment)
+      expect(comment.content).to eq("comment")
+    end
+
+    it "creates processing instruction" do
+      pi = doc.create_processing_instruction("target", "content")
+      expect(pi).to be_a(Moxml::ProcessingInstruction)
+      expect(pi.target).to eq("target")
+      expect(pi.content).to eq("content")
+    end
+
+    it "creates declaration" do
+      decl = doc.create_declaration("1.0", "UTF-8", "yes")
+      expect(decl).to be_a(Moxml::Declaration)
+      expect(decl.version).to eq("1.0")
+      expect(decl.encoding).to eq("UTF-8")
+      expect(decl.standalone).to eq("yes")
+    end
+  end
+
+  describe "document structure" do
+    let(:doc) { context.create_document }
+
+    it "builds complete document" do
+      doc.add_child(doc.create_declaration("1.0", "UTF-8"))
+      root = doc.create_element("root")
+      doc.add_child(root)
+
+      child = doc.create_element("child")
+      child.add_child(doc.create_text("text"))
+      root.add_child(child)
+
+      expect(doc.to_xml).to include(
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        "<root>",
+        "<child>text</child>",
+        "</root>"
+      )
+    end
+  end
+end

data/spec/support/shared_examples/document_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml::DocumentBuilder" do
+  let(:context) { Moxml.new }
+  let(:builder) { Moxml::DocumentBuilder.new(context) }
+
+  describe "#build" do
+    it "builds a document model from native document" do
+      xml = "<root><child>text</child></root>"
+      doc = context.config.adapter.parse(xml)
+
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root).to be_a(Moxml::Element)
+      expect(doc.root.name).to eq("root")
+      expect(doc.root.children.first).to be_a(Moxml::Element)
+      expect(doc.root.children.first.text).to eq("text")
+    end
+
+    it "handles complex documents" do
+      xml = <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <root xmlns="http://example.org">
+          <!-- comment -->
+          <child id="1">
+            <![CDATA[cdata content]]>
+          </child>
+          <?pi target data?>
+        </root>
+      XML
+
+      doc = context.config.adapter.parse(xml)
+
+      expect(doc.root.namespaces.count).to eq(1)
+      expect(doc.root.namespaces.first.uri).to eq("http://example.org")
+      expect(doc.root.children[0]).to be_a(Moxml::Comment)
+      expect(doc.root.children[1]).to be_a(Moxml::Element)
+      expect(doc.root.children[1].name).to eq("child")
+      expect(doc.root.children[1]["id"]).to eq("1")
+      expect(doc.root.children[1].children.first).to be_a(Moxml::Cdata)
+      expect(doc.root.children[2]).to be_a(Moxml::ProcessingInstruction)
+    end
+  end
+end