moxml 0.1.7 → 0.1.9

data/spec/moxml/context_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Context do
+  let(:context) { described_class.new }
+
+  describe "#parse" do
+    it "parses XML string" do
+      doc = context.parse("<root><child/></root>")
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root.name).to eq("root")
+    end
+  end
+
+  describe "#config" do
+    it "has a configuration" do
+      expect(context.config).to be_a(Moxml::Config)
+    end
+  end
+
+  describe "adapter access" do
+    it "provides adapter through config" do
+      expect(context.config.adapter).to be_a(Class)
+      expect(context.config.adapter.ancestors).to include(Moxml::Adapter::Base)
+    end
+  end
+end

data/spec/moxml/declaration_preservation_spec.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML Declaration Preservation" do
+  # Test with all available adapters
+  ADAPTERS = %i[nokogiri oga rexml ox libxml headed_ox].freeze
+
+  ADAPTERS.each do |adapter_name|
+    context "with #{adapter_name} adapter" do
+      let(:context) { Moxml.new(adapter_name) }
+
+      describe "automatic preservation" do
+        context "when input has no XML declaration" do
+          let(:xml_without_decl) { '<svg xmlns="http://www.w3.org/2000/svg"><rect/></svg>' }
+
+          it "does not add XML declaration to output" do
+            doc = context.parse(xml_without_decl)
+            output = doc.to_xml
+
+            expect(output).not_to include("<?xml")
+            expect(output).to include("<svg")
+          end
+
+          it "sets has_xml_declaration to false" do
+            doc = context.parse(xml_without_decl)
+            expect(doc.has_xml_declaration).to be false
+          end
+        end
+
+        context "when input has XML declaration" do
+          let(:xml_with_decl) do
+            '<?xml version="1.0" encoding="UTF-8"?><root><child/></root>'
+          end
+
+          it "preserves XML declaration in output" do
+            doc = context.parse(xml_with_decl)
+            output = doc.to_xml
+
+            expect(output).to include("<?xml")
+            expect(output).to include('version="1.0"')
+          end
+
+          it "sets has_xml_declaration to true" do
+            doc = context.parse(xml_with_decl)
+            expect(doc.has_xml_declaration).to be true
+          end
+        end
+
+        context "when input has declaration with standalone attribute" do
+          let(:xml_with_standalone) do
+            '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><root/>'
+          end
+
+          it "preserves the declaration" do
+            doc = context.parse(xml_with_standalone)
+            output = doc.to_xml
+
+            expect(output).to include("<?xml")
+          end
+        end
+      end
+
+      describe "explicit override" do
+        let(:xml_without_decl) { "<root><child/></root>" }
+        let(:xml_with_decl) { '<?xml version="1.0"?><root><child/></root>' }
+
+        context "when forcing declaration on document without one" do
+          it "adds declaration when declaration: true" do
+            doc = context.parse(xml_without_decl)
+            output = doc.to_xml(declaration: true)
+
+            expect(output).to include("<?xml")
+          end
+        end
+
+        context "when removing declaration from document with one" do
+          it "removes declaration when declaration: false" do
+            doc = context.parse(xml_with_decl)
+            output = doc.to_xml(declaration: false)
+
+            expect(output).not_to include("<?xml")
+            expect(output).to include("<root")
+          end
+        end
+
+        context "when explicitly preserving declaration" do
+          it "keeps declaration when declaration: true" do
+            doc = context.parse(xml_with_decl)
+            output = doc.to_xml(declaration: true)
+
+            expect(output).to include("<?xml")
+          end
+        end
+      end
+
+      describe "round-trip fidelity" do
+        context "for document without declaration" do
+          let(:original) { "<root><item id=\"1\"/></root>" }
+
+          it "maintains absence of declaration through parse and serialize" do
+            doc = context.parse(original)
+            output = doc.to_xml
+
+            expect(output).not_to include("<?xml")
+
+            # Parse again and verify
+            doc2 = context.parse(output)
+            expect(doc2.has_xml_declaration).to be false
+          end
+        end
+
+        context "for document with declaration" do
+          let(:original) do
+            '<?xml version="1.0" encoding="UTF-8"?><root><item id="1"/></root>'
+          end
+
+          it "maintains presence of declaration through parse and serialize" do
+            doc = context.parse(original)
+            output = doc.to_xml
+
+            expect(output).to include("<?xml")
+
+            # Parse again and verify
+            doc2 = context.parse(output)
+            expect(doc2.has_xml_declaration).to be true
+          end
+        end
+      end
+
+      describe "edge cases" do
+        context "with empty document" do
+          it "does not add declaration to empty document" do
+            doc = context.create_document
+
+            # Empty documents should not have declaration by default
+            expect(doc.has_xml_declaration).to be false
+          end
+        end
+
+        context "with built document" do
+          it "does not add declaration to programmatically built document" do
+            doc = context.create_document
+            root = doc.create_element("root")
+            doc.root = root
+
+            output = doc.to_xml
+
+            expect(output).not_to include("<?xml")
+            expect(doc.has_xml_declaration).to be false
+          end
+
+          it "can explicitly add declaration to built document" do
+            doc = context.create_document
+            root = doc.create_element("root")
+            doc.root = root
+
+            output = doc.to_xml(declaration: true)
+
+            expect(output).to include("<?xml")
+          end
+        end
+      end
+
+      describe "non-document nodes" do
+        let(:xml) { '<?xml version="1.0"?><root><child>text</child></root>' }
+
+        it "does not add declaration when serializing element nodes" do
+          doc = context.parse(xml)
+          root = doc.root
+          output = root.to_xml
+
+          expect(output).not_to include("<?xml")
+          expect(output).to include("<root>")
+        end
+      end
+    end
+  end
+
+  describe "integration with svg_conform use case" do
+    let(:context) { Moxml.new }
+
+    context "remediating SVG without declaration" do
+      let(:svg_input) { '<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100"><rect x="10" y="10" width="80" height="80"/></svg>' }
+
+      it "does not add declaration to remediated output" do
+        doc = context.parse(svg_input)
+
+        # Simulate remediation: add viewport
+        root = doc.root
+        root["viewBox"] = "0 0 100 100"
+
+        output = doc.to_xml
+
+        expect(output).not_to include("<?xml")
+        expect(output).to include('viewBox="0 0 100 100"')
+      end
+    end
+
+    context "remediating SVG with declaration" do
+      let(:svg_input) { '<?xml version="1.0" encoding="UTF-8"?><svg xmlns="http://www.w3.org/2000/svg"><rect/></svg>' }
+
+      it "preserves declaration in remediated output" do
+        doc = context.parse(svg_input)
+
+        # Simulate remediation
+        root = doc.root
+        root["viewBox"] = "0 0 100 100"
+
+        output = doc.to_xml
+
+        expect(output).to include("<?xml")
+        expect(output).to include('viewBox="0 0 100 100"')
+      end
+    end
+  end
+end

data/spec/moxml/declaration_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Declaration do
+  let(:context) { Moxml.new }
+  let(:doc) { context.create_document }
+
+  describe "#version" do
+    it "returns XML version" do
+      decl = doc.create_declaration("1.0", "UTF-8")
+      expect(decl.version).to eq("1.0")
+    end
+  end
+
+  describe "#encoding" do
+    it "returns encoding" do
+      decl = doc.create_declaration("1.0", "UTF-8")
+      expect(decl.encoding).to eq("UTF-8")
+    end
+  end
+
+  describe "creation" do
+    it "creates declaration with defaults" do
+      decl = doc.create_declaration
+      expect(decl).to be_a(described_class)
+      expect(decl.version).to eq("1.0")
+    end
+
+    it "creates declaration with custom values" do
+      decl = doc.create_declaration("1.0", "ISO-8859-1")
+      expect(decl.version).to eq("1.0")
+      expect(decl.encoding).to eq("ISO-8859-1")
+    end
+  end
+end

data/spec/moxml/doctype_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Doctype do
+  let(:context) { Moxml.new }
+  let(:doc) { context.create_document }
+
+  describe "#name" do
+    it "returns doctype name" do
+      skip "Doctype accessor methods not yet implemented in all adapters"
+      doctype = doc.create_doctype("root", nil, "test.dtd")
+      expect(doctype.name).to eq("root")
+    end
+  end
+
+  describe "#system_id" do
+    it "returns system identifier" do
+      skip "Doctype accessor methods not yet implemented in all adapters"
+      doctype = doc.create_doctype("root", nil, "test.dtd")
+      expect(doctype.system_id).to eq("test.dtd")
+    end
+  end
+
+  describe "creation" do
+    it "creates a doctype" do
+      skip "Doctype accessor methods not yet implemented in all adapters"
+      doctype = doc.create_doctype("html", nil, nil)
+      expect(doctype).to be_a(described_class)
+      expect(doctype.name).to eq("html")
+    end
+  end
+end

data/spec/moxml/document_builder_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# DocumentBuilder is an internal class for parsing
+# These tests verify it correctly builds Moxml document from native documents
+RSpec.describe Moxml::DocumentBuilder do
+  let(:context) { Moxml.new }
+
+  describe "#build" do
+    it "builds a Moxml document from native document" do
+      native_doc = context.parse("<root><child>content</child></root>").native
+      builder = described_class.new(context)
+      doc = builder.build(native_doc)
+
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root.name).to eq("root")
+    end
+  end
+
+  describe "element handling" do
+    it "handles nested elements" do
+      native_doc = context.parse("<parent><child1/><child2/></parent>").native
+      builder = described_class.new(context)
+      doc = builder.build(native_doc)
+
+      expect(doc.root.children.length).to eq(2)
+    end
+  end
+end

data/spec/moxml/document_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Document do
+  let(:context) { Moxml.new }
+  let(:doc) { context.parse("<root/>") }
+
+  describe "document creation" do
+    it "creates a document via parsing" do
+      expect(doc).to be_a(described_class)
+    end
+
+    it "has a context" do
+      expect(doc.context).to be_a(Moxml::Context)
+    end
+
+    it "has a root element" do
+      expect(doc.root).to be_a(Moxml::Element)
+      expect(doc.root.name).to eq("root")
+    end
+  end
+
+  describe "#create_element" do
+    it "creates an element" do
+      element = doc.create_element("test")
+      expect(element).to be_a(Moxml::Element)
+      expect(element.name).to eq("test")
+    end
+  end
+
+  describe "#to_xml" do
+    it "serializes to XML" do
+      doc = context.parse("<root><child>text</child></root>")
+      xml = doc.to_xml
+      expect(xml).to include("<root>")
+      expect(xml).to include("<child>")
+    end
+  end
+
+  describe "convenience API methods" do
+    describe "#add_element" do
+      it "creates and adds element with attributes" do
+        fresh_doc = context.create_document
+        elem = fresh_doc.add_element("book", id: "123", title: "Ruby")
+
+        expect(elem).to be_a(Moxml::Element)
+        expect(elem.name).to eq("book")
+        expect(elem["id"]).to eq("123")
+        expect(elem["title"]).to eq("Ruby")
+        expect(fresh_doc.children).to include(elem)
+      end
+
+      it "accepts a block for further customization" do
+        fresh_doc = context.create_document
+        elem = fresh_doc.add_element("book", id: "123") do |e|
+          e.text = "Content"
+        end
+
+        expect(elem.text).to eq("Content")
+      end
+
+      it "returns the created element" do
+        fresh_doc = context.create_document
+        elem = fresh_doc.add_element("book")
+
+        expect(elem).to be_a(Moxml::Element)
+        expect(elem.name).to eq("book")
+      end
+    end
+
+    describe "#find" do
+      it "finds first element matching xpath" do
+        doc = context.parse("<root><book id='1'/><book id='2'/></root>")
+        result = doc.find("//book")
+
+        expect(result).to be_a(Moxml::Element)
+        expect(result["id"]).to eq("1")
+      end
+
+      it "returns nil when not found" do
+        result = doc.find("//nonexistent")
+
+        expect(result).to be_nil
+      end
+    end
+
+    describe "#find_all" do
+      it "finds all elements matching xpath" do
+        doc = context.parse("<root><book id='1'/><book id='2'/></root>")
+        results = doc.find_all("//book")
+
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(2)
+        expect(results.map { |r| r["id"] }).to eq(%w[1 2])
+      end
+
+      it "returns empty array when not found" do
+        results = doc.find_all("//nonexistent")
+
+        expect(results).to eq([])
+      end
+    end
+  end
+end

data/spec/moxml/element_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Element do
+  let(:context) { Moxml.new }
+  let(:doc) { context.parse("<root><child>text</child></root>") }
+  let(:element) { doc.root }
+
+  describe "#name" do
+    it "returns the element name" do
+      expect(element.name).to eq("root")
+    end
+  end
+
+  describe "#children" do
+    it "returns child elements" do
+      children = element.children
+      expect(children).not_to be_empty
+      expect(children.first.name).to eq("child")
+    end
+  end
+
+  describe "#[]" do
+    it "gets attribute value" do
+      elem = context.parse('<root id="123"/>').root
+      expect(elem["id"]).to eq("123")
+    end
+  end
+
+  describe "#[]=" do
+    it "sets attribute value" do
+      elem = doc.create_element("test")
+      elem["id"] = "456"
+      expect(elem["id"]).to eq("456")
+    end
+  end
+
+  describe "#text" do
+    it "returns text content" do
+      child = element.children.first
+      expect(child.text).to eq("text")
+    end
+  end
+
+  describe "convenience API methods" do
+    describe "#set_attributes" do
+      it "sets multiple attributes at once" do
+        elem = doc.create_element("book")
+        elem.set_attributes(id: "123", title: "Ruby", year: "2024")
+
+        expect(elem["id"]).to eq("123")
+        expect(elem["title"]).to eq("Ruby")
+        expect(elem["year"]).to eq("2024")
+      end
+
+      it "returns self for chaining" do
+        elem = doc.create_element("book")
+        result = elem.set_attributes(id: "123")
+
+        expect(result).to eq(elem)
+      end
+
+      it "handles empty hash" do
+        elem = doc.create_element("book")
+        expect { elem.set_attributes({}) }.not_to raise_error
+      end
+    end
+
+    describe "#with_child" do
+      it "adds a child and returns self" do
+        elem = doc.create_element("parent")
+        child = doc.create_element("child")
+
+        result = elem.with_child(child)
+
+        expect(result).to eq(elem)
+        expect(elem.children.map(&:name)).to include("child")
+      end
+
+      it "can be chained" do
+        elem = doc.create_element("parent")
+        child1 = doc.create_element("child1")
+        child2 = doc.create_element("child2")
+
+        elem.with_child(child1).with_child(child2)
+
+        expect(elem.children.map(&:name)).to eq(%w[child1 child2])
+      end
+    end
+
+    describe "#find_element" do
+      it "finds first element matching xpath" do
+        doc = context.parse("<root><book id='1'/><book id='2'/></root>")
+        result = doc.root.find_element(".//book")
+
+        expect(result).to be_a(described_class)
+        expect(result["id"]).to eq("1")
+      end
+
+      it "returns nil when not found" do
+        result = element.find_element(".//nonexistent")
+
+        expect(result).to be_nil
+      end
+    end
+
+    describe "#find_all" do
+      it "finds all elements matching xpath" do
+        doc = context.parse("<root><book id='1'/><book id='2'/></root>")
+        results = doc.root.find_all(".//book")
+
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(2)
+        expect(results.map { |r| r["id"] }).to eq(%w[1 2])
+      end
+
+      it "returns empty array when not found" do
+        results = element.find_all(".//nonexistent")
+
+        expect(results).to eq([])
+      end
+    end
+
+    describe "method chaining" do
+      it "chains with_namespace, set_attributes, and with_child" do
+        elem = doc.create_element("book")
+        child = doc.create_element("title")
+        child.text = "Ruby Programming"
+
+        elem
+          .with_namespace("dc", "http://purl.org/dc/elements/1.1/")
+          .set_attributes(id: "123", type: "technical")
+          .with_child(child)
+
+        expect(elem["id"]).to eq("123")
+        expect(elem["type"]).to eq("technical")
+        expect(elem.children.first.name).to eq("title")
+        expect(elem.namespaces.map(&:uri)).to include("http://purl.org/dc/elements/1.1/")
+      end
+    end
+  end
+end