html-table 1.3.2 → 1.3.3

data/test/{tc_body.rb → test_body.rb}

@@ -1,16 +1,19 @@
 ############################################
-# tc_body.rb
+# test_body.rb
 #
 # Test suite for the Table::Body class
 ############################################
-require "test/unit"
-require "html/table"
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'html/table'
 include HTML
 
 class TC_HTML_Table_Body < Test::Unit::TestCase
    def setup
-      @t = Table.new
-      @tb = Table::Body.new
+      @table = Table.new
+      @tbody = Table::Body.new
    end
 
    def test_constructor
@@ -24,64 +27,64 @@ class TC_HTML_Table_Body < Test::Unit::TestCase
    
    def test_basic
       html = "<tbody></tbody>"
-      assert_equal(html,@tb.html.gsub(/\s{2,}|\n/,''))
+      assert_equal(html, @tbody.html.gsub(/\s{2,}|\n/,''))
    end
    
    def test_with_attributes
       html = "<tbody align='left' char='x'></tbody>"
-      @tb.align = "left"
-      @tb.char = 'x'
-      assert_equal(html,@tb.html.gsub(/\s{2,}|\n/,''))
+      @tbody.align = "left"
+      @tbody.char = 'x'
+      assert_equal(html, @tbody.html.gsub(/\s{2,}|\n/,''))
    end
    
    def test_push_single_row
       html = "<tbody><tr><td>test</td></tr></tbody>"
-      @tb.push Table::Row.new{|r| r.content = "test"}
-      assert_equal(html,@tb.html.gsub(/\s{2,}|\n/,''))
+      @tbody.push Table::Row.new{|r| r.content = "test" }
+      assert_equal(html, @tbody.html.gsub(/\s{2,}|\n/,''))
    end
    
    def test_push_multiple_rows
       html = "<tbody><tr><td>test</td></tr><tr><td>foo</td></tr></tbody>"
-      r1 = Table::Row.new{|r| r.content = "test"}
-      r2 = Table::Row.new{|r| r.content = "foo"}
-      @tb.push r1, r2
-      assert_equal(html,@tb.html.gsub(/\s{2,}|\n/,''))
+      r1 = Table::Row.new{|r| r.content = "test" }
+      r2 = Table::Row.new{|r| r.content = "foo" }
+      @tbody.push r1, r2
+      assert_equal(html, @tbody.html.gsub(/\s{2,}|\n/,''))
    end
    
    def test_add_content_directly
       html = "<tbody><tr><td>hello</td><td>world</td></tr></tbody>"
-      @tb.content = "hello","world"
-      assert_equal(html,@tb.html.gsub(/\s{2,}|\n+/,''))
+      @tbody.content = "hello","world"
+      assert_equal(html, @tbody.html.gsub(/\s{2,}|\n+/,''))
    end
 
    def test_add_content_in_constructor
       html = "<tbody><tr><td>hello</td><td>world</td></tr></tbody>"
       tb = Table::Body.new(%w/hello world/)
-      assert_equal(html,tb.html.gsub(/\s{2,}|\n+/,''))
+      assert_equal(html, tb.html.gsub(/\s{2,}|\n+/,''))
    end
    
    def test_configure_column
       html = "<tbody><tr><td>hello</td><td abbr='test' width=3 nowrap>world"
       html += "</td></tr></tbody>"
-      @tb.content = "hello","world"
-      @tb.configure(0,1){ |d|
-         d.abbr = 'test'
-         d.width = 3
-         d.nowrap = true
+      @tbody.content = "hello","world"
+      @tbody.configure(0,1){ |data|
+         data.abbr   = 'test'
+         data.width  = 3
+         data.nowrap = true
       }
-      assert_equal(html,@tb.html.gsub(/\s{2,}|\n+/,''))
+      assert_equal(html, @tbody.html.gsub(/\s{2,}|\n+/,''))
    end
 
    def test_end_tags
-      assert_respond_to(Table::Body,:end_tags?)
-      assert_respond_to(Table::Body,:end_tags=)
+      assert_respond_to(Table::Body, :end_tags?)
+      assert_respond_to(Table::Body, :end_tags=)
       assert_raises(ArgumentTypeError){ Table::Body.end_tags = "foo" }
       assert_raises(ArgumentTypeError){ Table::Body.end_tags = 1 }
       assert_nothing_raised{ Table::Body.end_tags = true }
    end
    
    def teardown
-      @t = nil
-      @tb = nil
+      @table = nil
+      @tbody = nil
    end
 end

data/test/{tc_caption.rb → test_caption.rb}

@@ -1,16 +1,19 @@
 ################################################
-# tc_caption.rb
+# test_caption.rb
 #
 # Test suite for the Table::Caption class
 ################################################
-require "test/unit"
-require "html/table"
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'html/table'
 include HTML
 
 class TC_HTML_Table_Caption < Test::Unit::TestCase
    def setup
-      @t = Table.new
-      @tc = Table::Caption.new
+      @table = Table.new
+      @tcaption = Table::Caption.new
    end
 
    def test_constructor
@@ -24,36 +27,36 @@ class TC_HTML_Table_Caption < Test::Unit::TestCase
    
    def test_basic
       html = "<caption></caption>"
-      assert_equal(html,@tc.html.gsub(/\s+/,''))
+      assert_equal(html, @tcaption.html.gsub(/\s+/,''))
    end
    
    def test_with_attributes
       html = "<caption align='left' valign='top'></caption>"
-      @tc.align = "left"
-      @tc.valign = "top"
-      assert_equal(html,@tc.html.gsub(/\s{2,}|\n+/,''))
+      @tcaption.align = "left"
+      @tcaption.valign = "top"
+      assert_equal(html, @tcaption.html.gsub(/\s{2,}|\n+/,''))
    end
    
    def test_configure_not_allowed
-      assert_raises(NoMethodError){ @tc.configure }
+      assert_raises(NoMethodError){ @tcaption.configure }
    end
    
    def test_add_content
       html = "<caption>hello world</caption>"
-      @tc.content = "hello world"
-      assert_equal(html,@tc.html.gsub(/\s{2,}/,''))
+      @tcaption.content = "hello world"
+      assert_equal(html,@tcaption.html.gsub(/\s{2,}/,''))
    end
    
    def test_add_multiple_content_items
       html = "<caption>hello world</caption>"
-      @tc.content = "hello"," world"
-      assert_equal(html,@tc.html.gsub(/\s{2,}/,''))
+      @tcaption.content = "hello"," world"
+      assert_equal(html,@tcaption.html.gsub(/\s{2,}/,''))
    end
 
    def test_add_content_in_constructor
       html = "<caption>hello world</caption>"
-      tc = Table::Caption.new("hello world")
-      assert_equal(html,tc.html.gsub(/\s{2,}/,''))
+      @tcaption = Table::Caption.new("hello world")
+      assert_equal(html, @tcaption.html.gsub(/\s{2,}/,''))
    end
 
    def test_indent_level
@@ -63,18 +66,18 @@ class TC_HTML_Table_Caption < Test::Unit::TestCase
       assert_nothing_raised{ Table::Caption.indent_level = 3 }
    end
    
-   def test_only_row_zero
-      assert_raises(ArgumentError){ @t[1] = @tc }
+   def test_only_row_zero_allowed
+      assert_raises(ArgumentError){ @table[1] = @tcaption }
    end
    
    def test_automatically_set_to_row_zero
-      @t.content = "hello","world"
-      @t.push(@tc)
-      assert_equal(true,@t[0].kind_of?(Table::Caption))
+      @table.content = "hello","world"
+      @table.push(@tcaption)
+      assert_equal(true, @table[0].kind_of?(Table::Caption))
    end
    
    def teardown
-      @t = nil
-      @tc = nil
+      @table = nil
+      @tcaption = nil
    end
 end

data/test/{tc_col.rb → test_col.rb}

@@ -1,30 +1,33 @@
 ##################################################
-# tc_col.rb
+# test_col.rb
 #
 # Test suite for the Table::ColGroup::Col class
 ##################################################
-require "test/unit"
-require "html/table"
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'html/table'
 include HTML
 
 class TC_HTML_Table_Col < Test::Unit::TestCase
    def setup
-      @c = Table::ColGroup::Col.new
-      @cg = Table::ColGroup.new
+      @col = Table::ColGroup::Col.new
+      @cgroup = Table::ColGroup.new
    end
 
    def test_basic
       html = "<col>"
-      assert_equal(html,@c.html.gsub(/\s{2,}|\n+/,''))
+      assert_equal(html, @col.html.gsub(/\s{2,}|\n+/,''))
    end
 
    def test_no_configure
-      assert_raises(NoMethodError){ @c.configure }
+      assert_raises(NoMethodError){ @col.configure }
    end
    
    def test_no_content_allowed
-      assert_raises(NoMethodError){ @c.content }
-      assert_raises(NoMethodError){ @c.content = "foo" }
+      assert_raises(NoMethodError){ @col.content }
+      assert_raises(NoMethodError){ @col.content = "foo" }
    end
 
    def test_indent_level
@@ -35,6 +38,6 @@ class TC_HTML_Table_Col < Test::Unit::TestCase
    end
    
    def teardown
-      @c = nil
+      @col = nil
    end
 end

data/test/{tc_colgroup.rb → test_colgroup.rb}

@@ -1,15 +1,18 @@
 ############################################
-# tc_colgroup.rb
+# test_colgroup.rb
 #
 # Test suite for the Table::ColGroup class
 ############################################
-require "test/unit"
-require "html/table"
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'html/table'
 include HTML
 
 class TC_HTML_Table_ColGroup < Test::Unit::TestCase
    def setup
-      @cg = Table::ColGroup.new
+      @cgroup = Table::ColGroup.new
       @col = Table::ColGroup::Col.new
    end
 
@@ -21,51 +24,51 @@ class TC_HTML_Table_ColGroup < Test::Unit::TestCase
    
    def test_basic
       html = "<colgroup></colgroup>"
-      assert_equal(html,@cg.html.gsub(/\s+/,''))
+      assert_equal(html,@cgroup.html.gsub(/\s+/,''))
    end
    
    def test_with_attributes
       html = "<colgroup align='center' width='20%'></colgroup>"
-      @cg.align = "center"
-      @cg.width = "20%"
-      assert_equal(html,@cg.html.gsub(/\s{2,}|\n+/,''))
+      @cgroup.align = "center"
+      @cgroup.width = "20%"
+      assert_equal(html,@cgroup.html.gsub(/\s{2,}|\n+/,''))
    end
    
    def test_push_single_col_element
       html = "<colgroup><col></colgroup>"
-      @cg.push(@col)
-      assert_equal(html,@cg.html.gsub(/\s{2,}|\n+/,''))
+      @cgroup.push(@col)
+      assert_equal(html,@cgroup.html.gsub(/\s{2,}|\n+/,''))
    end
 
    def test_index_assignment_constraints
-      assert_raises(ArgumentTypeError){ @cg[0] = "foo" }
-      assert_raises(ArgumentTypeError){ @cg[0] = 1 }
-      assert_raises(ArgumentTypeError){ @cg[1] = Table::Row.new }
-      assert_nothing_raised{ @cg[0] = Table::ColGroup::Col.new }
+      assert_raises(ArgumentTypeError){ @cgroup[0] = "foo" }
+      assert_raises(ArgumentTypeError){ @cgroup[0] = 1 }
+      assert_raises(ArgumentTypeError){ @cgroup[1] = Table::Row.new }
+      assert_nothing_raised{ @cgroup[0] = Table::ColGroup::Col.new }
    end
 
    def test_push_constraints
-      assert_raises(TypeError){ @cg.push(7) }
-      assert_raises(TypeError){ @cg.push("hello") }
-      assert_raises(TypeError){ @cg.push(Table::Row.new) }
-      assert_nothing_raised{ @cg.push(Table::ColGroup::Col.new) }
+      assert_raises(TypeError){ @cgroup.push(7) }
+      assert_raises(TypeError){ @cgroup.push("hello") }
+      assert_raises(TypeError){ @cgroup.push(Table::Row.new) }
+      assert_nothing_raised{ @cgroup.push(Table::ColGroup::Col.new) }
    end
 
    # Test '<<'
    def test_double_arrow_constraints
-      assert_raises(TypeError){ @cg << 7 }
-      assert_raises(TypeError){ @cg << "hello" }
-      assert_raises(TypeError){ @cg << Table::Row.new }
-      assert_nothing_raised{ @cg << Table::ColGroup::Col.new }
+      assert_raises(TypeError){ @cgroup << 7 }
+      assert_raises(TypeError){ @cgroup << "hello" }
+      assert_raises(TypeError){ @cgroup << Table::Row.new }
+      assert_nothing_raised{ @cgroup << Table::ColGroup::Col.new }
    end
    
    def test_configure_error
-      assert_raises(ArgumentError){ @cg.configure(0,0){ } }
+      assert_raises(ArgumentError){ @cgroup.configure(0,0){ } }
    end
   
    def test_content_error
-      assert_raises(NoMethodError){ @cg.content }
-      assert_raises(NoMethodError){ @cg.content = 'blah' }
+      assert_raises(NoMethodError){ @cgroup.content }
+      assert_raises(NoMethodError){ @cgroup.content = 'blah' }
    end
 
    def test_indent_level
@@ -84,6 +87,6 @@ class TC_HTML_Table_ColGroup < Test::Unit::TestCase
    end
    
    def teardown
-      @cg = nil
+      @cgroup = nil
    end
 end

data/test/{tc_data.rb → test_data.rb}

@@ -1,15 +1,18 @@
 ##############################################
-# tc_data.rb
+# test_data.rb
 #
 # Test suite for the Table::Row::Data 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_Data < Test::Unit::TestCase
    def setup
-      @td = Table::Row::Data.new
+      @tdata = Table::Row::Data.new
    end
 
    def test_constructor
@@ -23,25 +26,25 @@ class TC_HTML_Table_Row_Data < Test::Unit::TestCase
    
    def test_basic
       html = "<td></td>"
-      assert_equal(html,@td.html.gsub(/\s+/,''))
+      assert_equal(html,@tdata.html.gsub(/\s+/,''))
    end
    
    def test_with_attributes
       html = "<td align='left' width=3 nowrap></td>"
-      @td.align = 'left'
-      @td.width = 3
-      @td.nowrap = true
-      assert_equal(html,@td.html.gsub(/\s{2,}|\n+/,''))
+      @tdata.align = 'left'
+      @tdata.width = 3
+      @tdata.nowrap = true
+      assert_equal(html,@tdata.html.gsub(/\s{2,}|\n+/,''))
    end
    
    def test_configure_not_allowed
-      assert_raises(NoMethodError){ @td.configure }
+      assert_raises(NoMethodError){ @tdata.configure }
    end
    
    def test_add_content
       html = "<td>hello world</td>"
-      @td.content = "hello world"
-      assert_equal(html,@td.html.gsub(/\s{2,}/,''))
+      @tdata.content = "hello world"
+      assert_equal(html,@tdata.html.gsub(/\s{2,}/,''))
    end
 
    def test_add_content_in_constructor
@@ -52,8 +55,8 @@ class TC_HTML_Table_Row_Data < Test::Unit::TestCase
    
    def test_add_multiple_content_items
       html = "<td>hello world</td>"
-      @td.content = "hello"," world"
-      assert_equal(html,@td.html.gsub(/\s{2,}/,''))
+      @tdata.content = "hello"," world"
+      assert_equal(html,@tdata.html.gsub(/\s{2,}/,''))
    end
 
    def test_indent_level
@@ -72,6 +75,6 @@ class TC_HTML_Table_Row_Data < Test::Unit::TestCase
    end
    
    def teardown
-      @td = nil
+      @tdata = nil
    end
 end

data/test/{tc_foot.rb → test_foot.rb}

@@ -1,12 +1,15 @@
 ###############################################################################
-# tc_foot.rb
+# test_foot.rb
 #
 # Test suite for the Table::Foot class.  The Table::Foot 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_Foot < Test::Unit::TestCase
    def setup
-      @t = Table.new
-      @tf = Table::Foot.create
+      @table = Table.new
+      @tfoot = Table::Foot.create
    end
 
    def test_new_not_allowed
@@ -36,12 +39,12 @@ class TC_HTML_Table_Foot < Test::Unit::TestCase
       assert_nothing_raised{ Table::Foot.create(1) }
       assert_nothing_raised{ Table::Foot.create(%w/foo bar baz/) }
       assert_nothing_raised{ Table::Foot.create([1,2,3]) }
-      assert_nothing_raised{ Table::Foot.create([[1,2,3],["foo","bar"]]) }
+      assert_nothing_raised{ Table::Foot.create([[1,2,3], ["foo","bar"]]) }
    end
    
    def test_basic
       html = "<tfoot></tfoot>"
-      assert_equal(html,@tf.html.gsub(/\s{2,}|\n/,''))
+      assert_equal(html, @tfoot.html.gsub(/\s{2,}|\n/,''))
    end
 
    def test_end_tags
@@ -49,6 +52,9 @@ class TC_HTML_Table_Foot < Test::Unit::TestCase
       assert_respond_to(Table::Foot, :end_tags=)
       assert_nothing_raised{ Table::Foot.end_tags? }
       assert_nothing_raised{ Table::Foot.end_tags = true }
+   end
+
+   def test_end_tags_expected_errors
       assert_raises(StrongTyping::ArgumentTypeError){
          Table::Foot.end_tags = "foo"
       }
@@ -56,53 +62,53 @@ class TC_HTML_Table_Foot < Test::Unit::TestCase
 
    def test_with_attributes
       html = "<tfoot align='left' char='x'></tfoot>"
-      @tf.align = "left"
-      @tf.char = 'x'
-      assert_equal(html,@tf.html.gsub(/\s{2,}|\n/,''))
+      @tfoot.align = "left"
+      @tfoot.char = 'x'
+      assert_equal(html, @tfoot.html.gsub(/\s{2,}|\n/,''))
    end
    
    def test_push_single_row
       html = "<tfoot><tr><td>test</td></tr></tfoot>"
-      @tf.push Table::Row.new{|r| r.content = "test"}
-      assert_equal(html,@tf.html.gsub(/\s{2,}|\n/,''))
+      @tfoot.push Table::Row.new{|r| r.content = "test"}
+      assert_equal(html, @tfoot.html.gsub(/\s{2,}|\n/,''))
    end
 
    def test_push_multiple_rows
       html = "<tfoot><tr><td>test</td></tr><tr><td>foo</td></tr></tfoot>"
       r1 = Table::Row.new{|r| r.content = "test"}
       r2 = Table::Row.new{|r| r.content = "foo"}
-      @tf.push r1, r2
-      assert_equal(html,@tf.html.gsub(/\s{2,}|\n/,''))
+      @tfoot.push r1, r2
+      assert_equal(html, @tfoot.html.gsub(/\s{2,}|\n/,''))
    end
    
    def test_add_content_directly
       html = "<tfoot><tr><td>hello</td><td>world</td></tr></tfoot>"
-      @tf.content = "hello","world"
-      assert_equal(html,@tf.html.gsub(/\s{2,}|\n+/,''))
+      @tfoot.content = "hello","world"
+      assert_equal(html, @tfoot.html.gsub(/\s{2,}|\n+/,''))
    end
 
    def test_add_content_in_constructor
       html = "<tfoot><tr><td>hello</td><td>world</td></tr></tfoot>"
-      @tf.send(:refresh)
-      @tf = Table::Foot.create(["hello","world"])
-      assert_equal(html,@tf.html.gsub(/\s{2,}|\n+/,''))
+      @tfoot.send(:refresh)
+      @tfoot = Table::Foot.create(["hello","world"])
+      assert_equal(html, @tfoot.html.gsub(/\s{2,}|\n+/,''))
    end
    
    def test_configure_column
       html = "<tfoot><tr><td>hello</td><td abbr='test' width=3 nowrap>world"
       html += "</td></tr></tfoot>"
-      @tf.content = "hello","world"
-      @tf.configure(0,1){ |d|
-         d.abbr = 'test'
-         d.width = 3
-         d.nowrap = true
+      @tfoot.content = "hello","world"
+      @tfoot.configure(0,1){ |data|
+         data.abbr   = 'test'
+         data.width  = 3
+         data.nowrap = true
       }
-      assert_equal(html,@tf.html.gsub(/\s{2,}|\n+/,''))
+      assert_equal(html, @tfoot.html.gsub(/\s{2,}|\n+/,''))
    end
 
    def teardown
-      @t = nil
-      @tf.send(:refresh)
-      @tf = nil
+      @table = nil
+      @tfoot.send(:refresh)
+      @tfoot = nil
    end
 end