fat_table 0.2.7 → 0.3.1

data/lib/fat_table.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This module provides objects for treating tables as a data type on which you
 # can (1) perform operations, such as select, where, join, and others and (2)
 # output the tables in several formats, including text, ANSI terminal, LaTeX,
@@ -24,6 +26,15 @@ module FatTable
   require 'fat_table/db_handle'
   require 'fat_table/errors'
 
+  # Add paths for common db gems to the load paths
+  %w[pg mysql2 sqlite].each do |gem_name|
+    path = Dir.glob("#{ENV['GEM_HOME']}/gems/#{gem_name}*").sort.last
+    if path
+      path = File.join(path, 'lib')
+      $LOAD_PATH << path unless $LOAD_PATH.include?(path)
+    end
+  end
+
   # Valid output formats as symbols.
   FORMATS = %i[psv aoa aoh latex org term text].freeze
 
@@ -114,7 +125,7 @@ module FatTable
   end
 
   # Construct a Table by running a SQL query against the database set up with
-  # FatTable.set_db. Return the Table with the query results as rows and the
+  # FatTable.connect. Return the Table with the query results as rows and the
   # headers from the query, converted to symbols, as headers.
   def self.from_sql(query)
     Table.from_sql(query)
@@ -149,9 +160,9 @@ module FatTable
     raise UserError, "unknown format '#{fmt}'" unless FORMATS.include?(fmt)
     method = "to_#{fmt}"
     if block_given?
-      send method, table, options, &Proc.new
+      send(method, table, options, &Proc.new)
     else
-      send method, table, options
+      send(method, table, options)
     end
   end
 

data/lib/fat_table/column.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # Column objects are a thin wrapper around an Array to allow columns to be
   # summed and have other aggregate operations performed on them, but compacting
@@ -21,7 +23,7 @@ module FatTable
     attr_reader :type
 
     # An Array of the items of this Column, all of which must be values of the
-    # Columns type or a nil.  This Array contains the value of the item after
+    # Column's type or a nil.  This Array contains the value of the item after
     # conversion to a native Ruby type, such as TrueClass, Date, DateTime,
     # Integer, String, etc.  Thus, you can perform operations on the items,
     # perhaps after removing nils with +.items.compact+.
@@ -92,6 +94,7 @@ module FatTable
       @type = 'NilClass'
       msg = "unknown column type '#{type}"
       raise UserError, msg unless TYPES.include?(@type.to_s)
+
       @items = []
       items.each { |i| self << i }
     end
@@ -103,8 +106,8 @@ module FatTable
     # :category: Attributes
 
     # Return the item of the Column at the given index.
-    def [](k)
-      items[k]
+    def [](idx)
+      items[idx]
     end
 
     # :category: Attributes
@@ -229,11 +232,13 @@ module FatTable
     # average back to a DateTime.
     def avg
       only_with('avg', 'DateTime', 'Numeric')
+      itms = items.compact
+      size = itms.size.to_d
       if type == 'DateTime'
-        avg_jd = items.compact.map(&:jd).sum / items.compact.size.to_d
+        avg_jd = itms.map(&:jd).sum / size
         DateTime.jd(avg_jd)
       else
-        sum / items.compact.size.to_d
+        itms.sum / size
       end
     end
 
@@ -480,34 +485,41 @@ module FatTable
       end
     end
 
-    IS0_DATE_RE = %r{\b(\d\d\d\d)[-/](\d\d?)[-/](\d\d?)\s*
-                     (T\d\d:\d\d:\d\d(\+\d\d:\d\d)?)?\b}x
-    AMR_DATE_RE = %r{\b(\d\d?)[-/](\d\d?)[-/](\d\d\d\d)\s*
-                     (T\d\d:\d\d:\d\d(\+\d\d:\d\d)?)?\b}x
+    ISO_DATE_RE = %r{(?<yr>\d\d\d\d)[-\/]
+                (?<mo>\d\d?)[-\/]
+                (?<dy>\d\d?)\s*
+                (T?\s*\d\d:\d\d(:\d\d)?
+                ([-+](\d\d?)(:\d\d?))?)?}x
+
+    AMR_DATE_RE = %r{(?<dy>\d\d?)[-/](?<mo>\d\d?)[-/](?<yr>\d\d\d\d)\s*
+                     (?<tm>T\d\d:\d\d:\d\d(\+\d\d:\d\d)?)?}x
 
-    # Convert the val to a DateTime if it is either a DateTime, a Date, or a
+    # Convert the val to a DateTime if it is either a DateTime, a Date, a Time, or a
     # String that can be parsed as a DateTime, otherwise return nil. It only
-    # recognizes strings that contain a something like '2016-01-14' or
-    # '2/12/1985' within them, otherwise DateTime.parse would treat many bare
-    # numbers as dates, such as '2841381', which it would recognize as a valid
-    # date, but the user probably does not intend it to be so treated.
+    # recognizes strings that contain a something like '2016-01-14' or '2/12/1985'
+    # within them, otherwise DateTime.parse would treat many bare numbers as dates,
+    # such as '2841381', which it would recognize as a valid date, but the user
+    # probably does not intend it to be so treated.
     def convert_to_date_time(val)
       return val if val.is_a?(DateTime)
       return val if val.is_a?(Date)
       begin
-        val = val.to_s.clean
-        return nil if val.blank?
-        if val.match?(IS0_DATE_RE)
-          val = DateTime.parse(val)
-        elsif val =~ AMR_DATE_RE
-          val = DateTime.new($3.to_i, $1.to_i, $2.to_i)
+        str = val.to_s.clean
+        return nil if str.blank?
+
+        if str.match(ISO_DATE_RE)
+          date = DateTime.parse(val)
+        elsif str =~ AMR_DATE_RE
+          date = DateTime.new(Regexp.last_match[:yr].to_i,
+                         Regexp.last_match[:mo].to_i,
+                         Regexp.last_match[:dy].to_i)
         else
           return nil
         end
-        val = val.to_date if val.seconds_since_midnight.zero?
-        val
+        # val = val.to_date if
+        date.seconds_since_midnight.zero? ? date.to_date : date
       rescue ArgumentError
-        return nil
+        nil
       end
     end
 
@@ -515,7 +527,7 @@ module FatTable
     # looks like one. Any Float is promoted to a BigDecimal. Otherwise return
     # nil.
     def convert_to_numeric(val)
-      return BigDecimal.new(val, Float::DIG) if val.is_a?(Float)
+      return BigDecimal(val, Float::DIG) if val.is_a?(Float)
       return val if val.is_a?(Numeric)
       # Eliminate any commas, $'s (or other currency symbol), or _'s.
       cursym = Regexp.quote(FatTable.currency_symbol)
@@ -524,11 +536,11 @@ module FatTable
       return nil if val.blank?
       case val
       when /(\A[-+]?\d+\.\d*\z)|(\A[-+]?\d*\.\d+\z)/
-        BigDecimal.new(val.to_s.clean)
+        BigDecimal(val.to_s.clean)
       when /\A[-+]?[\d]+\z/
         val.to_i
-      when %r{\A([-+]?\d+)\s*[:/]\s*([-+]?\d+)\z}
-        Rational($1, $2)
+      when %r{\A(?<nm>[-+]?\d+)\s*[:/]\s*(?<dn>[-+]?\d+)\z}
+        Rational(Regexp.last_match[:nm], Regexp.last_match[:dn])
       end
     end
 

data/lib/fat_table/db_handle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Set and access a database by module-level methods.
 module FatTable
   class << self
@@ -18,10 +20,11 @@ module FatTable
   #    Sequel's adapter-specific connection methods.
   #    http://sequel.jeremyevans.net/rdoc/files/doc/opening_databases_rdoc.html
   #
-  # +driver+::
+  # +adapter+::
   #    One of 'pg' (for Postgresql), 'mysql' or 'mysql2' (for Mysql), or
-  #    'sqlite' (for SQLite3) to specify the +Sequel+ driver to use. You may
-  #    have to install the driver to make this work. By default use 'Pg'.
+  #    'sqlite' (for SQLite3) (or any other adapter supported by the +Sequel+
+  #    gem) to specify the driver to use. You may have to install the
+  #    appropriate driver to make this work.
   #
   # +database+::
   #    The name of the database to access. There is no default for this.
@@ -51,63 +54,32 @@ module FatTable
   # successfully, this establishes the database handle to use for all subsequent
   # calls to FatTable.from_sql or FatTable::Table.from_sql. You can then access
   # the handle if needed with FatTable.db.
-  def self.set_db(args)
+  def self.connect(args)
     # Set the dsn for Sequel
     begin
       self.handle = Sequel.connect(args)
-    rescue Sequel::Error => ex
-      raise TransientError, "#{args}: #{ex}"
+    rescue Sequel::AdapterNotFound => ex
+      case ex.to_s
+      when /pg/
+        raise TransientError, 'You need to install the postgres adapter pg'
+      when /mysql/
+        raise TransientError, 'You need to install the mysql adapter'
+      when /sqlite/
+        raise TransientError, 'You need to install the sqlite adapter'
+      else
+        raise ex
+      end
     end
     handle
   end
 
-  # def self.set_db(adapter: 'postgres',
-  #                 database:,
-  #                 user: ENV['LOGNAME'],
-  #                 password: nil,
-  #                 host: 'localhost',
-  #                 port: nil,
-  #                 socket: '/tmp/.s.PGSQL.5432')
-  #   if db
-  #     self.handle = db
-  #   else
-  #     raise UserError, 'must supply database name to set_db' unless database
-
-  #     valid_drivers = %w[postgres mysql mysql2 sqlite]
-  #     unless valid_drivers.include?(driver)
-  #       msg = "'#{driver}' driver must be one of #{valid_drivers.join(' or ')}"
-  #       raise UserError, msg
-  #     end
-  #     if database.blank?
-  #       raise UserError, 'must supply database parameter to set_db'
-  #     end
-
-  #     if driver == 'sqlite'
-  #       dsn = "sqlite://#{database}"
-  #     else
-  #       pw_part = password ? ":#{password}" : ''
-  #       hst_part = host ? "@#{host}" : ''
-  #       prt_part = port ? ":#{port}" : ''
-  #       dsn = "#{driver}:://#{user}#{pw_part}#{hst_part}#{prt_part}/#{database}"
-  #     end
-
-  #     # Set the dsn for Sequel
-  #     begin
-  #       self.handle = Sequel.connect(dsn)
-  #     rescue Sequel::Error => ex
-  #       raise TransientError, "#{dsn}: #{ex}"
-  #     end
-  #   end
-  #   handle
-  # end
-
   # Return the +Sequel+ database handle.
   def self.db
     handle
   end
 
   # Directly set the db handle to a Sequel connection formed without
-  # FatTable.set_db.
+  # FatTable.connect.
   def self.db=(db)
     self.handle = db
   end

data/lib/fat_table/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # Raised when the caller of the code made an error that the caller can
   # correct.

data/lib/fat_table/evaluator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # The Evaluator class provides a class for evaluating Ruby expressions based
   # on variable settings provided at runtime. If the same Evaluator object is
@@ -20,23 +22,25 @@ module FatTable
     def initialize(ivars: {}, before: nil, after: nil)
       @before = before
       @after = after
-      set_instance_vars(ivars)
+      instance_vars(ivars)
     end
 
     # Set the @group instance variable to the given value.
     def update_ivars(ivars)
-      set_instance_vars(ivars)
+      instance_vars(ivars)
     end
 
     # Run any before hook in the context of the given local variables.
     def eval_before_hook(locals: {})
       return if @before.blank?
+
       evaluate(@before, locals: locals)
     end
 
     # Run any after hook in the context of the given local variables.
     def eval_after_hook(locals: {})
       return if @after.blank?
+
       evaluate(@after, locals: locals)
     end
 
@@ -44,19 +48,21 @@ module FatTable
     # instance variables set in Evaluator.new and any local variables set in the
     # Hash parameter +locals+ are available to the expression.
     def evaluate(expr = '', locals: {})
-      eval(expr, set_local_vars(binding, locals))
+      eval(expr, local_vars(binding, locals))
     end
 
     private
 
-    def set_instance_vars(vars = {})
+    # Set the instance variables according to Hash vars.
+    def instance_vars(vars = {})
       vars.each_pair do |name, val|
         name = "@#{name}" unless name.to_s.start_with?('@')
         instance_variable_set(name, val)
       end
     end
 
-    def set_local_vars(bnd, vars = {})
+    # Set the local variables within the binding bnd according to Hash vars.
+    def local_vars(bnd, vars = {})
       vars.each_pair do |name, val|
         bnd.local_variable_set(name, val)
       end

data/lib/fat_table/formatters.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fat_table/formatters/formatter'
 require 'fat_table/formatters/aoa_formatter'
 require 'fat_table/formatters/aoh_formatter'

data/lib/fat_table/formatters/aoa_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # A subclass of Formatter for rendering the table as a Ruby Array of Arrays.
   # Each cell is formatted as a string in accordance with the formatting
@@ -30,20 +32,20 @@ module FatTable
       '['
     end
 
-    def pre_cell(_h)
+    def pre_cell(_val)
       "'"
     end
 
     # Because the cell, after conversion to a single-quoted string will be
     # eval'ed, we need to escape any single-quotes (') that appear in the
     # string.
-    def quote_cell(v)
-      if v.match?(/'/)
+    def quote_cell(val)
+      if val.match?(/'/)
         # Use a negative look-behind to only quote single-quotes that are not
         # already preceded by a backslash
-        v.gsub(/(?<!\\)'/, "'" => "\\'")
+        val.gsub(/(?<!\\)'/, "'" => "\\'")
       else
-        v
+        val
       end
     end
 

data/lib/fat_table/formatters/aoh_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # A subclass of Formatter for rendering the table as a Ruby Array of Hashes.
   # Each row of the Array is a Hash representing one row of the table with the
@@ -30,20 +32,20 @@ module FatTable
       '{'
     end
 
-    def pre_cell(h)
-      ":#{h.as_sym} => '"
+    def pre_cell(head)
+      ":#{head.as_sym} => '"
     end
 
     # Because the cell, after conversion to a single-quoted string will be
     # eval'ed, we need to escape any single-quotes (') that appear in the
     # string.
-    def quote_cell(v)
-      if v.match?(/'/)
+    def quote_cell(val)
+      if val.match?(/'/)
         # Use a negative look-behind to only quote single-quotes that are not
         # already preceded by a backslash
-        v.gsub(/(?<!\\)'/, "'" => "\\'")
+        val.gsub(/(?<!\\)'/, "'" => "\\'")
       else
-        v
+        val
       end
     end
 

data/lib/fat_table/formatters/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # A Formatter is for use in Table output routines, and provides methods for
   # adding group and table footers to the output and instructions for how the
@@ -73,7 +75,7 @@ module FatTable
       false_color: 'none',
       false_bgcolor: 'none',
       underline: false,
-      blink: false
+      blink: false,
     }
 
     class_attribute :valid_colors
@@ -92,9 +94,10 @@ module FatTable
     # Formatter is yielded to the block so that methods for formatting and
     # adding footers can be called on it.
     def initialize(table = Table.new, **options)
-      unless table && table.is_a?(Table)
+      unless table&.is_a?(Table)
         raise UserError, 'must initialize Formatter with a Table'
       end
+
       @table = table
       @options = options
       @footers = {}
@@ -170,12 +173,14 @@ module FatTable
         unless table.headers.include?(h)
           raise UserError, "No '#{h}' column in table to sum in the footer"
         end
+
         foot[h] = :sum
       end
       agg_cols.each do |h, agg|
         unless table.headers.include?(h)
           raise UserError, "No '#{h}' column in table to #{agg} in the footer"
         end
+
         foot[h] = agg
       end
       @footers[label] = foot
@@ -208,12 +213,14 @@ module FatTable
         unless table.headers.include?(h)
           raise UserError, "No '#{h}' column in table for group sum footer"
         end
+
         foot[h] = :sum
       end
       agg_cols.each do |h, agg|
         unless table.headers.include?(h)
           raise UserError, "No '#{h}' column in table for #{agg} group footer"
         end
+
         foot[h] = agg
       end
       @gfooters[label] = foot
@@ -242,7 +249,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :avg
       end
-      footer('Average', hsh)
+      footer('Average', **hsh)
     end
 
     # :category: Footers
@@ -253,7 +260,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :avg
       end
-      gfooter('Group Average', hsh)
+      gfooter('Group Average', **hsh)
     end
 
     # :category: Footers
@@ -265,7 +272,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :min
       end
-      footer('Minimum', hsh)
+      footer('Minimum', **hsh)
     end
 
     # :category: Footers
@@ -277,7 +284,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :min
       end
-      gfooter('Group Minimum', hsh)
+      gfooter('Group Minimum', **hsh)
     end
 
     # :category: Footers
@@ -289,7 +296,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :max
       end
-      footer('Maximum', hsh)
+      footer('Maximum', **hsh)
     end
 
     # :category: Footers
@@ -301,7 +308,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :max
       end
-      gfooter('Group Maximum', hsh)
+      gfooter('Group Maximum', **hsh)
     end
 
     # :category: Formatting
@@ -413,7 +420,7 @@ module FatTable
     # \n\[niltext\]:: render a nil item with the given text.
     def format(**fmts)
       %i[header bfirst gfirst body footer gfooter].each do |loc|
-        format_for(loc, fmts)
+        format_for(loc, **fmts)
       end
       self
     end
@@ -466,6 +473,7 @@ module FatTable
       unless LOCATIONS.include?(location)
         raise UserError, "unknown format location '#{location}'"
       end
+
       valid_keys = table.headers + %i[string numeric datetime boolean nil]
       invalid_keys = (fmts.keys - valid_keys).uniq
       unless invalid_keys.empty?
@@ -487,18 +495,18 @@ module FatTable
           # Merge in string and nil formatting, but not in header.  Header is
           # always typed a string, so it will get formatted in type-based
           # formatting below. And headers are never nil.
-          if fmts.keys.include?(:string)
+          if fmts.key?(:string)
             typ_fmt = parse_string_fmt(fmts[:string])
             format_h = format_h.merge(typ_fmt)
           end
-          if fmts.keys.include?(:nil)
+          if fmts.key?(:nil)
             typ_fmt = parse_nil_fmt(fmts[:nil]).first
             format_h = format_h.merge(typ_fmt)
           end
         end
         typ = location == :header ? :string : table.type(h).as_sym
         parse_typ_method_name = 'parse_' + typ.to_s + '_fmt'
-        if fmts.keys.include?(typ)
+        if fmts.key?(typ)
           # Merge in type-based formatting
           typ_fmt = send(parse_typ_method_name, fmts[typ])
           format_h = format_h.merge(typ_fmt)
@@ -547,7 +555,7 @@ module FatTable
     private
 
     # Re to match a color name
-    CLR_RE = /(?:[-_a-zA-Z0-9 ]*)/
+    CLR_RE = /(?:[-_a-zA-Z0-9 ]*)/.freeze
 
     # Return a hash that reflects the formatting instructions given in the
     # string fmt. Raise an error if it contains invalid formatting instructions.
@@ -558,6 +566,7 @@ module FatTable
       unless fmt.blank? || !strict
         raise UserError, "unrecognized string formatting instructions '#{fmt}'"
       end
+
       format
     end
 
@@ -570,9 +579,9 @@ 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\[(#{CLR_RE})(\.(#{CLR_RE}))?\]/
-        fmt_hash[:color] = $1 unless $1.blank?
-        fmt_hash[:bgcolor] = $3 unless $3.blank?
+      if fmt =~ /c\[(?<co>#{CLR_RE})(\.(?<bg>#{CLR_RE}))?\]/
+        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($&, '')
@@ -592,12 +601,12 @@ module FatTable
         fmt_hash[:case] = :title
         fmt = fmt.sub($&, '')
       end
-      if fmt =~ /(~\s*)?B/
-        fmt_hash[:bold] = !$1
+      if fmt =~ /(?<neg>~\s*)?B/
+        fmt_hash[:bold] = !Regexp.last_match[:neg]
         fmt = fmt.sub($&, '')
       end
-      if fmt =~ /(~\s*)?I/
-        fmt_hash[:italic] = !$1
+      if fmt =~ /(?<neg>~\s*)?I/
+        fmt_hash[:italic] = !Regexp.last_match[:neg]
         fmt = fmt.sub($&, '')
       end
       if fmt =~ /R/
@@ -612,12 +621,12 @@ module FatTable
         fmt_hash[:alignment] = :left
         fmt = fmt.sub($&, '')
       end
-      if fmt =~ /(~\s*)?_/
-        fmt_hash[:underline] = !$1
+      if fmt =~ /(?<neg>~\s*)?_/
+        fmt_hash[:underline] = !Regexp.last_match[:neg]
         fmt = fmt.sub($&, '')
       end
-      if fmt =~ /(~\s*)?\*/
-        fmt_hash[:blink] = !$1
+      if fmt =~ /(?<neg>~\s*)?\*/
+        fmt_hash[:blink] = !Regexp.last_match[:neg]
         fmt = fmt.sub($&, '')
       end
       [fmt_hash, fmt]
@@ -632,9 +641,9 @@ 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 =~ /n\[\s*([^\]]*)\s*\]/
-        fmt_hash[:nil_text] = $1.clean
-        fmt = fmt.sub($&, '')
+      if fmt =~ /n\[\s*(?<bdy>[^\]]*)\s*\]/
+        fmt_hash[:nil_text] = Regexp.last_match[:bdy].clean
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
       [fmt_hash, fmt]
     end
@@ -648,26 +657,27 @@ module FatTable
       # parse, we remove the matched construct from fmt.  At the end, any
       # remaining characters in fmt should be invalid.
       fmt_hash, fmt = parse_str_fmt(fmt)
-      if fmt =~ /(\d+).(\d+)/
-        fmt_hash[:pre_digits] = $1.to_i
-        fmt_hash[:post_digits] = $2.to_i
-        fmt = fmt.sub($&, '')
+      if fmt =~ /(?<pre>\d+).(?<post>\d+)/
+        fmt_hash[:pre_digits] = Regexp.last_match[:pre].to_i
+        fmt_hash[:post_digits] = Regexp.last_match[:post].to_i
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
-      if fmt =~ /(~\s*)?,/
-        fmt_hash[:commas] = !$1
-        fmt = fmt.sub($&, '')
+      if fmt =~ /(?<neg>~\s*)?,/
+        fmt_hash[:commas] = !Regexp.last_match[:neg]
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
-      if fmt =~ /(~\s*)?\$/
-        fmt_hash[:currency] = !$1
-        fmt = fmt.sub($&, '')
+      if fmt =~ /(?<neg>~\s*)?\$/
+        fmt_hash[:currency] = !Regexp.last_match[:neg]
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
-      if fmt =~ /(~\s*)?H/
-        fmt_hash[:hms] = !$1
-        fmt = fmt.sub($&, '')
+      if fmt =~ /(?<neg>~\s*)?H/
+        fmt_hash[:hms] = !Regexp.last_match[:neg]
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
       unless fmt.blank? || !strict
         raise UserError, "unrecognized numeric formatting instructions '#{fmt}'"
       end
+
       fmt_hash
     end
 
@@ -680,13 +690,13 @@ module FatTable
       # parse, we remove the matched construct from fmt.  At the end, any
       # remaining characters in fmt should be invalid.
       fmt_hash, fmt = parse_str_fmt(fmt)
-      if fmt =~ /d\[([^\]]*)\]/
-        fmt_hash[:date_fmt] = $1
-        fmt = fmt.sub($&, '')
+      if fmt =~ /d\[(?<bdy>[^\]]*)\]/
+        fmt_hash[:date_fmt] = Regexp.last_match[:bdy]
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
-      if fmt =~ /D\[([^\]]*)\]/
-        fmt_hash[:date_fmt] = $1
-        fmt = fmt.sub($&, '')
+      if fmt =~ /D\[(?<bdy>[^\]]*)\]/
+        fmt_hash[:date_fmt] = Regexp.last_match[:bdy]
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
       unless fmt.blank? || !strict
         msg = "unrecognized datetime formatting instructions '#{fmt}'"
@@ -704,41 +714,43 @@ 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 =~ /b\[\s*([^\],]*),([^\]]*)\s*\]/
-        fmt_hash[:true_text] = $1.clean
-        fmt_hash[:false_text] = $2.clean
-        fmt = fmt.sub($&, '')
+      if fmt =~ /b\[\s*(?<t>[^\],]*),(?<f>[^\]]*)\s*\]/
+        fmt_hash[:true_text] = Regexp.last_match[:t].clean
+        fmt_hash[:false_text] = Regexp.last_match[:f].clean
+        fmt = fmt.sub(Regexp.last_match[0], '')
       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
-        fmt_hash[:true_color] = $1 unless $1.blank?
-        fmt_hash[:true_bgcolor] = $3 unless $3.blank?
-        fmt_hash[:false_color] = $4 unless $4.blank?
-        fmt_hash[:false_bgcolor] = $6 unless $6.blank?
-        fmt = fmt.sub($&, '')
+        tco, _, tbg, fco, _, fbg = Regexp.last_match.captures
+        fmt_hash[:true_color] = tco unless tco.blank?
+        fmt_hash[:true_bgcolor] = tbg unless tbg.blank?
+        fmt_hash[:false_color] = fco unless fco.blank?
+        fmt_hash[:false_bgcolor] = fbg unless fbg.blank?
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
       str_fmt_hash, fmt = parse_str_fmt(fmt)
       fmt_hash = fmt_hash.merge(str_fmt_hash)
       if fmt =~ /Y/
         fmt_hash[:true_text] = 'Y'
         fmt_hash[:false_text] = 'N'
-        fmt = fmt.sub($&, '')
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
       if fmt =~ /T/
         fmt_hash[:true_text] = 'T'
         fmt_hash[:false_text] = 'F'
-        fmt = fmt.sub($&, '')
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
       if fmt =~ /X/
         fmt_hash[:true_text] = 'X'
         fmt_hash[:false_text] = ''
-        fmt = fmt.sub($&, '')
+        fmt = fmt.sub(Regexp.last_match[0], '')
       end
       unless fmt.blank? || !strict
         raise UserError, "unrecognized boolean formatting instructions '#{fmt}'"
       end
+
       fmt_hash
     end
 
@@ -810,6 +822,7 @@ module FatTable
     # specializing this method.
     def format_boolean(val, istruct)
       return istruct.nil_text if val.nil?
+
       val ? istruct.true_text : istruct.false_text
     end
 
@@ -820,6 +833,7 @@ module FatTable
     # specializing this method.
     def format_datetime(val, istruct)
       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)
@@ -835,6 +849,7 @@ module FatTable
     # specializing this method.
     def format_numeric(val, istruct)
       return istruct.nil_text if val.nil?
+
       val = val.round(istruct.post_digits) if istruct.post_digits >= 0
       if istruct.hms
         result = val.secs_to_hms
@@ -998,6 +1013,7 @@ module FatTable
       new_rows.each do |loc_row|
         result += hline(widths) if loc_row.nil?
         next if loc_row.nil?
+
         _loc, row = *loc_row
         result += pre_row
         cells = []
@@ -1140,6 +1156,7 @@ module FatTable
       end
       rows.each do |loc_row|
         next if loc_row.nil?
+
         _loc, row = *loc_row
         row.each_pair do |h, (_v, fmt_v)|
           widths[h] ||= 0
@@ -1222,12 +1239,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