rubyful_soup_2011 0.1.5

data/tests/rubyful_soup_tests.rb

@@ -0,0 +1,441 @@
+#Unit tests for Rubyful Soup.
+#
+#These tests make sure the Rubyful Soup works as it should. If you
+#find a bug in Rubyful Soup, the best way to express it is as a test
+#case like this that fails.
+
+require 'test/unit'
+require 'rubygems'
+require 'rubyful_soup'
+
+class SoupTest < Test::Unit::TestCase
+
+  #Parse the given text and make sure its string rep is the other
+  #given text.
+  def assert_soup_equals(toParse, rep=nil, c=BeautifulStoneSoup)
+    if rep == nil
+      rep = toParse
+    end
+    assert_equal(c.new(toParse).to_s(false), rep)
+  end
+
+  #Null test to shut the compiler up.
+  def test_null
+  end
+
+end
+
+#Tests the various ways of fetching tags from a soup.
+class ToteThatTag < SoupTest    
+
+  def setup
+    ml = %{
+      <a id="x">1</a>
+        <a id="a">2</a>
+        <b id="b">3</b>
+        <b id="x">4</b>
+        <abc:d width="100">5</abc:d>}
+    @soup = BeautifulStoneSoup.new(ml)
+  end
+
+  def test_fetch_by_name
+    matching = @soup.find_all('a')
+    assert_equal(matching.length, 2)
+    assert_equal(matching[0].name, 'a')
+    assert_equal(matching[0], @soup.find('a'))
+    assert_equal(@soup.find('abc:d').contents.length, 1)
+
+    firstB = @soup.find('b')
+    nextB = firstB.find_next('b')
+    assert_equal(nextB.contents[0], '4')
+    assert_equal(nextB['id'], 'x')
+
+  end
+
+  def test_fetch_by_block
+
+    a = @soup.find_all('a')
+    b = @soup.find_all do |x|
+      x.is_a? Tag and x.name == 'a'
+    end
+    assert_equal(a,b)
+
+    a = @soup.find_text('3')
+    b = @soup.find_text do |x|
+      x.is_a? NavigableString and x == '3'
+    end
+    assert_equal(a,b)
+
+    matching = @soup.find_all do |x|
+      x.respond_to?('name') and x.name == x['id']
+    end
+    assert_equal(matching.length, 2)
+    assert_equal(matching[0].name, 'a')
+  end
+
+  def test_fetch_by_attribute
+    matching = @soup.find_all(nil, :attrs=>{'id' => 'x'})
+    assert_equal(matching.length, 2)
+    assert_equal(matching[0].name, 'a')
+    assert_equal(matching[1].name, 'b')    
+    
+    assert_equal(@soup.find_all(nil, :attrs=>{'id' => nil}).length, 1)
+    assert_equal(@soup.find_all(nil, :attrs=>{'id' => nil}).length, 1)
+
+    assert_equal(@soup.find_all(nil, :attrs=>{'width' => 100}).length, 1)
+  end
+
+  def test_tag_name_as_method
+    firstB = @soup.find('b')
+    assert_equal(firstB, @soup.b)
+    assert_equal(firstB, @soup.b_tag)
+  end
+
+  def test_fetch_by_list
+    matching = @soup.find_all(['a', 'abc:d'])
+    assert_equal(matching.length, 3)
+  end
+
+  def test_fetch_by_hash
+    matching = @soup.find_all({'a' => true, 'b' => true})
+    assert_equal(matching.length, 4)
+  end
+
+  def test_fetch_by_re
+    r = /a.*/
+    assert_equal(@soup.find_all(r).length, 3)
+  end
+
+  def test_fetch_by_method
+    proc = Proc.new { |x| return x.name == x['id'] }
+    matching = @soup.find_all(proc)
+    assert_equal(matching.length, 2)
+    assert_equal(matching[0].name, 'a')
+  end
+
+end
+
+#Testing the integrity of the parse tree.
+class FollowThatTag < SoupTest
+
+  @@PROXIMITY_TEST = BeautifulStoneSoup.new('<b id="1"><b id="2"><b id="3"><b id="4">')
+
+  @@SIBLING_TEST = BeautifulStoneSoup.new('<blockquote id="1"><blockquote id="1.1"></blockquote></blockquote><blockquote id="2"><blockquote id="2.1"></blockquote></blockquote><blockquote id="3"><blockquote id="3.1"></blockquote></blockquote><blockquote id="4">')                          
+
+  def test_parents
+    soup = BeautifulSoup.new('<ul id="foo"></ul><ul id="foo"><ul><ul id="foo" a="b"><b>Blah</b></ul></ul></ul>')
+    b = soup.find('b')
+    assert_equal(b.find_parents('ul', :attrs=>{'id' => 'foo'}).length, 2)
+    assert_equal(b.find_parent('ul')['a'], 'b')
+  end
+  
+  def test_next_sibling
+    soup = @@SIBLING_TEST
+    tag = 'blockquote'
+    b = soup.find(tag, :attrs=>{'id' => 2})
+    assert_equal(b.find_next(tag)['id'], '2.1')
+    assert_equal(b.find_next_sibling(tag)['id'], '3')
+    assert_equal(b.find_next_sibling(tag)['id'], '3')
+    assert_equal(b.find_next_siblings(tag).length, 2)
+    assert_equal(b.find_next_siblings(tag, :attrs=>{'id' => 4}).length, 1)
+  end
+
+  def test_previous_sibling
+    soup = @@SIBLING_TEST
+    tag = 'blockquote'
+    b = soup.find(tag, :attrs=>{'id' => 3})
+    assert_equal(b.find_previous(tag)['id'], '2.1')
+    assert_equal(b.find_previous_sibling(tag)['id'], '2')
+    assert_equal(b.find_previous_sibling(tag)['id'], '2')
+    assert_equal(b.find_previous_siblings(tag).length, 2)
+    assert_equal(b.find_previous_siblings(tag, :attrs=>{'id' => 1}).length, 1)
+  end
+
+  def test_text_navigation
+    soup = BeautifulSoup.new('Foo<b>Bar</b><i id="1"><b>Baz<br />Blee<hr id="1"/></b></i>Blargh')
+    baz = soup.find_text('Baz')
+    assert_equal(baz.find_parent("i")['id'], '1')
+    assert_equal(baz.find_next(nil, :text=> 'Blee'), 'Blee')
+    assert_equal(baz.find_next_sibling(nil, :text=>'Blee'), 'Blee')
+    assert_equal(baz.find_next_sibling(nil, :text=>'Blargh'), nil)
+    assert_equal(baz.find_next_sibling('hr')['id'], '1')
+  end
+
+end
+
+#Tests the nextSibling and previousSibling navigation.
+class SiblingRivalry < SoupTest
+
+    def test_siblings
+      soup = BeautifulSoup.new("<ul><li>1<p>A</p>B</li><li>2</li><li>3</li></ul>")
+      second_li = soup.find('li').next_sibling
+      assert_equal(second_li.name, 'li')
+      assert_equal(second_li.string, '2')
+      assert_equal(soup.find_text('1').next_sibling.name, 'p')
+      assert_equal(soup.find('p').next_sibling, 'B')
+      assert_equal(soup.find('p').next_sibling.previous_sibling.next_sibling,
+                   'B')
+    end
+end
+
+#Tests the various built-in functions of Tag objects.
+class TagsAreObjectsToo < SoupTest
+
+  @@SOUP = BeautifulSoup.new('<top id="1">1<b>2</b>3</top>')
+
+  def test_length    
+    assert_equal(@@SOUP.top.length, 3)      
+  end
+
+  def test_hash_lookup    
+    assert_equal(@@SOUP.top['id'], "1")      
+  end
+
+  def test_iterator
+    bucket = []
+    @@SOUP.top.each do |x|
+      bucket << x
+    end
+    assert_equal(bucket.length, 3)
+    assert_equal(bucket[2], "3")
+  end
+
+end
+
+#Tests the use of 'string' as an alias for a tag's only content.
+class StringEmUp < SoupTest
+
+  def test_string
+    s = BeautifulSoup.new('<b>foo</b>')
+    assert_equal(s.b.string, 'foo')
+  end
+  
+  def test_lack_of_string
+    s = BeautifulSoup.new("<b>f<i>e</i>o</b>")
+    self.assert_equal(s.b.string, nil)
+  end
+end
+
+#Tests the limit argument.
+class ThatsMyLimit < SoupTest
+  
+  def test_basic_limits
+    s = BeautifulSoup.new('<br id="1" /><br id="1" /><br id="1" /><br id="1" />')
+    assert_equal(s.find_all('br').length, 4)
+    assert_equal(s.find_all('br', :limit=> 2).length, 2)
+  end
+end
+
+#Testing the modification of the tree.
+class WriteOnlyCode < SoupTest
+
+  def test_replace_contents
+    soup = BeautifulSoup.new('<a>foo</a>')
+    soup.a.contents[0] = (NavigableString.new('bar'))
+    assert_equal(soup.render_contents, '<a>bar</a>')
+  end
+
+  def test_modify_attributes
+    soup = BeautifulSoup.new('<a id="1"></a>')
+    first_a = soup.find('a')
+
+    first_a['id'] = 2
+    assert_equal(soup.render_contents, '<a id="2"></a>')
+    first_a['id'] = nil
+    assert_equal(soup.render_contents, '<a></a>')
+
+    first_a['id2'] = 'foo'
+    assert_equal(soup.render_contents, '<a id2="foo"></a>')
+    first_a.delete('id2')
+    assert_equal(soup.render_contents, '<a></a>')
+  end
+
+  #Makes sure tags don't step on each others' toes.
+  def test_new_tag_    
+    soup = BeautifulSoup.new('')
+    a = Tag.new(soup, 'a')
+    ol = Tag.new(soup, 'ol')
+    a["href"] = "http://foo.com/"
+    assert_equal(ol["href"], nil)
+  end
+end
+
+#Our operators do it all! Call now!
+class OperatorOverload < SoupTest  
+
+  def test_tag_name_as_find
+    # Tests that referencing a tag name as a member delegates to find.
+    soup = BeautifulSoup.new('<b id="1">foo<i>bar</i></b><b>Red herring</b>')
+    assert_equal(soup.b.i, soup.find('b').find('i'))
+    assert_equal(soup.b.i.string, 'bar')
+    assert_equal(soup.b['id'], '1')
+    assert_equal(soup.b.contents[0], 'foo')
+    assert(soup.a == nil)
+    
+    #Test the .foo_tag variant of .foo.
+    assert_equal(soup.b_tag.i_tag.string, 'bar')
+    assert_equal(soup.b.i_tag.string, 'bar')
+    assert_equal(soup.find('b').find('i'), soup.b_tag.i_tag)
+  end
+end  
+
+#Here we test tag nesting. TEST THE NEST, DUDE! X-TREME!
+class NestableEgg < SoupTest
+
+  def test_para_inside_blockquote
+    soup = BeautifulSoup.new('<blockquote><p><b>Foo</b></p></blockquote><p>Bar')
+    assert_equal(soup.blockquote.p.b.string, 'Foo')
+    assert_equal(soup.blockquote.b.string, 'Foo')
+    assert_equal(soup.find('p', :recursive=>false).string, 'Bar')
+  end
+  
+  def test_nested_tables
+    text = %{<table id="1"><tr><td>Here's another table:
+        <table id="2"><tr><td>Juicy text</td></tr></table></td></tr></table>}
+    soup = BeautifulSoup.new(text)
+    assert_equal(soup.table.table.td.string, 'Juicy text')
+    assert_equal(soup.find_all('table').length, 2)
+    assert_equal(soup.table.find_all('table').length, 1)
+    assert_equal(soup.find('table', :attrs=>{'id' => 2}).parent.parent.parent.name,
+                 'table')
+  end
+  
+  def test_bad_nested_tables
+    soup = BeautifulSoup.new("<table><tr><table><tr id='nested'></tr></table></tr></table>")
+    assert_equal(soup.table.tr.table.tr['id'], 'nested')
+  end
+end
+
+
+#Here we test cleanup of text that breaks an unaltered parser or is just
+#obnoxious.
+class CleanupOnAisleFour < SoupTest
+
+     def test_self_closing_tag
+       assert_equal(BeautifulStoneSoup.new("Foo<br/>Bar").find('br').to_s,
+                      '<br />')
+       assert_soup_equals('<p>test1<br/>test2</p>',
+                          '<p>test1<br />test2</p>')
+     end
+
+     def test_bad_closing_tags
+       BeautifulStoneSoup.new("<a>Foo<b>Bar</a>")
+     end
+
+     def test_premature_closing_tag
+       BeautifulStoneSoup.new("</b><a>Foo<b>Bar</a>")
+     end
+
+     def test_bad_doctype
+       assert_soup_equals("<!DOCTYPE foo='bar'>")
+     end
+
+     def test_whitespace_in_declaration
+       assert_soup_equals('<! DOCTYPE>', '<!DOCTYPE>')
+     end
+
+     def test_JunkInDeclaration
+       assert_soup_equals('<! Foo = -8>a', '<!Foo = -8>a')
+     end
+
+     def test_incomplete_declaration
+       assert_soup_equals('a<!b <p>c', 'a<!b <p>c</p>')
+     end
+
+     def test_valid_but_bogus_declaration
+       assert_soup_equals('<! Foo >a', '<!Foo >a')
+     end
+
+     #This fails for a totally bogus reason! I can't figure it out.
+     #def test_smart_quotes_not_so_smart_anymore_FAILS
+     #  assert_soup_equals("\x91Foo\x92", '&lsquo;Foo&rsquo;')        
+     #end
+
+     #def test_incomplete_declaration_at_endFAILS
+     #  assert_soup_equals('a<!b')
+     #end
+
+end
+
+#Verifies that the parser treats multiple feed calls the same as one
+#big feed call only if constructed with
+#initialTextIsEverything=False.
+class KeepOnParsing < SoupTest
+
+    def test_multiple_parse_calls
+      f1 = '<foo>bah<bar>'
+      f2 = 'blee</bar></foo>'        
+      
+      s1 = BeautifulSoup.new(f1+f2)
+      s2 = BeautifulSoup.new(f1)
+      s2.feed(f2)
+      s3 = BeautifulSoup.new(f1, :initial_text_is_everything => false)
+      s3.feed(f2)
+      assert_not_equal(s1, s2)
+      assert_equal(s1, s3)
+    end
+end
+
+#Verifies that BeautifulSOAP parser works.
+class SOAPMeUp < SoupTest
+  def test_basic_soap
+    s = "<foo><bar>baz</bar></foo>"
+    soup = BeautifulSOAP.new(s)
+    assert_equal(soup.to_s, %{<foo bar="baz"><bar>baz</bar></foo>})
+  end
+
+  def test_dont_overwrite_existing_attr
+    s = %{<foo bar="don't kill me!"><bar>baz</bar></foo>}
+    soup = BeautifulSOAP.new(s)
+    assert_equal(soup.to_s, s)
+  end
+end
+
+# Verifies that you can decide not to parse certain tags.
+class OnlyTheLonely < SoupTest
+  def test_parse_only_these
+    html = "<a>1<b>2</b>3</a><b>4<a>5</a>6</b>"
+    soup = BeautifulStoneSoup.new(html, :parse_only_these=>'b')
+    puts soup
+    assert_equal(soup.to_s, "<b>2</b><b>4<a>5</a>6</b>")
+  end
+end
+
+#The Unicode test suite has not yet been ported because I haven't
+#figured out how Ruby does Unicode.
+
+# class UnicodeRed < SoupTest
+#     "Makes sure Unicode works."
+
+#     def setUp    
+#         text = 'foo<b>bar</b>'
+#         @soup = BeautifulStoneSoup
+#         @soup.feed(text)
+
+#     def test_BasicUnicode
+#         import types
+#         sType = types.StringType
+#         uType = types.UnicodeType
+        
+#         u = u'\3100'
+#         #It starts out ASCII...
+#         assert_equal(type(@soup.renderContents), sType)
+#         assert_equal(type(@soup.prettify), sType)
+#         #But you can have unicode if you want.
+#         assert_equal(type(unicode(@soup)), uType)
+
+#         #Add a Unicode character and it's Unicode.
+#         @soup.feed(u)
+#         assert_equal(type(@soup.renderContents), uType)
+#         assert_equal(type(@soup.prettify), uType)
+#         #But you can have ASCII if you want.
+#         assert_equal(type(str(@soup)), sType)
+
+#         #The part without any Unicode is still ASCII.
+#         assert_equal(type(@soup.b.prettify), sType)
+
+#         #But if you add a Unicode character it'll become Unicode.
+#         @soup.b['foo'] = u'\3100'
+#         assert_equal(type(@soup.b.prettify), uType)
+
+

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: rubyful_soup_2011
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.5
+platform: ruby
+authors: 
+- Drew Baumann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-11 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Finally updated this to work 1.9.2 so we can use it with our flybymiles app
+email: db@30robots.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rubyful_soup.rb
+- tests/rubyful_soup_tests.rb
+has_rdoc: true
+homepage: http://xxx.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: rubyful_soup_2011
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Updated rubyful_soup to work with 1.9.2
+test_files: 
+- tests/rubyful_soup_tests.rb