nokogiri 1.2.3 → 1.3.0

data/test/test_xslt_transforms.rb

@@ -1,93 +1,131 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
 
 class TestXsltTransforms < Nokogiri::TestCase
-  def test_transform
-    assert doc = Nokogiri::XML.parse(File.read(XML_FILE))
-    assert doc.xml?
-
-    assert style = Nokogiri::XSLT.parse(File.read(XSLT_FILE))
-
-    assert result = style.apply_to(doc, ['title', '"Booyah"'])
-    assert_match %r{<h1>Booyah</h1>}, result
-    assert_match %r{<th.*Employee ID</th>}, result
-    assert_match %r{<th.*Name</th>}, result
-    assert_match %r{<th.*Position</th>}, result
-    assert_match %r{<th.*Salary</th>}, result
-    assert_match %r{<td>EMP0003</td>}, result
-    assert_match %r{<td>Margaret Martin</td>}, result
-    assert_match %r{<td>Computer Specialist</td>}, result
-    assert_match %r{<td>100,000</td>}, result
-    assert_no_match %r{Dallas|Texas}, result
-    assert_no_match %r{Female}, result
-
-    assert result = style.apply_to(doc, ['title', '"Grandma"'])
-    assert_match %r{<h1>Grandma</h1>}, result
-
-    assert result = style.apply_to(doc)
-    assert_match %r{<h1></h1>}, result
-  end
-  def test_transform2
-    assert doc = Nokogiri::XML.parse(File.read(XML_FILE))
-    assert doc.xml?
 
-    assert style = Nokogiri::XSLT.parse(File.read(XSLT_FILE))
-    assert result_doc = style.transform(doc, ['title', '"Booyah"'])
-    assert doc.xml?
+  if Nokogiri::VERSION_INFO['libxml']['loaded'] > '2.6.16'
 
-    assert result_string = style.apply_to(doc, ['title', '"Booyah"'])
-    assert_equal result_string, style.serialize(result_doc)
-  end
-  def test_quote_params
-    h = {
-      :sym   => %{xxx},
-      'str'  => %{"xxx"},
-      :sym2  => %{'xxx'},
-      'str2' => %{x'x'x},
-      :sym3  => %{x"x"x},
-    }
-    hh=h.dup
-    result_hash = Nokogiri::XSLT.quote_params(h)
-    assert_equal hh, h # non-destructive 
-
-    a=h.to_a.flatten
-    result_array = Nokogiri::XSLT.quote_params(a)
-    assert_equal h.to_a.flatten, a #non-destructive
-
-    assert_equal  result_array, result_hash
-  end
+    def test_class_methods
+      doc   = Nokogiri::XML(File.read(XML_FILE))
+      style = Nokogiri::XSLT(File.read(XSLT_FILE))
 
-  def test_exslt
-    assert doc = Nokogiri::XML.parse(File.read(EXML_FILE))
-    assert doc.xml?
-    
-    assert style = Nokogiri::XSLT.parse(File.read(EXSLT_FILE))
-    params = { 
-      :p1 => 'xxx',
-      :p2 => "x'x'x",
-      :p3 => 'x"x"x',
-      :p4 => '"xxx"'
-    }
-    result_doc = Nokogiri::XML.parse(style.apply_to(doc, 
-        Nokogiri::XSLT.quote_params(params)))
+      assert result = style.apply_to(doc, ['title', '"Grandma"'])
+      assert_match %r{<h1>Grandma</h1>}, result
+    end
+
+    def test_transform
+      assert doc = Nokogiri::XML.parse(File.read(XML_FILE))
+      assert doc.xml?
+
+      assert style = Nokogiri::XSLT.parse(File.read(XSLT_FILE))
+
+      assert result = style.apply_to(doc, ['title', '"Booyah"'])
+      assert_match %r{<h1>Booyah</h1>}, result
+      assert_match %r{<th.*Employee ID</th>}, result
+      assert_match %r{<th.*Name</th>}, result
+      assert_match %r{<th.*Position</th>}, result
+      assert_match %r{<th.*Salary</th>}, result
+      assert_match %r{<td>EMP0003</td>}, result
+      assert_match %r{<td>Margaret Martin</td>}, result
+      assert_match %r{<td>Computer Specialist</td>}, result
+      assert_match %r{<td>100,000</td>}, result
+      assert_no_match %r{Dallas|Texas}, result
+      assert_no_match %r{Female}, result
+
+      assert result = style.apply_to(doc, ['title', '"Grandma"'])
+      assert_match %r{<h1>Grandma</h1>}, result
+
+      assert result = style.apply_to(doc)
+      assert_match %r{<h1></h1>}, result
+    end
+
+    def test_transform2
+      assert doc = Nokogiri::XML.parse(File.read(XML_FILE))
+      assert doc.xml?
+
+      assert style = Nokogiri::XSLT.parse(File.read(XSLT_FILE))
+      assert result_doc = style.transform(doc)
+      assert doc.xml?
+
+      assert style = Nokogiri::XSLT.parse(File.read(XSLT_FILE))
+      assert result_doc = style.transform(doc, ['title', '"Booyah"'])
+      assert doc.xml?
+
+      assert result_string = style.apply_to(doc, ['title', '"Booyah"'])
+      assert_equal result_string, style.serialize(result_doc)
+    end
+
+    def test_quote_params
+      h = {
+        :sym   => %{xxx},
+        'str'  => %{"xxx"},
+        :sym2  => %{'xxx'},
+        'str2' => %{x'x'x},
+        :sym3  => %{x"x"x},
+      }
+      hh=h.dup
+      result_hash = Nokogiri::XSLT.quote_params(h)
+      assert_equal hh, h # non-destructive 
+
+      a=h.to_a.flatten
+      result_array = Nokogiri::XSLT.quote_params(a)
+      assert_equal h.to_a.flatten, a #non-destructive
+
+      assert_equal  result_array, result_hash
+    end
+
+    def test_exslt
+      assert doc = Nokogiri::XML.parse(File.read(EXML_FILE))
+      assert doc.xml?
+      
+      assert style = Nokogiri::XSLT.parse(File.read(EXSLT_FILE))
+      params = { 
+        :p1 => 'xxx',
+        :p2 => "x'x'x",
+        :p3 => 'x"x"x',
+        :p4 => '"xxx"'
+      }
+      result_doc = Nokogiri::XML.parse(style.apply_to(doc, 
+          Nokogiri::XSLT.quote_params(params)))
+      
+      assert_equal 'func-result', result_doc.at('/root/function').content
+      assert_equal 3, result_doc.at('/root/max').content.to_i
+      assert_match(
+        /\d{4}-\d\d-\d\d[-|+]\d\d:\d\d/,
+        result_doc.at('/root/date').content
+        )
+      result_doc.xpath('/root/params/*').each do  |p|
+        assert_equal p.content, params[p.name.intern]
+      end
+      check_params result_doc, params
+      result_doc = Nokogiri::XML.parse(style.apply_to(doc, 
+          Nokogiri::XSLT.quote_params(params.to_a.flatten)))
+      check_params result_doc, params
+    end
     
-    assert_equal 'func-result', result_doc.at('/root/function').content
-    assert_equal 3, result_doc.at('/root/max').content.to_i
-    assert_match(
-      /\d{4}-\d\d-\d\d[-|+]\d\d:\d\d/,
-      result_doc.at('/root/date').content
-      )
-    result_doc.xpath('/root/params/*').each do  |p|
-      assert_equal p.content, params[p.name.intern]
+    def test_xslt_parse_error
+      xslt_str = <<-EOX
+<xsl:stylesheet version="1.0"
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <!-- Not well-formed: -->
+  <xsl:template match="/"/>
+    <values>
+      <xsl:for-each select="//*">
+        <value>
+          <xsl:value-of select="@id"/>
+        </value>
+      </xsl:for-each>
+    </values>
+  </xsl:template>
+</xsl:stylesheet>}
+      EOX
+      assert_raises(RuntimeError) { Nokogiri::XSLT.parse(xslt_str) }
     end
-    check_params result_doc, params
-    result_doc = Nokogiri::XML.parse(style.apply_to(doc, 
-        Nokogiri::XSLT.quote_params(params.to_a.flatten)))
-    check_params result_doc, params
-  end
-  
-  def check_params result_doc, params
-    result_doc.xpath('/root/params/*').each do  |p|
-      assert_equal p.content, params[p.name.intern]
+
+    def check_params result_doc, params
+      result_doc.xpath('/root/params/*').each do  |p|
+        assert_equal p.content, params[p.name.intern]
+      end
     end
+
   end
 end

data/test/xml/node/test_subclass.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..',"helper"))
+
+module Nokogiri
+  module XML
+    class Node
+      class TestSubclass < Nokogiri::TestCase
+        {
+          Nokogiri::XML::CDATA                  => 'doc, "foo"',
+          Nokogiri::XML::Attr                   => 'doc, "foo"',
+          Nokogiri::XML::Comment                => 'doc, "foo"',
+          Nokogiri::XML::EntityReference        => 'doc, "foo"',
+          Nokogiri::XML::ProcessingInstruction  => 'doc, "foo", "bar"',
+          Nokogiri::XML::DocumentFragment       => 'doc',
+          Nokogiri::XML::Node                   => '"foo", doc',
+          Nokogiri::XML::Text                   => '"foo", doc',
+        }.each do |klass, constructor|
+          class_eval %{
+            def test_subclass_#{klass.name.gsub('::', '_')}
+              doc = Nokogiri::XML::Document.new
+              klass = Class.new(#{klass.name})
+              node = klass.new(#{constructor})
+              assert_instance_of klass, node
+            end
+          }
+
+          class_eval <<-eocode, __FILE__, __LINE__ + 1
+            def test_subclass_initialize_#{klass.name.gsub('::', '_')}
+              doc = Nokogiri::XML::Document.new
+              klass = Class.new(#{klass.name}) do
+                attr_accessor :initialized_with
+
+                def initialize *args
+                  @initialized_with = args
+                end
+              end
+              node = klass.new(#{constructor}, 1)
+              assert_equal [#{constructor}, 1], node.initialized_with
+            end
+          eocode
+        end
+      end
+    end
+  end
+end

data/test/xml/sax/test_parser.rb

@@ -90,6 +90,11 @@ module Nokogiri
 
         def test_parse_file
           @parser.parse_file(XML_FILE)
+
+          assert_raises(ArgumentError) {
+            @parser.parse_file(nil)
+          }
+
           assert_raises(Errno::ENOENT) {
             @parser.parse_file('')
           }
@@ -98,6 +103,10 @@ module Nokogiri
           }
         end
 
+        def test_render_parse_nil_param
+          assert_raises(ArgumentError) { @parser.parse_memory(nil) }
+        end
+
         def test_ctag
           @parser.parse_memory(<<-eoxml)
             <p id="asdfasdf">

data/test/xml/sax/test_push_parser.rb

@@ -38,6 +38,30 @@ module Nokogiri
           @parser.finish
         end
 
+        def test_start_element_ns
+          @parser.<<(<<-eoxml)
+            <stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0' size='large'></stream:stream>
+          eoxml
+
+          assert_equal [[ 'stream',
+                          {'version' => '1.0', 'size' => 'large'},
+                          'stream',
+                          'http://etherx.jabber.org/streams',
+                          {nil => 'jabber:client', 'stream' => 'http://etherx.jabber.org/streams'}]],
+            @parser.document.start_elements_ns
+          @parser.finish
+        end
+
+        def test_end_element_ns
+          @parser.<<(<<-eoxml)
+            <stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0'></stream:stream>
+          eoxml
+
+          assert_equal [['stream', 'stream', 'http://etherx.jabber.org/streams']],
+            @parser.document.end_elements_ns
+          @parser.finish
+        end
+
         def test_chevron_partial_xml
           @parser.<<(<<-eoxml)
             <p id="asdfasdf">

data/test/xml/test_attr.rb

@@ -3,6 +3,13 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
 module Nokogiri
   module XML
     class TestAttr < Nokogiri::TestCase
+      def test_new
+        100.times {
+          doc = Nokogiri::XML::Document.new
+          attribute = Nokogiri::XML::Attr.new(doc, 'foo')
+        }
+      end
+
       def test_content=
         xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
         address = xml.xpath('//address')[3]

data/test/xml/test_builder.rb

@@ -3,6 +3,54 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
 module Nokogiri
   module XML
     class TestBuilder < Nokogiri::TestCase
+      def test_set_encoding
+        builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml.root do
+            xml.bar 'blah'
+          end
+        end
+        assert_match 'UTF-8', builder.to_xml
+      end
+
+      def test_bang_and_underscore_is_escaped
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.root do
+            xml.p_('adsfadsf')
+            xml.p!('adsfadsf')
+          end
+        end
+        assert_equal 2, builder.doc.xpath('//p').length
+      end
+
+      def test_square_brackets_set_attributes
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.root do
+            foo = xml.foo
+            foo['id'] = 'hello'
+            assert_equal 'hello', foo['id']
+          end
+        end
+        assert_equal 1, builder.doc.xpath('//foo[@id = "hello"]').length
+      end
+
+      def test_nested_local_variable
+        @ivar     = 'hello'
+        local_var = 'hello world'
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.root do
+            xml.foo local_var
+            xml.bar @ivar
+            xml.baz {
+              xml.text @ivar
+            }
+          end
+        end
+
+        assert_equal 'hello world', builder.doc.at('//root/foo').content
+        assert_equal 'hello', builder.doc.at('//root/bar').content
+        assert_equal 'hello', builder.doc.at('baz').content
+      end
+
       def test_cdata
         builder = Nokogiri::XML::Builder.new do
           root {

data/test/xml/test_cdata.rb

@@ -14,6 +14,25 @@ module Nokogiri
         assert cdata.cdata?
         assert_equal '#cdata-section', cdata.name
       end
+
+      def test_new
+        node = CDATA.new(@xml, "foo")
+        assert_equal "foo", node.content
+
+        node = CDATA.new(@xml.root, "foo")
+        assert_equal "foo", node.content
+      end
+
+      def test_new_with_nil
+        node = CDATA.new(@xml, nil)
+        assert_equal nil, node.content
+      end
+
+      def test_lots_of_new_cdata
+        100.times {
+          node = CDATA.new(@xml, "asdfasdf")
+        }
+      end
     end
   end
 end

data/test/xml/test_comment.rb

@@ -12,6 +12,12 @@ module Nokogiri
         comment = Nokogiri::XML::Comment.new(@xml, 'hello world')
         assert_equal('<!--hello world-->', comment.to_s)
       end
+
+      def test_many_comments
+        100.times {
+          Nokogiri::XML::Comment.new(@xml, 'hello world')
+        }
+      end
     end
   end
 end

data/test/xml/test_document.rb

@@ -10,6 +10,80 @@ module Nokogiri
         @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
       end
 
+      def test_parse_takes_block
+        options = nil
+        Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE) do |cfg|
+          options = cfg
+        end
+        assert options
+      end
+
+      def test_parse_yields_parse_options
+        options = nil
+        Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE) do |cfg|
+          options = cfg
+          options.nonet.nowarning.dtdattr
+        end
+        assert options.nonet?
+        assert options.nowarning?
+        assert options.dtdattr?
+      end
+
+      def test_XML_takes_block
+        options = nil
+        Nokogiri::XML(File.read(XML_FILE), XML_FILE) do |cfg|
+          options = cfg
+          options.nonet.nowarning.dtdattr
+        end
+        assert options.nonet?
+        assert options.nowarning?
+        assert options.dtdattr?
+      end
+
+      def test_subclass
+        klass = Class.new(Nokogiri::XML::Document)
+        doc = klass.new
+        assert_instance_of klass, doc
+      end
+
+      def test_subclass_initialize
+        klass = Class.new(Nokogiri::XML::Document) do
+          attr_accessor :initialized_with
+
+          def initialize(*args)
+            @initialized_with = args
+          end
+        end
+        doc = klass.new("1.0", 1)
+        assert_equal ["1.0", 1], doc.initialized_with
+      end
+
+      def test_subclass_dup
+        klass = Class.new(Nokogiri::XML::Document)
+        doc = klass.new.dup
+        assert_instance_of klass, doc
+      end
+
+      def test_subclass_parse
+        klass = Class.new(Nokogiri::XML::Document)
+        doc = klass.parse(File.read(XML_FILE))
+        assert_equal @xml.to_s, doc.to_s
+        assert_instance_of klass, doc
+      end
+
+      def test_document_parse_method
+        xml = Nokogiri::XML::Document.parse(File.read(XML_FILE))
+        assert_equal @xml.to_s, xml.to_s
+      end
+
+      def test_encoding=
+        @xml.encoding = 'UTF-8'
+        assert_match 'UTF-8', @xml.to_xml
+
+        @xml.encoding = 'EUC-JP'
+        assert_match 'EUC-JP', @xml.to_xml
+      end
+
       def test_namespace_should_not_exist
         assert_raises(NoMethodError) {
           @xml.namespace
@@ -17,13 +91,22 @@ module Nokogiri
       end
 
       def test_non_existant_function
-        assert_raises(RuntimeError) {
+        # WTF.  I don't know why this is different between MRI and ffi.
+        # They should be the same...  Either way, raising an exception
+        # is the correct thing to do.
+        exception = RuntimeError
+
+        if Nokogiri::VERSION_INFO['libxml']['platform'] == 'jruby'
+          exception = Nokogiri::XML::XPath::SyntaxError
+        end
+
+        assert_raises(exception) {
           @xml.xpath('//name[foo()]')
         }
       end
 
       def test_ancestors
-        assert_equal [], @xml.ancestors
+        assert_equal 0, @xml.ancestors.length
       end
 
       def test_root_node_parent_is_document
@@ -68,6 +151,22 @@ module Nokogiri
         assert_equal 1, doc.search('//xmlns:foo').search('./xmlns:bar').length
       end
 
+      def test_to_xml_with_indent
+        doc = Nokogiri::XML('<root><foo><bar/></foo></root>')
+        doc = Nokogiri::XML(doc.to_xml(:indent => 5))
+
+        assert_indent 5, doc
+      end
+
+      def test_write_xml_to_with_indent
+        io = StringIO.new
+        doc = Nokogiri::XML('<root><foo><bar/></foo></root>')
+        doc.write_xml_to io, :indent => 5
+        io.rewind
+        doc = Nokogiri::XML(io.read)
+        assert_indent 5, doc
+      end
+
       # wtf...  osx's libxml sucks.
       unless Nokogiri::LIBXML_VERSION =~ /^2\.6\./
         def test_encoding