fat_table 0.2.6 → 0.2.7

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
@@ -18,20 +19,21 @@ module FatTable
   #    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'.
+  #    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'.
   #
   # +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,57 +41,66 @@ 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}"
-      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}"
-      end
+  # 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(args)
+    # Set the dsn for Sequel
+    begin
+      self.handle = Sequel.connect(args)
+    rescue Sequel::Error => ex
+      raise TransientError, "#{args}: #{ex}"
     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

data/lib/fat_table/evaluator.rb

@@ -12,10 +12,10 @@ 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
@@ -23,31 +23,28 @@ module FatTable
       set_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)
+      set_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 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 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, set_local_vars(binding, locals))
     end
 
     private
@@ -59,10 +56,11 @@ module FatTable
       end
     end
 
-    def set_local_vars(vars = {}, bnd)
+    def set_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?
@@ -39,7 +38,7 @@ module FatTable
     # eval'ed, we need to escape any single-quotes (') that appear in the
     # string.
     def quote_cell(v)
-      if v =~ /'/
+      if v.match?(/'/)
         # Use a negative look-behind to only quote single-quotes that are not
         # already preceded by a backslash
         v.gsub(/(?<!\\)'/, "'" => "\\'")

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?
@@ -39,7 +38,7 @@ module FatTable
     # eval'ed, we need to escape any single-quotes (') that appear in the
     # string.
     def quote_cell(v)
-      if v =~ /'/
+      if v.match?(/'/)
         # Use a negative look-behind to only quote single-quotes that are not
         # already preceded by a backslash
         v.gsub(/(?<!\\)'/, "'" => "\\'")

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
@@ -98,13 +99,13 @@ module FatTable
       @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
@@ -205,13 +206,13 @@ 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
@@ -411,7 +412,7 @@ module FatTable
     #
     # \n\[niltext\]:: render a nil item with the given text.
     def format(**fmts)
-      [:header, :bfirst, :gfirst, :body, :footer, :gfooter].each do |loc|
+      %i[header bfirst gfirst body footer gfooter].each do |loc|
         format_for(loc, fmts)
       end
       self
@@ -465,7 +466,7 @@ 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(',')}"
@@ -504,14 +505,15 @@ module FatTable
         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,9 +540,9 @@ module FatTable
       self
     end
 
-    ###############################################################################
+    ############################################################################
     # Parsing and validation routines
-    ###############################################################################
+    ############################################################################
 
     private
 
@@ -591,11 +593,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 +613,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,15 +654,15 @@ 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
@@ -687,7 +689,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 +711,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?
@@ -738,9 +742,9 @@ module FatTable
       fmt_hash
     end
 
-    ###############################################################################
+    ############################################################################
     # Applying formatting
-    ###############################################################################
+    ############################################################################
 
     public
 
@@ -836,7 +840,7 @@ module FatTable
         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 +907,9 @@ module FatTable
       val
     end
 
-    ###############################################################################
+    ############################################################################
     # Output routines
-    ###############################################################################
+    ############################################################################
 
     public
 
@@ -1016,7 +1020,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 +1062,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