fat_table 0.2.6 → 0.3.0

data/lib/fat_table/db_handle.rb

@@ -1,5 +1,6 @@
+# Set and access a database by module-level methods.
 module FatTable
-  class << self;
+  class << self
     # The +Sequel+ database handle to use in calls to +FatTable.from_sql+.
     attr_accessor :handle
   end
@@ -17,21 +18,23 @@ module FatTable
   #    Sequel's adapter-specific connection methods.
   #    http://sequel.jeremyevans.net/rdoc/files/doc/opening_databases_rdoc.html
   #
-  # +driver+::
-  #    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'.
+  # +adapter+::
+  #    One of 'pg' (for Postgresql), 'mysql' or 'mysql2' (for Mysql), or
+  #    '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.
   #
   # +user+::
-  #    The user name to use for accessing the database.  It defaults to nil,
-  #    which may be interpreted as a default user by the Sequel driver being used.
+  #    The user name to use for accessing the database. It defaults to nil,
+  #    which may be interpreted as a default user by the Sequel driver being
+  #    used.
   #
   # +password+::
-  #    The password to use for accessing the database.  It defaults to nil,
-  #    which may be interpreted as a default password by the Sequel driver being used.
+  #    The password to use for accessing the database. It defaults to nil, which
+  #    may be interpreted as a default password by the Sequel driver being used.
   #
   # +host+::
   #    The name of the host on which to look for the database connection,
@@ -39,52 +42,30 @@ module FatTable
   #
   # +port+::
   #    The port number as a string or integer on which to access the database on
-  #    the given host.  Defaults to '5432'.  Only used if host is not 'localhost'.
+  #    the given host. Defaults to '5432'. Only used if host is not 'localhost'.
   #
   # +socket+::
   #    The socket to use to access the database if the host is 'localhost'.
   #    Defaults to the standard socket for the Pg driver, '/tmp/.s.PGSQL.5432'.
   #
-  # If successful the database handle for Sequel is return.
-  # Once called 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(db: nil,
-                  driver: 'postgres',
-                  database:,
-                  user: ENV['LOGNAME'],
-                  password: nil,
-                  host: 'localhost',
-                  port: '5432',
-                  socket: '/tmp/.s.PGSQL.5432')
-    if db
-      self.handle = db
-    else
-      raise UserError, 'must supply database name to set_db' unless database
-
-      valid_drivers = ['postgres', 'mysql', 'mysql2', 'sqlite']
-      unless valid_drivers.include?(driver)
-        raise UserError, "'#{driver}' driver must be one of #{valid_drivers.join(' or ')}"
-      end
-      if database.blank?
-        raise UserError, "must supply database parameter to set_db"
-      end
-
-      if driver == 'sqlite'
-        dsn = "sqlite://#{database}"
+  # If successful the database handle for Sequel is return. Once called
+  # 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.connect(args)
+    # Set the dsn for Sequel
+    begin
+      self.handle = Sequel.connect(args)
+    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
-        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
-        # DB = Sequel.connect(dsn)
-        self.handle = Sequel.connect(dsn)
-      rescue => ex
-        raise TransientError, "#{dsn}: #{ex}"
+        raise ex
       end
     end
     handle
@@ -96,7 +77,7 @@ module FatTable
   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/evaluator.rb

@@ -12,57 +12,59 @@ module FatTable
   # update values of instance variables for use in subsequent calls to
   # #evaluate.
   class Evaluator
-    # Return a new Evaluator object in which the Hash +vars+ defines the
+    # Return a new Evaluator object in which the Hash +ivars+ defines the
     # bindings for instance variables to be available and maintained across all
     # subsequent calls to Evaluator.evaluate. The strings +before+ and +after+
-    # are string expressions that will be evaluated before and after each
+    # are string Ruby expressions that will be evaluated before and after each
     # subsequent call to Evaluator.evaluate.
     def initialize(ivars: {}, before: nil, after: nil)
       @before = before
       @after = after
-      set_instance_vars(ivars)
+      instance_vars(ivars)
     end
 
-    # Run the before hook after setting the @group to grp, passed in as a
-    # parameter.  This is run before any column has been evaluated with the
-    # evaluate method.
-    def eval_before_hook(vars)
-      bdg = binding
-      set_local_vars(vars, bdg)
-      @group = vars[:__group]
-      eval(@before, bdg) if @before
+    # Set the @group instance variable to the given value.
+    def update_ivars(ivars)
+      instance_vars(ivars)
     end
 
-    # Run the after hook.  This is run after each column in the row has been
-    # evaluated with the evaluate method.
-    def eval_after_hook(vars)
-      bdg = binding
-      set_local_vars(vars, bdg)
-      eval(@after, bdg) if @after
+    # 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
 
     # Return the result of evaluating +expr+ as a Ruby expression in which the
     # instance variables set in Evaluator.new and any local variables set in the
-    # Hash parameter +vars+ are available to the expression.
-    def evaluate(expr = '', vars: {})
-      bdg = binding
-      set_local_vars(vars, bdg)
-      eval(expr, bdg)
+    # Hash parameter +locals+ are available to the expression.
+    def evaluate(expr = '', 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(vars = {}, bnd)
+    # 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
+      bnd
     end
   end
 end

data/lib/fat_table/formatters/aoa_formatter.rb

@@ -4,7 +4,6 @@ module FatTable
   # directives. All footers are included as extra Arrays of the output.
   # AoaFormatter supports no +options+
   class AoaFormatter < Formatter
-
     private
 
     def evaluate?
@@ -31,20 +30,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 =~ /'/
+    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

@@ -6,7 +6,6 @@ module FatTable
   # footers are included as extra Hashes of the output. AoaFormatter supports no
   # +options+
   class AohFormatter < Formatter
-
     private
 
     def evaluate?
@@ -31,20 +30,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 =~ /'/
+    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

@@ -12,7 +12,7 @@ module FatTable
   # provided by subclasses will override these for different output targets.
   class Formatter
     # Valid locations in a Table as an array of symbols.
-    LOCATIONS = [:header, :body, :bfirst, :gfirst, :gfooter, :footer].freeze
+    LOCATIONS = %i[header body bfirst gfirst gfooter footer].freeze
 
     # The table that is the subject of the Formatter.
     attr_reader :table
@@ -45,8 +45,9 @@ module FatTable
     # footer content. The value is Hash in which the keys are column symbols and
     # the values are symbols for the aggregate method to be applied to the
     # group's column to provide a value in the group footer for that column.
-    # Thus, +gfooters['Average'][:shares]+ might be set to +:avg+ to indicate that
-    # the +:shares+ column is to be averaged in the group footer labeled 'Average'.
+    # Thus, +gfooters['Average'][:shares]+ might be set to +:avg+ to indicate
+    # that the +:shares+ column is to be averaged in the group footer labeled
+    # 'Average'.
     attr_reader :gfooters
 
     class_attribute :default_format
@@ -91,20 +92,21 @@ 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 = {}
       @gfooters = {}
-      # Formatting instructions for various "locations" within the Table, as
-      # a 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
+      # Formatting instructions for various "locations" within the Table, as a
+      # 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.
       @format_at = {}
-      [:header, :bfirst, :gfirst, :body, :footer, :gfooter].each do |loc|
+      %i[header bfirst gfirst body footer gfooter].each do |loc|
         @format_at[loc] = {}
         table.headers.each do |h|
           fmt_hash = self.class.default_format
@@ -169,12 +171,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
@@ -205,14 +209,16 @@ module FatTable
       foot = {}
       sum_cols.each do |h|
         unless table.headers.include?(h)
-          raise UserError, "No '#{h}' column in table to sum in the group footer"
+          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 to #{agg} in the group footer"
+          raise UserError, "No '#{h}' column in table for #{agg} group footer"
         end
+
         foot[h] = agg
       end
       @gfooters[label] = foot
@@ -241,7 +247,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :avg
       end
-      footer('Average', hsh)
+      footer('Average', **hsh)
     end
 
     # :category: Footers
@@ -252,7 +258,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :avg
       end
-      gfooter('Group Average', hsh)
+      gfooter('Group Average', **hsh)
     end
 
     # :category: Footers
@@ -264,7 +270,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :min
       end
-      footer('Minimum', hsh)
+      footer('Minimum', **hsh)
     end
 
     # :category: Footers
@@ -276,7 +282,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :min
       end
-      gfooter('Group Minimum', hsh)
+      gfooter('Group Minimum', **hsh)
     end
 
     # :category: Footers
@@ -288,7 +294,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :max
       end
-      footer('Maximum', hsh)
+      footer('Maximum', **hsh)
     end
 
     # :category: Footers
@@ -300,7 +306,7 @@ module FatTable
       cols.each do |c|
         hsh[c] = :max
       end
-      gfooter('Group Maximum', hsh)
+      gfooter('Group Maximum', **hsh)
     end
 
     # :category: Formatting
@@ -411,8 +417,8 @@ module FatTable
     #
     # \n\[niltext\]:: render a nil item with the given text.
     def format(**fmts)
-      [:header, :bfirst, :gfirst, :body, :footer, :gfooter].each do |loc|
-        format_for(loc, fmts)
+      %i[header bfirst gfirst body footer gfooter].each do |loc|
+        format_for(loc, **fmts)
       end
       self
     end
@@ -465,7 +471,8 @@ module FatTable
       unless LOCATIONS.include?(location)
         raise UserError, "unknown format location '#{location}'"
       end
-      valid_keys = table.headers + [:string, :numeric, :datetime, :boolean, :nil]
+
+      valid_keys = table.headers + %i[string numeric datetime boolean nil]
       invalid_keys = (fmts.keys - valid_keys).uniq
       unless invalid_keys.empty?
         msg = "invalid #{location} column or type: #{invalid_keys.join(',')}"
@@ -486,32 +493,33 @@ 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)
         end
         if fmts[h]
           # Merge in column formatting
-          col_fmt = send(parse_typ_method_name, fmts[h], strict: location != :header)
+          col_fmt = send(parse_typ_method_name, fmts[h],
+                         strict: location != :header)
           format_h = format_h.merge(col_fmt)
         end
 
         if location == :body
           # Copy :body formatting for column h to :bfirst and :gfirst if they
-          # still have the default formatting. Can be overridden with a format_for
-          # call with those locations.
+          # still have the default formatting. Can be overridden with a
+          # format_for call with those locations.
           format_h.each_pair do |k, v|
             if format_at[:bfirst][h].send(k) == default_format[k]
               format_at[:bfirst][h].send("#{k}=", v)
@@ -538,14 +546,14 @@ module FatTable
       self
     end
 
-    ###############################################################################
+    ############################################################################
     # Parsing and validation routines
-    ###############################################################################
+    ############################################################################
 
     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.
@@ -556,6 +564,7 @@ module FatTable
       unless fmt.blank? || !strict
         raise UserError, "unrecognized string formatting instructions '#{fmt}'"
       end
+
       format
     end
 
@@ -591,11 +600,11 @@ module FatTable
         fmt = fmt.sub($&, '')
       end
       if fmt =~ /(~\s*)?B/
-        fmt_hash[:bold] = !!!$1
+        fmt_hash[:bold] = !$1
         fmt = fmt.sub($&, '')
       end
       if fmt =~ /(~\s*)?I/
-        fmt_hash[:italic] = !!!$1
+        fmt_hash[:italic] = !$1
         fmt = fmt.sub($&, '')
       end
       if fmt =~ /R/
@@ -611,11 +620,11 @@ module FatTable
         fmt = fmt.sub($&, '')
       end
       if fmt =~ /(~\s*)?_/
-        fmt_hash[:underline] = !!!$1
+        fmt_hash[:underline] = !$1
         fmt = fmt.sub($&, '')
       end
       if fmt =~ /(~\s*)?\*/
-        fmt_hash[:blink] = !!!$1
+        fmt_hash[:blink] = !$1
         fmt = fmt.sub($&, '')
       end
       [fmt_hash, fmt]
@@ -652,20 +661,21 @@ module FatTable
         fmt = fmt.sub($&, '')
       end
       if fmt =~ /(~\s*)?,/
-        fmt_hash[:commas] = !!!$1
+        fmt_hash[:commas] = !$1
         fmt = fmt.sub($&, '')
       end
       if fmt =~ /(~\s*)?\$/
-        fmt_hash[:currency] = !!!$1
+        fmt_hash[:currency] = !$1
         fmt = fmt.sub($&, '')
       end
       if fmt =~ /(~\s*)?H/
-        fmt_hash[:hms] = !!!$1
+        fmt_hash[:hms] = !$1
         fmt = fmt.sub($&, '')
       end
       unless fmt.blank? || !strict
         raise UserError, "unrecognized numeric formatting instructions '#{fmt}'"
       end
+
       fmt_hash
     end
 
@@ -687,7 +697,8 @@ module FatTable
         fmt = fmt.sub($&, '')
       end
       unless fmt.blank? || !strict
-        raise UserError, "unrecognized datetime formatting instructions '#{fmt}'"
+        msg = "unrecognized datetime formatting instructions '#{fmt}'"
+        raise UserError, msg
       end
       fmt_hash
     end
@@ -708,7 +719,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}))?\]/
+      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?
@@ -735,12 +747,13 @@ module FatTable
       unless fmt.blank? || !strict
         raise UserError, "unrecognized boolean formatting instructions '#{fmt}'"
       end
+
       fmt_hash
     end
 
-    ###############################################################################
+    ############################################################################
     # Applying formatting
-    ###############################################################################
+    ############################################################################
 
     public
 
@@ -806,6 +819,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
 
@@ -816,6 +830,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)
@@ -831,12 +846,13 @@ 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
         istruct.commas = false
       elsif istruct.currency
-        prec = istruct.post_digits == 0 ? 2 : istruct.post_digits
+        prec = istruct.post_digits.zero? ? 2 : istruct.post_digits
         delim = istruct.commas ? ',' : ''
         result = val.to_s(:currency, precision: prec, delimiter: delim,
                           unit: FatTable.currency_symbol)
@@ -903,9 +919,9 @@ module FatTable
       val
     end
 
-    ###############################################################################
+    ############################################################################
     # Output routines
-    ###############################################################################
+    ############################################################################
 
     public
 
@@ -994,6 +1010,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 = []
@@ -1016,7 +1033,7 @@ module FatTable
     # Return a hash mapping the table's headers to their formatted versions. If
     # a hash of column widths is given, perform alignment within the given field
     # widths.
-    def build_formatted_headers(widths = {})
+    def build_formatted_headers(_widths = {})
       # Don't decorate if this Formatter calls for alignment.  It will be done
       # in the second pass.
       decorate = !aligned?
@@ -1058,7 +1075,8 @@ module FatTable
             grp_col[h] ||= Column.new(header: h)
             grp_col[h] << row[h]
             istruct = format_at[location][h]
-            new_row[h] = [row[h], format_cell(row[h], istruct, decorate: decorate)]
+            new_row[h] = [row[h], format_cell(row[h], istruct,
+                                              decorate: decorate)]
           end
           new_rows << [location, new_row]
           tbl_row_k += 1
@@ -1135,6 +1153,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
@@ -1217,12 +1236,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