nokogiri 1.8.5 → 1.13.6

data/test/test_convert_xpath.rb

@@ -1,135 +0,0 @@
-require "helper"
-
-class TestConvertXPath < Nokogiri::TestCase
-
-  def setup
-    super
-    @N = Nokogiri(File.read(HTML_FILE))
-  end
-
-  def assert_syntactical_equivalence(hpath, xpath, match, &blk)
-    blk ||= lambda {|j| j.first}
-    assert_equal match, blk.call(@N.search(xpath)), "xpath result did not match"
-  end
-
-  def test_child_tag
-    assert_syntactical_equivalence("h1[a]", ".//h1[child::a]", "Tender Lovemaking") do |j|
-      j.inner_text
-    end
-  end
-
-  def test_child_tag_equals
-    assert_syntactical_equivalence("h1[a='Tender Lovemaking']", ".//h1[child::a = 'Tender Lovemaking']", "Tender Lovemaking") do |j|
-      j.inner_text
-    end
-  end
-
-  def test_filter_contains
-    assert_syntactical_equivalence("title:contains('Tender')", ".//title[contains(., 'Tender')]",
-                                   "Tender Lovemaking  ") do |j|
-      j.inner_text
-    end
-  end
-
-  def test_filter_comment
-    assert_syntactical_equivalence("div comment()[2]", ".//div//comment()[position() = 2]", "<!-- end of header -->") do |j|
-      j.first.to_s
-    end
-  end
-
-  def test_filter_text
-    assert_syntactical_equivalence("a[text()]", ".//a[normalize-space(child::text())]", "<a href=\"http://tenderlovemaking.com\">Tender Lovemaking</a>") do |j|
-      j.first.to_s
-    end
-    assert_syntactical_equivalence("a[text()='Tender Lovemaking']", ".//a[normalize-space(child::text()) = 'Tender Lovemaking']", "<a href=\"http://tenderlovemaking.com\">Tender Lovemaking</a>") do |j|
-      j.first.to_s
-    end
-    assert_syntactical_equivalence("a/text()", ".//a/child::text()", "Tender Lovemaking") do |j|
-      j.first.to_s
-    end
-    assert_syntactical_equivalence("h2//a[text()!='Back Home!']", ".//h2//a[normalize-space(child::text()) != 'Back Home!']", "Meow meow meow meow meow") do |j|
-      j.first.inner_text
-    end
-  end
-
-  def test_filter_by_attr
-    assert_syntactical_equivalence("a[@href='http://blog.geminigeek.com/wordpress-theme']",
-                                   ".//a[@href = 'http://blog.geminigeek.com/wordpress-theme']",
-                                   "http://blog.geminigeek.com/wordpress-theme") do |j|
-      j.first["href"]
-    end
-  end
-
-  def test_css_id
-    assert_syntactical_equivalence("#linkcat-7", ".//*[@id = 'linkcat-7']", "linkcat-7") do |j|
-      j.first["id"]
-    end
-    assert_syntactical_equivalence("li#linkcat-7", ".//li[@id = 'linkcat-7']", "linkcat-7") do |j|
-      j.first["id"]
-    end
-  end
-
-  def test_css_class
-    assert_syntactical_equivalence(".cat-item-15", ".//*[contains(concat(' ', @class, ' '), ' cat-item-15 ')]",
-                                   "cat-item cat-item-15") do |j|
-      j.first["class"]
-    end
-    assert_syntactical_equivalence("li.cat-item-15", ".//li[contains(concat(' ', @class, ' '), ' cat-item-15 ')]",
-                                   "cat-item cat-item-15") do |j|
-      j.first["class"]
-    end
-  end
-
-  def test_css_tags
-    assert_syntactical_equivalence("div li a", ".//div//li//a", "http://brobinius.org/") do |j|
-      j.first.inner_text
-    end
-    assert_syntactical_equivalence("div li > a", ".//div//li/a", "http://brobinius.org/") do |j|
-      j.first.inner_text
-    end
-    assert_syntactical_equivalence("h1 ~ small", ".//small[preceding-sibling::h1]", "The act of making love, tenderly.") do |j|
-      j.first.inner_text
-    end
-    assert_syntactical_equivalence("h1 ~ small", ".//small[preceding-sibling::h1]", "The act of making love, tenderly.") do |j|
-      j.first.inner_text
-    end
-  end
-
-  def test_positional
-    assert_syntactical_equivalence("div/div:first()", ".//div/div[position() = 1]", "\r\nTender Lovemaking\r\nThe act of making love, tenderly.\r\n".gsub(/[\r\n]/, '')) do |j|
-      j.first.inner_text.gsub(/[\r\n]/, '')
-    end
-    assert_syntactical_equivalence("div/div:first", ".//div/div[position() = 1]", "\r\nTender Lovemaking\r\nThe act of making love, tenderly.\r\n".gsub(/[\r\n]/, '')) do |j|
-      j.first.inner_text.gsub(/[\r\n]/, '')
-    end
-    assert_syntactical_equivalence("div//a:last()", ".//div//a[position() = last()]", "Wordpress") do |j|
-      j.last.inner_text
-    end
-    assert_syntactical_equivalence("div//a:last", ".//div//a[position() = last()]", "Wordpress") do |j|
-      j.last.inner_text
-    end
-  end
-
-  def test_multiple_filters
-    assert_syntactical_equivalence("a[@rel='bookmark'][1]", ".//a[@rel = 'bookmark' and position() = 1]", "Back Home!") do |j|
-      j.first.inner_text
-    end
-  end
-
-# TODO:
-#       doc/'title ~ link' -> links that are siblings of title
-#       doc/'p[@class~="final"]' -> class includes string (whitespacy)
-#       doc/'p[text()*="final"]' -> class includes string (index) (broken: always returns true?)
-#       doc/'p[text()$="final"]' -> /final$/
-#       doc/'p[text()|="final"]' -> /^final$/
-#       doc/'p[text()^="final"]' -> string starts with 'final
-#       nth_first
-#       nth_last
-#       even
-#       odd
-#       first-child, nth-child, last-child, nth-last-child, nth-last-of-type
-#       only-of-type, only-child
-#       parent
-#       empty
-#       root
-end

data/test/test_css_cache.rb

@@ -1,47 +0,0 @@
-require "helper"
-
-class TestCssCache < Nokogiri::TestCase
-
-  def setup
-    super
-    @css = "a1 > b2 > c3"
-    @parse_result = Nokogiri::CSS.parse(@css)
-    @to_xpath_result = @parse_result.map(&:to_xpath)
-    Nokogiri::CSS::Parser.class_eval do
-      class << @cache
-        alias :old_bracket :[]
-        attr_reader :count
-        def [](key)
-          @count ||= 0
-          @count += 1
-          old_bracket(key)
-        end
-      end
-    end
-    assert Nokogiri::CSS::Parser.cache_on?
-  end
-
-  def teardown
-    Nokogiri::CSS::Parser.clear_cache
-    Nokogiri::CSS::Parser.set_cache true
-  end
-
-  [ false, true ].each do |cache_setting|
-    define_method "test_css_cache_#{cache_setting ? "true" : "false"}" do
-      Nokogiri::CSS::Parser.set_cache cache_setting
-
-      Nokogiri::CSS.xpath_for(@css)
-      Nokogiri::CSS.xpath_for(@css)
-      Nokogiri::CSS::Parser.new.xpath_for(@css)
-      Nokogiri::CSS::Parser.new.xpath_for(@css)
-
-      if cache_setting
-        assert_equal(4, Nokogiri::CSS::Parser.class_eval { @cache.count })
-      else
-        assert_nil(Nokogiri::CSS::Parser.class_eval { @cache.count })
-      end
-    end
-  end
-
-
-end

data/test/test_encoding_handler.rb

@@ -1,48 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require "helper"
-
-class TestEncodingHandler < Nokogiri::TestCase
-  def teardown
-    Nokogiri::EncodingHandler.clear_aliases!
-    #Replace default aliases removed by clear_aliases!
-    Nokogiri.install_default_aliases
-  end
-
-  def test_get
-    assert_not_nil Nokogiri::EncodingHandler['UTF-8']
-    assert_nil Nokogiri::EncodingHandler['alsdkjfhaldskjfh']
-  end
-
-  def test_name
-    eh = Nokogiri::EncodingHandler['UTF-8']
-    assert_equal "UTF-8", eh.name
-  end
-
-  def test_alias
-    Nokogiri::EncodingHandler.alias('UTF-8', 'UTF-18')
-    assert_equal 'UTF-8', Nokogiri::EncodingHandler['UTF-18'].name
-  end
-
-  def test_cleanup_aliases
-    assert_nil Nokogiri::EncodingHandler['UTF-9']
-    Nokogiri::EncodingHandler.alias('UTF-8', 'UTF-9')
-    assert_not_nil Nokogiri::EncodingHandler['UTF-9']
-
-    Nokogiri::EncodingHandler.clear_aliases!
-    assert_nil Nokogiri::EncodingHandler['UTF-9']
-  end
-
-  def test_delete
-    assert_nil Nokogiri::EncodingHandler['UTF-9']
-    Nokogiri::EncodingHandler.alias('UTF-8', 'UTF-9')
-    assert_not_nil Nokogiri::EncodingHandler['UTF-9']
-
-    Nokogiri::EncodingHandler.delete 'UTF-9'
-    assert_nil Nokogiri::EncodingHandler['UTF-9']
-  end
-
-  def test_delete_non_existent
-    assert_nil Nokogiri::EncodingHandler.delete('UTF-9')
-  end
-end

data/test/test_memory_leak.rb

@@ -1,156 +0,0 @@
-require "helper"
-
-class TestMemoryLeak < Nokogiri::TestCase
-  def setup
-    super
-    @str = <<EOF
-<!DOCTYPE HTML>
-<html>
-  <body>
-    <br />
-  </body>
-</html>
-EOF
-  end
-
-  if ENV['NOKOGIRI_GC'] # turning these off by default for now
-    def test_dont_hurt_em_why
-      content = File.open("#{File.dirname(__FILE__)}/files/dont_hurt_em_why.xml").read
-      ndoc = Nokogiri::XML(content)
-      2.times do
-        ndoc.search('status text').first.inner_text
-        ndoc.search('user name').first.inner_text
-        GC.start
-      end
-    end
-
-    class BadIO
-      def read(*args)
-        raise 'hell'
-      end
-
-      def write(*args)
-        raise 'chickens'
-      end
-    end
-
-    def test_for_mem_leak_on_io_callbacks
-      io = File.open SNUGGLES_FILE
-      Nokogiri::XML.parse(io)
-
-      loop do
-        Nokogiri::XML.parse(BadIO.new) rescue nil
-        doc.write BadIO.new rescue nil
-      end
-    end
-
-    def test_for_memory_leak
-      begin
-        #  we don't use Dike in any tests, but requiring it has side effects
-        #  that can create memory leaks, and that's what we're testing for.
-        require 'rubygems'
-        require 'dike' # do not remove!
-
-        count_start = count_object_space_documents
-        xml_data = <<-EOS
-        <test>
-          <items>
-            <item>abc</item>
-            <item>1234</item>
-            <item>Zzz</item>
-          <items>
-        </test>
-        EOS
-        20.times do
-          doc = Nokogiri::XML(xml_data)
-          doc.xpath("//item")
-        end
-        2.times { GC.start }
-        count_end = count_object_space_documents
-        assert((count_end - count_start) <= 2, "memory leak detected")
-      rescue LoadError
-        puts "\ndike is not installed, skipping memory leak test"
-      end
-    end
-
-    def test_node_set_namespace_mem_leak
-      xml = Nokogiri::XML "<foo></foo>"
-      ctx = Nokogiri::XML::XPathContext.new(xml)
-      loop do
-        ctx.evaluate("//namespace::*")
-      end
-    end
-
-    def test_leak_on_node_replace
-      loop do
-        doc = Nokogiri.XML("<root><foo /></root>")
-        n = Nokogiri::XML::CDATA.new(doc, "bar")
-        pivot = doc.root.children[0]
-        pivot.replace(n)
-      end
-    end
-
-    def test_sax_parser_context
-      io = StringIO.new(@str)
-
-      loop do
-        Nokogiri::XML::SAX::ParserContext.new(@str)
-        Nokogiri::XML::SAX::ParserContext.new(io)
-        io.rewind
-
-        Nokogiri::HTML::SAX::ParserContext.new(@str)
-        Nokogiri::HTML::SAX::ParserContext.new(io)
-        io.rewind
-      end
-    end
-
-    class JumpingSaxHandler < Nokogiri::XML::SAX::Document
-      def initialize(jumptag)
-        @jumptag = jumptag
-        super()
-      end
-
-      def start_element(name, attrs = [])
-        throw @jumptag
-      end
-    end
-
-    def test_jumping_sax_handler
-      doc = JumpingSaxHandler.new(:foo)
-
-      loop do
-        catch(:foo) do
-          Nokogiri::HTML::SAX::Parser.new(doc).parse(@str)
-        end
-      end
-    end
-
-    def test_in_context_parser_leak
-      loop do 
-        doc = Nokogiri::XML::Document.new
-        fragment1 = Nokogiri::XML::DocumentFragment.new(doc, '<foo/>')
-        node = fragment1.children[0]
-        node.parse('<bar></bar>')
-      end
-    end
-
-    def test_in_context_parser_leak_ii
-      loop { Nokogiri::XML('<a/>').root.parse('<b/>') }
-    end
-
-    def test_leak_on_xpath_string_function
-      doc = Nokogiri::XML(@str)
-      loop do
-        doc.xpath('name(//node())')
-      end
-    end
-  end # if NOKOGIRI_GC
-
-  private
-
-  def count_object_space_documents
-    count = 0
-    ObjectSpace.each_object {|j| count += 1 if j.is_a?(Nokogiri::XML::Document) }
-    count
-  end
-end

data/test/test_nokogiri.rb

@@ -1,138 +0,0 @@
-require "helper"
-
-class TestNokogiri < Nokogiri::TestCase
-  def test_versions
-    version_match = /\d+\.\d+\.\d+/
-    assert_match version_match, Nokogiri::VERSION
-
-    assert_equal Nokogiri::VERSION_INFO['ruby']['version'], ::RUBY_VERSION
-    assert_equal Nokogiri::VERSION_INFO['ruby']['platform'], ::RUBY_PLATFORM
-
-    if Nokogiri.uses_libxml?
-      assert_match version_match, Nokogiri::LIBXML_VERSION
-      assert_equal 'extension', Nokogiri::VERSION_INFO['libxml']['binding']
-
-      assert_match version_match, Nokogiri::VERSION_INFO['libxml']['compiled']
-      assert_equal Nokogiri::LIBXML_VERSION, Nokogiri::VERSION_INFO['libxml']['compiled']
-
-      assert_match version_match, Nokogiri::VERSION_INFO['libxml']['loaded']
-      Nokogiri::LIBXML_PARSER_VERSION =~ /(\d)(\d{2})(\d{2})/
-      major = $1.to_i
-      minor = $2.to_i
-      bug   = $3.to_i
-      assert_equal "#{major}.#{minor}.#{bug}", Nokogiri::VERSION_INFO['libxml']['loaded']
-    end
-  end
-
-  def test_libxml_iconv
-    assert Nokogiri.const_defined?(:LIBXML_ICONV_ENABLED) if Nokogiri.uses_libxml?
-  end
-
-  def test_parse_with_io
-    doc = Nokogiri.parse(
-      StringIO.new("<html><head><title></title><body></body></html>")
-    )
-    assert_instance_of Nokogiri::HTML::Document, doc
-  end
-
-  def test_xml?
-    doc = Nokogiri.parse(File.read(XML_FILE))
-    assert doc.xml?
-    assert !doc.html?
-  end
-
-  def test_atom_is_xml?
-    doc = Nokogiri.parse(File.read(XML_ATOM_FILE))
-    assert doc.xml?
-    assert !doc.html?
-  end
-
-  def test_html?
-    doc = Nokogiri.parse(File.read(HTML_FILE))
-    assert !doc.xml?
-    assert doc.html?
-  end
-
-  def test_nokogiri_method_with_html
-    doc1 = Nokogiri(File.read(HTML_FILE))
-    doc2 = Nokogiri.parse(File.read(HTML_FILE))
-    assert_equal doc1.serialize, doc2.serialize
-  end
-
-  def test_nokogiri_method_with_block
-    doc = Nokogiri { b "bold tag" }
-    assert_equal('<b>bold tag</b>', doc.to_html.chomp)
-  end
-
-  def test_make_with_html
-    doc = Nokogiri.make("<b>bold tag</b>")
-    assert_equal('<b>bold tag</b>', doc.to_html.chomp)
-  end
-
-  def test_make_with_block
-    doc = Nokogiri.make { b "bold tag" }
-    assert_equal('<b>bold tag</b>', doc.to_html.chomp)
-  end
-
-  SLOP_HTML = <<-END
-  <html>
-    <body>
-      <ul>
-        <li class='red'>one</li>
-        <li class='blue'>two</li>
-      </ul>
-      <div>
-        one
-        <div>div two</div>
-      </div>
-    </body>
-  </html>
-  END
-
-  def test_slop_css
-    doc = Nokogiri::Slop(<<-eohtml)
-    <html>
-      <body>
-        <div>
-          one
-          <div class='foo'>
-            div two
-            <div class='foo'>
-              div three
-            </div>
-          </div>
-        </div>
-      </body>
-    </html>
-    eohtml
-    assert_equal "div", doc.html.body.div.div('.foo').name
-  end
-
-  def test_slop
-    doc = Nokogiri::Slop(SLOP_HTML)
-
-    assert_equal "one", doc.html.body.ul.li.first.text
-    assert_equal "two", doc.html.body.ul.li(".blue").text
-    assert_equal "div two", doc.html.body.div.div.text
-
-    assert_equal "two", doc.html.body.ul.li(:css => ".blue").text
-
-    assert_equal "two", doc.html.body.ul.li(:xpath => "position()=2").text
-    assert_equal "one", doc.html.body.ul.li(:xpath => ["contains(text(),'o')"]).first.text
-    assert_equal "two", doc.html.body.ul.li(:xpath => ["contains(text(),'o')","contains(text(),'t')"]).text
-
-    assert_raise(NoMethodError) { doc.nonexistent }
-  end
-
-  def test_slop_decorator
-    doc = Nokogiri(SLOP_HTML)
-    assert !doc.decorators(Nokogiri::XML::Node).include?(Nokogiri::Decorators::Slop)
-
-    doc.slop!
-    assert doc.decorators(Nokogiri::XML::Node).include?(Nokogiri::Decorators::Slop)
-
-    doc.slop!
-    assert_equal 1, doc.decorators(Nokogiri::XML::Node).select { |d| d == Nokogiri::Decorators::Slop }.size
-  end
-
-end

data/test/test_soap4r_sax.rb

@@ -1,52 +0,0 @@
-require "helper"
-
-module XSD
-  module XMLParser
-    class Parser
-      @factory_added = nil
-
-      class << self; attr_reader :factory_added; end
-
-      def self.add_factory o
-        @factory_added = o
-      end
-
-      def initialize *args
-        @charset = nil
-      end
-
-      def characters foo
-      end
-
-      def start_element *args
-      end
-
-      def end_element *args
-      end
-    end
-  end
-end
-
-require 'xsd/xmlparser/nokogiri'
-
-class TestSoap4rSax < Nokogiri::TestCase
-  def test_factory_added
-    assert_equal XSD::XMLParser::Nokogiri, XSD::XMLParser::Nokogiri.factory_added
-  end
-
-  def test_parse
-    o = Class.new(::XSD::XMLParser::Nokogiri) do
-      attr_accessor :element_started
-      def initialize *args
-        super
-        @element_started = false
-      end
-
-      def start_element *args
-        @element_started = true
-      end
-    end.new 'foo'
-    o.do_parse '<?xml version="1.0" ?><root xmlns="http://example.com/"/>'
-    assert o.element_started, 'element started'
-  end
-end