rxerces 0.3.0 → 0.5.0

data/ext/rxerces/rxerces.cpp

@@ -13,7 +13,28 @@
 #include <sstream>
 #include <vector>
 
+#ifdef HAVE_XALAN
+#include <xalanc/XPath/XPathEvaluator.hpp>
+#include <xalanc/XPath/NodeRefList.hpp>
+#include <xalanc/XPath/XObject.hpp>
+#include <xalanc/XPath/XObjectFactoryDefault.hpp>
+#include <xalanc/XPath/XPathEnvSupportDefault.hpp>
+#include <xalanc/XPath/XPathExecutionContextDefault.hpp>
+#include <xalanc/XPath/XPathConstructionContextDefault.hpp>
+#include <xalanc/XPath/ElementPrefixResolverProxy.hpp>
+#include <xalanc/XPath/XPathFactoryDefault.hpp>
+#include <xalanc/XPath/XPathProcessorImpl.hpp>
+#include <xalanc/XPath/XPath.hpp>
+#include <xalanc/XercesParserLiaison/XercesParserLiaison.hpp>
+#include <xalanc/XercesParserLiaison/XercesDOMSupport.hpp>
+#include <xalanc/XercesParserLiaison/XercesDocumentWrapper.hpp>
+#include <xalanc/PlatformSupport/XalanMemoryManagerDefault.hpp>
+#endif
+
 using namespace xercesc;
+#ifdef HAVE_XALAN
+using namespace xalanc;
+#endif
 
 VALUE rb_mRXerces;
 VALUE rb_mXML;
@@ -24,8 +45,17 @@ VALUE rb_cElement;
 VALUE rb_cText;
 VALUE rb_cSchema;
 
-// Xerces initialization flag
+// Initialization flags
 static bool xerces_initialized = false;
+#ifdef HAVE_XALAN
+static bool xalan_initialized = false;
+#endif
+
+// Forward declarations
+static std::string css_to_xpath(const char* css);
+static VALUE node_css(VALUE self, VALUE selector);
+static VALUE node_xpath(VALUE self, VALUE path);
+static VALUE document_xpath(VALUE self, VALUE path);
 
 // Helper class to manage XMLCh strings
 class XStr {
@@ -246,7 +276,7 @@ static VALUE document_parse(VALUE klass, VALUE str) {
 
     XercesDOMParser* parser = new XercesDOMParser();
     parser->setValidationScheme(XercesDOMParser::Val_Never);
-    parser->setDoNamespaces(false);
+    parser->setDoNamespaces(true);
     parser->setDoSchema(false);
 
     try {
@@ -319,6 +349,87 @@ static VALUE document_to_s(VALUE self) {
     return Qnil;
 }
 
+// document.inspect - human-readable representation
+static VALUE document_inspect(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    std::string result = "#<RXerces::XML::Document:0x";
+
+    // Add object ID
+    char buf[32];
+    snprintf(buf, sizeof(buf), "%016lx", (unsigned long)self);
+    result += buf;
+
+    if (!wrapper->doc) {
+        result += " (empty)>";
+        return rb_str_new_cstr(result.c_str());
+    }
+
+    // Add encoding
+    const XMLCh* encoding = wrapper->doc->getXmlEncoding();
+    if (encoding && XMLString::stringLen(encoding) > 0) {
+        CharStr utf8_encoding(encoding);
+        result += " encoding=\"";
+        result += utf8_encoding.localForm();
+        result += "\"";
+    }
+
+    // Add root element name
+    DOMElement* root = wrapper->doc->getDocumentElement();
+    if (root) {
+        CharStr rootName(root->getNodeName());
+        result += " root=<";
+        result += rootName.localForm();
+        result += ">";
+    }
+
+    result += ">";
+    return rb_str_new_cstr(result.c_str());
+}
+
+// document.encoding
+static VALUE document_encoding(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    if (!wrapper->doc) {
+        return Qnil;
+    }
+
+    const XMLCh* encoding = wrapper->doc->getXmlEncoding();
+    if (!encoding || XMLString::stringLen(encoding) == 0) {
+        // Default to UTF-8 if no encoding is specified
+        return rb_str_new_cstr("UTF-8");
+    }
+
+    CharStr utf8_encoding(encoding);
+    return rb_str_new_cstr(utf8_encoding.localForm());
+}
+
+// document.text / document.content - returns text content of entire document
+static VALUE document_text(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    if (!wrapper->doc) {
+        return rb_str_new_cstr("");
+    }
+
+    DOMElement* root = wrapper->doc->getDocumentElement();
+    if (!root) {
+        return rb_str_new_cstr("");
+    }
+
+    const XMLCh* content = root->getTextContent();
+    if (!content) {
+        return rb_str_new_cstr("");
+    }
+
+    CharStr utf8_content(content);
+    return rb_str_new_cstr(utf8_content.localForm());
+}
+
 // document.create_element(name)
 static VALUE document_create_element(VALUE self, VALUE name) {
     DocumentWrapper* doc_wrapper;
@@ -354,6 +465,107 @@ static VALUE document_create_element(VALUE self, VALUE name) {
     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;
+        }
+
+        // Get the document
+        DOMDocument* domDoc = context_node->getOwnerDocument();
+        if (!domDoc && context_node->getNodeType() == DOMNode::DOCUMENT_NODE) {
+            domDoc = static_cast<DOMDocument*>(context_node);
+        }
+
+        if (!domDoc) {
+            NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
+            wrapper->nodes_array = rb_ary_new();
+            return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+        }
+
+        // Create Xalan support objects
+        XercesParserLiaison liaison;
+        XercesDOMSupport domSupport(liaison);
+
+        // Create Xalan document - this creates and returns a XercesDocumentWrapper
+        XalanDocument* xalanDoc = liaison.createDocument(domDoc, false, false, false);
+        if (!xalanDoc) {
+            rb_raise(rb_eRuntimeError, "Failed to create Xalan document wrapper");
+        }
+
+        // The document IS the wrapper
+        XercesDocumentWrapper* docWrapper = static_cast<XercesDocumentWrapper*>(xalanDoc);
+
+        // Map the context node to Xalan
+        XalanNode* xalanContextNode = docWrapper->mapNode(context_node);
+        if (!xalanContextNode) {
+            xalanContextNode = docWrapper;
+        }
+
+        // Set up XPath factories and contexts
+        XPathEnvSupportDefault envSupport;
+        XObjectFactoryDefault objectFactory;
+        XPathExecutionContextDefault executionContext(envSupport, domSupport, objectFactory);
+        XPathConstructionContextDefault constructionContext;
+        XPathFactoryDefault factory;
+
+        // Create XPath
+        XPathProcessorImpl processor;
+        XPath* xpath = factory.create();
+
+        // Compile XPath expression
+        ElementPrefixResolverProxy resolver(docWrapper->getDocumentElement(), envSupport, domSupport);
+        processor.initXPath(*xpath, constructionContext, XalanDOMString(xpath_str), resolver);
+
+        // Execute XPath query
+        const XObjectPtr result = xpath->execute(xalanContextNode, resolver, executionContext);
+
+        VALUE nodes_array = rb_ary_new();
+
+        if (result.get() != 0) {
+            // Check if result is a node set
+            const NodeRefListBase& nodeList = result->nodeset();
+            const NodeRefListBase::size_type length = nodeList.getLength();
+
+            for (NodeRefListBase::size_type i = 0; i < length; ++i) {
+                XalanNode* xalanNode = nodeList.item(i);
+                if (xalanNode) {
+                    // Map back to Xerces DOM node
+                    const DOMNode* domNode = docWrapper->mapNode(xalanNode);
+                    if (domNode) {
+                        rb_ary_push(nodes_array, wrap_node(const_cast<DOMNode*>(domNode), doc_ref));
+                    }
+                }
+            }
+        }
+
+        factory.returnObject(xpath);
+
+        NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
+        wrapper->nodes_array = nodes_array;
+        return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+
+    } catch (const XalanXPathException& e) {
+        CharStr msg(e.getMessage().c_str());
+        rb_raise(rb_eRuntimeError, "XPath error: %s", msg.localForm());
+    } catch (const XMLException& e) {
+        CharStr message(e.getMessage());
+        rb_raise(rb_eRuntimeError, "XML error: %s", message.localForm());
+    } catch (...) {
+        rb_raise(rb_eRuntimeError, "Unknown XPath error");
+    }
+
+    NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
+    wrapper->nodes_array = rb_ary_new();
+    return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+}
+#endif
+
 // document.xpath(path)
 static VALUE document_xpath(VALUE self, VALUE path) {
     DocumentWrapper* doc_wrapper;
@@ -368,6 +580,17 @@ static VALUE document_xpath(VALUE self, VALUE path) {
     Check_Type(path, T_STRING);
     const char* xpath_str = StringValueCStr(path);
 
+#ifdef HAVE_XALAN
+    // Use Xalan for full XPath 1.0 support
+    DOMElement* root = doc_wrapper->doc->getDocumentElement();
+    if (!root) {
+        NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
+        wrapper->nodes_array = rb_ary_new();
+        return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+    }
+    return execute_xpath_with_xalan(root, xpath_str, self);
+#else
+    // Fall back to Xerces XPath subset
     try {
         DOMElement* root = doc_wrapper->doc->getDocumentElement();
         if (!root) {
@@ -417,6 +640,141 @@ static VALUE document_xpath(VALUE self, VALUE path) {
     NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
     wrapper->nodes_array = rb_ary_new();
     return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+#endif
+}
+
+// document.css(selector) - Convert CSS to XPath and execute
+static VALUE document_css(VALUE self, VALUE selector) {
+    Check_Type(selector, T_STRING);
+    const char* css_str = StringValueCStr(selector);
+
+    // Convert CSS to XPath
+    std::string xpath_str = css_to_xpath(css_str);
+
+    // Call the xpath method with converted selector
+    return document_xpath(self, rb_str_new2(xpath_str.c_str()));
+}
+
+// document.at_css(selector) - Returns first matching node
+static VALUE document_at_css(VALUE self, VALUE selector) {
+    VALUE nodeset = document_css(self, selector);
+
+    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);
+}
+
+// node.inspect - human-readable representation
+static VALUE node_inspect(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return rb_str_new_cstr("#<RXerces::XML::Node (nil)>");
+    }
+
+    DOMNode::NodeType nodeType = wrapper->node->getNodeType();
+    std::string result;
+
+    // Add object ID
+    char buf[32];
+    snprintf(buf, sizeof(buf), "%016lx", (unsigned long)self);
+
+    if (nodeType == DOMNode::ELEMENT_NODE) {
+        result = "#<RXerces::XML::Element:0x";
+        result += buf;
+        result += " <";
+
+        CharStr name(wrapper->node->getNodeName());
+        result += name.localForm();
+
+        // Add attributes
+        DOMElement* element = dynamic_cast<DOMElement*>(wrapper->node);
+        if (element) {
+            DOMNamedNodeMap* attributes = element->getAttributes();
+            if (attributes && attributes->getLength() > 0) {
+                XMLSize_t attrLen = attributes->getLength();
+                if (attrLen > 3) attrLen = 3;
+
+                for (XMLSize_t i = 0; i < attrLen; i++) {
+                    DOMNode* attr = attributes->item(i);
+                    CharStr attrName(attr->getNodeName());
+                    CharStr attrValue(attr->getNodeValue());
+                    result += " ";
+                    result += attrName.localForm();
+                    result += "=\"";
+                    result += attrValue.localForm();
+                    result += "\"";
+                }
+                if (attributes->getLength() > 3) {
+                    result += " ...";
+                }
+            }
+        }
+
+        result += ">";
+
+        // Add truncated text content
+        const XMLCh* textContent = wrapper->node->getTextContent();
+        if (textContent && XMLString::stringLen(textContent) > 0) {
+            CharStr text(textContent);
+            std::string textStr = text.localForm();
+
+            size_t start = textStr.find_first_not_of(" \t\n\r");
+            if (start != std::string::npos) {
+                size_t end = textStr.find_last_not_of(" \t\n\r");
+                textStr = textStr.substr(start, end - start + 1);
+
+                if (textStr.length() > 40) {
+                    textStr = textStr.substr(0, 37) + "...";
+                }
+
+                result += "\"";
+                result += textStr;
+                result += "\"";
+            }
+        }
+
+        result += ">";
+    } else if (nodeType == DOMNode::TEXT_NODE) {
+        result = "#<RXerces::XML::Text:0x";
+        result += buf;
+        result += " \"";
+
+        const XMLCh* textContent = wrapper->node->getNodeValue();
+        if (textContent) {
+            CharStr text(textContent);
+            std::string textStr = text.localForm();
+
+            size_t start = textStr.find_first_not_of(" \t\n\r");
+            if (start != std::string::npos) {
+                size_t end = textStr.find_last_not_of(" \t\n\r");
+                textStr = textStr.substr(start, end - start + 1);
+
+                if (textStr.length() > 40) {
+                    textStr = textStr.substr(0, 37) + "...";
+                }
+
+                result += textStr;
+            }
+        }
+
+        result += "\">";
+    } else {
+        result = "#<RXerces::XML::Node:0x";
+        result += buf;
+        result += " ";
+        CharStr name(wrapper->node->getNodeName());
+        result += name.localForm();
+        result += ">";
+    }
+
+    return rb_str_new_cstr(result.c_str());
 }
 
 // node.name
@@ -434,6 +792,24 @@ static VALUE node_name(VALUE self) {
     return rb_str_new_cstr(utf8_name.localForm());
 }
 
+// node.namespace
+static VALUE node_namespace(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    const XMLCh* namespaceURI = wrapper->node->getNamespaceURI();
+    if (!namespaceURI || XMLString::stringLen(namespaceURI) == 0) {
+        return Qnil;
+    }
+
+    CharStr utf8_namespace(namespaceURI);
+    return rb_str_new_cstr(utf8_namespace.localForm());
+}
+
 // node.text / node.content
 static VALUE node_text(VALUE self) {
     NodeWrapper* wrapper;
@@ -513,6 +889,28 @@ static VALUE node_set_attribute(VALUE self, VALUE attr_name, VALUE attr_value) {
     return attr_value;
 }
 
+// node.has_attribute?(attribute_name)
+static VALUE node_has_attribute_p(VALUE self, VALUE attr_name) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node || wrapper->node->getNodeType() != DOMNode::ELEMENT_NODE) {
+        return Qfalse;
+    }
+
+    Check_Type(attr_name, T_STRING);
+    const char* attr_str = StringValueCStr(attr_name);
+
+    DOMElement* element = dynamic_cast<DOMElement*>(wrapper->node);
+    const XMLCh* value = element->getAttribute(XStr(attr_str).unicodeForm());
+
+    if (!value || XMLString::stringLen(value) == 0) {
+        return Qfalse;
+    }
+
+    return Qtrue;
+}
+
 // node.children
 static VALUE node_children(VALUE self) {
     NodeWrapper* wrapper;
@@ -536,6 +934,31 @@ static VALUE node_children(VALUE self) {
     return children;
 }
 
+// node.element_children - returns only element children (no text nodes)
+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;
+    }
+
+    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) {
+            rb_ary_push(children, wrap_node(child, doc_ref));
+        }
+    }
+
+    return children;
+}
+
 // node.parent
 static VALUE node_parent(VALUE self) {
     NodeWrapper* wrapper;
@@ -554,6 +977,78 @@ static VALUE node_parent(VALUE self) {
     return wrap_node(parent, doc_ref);
 }
 
+// node.ancestors(selector = nil) - returns an array of all ancestor nodes, optionally filtered by selector
+static VALUE node_ancestors(int argc, VALUE* argv, VALUE self) {
+    VALUE selector;
+    rb_scan_args(argc, argv, "01", &selector);
+
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    VALUE ancestors = rb_ary_new();
+
+    if (!wrapper->node) {
+        return ancestors;
+    }
+
+    VALUE doc_ref = rb_iv_get(self, "@document");
+    DOMNode* current = wrapper->node->getParentNode();
+
+    // Walk up the tree, collecting all ancestors
+    while (current) {
+        // Stop at the document node (don't include it in ancestors)
+        if (current->getNodeType() == DOMNode::DOCUMENT_NODE) {
+            break;
+        }
+        rb_ary_push(ancestors, wrap_node(current, doc_ref));
+        current = current->getParentNode();
+    }
+
+    // If selector is provided, filter the ancestors
+    if (!NIL_P(selector)) {
+        Check_Type(selector, T_STRING);
+        const char* selector_str = StringValueCStr(selector);
+
+        // Convert CSS to XPath if needed (css_to_xpath adds // prefix)
+        std::string xpath_str = css_to_xpath(selector_str);
+
+        // Get all matching nodes from the document
+        VALUE all_matches = document_xpath(doc_ref, rb_str_new2(xpath_str.c_str()));
+
+        NodeSetWrapper* matches_wrapper;
+        TypedData_Get_Struct(all_matches, NodeSetWrapper, &nodeset_type, matches_wrapper);
+
+        VALUE filtered = rb_ary_new();
+        long ancestor_len = RARRAY_LEN(ancestors);
+        long matches_len = RARRAY_LEN(matches_wrapper->nodes_array);
+
+        // For each ancestor, check if it's in the matches
+        for (long i = 0; i < ancestor_len; i++) {
+            VALUE ancestor = rb_ary_entry(ancestors, i);
+
+            NodeWrapper* ancestor_wrapper;
+            TypedData_Get_Struct(ancestor, NodeWrapper, &node_type, ancestor_wrapper);
+
+            // Check if this ancestor node is in the matches
+            for (long j = 0; j < matches_len; j++) {
+                VALUE match = rb_ary_entry(matches_wrapper->nodes_array, j);
+                NodeWrapper* match_wrapper;
+                TypedData_Get_Struct(match, NodeWrapper, &node_type, match_wrapper);
+
+                // Compare the actual DOM nodes
+                if (ancestor_wrapper->node == match_wrapper->node) {
+                    rb_ary_push(filtered, ancestor);
+                    break;
+                }
+            }
+        }
+
+        return filtered;
+    }
+
+    return ancestors;
+}
+
 // node.attributes - returns hash of all attributes (only for element nodes)
 static VALUE node_attributes(VALUE self) {
     NodeWrapper* wrapper;
@@ -627,6 +1122,54 @@ static VALUE node_previous_sibling(VALUE self) {
     return wrap_node(prev, doc_ref);
 }
 
+// node.next_element - next sibling that is an element (skipping text nodes)
+static VALUE node_next_element(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    VALUE doc_ref = rb_iv_get(self, "@document");
+    DOMNode* next = wrapper->node->getNextSibling();
+
+    // Skip non-element nodes
+    while (next && next->getNodeType() != DOMNode::ELEMENT_NODE) {
+        next = next->getNextSibling();
+    }
+
+    if (!next) {
+        return Qnil;
+    }
+
+    return wrap_node(next, doc_ref);
+}
+
+// node.previous_element - previous sibling that is an element (skipping text nodes)
+static VALUE node_previous_element(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    VALUE doc_ref = rb_iv_get(self, "@document");
+    DOMNode* prev = wrapper->node->getPreviousSibling();
+
+    // Skip non-element nodes
+    while (prev && prev->getNodeType() != DOMNode::ELEMENT_NODE) {
+        prev = prev->getPreviousSibling();
+    }
+
+    if (!prev) {
+        return Qnil;
+    }
+
+    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;
@@ -880,6 +1423,11 @@ static VALUE node_xpath(VALUE self, VALUE path) {
     const char* xpath_str = StringValueCStr(path);
     VALUE doc_ref = rb_iv_get(self, "@document");
 
+#ifdef HAVE_XALAN
+    // Use Xalan for full XPath 1.0 support
+    return execute_xpath_with_xalan(node_wrapper->node, xpath_str, doc_ref);
+#else
+    // Fall back to Xerces XPath subset
     try {
         DOMDocument* doc = node_wrapper->node->getOwnerDocument();
         if (!doc) {
@@ -929,6 +1477,201 @@ static VALUE node_xpath(VALUE self, VALUE path) {
     NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
     wrapper->nodes_array = rb_ary_new();
     return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+#endif
+}
+
+// node.at_xpath(path) - returns first matching node or nil
+static VALUE node_at_xpath(VALUE self, VALUE path) {
+    VALUE nodeset = node_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);
+}
+
+// node.at_css(selector) - returns first matching node or nil
+static VALUE node_at_css(VALUE self, VALUE selector) {
+    VALUE nodeset = node_css(self, selector);
+    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);
+}
+
+// Helper function to convert basic CSS selectors to XPath
+// Supports common patterns like: tag, .class, #id, tag.class, tag#id, [attr], [attr=value]
+static std::string css_to_xpath(const char* css) {
+    std::string selector(css);
+
+    // Trim whitespace
+    size_t start = selector.find_first_not_of(" \t\n\r");
+    size_t end = selector.find_last_not_of(" \t\n\r");
+    if (start == std::string::npos) return "//*";
+    selector = selector.substr(start, end - start + 1);
+
+    std::string result = "//";
+    std::string current_element = "*";
+    bool has_element = false;
+    bool in_brackets = false;
+
+    for (size_t i = 0; i < selector.length(); i++) {
+        char c = selector[i];
+
+        if (c == '[') in_brackets = true;
+        if (c == ']') in_brackets = false;
+
+        // Handle spaces (descendant combinator) outside of attribute selectors
+        if (c == ' ' && !in_brackets) {
+            // Flush current element
+            if (!has_element && current_element != "*") {
+                result += current_element;
+            }
+            // Skip multiple spaces
+            while (i + 1 < selector.length() && selector[i + 1] == ' ') i++;
+            result += "//";
+            current_element = "*";
+            has_element = false;
+            continue;
+        }
+
+        // Handle child combinator
+        if (c == '>' && !in_brackets) {
+            // Flush current element
+            if (!has_element && current_element != "*") {
+                result += current_element;
+            }
+            // Remove any trailing slashes and spaces
+            while (!result.empty() && (result.back() == ' ' || result.back() == '/')) {
+                if (result.back() == '/') {
+                    result.pop_back();
+                    break;
+                }
+                result.pop_back();
+            }
+            result += "/";
+            // Skip spaces after >
+            while (i + 1 < selector.length() && selector[i + 1] == ' ') i++;
+            current_element = "*";
+            has_element = false;
+            continue;
+        }
+
+        // Handle ID selector
+        if (c == '#' && !in_brackets) {
+            if (!has_element) {
+                result += "*";
+                has_element = true;
+            } else if (current_element != "*") {
+                result += current_element;
+                current_element = "*";
+                has_element = true;
+            }
+            result += "[@id='";
+            i++;
+            while (i < selector.length() && selector[i] != ' ' && selector[i] != '.' &&
+                   selector[i] != '[' && selector[i] != '>' && selector[i] != '+' && selector[i] != '~') {
+                result += selector[i++];
+            }
+            result += "']";
+            i--;
+            continue;
+        }
+
+        // Handle class selector
+        if (c == '.' && !in_brackets) {
+            if (!has_element) {
+                result += "*";
+                has_element = true;
+            } else if (current_element != "*") {
+                result += current_element;
+                current_element = "*";
+                has_element = true;
+            }
+            result += "[contains(concat(' ', @class, ' '), ' ";
+            i++;
+            while (i < selector.length() && selector[i] != ' ' && selector[i] != '.' &&
+                   selector[i] != '[' && selector[i] != '>' && selector[i] != '+' && selector[i] != '~' && selector[i] != '#') {
+                result += selector[i++];
+            }
+            result += " ')]";
+            i--;
+            continue;
+        }
+
+        // Handle attribute selectors
+        if (c == '[') {
+            if (!has_element && current_element != "*") {
+                result += current_element;
+                has_element = true;
+            }
+            result += "[@";
+            i++;
+            // Get attribute name
+            while (i < selector.length() && selector[i] != ']' && selector[i] != '=' &&
+                   selector[i] != '!' && selector[i] != '~' && selector[i] != '^' && selector[i] != '$' && selector[i] != '*') {
+                result += selector[i++];
+            }
+
+            if (i < selector.length() && selector[i] == '=') {
+                result += "='";
+                i++;
+                // Skip quotes if present
+                if (i < selector.length() && (selector[i] == '"' || selector[i] == '\'')) {
+                    char quote = selector[i++];
+                    while (i < selector.length() && selector[i] != quote) {
+                        result += selector[i++];
+                    }
+                    if (i < selector.length()) i++; // Skip closing quote
+                } else {
+                    // No quotes, read until ]
+                    while (i < selector.length() && selector[i] != ']') {
+                        result += selector[i++];
+                    }
+                }
+                result += "'";
+            }
+
+            // Skip to closing bracket
+            while (i < selector.length() && selector[i] != ']') i++;
+            result += ']';
+            continue;
+        }
+
+        // Regular character - part of element name
+        if (c != ' ' && c != '>' && c != '.' && c != '#' && c != '[' && !has_element) {
+            if (current_element == "*") {
+                current_element = "";
+            }
+            current_element += c;
+        }
+    }
+
+    // Flush any remaining element name
+    if (!has_element && current_element != "*") {
+        result += current_element;
+    }
+
+    return result;
+}
+
+// node.css(selector) - Convert CSS to XPath and execute
+static VALUE node_css(VALUE self, VALUE selector) {
+    Check_Type(selector, T_STRING);
+    const char* css_str = StringValueCStr(selector);
+
+    // Convert CSS to XPath
+    std::string xpath_str = css_to_xpath(css_str);
+
+    // Call the xpath method with converted selector
+    return node_xpath(self, rb_str_new2(xpath_str.c_str()));
 }
 
 // nodeset.length / nodeset.size
@@ -972,6 +1715,205 @@ static VALUE nodeset_to_a(VALUE self) {
     return rb_ary_dup(wrapper->nodes_array);
 }
 
+// nodeset.first - returns first node or nil
+static VALUE nodeset_first(VALUE self) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    if (RARRAY_LEN(wrapper->nodes_array) == 0) {
+        return Qnil;
+    }
+
+    return rb_ary_entry(wrapper->nodes_array, 0);
+}
+
+// nodeset.last - returns last node or nil
+static VALUE nodeset_last(VALUE self) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    long len = RARRAY_LEN(wrapper->nodes_array);
+    if (len == 0) {
+        return Qnil;
+    }
+
+    return rb_ary_entry(wrapper->nodes_array, len - 1);
+}
+
+// nodeset.empty? - returns true if nodeset is empty
+static VALUE nodeset_empty_p(VALUE self) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    return RARRAY_LEN(wrapper->nodes_array) == 0 ? Qtrue : Qfalse;
+}
+
+// nodeset.inner_html - returns concatenated inner_html of all nodes
+static VALUE nodeset_inner_html(VALUE self) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    std::string result;
+    long len = RARRAY_LEN(wrapper->nodes_array);
+
+    for (long i = 0; i < len; i++) {
+        VALUE node = rb_ary_entry(wrapper->nodes_array, i);
+        VALUE inner_html = rb_funcall(node, rb_intern("inner_html"), 0);
+        result += StringValueCStr(inner_html);
+    }
+
+    return rb_str_new_cstr(result.c_str());
+}
+
+// nodeset.text - returns concatenated text content of all nodes
+static VALUE nodeset_text(VALUE self) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    std::string result;
+    long len = RARRAY_LEN(wrapper->nodes_array);
+
+    for (long i = 0; i < len; i++) {
+        VALUE node = rb_ary_entry(wrapper->nodes_array, i);
+        NodeWrapper* node_wrapper;
+        TypedData_Get_Struct(node, NodeWrapper, &node_type, node_wrapper);
+
+        if (node_wrapper->node) {
+            const XMLCh* content = node_wrapper->node->getTextContent();
+            if (content) {
+                CharStr utf8_content(content);
+                result += utf8_content.localForm();
+            }
+        }
+    }
+
+    return rb_str_new_cstr(result.c_str());
+}
+
+// nodeset.inspect / nodeset.to_s - human-readable representation
+static VALUE nodeset_inspect(VALUE self) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    long len = RARRAY_LEN(wrapper->nodes_array);
+    std::string result = "#<RXerces::XML::NodeSet:0x";
+
+    // Add object ID
+    char buf[32];
+    snprintf(buf, sizeof(buf), "%016lx", (unsigned long)self);
+    result += buf;
+    result += " [";
+
+    for (long i = 0; i < len; i++) {
+        if (i > 0) result += ", ";
+
+        VALUE node = rb_ary_entry(wrapper->nodes_array, i);
+        NodeWrapper* node_wrapper;
+        TypedData_Get_Struct(node, NodeWrapper, &node_type, node_wrapper);
+
+        if (!node_wrapper->node) {
+            result += "nil";
+            continue;
+        }
+
+        DOMNode::NodeType nodeType = node_wrapper->node->getNodeType();
+
+        if (nodeType == DOMNode::ELEMENT_NODE) {
+            // For elements, show: <tag attr="value">content</tag>
+            CharStr name(node_wrapper->node->getNodeName());
+            result += "<";
+            result += name.localForm();
+
+            // Add first few attributes if present
+            DOMElement* element = dynamic_cast<DOMElement*>(node_wrapper->node);
+            if (element) {
+                DOMNamedNodeMap* attributes = element->getAttributes();
+                if (attributes && attributes->getLength() > 0) {
+                    XMLSize_t attrLen = attributes->getLength();
+                    if (attrLen > 3) attrLen = 3; // Limit to first 3 attributes
+
+                    for (XMLSize_t j = 0; j < attrLen; j++) {
+                        DOMNode* attr = attributes->item(j);
+                        CharStr attrName(attr->getNodeName());
+                        CharStr attrValue(attr->getNodeValue());
+                        result += " ";
+                        result += attrName.localForm();
+                        result += "=\"";
+                        result += attrValue.localForm();
+                        result += "\"";
+                    }
+                    if (attributes->getLength() > 3) {
+                        result += " ...";
+                    }
+                }
+            }
+
+            // Show truncated text content
+            const XMLCh* textContent = node_wrapper->node->getTextContent();
+            if (textContent && XMLString::stringLen(textContent) > 0) {
+                CharStr text(textContent);
+                std::string textStr = text.localForm();
+
+                // Trim whitespace and truncate
+                size_t start = textStr.find_first_not_of(" \t\n\r");
+                if (start != std::string::npos) {
+                    size_t end = textStr.find_last_not_of(" \t\n\r");
+                    textStr = textStr.substr(start, end - start + 1);
+
+                    if (textStr.length() > 30) {
+                        textStr = textStr.substr(0, 27) + "...";
+                    }
+
+                    result += ">";
+                    result += textStr;
+                    result += "</";
+                    result += name.localForm();
+                    result += ">";
+                } else {
+                    result += ">";
+                }
+            } else {
+                result += ">";
+            }
+        } else if (nodeType == DOMNode::TEXT_NODE) {
+            // For text nodes, show: text("content")
+            const XMLCh* textContent = node_wrapper->node->getNodeValue();
+            if (textContent) {
+                CharStr text(textContent);
+                std::string textStr = text.localForm();
+
+                // Trim and truncate
+                size_t start = textStr.find_first_not_of(" \t\n\r");
+                if (start != std::string::npos) {
+                    size_t end = textStr.find_last_not_of(" \t\n\r");
+                    textStr = textStr.substr(start, end - start + 1);
+
+                    if (textStr.length() > 30) {
+                        textStr = textStr.substr(0, 27) + "...";
+                    }
+
+                    result += "text(\"";
+                    result += textStr;
+                    result += "\")";
+                } else {
+                    result += "text()";
+                }
+            } else {
+                result += "text()";
+            }
+        } else {
+            // For other nodes, just show the type
+            CharStr name(node_wrapper->node->getNodeName());
+            result += "#<";
+            result += name.localForm();
+            result += ">";
+        }
+    }
+
+    result += "]>";
+    return rb_str_new_cstr(result.c_str());
+}
+
 // 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;
@@ -1162,32 +2104,55 @@ static VALUE document_validate(VALUE self, VALUE rb_schema) {
     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, "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_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, "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_cNode = rb_define_class_under(rb_mXML, "Node", rb_cObject);
     rb_undef_alloc_func(rb_cNode);
+    rb_define_method(rb_cNode, "inspect", RUBY_METHOD_FUNC(node_inspect), 0);
     rb_define_method(rb_cNode, "name", RUBY_METHOD_FUNC(node_name), 0);
+    rb_define_method(rb_cNode, "namespace", RUBY_METHOD_FUNC(node_namespace), 0);
     rb_define_method(rb_cNode, "text", RUBY_METHOD_FUNC(node_text), 0);
-    rb_define_method(rb_cNode, "content", RUBY_METHOD_FUNC(node_text), 0);
+    rb_define_alias(rb_cNode, "content", "text");
     rb_define_method(rb_cNode, "text=", RUBY_METHOD_FUNC(node_text_set), 1);
-    rb_define_method(rb_cNode, "content=", RUBY_METHOD_FUNC(node_text_set), 1);
+    rb_define_alias(rb_cNode, "content=", "text=");
     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_alias(rb_cNode, "get_attribute", "[]");
+    rb_define_alias(rb_cNode, "attribute", "[]");
+    rb_define_method(rb_cNode, "has_attribute?", RUBY_METHOD_FUNC(node_has_attribute_p), 1);
     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, "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);
     rb_define_method(rb_cNode, "next_sibling", RUBY_METHOD_FUNC(node_next_sibling), 0);
+    rb_define_method(rb_cNode, "next_element", RUBY_METHOD_FUNC(node_next_element), 0);
     rb_define_method(rb_cNode, "previous_sibling", RUBY_METHOD_FUNC(node_previous_sibling), 0);
+    rb_define_method(rb_cNode, "previous_element", RUBY_METHOD_FUNC(node_previous_element), 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_alias(rb_cNode, "unlink", "remove");
     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_alias(rb_cNode, "inner_xml", "inner_html");
     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_define_alias(rb_cNode, "search", "xpath");
+    rb_define_method(rb_cNode, "at_xpath", RUBY_METHOD_FUNC(node_at_xpath), 1);
+    rb_define_alias(rb_cNode, "at", "at_xpath");
+    rb_define_method(rb_cNode, "css", RUBY_METHOD_FUNC(node_css), 1);
+    rb_define_method(rb_cNode, "at_css", RUBY_METHOD_FUNC(node_at_css), 1);
+    rb_define_alias(rb_cNode, "get_attribute", "[]");
+    rb_define_alias(rb_cNode, "attribute", "[]");
 
     rb_cElement = rb_define_class_under(rb_mXML, "Element", rb_cNode);
     rb_undef_alloc_func(rb_cElement);
@@ -1198,10 +2163,17 @@ static VALUE document_validate(VALUE self, VALUE rb_schema) {
     rb_cNodeSet = rb_define_class_under(rb_mXML, "NodeSet", rb_cObject);
     rb_undef_alloc_func(rb_cNodeSet);
     rb_define_method(rb_cNodeSet, "length", RUBY_METHOD_FUNC(nodeset_length), 0);
-    rb_define_method(rb_cNodeSet, "size", RUBY_METHOD_FUNC(nodeset_length), 0);
+    rb_define_alias(rb_cNodeSet, "size", "length");
     rb_define_method(rb_cNodeSet, "[]", RUBY_METHOD_FUNC(nodeset_at), 1);
+    rb_define_method(rb_cNodeSet, "first", RUBY_METHOD_FUNC(nodeset_first), 0);
+    rb_define_method(rb_cNodeSet, "last", RUBY_METHOD_FUNC(nodeset_last), 0);
+    rb_define_method(rb_cNodeSet, "empty?", RUBY_METHOD_FUNC(nodeset_empty_p), 0);
     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_define_method(rb_cNodeSet, "text", RUBY_METHOD_FUNC(nodeset_text), 0);
+    rb_define_method(rb_cNodeSet, "inner_html", RUBY_METHOD_FUNC(nodeset_inner_html), 0);
+    rb_define_method(rb_cNodeSet, "inspect", RUBY_METHOD_FUNC(nodeset_inspect), 0);
+    rb_define_alias(rb_cNodeSet, "to_s", "inspect");
     rb_include_module(rb_cNodeSet, rb_mEnumerable);
 
     rb_cSchema = rb_define_class_under(rb_mXML, "Schema", rb_cObject);