rxerces 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a6f91adbbf73a000b638acc525461a8e0a06ce847bff4f8fd48ad5faf117483
-  data.tar.gz: ce10fe12e10294c5012624263cdbc05e4d751c7f62cad3647b2d73f88b19b8ab
+  metadata.gz: 5c6ba3896b05b5303ed0842c6ccc0376ce27e0325301dafe54472c73f9298ed9
+  data.tar.gz: 45844824ec1ca0ba91acf214cd1369466b40e1e0d7d1a653ed5ad7807a488e58
 SHA512:
-  metadata.gz: c70510870068a501df10218e42c2eee838df962588929e0731d7e37eb250a80f3e875f77646a254681b976f487435fa531aca4144c1efc39ba22c6ec79c722fc
-  data.tar.gz: 47cacc7b927ff6ea7a5c206cd24d2d44fb52bc74ebdb314d05fa67d3bacd8f228113d7053f759626f70acde116ddcfffa194969c85a46a6a8e7e5850f906f36e
+  metadata.gz: d9513b47e15bf8219c9cfc0a801763b656622e0f00c517d4e3cc3065b7775555d03ec1ad933eb309933e9bb9563ec234f66d19ce179693a265bac1a9a9d52f7e
+  data.tar.gz: 8df33c1af2dc29c325e2b82a148b2adaa75d61d1e80a7dba466b39cb0896ea9a26da3c53b564a84643330c70d88f239202ee87b3fedb7c2ca66e4b82e5eb4112

checksums.yaml.gz.sig

@@ -1,4 +1,4 @@
-���\�|�1�"�F:\�A���Ի�pI�r4s�h�ҿ��>H݄����{,�R��ҩ���rV87]�B�*̃_��}��jf�ku�0�Ҩ�ܸ=PIR8���Z��ܯ�
-kl��k@�'��(;�T�0��F-a��p�B"�(�Tu����pz8R�}'H#7}F@O/�L�l��H�h�%[%�
-^���ju�W���^��R/}-nUU�ZU�Q��j��ϳkS�q͆��GyQ:��:��`�q����	��<ǯo��xt
-��3\QK�gI���\9Lԟݺ��Zi�A��
+
+�J���A��h%۲���4z>@[re�j
+
+�͏�G��"�!�/���l��D��
�n���G�"C�J�)��8o��7Xc��E��h��*����v�T�C��VT�(F,�l������E��&��7�V��N&����0���ueE<�O�����I�uJR�L���FL���A��#K�@�c�(
����Å�v[O�����Icd�GDCxx��%��7X�+f%MY��(��������!+�/K����Ü�ZBd�AA�@�=_��@��yzF#%W�qZXi7�����=�29r����O���X}�4����P��fg^����Z?/Xw��C�o�>S���7�4���!%o��̇c^02cr@л���)W�2"N���

data/CHANGES.md

@@ -1,3 +1,11 @@
+## 0.4.0 - 15-Dec-2025
+* Now uses Xalan if installed for xpath 1.0 compliance.
+* Added Node#search.
+* Added Node#at and Node#at_xpath.
+* Added Document#encoding.
+* Added Node#namespace.
+* Added a placeholder css method for now, it's on the TODO list.
+
 ## 0.3.0 - 14-Dec-2025
 * Added Node#parent.
 * Added Element#attributes.

data/README.md

@@ -39,6 +39,28 @@ sudo apt-get install libxerces-c-dev
 sudo yum install xerces-c-devel
 ```
 
+### Xalan
+
+For XPath 1.0 compliance, you will need to install the Xalan library. Note
+that this is optional, and rxerces will default to using the Xpath support
+from Xerces, which is more limited.
+
+**Ubuntu/Debian:**
+```bash
+sudo apt-get install libxalan-c-dev
+```
+
+**Fedora/RHEL:**
+```bash
+sudo yum install xalan-c-devel
+```
+
+Note that MacOS, contrary to what the documentation currently says, does not
+have a brew package for Xalan. You will either need to use Mac ports or clone
+and build the code manually. I found that it required some tweaking to work:
+
+https://github.com/apache/xalan-c/pull/44
+
 ### Install the Gem
 
 Add this line to your application's Gemfile:
@@ -156,7 +178,7 @@ puts doc.to_s
 
 ### XPath Queries
 
-RXerces supports XPath queries using Xerces-C's XPath implementation:
+RXerces supports XPath queries using Xerces-C's XPath implementation by default:
 
 ```ruby
 xml = <<-XML
@@ -206,6 +228,8 @@ Not supported:
 
 For more complex queries, you can combine basic XPath with Ruby's `select` and `find` methods.
 
+For full XPath 1.0 support, install the Xalan library.
+
 ## API Reference
 
 ### RXerces Module
@@ -270,7 +294,7 @@ bundle exec rake
 
 - 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)
+- XPath support is basic by default (full XPath requires Xalan)
 - Memory management handled by Ruby's GC and Xerces-C's DOM
 
 ## Differences from Nokogiri

data/ext/rxerces/extconf.rb

@@ -29,4 +29,46 @@ unless find_header('xercesc/util/PlatformUtils.hpp')
   puts "Proceeding with compilation..."
 end
 
+# Check for Xalan-C (optional for enhanced XPath support)
+# Use dir_config which handles --with-xalan-dir and --with-xalan-include/lib
+dir_config('xalan')
+
+# Also try to auto-detect in common locations
+if RUBY_PLATFORM =~ /darwin/
+  homebrew_xalan = `brew --prefix xalan-c 2>/dev/null`.chomp
+  if !homebrew_xalan.empty? && File.directory?(homebrew_xalan)
+    $INCFLAGS << " -I#{homebrew_xalan}/include" unless $INCFLAGS.include?("-I#{homebrew_xalan}/include")
+    $LDFLAGS << " -L#{homebrew_xalan}/lib" unless $LDFLAGS.include?("-L#{homebrew_xalan}/lib")
+  end
+end
+
+# Try standard locations
+xalan_found_prefix = nil
+['/usr/local', '/opt/local', '/usr'].each do |prefix|
+  if File.directory?("#{prefix}/include/xalanc")
+    $INCFLAGS << " -I#{prefix}/include" unless $INCFLAGS.include?("-I#{prefix}/include")
+    $LDFLAGS << " -L#{prefix}/lib" unless $LDFLAGS.include?("-L#{prefix}/lib")
+    xalan_found_prefix = prefix
+    break
+  end
+end
+
+# Check for Xalan libraries
+# Note: We skip the header check because Xalan C++ headers require C++ compilation
+# which mkmf's find_header doesn't handle well. The library check is sufficient.
+if have_library('xalanMsg') && have_library('xalan-c')
+  $CXXFLAGS << " -DHAVE_XALAN"
+  # Add rpath so the dynamic libraries can be found at runtime
+  if xalan_found_prefix
+    $LDFLAGS << " -Wl,-rpath,#{xalan_found_prefix}/lib"
+  end
+  puts "Xalan-C found: Full XPath 1.0 support enabled"
+else
+  puts "Xalan-C not found: Using Xerces XPath subset"
+  puts "For full XPath 1.0 support, install Xalan-C:"
+  puts "  macOS: Build from source (no homebrew formula available)"
+  puts "  Linux: May be available via package manager"
+  puts "  Or specify: --with-xalan-dir=/path/to/xalan"
+end
+
 create_makefile('rxerces/rxerces')

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,11 @@ 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
 
 // Helper class to manage XMLCh strings
 class XStr {
@@ -246,7 +270,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 +343,25 @@ static VALUE document_to_s(VALUE self) {
     return Qnil;
 }
 
+// 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.create_element(name)
 static VALUE document_create_element(VALUE self, VALUE name) {
     DocumentWrapper* doc_wrapper;
@@ -354,6 +397,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 +512,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 +572,7 @@ 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
 }
 
 // node.name
@@ -434,6 +590,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;
@@ -880,6 +1054,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 +1108,26 @@ 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.css(selector) - CSS selectors not supported
+static VALUE node_css(VALUE self, VALUE selector) {
+    rb_raise(rb_eNotImpError, "CSS selectors are not supported. Use xpath() instead. Xerces-C only supports XPath queries.");
+    return Qnil;
 }
 
 // nodeset.length / nodeset.size
@@ -1162,17 +1361,19 @@ 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, "xpath", RUBY_METHOD_FUNC(document_xpath), 1);
+    rb_define_method(rb_cDocument, "encoding", RUBY_METHOD_FUNC(document_encoding), 0);
     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, "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_method(rb_cNode, "children", RUBY_METHOD_FUNC(node_children), 0);
@@ -1182,12 +1383,16 @@ static VALUE document_validate(VALUE self, VALUE rb_schema) {
     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_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_cElement = rb_define_class_under(rb_mXML, "Element", rb_cNode);
     rb_undef_alloc_func(rb_cElement);
@@ -1198,7 +1403,7 @@ 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, "each", RUBY_METHOD_FUNC(nodeset_each), 0);
     rb_define_method(rb_cNodeSet, "to_a", RUBY_METHOD_FUNC(nodeset_to_a), 0);

data/lib/rxerces/version.rb

@@ -1,3 +1,3 @@
 module RXerces
-  VERSION = "0.3.0".freeze
+  VERSION = "0.4.0".freeze
 end

data/rxerces.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name        = "rxerces"
-  spec.version     = "0.3.0"
+  spec.version     = "0.4.0"
   spec.author      = "Daniel J. Berger"
   spec.email       = "djberg96@gmail.com"
   spec.cert_chain  = ["certs/djberg96_pub.pem"]
@@ -17,7 +17,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake-compiler", "~> 1.2"
   spec.add_development_dependency "rspec", "~> 3.12"
 
-  spec.description = "A Ruby XML library with Nokogiri-compatible API, powered by Xerces-C instead of libxml2"
+  spec.description = <<-EOF
+    A Ruby XML library with Nokogiri-compatible API, powered by Xerces-C
+    instead of libxml2. It also optionally uses Xalan for Xpath 1.0 compliance.
+  EOF
 
   spec.metadata = {
     'homepage_uri'          => 'https://github.com/djberg96/rxerces',

data/spec/document_spec.rb

@@ -64,6 +64,25 @@ RSpec.describe RXerces::XML::Document do
     end
   end
 
+  describe "#encoding" do
+    it "returns UTF-8 for documents without explicit encoding" do
+      doc = RXerces::XML::Document.parse(simple_xml)
+      expect(doc.encoding).to eq('UTF-8')
+    end
+
+    it "returns the encoding specified in the XML declaration" do
+      xml_with_encoding = '<?xml version="1.0" encoding="ISO-8859-1"?><root><item>Test</item></root>'
+      doc = RXerces::XML::Document.parse(xml_with_encoding)
+      expect(doc.encoding).to eq('ISO-8859-1')
+    end
+
+    it "returns the encoding for UTF-16 documents" do
+      xml_with_encoding = '<?xml version="1.0" encoding="UTF-16"?><root><item>Test</item></root>'
+      doc = RXerces::XML::Document.parse(xml_with_encoding)
+      expect(doc.encoding).to eq('UTF-16')
+    end
+  end
+
   describe "#create_element" do
     let(:doc) { RXerces::XML::Document.parse(simple_xml) }
 

data/spec/node_spec.rb

@@ -29,6 +29,32 @@ RSpec.describe RXerces::XML::Node do
     end
   end
 
+  describe "#namespace" do
+    let(:ns_xml) do
+      <<-XML
+        <root xmlns="http://example.com/default">
+          <item>Default namespace</item>
+        </root>
+      XML
+    end
+    let(:ns_doc) { RXerces::XML::Document.parse(ns_xml) }
+
+    it "returns nil for nodes without a namespace" do
+      expect(root.namespace).to be_nil
+    end
+
+    it "returns the default namespace URI" do
+      ns_root = ns_doc.root
+      expect(ns_root.namespace).to eq('http://example.com/default')
+    end
+
+    it "returns the namespace for child elements inheriting default namespace" do
+      ns_root = ns_doc.root
+      item = ns_root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      expect(item.namespace).to eq('http://example.com/default')
+    end
+  end
+
   describe "#text" do
     it "returns text content" do
       person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
@@ -469,4 +495,65 @@ RSpec.describe RXerces::XML::Node do
       expect(text_node.blank?).to be true
     end
   end
+
+  describe "#search" do
+    it "is an alias for xpath" do
+      result1 = root.search('.//age')
+      result2 = root.xpath('.//age')
+      expect(result1.length).to eq(result2.length)
+      expect(result1.first.text).to eq(result2.first.text)
+    end
+
+    it "returns a NodeSet" do
+      result = root.search('.//person')
+      expect(result).to be_a(RXerces::XML::NodeSet)
+    end
+
+    it "finds nested elements" do
+      result = root.search('.//age')
+      expect(result.length).to eq(2)
+      expect(result.first.text).to eq('30')
+    end
+  end
+
+  describe "#at_xpath" do
+    it "returns the first matching node" do
+      result = root.at_xpath('.//age')
+      expect(result).to be_a(RXerces::XML::Element)
+      expect(result.text).to eq('30')
+    end
+
+    it "returns nil when no match found" do
+      result = root.at_xpath('.//nonexistent')
+      expect(result).to be_nil
+    end
+
+    it "returns only the first match when multiple exist" do
+      result = root.at_xpath('.//person')
+      expect(result['id']).to eq('1')
+    end
+  end
+
+  describe "#at" do
+    it "is an alias for at_xpath" do
+      result1 = root.at('.//age')
+      result2 = root.at_xpath('.//age')
+      expect(result1.text).to eq(result2.text)
+    end
+
+    it "returns the first matching element" do
+      result = root.at('.//city')
+      expect(result.text).to eq('New York')
+    end
+  end
+
+  describe "#css" do
+    it "raises NotImplementedError for CSS selectors" do
+      expect { root.css('div.class') }.to raise_error(NotImplementedError, /CSS selectors are not supported/)
+    end
+
+    it "suggests using xpath instead" do
+      expect { root.css('p') }.to raise_error(NotImplementedError, /Use xpath/)
+    end
+  end
 end

data/spec/rxerces_shared.rb

@@ -4,7 +4,7 @@ require 'rxerces'
 
 RSpec.shared_examples RXerces do
   example 'version number is set to the expected value' do
-    expect(RXerces::VERSION).to eq('0.3.0')
+    expect(RXerces::VERSION).to eq('0.4.0')
     expect(RXerces::VERSION).to be_frozen
   end
 end

data/spec/xpath_spec.rb

@@ -141,24 +141,258 @@ RSpec.describe "XPath support" do
     end
   end
 
-  describe "XPath limitations" do
-    it "notes that Xerces-C uses XML Schema XPath subset" do
-      # Xerces-C implements the XML Schema XPath subset, not full XPath 1.0
-      # This means the following are NOT supported:
-      # - Attribute predicates like [@id="1"]
-      # - Functions like last(), position(), text()
-      # - Comparison operators in predicates
-      #
-      # However, basic path expressions work well:
-      # - // (descendant-or-self)
-      # - / (child)
-      # - . (self)
-      # - .. (parent)
-
-      # Basic paths work
-      expect(doc.xpath('//book').length).to eq(3)
-      expect(doc.xpath('/library/book').length).to eq(3)
-      expect(doc.xpath('//title').length).to eq(3)
+  describe "XPath 1.0 compliance with Xalan" do
+    # Check if Xalan support is compiled in
+    xalan_available = begin
+      # Try a feature that only works with Xalan (attribute predicates)
+      test_xml = '<root><item id="1">A</item><item id="2">B</item></root>'
+      test_doc = RXerces::XML::Document.parse(test_xml)
+      result = test_doc.xpath('//item[@id="1"]')
+      result.length == 1
+    rescue
+      false
+    end
+
+    before(:all) do
+      unless xalan_available
+        skip "Xalan-C not available - XPath 1.0 features require Xalan-C library"
+      end
+    end
+
+    describe "Attribute predicates" do
+      it "finds elements by attribute value" do
+        book = doc.xpath('//book[@id="1"]')
+        expect(book.length).to eq(1)
+        expect(book[0].xpath('.//title')[0].text.strip).to eq('1984')
+      end
+
+      it "finds elements by attribute equality" do
+        fiction_books = doc.xpath('//book[@category="fiction"]')
+        expect(fiction_books.length).to eq(2)
+      end
+
+      it "finds elements by attribute inequality" do
+        non_fiction = doc.xpath('//book[@category!="fiction"]')
+        expect(non_fiction.length).to eq(1)
+        expect(non_fiction[0].xpath('.//title')[0].text.strip).to eq('Sapiens')
+      end
+
+      it "supports multiple attribute predicates" do
+        book = doc.xpath('//book[@id="2"][@category="fiction"]')
+        expect(book.length).to eq(1)
+        expect(book[0].xpath('.//title')[0].text.strip).to eq('Brave New World')
+      end
+    end
+
+    describe "Position and indexing functions" do
+      it "uses position() to find first element" do
+        first_book = doc.xpath('//book[position()=1]')
+        expect(first_book.length).to eq(1)
+        expect(first_book[0].xpath('.//title')[0].text.strip).to eq('1984')
+      end
+
+      it "uses last() to find last element" do
+        last_book = doc.xpath('//book[position()=last()]')
+        expect(last_book.length).to eq(1)
+        expect(last_book[0].xpath('.//title')[0].text.strip).to eq('Sapiens')
+      end
+
+      it "uses numeric predicates for indexing" do
+        second_book = doc.xpath('//book[2]')
+        expect(second_book.length).to eq(1)
+        expect(second_book[0].xpath('.//title')[0].text.strip).to eq('Brave New World')
+      end
+
+      it "finds elements by position greater than" do
+        later_books = doc.xpath('//book[position()>1]')
+        expect(later_books.length).to eq(2)
+      end
+    end
+
+    describe "String functions" do
+      it "uses contains() function" do
+        books_with_new = doc.xpath('//book[contains(.//title, "New")]')
+        expect(books_with_new.length).to eq(1)
+        expect(books_with_new[0].xpath('.//title')[0].text.strip).to eq('Brave New World')
+      end
+
+      it "uses starts-with() function" do
+        books_starting_with_1 = doc.xpath('//book[starts-with(.//title, "1")]')
+        expect(books_starting_with_1.length).to eq(1)
+        expect(books_starting_with_1[0].xpath('.//title')[0].text.strip).to eq('1984')
+      end
+
+      it "uses normalize-space() function" do
+        # Should find titles even with whitespace differences
+        result = doc.xpath('//title[normalize-space()="1984"]')
+        expect(result.length).to eq(1)
+      end
+
+      it "uses string-length() function" do
+        # Find books where title length is less than 10 characters
+        short_titles = doc.xpath('//book[string-length(.//title) < 10]')
+        expect(short_titles.length).to eq(2) # "1984" and "Sapiens"
+      end
+
+      it "uses concat() function" do
+        # This tests that concat works by checking if a book has matching text
+        # concat('19', '84') = '1984'
+        result = doc.xpath('//book[.//title = concat("19", "84")]')
+        expect(result.length).to eq(1)
+      end
+
+      it "uses substring() function" do
+        # Find books where first 5 chars of title is "Brave"
+        result = doc.xpath('//book[substring(.//title, 1, 5) = "Brave"]')
+        expect(result.length).to eq(1)
+        expect(result[0].xpath('.//title')[0].text.strip).to eq('Brave New World')
+      end
+    end
+
+    describe "Numeric functions and comparisons" do
+      it "uses count() function" do
+        # Find library element that has exactly 3 book children
+        result = doc.xpath('/library[count(book) = 3]')
+        expect(result.length).to eq(1)
+      end
+
+      it "compares numeric values with >" do
+        expensive_books = doc.xpath('//book[.//price > 15]')
+        expect(expensive_books.length).to eq(2) # 15.99 and 18.99
+      end
+
+      it "compares numeric values with <" do
+        cheap_books = doc.xpath('//book[.//price < 16]')
+        expect(cheap_books.length).to eq(2) # 15.99 and 14.99
+      end
+
+      it "compares numeric values with >=" do
+        books_1950_or_later = doc.xpath('//book[.//year >= 1949]')
+        expect(books_1950_or_later.length).to eq(2) # 1949 and 2011
+      end
+
+      it "uses sum() function" do
+        # sum() returns a number, not a nodeset, so we can't call it directly
+        # Instead, test it within a predicate
+        result = doc.xpath('//library[sum(book/price) > 40]')
+        expect(result.length).to eq(1) # Total is 49.97
+      end
+
+      it "uses floor() function" do
+        # Find books where floor(price) = 15 (15.99 -> 15)
+        result = doc.xpath('//book[floor(.//price) = 15]')
+        expect(result.length).to eq(1)
+      end
+
+      it "uses ceiling() function" do
+        # Find books where ceiling(price) = 19 (18.99 -> 19)
+        result = doc.xpath('//book[ceiling(.//price) = 19]')
+        expect(result.length).to eq(1)
+      end
+
+      it "uses round() function" do
+        # Find books where round(price) = 15 (14.99 -> 15, 15.99 -> 16)
+        result = doc.xpath('//book[round(.//price) = 15]')
+        expect(result.length).to eq(1) # Only 14.99
+      end
+    end
+
+    describe "Boolean operators" do
+      it "uses 'and' operator" do
+        result = doc.xpath('//book[@category="fiction" and .//year < 1940]')
+        expect(result.length).to eq(1) # Only "Brave New World" (1932)
+      end
+
+      it "uses 'or' operator" do
+        result = doc.xpath('//book[@id="1" or @id="3"]')
+        expect(result.length).to eq(2)
+      end
+
+      it "uses 'not()' function" do
+        result = doc.xpath('//book[not(@category="fiction")]')
+        expect(result.length).to eq(1)
+        expect(result[0].xpath('.//title')[0].text.strip).to eq('Sapiens')
+      end
+
+      it "combines multiple boolean operators" do
+        result = doc.xpath('//book[@category="fiction" and .//price < 15.50]')
+        expect(result.length).to eq(1) # Only "Brave New World" (14.99)
+      end
+    end
+
+    describe "Axes" do
+      it "uses parent:: axis" do
+        # Find parent of first title
+        first_title = doc.xpath('//title[1]')
+        parent = first_title[0].xpath('parent::*')
+        expect(parent.length).to eq(1)
+        expect(parent[0].name).to eq('book')
+      end
+
+      it "uses ancestor:: axis" do
+        # Find all ancestors of a title element
+        first_title = doc.xpath('//title[1]')
+        ancestors = first_title[0].xpath('ancestor::*')
+        expect(ancestors.length).to eq(2) # book and library
+      end
+
+      it "uses following-sibling:: axis" do
+        # Find siblings after title
+        first_title = doc.xpath('//title[1]')
+        siblings = first_title[0].xpath('following-sibling::*')
+        expect(siblings.length).to eq(3) # author, year, price
+      end
+
+      it "uses preceding-sibling:: axis" do
+        # Find siblings before author
+        first_author = doc.xpath('//author[1]')
+        siblings = first_author[0].xpath('preceding-sibling::*')
+        expect(siblings.length).to eq(1) # title
+      end
+
+      it "uses descendant:: axis" do
+        root = doc.root
+        descendants = root.xpath('descendant::title')
+        expect(descendants.length).to eq(3)
+      end
+
+      it "uses self:: axis" do
+        books = doc.xpath('//book')
+        self_nodes = books[0].xpath('self::book')
+        expect(self_nodes.length).to eq(1)
+      end
+    end
+
+    describe "Complex predicates" do
+      it "chains multiple predicates" do
+        result = doc.xpath('//book[@category="fiction"][.//year > 1940]')
+        expect(result.length).to eq(1) # Only "1984" (1949)
+      end
+
+      it "uses nested predicates" do
+        result = doc.xpath('//library[book[@category="fiction"]]')
+        expect(result.length).to eq(1)
+      end
+
+      it "combines functions in predicates" do
+        result = doc.xpath('//book[contains(.//title, "World") and .//year < 1950]')
+        expect(result.length).to eq(1)
+        expect(result[0].xpath('.//title')[0].text.strip).to eq('Brave New World')
+      end
+    end
+
+    describe "Text nodes" do
+      it "selects text nodes with text()" do
+        text_nodes = doc.xpath('//title/text()')
+        expect(text_nodes.length).to eq(3)
+      end
+
+      it "uses text() in predicates" do
+        result = doc.xpath('//title[text()="1984"]')
+        # Note: text() returns the raw text which includes whitespace
+        # This might not match due to whitespace, so we test it doesn't error
+        expect { result }.not_to raise_error
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rxerces
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Daniel J. Berger
@@ -78,8 +78,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.12'
-description: A Ruby XML library with Nokogiri-compatible API, powered by Xerces-C
-  instead of libxml2
+description: |2
+      A Ruby XML library with Nokogiri-compatible API, powered by Xerces-C
+      instead of libxml2. It also optionally uses Xalan for Xpath 1.0 compliance.
 email: djberg96@gmail.com
 executables: []
 extensions: