nokogiri 1.8.5 → 1.9.1

data/test/xml/test_builder.rb

@@ -1,341 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestBuilder < Nokogiri::TestCase
-      def test_attribute_sensitivity
-        xml = Nokogiri::XML::Builder.new { |x|
-          x.tag "hello", "abcDef" => "world"
-        }.to_xml
-        doc = Nokogiri.XML xml
-        assert_equal 'world', doc.root['abcDef']
-      end
-
-      def test_builder_multiple_nodes
-        Nokogiri::XML::Builder.new do |xml|
-          0.upto(10) do
-            xml.text "test"
-          end
-        end
-      end
-
-
-      def test_builder_with_utf8_text
-        text = "test ﺵ "
-        doc = Nokogiri::XML::Builder.new(:encoding => "UTF-8") { |xml| xml.test text }.doc
-        assert_equal text, doc.content
-      end
-
-      def test_builder_escape
-        xml = Nokogiri::XML::Builder.new { |x|
-          x.condition "value < 1", :attr => "value < 1"
-        }.to_xml
-        doc = Nokogiri.XML xml
-        assert_equal 'value < 1', doc.root['attr']
-        assert_equal 'value < 1', doc.root.content
-      end
-
-      def test_builder_namespace
-        doc = Nokogiri::XML::Builder.new { |xml|
-          xml.a("xmlns:a" => "x") do
-            xml.b("xmlns:a" => "x", "xmlns:b" => "y")
-          end
-        }.doc
-
-        b = doc.at('b')
-        assert b
-        assert_equal({"xmlns:a"=>"x", "xmlns:b"=>"y"}, b.namespaces)
-        assert_equal({"xmlns:b"=>"y"}, namespaces_defined_on(b))
-      end
-
-      def test_builder_namespace_part_deux
-        doc = Nokogiri::XML::Builder.new { |xml|
-          xml.a("xmlns:b" => "y") do
-            xml.b("xmlns:a" => "x", "xmlns:b" => "y", "xmlns:c" => "z")
-          end
-        }.doc
-
-        b = doc.at('b')
-        assert b
-        assert_equal({"xmlns:a"=>"x", "xmlns:b"=>"y", "xmlns:c"=>"z"}, b.namespaces)
-        assert_equal({"xmlns:a"=>"x", "xmlns:c"=>"z"}, namespaces_defined_on(b))
-      end
-
-      def test_builder_with_unlink
-        b = Nokogiri::XML::Builder.new do |xml|
-          xml.foo do
-            xml.bar { xml.parent.unlink }
-            xml.bar2
-          end
-        end
-        assert b
-      end
-
-      def test_with_root
-        doc = Nokogiri::XML(File.read(XML_FILE))
-        Nokogiri::XML::Builder.with(doc.at('employee')) do |xml|
-          xml.foo
-        end
-        assert_equal 1, doc.xpath('//employee/foo').length
-      end
-
-      def test_root_namespace_default_decl
-        b = Nokogiri::XML::Builder.new { |xml| xml.root(:xmlns => 'one:two') }
-        doc = b.doc
-        assert_equal 'one:two', doc.root.namespace.href
-        assert_equal({ 'xmlns' => 'one:two' }, doc.root.namespaces)
-      end
-
-      def test_root_namespace_multi_decl
-        b = Nokogiri::XML::Builder.new { |xml|
-          xml.root(:xmlns => 'one:two', 'xmlns:foo' => 'bar') do
-            xml.hello
-          end
-        }
-        doc = b.doc
-        assert_equal 'one:two', doc.root.namespace.href
-        assert_equal({ 'xmlns' => 'one:two', 'xmlns:foo' => 'bar' }, doc.root.namespaces)
-
-        assert_equal 'one:two', doc.at('hello').namespace.href
-      end
-
-      def test_non_root_namespace
-        b = Nokogiri::XML::Builder.new { |xml|
-          xml.root { xml.hello(:xmlns => 'one') }
-        }
-        assert_equal 'one', b.doc.at('hello', 'xmlns' => 'one').namespace.href
-      end
-
-      def test_specify_namespace
-        b = Nokogiri::XML::Builder.new { |xml|
-          xml.root('xmlns:foo' => 'bar') do
-            xml[:foo].bar
-            xml['foo'].baz
-          end
-        }
-        doc = b.doc
-        assert_equal 'bar', doc.at('foo|bar', 'foo' => 'bar').namespace.href
-        assert_equal 'bar', doc.at('foo|baz', 'foo' => 'bar').namespace.href
-      end
-
-      def test_dtd_in_builder_output
-        builder = Nokogiri::XML::Builder.new do |xml|
-          xml.doc.create_internal_subset(
-                                         'html',
-                                         "-//W3C//DTD HTML 4.01 Transitional//EN",
-                                         "http://www.w3.org/TR/html4/loose.dtd"
-                                         )
-          xml.root do
-            xml.foo
-          end
-        end
-        assert_match(/<!DOCTYPE html PUBLIC "-\/\/W3C\/\/DTD HTML 4.01 Transitional\/\/EN" "http:\/\/www.w3.org\/TR\/html4\/loose.dtd">/,
-                     builder.to_xml)
-      end
-
-      def test_specify_namespace_nested
-        b = Nokogiri::XML::Builder.new { |xml|
-          xml.root('xmlns:foo' => 'bar') do
-            xml.yay do
-              xml[:foo].bar
-
-              xml.yikes do
-                xml['foo'].baz
-              end
-            end
-          end
-        }
-        doc = b.doc
-        assert_equal 'bar', doc.at('foo|bar', 'foo' => 'bar').namespace.href
-        assert_equal 'bar', doc.at('foo|baz', 'foo' => 'bar').namespace.href
-      end
-
-      def test_specified_namespace_postdeclared
-        doc = Nokogiri::XML::Builder.new { |xml|
-          xml.a do
-            xml[:foo].b("xmlns:foo" => "bar")
-          end
-        }.doc
-        a = doc.at('a')
-        assert_equal({}, a.namespaces)
-
-        b = doc.at_xpath('//foo:b', {:foo=>'bar'})
-        assert b
-        assert_equal({"xmlns:foo"=>"bar"}, b.namespaces)
-        assert_equal("b", b.name)
-        assert_equal("bar", b.namespace.href)
-      end
-
-      def test_specified_namespace_undeclared
-        Nokogiri::XML::Builder.new { |xml|
-          xml.root do
-            assert_raises(ArgumentError) do
-              xml[:foo].bar
-            end
-          end
-        }
-      end
-
-      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_raw_append
-        builder = Nokogiri::XML::Builder.new do |xml|
-          xml.root do
-            xml << 'hello'
-          end
-        end
-
-        assert_equal 'hello', builder.doc.at('/root').content
-      end
-
-      def test_raw_append_with_instance_eval
-        builder = Nokogiri::XML::Builder.new do
-          root do
-            self << 'hello'
-          end
-        end
-
-        assert_equal 'hello', builder.doc.at('/root').content
-      end
-
-      def test_raw_xml_append
-        builder = Nokogiri::XML::Builder.new do |xml|
-          xml.root do
-            xml << '<aaa><bbb/><ccc/></aaa>'
-          end
-        end
-
-        assert_equal ["aaa"],       builder.doc.at_css("root").children.collect(&:name)
-        assert_equal ["bbb","ccc"], builder.doc.at_css("aaa").children.collect(&:name)
-      end
-
-      def test_raw_xml_append_with_namespaces
-        doc = Nokogiri::XML::Builder.new do |xml|
-          xml.root("xmlns:foo" => "x", "xmlns" => "y") do
-            xml << '<Element foo:bar="bazz"/>'
-          end
-        end.doc
-
-        el = doc.at 'Element'
-        assert_not_nil el
-
-        assert_equal 'y', el.namespace.href
-        assert_nil el.namespace.prefix
-
-        attr = el.attributes["bar"]
-        assert_not_nil attr
-        assert_not_nil attr.namespace
-        assert_equal "foo", attr.namespace.prefix
-      end
-
-      def test_cdata
-        builder = Nokogiri::XML::Builder.new do
-          root {
-            cdata "hello world"
-          }
-        end
-        assert_equal("<?xml version=\"1.0\"?><root><![CDATA[hello world]]></root>",
-          builder.to_xml.gsub(/\n/, ""))
-      end
-
-      def test_comment
-        builder = Nokogiri::XML::Builder.new do
-          root {
-            comment "this is a comment"
-          }
-        end
-        assert builder.doc.root.children.first.comment?
-      end
-
-      def test_builder_no_block
-        string = "hello world"
-        builder = Nokogiri::XML::Builder.new
-        builder.root {
-          cdata string
-        }
-        assert_equal("<?xml version=\"1.0\"?><root><![CDATA[hello world]]></root>",
-          builder.to_xml.gsub(/\n/, ''))
-      end
-
-      def test_builder_can_inherit_parent_namespace
-        builder = Nokogiri::XML::Builder.new
-        builder.products {
-          builder.parent.default_namespace = "foo"
-          builder.product {
-            builder.parent.default_namespace = nil
-          }
-        }
-        doc = builder.doc
-        ['product', 'products'].each do |n|
-          assert_equal doc.at_xpath("//*[local-name() = '#{n}']").namespace.href, 'foo'
-        end
-      end
-
-      def test_builder_can_handle_namespace_override
-        builder = Nokogiri::XML::Builder.new
-        builder.products('xmlns:foo' => 'bar') {
-          builder.product('xmlns:foo' => 'baz')
-        }
-
-        doc = builder.doc
-        assert_equal doc.at_xpath("//*[local-name() = 'product']").namespaces['xmlns:foo'], 'baz'
-        assert_equal doc.at_xpath("//*[local-name() = 'products']").namespaces['xmlns:foo'], 'bar'
-        assert_nil doc.at_xpath("//*[local-name() = 'products']").namespace
-      end
-
-      private
-
-      def namespaces_defined_on(node)
-        Hash[*node.namespace_definitions.collect{|n| ["xmlns:" + n.prefix, n.href]}.flatten]
-      end
-    end
-  end
-end

data/test/xml/test_c14n.rb

@@ -1,180 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestC14N < Nokogiri::TestCase
-      # http://www.w3.org/TR/xml-c14n#Example-OutsideDoc
-      def test_3_1
-        doc = Nokogiri.XML <<-eoxml
-<?xml version="1.0"?>
-
-<?xml-stylesheet   href="doc.xsl"
-   type="text/xsl"   ?>
-
-<!DOCTYPE doc SYSTEM "doc.dtd">
-
-<doc>Hello, world!<!-- Comment 1 --></doc>
-
-<?pi-without-data     ?>
-
-<!-- Comment 2 -->
-
-<!-- Comment 3 -->
-        eoxml
-
-        c14n = doc.canonicalize
-        assert_no_match(/version=/, c14n)
-        assert_match(/Hello, world/, c14n)
-        assert_no_match(/Comment/, c14n)
-        c14n = doc.canonicalize(nil, nil, true)
-        assert_match(/Comment/, c14n)
-        c14n = doc.canonicalize(nil, nil, false)
-        assert_no_match(/Comment/, c14n)
-      end
-
-      def test_exclude_block_params
-        xml = '<a><b></b></a>'
-        doc = Nokogiri.XML xml
-
-        list = []
-        doc.canonicalize do |node, parent|
-          list << [node, parent]
-          true
-        end
-        if Nokogiri.jruby?
-          assert_equal(
-            ['a', 'document', 'document', nil, 'b', 'a'],
-            list.flatten.map { |x| x ? x.name : x }
-          )
-        else
-          assert_equal(
-            ['a', 'document', 'document', nil, 'b', 'a', 'a', 'document'],
-            list.flatten.map { |x| x ? x.name : x }
-          )
-        end
-      end
-
-      def test_exclude_block_true
-        xml = '<a><b></b></a>'
-        doc = Nokogiri.XML xml
-
-        c14n = doc.canonicalize do |node, parent|
-          true
-        end
-        assert_equal xml, c14n
-      end
-
-      def test_exclude_block_false
-        xml = '<a><b></b></a>'
-        doc = Nokogiri.XML xml
-
-        c14n = doc.canonicalize do |node, parent|
-          false
-        end
-        assert_equal '', c14n
-      end
-
-      def test_exclude_block_nil
-        xml = '<a><b></b></a>'
-        doc = Nokogiri.XML xml
-
-        c14n = doc.canonicalize do |node, parent|
-          nil
-        end
-        assert_equal '', c14n
-      end
-
-      def test_exclude_block_object
-        xml = '<a><b></b></a>'
-        doc = Nokogiri.XML xml
-
-        c14n = doc.canonicalize do |node, parent|
-          Object.new
-        end
-        assert_equal xml, c14n
-      end
-
-      def test_c14n_node
-        xml = '<a><b><c></c></b></a>'
-        doc = Nokogiri.XML xml
-        c14n = doc.at_xpath('//b').canonicalize
-        assert_equal '<b><c></c></b>', c14n
-      end
-
-      def test_c14n_modes
-        # http://www.w3.org/TR/xml-exc-c14n/#sec-Enveloping
-        
-        doc1 = Nokogiri.XML <<-EOXML
-<n0:local xmlns:n0="http://foobar.org" xmlns:n3="ftp://example.org">
-  <n1:elem2 xmlns:n1="http://example.net" xml:lang="en">
-    <n3:stuff xmlns:n3="ftp://example.org"/>
-  </n1:elem2>
-</n0:local>        
-        EOXML
-
-        doc2 = Nokogiri.XML <<-EOXML
-<n2:pdu xmlns:n1="http://example.com"
-           xmlns:n2="http://foo.example"
-           xmlns:n4="http://foo.example"
-           xml:lang="fr"
-           xml:space="retain">
-  <n1:elem2 xmlns:n1="http://example.net" xml:lang="en">
-    <n3:stuff xmlns:n3="ftp://example.org"/>
-    <n4:stuff />
-  </n1:elem2>
-</n2:pdu>        
-        EOXML
-
-        c14n = doc1.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize
-        assert_equal '<n1:elem2 xmlns:n0="http://foobar.org" xmlns:n1="http://example.net" xmlns:n3="ftp://example.org" xml:lang="en">
-    <n3:stuff></n3:stuff>
-  </n1:elem2>', c14n
-
-        expected = '<n1:elem2 xmlns:n1="http://example.net" xmlns:n2="http://foo.example" xmlns:n4="http://foo.example" xml:lang="en" xml:space="retain">
-    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
-    <n4:stuff></n4:stuff>
-  </n1:elem2>'
-        c14n = doc2.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize
-        assert_equal expected, c14n
-
-        expected = '<n1:elem2 xmlns:n1="http://example.net" xml:lang="en">
-    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
-  </n1:elem2>'
-        c14n = doc1.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize(XML::XML_C14N_EXCLUSIVE_1_0)
-        assert_equal expected, c14n
-
-        expected = '<n1:elem2 xmlns:n1="http://example.net" xml:lang="en">
-    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
-    <n4:stuff xmlns:n4="http://foo.example"></n4:stuff>
-  </n1:elem2>'
-        c14n = doc2.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize(XML::XML_C14N_EXCLUSIVE_1_0)
-        assert_equal expected, c14n
-
-        expected = '<n1:elem2 xmlns:n1="http://example.net" xmlns:n2="http://foo.example" xml:lang="en">
-    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
-    <n4:stuff xmlns:n4="http://foo.example"></n4:stuff>
-  </n1:elem2>'
-        c14n = doc2.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize(XML::XML_C14N_EXCLUSIVE_1_0, ['n2'])
-        assert_equal expected, c14n
-
-        expected = '<n1:elem2 xmlns:n1="http://example.net" xmlns:n2="http://foo.example" xmlns:n4="http://foo.example" xml:lang="en">
-    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
-    <n4:stuff></n4:stuff>
-  </n1:elem2>'
-        c14n = doc2.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize(XML::XML_C14N_EXCLUSIVE_1_0, ['n2', 'n4'])
-        assert_equal expected, c14n
-      end
-
-      def test_wrong_params
-        xml = '<a><b></b></a>'
-        doc = Nokogiri.XML xml
-
-        assert_raise(TypeError){ doc.canonicalize :wrong_type }
-        assert_raise(TypeError){ doc.canonicalize nil, :wrong_type }
-        doc.canonicalize nil, nil, :wrong_type
-      end
-
-
-    end
-  end
-end

data/test/xml/test_cdata.rb

@@ -1,54 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestCDATA < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
-      end
-
-      def test_cdata_node
-        name = @xml.xpath('//employee[2]/name').first
-        assert cdata = name.children[1]
-        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_nil node.content
-      end
-
-      def test_new_with_non_string
-        assert_raises(TypeError) do
-          CDATA.new(@xml, 1.234)
-        end
-      end
-
-      def test_lots_of_new_cdata
-        assert 100.times { CDATA.new(@xml, "asdfasdf") }
-      end
-
-      def test_content=
-        node = CDATA.new(@xml, 'foo')
-        assert_equal('foo', node.content)
-
-        node.content = '& <foo> &amp;'
-        assert_equal('& <foo> &amp;', node.content)
-        assert_equal('<![CDATA[& <foo> &amp;]]>', node.to_xml)
-
-        node.content = 'foo ]]> bar'
-        assert_equal('foo ]]> bar', node.content)
-      end
-    end
-  end
-end

data/test/xml/test_comment.rb

@@ -1,40 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestComment < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
-      end
-
-      def test_new
-        comment = Nokogiri::XML::Comment.new(@xml, 'hello world')
-        assert_equal('<!--hello world-->', comment.to_s)
-      end
-
-      def test_comment?
-        comment = Nokogiri::XML::Comment.new(@xml, 'hello world')
-        assert(comment.comment?)
-        assert(!@xml.root.comment?)
-      end
-
-      def test_passing_a_node_uses_the_node_document
-        comment = Nokogiri::XML::Comment.new(@xml.at_css("employee"), 'hello world')
-        assert_equal @xml, comment.document
-      end
-
-      def test_passing_anything_else
-        assert_raises ArgumentError do
-          Nokogiri::XML::Comment.new("NOT A NOKOGIRI CLASS", 'hello world')
-        end
-      end
-
-      def test_many_comments
-        100.times {
-          Nokogiri::XML::Comment.new(@xml, 'hello world')
-        }
-      end
-    end
-  end
-end