rxerces 0.6.1 → 0.7.0

data/lib/rxerces/version.rb

@@ -1,3 +1,3 @@
 module RXerces
-  VERSION = "0.6.1".freeze
+  VERSION = "0.7.0".freeze
 end

data/lib/rxerces.rb

@@ -5,9 +5,10 @@ require 'rxerces/version'
 module RXerces
   # Parse XML from a string
   # @param string [String] XML string to parse
+  # @param options [Hash] parsing options
   # @return [RXerces::XML::Document] parsed document
-  def self.XML(string)
-    RXerces::XML::Document.parse(string)
+  def self.XML(string, **options)
+    RXerces::XML::Document.parse(string, **options)
   end
 
   # Alias for compatibility

data/rxerces.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name        = "rxerces"
-  spec.version     = "0.6.1"
+  spec.version     = "0.7.0"
   spec.author      = "Daniel J. Berger"
   spec.email       = "djberg96@gmail.com"
   spec.cert_chain  = ["certs/djberg96_pub.pem"]
@@ -16,6 +16,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rake-compiler", "~> 1.2"
   spec.add_development_dependency "rspec", "~> 3.12"
+  spec.add_development_dependency "mkmf-lite", "~> 0.7.5"
 
   spec.description = <<-EOF
     A Ruby XML library with Nokogiri-compatible API, powered by Xerces-C

data/spec/document_spec.rb

@@ -27,6 +27,76 @@ RSpec.describe RXerces::XML::Document do
       doc = RXerces::XML::Document.parse(complex_xml)
       expect(doc).to be_a(RXerces::XML::Document)
     end
+
+    it "handles empty documents" do
+      expect {
+        RXerces::XML::Document.parse('')
+      }.to raise_error(RuntimeError, /invalid document structure/)
+    end
+
+    it "handles documents with only XML declaration" do
+      expect {
+        RXerces::XML::Document.parse('<?xml version="1.0"?>')
+      }.to raise_error(RuntimeError, /invalid document structure/)
+    end
+
+    it "handles deeply nested elements" do
+      # Create XML with 50 levels of nesting
+      xml = '<root>'
+      50.times { |i| xml += "<level#{i}>" }
+      xml += 'deep content'
+      50.times { |i| xml += "</level#{49-i}>" }
+      xml += '</root>'
+
+      doc = RXerces::XML::Document.parse(xml)
+      expect(doc).to be_a(RXerces::XML::Document)
+      expect(doc.root.name).to eq('root')
+
+      # Verify we can access deeply nested content
+      deepest = doc.root
+      50.times { |i| deepest = deepest.element_children.first }
+      expect(deepest.text).to eq('deep content')
+    end
+
+    it "handles documents with CDATA sections" do
+      xml_with_cdata = '<root><![CDATA[<not>&parsed;]]></root>'
+      doc = RXerces::XML::Document.parse(xml_with_cdata)
+      expect(doc.root.text).to eq('<not>&parsed;')
+    end
+
+    it "handles documents with processing instructions" do
+      xml_with_pi = '<?xml-stylesheet type="text/xsl" href="style.xsl"?><root>content</root>'
+      doc = RXerces::XML::Document.parse(xml_with_pi)
+      expect(doc.root.text).to eq('content')
+    end
+
+    it "handles documents with comments" do
+      xml_with_comment = '<root><!-- This is a comment -->content</root>'
+      doc = RXerces::XML::Document.parse(xml_with_comment)
+      expect(doc.root.text).to eq('content')
+    end
+
+    it "handles mixed content" do
+      mixed_xml = '<root>text <b>bold</b> more text <i>italic</i> end</root>'
+      doc = RXerces::XML::Document.parse(mixed_xml)
+      expect(doc.root.children.length).to eq(5) # 3 text nodes + 2 elements
+      expect(doc.root.text).to eq('text bold more text italic end')
+    end
+
+    it "handles elements with many attributes" do
+      xml_many_attrs = '<root ' + (1..100).map { |i| "attr#{i}=\"value#{i}\"" }.join(' ') + '>content</root>'
+      doc = RXerces::XML::Document.parse(xml_many_attrs)
+      expect(doc.root.attributes.length).to eq(100)
+      expect(doc.root['attr50']).to eq('value50')
+    end
+
+    it "handles large text content" do
+      large_text = 'x' * 10000
+      xml_large = "<root>#{large_text}</root>"
+      doc = RXerces::XML::Document.parse(xml_large)
+      expect(doc.root.text.length).to eq(10000)
+      expect(doc.root.text).to start_with('xxxxx')
+    end
   end
 
   describe "#root" do
@@ -64,23 +134,7 @@ 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
-
+  describe "#css", xalan: true do
     let(:xml) do
       <<-XML
         <library>
@@ -234,4 +288,117 @@ RSpec.describe RXerces::XML::Document do
       end
     end
   end
+
+  describe "parse options validation" do
+    let(:simple_xml) { '<root><child>test</child></root>' }
+
+    context "with valid options" do
+      it "accepts no options" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml)
+        }.not_to raise_error
+      end
+
+      it "accepts nil options" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, nil)
+        }.not_to raise_error
+      end
+
+      it "accepts empty hash" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, {})
+        }.not_to raise_error
+      end
+
+      it "accepts allow_external_entities with symbol key" do
+        expect {
+          doc = RXerces::XML::Document.parse(simple_xml, allow_external_entities: false)
+          expect(doc).to be_a(RXerces::XML::Document)
+        }.not_to raise_error
+      end
+
+      it "accepts allow_external_entities with string key" do
+        expect {
+          doc = RXerces::XML::Document.parse(simple_xml, 'allow_external_entities' => false)
+          expect(doc).to be_a(RXerces::XML::Document)
+        }.not_to raise_error
+      end
+
+      it "accepts allow_external_entities set to true" do
+        expect {
+          doc = RXerces::XML::Document.parse(simple_xml, allow_external_entities: true)
+          expect(doc).to be_a(RXerces::XML::Document)
+        }.not_to raise_error
+      end
+    end
+
+    context "with invalid options" do
+      it "rejects unknown option keys" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, unknown_option: true)
+        }.to raise_error(ArgumentError, /Unknown option: unknown_option/)
+      end
+
+      it "rejects multiple unknown options and reports the first one" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, foo: 1, bar: 2)
+        }.to raise_error(ArgumentError, /Unknown option:/)
+      end
+
+      it "lists allowed options in error message" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, invalid: true)
+        }.to raise_error(ArgumentError, /Allowed options are: allow_external_entities/)
+      end
+
+      it "rejects options with both valid and invalid keys" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml,
+                                      allow_external_entities: true,
+                                      invalid_key: false)
+        }.to raise_error(ArgumentError, /Unknown option: invalid_key/)
+      end
+
+      it "rejects non-string, non-symbol keys" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, 123 => true)
+        }.to raise_error(ArgumentError, /Option keys must be symbols or strings/)
+      end
+
+      it "rejects options that are not a hash" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, "not a hash")
+        }.to raise_error(TypeError)
+      end
+
+      it "rejects options array" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, [:allow_external_entities])
+        }.to raise_error(TypeError)
+      end
+    end
+
+    context "security" do
+      it "prevents typos from silently disabling security features" do
+        # If someone mistypes allow_external_entities, it should fail
+        # rather than silently ignoring the option
+        expect {
+          RXerces::XML::Document.parse(simple_xml, allow_external_entity: true)
+        }.to raise_error(ArgumentError, /Unknown option/)
+      end
+
+      it "prevents typos with underscores" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, allowexternalentities: true)
+        }.to raise_error(ArgumentError, /Unknown option/)
+      end
+
+      it "prevents similar-looking options" do
+        expect {
+          RXerces::XML::Document.parse(simple_xml, external_entities: true)
+        }.to raise_error(ArgumentError, /Unknown option/)
+      end
+    end
+  end
 end

data/spec/node_spec.rb

@@ -65,6 +65,50 @@ RSpec.describe RXerces::XML::Node do
     it "returns empty string for nodes without text" do
       expect(root.text).to be_a(String)
     end
+
+    context "edge cases" do
+      let(:edge_xml) do
+        <<-XML
+          <root>
+            <empty></empty>
+            <mixed>Hello <b>world</b>!</mixed>
+            <whitespace>   </whitespace>
+            <cdata><![CDATA[<not>parsed</not>]]></cdata>
+            <multiline>
+              Line 1
+              Line 2
+            </multiline>
+          </root>
+        XML
+      end
+      let(:edge_doc) { RXerces::XML::Document.parse(edge_xml) }
+      let(:edge_root) { edge_doc.root }
+
+      it "returns empty string for empty elements" do
+        empty = edge_root.children.find { |n| n.name == 'empty' }
+        expect(empty.text).to eq('')
+      end
+
+      it "concatenates text from mixed content elements" do
+        mixed = edge_root.children.find { |n| n.name == 'mixed' }
+        expect(mixed.text).to eq('Hello world!')
+      end
+
+      it "preserves whitespace-only content" do
+        whitespace = edge_root.children.find { |n| n.name == 'whitespace' }
+        expect(whitespace.text).to eq('   ')
+      end
+
+      it "returns CDATA content as plain text" do
+        cdata = edge_root.children.find { |n| n.name == 'cdata' }
+        expect(cdata.text).to eq('<not>parsed</not>')
+      end
+
+      it "preserves multiline text content" do
+        multiline = edge_root.children.find { |n| n.name == 'multiline' }
+        expect(multiline.text).to include("Line 1\n              Line 2")
+      end
+    end
   end
 
   describe "#content" do
@@ -142,6 +186,33 @@ RSpec.describe RXerces::XML::Node 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
+
+    context "edge cases" do
+      let(:attr_xml) do
+        <<-XML
+          <root>
+            <element empty="" xmlns:prefix="http://example.com" special_chars="a&amp;b&lt;c&gt;">
+              content
+            </element>
+          </root>
+        XML
+      end
+      let(:attr_doc) { RXerces::XML::Document.parse(attr_xml) }
+      let(:element) { attr_doc.root.children.find { |n| n.is_a?(RXerces::XML::Element) } }
+
+      it "handles empty string attribute values" do
+        expect(element['empty']).to be_nil
+        expect(element.has_attribute?('empty')).to be false
+      end
+
+      it "handles attributes with special characters" do
+        expect(element['special_chars']).to eq('a&b<c>')
+      end
+
+      it "handles namespace prefix attributes" do
+        expect(element['xmlns:prefix']).to eq('http://example.com')
+      end
+    end
   end
 
   describe "#children" do
@@ -233,23 +304,7 @@ RSpec.describe RXerces::XML::Node do
       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
-
+    context "with selector", xalan: true do
       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' }
@@ -312,6 +367,45 @@ RSpec.describe RXerces::XML::Node do
     end
   end
 
+  describe "#attribute_nodes" do
+    it "returns an array of attribute nodes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      attr_nodes = person.attribute_nodes
+      expect(attr_nodes).to be_an(Array)
+      expect(attr_nodes.length).to eq(2)
+      expect(attr_nodes.all? { |n| n.is_a?(RXerces::XML::Node) }).to be true
+    end
+
+    it "returns nodes with name and text/value" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      attr_nodes = person.attribute_nodes
+
+      id_node = attr_nodes.find { |n| n.name == 'id' }
+      expect(id_node).not_to be_nil
+      expect(id_node.text).to eq('1')
+
+      name_node = attr_nodes.find { |n| n.name == 'name' }
+      expect(name_node).not_to be_nil
+      expect(name_node.text).to eq('Alice')
+    end
+
+    it "returns empty array for elements without attributes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      age = person.children.find { |n| n.name == 'age' }
+      attr_nodes = age.attribute_nodes
+      expect(attr_nodes).to be_an(Array)
+      expect(attr_nodes).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) }
+      attr_nodes = text_node.attribute_nodes
+      expect(attr_nodes).to be_an(Array)
+      expect(attr_nodes).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) }
@@ -554,25 +648,104 @@ RSpec.describe RXerces::XML::Node do
     end
 
     context "with nodes from different documents" do
-      it "raises error when adding node from different document" do
+      it "automatically imports 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) }
 
+        # Should not raise an error - should import automatically
         expect {
           root1.add_child(item2)
-        }.to raise_error(RuntimeError, /belongs to a different document/)
+        }.not_to raise_error
+
+        # Verify the node was added
+        items = doc1.xpath('//item')
+        expect(items.length).to eq(2)
       end
 
-      it "provides helpful error message mentioning importNode" do
+      it "imports node with all its children (deep copy)" do
         doc1 = RXerces::XML::Document.parse('<root></root>')
-        doc2 = RXerces::XML::Document.parse('<other><child/></other>')
+        doc2 = RXerces::XML::Document.parse('<other><parent><child>text</child></parent></other>')
 
-        expect {
-          doc1.root.add_child(doc2.root.children.first)
-        }.to raise_error(RuntimeError, /importNode/)
+        parent_node = doc2.xpath('//parent').first
+
+        # Add parent node from doc2 to doc1
+        doc1.root.add_child(parent_node)
+
+        # Verify the entire subtree was imported
+        expect(doc1.xpath('//parent').length).to eq(1)
+        expect(doc1.xpath('//parent/child').length).to eq(1)
+        expect(doc1.xpath('//parent/child').first.text).to eq('text')
+      end
+
+      it "preserves node content when importing" do
+        doc1 = RXerces::XML::Document.parse('<root></root>')
+        doc2 = RXerces::XML::Document.parse('<other><item attr="value">content</item></other>')
+
+        item = doc2.xpath('//item').first
+        doc1.root.add_child(item)
+
+        imported_item = doc1.xpath('//item').first
+        expect(imported_item.text).to eq('content')
+        expect(imported_item['attr']).to eq('value')
+      end
+
+      it "does not modify the original document when importing" do
+        doc1 = RXerces::XML::Document.parse('<root></root>')
+        doc2 = RXerces::XML::Document.parse('<other><item>original</item></other>')
+
+        item = doc2.xpath('//item').first
+        doc1.root.add_child(item)
+
+        # Original document should still have the item
+        # Note: importNode creates a copy, but the Ruby wrapper gets updated
+        # to point to the imported node, so we need to re-query doc2
+        expect(doc2.xpath('//item').length).to eq(1)
+      end
+
+      it "handles importing complex nested structures" do
+        doc1 = RXerces::XML::Document.parse('<root></root>')
+        doc2 = RXerces::XML::Document.parse(<<-XML)
+          <other>
+            <section id="s1">
+              <title>Section 1</title>
+              <paragraph>Content 1</paragraph>
+              <subsection>
+                <title>Subsection</title>
+                <paragraph>Nested content</paragraph>
+              </subsection>
+            </section>
+          </other>
+        XML
+
+        section = doc2.xpath('//section').first
+        doc1.root.add_child(section)
+
+        # Verify entire structure was imported
+        expect(doc1.xpath('//section').length).to eq(1)
+        expect(doc1.xpath('//section').first['id']).to eq('s1')
+        expect(doc1.xpath('//title').length).to eq(2)
+        expect(doc1.xpath('//paragraph').length).to eq(2)
+        expect(doc1.xpath('//subsection').length).to eq(1)
+      end
+
+      it "allows importing multiple nodes from different documents" do
+        doc1 = RXerces::XML::Document.parse('<root></root>')
+        doc2 = RXerces::XML::Document.parse('<other><item>A</item></other>')
+        doc3 = RXerces::XML::Document.parse('<another><item>B</item></another>')
+
+        item2 = doc2.xpath('//item').first
+        item3 = doc3.xpath('//item').first
+
+        doc1.root.add_child(item2)
+        doc1.root.add_child(item3)
+
+        items = doc1.xpath('//item')
+        expect(items.length).to eq(2)
+        expect(items[0].text).to eq('A')
+        expect(items[1].text).to eq('B')
       end
     end
 
@@ -674,6 +847,37 @@ RSpec.describe RXerces::XML::Node do
       result = root.xpath('.//age')
       expect(result).to be_a(RXerces::XML::NodeSet)
     end
+
+    context "edge cases" do
+      it "returns empty NodeSet for nonexistent elements" do
+        result = root.xpath('.//nonexistent')
+        expect(result).to be_a(RXerces::XML::NodeSet)
+        expect(result.length).to eq(0)
+      end
+
+      it "raises error for invalid XPath syntax" do
+        expect {
+          root.xpath('.//[invalid')
+        }.to raise_error(ArgumentError, /XPath expression has unbalanced/)
+      end
+
+      it "handles very deep XPath expressions" do
+        # Create a deep nesting scenario
+        deep_xml = '<root>' + ('<level>' * 50) + '<deep>content</deep>' + ('</level>' * 50) + '</root>'
+        deep_doc = RXerces::XML::Document.parse(deep_xml)
+        result = deep_doc.xpath('//deep')
+        expect(result.length).to eq(1)
+        expect(result.first.text).to eq('content')
+      end
+
+      it "handles XPath with special characters in element names" do
+        special_xml = '<root><element-name_with.specials>content</element-name_with.specials></root>'
+        special_doc = RXerces::XML::Document.parse(special_xml)
+        result = special_doc.xpath('//element-name_with.specials')
+        expect(result.length).to eq(1)
+        expect(result.first.text).to eq('content')
+      end
+    end
   end
 
   describe "#inner_html" do
@@ -823,23 +1027,7 @@ 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
-
+  describe "#at_css", xalan: true do
     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)
@@ -863,23 +1051,7 @@ RSpec.describe RXerces::XML::Node 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
-
+  describe "#css", xalan: true do
     let(:xml) do
       <<-XML
         <library>