rxerces 0.2.0 → 0.4.0

data/lib/rxerces/nokogiri.rb

@@ -18,6 +18,7 @@ module Nokogiri
     Element = RXerces::XML::Element
     Text = RXerces::XML::Text
     NodeSet = RXerces::XML::NodeSet
+    Schema = RXerces::XML::Schema
   end
 
   # Top-level parse method for compatibility

data/lib/rxerces/version.rb

@@ -1,3 +1,3 @@
 module RXerces
-  VERSION = "0.2.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.2.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

@@ -63,4 +63,58 @@ RSpec.describe RXerces::XML::Document do
       expect(result).to be_a(RXerces::XML::NodeSet)
     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) }
+
+    it "creates a new element with the specified name" do
+      element = doc.create_element('book')
+      expect(element).to be_a(RXerces::XML::Element)
+      expect(element.name).to eq('book')
+    end
+
+    it "creates an element that can have attributes set" do
+      element = doc.create_element('book')
+      attributes = element.attributes
+      expect(attributes).to be_a(Hash)
+      expect(attributes).to be_empty
+    end
+
+    it "creates an element that can have children added" do
+      element = doc.create_element('book')
+      element.add_child('Test Content')
+      expect(element.text).to eq('Test Content')
+    end
+
+    it "creates an element that can be added to the document" do
+      root = doc.root
+      new_element = doc.create_element('new_child')
+      new_element.add_child('New content')
+      root.add_child(new_element)
+
+      # Verify the new element is in the document
+      result = doc.xpath('//new_child')
+      expect(result.length).to eq(1)
+      expect(result.first.text).to eq('New content')
+    end
+  end
 end

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) }
@@ -102,10 +128,432 @@ RSpec.describe RXerces::XML::Node do
     end
   end
 
+  describe "#parent" do
+    it "returns the parent node" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      parent = person.parent
+      expect(parent).to be_a(RXerces::XML::Element)
+      expect(parent.name).to eq('root')
+    end
+
+    it "returns the parent for nested elements" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      age = person.children.find { |n| n.name == 'age' }
+      parent = age.parent
+      expect(parent).to be_a(RXerces::XML::Element)
+      expect(parent.name).to eq('person')
+      expect(parent['id']).to eq('1')
+    end
+
+    it "returns the document for root element" do
+      parent = root.parent
+      expect(parent).not_to be_nil
+      expect(parent.name).to eq('#document')
+    end
+
+    it "returns nil for nodes without parent" do
+      # This is edge case - all nodes in a parsed document have parents
+      # but we test the safety of the method
+      expect(root.parent).not_to be_nil
+    end
+  end
+
+  describe "#attributes" do
+    it "returns a hash of attributes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      attrs = person.attributes
+      expect(attrs).to be_a(Hash)
+      expect(attrs['id']).to eq('1')
+      expect(attrs['name']).to eq('Alice')
+    end
+
+    it "returns all attributes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      attrs = person.attributes
+      expect(attrs.keys).to match_array(['id', 'name'])
+    end
+
+    it "returns empty hash for elements without attributes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      age = person.children.find { |n| n.name == 'age' }
+      attrs = age.attributes
+      expect(attrs).to be_a(Hash)
+      expect(attrs).to be_empty
+    end
+
+    it "returns empty hash for text nodes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      text_node = person.children.find { |n| n.is_a?(RXerces::XML::Text) }
+      attrs = text_node.attributes
+      expect(attrs).to be_a(Hash)
+      expect(attrs).to be_empty
+    end
+  end
+
+  describe "#next_sibling" do
+    it "returns the next sibling node" do
+      people = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      first_person = people[0]
+      next_node = first_person.next_sibling
+
+      # May be a text node (whitespace) between elements
+      # Skip to next element if needed
+      while next_node && next_node.is_a?(RXerces::XML::Text)
+        next_node = next_node.next_sibling
+      end
+
+      expect(next_node).to be_a(RXerces::XML::Element)
+      expect(next_node.name).to eq('person')
+      expect(next_node['id']).to eq('2')
+    end
+
+    it "returns nil for last sibling" do
+      people = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      last_person = people.last
+
+      # Navigate past any trailing whitespace
+      next_node = last_person.next_sibling
+      while next_node && next_node.is_a?(RXerces::XML::Text)
+        next_node = next_node.next_sibling
+      end
+
+      expect(next_node).to be_nil
+    end
+
+    it "can navigate through all siblings" do
+      first_element = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      siblings = []
+      current = first_element
+
+      while current
+        siblings << current if current.is_a?(RXerces::XML::Element)
+        current = current.next_sibling
+      end
+
+      expect(siblings.length).to eq(2)
+      expect(siblings[0]['id']).to eq('1')
+      expect(siblings[1]['id']).to eq('2')
+    end
+  end
+
+  describe "#previous_sibling" do
+    it "returns the previous sibling node" do
+      people = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      second_person = people[1]
+      prev_node = second_person.previous_sibling
+
+      # May be a text node (whitespace) between elements
+      # Skip to previous element if needed
+      while prev_node && prev_node.is_a?(RXerces::XML::Text)
+        prev_node = prev_node.previous_sibling
+      end
+
+      expect(prev_node).to be_a(RXerces::XML::Element)
+      expect(prev_node.name).to eq('person')
+      expect(prev_node['id']).to eq('1')
+    end
+
+    it "returns nil for first sibling" do
+      first_element = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+
+      # Navigate past any leading whitespace
+      prev_node = first_element.previous_sibling
+      while prev_node && prev_node.is_a?(RXerces::XML::Text)
+        prev_node = prev_node.previous_sibling
+      end
+
+      expect(prev_node).to be_nil
+    end
+
+    it "can navigate backward through all siblings" do
+      last_element = root.children.select { |n| n.is_a?(RXerces::XML::Element) }.last
+      siblings = []
+      current = last_element
+
+      while current
+        siblings.unshift(current) if current.is_a?(RXerces::XML::Element)
+        current = current.previous_sibling
+      end
+
+      expect(siblings.length).to eq(2)
+      expect(siblings[0]['id']).to eq('1')
+      expect(siblings[1]['id']).to eq('2')
+    end
+  end
+
+  describe "#add_child" do
+    it "adds a text node from a string" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      initial_count = person.children.length
+
+      person.add_child("New text content")
+
+      expect(person.children.length).to eq(initial_count + 1)
+      last_child = person.children.last
+      expect(last_child).to be_a(RXerces::XML::Text)
+      expect(last_child.text).to eq("New text content")
+    end
+
+    it "adds a new element to another element" do
+      # Create a simple document to test with
+      simple_xml = '<root><parent></parent></root>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      parent = simple_doc.root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+
+      # Add text child
+      parent.add_child("Hello World")
+
+      expect(parent.children.length).to be > 0
+      text_child = parent.children.find { |n| n.is_a?(RXerces::XML::Text) }
+      expect(text_child.text).to eq("Hello World")
+    end
+
+    it "allows building a document structure" do
+      simple_xml = '<root></root>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      root = simple_doc.root
+
+      # Add multiple children
+      root.add_child("First text")
+      root.add_child("Second text")
+
+      text_nodes = root.children.select { |n| n.is_a?(RXerces::XML::Text) }
+      expect(text_nodes.length).to eq(2)
+      expect(text_nodes[0].text).to eq("First text")
+      expect(text_nodes[1].text).to eq("Second text")
+    end
+
+    it "modifies the document" do
+      simple_xml = '<item></item>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      item = simple_doc.root
+
+      item.add_child("Content")
+
+      xml_output = simple_doc.to_s
+      expect(xml_output).to include("Content")
+    end
+  end
+
+  describe "#remove" do
+    it "removes a node from its parent" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      initial_count = root.children.select { |n| n.is_a?(RXerces::XML::Element) }.length
+
+      person.remove
+
+      remaining = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      expect(remaining.length).to eq(initial_count - 1)
+    end
+
+    it "removes a child element from parent" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      age = person.children.find { |n| n.name == 'age' }
+      initial_count = person.children.select { |n| n.is_a?(RXerces::XML::Element) }.length
+
+      age.remove
+
+      remaining = person.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      expect(remaining.length).to eq(initial_count - 1)
+      expect(person.children.find { |n| n.name == 'age' }).to be_nil
+    end
+
+    it "modifies the document" do
+      simple_xml = '<root><item>Remove me</item><keep>Keep me</keep></root>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      item = simple_doc.xpath('//item').first
+
+      item.remove
+
+      xml_output = simple_doc.to_s
+      expect(xml_output).not_to include("Remove me")
+      expect(xml_output).to include("Keep me")
+    end
+
+    it "raises error when node has no parent" do
+      # The root element's parent is the document, so this should work
+      # We'll test with a document node instead
+      expect {
+        root.parent.remove
+      }.to raise_error(RuntimeError, /no parent/)
+    end
+  end
+
+  describe "#unlink" do
+    it "is an alias for remove" do
+      simple_xml = '<root><item>Test</item></root>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      item = simple_doc.xpath('//item').first
+
+      expect(item).to respond_to(:unlink)
+      item.unlink
+
+      xml_output = simple_doc.to_s
+      expect(xml_output).not_to include("Test")
+    end
+  end
+
   describe "#xpath" do
     it "returns a NodeSet" do
       result = root.xpath('.//age')
       expect(result).to be_a(RXerces::XML::NodeSet)
     end
   end
+
+  describe "#inner_html" do
+    it "returns the XML content of children without parent tags" do
+      person = root.xpath('//person').first
+      inner = person.inner_html
+      expect(inner).to include('<age>')
+      expect(inner).to include('<city>')
+      expect(inner).not_to include('<person')
+    end
+
+    it "returns empty string for nodes without children" do
+      age = root.xpath('//age').first
+      inner = age.inner_html
+      expect(inner).to eq('30')
+    end
+
+    it "includes multiple children" do
+      person = root.xpath('//person').first
+      inner = person.inner_html
+      expect(inner).to include('<age>30</age>')
+      expect(inner).to include('<city>New York</city>')
+    end
+  end
+
+  describe "#inner_xml" do
+    it "is an alias for inner_html" do
+      person = root.xpath('//person').first
+      expect(person.inner_xml).to eq(person.inner_html)
+    end
+
+    it "returns the same XML content" do
+      person = root.xpath('//person').first
+      inner = person.inner_xml
+      expect(inner).to include('<age>')
+      expect(inner).to include('<city>')
+    end
+  end
+
+  describe "#path" do
+    it "returns the XPath to the root element" do
+      expect(root.path).to eq('/root[1]')
+    end
+
+    it "returns the XPath to a nested element" do
+      person = root.xpath('//person').first
+      expect(person.path).to eq('/root[1]/person[1]')
+    end
+
+    it "returns the XPath to the second person element" do
+      people = root.xpath('//person')
+      second_person = people[1]
+      expect(second_person.path).to eq('/root[1]/person[2]')
+    end
+
+    it "returns the XPath to deeply nested elements" do
+      age = root.xpath('//age').first
+      expect(age.path).to eq('/root[1]/person[1]/age[1]')
+    end
+  end
+
+  describe "#blank?" do
+    let(:blank_xml) { '<root><empty></empty><whitespace>   </whitespace><content>Hello</content></root>' }
+    let(:blank_doc) { RXerces::XML::Document.parse(blank_xml) }
+
+    it "returns false for elements with text content" do
+      content = blank_doc.xpath('//content').first
+      expect(content.blank?).to be false
+    end
+
+    it "returns true for empty elements" do
+      empty = blank_doc.xpath('//empty').first
+      expect(empty.blank?).to be true
+    end
+
+    it "returns true for elements with only whitespace" do
+      whitespace = blank_doc.xpath('//whitespace').first
+      expect(whitespace.blank?).to be true
+    end
+
+    it "returns false for elements with child elements" do
+      root = blank_doc.root
+      expect(root.blank?).to be false
+    end
+
+    it "returns false for text nodes with content" do
+      content = blank_doc.xpath('//content').first
+      text_node = content.children.first
+      expect(text_node.blank?).to be false
+    end
+
+    it "returns true for text nodes with only whitespace" do
+      whitespace = blank_doc.xpath('//whitespace').first
+      text_node = whitespace.children.first
+      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/nokogiri_compatibility_spec.rb

@@ -61,6 +61,12 @@ RSpec.describe "Nokogiri compatibility" do
     end
   end
 
+  describe "Nokogiri::XML::Schema" do
+    it "is an alias for RXerces::XML::Schema" do
+      expect(Nokogiri::XML::Schema).to eq(RXerces::XML::Schema)
+    end
+  end
+
   describe "API compatibility" do
     let(:doc) { Nokogiri.XML(simple_xml) }
 
@@ -95,4 +101,67 @@ RSpec.describe "Nokogiri compatibility" do
       expect(children).to be_an(Array)
     end
   end
+
+  describe "Schema validation compatibility" do
+    let(:xsd) do
+      <<~XSD
+        <?xml version="1.0"?>
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+          <xs:element name="person">
+            <xs:complexType>
+              <xs:sequence>
+                <xs:element name="name" type="xs:string"/>
+                <xs:element name="age" type="xs:integer"/>
+              </xs:sequence>
+            </xs:complexType>
+          </xs:element>
+        </xs:schema>
+      XSD
+    end
+
+    let(:valid_xml) do
+      <<~XML
+        <?xml version="1.0"?>
+        <person>
+          <name>John</name>
+          <age>30</age>
+        </person>
+      XML
+    end
+
+    let(:invalid_xml) do
+      <<~XML
+        <?xml version="1.0"?>
+        <person>
+          <name>Jane</name>
+          <age>invalid</age>
+        </person>
+      XML
+    end
+
+    it "provides Schema.from_string method" do
+      schema = Nokogiri::XML::Schema.from_string(xsd)
+      expect(schema).to be_a(Nokogiri::XML::Schema)
+    end
+
+    it "provides Schema.from_document method" do
+      doc = Nokogiri::XML.parse(xsd)
+      schema = Nokogiri::XML::Schema.from_document(doc)
+      expect(schema).to be_a(Nokogiri::XML::Schema)
+    end
+
+    it "validates a valid document" do
+      schema = Nokogiri::XML::Schema.from_string(xsd)
+      doc = Nokogiri::XML.parse(valid_xml)
+      errors = doc.validate(schema)
+      expect(errors).to be_empty
+    end
+
+    it "returns errors for an invalid document" do
+      schema = Nokogiri::XML::Schema.from_string(xsd)
+      doc = Nokogiri::XML.parse(invalid_xml)
+      errors = doc.validate(schema)
+      expect(errors).not_to be_empty
+    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.2.0')
+    expect(RXerces::VERSION).to eq('0.4.0')
     expect(RXerces::VERSION).to be_frozen
   end
 end