rxerces 0.5.0 → 0.6.0

data/ext/rxerces/rxerces.cpp

@@ -57,6 +57,41 @@ static VALUE node_css(VALUE self, VALUE selector);
 static VALUE node_xpath(VALUE self, VALUE path);
 static VALUE document_xpath(VALUE self, VALUE path);
 
+// Initialize Xerces (and Xalan if available) exactly once
+static void ensure_xerces_initialized() {
+    if (xerces_initialized) {
+        return;
+    }
+
+    try {
+        XMLPlatformUtils::Initialize();
+#ifdef HAVE_XALAN
+        XPathEvaluator::initialize();
+        xalan_initialized = true;
+#endif
+        xerces_initialized = true;
+    } catch (const XMLException& e) {
+        char* message = XMLString::transcode(e.getMessage());
+        std::string error_msg = std::string("Xerces initialization failed: ") + message;
+        XMLString::release(&message);
+        rb_raise(rb_eRuntimeError, "%s", error_msg.c_str());
+    }
+}
+
+// Cleanup function called at exit
+static void cleanup_xerces() {
+#ifdef HAVE_XALAN
+    if (xalan_initialized) {
+        XPathEvaluator::terminate();
+        xalan_initialized = false;
+    }
+#endif
+    if (xerces_initialized) {
+        XMLPlatformUtils::Terminate();
+        xerces_initialized = false;
+    }
+}
+
 // Helper class to manage XMLCh strings
 class XStr {
 public:
@@ -103,6 +138,7 @@ private:
 typedef struct {
     DOMDocument* doc;
     XercesDOMParser* parser;
+    std::vector<std::string>* parse_errors;
 } DocumentWrapper;
 
 // Wrapper structure for DOMNode
@@ -128,19 +164,34 @@ public:
 
     void warning(const SAXParseException& e) {
         char* msg = XMLString::transcode(e.getMessage());
-        errors.push_back(std::string("Warning: ") + msg);
+        char buffer[512];
+        snprintf(buffer, sizeof(buffer), "Warning at line %lu, column %lu: %s",
+                 (unsigned long)e.getLineNumber(),
+                 (unsigned long)e.getColumnNumber(),
+                 msg);
+        errors.push_back(buffer);
         XMLString::release(&msg);
     }
 
     void error(const SAXParseException& e) {
         char* msg = XMLString::transcode(e.getMessage());
-        errors.push_back(std::string("Error: ") + msg);
+        char buffer[512];
+        snprintf(buffer, sizeof(buffer), "Error at line %lu, column %lu: %s",
+                 (unsigned long)e.getLineNumber(),
+                 (unsigned long)e.getColumnNumber(),
+                 msg);
+        errors.push_back(buffer);
         XMLString::release(&msg);
     }
 
     void fatalError(const SAXParseException& e) {
         char* msg = XMLString::transcode(e.getMessage());
-        errors.push_back(std::string("Fatal: ") + msg);
+        char buffer[512];
+        snprintf(buffer, sizeof(buffer), "Fatal error at line %lu, column %lu: %s",
+                 (unsigned long)e.getLineNumber(),
+                 (unsigned long)e.getColumnNumber(),
+                 msg);
+        errors.push_back(buffer);
         XMLString::release(&msg);
     }
 
@@ -149,6 +200,55 @@ public:
     }
 };
 
+// Error handler for parsing - stores errors but doesn't throw
+class ParseErrorHandler : public ErrorHandler {
+public:
+    std::vector<std::string>* errors;
+    bool has_fatal;
+
+    ParseErrorHandler(std::vector<std::string>* error_vec)
+        : errors(error_vec), has_fatal(false) {}
+
+    void warning(const SAXParseException& e) {
+        char* msg = XMLString::transcode(e.getMessage());
+        char buffer[512];
+        snprintf(buffer, sizeof(buffer), "Warning at line %lu, column %lu: %s",
+                 (unsigned long)e.getLineNumber(),
+                 (unsigned long)e.getColumnNumber(),
+                 msg);
+        errors->push_back(buffer);
+        XMLString::release(&msg);
+    }
+
+    void error(const SAXParseException& e) {
+        char* msg = XMLString::transcode(e.getMessage());
+        char buffer[512];
+        snprintf(buffer, sizeof(buffer), "Error at line %lu, column %lu: %s",
+                 (unsigned long)e.getLineNumber(),
+                 (unsigned long)e.getColumnNumber(),
+                 msg);
+        errors->push_back(buffer);
+        XMLString::release(&msg);
+    }
+
+    void fatalError(const SAXParseException& e) {
+        has_fatal = true;
+        char* msg = XMLString::transcode(e.getMessage());
+        char buffer[512];
+        snprintf(buffer, sizeof(buffer), "Fatal error at line %lu, column %lu: %s",
+                 (unsigned long)e.getLineNumber(),
+                 (unsigned long)e.getColumnNumber(),
+                 msg);
+        errors->push_back(buffer);
+        XMLString::release(&msg);
+    }
+
+    void resetErrors() {
+        errors->clear();
+        has_fatal = false;
+    }
+};
+
 // Memory management functions
 static void document_free(void* ptr) {
     DocumentWrapper* wrapper = (DocumentWrapper*)ptr;
@@ -156,6 +256,9 @@ static void document_free(void* ptr) {
         if (wrapper->parser) {
             delete wrapper->parser;
         }
+        if (wrapper->parse_errors) {
+            delete wrapper->parse_errors;
+        }
         // Document is owned by parser, so don't delete it separately
         xfree(wrapper);
     }
@@ -169,6 +272,13 @@ static void node_free(void* ptr) {
     }
 }
 
+static void node_mark(void* ptr) {
+    NodeWrapper* wrapper = (NodeWrapper*)ptr;
+    if (wrapper) {
+        rb_gc_mark(wrapper->doc_ref);
+    }
+}
+
 static void nodeset_free(void* ptr) {
     NodeSetWrapper* wrapper = (NodeSetWrapper*)ptr;
     if (wrapper) {
@@ -176,6 +286,13 @@ static void nodeset_free(void* ptr) {
     }
 }
 
+static void nodeset_mark(void* ptr) {
+    NodeSetWrapper* wrapper = (NodeSetWrapper*)ptr;
+    if (wrapper) {
+        rb_gc_mark(wrapper->nodes_array);
+    }
+}
+
 static void schema_free(void* ptr) {
     SchemaWrapper* wrapper = (SchemaWrapper*)ptr;
     if (wrapper) {
@@ -211,14 +328,14 @@ static const rb_data_type_t document_type = {
 
 static const rb_data_type_t node_type = {
     "RXerces::XML::Node",
-    {0, node_free, node_size},
+    {node_mark, node_free, node_size},
     0, 0,
     RUBY_TYPED_FREE_IMMEDIATELY
 };
 
 static const rb_data_type_t nodeset_type = {
     "RXerces::XML::NodeSet",
-    {0, nodeset_free, nodeset_size},
+    {nodeset_mark, nodeset_free, nodeset_size},
     0, 0,
     RUBY_TYPED_FREE_IMMEDIATELY
 };
@@ -254,22 +371,12 @@ static VALUE wrap_node(DOMNode* node, VALUE doc_ref) {
             break;
     }
 
-    // Keep reference to document to prevent GC
-    rb_iv_set(rb_node, "@document", doc_ref);
-
     return rb_node;
 }
 
 // RXerces::XML::Document.parse(string)
 static VALUE document_parse(VALUE klass, VALUE str) {
-    if (!xerces_initialized) {
-        try {
-            XMLPlatformUtils::Initialize();
-            xerces_initialized = true;
-        } catch (const XMLException& e) {
-            rb_raise(rb_eRuntimeError, "Xerces initialization failed");
-        }
-    }
+    ensure_xerces_initialized();
 
     Check_Type(str, T_STRING);
     const char* xml_str = StringValueCStr(str);
@@ -279,6 +386,11 @@ static VALUE document_parse(VALUE klass, VALUE str) {
     parser->setDoNamespaces(true);
     parser->setDoSchema(false);
 
+    // Set up error handler to capture parse errors
+    std::vector<std::string>* parse_errors = new std::vector<std::string>();
+    ParseErrorHandler error_handler(parse_errors);
+    parser->setErrorHandler(&error_handler);
+
     try {
         MemBufInputSource input((const XMLByte*)xml_str, strlen(xml_str), "memory");
         parser->parse(input);
@@ -288,18 +400,33 @@ static VALUE document_parse(VALUE klass, VALUE str) {
         DocumentWrapper* wrapper = ALLOC(DocumentWrapper);
         wrapper->doc = doc;
         wrapper->parser = parser;
+        wrapper->parse_errors = parse_errors;
 
         VALUE rb_doc = TypedData_Wrap_Struct(rb_cDocument, &document_type, wrapper);
+
+        // If there were fatal errors, raise an exception with details
+        if (error_handler.has_fatal && !parse_errors->empty()) {
+            std::string all_errors;
+            for (const auto& err : *parse_errors) {
+                if (!all_errors.empty()) all_errors += "\n";
+                all_errors += err;
+            }
+            rb_raise(rb_eRuntimeError, "XML parsing failed:\n%s", all_errors.c_str());
+        }
+
         return rb_doc;
     } catch (const XMLException& e) {
         CharStr message(e.getMessage());
+        delete parse_errors;
         delete parser;
         rb_raise(rb_eRuntimeError, "XML parsing error: %s", message.localForm());
     } catch (const DOMException& e) {
         CharStr message(e.getMessage());
+        delete parse_errors;
         delete parser;
         rb_raise(rb_eRuntimeError, "DOM error: %s", message.localForm());
     } catch (...) {
+        delete parse_errors;
         delete parser;
         rb_raise(rb_eRuntimeError, "Unknown XML parsing error");
     }
@@ -307,6 +434,22 @@ static VALUE document_parse(VALUE klass, VALUE str) {
     return Qnil;
 }
 
+// document.errors - returns array of parse errors (warnings and errors)
+static VALUE document_errors(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    VALUE errors_array = rb_ary_new();
+
+    if (wrapper->parse_errors) {
+        for (const auto& error : *wrapper->parse_errors) {
+            rb_ary_push(errors_array, rb_str_new2(error.c_str()));
+        }
+    }
+
+    return errors_array;
+}
+
 // document.root
 static VALUE document_root(VALUE self) {
     DocumentWrapper* wrapper;
@@ -468,14 +611,9 @@ static VALUE document_create_element(VALUE self, VALUE name) {
 #ifdef HAVE_XALAN
 // Helper function to execute XPath using Xalan for full XPath 1.0 support
 static VALUE execute_xpath_with_xalan(DOMNode* context_node, const char* xpath_str, VALUE doc_ref) {
-    try {
-        // Initialize Xalan if needed
-        if (!xalan_initialized) {
-            XPathEvaluator::initialize();
-            XMLPlatformUtils::Initialize();
-            xalan_initialized = true;
-        }
+    ensure_xerces_initialized();
 
+    try {
         // Get the document
         DOMDocument* domDoc = context_node->getOwnerDocument();
         if (!domDoc && context_node->getNodeType() == DOMNode::DOCUMENT_NODE) {
@@ -600,8 +738,9 @@ static VALUE document_xpath(VALUE self, VALUE path) {
         }
 
         DOMXPathNSResolver* resolver = doc_wrapper->doc->createNSResolver(root);
+        XStr xpath_xstr(xpath_str);
         DOMXPathExpression* expression = doc_wrapper->doc->createExpression(
-            XStr(xpath_str).unicodeForm(), resolver);
+            xpath_xstr.unicodeForm(), resolver);
 
         DOMXPathResult* result = expression->evaluate(
             doc_wrapper->doc->getDocumentElement(),
@@ -840,7 +979,8 @@ static VALUE node_text_set(VALUE self, VALUE text) {
     Check_Type(text, T_STRING);
     const char* text_str = StringValueCStr(text);
 
-    wrapper->node->setTextContent(XStr(text_str).unicodeForm());
+    XStr text_xstr(text_str);
+    wrapper->node->setTextContent(text_xstr.unicodeForm());
 
     return text;
 }
@@ -858,7 +998,8 @@ static VALUE node_get_attribute(VALUE self, VALUE attr_name) {
     const char* attr_str = StringValueCStr(attr_name);
 
     DOMElement* element = dynamic_cast<DOMElement*>(wrapper->node);
-    const XMLCh* value = element->getAttribute(XStr(attr_str).unicodeForm());
+    XStr attr_xstr(attr_str);
+    const XMLCh* value = element->getAttribute(attr_xstr.unicodeForm());
 
     if (!value || XMLString::stringLen(value) == 0) {
         return Qnil;
@@ -884,7 +1025,9 @@ static VALUE node_set_attribute(VALUE self, VALUE attr_name, VALUE attr_value) {
     const char* value_str = StringValueCStr(attr_value);
 
     DOMElement* element = dynamic_cast<DOMElement*>(wrapper->node);
-    element->setAttribute(XStr(attr_str).unicodeForm(), XStr(value_str).unicodeForm());
+    XStr attr_xstr(attr_str);
+    XStr value_xstr(value_str);
+    element->setAttribute(attr_xstr.unicodeForm(), value_xstr.unicodeForm());
 
     return attr_value;
 }
@@ -902,7 +1045,8 @@ static VALUE node_has_attribute_p(VALUE self, VALUE attr_name) {
     const char* attr_str = StringValueCStr(attr_name);
 
     DOMElement* element = dynamic_cast<DOMElement*>(wrapper->node);
-    const XMLCh* value = element->getAttribute(XStr(attr_str).unicodeForm());
+    XStr attr_xstr(attr_str);
+    const XMLCh* value = element->getAttribute(attr_xstr.unicodeForm());
 
     if (!value || XMLString::stringLen(value) == 0) {
         return Qfalse;
@@ -916,13 +1060,14 @@ static VALUE node_children(VALUE self) {
     NodeWrapper* wrapper;
     TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
 
-    VALUE doc_ref = rb_iv_get(self, "@document");
     VALUE children = rb_ary_new();
 
     if (!wrapper->node) {
         return children;
     }
 
+    VALUE doc_ref = wrapper->doc_ref;
+
     DOMNodeList* child_nodes = wrapper->node->getChildNodes();
     XMLSize_t count = child_nodes->getLength();
 
@@ -939,13 +1084,13 @@ static VALUE node_element_children(VALUE self) {
     NodeWrapper* wrapper;
     TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
 
-    VALUE doc_ref = rb_iv_get(self, "@document");
     VALUE children = rb_ary_new();
 
     if (!wrapper->node) {
         return children;
     }
 
+    VALUE doc_ref = wrapper->doc_ref;
     DOMNodeList* child_nodes = wrapper->node->getChildNodes();
     XMLSize_t count = child_nodes->getLength();
 
@@ -973,7 +1118,7 @@ static VALUE node_parent(VALUE self) {
         return Qnil;
     }
 
-    VALUE doc_ref = rb_iv_get(self, "@document");
+    VALUE doc_ref = wrapper->doc_ref;
     return wrap_node(parent, doc_ref);
 }
 
@@ -991,7 +1136,7 @@ static VALUE node_ancestors(int argc, VALUE* argv, VALUE self) {
         return ancestors;
     }
 
-    VALUE doc_ref = rb_iv_get(self, "@document");
+    VALUE doc_ref = wrapper->doc_ref;
     DOMNode* current = wrapper->node->getParentNode();
 
     // Walk up the tree, collecting all ancestors
@@ -1100,7 +1245,7 @@ static VALUE node_next_sibling(VALUE self) {
         return Qnil;
     }
 
-    VALUE doc_ref = rb_iv_get(self, "@document");
+    VALUE doc_ref = wrapper->doc_ref;
     return wrap_node(next, doc_ref);
 }
 
@@ -1118,7 +1263,7 @@ static VALUE node_previous_sibling(VALUE self) {
         return Qnil;
     }
 
-    VALUE doc_ref = rb_iv_get(self, "@document");
+    VALUE doc_ref = wrapper->doc_ref;
     return wrap_node(prev, doc_ref);
 }
 
@@ -1131,7 +1276,7 @@ static VALUE node_next_element(VALUE self) {
         return Qnil;
     }
 
-    VALUE doc_ref = rb_iv_get(self, "@document");
+    VALUE doc_ref = wrapper->doc_ref;
     DOMNode* next = wrapper->node->getNextSibling();
 
     // Skip non-element nodes
@@ -1155,7 +1300,7 @@ static VALUE node_previous_element(VALUE self) {
         return Qnil;
     }
 
-    VALUE doc_ref = rb_iv_get(self, "@document");
+    VALUE doc_ref = wrapper->doc_ref;
     DOMNode* prev = wrapper->node->getPreviousSibling();
 
     // Skip non-element nodes
@@ -1185,6 +1330,7 @@ static VALUE node_add_child(VALUE self, VALUE child) {
     }
 
     DOMNode* child_node = NULL;
+    bool needs_import = false;
 
     // Check if child is a string or a node
     if (TYPE(child) == T_STRING) {
@@ -1199,6 +1345,13 @@ static VALUE node_add_child(VALUE self, VALUE child) {
         if (rb_obj_is_kind_of(child, rb_cNode)) {
             TypedData_Get_Struct(child, NodeWrapper, &node_type, child_wrapper);
             child_node = child_wrapper->node;
+
+            // Check if child belongs to a different document
+            DOMDocument* child_doc = child_node->getOwnerDocument();
+            if (child_doc && child_doc != doc) {
+                rb_raise(rb_eRuntimeError,
+                    "Node belongs to a different document. Use importNode to adopt nodes from other documents.");
+            }
         } else {
             rb_raise(rb_eTypeError, "Argument must be a String or Node");
         }
@@ -1209,12 +1362,24 @@ static VALUE node_add_child(VALUE self, VALUE child) {
     }
 
     try {
+        // appendChild will automatically detach the node from its current parent if it has one
         wrapper->node->appendChild(child_node);
     } catch (const DOMException& e) {
         char* message = XMLString::transcode(e.getMessage());
         VALUE rb_error = rb_str_new_cstr(message);
         XMLString::release(&message);
-        rb_raise(rb_eRuntimeError, "Failed to add child: %s", StringValueCStr(rb_error));
+
+        // Provide more context for common errors
+        unsigned short code = e.code;
+        if (code == DOMException::WRONG_DOCUMENT_ERR) {
+            rb_raise(rb_eRuntimeError, "Node belongs to a different document: %s", StringValueCStr(rb_error));
+        } else if (code == DOMException::HIERARCHY_REQUEST_ERR) {
+            rb_raise(rb_eRuntimeError, "Invalid hierarchy: cannot add this node as a child: %s", StringValueCStr(rb_error));
+        } else if (code == DOMException::NO_MODIFICATION_ALLOWED_ERR) {
+            rb_raise(rb_eRuntimeError, "Node is read-only: %s", StringValueCStr(rb_error));
+        } else {
+            rb_raise(rb_eRuntimeError, "Failed to add child: %s", StringValueCStr(rb_error));
+        }
     }
 
     return child;
@@ -1256,7 +1421,8 @@ static VALUE node_inner_html(VALUE self) {
     }
 
     try {
-        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(XStr("LS").unicodeForm());
+        XStr ls_name("LS");
+        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(ls_name.unicodeForm());
         DOMLSSerializer* serializer = ((DOMImplementationLS*)impl)->createLSSerializer();
 
         // Build a string by serializing each child
@@ -1421,7 +1587,7 @@ static VALUE node_xpath(VALUE self, VALUE path) {
 
     Check_Type(path, T_STRING);
     const char* xpath_str = StringValueCStr(path);
-    VALUE doc_ref = rb_iv_get(self, "@document");
+    VALUE doc_ref = node_wrapper->doc_ref;
 
 #ifdef HAVE_XALAN
     // Use Xalan for full XPath 1.0 support
@@ -1437,8 +1603,9 @@ static VALUE node_xpath(VALUE self, VALUE path) {
         }
 
         DOMXPathNSResolver* resolver = doc->createNSResolver(node_wrapper->node);
+        XStr xpath_xstr(xpath_str);
         DOMXPathExpression* expression = doc->createExpression(
-            XStr(xpath_str).unicodeForm(), resolver);
+            xpath_xstr.unicodeForm(), resolver);
 
         DOMXPathResult* result = expression->evaluate(
             node_wrapper->node,
@@ -1919,18 +2086,7 @@ static VALUE schema_from_document(int argc, VALUE* argv, VALUE klass) {
     VALUE schema_source;
     rb_scan_args(argc, argv, "1", &schema_source);
 
-    // Ensure Xerces is initialized
-    if (!xerces_initialized) {
-        try {
-            XMLPlatformUtils::Initialize();
-            xerces_initialized = true;
-        } catch (const XMLException& e) {
-            char* message = XMLString::transcode(e.getMessage());
-            VALUE rb_error = rb_str_new_cstr(message);
-            XMLString::release(&message);
-            rb_raise(rb_eRuntimeError, "Failed to initialize Xerces-C: %s", StringValueCStr(rb_error));
-        }
-    }
+    ensure_xerces_initialized();
 
     try {
         SchemaWrapper* wrapper = ALLOC(SchemaWrapper);
@@ -2103,6 +2259,7 @@ static VALUE document_validate(VALUE self, VALUE rb_schema) {
     rb_undef_alloc_func(rb_cDocument);
     rb_define_singleton_method(rb_cDocument, "parse", RUBY_METHOD_FUNC(document_parse), 1);
     rb_define_method(rb_cDocument, "root", RUBY_METHOD_FUNC(document_root), 0);
+    rb_define_method(rb_cDocument, "errors", RUBY_METHOD_FUNC(document_errors), 0);
     rb_define_method(rb_cDocument, "to_s", RUBY_METHOD_FUNC(document_to_s), 0);
     rb_define_alias(rb_cDocument, "to_xml", "to_s");
     rb_define_method(rb_cDocument, "inspect", RUBY_METHOD_FUNC(document_inspect), 0);
@@ -2182,4 +2339,7 @@ static VALUE document_validate(VALUE self, VALUE rb_schema) {
     rb_define_singleton_method(rb_cSchema, "from_string", RUBY_METHOD_FUNC(schema_from_document), -1);
 
     rb_define_method(rb_cDocument, "validate", RUBY_METHOD_FUNC(document_validate), 1);
+
+    // Register cleanup handler
+    atexit(cleanup_xerces);
 }

data/lib/rxerces/version.rb

@@ -1,3 +1,3 @@
 module RXerces
-  VERSION = "0.5.0".freeze
+  VERSION = "0.6.0".freeze
 end

data/rxerces.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name        = "rxerces"
-  spec.version     = "0.5.0"
+  spec.version     = "0.6.0"
   spec.author      = "Daniel J. Berger"
   spec.email       = "djberg96@gmail.com"
   spec.cert_chain  = ["certs/djberg96_pub.pem"]

data/spec/document_spec.rb

@@ -176,4 +176,62 @@ RSpec.describe RXerces::XML::Document do
       expect(result.first.text).to eq('New content')
     end
   end
+
+  describe "#errors" do
+    it "returns empty array for valid XML" do
+      doc = RXerces::XML::Document.parse(simple_xml)
+      expect(doc.errors).to eq([])
+    end
+
+    it "returns empty array for complex valid XML" do
+      doc = RXerces::XML::Document.parse(complex_xml)
+      expect(doc.errors).to eq([])
+    end
+
+    context "with malformed XML" do
+      it "raises error and provides line/column information for unclosed tags" do
+        expect {
+          RXerces::XML::Document.parse('<root><item>test</root>')
+        }.to raise_error(RuntimeError, /Fatal error at line \d+, column \d+/)
+      end
+
+      it "raises error with detailed message for multiple errors" do
+        expect {
+          RXerces::XML::Document.parse('<root><item>test</item><unclosed>')
+        }.to raise_error(RuntimeError, /Fatal error at line/)
+      end
+
+      it "raises error for completely invalid XML" do
+        expect {
+          RXerces::XML::Document.parse('not xml at all')
+        }.to raise_error(RuntimeError, /Fatal error at line/)
+      end
+
+      it "raises error for mismatched tags" do
+        expect {
+          RXerces::XML::Document.parse('<root><item>test</other></root>')
+        }.to raise_error(RuntimeError, /Fatal error at line/)
+      end
+    end
+
+    context "error message format" do
+      it "includes line number in error message" do
+        expect {
+          RXerces::XML::Document.parse('<root><bad>')
+        }.to raise_error(RuntimeError, /line \d+/)
+      end
+
+      it "includes column number in error message" do
+        expect {
+          RXerces::XML::Document.parse('<root><bad>')
+        }.to raise_error(RuntimeError, /column \d+/)
+      end
+
+      it "describes the error type" do
+        expect {
+          RXerces::XML::Document.parse('<root><item>test</root>')
+        }.to raise_error(RuntimeError, /expected end of tag/)
+      end
+    end
+  end
 end

data/spec/node_spec.rb

@@ -552,6 +552,63 @@ RSpec.describe RXerces::XML::Node do
       xml_output = simple_doc.to_s
       expect(xml_output).to include("Content")
     end
+
+    context "with nodes from different documents" do
+      it "raises error when adding node from different document" do
+        doc1 = RXerces::XML::Document.parse('<root><item>one</item></root>')
+        doc2 = RXerces::XML::Document.parse('<other><item>two</item></other>')
+
+        root1 = doc1.root
+        item2 = doc2.root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+
+        expect {
+          root1.add_child(item2)
+        }.to raise_error(RuntimeError, /belongs to a different document/)
+      end
+
+      it "provides helpful error message mentioning importNode" do
+        doc1 = RXerces::XML::Document.parse('<root></root>')
+        doc2 = RXerces::XML::Document.parse('<other><child/></other>')
+
+        expect {
+          doc1.root.add_child(doc2.root.children.first)
+        }.to raise_error(RuntimeError, /importNode/)
+      end
+    end
+
+    context "when child already has a parent" do
+      it "moves node from one parent to another (detaches automatically)" do
+        doc = RXerces::XML::Document.parse('<root><parent1><child>text</child></parent1><parent2/></root>')
+        parent1 = doc.xpath('//parent1').first
+        parent2 = doc.xpath('//parent2').first
+        child = doc.xpath('//child').first
+
+        # Verify initial state
+        expect(parent1.children.select { |n| n.is_a?(RXerces::XML::Element) }.length).to eq(1)
+        expect(parent2.children.select { |n| n.is_a?(RXerces::XML::Element) }.length).to eq(0)
+
+        # Move child from parent1 to parent2
+        parent2.add_child(child)
+
+        # Child should now be under parent2, not parent1
+        expect(parent1.children.select { |n| n.is_a?(RXerces::XML::Element) }.length).to eq(0)
+        expect(parent2.children.select { |n| n.is_a?(RXerces::XML::Element) }.length).to eq(1)
+        expect(doc.xpath('//parent2/child').length).to eq(1)
+        expect(doc.xpath('//parent1/child').length).to eq(0)
+      end
+
+      it "preserves node content when moving" do
+        doc = RXerces::XML::Document.parse('<root><a><item>content</item></a><b/></root>')
+        a = doc.xpath('//a').first
+        b = doc.xpath('//b').first
+        item = doc.xpath('//item').first
+
+        b.add_child(item)
+
+        expect(item.text).to eq('content')
+        expect(doc.xpath('//b/item').first.text).to eq('content')
+      end
+    end
   end
 
   describe "#remove" do