rxerces 0.3.0 → 0.5.0

data/lib/rxerces/nokogiri.rb

@@ -21,6 +21,25 @@ module Nokogiri
     Schema = RXerces::XML::Schema
   end
 
+  # Nokogiri-compatible HTML module
+  # Since RXerces uses Xerces-C which is an XML parser,
+  # HTML parsing delegates to XML parsing
+  module HTML
+    # Parse HTML from a string - delegates to XML parsing
+    # @param string [String] HTML 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
@@ -28,6 +47,13 @@ module Nokogiri
     RXerces::XML::Document.parse(string)
   end
 
+  # Top-level HTML parsing method
+  # @param string [String] HTML string to parse
+  # @return [RXerces::XML::Document] parsed document
+  def self.HTML(string)
+    RXerces::XML::Document.parse(string)
+  end
+
   class << self
     alias_method :parse, :XML
   end

data/lib/rxerces/version.rb

@@ -1,3 +1,3 @@
 module RXerces
-  VERSION = "0.3.0".freeze
+  VERSION = "0.5.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.5.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,84 @@ RSpec.describe RXerces::XML::Document do
     end
   end
 
+  describe "#css" do
+    # Check if Xalan support is compiled in (CSS requires XPath which needs Xalan)
+    xalan_available = begin
+      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 - CSS selectors require Xalan-C library"
+      end
+    end
+
+    let(:xml) do
+      <<-XML
+        <library>
+          <book id="book1" class="fiction">
+            <title>1984</title>
+          </book>
+          <book id="book2" class="non-fiction">
+            <title>Sapiens</title>
+          </book>
+        </library>
+      XML
+    end
+
+    let(:doc) { RXerces::XML::Document.parse(xml) }
+
+    it "returns a NodeSet" do
+      result = doc.css('book')
+      expect(result).to be_a(RXerces::XML::NodeSet)
+    end
+
+    it "finds elements by tag name" do
+      books = doc.css('book')
+      expect(books.length).to eq(2)
+    end
+
+    it "finds elements by class" do
+      fiction = doc.css('.fiction')
+      expect(fiction.length).to eq(1)
+    end
+
+    it "finds elements by id" do
+      book = doc.css('#book1')
+      expect(book.length).to eq(1)
+      expect(book[0].xpath('.//title')[0].text.strip).to eq('1984')
+    end
+
+    it "finds elements with combined selectors" do
+      fiction_books = doc.css('book.fiction')
+      expect(fiction_books.length).to eq(1)
+    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) }
@@ -84,6 +110,40 @@ RSpec.describe RXerces::XML::Node do
     end
   end
 
+  describe "#get_attribute" do
+    it "is an alias for []" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      expect(person.get_attribute('id')).to eq('1')
+      expect(person.get_attribute('name')).to eq('Alice')
+    end
+  end
+
+  describe "#attribute" do
+    it "is an alias for []" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      expect(person.attribute('id')).to eq('1')
+      expect(person.attribute('name')).to eq('Alice')
+    end
+  end
+
+  describe "#has_attribute?" do
+    it "returns true when attribute exists" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      expect(person.has_attribute?('id')).to be true
+      expect(person.has_attribute?('name')).to be true
+    end
+
+    it "returns false when attribute does not exist" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      expect(person.has_attribute?('nonexistent')).to be false
+    end
+
+    it "returns false for non-element nodes" do
+      text_node = root.children.find { |n| n.is_a?(RXerces::XML::Text) }
+      expect(text_node.has_attribute?('anything')).to be false if text_node
+    end
+  end
+
   describe "#children" do
     it "returns an array of child nodes" do
       children = root.children
@@ -132,6 +192,94 @@ RSpec.describe RXerces::XML::Node do
     end
   end
 
+  describe "#ancestors" do
+    it "returns an array of ancestor nodes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      age = person.children.find { |n| n.name == 'age' }
+      ancestors = age.ancestors
+
+      expect(ancestors).to be_an(Array)
+      expect(ancestors.length).to eq(2)
+      expect(ancestors[0].name).to eq('person')
+      expect(ancestors[1].name).to eq('root')
+    end
+
+    it "returns ancestors in order from immediate parent to root" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      city = person.children.find { |n| n.name == 'city' }
+      ancestors = city.ancestors
+
+      expect(ancestors.map(&:name)).to eq(['person', 'root'])
+    end
+
+    it "returns empty array for root element" do
+      ancestors = root.ancestors
+      expect(ancestors).to be_an(Array)
+      expect(ancestors).to be_empty
+    end
+
+    it "returns only one ancestor for direct children of root" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      ancestors = person.ancestors
+
+      expect(ancestors.length).to eq(1)
+      expect(ancestors[0].name).to eq('root')
+    end
+
+    it "does not include the document node in ancestors" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      ancestors = person.ancestors
+
+      expect(ancestors.any? { |a| a.name == '#document' }).to be false
+    end
+
+    context "with selector" do
+      # Check if Xalan support is compiled in (selectors require XPath which needs Xalan)
+      xalan_available = begin
+        test_xml = '<root><item id="1">A</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 - ancestor selectors require Xalan-C library"
+        end
+      end
+
+      it "filters ancestors by tag name selector" do
+        person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+        city = person.children.find { |n| n.name == 'city' }
+        ancestors = city.ancestors('person')
+
+        expect(ancestors.length).to eq(1)
+        expect(ancestors[0].name).to eq('person')
+      end
+
+      it "filters ancestors by CSS class selector" do
+        person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+        city = person.children.find { |n| n.name == 'city' }
+        person_ancestors = city.ancestors('person[name]')
+
+        expect(person_ancestors.length).to eq(1)
+        expect(person_ancestors[0].name).to eq('person')
+        expect(person_ancestors[0]['name']).to eq('Alice')
+      end
+
+      it "returns empty array when no ancestors match selector" do
+        person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+        city = person.children.find { |n| n.name == 'city' }
+        ancestors = city.ancestors('nonexistent')
+
+        expect(ancestors).to be_an(Array)
+        expect(ancestors).to be_empty
+      end
+    end
+  end
+
   describe "#attributes" do
     it "returns a hash of attributes" do
       person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
@@ -255,6 +403,103 @@ RSpec.describe RXerces::XML::Node do
     end
   end
 
+  describe "#element_children" do
+    it "returns only element children, filtering out text nodes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      element_children = person.element_children
+
+      expect(element_children).to be_an(Array)
+      expect(element_children.all? { |n| n.is_a?(RXerces::XML::Element) }).to be true
+      expect(element_children.length).to eq(2) # age and city elements
+      expect(element_children.map(&:name)).to match_array(['age', 'city'])
+    end
+
+    it "returns empty array for elements with no element children" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      age = person.element_children.find { |n| n.name == 'age' }
+      expect(age.element_children).to be_empty
+    end
+
+    it "returns empty array 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) }
+      expect(text_node.element_children).to be_empty if text_node
+    end
+  end
+
+  describe "#elements" do
+    it "is an alias for element_children" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      expect(person.elements.map(&:name)).to eq(person.element_children.map(&:name))
+      expect(person.elements.length).to eq(2)
+    end
+  end
+
+  describe "#next_element" do
+    it "returns the next element sibling, skipping text nodes" do
+      people = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      first_person = people[0]
+      next_element = first_person.next_element
+
+      expect(next_element).to be_a(RXerces::XML::Element)
+      expect(next_element.name).to eq('person')
+      expect(next_element['id']).to eq('2')
+    end
+
+    it "returns nil when there is no next element" do
+      people = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      last_person = people.last
+      expect(last_person.next_element).to be_nil
+    end
+
+    it "can navigate through all element siblings" do
+      first_element = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      siblings = []
+      current = first_element
+
+      while current
+        siblings << current
+        current = current.next_element
+      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_element" do
+    it "returns the previous element sibling, skipping text nodes" do
+      people = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      second_person = people[1]
+      prev_element = second_person.previous_element
+
+      expect(prev_element).to be_a(RXerces::XML::Element)
+      expect(prev_element.name).to eq('person')
+      expect(prev_element['id']).to eq('1')
+    end
+
+    it "returns nil when there is no previous element" do
+      first_element = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      expect(first_element.previous_element).to be_nil
+    end
+
+    it "can navigate backward through all element siblings" do
+      last_element = root.children.select { |n| n.is_a?(RXerces::XML::Element) }.last
+      siblings = []
+      current = last_element
+
+      while current
+        siblings.unshift(current)
+        current = current.previous_element
+      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) }
@@ -469,4 +714,193 @@ 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 "#at_css" do
+    # Check if Xalan support is compiled in (CSS requires XPath which needs Xalan)
+    xalan_available = begin
+      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 - CSS selectors require Xalan-C library"
+      end
+    end
+
+    it "is an alias for at (which uses CSS converted to XPath)" do
+      xml = '<root><item class="foo">First</item><item class="bar">Second</item></root>'
+      doc = RXerces::XML::Document.parse(xml)
+      result = doc.root.at_css('.foo')
+      expect(result).to be_a(RXerces::XML::Element)
+      expect(result.text).to eq('First')
+    end
+
+    it "returns the first matching element" do
+      xml = '<root><item>A</item><item>B</item></root>'
+      doc = RXerces::XML::Document.parse(xml)
+      result = doc.root.at_css('item')
+      expect(result.text).to eq('A')
+    end
+
+    it "returns nil when no match found" do
+      xml = '<root><item>A</item></root>'
+      doc = RXerces::XML::Document.parse(xml)
+      result = doc.root.at_css('nonexistent')
+      expect(result).to be_nil
+    end
+  end
+
+  describe "#css" do
+    # Check if Xalan support is compiled in (CSS requires XPath which needs Xalan)
+    xalan_available = begin
+      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 - CSS selectors require Xalan-C library"
+      end
+    end
+
+    let(:xml) do
+      <<-XML
+        <library>
+          <book id="book1" class="fiction bestseller">
+            <title>1984</title>
+            <author>George Orwell</author>
+          </book>
+          <book id="book2" class="fiction">
+            <title>Brave New World</title>
+            <author>Aldous Huxley</author>
+          </book>
+          <book id="book3" class="non-fiction">
+            <title>Sapiens</title>
+            <author>Yuval Noah Harari</author>
+          </book>
+        </library>
+      XML
+    end
+
+    let(:doc) { RXerces::XML::Document.parse(xml) }
+    let(:root) { doc.root }
+
+    it "finds elements by tag name" do
+      books = root.css('book')
+      expect(books.length).to eq(3)
+    end
+
+    it "finds elements by class" do
+      fiction = root.css('.fiction')
+      expect(fiction.length).to eq(2)
+    end
+
+    it "finds elements by id" do
+      book = root.css('#book1')
+      expect(book.length).to eq(1)
+      expect(book[0].xpath('.//title')[0].text.strip).to eq('1984')
+    end
+
+    it "finds elements by tag and class" do
+      fiction_books = root.css('book.fiction')
+      expect(fiction_books.length).to eq(2)
+    end
+
+    it "finds elements by tag and id" do
+      book = root.css('book#book2')
+      expect(book.length).to eq(1)
+      expect(book[0].xpath('.//title')[0].text.strip).to eq('Brave New World')
+    end
+
+    it "finds elements with attribute selector" do
+      books_with_id = root.css('book[id]')
+      expect(books_with_id.length).to eq(3)
+    end
+
+    it "finds elements with attribute value selector" do
+      book = root.css('book[id=book3]')
+      expect(book.length).to eq(1)
+      expect(book[0].xpath('.//title')[0].text.strip).to eq('Sapiens')
+    end
+
+    it "handles descendant combinator" do
+      titles = root.css('library title')
+      expect(titles.length).to eq(3)
+    end
+
+    it "handles child combinator" do
+      books = root.css('library > book')
+      expect(books.length).to eq(3)
+    end
+
+    it "finds nested elements" do
+      authors = root.css('book author')
+      expect(authors.length).to eq(3)
+    end
+
+    it "combines multiple selectors" do
+      result = root.css('book.fiction title')
+      expect(result.length).to eq(2)
+    end
+  end
 end

data/spec/nodeset_spec.rb

@@ -86,6 +86,65 @@ RSpec.describe RXerces::XML::NodeSet do
     end
   end
 
+  describe "#first" do
+    it "returns the first node" do
+      first = nodeset.first
+      expect(first).to be_a(RXerces::XML::Element)
+      expect(first.text.strip).to eq('First')
+    end
+
+    it "returns nil for empty nodeset" do
+      expect(empty_nodeset.first).to be_nil
+    end
+  end
+
+  describe "#last" do
+    it "returns the last node" do
+      last = nodeset.last
+      expect(last).to be_a(RXerces::XML::Element)
+      expect(last.text.strip).to eq('Third')
+    end
+
+    it "returns nil for empty nodeset" do
+      expect(empty_nodeset.last).to be_nil
+    end
+  end
+
+  describe "#empty?" do
+    it "returns false for non-empty nodeset" do
+      expect(nodeset.empty?).to be false
+    end
+
+    it "returns true for empty nodeset" do
+      expect(empty_nodeset.empty?).to be true
+    end
+  end
+
+  describe "#inner_html" do
+    it "returns concatenated inner_html of all nodes" do
+      result = nodeset.inner_html
+      expect(result).to be_a(String)
+      expect(result).to eq('FirstSecondThird')
+    end
+
+    it "returns empty string for empty nodeset" do
+      expect(empty_nodeset.inner_html).to eq('')
+    end
+
+    it "includes child elements in inner_html" do
+      xml_with_children = <<-XML
+        <root>
+          <div><span>A</span></div>
+          <div><span>B</span></div>
+        </root>
+      XML
+      doc = RXerces::XML::Document.parse(xml_with_children)
+      divs = doc.xpath('//div')
+      expect(divs.inner_html).to include('<span>A</span>')
+      expect(divs.inner_html).to include('<span>B</span>')
+    end
+  end
+
   it "includes Enumerable" do
     expect(RXerces::XML::NodeSet.ancestors).to include(Enumerable)
   end