html-table 1.6.3 → 1.7.1

data/lib/html/mixin/html_handler.rb

@@ -1,31 +1,33 @@
+# The HTML module serves as a namespace only.
 module HTML
+  # The Mixin module is a namespace for html-table mixins.
   module Mixin
+    # The HtmlHandler module is the library for generating html output.
     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",
+      # 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)
+      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}'"
+          case arg
+            when Integer
+              @html_begin << " #{attribute}=#{arg}"
+            when 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}'")
+          case arg
+            when Integer
+              @html_begin.gsub!(/#{attribute}=\d+/, "#{attribute}=#{arg}")
+            when FalseClass
+              @html_begin.gsub!(/#{attribute}/, '')
+            else
+              @html_begin.gsub!(/#{attribute}=['\w.]+/, "#{attribute}='#{arg}'")
           end
         end
       end
@@ -38,11 +40,7 @@ module HTML
       # honored.
       #
       def html(formatting = true)
-        if self.class.respond_to?(:html_case)
-          $upper = true if self.class.html_case == "upper"
-        end
-
-        if $upper
+        if HTML::Table.html_case == 'upper'
           @html_begin.upcase!
           @html_end.upcase!
         end
@@ -53,15 +51,15 @@ module HTML
           ilevel = self.class.indent_level
         end
 
-        html          = ' ' * ilevel + @html_begin[0..-1]
+        html          = (' ' * ilevel) + @html_begin[0..]
         len           = html.length
-        html[len,len] = '>'
+        html[len, len] = '>'
 
-        if self.kind_of?(Array)
+        if is_a?(Array)
           if formatting
-            html << self.map{ |e| "\n" + e.html(formatting).to_s }.join
+            html << map { |e| "\n#{e.html(formatting)}" }.join
           else
-            html << self.map{ |e| e.html(formatting).to_s }.join
+            html << map { |e| e.html(formatting).to_s }.join
           end
         else
           html << @html_body
@@ -75,29 +73,29 @@ module HTML
         # The Table.global_end_tags method overrides the individual class
         # preferences with regards to end tags.
         #####################################################################
-        if self.kind_of?(Array)
+        if is_a?(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
+                  html << ("\n" << (' ' * ilevel) << @html_end)
                 end
               else
-                html << (' ' * ilevel) + @html_end if self.class.end_tags?
+                html << ((' ' * ilevel) << @html_end) if self.class.end_tags?
               end
             else
               if formatting
-                html << "\n" + (' ' * ilevel) + @html_end
+                html << ("\n" << (' ' * ilevel) << @html_end)
               else
-                html << (' ' * ilevel) + @html_end
+                html << ((' ' * ilevel) << @html_end)
               end
             end
           else
             unless self.class.respond_to?(:end_tags?)
               if formatting
-                html << "\n" + (' ' * ilevel) + @html_end
+                html << ("\n" << (' ' * ilevel) << @html_end)
               else
-                html << (' ' * ilevel) + @html_end
+                html << ((' ' * ilevel) << @html_end)
               end
             end
           end
@@ -115,7 +113,7 @@ module HTML
           end
         end
 
-        return html
+        html
       end
 
       private :modify_html

data/lib/html/mixin/strongtyping.rb

@@ -1,16 +1,16 @@
-# A pure-ruby replacement for strongtyping gem
-
+# The HTML module serves as a namespace only.
 module HTML
+  # The Mixin module serves as a namespace only to prevent collisions.
   module Mixin
+    # The StrongTyping module is a pure Ruby replacement for the strongtyping gem.
     module StrongTyping
-      class ArgumentTypeError < ArgumentError; end
-
       def expect(arg, allowed_types)
         return true if Array(allowed_types).any? do |klass|
-          arg.kind_of?(klass)
+          arg.is_a?(klass)
         end
 
-        raise ArgumentTypeError.new("#{arg} must be of type #{allowed_types}")
+        # Defined in table.rb
+        raise ArgumentTypeError, "#{arg} must be of type #{allowed_types}"
       end
     end
   end

data/lib/html/mixin/tag_handler.rb

@@ -5,8 +5,12 @@
 # Only used for Table::Content objects, which are in turn used by
 # Table::Row::Data, Table::Row::Header and Table::Caption.
 ###################################################################
+
+# The HTML module serves as a namespace only.
 module HTML
+  # The Mixin module serves as a namespace only.
   module Mixin
+    # The TagHandler module implements handling for standard html physical tags.
     module TagHandler
       def bold(bool = nil)
         @bold ||= nil
@@ -115,9 +119,9 @@ module HTML
         end_tag = "</#{tag}>"
 
         if bool
-          self.replace(begin_tag << self << end_tag)
+          replace(begin_tag << self << end_tag)
         else
-          self.replace(self.gsub(/#{begin_tag}|#{end_tag}/,''))
+          replace(gsub(/#{begin_tag}|#{end_tag}/, ''))
         end
       end
     end

data/lib/html/row.rb

@@ -1,188 +1,161 @@
+# The HTML module is a namespace only.
 module HTML
-   class Table::Row < Array
-      include HTML::Mixin::AttributeHandler
-      include HTML::Mixin::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
+  # The Table::Row class is a subclass of array that encapsulates an
+  # html table row, i.e. <tr> element.
+  class Table::Row < Array
+    include HTML::Mixin::AttributeHandler
+    include HTML::Mixin::HtmlHandler
+    include HTML::Mixin::StrongTyping
+    extend HTML::Mixin::StrongTyping
+
+    @indent_level = 3
+    @end_tags     = true
+
+    # Gets and sets whether or not content is converted into a Row::Header
+    # object or a Row::Data object.
+    attr_accessor :header
+
+    # 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
+
+    # 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)
+      Array(arg).each do |e|
+        push_content(e)
       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
+
+    # 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, "Indent level must be non-negative" 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)
+      objs = obj.is_a?(Array) ? obj : [obj]
+      objs.each { |o| expect(o, [Data, Header]) }
+      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 { |obj| super(convert_content(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 <<(obj)
+      super(convert_content(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)
+      super(convert_content(obj))
+    end
+
+    alias to_s html
+    alias to_str html
+
+    private
+
+    def push_content(e)
+      if e.is_a?(Table::Row::Data) || e.is_a?(Table::Row::Header)
+        push(e)
+      else
+        push(@header ? Table::Row::Header.new(e) : Table::Row::Data.new(e))
       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
+
+    def convert_content(obj)
+      if obj.is_a?(String) || obj.is_a?(Integer)
+        Table::Row::Data.new(obj.to_s)
+      else
+        expect(obj, [Data, Header])
+        obj
       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
+  end
 end