rxerces 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 71254540124db9069ed4366fe61e6efa20d0d74fe4c92f5f8b51793bca16099d
+  data.tar.gz: ba91d5747e0394f5cd5149921af75d838e97815f0dc8b2b09528ac775530461d
+SHA512:
+  metadata.gz: 6e26d2111e1ef02ed72fdac2e532d38201dfba9de4b1521bbf22046c2a23a1a821f0ad42368d47520f61139caa0aca365169399abf6ce79b2fa6fd337e0e0026
+  data.tar.gz: 6897cb5b3f9755c4cab71735c4ca5eeaf5a3e85917c67d6a4e5903adb3312067de51961262ec7470ca7b91c1984007d58090f7078081a8400692358be870acc7

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RXerces Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,309 @@
+# RXerces
+
+A Ruby XML library with a Nokogiri-compatible API, powered by Apache Xerces-C instead of libxml2.
+
+## Overview
+
+RXerces provides a familiar Nokogiri-like interface for XML parsing and manipulation, but uses the robust Apache Xerces-C XML parser under the hood. This allows Ruby developers to leverage Xerces-C's performance and standards compliance while maintaining compatibility with existing Nokogiri-based code.
+
+## Features
+
+- ✅ Nokogiri-compatible API
+- ✅ Powered by Apache Xerces-C
+- ✅ Parse XML documents
+- ✅ Navigate and manipulate DOM trees
+- ✅ Read and write node attributes
+- ✅ Query nodes with XPath (basic support)
+- ✅ Serialize documents back to XML strings
+
+## Installation
+
+### Prerequisites
+
+You need to have Xerces-C installed on your system:
+
+**macOS (Homebrew):**
+```bash
+brew install xerces-c
+```
+
+**Ubuntu/Debian:**
+```bash
+sudo apt-get install libxerces-c-dev
+```
+
+**Fedora/RHEL:**
+```bash
+sudo yum install xerces-c-devel
+```
+
+### Install the Gem
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rxerces'
+```
+
+And then execute:
+```bash
+bundle install
+```
+
+Or install it yourself as:
+```bash
+gem install rxerces
+```
+
+## Usage
+
+### Basic Parsing
+
+```ruby
+require 'rxerces'
+
+# Parse XML string
+xml = '<root><person name="Alice">Hello</person></root>'
+doc = RXerces.XML(xml)
+
+# Access root element
+root = doc.root
+puts root.name  # => "root"
+```
+
+### Nokogiri Compatibility
+
+RXerces provides a `Nokogiri` module for drop-in compatibility:
+
+```ruby
+require 'rxerces'
+
+# Use Nokogiri syntax
+doc = Nokogiri.XML('<root><child>text</child></root>')
+puts doc.root.name  # => "root"
+
+# Classes are aliased
+Nokogiri::XML::Document == RXerces::XML::Document  # => true
+```
+
+### Working with Nodes
+
+```ruby
+# Parse XML
+xml = <<-XML
+  <library>
+    <book id="1" title="1984">
+      <author>George Orwell</author>
+      <year>1949</year>
+    </book>
+    <book id="2" title="Brave New World">
+      <author>Aldous Huxley</author>
+      <year>1932</year>
+    </book>
+  </library>
+XML
+
+doc = RXerces.XML(xml)
+root = doc.root
+
+# Get attributes
+book = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+puts book['id']     # => "1"
+puts book['title']  # => "1984"
+
+# Set attributes
+book['isbn'] = '978-0451524935'
+puts book['isbn']   # => "978-0451524935"
+
+# Get text content
+author = book.children.find { |n| n.name == 'author' }
+puts author.text    # => "George Orwell"
+
+# Set text content
+author.text = "Eric Arthur Blair"
+puts author.text    # => "Eric Arthur Blair"
+```
+
+### Navigating the DOM
+
+```ruby
+# Get all children
+root.children.each do |child|
+  puts "#{child.name}: #{child.class}"
+end
+
+# Find specific elements
+books = root.children.select { |n| n.is_a?(RXerces::XML::Element) && n.name == 'book' }
+books.each do |book|
+  puts "Book ID: #{book['id']}"
+end
+```
+
+### Serialization
+
+```ruby
+# Convert document back to XML string
+xml_string = doc.to_xml
+puts xml_string
+
+# or use to_s
+puts doc.to_s
+```
+
+### XPath Queries
+
+RXerces supports XPath queries using Xerces-C's XPath implementation:
+
+```ruby
+xml = <<-XML
+  <library>
+    <book>
+      <title>1984</title>
+      <author>George Orwell</author>
+    </book>
+    <book>
+      <title>Brave New World</title>
+      <author>Aldous Huxley</author>
+    </book>
+  </library>
+XML
+
+doc = RXerces.XML(xml)
+
+# Find all book elements
+books = doc.xpath('//book')
+puts books.length  # => 2
+
+# Find all titles
+titles = doc.xpath('//title')
+titles.each do |title|
+  puts title.text.strip
+end
+
+# Use path expressions
+authors = doc.xpath('/library/book/author')
+puts authors.length  # => 2
+
+# Query from a specific node
+first_book = books[0]
+title = first_book.xpath('.//title').first
+puts title.text  # => "1984"
+```
+
+**Note on XPath Support**: Xerces-C implements the XML Schema XPath subset, not full XPath 1.0. Supported features include:
+- Basic path expressions (`/`, `//`, `.`, `..`)
+- Element selection by name
+- Descendant and child axes
+
+Not supported:
+- Attribute predicates (`[@attribute="value"]`)
+- XPath functions (`last()`, `position()`, `text()`)
+- Comparison operators in predicates
+
+For more complex queries, you can combine basic XPath with Ruby's `select` and `find` methods.
+
+## API Reference
+
+### RXerces Module
+
+- `RXerces.XML(string)` - Parse XML string and return Document
+- `RXerces.parse(string)` - Alias for `XML`
+
+### RXerces::XML::Document
+
+- `.parse(string)` - Parse XML string (class method)
+- `#root` - Get root element
+- `#to_s` / `#to_xml` - Serialize to XML string
+- `#xpath(path)` - Query with XPath (returns NodeSet)
+
+### RXerces::XML::Node
+
+- `#name` - Get node name
+- `#text` / `#content` - Get text content
+- `#text=` / `#content=` - Set text content
+- `#[attribute]` - Get attribute value
+- `#[attribute]=` - Set attribute value
+- `#children` - Get array of child nodes
+- `#xpath(path)` - Query descendants with XPath
+
+### RXerces::XML::Element
+
+Inherits all methods from `Node`. Represents element nodes.
+
+### RXerces::XML::Text
+
+Inherits all methods from `Node`. Represents text nodes.
+
+### RXerces::XML::NodeSet
+
+- `#length` / `#size` - Get number of nodes
+- `#[]` - Access node by index
+- `#each` - Iterate over nodes (Enumerable)
+- `#to_a` - Convert to array
+
+## Development
+
+### Building the Extension
+
+```bash
+bundle install
+bundle exec rake compile
+```
+
+### Running Tests
+
+```bash
+bundle exec rspec
+```
+
+### Running Tests with Compilation
+
+```bash
+bundle exec rake
+```
+
+## Implementation Notes
+
+- Uses Apache Xerces-C 3.x for XML parsing
+- C++ extension compiled with Ruby's native extension API
+- XPath support is basic (full XPath requires additional implementation)
+- Memory management handled by Ruby's GC and Xerces-C's DOM
+
+## Differences from Nokogiri
+
+While RXerces aims for API compatibility with Nokogiri, there are some differences:
+
+1. **Parser Backend**: Uses Xerces-C instead of libxml2
+2. **XPath**: Basic XPath support (returns empty NodeSet currently)
+3. **Features**: Subset of Nokogiri's full feature set
+4. **Performance**: Different performance characteristics due to Xerces-C
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Credits
+
+- Built with [Apache Xerces-C](https://xerces.apache.org/xerces-c/)
+- API inspired by [Nokogiri](https://nokogiri.org/)
+
+## Misc
+This library was almost entirely written using AI (Claude Sonnet 4.5). It
+was mainly a reaction to the lack of maintainers for libxml2, and the generally
+sorry state of that library in general. Since nokogiri uses it under the hood,
+I thought it best to create an alternative.
+
+## Copyright
+(C) 2025, Daniel J. Berger
+All Rights Reserved
+
+## Author
+* Daniel J. Berger

data/ext/rxerces/extconf.rb

@@ -0,0 +1,32 @@
+require 'mkmf'
+
+# Force C++ compiler for the extension
+$CXXFLAGS << " -std=c++11"
+
+# Try to find Xerces-C via homebrew on macOS
+if RUBY_PLATFORM =~ /darwin/
+  homebrew_prefix = `brew --prefix xerces-c 2>/dev/null`.chomp
+  if !homebrew_prefix.empty? && File.directory?(homebrew_prefix)
+    $INCFLAGS << " -I#{homebrew_prefix}/include"
+    $LDFLAGS << " -L#{homebrew_prefix}/lib"
+  end
+end
+
+# Check for Xerces-C library
+unless have_library('xerces-c')
+  puts "Xerces-C library not found. Please install it:"
+  puts "  macOS: brew install xerces-c"
+  puts "  Ubuntu/Debian: sudo apt-get install libxerces-c-dev"
+  puts "  Fedora/RHEL: sudo yum install xerces-c-devel"
+  exit 1
+end
+
+# Use C++ for header checking
+# We check by trying to find the library itself rather than header
+unless find_header('xercesc/util/PlatformUtils.hpp')
+  # Header check failed, but library exists, so we'll proceed with a warning
+  puts "Warning: Xerces-C headers not automatically detected, but library is present."
+  puts "Proceeding with compilation..."
+end
+
+create_makefile('rxerces/rxerces')

data/ext/rxerces/rxerces.cpp

@@ -0,0 +1,591 @@
+#include "rxerces.h"
+#include <xercesc/util/PlatformUtils.hpp>
+#include <xercesc/parsers/XercesDOMParser.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/util/XMLString.hpp>
+#include <xercesc/framework/MemBufInputSource.hpp>
+#include <xercesc/framework/MemBufFormatTarget.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOMXPathResult.hpp>
+#include <xercesc/dom/DOMXPathExpression.hpp>
+#include <sstream>
+
+using namespace xercesc;
+
+VALUE rb_mRXerces;
+VALUE rb_mXML;
+VALUE rb_cDocument;
+VALUE rb_cNode;
+VALUE rb_cNodeSet;
+VALUE rb_cElement;
+VALUE rb_cText;
+
+// Xerces initialization flag
+static bool xerces_initialized = false;
+
+// Helper class to manage XMLCh strings
+class XStr {
+public:
+    XStr(const char* const toTranscode) {
+        fUnicodeForm = XMLString::transcode(toTranscode);
+    }
+
+    XStr(const std::string& toTranscode) {
+        fUnicodeForm = XMLString::transcode(toTranscode.c_str());
+    }
+
+    ~XStr() {
+        XMLString::release(&fUnicodeForm);
+    }
+
+    const XMLCh* unicodeForm() const {
+        return fUnicodeForm;
+    }
+
+private:
+    XMLCh* fUnicodeForm;
+};
+
+// Helper to convert XMLCh to char*
+class CharStr {
+public:
+    CharStr(const XMLCh* const toTranscode) {
+        fLocalForm = XMLString::transcode(toTranscode);
+    }
+
+    ~CharStr() {
+        XMLString::release(&fLocalForm);
+    }
+
+    const char* localForm() const {
+        return fLocalForm;
+    }
+
+private:
+    char* fLocalForm;
+};
+
+// Wrapper structure for DOMDocument
+typedef struct {
+    DOMDocument* doc;
+    XercesDOMParser* parser;
+} DocumentWrapper;
+
+// Wrapper structure for DOMNode
+typedef struct {
+    DOMNode* node;
+    VALUE doc_ref; // Keep reference to parent document
+} NodeWrapper;
+
+// Wrapper structure for NodeSet (array of nodes)
+typedef struct {
+    VALUE nodes_array;
+} NodeSetWrapper;
+
+// Memory management functions
+static void document_free(void* ptr) {
+    DocumentWrapper* wrapper = (DocumentWrapper*)ptr;
+    if (wrapper) {
+        if (wrapper->parser) {
+            delete wrapper->parser;
+        }
+        // Document is owned by parser, so don't delete it separately
+        xfree(wrapper);
+    }
+}
+
+static void node_free(void* ptr) {
+    NodeWrapper* wrapper = (NodeWrapper*)ptr;
+    if (wrapper) {
+        // Don't delete node - it's owned by the document
+        xfree(wrapper);
+    }
+}
+
+static void nodeset_free(void* ptr) {
+    NodeSetWrapper* wrapper = (NodeSetWrapper*)ptr;
+    if (wrapper) {
+        xfree(wrapper);
+    }
+}
+
+static size_t document_size(const void* ptr) {
+    return sizeof(DocumentWrapper);
+}
+
+static size_t node_size(const void* ptr) {
+    return sizeof(NodeWrapper);
+}
+
+static size_t nodeset_size(const void* ptr) {
+    return sizeof(NodeSetWrapper);
+}
+
+static const rb_data_type_t document_type = {
+    "RXerces::XML::Document",
+    {0, document_free, document_size},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static const rb_data_type_t node_type = {
+    "RXerces::XML::Node",
+    {0, 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},
+    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) {
+        return Qnil;
+    }
+
+    NodeWrapper* wrapper = ALLOC(NodeWrapper);
+    wrapper->node = node;
+    wrapper->doc_ref = doc_ref;
+
+    VALUE rb_node;
+
+    switch (node->getNodeType()) {
+        case DOMNode::ELEMENT_NODE:
+            rb_node = TypedData_Wrap_Struct(rb_cElement, &node_type, wrapper);
+            break;
+        case DOMNode::TEXT_NODE:
+            rb_node = TypedData_Wrap_Struct(rb_cText, &node_type, wrapper);
+            break;
+        default:
+            rb_node = TypedData_Wrap_Struct(rb_cNode, &node_type, wrapper);
+            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");
+        }
+    }
+
+    Check_Type(str, T_STRING);
+    const char* xml_str = StringValueCStr(str);
+
+    XercesDOMParser* parser = new XercesDOMParser();
+    parser->setValidationScheme(XercesDOMParser::Val_Never);
+    parser->setDoNamespaces(false);
+    parser->setDoSchema(false);
+
+    try {
+        MemBufInputSource input((const XMLByte*)xml_str, strlen(xml_str), "memory");
+        parser->parse(input);
+
+        DOMDocument* doc = parser->getDocument();
+
+        DocumentWrapper* wrapper = ALLOC(DocumentWrapper);
+        wrapper->doc = doc;
+        wrapper->parser = parser;
+
+        VALUE rb_doc = TypedData_Wrap_Struct(rb_cDocument, &document_type, wrapper);
+        return rb_doc;
+    } catch (const XMLException& e) {
+        CharStr message(e.getMessage());
+        delete parser;
+        rb_raise(rb_eRuntimeError, "XML parsing error: %s", message.localForm());
+    } catch (const DOMException& e) {
+        CharStr message(e.getMessage());
+        delete parser;
+        rb_raise(rb_eRuntimeError, "DOM error: %s", message.localForm());
+    } catch (...) {
+        delete parser;
+        rb_raise(rb_eRuntimeError, "Unknown XML parsing error");
+    }
+
+    return Qnil;
+}
+
+// document.root
+static VALUE document_root(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    if (!wrapper->doc) {
+        return Qnil;
+    }
+
+    DOMElement* root = wrapper->doc->getDocumentElement();
+    return wrap_node(root, self);
+}
+
+// document.to_s / document.to_xml
+static VALUE document_to_s(VALUE self) {
+    DocumentWrapper* wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, wrapper);
+
+    if (!wrapper->doc) {
+        return rb_str_new_cstr("");
+    }
+
+    try {
+        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(XStr("LS").unicodeForm());
+        DOMLSSerializer* serializer = ((DOMImplementationLS*)impl)->createLSSerializer();
+
+        XMLCh* xml_str = serializer->writeToString(wrapper->doc);
+        CharStr utf8_str(xml_str);
+
+        VALUE result = rb_str_new_cstr(utf8_str.localForm());
+
+        XMLString::release(&xml_str);
+        serializer->release();
+
+        return result;
+    } catch (...) {
+        rb_raise(rb_eRuntimeError, "Failed to serialize document");
+    }
+
+    return Qnil;
+}
+
+// document.xpath(path)
+static VALUE document_xpath(VALUE self, VALUE path) {
+    DocumentWrapper* doc_wrapper;
+    TypedData_Get_Struct(self, DocumentWrapper, &document_type, doc_wrapper);
+
+    if (!doc_wrapper->doc) {
+        NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
+        wrapper->nodes_array = rb_ary_new();
+        return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+    }
+
+    Check_Type(path, T_STRING);
+    const char* xpath_str = StringValueCStr(path);
+
+    try {
+        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);
+        }
+
+        DOMXPathNSResolver* resolver = doc_wrapper->doc->createNSResolver(root);
+        DOMXPathExpression* expression = doc_wrapper->doc->createExpression(
+            XStr(xpath_str).unicodeForm(), resolver);
+
+        DOMXPathResult* result = expression->evaluate(
+            doc_wrapper->doc->getDocumentElement(),
+            DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
+            NULL);
+
+        VALUE nodes_array = rb_ary_new();
+        XMLSize_t length = result->getSnapshotLength();
+
+        for (XMLSize_t i = 0; i < length; i++) {
+            result->snapshotItem(i);
+            DOMNode* node = result->getNodeValue();
+            if (node) {
+                rb_ary_push(nodes_array, wrap_node(node, self));
+            }
+        }
+
+        expression->release();
+        resolver->release();
+        result->release();
+
+        NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
+        wrapper->nodes_array = nodes_array;
+        return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+
+    } catch (const DOMXPathException& e) {
+        CharStr message(e.getMessage());
+        rb_raise(rb_eRuntimeError, "XPath error: %s", message.localForm());
+    } catch (const DOMException& e) {
+        CharStr message(e.getMessage());
+        rb_raise(rb_eRuntimeError, "DOM 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);
+}
+
+// node.name
+static VALUE node_name(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    const XMLCh* name = wrapper->node->getNodeName();
+    CharStr utf8_name(name);
+
+    return rb_str_new_cstr(utf8_name.localForm());
+}
+
+// node.text / node.content
+static VALUE node_text(VALUE self) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return rb_str_new_cstr("");
+    }
+
+    const XMLCh* content = wrapper->node->getTextContent();
+    if (!content) {
+        return rb_str_new_cstr("");
+    }
+
+    CharStr utf8_content(content);
+    return rb_str_new_cstr(utf8_content.localForm());
+}
+
+// node.text = value
+static VALUE node_text_set(VALUE self, VALUE text) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node) {
+        return Qnil;
+    }
+
+    Check_Type(text, T_STRING);
+    const char* text_str = StringValueCStr(text);
+
+    wrapper->node->setTextContent(XStr(text_str).unicodeForm());
+
+    return text;
+}
+
+// node[attribute_name]
+static VALUE node_get_attribute(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 Qnil;
+    }
+
+    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 Qnil;
+    }
+
+    CharStr utf8_value(value);
+    return rb_str_new_cstr(utf8_value.localForm());
+}
+
+// node[attribute_name] = value
+static VALUE node_set_attribute(VALUE self, VALUE attr_name, VALUE attr_value) {
+    NodeWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, wrapper);
+
+    if (!wrapper->node || wrapper->node->getNodeType() != DOMNode::ELEMENT_NODE) {
+        return Qnil;
+    }
+
+    Check_Type(attr_name, T_STRING);
+    Check_Type(attr_value, T_STRING);
+
+    const char* attr_str = StringValueCStr(attr_name);
+    const char* value_str = StringValueCStr(attr_value);
+
+    DOMElement* element = dynamic_cast<DOMElement*>(wrapper->node);
+    element->setAttribute(XStr(attr_str).unicodeForm(), XStr(value_str).unicodeForm());
+
+    return attr_value;
+}
+
+// node.children
+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;
+    }
+
+    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);
+        rb_ary_push(children, wrap_node(child, doc_ref));
+    }
+
+    return children;
+}
+
+// node.xpath(path)
+static VALUE node_xpath(VALUE self, VALUE path) {
+    NodeWrapper* node_wrapper;
+    TypedData_Get_Struct(self, NodeWrapper, &node_type, node_wrapper);
+
+    if (!node_wrapper->node) {
+        NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
+        wrapper->nodes_array = rb_ary_new();
+        return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+    }
+
+    Check_Type(path, T_STRING);
+    const char* xpath_str = StringValueCStr(path);
+    VALUE doc_ref = rb_iv_get(self, "@document");
+
+    try {
+        DOMDocument* doc = node_wrapper->node->getOwnerDocument();
+        if (!doc) {
+            NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
+            wrapper->nodes_array = rb_ary_new();
+            return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+        }
+
+        DOMXPathNSResolver* resolver = doc->createNSResolver(node_wrapper->node);
+        DOMXPathExpression* expression = doc->createExpression(
+            XStr(xpath_str).unicodeForm(), resolver);
+
+        DOMXPathResult* result = expression->evaluate(
+            node_wrapper->node,
+            DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
+            NULL);
+
+        VALUE nodes_array = rb_ary_new();
+        XMLSize_t length = result->getSnapshotLength();
+
+        for (XMLSize_t i = 0; i < length; i++) {
+            result->snapshotItem(i);
+            DOMNode* node = result->getNodeValue();
+            if (node) {
+                rb_ary_push(nodes_array, wrap_node(node, doc_ref));
+            }
+        }
+
+        expression->release();
+        resolver->release();
+        result->release();
+
+        NodeSetWrapper* wrapper = ALLOC(NodeSetWrapper);
+        wrapper->nodes_array = nodes_array;
+        return TypedData_Wrap_Struct(rb_cNodeSet, &nodeset_type, wrapper);
+
+    } catch (const DOMXPathException& e) {
+        CharStr message(e.getMessage());
+        rb_raise(rb_eRuntimeError, "XPath error: %s", message.localForm());
+    } catch (const DOMException& e) {
+        CharStr message(e.getMessage());
+        rb_raise(rb_eRuntimeError, "DOM 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);
+}
+
+// nodeset.length / nodeset.size
+static VALUE nodeset_length(VALUE self) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    return LONG2NUM(RARRAY_LEN(wrapper->nodes_array));
+}
+
+// nodeset[index]
+static VALUE nodeset_at(VALUE self, VALUE index) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    return rb_ary_entry(wrapper->nodes_array, NUM2LONG(index));
+}
+
+// nodeset.each
+static VALUE nodeset_each(VALUE self) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    if (!rb_block_given_p()) {
+        return rb_funcall(wrapper->nodes_array, rb_intern("each"), 0);
+    }
+
+    long len = RARRAY_LEN(wrapper->nodes_array);
+    for (long i = 0; i < len; i++) {
+        rb_yield(rb_ary_entry(wrapper->nodes_array, i));
+    }
+
+    return self;
+}
+
+// nodeset.to_a
+static VALUE nodeset_to_a(VALUE self) {
+    NodeSetWrapper* wrapper;
+    TypedData_Get_Struct(self, NodeSetWrapper, &nodeset_type, wrapper);
+
+    return rb_ary_dup(wrapper->nodes_array);
+}
+
+extern "C" void Init_rxerces(void) {
+    rb_mRXerces = rb_define_module("RXerces");
+    rb_mXML = rb_define_module_under(rb_mRXerces, "XML");
+
+    rb_cDocument = rb_define_class_under(rb_mXML, "Document", rb_cObject);
+    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, "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_cNode = rb_define_class_under(rb_mXML, "Node", rb_cObject);
+    rb_undef_alloc_func(rb_cNode);
+    rb_define_method(rb_cNode, "name", RUBY_METHOD_FUNC(node_name), 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_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_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, "xpath", RUBY_METHOD_FUNC(node_xpath), 1);
+
+    rb_cElement = rb_define_class_under(rb_mXML, "Element", rb_cNode);
+    rb_undef_alloc_func(rb_cElement);
+
+    rb_cText = rb_define_class_under(rb_mXML, "Text", rb_cNode);
+    rb_undef_alloc_func(rb_cText);
+
+    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_method(rb_cNodeSet, "[]", RUBY_METHOD_FUNC(nodeset_at), 1);
+    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);
+}

data/ext/rxerces/rxerces.h

@@ -0,0 +1,8 @@
+#ifndef RXERCES_H
+#define RXERCES_H
+
+#include <ruby.h>
+
+extern "C" void Init_rxerces(void);
+
+#endif

data/lib/rxerces/version.rb

@@ -0,0 +1,3 @@
+module RXerces
+  VERSION = "0.1.0"
+end

data/lib/rxerces.rb

@@ -0,0 +1,48 @@
+require 'rxerces/rxerces'
+require 'rxerces/version'
+
+# Main module providing Nokogiri-compatible XML parsing using Xerces-C
+module RXerces
+  # Parse XML from a string
+  # @param string [String] XML string to parse
+  # @return [RXerces::XML::Document] parsed document
+  def self.XML(string)
+    RXerces::XML::Document.parse(string)
+  end
+
+  # Alias for compatibility
+  class << self
+    alias_method :parse, :XML
+  end
+end
+
+# Nokogiri compatibility module
+module Nokogiri
+  # Nokogiri-compatible XML module
+  module XML
+    # Parse XML from a string - delegates to RXerces
+    # @param string [String] XML string to parse
+    # @return [RXerces::XML::Document] parsed document
+    def self.parse(string)
+      RXerces::XML::Document.parse(string)
+    end
+
+    # Alias Document class for compatibility
+    Document = RXerces::XML::Document
+    Node = RXerces::XML::Node
+    Element = RXerces::XML::Element
+    Text = RXerces::XML::Text
+    NodeSet = RXerces::XML::NodeSet
+  end
+
+  # Top-level parse method for compatibility
+  # @param string [String] XML string to parse
+  # @return [RXerces::XML::Document] parsed document
+  def self.XML(string)
+    RXerces::XML::Document.parse(string)
+  end
+
+  class << self
+    alias_method :parse, :XML
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: rxerces
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- RXerces Contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: A Ruby XML library with Nokogiri-compatible API, powered by Xerces-C
+  instead of libxml2
+email:
+- contributors@example.com
+executables: []
+extensions:
+- ext/rxerces/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- ext/rxerces/extconf.rb
+- ext/rxerces/rxerces.cpp
+- ext/rxerces/rxerces.h
+- lib/rxerces.rb
+- lib/rxerces/rxerces.bundle
+- lib/rxerces/version.rb
+homepage: https://github.com/example/rxerces
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Nokogiri-compatible XML library using Xerces-C
+test_files: []