html-table 1.6.3 → 1.7.1

data/lib/html/table.rb

@@ -2,7 +2,6 @@ require_relative 'mixin/attribute_handler'
 require_relative 'mixin/html_handler'
 require_relative 'mixin/strongtyping'
 require 'structured_warnings'
-include HTML::Mixin::StrongTyping
 
 # Warning raised if a non-standard extension is used.
 class NonStandardExtensionWarning < StructuredWarnings::StandardWarning; end
@@ -10,6 +9,9 @@ class NonStandardExtensionWarning < StructuredWarnings::StandardWarning; end
 # Please, think of the children before using the blink tag.
 class BlinkWarning < StructuredWarnings::StandardWarning; end
 
+# Used by the strongtyping mixin.
+class ArgumentTypeError < ArgumentError; end
+
 # The HTML module serves as a namespace only.
 module HTML
 
@@ -18,9 +20,11 @@ module HTML
   class Table < Array
     include HTML::Mixin::AttributeHandler
     include HTML::Mixin::HtmlHandler
+    include HTML::Mixin::StrongTyping
+    extend HTML::Mixin::StrongTyping
 
     # The version of the html-table library
-    VERSION = '1.6.3'.freeze
+    VERSION = '1.7.1'.freeze
 
     # The indentation level for the <table> and </table> tags
     @indent_level = 0
@@ -29,7 +33,7 @@ module HTML
     @html_case = 'lower'
 
     # Determines whether or not end tags will be included in printed output
-    @@global_end_tags = true
+    @global_end_tags = true
 
     # Returns a new Table object. Optionally takes a block which is
     # eval'd if provided. If an argument is provided it is interpreted as
@@ -94,9 +98,9 @@ module HTML
       self.content = arg if arg
 
       # Assume html_options are attributes
-      html_options.each{ |key, val|
-        self.send("#{key}=", val)
-      }
+      html_options.each do |key, val|
+        send("#{key}=", val)
+      end
     end
 
     # Adds content to the table. How this method behaves depends on the
@@ -108,8 +112,8 @@ module HTML
     # object is created, with the string as the content.
     #
     def content=(arg)
-      if arg.kind_of?(Array)
-        arg.each{ |e| self << Table::Row.new(e) }
+      if arg.is_a?(Array)
+        arg.each { |e| self << Table::Row.new(e) }
       else
         self << Table::Row.new(arg)
       end
@@ -128,8 +132,8 @@ module HTML
     # object.
     #
     def header=(arg)
-      if arg.kind_of?(Array)
-        arg.each{ |h| self << Table::Row.new(h, true) }
+      if arg.is_a?(Array)
+        arg.each { |h| self << Table::Row.new(h, true) }
       else
         self << Table::Row::Header.new(arg)
       end
@@ -139,18 +143,18 @@ module HTML
     # turned on or off, respectively.
     #
     def self.global_end_tags?
-      @@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.
+    # 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
+      @global_end_tags = bool
     end
 
     # Returns either "lower" or "upper", indicating the case of all HTML
@@ -160,13 +164,13 @@ module HTML
       @html_case
     end
 
-    # Sets the case of all HTML tags to either lower or upper.  The only
+    # 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"
+      unless %w[upper lower].include?(arg)
         msg = "Argument to html_case() must be 'upper' or 'lower'"
         raise ArgumentError, msg
       end
@@ -187,7 +191,7 @@ module HTML
     #
     def self.indent_level=(num)
       expect(num, Integer)
-      raise ArgumentError, "indent level must be >= 0" if num < 0
+      raise ArgumentError, 'indent level must be >= 0' if num < 0
       @indent_level = num
     end
 
@@ -200,30 +204,30 @@ module HTML
     # 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)
+    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"
+      if index != 0 && obj.is_a?(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"
+      if obj.is_a?(HTML::Table::Head)
+        if self[0].is_a?(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"
+        if !self[0].is_a?(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"
+      if obj.is_a?(HTML::Table::Foot) && index != -1
+        msg = 'FOOT must be last element'
         raise ArgumentError, msg
       end
 
@@ -242,29 +246,27 @@ module HTML
     # element, or the second element if a Caption already exists.
     #
     def push(*args)
-      args.each{ |obj|
+      args.each do |obj|
         expect(obj, [Caption, ColGroup, Body, Foot, Head, Row, Row::Data, Row::Header])
 
         case obj
           when Table::Row::Data, Table::Row::Header
-            self.push(Table::Row.new(obj))
+            push(Table::Row.new(obj))
           when Table::Caption
-            if self[0].kind_of?(Table::Caption)
+            if self[0].is_a?(Table::Caption)
               self[0] = obj
             else
-              self.unshift(obj)
+              unshift(obj)
             end
           when Table::Head
-            if self[0].kind_of?(Table::Caption)
-              self.unshift(obj)
-              self[0],self[1] = self[1],self[0]
-            else
-              self.unshift(obj)
+            unshift(obj)
+            if self[0].is_a?(Table::Caption)
+              self[0], self[1] = self[1], self[0]
             end
           else
             super(obj)
         end
-      }
+      end
     end
 
     # This method has been redefined to only allow certain subclasses to
@@ -279,20 +281,18 @@ module HTML
         when Table::Row::Data, Table::Row::Header # Each get their own row
           self << Table::Row.new(obj)
         when Table::Caption                       # Always the first row
-          if self[0].kind_of?(Table::Caption)
+          if self[0].is_a?(Table::Caption)
             self[0] = obj
           else
-            self.unshift(obj)
+            unshift(obj)
           end
         when Table::Head                          # Always at row 0 or 1
-          if self[0].kind_of?(Table::Caption)
-            self.unshift(obj)
+          unshift(obj)
+          if self[0].is_a?(Table::Caption)
             self[0], self[1] = self[1], self[0]
-          else
-            self.unshift(obj)
           end
         else
-          super(obj)
+          super
       end
     end
 

data/lib/html/tablesection.rb

@@ -1,48 +1,53 @@
+# The HTML module serves as a namespace only.
 module HTML
-   # Superclass for THEAD, TBODY, TFOOT
-   #
-   class Table::TableSection < Array
-      include HTML::Mixin::AttributeHandler
-      include HTML::Mixin::HtmlHandler
-
-      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)
-      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
-
-      alias to_s html
-      alias to_str html
-   end
+
+  # Superclass for THEAD, TBODY, TFOOT
+  #
+  class Table::TableSection < Array
+    include HTML::Mixin::AttributeHandler
+    include HTML::Mixin::HtmlHandler
+    include HTML::Mixin::StrongTyping
+    extend HTML::Mixin::StrongTyping
+
+    def initialize(&block)
+      super
+      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)
+      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
+
+    alias to_s html
+    alias to_str html
+  end
 end

data/spec/attribute_handler_spec.rb

@@ -0,0 +1,374 @@
+############################################################################
+# attribute_handler_spec.rb
+#
+# Test suite for the AttributeHandler module. For these tests, we'll use an
+# instance of the Table class where the module has been mixed in.
+############################################################################
+require 'rspec'
+require 'html/table'
+
+RSpec.describe HTML::Mixin::AttributeHandler do
+  before(:all) do
+    NonStandardExtensionWarning.disable
+  end
+
+  before do
+    @table = HTML::Table.new(['foo', 1, 'bar'])
+  end
+
+  after(:all) do
+    NonStandardExtensionWarning.enable
+  end
+
+  example 'abbr_basic' do
+    expect(@table).to respond_to(:abbr)
+    expect(@table).to respond_to(:abbr=)
+  end
+
+  example 'abbr' do
+    expect{ @table.abbr }.not_to raise_error
+    expect(@table.abbr).to be_nil
+    expect{ @table.abbr = 'foo' }.not_to raise_error
+    expect(@table.abbr).to eq('foo')
+  end
+
+  example 'align_basic' do
+    expect(@table).to respond_to(:align)
+    expect(@table).to respond_to(:align=)
+  end
+
+  example 'align' do
+    expect{ @table.align }.not_to raise_error
+    expect(@table.align).to be_nil
+    expect{ @table.align = 'center' }.not_to raise_error
+    expect(@table.align).to eq('center')
+  end
+
+  example 'align_expected_errors' do
+    expect{ @table.align = 'foo' }.to raise_error(ArgumentError)
+  end
+
+  example 'axis' do
+    expect(@table).to respond_to(:axis)
+    expect(@table).to respond_to(:axis=)
+    expect{ @table.axis }.not_to raise_error
+    expect{ @table.axis = 'foo' }.not_to raise_error
+  end
+
+  example 'background_basic' do
+    expect(@table).to respond_to(:background)
+    expect(@table).to respond_to(:background=)
+  end
+
+  example 'background' do
+    expect{ @table.background }.not_to raise_error
+    expect(@table.background).to be_nil
+    expect{ @table.background = 'foo' }.not_to raise_error
+    expect(@table.background).to eq('foo')
+  end
+
+  example 'background_expected_errors' do
+    expect{ @table.background = 1 }.to raise_error(TypeError)
+  end
+
+  example 'bgcolor_basic' do
+    expect(@table).to respond_to(:bgcolor)
+    expect(@table).to respond_to(:bgcolor=)
+  end
+
+  example 'bgcolor' do
+    expect{ @table.bgcolor }.not_to raise_error
+    expect(@table.bgcolor).to be_nil
+    expect{ @table.bgcolor = 'foo' }.not_to raise_error
+    expect(@table.bgcolor).to eq('foo')
+  end
+
+  example 'border_basic' do
+    expect(@table).to respond_to(:border)
+    expect(@table).to respond_to(:border=)
+  end
+
+  example 'border' do
+    expect{ @table.border }.not_to raise_error
+    expect{ @table.border = 2 }.not_to raise_error
+    expect{ @table.border = true }.not_to raise_error
+    expect{ @table.border = false }.not_to raise_error
+  end
+
+  example 'bordercolor_basic' do
+    expect(@table).to respond_to(:bordercolor)
+    expect(@table).to respond_to(:bordercolor=)
+  end
+
+  example 'bordercolor' do
+    expect{ @table.bordercolor }.not_to raise_error
+    expect(@table.bordercolor).to be_nil
+    expect{ @table.bordercolor = 'foo' }.not_to raise_error
+    expect(@table.bordercolor).to eq('foo')
+  end
+
+  example 'bordercolordark_basic' do
+    expect(@table).to respond_to(:bordercolordark)
+    expect(@table).to respond_to(:bordercolordark=)
+  end
+
+  example 'bordercolordark' do
+    expect{ @table.bordercolordark }.not_to raise_error
+    expect(@table.bordercolordark).to be_nil
+    expect{ @table.bordercolordark = 'foo' }.not_to raise_error
+    expect(@table.bordercolordark).to eq('foo')
+  end
+
+  example 'bordercolorlight' do
+    expect(@table).to respond_to(:bordercolorlight)
+    expect(@table).to respond_to(:bordercolorlight=)
+    expect{ @table.bordercolorlight }.not_to raise_error
+    expect{ @table.bordercolorlight = 'foo' }.not_to raise_error
+  end
+
+  example 'cellpadding' do
+    expect(@table).to respond_to(:cellpadding)
+    expect(@table).to respond_to(:cellpadding=)
+    expect{ @table.cellpadding }.not_to raise_error
+    expect{ @table.cellpadding = 1 }.not_to raise_error
+  end
+
+  example 'cellpadding_expected_errors' do
+    expect{ @table.cellpadding = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'cellspacing' do
+    expect(@table).to respond_to(:cellspacing)
+    expect(@table).to respond_to(:cellspacing=)
+    expect{ @table.cellspacing }.not_to raise_error
+    expect{ @table.cellspacing = 1 }.not_to raise_error
+  end
+
+  example 'cellspacing_expected_errors' do
+    expect{ @table.cellspacing = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'char' do
+    expect(@table).to respond_to(:char)
+    expect(@table).to respond_to(:char=)
+    expect{ @table.char }.not_to raise_error
+    expect{ @table.char = 'x' }.not_to raise_error
+  end
+
+  example 'char_expected_errors' do
+    expect{ @table.char = 'xx' }.to raise_error(ArgumentError)
+  end
+
+  example 'charoff' do
+    expect(@table).to respond_to(:charoff)
+    expect(@table).to respond_to(:charoff=)
+    expect{ @table.charoff }.not_to raise_error
+    expect{ @table.charoff = 1 }.not_to raise_error
+  end
+
+  example 'charoff_expected_errors' do
+    expect{ @table.charoff = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'class' do
+    expect(@table).to respond_to(:class_)
+    expect(@table).to respond_to(:class_=)
+    expect{ @table.class_ }.not_to raise_error
+    expect{ @table.class_ = 'myclass' }.not_to raise_error
+  end
+
+  example 'col' do
+    expect(@table).to respond_to(:col)
+    expect(@table).to respond_to(:col=)
+    expect{ @table.col }.not_to raise_error
+    expect{ @table.col = 1 }.not_to raise_error
+  end
+
+  example 'col_expected_errors' do
+    expect{ @table.col = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'colspan' do
+    expect(@table).to respond_to(:colspan)
+    expect(@table).to respond_to(:colspan=)
+    expect{ @table.colspan }.not_to raise_error
+    expect{ @table.colspan = 1 }.not_to raise_error
+  end
+
+  example 'colspan_expected_errors' do
+    expect{ @table.colspan = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'configure' do
+    expect(@table).to respond_to(:configure)
+    expect{ @table.configure(0){} }.not_to raise_error
+    expect{ @table.configure(0, 0){} }.not_to raise_error
+  end
+
+  example 'configure_expected_errors' do
+    expect{ @table.configure(0, 0, 0){} }.to raise_error(ArgumentError)
+  end
+
+  example 'content' do
+    expect(@table).to respond_to(:content)
+    expect(@table).to respond_to(:content=)
+  end
+
+  example 'content= with string' do
+    expect{ @table.content = 'foo' }.not_to raise_error
+  end
+
+  example 'content= with numeric' do
+    expect{ @table.content = 123 }.not_to raise_error
+  end
+
+  example 'content= with array' do
+    expect{ @table.content = ['one', 2, 'three'] }.not_to raise_error
+    expect{ @table.content = [%w[foo bar], [1, 2, 3]] }.not_to raise_error
+  end
+
+  example 'content= with explicit row types' do
+    expect{ @table.content = HTML::Table::Row.new }.not_to raise_error
+    expect{ @table.content = HTML::Table::Row::Data.new }.not_to raise_error
+    expect{ @table.content = HTML::Table::Row::Header.new }.not_to raise_error
+  end
+
+  example 'content= with other table types' do
+    expect{ @table.content = HTML::Table::Head.create }.not_to raise_error
+    expect{ @table.content = HTML::Table::Foot.create }.not_to raise_error
+    expect{ @table.content = HTML::Table::Body.new }.not_to raise_error
+  end
+
+  example 'frame' do
+    expect(@table).to respond_to(:frame)
+    expect(@table).to respond_to(:frame=)
+    expect{ @table.frame }.not_to raise_error
+    expect{ @table.frame = 'below' }.not_to raise_error
+  end
+
+  example 'frame_expected_errors' do
+    expect{ @table.frame = 'foo' }.to raise_error(ArgumentError)
+  end
+
+  example 'height' do
+    expect(@table).to respond_to(:height)
+    expect(@table).to respond_to(:height=)
+    expect{ @table.height }.not_to raise_error
+    expect{ @table.height = 1 }.not_to raise_error
+  end
+
+  example 'height_expected_errors' do
+    expect{ @table.height = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'hspace' do
+    expect(@table).to respond_to(:hspace)
+    expect(@table).to respond_to(:hspace=)
+    expect{ @table.hspace }.not_to raise_error
+    expect{ @table.hspace = 1 }.not_to raise_error
+  end
+
+  example 'hspace_expected_errors' do
+    expect{ @table.hspace = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'nowrap' do
+    expect(@table).to respond_to(:nowrap)
+    expect(@table).to respond_to(:nowrap=)
+    expect{ @table.nowrap }.not_to raise_error
+    expect{ @table.nowrap = false }.not_to raise_error
+  end
+
+  example 'nowrap_expected_errors' do
+    expect{ @table.nowrap = 'foo' }.to raise_error(TypeError)
+  end
+
+  example 'rowspan' do
+    expect(@table).to respond_to(:rowspan)
+    expect(@table).to respond_to(:rowspan=)
+    expect{ @table.rowspan }.not_to raise_error
+    expect{ @table.rowspan = 1 }.not_to raise_error
+  end
+
+  example 'rowspan_expected_errors' do
+    expect{ @table.rowspan = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'rules' do
+    expect(@table).to respond_to(:rules)
+    expect(@table).to respond_to(:rules=)
+    expect{ @table.rules }.not_to raise_error
+    expect{ @table.rules = 'all' }.not_to raise_error
+  end
+
+  example 'rules_expected_errors' do
+    expect{ @table.rules = 'foo' }.to raise_error(ArgumentError)
+  end
+
+  example 'span' do
+    expect(@table).to respond_to(:span)
+    expect(@table).to respond_to(:span=)
+    expect{ @table.span }.not_to raise_error
+    expect{ @table.span = 1 }.not_to raise_error
+  end
+
+  example 'span_expected_errors' do
+    expect{ @table.span = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'style' do
+    expect(@table).to respond_to(:style)
+    expect(@table).to respond_to(:style=)
+    expect{ @table.style }.not_to raise_error
+    expect{ @table.style = 'color: blue' }.not_to raise_error
+  end
+
+  example 'summary' do
+    expect(@table).to respond_to(:summary)
+    expect{ @table.summary }.not_to raise_error
+  end
+
+  example 'summary=' do
+    expect(@table).to respond_to(:summary=)
+    expect{ @table.summary = 'foo' }.not_to raise_error
+    expect{ @table.summary = 1 }.not_to raise_error
+  end
+
+  example 'valign' do
+    expect(@table).to respond_to(:valign)
+    expect(@table).to respond_to(:valign=)
+    expect{ @table.valign }.not_to raise_error
+    expect{ @table.valign = 'center' }.not_to raise_error
+  end
+
+  example 'valign_expected_errors' do
+    expect{ @table.valign = 'foo' }.to raise_error(ArgumentError)
+  end
+
+  example 'vspace' do
+    expect(@table).to respond_to(:vspace)
+    expect(@table).to respond_to(:vspace=)
+    expect{ @table.vspace }.not_to raise_error
+    expect{ @table.vspace = 1 }.not_to raise_error
+  end
+
+  example 'vspace_expected_errors' do
+    expect{ @table.vspace = -1 }.to raise_error(ArgumentError)
+  end
+
+  example 'width' do
+    expect(@table).to respond_to(:width)
+    expect(@table).to respond_to(:width=)
+    expect{ @table.width }.not_to raise_error
+    expect{ @table.width = 10 }.not_to raise_error
+  end
+
+  example 'width_with_percent' do
+    expect{ @table.width = '5%' }.not_to raise_error
+    expect(@table.width).to eq('5%')
+  end
+
+  example 'width_expected_errors' do
+    expect{ @table.width = -1 }.to raise_error(ArgumentError)
+  end
+end