html-table 1.5.2 → 1.7.0

data/lib/html/mixin/html_handler.rb

@@ -0,0 +1,124 @@
+module HTML
+  module Mixin
+    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
+  end
+end

data/lib/html/mixin/strongtyping.rb

@@ -0,0 +1,17 @@
+# A pure-ruby replacement for strongtyping gem
+
+module HTML
+  module Mixin
+    module StrongTyping
+      class ArgumentTypeError < ArgumentError; end
+
+      def expect(arg, allowed_types)
+        return true if Array(allowed_types).any? do |klass|
+          arg.kind_of?(klass)
+        end
+
+        raise ArgumentTypeError.new("#{arg} must be of type #{allowed_types}")
+      end
+    end
+  end
+end

data/lib/html/mixin/tag_handler.rb

@@ -0,0 +1,125 @@
+###################################################################
+# tag_handler.rb
+#
+# Module for handling standard html physical tags (<b>, <i>, etc).
+# Only used for Table::Content objects, which are in turn used by
+# Table::Row::Data, Table::Row::Header and Table::Caption.
+###################################################################
+module HTML
+  module Mixin
+    module TagHandler
+      def bold(bool = nil)
+        @bold ||= nil
+        self.bold = bool if bool
+        @bold
+      end
+
+      def bold=(bool)
+        handle_physical_tag('b', bool)
+        @bold = bool
+      end
+
+      def big(bool = nil)
+        @big ||= nil
+        self.big = bool if bool
+        @big
+      end
+
+      def big=(bool)
+        handle_physical_tag('big', bool)
+        @big = bool
+      end
+
+      def blink(bool = nil)
+        @blink ||= nil
+        self.blink = bool if bool
+        @blink
+      end
+
+      def blink=(bool)
+        warn BlinkWarning, "The 'blink' tag is very annoying. Please reconsider."
+        handle_physical_tag('blink', bool)
+        @blink = bool
+      end
+
+      def italic(bool = nil)
+        @italic ||= nil
+        self.italic = bool if bool
+        @italic
+      end
+
+      def italic=(bool)
+        handle_physical_tag('i', bool)
+        @italic = bool
+      end
+
+      def strike(bool = nil)
+        @strike ||= nil
+        self.strike = bool if bool
+        @strike
+      end
+
+      def strike=(bool)
+        handle_physical_tag('strike', bool)
+        @strike = bool
+      end
+
+      def sub(bool = nil)
+        @sub ||= nil
+        self.sub = bool if bool
+        @sub
+      end
+
+      def sub=(bool)
+        handle_physical_tag('sub', bool)
+        @sub = bool
+      end
+
+      def sup(bool = nil)
+        @sup ||= nil
+        self.sup = bool if bool
+        @sup
+      end
+
+      def sup=(bool)
+        handle_physical_tag('sup', bool)
+        @sup = bool
+      end
+
+      def tt(bool = nil)
+        @tt ||= nil
+        self.tt = bool if bool
+        @tt
+      end
+
+      def tt=(bool)
+        handle_physical_tag('tt', bool)
+        @tt = bool
+      end
+
+      def underline(bool = nil)
+        @underline ||= nil
+        self.underline = bool if bool
+        @underline
+      end
+
+      def underline=(bool)
+        handle_physical_tag('u', bool)
+        @bool = bool
+      end
+
+      private
+
+      def handle_physical_tag(tag, bool)
+        begin_tag = "<#{tag}>"
+        end_tag = "</#{tag}>"
+
+        if bool
+          self.replace(begin_tag << self << end_tag)
+        else
+          self.replace(self.gsub(/#{begin_tag}|#{end_tag}/,''))
+        end
+      end
+    end
+  end
+end

data/lib/html/row.rb

@@ -1,7 +1,7 @@
 module HTML
    class Table::Row < Array
-      include AttributeHandler
-      include HtmlHandler
+      include HTML::Mixin::AttributeHandler
+      include HTML::Mixin::HtmlHandler
 
       @indent_level = 3
       @end_tags     = true

data/lib/html/table.rb

@@ -1,8 +1,8 @@
-require_relative 'attribute_handler'
-require_relative 'html_handler'
-require 'strongtyping'
+require_relative 'mixin/attribute_handler'
+require_relative 'mixin/html_handler'
+require_relative 'mixin/strongtyping'
 require 'structured_warnings'
-include StrongTyping
+include HTML::Mixin::StrongTyping
 
 # Warning raised if a non-standard extension is used.
 class NonStandardExtensionWarning < StructuredWarnings::StandardWarning; end
@@ -16,11 +16,11 @@ module HTML
   # The Table class encapsulates methods associated with an html table
   # element. It is the "outermost" class of the html-table classes.
   class Table < Array
-    include AttributeHandler
-    include HtmlHandler
+    include HTML::Mixin::AttributeHandler
+    include HTML::Mixin::HtmlHandler
 
     # The version of the html-table library
-    VERSION = '1.5.2'.freeze
+    VERSION = '1.7.0'.freeze
 
     # The indentation level for the <table> and </table> tags
     @indent_level = 0

data/lib/html/tablesection.rb

@@ -2,8 +2,8 @@ module HTML
    # Superclass for THEAD, TBODY, TFOOT
    #
    class Table::TableSection < Array
-      include AttributeHandler
-      include HtmlHandler
+      include HTML::Mixin::AttributeHandler
+      include HTML::Mixin::HtmlHandler
 
       def initialize(&block)
          instance_eval(&block) if block_given?

data/spec/attribute_handler_spec.rb

@@ -0,0 +1,360 @@
+############################################################################
+# 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
+
+  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
+
+  ########################################################################
+  # This test could probably be broken out into separate tests for each
+  # type that we want to add as content.
+  ########################################################################
+  example "content" do
+    expect(@table).to respond_to(:content)
+    expect(@table).to respond_to(:content=)
+    expect{ @table.content = 'foo' }.not_to raise_error
+    expect{ @table.content = 123 }.not_to raise_error
+    expect{ @table.content = ['one',2,'three'] }.not_to raise_error
+    expect{ @table.content = [['foo','bar'],[1,2,3]] }.not_to raise_error
+    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
+    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).to respond_to(:summary=)
+    expect{ @table.summary }.not_to raise_error
+    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
+
+  after(:all) do
+    NonStandardExtensionWarning.enable
+  end
+end