html-table 1.3.1 → 1.3.2

data/lib/html/html_handler.rb

@@ -1,120 +1,120 @@
-module HtmlHandler
-
-   $upper = false
-   
-   # Used on HTML attributes. It creates proper HTML text based on the argument
-   # type.  A string looks like "attr='text'", a number looks like "attr=1",
-   # while a true value simply looks like "attr" (no equal sign).
-   #--
-   # This is private method.
-   #
-   def modify_html(attribute,arg=nil)
-      if @html_begin.scan(/\b#{attribute}\b/).empty?
-         if arg.kind_of?(Fixnum)
-            @html_begin << " #{attribute}=#{arg}"
-         elsif arg.kind_of?(TrueClass)
-            @html_begin << " #{attribute}"
-         else
-            @html_begin << " #{attribute}='#{arg}'"
-         end
-      else
-         if arg.kind_of?(Fixnum)
-            @html_begin.gsub!(/#{attribute}=\d+/,"#{attribute}=#{arg}")
-         elsif arg.kind_of?(FalseClass)
-            @html_begin.gsub!(/#{attribute}/,'')
-         else
-            @html_begin.gsub!(/#{attribute}=['\w\.]+/,"#{attribute}='#{arg}'")
-         end
-      end
-   end
-
-   # Returns the HTML text for the current object.  Indentation and end tag
-   # options are optional, based on the settings of the classes themselves.
-   #
-   # If +formatting+ is false, then formatting and whitespace is not applied
-   # and you will get a single, very long string.  Note that case is still
-   # honored.
-   #
-   def html(formatting = true)
-      if self.class.respond_to?(:html_case)
-         $upper = true if self.class.html_case == "upper"
-      end
-      
-      if $upper
-         @html_begin.upcase!
-         @html_end.upcase!
-      end
-      
-      ilevel = 0
-      
-      if formatting && self.class.respond_to?(:indent_level)
-         ilevel = self.class.indent_level
-      end
-
-      html          = ' ' * ilevel + @html_begin[0..-1]
-      len           = html.length
-      html[len,len] = '>'
-
-      if self.kind_of?(Array)
-         if formatting
-            html << self.map{ |e| "\n" + e.html(formatting).to_s }.join
-         else
-            html << self.map{ |e| e.html(formatting).to_s }.join
-         end
-      else
-         html << @html_body
-      end
-
-      #####################################################################
-      # Add end tags, or not, depending on whether the class supports the
-      # end_tags class method.  Those that don't have an end_tags class
-      # method necessarily means that the end tag must be included.
-      #
-      # The Table.global_end_tags method overrides the individual class
-      # preferences with regards to end tags.
-      #####################################################################
-      if self.kind_of?(Array)
-         if HTML::Table.global_end_tags?
-            if self.class.respond_to?(:end_tags?)
-               if formatting
-                  if self.class.end_tags?
-                     html << "\n" + (' ' * ilevel) + @html_end
-                  end
-               else
-                  html << (' ' * ilevel) + @html_end if self.class.end_tags?
-               end
-            else
-               if formatting
-                  html << "\n" + (' ' * ilevel) + @html_end
-               else
-                  html << (' ' * ilevel) + @html_end
-               end
-            end
-         else
-            unless self.class.respond_to?(:end_tags?)
-               if formatting
-                  html << "\n" + (' ' * ilevel) + @html_end
-               else
-                  html << (' ' * ilevel) + @html_end
-               end
-            end
-         end
-      else
-         if HTML::Table.global_end_tags?
-            if self.class.respond_to?(:end_tags?)
-               html << @html_end if self.class.end_tags?
-            else
-               html << @html_end
-            end
-         else
-            unless self.class.respond_to?(:end_tags?)
-               html << @html_end
-            end
-         end
-      end
-
-      return html
-   end
-   
-   private :modify_html
-end
+module HtmlHandler
+
+   $upper = false
+   
+   # Used on HTML attributes. It creates proper HTML text based on the argument
+   # type.  A string looks like "attr='text'", a number looks like "attr=1",
+   # while a true value simply looks like "attr" (no equal sign).
+   #--
+   # This is private method.
+   #
+   def modify_html(attribute,arg=nil)
+      if @html_begin.scan(/\b#{attribute}\b/).empty?
+         if arg.kind_of?(Fixnum)
+            @html_begin << " #{attribute}=#{arg}"
+         elsif arg.kind_of?(TrueClass)
+            @html_begin << " #{attribute}"
+         else
+            @html_begin << " #{attribute}='#{arg}'"
+         end
+      else
+         if arg.kind_of?(Fixnum)
+            @html_begin.gsub!(/#{attribute}=\d+/,"#{attribute}=#{arg}")
+         elsif arg.kind_of?(FalseClass)
+            @html_begin.gsub!(/#{attribute}/,'')
+         else
+            @html_begin.gsub!(/#{attribute}=['\w\.]+/,"#{attribute}='#{arg}'")
+         end
+      end
+   end
+
+   # Returns the HTML text for the current object.  Indentation and end tag
+   # options are optional, based on the settings of the classes themselves.
+   #
+   # If +formatting+ is false, then formatting and whitespace is not applied
+   # and you will get a single, very long string.  Note that case is still
+   # honored.
+   #
+   def html(formatting = true)
+      if self.class.respond_to?(:html_case)
+         $upper = true if self.class.html_case == "upper"
+      end
+      
+      if $upper
+         @html_begin.upcase!
+         @html_end.upcase!
+      end
+      
+      ilevel = 0
+      
+      if formatting && self.class.respond_to?(:indent_level)
+         ilevel = self.class.indent_level
+      end
+
+      html          = ' ' * ilevel + @html_begin[0..-1]
+      len           = html.length
+      html[len,len] = '>'
+
+      if self.kind_of?(Array)
+         if formatting
+            html << self.map{ |e| "\n" + e.html(formatting).to_s }.join
+         else
+            html << self.map{ |e| e.html(formatting).to_s }.join
+         end
+      else
+         html << @html_body
+      end
+
+      #####################################################################
+      # Add end tags, or not, depending on whether the class supports the
+      # end_tags class method.  Those that don't have an end_tags class
+      # method necessarily means that the end tag must be included.
+      #
+      # The Table.global_end_tags method overrides the individual class
+      # preferences with regards to end tags.
+      #####################################################################
+      if self.kind_of?(Array)
+         if HTML::Table.global_end_tags?
+            if self.class.respond_to?(:end_tags?)
+               if formatting
+                  if self.class.end_tags?
+                     html << "\n" + (' ' * ilevel) + @html_end
+                  end
+               else
+                  html << (' ' * ilevel) + @html_end if self.class.end_tags?
+               end
+            else
+               if formatting
+                  html << "\n" + (' ' * ilevel) + @html_end
+               else
+                  html << (' ' * ilevel) + @html_end
+               end
+            end
+         else
+            unless self.class.respond_to?(:end_tags?)
+               if formatting
+                  html << "\n" + (' ' * ilevel) + @html_end
+               else
+                  html << (' ' * ilevel) + @html_end
+               end
+            end
+         end
+      else
+         if HTML::Table.global_end_tags?
+            if self.class.respond_to?(:end_tags?)
+               html << @html_end if self.class.end_tags?
+            else
+               html << @html_end
+            end
+         else
+            unless self.class.respond_to?(:end_tags?)
+               html << @html_end
+            end
+         end
+      end
+
+      return html
+   end
+   
+   private :modify_html
+end

data/lib/html/row.rb

@@ -1,185 +1,188 @@
-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 +arg+
-      # is provided it is treated as content.  If +header+ is false, that
-      # content is transformed into a Row::Data object.  Otherwise, it is
-      # converted into a Row::Header object.
-      #
-      # See the # Table::Row#content= method for more information.
-      #--
-      # Note that, despite the name, Row is a subclass of Array, not Table.
-      #
-      def initialize(arg = nil, header = false, &block)
-         @html_begin = '<tr'
-         @html_end   = '</tr>'
-
-         @header = header
-
-         instance_eval(&block) if block_given?
-         self.content = arg if arg
-      end
-
-      # Returns whether or not content is converted into a Row::Header object
-      # (as opposed to a Row::Data object).
-      #
-      def header?
-         @header
-      end
-
-      # Sets whether or not content is converted into a Row::Header object
-      # or a Row::Data object.
-      #
-      def header=(bool)
-         @header = bool
-      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.
-      #
-      # Examples (with whitespace and newlines removed):
-      #
-      # row = Table::Row.new
-      #
-      # # Same as Table::Row.new('foo')
-      # row.content = 'foo'
-      # row.html => <tr><td>foo</td></tr>
-      #
-      # row.content = [['foo,'bar']]
-      # row.html => <tr><td>foo</td><td>bar</td></tr>
-      #
-      # row.content = Table::Row::Data.new('foo')
-      # row.html => <tr><td>foo</td></tr>
-      #
-      # row.content = Table::Row::Header.new('foo')
-      # row.html => <tr><th>foo</th></tr>
-      #
-      def content=(arg)
-         case arg
-            when String
-               if @header
-                  self.push(Table::Row::Header.new(arg))
-               else
-                  self.push(Table::Row::Data.new(arg))
-               end
-            when Array
-               arg.each{ |e|
-                  if e.kind_of?(Table::Row::Data) || e.kind_of?(Table::Row::Header)
-                     self.push(e)
-                  else
-                     if @header
-                        self.push(Table::Row::Header.new(e))
-                     else
-                        self.push(Table::Row::Data.new(e))
-                     end
-                  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
+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 +arg+
+      # is provided it is treated as content.  If +header+ is false, that
+      # content is transformed into a Row::Data object.  Otherwise, it is
+      # converted into a Row::Header object.
+      #
+      # See the # Table::Row#content= method for more information.
+      #--
+      # Note that, despite the name, Row is a subclass of Array, not Table.
+      #
+      def initialize(arg = nil, header = false, &block)
+         @html_begin = '<tr'
+         @html_end   = '</tr>'
+
+         @header = header
+
+         instance_eval(&block) if block_given?
+         self.content = arg if arg
+      end
+
+      # Returns whether or not content is converted into a Row::Header object
+      # (as opposed to a Row::Data object).
+      #
+      def header?
+         @header
+      end
+
+      # Sets whether or not content is converted into a Row::Header object
+      # or a Row::Data object.
+      #
+      def header=(bool)
+         @header = bool
+      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.
+      #
+      # Examples (with whitespace and newlines removed):
+      #
+      # row = Table::Row.new
+      #
+      # # Same as Table::Row.new('foo')
+      # row.content = 'foo'
+      # row.html => <tr><td>foo</td></tr>
+      #
+      # row.content = [['foo,'bar']]
+      # row.html => <tr><td>foo</td><td>bar</td></tr>
+      #
+      # row.content = Table::Row::Data.new('foo')
+      # row.html => <tr><td>foo</td></tr>
+      #
+      # row.content = Table::Row::Header.new('foo')
+      # row.html => <tr><th>foo</th></tr>
+      #
+      def content=(arg)
+         case arg
+            when String
+               if @header
+                  self.push(Table::Row::Header.new(arg))
+               else
+                  self.push(Table::Row::Data.new(arg))
+               end
+            when Array
+               arg.each{ |e|
+                  if e.kind_of?(Table::Row::Data) || e.kind_of?(Table::Row::Header)
+                     self.push(e)
+                  else
+                     if @header
+                        self.push(Table::Row::Header.new(e))
+                     else
+                        self.push(Table::Row::Data.new(e))
+                     end
+                  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
+
+      alias to_s html
+      alias to_str html
+   end
+end