RubyGems - htmltools - Versions diffs - 1.10 - Mend

htmltools 1.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

data/test/tc_html-tree.rb ADDED

@@ -0,0 +1,201 @@
+#!/usr/bin/ruby
+require 'html/tree'
+require 'test/unit'
+module HTMLTree
+  class Parser
+    attr_reader :currentNode
+    attr_reader :rootNode
+  end
+  module TreeElement
+    alias :ch :children
+  end
+end
+class HTMLTreeParserTestCase < Test::Unit::TestCase
+  def setup
+    @p = HTMLTree::Parser.new(true, false)
+  end
+  def rn
+    @p.rootNode
+  end
+  def cn
+    @p.currentNode
+  end
+  attr_reader :p
+  def test_empty
+    assert_equal(cn, rn)
+    assert_equal(nil, cn.parent)
+    assert_equal([], rn.children)
+  end
+  def test_skeleton
+    d = rn
+    assert_equal(d.class, HTMLTree::Document)
+    p.feed('<html></html>')
+    assert_equal(d, cn)
+    assert_equal(d, rn)
+    assert_equal(rn, @p.tree)
+    assert_equal(@p.html, @p.tree.html_node)
+    assert_equal(@p.html, rn.ch[0])
+    assert_equal(1, rn.ch.size)
+    assert_equal('', rn.tag)
+    assert_equal('html', rn.ch[0].tag)
+    assert_equal(d.html_node, rn.ch[0])
+  end
+  def test_reset
+    p.feed('<html><head></head><body attrib1="xxx"></body></html>')
+    assert_equal(1, rn.ch.size)
+    assert_equal(2, rn.ch[0].ch.size)
+    p.reset
+    assert_equal(0, rn.ch.size)
+    p.feed('<html><head></head><body attrib1="xxx"></body></html>')
+    assert_equal(1, rn.ch.size)
+    assert_equal(2, rn.ch[0].ch.size)
+  end
+  def test_skeleton2
+    d = rn
+    p.feed('<html><head></head><body attrib1="xxx"></body></html>')
+    assert_equal(d, cn)
+    assert_equal(d, rn)
+    assert_equal(1, rn.ch.size)
+    h = rn.ch[0]  # html
+    assert_equal(d.html_node, h)
+    assert_equal('html', h.tag)
+    assert_equal(2, h.ch.size)
+    assert_equal(0, h.ch[1].ch.size)
+    assert_equal(0, h.ch[0].ch.size)
+    assert_equal('head', h.ch[0].tag)
+    assert_equal('body', h.ch[1].tag)
+    assert_equal('xxx', h.ch[1].attribute('attrib1'))
+  end
+  def test_empty_tag
+    d = rn
+    p.feed('<html><head></head><body attrib1="xxx"><br></body></html>')
+    assert_equal(d, cn)
+    h = rn.ch[0]
+    assert_equal('html', h.tag)
+    assert_equal(2, h.ch.size)
+    assert_equal(0, h.ch[0].ch.size)
+    assert_equal(1, h.ch[1].ch.size)
+    assert_equal('head', h.ch[0].tag)
+    assert_equal('body', h.ch[1].tag)
+    assert_equal('br', h.ch[1].ch[0].tag)
+  end
+  def test_no_end_tag
+    p.feed("<html><body>Foo<br />bar</body></html>")
+    h = rn.ch[0]
+    assert_equal('html', h.tag)
+    assert_equal('body', h.ch[0].tag)
+    assert_equal('br', h.ch[0].ch[1].tag)
+    assert_equal({}, h.ch[0].ch[1].attributes)
+    assert_equal([], h.ch[0].ch[1].ch)
+    assert_equal('Foo', h.ch[0].ch[0].content)
+    assert_equal('bar', h.ch[0].ch[2].content)
+  end
+  def test_content
+    d = rn
+    p.feed('<html><head></head><body attrib1="xxx"><p>stuff</p></body></html>')
+    assert_equal(d, rn)
+    assert_equal(d, cn)
+    h = rn.ch[0]
+    assert_equal('html', h.tag)
+    assert_equal(2, h.ch.size) # html => head, body
+    assert_equal(0, h.ch[0].ch.size) # head =>
+    assert_equal(1, h.ch[1].ch.size) # body=>p
+    assert_equal(1, h.ch[1].ch[0].ch.size) #p=>stuff
+    assert_equal('head', h.ch[0].tag)
+    assert_equal('body', h.ch[1].tag)
+    assert_equal('p', h.ch[1].ch[0].tag)
+    data = h.ch[1].ch[0].ch[0]  # html/body/p/<data>
+    assert_equal(true, data.data?)
+    assert_equal('', data.tag)
+    assert_equal('stuff', data.to_s)
+    assert_equal({}, data.attributes)
+  end
+  def test_unclosed_li
+    p.feed('<html><body><ul><li>Item 1<li>Item 2<li>Item 3</ul></body></html>')
+    html = rn.ch[0]
+    assert_equal('html', html.tag)
+    ul = html.ch[0].ch[0]
+    assert_equal('ul', ul.tag)
+    assert_equal(3, ul.ch.size)
+  end
+  def test_partial_file
+    p.feed("<ul><li>test</li><li>test test</li></ul>")
+    li = rn.ch[0]
+    assert_equal('ul', li.tag)
+    assert_equal(2, li.ch.size)
+    assert_equal('li', li.ch[0].tag)
+    assert_equal('li', li.ch[1].tag)
+  end
+  def test_break_nesting
+    p.feed('<HTML><BODY><p><ul><LI></ul><p></BODY></HTML>')
+    expected = tree("html",
+      tree("body",  tree("p", tree("ul", tree("li"))), tree("p"))
+      )
+    expected.assert_matches(p.html)
+  end
+  def test_meta
+    p.feed('<html><head><META NAME="robots" CONTENT="noindex,follow"></head><body></body></html>')
+    expected = tree("html",
+        tree("head", tree("meta")),
+        tree("body"))
+    expected.assert_matches(p.html)
+  end
+  class VerificationTree
+    include Test::Unit::Assertions
+    def initialize(tag)
+      @tag = tag
+      @children = []
+    end
+    def add_children(children)
+      @children = children
+      self
+    end
+    def assert_matches(tree)
+      assert_equal(@tag, tree.tag)
+      assert_equal(tree.elements.collect { |node| node.tag }, @children.collect { |node| node.tag }, tree.path)
+      assert_children_matches(@children, tree.elements)
+    end
+    def assert_children_matches(children, treechildren)
+      for i in (0...children.size) do
+        children[i].assert_matches(treechildren[i])
+      end
+    end
+    attr_reader :tag
+  end
+  def tree(tag, *children)
+    tree = VerificationTree.new(tag)
+    tree.add_children(children)
+    tree
+  end
+end

data/test/tc_source-parser.rb ADDED

@@ -0,0 +1,160 @@
+# $Id: tc_source-parser.rb,v 1.3 2006/07/24 09:28:19 Philip Dorrell Exp $
+require 'html/stparser'
+require 'test/unit'
+class TestSourceParser < HTML::SGMLParser
+ def initialize(verbose, test_case)
+   super(verbose)
+   @test_case = test_case
+   @fulldata = ""
+ end
+ attr_reader :test_case
+ def feed(data)
+   @fulldata = @fulldata + data
+   super(data)
+ end
+ def last_src
+   return @fulldata[src_range]
+ end
+ def warn(msg); test_case.callback('warn', msg); end
+ def handle_starttag(tag, method, attrs); test_case.callback('starttag', last_src); end
+ def unknown_starttag(tag, attrs); test_case.callback('starttag', last_src); end
+ def handle_endtag(tag, method); test_case.callback('endtag', last_src); end
+ def unknown_endtag(tag); test_case.callback('endtag', last_src); end
+ def handle_charref(name); test_case.callback('charref', last_src); end
+ def handle_entityref(name); test_case.callback('entityref', last_src); end
+ def handle_data(data); test_case.callback('data', last_src); end
+ def handle_comment(data); test_case.callback('comment', last_src); end
+ def handle_special(data); test_case.callback('special', last_src); end
+end
+class SourceParserTestCase < Test::Unit::TestCase
+ def setup
+   @parser = TestSourceParser.new(true, self)
+   @callbacks = []
+ end
+ def callback(*stuff)
+   @callbacks << stuff
+ end
+ attr_reader :parser
+ attr_reader :callbacks
+ # run the given block and return the callbacks if any
+ def callbacks_from
+   @callbacks = []
+   yield
+   #show_callbacks
+   @callbacks
+ end
+ def show_callbacks
+   puts "Callbacks: "
+   @callbacks.each do |callback|
+     puts " [#{callback[0]}: \"#{callback[1]}\"]"
+   end
+ end
+ def test_empty_html
+   cbs = callbacks_from { parser.feed('<html>') }
+   assert_equal(1, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(['starttag', '<html>'], cbs[0])
+   cbs = callbacks_from{ parser.feed('</html>') }
+   assert_equal(1, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(['endtag', '</html>'], cbs[0])
+ end
+ def test_attribs
+   cbs = callbacks_from {
+     parser.feed('<html><body bgcolor="#ffffff" width="123"><p>Fred</p></body></html>')
+   }
+   assert_equal(7, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(['starttag', '<html>'], cbs[0])
+   assert_equal(['starttag', '<body bgcolor="#ffffff" width="123">'], cbs[1])
+   assert_equal(['data', "Fred"], cbs[3])
+   assert_equal(['endtag', '</body>'], cbs[5])
+ end
+ # FIXME should we insert <p> tags here?
+ def test_no_para_tags_in_body
+   cbs = callbacks_from { parser.feed('<html><body>Fred</body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(['endtag', '</body>'], cbs[3])
+ end
+ def test_empty_tag
+   cbs = callbacks_from { parser.feed('<html><body><img src="whatever"></body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["starttag", '<img src="whatever">'], cbs[2])
+ end
+ def test_data
+   cbs = callbacks_from { parser.feed('<html><body><p>Data1</p><br><p>More_data</p></body></html>') }
+   assert_equal(11, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["data", "Data1"], cbs[3])
+   assert_equal(["data", "More_data"], cbs[7])
+ end
+ def test_whitespace_stripping
+   cbs = callbacks_from { parser.feed('<html><body><p>  Data1  ') }
+   assert_equal(4, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["data", "  Data1  "], cbs[3])
+   cbs = callbacks_from { parser.feed('</p><p>  Data2  </p></body></html>') }
+   assert_equal(6, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["data", "  Data2  "], cbs[2])
+ end
+ def test_script
+   cbs = callbacks_from { parser.feed <<EOS
+<html><body>
+<script type="text/javascript" language="Java_script">
+<!--
+var page_name = "Page_view_item";
+//-->
+</script>
+</body></html>
+EOS
+   }
+   assert_equal(12, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["starttag", '<script type="text/javascript" language="Java_script">'], cbs[3]);
+   assert_equal(["endtag", "</script>"], cbs[7])
+ end
+ def test_unknown_character
+   cbs = callbacks_from { parser.feed('<html><body>&#12345;</body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["charref", "&#12345;"], cbs[2])
+ end
+ def test_unknown_entity
+   cbs = callbacks_from { parser.feed('<html><body>&fred;</body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["entityref", "&fred;"], cbs[2])
+ end
+ def test_comment
+   cbs = callbacks_from { parser.feed('<html><body><!--  comment here --></body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["comment", "<!--  comment here -->"], cbs[2])
+ end
+ #TODO is this right (w/the !)?
+ def test_special
+   cbs = callbacks_from { parser.feed <<EOS
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><body></body></html>
+EOS
+   }
+   assert_equal(7, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["special", '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">'], cbs[0])
+ end
+end

data/test/tc_stacking-parser.rb ADDED

@@ -0,0 +1,196 @@
+# Test cases for html-tree.rb
+# Copyright (C) 2002 Ned Konz <ned@bike-nomad.com>
+# License: Ruby's
+# $Id: tc_stacking-parser.rb,v 1.4 2004/02/10 21:36:31 jhannes Exp $
+require 'html/stparser'
+require 'test/unit'
+class TestStackingParser < HTML::StackingParser
+  def initialize(verbose, test_case)
+    super(verbose)
+    @test_case = test_case
+  end
+  attr_reader :test_case
+  def warn(msg); test_case.callback('warn', msg); end
+  def handle_comment(data); super; test_case.callback('comment', data); end
+  def handle_cdata(data); test_case.callback('data', data); end
+  def handle_start_tag(tag, attrs); test_case.callback('start_tag', tag, attrs); end
+  def handle_end_tag(tag); test_case.callback('end_tag', tag); end
+  def handle_empty_tag(tag, attrs); test_case.callback('empty_tag', tag, attrs); end
+  def handle_unknown_tag(tag, attrs); test_case.callback('unknown_tag', tag, attrs); end
+  def handle_missing_end_tag(tag); test_case.callback('missing_end_tag', tag); end;
+  def handle_extra_end_tag(tag); test_case.callback('extra_end_tag', tag); end
+  def handle_script(data); test_case.callback('script', data); end
+  def handle_unknown_character(name); test_case.callback('unknown_character', name); end
+  def handle_unknown_entity(name); test_case.callback('unknown_entity', name); end
+  def handle_special(data); test_case.callback('special', data); end
+end
+class StackingParserTestCase < Test::Unit::TestCase
+  def setup
+    @parser = TestStackingParser.new(true, self)
+    @callbacks = []
+  end
+  def callback(*stuff)
+    @callbacks << stuff
+  end
+  attr_reader :parser
+  attr_reader :callbacks
+  # run the given block and return the callbacks if any
+  def callbacks_from
+    @callbacks = []
+    yield
+    @callbacks
+  end
+  def test_empty_stack
+    # test stack empty at first
+    assert(parser.stack.empty?)
+    # test last_tag and parent_tag don't blow up with empty stack
+    assert_equal('html', parser.last_tag)
+    assert_equal('html', parser.parent_tag)
+  end
+  def test_empty_html
+    cbs = callbacks_from { parser.feed('<html>') }
+    assert_same(false, parser.stack.empty?)
+    assert_equal('html', parser.last_tag)
+    assert_equal('html', parser.parent_tag)
+    assert_equal(1, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(['start_tag', 'html', []], cbs[0])
+    cbs = callbacks_from{ parser.feed('</html>') }
+    assert(parser.stack.empty?)
+    assert_equal(1, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(['end_tag', 'html'], cbs[0])
+  end
+  def test_attribs
+    cbs = callbacks_from {
+      parser.feed('<html><body bgcolor="#ffffff" width="123"><p>Fred</p></body></html>')
+    }
+    assert_same(true, parser.stack.empty?)
+    assert_equal(7, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(['start_tag', 'html', []], cbs[0])
+    assert_equal(["start_tag", "body", [["bgcolor", "#ffffff"], ["width", "123"]]], cbs[1])
+    assert_equal(['data', "Fred"], cbs[3])
+  end
+  # FIXME should we insert <p> tags here?
+  def test_no_para_tags_in_body
+    cbs = callbacks_from { parser.feed('<html><body>Fred</body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(['data', 'Fred'], cbs[2])
+  end
+  def test_empty_tag
+    cbs = callbacks_from { parser.feed('<html><body><img src="whatever"></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["empty_tag", "img", [["src", "whatever"]]], cbs[2])
+  end
+  def test_unknown_tag
+    cbs = callbacks_from { parser.feed('<html><body><froobzle a="b"></froobzle></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(6, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["unknown_tag", "froobzle", [["a", "b"]]], cbs[2])
+  end
+  def test_missing_end_tag
+    cbs = callbacks_from { parser.feed('<html><body><div></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(6, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["missing_end_tag", "div"], cbs[3])
+  end
+  def test_extra_end_tag
+    cbs = callbacks_from { parser.feed('<html><body></body></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["extra_end_tag", "body"], cbs[3])
+  end
+  def test_data
+    cbs = callbacks_from { parser.feed('<html><body><p>Data1</p><br><p>More_data</p></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(11, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["data", "Data1"], cbs[3])
+    assert_equal(["data", "More_data"], cbs[7])
+  end
+  def test_whitespace_stripping
+    parser.strip_whitespace = false
+    cbs = callbacks_from { parser.feed('<html><body><p>  Data1  ') }
+    assert_equal(4, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["data", "  Data1  "], cbs[3])
+    parser.strip_whitespace = true
+    cbs = callbacks_from { parser.feed('</p><p>  Data2  </p></body></html>') }
+    assert_equal(6, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["data", "Data2"], cbs[2])
+    assert_equal(true, parser.stack.empty?)
+  end
+  def test_script
+    parser.strip_whitespace = true
+    cbs = callbacks_from { parser.feed <<EOS
+<html><body>
+<script type="text/javascript" language="Java_script">
+<!--
+var page_name = "Page_view_item";
+//-->
+</script>
+</body></html>
+EOS
+    }
+    assert_equal([], parser.stack)
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(7, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["start_tag", "script",
+      [["type", "text/javascript"], ["language", "Java_script"]]], cbs[2])
+    assert_equal(["script", "\n<!--\nvar page_name = \"Page_view_item\";\n//-->\n"], cbs[3])
+    assert_equal(["end_tag", "script"], cbs[4])
+  end
+  def test_unknown_character
+    cbs = callbacks_from { parser.feed('<html><body>&#12345;</body></html>') }
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["unknown_character", "12345"], cbs[2])
+  end
+  def test_unknown_entity
+    cbs = callbacks_from { parser.feed('<html><body>&fred;</body></html>') }
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["unknown_entity", "fred"], cbs[2])
+  end
+  def test_comment
+    parser.strip_whitespace = true
+    cbs = callbacks_from { parser.feed('<html><body><!--  comment here --></body></html>') }
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["comment", "comment here"], cbs[2])
+  end
+  #TODO is this right (w/the !)?
+  def test_special
+    parser.strip_whitespace = true
+    cbs = callbacks_from { parser.feed <<EOS
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><body></body></html>
+EOS
+    }
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["special", '!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"'], cbs[0])
+  end
+end
+$stdout.sync = true