rxerces 0.4.0 → 0.6.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.4.0".freeze
+  VERSION = "0.6.0".freeze
 end

data/rxerces.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name        = "rxerces"
-  spec.version     = "0.4.0"
+  spec.version     = "0.6.0"
   spec.author      = "Daniel J. Berger"
   spec.email       = "djberg96@gmail.com"
   spec.cert_chain  = ["certs/djberg96_pub.pem"]

data/spec/document_spec.rb

@@ -64,6 +64,65 @@ 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)
@@ -117,4 +176,62 @@ RSpec.describe RXerces::XML::Document do
       expect(result.first.text).to eq('New content')
     end
   end
+
+  describe "#errors" do
+    it "returns empty array for valid XML" do
+      doc = RXerces::XML::Document.parse(simple_xml)
+      expect(doc.errors).to eq([])
+    end
+
+    it "returns empty array for complex valid XML" do
+      doc = RXerces::XML::Document.parse(complex_xml)
+      expect(doc.errors).to eq([])
+    end
+
+    context "with malformed XML" do
+      it "raises error and provides line/column information for unclosed tags" do
+        expect {
+          RXerces::XML::Document.parse('<root><item>test</root>')
+        }.to raise_error(RuntimeError, /Fatal error at line \d+, column \d+/)
+      end
+
+      it "raises error with detailed message for multiple errors" do
+        expect {
+          RXerces::XML::Document.parse('<root><item>test</item><unclosed>')
+        }.to raise_error(RuntimeError, /Fatal error at line/)
+      end
+
+      it "raises error for completely invalid XML" do
+        expect {
+          RXerces::XML::Document.parse('not xml at all')
+        }.to raise_error(RuntimeError, /Fatal error at line/)
+      end
+
+      it "raises error for mismatched tags" do
+        expect {
+          RXerces::XML::Document.parse('<root><item>test</other></root>')
+        }.to raise_error(RuntimeError, /Fatal error at line/)
+      end
+    end
+
+    context "error message format" do
+      it "includes line number in error message" do
+        expect {
+          RXerces::XML::Document.parse('<root><bad>')
+        }.to raise_error(RuntimeError, /line \d+/)
+      end
+
+      it "includes column number in error message" do
+        expect {
+          RXerces::XML::Document.parse('<root><bad>')
+        }.to raise_error(RuntimeError, /column \d+/)
+      end
+
+      it "describes the error type" do
+        expect {
+          RXerces::XML::Document.parse('<root><item>test</root>')
+        }.to raise_error(RuntimeError, /expected end of tag/)
+      end
+    end
+  end
 end

data/spec/node_spec.rb

@@ -110,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
@@ -158,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) }
@@ -281,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) }
@@ -333,6 +552,63 @@ RSpec.describe RXerces::XML::Node do
       xml_output = simple_doc.to_s
       expect(xml_output).to include("Content")
     end
+
+    context "with nodes from different documents" do
+      it "raises error when adding node from different document" do
+        doc1 = RXerces::XML::Document.parse('<root><item>one</item></root>')
+        doc2 = RXerces::XML::Document.parse('<other><item>two</item></other>')
+
+        root1 = doc1.root
+        item2 = doc2.root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+
+        expect {
+          root1.add_child(item2)
+        }.to raise_error(RuntimeError, /belongs to a different document/)
+      end
+
+      it "provides helpful error message mentioning importNode" do
+        doc1 = RXerces::XML::Document.parse('<root></root>')
+        doc2 = RXerces::XML::Document.parse('<other><child/></other>')
+
+        expect {
+          doc1.root.add_child(doc2.root.children.first)
+        }.to raise_error(RuntimeError, /importNode/)
+      end
+    end
+
+    context "when child already has a parent" do
+      it "moves node from one parent to another (detaches automatically)" do
+        doc = RXerces::XML::Document.parse('<root><parent1><child>text</child></parent1><parent2/></root>')
+        parent1 = doc.xpath('//parent1').first
+        parent2 = doc.xpath('//parent2').first
+        child = doc.xpath('//child').first
+
+        # Verify initial state
+        expect(parent1.children.select { |n| n.is_a?(RXerces::XML::Element) }.length).to eq(1)
+        expect(parent2.children.select { |n| n.is_a?(RXerces::XML::Element) }.length).to eq(0)
+
+        # Move child from parent1 to parent2
+        parent2.add_child(child)
+
+        # Child should now be under parent2, not parent1
+        expect(parent1.children.select { |n| n.is_a?(RXerces::XML::Element) }.length).to eq(0)
+        expect(parent2.children.select { |n| n.is_a?(RXerces::XML::Element) }.length).to eq(1)
+        expect(doc.xpath('//parent2/child').length).to eq(1)
+        expect(doc.xpath('//parent1/child').length).to eq(0)
+      end
+
+      it "preserves node content when moving" do
+        doc = RXerces::XML::Document.parse('<root><a><item>content</item></a><b/></root>')
+        a = doc.xpath('//a').first
+        b = doc.xpath('//b').first
+        item = doc.xpath('//item').first
+
+        b.add_child(item)
+
+        expect(item.text).to eq('content')
+        expect(doc.xpath('//b/item').first.text).to eq('content')
+      end
+    end
   end
 
   describe "#remove" do
@@ -547,13 +823,141 @@ RSpec.describe RXerces::XML::Node do
     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
-    it "raises NotImplementedError for CSS selectors" do
-      expect { root.css('div.class') }.to raise_error(NotImplementedError, /CSS selectors are not supported/)
+    # 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 "suggests using xpath instead" do
-      expect { root.css('p') }.to raise_error(NotImplementedError, /Use xpath/)
+    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