fat_table 0.2.6 → 0.2.7

data/lib/fat_table/formatters/latex_formatter.rb

@@ -25,7 +25,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 +76,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

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] = '|'
@@ -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
@@ -219,7 +217,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
@@ -253,7 +251,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 +285,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] = '+'
@@ -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,30 @@ 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?(re)
+      self =~ re
+    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)
+  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
@@ -140,8 +140,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
@@ -151,7 +151,8 @@ module FatTable
     # 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.
     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.set_db'
+      raise UserError, msg if FatTable.db.nil?
       result = Table.new
       FatTable.db[query].each do |h|
         result << h
@@ -166,15 +167,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 +221,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 +256,15 @@ 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
@@ -311,13 +314,16 @@ 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}"
@@ -413,9 +419,9 @@ module FatTable
       rows
     end
 
-    #############################################################################
+    ############################################################################
     # Enumerable
-    #############################################################################
+    ############################################################################
 
     public
 
@@ -430,9 +436,6 @@ module FatTable
       end
     end
 
-
-    public
-
     # :category: Attributes
 
     # Boundaries mark the last row in each "group" within the table. The last
@@ -505,16 +508,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?
@@ -682,9 +675,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 +694,35 @@ 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.keys.include?(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 +748,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
@@ -878,10 +872,12 @@ module FatTable
                       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
@@ -902,7 +898,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
     #
@@ -982,7 +978,8 @@ module FatTable
       # 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,7 +990,7 @@ 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,
@@ -1001,19 +998,18 @@ module FatTable
                                   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
@@ -1100,8 +1096,8 @@ module FatTable
       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|
@@ -1126,7 +1122,9 @@ module FatTable
               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
@@ -1142,7 +1140,9 @@ module FatTable
               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 +1158,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 +1175,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 +1187,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
 
@@ -1277,7 +1279,8 @@ 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 +1327,8 @@ 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