nokogiri 1.6.0 → 1.13.2

data/test/files/to_be_xincluded.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<included>this snippet is to be included from xinclude.xml</included>

data/test/files/valid_bar.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<bar />

data/test/files/xinclude.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<test xmlns:xi="http://www.w3.org/2001/XInclude">
-    <xi:include href="to_be_xincluded.xml"/>
-</test>

data/test/helper.rb

@@ -1,154 +0,0 @@
-#Process.setrlimit(Process::RLIMIT_CORE, Process::RLIM_INFINITY) unless RUBY_PLATFORM =~ /(java|mswin|mingw)/i
-$VERBOSE = true
-require 'minitest/autorun'
-require 'minitest/pride'
-require 'fileutils'
-require 'tempfile'
-require 'pp'
-
-require 'nokogiri'
-
-warn "#{__FILE__}:#{__LINE__}: version info: #{Nokogiri::VERSION_INFO.inspect}"
-
-module Nokogiri
-  class TestCase < MiniTest::Spec
-    ASSETS_DIR          = File.expand_path File.join(File.dirname(__FILE__), 'files')
-    ADDRESS_SCHEMA_FILE = File.join(ASSETS_DIR, 'address_book.rlx')
-    ADDRESS_XML_FILE    = File.join(ASSETS_DIR, 'address_book.xml')
-    ENCODING_HTML_FILE  = File.join(ASSETS_DIR, 'encoding.html')
-    ENCODING_XHTML_FILE = File.join(ASSETS_DIR, 'encoding.xhtml')
-    EXML_FILE           = File.join(ASSETS_DIR, 'exslt.xml')
-    EXSLT_FILE          = File.join(ASSETS_DIR, 'exslt.xslt')
-    HTML_FILE           = File.join(ASSETS_DIR, 'tlm.html')
-    METACHARSET_FILE    = File.join(ASSETS_DIR, 'metacharset.html')
-    NICH_FILE           = File.join(ASSETS_DIR, '2ch.html')
-    NOENCODING_FILE     = File.join(ASSETS_DIR, 'noencoding.html')
-    PO_SCHEMA_FILE      = File.join(ASSETS_DIR, 'po.xsd')
-    PO_XML_FILE         = File.join(ASSETS_DIR, 'po.xml')
-    SHIFT_JIS_HTML      = File.join(ASSETS_DIR, 'shift_jis.html')
-    SHIFT_JIS_XML       = File.join(ASSETS_DIR, 'shift_jis.xml')
-    SNUGGLES_FILE       = File.join(ASSETS_DIR, 'snuggles.xml')
-    XML_FILE            = File.join(ASSETS_DIR, 'staff.xml')
-    XML_XINCLUDE_FILE   = File.join(ASSETS_DIR, 'xinclude.xml')
-    XSLT_FILE           = File.join(ASSETS_DIR, 'staff.xslt')
-
-    def teardown
-      if ENV['NOKOGIRI_GC']
-        STDOUT.putc '!'
-        if RUBY_PLATFORM =~ /java/
-          require 'java'
-          java.lang.System.gc
-        else
-          GC.start
-        end
-      end
-    end
-
-    def assert_indent amount, doc, message = nil
-      nodes = []
-      doc.traverse do |node|
-        nodes << node if node.text? && node.blank?
-      end
-      assert nodes.length > 0
-      nodes.each do |node|
-        len = node.content.gsub(/[\r\n]/, '').length
-        assert_equal(0, len % amount, message)
-      end
-    end
-
-    def util_decorate(document, decorator_module)
-      document.decorators(XML::Node) << decorator_module
-      document.decorators(XML::NodeSet) << decorator_module
-      document.decorate!
-    end
-
-    #
-    #  Test::Unit backwards compatibility section
-    #
-    alias :assert_no_match      :refute_match
-    alias :assert_not_nil       :refute_nil
-    alias :assert_raise         :assert_raises
-    alias :assert_not_equal     :refute_equal
-  end
-
-  module SAX
-    class TestCase < Nokogiri::TestCase
-      class Doc < XML::SAX::Document
-        attr_reader :start_elements, :start_document_called
-        attr_reader :end_elements, :end_document_called
-        attr_reader :data, :comments, :cdata_blocks, :start_elements_namespace
-        attr_reader :errors, :warnings, :end_elements_namespace
-        attr_reader :xmldecls
-        attr_reader :processing_instructions
-
-        def xmldecl version, encoding, standalone
-          @xmldecls = [version, encoding, standalone].compact
-          super
-        end
-
-        def start_document
-          @start_document_called = true
-          super
-        end
-
-        def end_document
-          @end_document_called = true
-          super
-        end
-
-        def error error
-          (@errors ||= []) << error
-          super
-        end
-
-        def warning warning
-          (@warning ||= []) << warning
-          super
-        end
-
-        def start_element *args
-          (@start_elements ||= []) << args
-          super
-        end
-
-        def start_element_namespace *args
-          (@start_elements_namespace ||= []) << args
-          super
-        end
-
-        def end_element *args
-          (@end_elements ||= []) << args
-          super
-        end
-
-        def end_element_namespace *args
-          (@end_elements_namespace ||= []) << args
-          super
-        end
-
-        def characters string
-          @data ||= []
-          @data += [string]
-          super
-        end
-
-        def comment string
-          @comments ||= []
-          @comments += [string]
-          super
-        end
-
-        def cdata_block string
-          @cdata_blocks ||= []
-          @cdata_blocks += [string]
-          super
-        end
-
-        def processing_instruction name, content
-          @processing_instructions ||= []
-          @processing_instructions << [name, content]
-        end
-      end
-    end
-  end
-end

data/test/html/sax/test_parser.rb

@@ -1,141 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-
-module Nokogiri
-  module HTML
-    module SAX
-      class TestParser < Nokogiri::SAX::TestCase
-        def setup
-          super
-          @parser = HTML::SAX::Parser.new(Doc.new)
-        end
-
-        def test_parse_empty_document
-          # This caused a segfault in libxml 2.6.x
-          assert_nil @parser.parse ''
-        end
-
-        def test_parse_empty_file
-          # Make sure empty files don't break stuff
-          empty_file_name =  File.join(ASSETS_DIR, 'bogus.xml')
-          # assert_nothing_raised do
-            @parser.parse_file empty_file_name
-          # end
-        end
-
-        def test_parse_file
-          @parser.parse_file(HTML_FILE)
-
-          # Take a look at the comment in test_parse_document to know
-          # a possible reason to this difference.
-          if Nokogiri.uses_libxml?
-            assert_equal 1110, @parser.document.end_elements.length
-          else
-            assert_equal 1119, @parser.document.end_elements.length
-          end
-        end
-
-        def test_parse_file_nil_argument
-          assert_raises(ArgumentError) {
-            @parser.parse_file(nil)
-          }
-        end
-
-        def test_parse_file_non_existant
-          assert_raise Errno::ENOENT do
-            @parser.parse_file('there_is_no_reasonable_way_this_file_exists')
-          end
-        end
-
-        def test_parse_file_with_dir
-          assert_raise Errno::EISDIR do
-            @parser.parse_file(File.dirname(__FILE__))
-          end
-        end
-
-        def test_parse_memory_nil
-          assert_raise ArgumentError do
-            @parser.parse_memory(nil)
-          end
-        end
-
-        def test_parse_force_encoding
-          @parser.parse_memory(<<-HTML, 'UTF-8')
-          <meta http-equiv="Content-Type" content="text/html; charset=windows-1251">
-          Информация
-          HTML
-          assert_equal("Информация",
-                       @parser.document.data.join.strip)
-        end
-
-        def test_parse_document
-          @parser.parse_memory(<<-eoxml)
-            <p>Paragraph 1</p>
-            <p>Paragraph 2</p>
-          eoxml
-
-          # JRuby version is different because of the internal implementation
-          # JRuby version uses NekoHTML which inserts empty "head" elements.
-          #
-          # Currently following features are set:
-          # "http://cyberneko.org/html/properties/names/elems" => "lower"
-          # "http://cyberneko.org/html/properties/names/attrs" => "lower"
-          if Nokogiri.uses_libxml?
-            assert_equal([["html", []], ["body", []], ["p", []], ["p", []]],
-                         @parser.document.start_elements)
-          else
-            assert_equal([["html", []], ["head", []], ["body", []], ["p", []], ["p", []]],
-                         @parser.document.start_elements)
-          end
-        end
-
-        def test_parser_attributes
-          html = <<-eohtml
-<html>
-  <head>
-    <title>hello</title>
-  </head>
-<body>
-  <img src="face.jpg" title="daddy &amp; me">
-  <hr noshade size="2">
-</body>
-</html>
-          eohtml
-
-          block_called = false
-          @parser.parse(html) { |ctx|
-            block_called = true
-            ctx.replace_entities = true
-          }
-
-          assert block_called
-
-          noshade_value = if Nokogiri.uses_libxml? && Nokogiri::VERSION_INFO['libxml']['loaded'] < '2.7.7'
-                            ['noshade', 'noshade']
-                          else
-                            ['noshade', nil]
-                          end
-
-          assert_equal [
-            ['html', []],
-            ['head', []],
-            ['title', []],
-            ['body', []],
-            ['img', [
-                ['src', 'face.jpg'],
-                ['title', 'daddy & me']
-              ]],
-            ['hr', [
-                noshade_value,
-                ['size', '2']
-              ]]
-          ], @parser.document.start_elements
-        end
-
-        def test_empty_processing_instruction
-          @parser.parse_memory("<strong>this will segfault<?strong>")
-        end
-      end
-    end
-  end
-end

data/test/html/sax/test_parser_context.rb

@@ -1,46 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require "helper"
-
-module Nokogiri
-  module HTML
-    module SAX
-      class TestParserContext < Nokogiri::SAX::TestCase
-        def test_from_io
-          ctx = ParserContext.new StringIO.new('fo'), 'UTF-8'
-          assert ctx
-        end
-
-        def test_from_string
-          ctx = ParserContext.new 'blah blah'
-          assert ctx
-        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 HTML_FILE, 'UTF-8'
-            parser = Parser.new Doc.new
-            ctx.parse_with parser
-          # end
-        end
-      end
-    end
-  end
-end
-

data/test/html/test_builder.rb

@@ -1,164 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module HTML
-    class TestBuilder < Nokogiri::TestCase
-      def test_top_level_function_builds
-        foo = nil
-        Nokogiri() { |xml| foo = xml }
-        assert_instance_of Nokogiri::HTML::Builder, foo
-      end
-
-      def test_builder_with_explicit_tags
-        html_doc = Nokogiri::HTML::Builder.new {
-          div.slide(:class => 'another_class') {
-            node = Nokogiri::XML::Node.new("id", doc)
-            node.content = "hello"
-            insert(node)
-          }
-        }.doc
-        assert_equal 1, html_doc.css('div.slide > id').length
-        assert_equal 'hello', html_doc.at('div.slide > id').content
-      end
-
-      def test_hash_as_attributes_for_attribute_method
-        html = Nokogiri::HTML::Builder.new { ||
-          div.slide(:class => 'another_class') {
-            span 'Slide 1'
-          }
-        }.to_html
-        assert_match 'class="slide another_class"', html
-      end
-
-      def test_hash_as_attributes
-        builder = Nokogiri::HTML::Builder.new do
-          div(:id => 'awesome') {
-            h1 "america"
-          }
-        end
-        assert_equal('<div id="awesome"><h1>america</h1></div>',
-                     builder.doc.root.to_html.gsub(/\n/, '').gsub(/>\s*</, '><'))
-      end
-
-      def test_href_with_attributes
-        uri = 'http://tenderlovemaking.com/'
-        built = Nokogiri::XML::Builder.new {
-          div {
-            a('King Khan & The Shrines', :href => uri)
-          }
-        }
-        assert_equal 'http://tenderlovemaking.com/',
-          built.doc.at('a')[:href]
-      end
-
-      def test_tag_nesting
-        builder = Nokogiri::HTML::Builder.new do
-          body {
-            span.left ''
-            span.middle {
-              div.icon ''
-            }
-            span.right ''
-          }
-        end
-        assert node = builder.doc.css('span.right').first
-        assert_equal 'middle', node.previous_sibling['class']
-      end
-
-      def test_has_ampersand
-        builder = Nokogiri::HTML::Builder.new do
-          div.rad.thing! {
-            text "<awe&some>"
-            b "hello & world"
-          }
-        end
-        assert_equal(
-          '<div class="rad" id="thing">&lt;awe&amp;some&gt;<b>hello &amp; world</b></div>',
-                     builder.doc.root.to_html.gsub(/\n/, ''))
-      end
-
-      def test_multi_tags
-        builder = Nokogiri::HTML::Builder.new do
-          div.rad.thing! {
-            text "<awesome>"
-            b "hello"
-          }
-        end
-        assert_equal(
-          '<div class="rad" id="thing">&lt;awesome&gt;<b>hello</b></div>',
-                     builder.doc.root.to_html.gsub(/\n/, ''))
-      end
-
-      def test_attributes_plus_block
-        builder = Nokogiri::HTML::Builder.new do
-          div.rad.thing! {
-            text "<awesome>"
-          }
-        end
-        assert_equal('<div class="rad" id="thing">&lt;awesome&gt;</div>',
-                     builder.doc.root.to_html.chomp)
-      end
-
-      def test_builder_adds_attributes
-        builder = Nokogiri::HTML::Builder.new do
-          div.rad.thing! "tender div"
-        end
-        assert_equal('<div class="rad" id="thing">tender div</div>',
-                     builder.doc.root.to_html.chomp)
-      end
-
-      def test_bold_tag
-        builder = Nokogiri::HTML::Builder.new do
-          b "bold tag"
-        end
-        assert_equal('<b>bold tag</b>', builder.doc.root.to_html.chomp)
-      end
-
-      def test_html_then_body_tag
-        builder = Nokogiri::HTML::Builder.new do
-          html {
-            body {
-              b "bold tag"
-            }
-          }
-        end
-        assert_equal('<html><body><b>bold tag</b></body></html>',
-                     builder.doc.root.to_html.chomp.gsub(/>\s*</, '><'))
-      end
-
-      def test_instance_eval_with_delegation_to_block_context
-        class << self
-          def foo
-            "foo!"
-          end
-        end
-
-        builder = Nokogiri::HTML::Builder.new { text foo }
-        assert builder.to_html.include?("foo!")
-      end
-
-      def test_builder_with_param
-        doc = Nokogiri::HTML::Builder.new { |html|
-          html.body {
-            html.p "hello world"
-          }
-        }.doc
-
-        assert node = doc.xpath('//body/p').first
-        assert_equal 'hello world', node.content
-      end
-
-      def test_builder_with_id
-        text = "hello world"
-        doc = Nokogiri::HTML::Builder.new { |html|
-          html.body {
-            html.id_ text
-          }
-        }.doc
-
-        assert node = doc.xpath('//body/id').first
-        assert_equal text, node.content
-      end
-    end
-  end
-end