html-table 1.6.0 → 1.6.1

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.6.0'.freeze
+    VERSION = '1.6.1'.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/test/test_table.rb

@@ -16,7 +16,7 @@ class TC_HTML_Table < Test::Unit::TestCase
   end
 
   def test_version
-    assert_equal('1.6.0', Table::VERSION)
+    assert_equal('1.6.1', Table::VERSION)
     assert_true(Table::VERSION.frozen?)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: html-table
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.1
 platform: ruby
 authors:
 - Daniel J. Berger
@@ -146,11 +146,14 @@ files:
 - lib
 - lib/html
 - lib/html/row.rb
-- lib/html/attribute_handler.rb
 - lib/html/head.rb
 - lib/html/table.rb
-- lib/html/html_handler.rb
 - lib/html/content.rb
+- lib/html/mixin
+- lib/html/mixin/attribute_handler.rb
+- lib/html/mixin/html_handler.rb
+- lib/html/mixin/strongtyping.rb
+- lib/html/mixin/tag_handler.rb
 - lib/html/data.rb
 - lib/html/tablesection.rb
 - lib/html/foot.rb
@@ -158,10 +161,8 @@ files:
 - lib/html/col.rb
 - lib/html/caption.rb
 - lib/html/colgroup.rb
-- lib/html/tag_handler.rb
 - lib/html/header.rb
 - lib/html-table.rb
-- lib/strongtyping.rb
 - certs
 - certs/djberg96_pub.pem
 homepage: http://github.com/djberg96/html-table

data/lib/html/attribute_handler.rb

@@ -1,403 +0,0 @@
-# This module creates methods for each of the various attributes associated
-# with HTML tables.  In some cases validation is done on the setters.
-#--
-# The seemingly redundant writer methods were left here for backwards
-# compatibility and for those who may not prefer the DSI.
-#
-module AttributeHandler
-   def abbr(string = nil)
-      @abbr ||= nil
-      self.abbr = string if string
-      @abbr
-   end
-
-   def abbr=(string)
-     @abbr = string
-     modify_html("abbr", string)
-   end
-
-   def align(position = nil)
-      @align ||= nil
-      self.align = position if position
-      @align
-   end
-
-   def align=(position)
-      valid = %w/top bottom left center right/
-      raise ArgumentError unless valid.include?(position.downcase)
-      @align = position
-      modify_html("align", position)
-   end
-
-   def axis(string = nil)
-      @axis ||= nil
-      self.axis = string if string
-      @axis
-   end
-
-   def axis=(string)
-     @axis = string
-     modify_html("axis", string)
-   end
-
-   def background(url = nil)
-      @background ||= nil
-      self.background = url if url
-      @background
-   end
-
-   def background=(url)
-      raise TypeError unless url.kind_of?(String)
-      msg =  "'background' is a non-standard extension"
-      warn NonStandardExtensionWarning, msg
-      @background = url
-      modify_html("background", url)
-   end
-
-   def bgcolor(color = nil)
-      @bgcolor ||= nil
-      self.bgcolor = color if color
-      @bgcolor
-   end
-
-   def bgcolor=(color)
-      @bgcolor = color
-      modify_html("bgcolor", color)
-   end
-
-   def border(num = nil)
-      @border ||= nil
-      self.border = num if num
-      @border
-   end
-
-   # Allow either true/false or an integer
-   def border=(num)
-      if num.kind_of?(TrueClass)
-         modify_html("border", true)
-      elsif num.kind_of?(FalseClass)
-         # Do nothing
-      else
-         @border = num.to_i
-         modify_html("border", num.to_i)
-      end
-   end
-
-   def bordercolor(color = nil)
-      @bordercolor ||= nil
-      self.bordercolor = color if color
-      @bordercolor
-   end
-
-   def bordercolor=(color)
-      @bordercolor = color
-      msg =  "'bordercolor' is a non-standard extension"
-      warn NonStandardExtensionWarning, msg
-      modify_html("bordercolor", color)
-   end
-
-   def bordercolordark(color = nil)
-      @bordercolordark ||= nil
-      self.bordercolordark = color if color
-      @bordercolordark
-   end
-
-   def bordercolordark=(color)
-      @bordercolordark = color
-      msg = "'bordercolordark' is a non-standard extension"
-      warn NonStandardExtensionWarning, msg
-      modify_html("bordercolordark", color)
-   end
-
-   def bordercolorlight(color = nil)
-      @bordercolorlight ||= nil
-      self.bordercolorlight = color if color
-      @bordercolorlight
-   end
-
-   def bordercolorlight=(color)
-      @bordercolorlight = color
-      msg = "'bordercolorlight' is a non-standard extension"
-      warn NonStandardExtensionWarning, msg
-      modify_html("bordercolorlight", @bordercolorlight)
-   end
-
-   def cellpadding(num = nil)
-      @cellpadding ||= nil
-      self.cellpadding = num if num
-      @cellpadding
-   end
-
-   def cellpadding=(num)
-      raise ArgumentError if num.to_i < 0
-      @cellpadding = num.to_i
-      modify_html("cellpadding", @cellpadding)
-   end
-
-   def cellspacing(num = nil)
-      @cellspacing ||= nil
-      self.cellspacing = num if num
-      @cellspacing
-   end
-
-   def cellspacing=(num)
-      raise ArgumentError if num.to_i < 0
-      @cellspacing = num.to_i
-      modify_html("cellspacing", @cellspacing)
-   end
-
-   def char(character = nil)
-      @char ||= nil
-      self.char = character if character
-      @char
-   end
-
-   def char=(character)
-      raise ArgumentError if character.to_s.length > 1
-      @char = character.to_s
-      modify_html("char", character.to_s)
-   end
-
-   def charoff(offset = nil)
-      @charoff ||= nil
-      self.charoff = offset if offset
-      @charoff
-   end
-
-   def charoff=(offset)
-      raise ArgumentError if offset.to_i < 0
-      @charoff = offset
-      modify_html("charoff", offset)
-   end
-
-   # Returns the CSS class. The trailing underscore is necessary in order
-   # to avoid conflict with the 'class' keyword.
-   #
-   def class_(klass = nil)
-      @class ||= nil
-      self.class_ = klass if klass
-      @class
-   end
-
-   # Returns the CSS class.  The trailing underscore is necessary in order
-   # to avoid conflict with the 'class' keyword.
-   #
-   def class_=(klass)
-      modify_html('class', klass)
-      @class = klass
-   end
-   
-   def col(num = nil)
-      @col ||= nil
-      self.col = num if num
-      @col
-   end
-
-   def col=(num)
-      raise ArgumentError if num.to_i < 0
-      @col = num.to_i
-      modify_html("col", @col)
-   end
-
-   def colspan(span = nil)
-      @colspan ||= nil
-      self.colspan = span if span
-      @colspan
-   end
-
-   def colspan=(span)
-      raise ArgumentError if span.to_i < 0
-      @colspan = span.to_i
-      modify_html("colspan", @colspan)
-   end
-
-   # Allows you to configure various attributes by row or row + column.
-   #
-   def configure(row, col=nil, &block)
-      if col
-         begin
-            yield self[row][col]
-         rescue NameError
-            msg = "No column to configure in a " + self.class.to_s + " class"
-            raise ArgumentError, msg
-         end
-      else
-         yield self[row]
-      end
-   end
-
-   # Returns the HTML content (i.e. text).
-   #
-   def content(arg = nil, &block)
-      case arg
-         when String
-            self.content = Table::Content.new(arg, &block)
-         when Array
-            arg.each{ |e|
-               if e.kind_of?(Array)
-                  row = Table::Row.new
-                  e.each{ |element| row.push(Table::Content.new(element, &block)) }
-                  self.push(row)
-               else
-                  self.content = Table::Content.new(e, &block)
-               end
-            }
-         else
-            self.content = arg if arg
-      end
-      @html_body
-   end
-
-   alias data content
-
-   def frame(type = nil)
-      @frame ||= nil
-      self.frame = type if type
-      @frame
-   end
-
-   def frame=(type)
-      valid = %w/border void above below hsides lhs rhs vsides box/
-      raise ArgumentError unless valid.include?(type.downcase)
-      @frame = type
-      modify_html("frame", @frame)
-   end
-
-   def height(num = nil)
-      @height ||= nil
-      self.height = num if num
-      @height
-   end
-
-   def height=(num)
-      raise ArgumentError if num.to_i < 0
-      @height = num.to_i
-      modify_html("height", @height)
-   end
-
-   def hspace(num = nil)
-      @hspace ||= nil
-      self.hspace = num if num
-      @hspace
-   end
-
-   def hspace=(num)
-      raise ArgumentError if num.to_i < 0
-      @hspace = num.to_i
-      modify_html("hspace", @hspace)
-   end
-
-   def nowrap(bool = nil)
-      @nowrap ||= nil
-      self.nowrap = bool if bool
-      @nowrap
-   end
-
-   def nowrap=(bool)
-      unless bool.kind_of?(TrueClass) || bool.kind_of?(FalseClass)
-         raise TypeError
-      end
-      @nowrap = bool
-      modify_html("nowrap", @nowrap)
-   end
-
-   def rowspan(num = nil)
-      @rowspan ||= nil
-      self.rowspan = num if num
-      @rowspan
-   end
-
-   def rowspan=(num)
-      raise ArgumentError if num.to_i < 0
-      @rowspan = num.to_i
-      modify_html("rowspan", @rowspan)
-   end
-
-   def rules(edges = nil)
-      @rules ||= nil
-      self.rules = edges if edges
-      @rules
-   end
-
-   def rules=(edges)
-      valid = %w/all groups rows cols none/
-      raise ArgumentError unless valid.include?(edges.to_s.downcase)
-      @rules = edges
-      modify_html("rules", @rules)
-   end
-
-   def span(num = nil)
-      @span ||= nil
-      self.span = num if num
-      @span
-   end
-
-   def span=(num)
-      raise ArgumentError if num.to_i < 0
-      @span = num.to_i
-      modify_html("span", @span)
-   end
-
-   def style(string = nil)
-      @style ||= nil
-      self.style = string if string
-      @style
-   end
-
-   def style=(string)
-      @style = string.to_s
-      modify_html("style", @style)
-   end
-
-   def summary(string = nil)
-      @summary ||= nil
-      self.summary = string if string
-      @summary
-   end
-
-   def summary=(string)
-      @summary = string.to_s
-      modify_html("summary", @summary)
-   end
-
-   def valign(position = nil)
-      @valign ||= nil
-      self.valign = position if position
-      @valign
-   end
-
-   def valign=(position)
-      valid = %w/top center bottom baseline/
-      raise ArgumentError unless valid.include?(position.to_s.downcase)
-      @valign = position
-      modify_html("valign", @valign)
-   end
-
-   def vspace(num = nil)
-      @vspace ||= nil
-      self.vspace = num if num
-      @vspace
-   end
-
-   def vspace=(num)
-      raise ArgumentError if num.to_i < 0
-      @vspace = num.to_i
-      modify_html("vspace", @vspace)
-   end
-
-   def width(num = nil)
-      @width ||= nil
-      self.width = num if num
-      @width
-   end
-
-   def width=(num)
-      if num =~ /%/
-         @width = num
-      else
-         raise ArgumentError if num.to_i < 0
-         @width = num.to_i
-      end
-      modify_html("width", @width)
-   end
-end