nokogiri 1.2.3-x86-mswin32-60 → 1.4.5-x86-mswin32-60

data/test/xml/node/test_save_options.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..',"helper"))
+require "helper"
 
 module Nokogiri
   module XML

data/test/xml/node/test_subclass.rb

@@ -0,0 +1,44 @@
+require "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

@@ -1,4 +1,6 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', "helper"))
+# -*- coding: utf-8 -*-
+
+require "helper"
 
 module Nokogiri
   module XML
@@ -9,12 +11,144 @@ module Nokogiri
           @parser = XML::SAX::Parser.new(Doc.new)
         end
 
+        def test_parser_context_yielded_io
+          doc = Doc.new
+          parser = XML::SAX::Parser.new doc
+          xml = "<foo a='&amp;b'/>"
+
+          block_called = false
+          parser.parse(StringIO.new(xml)) { |ctx|
+            block_called = true
+            ctx.replace_entities = true
+          }
+
+          assert block_called
+
+          assert_equal [['foo', [['a', '&b']]]], doc.start_elements
+        end
+
+        def test_parser_context_yielded_in_memory
+          doc = Doc.new
+          parser = XML::SAX::Parser.new doc
+          xml = "<foo a='&amp;b'/>"
+
+          block_called = false
+          parser.parse(xml) { |ctx|
+            block_called = true
+            ctx.replace_entities = true
+          }
+
+          assert block_called
+
+          assert_equal [['foo', [['a', '&b']]]], doc.start_elements
+        end
+
+        def test_xml_decl
+          {
+            ''          => nil,
+            '<?xml version="1.0" ?>'                  => ['1.0'],
+            '<?xml version="1.0" encoding="UTF-8" ?>' => ['1.0', 'UTF-8'],
+            '<?xml version="1.0" standalone="yes"?>'  => ['1.0', 'yes'],
+            '<?xml version="1.0" standalone="no"?>'   => ['1.0', 'no'],
+          }.each do |decl,value|
+            parser = XML::SAX::Parser.new(Doc.new)
+
+            xml = "#{decl}\n<root />"
+            parser.parse xml
+            assert parser.document.start_document_called, xml
+            assert_equal value, parser.document.xmldecls, xml
+          end
+        end
+
+        def test_parse_empty
+          assert_raises RuntimeError do
+            @parser.parse('')
+          end
+        end
+
+        def test_namespace_declaration_order_is_saved
+          @parser.parse <<-eoxml
+<root xmlns:foo='http://foo.example.com/' xmlns='http://example.com/'>
+  <a foo:bar='hello' />
+</root>
+          eoxml
+          assert_equal 2, @parser.document.start_elements_namespace.length
+          el = @parser.document.start_elements_namespace.first
+          namespaces = el.last
+          assert_equal ['foo', 'http://foo.example.com/'], namespaces.first
+          assert_equal [nil, 'http://example.com/'], namespaces.last
+        end
+
         def test_bad_document_calls_error_handler
           @parser.parse('<foo><bar></foo>')
           assert @parser.document.errors
           assert @parser.document.errors.length > 0
         end
 
+        def test_namespace_are_super_fun_to_parse
+          @parser.parse <<-eoxml
+<root xmlns:foo='http://foo.example.com/'>
+  <a foo:bar='hello' />
+  <b xmlns:foo='http://bar.example.com/'>
+    <a foo:bar='hello' />
+  </b>
+  <foo:bar>hello world</foo:bar>
+</root>
+          eoxml
+          assert @parser.document.start_elements_namespace.length > 0
+          el = @parser.document.start_elements_namespace[1]
+          assert_equal 'a', el.first
+          assert_equal 1, el[1].length
+
+          attribute = el[1].first
+          assert_equal 'bar', attribute.localname
+          assert_equal 'foo', attribute.prefix
+          assert_equal 'hello', attribute.value
+          assert_equal 'http://foo.example.com/', attribute.uri
+        end
+
+        def test_sax_v1_namespace_attribute_declarations
+          @parser.parse <<-eoxml
+<root xmlns:foo='http://foo.example.com/' xmlns='http://example.com/'>
+  <a foo:bar='hello' />
+  <b xmlns:foo='http://bar.example.com/'>
+    <a foo:bar='hello' />
+  </b>
+  <foo:bar>hello world</foo:bar>
+</root>
+          eoxml
+          assert @parser.document.start_elements.length > 0
+          elm = @parser.document.start_elements.first
+          assert_equal 'root', elm.first
+          assert elm[1].include?(['xmlns:foo', 'http://foo.example.com/'])
+          assert elm[1].include?(['xmlns', 'http://example.com/'])
+        end
+
+        def test_sax_v1_namespace_nodes
+          @parser.parse <<-eoxml
+<root xmlns:foo='http://foo.example.com/' xmlns='http://example.com/'>
+  <a foo:bar='hello' />
+  <b xmlns:foo='http://bar.example.com/'>
+    <a foo:bar='hello' />
+  </b>
+  <foo:bar>hello world</foo:bar>
+</root>
+          eoxml
+          assert_equal 5, @parser.document.start_elements.length
+          assert @parser.document.start_elements.map { |se|
+            se.first
+          }.include?('foo:bar')
+          assert @parser.document.end_elements.map { |se|
+            se.first
+          }.include?('foo:bar')
+        end
+
+        def test_start_is_called_without_namespace
+          @parser.parse('<foo:f><bar></foo:f>')
+          assert_equal ['foo:f', 'bar'],
+            @parser.document.start_elements.map { |x| x.first }
+        end
+
         def test_parser_sets_encoding
           parser = XML::SAX::Parser.new(Doc.new, 'UTF-8')
           assert_equal 'UTF-8', parser.encoding
@@ -37,11 +171,15 @@ module Nokogiri
           assert_equal doc.errors.length, @parser.document.errors.length
         end
 
-        def test_parse
+        def test_parse_with_memory_argument
+          @parser.parse(File.read(XML_FILE))
+          assert(@parser.document.cdata_blocks.length > 0)
+        end
+
+        def test_parse_with_io_argument
           File.open(XML_FILE, 'rb') { |f|
             @parser.parse(f)
           }
-          @parser.parse(File.read(XML_FILE))
           assert(@parser.document.cdata_blocks.length > 0)
         end
 
@@ -90,6 +228,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 +241,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">
@@ -144,7 +291,15 @@ module Nokogiri
           @parser.parse_memory(<<-eoxml)
             <p id="asdfasdf">Paragraph 1</p>
           eoxml
-          assert_equal [["p", ["id", "asdfasdf"]]],
+          assert_equal [["p", [["id", "asdfasdf"]]]],
+                       @parser.document.start_elements
+        end
+
+        def test_start_element_attrs_include_namespaces
+          @parser.parse_memory(<<-eoxml)
+            <p xmlns:foo='http://foo.example.com/'>Paragraph 1</p>
+          eoxml
+          assert_equal [["p", [['xmlns:foo', 'http://foo.example.com/']]]],
                        @parser.document.start_elements
         end
 
@@ -154,6 +309,22 @@ module Nokogiri
             <p>Paragraph 2</p>
           eoxml
         end
+
+        def test_parser_attributes
+          xml = <<-eoxml
+<?xml version="1.0" ?><root><foo a="&amp;b" c="&gt;d" /></root>
+          eoxml
+
+          block_called = false
+          @parser.parse(xml) { |ctx|
+            block_called = true
+            ctx.replace_entities = true
+          }
+
+          assert block_called
+
+          assert_equal [['root', []], ['foo', [['a', '&b'], ['c', '>d']]]], @parser.document.start_elements
+        end
       end
     end
   end

data/test/xml/sax/test_parser_context.rb

@@ -0,0 +1,113 @@
+# -*- 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_from_io
+          assert_nothing_raised do
+            ParserContext.new StringIO.new('fo'), 'UTF-8'
+          end
+        end
+
+        def test_from_string
+          assert_nothing_raised do
+            ParserContext.new 'blah blah'
+          end
+        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
+          assert_nothing_raised do
+            xml = "<root />"
+            ctx = ParserContext.new xml
+            parser = Parser.new Doc.new
+            ctx.parse_with parser
+          end
+        end
+
+        def test_from_file
+          assert_nothing_raised do
+            ctx = ParserContext.file XML_FILE
+            parser = Parser.new Doc.new
+            ctx.parse_with parser
+          end
+        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

@@ -1,4 +1,6 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', "helper"))
+# -*- coding: utf-8 -*-
+
+require "helper"
 
 module Nokogiri
   module XML
@@ -9,6 +11,16 @@ module Nokogiri
           @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">
@@ -26,7 +38,24 @@ module Nokogiri
             <p id="asdfasdf">
           eoxml
 
-          assert_equal [["p", ["id", "asdfasdf"]]],
+          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)
@@ -38,6 +67,34 @@ 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 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">
@@ -62,6 +119,37 @@ module Nokogiri
           @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
+          @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