moxml 0.1.6 → 0.1.8

data/spec/moxml/error_spec.rb

@@ -4,68 +4,312 @@
 RSpec.describe "Moxml errors" do
   describe Moxml::Error do
     it "is a StandardError" do
-      expect(Moxml::Error.new).to be_a(StandardError)
+      expect(described_class.new).to be_a(StandardError)
     end
   end
 
   describe Moxml::ParseError do
     it "includes line and column information" do
-      error = Moxml::ParseError.new("Invalid XML", line: 5, column: 10)
+      error = described_class.new("Invalid XML", line: 5, column: 10)
       expect(error.line).to eq(5)
       expect(error.column).to eq(10)
-      expect(error.message).to eq("Invalid XML")
+      # The base message should be unchanged
+      expect(error.message).to include("Invalid XML")
     end
 
     it "works without line and column" do
-      error = Moxml::ParseError.new("Invalid XML")
+      error = described_class.new("Invalid XML")
       expect(error.line).to be_nil
       expect(error.column).to be_nil
     end
-  end
 
-  describe Moxml::ValidationError do
-    it "handles validation errors" do
-      error = Moxml::ValidationError.new("Invalid document structure")
-      expect(error.message).to eq("Invalid document structure")
+    it "includes source context" do
+      error = described_class.new("Invalid XML", source: "<invalid>")
+      expect(error.source).to eq("<invalid>")
+    end
+
+    it "provides helpful error message with context" do
+      error = described_class.new("Invalid XML", line: 5, column: 10)
+      message = error.to_s
+      expect(message).to include("Invalid XML")
+      expect(message).to include("Line: 5")
+      expect(message).to include("Column: 10")
+      expect(message).to include("Hint:")
     end
   end
 
   describe Moxml::XPathError do
-    it "handles XPath errors" do
-      error = Moxml::XPathError.new("Invalid XPath expression")
-      expect(error.message).to eq("Invalid XPath expression")
+    it "includes expression and adapter information" do
+      error = described_class.new(
+        "Invalid XPath",
+        expression: "//invalid[",
+        adapter: "Nokogiri",
+      )
+      expect(error.expression).to eq("//invalid[")
+      expect(error.adapter).to eq("Nokogiri")
+    end
+
+    it "provides helpful error message" do
+      error = described_class.new(
+        "Invalid XPath",
+        expression: "//test",
+        adapter: "REXML",
+      )
+      message = error.to_s
+      expect(message).to include("Invalid XPath")
+      expect(message).to include("Expression: //test")
+      expect(message).to include("Adapter: REXML")
+      expect(message).to include("Hint:")
+    end
+  end
+
+  describe Moxml::ValidationError do
+    it "includes node, constraint, and value information" do
+      error = described_class.new(
+        "Invalid version",
+        constraint: "version",
+        value: "2.0",
+      )
+      expect(error.constraint).to eq("version")
+      expect(error.value).to eq("2.0")
+    end
+
+    it "provides helpful error message" do
+      error = described_class.new(
+        "Invalid encoding",
+        constraint: "encoding",
+        value: "INVALID",
+      )
+      message = error.to_s
+      expect(message).to include("Invalid encoding")
+      expect(message).to include("Constraint: encoding")
+      expect(message).to include("Value: \"INVALID\"")
+      expect(message).to include("Hint:")
     end
   end
 
   describe Moxml::NamespaceError do
-    it "handles namespace errors" do
-      error = Moxml::NamespaceError.new("Invalid namespace URI")
-      expect(error.message).to eq("Invalid namespace URI")
+    it "includes prefix, uri, and element information" do
+      error = described_class.new(
+        "Invalid namespace",
+        prefix: "ns",
+        uri: "http://example.com",
+      )
+      expect(error.prefix).to eq("ns")
+      expect(error.uri).to eq("http://example.com")
+      expect(error.message).to eq("Invalid namespace")
+    end
+
+    it "provides access to error attributes" do
+      error = described_class.new(
+        "Invalid namespace",
+        prefix: "ns",
+        uri: "invalid-uri",
+      )
+      expect(error.message).to include("Invalid namespace")
+      expect(error.prefix).to eq("ns")
+      expect(error.uri).to eq("invalid-uri")
+    end
+  end
+
+  describe Moxml::AdapterError do
+    it "includes adapter name and operation" do
+      error = described_class.new(
+        "Failed to load adapter",
+        adapter: "nokogiri",
+        operation: "load",
+      )
+      expect(error.adapter_name).to eq("nokogiri")
+      expect(error.operation).to eq("load")
+    end
+
+    it "includes native error information" do
+      native_err = StandardError.new("Gem not found")
+      error = described_class.new(
+        "Failed to load adapter",
+        adapter: "nokogiri",
+        native_error: native_err,
+      )
+      expect(error.native_error).to eq(native_err)
+    end
+
+    it "provides helpful error message" do
+      native_err = LoadError.new("cannot load such file")
+      error = described_class.new(
+        "Failed to load adapter",
+        adapter: "oga",
+        operation: "require",
+        native_error: native_err,
+      )
+      message = error.to_s
+      expect(message).to include("Failed to load adapter")
+      expect(message).to include("Adapter: oga")
+      expect(message).to include("Operation: require")
+      expect(message).to include("Native Error: LoadError")
+      expect(message).to include("Hint:")
+    end
+  end
+
+  describe Moxml::SerializationError do
+    it "includes node, adapter, and format information" do
+      error = described_class.new(
+        "Failed to serialize",
+        adapter: "LibXML",
+        format: "xml",
+      )
+      expect(error.adapter).to eq("LibXML")
+      expect(error.format).to eq("xml")
+    end
+
+    it "provides helpful error message" do
+      error = described_class.new(
+        "Failed to serialize",
+        adapter: "Ox",
+        format: "xml",
+      )
+      message = error.to_s
+      expect(message).to include("Failed to serialize")
+      expect(message).to include("Adapter: Ox")
+      expect(message).to include("Format: xml")
+      expect(message).to include("Hint:")
+    end
+  end
+
+  describe Moxml::DocumentStructureError do
+    it "includes attempted operation and state" do
+      error = described_class.new(
+        "Invalid operation",
+        operation: "add_child",
+        state: "no_root",
+      )
+      expect(error.attempted_operation).to eq("add_child")
+      expect(error.current_state).to eq("no_root")
+    end
+
+    it "provides helpful error message" do
+      error = described_class.new(
+        "Invalid operation",
+        operation: "set_root",
+        state: "root_already_exists",
+      )
+      message = error.to_s
+      expect(message).to include("Invalid operation")
+      expect(message).to include("Operation: set_root")
+      expect(message).to include("Current State: root_already_exists")
+      expect(message).to include("Hint:")
+    end
+  end
+
+  describe Moxml::AttributeError do
+    it "includes attribute name, element, and value" do
+      error = described_class.new(
+        "Invalid attribute",
+        name: "id",
+        value: 123,
+      )
+      expect(error.attribute_name).to eq("id")
+      expect(error.value).to eq(123)
+    end
+
+    it "provides helpful error message" do
+      error = described_class.new(
+        "Invalid attribute name",
+        name: "123invalid",
+        value: "test",
+      )
+      message = error.to_s
+      expect(message).to include("Invalid attribute name")
+      expect(message).to include("Attribute: 123invalid")
+      expect(message).to include("Value: \"test\"")
+      expect(message).to include("Hint:")
+    end
+  end
+
+  describe Moxml::NotImplementedError do
+    it "includes feature and adapter information" do
+      error = described_class.new(
+        "Feature not supported",
+        feature: "xpath",
+        adapter: "CustomAdapter",
+      )
+      expect(error.feature).to eq("xpath")
+      expect(error.adapter).to eq("CustomAdapter")
+    end
+
+    it "provides helpful error message" do
+      error = described_class.new(
+        "Feature not supported",
+        feature: "namespaces",
+        adapter: "MinimalAdapter",
+      )
+      message = error.to_s
+      expect(message).to include("Feature not supported")
+      expect(message).to include("Feature: namespaces")
+      expect(message).to include("Adapter: MinimalAdapter")
+      expect(message).to include("Hint:")
+    end
+
+    it "has a default message" do
+      error = described_class.new
+      expect(error.message).to include("Feature not implemented")
     end
   end
 
   describe "error handling in context" do
     let(:context) { Moxml.new }
 
-    it "raises ParseError for invalid XML" do
+    it "raises ParseError for invalid XML with enhanced context" do
       expect do
-        context.parse("<invalid>")
-      end.to raise_error(Moxml::ParseError)
+        context.parse("<invalid>", strict: true)
+      end.to raise_error(Moxml::ParseError) do |error|
+        expect(error.to_s).to include("Hint:")
+      end
     end
 
-    it "raises XPathError for invalid XPath" do
+    it "raises XPathError for invalid XPath with enhanced context" do
       doc = context.parse("<root/>")
       expect do
         doc.xpath("///")
-      end.to raise_error(Moxml::XPathError)
+      end.to raise_error(Moxml::XPathError) do |error|
+        expect(error.expression).to eq("///")
+        expect(error.to_s).to include("Hint:")
+      end
     end
 
-    it "raises NamespaceError for invalid namespace" do
+    it "raises NamespaceError for invalid namespace with enhanced context" do
       doc = context.parse("<root/>")
 
       expect do
         doc.root.add_namespace("xml", "http//invalid.com")
-      end.to raise_error(Moxml::NamespaceError, "Invalid URI: http//invalid.com")
+      end.to raise_error(Moxml::NamespaceError) do |error|
+        expect(error.uri).to eq("http//invalid.com")
+        expect(error.prefix).to eq("xml")
+        expect(error.message).to include("Invalid URI")
+      end
+    end
+
+    it "raises ValidationError for invalid XML constructs" do
+      expect do
+        context.parse('<?xml version="2.0"?><root/>', strict: true)
+      end.to raise_error(Moxml::ParseError)
+    end
+
+    it "raises AdapterError for invalid adapter configuration" do
+      expect do
+        Moxml::Config.new.adapter = :invalid_adapter
+      end.to raise_error(Moxml::AdapterError) do |error|
+        expect(error.adapter_name).to eq(:invalid_adapter)
+        expect(error.to_s).to include("Hint:")
+      end
+    end
+
+    it "raises DocumentStructureError for invalid node operations" do
+      doc = context.parse("<root/>")
+      expect do
+        doc.root.add_child(Object.new)
+      end.to raise_error(Moxml::DocumentStructureError) do |error|
+        expect(error.to_s).to include("Hint:")
+      end
     end
   end
 end

data/spec/{moxml_spec.rb → moxml/moxml_spec.rb}

@@ -8,42 +8,42 @@ RSpec.describe Moxml do
 
   describe ".new" do
     it "creates a new context" do
-      expect(Moxml.new).to be_a(Moxml::Context)
+      expect(described_class.new).to be_a(Moxml::Context)
     end
 
     it "accepts adapter specification" do
-      context = Moxml.new(:nokogiri)
+      context = described_class.new(:nokogiri)
       expect(context.config.adapter_name).to eq(:nokogiri)
     end
 
     it "raises error for invalid adapter" do
-      expect { Moxml.new(:invalid) }.to raise_error(ArgumentError)
+      expect { described_class.new(:invalid) }.to raise_error(Moxml::AdapterError)
     end
   end
 
   describe ".configure" do
     around do |example|
       # preserve the original config because it may be changed in examples
-      Moxml.with_config { example.run }
+      described_class.with_config { example.run }
     end
 
     it "sets default values without a block" do
-      Moxml.configure
+      described_class.configure
 
-      context = Moxml.new
+      context = described_class.new
       expect(context.config.adapter_name).to eq(:nokogiri)
     end
 
     it "uses configured options from the block" do
-      Moxml.configure do |config|
+      described_class.configure do |config|
         config.default_adapter = :oga
         config.strict_parsing = false
         config.default_encoding = "US-ASCII"
       end
 
-      context = Moxml.new
+      context = described_class.new
       expect(context.config.adapter_name).to eq(:oga)
-      expect(context.config.strict_parsing).to eq(false)
+      expect(context.config.strict_parsing).to be(false)
       expect(context.config.default_encoding).to eq("US-ASCII")
     end
   end

data/spec/moxml/namespace_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Namespace do
+  let(:context) { Moxml.new }
+  let(:doc) do
+    context.parse('<root xmlns:ns="http://example.com"><ns:child/></root>')
+  end
+
+  describe "#prefix" do
+    it "returns namespace prefix" do
+      ns = doc.root.namespace
+      expect(ns).to be_nil # root has no prefix
+    end
+  end
+
+  describe "#uri" do
+    it "returns namespace URI" do
+      child = doc.root.children.first
+      ns = child.namespace
+      expect(ns.uri).to eq("http://example.com") if ns
+    end
+  end
+
+  describe "namespace handling" do
+    it "handles namespaces on elements" do
+      elem = doc.root.children.first
+      expect(elem.name).to include("child")
+    end
+  end
+end

data/spec/moxml/node_set_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::NodeSet do
+  let(:context) { Moxml.new }
+  let(:doc) { context.parse("<root><child/><child/><child/></root>") }
+
+  describe "#length" do
+    it "returns number of nodes" do
+      nodes = doc.root.children
+      expect(nodes.length).to eq(3)
+    end
+  end
+
+  describe "#[]" do
+    it "accesses nodes by index" do
+      nodes = doc.root.children
+      expect(nodes[0]).to be_a(Moxml::Element)
+      expect(nodes[0].name).to eq("child")
+    end
+  end
+
+  describe "#each" do
+    it "iterates over nodes" do
+      nodes = doc.root.children
+      count = 0
+      nodes.each { |_node| count += 1 }
+      expect(count).to eq(3)
+    end
+  end
+
+  describe "#empty?" do
+    it "returns true when empty" do
+      nodes = doc.create_element("empty").children
+      expect(nodes).to be_empty
+    end
+  end
+end

data/spec/moxml/node_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Node do
+  let(:context) { Moxml.new }
+  let(:doc) { context.parse("<root><child>text</child></root>") }
+  let(:node) { doc.root }
+
+  describe "#parent" do
+    it "returns parent node" do
+      child = node.children.first
+      expect(child.parent).to eq(node)
+    end
+  end
+
+  describe "#document" do
+    it "returns document" do
+      expect(node.document).to eq(doc)
+    end
+  end
+
+  describe "#to_xml" do
+    it "serializes node to XML" do
+      expect(node.to_xml).to include("<root>")
+      expect(node.to_xml).to include("<child>")
+    end
+  end
+
+  describe "#remove" do
+    it "removes node from parent" do
+      child = node.children.first
+      child.remove
+      expect(node.children).to be_empty
+    end
+  end
+end

data/spec/moxml/processing_instruction_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::ProcessingInstruction do
+  let(:context) { Moxml.new }
+  let(:doc) do
+    context.parse('<?xml version="1.0"?><?xml-stylesheet type="text/xsl" href="style.xsl"?><root/>')
+  end
+
+  describe "#target" do
+    it "returns PI target" do
+      pi = doc.children.find { |n| n.is_a?(described_class) }
+      expect(pi.target).to eq("xml-stylesheet")
+    end
+  end
+
+  describe "#content" do
+    it "returns PI content" do
+      pi = doc.children.find { |n| n.is_a?(described_class) }
+      expect(pi.content).to include("type=")
+      expect(pi.content).to include("href=")
+    end
+  end
+
+  describe "creation" do
+    it "creates a processing instruction" do
+      pi = doc.create_processing_instruction("target", "content")
+      expect(pi).to be_a(described_class)
+      expect(pi.target).to eq("target")
+      expect(pi.content).to eq("content")
+    end
+  end
+end