nokogiri 1.5.10 → 1.13.0

data/test/xml/test_document_encoding.rb

@@ -1,28 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    if RUBY_VERSION =~ /^1\.9/
-      class TestDocumentEncoding < Nokogiri::TestCase
-        def setup
-          super
-          @xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE, 'UTF-8')
-        end
-
-        def test_url
-          assert_equal @xml.encoding, @xml.url.encoding.name
-        end
-
-        def test_encoding
-          assert_equal @xml.encoding, @xml.encoding.encoding.name
-        end
-
-        def test_dotted_version
-          if Nokogiri.uses_libxml?
-            assert_equal 'UTF-8', Nokogiri::LIBXML_VERSION.encoding.name
-          end
-        end
-      end
-    end
-  end
-end

data/test/xml/test_document_fragment.rb

@@ -1,223 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestDocumentFragment < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
-      end
-
-      def test_replace_text_node
-        html = "foo"
-        doc = Nokogiri::XML::DocumentFragment.parse(html)
-        doc.children[0].replace "bar"
-        assert_equal 'bar', doc.children[0].content
-      end
-
-      def test_fragment_is_relative
-        doc      = Nokogiri::XML('<root><a xmlns="blah" /></root>')
-        ctx      = doc.root.child
-        fragment = Nokogiri::XML::DocumentFragment.new(doc, '<hello />', ctx)
-        hello    = fragment.child
-
-        assert_equal 'hello', hello.name
-        assert_equal doc.root.child.namespace, hello.namespace
-      end
-
-      def test_node_fragment_is_relative
-        doc      = Nokogiri::XML('<root><a xmlns="blah" /></root>')
-        assert doc.root.child
-        fragment = doc.root.child.fragment('<hello />')
-        hello    = fragment.child
-
-        assert_equal 'hello', hello.name
-        assert_equal doc.root.child.namespace, hello.namespace
-      end
-
-      def test_new
-        assert Nokogiri::XML::DocumentFragment.new(@xml)
-      end
-
-      def test_fragment_should_have_document
-        fragment = Nokogiri::XML::DocumentFragment.new(@xml)
-        assert_equal @xml, fragment.document
-      end
-
-      def test_name
-        fragment = Nokogiri::XML::DocumentFragment.new(@xml)
-        assert_equal '#document-fragment', fragment.name
-      end
-
-      def test_static_method
-        fragment = Nokogiri::XML::DocumentFragment.parse("<div>a</div>")
-        assert_instance_of Nokogiri::XML::DocumentFragment, fragment
-      end
-
-      def test_static_method_with_namespaces
-        # follows different path in FragmentHandler#start_element which blew up after 597195ff
-        fragment = Nokogiri::XML::DocumentFragment.parse("<o:div>a</o:div>")
-        assert_instance_of Nokogiri::XML::DocumentFragment, fragment
-      end
-
-      def test_many_fragments
-        100.times { Nokogiri::XML::DocumentFragment.new(@xml) }
-      end
-
-      def test_subclass
-        klass = Class.new(Nokogiri::XML::DocumentFragment)
-        fragment = klass.new(@xml, "<div>a</div>")
-        assert_instance_of klass, fragment
-      end
-
-      def test_subclass_parse
-        klass = Class.new(Nokogiri::XML::DocumentFragment)
-        doc = klass.parse("<div>a</div>")
-        assert_instance_of klass, doc
-      end
-
-      def test_xml_fragment
-        fragment = Nokogiri::XML.fragment("<div>a</div>")
-        assert_equal "<div>a</div>", fragment.to_s
-      end
-
-      def test_xml_fragment_has_multiple_toplevel_children
-        doc = "<div>b</div><div>e</div>"
-        fragment = Nokogiri::XML::Document.new.fragment(doc)
-        assert_equal "<div>b</div><div>e</div>", fragment.to_s
-      end
-
-      def test_xml_fragment_has_outer_text
-        # this test is descriptive, not prescriptive.
-        doc = "a<div>b</div>"
-        fragment = Nokogiri::XML::Document.new.fragment(doc)
-        assert_equal "a<div>b</div>", fragment.to_s
-
-        doc = "<div>b</div>c"
-        fragment = Nokogiri::XML::Document.new.fragment(doc)
-        assert_equal "<div>b</div>c", fragment.to_s
-      end
-
-      def test_xml_fragment_case_sensitivity
-        doc = "<crazyDiv>b</crazyDiv>"
-        fragment = Nokogiri::XML::Document.new.fragment(doc)
-        assert_equal "<crazyDiv>b</crazyDiv>", fragment.to_s
-      end
-
-      def test_xml_fragment_with_leading_whitespace
-        doc = "     <div>b</div>  "
-        fragment = Nokogiri::XML::Document.new.fragment(doc)
-        assert_equal "     <div>b</div>  ", fragment.to_s
-      end
-
-      def test_xml_fragment_with_leading_whitespace_and_newline
-        doc = "     \n<div>b</div>  "
-        fragment = Nokogiri::XML::Document.new.fragment(doc)
-        assert_equal "     \n<div>b</div>  ", fragment.to_s
-      end
-
-      def test_fragment_children_search
-        fragment = Nokogiri::XML::Document.new.fragment(
-          '<div><p id="content">hi</p></div>'
-        )
-        css     = fragment.children.css('p')
-        xpath   = fragment.children.xpath('.//p')
-        assert_equal css, xpath
-      end
-
-      def test_fragment_search
-        frag = Nokogiri::XML::Document.new.fragment '<p id="content">hi</p>'
-
-        p_tag = frag.css('#content').first
-        assert_equal 'p', p_tag.name
-
-        assert_equal p_tag, frag.xpath('./*[@id = \'content\']').first
-      end
-
-      def test_fragment_without_a_namespace_does_not_get_a_namespace
-        doc = Nokogiri::XML <<-EOX
-          <root xmlns="http://tenderlovemaking.com/" xmlns:foo="http://flavorjon.es/" xmlns:bar="http://google.com/">
-            <foo:existing></foo:existing>
-          </root>
-        EOX
-        frag = doc.fragment "<newnode></newnode>"
-        assert_nil frag.namespace
-      end
-
-      def test_fragment_namespace_resolves_against_document_root
-        doc = Nokogiri::XML <<-EOX
-          <root xmlns:foo="http://flavorjon.es/" xmlns:bar="http://google.com/">
-            <foo:existing></foo:existing>
-          </root>
-        EOX
-        ns = doc.root.namespace_definitions.detect { |x| x.prefix == "bar" }
-
-        frag = doc.fragment "<bar:newnode></bar:newnode>"
-        assert frag.children.first.namespace
-        assert_equal ns, frag.children.first.namespace
-      end
-
-      def test_fragment_invalid_namespace_is_silently_ignored
-        doc = Nokogiri::XML <<-EOX
-          <root xmlns:foo="http://flavorjon.es/" xmlns:bar="http://google.com/">
-            <foo:existing></foo:existing>
-          </root>
-        EOX
-        frag = doc.fragment "<baz:newnode></baz:newnode>"
-        assert_nil frag.children.first.namespace
-      end
-
-      def test_decorator_is_applied
-        x = Module.new do
-          def awesome!
-          end
-        end
-        util_decorate(@xml, x)
-        fragment = Nokogiri::XML::DocumentFragment.new(@xml, "<div>a</div><div>b</div>")
-
-        assert node_set = fragment.css('div')
-        assert node_set.respond_to?(:awesome!)
-        node_set.each do |node|
-          assert node.respond_to?(:awesome!), node.class
-        end
-        assert fragment.children.respond_to?(:awesome!), fragment.children.class
-      end
-
-      def test_add_node_to_doc_fragment_segfault
-        frag = Nokogiri::XML::DocumentFragment.new(@xml, '<p>hello world</p>')
-        Nokogiri::XML::Comment.new(frag,'moo')
-      end
-
-      if Nokogiri.uses_libxml?
-        def test_for_libxml_in_context_fragment_parsing_bug_workaround
-          10.times do
-            begin
-              fragment = Nokogiri::XML.fragment("<div></div>")
-              parent = fragment.children.first
-              child = parent.parse("<h1></h1>").first
-              parent.add_child child
-            end
-            GC.start
-          end
-        end
-
-        def test_for_libxml_in_context_memory_badness_when_encountering_encoding_errors
-          # see issue #643 for background
-          # this test exists solely to raise an error during valgrind test runs.
-          html = <<-EOHTML
-<html>
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=shizzle" />
-  </head>
-  <body>
-    <div>Foo</div>
-  </body>
-</html>
-EOHTML
-          doc = Nokogiri::HTML html
-          doc.at_css("div").replace("Bar")
-        end
-      end
-    end
-  end
-end

data/test/xml/test_dtd.rb

@@ -1,103 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestDTD < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML(File.open(XML_FILE))
-        assert @dtd = @xml.internal_subset
-      end
-
-      def test_system_id
-        assert_equal 'staff.dtd', @dtd.system_id
-      end
-
-      def test_external_id
-        xml = Nokogiri::XML('<!DOCTYPE foo PUBLIC "bar" ""><foo />')
-        assert dtd = xml.internal_subset, 'no internal subset'
-        assert_equal 'bar', dtd.external_id
-      end
-
-      def test_content
-        assert_raise NoMethodError do
-          @dtd.content
-        end
-      end
-
-      def test_empty_attributes
-        dtd = Nokogiri::HTML("<html></html>").internal_subset
-        assert_equal Hash.new, dtd.attributes
-      end
-
-      def test_attributes
-        assert_equal ['width'], @dtd.attributes.keys
-        assert_equal '0', @dtd.attributes['width'].default
-      end
-
-      def test_keys
-        assert_equal ['width'], @dtd.keys
-      end
-
-      def test_each
-        hash = {}
-        @dtd.each { |key, value| hash[key] = value }
-        assert_equal @dtd.attributes, hash
-      end
-
-      def test_namespace
-        assert_raise NoMethodError do
-          @dtd.namespace
-        end
-      end
-
-      def test_namespace_definitions
-        assert_raise NoMethodError do
-          @dtd.namespace_definitions
-        end
-      end
-
-      def test_line
-        assert_raise NoMethodError do
-          @dtd.line
-        end
-      end
-
-      def test_validate
-        if Nokogiri.uses_libxml?
-          list = @xml.internal_subset.validate @xml
-          assert_equal 44, list.length
-        else
-          xml = Nokogiri::XML(File.open(XML_FILE)) {|cfg| cfg.dtdvalid}
-          list = xml.internal_subset.validate xml
-          assert_equal 40, list.length
-        end
-      end
-
-      def test_external_subsets
-        assert subset = @xml.internal_subset
-        assert_equal 'staff', subset.name
-      end
-
-      def test_entities
-        assert entities = @dtd.entities
-        assert_equal %w[ ent1 ent2 ent3 ent4 ent5 ].sort, entities.keys.sort
-      end
-
-      def test_elements
-        assert elements = @dtd.elements
-        assert_equal %w[ br ], elements.keys
-        assert_equal 'br', elements['br'].name
-      end
-
-      def test_notations
-        assert notations = @dtd.notations
-        assert_equal %w[ notation1 notation2 ].sort, notations.keys.sort
-        assert notation1 = notations['notation1']
-        assert_equal 'notation1', notation1.name
-        assert_equal 'notation1File', notation1.public_id
-        assert_nil notation1.system_id
-      end
-    end
-  end
-end

data/test/xml/test_dtd_encoding.rb

@@ -1,33 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require "helper"
-
-module Nokogiri
-  module XML
-   if RUBY_VERSION =~ /^1\.9/
-    class TestDTDEncoding < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE, 'UTF-8')
-        assert @dtd = @xml.internal_subset
-      end
-
-      def test_entities
-        @dtd.entities.each do |k,v|
-          assert_equal @xml.encoding, k.encoding.name
-        end
-      end
-
-      def test_notations
-        @dtd.notations.each do |k,notation|
-          assert_equal 'UTF-8', k.encoding.name
-          %w{ name public_id system_id }.each do |attribute|
-            v = notation.send(:"#{attribute}") || next
-            assert_equal 'UTF-8', v.encoding.name
-          end
-        end
-      end
-    end
-   end
-  end
-end

data/test/xml/test_element_content.rb

@@ -1,56 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestElementContent < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML(<<-eoxml)
-<?xml version="1.0"?><?TEST-STYLE PIDATA?>
-<!DOCTYPE staff SYSTEM "staff.dtd" [
-   <!ELEMENT br EMPTY>
-   <!ELEMENT div1 (head, (p | list | note)*, div2*)>
-   <!ELEMENT div2 (tender:love)>
-]>
-<root/>
-        eoxml
-        @elements = @xml.internal_subset.children.find_all { |x|
-          x.type == 15
-        }
-        @tree = @elements[1].content
-      end
-
-      def test_allowed_content_not_defined
-        assert_nil @elements.first.content
-      end
-
-      def test_document
-        assert @tree
-        assert_equal @xml, @tree.document
-      end
-
-      def test_type
-        assert_equal ElementContent::SEQ, @tree.type
-      end
-
-      def test_children
-        assert_equal 2, @tree.children.length
-      end
-
-      def test_name
-        assert_nil @tree.name
-        assert_equal 'head', @tree.children.first.name
-        assert_equal 'p', @tree.children[1].children.first.children.first.name
-      end
-
-      def test_occur
-        assert_equal ElementContent::ONCE, @tree.occur
-      end
-
-      def test_prefix
-        assert_nil @tree.prefix
-        assert_equal 'tender', @elements[2].content.prefix
-      end
-    end
-  end
-end

data/test/xml/test_element_decl.rb

@@ -1,73 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestElementDecl < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML(<<-eoxml)
-<?xml version="1.0"?><?TEST-STYLE PIDATA?>
-<!DOCTYPE staff SYSTEM "staff.dtd" [
-   <!ELEMENT br EMPTY>
-   <!ELEMENT div1 (head, (p | list | note)*, div2*)>
-   <!ELEMENT my:way EMPTY>
-   <!ATTLIST br width CDATA "0">
-   <!ATTLIST br height CDATA "0">
-]>
-<root/>
-        eoxml
-        @elements = @xml.internal_subset.children.find_all { |x|
-          x.type == 15
-        }
-      end
-
-      def test_inspect
-        e = @elements.first
-        assert_equal(
-          "#<#{e.class.name}:#{sprintf("0x%x", e.object_id)} #{e.to_s.inspect}>",
-          e.inspect
-        )
-      end
-
-      def test_prefix
-        assert_nil @elements[1].prefix
-        assert_equal 'my', @elements[2].prefix
-      end
-
-      def test_line
-        assert_raise NoMethodError do
-          @elements.first.line
-        end
-      end
-
-      def test_namespace
-        assert_raise NoMethodError do
-          @elements.first.namespace
-        end
-      end
-
-      def test_namespace_definitions
-        assert_raise NoMethodError do
-          @elements.first.namespace_definitions
-        end
-      end
-
-      def test_element_type
-        assert_equal 1, @elements.first.element_type
-      end
-
-      def test_type
-        assert_equal 15, @elements.first.type
-      end
-
-      def test_class
-        assert_instance_of Nokogiri::XML::ElementDecl, @elements.first
-      end
-
-      def test_attributes
-        assert_equal 2, @elements.first.attribute_nodes.length
-        assert_equal 'width', @elements.first.attribute_nodes.first.name
-      end
-    end
-  end
-end

data/test/xml/test_entity_decl.rb

@@ -1,122 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestEntityDecl < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML(<<-eoxml)
-<?xml version="1.0"?><?TEST-STYLE PIDATA?>
-<!DOCTYPE staff SYSTEM "staff.dtd" [
-   <!ENTITY ent1 "es">
-   <!ENTITY nocontent "">
-]>
-<root />
-        eoxml
-
-        @entities = @xml.internal_subset.children
-        @entity_decl = @entities.first
-      end
-
-      def test_constants
-        assert_equal 1, EntityDecl::INTERNAL_GENERAL
-        assert_equal 2, EntityDecl::EXTERNAL_GENERAL_PARSED
-        assert_equal 3, EntityDecl::EXTERNAL_GENERAL_UNPARSED
-        assert_equal 4, EntityDecl::INTERNAL_PARAMETER
-        assert_equal 5, EntityDecl::EXTERNAL_PARAMETER
-        assert_equal 6, EntityDecl::INTERNAL_PREDEFINED
-      end
-
-      def test_create_typed_entity
-        entity = @xml.create_entity(
-          'foo', EntityDecl::INTERNAL_GENERAL, nil, nil, nil
-        )
-        assert_equal EntityDecl::INTERNAL_GENERAL, entity.entity_type
-        assert_equal 'foo', entity.name
-      end
-
-      def test_new
-        entity = Nokogiri::XML::EntityDecl.new(
-          'foo', @xml, EntityDecl::INTERNAL_GENERAL, nil, nil, nil
-        )
-        assert_equal EntityDecl::INTERNAL_GENERAL, entity.entity_type
-        assert_equal 'foo', entity.name
-      end
-
-      def test_create_default_args
-        entity = @xml.create_entity('foo')
-        assert_equal EntityDecl::INTERNAL_GENERAL, entity.entity_type
-        assert_equal 'foo', entity.name
-      end
-
-      def test_external_id
-        assert_nil @entity_decl.external_id
-      end
-
-      def test_system_id
-        assert_nil @entity_decl.system_id
-      end
-
-      def test_entity_type
-        assert_equal 1, @entity_decl.entity_type
-      end
-
-      def test_original_content
-        assert_equal "es", @entity_decl.original_content
-        if Nokogiri.jruby?
-          assert_nil @entities[1].original_content
-        else
-          assert_equal "", @entities[1].original_content
-        end
-      end
-
-      def test_content
-        assert_equal "es", @entity_decl.content
-        if Nokogiri.jruby?
-          assert_nil @entities[1].content
-        else
-          assert_equal "", @entities[1].content
-        end
-      end
-
-      def test_type
-        assert_equal 17, @entities.first.type
-      end
-
-      def test_class
-        assert_instance_of Nokogiri::XML::EntityDecl, @entities.first
-      end
-
-      def test_attributes
-        assert_raise NoMethodError do
-          @entity_decl.attributes
-        end
-      end
-
-      def test_namespace
-        assert_raise NoMethodError do
-          @entity_decl.namespace
-        end
-      end
-
-      def test_namespace_definitions
-        assert_raise NoMethodError do
-          @entity_decl.namespace_definitions
-        end
-      end
-
-      def test_line
-        assert_raise NoMethodError do
-          @entity_decl.line
-        end
-      end
-
-      def test_inspect
-        assert_equal(
-          "#<#{@entity_decl.class.name}:#{sprintf("0x%x", @entity_decl.object_id)} #{@entity_decl.to_s.inspect}>",
-          @entity_decl.inspect
-        )
-      end
-    end
-  end
-end