fat_table 0.2.6 → 0.3.0

data/lib/fat_table/formatters/latex_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # A subclass of Formatter for rendering the table as a LaTeX table. It allows
   # foreground colors through LaTeX's xcolor package but ignores background
@@ -17,7 +19,6 @@ module FatTable
     #   LaTeX tabular-like environment to use for the table. The default is good
     #   for tables that might continue over multiple pages since it repeats the
     #   header at the top of each continuation page.
-
     def initialize(table = Table.new, **options)
       super
       @options[:document] = options.fetch(:document, false)
@@ -25,7 +26,7 @@ module FatTable
     end
 
     # Taken from the Rainbow gem's list of valid colors.
-    self.valid_colors = %w(
+    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
@@ -76,7 +77,7 @@ module FatTable
       Turquoise1 Turquoise2 Turquoise3 Turquoise4 VioletRed1 VioletRed2
       VioletRed3 VioletRed4 Wheat1 Wheat2 Wheat3 Wheat4 Yellow1 Yellow2 Yellow3
       Yellow4
-    )
+    ]
 
     # LaTeX commands to load the needed packages based on the :environement
     # option.  For now, just handles the default 'longtable' :environment.  The
@@ -115,7 +116,8 @@ module FatTable
       result = ''
       result += '\\bfseries{}' if istruct.bold
       result += '\\itshape{}' if istruct.italic
-      result += "\\color{#{istruct.color}}" if istruct.color && istruct.color != 'none'
+      result += "\\color{#{istruct.color}}" if istruct.color &&
+                                               istruct.color != 'none'
       result = "#{result}#{str}"
       unless istruct.alignment == format_at[:body][istruct._h].alignment
         ac = alignment_code(istruct.alignment)
@@ -173,14 +175,14 @@ module FatTable
       ''
     end
 
-    def pre_cell(_h)
+    def pre_cell(_head)
       ''
     end
 
     # We do quoting before applying decoration, so do not re-quote here.  We
     # will have LaTeX commands in v.
-    def quote_cell(v)
-      v
+    def quote_cell(val)
+      val
     end
 
     def post_cell

data/lib/fat_table/formatters/org_formatter.rb

@@ -4,10 +4,9 @@ module FatTable
   # timestamps and the connector at the beginning of hlines is a '|' rather than
   # a '+' as for text tables.
   class OrgFormatter < Formatter
-
     self.default_format = default_format.dup
-    self.default_format[:date_fmt] = '[%F]'
-    self.default_format[:datetime_fmt] = '[%F %a %H:%M:%S]'
+    default_format[:date_fmt] = '[%F]'
+    default_format[:datetime_fmt] = '[%F %a %H:%M:%S]'
 
     private
 
@@ -20,7 +19,7 @@ module FatTable
 
     def pre_header(widths)
       result = '|'
-      widths.values.each do |w|
+      widths.each_value do |w|
         result += '-' * (w + 2) + '+'
       end
       result[-1] = '|'
@@ -31,12 +30,12 @@ module FatTable
       '|'
     end
 
-    def pre_cell(_h)
+    def pre_cell(_head)
       ''
     end
 
-    def quote_cell(v)
-      v
+    def quote_cell(val)
+      val
     end
 
     def post_cell
@@ -53,7 +52,7 @@ module FatTable
 
     def hline(widths)
       result = '|'
-      widths.values.each do |w|
+      widths.each_value do |w|
         result += '-' * (w + 2) + '+'
       end
       result[-1] = '|'
@@ -62,7 +61,7 @@ module FatTable
 
     def post_footers(widths)
       result = '|'
-      widths.values.each do |w|
+      widths.each_value do |w|
         result += '-' * (w + 2) + '+'
       end
       result[-1] = '|'

data/lib/fat_table/formatters/term_formatter.rb

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 require 'rainbow'
 
 module FatTable
@@ -29,6 +27,7 @@ module FatTable
       @options[:unicode] = options.fetch(:unicode, true)
       @options[:framecolor] = options.fetch(:framecolor, 'none.none')
       return unless @options[:framecolor] =~ /([-_a-zA-Z]*)(\.([-_a-zA-Z]*))/
+
       @options[:frame_fg] = $1.downcase unless $1.blank?
       @options[:frame_bg] = $3.downcase unless $3.blank?
     end
@@ -61,6 +60,7 @@ module FatTable
 
     def strip_ansi(str)
       return '' unless str
+
       str.gsub(/\e\[[0-9;]+m/, '')
     end
 
@@ -75,18 +75,19 @@ module FatTable
       result
     end
 
-    def colorize(str, fg, bg)
-      fg = nil if fg == 'none'
-      bg = nil if bg == 'none'
-      return str unless fg || bg
+    def colorize(str, fg_color, bg_color)
+      fg_color = nil if fg_color == 'none'
+      bg_color = nil if bg_color == 'none'
+      return str unless fg_color || bg_color
+
       result = Rainbow(str)
-      if fg
-        fg = fg.tr(' ', '').downcase.as_sym
-        result = result.color(fg) if fg
+      if fg_color
+        fg_color = fg_color.tr(' ', '').downcase.as_sym
+        result = result.color(fg_color) if fg_color
       end
-      if bg
-        bg = bg.tr(' ', '').downcase.as_sym
-        result = result.bg(bg) if bg
+      if bg_color
+        bg_color = bg_color.tr(' ', '').downcase.as_sym
+        result = result.bg(bg_color) if bg_color
       end
       result
     end
@@ -219,7 +220,7 @@ module FatTable
 
     def pre_header(widths)
       result = upper_left
-      widths.values.each do |w|
+      widths.each_value do |w|
         result += double_rule * (w + 2) + upper_tee
       end
       result[-1] = upper_right
@@ -231,12 +232,12 @@ module FatTable
       frame_colorize(vertical_rule)
     end
 
-    def pre_cell(_h)
+    def pre_cell(_head)
       ''
     end
 
-    def quote_cell(v)
-      v
+    def quote_cell(val)
+      val
     end
 
     def post_cell
@@ -253,7 +254,7 @@ module FatTable
 
     def hline(widths)
       result = left_tee
-      widths.values.each do |w|
+      widths.each_value do |w|
         result += horizontal_rule * (w + 2) + single_cross
       end
       result[-1] = right_tee
@@ -287,7 +288,7 @@ module FatTable
 
     def post_footers(widths)
       result = lower_left
-      widths.values.each do |w|
+      widths.each_value do |w|
         result += double_rule * (w + 2) + lower_tee
       end
       result[-1] = lower_right

data/lib/fat_table/formatters/text_formatter.rb

@@ -4,7 +4,6 @@ module FatTable
   # connector at the beginning of hlines is a '+' rather than a '|' as for org
   # tables.
   class TextFormatter < Formatter
-
     private
 
     # Does this Formatter require a second pass over the cells to align the
@@ -16,7 +15,7 @@ module FatTable
 
     def pre_header(widths)
       result = '+'
-      widths.values.each do |w|
+      widths.each_value do |w|
         result += '=' * (w + 2) + '+'
       end
       result[-1] = '+'
@@ -27,12 +26,12 @@ module FatTable
       '|'
     end
 
-    def pre_cell(_h)
+    def pre_cell(_head)
       ''
     end
 
-    def quote_cell(v)
-      v
+    def quote_cell(val)
+      val
     end
 
     def post_cell
@@ -49,7 +48,7 @@ module FatTable
 
     def hline(widths)
       result = '+'
-      widths.values.each do |w|
+      widths.each_value do |w|
         result += '-' * (w + 2) + '+'
       end
       result[-1] = '+'
@@ -82,7 +81,7 @@ module FatTable
 
     def post_footers(widths)
       result = '+'
-      widths.values.each do |w|
+      widths.each_value do |w|
         result += '=' * (w + 2) + '+'
       end
       result[-1] = '+'

data/lib/fat_table/patches.rb

@@ -1,4 +1,5 @@
-unless {a: 1}.respond_to?(:fetch_values)
+unless { a: 1 }.respond_to?(:fetch_values)
+  # Add fetch_values if this version of ruby does not define it.
   class Hash
     def fetch_values(*keys)
       result = []
@@ -14,3 +15,31 @@ unless {a: 1}.respond_to?(:fetch_values)
     end
   end
 end
+
+unless ''.respond_to?(:match?)
+  # Add String#match? to pre-2.4 ruby
+  class String
+    def match?(regexp)
+      self =~ regexp
+    end
+  end
+end
+
+unless //.respond_to?(:match?)
+  # Add Regexp#match? to pre-2.4 ruby
+  class Regexp
+    def match?(str)
+      self =~ str
+    end
+  end
+end
+
+unless ''.respond_to?(:strip_heredoc)
+  # Patch String to provide heredocs with whitespace stripped
+  class String
+    def strip_heredoc
+      indent = chomp.scan(/^\s*/).min.size
+      gsub(/^\s{#{indent}}/, '')
+    end
+  end
+end

data/lib/fat_table/table.rb

@@ -49,9 +49,9 @@ module FatTable
   # spaces converted to underscore and everything down-cased. So, the heading,
   # 'Two Words' becomes the header +:two_words+.
   class Table
-
     # An Array of FatTable::Columns that constitute the table.
     attr_reader :columns
+    attr_accessor :boundaries
 
     ###########################################################################
     # Constructors
@@ -106,18 +106,19 @@ module FatTable
     # :category: Constructors
 
     # Construct a new table from an Array of Arrays +aoa+. By default, with
-    # +hlines+ set to false, do not look for separators, i.e. +nils+, just treat
-    # the first row as headers. With +hlines+ set true, expect +nil+ separators
-    # to mark the header row and any boundaries. If the second element of the
-    # array is a +nil+, interpret the first element of the array as a row of
-    # headers. Otherwise, synthesize headers of the form +:col_1+, +:col_2+, ...
-    # and so forth. The remaining elements are taken as the body of the table,
-    # except that if an element of the outer array is a +nil+, mark the
-    # preceding row as a group boundary. Note for Emacs users: In org mode code
-    # blocks when an org-mode table is passed in as a variable it is passed in
-    # as an Array of Arrays. By default (+ HEADER: :hlines no +) org-mode strips
-    # all from the table; otherwise (+ HEADER: :hlines yes +) they are indicated
-    # with nil elements in the outer array.
+    # +hlines+ set to false, do not look for separators, i.e. +nils+, just
+    # treat the first row as headers. With +hlines+ set true, expect +nil+
+    # separators to mark the header row and any boundaries. If the second
+    # element of the array is a +nil+, interpret the first element of the
+    # array as a row of headers. Otherwise, synthesize headers of the form
+    # +:col_1+, +:col_2+, ...  and so forth. The remaining elements are taken
+    # as the body of the table, except that if an element of the outer array
+    # is a +nil+, mark the preceding row as a group boundary. Note for Emacs
+    # users: In org mode code blocks when an org-mode table is passed in as a
+    # variable it is passed in as an Array of Arrays. By default (+ HEADER:
+    # :hlines no +) org-mode strips all hrules from the table; otherwise (+
+    # HEADER: :hlines yes +) they are indicated with nil elements in the outer
+    # array.
     def self.from_aoa(aoa, hlines: false)
       from_array_of_arrays(aoa, hlines: hlines)
     end
@@ -140,8 +141,8 @@ module FatTable
 
     # :category: Constructors
 
-    # Construct a new table from another FatTable::Table object +table+. Inherit any
-    # group boundaries from the input table.
+    # Construct a new table from another FatTable::Table object +table+. Inherit
+    # any group boundaries from the input table.
     def self.from_table(table)
       table.deep_dup
     end
@@ -149,9 +150,11 @@ module FatTable
     # :category: Constructors
 
     # Construct a Table by running a SQL +query+ against the database set up
-    # with FatTable.set_db, with the rows of the query result as rows.
+    # with FatTable.connect, with the rows of the query result as rows.
     def self.from_sql(query)
-      raise UserError, 'FatTable.db must be set with FatTable.set_db' if FatTable.db.nil?
+      msg = 'FatTable.db must be set with FatTable.connect'
+      raise UserError, msg if FatTable.db.nil?
+
       result = Table.new
       FatTable.db[query].each do |h|
         result << h
@@ -166,15 +169,16 @@ module FatTable
     class << self
       private
 
-      # Construct table from an array of hashes or an array of any object that can
-      # respond to #to_h.  If an array element is a nil, mark it as a group
+      # Construct table from an array of hashes or an array of any object that
+      # can respond to #to_h. If an array element is a nil, mark it as a group
       # boundary in the Table.
       def from_array_of_hashes(hashes, hlines: false)
         result = new
         hashes.each do |hsh|
           if hsh.nil?
             unless hlines
-              raise UserError, 'found an hline in input with hlines false; try setting hlines true'
+              msg = 'found an hline in input: try setting hlines true'
+              raise UserError, msg
             end
             result.mark_boundary
             next
@@ -219,7 +223,8 @@ module FatTable
         rows[first_data_row..-1].each do |row|
           if row.nil?
             unless hlines
-              raise UserError, 'found an hline in input with hlines false; try setting hlines true'
+              msg = 'found an hline in input: try setting hlines true'
+              raise UserError, msg
             end
             result.mark_boundary
             next
@@ -253,15 +258,17 @@ module FatTable
         io.each do |line|
           unless table_found
             # Skip through the file until a table is found
-            next unless line =~ table_re
-            unless line =~ hrule_re
+            next unless line.match?(table_re)
+
+            unless line.match?(hrule_re)
               line = line.sub(/\A\s*\|/, '').sub(/\|\s*\z/, '')
               rows << line.split('|').map(&:clean)
             end
             table_found = true
             next
           end
-          break unless line =~ table_re
+          break unless line.match?(table_re)
+
           if !header_found && line =~ hrule_re
             rows << nil
             header_found = true
@@ -269,7 +276,7 @@ module FatTable
           elsif header_found && line =~ hrule_re
             # Mark the boundary with a nil
             rows << nil
-          elsif line !~ table_re
+          elsif !line.match?(table_re)
             # Stop reading at the second hline
             break
           else
@@ -311,13 +318,19 @@ module FatTable
     def [](key)
       case key
       when Integer
-        raise UserError, "index '#{key}' out of range" unless (0..size-1).cover?(key.abs)
+        msg = "index '#{key}' out of range"
+        raise UserError, msg unless (0..size - 1).cover?(key.abs)
+
         rows[key]
       when String
-        raise UserError, "header '#{key}' not in table" unless headers.include?(key)
+        msg = "header '#{key}' not in table"
+        raise UserError, msg unless headers.include?(key)
+
         column(key).items
       when Symbol
-        raise UserError, "header ':#{key}' not in table" unless headers.include?(key)
+        msg = "header ':#{key}' not in table"
+        raise UserError, msg unless headers.include?(key)
+
         column(key).items
       else
         raise UserError, "cannot index table with a #{key.class}"
@@ -354,6 +367,7 @@ module FatTable
     # Return the number of rows in the Table.
     def size
       return 0 if columns.empty?
+
       columns.first.size
     end
 
@@ -362,6 +376,7 @@ module FatTable
     # Return the number of Columns in the Table.
     def width
       return 0 if columns.empty?
+
       columns.size
     end
 
@@ -400,6 +415,7 @@ module FatTable
       last ||= size - 1
       last = [last, 0].max
       raise UserError, 'first must be <= last' unless first <= last
+
       rows = []
       unless columns.empty?
         first.upto(last) do |rnum|
@@ -413,9 +429,9 @@ module FatTable
       rows
     end
 
-    #############################################################################
+    ############################################################################
     # Enumerable
-    #############################################################################
+    ############################################################################
 
     public
 
@@ -430,9 +446,6 @@ module FatTable
       end
     end
 
-
-    public
-
     # :category: Attributes
 
     # Boundaries mark the last row in each "group" within the table. The last
@@ -490,12 +503,12 @@ module FatTable
       self
     end
 
-    # Mark a group boundary at row +k+, and if +k+ is +nil+, mark the last row
-    # in the table as a group boundary. This is mainly used for internal
+    # Mark a group boundary at row +row+, and if +row+ is +nil+, mark the last
+    # row in the table as a group boundary. This is mainly used for internal
     # purposes.
-    def mark_boundary(k = nil) # :nodoc:
-      if k
-        boundaries.push(k)
+    def mark_boundary(row = nil) # :nodoc:
+      if row
+        boundaries.push(row)
       else
         boundaries.push(size - 1)
       end
@@ -505,16 +518,6 @@ module FatTable
 
     # :stopdoc:
 
-    # Reader for boundaries, but not public.
-    def boundaries
-      @boundaries
-    end
-
-    # Writer for boundaries, but not public.
-    def boundaries=(bounds)
-      @boundaries = bounds
-    end
-
     # Make sure size - 1 is last boundary and that they are unique and sorted.
     def normalize_boundaries
       unless empty?
@@ -531,20 +534,21 @@ module FatTable
       @boundaries += bounds.map { |k| k + shift }
     end
 
-    # Return the group number to which row k belongs. Groups, from the user's
-    # point of view are indexed starting at 1.
-    def row_index_to_group_index(k)
+    # Return the group number to which row ~row~ belongs. Groups, from the
+    # user's point of view are indexed starting at 1.
+    def row_index_to_group_index(row)
       boundaries.each_with_index do |b_last, g_num|
-        return (g_num + 1) if k <= b_last
+        return (g_num + 1) if row <= b_last
       end
       1
     end
 
-    def group_rows(k) # :nodoc:
+    def group_rows(row) # :nodoc:
       normalize_boundaries
-      return [] unless k < boundaries.size
-      first = k.zero? ? 0 : boundaries[k - 1] + 1
-      last = boundaries[k]
+      return [] unless row < boundaries.size
+
+      first = row.zero? ? 0 : boundaries[row - 1] + 1
+      last = boundaries[row]
       rows_range(first, last)
     end
 
@@ -682,9 +686,8 @@ module FatTable
         ivars = ivars.merge(new_cols[:ivars])
         new_cols.delete(:ivars)
       end
-      before_hook = '@row += 1'
       if new_cols.key?(:before_hook)
-        before_hook += "; #{new_cols[:before_hook]}"
+        before_hook = new_cols[:before_hook].to_s
         new_cols.delete(:before_hook)
       end
       after_hook = nil
@@ -702,32 +705,37 @@ module FatTable
         # Set the group number in the before hook and run the hook with the
         # local variables set to the row before the new row is evaluated.
         grp = row_index_to_group_index(old_k)
-        vars = old_row.merge(__group: grp)
-        ev.eval_before_hook(vars)
+        ev.update_ivars(row: old_k + 1, group: grp)
+        ev.eval_before_hook(locals: old_row)
         # Compute the new row.
         new_row = {}
         cols.each do |k|
           h = k.as_sym
-          raise UserError, "Column '#{h}' in select does not exist" unless column?(h)
+          msg = "Column '#{h}' in select does not exist"
+          raise UserError, msg unless column?(h)
+
           new_row[h] = old_row[h]
         end
-        new_cols.each_pair do |key, val|
+        new_cols.each_pair do |key, expr|
           key = key.as_sym
           vars = old_row.merge(new_row)
-          case val
+          case expr
           when Symbol
-            raise UserError, "Column '#{val}' in select does not exist" unless vars.keys.include?(val)
-            new_row[key] = vars[val]
+            msg = "Column '#{expr}' in select does not exist"
+            raise UserError, msg unless vars.key?(expr)
+
+            new_row[key] = vars[expr]
           when String
-            new_row[key] = ev.evaluate(val, vars: vars)
+            new_row[key] = ev.evaluate(expr, locals: vars)
           else
-            raise UserError, "Hash parameter '#{key}' to select must be a symbol or string"
+            msg = "Hash parameter '#{key}' to select must be a symbol or string"
+            raise UserError, msg
           end
         end
         # Set the group number and run the hook with the local variables set to
         # the row after the new row is evaluated.
-        vars = new_row.merge(__group: grp)
-        ev.eval_after_hook(vars)
+        # vars = new_row.merge(__group: grp)
+        ev.eval_after_hook(locals: new_row)
         result << new_row
       end
       result.boundaries = boundaries
@@ -753,14 +761,13 @@ module FatTable
         col = Column.new(header: h)
         result.add_column(col)
       end
-      ev = Evaluator.new(ivars: { row: 0, group: 0 },
-                         before: '@row += 1')
+      ev = Evaluator.new(ivars: { row: 0, group: 0 })
       rows.each_with_index do |row, k|
         grp = row_index_to_group_index(k)
-        vars = row.merge(__group: grp)
-        ev.eval_before_hook(vars)
-        result << row if ev.evaluate(expr, vars: vars)
-        ev.eval_after_hook(vars)
+        ev.update_ivars(row: k + 1, group: grp)
+        ev.eval_before_hook(locals: row)
+        result << row if ev.evaluate(expr, locals: row)
+        ev.eval_after_hook(locals: row)
       end
       result.normalize_boundaries
       result
@@ -870,22 +877,24 @@ module FatTable
 
     private
 
-    # Apply the set operation given by op between this table and the other table
-    # given in the first argument.  If distinct is true, eliminate duplicates
-    # from the result.
-    def set_operation(other, op = :+,
+    # Apply the set operation given by ~oper~ between this table and the other
+    # table given in the first argument.  If distinct is true, eliminate
+    # duplicates from the result.
+    def set_operation(other, oper = :+,
                       distinct: true,
                       add_boundaries: true,
                       inherit_boundaries: false)
       unless columns.size == other.columns.size
-        raise UserError, 'Cannot apply a set operation to tables with a different number of columns.'
+        msg = "can't apply set ops to tables with a different number of columns"
+        raise UserError, msg
       end
       unless columns.map(&:type) == other.columns.map(&:type)
-        raise UserError, 'Cannot apply a set operation to tables with different column types.'
+        msg = "can't apply a set ops to tables with different column types."
+        raise UserError, msg
       end
       other_rows = other.rows.map { |r| r.replace_keys(headers) }
       result = Table.new
-      new_rows = rows.send(op, other_rows)
+      new_rows = rows.send(oper, other_rows)
       new_rows.each_with_index do |row, k|
         result << row
         result.mark_boundary if k == size - 1 && add_boundaries
@@ -902,7 +911,7 @@ module FatTable
     public
 
     # An Array of symbols for the valid join types.
-    JOIN_TYPES = [:inner, :left, :right, :full, :cross].freeze
+    JOIN_TYPES = %i[inner left right full cross].freeze
 
     # :category: Operators
     #
@@ -979,10 +988,12 @@ module FatTable
       unless JOIN_TYPES.include?(join_type)
         raise UserError, "join_type may only be: #{JOIN_TYPES.join(', ')}"
       end
+
       # These may be needed for outer joins.
       self_row_nils = headers.map { |h| [h, nil] }.to_h
       other_row_nils = other.headers.map { |h| [h, nil] }.to_h
-      join_expression, other_common_heads = build_join_expression(exps, other, join_type)
+      join_exp, other_common_heads =
+        build_join_expression(exps, other, join_type)
       ev = Evaluator.new
       result = Table.new
       other_rows = other.rows
@@ -993,27 +1004,29 @@ module FatTable
           # Same as other_row, but with keys that are common with self and equal
           # in value, removed, so the output table need not repeat them.
           locals = build_locals_hash(row_a: self_row, row_b: other_row)
-          matches = ev.evaluate(join_expression, vars: locals)
+          matches = ev.evaluate(join_exp, locals: locals)
           next unless matches
+
           self_row_matched = other_row_matches[k] = true
           out_row = build_out_row(row_a: self_row, row_b: other_row,
                                   common_heads: other_common_heads,
                                   type: join_type)
           result << out_row
         end
-        if join_type == :left || join_type == :full
-          unless self_row_matched
-            out_row = build_out_row(row_a: self_row, row_b: other_row_nils, type: join_type)
-            result << out_row
-          end
-        end
+        next unless %i[left full].include?(join_type)
+        next if self_row_matched
+
+        result << build_out_row(row_a: self_row,
+                                row_b: other_row_nils,
+                                type: join_type)
       end
-      if join_type == :right || join_type == :full
+      if %i[right full].include?(join_type)
         other_rows.each_with_index do |other_row, k|
-          unless other_row_matches[k]
-            out_row = build_out_row(row_a: self_row_nils, row_b: other_row, type: join_type)
-            result << out_row
-          end
+          next if other_row_matches[k]
+
+          result << build_out_row(row_a: self_row_nils,
+                                  row_b: other_row,
+                                  type: join_type)
         end
       end
       result.normalize_boundaries
@@ -1094,14 +1107,15 @@ module FatTable
     # and all the headers in the other table with '_b' appended.
     def build_join_expression(exps, other, type)
       return ['true', []] if type == :cross
+
       a_heads = headers
       b_heads = other.headers
       common_heads = a_heads & b_heads
       b_common_heads = []
       if exps.empty?
         if common_heads.empty?
-          raise UserError,
-                'A non-cross join with no common column names requires join expressions'
+          msg = "#{type}-join with no common column names needs join expression"
+          raise UserError, msg
         else
           # A Natural join on all common heads
           common_heads.each do |h|
@@ -1124,9 +1138,12 @@ module FatTable
               unless a_heads.include?(a_head)
                 raise UserError, "no column '#{a_head}' in table"
               end
+
               if partial_result
                 # Second of a pair
-                ensure_common_types!(self_h: a_head, other_h: last_sym, other: other)
+                ensure_common_types!(self_h: a_head,
+                                     other_h: last_sym,
+                                     other: other)
                 partial_result << "#{a_head}_a)"
                 and_conds << partial_result
                 partial_result = nil
@@ -1140,9 +1157,12 @@ module FatTable
               unless b_heads.include?(b_head)
                 raise UserError, "no column '#{b_head}' in second table"
               end
+
               if partial_result
                 # Second of a pair
-                ensure_common_types!(self_h: last_sym, other_h: b_head, other: other)
+                ensure_common_types!(self_h: last_sym,
+                                     other_h: b_head,
+                                     other: other)
                 partial_result << "#{b_head}_b)"
                 and_conds << partial_result
                 partial_result = nil
@@ -1158,12 +1178,13 @@ module FatTable
                 # We were expecting the second of a modified pair, but got an
                 # unmodified symbol instead.
                 msg =
-                  "must follow '#{last_sym}' by qualified exp from the other table"
+                  "follow '#{last_sym}' by qualified exp from the other table"
                 raise UserError, msg
               end
               # We have an unqualified symbol that must appear in both tables
               unless common_heads.include?(exp)
-                raise UserError, "unqualified column '#{exp}' must occur in both tables"
+                msg = "unqualified column '#{exp}' must occur in both tables"
+                raise UserError, msg
               end
               ensure_common_types!(self_h: exp, other_h: exp, other: other)
               and_conds << "(#{exp}_a == #{exp}_b)"
@@ -1174,7 +1195,8 @@ module FatTable
             # qualified.
             and_conds << "(#{exp})"
           else
-            raise UserError, "invalid join expression '#{exp}' of class #{exp.class}"
+            msg = "invalid join expression '#{exp}' of class #{exp.class}"
+            raise UserError, msg
           end
         end
         [and_conds.join(' && '), b_common_heads]
@@ -1185,15 +1207,15 @@ module FatTable
     # have the same types.
     def ensure_common_types!(self_h:, other_h:, other:)
       unless column(self_h).type == other.column(other_h).type
-        raise UserError,
-              "type of column '#{self_h}' does not match type of column '#{other_h}"
+        msg = "column '#{self_h}' type does not match column '#{other_h}"
+        raise UserError, msg
       end
       self
     end
 
-    ###################################################################################
+    ############################################################################
     # Group By
-    ###################################################################################
+    ############################################################################
 
     public
 
@@ -1268,7 +1290,7 @@ module FatTable
 
     # :category: Constructors
 
-    # Add a +row+ without marking it as a group boundary.
+    # Add a +row+ to this Table without marking it as a group boundary.
     def <<(row)
       add_row(row)
     end
@@ -1277,7 +1299,9 @@ module FatTable
 
     # Add a FatTable::Column object +col+ to the table.
     def add_column(col)
-      raise "Table already has a column with header '#{col.header}'" if column?(col.header)
+      msg = "Table already has a column with header '#{col.header}'"
+      raise msg if column?(col.header)
+
       columns << col
       self
     end
@@ -1324,7 +1348,9 @@ module FatTable
     #
     def to_any(fmt_type, options = {})
       fmt = fmt_type.as_sym
-      raise UserError, "unknown format '#{fmt}'" unless FatTable::FORMATS.include?(fmt)
+      msg = "unknown format '#{fmt}'"
+      raise UserError, msg unless FatTable::FORMATS.include?(fmt)
+
       method = "to_#{fmt}"
       if block_given?
         send method, options, &Proc.new
@@ -1343,7 +1369,7 @@ module FatTable
     # default format for Formatter, there is no class PsvFormatter as you might
     # expect.
     def to_psv(options = {})
-      fmt = Formatter.new(self, options)
+      fmt = Formatter.new(self, **options)
       yield fmt if block_given?
       fmt.output
     end
@@ -1356,7 +1382,7 @@ module FatTable
     # the block to which formatting instructions and footers can be added by
     # calling methods on it.
     def to_aoa(options = {})
-      fmt = FatTable::AoaFormatter.new(self, options)
+      fmt = FatTable::AoaFormatter.new(self, **options)
       yield fmt if block_given?
       fmt.output
     end
@@ -1370,7 +1396,7 @@ module FatTable
     # given, it yields an AohFormatter to the block to which formatting
     # instructions and footers can be added by calling methods on it.
     def to_aoh(options = {})
-      fmt = AohFormatter.new(self, options)
+      fmt = AohFormatter.new(self, **options)
       yield fmt if block_given?
       fmt.output
     end
@@ -1383,7 +1409,7 @@ module FatTable
     # LaTeXFormatter to the block to which formatting instructions and footers
     # can be added by calling methods on it.
     def to_latex(options = {})
-      fmt = LaTeXFormatter.new(self, options)
+      fmt = LaTeXFormatter.new(self, **options)
       yield fmt if block_given?
       fmt.output
     end
@@ -1396,7 +1422,7 @@ module FatTable
     # OrgFormatter to the block to which formatting instructions and footers can
     # be added by calling methods on it.
     def to_org(options = {})
-      fmt = OrgFormatter.new(self, options)
+      fmt = OrgFormatter.new(self, **options)
       yield fmt if block_given?
       fmt.output
     end
@@ -1409,7 +1435,7 @@ module FatTable
     # given, it yields a TermFormatter to the block to which formatting
     # instructions and footers can be added by calling methods on it.
     def to_term(options = {})
-      fmt = TermFormatter.new(self, options)
+      fmt = TermFormatter.new(self, **options)
       yield fmt if block_given?
       fmt.output
     end
@@ -1423,7 +1449,7 @@ module FatTable
     # footers can be added by calling methods on it.
     # @return [String]
     def to_text(options = {})
-      fmt = TextFormatter.new(self, options)
+      fmt = TextFormatter.new(self, **options)
       yield fmt if block_given?
       fmt.output
     end