html-table 1.3.1 → 1.3.2

data/test/tc_data.rb

@@ -1,87 +1,77 @@
-##############################################
-# tc_data.rb
-#
-# Test suite for the Table::Row::Data class
-##############################################
-base = File.basename(Dir.pwd)
-
-if base == "test" || base =~ /html-table/
-   Dir.chdir("..") if base == "test"
-   $LOAD_PATH.unshift(Dir.pwd)
-   $LOAD_PATH.unshift(Dir.pwd + "/lib")
-   $LOAD_PATH.unshift(Dir.pwd + "/lib/html")
-   Dir.chdir("test") rescue nil
-end
-
-require "test/unit"
-require "html/table"
-include HTML
-
-class TC_HTML_Table_Row_Data < Test::Unit::TestCase
-   def setup
-      @td = Table::Row::Data.new
-   end
-
-   def test_constructor
-      assert_nothing_raised{ Table::Row::Data.new }
-      assert_nothing_raised{ Table::Row::Data.new("foo") }
-      assert_nothing_raised{ Table::Row::Data.new(1) }
-      assert_nothing_raised{ Table::Row::Data.new(%w/foo bar baz/) }
-      assert_nothing_raised{ Table::Row::Data.new([1,2,3]) }
-      assert_nothing_raised{ Table::Row::Data.new([[1,2,3],["foo","bar"]]) }
-   end
-   
-   def test_basic
-      html = "<td></td>"
-      assert_equal(html,@td.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+/,''))
-   end
-   
-   def test_configure_not_allowed
-      assert_raises(NoMethodError){ @td.configure }
-   end
-   
-   def test_add_content
-      html = "<td>hello world</td>"
-      @td.content = "hello world"
-      assert_equal(html,@td.html.gsub(/\s{2,}/,''))
-   end
-
-   def test_add_content_in_constructor
-      html = "<td>hello world</td>"
-      td = Table::Row::Data.new("hello world")
-      assert_equal(html,td.html.gsub(/\s{2,}/,''))
-   end
-   
-   def test_add_multiple_content_items
-      html = "<td>hello world</td>"
-      @td.content = "hello"," world"
-      assert_equal(html,@td.html.gsub(/\s{2,}/,''))
-   end
-
-   def test_indent_level
-      assert_respond_to(Table::Row::Data,:indent_level)
-      assert_respond_to(Table::Row::Data,:indent_level=)
-      assert_raises(ArgumentTypeError){ Table::Row::Data.indent_level = "foo" }
-      assert_nothing_raised{ Table::Row::Data.indent_level = 6 }
-   end
-
-   def test_end_tags
-      assert_respond_to(Table::Row::Data,:end_tags?)
-      assert_respond_to(Table::Row::Data,:end_tags=)
-      assert_raises(ArgumentTypeError){ Table::Row::Data.end_tags = "foo" }
-      assert_raises(ArgumentTypeError){ Table::Row::Data.end_tags = 1 }
-      assert_nothing_raised{ Table::Row::Data.end_tags = true }
-   end
-   
-   def teardown
-      @td = nil
-   end
-end
+##############################################
+# tc_data.rb
+#
+# Test suite for the Table::Row::Data class
+##############################################
+require "test/unit"
+require "html/table"
+include HTML
+
+class TC_HTML_Table_Row_Data < Test::Unit::TestCase
+   def setup
+      @td = Table::Row::Data.new
+   end
+
+   def test_constructor
+      assert_nothing_raised{ Table::Row::Data.new }
+      assert_nothing_raised{ Table::Row::Data.new("foo") }
+      assert_nothing_raised{ Table::Row::Data.new(1) }
+      assert_nothing_raised{ Table::Row::Data.new(%w/foo bar baz/) }
+      assert_nothing_raised{ Table::Row::Data.new([1,2,3]) }
+      assert_nothing_raised{ Table::Row::Data.new([[1,2,3],["foo","bar"]]) }
+   end
+   
+   def test_basic
+      html = "<td></td>"
+      assert_equal(html,@td.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+/,''))
+   end
+   
+   def test_configure_not_allowed
+      assert_raises(NoMethodError){ @td.configure }
+   end
+   
+   def test_add_content
+      html = "<td>hello world</td>"
+      @td.content = "hello world"
+      assert_equal(html,@td.html.gsub(/\s{2,}/,''))
+   end
+
+   def test_add_content_in_constructor
+      html = "<td>hello world</td>"
+      td = Table::Row::Data.new("hello world")
+      assert_equal(html,td.html.gsub(/\s{2,}/,''))
+   end
+   
+   def test_add_multiple_content_items
+      html = "<td>hello world</td>"
+      @td.content = "hello"," world"
+      assert_equal(html,@td.html.gsub(/\s{2,}/,''))
+   end
+
+   def test_indent_level
+      assert_respond_to(Table::Row::Data,:indent_level)
+      assert_respond_to(Table::Row::Data,:indent_level=)
+      assert_raises(ArgumentTypeError){ Table::Row::Data.indent_level = "foo" }
+      assert_nothing_raised{ Table::Row::Data.indent_level = 6 }
+   end
+
+   def test_end_tags
+      assert_respond_to(Table::Row::Data,:end_tags?)
+      assert_respond_to(Table::Row::Data,:end_tags=)
+      assert_raises(ArgumentTypeError){ Table::Row::Data.end_tags = "foo" }
+      assert_raises(ArgumentTypeError){ Table::Row::Data.end_tags = 1 }
+      assert_nothing_raised{ Table::Row::Data.end_tags = true }
+   end
+   
+   def teardown
+      @td = nil
+   end
+end

data/test/tc_foot.rb

@@ -1,118 +1,108 @@
-###############################################################################
-# tc_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.
-###############################################################################
-base = File.basename(Dir.pwd)
-
-if base == "test" || base =~ /html-table/
-   Dir.chdir("..") if base == "test"
-   $LOAD_PATH.unshift(Dir.pwd)
-   $LOAD_PATH.unshift(Dir.pwd + "/lib")
-   $LOAD_PATH.unshift(Dir.pwd + "/lib/html")
-   Dir.chdir("test") rescue nil
-end
-
-require "test/unit"
-require "html/table"
-include HTML
-
-#####################################################################
-# Ensure that a fresh instance of Table::Foot is used between tests
-# by calling 'refresh' in the 'teardown' method.
-#####################################################################
-class Table::Foot
-   private
-   def refresh
-      @@foot = nil
-   end
-end
-
-class TC_HTML_Table_Foot < Test::Unit::TestCase
-   def setup
-      @t = Table.new
-      @tf = Table::Foot.create
-   end
-
-   def test_new_not_allowed
-      assert_raises(NoMethodError){ Table::Foot.new }
-   end
-
-   def test_constructor
-      assert_nothing_raised{ Table::Foot.create }
-      assert_nothing_raised{ Table::Foot.create("foo") }
-      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"]]) }
-   end
-   
-   def test_basic
-      html = "<tfoot></tfoot>"
-      assert_equal(html,@tf.html.gsub(/\s{2,}|\n/,''))
-   end
-
-   def test_end_tags
-      assert_respond_to(Table::Foot, :end_tags?)
-      assert_respond_to(Table::Foot, :end_tags=)
-      assert_nothing_raised{ Table::Foot.end_tags? }
-      assert_nothing_raised{ Table::Foot.end_tags = true }
-      assert_raises(StrongTyping::ArgumentTypeError){
-         Table::Foot.end_tags = "foo"
-      }
-   end
-
-   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/,''))
-   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/,''))
-   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/,''))
-   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+/,''))
-   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+/,''))
-   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
-      }
-      assert_equal(html,@tf.html.gsub(/\s{2,}|\n+/,''))
-   end
-
-   def teardown
-      @t = nil
-      @tf.send(:refresh)
-      @tf = nil
-   end
-end
+###############################################################################
+# tc_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"
+include HTML
+
+#####################################################################
+# Ensure that a fresh instance of Table::Foot is used between tests
+# by calling 'refresh' in the 'teardown' method.
+#####################################################################
+class Table::Foot
+   private
+   def refresh
+      @@foot = nil
+   end
+end
+
+class TC_HTML_Table_Foot < Test::Unit::TestCase
+   def setup
+      @t = Table.new
+      @tf = Table::Foot.create
+   end
+
+   def test_new_not_allowed
+      assert_raises(NoMethodError){ Table::Foot.new }
+   end
+
+   def test_constructor
+      assert_nothing_raised{ Table::Foot.create }
+      assert_nothing_raised{ Table::Foot.create("foo") }
+      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"]]) }
+   end
+   
+   def test_basic
+      html = "<tfoot></tfoot>"
+      assert_equal(html,@tf.html.gsub(/\s{2,}|\n/,''))
+   end
+
+   def test_end_tags
+      assert_respond_to(Table::Foot, :end_tags?)
+      assert_respond_to(Table::Foot, :end_tags=)
+      assert_nothing_raised{ Table::Foot.end_tags? }
+      assert_nothing_raised{ Table::Foot.end_tags = true }
+      assert_raises(StrongTyping::ArgumentTypeError){
+         Table::Foot.end_tags = "foo"
+      }
+   end
+
+   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/,''))
+   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/,''))
+   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/,''))
+   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+/,''))
+   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+/,''))
+   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
+      }
+      assert_equal(html,@tf.html.gsub(/\s{2,}|\n+/,''))
+   end
+
+   def teardown
+      @t = nil
+      @tf.send(:refresh)
+      @tf = nil
+   end
+end

data/test/tc_head.rb

@@ -1,114 +1,104 @@
-###############################################################################
-# tc_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.
-###############################################################################
-base = File.basename(Dir.pwd)
-
-if base == "test" || base =~ /html-table/
-   Dir.chdir("..") if base == "test"
-   $LOAD_PATH.unshift(Dir.pwd)
-   $LOAD_PATH.unshift(Dir.pwd + "/lib")
-   $LOAD_PATH.unshift(Dir.pwd + "/lib/html")
-   Dir.chdir("test") rescue nil
-end
-
-require "test/unit"
-require "html/table"
-include HTML
-
-#####################################################################
-# Ensure that a fresh instance of Table::Head is used between tests
-# by calling 'refresh' in the 'teardown' method.
-#####################################################################
-class Table::Head
-   private
-   def refresh
-      @@head = nil
-   end
-end
-
-class TC_HTML_Table_Head < Test::Unit::TestCase
-   def setup
-      @t = Table.new
-      @th = Table::Head.create
-   end
-
-   def test_constructor
-      assert_nothing_raised{ Table::Head.create }
-      assert_nothing_raised{ Table::Head.create("foo") }
-      assert_nothing_raised{ Table::Head.create(1) }
-      assert_nothing_raised{ Table::Head.create(%w/foo bar baz/) }
-      assert_nothing_raised{ Table::Head.create([1,2,3]) }
-      assert_nothing_raised{ Table::Head.create([[1,2,3],["foo","bar"]]) }
-   end
-   
-   def test_basic
-      html = "<thead></thead>"
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n/,''))
-   end
-
-   def test_end_tags
-      assert_respond_to(Table::Head, :end_tags?)
-      assert_respond_to(Table::Head, :end_tags=)
-      assert_nothing_raised{ Table::Head.end_tags? }
-      assert_nothing_raised{ Table::Head.end_tags = true }
-      assert_raises(StrongTyping::ArgumentTypeError){
-         Table::Head.end_tags = "foo"
-      }
-   end
-
-   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/,''))
-   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/,''))
-   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/,''))
-   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+/,''))
-   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+/,''))
-   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|
-         d.abbr = 'test'
-         d.width = 3
-         d.nowrap = true
-      }
-      assert_equal(html,@th.html.gsub(/\s{2,}|\n+/,''))
-   end
-   
-   def teardown
-      @t = nil
-      @th.send(:refresh)
-      @th = nil
-   end
-end
+###############################################################################
+# tc_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"
+include HTML
+
+#####################################################################
+# Ensure that a fresh instance of Table::Head is used between tests
+# by calling 'refresh' in the 'teardown' method.
+#####################################################################
+class Table::Head
+   private
+   def refresh
+      @@head = nil
+   end
+end
+
+class TC_HTML_Table_Head < Test::Unit::TestCase
+   def setup
+      @t = Table.new
+      @th = Table::Head.create
+   end
+
+   def test_constructor
+      assert_nothing_raised{ Table::Head.create }
+      assert_nothing_raised{ Table::Head.create("foo") }
+      assert_nothing_raised{ Table::Head.create(1) }
+      assert_nothing_raised{ Table::Head.create(%w/foo bar baz/) }
+      assert_nothing_raised{ Table::Head.create([1,2,3]) }
+      assert_nothing_raised{ Table::Head.create([[1,2,3],["foo","bar"]]) }
+   end
+   
+   def test_basic
+      html = "<thead></thead>"
+      assert_equal(html,@th.html.gsub(/\s{2,}|\n/,''))
+   end
+
+   def test_end_tags
+      assert_respond_to(Table::Head, :end_tags?)
+      assert_respond_to(Table::Head, :end_tags=)
+      assert_nothing_raised{ Table::Head.end_tags? }
+      assert_nothing_raised{ Table::Head.end_tags = true }
+      assert_raises(StrongTyping::ArgumentTypeError){
+         Table::Head.end_tags = "foo"
+      }
+   end
+
+   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/,''))
+   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/,''))
+   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/,''))
+   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+/,''))
+   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+/,''))
+   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|
+         d.abbr = 'test'
+         d.width = 3
+         d.nowrap = true
+      }
+      assert_equal(html,@th.html.gsub(/\s{2,}|\n+/,''))
+   end
+   
+   def teardown
+      @t = nil
+      @th.send(:refresh)
+      @th = nil
+   end
+end