html-table 1.2.2 → 1.3.0

data/lib/html/tablesection.rb

@@ -1,14 +1,17 @@
 module HTML
    # Superclass for THEAD, TBODY, TFOOT
+   #
    class Table::TableSection < Array
       include AttributeHandler
       include HtmlHandler
-      def initialize
-         yield self if block_given?
+
+      def initialize(&block)
+         instance_eval(&block) if block_given?
       end
 
       # Adds a Table::Row object as content. The +arg+ is passed as the value
       # to the Table::Row constructor.
+      #
       def content=(arg)
          tr = Table::Row.new(arg)
          self.push(tr)
@@ -19,8 +22,8 @@ module HTML
       end
 
       def self.indent_level=(num)
-         expect(num,Integer)
-         raise ArgumentError,"indent_level must be >= 0" if num < 0
+         expect(num, Integer)
+         raise ArgumentError, "indent_level must be >= 0" if num < 0
          @indent_level = num
       end
 

data/lib/html/tag_handler.rb

@@ -2,63 +2,113 @@
 # tag_handler.rb
 #
 # Module for handling standard html physical tags (<b>, <i>, etc).
-# Only used for Table objects that contain text content.  That
-# means Table::Row::Data, Table::Row::Header and Table::Caption.
+# Only used for Table::Content objects, which are in turn used by 
+# Table::Row::Data, Table::Row::Header and Table::Caption.
 ###################################################################
-module Tag_Handler
+module TagHandler
+   def bold(bool = nil)
+      self.bold = bool if bool
+      @bold
+   end
 
    def bold=(bool)
-      handle_physical_tag('b',bool)
+      handle_physical_tag('b', bool)
+      @bold = bool
+   end
+
+   def big(bool = nil)
+      self.big = bool if bool
+      @big
    end
    
    def big=(bool)
-      handle_physical_tag('big',bool)
+      handle_physical_tag('big', bool)
+      @big = bool
+   end
+
+   def blink(bool = nil)
+      self.blink = bool if bool
+      @blink
    end
    
    def blink=(bool)
       if $VERBOSE
          STDERR.puts("The 'blink' tag is very annoying.  Please reconsider.")
       end
-      handle_physical_tag('blink',bool)
+      handle_physical_tag('blink', bool)
+      @blink = bool
+   end
+
+   def italic(bool = nil)
+      self.italic = bool if bool
+      @italic
    end
    
    def italic=(bool)
-      handle_physical_tag('i',bool)
+      handle_physical_tag('i', bool)
+      @italic = bool
+   end
+
+   def strike(bool = nil)
+      self.strike = bool if bool
+      @strike
    end
    
    def strike=(bool)
-      handle_physical_tag('strike',bool)
+      handle_physical_tag('strike', bool)
+      @strike = bool
+   end
+
+   def sub(bool = nil)
+      self.sub = bool if bool
+      @sub
    end
    
    def sub=(bool)
-      handle_physical_tag('sub',bool)
+      handle_physical_tag('sub', bool)
+      @sub = bool
+   end
+
+   def sup(bool = nil)
+      self.sup = bool if bool
+      @sup
    end
    
    def sup=(bool)
-      handle_physical_tag('sup',bool)
+      handle_physical_tag('sup', bool)
+      @sup = bool
+   end
+
+   def tt(bool = nil)
+      self.tt = bool if bool
+      @tt
    end
    
    def tt=(bool)
-      handle_physical_tag('tt',bool)
+      handle_physical_tag('tt', bool)
+      @tt = bool
+   end
+
+   def underline(bool = nil)
+      self.underline = bool if bool
+      @bool
    end
    
    def underline=(bool)
-      handle_physical_tag('u',bool)
+      handle_physical_tag('u', bool)
+      @bool = bool
    end
 
-   def handle_physical_tag(tag,bool)
+   private
+
+   def handle_physical_tag(tag, bool)
       begin_tag = "<#{tag}>"
       end_tag = "</#{tag}>"
-      unless bool == true || bool == false
-         msg = "Invalid tag value: #{bool}"
-         raise ArgumentError, msg
-      end
-      if bool == true
-         @html_body = begin_tag + @html_body + end_tag
+
+      if bool
+         self.replace(begin_tag << self << end_tag)
       else
-         @html_body.gsub!(/#{begin_tag}|#{end_tag}/,'')
+         self.replace(self.gsub(/#{begin_tag}|#{end_tag}/,''))
       end
-      @html_body
    end
-  
-end
+end

data/test/tc_attribute_handler.rb

@@ -6,143 +6,150 @@
 ############################################################################
 base = File.basename(Dir.pwd)
 
-if base == "test" || base =~ /html-table/
-   Dir.chdir("..") if base == "test"
+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
+   $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"
+require 'test/unit'
+require 'html/table'
 include HTML
 
 class TC_AttributeHandler < Test::Unit::TestCase
    def setup
-      @t = Table.new(["foo",1,"bar"])
+      @table = 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" }
+      assert_respond_to(@table, :abbr)
+      assert_respond_to(@table, :abbr=)
+      assert_nothing_raised{ @table.abbr }
+      assert_nothing_raised{ @table.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" }
+      assert_respond_to(@table, :align)
+      assert_respond_to(@table, :align=)
+      assert_nothing_raised{ @table.align }
+      assert_nothing_raised{ @table.align = 'center' }
+      assert_raises(ArgumentError){ @table.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" }
+      assert_respond_to(@table, :axis)
+      assert_respond_to(@table, :axis=)
+      assert_nothing_raised{ @table.axis }
+      assert_nothing_raised{ @table.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 }
+      assert_respond_to(@table, :background)
+      assert_respond_to(@table, :background=)
+      assert_nothing_raised{ @table.background }
+      assert_nothing_raised{ @table.background = 'foo' }
+      assert_raises(TypeError){ @table.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" }
+      assert_respond_to(@table, :bgcolor)
+      assert_respond_to(@table, :bgcolor=)
+      assert_nothing_raised{ @table.bgcolor }
+      assert_nothing_raised{ @table.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 }
+      assert_respond_to(@table, :border)
+      assert_respond_to(@table, :border=)
+      assert_nothing_raised{ @table.border }
+      assert_nothing_raised{ @table.border = 2 }
+      assert_nothing_raised{ @table.border = true }
+      assert_nothing_raised{ @table.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" }
+      assert_respond_to(@table, :bordercolor)
+      assert_respond_to(@table, :bordercolor=)
+      assert_nothing_raised{ @table.bordercolor }
+      assert_nothing_raised{ @table.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" }
+      assert_respond_to(@table, :bordercolordark)
+      assert_respond_to(@table, :bordercolordark=)
+      assert_nothing_raised{ @table.bordercolordark }
+      assert_nothing_raised{ @table.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" }
+      assert_respond_to(@table, :bordercolorlight)
+      assert_respond_to(@table, :bordercolorlight=)
+      assert_nothing_raised{ @table.bordercolorlight }
+      assert_nothing_raised{ @table.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 }
+      assert_respond_to(@table, :cellpadding)
+      assert_respond_to(@table, :cellpadding=)
+      assert_nothing_raised{ @table.cellpadding }
+      assert_nothing_raised{ @table.cellpadding = 1 }
+      assert_raises(ArgumentError){ @table.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 }
+      assert_respond_to(@table, :cellspacing)
+      assert_respond_to(@table, :cellspacing=)
+      assert_nothing_raised{ @table.cellspacing }
+      assert_nothing_raised{ @table.cellspacing = 1 }
+      assert_raises(ArgumentError){ @table.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" }
+      assert_respond_to(@table, :char)
+      assert_respond_to(@table, :char=)
+      assert_nothing_raised{ @table.char }
+      assert_nothing_raised{ @table.char = 'x' }
+      assert_raises(ArgumentError){ @table.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 }
+      assert_respond_to(@table, :charoff)
+      assert_respond_to(@table, :charoff=)
+      assert_nothing_raised{ @table.charoff }
+      assert_nothing_raised{ @table.charoff = 1 }
+      assert_raises(ArgumentError){ @table.charoff = -1 }
+   end
+
+   def test_class
+      assert_respond_to(@table, :class_)
+      assert_respond_to(@table, :class_=)
+      assert_nothing_raised{ @table.class_ }
+      assert_nothing_raised{ @table.class_ = 'myclass' }
    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 }
+      assert_respond_to(@table, :col)
+      assert_respond_to(@table, :col=)
+      assert_nothing_raised{ @table.col }
+      assert_nothing_raised{ @table.col = 1 }
+      assert_raises(ArgumentError){ @table.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 }
+      assert_respond_to(@table, :colspan)
+      assert_respond_to(@table, :colspan=)
+      assert_nothing_raised{ @table.colspan }
+      assert_nothing_raised{ @table.colspan = 1 }
+      assert_raises(ArgumentError){ @table.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){} }
+      assert_respond_to(@table, :configure)
+      assert_nothing_raised{ @table.configure(0){} }
+      assert_nothing_raised{ @table.configure(0,0){} }
+      assert_raises(ArgumentError){ @table.configure(0,0,0){} }
    end
    
    ########################################################################
@@ -150,110 +157,117 @@ class TC_AttributeHandler < Test::Unit::TestCase
    # 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 }
+      assert_respond_to(@table, :content)
+      assert_respond_to(@table, :content=)
+      assert_nothing_raised{ @table.content = 'foo' }
+      assert_nothing_raised{ @table.content = 123 }
+      assert_nothing_raised{ @table.content = ['one',2,'three'] }
+      assert_nothing_raised{ @table.content = [['foo','bar'],[1,2,3]] }
+      assert_nothing_raised{ @table.content = Table::Row.new }
+      assert_nothing_raised{ @table.content = Table::Row::Data.new }
+      assert_nothing_raised{ @table.content = Table::Row::Header.new }
+      assert_nothing_raised{ @table.content = Table::Head.create }
+      assert_nothing_raised{ @table.content = Table::Foot.create }
+      assert_nothing_raised{ @table.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" }
+      assert_respond_to(@table, :frame)
+      assert_respond_to(@table, :frame=)
+      assert_nothing_raised{ @table.frame }
+      assert_nothing_raised{ @table.frame = 'below' }
+      assert_raises(ArgumentError){ @table.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 }
+      assert_respond_to(@table, :height)
+      assert_respond_to(@table, :height=)
+      assert_nothing_raised{ @table.height }
+      assert_nothing_raised{ @table.height = 1 }
+      assert_raises(ArgumentError){ @table.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 }
+      assert_respond_to(@table, :hspace)
+      assert_respond_to(@table, :hspace=)
+      assert_nothing_raised{ @table.hspace }
+      assert_nothing_raised{ @table.hspace = 1 }
+      assert_raises(ArgumentError){ @table.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" }
+      assert_respond_to(@table, :nowrap)
+      assert_respond_to(@table, :nowrap=)
+      assert_nothing_raised{ @table.nowrap }
+      assert_nothing_raised{ @table.nowrap = false }
+      assert_raises(TypeError){ @table.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 }
+      assert_respond_to(@table, :rowspan)
+      assert_respond_to(@table, :rowspan=)
+      assert_nothing_raised{ @table.rowspan }
+      assert_nothing_raised{ @table.rowspan = 1 }
+      assert_raises(ArgumentError){ @table.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" }
+      assert_respond_to(@table, :rules)
+      assert_respond_to(@table, :rules=)
+      assert_nothing_raised{ @table.rules }
+      assert_nothing_raised{ @table.rules = 'all' }
+      assert_raises(ArgumentError){ @table.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 }
+      assert_respond_to(@table, :span)
+      assert_respond_to(@table, :span=)
+      assert_nothing_raised{ @table.span }
+      assert_nothing_raised{ @table.span = 1 }
+      assert_raises(ArgumentError){ @table.span = -1 }
+   end
+
+   def test_style
+      assert_respond_to(@table, :style)
+      assert_respond_to(@table, :style=)
+      assert_nothing_raised{ @table.style }
+      assert_nothing_raised{ @table.style = 'color: blue' }
    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 }
+      assert_respond_to(@table, :summary)
+      assert_respond_to(@table, :summary=)
+      assert_nothing_raised{ @table.summary }
+      assert_nothing_raised{ @table.summary = 'foo' }
+      assert_nothing_raised{ @table.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" }
+      assert_respond_to(@table, :valign)
+      assert_respond_to(@table, :valign=)
+      assert_nothing_raised{ @table.valign }
+      assert_nothing_raised{ @table.valign = 'center' }
+      assert_raises(ArgumentError){ @table.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 }
+      assert_respond_to(@table, :vspace)
+      assert_respond_to(@table, :vspace=)
+      assert_nothing_raised{ @table.vspace }
+      assert_nothing_raised{ @table.vspace = 1 }
+      assert_raises(ArgumentError){ @table.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 }
+      assert_respond_to(@table, :width)
+      assert_respond_to(@table, :width=)
+      assert_nothing_raised{ @table.width}
+      assert_nothing_raised{ @table.width = 10 }
+      assert_nothing_raised{ @table.width = '5%' }
+      assert_raises(ArgumentError){ @table.width = -1 }
    end
    
    def teardown
-      @t = nil
+      @table = nil
    end
 end