rxerces 0.5.0 → 0.6.1

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;
@@ -465,17 +608,103 @@ static VALUE document_create_element(VALUE self, VALUE name) {
     return Qnil;
 }
 
+// document.children - returns all children (elements, text, comments, etc.)
+static VALUE document_children(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    VALUE children = rb_ary_new();
+
+    if (!wrapper->doc) {
+        return children;
+    }
+
+    DOMNodeList* child_nodes = wrapper->doc->getChildNodes();
+    XMLSize_t count = child_nodes->getLength();
+
+    for (XMLSize_t i = 0; i < count; i++) {
+        DOMNode* child = child_nodes->item(i);
+        rb_ary_push(children, wrap_node(child, self));
+    }
+
+    return children;
+}
+
+// document.element_children - returns only element children (no text nodes, comments, etc.)
+static VALUE document_element_children(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    VALUE children = rb_ary_new();
+
+    if (!wrapper->doc) {
+        return children;
+    }
+
+    DOMNodeList* child_nodes = wrapper->doc->getChildNodes();
+    XMLSize_t count = child_nodes->getLength();
+
+    for (XMLSize_t i = 0; i < count; i++) {
+        DOMNode* child = child_nodes->item(i);
+        if (child->getNodeType() == DOMNode::ELEMENT_NODE) {
+            rb_ary_push(children, wrap_node(child, self));
+        }
+    }
+
+    return children;
+}
+
+// document.first_element_child - returns first element child
+static VALUE document_first_element_child(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    if (!wrapper->doc) {
+        return Qnil;
+    }
+
+    DOMNodeList* child_nodes = wrapper->doc->getChildNodes();
+    XMLSize_t count = child_nodes->getLength();
+
+    for (XMLSize_t i = 0; i < count; i++) {
+        DOMNode* child = child_nodes->item(i);
+        if (child->getNodeType() == DOMNode::ELEMENT_NODE) {
+            return wrap_node(child, self);
+        }
+    }
+
+    return Qnil;
+}
+
+// document.last_element_child - returns last element child
+static VALUE document_last_element_child(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    if (!wrapper->doc) {
+        return Qnil;
+    }
+
+    DOMNodeList* child_nodes = wrapper->doc->getChildNodes();
+    XMLSize_t count = child_nodes->getLength();
+
+    // Search backwards for last element
+    for (XMLSize_t i = count; i > 0; i--) {
+        DOMNode* child = child_nodes->item(i - 1);
+        if (child->getNodeType() == DOMNode::ELEMENT_NODE) {
+            return wrap_node(child, self);
+        }
+    }
+
+    return Qnil;
+}
+
 #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 +829,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(),
@@ -643,6 +873,19 @@ static VALUE document_xpath(VALUE self, VALUE path) {
 #endif
 }
 
+// document.at_xpath(path) - returns first matching node or nil
+static VALUE document_at_xpath(VALUE self, VALUE path) {
+    VALUE nodeset = document_xpath(self, path);
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(nodeset, NodeSetWrapper, &nodeset_type, wrapper);
+
+    if (RARRAY_LEN(wrapper->nodes_array) == 0) {
+        return Qnil;
+    }
+
+    return rb_ary_entry(wrapper->nodes_array, 0);
+}
+
 // document.css(selector) - Convert CSS to XPath and execute
 static VALUE document_css(VALUE self, VALUE selector) {
     Check_Type(selector, T_STRING);
@@ -840,7 +1083,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 +1102,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 +1129,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 +1149,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 +1164,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 +1188,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();
 
@@ -959,6 +1208,65 @@ static VALUE node_element_children(VALUE self) {
     return children;
 }
 
+// node.first_element_child - returns first element child
+static VALUE node_first_element_child(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    VALUE doc_ref = wrapper->doc_ref;
+    DOMNodeList* child_nodes = wrapper->node->getChildNodes();
+    XMLSize_t count = child_nodes->getLength();
+
+    for (XMLSize_t i = 0; i < count; i++) {
+        DOMNode* child = child_nodes->item(i);
+        if (child->getNodeType() == DOMNode::ELEMENT_NODE) {
+            return wrap_node(child, doc_ref);
+        }
+    }
+
+    return Qnil;
+}
+
+// node.last_element_child - returns last element child
+static VALUE node_last_element_child(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    VALUE doc_ref = wrapper->doc_ref;
+    DOMNodeList* child_nodes = wrapper->node->getChildNodes();
+    XMLSize_t count = child_nodes->getLength();
+
+    // Search backwards for last element
+    for (XMLSize_t i = count; i > 0; i--) {
+        DOMNode* child = child_nodes->item(i - 1);
+        if (child->getNodeType() == DOMNode::ELEMENT_NODE) {
+            return wrap_node(child, doc_ref);
+        }
+    }
+
+    return Qnil;
+}
+
+// node.document - returns the document that owns this node
+static VALUE node_document(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    return wrapper->doc_ref;
+}
+
 // node.parent
 static VALUE node_parent(VALUE self) {
     NodeWrapper* wrapper;
@@ -973,7 +1281,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 +1299,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 +1408,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 +1426,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 +1439,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 +1463,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 +1493,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 +1508,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 +1525,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 +1584,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 +1750,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 +1766,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 +2249,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,16 +2422,24 @@ 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);
     rb_define_method(rb_cDocument, "xpath", RUBY_METHOD_FUNC(document_xpath), 1);
+    rb_define_method(rb_cDocument, "at_xpath", RUBY_METHOD_FUNC(document_at_xpath), 1);
+    rb_define_alias(rb_cDocument, "at", "at_xpath");
     rb_define_method(rb_cDocument, "css", RUBY_METHOD_FUNC(document_css), 1);
     rb_define_method(rb_cDocument, "at_css", RUBY_METHOD_FUNC(document_at_css), 1);
     rb_define_method(rb_cDocument, "encoding", RUBY_METHOD_FUNC(document_encoding), 0);
     rb_define_method(rb_cDocument, "text", RUBY_METHOD_FUNC(document_text), 0);
     rb_define_alias(rb_cDocument, "content", "text");
     rb_define_method(rb_cDocument, "create_element", RUBY_METHOD_FUNC(document_create_element), 1);
+    rb_define_method(rb_cDocument, "children", RUBY_METHOD_FUNC(document_children), 0);
+    rb_define_method(rb_cDocument, "element_children", RUBY_METHOD_FUNC(document_element_children), 0);
+    rb_define_alias(rb_cDocument, "elements", "element_children");
+    rb_define_method(rb_cDocument, "first_element_child", RUBY_METHOD_FUNC(document_first_element_child), 0);
+    rb_define_method(rb_cDocument, "last_element_child", RUBY_METHOD_FUNC(document_last_element_child), 0);
 
     rb_cNode = rb_define_class_under(rb_mXML, "Node", rb_cObject);
     rb_undef_alloc_func(rb_cNode);
@@ -2131,6 +2458,9 @@ static VALUE document_validate(VALUE self, VALUE rb_schema) {
     rb_define_method(rb_cNode, "children", RUBY_METHOD_FUNC(node_children), 0);
     rb_define_method(rb_cNode, "element_children", RUBY_METHOD_FUNC(node_element_children), 0);
     rb_define_alias(rb_cNode, "elements", "element_children");
+    rb_define_method(rb_cNode, "first_element_child", RUBY_METHOD_FUNC(node_first_element_child), 0);
+    rb_define_method(rb_cNode, "last_element_child", RUBY_METHOD_FUNC(node_last_element_child), 0);
+    rb_define_method(rb_cNode, "document", RUBY_METHOD_FUNC(node_document), 0);
     rb_define_method(rb_cNode, "parent", RUBY_METHOD_FUNC(node_parent), 0);
     rb_define_method(rb_cNode, "ancestors", RUBY_METHOD_FUNC(node_ancestors), -1);
     rb_define_method(rb_cNode, "attributes", RUBY_METHOD_FUNC(node_attributes), 0);
@@ -2182,4 +2512,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);
 }