html-table 1.3.2 → 1.3.3

data/test/{tc_head.rb → test_head.rb}

@@ -1,12 +1,15 @@
 ###############################################################################
-# tc_head.rb
+# test_head.rb
 #
 # Test suite for the Table::Head class.  The Table::Head class is a singleton
 # class, so we have to take extra measures to ensure that a fresh instance
 # is created between tests.
 ###############################################################################
-require "test/unit"
-require "html/table"
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'html/table'
 include HTML
 
 #####################################################################
@@ -22,8 +25,8 @@ end
 
 class TC_HTML_Table_Head < Test::Unit::TestCase
    def setup
-      @t = Table.new
-      @th = Table::Head.create
+      @table = Table.new
+      @thead = Table::Head.create
    end
 
    def test_constructor
@@ -37,7 +40,7 @@ class TC_HTML_Table_Head < Test::Unit::TestCase
    
    def test_basic
       html = "<thead></thead>"
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n/,''))
+      assert_equal(html,@thead.html.gsub(/\s{2,}|\n/,''))
    end
 
    def test_end_tags
@@ -52,53 +55,53 @@ class TC_HTML_Table_Head < Test::Unit::TestCase
 
    def test_with_attributes
       html = "<thead align='left' char='x'></thead>"
-      @th.align = "left"
-      @th.char = 'x'
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n/,''))
+      @thead.align = "left"
+      @thead.char = 'x'
+      assert_equal(html,@thead.html.gsub(/\s{2,}|\n/,''))
    end
    
    def test_push_single_row
       html = "<thead><tr><td>test</td></tr></thead>"
-      @th.push Table::Row.new{|r| r.content = "test"}
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n/,''))
+      @thead.push Table::Row.new{|r| r.content = "test"}
+      assert_equal(html,@thead.html.gsub(/\s{2,}|\n/,''))
    end
 
    def test_push_multiple_rows
       html = "<thead><tr><td>test</td></tr><tr><td>foo</td></tr></thead>"
       r1 = Table::Row.new("test")
       r2 = Table::Row.new("foo")
-      @th.push(r1, r2)
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n/,''))
+      @thead.push(r1, r2)
+      assert_equal(html,@thead.html.gsub(/\s{2,}|\n/,''))
    end
    
    def test_add_content_directly
       html = "<thead><tr><td>hello</td><td>world</td></tr></thead>"
-      @th.content = "hello","world"
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n+/,''))
+      @thead.content = "hello","world"
+      assert_equal(html,@thead.html.gsub(/\s{2,}|\n+/,''))
    end
 
    def test_add_content_in_constructor
       html = "<thead><tr><td>hello</td><td>world</td></tr></thead>"
-      @th.send(:refresh)
-      @th = Table::Head.create(["hello","world"])
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n+/,''))
+      @thead.send(:refresh)
+      @thead = Table::Head.create(["hello","world"])
+      assert_equal(html,@thead.html.gsub(/\s{2,}|\n+/,''))
    end
    
    def test_configure_column
       html = "<thead><tr><td>hello</td><td abbr='test' width=3 nowrap>world"
       html += "</td></tr></thead>"
-      @th.content = "hello","world"
-      @th.configure(0,1){ |d|
+      @thead.content = "hello","world"
+      @thead.configure(0,1){ |d|
          d.abbr = 'test'
          d.width = 3
          d.nowrap = true
       }
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n+/,''))
+      assert_equal(html,@thead.html.gsub(/\s{2,}|\n+/,''))
    end
    
    def teardown
-      @t = nil
-      @th.send(:refresh)
-      @th = nil
+      @table = nil
+      @thead.send(:refresh)
+      @thead = nil
    end
 end

data/test/{tc_header.rb → test_header.rb}

@@ -1,20 +1,23 @@
 ################################################
-# tc_header.rb
+# test_header.rb
 #
 # Test suite for the Table::Row::Header class
 ################################################
-require "test/unit"
-require "html/table"
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'html/table'
 include HTML
 
 class TC_HTML_Table_Row_Header < Test::Unit::TestCase
    def setup
-      @th = Table::Row::Header.new
+      @theader = Table::Row::Header.new
    end
    
    def test_basic
       html = "<th></th>"
-      assert_equal(html,@th.html.gsub(/\s+/,''))
+      assert_equal(html, @theader.html.gsub(/\s+/,''))
    end
 
    def test_constructor
@@ -28,32 +31,32 @@ class TC_HTML_Table_Row_Header < Test::Unit::TestCase
 
    def test_with_attributes
       html = "<th align='left' colspan=3 nowrap></th>"
-      @th.align = 'left'
-      @th.colspan = 3
-      @th.nowrap = true
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n+/,''))
+      @theader.align = 'left'
+      @theader.colspan = 3
+      @theader.nowrap = true
+      assert_equal(html, @theader.html.gsub(/\s{2,}|\n+/,''))
    end
    
    def test_configure_not_allowed
-      assert_raises(NoMethodError){ @th.configure }
+      assert_raises(NoMethodError){ @theader.configure }
    end
    
    def test_add_content
       html = "<th>hello world</th>"
-      @th.content = "hello world"
-      assert_equal(html,@th.html.gsub(/\s{2,}/,''))
+      @theader.content = "hello world"
+      assert_equal(html, @theader.html.gsub(/\s{2,}/,''))
    end
    
    def test_add_multiple_content_items
       html = "<th>hello world</th>"
-      @th.content = "hello"," world"
-      assert_equal(html,@th.html.gsub(/\s{2,}/,''))
+      @theader.content = "hello"," world"
+      assert_equal(html, @theader.html.gsub(/\s{2,}/,''))
    end
 
    def test_add_content_in_constructor
       html = "<th>hello world</th>"
-      th = Table::Row::Header.new("hello world")
-      assert_equal(html,th.html.gsub(/\s{2,}/,''))
+      @theader = Table::Row::Header.new("hello world")
+      assert_equal(html, @theader.html.gsub(/\s{2,}/,''))
    end
 
    def test_indent_level
@@ -72,6 +75,6 @@ class TC_HTML_Table_Row_Header < Test::Unit::TestCase
    end
    
    def teardown
-      @th = nil
+      @theader = nil
    end
 end

data/test/test_html_handler.rb

@@ -0,0 +1,40 @@
+############################################################################
+# test_html_handler.rb
+#
+# Test suite for the HtmlHandler module. For these tests, we'll use an
+# instance of the Table class where the module has been mixed in.
+############################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'html/table'
+include HTML
+
+class TC_HtmlHandler < Test::Unit::TestCase
+   def setup
+      @table = Table.new(["foo",1,"bar"])
+   end
+   
+   def test_html
+      assert_respond_to(@table, :html)
+      assert_nothing_raised{ @table.html }
+      assert_raises(NoMethodError){ @table.html = "foo" }
+      assert_kind_of(String, @table.html)
+      assert_equal(true, @table.html.length > 0)
+   end
+   
+   def test_modify_html
+      assert_raises(ArgumentError){ @table.send(:modify_html) }
+      assert_nothing_raised{ @table.send(:modify_html,"nowrap") }
+      assert_nothing_raised{ @table.send(:modify_html,"align","top") }
+      assert_nothing_raised{
+         @table.send(:modify_html,"align","top")
+         @table.send(:modify_html,"align","top")
+      }
+   end   
+   
+   def teardown
+      @table = nil
+   end
+end

data/test/test_row.rb

@@ -0,0 +1,144 @@
+############################################
+# test_row.rb
+#
+# Test suite for the Table::Row class
+############################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'html/table'
+include HTML
+
+class TC_HTML_Table_Row < Test::Unit::TestCase
+   def setup
+      @trow = Table::Row.new
+   end
+
+   def test_constructor
+      assert_nothing_raised{ Table::Row.new }
+      assert_nothing_raised{ Table::Row.new("foo") }
+      assert_nothing_raised{ Table::Row.new(1) }
+      assert_nothing_raised{ Table::Row.new([1,2,3]) }
+      assert_nothing_raised{ Table::Row.new([[1,2,3],["foo","bar"]]) }
+   end
+   
+   def test_basic
+      html = "<tr></tr>"
+      assert_equal(html,@trow.html.gsub(/\s+/,''))
+   end
+
+   def test_header
+      assert_respond_to(@trow, :header?)
+      assert_respond_to(@trow, :header=)
+      assert_nothing_raised{ @trow.header? }
+      assert_nothing_raised{ @trow.header = true }
+   end
+   
+   def test_with_attributes
+      html = "<tr align='center'></tr>"
+      @trow.align = "center"
+      assert_equal(html, @trow.html.gsub(/\s{2,}|\n+/,''))
+   end
+
+   def test_index_assignment_constraints
+      assert_raises(ArgumentTypeError){ @trow[0] = "foo" }
+      assert_raises(ArgumentTypeError){ @trow[0] = 1 }
+      assert_raises(ArgumentTypeError){ @trow[0] = Table::Caption.new }
+      assert_nothing_raised{ @trow[0] = Table::Row::Data.new }
+      assert_nothing_raised{ @trow[0] = Table::Row::Header.new }
+   end
+
+   def test_push_constraints
+      assert_raises(ArgumentTypeError){ @trow.push(Table::Caption.new) }
+      assert_raises(ArgumentTypeError){ @trow.push(nil) }
+      assert_nothing_raised{ @trow.push("test") }
+      assert_nothing_raised{ @trow.push(7) }
+      assert_nothing_raised{ @trow.push(Table::Row::Data.new) }
+      assert_nothing_raised{ @trow.push(Table::Row::Header.new) }
+   end
+
+   # Test the '<<' method
+   def test_doubl_arrow_constraints
+      assert_raises(ArgumentTypeError){ @trow << Table::Caption.new }
+      assert_nothing_raised{ @trow << "test" }
+      assert_nothing_raised{ @trow << "test" << "foo" }
+      assert_nothing_raised{ @trow << Table::Row::Data.new }
+      assert_nothing_raised{ @trow << Table::Row::Header.new }
+   end
+
+   def test_header_in_constructor
+      assert_nothing_raised{ @trow = Table::Row.new('test', true) }
+      html = "<tr><th>test</th></tr>"
+      assert_equal(html, @trow.html.gsub(/\s+/,''))
+   end
+   
+   def test_push_single_data_element
+      html = "<tr><td>hello</td></tr>"
+      @trow.push Table::Row::Data.new{ |d| d.content = "hello" }
+      assert_equal(html, @trow.html.gsub(/\s{2,}|\n+/,''))
+   end
+
+   def test_push_multiple_data_element
+      html = "<tr><td>hello</td><td>world</td></tr>"
+      d1 = Table::Row::Data.new{ |d| d.content = "hello" }
+      d2 = Table::Row::Data.new{ |d| d.content = "world" }
+      @trow.push d1, d2
+      assert_equal(html, @trow.html.gsub(/\s{2,}|\n+/,''))
+   end
+   
+   def test_add_content_directly
+      html = "<tr><td>hello</td><td>world</td></tr>"
+      @trow.content = "hello","world"
+      assert_equal(html, @trow.html.gsub(/\s{2,}|\n+/,''))
+   end
+
+   def test_add_content_in_constructor
+      html = "<tr><td>hello</td><td>world</td></tr>"
+      @trow = Table::Row.new(%w/hello world/)
+      assert_equal(html, @trow.html.gsub(/\s{2,}|\n+/,''))
+   end
+   
+   def test_configure_column
+      html = "<tr><td>hello</td><td abbr='test' width=3 nowrap>world</td></tr>"
+      @trow.content = "hello","world"
+      @trow.configure(1){ |d|
+         d.abbr = 'test'
+         d.width = 3
+         d.nowrap = true
+      }
+      assert_equal(html, @trow.html.gsub(/\s{2,}|\n+/,''))
+   end
+
+   def test_unshift_constraints
+      assert_raises(ArgumentTypeError){ @trow.unshift(Table::Caption.new) }
+      assert_raises(ArgumentTypeError){ @trow.unshift(nil) }
+      assert_nothing_raised{ @trow.unshift("test") }
+      assert_nothing_raised{ @trow.unshift(7) }
+      assert_nothing_raised{ @trow.unshift(Table::Row::Data.new) }
+      assert_nothing_raised{ @trow.unshift(Table::Row::Header.new) }
+   end
+   
+   def test_configure_error
+      assert_raises(ArgumentError){ @trow.configure(0,0){ } }
+   end
+
+   def test_indent_level
+      assert_respond_to(Table::Row,:indent_level)
+      assert_respond_to(Table::Row,:indent_level=)
+      assert_raises(ArgumentTypeError){ Table::Row.indent_level = "foo" }
+      assert_nothing_raised{ Table::Row.indent_level = 3 }
+   end
+
+   def test_end_tags
+      assert_respond_to(Table::Row,:end_tags?)
+      assert_respond_to(Table::Row,:end_tags=)
+      assert_raises(ArgumentTypeError){ Table::Row.end_tags = "foo" }
+      assert_raises(ArgumentTypeError){ Table::Row.end_tags = 1 }
+      assert_nothing_raised{ Table::Row.end_tags = true }
+   end
+   
+   def teardown
+      @trow = nil
+   end
+end

data/test/{tc_table.rb → test_table.rb}

@@ -1,9 +1,12 @@
 #######################################################################
-# tc_table.rb
+# test_table.rb
 #
 # Test suite for the HTML::Table class. This test case should be run
 # via the 'rake test' task.
 #######################################################################
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'html/table'
 require 'strongtyping'
@@ -12,11 +15,11 @@ include HTML
 
 class TC_HTML_Table < Test::Unit::TestCase
    def setup
-      @t = Table.new   
+      @table = Table.new   
    end   
    
    def test_version
-      assert_equal('1.3.2', Table::VERSION)
+      assert_equal('1.3.3', Table::VERSION)
    end
 
    def test_constructor
@@ -45,99 +48,99 @@ class TC_HTML_Table < Test::Unit::TestCase
    end
 
    def test_index
-      assert_raises(ArgumentTypeError){ @t[0] = 'foo' }
+      assert_raises(ArgumentTypeError){ @table[0] = 'foo' }
    end
 
    def test_caption_index_constraints
-      assert_nothing_raised{ @t[0] = Table::Caption.new }
-      assert_raises(ArgumentError){ @t[1] = Table::Caption.new }
+      assert_nothing_raised{ @table[0] = Table::Caption.new }
+      assert_raises(ArgumentError){ @table[1] = Table::Caption.new }
    end
 
    def test_head_index_constraints
-      assert_nothing_raised{ @t[0] = Table::Head.create }
-      assert_raises(ArgumentError){ @t[1] = Table::Head.create }
-      assert_raises(ArgumentError){ @t[2] = Table::Head.create }
+      assert_nothing_raised{ @table[0] = Table::Head.create }
+      assert_raises(ArgumentError){ @table[1] = Table::Head.create }
+      assert_raises(ArgumentError){ @table[2] = Table::Head.create }
    end
 
    def test_foot_index_constraints
       assert_nothing_raised{ 
-         @t[0] = Table::Caption.new
-         @t[-1] = Table::Foot.create
+         @table[0] = Table::Caption.new
+         @table[-1] = Table::Foot.create
       }
-      assert_raises(ArgumentError){ @t[0] = Table::Foot.create }
+      assert_raises(ArgumentError){ @table[0] = Table::Foot.create }
    end
 
    def test_unshift_constraints
-      assert_nothing_raised{ @t.unshift Table::Row.new }
-      assert_raises(ArgumentTypeError){ @t.unshift Table::Row::Data.new }
-      assert_raises(ArgumentTypeError){ @t.unshift 'foo' }
+      assert_nothing_raised{ @table.unshift Table::Row.new }
+      assert_raises(ArgumentTypeError){ @table.unshift Table::Row::Data.new }
+      assert_raises(ArgumentTypeError){ @table.unshift 'foo' }
    end
 
    def test_push_constraints
-      assert_nothing_raised{ @t.push Table::Row.new }
-      assert_raises(ArgumentTypeError){ @t.push('foo') }
-      assert_raises(ArgumentTypeError){ @t.push(7) }
-      assert_raises(ArgumentTypeError){ @t.push(nil) }
+      assert_nothing_raised{ @table.push Table::Row.new }
+      assert_raises(ArgumentTypeError){ @table.push('foo') }
+      assert_raises(ArgumentTypeError){ @table.push(7) }
+      assert_raises(ArgumentTypeError){ @table.push(nil) }
    end
 
    def test_double_arrow_constraints
-      assert_nothing_raised{ @t << Table::Row.new }
-      assert_nothing_raised{ @t << Table::Row.new << Table::Row.new }
-      assert_raises(ArgumentTypeError){ @t << 'foo' }
-      assert_raises(ArgumentTypeError){ @t << 7 }
-      assert_raises(ArgumentTypeError){ @t << nil }
+      assert_nothing_raised{ @table << Table::Row.new }
+      assert_nothing_raised{ @table << Table::Row.new << Table::Row.new }
+      assert_raises(ArgumentTypeError){ @table << 'foo' }
+      assert_raises(ArgumentTypeError){ @table << 7 }
+      assert_raises(ArgumentTypeError){ @table << nil }
    end
 
    def test_basic
       html = "<table>\n</table>"
-      assert_equal(html, @t.html)
+      assert_equal(html, @table.html)
    end
    
    def test_with_attributes
       html = "<table border=1 align='left' nowrap>\n</table>"
-      @t.border = 1
-      @t.align = 'left'
-      @t.nowrap = true
-      assert_equal(html, @t.html)
+      @table.border = 1
+      @table.align = 'left'
+      @table.nowrap = true
+      assert_equal(html, @table.html)
    end   
    
    def test_add_row_push
       html = '<table><tr></tr></table>'
-      @t.push(Table::Row.new)
-      assert_equal(html, @t.html.gsub(/\s+/,''))
+      @table.push(Table::Row.new)
+      assert_equal(html, @table.html.gsub(/\s+/,''))
    end
    
    def test_add_row_by_index
       html = '<table><tr></tr></table>'
-      @t[0] = Table::Row.new
-      assert_equal(html, @t.html.gsub(/\s+/,''))
+      @table[0] = Table::Row.new
+      assert_equal(html, @table.html.gsub(/\s+/,''))
    end
    
    def test_add_multiple_rows
       html = '<table><tr></tr><tr></tr></table>'
-      @t.push Table::Row.new, Table::Row.new
-      assert_equal(html, @t.html.gsub(/\s+/,''))
+      @table.push Table::Row.new, Table::Row.new
+      assert_equal(html, @table.html.gsub(/\s+/,''))
    end
    
    def test_add_single_data_element
       html = '<table><tr><td>hello</td></tr></table>'
-      @t.content = 'hello'
-      assert_equal(html, @t.html.gsub(/\s+/,''))
+      @table.content = 'hello'
+      assert_equal(html, @table.html.gsub(/\s+/,''))
    end
    
    def test_add_multiple_data_elements
       html = '<table><tr><td>hello</td></tr><tr><td>world</td></tr></table>'
-      @t.content = 'hello','world'
-      assert_equal(html, @t.html.gsub(/\s+/,''))
+      @table.content = 'hello','world'
+      assert_equal(html, @table.html.gsub(/\s+/,''))
    end
    
    def test_configure_row
       html = "<table><tr align='center'><td bgcolor='red'>hello</td></tr>"
       html << '</table>'
-      @t.push Table::Row::Data.new{ |d| d.content = 'hello' }
-      @t.configure(0){ |t| t.align = 'center' }
-      @t.configure(0,0){ |d| d.bgcolor = 'red' }
-      assert_equal(html, @t.html.gsub(/\s{2,}|\n+/,''))
+      @table.push Table::Row::Data.new{ |d| d.content = 'hello' }
+      @table.configure(0){ |t| t.align = 'center' }
+      @table.configure(0,0){ |d| d.bgcolor = 'red' }
+      assert_equal(html, @table.html.gsub(/\s{2,}|\n+/,''))
    end
 
    def test_global_end_tags
@@ -149,6 +152,6 @@ class TC_HTML_Table < Test::Unit::TestCase
    end
    
    def teardown
-      @t = nil
+      @table = nil
    end
 end