libxml-ruby 2.8.0 → 3.2.1

data/test/{tc_namespaces.rb → test_namespaces.rb}

@@ -1,13 +1,12 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 
-require 'test/unit'
 
-class TestNamespaces < Test::Unit::TestCase
+class TestNamespaces < Minitest::Test
   def setup
     file = File.join(File.dirname(__FILE__), 'model/soap.xml')
-    @doc = XML::Document.file(file)
+    @doc = LibXML::XML::Document.file(file)
   end
 
   def teardown
@@ -29,62 +28,62 @@ class TestNamespaces < Test::Unit::TestCase
   end
 
   def test_set_namespace_node
-    node = XML::Node.new('Envelope')
+    node = LibXML::XML::Node.new('Envelope')
     assert_equal('<Envelope/>', node.to_s)
 
-    ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    ns = LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
     assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
     assert_nil(node.namespaces.namespace)
 
     # Now put the node in the soap namespace
     node.namespaces.namespace = ns
-    assert_not_nil(node.namespaces.namespace)
+    refute_nil(node.namespaces.namespace)
     assert_equal("<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
   end
 
   def test_set_namespace_attribute
     # Create node
-    node = XML::Node.new('Envelope')
+    node = LibXML::XML::Node.new('Envelope')
     assert_equal('<Envelope/>', node.to_s)
 
     # Create attribute
-    attr = XML::Attr.new(node, "encodingStyle", "http://www.w3.org/2001/12/soap-encoding")
+    attr = LibXML::XML::Attr.new(node, "encodingStyle", "http://www.w3.org/2001/12/soap-encoding")
     assert_equal('<Envelope encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
                  node.to_s)
 
     # Create namespace attribute
-    ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    ns = LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
     assert_equal('<Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
                   node.to_s)
     assert_nil(node.namespaces.namespace)
 
     # Now put the node in the soap namespace
     node.namespaces.namespace = ns
-    assert_not_nil(node.namespaces.namespace)
+    refute_nil(node.namespaces.namespace)
     assert_equal('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
                   node.to_s)
 
     # Now put the attribute in the soap namespace
     attr.namespaces.namespace = ns
-    assert_not_nil(node.namespaces.namespace)
+    refute_nil(node.namespaces.namespace)
     assert_equal('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
                   node.to_s)
   end
 
   def test_define_namespace
-    node = XML::Node.new('Envelope')
+    node = LibXML::XML::Node.new('Envelope')
     assert_equal('<Envelope/>', node.to_s)
 
-    XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
     assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
     assert_nil(node.namespaces.namespace)
   end
 
   def test_define_default_namespace
-    node = XML::Node.new('Envelope')
+    node = LibXML::XML::Node.new('Envelope')
     assert_equal('<Envelope/>', node.to_s)
 
-    XML::Namespace.new(node, nil, 'http://schemas.xmlsoap.org/soap/envelope/')
+    LibXML::XML::Namespace.new(node, nil, 'http://schemas.xmlsoap.org/soap/envelope/')
     assert_equal("<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
     # This seems wrong, but appears to be the way libxml works
     assert_nil(node.namespaces.namespace)
@@ -98,56 +97,47 @@ class TestNamespaces < Test::Unit::TestCase
     assert_equal(5, namespaces.length)
 
     namespace = namespaces[0]
-    assert_instance_of(XML::Namespace, namespace)
-    assert_equal(nil, namespace.prefix)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_nil(namespace.prefix)
     assert_equal('http://services.somewhere.com', namespace.href)
 
     namespace = namespaces[1]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('ns1', namespace.prefix)
     assert_equal('http://domain.somewhere.com', namespace.href)
 
     namespace = namespaces[2]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('soap', namespace.prefix)
     assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
 
     namespace = namespaces[3]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('xsd', namespace.prefix)
     assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
 
     namespace = namespaces[4]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('xsi', namespace.prefix)
     assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
   end
 
-  def test_namespaces
-    node = @doc.find_first('//ns1:IdAndName',
-                           :ns1 => 'http://domain.somewhere.com')
-
-    node.namespaces.each do |namespace|
-      assert_instance_of(XML::Namespace, namespace)
-    end
-  end
-
   def test_namespace_definitions
     ns_defs = @doc.root.namespaces.definitions
     assert_equal(3, ns_defs.size)
 
     namespace = ns_defs[0]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('soap', namespace.prefix)
     assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
 
     namespace = ns_defs[1]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('xsd', namespace.prefix)
     assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
 
     namespace = ns_defs[2]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('xsi', namespace.prefix)
     assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
 
@@ -157,15 +147,15 @@ class TestNamespaces < Test::Unit::TestCase
     assert_equal(1, ns_defs.size)
 
     namespace = ns_defs[0]
-    assert_instance_of(XML::Namespace, namespace)
-    assert_equal(nil, namespace.prefix)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_nil(namespace.prefix)
     assert_equal('http://services.somewhere.com', namespace.href)
   end
 
   def test_find_by_prefix
     namespace = @doc.root.namespaces.find_by_prefix('soap')
 
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('soap', namespace.prefix)
     assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
   end
@@ -178,8 +168,8 @@ class TestNamespaces < Test::Unit::TestCase
                            :ns1 => 'http://services.somewhere.com')
     namespace = node.namespaces.find_by_prefix(nil)
 
-    assert_instance_of(XML::Namespace, namespace)
-    assert_equal(nil, namespace.prefix)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_nil(namespace.prefix)
     assert_equal('http://services.somewhere.com', namespace.href)
   end
 
@@ -189,22 +179,22 @@ class TestNamespaces < Test::Unit::TestCase
 
     namespace = node.namespaces.find_by_href('http://schemas.xmlsoap.org/soap/envelope/')
 
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('soap', namespace.prefix)
     assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
   end
 
   def test_default_namespace
-    doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    doc = LibXML::XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
     ns = doc.root.namespaces.default
     assert_equal(ns.href, 'http://schemas.xmlsoap.org/soap/envelope/')
   end
 
   def test_default_prefix
-    doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    doc = LibXML::XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
     doc.root.namespaces.default_prefix = 'soap'
 
     node = doc.root.find_first('/soap:Envelope')
-    assert_not_nil(node)
+    refute_nil(node)
   end
-end
+end

data/test/{tc_node.rb → test_node.rb}

@@ -1,20 +1,19 @@
 # encoding: UTF-8
 
-require './test_helper'
-require 'test/unit'
+require_relative './test_helper'
 
-class TestNode < Test::Unit::TestCase
+class TestNode < Minitest::Test
   def setup
     @file_name = "model/bands.utf-8.xml"
 
     # Strip spaces to make testing easier
-    XML.default_keep_blanks = false
+    LibXML::XML.default_keep_blanks = false
     file = File.join(File.dirname(__FILE__), @file_name)
-    @doc = XML::Document.file(file)
+    @doc = LibXML::XML::Document.file(file)
   end
   
   def teardown
-    XML.default_keep_blanks = true
+    LibXML::XML.default_keep_blanks = true
     @doc = nil
   end
 
@@ -24,55 +23,51 @@ class TestNode < Test::Unit::TestCase
   end
 
   def test_doc_class
-    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(LibXML::XML::Document, @doc)
   end
 
   def test_doc_node_type
-    assert_equal XML::Node::DOCUMENT_NODE, @doc.node_type
+    assert_equal LibXML::XML::Node::DOCUMENT_NODE, @doc.node_type
   end
 
   def test_root_class
-    assert_instance_of(XML::Node, @doc.root)
+    assert_instance_of(LibXML::XML::Node, @doc.root)
   end
 
   def test_root_node_type
-    assert_equal XML::Node::ELEMENT_NODE, @doc.root.node_type
+    assert_equal LibXML::XML::Node::ELEMENT_NODE, @doc.root.node_type
   end
 
   def test_node_class
     for n in nodes
-      assert_instance_of(XML::Node, n)
+      assert_instance_of(LibXML::XML::Node, n)
     end
   end
 
   def test_context
     node = @doc.root
     context = node.context
-    assert_instance_of(XML::XPath::Context, context)
+    assert_instance_of(LibXML::XML::XPath::Context, context)
   end
 
   def test_find
-    assert_instance_of(XML::XPath::Object, self.nodes)
+    assert_instance_of(LibXML::XML::XPath::Object, self.nodes)
   end
 
   def test_node_child_get
     assert_instance_of(TrueClass, @doc.root.child?)
-    assert_instance_of(XML::Node, @doc.root.child)
+    assert_instance_of(LibXML::XML::Node, @doc.root.child)
 
-    if defined?(Encoding)
-      assert_equal(Encoding::UTF_8, @doc.root.child.name.encoding)
-      assert_equal("m\u00F6tley_cr\u00FCe", @doc.root.child.name)
-    else
-      assert_equal("m\303\266tley_cr\303\274e", @doc.root.child.name)
-    end
+    assert_equal(Encoding::UTF_8, @doc.root.child.name.encoding)
+    assert_equal("m\u00F6tley_cr\u00FCe", @doc.root.child.name)
   end
 
   def test_node_doc
     for n in nodes
-      assert_instance_of(XML::Document, n.doc) if n.document?
+      assert_instance_of(LibXML::XML::Document, n.doc) if n.document?
     end
   end
-  
+
   def test_name
     node = @doc.root.children.last
     assert_equal("iron_maiden", node.name)
@@ -81,7 +76,7 @@ class TestNode < Test::Unit::TestCase
   def test_node_find
     nodes = @doc.root.find('./fixnum')
     for node in nodes
-      assert_instance_of(XML::Node, node)
+      assert_instance_of(LibXML::XML::Node, node)
     end
   end
 
@@ -89,19 +84,35 @@ class TestNode < Test::Unit::TestCase
     node_a = @doc.find_first('*[@country]')
     node_b = @doc.root.child
 
+    # On the ruby side these are different objects
+    refute(node_a.equal?(node_b))
+
+    # But they are the same underlying libxml node so specify they are equal
     assert(node_a == node_b)
     assert(node_a.eql?(node_b))
-    assert(node_a.equal?(node_b))
 
     file = File.join(File.dirname(__FILE__), @file_name)
-    doc2 = XML::Document.file(file)
+    doc2 = LibXML::XML::Document.file(file)
 
     node_a2 = doc2.find_first('*[@country]')
 
+    refute(node_a == node_a2)
+    refute(node_a.eql?(node_a2))
     assert_equal(node_a.to_s, node_a2.to_s)
-    assert_equal(node_a, node_a2)
-    assert(node_a.eql?(node_a2))
-    assert(!node_a.equal?(node_a2))
+    refute(node_a.equal?(node_a2))
+  end
+
+  def test_equality_2
+    parent = LibXML::XML::Node.new('parent')
+    child = LibXML::XML::Node.new('child')
+    parent << child
+
+    node_a = child.parent
+    node_b = child.parent
+    # In this case the nodes are equal - the parent being the root
+    assert(node_a.equal?(node_b))
+    assert(node_a == node_b)
+    assert(node_a.eql?(node_b))
   end
 
   def test_equality_nil
@@ -112,7 +123,7 @@ class TestNode < Test::Unit::TestCase
   def test_equality_wrong_type
     node = @doc.root
 
-    assert_raise(TypeError) do
+    assert_raises(TypeError) do
       assert(node != 'abc')
     end
   end
@@ -124,20 +135,20 @@ class TestNode < Test::Unit::TestCase
   end
 
   def test_base
-    doc = XML::Parser.string('<person />').parse
+    doc = LibXML::XML::Parser.string('<person />').parse
     assert_nil(doc.root.base_uri)
   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
+  # 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
 		text = '<bad-script>if (a &lt; b || b &gt; c) { return "text"; }<stop/>return "&gt;&gt;&gt;snip&lt;&lt;&lt;";</bad-script>'
-    node = XML::Parser.string(text).parse.root
+    node = LibXML::XML::Parser.string(text).parse.root
 		assert_equal text, node.to_s
 
 		text_noenc = '<bad-script>if (a < b || b > c) { return "text"; }<stop/>return ">>>snip<<<";</bad-script>'
@@ -154,10 +165,10 @@ class TestNode < Test::Unit::TestCase
 		assert_equal text, node.to_s
   end
 
-	# Just a sanity check for output escaping.
-	def test_output_escaping_sanity
+  # Just a sanity check for output escaping.
+  def test_output_escaping_sanity
 		text = '<bad-script>if (a &lt; b || b &gt; c) { return "text"; }<stop/>return "&gt;&gt;&gt;snip&lt;&lt;&lt;";</bad-script>'
-    node = XML::Parser.string(text).parse.root
+    node = LibXML::XML::Parser.string(text).parse.root
 		affected = node.find('//text()')
 
 		check_escaping = lambda do |flag|
@@ -190,25 +201,35 @@ class TestNode < Test::Unit::TestCase
     node = @doc.root
 
     node.space_preserve = false
-    assert_equal XML::Node::SPACE_DEFAULT, node.space_preserve
+    assert_equal LibXML::XML::Node::SPACE_DEFAULT, node.space_preserve
 
     node.space_preserve = true
-    assert_equal XML::Node::SPACE_PRESERVE, node.space_preserve
+    assert_equal LibXML::XML::Node::SPACE_PRESERVE, node.space_preserve
   end
 
   def test_empty
     text = '<name> </name>'
-    doc = XML::Parser.string(text).parse
+    doc = LibXML::XML::Parser.string(text).parse
 
     node = doc.root
     assert(!node.empty?)
-    
+
     text_node = node.first
     assert(text_node.empty?)
   end
 
+  def test_save_no_empty_tags
+    node = LibXML::XML::Node.new('test')
+    assert_equal '<test/>', node.to_s
+
+    LibXML::XML.default_save_no_empty_tags = true
+    assert_equal '<test></test>', node.to_s
+
+    LibXML::XML.default_save_no_empty_tags = false
+  end
+
   def test_set_content
-    node = XML::Node.new('test')
+    node = LibXML::XML::Node.new('test')
     node.content = "unescaped & string"
     assert_equal("unescaped & string", node.content)
     assert_equal("<test>unescaped &amp; string</test>", node.to_s)

data/test/{tc_node_cdata.rb → test_node_cdata.rb}

@@ -1,50 +1,49 @@
 # encoding: UTF-8
 
-require './test_helper'
-require 'test/unit'
+require_relative './test_helper'
 
-class CDataCommentTest < Test::Unit::TestCase
+class CDataCommentTest < Minitest::Test
   def setup
-    xp = XML::Parser.string('<root></root>')
+    xp = LibXML::XML::Parser.string('<root></root>')
     @doc = xp.parse
-    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(LibXML::XML::Document, @doc)
     @root = @doc.root
   end
 
   def test_node_type
-    cnode = XML::Node.new_cdata('test cdata')
-    assert_equal(XML::Node::CDATA_SECTION_NODE, cnode.node_type)
+    cnode = LibXML::XML::Node.new_cdata('test cdata')
+    assert_equal(LibXML::XML::Node::CDATA_SECTION_NODE, cnode.node_type)
   end
 
   def test_add_cdata
-    @root << XML::Node.new_cdata('mycdata')
+    @root << LibXML::XML::Node.new_cdata('mycdata')
     assert_equal '<root><![CDATA[mycdata]]></root>',
       @root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_add_cdata_2
-    @root << XML::Node.new_cdata('mycdata')
+    @root << LibXML::XML::Node.new_cdata('mycdata')
     assert_equal 'cdata',
     @root.child.node_type_name
   end
 
   def test_add_cdata_3
-    @root << el = XML::Node.new_cdata('mycdata')
+    @root << el = LibXML::XML::Node.new_cdata('mycdata')
     el << "_this_is_added"
     assert_equal '<root><![CDATA[mycdata_this_is_added]]></root>',
       @root.to_s.gsub(/\n\s*/,'')
   end
   
   def test_attributes
-    cnode = XML::Node.new_cdata('test cdata')
+    cnode = LibXML::XML::Node.new_cdata('test cdata')
     assert_equal(0, cnode.attributes.length)
   end
   
   def test_set_cdata_attribute
-    cnode = XML::Node.new_cdata('test cdata')
+    cnode = LibXML::XML::Node.new_cdata('test cdata')
     
     # Can't create attributes on non-element nodes
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       cnode['attr'] = '123'
     end
   end