libxml-ruby 0.9.7 → 0.9.8

data/test/tc_node_cdata.rb

@@ -3,9 +3,7 @@ require 'test/unit'
 
 class CDataCommentTest < Test::Unit::TestCase
   def setup
-    xp = XML::Parser.new()
-    str = '<root></root>'
-    assert_equal(str, xp.string = str)
+    xp = XML::Parser.string('<root></root>')
     @doc = xp.parse
     assert_instance_of(XML::Document, @doc)
     @root = @doc.root

data/test/tc_node_comment.rb

@@ -2,10 +2,8 @@ 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)
+  def setup
+    xp = XML::Parser.string('<root></root>')
     @doc = xp.parse
     assert_instance_of(XML::Document, @doc)
     @root = @doc.root

data/test/tc_node_edit.rb

@@ -3,8 +3,7 @@ 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>'
+    xp = XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
     @doc = xp.parse
   end
 
@@ -108,7 +107,7 @@ class TestNodeEdit < Test::Unit::TestCase
   end
 
   def test_set_base
-    @doc.root.base = 'http://www.rubynet.org/'
+    @doc.root.base_uri = 'http://www.rubynet.org/'
     assert_equal("<test xml:base=\"http://www.rubynet.org/\">\n  <num>one</num>\n  <num>two</num>\n  <num>three</num>\n</test>",
                  @doc.root.to_s)
   end

data/test/tc_node_text.rb

@@ -14,4 +14,38 @@ class TestTextNode < Test::Unit::TestCase
     end
     assert_equal('wrong argument type nil (expected String)', error.to_s)
   end
-end
+
+	# Disabling output escaping can't work without this test passing.
+	def test_text_node_name_sanity
+		node = XML::Node.new_text('testdata')
+    assert_equal XML::Node::XML_STRING_TEXT.object_id, node.name.object_id
+    node.name = 'ignore-me'
+    assert_equal XML::Node::XML_STRING_TEXT.object_id, node.name.object_id
+    node.name = XML::Node::XML_STRING_TEXT_NOENC
+    assert_equal XML::Node::XML_STRING_TEXT_NOENC.object_id, node.name.object_id
+    node.name = 'ignore-me'
+    assert_equal XML::Node::XML_STRING_TEXT_NOENC.object_id, node.name.object_id
+  end
+
+	def test_text_node_name_singletons_frozen
+    assert XML::Node::XML_STRING_TEXT.frozen?
+    assert XML::Node::XML_STRING_TEXT_NOENC.frozen?
+  end
+
+	# We use the same facility that libXSLT does here to disable output escaping.
+	# This lets you specify that the node's content should be rendered unaltered
+	# whenever it is being output.  This is useful for things like <script> and
+	# <style> nodes in HTML documents if you don't want to be forced to wrap them
+	# in CDATA nodes.  Or if you are sanitizing existing HTML documents and want
+	# to preserve the content of any of the text nodes.
+	#
+	def test_output_escaping
+    node = XML::Node.new_text('<my> "entity"')
+		assert_equal '&lt;my&gt; "entity"', node.to_s
+    node.name = XML::Node::XML_STRING_TEXT_NOENC
+		assert_equal '<my> "entity"', node.to_s
+    node.name = XML::Node::XML_STRING_TEXT
+		assert_equal '&lt;my&gt; "entity"', node.to_s
+  end
+
+end

data/test/tc_node_write.rb

@@ -53,20 +53,20 @@ class TestNodeWrite < Test::Unit::TestCase
     # ö - c3 b6 in hex, \303\266 in octal
     # ü - c3 bc in hex, \303\274 in octal
     assert_equal("<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
-                 node.to_s(:encoding => XML::Input::UTF_8))
+                 node.to_s(:encoding => XML::Encoding::UTF_8))
 
     # ISO_8859_1:
     # ö - f6 in hex, \366 in octal
     # ü - fc in hex, \374 in octal
     assert_equal("<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
-                 node.to_s(:encoding => XML::Input::ISO_8859_1))
+                 node.to_s(:encoding => XML::Encoding::ISO_8859_1))
 
 
     # Invalid encoding
     error = assert_raise(ArgumentError) do
       node.to_s(:encoding => -9999)
     end
-    assert_equal('Unknown encoding.', error.to_s)
+    assert_equal('Unknown encoding value: -9999', error.to_s)
   end
 
   # --- Debug ---

data/test/tc_node_xlink.rb

@@ -1,12 +1,10 @@
-# $Id: tc_node_xlink.rb 481 2008-07-19 08:59:39Z cfis $
+# $Id: tc_node_xlink.rb 710 2009-01-20 05:30:51Z cfis $
 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)
+    xp = XML::Parser.string('<ruby_array xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"><fixnum xlink:type="simple">one</fixnum></ruby_array>')
     doc = xp.parse
     assert_instance_of(XML::Document, doc)
     @root = doc.root

data/test/tc_parser.rb

@@ -5,110 +5,164 @@ require 'stringio'
 class TestParser < Test::Unit::TestCase
   def setup
     XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
-    @xp = XML::Parser.new
   end
 
   def teardown
-    @xp = nil
     GC.start
     GC.start
     GC.start
   end
       
   # -----  Sources  ------
-  def test_file
-    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+  def test_document
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.xml'))
+    parser = XML::Parser.file(file)
+    doc = parser.parse
 
-    @xp.file = file
-    assert_equal(file, @xp.file)
-    assert_equal(file, @xp.input.file)
+    parser = XML::Parser.document(doc)
 
-    doc = @xp.parse
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, @xp.context)
-    GC.start
-    GC.start
-    GC.start
- end
-
-  def test_file_class
-    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    doc = parser.parse
 
-    xp = XML::Parser.file(file)
-    assert_instance_of(XML::Parser, xp)
-    assert_equal(file, xp.file)
-    assert_equal(file, xp.input.file)
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
   end
 
-  def test_string
-    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
-
-    @xp.string = str
-    assert_equal(str, @xp.string)
-    assert_equal(str, @xp.input.string)
+  def test_file
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
 
-    doc = @xp.parse
+    parser = XML::Parser.file(file)
+    doc = parser.parse
     assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, @xp.context)
+    assert_instance_of(XML::Parser::Context, parser.context)
   end
 
-  def test_string_empty
-    assert_raise(XML::Error) do
-      @xp.string = ''
-      @xp.parse
-    end
+  def test_file_encoding
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.xml'))
+    parser = XML::Parser.file(file, :encoding => XML::Encoding::ISO_8859_1)
 
-    assert_raise(TypeError) do
-      @xp.string = nil
+    error = assert_raise(XML::Error) do
+      doc = parser.parse
     end
-  end
 
-  def test_string_class
-    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    assert(error.to_s.match(/Fatal error: Extra content at the end of the document/))
 
-    xp = XML::Parser.string(str)
-    assert_instance_of(XML::Parser, xp)
-    assert_equal(str, xp.string)
-    assert_equal(str, xp.input.string)
+    parser = XML::Parser.file(file, :encoding => XML::Encoding::UTF_8)
+    doc = parser.parse
+    assert_not_nil(doc)
   end
 
-  def test_io
-    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
-      @xp.io = io
-      assert_equal(io, @xp.io)
-      assert_equal(io, @xp.input.io)
+  def test_file_base_uri
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.xml'))
 
-      doc = @xp.parse
-      assert_instance_of(XML::Document, doc)
-      assert_instance_of(XML::Parser::Context, @xp.context)
-    end
+    parser = XML::Parser.file(file)
+    doc = parser.parse
+    assert(doc.child.base.match(/test\/model\/bands.xml/))
+
+    parser = XML::Parser.file(file, :base_uri => "http://libxml.org")
+    doc = parser.parse
+    assert(doc.child.base.match(/test\/model\/bands.xml/))
   end
 
-  def test_io_class
+  def test_io
     File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
-      xp = XML::Parser.io(io)
-      assert_instance_of(XML::Parser, xp)
-      assert_equal(io, xp.io)
-      assert_equal(io, xp.input.io)
+      parser = XML::Parser.io(io)
+      assert_instance_of(XML::Parser, parser)
 
-      doc = xp.parse
+      doc = parser.parse
       assert_instance_of(XML::Document, doc)
-      assert_instance_of(XML::Parser::Context, xp.context)
+      assert_instance_of(XML::Parser::Context, parser.context)
     end
   end
 
   def test_string_io
     data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
     string_io = StringIO.new(data)
-    @xp.io = string_io
-    assert_equal(string_io, @xp.io)
-    assert_equal(string_io, @xp.input.io)
+    parser = XML::Parser.io(string_io)
+
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_string
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+
+    parser = XML::Parser.string(str)
+    assert_instance_of(XML::Parser, parser)
 
-    doc = @xp.parse
+    doc = parser.parse
     assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, @xp.context)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_string_options
+    xml = <<-EOS
+      <!DOCTYPE foo [<!ENTITY foo 'bar'>]>
+      <test>
+        <cdata><![CDATA[something]]></cdata>
+        <entity>&foo;</entity>
+      </test>
+    EOS
+
+    XML::default_substitute_entities = false
+
+    # Parse normally
+    parser = XML::Parser.string(xml)
+    doc = parser.parse
+    assert_nil(doc.child.base)
+
+    # Cdata section should be cdata nodes
+    node = doc.find_first('/test/cdata').child
+    assert_equal(XML::Node::CDATA_SECTION_NODE, node.node_type)
+
+    # Entities should not be subtituted
+    node = doc.find_first('/test/entity')
+    assert_equal('&foo;', node.child.to_s)
+
+    # Parse with options
+    parser = XML::Parser.string(xml, :base_uri => 'http://libxml.rubyforge.org',
+                                     :options => XML::Parser::Options::NOCDATA | XML::Parser::Options::NOENT)
+    doc = parser.parse
+    assert_equal(doc.child.base_uri, 'http://libxml.rubyforge.org')
+
+    # Cdata section should be text nodes
+    node = doc.find_first('/test/cdata').child
+    assert_equal(XML::Node::TEXT_NODE, node.node_type)
+
+    # Entities should be subtituted
+    node = doc.find_first('/test/entity')
+    assert_equal('bar', node.child.to_s)
   end
 
+  def test_string_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+
+    xml = <<-EOS
+      <bands>
+        <metal>m\366tley_cr\374e</metal>
+      </bands>
+    EOS
+
+    # Parse as UTF_8
+    parser = XML::Parser.string(xml)
+
+    error = assert_raise(XML::Error) do
+      doc = parser.parse
+    end
+
+    assert_equal("Fatal error: Input is not proper UTF-8, indicate encoding !\nBytes: 0xF6 0x74 0x6C 0x65 at :2.",
+                 error.to_s)
+
+    # Parse as ISO_8859_1:
+    parser = XML::Parser.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    doc = parser.parse
+    node = doc.find_first('//metal')
+    assert_equal("m\303\266tley_cr\303\274e", node.content)
+  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,
@@ -155,9 +209,9 @@ class TestParser < Test::Unit::TestCase
   end
 
   def test_bad_xml
-    @xp.string = '<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    parser = XML::Parser.string('<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
     error = assert_raise(XML::Error) do
-      assert_not_nil(@xp.parse)
+      assert_not_nil(parser.parse)
     end
 
     assert_not_nil(error)
@@ -176,12 +230,51 @@ class TestParser < Test::Unit::TestCase
     assert_nil(error.node)
   end
 
-  def test_double_parse
-    parser = XML::Parser.string("<test>something</test>")
+  # Deprecated methods
+  def test_document_deprecated
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.xml'))
+    parser = XML::Parser.file(file)
     doc = parser.parse
 
-    assert_raise(RuntimeError) do
-      parser.parse
+    parser = XML::Parser.new
+    parser.document = doc
+    doc = parser.parse
+
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_file_deprecated
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+
+    parser = XML::Parser.new
+    parser.file = file
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_io_deprecated
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
+      parser = XML::Parser.new
+      assert_instance_of(XML::Parser, parser)
+      parser.io = io
+
+      doc = parser.parse
+      assert_instance_of(XML::Document, doc)
+      assert_instance_of(XML::Parser::Context, parser.context)
     end
   end
+
+  def test_string_deprecated
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+
+    parser = XML::Parser.new
+    parser.string = str
+    assert_instance_of(XML::Parser, parser)
+
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
 end

data/test/tc_parser_context.rb

@@ -2,101 +2,162 @@ require "xml"
 require 'test/unit'
 
 class TestParserContext < Test::Unit::TestCase
-  def setup
-    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
-    xp = XML::Parser.string(str)
-    assert_equal(str, xp.string = str)
-    doc = xp.parse
-    assert_instance_of(XML::Document, doc)
-    @ctxt = xp.context
-    assert_instance_of(XML::Parser::Context, @ctxt)
+  def test_string
+    # UTF8
+    xml = <<-EOS
+      <bands>
+        <metal>m\303\266tley_cr\303\274e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+    assert_instance_of(XML::Parser::Context, context)
+    assert_equal(XML::Encoding::NONE, context.encoding)
+    assert_nil(context.base_uri)
+  end
+
+  def test_encoding
+    # ISO_8859_1:
+    xml = <<-EOS
+      <bands>
+        <metal>m\366tley_cr\374e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+    assert_equal(XML::Encoding::NONE, context.encoding)
+
+    context.encoding = XML::Encoding::ISO_8859_1
+    assert_equal(XML::Encoding::ISO_8859_1, context.encoding)
+  end
+
+  def test_base_uri
+    # UTF8
+    xml = <<-EOS
+      <bands>
+        <metal>m\303\266tley_cr\303\274e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+    assert_nil(context.base_uri)
+
+    context.base_uri = 'http://libxml.rubyforge.org'
+    assert_equal('http://libxml.rubyforge.org', context.base_uri)
   end
 
-  def teardown
-    @ctxt = nil
+  def test_string_empty
+    error = assert_raise(TypeError) do
+      parser = XML::Parser::Context.string(nil)
+    end
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+
+    error = assert_raise(ArgumentError) do
+      XML::Parser::Context.string('')
+    end
+    assert_equal("Must specify a string with one or more characters", error.to_s)
   end
 
   def test_well_formed
-    if @ctxt.well_formed?
-      assert_instance_of(TrueClass, @ctxt.well_formed?)
-    else
-      assert_instance_of(FalseClass, @ctxt.well_formed?)
+    parser = XML::Parser.string("<abc/>")
+    parser.parse
+    assert(parser.context.well_formed?)
+  end
+
+  def test_not_well_formed
+    parser = XML::Parser.string("<abc>")
+    assert_raise(XML::Error) do
+      parser.parse
     end
+    assert(!parser.context.well_formed?)
   end
 
   def test_version_info
-    assert_instance_of(String, @ctxt.version)
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.xml'))
+    parser = XML::Parser.file(file)
+    assert_nil(parser.context.version)
+    parser.parse
+    assert_equal("1.0", parser.context.version)
   end
 
   def test_depth
-    assert_instance_of(Fixnum, @ctxt.depth)
+    context = XML::Parser::Context.new
+    assert_instance_of(Fixnum, context.depth)
   end
 
   def test_disable_sax
-    assert(!@ctxt.disable_sax?)
+    context = XML::Parser::Context.new
+    assert(!context.disable_sax?)
   end
 
   def test_docbook
-    assert(!@ctxt.docbook?)
-  end
-
-  def test_encoding
-    assert(!@ctxt.encoding)
+    context = XML::Parser::Context.new
+    assert(!context.docbook?)
   end
 
   def test_html
-    assert(!@ctxt.html?)
+    context = XML::Parser::Context.new
+    assert(!context.html?)
   end
 
   def test_keep_blanks
-    if @ctxt.keep_blanks?
-      assert_instance_of(TrueClass, @ctxt.keep_blanks?)
+    context = XML::Parser::Context.new
+    if context.keep_blanks?
+      assert_instance_of(TrueClass, context.keep_blanks?)
     else
-      assert_instance_of(FalseClass, @ctxt.keep_blanks?)
+      assert_instance_of(FalseClass, context.keep_blanks?)
     end
   end
 
   if ENV['NOTWORKING']
     def test_num_chars
-      assert_equal(17, @ctxt.num_chars)
+      assert_equal(17, context.num_chars)
     end
   end
 
   def test_replace_entities
-    if @ctxt.replace_entities?
-      assert_instance_of(TrueClass, @ctxt.replace_entities?)
-    else
-      assert_instance_of(FalseClass, @ctxt.replace_entities?)
-    end
+    context = XML::Parser::Context.new
+    assert(!context.replace_entities?)
+
+#    context.options = 1
+ #   assert(context.replace_entities?)
+
+    context.options = 0
+    assert(!context.replace_entities?)
+
+    context.replace_entities = true
+    assert(context.replace_entities?)
   end
 
   def test_space_depth
-    assert_equal(1, @ctxt.space_depth)
+    context = XML::Parser::Context.new
+    assert_equal(1, context.space_depth)
   end
 
   def test_subset_external
-    assert(!@ctxt.subset_external?)
+    context = XML::Parser::Context.new
+    assert(!context.subset_external?)
   end
 
   def test_data_directory_get
-    assert_nil(@ctxt.data_directory)
+    context = XML::Parser::Context.new
+    assert_nil(context.data_directory)
   end
 
   def test_parse_error
-    xp = XML::Parser.new
-    xp.string = '<foo><bar/></foz>'
-    
+    xp = XML::Parser.string('<foo><bar/></foz>')
+
     assert_raise(XML::Error) do
       xp.parse
     end
-    
+
     # Now check context
     context = xp.context
     assert_equal(nil, context.data_directory)
     assert_equal(0, context.depth)
     assert_equal(true, context.disable_sax?)
     assert_equal(false, context.docbook?)
-    assert_equal(nil, context.encoding)
+    assert_equal(XML::Encoding::NONE, context.encoding)
     assert_equal(76, context.errno)
     assert_equal(false, context.html?)
     assert_equal(5, context.io_max_num_streams)
@@ -107,7 +168,7 @@ class TestParserContext < Test::Unit::TestCase
     assert_equal(0, context.name_depth)
     assert_equal(10, context.name_depth_max)
     assert_equal(17, context.num_chars)
-    assert_equal(true, context.replace_entities?)
+    assert_equal(false, context.replace_entities?)
     assert_equal(1, context.space_depth)
     assert_equal(10, context.space_depth_max)
     assert_equal(false, context.subset_external?)
@@ -122,4 +183,4 @@ class TestParserContext < Test::Unit::TestCase
     assert_equal('1.0', context.version)
     assert_equal(false, context.well_formed?)
   end
-end
+end