nokogiri 1.6.2.rc1-x64-mingw32

data/test/xml/sax/test_parser_context.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+
+require "helper"
+
+module Nokogiri
+  module XML
+    module SAX
+      class TestParserContext < Nokogiri::SAX::TestCase
+        def setup
+          @xml = '<hello>
+
+world
+<inter>
+    <net>
+    </net>
+</inter>
+
+</hello>'
+        end
+
+        class Counter < Nokogiri::XML::SAX::Document
+          attr_accessor :context, :lines, :columns
+          def initialize
+            @context = nil
+            @lines   = []
+            @columns = []
+          end
+
+          def start_element name, attrs = []
+            @lines << [name, context.line]
+            @columns << [name, context.column]
+          end
+        end
+
+        def test_line_numbers
+          sax_handler = Counter.new
+
+          parser = Nokogiri::XML::SAX::Parser.new(sax_handler)
+          parser.parse(@xml) do |ctx|
+            sax_handler.context = ctx
+          end
+
+          assert_equal [["hello", 1], ["inter", 4], ["net", 5]],
+            sax_handler.lines
+        end
+
+        def test_column_numbers
+          sax_handler = Counter.new
+
+          parser = Nokogiri::XML::SAX::Parser.new(sax_handler)
+          parser.parse(@xml) do |ctx|
+            sax_handler.context = ctx
+          end
+
+          assert_equal [["hello", 7], ["inter", 7], ["net", 9]],
+            sax_handler.columns
+        end
+
+        def test_replace_entities
+          pc = ParserContext.new StringIO.new('<root />'), 'UTF-8'
+          pc.replace_entities = false
+          assert_equal false, pc.replace_entities
+
+          pc.replace_entities = true
+          assert_equal true, pc.replace_entities
+        end
+
+        def test_recovery
+          pc = ParserContext.new StringIO.new('<root />'), 'UTF-8'
+          pc.recovery = false
+          assert_equal false, pc.recovery
+
+          pc.recovery = true
+          assert_equal true, pc.recovery
+        end
+
+        def test_from_io
+          ctx = ParserContext.new StringIO.new('fo'), 'UTF-8'
+          assert ctx
+        end
+
+        def test_from_string
+          assert ParserContext.new 'blah blah'
+        end
+
+        def test_parse_with
+          ctx = ParserContext.new 'blah'
+          assert_raises ArgumentError do
+            ctx.parse_with nil
+          end
+        end
+
+        def test_parse_with_sax_parser
+          xml = "<root />"
+          ctx = ParserContext.new xml
+          parser = Parser.new Doc.new
+          assert_nil ctx.parse_with parser
+        end
+
+        def test_from_file
+          ctx = ParserContext.file XML_FILE
+          parser = Parser.new Doc.new
+          assert_nil ctx.parse_with parser
+        end
+
+        def test_parse_with_returns_nil
+          xml = "<root />"
+          ctx = ParserContext.new xml
+          parser = Parser.new Doc.new
+          assert_nil ctx.parse_with(parser)
+        end
+      end
+    end
+  end
+end

data/test/xml/sax/test_push_parser.rb

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+
+require "helper"
+
+module Nokogiri
+  module XML
+    module SAX
+      class TestPushParser < Nokogiri::SAX::TestCase
+        def setup
+          super
+          @parser = XML::SAX::PushParser.new(Doc.new)
+        end
+
+        def test_exception
+          assert_raises(SyntaxError) do
+            @parser << "<foo /><foo />"
+          end
+
+          assert_raises(SyntaxError) do
+            @parser << nil
+          end
+        end
+
+        def test_end_document_called
+          @parser.<<(<<-eoxml)
+            <p id="asdfasdf">
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          assert ! @parser.document.end_document_called
+          @parser.finish
+          assert @parser.document.end_document_called
+        end
+
+        def test_start_element
+          @parser.<<(<<-eoxml)
+            <p id="asdfasdf">
+          eoxml
+
+          assert_equal [["p", [["id", "asdfasdf"]]]],
+            @parser.document.start_elements
+
+          @parser.<<(<<-eoxml)
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          assert_equal [' This is a comment '], @parser.document.comments
+          @parser.finish
+        end
+
+        def test_start_element_with_namespaces
+          @parser.<<(<<-eoxml)
+            <p xmlns:foo="http://foo.example.com/">
+          eoxml
+
+          assert_equal [["p", [["xmlns:foo", "http://foo.example.com/"]]]],
+            @parser.document.start_elements
+
+          @parser.<<(<<-eoxml)
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          assert_equal [' This is a comment '], @parser.document.comments
+          @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 1, @parser.document.start_elements_namespace.length
+          el = @parser.document.start_elements_namespace.first
+
+          assert_equal 'stream', el.first
+          assert_equal 2, el[1].length
+          assert_equal [['version', '1.0'], ['size', 'large']],
+            el[1].map { |x| [x.localname, x.value] }
+
+          assert_equal 'stream', el[2]
+          assert_equal 'http://etherx.jabber.org/streams', el[3]
+          @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_namespace
+          @parser.finish
+        end
+
+        def test_chevron_partial_xml
+          @parser.<<(<<-eoxml)
+            <p id="asdfasdf">
+          eoxml
+
+          @parser.<<(<<-eoxml)
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          assert_equal [' This is a comment '], @parser.document.comments
+          @parser.finish
+        end
+
+        def test_chevron
+          @parser.<<(<<-eoxml)
+            <p id="asdfasdf">
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          @parser.finish
+          assert_equal [' This is a comment '], @parser.document.comments
+        end
+
+        def test_default_options
+          assert_equal 0, @parser.options
+        end
+
+        def test_recover
+          @parser.options |= XML::ParseOptions::RECOVER
+          @parser.<<(<<-eoxml)
+            <p>
+              Foo
+              <bar>
+              Bar
+            </p>
+          eoxml
+          @parser.finish
+          assert(@parser.document.errors.size >= 1)
+          assert_equal [["p", []], ["bar", []]], @parser.document.start_elements
+          assert_equal "FooBar", @parser.document.data.map { |x|
+            x.gsub(/\s/, '')
+          }.join
+        end
+
+        def test_broken_encoding
+          skip("ultra hard to fix for pure Java version") if Nokogiri.jruby?
+          @parser.options |= XML::ParseOptions::RECOVER
+          # This is ISO_8859-1:
+          @parser.<< "<?xml version='1.0' encoding='UTF-8'?><r>Gau\337</r>"
+          @parser.finish
+          assert(@parser.document.errors.size >= 1)
+          assert_equal "Gau\337", @parser.document.data.join
+          assert_equal [["r"]], @parser.document.end_elements
+        end
+      end
+    end
+  end
+end

data/test/xml/test_attr.rb

@@ -0,0 +1,64 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestAttr < Nokogiri::TestCase
+      def test_new
+        100.times {
+          doc = Nokogiri::XML::Document.new
+          assert doc
+          assert 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]
+        street = address.attributes['street']
+        street.content = "Y&ent1;"
+        assert_equal "Y&ent1;", street.value
+      end
+
+      def test_value=
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        address = xml.xpath('//address')[3]
+        street = address.attributes['street']
+        street.value = "Y&ent1;"
+        assert_equal "Y&ent1;", street.value
+      end
+
+      def test_unlink
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        address = xml.xpath('/staff/employee/address').first
+        assert_equal 'Yes', address['domestic']
+        address.attribute_nodes.first.unlink
+        assert_nil address['domestic']
+      end
+
+      def test_parsing_attribute_namespace
+        doc = Nokogiri::XML <<-EOXML
+<root xmlns='http://google.com/' xmlns:f='http://flavorjon.es/'>
+  <div f:myattr='foo'></div>
+</root>
+        EOXML
+
+        node = doc.at_css "div"
+        attr = node.attributes["myattr"]
+        assert_equal "http://flavorjon.es/", attr.namespace.href
+      end
+
+      def test_setting_attribute_namespace
+        doc = Nokogiri::XML <<-EOXML
+<root xmlns='http://google.com/' xmlns:f='http://flavorjon.es/'>
+  <div f:myattr='foo'></div>
+</root>
+        EOXML
+
+        node = doc.at_css "div"
+        attr = node.attributes["myattr"]
+        attr.add_namespace("fizzle", "http://fizzle.com/")
+        assert_equal "http://fizzle.com/", attr.namespace.href
+      end
+    end
+  end
+end

data/test/xml/test_attribute_decl.rb

@@ -0,0 +1,86 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestAttributeDecl < Nokogiri::TestCase
+      def setup
+        super
+        @xml = Nokogiri::XML(<<-eoxml)
+<?xml version="1.0"?><?TEST-STYLE PIDATA?>
+<!DOCTYPE staff SYSTEM "staff.dtd" [
+   <!ATTLIST br width CDATA "0">
+   <!ATTLIST a width CDATA "0">
+   <!ATTLIST payment type (check|cash) "cash">
+]>
+<root />
+        eoxml
+        @attrs = @xml.internal_subset.children
+        @attr_decl = @attrs.first
+      end
+
+      def test_inspect
+        assert_equal(
+          "#<#{@attr_decl.class.name}:#{sprintf("0x%x", @attr_decl.object_id)} #{@attr_decl.to_s.inspect}>",
+          @attr_decl.inspect
+        )
+      end
+
+      def test_type
+        assert_equal 16, @attr_decl.type
+      end
+
+      def test_class
+        assert_instance_of Nokogiri::XML::AttributeDecl, @attr_decl
+      end
+
+      def test_content
+        assert_raise NoMethodError do
+          @attr_decl.content
+        end
+      end
+
+      def test_attributes
+        assert_raise NoMethodError do
+          @attr_decl.attributes
+        end
+      end
+
+      def test_namespace
+        assert_raise NoMethodError do
+          @attr_decl.namespace
+        end
+      end
+
+      def test_namespace_definitions
+        assert_raise NoMethodError do
+          @attr_decl.namespace_definitions
+        end
+      end
+
+      def test_line
+        assert_raise NoMethodError do
+          @attr_decl.line
+        end
+      end
+
+      def test_attribute_type
+        if Nokogiri.uses_libxml?
+          assert_equal 1, @attr_decl.attribute_type
+        else
+          assert_equal 'CDATA', @attr_decl.attribute_type
+        end
+      end
+
+      def test_default
+        assert_equal '0', @attr_decl.default
+        assert_equal '0', @attrs[1].default
+      end
+
+      def test_enumeration
+        assert_equal [], @attr_decl.enumeration
+        assert_equal ['check', 'cash'], @attrs[2].enumeration
+      end
+    end
+  end
+end
+

data/test/xml/test_builder.rb

@@ -0,0 +1,315 @@
+# -*- 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
+        builder = 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
+
+    private
+
+      def namespaces_defined_on(node)
+        Hash[*node.namespace_definitions.collect{|n| ["xmlns:" + n.prefix, n.href]}.flatten]
+      end
+    end
+  end
+end