moxml 0.1.6 → 0.1.8

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_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