html-table 1.5.0 → 1.5.1

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?(Integer)
+        @html_begin << " #{attribute}=#{arg}"
+      elsif arg.kind_of?(TrueClass)
+        @html_begin << " #{attribute}"
+      else
+        @html_begin << " #{attribute}='#{arg}'"
+      end
+    else
+      if arg.kind_of?(Integer)
+        @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,188 +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
-
-      alias to_s html
-      alias to_str html
-   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, Integer,
+      # 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?(Integer)
+               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?(Integer)
+            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?(Integer)
+            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