html-table 1.2.2

data/test/tc_attribute_handler.rb

@@ -0,0 +1,259 @@
+############################################################################
+# tc_attribute_handler.rb
+#
+# Test suite for the AttributeHandler module. For these tests, we'll use an
+# instance of the Table class where the module has been mixed in.
+############################################################################
+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_AttributeHandler < Test::Unit::TestCase
+   def setup
+      @t = Table.new(["foo",1,"bar"])
+   end
+   
+   def test_abbr
+      assert_respond_to(@t,:abbr)
+      assert_respond_to(@t,:abbr=)
+      assert_nothing_raised{ @t.abbr }
+      assert_nothing_raised{ @t.abbr="foo" }
+   end
+   
+   def test_align
+      assert_respond_to(@t,:align)
+      assert_respond_to(@t,:align=)
+      assert_nothing_raised{ @t.align }
+      assert_nothing_raised{ @t.align = "center" }
+      assert_raises(ArgumentError){ @t.align = "foo" }
+   end
+   
+   def test_axis
+      assert_respond_to(@t,:axis)
+      assert_respond_to(@t,:axis=)
+      assert_nothing_raised{ @t.axis }
+      assert_nothing_raised{ @t.axis="foo" }
+   end
+   
+   def test_background
+      assert_respond_to(@t,:background)
+      assert_respond_to(@t,:background=)
+      assert_nothing_raised{ @t.background }
+      assert_nothing_raised{ @t.background="foo" }
+      assert_raises(TypeError){ @t.background = 1 }
+   end
+   
+   def test_bgcolor
+      assert_respond_to(@t,:bgcolor)
+      assert_respond_to(@t,:bgcolor=)
+      assert_nothing_raised{ @t.bgcolor }
+      assert_nothing_raised{ @t.bgcolor="foo" }
+   end
+   
+   def test_border
+      assert_respond_to(@t,:border)
+      assert_respond_to(@t,:border=)
+      assert_nothing_raised{ @t.border }
+      assert_nothing_raised{ @t.border = 2 }
+      assert_nothing_raised{ @t.border = true }
+      assert_nothing_raised{ @t.border = false }
+   end
+   
+   def test_bordercolor
+      assert_respond_to(@t,:bordercolor)
+      assert_respond_to(@t,:bordercolor=)
+      assert_nothing_raised{ @t.bordercolor }
+      assert_nothing_raised{ @t.bordercolor="foo" }
+   end
+   
+   def test_bordercolordark
+      assert_respond_to(@t,:bordercolordark)
+      assert_respond_to(@t,:bordercolordark=)
+      assert_nothing_raised{ @t.bordercolordark }
+      assert_nothing_raised{ @t.bordercolordark="foo" }
+   end
+   
+   def test_bordercolorlight
+      assert_respond_to(@t,:bordercolorlight)
+      assert_respond_to(@t,:bordercolorlight=)
+      assert_nothing_raised{ @t.bordercolorlight }
+      assert_nothing_raised{ @t.bordercolorlight="foo" }
+   end
+   
+   def test_cellpadding
+      assert_respond_to(@t,:cellpadding)
+      assert_respond_to(@t,:cellpadding=)
+      assert_nothing_raised{ @t.cellpadding }
+      assert_nothing_raised{ @t.cellpadding=1 }
+      assert_raises(ArgumentError){ @t.cellpadding = -1 }
+   end  
+   
+   def test_cellspacing
+      assert_respond_to(@t,:cellspacing)
+      assert_respond_to(@t,:cellspacing=)
+      assert_nothing_raised{ @t.cellspacing }
+      assert_nothing_raised{ @t.cellspacing=1 }
+      assert_raises(ArgumentError){ @t.cellspacing = -1 }
+   end
+   
+   def test_char
+      assert_respond_to(@t,:char)
+      assert_respond_to(@t,:char=)
+      assert_nothing_raised{ @t.char }
+      assert_nothing_raised{ @t.char="x" }
+      assert_raises(ArgumentError){ @t.char = "xx" }
+   end
+   
+   def test_charoff
+      assert_respond_to(@t,:charoff)
+      assert_respond_to(@t,:charoff=)
+      assert_nothing_raised{ @t.charoff }
+      assert_nothing_raised{ @t.charoff=1 }
+      assert_raises(ArgumentError){ @t.charoff = -1 }
+   end
+   
+   def test_col
+      assert_respond_to(@t,:col)
+      assert_respond_to(@t,:col=)
+      assert_nothing_raised{ @t.col }
+      assert_nothing_raised{ @t.col=1 }
+      assert_raises(ArgumentError){ @t.col = -1 }
+   end
+   
+   def test_colspan
+      assert_respond_to(@t,:colspan)
+      assert_respond_to(@t,:colspan=)
+      assert_nothing_raised{ @t.colspan }
+      assert_nothing_raised{ @t.colspan=1 }
+      assert_raises(ArgumentError){ @t.colspan = -1 }
+   end
+   
+   def test_configure
+      assert_respond_to(@t,:configure)
+      assert_nothing_raised{ @t.configure(0){} }
+      assert_nothing_raised{ @t.configure(0,0){} }
+      assert_raises(ArgumentError){ @t.configure(0,0,0){} }
+   end
+   
+   ########################################################################
+   # This test could probably be broken out into separate tests for each
+   # type that we want to add as content.
+   ########################################################################
+   def test_content
+      assert_respond_to(@t,:content)
+      assert_respond_to(@t,:content=)
+      assert_nothing_raised{ @t.content = "foo" }
+      assert_nothing_raised{ @t.content = 123 }
+      assert_nothing_raised{ @t.content = ["one",2,"three"] }
+      assert_nothing_raised{ @t.content = [["foo","bar"],[1,2,3]] }
+      assert_nothing_raised{ @t.content = Table::Row.new }
+      assert_nothing_raised{ @t.content = Table::Row::Data.new }
+      assert_nothing_raised{ @t.content = Table::Row::Header.new }
+      assert_nothing_raised{ @t.content = Table::Head.create }
+      assert_nothing_raised{ @t.content = Table::Foot.create }
+      assert_nothing_raised{ @t.content = Table::Body.new }
+   end
+   
+   def test_frame
+      assert_respond_to(@t,:frame)
+      assert_respond_to(@t,:frame=)
+      assert_nothing_raised{ @t.frame }
+      assert_nothing_raised{ @t.frame="below" }
+      assert_raises(ArgumentError){ @t.frame = "foo" }
+   end
+   
+   def test_height
+      assert_respond_to(@t,:height)
+      assert_respond_to(@t,:height=)
+      assert_nothing_raised{ @t.height }
+      assert_nothing_raised{ @t.height=1 }
+      assert_raises(ArgumentError){ @t.height = -1 }
+   end
+   
+   def test_hspace
+      assert_respond_to(@t,:hspace)
+      assert_respond_to(@t,:hspace=)
+      assert_nothing_raised{ @t.hspace }
+      assert_nothing_raised{ @t.hspace=1 }
+      assert_raises(ArgumentError){ @t.hspace = -1 }
+   end
+   
+   def test_nowrap
+      assert_respond_to(@t,:nowrap)
+      assert_respond_to(@t,:nowrap=)
+      assert_nothing_raised{ @t.nowrap }
+      assert_nothing_raised{ @t.nowrap=false }
+      assert_raises(TypeError){ @t.nowrap = "foo" }
+   end
+   
+   def test_rowspan
+      assert_respond_to(@t,:rowspan)
+      assert_respond_to(@t,:rowspan=)
+      assert_nothing_raised{ @t.rowspan }
+      assert_nothing_raised{ @t.rowspan=1 }
+      assert_raises(ArgumentError){ @t.rowspan = -1 }
+   end
+   
+   def test_rules
+      assert_respond_to(@t,:rules)
+      assert_respond_to(@t,:rules=)
+      assert_nothing_raised{ @t.rules}
+      assert_nothing_raised{ @t.rules="all" }
+      assert_raises(ArgumentError){ @t.rules = "foo" }
+   end
+   
+   def test_span
+      assert_respond_to(@t,:span)
+      assert_respond_to(@t,:span=)
+      assert_nothing_raised{ @t.span }
+      assert_nothing_raised{ @t.span=1 }
+      assert_raises(ArgumentError){ @t.span = -1 }
+   end
+   
+   def test_summary
+      assert_respond_to(@t,:summary)
+      assert_respond_to(@t,:summary=)
+      assert_nothing_raised{ @t.summary }
+      assert_nothing_raised{ @t.summary="foo" }
+      assert_nothing_raised{ @t.summary=1 }
+   end
+   
+   def test_valign
+      assert_respond_to(@t,:valign)
+      assert_respond_to(@t,:valign=)
+      assert_nothing_raised{ @t.valign }
+      assert_nothing_raised{ @t.valign="center" }
+      assert_raises(ArgumentError){ @t.valign="foo" }
+   end
+   
+   def test_vspace
+      assert_respond_to(@t,:vspace)
+      assert_respond_to(@t,:vspace=)
+      assert_nothing_raised{ @t.vspace }
+      assert_nothing_raised{ @t.vspace=1 }
+      assert_raises(ArgumentError){ @t.vspace = -1 }
+   end
+   
+   def test_width
+      assert_respond_to(@t,:width)
+      assert_respond_to(@t,:width=)
+      assert_nothing_raised{ @t.width}
+      assert_nothing_raised{ @t.width = 10 }
+      assert_nothing_raised{ @t.width = "5%" }
+      assert_raises(ArgumentError){ @t.width = -1 }
+   end
+   
+   def teardown
+      @t = nil
+   end
+end

data/test/tc_body.rb

@@ -0,0 +1,97 @@
+############################################
+# tc_body.rb
+#
+# Test suite for the Table::Body 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_Body < Test::Unit::TestCase
+   def setup
+      @t = Table.new
+      @tb = Table::Body.new
+   end
+
+   def test_constructor
+      assert_nothing_raised{ Table::Body.new }
+      assert_nothing_raised{ Table::Body.new("foo") }
+      assert_nothing_raised{ Table::Body.new(1) }
+      assert_nothing_raised{ Table::Body.new(%w/foo bar baz/) }
+      assert_nothing_raised{ Table::Body.new([1,2,3]) }
+      assert_nothing_raised{ Table::Body.new([[1,2,3],["foo","bar"]]) }
+   end
+   
+   def test_basic
+      html = "<tbody></tbody>"
+      assert_equal(html,@tb.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/,''))
+   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/,''))
+   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/,''))
+   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+/,''))
+   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+/,''))
+   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
+      }
+      assert_equal(html,@tb.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_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
+   end
+end

data/test/tc_caption.rb

@@ -0,0 +1,90 @@
+################################################
+# tc_caption.rb
+#
+# Test suite for the Table::Caption 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_Caption < Test::Unit::TestCase
+   def setup
+      @t = Table.new
+      @tc = 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,@tc.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+/,''))
+   end
+   
+   def test_configure_not_allowed
+      assert_raises(NoMethodError){ @tc.configure }
+   end
+   
+   def test_add_content
+      html = "<caption>hello world</caption>"
+      @tc.content = "hello world"
+      assert_equal(html,@tc.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,}/,''))
+   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,}/,''))
+   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
+      assert_raises(ArgumentError){ @t[1] = @tc }
+   end
+   
+   def test_automatically_set_to_row_zero
+      @t.content = "hello","world"
+      @t.push(@tc)
+      assert_equal(true,@t[0].kind_of?(Table::Caption))
+   end
+   
+   def teardown
+      @t = nil
+      @tc = nil
+   end
+end

data/test/tc_col.rb

@@ -0,0 +1,50 @@
+##################################################
+# tc_col.rb
+#
+# Test suite for the Table::ColGroup::Col 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_Col < Test::Unit::TestCase
+   def setup
+      @c = Table::ColGroup::Col.new
+      @cg = Table::ColGroup.new
+   end
+
+   def test_basic
+      html = "<col>"
+      assert_equal(html,@c.html.gsub(/\s{2,}|\n+/,''))
+   end
+
+   def test_no_configure
+      assert_raises(NoMethodError){ @c.configure }
+   end
+   
+   def test_no_content_allowed
+      assert_raises(NoMethodError){ @c.content }
+      assert_raises(NoMethodError){ @c.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
+      @c = nil
+   end
+end