RubyGems - libxml-jruby-modified - Versions diffs - 1.0.1-jruby - Mend

libxml-jruby-modified 1.0.1-jruby

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (95) hide show

checksums.yaml +7 -0
data/History.txt +4 -0
data/Manifest.txt +91 -0
data/README.txt +50 -0
data/Rakefile +20 -0
data/lib/libxml-jruby/xml/attr.rb +46 -0
data/lib/libxml-jruby/xml/attributes.rb +68 -0
data/lib/libxml-jruby/xml/document.rb +48 -0
data/lib/libxml-jruby/xml/dtd.rb +25 -0
data/lib/libxml-jruby/xml/node.rb +285 -0
data/lib/libxml-jruby/xml/ns.rb +19 -0
data/lib/libxml-jruby/xml/parser.rb +121 -0
data/lib/libxml-jruby/xml/xpath.rb +98 -0
data/lib/libxml-jruby/xml.rb +1 -0
data/lib/libxml-jruby.rb +82 -0
data/lib/libxml.rb +1 -0
data/lib/xml/libxml.rb +8 -0
data/lib/xml.rb +13 -0
data/libxml-jruby-1.0.1-java.gem +0 -0
data/libxml-jruby.gemspec +15 -0
data/script/benchmark/depixelate.rb +633 -0
data/script/benchmark/hamlet.xml +9055 -0
data/script/benchmark/sock_entries.xml +507 -0
data/script/benchmark/throughput.rb +40 -0
data/script/benchmark/xml_benchmarks.rb +228 -0
data/script/test +6 -0
data/tasks/ann.rake +81 -0
data/tasks/bones.rake +21 -0
data/tasks/gem.rake +126 -0
data/tasks/git.rake +41 -0
data/tasks/manifest.rake +49 -0
data/tasks/notes.rake +28 -0
data/tasks/post_load.rake +39 -0
data/tasks/rdoc.rake +51 -0
data/tasks/rubyforge.rake +57 -0
data/tasks/setup.rb +268 -0
data/tasks/spec.rake +55 -0
data/tasks/svn.rake +48 -0
data/tasks/test.rake +38 -0
data/test/etc_doc_to_s.rb +19 -0
data/test/ets_copy_bug.rb +21 -0
data/test/ets_copy_bug3.rb +38 -0
data/test/ets_doc_file.rb +15 -0
data/test/ets_doc_to_s.rb +21 -0
data/test/ets_gpx.rb +26 -0
data/test/ets_node_gc.rb +21 -0
data/test/ets_test.xml +2 -0
data/test/ets_tsr.rb +9 -0
data/test/model/books.xml +147 -0
data/test/model/default_validation_bug.rb +0 -0
data/test/model/merge_bug_data.xml +58 -0
data/test/model/rubynet.xml +78 -0
data/test/model/rubynet_project +1 -0
data/test/model/saxtest.xml +5 -0
data/test/model/shiporder.rnc +28 -0
data/test/model/shiporder.rng +86 -0
data/test/model/shiporder.xml +23 -0
data/test/model/shiporder.xsd +31 -0
data/test/model/simple.xml +7 -0
data/test/model/soap.xml +27 -0
data/test/model/xinclude.xml +5 -0
data/test/tc_attributes.rb +110 -0
data/test/tc_deprecated_require.rb +13 -0
data/test/tc_document.rb +97 -0
data/test/tc_document_write.rb +139 -0
data/test/tc_dtd.rb +70 -0
data/test/tc_html_parser.rb +63 -0
data/test/tc_node.rb +108 -0
data/test/tc_node_attr.rb +176 -0
data/test/tc_node_cdata.rb +51 -0
data/test/tc_node_comment.rb +32 -0
data/test/tc_node_copy.rb +40 -0
data/test/tc_node_edit.rb +98 -0
data/test/tc_node_set.rb +24 -0
data/test/tc_node_set2.rb +37 -0
data/test/tc_node_text.rb +17 -0
data/test/tc_node_xlink.rb +28 -0
data/test/tc_ns.rb +18 -0
data/test/tc_parser.rb +308 -0
data/test/tc_parser_context.rb +126 -0
data/test/tc_properties.rb +37 -0
data/test/tc_reader.rb +112 -0
data/test/tc_relaxng.rb +39 -0
data/test/tc_sax_parser.rb +113 -0
data/test/tc_schema.rb +39 -0
data/test/tc_traversal.rb +220 -0
data/test/tc_well_formed.rb +11 -0
data/test/tc_xinclude.rb +26 -0
data/test/tc_xpath.rb +130 -0
data/test/tc_xpath_context.rb +72 -0
data/test/tc_xpointer.rb +78 -0
data/test/test_libxml-jruby.rb +0 -0
data/test/test_suite.rb +31 -0
data/test/ts_working.rb +31 -0
metadata +135 -0

data/test/tc_node_comment.rb ADDED Viewed

@@ -0,0 +1,32 @@
+require "xml"
+require 'test/unit'
+class NodeCommentTest < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.new()
+    str = '<root></root>'
+    assert_equal(str, xp.string = str)
+    @doc = xp.parse
+    assert_instance_of(XML::Document, @doc)
+    @root = @doc.root
+  end
+  def test_libxml_node_add_comment_01
+    @root << XML::Node.new_comment('mycomment')
+    assert_equal '<root><!--mycomment--></root>',
+      @root.to_s.gsub(/\n\s*/,'')
+  end
+  def test_libxml_node_add_comment_02
+    @root << XML::Node.new_comment('mycomment')
+    assert_equal 'comment',
+    @root.child.node_type_name
+  end
+  def test_libxml_node_add_comment_03
+    @root << el = XML::Node.new_comment('mycomment')
+    el << "_this_is_added"
+    assert_equal '<root><!--mycomment_this_is_added--></root>',
+    @root.to_s.gsub(/\n\s*/,'')
+  end
+end

data/test/tc_node_copy.rb ADDED Viewed

@@ -0,0 +1,40 @@
+require "xml"
+require 'test/unit'
+# see mailing list archive
+# [libxml-devel] Segmentation fault when add the cloned/copied node
+# 2007/11/27 20:51
+class TC_XML_Node_Copy < Test::Unit::TestCase
+  def setup
+    str = <<-STR
+      <html><body>
+        <div class="textarea" id="t1" style="STATIC">foo</div>
+        <div class="textarea" id="t2" style="STATIC">bar</div>
+      </body></html>
+    STR
+    doc = XML::Parser.string(str).parse
+    xpath = "//div"
+    @div1 = doc.find(xpath).to_a[0]
+    @div2 = doc.find(xpath).to_a[1]
+  end
+  def test_libxml_node_copy_not_segv
+    @div2.each do |child|
+      c = child.copy(false)
+      @div1.child_add(c)
+    end
+    assert @div1.to_s =~ /foo/
+  end
+  def test_libxml_node_clone_not_segv
+    @div2.each do |child|
+      c = child.clone
+      @div1.child_add(c)
+    end
+    assert @div1.to_s =~ /foo/
+  end
+end # TC_XML_Node_Copy

data/test/tc_node_edit.rb ADDED Viewed

@@ -0,0 +1,98 @@
+require "xml"
+require 'test/unit'
+class TestNodeEdit < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.new()
+    xp.string = '<test><num>one</num><num>two</num><num>three</num></test>'
+    @doc = xp.parse
+  end
+  def teardown
+    @doc = nil
+  end
+  def first_node
+    @doc.root.child
+  end
+  def second_node
+    first_node.next
+  end
+  def third_node
+    second_node.next
+  end
+  def test_add_next_01
+    first_node.next = XML::Node.new('num', 'one-and-a-half')
+    assert_equal('<test><num>one</num><num>one-and-a-half</num><num>two</num><num>three</num></test>',
+                 @doc.root.to_s.gsub(/\n\s*/,''))
+  end
+  def test_add_next_02
+    second_node.next = XML::Node.new('num', 'two-and-a-half')
+    assert_equal('<test><num>one</num><num>two</num><num>two-and-a-half</num><num>three</num></test>',
+                 @doc.root.to_s.gsub(/\n\s*/,''))
+  end
+  def test_add_next_03
+    third_node.next = XML::Node.new('num', 'four')
+    assert_equal '<test><num>one</num><num>two</num><num>three</num><num>four</num></test>',
+      @doc.root.to_s.gsub(/\n\s*/,'')
+  end
+  def test_add_prev_01
+    first_node.prev = XML::Node.new('num', 'half')
+    assert_equal '<test><num>half</num><num>one</num><num>two</num><num>three</num></test>',
+      @doc.root.to_s.gsub(/\n\s*/,'')
+  end
+  def test_add_prev_02
+    second_node.prev = XML::Node.new('num', 'one-and-a-half')
+    assert_equal '<test><num>one</num><num>one-and-a-half</num><num>two</num><num>three</num></test>',
+      @doc.root.to_s.gsub(/\n\s*/,'')
+  end
+  def test_add_prev_03
+    third_node.prev = XML::Node.new('num', 'two-and-a-half')
+    assert_equal '<test><num>one</num><num>two</num><num>two-and-a-half</num><num>three</num></test>',
+      @doc.root.to_s.gsub(/\n\s*/,'')
+  end
+  def test_remove_node()
+    first_node.remove!
+    assert_equal('<test><num>two</num><num>three</num></test>',
+                 @doc.root.to_s.gsub(/\n\s*/,''))
+  end
+  # This test is to verify that an earlier reported bug has been fixed
+  def test_merge
+    documents = []
+    # Read in 500 documents
+    500.times do
+      documents << XML::Parser.string(File.read(File.join(File.dirname(__FILE__), 'model', 'merge_bug_data.xml'))).parse
+    end
+    master_doc = documents.shift
+    documents.inject(master_doc) do |master_doc, child_doc|
+      master_body = master_doc.find("//body").first
+      child_body = child_doc.find("//body").first
+      child_element = child_body.detect do |node|
+        node.element?
+      end
+      master_body << child_element.copy(true)
+      master_doc
+    end
+  end
+  def test_append_chain
+    node = XML::Node.new('foo') << XML::Node.new('bar') << "bars contents"
+    assert_equal('bars contents',
+                 node.to_s)
+    assert_equal("<foo>\n  <bar>bars contents</bar>\n</foo>", node.parent.parent.to_s)
+  end
+end

data/test/tc_node_set.rb ADDED Viewed

@@ -0,0 +1,24 @@
+require "xml"
+require 'test/unit'
+class TC_XML_Node_Set < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.new()
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    assert_equal(str, xp.string = str)
+    doc = xp.parse
+    assert_instance_of(XML::Document, doc)
+    @set = doc.find('/ruby_array/fixnum').set
+    assert_instance_of(XML::Node::Set, @set)
+  end
+  def teardown()
+    @set = nil
+  end
+  def test_libxml_nodeset_each()
+    @set.each do |n|
+      assert_instance_of(XML::Node, n)
+    end
+  end
+end # TC_XML_Document

data/test/tc_node_set2.rb ADDED Viewed

@@ -0,0 +1,37 @@
+require "xml"
+require 'test/unit'
+class TC_XML_Node_Set2 < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.new()
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    assert_equal(str, xp.string = str)
+    doc = xp.parse
+    assert_instance_of(XML::Document, doc)
+    @one = doc.root.child
+    @two = @one.next
+    @set = doc.find('/ruby_array/fixnum').set
+    @emptyset = doc.find('/fixnum').set
+    assert_instance_of(XML::Node::Set, @set)
+  end
+  def teardown()
+    @set, @emptyset, @one, @two = [nil] * 4
+  end
+  def test_libxml_nodeset_to_a()
+    assert_equal [@one, @two], @set.to_a
+    assert_equal [], @emptyset.to_a
+  end
+  def test_libxml_nodeset_empty?()
+    assert ! @set.empty?
+    assert @emptyset.empty?
+  end
+  def test_libxml_nodeset_first()
+    assert_equal @one.to_s, @set.first.to_s
+    assert_equal nil, @emptyset.first
+  end
+end # TC_XML_Document

data/test/tc_node_text.rb ADDED Viewed

@@ -0,0 +1,17 @@
+require 'xml'
+require 'test/unit'
+class TC_XML_Node_text < Test::Unit::TestCase
+  def setup
+    @t=XML::Node.new_text("testdata")
+    assert_instance_of(XML::Node,@t)
+  end
+  def test_content
+    assert_equal("testdata",@t.content)
+  end
+  def test_type
+    assert_equal(true,@t.text?)
+  end
+end

data/test/tc_node_xlink.rb ADDED Viewed

@@ -0,0 +1,28 @@
+# $Id$
+require "xml"
+require 'test/unit'
+class TC_XML_Node_XLink < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.new()
+    str = '<ruby_array xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"><fixnum xlink:type="simple">one</fixnum></ruby_array>'
+    assert_equal(str, xp.string = str)
+    doc = xp.parse
+    assert_instance_of(XML::Document, doc)
+    @root = doc.root
+    assert_instance_of(XML::Node, @root)
+  end
+  def teardown()
+    @root = nil
+  end
+  def test_xml_node_xlink()
+    for elem in @root.find('fixnum')
+      assert_instance_of(XML::Node, elem)
+      assert_instance_of(TrueClass, elem.xlink?)
+      assert_equal("simple", elem.xlink_type_name)
+      assert_equal(XML::Node::XLINK_TYPE_SIMPLE, elem.xlink_type)
+    end
+  end
+end

data/test/tc_ns.rb ADDED Viewed

@@ -0,0 +1,18 @@
+require "xml"
+require 'test/unit'
+class TestNS < Test::Unit::TestCase
+  def test_ns
+    node = XML::Node.new('foo')
+    ns = XML::NS.new(node, 'http://www.mynamespace.com', 'my_namepace')
+    assert_equal(ns.prefix, 'my_namepace')
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+  def test_default_ns
+    node = XML::Node.new('foo')
+    ns = XML::NS.new(node, 'http://www.mynamespace.com', nil)
+    assert_equal(ns.prefix, nil)
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+end

data/test/tc_parser.rb ADDED Viewed

@@ -0,0 +1,308 @@
+require "xml"
+require 'test/unit'
+require 'test_helper'
+class TestParser < Test::Unit::TestCase
+  def setup
+    XML::Parser.register_error_handler(nil)
+    @xp = XML::Parser.new
+  end
+  def teardown
+    @xp = nil
+    XML::Parser.register_error_handler(nil)
+    # Clear out all the files we opened up in
+    # the test_fd_gc test
+    GC.start
+  end
+  # -----  Constants  ------
+  def test_lib_versions
+    assert(XML::Parser::check_lib_versions)
+  end
+  def test_debug_entities
+    XML::Parser::debug_entities = false
+    assert(!XML::Parser::debug_entities)
+    XML::Parser::debug_entities = true
+    assert(XML::Parser::debug_entities)
+    XML::Parser::debug_entities = false
+    assert(!XML::Parser::debug_entities)
+  end
+  def test_default_compression
+    return unless XML::Parser::default_compression
+    0.upto(9) do |i|
+      XML::Parser::default_compression = i
+      assert_equal(i, XML::Parser::default_compression)
+    end
+    9.downto(0) do |i|
+      assert_equal(i, XML::Parser::default_compression = i)
+      assert_equal(i, XML::Parser::default_compression)
+    end
+    0.downto(-10) do |i|
+      assert_equal(i, XML::Parser::default_compression = i)
+      assert_equal(0, XML::Parser::default_compression)
+    end
+    10.upto(20) do |i|
+      assert_equal(i, XML::Parser::default_compression = i)
+      assert_equal(9, XML::Parser::default_compression)
+    end
+  end
+  def test_default_keep_blanks
+    XML::Parser::default_keep_blanks = false
+    assert(!XML::Parser::default_keep_blanks)
+    XML::Parser::default_keep_blanks = true
+    assert(XML::Parser::default_keep_blanks)
+    XML::Parser::default_keep_blanks = false
+    assert(!XML::Parser::default_keep_blanks)
+    # other tests depend on keeping blanks by default,
+    # which is the default default behaviour anyway.
+    XML::Parser::default_keep_blanks = true
+  end
+  def test_default_line_numbers
+    XML::Parser::default_line_numbers = false
+    assert(!XML::Parser::default_line_numbers)
+    XML::Parser::default_line_numbers = true
+    assert(XML::Parser::default_line_numbers)
+    XML::Parser::default_line_numbers = false
+    assert(!XML::Parser::default_line_numbers)
+  end
+  def test_default_substitute_entities
+    XML::Parser::default_substitute_entities = false
+    assert(!XML::Parser::default_substitute_entities)
+    XML::Parser::default_substitute_entities = true
+    assert(XML::Parser::default_substitute_entities)
+    XML::Parser::default_substitute_entities = false
+    assert(!XML::Parser::default_substitute_entities)
+  end
+  def test_default_tree_indent_string
+    s = XML::Parser::default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+    XML::Parser::default_tree_indent_string = 'uga'
+    s = XML::Parser::default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('uga', s)
+    XML::Parser::default_tree_indent_string = '  '
+    s = XML::Parser::default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+  end
+  def test_default_validity_checking
+    XML::Parser::default_validity_checking = false
+    assert(!XML::Parser::default_validity_checking)
+    XML::Parser::default_validity_checking = true
+    assert(XML::Parser::default_validity_checking)
+    XML::Parser::default_validity_checking = false
+    assert(!XML::Parser::default_validity_checking)
+  end
+  def test_default_warnings
+    XML::Parser::default_warnings = false
+    assert(!XML::Parser::default_warnings)
+    XML::Parser::default_warnings = true
+    assert(XML::Parser::default_warnings)
+    XML::Parser::default_warnings = false
+    assert(!XML::Parser::default_warnings)
+  end
+  def test_intent_tree_output
+    assert(TrueClass, XML::Parser::indent_tree_output)
+    XML::Parser::indent_tree_output = false
+    assert(FalseClass, XML::Parser::indent_tree_output)
+    XML::Parser::indent_tree_output = true
+    assert(TrueClass, XML::Parser::indent_tree_output)
+  end
+  def test_version
+    assert_instance_of(String, XML::Parser::VERSION)
+  end
+  def test_vernum
+    assert_instance_of(Fixnum, XML::Parser::VERNUM)
+  end
+  # -----  IO  ------
+  def test_string
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    assert_equal(str, @xp.string = str)
+    assert_instance_of(XML::Document, @xp.parse)
+  end
+  def test_context
+    @xp = XML::Parser.string('<rubynet><testing>uga</testing><uga>foo</uga></rubynet>')
+    doc = @xp.parse
+    assert_instance_of(XML::Document, doc)
+    # FIXME Parser#context is not implemented
+    # assert_instance_of(XML::Parser::Context, @xp.context)
+  end
+  def test_file
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    @xp.filename = file
+    assert_equal(file, @xp.filename)
+    doc = @xp.parse
+    assert_instance_of(XML::Document, doc)
+  end
+  def test_io
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |f|
+      assert_kind_of(IO, f)
+      assert_kind_of(IO, @xp.io = f)
+      assert_instance_of(XML::Document, @xp.parse)
+    end
+  end
+  def test_string_io
+    data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    string_io = StringIO.new(data)
+    assert_raises(TypeError) do
+      assert_kind_of(StringIO, @xp.io = string_io)
+    end
+  end
+  def test_fd_gc
+    # Test opening # of documents up to the file limit for the OS.
+    # Ideally it should run until libxml emits a warning,
+    # thereby knowing we've done a GC sweep. For the time being,
+    # re-open the same doc `limit descriptors` times.
+    # If we make it to the end, then we've succeeded,
+    # otherwise an exception will be thrown.
+    # FIXME removed test, extremely slow...
+    # XML::Parser.register_error_handler(lambda {|msg| nil })
+    #
+    # max_fd = if RUBY_PLATFORM.match(/mswin32/i)
+    #   500
+    # else
+    #   (`ulimit -n`.chomp.to_i) + 1
+    # end
+    #
+    # filename = File.join(File.dirname(__FILE__), 'model/rubynet.xml')
+    # max_fd.times do
+    #    XML::Document.file(filename)
+    # end
+  end
+  def test_libxml_parser_features
+    assert_instance_of(Array, XML::Parser::features)
+  end
+  # -----  Errors  ------
+  def test_error_handler
+    assert_raise(XML::Parser::ParseError) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+    ary = []
+    XML::Parser.register_error_handler do |msg|
+      ary << msg
+    end
+    # this will use our error handler
+    assert_raise(XML::Parser::ParseError) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+    # FIXME Errors are not the same across platforms
+    # assert_equal(["Entity: line 1: ",
+    #               "parser ",
+    #               "error : ",
+    #               "Opening and ending tag mismatch: foo line 1 and foz\n",
+    #               "<foo><bar/></foz>\n",
+    #               "                 ^\n"], ary)
+    # assert_instance_of(Proc, XML::Parser.register_error_handler(nil))
+    # this will go to stderr again
+    assert_raise(XML::Parser::ParseError) do
+      d = XML::Parser.string('<foo><bar/></foz>').parse
+    end
+  end
+  def test_error_handler_lambda
+    XML::Parser.register_error_handler(nil)
+    assert_raise(XML::Parser::ParseError) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+    ary = []
+    assert_nil XML::Parser.register_error_handler(lambda { |msg| ary << msg })
+    # this will use our error handler
+    assert_raise(XML::Parser::ParseError) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+    # FIXME Errors are not the same across platforms
+    # assert_equal(["Entity: line 1: ",
+    #               "parser ",
+    #               "error : ",
+    #               "Opening and ending tag mismatch: foo line 1 and foz\n",
+    #               "<foo><bar/></foz>\n",
+    #               "                 ^\n"], ary)
+    # assert_instance_of(Proc, XML::Parser.register_error_handler(nil))
+    # this will go to stderr again
+    assert_raise(XML::Parser::ParseError) do
+      d = XML::Parser.string('<foo><bar/></foz>').parse
+    end
+  end
+  def test_bad_xml
+    @xp.string = '<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    XML::Parser.register_error_handler(lambda {|msg| nil })
+    assert_raise(XML::Parser::ParseError) do
+      assert_not_nil(@xp.parse)
+    end
+  end
+  def test_double_parse
+    XML::Parser.register_error_handler(lambda {|msg| nil })
+    parser = XML::Parser.string("<test>something</test>")
+    doc = parser.parse
+    assert_raise(XML::Parser::ParseError) do
+      parser.parse
+    end
+  end
+  def test_libxml_parser_empty_string
+    assert_raise(XML::Parser::ParseError) do
+      @xp.string = ''
+      @xp.parse
+    end
+    assert_raise(TypeError) do
+      @xp.string = nil
+    end
+  end
+end