html-table 1.6.3 → 1.7.1

data/test/test_caption.rb

@@ -1,80 +0,0 @@
-################################################
-# test_caption.rb
-#
-# Test suite for the Table::Caption class
-################################################
-require 'test-unit'
-require 'html/table'
-include HTML
-
-class TC_HTML_Table_Caption < Test::Unit::TestCase
-  def setup
-    @table = Table.new
-    @tcaption = Table::Caption.new
-  end
-
-  def test_constructor
-    assert_nothing_raised{ Table::Caption.new }
-    assert_nothing_raised{ Table::Caption.new("foo") }
-    assert_nothing_raised{ Table::Caption.new(1) }
-    assert_nothing_raised{ Table::Caption.new(%w/foo bar baz/) }
-    assert_nothing_raised{ Table::Caption.new([1,2,3]) }
-    assert_nothing_raised{ Table::Caption.new([[1,2,3],["foo","bar"]]) }
-  end
-
-  def test_basic
-    html = "<caption></caption>"
-    assert_equal(html, @tcaption.html.gsub(/\s+/,''))
-  end
-
-  def test_with_attributes
-    html = "<caption align='left' valign='top'></caption>"
-    @tcaption.align = "left"
-    @tcaption.valign = "top"
-    assert_equal(html, @tcaption.html.gsub(/\s{2,}|\n+/,''))
-  end
-
-  def test_configure_not_allowed
-    assert_raises(NoMethodError){ @tcaption.configure }
-  end
-
-  def test_add_content
-    html = "<caption>hello world</caption>"
-    @tcaption.content = "hello world"
-    assert_equal(html,@tcaption.html.gsub(/\s{2,}/,''))
-  end
-
-  def test_add_multiple_content_items
-    html = "<caption>hello world</caption>"
-    @tcaption.content = "hello"," world"
-    assert_equal(html,@tcaption.html.gsub(/\s{2,}/,''))
-  end
-
-  def test_add_content_in_constructor
-    html = "<caption>hello world</caption>"
-    @tcaption = Table::Caption.new("hello world")
-    assert_equal(html, @tcaption.html.gsub(/\s{2,}/,''))
-  end
-
-  def test_indent_level
-    assert_respond_to(Table::Caption,:indent_level)
-    assert_respond_to(Table::Caption,:indent_level=)
-    assert_raises(ArgumentTypeError){ Table::Caption.indent_level = "foo" }
-    assert_nothing_raised{ Table::Caption.indent_level = 3 }
-  end
-
-  def test_only_row_zero_allowed
-    assert_raises(ArgumentError){ @table[1] = @tcaption }
-  end
-
-  def test_automatically_set_to_row_zero
-    @table.content = "hello","world"
-    @table.push(@tcaption)
-    assert_equal(true, @table[0].kind_of?(Table::Caption))
-  end
-
-  def teardown
-    @table = nil
-    @tcaption = nil
-  end
-end

data/test/test_col.rb

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

data/test/test_colgroup.rb

@@ -1,89 +0,0 @@
-############################################
-# test_colgroup.rb
-#
-# Test suite for the Table::ColGroup class
-############################################
-require 'test-unit'
-require 'html/table'
-include HTML
-
-class TC_HTML_Table_ColGroup < Test::Unit::TestCase
-   def setup
-      @cgroup = Table::ColGroup.new
-      @col = Table::ColGroup::Col.new
-   end
-
-   def test_constructor
-      assert_nothing_raised{ Table::ColGroup.new }
-      assert_nothing_raised{ Table::ColGroup.new(@col) }
-      assert_raises(TypeError){ Table::ColGroup.new("foo") }
-   end
-
-   def test_basic
-      html = "<colgroup></colgroup>"
-      assert_equal(html,@cgroup.html.gsub(/\s+/,''))
-   end
-
-   def test_with_attributes
-      html = "<colgroup align='center' width='20%'></colgroup>"
-      @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>"
-      @cgroup.push(@col)
-      assert_equal(html,@cgroup.html.gsub(/\s{2,}|\n+/,''))
-   end
-
-   def test_index_assignment_constraints
-      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){ @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){ @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){ @cgroup.configure(0,0){ } }
-   end
-
-   def test_content_error
-      assert_raises(NoMethodError){ @cgroup.content }
-      assert_raises(NoMethodError){ @cgroup.content = 'blah' }
-   end
-
-   def test_indent_level
-      assert_respond_to(Table::ColGroup,:indent_level)
-      assert_respond_to(Table::ColGroup,:indent_level=)
-      assert_raises(ArgumentTypeError){ Table::ColGroup.indent_level = "foo" }
-      assert_nothing_raised{ Table::ColGroup.indent_level = 6 }
-   end
-
-   def test_end_tags
-      assert_respond_to(Table::ColGroup,:end_tags?)
-      assert_respond_to(Table::ColGroup,:end_tags=)
-      assert_raises(ArgumentTypeError){ Table::ColGroup.end_tags = "foo" }
-      assert_raises(ArgumentTypeError){ Table::ColGroup.end_tags = 1 }
-      assert_nothing_raised{ Table::ColGroup.end_tags = true }
-   end
-
-   def teardown
-      @cgroup = nil
-   end
-end

data/test/test_data.rb

@@ -1,77 +0,0 @@
-##############################################
-# test_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
-      @tdata = 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,@tdata.html.gsub(/\s+/,''))
-   end
-
-   def test_with_attributes
-      html = "<td align='left' width=3 nowrap></td>"
-      @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){ @tdata.configure }
-   end
-
-   def test_add_content
-      html = "<td>hello world</td>"
-      @tdata.content = "hello world"
-      assert_equal(html,@tdata.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>"
-      @tdata.content = "hello"," world"
-      assert_equal(html,@tdata.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
-      @tdata = nil
-   end
-end

data/test/test_foot.rb

@@ -1,111 +0,0 @@
-###############################################################################
-# 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'
-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
-      @table = Table.new
-      @tfoot = 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, @tfoot.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 }
-   end
-
-   def test_end_tags_expected_errors
-      assert_raises(StrongTyping::ArgumentTypeError){
-         Table::Foot.end_tags = "foo"
-      }
-   end
-
-   def test_with_attributes
-      html = "<tfoot align='left' char='x'></tfoot>"
-      @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>"
-      @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"}
-      @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>"
-      @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>"
-      @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>"
-      @tfoot.content = "hello","world"
-      @tfoot.configure(0,1){ |data|
-         data.abbr   = 'test'
-         data.width  = 3
-         data.nowrap = true
-      }
-      assert_equal(html, @tfoot.html.gsub(/\s{2,}|\n+/,''))
-   end
-
-   def teardown
-      @table = nil
-      @tfoot.send(:refresh)
-      @tfoot = nil
-   end
-end

data/test/test_head.rb

@@ -1,104 +0,0 @@
-###############################################################################
-# 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'
-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
-      @table = Table.new
-      @thead = 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,@thead.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>"
-      @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>"
-      @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")
-      @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>"
-      @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>"
-      @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>"
-      @thead.content = "hello","world"
-      @thead.configure(0,1){ |d|
-         d.abbr = 'test'
-         d.width = 3
-         d.nowrap = true
-      }
-      assert_equal(html,@thead.html.gsub(/\s{2,}|\n+/,''))
-   end
-
-   def teardown
-      @table = nil
-      @thead.send(:refresh)
-      @thead = nil
-   end
-end

data/test/test_header.rb

@@ -1,77 +0,0 @@
-################################################
-# test_header.rb
-#
-# Test suite for the Table::Row::Header class
-################################################
-require 'test-unit'
-require 'html/table'
-include HTML
-
-class TC_HTML_Table_Row_Header < Test::Unit::TestCase
-   def setup
-      @theader = Table::Row::Header.new
-   end
-
-   def test_basic
-      html = "<th></th>"
-      assert_equal(html, @theader.html.gsub(/\s+/,''))
-   end
-
-   def test_constructor
-      assert_nothing_raised{ Table::Row::Header.new }
-      assert_nothing_raised{ Table::Row::Header.new("foo") }
-      assert_nothing_raised{ Table::Row::Header.new(1) }
-      assert_nothing_raised{ Table::Row::Header.new(%w/foo bar baz/) }
-      assert_nothing_raised{ Table::Row::Header.new([1,2,3]) }
-      assert_nothing_raised{ Table::Row::Header.new([[1,2,3],["foo","bar"]]) }
-   end
-
-   def test_with_attributes
-      html = "<th align='left' colspan=3 nowrap></th>"
-      @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){ @theader.configure }
-   end
-
-   def test_add_content
-      html = "<th>hello world</th>"
-      @theader.content = "hello world"
-      assert_equal(html, @theader.html.gsub(/\s{2,}/,''))
-   end
-
-   def test_add_multiple_content_items
-      html = "<th>hello world</th>"
-      @theader.content = "hello"," world"
-      assert_equal(html, @theader.html.gsub(/\s{2,}/,''))
-   end
-
-   def test_add_content_in_constructor
-      html = "<th>hello world</th>"
-      @theader = Table::Row::Header.new("hello world")
-      assert_equal(html, @theader.html.gsub(/\s{2,}/,''))
-   end
-
-   def test_indent_level
-      assert_respond_to(Table::Row::Header,:indent_level)
-      assert_respond_to(Table::Row::Header,:indent_level=)
-      assert_raises(ArgumentTypeError){ Table::Row::Header.indent_level = "foo" }
-      assert_nothing_raised{ Table::Row::Header.indent_level = 6 }
-   end
-
-   def test_end_tags
-      assert_respond_to(Table::Row::Header,:end_tags?)
-      assert_respond_to(Table::Row::Header,:end_tags=)
-      assert_raises(ArgumentTypeError){ Table::Row::Header.end_tags = "foo" }
-      assert_raises(ArgumentTypeError){ Table::Row::Header.end_tags = 1 }
-      assert_nothing_raised{ Table::Row::Header.end_tags = true }
-   end
-
-   def teardown
-      @theader = nil
-   end
-end

data/test/test_html_handler.rb

@@ -1,37 +0,0 @@
-############################################################################
-# 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 '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