rxerces 0.1.0 → 0.3.0

data/ext/rxerces/rxerces.cpp

@@ -8,7 +8,10 @@
 #include <xercesc/util/XercesDefs.hpp>
 #include <xercesc/dom/DOMXPathResult.hpp>
 #include <xercesc/dom/DOMXPathExpression.hpp>
+#include <xercesc/sax/ErrorHandler.hpp>
+#include <xercesc/sax/SAXParseException.hpp>
 #include <sstream>
+#include <vector>
 
 using namespace xercesc;
 
@@ -19,6 +22,7 @@ VALUE rb_cNode;
 VALUE rb_cNodeSet;
 VALUE rb_cElement;
 VALUE rb_cText;
+VALUE rb_cSchema;
 
 // Xerces initialization flag
 static bool xerces_initialized = false;
@@ -82,6 +86,39 @@ typedef struct {
     VALUE nodes_array;
 } NodeSetWrapper;
 
+// Wrapper structure for Schema
+typedef struct {
+    std::string* schemaContent;
+} SchemaWrapper;
+
+// Error handler for schema validation
+class ValidationErrorHandler : public ErrorHandler {
+public:
+    std::vector<std::string> errors;
+
+    void warning(const SAXParseException& e) {
+        char* msg = XMLString::transcode(e.getMessage());
+        errors.push_back(std::string("Warning: ") + msg);
+        XMLString::release(&msg);
+    }
+
+    void error(const SAXParseException& e) {
+        char* msg = XMLString::transcode(e.getMessage());
+        errors.push_back(std::string("Error: ") + msg);
+        XMLString::release(&msg);
+    }
+
+    void fatalError(const SAXParseException& e) {
+        char* msg = XMLString::transcode(e.getMessage());
+        errors.push_back(std::string("Fatal: ") + msg);
+        XMLString::release(&msg);
+    }
+
+    void resetErrors() {
+        errors.clear();
+    }
+};
+
 // Memory management functions
 static void document_free(void* ptr) {
     DocumentWrapper* wrapper = (DocumentWrapper*)ptr;
@@ -109,6 +146,16 @@ static void nodeset_free(void* ptr) {
     }
 }
 
+static void schema_free(void* ptr) {
+    SchemaWrapper* wrapper = (SchemaWrapper*)ptr;
+    if (wrapper) {
+        if (wrapper->schemaContent) {
+            delete wrapper->schemaContent;
+        }
+        xfree(wrapper);
+    }
+}
+
 static size_t document_size(const void* ptr) {
     return sizeof(DocumentWrapper);
 }
@@ -121,6 +168,10 @@ static size_t nodeset_size(const void* ptr) {
     return sizeof(NodeSetWrapper);
 }
 
+static size_t schema_size(const void* ptr) {
+    return sizeof(SchemaWrapper);
+}
+
 static const rb_data_type_t document_type = {
     "RXerces::XML::Document",
     {0, document_free, document_size},
@@ -142,6 +193,13 @@ static const rb_data_type_t nodeset_type = {
     RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+static const rb_data_type_t schema_type = {
+    "RXerces::XML::Schema",
+    {0, schema_free, schema_size},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 // Helper to create Ruby Node object from DOMNode
 static VALUE wrap_node(DOMNode* node, VALUE doc_ref) {
     if (!node) {
@@ -261,6 +319,41 @@ static VALUE document_to_s(VALUE self) {
     return Qnil;
 }
 
+// document.create_element(name)
+static VALUE document_create_element(VALUE self, VALUE name) {
+    DocumentWrapper* doc_wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, doc_wrapper);
+
+    if (!doc_wrapper->doc) {
+        rb_raise(rb_eRuntimeError, "Cannot create element on null document");
+    }
+
+    Check_Type(name, T_STRING);
+    const char* element_name = StringValueCStr(name);
+
+    try {
+        XMLCh* element_name_xml = XMLString::transcode(element_name);
+        DOMElement* element = doc_wrapper->doc->createElement(element_name_xml);
+        XMLString::release(&element_name_xml);
+
+        if (!element) {
+            rb_raise(rb_eRuntimeError, "Failed to create element");
+        }
+
+        return wrap_node(element, self);
+
+    } 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 create element: %s", StringValueCStr(rb_error));
+    } catch (...) {
+        rb_raise(rb_eRuntimeError, "Unknown error creating element");
+    }
+
+    return Qnil;
+}
+
 // document.xpath(path)
 static VALUE document_xpath(VALUE self, VALUE path) {
     DocumentWrapper* doc_wrapper;
@@ -443,6 +536,335 @@ static VALUE node_children(VALUE self) {
     return children;
 }
 
+// node.parent
+static VALUE node_parent(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    DOMNode* parent = wrapper->node->getParentNode();
+    if (!parent) {
+        return Qnil;
+    }
+
+    VALUE doc_ref = rb_iv_get(self, "@document");
+    return wrap_node(parent, doc_ref);
+}
+
+// node.attributes - returns hash of all attributes (only for element nodes)
+static VALUE node_attributes(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node || wrapper->node->getNodeType() != DOMNode::ELEMENT_NODE) {
+        return rb_hash_new();
+    }
+
+    DOMElement* element = dynamic_cast<DOMElement*>(wrapper->node);
+    DOMNamedNodeMap* attributes = element->getAttributes();
+
+    if (!attributes) {
+        return rb_hash_new();
+    }
+
+    VALUE hash = rb_hash_new();
+    XMLSize_t length = attributes->getLength();
+
+    for (XMLSize_t i = 0; i < length; i++) {
+        DOMNode* attr = attributes->item(i);
+        if (attr) {
+            const XMLCh* name = attr->getNodeName();
+            const XMLCh* value = attr->getNodeValue();
+
+            CharStr attr_name(name);
+            CharStr attr_value(value);
+
+            rb_hash_aset(hash,
+                        rb_str_new_cstr(attr_name.localForm()),
+                        rb_str_new_cstr(attr_value.localForm()));
+        }
+    }
+
+    return hash;
+}
+
+// node.next_sibling
+static VALUE node_next_sibling(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    DOMNode* next = wrapper->node->getNextSibling();
+    if (!next) {
+        return Qnil;
+    }
+
+    VALUE doc_ref = rb_iv_get(self, "@document");
+    return wrap_node(next, doc_ref);
+}
+
+// node.previous_sibling
+static VALUE node_previous_sibling(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    DOMNode* prev = wrapper->node->getPreviousSibling();
+    if (!prev) {
+        return Qnil;
+    }
+
+    VALUE doc_ref = rb_iv_get(self, "@document");
+    return wrap_node(prev, doc_ref);
+}
+
+// node.add_child(node_or_string) - adds a child node
+static VALUE node_add_child(VALUE self, VALUE child) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        rb_raise(rb_eRuntimeError, "Cannot add child to null node");
+    }
+
+    DOMDocument* doc = wrapper->node->getOwnerDocument();
+    if (!doc) {
+        rb_raise(rb_eRuntimeError, "Node has no owner document");
+    }
+
+    DOMNode* child_node = NULL;
+
+    // Check if child is a string or a node
+    if (TYPE(child) == T_STRING) {
+        // Create a text node from the string
+        const char* text_str = StringValueCStr(child);
+        XMLCh* text_content = XMLString::transcode(text_str);
+        child_node = doc->createTextNode(text_content);
+        XMLString::release(&text_content);
+    } else {
+        // Assume it's a Node object
+        NodeWrapper* child_wrapper;
+        if (rb_obj_is_kind_of(child, rb_cNode)) {
+            TypedData_Get_Struct(child, NodeWrapper, &node_type, child_wrapper);
+            child_node = child_wrapper->node;
+        } else {
+            rb_raise(rb_eTypeError, "Argument must be a String or Node");
+        }
+    }
+
+    if (!child_node) {
+        rb_raise(rb_eRuntimeError, "Failed to create child node");
+    }
+
+    try {
+        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));
+    }
+
+    return child;
+}
+
+// node.remove / node.unlink - removes node from its parent
+static VALUE node_remove(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        rb_raise(rb_eRuntimeError, "Cannot remove null node");
+    }
+
+    DOMNode* parent = wrapper->node->getParentNode();
+    if (!parent) {
+        rb_raise(rb_eRuntimeError, "Node has no parent to remove from");
+    }
+
+    try {
+        parent->removeChild(wrapper->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 remove node: %s", StringValueCStr(rb_error));
+    }
+
+    return self;
+}
+
+// node.inner_html / node.inner_xml - returns XML content of children
+static VALUE node_inner_html(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return rb_str_new_cstr("");
+    }
+
+    try {
+        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(XStr("LS").unicodeForm());
+        DOMLSSerializer* serializer = ((DOMImplementationLS*)impl)->createLSSerializer();
+
+        // Build a string by serializing each child
+        std::string result;
+        DOMNodeList* children = wrapper->node->getChildNodes();
+        XMLSize_t count = children->getLength();
+
+        for (XMLSize_t i = 0; i < count; i++) {
+            DOMNode* child = children->item(i);
+            XMLCh* xml_str = serializer->writeToString(child);
+            CharStr utf8_str(xml_str);
+            result += utf8_str.localForm();
+            XMLString::release(&xml_str);
+        }
+
+        serializer->release();
+        return rb_str_new_cstr(result.c_str());
+    } 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 serialize inner content: %s", StringValueCStr(rb_error));
+    } catch (...) {
+        rb_raise(rb_eRuntimeError, "Failed to serialize inner content");
+    }
+
+    return rb_str_new_cstr("");
+}
+
+// node.path - returns XPath to the node
+static VALUE node_path(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return rb_str_new_cstr("");
+    }
+
+    std::string path = "";
+    DOMNode* current = wrapper->node;
+
+    // Build path from current node to root
+    while (current && current->getNodeType() != DOMNode::DOCUMENT_NODE) {
+        std::string segment = "";
+
+        if (current->getNodeType() == DOMNode::ELEMENT_NODE) {
+            CharStr name(current->getNodeName());
+            segment = std::string(name.localForm());
+
+            // Count position among siblings with same name
+            int position = 1;
+            DOMNode* sibling = current->getPreviousSibling();
+            while (sibling) {
+                if (sibling->getNodeType() == DOMNode::ELEMENT_NODE &&
+                    XMLString::equals(sibling->getNodeName(), current->getNodeName())) {
+                    position++;
+                }
+                sibling = sibling->getPreviousSibling();
+            }
+
+            // Add position predicate
+            segment += "[" + std::to_string(position) + "]";
+            path = "/" + segment + path;
+        } else if (current->getNodeType() == DOMNode::TEXT_NODE) {
+            // Count position among text node siblings
+            int position = 1;
+            DOMNode* sibling = current->getPreviousSibling();
+            while (sibling) {
+                if (sibling->getNodeType() == DOMNode::TEXT_NODE) {
+                    position++;
+                }
+                sibling = sibling->getPreviousSibling();
+            }
+            path = "/text()[" + std::to_string(position) + "]" + path;
+        }
+
+        current = current->getParentNode();
+    }
+
+    return rb_str_new_cstr(path.c_str());
+}
+
+// node.blank? - returns true if node has no meaningful content
+static VALUE node_blank_p(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qtrue;
+    }
+
+    // Text nodes are blank if they contain only whitespace
+    if (wrapper->node->getNodeType() == DOMNode::TEXT_NODE) {
+        const XMLCh* text_content = wrapper->node->getNodeValue();
+        if (!text_content) {
+            return Qtrue;
+        }
+
+        // Check if text contains only whitespace
+        CharStr utf8_text(text_content);
+        const char* str = utf8_text.localForm();
+        while (*str) {
+            if (!isspace((unsigned char)*str)) {
+                return Qfalse;
+            }
+            str++;
+        }
+        return Qtrue;
+    }
+
+    // Element nodes are blank if they have no child elements and no non-blank text
+    if (wrapper->node->getNodeType() == DOMNode::ELEMENT_NODE) {
+        DOMNodeList* children = wrapper->node->getChildNodes();
+        XMLSize_t count = children->getLength();
+
+        if (count == 0) {
+            return Qtrue;
+        }
+
+        // Check if all children are blank text nodes
+        for (XMLSize_t i = 0; i < count; i++) {
+            DOMNode* child = children->item(i);
+
+            // If there's an element child, not blank
+            if (child->getNodeType() == DOMNode::ELEMENT_NODE) {
+                return Qfalse;
+            }
+
+            // If there's a non-whitespace text node, not blank
+            if (child->getNodeType() == DOMNode::TEXT_NODE) {
+                const XMLCh* text_content = child->getNodeValue();
+                if (text_content) {
+                    CharStr utf8_text(text_content);
+                    const char* str = utf8_text.localForm();
+                    while (*str) {
+                        if (!isspace((unsigned char)*str)) {
+                            return Qfalse;
+                        }
+                        str++;
+                    }
+                }
+            }
+        }
+
+        return Qtrue;
+    }
+
+    // Other node types are considered blank
+    return Qtrue;
+}
+
 // node.xpath(path)
 static VALUE node_xpath(VALUE self, VALUE path) {
     NodeWrapper* node_wrapper;
@@ -550,7 +972,188 @@ static VALUE nodeset_to_a(VALUE self) {
     return rb_ary_dup(wrapper->nodes_array);
 }
 
-extern "C" void Init_rxerces(void) {
+// Schema.from_document(schema_doc) or Schema.from_string(xsd_string)
+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));
+        }
+    }
+
+    try {
+        SchemaWrapper* wrapper = ALLOC(SchemaWrapper);
+        wrapper->schemaContent = new std::string();
+
+        // Convert schema source to string
+        std::string xsd_content;
+        if (rb_obj_is_kind_of(schema_source, rb_cString)) {
+            xsd_content = std::string(RSTRING_PTR(schema_source), RSTRING_LEN(schema_source));
+        } else {
+            // Assume it's a Document, call to_s
+            VALUE str = rb_funcall(schema_source, rb_intern("to_s"), 0);
+            xsd_content = std::string(RSTRING_PTR(str), RSTRING_LEN(str));
+        }
+
+        // Store the schema content
+        *wrapper->schemaContent = xsd_content;
+
+        // Validate that it's valid XML by trying to parse it
+        XercesDOMParser* schemaParser = new XercesDOMParser();
+        schemaParser->setValidationScheme(XercesDOMParser::Val_Never);
+        schemaParser->setDoNamespaces(true);
+
+        // Parse the schema using MemBufInputSource
+        MemBufInputSource schemaInput(
+            (const XMLByte*)xsd_content.c_str(),
+            xsd_content.length(),
+            "schema"
+        );
+
+        try {
+            schemaParser->parse(schemaInput);
+        } catch (...) {
+            delete schemaParser;
+            delete wrapper->schemaContent;
+            xfree(wrapper);
+            rb_raise(rb_eRuntimeError, "Schema parsing failed: Invalid XML");
+        }
+
+        delete schemaParser;
+
+        VALUE rb_schema = TypedData_Wrap_Struct(klass, &schema_type, wrapper);
+        return rb_schema;
+
+    } 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, "XMLException: %s", StringValueCStr(rb_error));
+    } 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, "DOMException: %s", StringValueCStr(rb_error));
+    } catch (...) {
+        rb_raise(rb_eRuntimeError, "Unknown exception during schema parsing");
+    }
+
+    return Qnil;
+}
+
+// document.validate(schema) - returns array of error messages (empty if valid)
+static VALUE document_validate(VALUE self, VALUE rb_schema) {
+    DocumentWrapper* doc_wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, doc_wrapper);
+
+    SchemaWrapper* schema_wrapper;
+    TypedData_Get_Struct(rb_schema, SchemaWrapper, &schema_type, schema_wrapper);
+
+    try {
+        // Serialize the document to UTF-8 for validation
+        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(XMLString::transcode("LS"));
+        DOMLSSerializer* serializer = ((DOMImplementationLS*)impl)->createLSSerializer();
+
+        // Use a MemBufFormatTarget to get UTF-8 encoded output
+        MemBufFormatTarget target;
+        DOMLSOutput* output = ((DOMImplementationLS*)impl)->createLSOutput();
+        output->setByteStream(&target);
+
+        serializer->write(doc_wrapper->doc, output);
+
+        // Get the UTF-8 content
+        std::string xml_content((const char*)target.getRawBuffer(), target.getLen());
+
+        output->release();
+        serializer->release();
+
+        // Create a validating parser
+        XercesDOMParser* validator = new XercesDOMParser();
+        validator->setValidationScheme(XercesDOMParser::Val_Always);
+        validator->setDoNamespaces(true);
+        validator->setDoSchema(true);
+        validator->setValidationSchemaFullChecking(true);
+
+        ValidationErrorHandler errorHandler;
+        validator->setErrorHandler(&errorHandler);
+
+        // Create a combined input with both the schema and the document
+        // First, we need to add schema location to the document
+        std::string schema_location = "http://example.com/schema";
+
+        // Create memory buffers for both schema and document
+        MemBufInputSource schemaSource(
+            (const XMLByte*)schema_wrapper->schemaContent->c_str(),
+            schema_wrapper->schemaContent->length(),
+            "schema.xsd"
+        );
+
+        // Load the schema grammar
+        try {
+            validator->loadGrammar(schemaSource, Grammar::SchemaGrammarType, true);
+            validator->setExternalNoNamespaceSchemaLocation("schema.xsd");
+            validator->useCachedGrammarInParse(true);
+        } catch (...) {
+            // If grammar loading fails, just note it
+            errorHandler.errors.push_back("Warning: Schema grammar could not be loaded");
+        }
+
+        // Now parse and validate the document
+        MemBufInputSource docSource(
+            (const XMLByte*)xml_content.c_str(),
+            xml_content.length(),
+            "document.xml"
+        );
+
+        try {
+            validator->parse(docSource);
+        } catch (const XMLException& e) {
+            char* message = XMLString::transcode(e.getMessage());
+            errorHandler.errors.push_back(std::string("XMLException: ") + message);
+            XMLString::release(&message);
+        } catch (const DOMException& e) {
+            char* message = XMLString::transcode(e.getMessage());
+            errorHandler.errors.push_back(std::string("DOMException: ") + message);
+            XMLString::release(&message);
+        } catch (...) {
+            errorHandler.errors.push_back("Unknown parsing exception");
+        }
+
+        delete validator;
+
+        // Return array of error messages
+        VALUE errors_array = rb_ary_new();
+        for (const auto& err : errorHandler.errors) {
+            rb_ary_push(errors_array, rb_str_new_cstr(err.c_str()));
+        }
+
+        return errors_array;
+
+    } 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, "XMLException during validation: %s", StringValueCStr(rb_error));
+    } 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, "DOMException during validation: %s", StringValueCStr(rb_error));
+    } catch (...) {
+        rb_raise(rb_eRuntimeError, "Unknown exception during validation");
+    }
+
+    return Qnil;
+}extern "C" void Init_rxerces(void) {
     rb_mRXerces = rb_define_module("RXerces");
     rb_mXML = rb_define_module_under(rb_mRXerces, "XML");
 
@@ -561,6 +1164,7 @@ extern "C" void Init_rxerces(void) {
     rb_define_method(rb_cDocument, "to_s", RUBY_METHOD_FUNC(document_to_s), 0);
     rb_define_method(rb_cDocument, "to_xml", RUBY_METHOD_FUNC(document_to_s), 0);
     rb_define_method(rb_cDocument, "xpath", RUBY_METHOD_FUNC(document_xpath), 1);
+    rb_define_method(rb_cDocument, "create_element", RUBY_METHOD_FUNC(document_create_element), 1);
 
     rb_cNode = rb_define_class_under(rb_mXML, "Node", rb_cObject);
     rb_undef_alloc_func(rb_cNode);
@@ -572,6 +1176,17 @@ extern "C" void Init_rxerces(void) {
     rb_define_method(rb_cNode, "[]", RUBY_METHOD_FUNC(node_get_attribute), 1);
     rb_define_method(rb_cNode, "[]=", RUBY_METHOD_FUNC(node_set_attribute), 2);
     rb_define_method(rb_cNode, "children", RUBY_METHOD_FUNC(node_children), 0);
+    rb_define_method(rb_cNode, "parent", RUBY_METHOD_FUNC(node_parent), 0);
+    rb_define_method(rb_cNode, "attributes", RUBY_METHOD_FUNC(node_attributes), 0);
+    rb_define_method(rb_cNode, "next_sibling", RUBY_METHOD_FUNC(node_next_sibling), 0);
+    rb_define_method(rb_cNode, "previous_sibling", RUBY_METHOD_FUNC(node_previous_sibling), 0);
+    rb_define_method(rb_cNode, "add_child", RUBY_METHOD_FUNC(node_add_child), 1);
+    rb_define_method(rb_cNode, "remove", RUBY_METHOD_FUNC(node_remove), 0);
+    rb_define_method(rb_cNode, "unlink", RUBY_METHOD_FUNC(node_remove), 0);
+    rb_define_method(rb_cNode, "inner_html", RUBY_METHOD_FUNC(node_inner_html), 0);
+    rb_define_method(rb_cNode, "inner_xml", RUBY_METHOD_FUNC(node_inner_html), 0);
+    rb_define_method(rb_cNode, "path", RUBY_METHOD_FUNC(node_path), 0);
+    rb_define_method(rb_cNode, "blank?", RUBY_METHOD_FUNC(node_blank_p), 0);
     rb_define_method(rb_cNode, "xpath", RUBY_METHOD_FUNC(node_xpath), 1);
 
     rb_cElement = rb_define_class_under(rb_mXML, "Element", rb_cNode);
@@ -588,4 +1203,11 @@ extern "C" void Init_rxerces(void) {
     rb_define_method(rb_cNodeSet, "each", RUBY_METHOD_FUNC(nodeset_each), 0);
     rb_define_method(rb_cNodeSet, "to_a", RUBY_METHOD_FUNC(nodeset_to_a), 0);
     rb_include_module(rb_cNodeSet, rb_mEnumerable);
+
+    rb_cSchema = rb_define_class_under(rb_mXML, "Schema", rb_cObject);
+    rb_undef_alloc_func(rb_cSchema);
+    rb_define_singleton_method(rb_cSchema, "from_document", RUBY_METHOD_FUNC(schema_from_document), -1);
+    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);
 }