html-table 1.6.3 → 1.7.0

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

data/test/test_row.rb

@@ -1,141 +0,0 @@
-############################################
-# test_row.rb
-#
-# Test suite for the Table::Row class
-############################################
-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/test_table.rb

@@ -1,159 +0,0 @@
-#######################################################################
-# test_table.rb
-#
-# Test suite for the HTML::Table class. This test case should be run
-# via the 'rake test' task.
-#######################################################################
-require 'test-unit'
-require 'html/table'
-require 'strongtyping'
-include StrongTyping
-include HTML
-
-class TC_HTML_Table < Test::Unit::TestCase
-  def setup
-    @table = Table.new
-  end
-
-  def test_version
-    assert_equal('1.6.3', Table::VERSION)
-    assert_true(Table::VERSION.frozen?)
-  end
-
-  def test_constructor
-    assert_nothing_raised{ Table.new }
-    assert_nothing_raised{ Table.new('foo') }
-    assert_nothing_raised{ Table.new(1) }
-    assert_nothing_raised{ Table.new(%w/foo bar baz/) }
-    assert_nothing_raised{ Table.new([1,2,3]) }
-    assert_nothing_raised{ Table.new([[1,2,3],['foo','bar']]) }
-  end
-
-  def test_constructor_with_attributes
-    assert_nothing_raised{ Table.new(%w[foo bar baz], :border => 1) }
-  end
-
-  def test_html_case
-    assert_respond_to(Table, :html_case)
-    assert_respond_to(Table, :html_case=)
-    assert_nothing_raised{ Table.html_case = 'upper' }
-    assert_nothing_raised{ Table.html_case = 'lower' }
-    assert_raises(ArgumentError){ Table.html_case = 'foo' }
-    assert_raises(ArgumentTypeError){ Table.html_case = 7 }
-  end
-
-  def test_indent_level
-    assert_respond_to(Table, :indent_level)
-    assert_respond_to(Table, :indent_level=)
-    assert_nothing_raised{ Table.indent_level = 0 }
-    assert_raises(ArgumentTypeError){ Table.indent_level = 'foo' }
-  end
-
-  def test_index
-    assert_raises(ArgumentTypeError){ @table[0] = 'foo' }
-  end
-
-  def test_caption_index_constraints
-    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{ @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{
-      @table[0] = Table::Caption.new
-      @table[-1] = Table::Foot.create
-    }
-    assert_raises(ArgumentError){ @table[0] = Table::Foot.create }
-  end
-
-  def test_unshift_constraints
-    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{ @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{ @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, @table.html)
-  end
-
-  def test_with_attributes
-    html = "<table border=1 align='left' nowrap>\n</table>"
-    @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>'
-    @table.push(Table::Row.new)
-    assert_equal(html, @table.html.gsub(/\s+/,''))
-  end
-
-  def test_add_row_by_index
-    html = '<table><tr></tr></table>'
-    @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>'
-    @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>'
-    @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>'
-    @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>'
-    @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
-    assert_respond_to(Table,:global_end_tags?)
-    assert_respond_to(Table,:global_end_tags=)
-    assert_nothing_raised{ Table.global_end_tags = false }
-    assert_nothing_raised{ Table.global_end_tags = true }
-    assert_raises(ArgumentTypeError){ Table.global_end_tags = 'foo' }
-  end
-
-  def teardown
-    @table = nil
-  end
-end