fat_table 0.9.7 → 0.9.9

data/lib/fat_table/formatters/formatter.rb

@@ -25,9 +25,9 @@ module FatTable
 
     # A Hash of Hashes with the outer Hash keyed on location.  The value for
     # the outer Hash is an inner Hash keyed on column names.  The values of
-    # the inner Hash are OpenStruct objects that contain the formatting
-    # instructions for the location and column.  For example,
-    # +format_at[:body][:shares].commas+ is set either true or false depending
+    # the inner Hash are hashes that contain the formatting instructions for
+    # the location and column.  For example,
+    # +format_at[:body][:shares][:commas]+ is set either true or false depending
     # on whether the +:shares+ column in the table body is to have grouping
     # commas inserted in the output.
     attr_reader :format_at
@@ -111,7 +111,7 @@ module FatTable
       # hash of hashes. The outer hash is keyed on the location, and each inner
       # hash is keyed on either a column sym or a type sym, :string, :numeric,
       # :datetime, :boolean, or :nil. The value of the inner hashes are
-      # OpenStruct structs.
+      # also hashes.
       @format_at = {}
       %i[header bfirst gfirst body footer gfooter].each do |loc|
         @format_at[loc] = {}
@@ -119,7 +119,7 @@ module FatTable
           fmt_hash = self.class.default_format
           fmt_hash[:_h] = h
           fmt_hash[:_location] = loc
-          format_at[loc][h] = OpenStruct.new(fmt_hash)
+          format_at[loc][h] = fmt_hash
         end
       end
       yield self if block_given?
@@ -172,7 +172,7 @@ module FatTable
     # price.
     #   fmtr.footer.('Summary', :shares, date: :avg, price: :avg)
     def footer(label, label_col = nil, *sum_cols, **agg_cols)
-      foot = Footer.new(label, table, label_col: label_col)
+      foot = Footer.new(table, label: label, label_col: label_col)
       sum_cols.each do |h|
         foot.add_value(h, :sum)
       end
@@ -252,7 +252,7 @@ module FatTable
     # to the lamda's column.
     #
     def foot(label: 'Total', label_col: nil, **agg_cols)
-      foot = Footer.new(label, table, label_col: label_col)
+      foot = Footer.new(table, label: label, label_col: label_col)
       agg_cols.each_pair do |h, agg|
         foot.add_value(h, agg)
       end
@@ -280,7 +280,7 @@ module FatTable
     # Do some sums and some other aggregates: sum shares, average date and
     # price. fmtr.gfooter.('Summary', :shares, date: :avg, price: :avg)
     def gfooter(label, label_col = nil, *sum_cols, **agg_cols)
-      foot = Footer.new(label, table, label_col: label_col, group: true)
+      foot = Footer.new(table, label: label, label_col: label_col, group: true)
       sum_cols.each do |h|
         foot.add_value(h, :sum)
       end
@@ -377,7 +377,7 @@ module FatTable
     # values (using f[:other_col]) as well as the Column object corresponding
     # to the lamda's column.
     def gfoot(label: 'Group Total', label_col: nil, **agg_cols)
-      foot = Footer.new(label, table, label_col: label_col, group: true)
+      foot = Footer.new(table, label: label, label_col: label_col, group: true)
       agg_cols.each_pair do |h, agg|
         foot.add_value(h, agg)
       end
@@ -683,8 +683,11 @@ module FatTable
         parse_typ_method_name = 'parse_' + typ.to_s + '_fmt'
         if fmts[h]
           # Merge in column formatting
-          col_fmt = send(parse_typ_method_name, fmts[h],
-                         strict: location != :header).first
+          col_fmt = send(
+            parse_typ_method_name,
+            fmts[h],
+            strict: location != :header,
+          ).first
           format_h = format_h.merge(col_fmt)
         elsif fmts.key?(typ)
           # Merge in type-based formatting
@@ -697,18 +700,18 @@ module FatTable
         # format_for call with those locations.
         if location == :body
           format_h.each_pair do |k, v|
-            if format_at[:bfirst][h].send(k) == self.class.default_format[k]
-              format_at[:bfirst][h].send("#{k}=", v)
+            if format_at[:bfirst][h][k] == self.class.default_format[k]
+              format_at[:bfirst][h][k] = v
             end
-            if format_at[:gfirst][h].send(k) == self.class.default_format[k]
-              format_at[:gfirst][h].send("#{k}=", v)
+            if format_at[:gfirst][h][k] == self.class.default_format[k]
+              format_at[:gfirst][h][k] = v
             end
           end
         elsif location == :gfirst
           # Copy :gfirst formatting to :bfirst if it is still the default
           format_h.each_pair do |k, v|
-            if format_at[:bfirst][h].send(k) == self.class.default_format[k]
-              format_at[:bfirst][h].send("#{k}=", v)
+            if format_at[:bfirst][h][k] == self.class.default_format[k]
+              format_at[:bfirst][h][k] = v
             end
           end
         end
@@ -717,7 +720,7 @@ module FatTable
         # headers named h or location) and convert to struct
         format_h[:_h] = h
         format_h[:_location] = location
-        format_at[location][h] = OpenStruct.new(format_h)
+        format_at[location][h] = format_h
       end
       self
     end
@@ -726,10 +729,10 @@ module FatTable
     # Parsing and validation routines
     ############################################################################
 
-    private
-
     # Re to match a color name
-    CLR_RE = /(?:[-_a-zA-Z0-9 ]*)/.freeze
+    CLR_RE = /(?:[-_a-zA-Z0-9 ]*)/
+
+    private
 
     # Return a hash that reflects the formatting instructions given in the
     # string fmt. Raise an error if it contains invalid formatting instructions.
@@ -753,27 +756,28 @@ module FatTable
       # parse, we remove the matched construct from fmt.  At the end, any
       # remaining characters in fmt should be invalid.
       fmt_hash = {}
-      if fmt =~ /c\[(?<co>#{CLR_RE})(\.(?<bg>#{CLR_RE}))?\]/
+      if fmt =~ /c\[(?<co>#{CLR_RE})(\.(?<bg>#{CLR_RE}))?\]/o
         fmt_hash[:color] = Regexp.last_match[:co] unless Regexp.last_match[:co].blank?
         fmt_hash[:bgcolor] = Regexp.last_match[:bg] unless Regexp.last_match[:bg].blank?
         validate_color(fmt_hash[:color])
         validate_color(fmt_hash[:bgcolor])
         fmt = fmt.sub($&, '')
       end
+      # binding.break
       # Nil formatting can apply to strings as well
       nil_hash, fmt = parse_nilclass_fmt(fmt)
       fmt_hash = fmt_hash.merge(nil_hash)
-      if fmt =~ /u/
+      if fmt.include?('u')
         fmt_hash[:case] = :lower
-        fmt = fmt.sub($&, '')
+        fmt = fmt.delete('u')
       end
-      if fmt =~ /U/
+      if fmt.include?('U')
         fmt_hash[:case] = :upper
-        fmt = fmt.sub($&, '')
+        fmt = fmt.delete('U')
       end
-      if fmt =~ /t/
+      if fmt.include?('t')
         fmt_hash[:case] = :title
-        fmt = fmt.sub($&, '')
+        fmt = fmt.delete('t')
       end
       if fmt =~ /(?<neg>~\s*)?B/
         fmt_hash[:bold] = !Regexp.last_match[:neg]
@@ -783,17 +787,17 @@ module FatTable
         fmt_hash[:italic] = !Regexp.last_match[:neg]
         fmt = fmt.sub($&, '')
       end
-      if fmt =~ /R/
+      if fmt.include?('R')
         fmt_hash[:alignment] = :right
-        fmt = fmt.sub($&, '')
+        fmt = fmt.delete('R')
       end
-      if fmt =~ /C/
+      if fmt.include?('C')
         fmt_hash[:alignment] = :center
-        fmt = fmt.sub($&, '')
+        fmt = fmt.delete('C')
       end
-      if fmt =~ /L/
+      if fmt.include?('L')
         fmt_hash[:alignment] = :left
-        fmt = fmt.sub($&, '')
+        fmt = fmt.delete('L')
       end
       if fmt =~ /(?<neg>~\s*)?_/
         fmt_hash[:underline] = !Regexp.last_match[:neg]
@@ -895,8 +899,8 @@ module FatTable
       end
       # Since true_text, false_text and nil_text may want to have internal
       # spaces, defer removing extraneous spaces until after they are parsed.
-      if fmt =~ /c\[(#{CLR_RE})(\.(#{CLR_RE}))?,
-                 \s*(#{CLR_RE})(\.(#{CLR_RE}))?\]/x
+      if fmt =~ %r{c\[(#{CLR_RE})(\.(#{CLR_RE}))?,
+                 \s*(#{CLR_RE})(\.(#{CLR_RE}))?\]}xo
         tco, _, tbg, fco, _, fbg = Regexp.last_match.captures
         fmt_hash[:true_color] = tco unless tco.blank?
         fmt_hash[:true_bgcolor] = tbg unless tbg.blank?
@@ -906,20 +910,20 @@ module FatTable
       end
       str_fmt_hash, fmt = parse_string_fmt(fmt)
       fmt_hash = fmt_hash.merge(str_fmt_hash)
-      if fmt =~ /Y/
+      if fmt.include?('Y')
         fmt_hash[:true_text] = 'Y'
         fmt_hash[:false_text] = 'N'
-        fmt = fmt.sub(Regexp.last_match[0], '')
+        fmt = fmt.delete('Y')
       end
-      if fmt =~ /T/
+      if fmt.include?('T')
         fmt_hash[:true_text] = 'T'
         fmt_hash[:false_text] = 'F'
-        fmt = fmt.sub(Regexp.last_match[0], '')
+        fmt = fmt.delete('T')
       end
-      if fmt =~ /X/
+      if fmt.include?('X')
         fmt_hash[:true_text] = 'X'
         fmt_hash[:false_text] = ''
-        fmt = fmt.sub(Regexp.last_match[0], '')
+        fmt = fmt.delete('X')
       end
       unless fmt.blank? || !strict
         raise UserError, "unrecognized boolean formatting instructions '#{fmt}'"
@@ -957,18 +961,18 @@ module FatTable
         str = format_boolean(val, istruct)
         str = format_string(str, istruct, width)
         true_istruct = istruct.dup
-        true_istruct.color = istruct.true_color
-        true_istruct.bgcolor = istruct.true_bgcolor
+        true_istruct[:color] = istruct[:true_color]
+        true_istruct[:bgcolor] = istruct[:true_bgcolor]
         decorate ? decorate_string(str, true_istruct) : str
       when FalseClass
         str = format_boolean(val, istruct)
         str = format_string(str, istruct, width)
         false_istruct = istruct.dup
-        false_istruct.color = istruct.false_color
-        false_istruct.bgcolor = istruct.false_bgcolor
+        false_istruct[:color] = istruct[:false_color]
+        false_istruct[:bgcolor] = istruct[:false_bgcolor]
         decorate ? decorate_string(str, false_istruct) : str
       when NilClass
-        str = istruct.nil_text
+        str = istruct[:nil_text]
         str = format_string(str, istruct, width)
         decorate ? decorate_string(str, istruct) : str
       when String
@@ -996,9 +1000,9 @@ module FatTable
     # formatting (e.g., color) can be done in a subclass of Formatter by
     # specializing this method.
     def format_boolean(val, istruct)
-      return istruct.nil_text if val.nil?
+      return istruct[:nil_text] if val.nil?
 
-      val ? istruct.true_text : istruct.false_text
+      val ? istruct[:true_text] : istruct[:false_text]
     end
 
     # Convert a datetime to a string according to instructions in istruct, which
@@ -1007,13 +1011,13 @@ module FatTable
     # formatting (e.g., color) can be done in a subclass of Formatter by
     # specializing this method.
     def format_datetime(val, istruct)
-      return istruct.nil_text if val.nil?
+      return istruct[:nil_text] if val.nil?
 
       if val.to_date == val
         # It is a Date, with no time component.
-        val.strftime(istruct.date_fmt)
+        val.strftime(istruct[:date_fmt])
       else
-        val.strftime(istruct.datetime_fmt)
+        val.strftime(istruct[:datetime_fmt])
       end
     end
 
@@ -1023,32 +1027,32 @@ module FatTable
     # formatting (e.g., color) can be done in a subclass of Formatter by
     # specializing this method.
     def format_numeric(val, istruct)
-      return istruct.nil_text if val.nil?
-      return val.secs_to_hms if istruct.hms
+      return istruct[:nil_text] if val.nil?
+      return val.secs_to_hms if istruct[:hms]
 
-      if istruct.commas
+      if istruct[:commas]
         # Commify the whole number part if not done already.
-        result = val.commas(istruct.post_digits)
+        result = val.commas(istruct[:post_digits])
       else
-        result = val.round(istruct.post_digits).to_s
+        result = val.round(istruct[:post_digits]).to_s
         match = result.match(/\.(\d+)\z/)
-        if match && match[1]&.size < istruct.post_digits
+        if match && (match[1]&.size&.< istruct[:post_digits])
           # Add trailing zeros to pad out post_digits
-          n_zeros = [istruct.post_digits - match[1].size, 0].max
+          n_zeros = [istruct[:post_digits] - match[1].size, 0].max
           zeros = '0' * n_zeros
-          result = result + zeros
+          result += zeros
         end
         result
       end
 
-      if istruct.pre_digits.positive?
+      if istruct[:pre_digits].positive?
         match = result.match(/\A([\d,]+)(\.\d+)?\z/)
         whole_part = match[1]
         frac_part = match[2]
-        n_zeros = [istruct.pre_digits - whole_part.gsub(',', '').size, 0].max
+        n_zeros = [istruct[:pre_digits] - whole_part.delete(',').size, 0].max
         result =
           if n_zeros.positive?
-            if istruct.commas
+            if istruct[:commas]
               # Insert leading zeros with commas
               pre_comma_match = whole_part.match(/\A(\d+),/)
               if pre_comma_match
@@ -1059,7 +1063,7 @@ module FatTable
               zeros = ''
               if n_zeros.positive?
                 zeros = "0" * n_zeros
-                if n_zeros > 3 && istruct.commas
+                if n_zeros > 3 && istruct[:commas]
                   zeros = zeros.reverse.gsub!(/([0-9]{3})/, "\\1,").reverse
                 end
               end
@@ -1075,7 +1079,7 @@ module FatTable
       else
         result
       end
-      if istruct.currency
+      if istruct[:currency]
         result = "#{FatTable.currency_symbol}#{result}"
       end
       result
@@ -1085,20 +1089,20 @@ module FatTable
     def format_string(val, istruct, width = nil)
       val = istruct.nil_text if val.nil?
       val =
-        case istruct.case
+        case istruct[:case]
         when :lower
           val.downcase
         when :upper
           val.upcase
         when :title
-          # Note: fat_core entitle keeps all uppercase words as upper case,
+          # NOTE: fat_core entitle keeps all uppercase words as upper case,
           val.downcase.entitle
         when :none
           val
         end
       if width && aligned?
         pad = [width - width(val), 0].max
-        case istruct.alignment
+        case istruct[:alignment]
         when :left
           val += ' ' * pad
         when :right
@@ -1229,7 +1233,10 @@ module FatTable
 
       # If this Formatter targets a ruby data structure (e.g., AoaFormatter), we
       # eval the string to get the object.
+      #
+      # rubocop:disable Security/Eval
       evaluate? ? eval(result) : result
+      # rubocop:enable Security/Eval
     end
 
     private
@@ -1244,7 +1251,7 @@ module FatTable
       map = {}
       table.headers.each do |h|
         istruct = format_at[:header][h]
-        map[h] = [h, format_cell(h.as_string, istruct, decorate: decorate)]
+        map[h] = [h, format_cell(h.entitle, istruct, decorate: decorate)]
       end
       map
     end
@@ -1277,7 +1284,7 @@ module FatTable
             end
 
           out_row = {}
-          row.each_pair do |h, v|
+          row.each_pair do |h, _v|
             istruct = format_at[location][h]
             out_row[h] = [row[h], format_cell(row[h], istruct, decorate: decorate)]
           end
@@ -1285,9 +1292,9 @@ module FatTable
           tbl_row_k += 1
         end
         # Format group footers
-        gfooters.each_pair do |label, gfooter|
+        gfooters.each_pair do |_label, gfooter|
           out_rows << nil
-          gfoot_row = Hash.new([nil, ''])
+          gfoot_row = Hash.new([nil, ''].freeze)
           gfooter.to_h(grp_k).each_pair do |h, v|
             istruct = format_at[:gfooter][h]
             gfoot_row[h] = [v, format_cell(v, istruct, decorate: decorate)]
@@ -1304,9 +1311,9 @@ module FatTable
       decorate = !aligned?
       out_rows = []
 
-      footers.each_pair do |label, foot|
+      footers.each_pair do |_label, foot|
         out_rows << nil
-        foot_row = Hash.new([nil, ''])
+        foot_row = Hash.new([nil, ''].freeze)
         foot.to_h.each_pair do |h, v|
           istruct = format_at[:gfooter][h]
           foot_row[h] = [v, format_cell(v, istruct, decorate: decorate)]

data/lib/fat_table/formatters/latex_formatter.rb

@@ -26,58 +26,8 @@ module FatTable
     end
 
     # Taken from the Rainbow gem's list of valid colors.
-    self.valid_colors = %w[
-      none black blue brown cyan darkgray gray green lightgray lime magenta
-      olive orange pink purple red teal violet white yellow AntiqueWhite1
-      AntiqueWhite2 AntiqueWhite3 AntiqueWhite4 Aquamarine1 Aquamarine2
-      Aquamarine3 Aquamarine4 Azure1 Azure2 Azure3 Azure4 Bisque1 Bisque2
-      Bisque3 Bisque4 Blue1 Blue2 Blue3 Blue4 Brown1 Brown2 Brown3 Brown4
-      Burlywood1 Burlywood2 Burlywood3 Burlywood4 CadetBlue1 CadetBlue2
-      CadetBlue3 CadetBlue4 Chartreuse1 Chartreuse2 Chartreuse3 Chartreuse4
-      Chocolate1 Chocolate2 Chocolate3 Chocolate4 Coral1 Coral2 Coral3 Coral4
-      Cornsilk1 Cornsilk2 Cornsilk3 Cornsilk4 Cyan1 Cyan2 Cyan3 Cyan4
-      DarkGoldenrod1 DarkGoldenrod2 DarkGoldenrod3 DarkGoldenrod4
-      DarkOliveGreen1 DarkOliveGreen2 DarkOliveGreen3 DarkOliveGreen4
-      DarkOrange1 DarkOrange2 DarkOrange3 DarkOrange4 DarkOrchid1 DarkOrchid2
-      DarkOrchid3 DarkOrchid4 DarkSeaGreen1 DarkSeaGreen2 DarkSeaGreen3
-      DarkSeaGreen4 DarkSlateGray1 DarkSlateGray2 DarkSlateGray3 DarkSlateGray4
-      DeepPink1 DeepPink2 DeepPink3 DeepPink4 DeepSkyBlue1 DeepSkyBlue2
-      DeepSkyBlue3 DeepSkyBlue4 DodgerBlue1 DodgerBlue2 DodgerBlue3 DodgerBlue4
-      Firebrick1 Firebrick2 Firebrick3 Firebrick4 Gold1 Gold2 Gold3 Gold4
-      Goldenrod1 Goldenrod2 Goldenrod3 Goldenrod4 Gray0 Green0 Green1 Green2
-      Green3 Green4 Grey0 Honeydew1 Honeydew2 Honeydew3 Honeydew4 HotPink1
-      HotPink2 HotPink3 HotPink4 IndianRed1 IndianRed2 IndianRed3 IndianRed4
-      Ivory1 Ivory2 Ivory3 Ivory4 Khaki1 Khaki2 Khaki3 Khaki4 LavenderBlush1
-      LavenderBlush2 LavenderBlush3 LavenderBlush4 LemonChiffon1 LemonChiffon2
-      LemonChiffon3 LemonChiffon4 LightBlue1 LightBlue2 LightBlue3 LightBlue4
-      LightCyan1 LightCyan2 LightCyan3 LightCyan4 LightGoldenrod1
-      LightGoldenrod2 LightGoldenrod3 LightGoldenrod4 LightPink1 LightPink2
-      LightPink3 LightPink4 LightSalmon1 LightSalmon2 LightSalmon3 LightSalmon4
-      LightSkyBlue1 LightSkyBlue2 LightSkyBlue3 LightSkyBlue4 LightSteelBlue1
-      LightSteelBlue2 LightSteelBlue3 LightSteelBlue4 LightYellow1 LightYellow2
-      LightYellow3 LightYellow4 Magenta1 Magenta2 Magenta3 Magenta4 Maroon0
-      Maroon1 Maroon2 Maroon3 Maroon4 MediumOrchid1 MediumOrchid2 MediumOrchid3
-      MediumOrchid4 MediumPurple1 MediumPurple2 MediumPurple3 MediumPurple4
-      MistyRose1 MistyRose2 MistyRose3 MistyRose4 NavajoWhite1 NavajoWhite2
-      NavajoWhite3 NavajoWhite4 OliveDrab1 OliveDrab2 OliveDrab3 OliveDrab4
-      Orange1 Orange2 Orange3 Orange4 OrangeRed1 OrangeRed2 OrangeRed3
-      OrangeRed4 Orchid1 Orchid2 Orchid3 Orchid4 PaleGreen1 PaleGreen2
-      PaleGreen3 PaleGreen4 PaleTurquoise1 PaleTurquoise2 PaleTurquoise3
-      PaleTurquoise4 PaleVioletRed1 PaleVioletRed2 PaleVioletRed3 PaleVioletRed4
-      PeachPuff1 PeachPuff2 PeachPuff3 PeachPuff4 Pink1 Pink2 Pink3 Pink4 Plum1
-      Plum2 Plum3 Plum4 Purple0 Purple1 Purple2 Purple3 Purple4 Red1 Red2 Red3
-      Red4 RosyBrown1 RosyBrown2 RosyBrown3 RosyBrown4 RoyalBlue1 RoyalBlue2
-      RoyalBlue3 RoyalBlue4 Salmon1 Salmon2 Salmon3 Salmon4 SeaGreen1 SeaGreen2
-      SeaGreen3 SeaGreen4 Seashell1 Seashell2 Seashell3 Seashell4 Sienna1
-      Sienna2 Sienna3 Sienna4 SkyBlue1 SkyBlue2 SkyBlue3 SkyBlue4 SlateBlue1
-      SlateBlue2 SlateBlue3 SlateBlue4 SlateGray1 SlateGray2 SlateGray3
-      SlateGray4 Snow1 Snow2 Snow3 Snow4 SpringGreen1 SpringGreen2 SpringGreen3
-      SpringGreen4 SteelBlue1 SteelBlue2 SteelBlue3 SteelBlue4 Tan1 Tan2 Tan3
-      Tan4 Thistle1 Thistle2 Thistle3 Thistle4 Tomato1 Tomato2 Tomato3 Tomato4
-      Turquoise1 Turquoise2 Turquoise3 Turquoise4 VioletRed1 VioletRed2
-      VioletRed3 VioletRed4 Wheat1 Wheat2 Wheat3 Wheat4 Yellow1 Yellow2 Yellow3
-      Yellow4
-    ]
+
+    self.valid_colors = File.readlines(File.join(__dir__, 'xcolors.txt'), chomp: true)
 
     # LaTeX commands to load the needed packages based on the :environement
     # option.  For now, just handles the default 'longtable' :environment.  The
@@ -101,18 +51,18 @@ module FatTable
     # default.
     def decorate_string(str, istruct)
       str = quote(str)
-      result = istruct.italic ? "\\itshape{#{str}}" : str
-      result = istruct.bold ? "\\bfseries{#{result}}" : result
-      if istruct.color && istruct.color != 'none'
-        result = "{\\textcolor{#{istruct.color}}{#{result}}}"
+      result = istruct[:italic] ? "\\itshape{#{str}}" : str
+      result = istruct[:bold] ? "\\bfseries{#{result}}" : result
+      if istruct[:color] && istruct[:color] != 'none'
+        result = "{\\textcolor{#{istruct[:color]}}{#{result}}}"
       end
-      if istruct.bgcolor && istruct.bgcolor != 'none'
-        result = "{\\cellcolor{#{istruct.bgcolor}}{#{result}}}"
+      if istruct[:bgcolor] && istruct[:bgcolor] != 'none'
+        result = "{\\cellcolor{#{istruct[:bgcolor]}}{#{result}}}"
       end
-      if (istruct._h && format_at[:body][istruct._h] &&
-         istruct.alignment != format_at[:body][istruct._h].alignment) ||
-         (istruct._h.nil? && istruct.alignment.to_sym != :left)
-        ac = alignment_code(istruct.alignment)
+      if (istruct[:_h] && format_at[:body][istruct[:_h]] &&
+         istruct[:alignment] != format_at[:body][istruct[:_h]][:alignment]) ||
+         (istruct[:_h].nil? && istruct[:alignment].to_sym != :left)
+        ac = alignment_code(istruct[:alignment])
         result = "\\multicolumn{1}{#{ac}}{#{result}}"
       end
       result
@@ -148,7 +98,7 @@ module FatTable
       end
       result += "\\begin{#{@options[:environment]}}{"
       table.headers.each do |h|
-        result += alignment_code(format_at[:body][h].alignment)
+        result += alignment_code(format_at[:body][h][:alignment])
       end
       result += "}\n"
       result

data/lib/fat_table/formatters/term_formatter.rb

@@ -41,14 +41,32 @@ module FatTable
     # Add ANSI codes to string to implement the given decorations
     def decorate_string(str, istruct)
       result = Rainbow(str)
-      result = colorize(result, istruct.color, istruct.bgcolor)
-      result = result.bold if istruct.bold
-      result = result.italic if istruct.italic
-      result = result.underline if istruct.underline
-      result = result.blink if istruct.blink
+      result = colorize(result, istruct[:color], istruct[:bgcolor])
+      result = result.bold if istruct[:bold]
+      result = result.italic if istruct[:italic]
+      result = result.underline if istruct[:underline]
+      result = result.blink if istruct[:blink]
       result
     end
 
+    # :stopdoc:
+    # Unicode line-drawing characters. We use double lines before and after the
+    # table and single lines for the sides and hlines between groups and
+    # footers.
+    UPPER_LEFT = "\u2552"
+    UPPER_RIGHT = "\u2555"
+    DOUBLE_RULE = "\u2550"
+    UPPER_TEE = "\u2564"
+    VERTICAL_RULE = "\u2502"
+    LEFT_TEE = "\u251C"
+    HORIZONTAL_RULE = "\u2500"
+    SINGLE_CROSS = "\u253C"
+    RIGHT_TEE = "\u2524"
+    LOWER_LEFT = "\u2558"
+    LOWER_RIGHT = "\u255B"
+    LOWER_TEE = "\u2567"
+    # :startdoc:
+
     private
 
     def color_valid?(clr)
@@ -99,24 +117,6 @@ module FatTable
       colorize(str, @options[:frame_fg], @options[:frame_bg])
     end
 
-    # :stopdoc:
-    # Unicode line-drawing characters. We use double lines before and after the
-    # table and single lines for the sides and hlines between groups and
-    # footers.
-    UPPER_LEFT = "\u2552"
-    UPPER_RIGHT = "\u2555"
-    DOUBLE_RULE = "\u2550"
-    UPPER_TEE = "\u2564"
-    VERTICAL_RULE = "\u2502"
-    LEFT_TEE = "\u251C"
-    HORIZONTAL_RULE = "\u2500"
-    SINGLE_CROSS = "\u253C"
-    RIGHT_TEE = "\u2524"
-    LOWER_LEFT = "\u2558"
-    LOWER_RIGHT = "\u255B"
-    LOWER_TEE = "\u2567"
-    # :startdoc:
-
     def upper_left
       if options[:unicode]
         UPPER_LEFT