rxerces 0.6.0 → 0.7.0

data/spec/nodeset_spec.rb

@@ -145,6 +145,96 @@ RSpec.describe RXerces::XML::NodeSet do
     end
   end
 
+  describe "#inspect" do
+    it "returns a string representation" do
+      result = nodeset.inspect
+      expect(result).to be_a(String)
+      expect(result).to include('RXerces::XML::NodeSet')
+    end
+
+    it "shows element names in the output" do
+      result = nodeset.inspect
+      expect(result).to include('<item>')
+    end
+
+    it "truncates long content" do
+      long_xml = '<root><item>' + ('x' * 100) + '</item></root>'
+      doc = RXerces::XML::Document.parse(long_xml)
+      result = doc.xpath('//item').inspect
+      expect(result).to include('...')
+      expect(result.length).to be < long_xml.length
+    end
+
+    context "with UTF-8 content" do
+      it "handles multi-byte characters without corruption" do
+        # Test with various multi-byte UTF-8 characters
+        utf8_xml = '<root><item>Hello 世界 🌍 Привет</item></root>'
+        doc = RXerces::XML::Document.parse(utf8_xml)
+        result = doc.xpath('//item').inspect
+
+        # Should not raise encoding errors
+        expect { result.encode('UTF-8') }.not_to raise_error
+        expect(result.encoding).to eq(Encoding::UTF_8)
+      end
+
+      it "truncates UTF-8 strings safely without cutting mid-character" do
+        # Create a string with multi-byte characters that would be cut off
+        # Use Japanese characters (3 bytes each in UTF-8) near the truncation boundary
+        long_text = 'a' * 25 + '世界你好こんにちは' + 'x' * 50
+        utf8_xml = "<root><item>#{long_text}</item></root>"
+        doc = RXerces::XML::Document.parse(utf8_xml)
+        result = doc.xpath('//item').inspect
+
+        # Result should be valid UTF-8
+        expect(result).to be_valid_encoding
+        expect { result.encode('UTF-8') }.not_to raise_error
+      end
+
+      it "handles emojis and 4-byte UTF-8 characters" do
+        # Emojis are 4-byte UTF-8 characters
+        emoji_xml = '<root><item>Test 🎉🎊🎈🎁🎀🎂 more text here that is quite long</item></root>'
+        doc = RXerces::XML::Document.parse(emoji_xml)
+        result = doc.xpath('//item').inspect
+
+        expect(result).to be_valid_encoding
+        expect { result.encode('UTF-8') }.not_to raise_error
+      end
+
+      it "handles mixed ASCII and multi-byte characters" do
+        mixed_xml = '<root><item>ASCII テキスト text 文字 more</item></root>'
+        doc = RXerces::XML::Document.parse(mixed_xml)
+        result = doc.xpath('//item').inspect
+
+        expect(result).to be_valid_encoding
+      end
+
+      it "handles UTF-8 in text nodes" do
+        text_xml = '<root><item>こんにちは世界' + ('x' * 50) + '</item></root>'
+        doc = RXerces::XML::Document.parse(text_xml)
+        # Get the item element which contains the text
+        result = doc.xpath('//item').inspect
+
+        expect(result).to be_valid_encoding
+      end
+
+      it "handles Cyrillic characters" do
+        cyrillic_xml = '<root><item>Привет мир это длинный текст на русском языке</item></root>'
+        doc = RXerces::XML::Document.parse(cyrillic_xml)
+        result = doc.xpath('//item').inspect
+
+        expect(result).to be_valid_encoding
+      end
+
+      it "handles Arabic characters" do
+        arabic_xml = '<root><item>مرحبا بالعالم هذا نص طويل بالعربية</item></root>'
+        doc = RXerces::XML::Document.parse(arabic_xml)
+        result = doc.xpath('//item').inspect
+
+        expect(result).to be_valid_encoding
+      end
+    end
+  end
+
   it "includes Enumerable" do
     expect(RXerces::XML::NodeSet.ancestors).to include(Enumerable)
   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.6.0')
+    expect(RXerces::VERSION).to eq('0.7.0')
     expect(RXerces::VERSION).to be_frozen
   end
 end

data/spec/rxerces_spec.rb

@@ -20,4 +20,62 @@ RSpec.describe RXerces do
       expect(doc).to be_a(RXerces::XML::Document)
     end
   end
+
+  describe "thread safety" do
+    it "handles concurrent initialization safely" do
+      xml = '<root><child>text</child></root>'
+      threads = []
+      results = []
+
+      # Create multiple threads that parse XML concurrently
+      10.times do
+        threads << Thread.new do
+          doc = RXerces.XML(xml)
+          results << doc.class
+        end
+      end
+
+      # Wait for all threads to complete
+      threads.each(&:join)
+
+      # All should succeed and return Document objects
+      expect(results.size).to eq(10)
+      results.each do |result|
+        expect(result).to eq(RXerces::XML::Document)
+      end
+    end
+  end
+
+  describe "security" do
+    it "prevents XXE attacks by not processing external entities" do
+      # XML with external entity reference
+      malicious_xml = <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE foo [ <!ENTITY xxe SYSTEM "file:///etc/passwd"> ]>
+        <foo>&xxe;</foo>
+      XML
+
+      # Should fail to parse because external entities are disabled
+      expect {
+        RXerces.XML(malicious_xml)
+      }.to raise_error(RuntimeError, /unable to open external entity/)
+    end
+
+    it "allows external entities when explicitly enabled" do
+      # XML with external entity reference
+      xml_with_entity = <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE foo [ <!ENTITY test "test content"> ]>
+        <foo>&test;</foo>
+      XML
+
+      # Should succeed with internal entities even when external are disabled
+      doc = RXerces.XML(xml_with_entity)
+      expect(doc.root.text).to eq("test content")
+
+      # With allow_external_entities: true, should still handle internal entities
+      doc2 = RXerces.XML(xml_with_entity, allow_external_entities: true)
+      expect(doc2.root.text).to eq("test content")
+    end
+  end
 end

data/spec/schema_spec.rb

@@ -44,7 +44,7 @@ RSpec.describe RXerces::XML::Schema do
     end
 
     # Note: Xerces-C parser is very tolerant of invalid XML
-    # So we just skip testing for invalid XML for now
+    # Schema creation succeeds even with malformed XML, validation catches issues
   end
 
   describe '.from_document' do
@@ -72,5 +72,32 @@ RSpec.describe RXerces::XML::Schema do
       expect(errors).not_to be_empty
       expect(errors.first).to include('not-a-number')
     end
+
+    it 'handles schema grammar loading errors gracefully' do
+      # Create a schema with an invalid type reference
+      invalid_schema_xsd = <<~XSD
+        <?xml version="1.0"?>
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+          <xs:element name="root">
+            <xs:complexType>
+              <xs:sequence>
+                <xs:element name="invalid" type="invalid-type"/>
+              </xs:sequence>
+            </xs:complexType>
+          </xs:element>
+        </xs:schema>
+      XSD
+
+      invalid_schema = described_class.from_string(invalid_schema_xsd)
+      doc = RXerces::XML::Document.parse(valid_xml)
+
+      # Validation should handle XMLException/SAXException in loadGrammar gracefully
+      # and continue with validation, producing errors
+      errors = doc.validate(invalid_schema)
+      expect(errors).to be_a(Array)
+      expect(errors).not_to be_empty
+      # Should contain errors about the invalid type
+      expect(errors.join).to include('invalid-type')
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,8 +1,11 @@
 require 'rspec'
 require 'rxerces'
 require 'rxerces_shared'
+require 'mkmf-lite'
 
 RSpec.configure do |config|
+  include Mkmf::Lite
+
   # Enable flags like --only-failures and --next-failure
   config.example_status_persistence_file_path = ".rspec_status"
 
@@ -14,4 +17,6 @@ RSpec.configure do |config|
   end
 
   config.include_context(RXerces)
+
+  config.filter_run_excluding(:xalan) unless have_library('xalan-c')
 end

data/spec/xpath_cache_spec.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe "XPath Validation Cache" do
+  let(:doc) { RXerces::XML::Document.parse('<root><item id="1"/><item id="2"/></root>') }
+
+  # Helper to generate unique XPath expressions that work with or without Xalan
+  # With Xalan: uses attribute predicates for more realistic expressions
+  # Without Xalan: uses unique element names
+  def unique_xpath(prefix, index)
+    if RXerces.xalan_enabled?
+      "//item[@id='#{prefix}_#{index}']"
+    else
+      "//#{prefix}#{index}"
+    end
+  end
+
+  before(:each) do
+    # Reset to default state before each test
+    RXerces.cache_xpath_validation = true
+    RXerces.xpath_validation_cache_max_size = 10_000
+    RXerces.clear_xpath_validation_cache
+  end
+
+  after(:all) do
+    # Restore defaults after all tests
+    RXerces.cache_xpath_validation = true
+    RXerces.xpath_validation_cache_max_size = 10_000
+  end
+
+  describe "configuration methods" do
+    describe ".cache_xpath_validation?" do
+      it "returns true by default" do
+        expect(RXerces.cache_xpath_validation?).to be true
+      end
+
+      it "returns false when caching is disabled" do
+        RXerces.cache_xpath_validation = false
+        expect(RXerces.cache_xpath_validation?).to be false
+      end
+    end
+
+    describe ".cache_xpath_validation=" do
+      it "enables caching when set to true" do
+        RXerces.cache_xpath_validation = false
+        RXerces.cache_xpath_validation = true
+        expect(RXerces.cache_xpath_validation?).to be true
+      end
+
+      it "disables caching when set to false" do
+        RXerces.cache_xpath_validation = false
+        expect(RXerces.cache_xpath_validation?).to be false
+      end
+
+      it "accepts truthy values" do
+        RXerces.cache_xpath_validation = 1
+        expect(RXerces.cache_xpath_validation?).to be true
+      end
+
+      it "accepts falsy values" do
+        RXerces.cache_xpath_validation = nil
+        expect(RXerces.cache_xpath_validation?).to be false
+      end
+    end
+
+    describe ".xpath_validation_cache_size" do
+      it "returns 0 when cache is empty" do
+        expect(RXerces.xpath_validation_cache_size).to eq(0)
+      end
+
+      it "increases after XPath queries" do
+        doc.xpath("//item")
+        expect(RXerces.xpath_validation_cache_size).to eq(1)
+      end
+
+      it "does not double-count repeated expressions" do
+        3.times { doc.xpath("//item") }
+        expect(RXerces.xpath_validation_cache_size).to eq(1)
+      end
+
+      it "counts unique expressions" do
+        doc.xpath("//item")
+        if RXerces.xalan_enabled?
+          doc.xpath("//item[@id='1']")
+        else
+          doc.xpath("//root")
+        end
+        doc.xpath("/root/item")
+        expect(RXerces.xpath_validation_cache_size).to eq(3)
+      end
+    end
+
+    describe ".xpath_validation_cache_max_size" do
+      it "returns 10000 by default" do
+        expect(RXerces.xpath_validation_cache_max_size).to eq(10_000)
+      end
+    end
+
+    describe ".xpath_validation_cache_max_size=" do
+      it "sets the maximum cache size" do
+        RXerces.xpath_validation_cache_max_size = 5000
+        expect(RXerces.xpath_validation_cache_max_size).to eq(5000)
+      end
+
+      it "accepts large values" do
+        RXerces.xpath_validation_cache_max_size = 100_000
+        expect(RXerces.xpath_validation_cache_max_size).to eq(100_000)
+      end
+
+      it "accepts zero" do
+        RXerces.xpath_validation_cache_max_size = 0
+        expect(RXerces.xpath_validation_cache_max_size).to eq(0)
+      end
+
+      it "raises TypeError for non-integer values" do
+        expect { RXerces.xpath_validation_cache_max_size = "1000" }.to raise_error(TypeError)
+        expect { RXerces.xpath_validation_cache_max_size = 1.5 }.to raise_error(TypeError)
+        expect { RXerces.xpath_validation_cache_max_size = nil }.to raise_error(TypeError)
+      end
+
+      it "raises ArgumentError for negative values" do
+        expect { RXerces.xpath_validation_cache_max_size = -1 }.to raise_error(ArgumentError)
+        expect { RXerces.xpath_validation_cache_max_size = -100 }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe ".clear_xpath_validation_cache" do
+      it "empties the cache" do
+        doc.xpath("//item")
+        if RXerces.xalan_enabled?
+          doc.xpath("//item[@id='1']")
+        else
+          doc.xpath("//root")
+        end
+        expect(RXerces.xpath_validation_cache_size).to be > 0
+
+        RXerces.clear_xpath_validation_cache
+        expect(RXerces.xpath_validation_cache_size).to eq(0)
+      end
+
+      it "returns nil" do
+        expect(RXerces.clear_xpath_validation_cache).to be_nil
+      end
+    end
+
+    describe ".xalan_enabled?" do
+      it "returns a boolean" do
+        expect([true, false]).to include(RXerces.xalan_enabled?)
+      end
+    end
+
+    describe ".xpath_max_length" do
+      it "returns 10000 by default" do
+        expect(RXerces.xpath_max_length).to eq(10_000)
+      end
+    end
+
+    describe ".xpath_max_length=" do
+      after(:each) do
+        # Restore default after each test
+        RXerces.xpath_max_length = 10_000
+      end
+
+      it "sets the maximum XPath expression length" do
+        RXerces.xpath_max_length = 5000
+        expect(RXerces.xpath_max_length).to eq(5000)
+      end
+
+      it "accepts zero to disable the limit" do
+        RXerces.xpath_max_length = 0
+        expect(RXerces.xpath_max_length).to eq(0)
+      end
+
+      it "raises TypeError for non-integer values" do
+        expect { RXerces.xpath_max_length = "1000" }.to raise_error(TypeError)
+        expect { RXerces.xpath_max_length = 1.5 }.to raise_error(TypeError)
+        expect { RXerces.xpath_max_length = nil }.to raise_error(TypeError)
+      end
+
+      it "raises ArgumentError for negative values" do
+        expect { RXerces.xpath_max_length = -1 }.to raise_error(ArgumentError)
+        expect { RXerces.xpath_max_length = -100 }.to raise_error(ArgumentError)
+      end
+
+      it "rejects XPath expressions exceeding the limit" do
+        RXerces.xpath_max_length = 50
+        expect {
+          doc.xpath("//" + "a" * 50)
+        }.to raise_error(ArgumentError, /too long/)
+      end
+
+      it "allows XPath expressions within the limit" do
+        RXerces.xpath_max_length = 100
+        expect { doc.xpath("//item") }.not_to raise_error
+      end
+
+      it "allows any length when set to zero" do
+        RXerces.xpath_max_length = 0
+        # This would normally exceed the default 10k limit
+        long_xpath = "//" + "a" * 15_000
+        # Should not raise "too long" error - verify by checking it doesn't match that pattern
+        begin
+          doc.xpath(long_xpath)
+        rescue ArgumentError => e
+          expect(e.message).not_to match(/too long/)
+        end
+      end
+    end
+  end
+
+  describe "caching behavior" do
+    it "caches validated expressions when enabled" do
+      RXerces.cache_xpath_validation = true
+      doc.xpath("//item")
+      expect(RXerces.xpath_validation_cache_size).to eq(1)
+    end
+
+    it "does not cache when disabled" do
+      RXerces.cache_xpath_validation = false
+      doc.xpath("//item")
+      expect(RXerces.xpath_validation_cache_size).to eq(0)
+    end
+
+    it "reuses cached validations for identical expressions" do
+      # This is implicitly tested by the fact that repeated queries
+      # don't increase cache size
+      xpath = RXerces.xalan_enabled? ? "//item[@id='1']" : "//item"
+      5.times { doc.xpath(xpath) }
+      expect(RXerces.xpath_validation_cache_size).to eq(1)
+    end
+
+    it "caches expressions from different documents" do
+      doc2 = RXerces::XML::Document.parse('<data><value/></data>')
+
+      doc.xpath("//item")
+      doc2.xpath("//value")
+      doc.xpath("//item")  # Should hit cache
+      doc2.xpath("//value") # Should hit cache
+
+      expect(RXerces.xpath_validation_cache_size).to eq(2)
+    end
+
+    it "caches expressions from node-level xpath calls" do
+      root = doc.root
+      root.xpath(".//item")
+      expect(RXerces.xpath_validation_cache_size).to eq(1)
+    end
+
+    it "shares cache between document and node xpath calls" do
+      doc.xpath("//item")
+      doc.root.xpath("//item")  # Same expression, should reuse cache
+      expect(RXerces.xpath_validation_cache_size).to eq(1)
+    end
+
+    it "respects max cache size" do
+      RXerces.xpath_validation_cache_max_size = 3
+
+      doc.xpath("//a")
+      doc.xpath("//b")
+      doc.xpath("//c")
+      initial_size = RXerces.xpath_validation_cache_size
+
+      # Cache should be at max
+      expect(initial_size).to eq(3)
+
+      # Additional expressions should not increase size beyond max
+      doc.xpath("//d")
+      doc.xpath("//e")
+      expect(RXerces.xpath_validation_cache_size).to eq(3)
+    end
+
+    it "uses LRU eviction when cache is full" do
+      RXerces.xpath_validation_cache_max_size = 3
+
+      # Add 3 expressions: //a is oldest, //c is newest
+      doc.xpath("//a")
+      doc.xpath("//b")
+      doc.xpath("//c")
+
+      # Access //a again to make it most recently used
+      # Now order is: //a (newest), //c, //b (oldest)
+      doc.xpath("//a")
+
+      # Add //d, which should evict //b (least recently used)
+      doc.xpath("//d")
+      expect(RXerces.xpath_validation_cache_size).to eq(3)
+
+      # //a should still be cached (was accessed recently)
+      # We can verify by checking that accessing it doesn't change cache size
+      doc.xpath("//a")
+      expect(RXerces.xpath_validation_cache_size).to eq(3)
+
+      # //b was evicted, adding it again should evict //c (now oldest)
+      doc.xpath("//b")
+      expect(RXerces.xpath_validation_cache_size).to eq(3)
+
+      # Cache should now contain: //b, //a, //d (in MRU order)
+      # //c was evicted
+    end
+  end
+
+  describe "thread safety" do
+    it "handles concurrent xpath queries without errors" do
+      threads = 10.times.map do |i|
+        Thread.new do
+          100.times do |j|
+            doc.xpath(unique_xpath("t#{i}", j))
+          end
+        end
+      end
+
+      expect { threads.each(&:join) }.not_to raise_error
+    end
+
+    it "handles concurrent cache configuration changes" do
+      threads = []
+
+      # Thread toggling cache on/off
+      threads << Thread.new do
+        50.times do
+          RXerces.cache_xpath_validation = false
+          RXerces.cache_xpath_validation = true
+        end
+      end
+
+      # Threads doing xpath queries
+      3.times do |i|
+        threads << Thread.new do
+          50.times do |j|
+            doc.xpath(unique_xpath("c#{i}", j))
+          end
+        end
+      end
+
+      expect { threads.each(&:join) }.not_to raise_error
+    end
+
+    it "handles concurrent cache clearing" do
+      threads = []
+
+      # Thread clearing cache periodically
+      threads << Thread.new do
+        20.times do
+          sleep(0.001)
+          RXerces.clear_xpath_validation_cache
+        end
+      end
+
+      # Threads doing xpath queries
+      3.times do |i|
+        threads << Thread.new do
+          100.times do |j|
+            doc.xpath(unique_xpath("r#{i}", j))
+          end
+        end
+      end
+
+      expect { threads.each(&:join) }.not_to raise_error
+    end
+
+    it "returns consistent cache size under concurrent access" do
+      # Fill cache with known expressions
+      10.times { |i| doc.xpath("//item#{i}") }
+      initial_size = RXerces.xpath_validation_cache_size
+
+      # Read cache size from multiple threads
+      sizes = []
+      mutex = Mutex.new
+
+      threads = 5.times.map do
+        Thread.new do
+          10.times do
+            size = RXerces.xpath_validation_cache_size
+            mutex.synchronize { sizes << size }
+          end
+        end
+      end
+
+      threads.each(&:join)
+
+      # All reads should return consistent values (either the initial
+      # size or values after any concurrent modifications)
+      expect(sizes).to all(be >= 0)
+    end
+  end
+
+  describe "interaction with validation" do
+    it "still validates expressions even when cached" do
+      # First call validates and caches
+      doc.xpath("//item")
+
+      # Invalid expression should still be rejected
+      expect {
+        doc.xpath("//item[@id=''] or 1=1")
+      }.to raise_error(ArgumentError)
+    end
+
+    it "caches valid expressions only" do
+      # Try an invalid expression
+      expect {
+        doc.xpath("")
+      }.to raise_error(ArgumentError)
+
+      # Cache should not have increased
+      expect(RXerces.xpath_validation_cache_size).to eq(0)
+    end
+  end
+end