html-table 1.2.2

data/lib/html/row.rb

@@ -0,0 +1,129 @@
+module HTML
+   class Table::Row < Array
+      include AttributeHandler
+      include HtmlHandler
+      @indent_level = 3
+      @end_tags     = true
+
+      # Returns a new Table::Row object.  Optionally takes a block.  If an
+      # argument is provided, it is treated as content.
+      #
+      # Note that, despite the name, Row is a subclass of Array, not Table.
+      def initialize(arg=nil)
+         @html_begin = '<tr'
+         @html_end   = '</tr>'
+         yield self if block_given?
+         self.content = arg if arg
+      end
+      
+      # Adds content to the Row object.
+      #
+      # Because a Row object doesn't store any of its own content, the
+      # arguments to this method must be a Row::Data object, a Row::Header
+      # object, or a String (or an array of any of these).  In the latter case,
+      # a single Row::Data object is created for each string.
+      def content=(arg)
+         if arg.kind_of?(String)
+            td = Table::Row::Data.new(arg)
+            self.push(td)
+         elsif arg.kind_of?(Array)
+            arg.each{ |e|
+               if e.kind_of?(Table::Row::Data) || e.kind_of?(Table::Row::Header)
+                  self.push(e)
+               else
+                  td = Table::Row::Data.new(e)
+                  self.push(td)
+               end
+            }
+         else
+            self.push(arg)
+         end
+      end
+
+      # Returns the number of spaces that tags for this class are indented.
+      # For the Row class, the indention level defaults to 3.
+      def self.indent_level
+         @indent_level
+      end
+
+      # Sets the number of spaces that tags for this class are indented.
+      def self.indent_level=(num)
+         expect(num,Integer)
+         raise ArgumentError if num < 0
+         @indent_level = num
+      end
+      
+      # Returns true or false, depending on whether or not the end tags for
+      # this class, </tr>, are included for each row or not. By default, this
+      # is set to true.
+      def self.end_tags?
+         @end_tags
+      end
+
+      # Sets the behavior for whether or not the end tags for this class,
+      # </tr>, are included for each row or not.  Only true and false are
+      # valid arguments.
+      def self.end_tags=(bool)
+         expect(bool,[TrueClass,FalseClass])
+         @end_tags = bool
+      end
+
+      # This method has been redefined to only allow certain classes to be
+      # accepted as arguments.  Specifically, they are Data and Header.  An
+      # Array is also valid, but only if it only includes Data or Header
+      # objects.
+      def []=(index,obj)
+         if obj.kind_of?(Array)
+            obj.each{ |o| expect(o,[Data,Header]) }
+         else   
+            expect(obj,[Data,Header])
+         end
+         super
+      end
+
+      # This method has been redefined to only allow certain classes to be
+      # accepted as arguments.  Specifically, they are String, Fixnum,
+      # Data and Header.
+      #
+      # A plain string or number pushed onto a Row is automatically
+      # converted to a Data object.
+      def push(*args)
+         args.each do |obj|
+            if obj.kind_of?(String) || obj.kind_of?(Fixnum)
+               td = Table::Row::Data.new(obj.to_s)
+               super(td)
+               next
+            else
+               expect(obj,[Data,Header])
+            end
+            super(obj)
+         end
+      end
+
+      # This method has been redefined to only allow certain classes to be
+      # accepted as arguments.  The rules are the same as they are for
+      # Row#push.
+      def <<(obj)
+         if obj.kind_of?(String) || obj.kind_of?(Fixnum)
+            td = Table::Row::Data.new(obj.to_s)
+            super(td)
+         else
+            expect(obj,[Data,Header])
+         end
+         super(obj)
+      end
+
+      # This method has been redefined to only allow certain classes to be
+      # accepted as arguments.  The rules are the same as they are for
+      # Row#push.
+      def unshift(obj)
+            if obj.kind_of?(String) || obj.kind_of?(Fixnum)
+            td = Table::Row::Data.new(obj.to_s)
+            super(td)
+         else
+            expect(obj,[Data,Header])
+         end
+         super(obj)
+      end
+   end
+end

data/lib/html/table.rb

@@ -0,0 +1,227 @@
+require "rbconfig"
+include Config
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "attribute_handler"
+require "html_handler"
+require "strongtyping"
+include StrongTyping
+
+module HTML
+   class Table < Array
+      include AttributeHandler
+      include HtmlHandler
+      VERSION           = "1.2.2"
+      @indent_level     = 0
+      @html_case        = "lower"
+      @@global_end_tags = true
+
+      # Returns a new Table object.  Optionally takes a block.
+      # If an argument is provided, it is interpreted as content.
+      def initialize(arg = nil)
+         @html_begin = '<table'
+         @html_body  = ''
+         @html_end   = '</table>'
+         yield self if block_given?
+         self.content = arg if arg
+      end
+      
+      # Adds content to the table.  How this method behaves depends on the
+      # type of argument being passed.  
+      #
+      # The +arg+ may be a Table::Row object, an Array of Table::Row objects,
+      # an Array of Array's, an Array of Strings, or a single String.  In the
+      # last two cases, a single Table::Row with a single Table::Row::Data
+      # object is created, with the string as the content.
+      def content=(arg)
+         if arg.kind_of?(Array)
+            arg.each{ |e|
+               tr = Table::Row.new(e)
+               self.push(tr)
+            }
+         else
+            tr = Table::Row.new(arg)
+            self.push(tr)
+         end
+      end
+
+      # Returns true or false, depending on whether or not end tags have been
+      # turned on or off, respectively.
+      def self.global_end_tags?
+         @@global_end_tags
+      end
+
+      # Sets the end tag class variable.  This is used to set whether or not
+      # to include optional end tags in the final HTML output.  The argument
+      # sent to this method must be true or false.  The default value is true.
+      #
+      # Note that mandatory end tags are unaffected by this setting.
+      def self.global_end_tags=(bool)
+         expect(bool,[TrueClass,FalseClass])
+         @@global_end_tags = bool
+      end
+      
+      # Returns either "lower" or "upper", indicating the case of all HTML
+      # tags in the final output.
+      def self.html_case
+         @html_case
+      end
+      
+      # Sets the case of all HTML tags to either lower or upper.  The only
+      # valid arguments to this method are 'upper' or 'lower'.
+      def self.html_case=(arg)
+         expect(arg,String)
+         arg.downcase!
+         unless arg == "upper" || arg == "lower"
+            msg = "Argument to html_case() must be 'upper' or 'lower'"
+            raise ArgumentError, msg
+         end
+         @html_case = arg
+      end
+
+      # Returns the number of spaces that tags for this class are indented.
+      # For the Table class, the indention level defaults to 0.
+      #
+      # Note that each class has its own default indentation level (a multiple
+      # of 3).
+      def self.indent_level
+         @indent_level
+      end
+
+      # Sets the number of spaces that tags for this class are indented.
+      def self.indent_level=(num)
+         expect(num,Integer)
+         raise ArgumentError,"indent level must be >= 0" if num < 0
+         @indent_level = num
+      end
+
+      # This method has been redefined to only allow certain subclasses to
+      # be assigned using a direct index notation.  Specifically, only
+      # Caption, ColGroup, Body, Foot, Head and Row objects may be use
+      # assigned using direct index notation.
+      #
+      # In addition, a Caption can only be assigned to index 0.  A Head can
+      # only be assigned to index 0, or index 1 if a Caption already exists.
+      # A Foot may only be assigned as the last element.
+      def []=(index,obj)
+         expect(obj,[Caption,ColGroup,Body,Foot,Head,Row])
+
+         # Only allow Caption objects at index 0
+         if index != 0 && obj.kind_of?(HTML::Table::Caption)
+            msg = "CAPTION can only be added at index 0"
+            raise ArgumentError, msg
+         end
+
+         # Only allow Head objects at index 0 or 1
+         if obj.kind_of?(HTML::Table::Head)
+            if self[0].kind_of?(HTML::Table::Caption) && index != 1
+                msg = "THEAD must be at index 1 when Caption is included"
+                raise ArgumentError, msg
+            end
+            if !self[0].kind_of?(HTML::Table::Caption) && index != 0
+               msg = "THEAD must be at index 0 when no Caption is included"
+               raise ArgumentError, msg
+            end
+         end
+
+         if obj.kind_of?(HTML::Table::Foot) && index != -1
+            msg = "FOOT must be last element"
+            raise ArgumentError, msg
+         end
+         super
+      end
+      
+      # This method has been redefined to only allow certain subclasses to
+      # be accepted as arguments.  Specifically, only Caption, ColGroup,
+      # Body, Foot, Head, Row and Row::Data objects may be pushed onto a
+      # Table.
+      #
+      # Pushing a Data or Header object onto a Table object creates its own
+      # row for each.  If a Caption object is pushed onto the Table, it will
+      # automatically be bumped to the first element.  If a Head object is
+      # pushed onto the Table, it is automatically bumped to the first
+      # element, or the second element if a Caption already exists.
+      def push(*args)
+         args.each{ |obj|
+            expect(obj,[Caption,ColGroup,Body,Foot,Head,Row,Row::Data])
+
+            # Pushing Data or Header objects onto a Table directly gives them
+            # each their own row.
+            if obj.kind_of?(HTML::Table::Row::Data)
+               tr = HTML::Table::Row.new(obj)
+               self.push(tr)           
+            # Caption objects are always the first row   
+            elsif obj.kind_of?(HTML::Table::Caption)
+               if self[0].kind_of?(HTML::Table::Caption)
+                  self[0] = obj
+               else
+                  self.unshift(obj)
+               end
+            # Head objects are always at row 0 or 1   
+            elsif obj.kind_of?(HTML::Table::Head)
+               if self[0].kind_of?(HTML::Table::Caption)
+                  self.unshift(obj)
+                  self[0],self[1] = self[1],self[0]
+               else
+                  self.unshift(obj)
+               end
+            else
+               super(obj)
+            end
+         }
+      end
+
+      # This method has been redefined to only allow certain subclasses to
+      # be accepted as arguments.
+      #
+      # The restrictions and behavior are identical to the push() method.
+      def <<(obj)
+         expect(obj,[Caption,ColGroup,Body,Foot,Head,Row,Row::Data])
+
+         # Pushing Data or Header objects onto a Table directly gives them
+         # each their own row.
+         if obj.kind_of?(HTML::Table::Row::Data)
+            tr = HTML::Table::Row.new(obj)
+            self.push(tr)
+         # Caption objects are always the first row   
+         elsif obj.kind_of?(HTML::Table::Caption)
+            if self[0].kind_of?(HTML::Table::Caption)
+               self[0] = obj
+            else
+               self.unshift(obj)
+            end
+         # Head objects are always at row 0 or 1   
+         elsif obj.kind_of?(HTML::Table::Head)
+            if self[0].kind_of?(HTML::Table::Caption)
+               self.unshift(obj)
+               self[0],self[1] = self[1],self[0]
+            else
+               self.unshift(obj)
+            end
+         else
+            super(obj)
+         end
+      end
+
+      # This method has been redefined to only allow certain subclasses to
+      # be unshifted onto a Table object.  Specifically, they are Caption,
+      # ColGroup, Body, Foot, Head and Row.
+      def unshift(obj)
+         expect(obj,[Caption,ColGroup,Body,Foot,Head,Row])
+         super
+      end
+
+   end
+end
+
+require "caption"
+require "colgroup"
+require "col"
+require "row"
+require "header"
+require "data"
+require "tablesection"
+require "head"
+require "foot"
+require "body"

data/lib/html/tablesection.rb

@@ -0,0 +1,42 @@
+module HTML
+   # Superclass for THEAD, TBODY, TFOOT
+   class Table::TableSection < Array
+      include AttributeHandler
+      include HtmlHandler
+      def initialize
+         yield self 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)
+      end
+
+      def self.indent_level
+         @indent_level
+      end
+
+      def self.indent_level=(num)
+         expect(num,Integer)
+         raise ArgumentError,"indent_level must be >= 0" if num < 0
+         @indent_level = num
+      end
+
+      def []=(index,obj)
+         expect(obj,Table::Row)
+         super
+      end
+
+      def push(*args)
+         args.each{ |obj| expect(obj,Table::Row) }
+         super
+      end
+
+      def unshift(obj)
+         expect(obj,Table::Row)
+         super
+      end
+   end
+end

data/lib/html/tag_handler.rb

@@ -0,0 +1,64 @@
+###################################################################
+# 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.
+###################################################################
+module Tag_Handler
+
+   def bold=(bool)
+      handle_physical_tag('b',bool)
+   end
+   
+   def big=(bool)
+      handle_physical_tag('big',bool)
+   end
+   
+   def blink=(bool)
+      if $VERBOSE
+         STDERR.puts("The 'blink' tag is very annoying.  Please reconsider.")
+      end
+      handle_physical_tag('blink',bool)
+   end
+   
+   def italic=(bool)
+      handle_physical_tag('i',bool)
+   end
+   
+   def strike=(bool)
+      handle_physical_tag('strike',bool)
+   end
+   
+   def sub=(bool)
+      handle_physical_tag('sub',bool)
+   end
+   
+   def sup=(bool)
+      handle_physical_tag('sup',bool)
+   end
+   
+   def tt=(bool)
+      handle_physical_tag('tt',bool)
+   end
+   
+   def underline=(bool)
+      handle_physical_tag('u',bool)
+   end
+
+   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
+      else
+         @html_body.gsub!(/#{begin_tag}|#{end_tag}/,'')
+      end
+      @html_body
+   end
+  
+end