fat_table 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7870805173324438b3a4c2416e4f59fc3830cd7dc9272b30237cfa1a9ac9d20
-  data.tar.gz: 31e1d6f2c8fdabe9459850e8ca1c570028c63eec1c0c2f61a030421e943d9d66
+  metadata.gz: dea0adf5d428fa875a7dda51538a79e514b9095b167d392ef06eae849e563a9f
+  data.tar.gz: d5ac2784c1f569fc1677f596278af3c6a00b1b5736ea1a080667f8a0f0acdd16
 SHA512:
-  metadata.gz: fd60f7879416e544c64c2e1d0efdc4cd349bf496a9c907bf7814d0ddc62c2b170ec46cc9bdb1d241fde7f50c6434233b0b2f4609adce5ec8c2073f32f52fd36e
-  data.tar.gz: f493a05c1b17640a41fffa5bceda6ff01047391a5f9ccb15abca1508e54a2701193912d2a6f5fc40d707b80209c93cf3c1524fd60f9cc55bdb9518b9383a3fec
+  metadata.gz: 7ea35509645ae4c11c8f7fd61157fe5057cf5d11237d888b9e5cfcbab437ff5fd90a3d3cffa9bd6d53038406138b12a890c65a72a59ac0b9542c1a90a979158c
+  data.tar.gz: 04eaf2e05b452efc8f25c14ab51b069d09dd9c548983481731562883d8866beac555a4a48a85b3352d408736c1b22d90881c0a23fab273fd78b459f31f704988

data/.rubocop.yml

@@ -1,3 +1,16 @@
-inherit_from: ~/.rubocop.yml
-require: rubocop-rspec
-require: rubocop-performance
+inherit_from:
+  - ~/.rubocop.yml
+
+AllCops:
+  Exclude:
+    - 'test/tmp/**/*'
+    - 'vendor/bundle/**/*'
+
+Style/MethodCallWithArgsParentheses:
+  Exclude:
+    - '**/Gemfile'
+    - '*_spec.rb'
+
+Style/ClassAndModuleChildren:
+  Exclude:
+    - 'test/**/*'

data/.travis.yml

@@ -18,5 +18,5 @@ rvm:
   - 2.5
   - 2.6
   - 2.7
-  - ruby-head
+  - 3.0
   - truffleruby

data/Gemfile

@@ -1,4 +1,6 @@
 source 'https://rubygems.org'
 
+gem 'rubocop-shopify', require: false
+
 # Specify your gem's dependencies in fat_table.gemspec
 gemspec

data/README.org

@@ -481,7 +481,7 @@ This example illustrates several things:
 A second ruby data structure that can be used to initialize a ~FatTable~ table
 is an array of ruby Hashes. Each hash represents a row of the table, and the
 headers of the table are taken from the keys of the hashes. Accordingly, all the
-hashes should have the same keys.
+hashes must have the same keys.
 
 This same method can in fact take an array of any objects that can be converted
 to a Hash with the ~#to_h~ method, so you can use an array of your own objects
@@ -768,17 +768,18 @@ symbol representing an existing column, which has the effect of renaming an
 existing column, or (2) a string representing a ruby expression for the value of
 a new column.
 
-Within the string expression, the names of existing or already-specified columns
-are available as local variables, as well as the instance variables '@row' and
-'@group'. So for our example table, the string expressions for new columns have
-access to local variables ~ref~, ~date~, ~code~, ~price~, ~g10~, ~qp10~,
+Within the string expression, the names of existing or already-specified
+columns are available as local variables.  In addition the instance variables
+'@row' and '@group' are available as the row number and group number of the
+new value. So for our example table, the string expressions for new columns
+have access to local variables ~ref~, ~date~, ~code~, ~price~, ~g10~, ~qp10~,
 ~shares~, ~lp~, ~qp~, ~iplp~, and ~ipqp~ as well as the instance variables
 ~@row~ and ~@group~. The local variables are set to the values of the cell in
-their respective columns for each row in the input table and the instance
-variables are set the number of the current row and group respectively.
+their respective columns for each row in the input table, and the instance
+variables are set the number of the current row and group number respectively.
 
-For example, if we want to rename the ~:date~ column and add a new column to
-compute the cost of shares, we could do the following:
+For example, if we want to rename the ~traded_on~ column to ~:date~ and add a
+new column to compute the cost of shares, we could do the following:
 
 #+HEADER: :colnames no :session readme :hlines yes :wrap EXAMPLE :exports both
 #+BEGIN_SRC ruby
@@ -1041,8 +1042,10 @@ the value is a symbol for one of several aggregating methods that
 to the :price column so that the output shows the average price in each group.
 The ~:shares~, ~:lp~, and ~:qp~ columns are summed, and the ~:any?~ aggregate is
 applied to one of the boolean fields, that is, it is ~true~ if any of the values
-in that column are ~true~. The column names in the output of the aggregated
-columns have the name of the aggregating method pre-pended to the column name.
+in that column are ~true~.
+
+Note that the column names in the output of the aggregated columns have the
+name of the aggregating method pre-pended to the column name.
 
 Here is a list of all the aggregate methods available.  If the description
 restricts the aggregate to particular column types, applying it to other types
@@ -1311,6 +1314,7 @@ table where the join expression is satisfied and augmented with nils otherwise.
 Finally, a cross join outputs every row of ~tab_a~ augmented with every row of
 ~tab_b~, in other words, the Cartesian product of the two tables. If ~tab_a~ has
 ~N~ rows and ~tab_b~ has ~M~ rows, the output table will have ~N * M~ rows.
+So be careful lest you consume all your computer's memory.
 
 #+HEADER: :colnames no :session readme :hlines yes :wrap EXAMPLE :exports both
 #+BEGIN_SRC ruby
@@ -1348,10 +1352,10 @@ Finally, a cross join outputs every row of ~tab_a~ augmented with every row of
 
 *** Set Operations
 
-~FatTable~ can perform several set operations on tables. In order for two tables
-to be used this way, they must have the same number of columns with the same
-types or an exception will be raised. We'll call two tables that qualify for
-combining with set operations "set-compatible."
+~FatTable~ can perform several set operations on pairs of tables. In order for
+two tables to be used this way, they must have the same number of columns with
+the same types or an exception will be raised. We'll call two tables that
+qualify for combining with set operations "set-compatible."
 
 We'll use the following two set-compatible tables in the examples. They each
 have some duplicates and some group boundaries so you can see the effect of the
@@ -1763,9 +1767,9 @@ but ruby data structures, and for them, things such as alignment are irrelevant.
      array of array,
 
 These are all implemented by classes that inherit from ~FatTable::Formatter~
-class by defining about a dozen methods that get called at various places during
-the construction of the output table. The idea is that more classes can be
-defined by adding additional classes.
+class by defining about a dozen methods that get called at various places
+during the construction of the output table. The idea is that more output
+formats can be defined by adding additional classes.
 
 *** Table Locations
 

data/fat_table.gemspec

@@ -64,19 +64,19 @@ Gem::Specification.new do |spec|
   spec.metadata['yard.run'] = 'yri' # use "yard" to build full HTML docs.
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'byebug'
+  spec.add_development_dependency 'debug', '>= 1.0.0'
   spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'pry-doc'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'redcarpet'
+  spec.add_development_dependency 'pg'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop-rspec'
   spec.add_development_dependency 'rubocop-performance'
   spec.add_development_dependency 'simplecov'
 
   spec.add_runtime_dependency 'activesupport', '>3.0'
-  spec.add_runtime_dependency 'fat_core', '>= 4.1'
+  spec.add_runtime_dependency 'fat_core', '>= 4.9.0'
   spec.add_runtime_dependency 'rainbow'
   spec.add_runtime_dependency 'sequel'
   spec.add_runtime_dependency 'gem-path'

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
@@ -81,7 +83,7 @@ module FatTable
     #   col.type #=> 'Numeric'
     #   col.header #=> :prices
     #   col.sum #=> 18376.75
-    def initialize(header:, items: [])
+    def initialize(header:, items: [], type: 'NilClass')
       @raw_header = header
       @header =
         if @raw_header.is_a?(Symbol)
@@ -89,7 +91,7 @@ module FatTable
         else
           @raw_header.to_s.as_sym
         end
-      @type = 'NilClass'
+      @type = type
       msg = "unknown column type '#{type}"
       raise UserError, msg unless TYPES.include?(@type.to_s)
 
@@ -137,6 +139,19 @@ module FatTable
       size - 1
     end
 
+    # :category: Attributes
+
+    # Force the column to have String type and then convert all items to
+    # strings.
+    def force_to_string_type
+      # msg = "Can only force an empty column to String type"
+      # raise UserError, msg unless empty?
+      @type = 'String'
+      unless empty?
+        @items = items.map(&:to_s)
+      end
+    end
+
     ##########################################################################
     # Enumerable
     ##########################################################################
@@ -483,34 +498,55 @@ 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
-
-    # Convert the val to a DateTime if it is either a DateTime, a Date, or a
+    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
+
+    # A Date like 'Tue, 01 Nov 2016' or 'Tue 01 Nov 2016' or '01 Nov 2016'.
+    # These are emitted by Postgresql, so it makes from_sql constructor
+    # possible without special formatting of the dates.
+    INV_DATE_RE = %r{((mon|tue|wed|thu|fri|sat|sun)[a-zA-z]*,?)?\s+  # looks like dow
+    (?<dy>\d\d?)\s+  # one or two-digit day
+    (?<mo_name>[jfmasondJFMASOND][A-Za-z]{2,})\s+  # looks like a month name
+    (?<yr>\d\d\d\d) # and a 4-digit year
+    }xi
+
+    # 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)
+      return val.to_datetime if val.is_a?(Time)
       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)
+        elsif str =~ INV_DATE_RE
+          mo = Date.mo_name_to_num(last_match[:mo_name])
+          date = DateTime.new(Regexp.last_match[:yr].to_i, mo,
+                              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
 
@@ -530,8 +566,8 @@ module FatTable
         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

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

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

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

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
@@ -577,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($&, '')
@@ -599,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/
@@ -619,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]
@@ -639,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
@@ -655,22 +657,22 @@ 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}'"
@@ -688,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}'"
@@ -712,37 +714,38 @@ 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}'"
@@ -1072,7 +1075,10 @@ module FatTable
               :body
             end
           table.headers.each do |h|
-            grp_col[h] ||= Column.new(header: h)
+            # We set the column type here in case the column type was forced
+            # to String.
+            # grp_col[h] ||= Column.new(header: h)
+            grp_col[h] ||= Column.new(header: h, type: table.type(h))
             grp_col[h] << row[h]
             istruct = format_at[location][h]
             new_row[h] = [row[h], format_cell(row[h], istruct,

data/lib/fat_table/formatters/org_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # Output the table in the same way as org-mode for emacs does. This is almost
   # identical to TextFormatter except that dates do get formatted as inactive

data/lib/fat_table/formatters/term_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rainbow'
 
 module FatTable
@@ -26,10 +28,10 @@ module FatTable
       super
       @options[:unicode] = options.fetch(:unicode, true)
       @options[:framecolor] = options.fetch(:framecolor, 'none.none')
-      return unless @options[:framecolor] =~ /([-_a-zA-Z]*)(\.([-_a-zA-Z]*))/
+      return unless @options[:framecolor] =~ /(?<co>[-_a-zA-Z]*)(\.(?<bg>[-_a-zA-Z]*))/
 
-      @options[:frame_fg] = $1.downcase unless $1.blank?
-      @options[:frame_bg] = $3.downcase unless $3.blank?
+      @options[:frame_fg] = Regexp.last_match[:co].downcase unless Regexp.last_match[:co].blank?
+      @options[:frame_bg] = Regexp.last_match[:bg].downcase unless Regexp.last_match[:bg].blank?
     end
 
     # Valid colors for ANSI terminal using the rainbow gem's X11ColorNames.
@@ -101,18 +103,18 @@ module FatTable
     # Unicode line-drawing characters. We use double lines before and after the
     # table and single lines for the sides and hlines between groups and
     # footers.
-    UPPER_LEFT = "\u2552".freeze
-    UPPER_RIGHT = "\u2555".freeze
-    DOUBLE_RULE = "\u2550".freeze
-    UPPER_TEE = "\u2564".freeze
-    VERTICAL_RULE = "\u2502".freeze
-    LEFT_TEE = "\u251C".freeze
-    HORIZONTAL_RULE = "\u2500".freeze
-    SINGLE_CROSS = "\u253C".freeze
-    RIGHT_TEE = "\u2524".freeze
-    LOWER_LEFT = "\u2558".freeze
-    LOWER_RIGHT = "\u255B".freeze
-    LOWER_TEE = "\u2567".freeze
+    UPPER_LEFT = "\u2552"
+    UPPER_RIGHT = "\u2555"
+    DOUBLE_RULE = "\u2550"
+    UPPER_TEE = "\u2564"
+    VERTICAL_RULE = "\u2502"
+    LEFT_TEE = "\u251C"
+    HORIZONTAL_RULE = "\u2500"
+    SINGLE_CROSS = "\u253C"
+    RIGHT_TEE = "\u2524"
+    LOWER_LEFT = "\u2558"
+    LOWER_RIGHT = "\u255B"
+    LOWER_TEE = "\u2567"
     # :startdoc:
 
     def upper_left

data/lib/fat_table/formatters/text_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # Output the table as plain text. This is almost identical to OrgFormatter
   # except that dates do not get formatted as inactive timestamps and the

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/patches.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 unless { a: 1 }.respond_to?(:fetch_values)
   # Add fetch_values if this version of ruby does not define it.
   class Hash

data/lib/fat_table/table.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # A container for a two-dimensional table. All cells in the table must be a
   # String, a DateTime (or Date), a Numeric (Bignum, Integer, or BigDecimal), or
@@ -156,7 +158,8 @@ module FatTable
       raise UserError, msg if FatTable.db.nil?
 
       result = Table.new
-      FatTable.db[query].each do |h|
+      rows = FatTable.db[query]
+      rows.each do |h|
         result << h
       end
       result
@@ -295,6 +298,8 @@ module FatTable
     # :category: Attributes
 
     # Return the table's Column with the given +key+ as its header.
+    # @param key [Symbol] symbol for header of column to return
+    # @return [FatTable::Column]
     def column(key)
       columns.detect { |c| c.header == key.as_sym }
     end
@@ -309,6 +314,15 @@ module FatTable
 
     # :category: Attributes
 
+    # Set the column type for Column with the given +key+ as a String type,
+    # but only if empty.  Otherwise, we would have to worry about converting
+    # existing items in the column to String.  Perhaps that's a TODO.
+    def set_column_to_string_type(key)
+      column(key).force_to_string_type
+    end
+
+    # :category: Attributes
+
     # Return the array of items of the column with the given header symbol
     # +key+, or if +key+ is an Integer, return that row at that index. So a
     # table's rows can be accessed by number, and its columns can be accessed by
@@ -880,10 +894,7 @@ module FatTable
     # 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)
+    def set_operation(other, oper = :+, distinct: true, add_boundaries: true, inherit_boundaries: false)
       unless columns.size == other.columns.size
         msg = "can't apply set ops to tables with a different number of columns"
         raise UserError, msg
@@ -981,6 +992,11 @@ module FatTable
     #
     # Any groups present in either Table are eliminated in the output Table. See
     # the README for examples.
+    # @param other [FatTable::Table] table to join with self
+    # @param exps [Array<String>, Array<Symbol>] table to join with self
+    # @param join_type [Array<String>, Array<Symbol>] type of join :inner, :left, :right, :full, :cross
+    # @return [FatTable::Table] result of joining self to other
+    #
     def join(other, *exps, join_type: :inner)
       unless other.is_a?(Table)
         raise UserError, 'need other table as first argument to join'
@@ -1083,10 +1099,10 @@ module FatTable
       # Translate any remaining row_b heads to append '_b' if they have the
       # same name as a row_a key.
       a_heads = row_a.keys
-      row_b = row_b.to_a.each.map { |k, v|
+      row_b = row_b.to_a.each.map do |k, v|
         [a_heads.include?(k) ? "#{k}_b".to_sym : k, v]
-      }.to_h
-      row_a.merge(row_b)
+      end
+      row_a.merge(row_b.to_h)
     end
 
     # Return a hash for the local variables of a join expression in which all
@@ -1125,7 +1141,7 @@ module FatTable
           [nat_exp, common_heads]
         end
       else
-        # We have expressions to evaluate
+        # We have join expressions to evaluate
         and_conds = []
         partial_result = nil
         last_sym = nil
@@ -1133,8 +1149,8 @@ module FatTable
           case exp
           when Symbol
             case exp.to_s.clean
-            when /\A(.*)_a\z/
-              a_head = $1.to_sym
+            when /\A(?<sy>.*)_a\z/
+              a_head = Regexp.last_match[:sy].to_sym
               unless a_heads.include?(a_head)
                 raise UserError, "no column '#{a_head}' in table"
               end
@@ -1149,11 +1165,11 @@ module FatTable
                 partial_result = nil
               else
                 # First of a pair of _a or _b
-                partial_result = "(#{a_head}_a == "
+                partial_result = String.new("(#{a_head}_a == ")
               end
               last_sym = a_head
-            when /\A(.*)_b\z/
-              b_head = $1.to_sym
+            when /\A(?<sy>.*)_b\z/
+              b_head = Regexp.last_match[:sy].to_sym
               unless b_heads.include?(b_head)
                 raise UserError, "no column '#{b_head}' in second table"
               end
@@ -1168,7 +1184,7 @@ module FatTable
                 partial_result = nil
               else
                 # First of a pair of _a or _b
-                partial_result = "(#{b_head}_b == "
+                partial_result = String.new("(#{b_head}_b == ")
               end
               b_common_heads << b_head
               last_sym = b_head
@@ -1275,16 +1291,33 @@ module FatTable
 
     # :category: Constructors
 
+    # Add a group boundary mark at the given row, or at the end of the table
+    # by default.
+    def add_boundary(at_row = nil)
+      row = at_row || (size - 1)
+      @boundaries << row
+    end
+
+    # :category: Constructors
+
     # Add a +row+ represented by a Hash having the headers as keys. If +mark:+
     # is set true, mark this row as a boundary. All tables should be built
     # ultimately using this method as a primitive.
     def add_row(row, mark: false)
-      row.each_pair do |k, v|
-        key = k.as_sym
-        columns << Column.new(header: k) unless column?(k)
-        column(key) << v
+      row.transform_keys!(&:as_sym)
+      # Make sure there is a column for each known header and each new key
+      # present in row.
+      new_heads = row.keys - headers
+      new_heads.each do |h|
+        # This column is new, so it needs nil items for all prior rows lest
+        # the value be added to a prior row.
+        items = Array.new(size, nil)
+        columns << Column.new(header: h, items: items)
+      end
+      headers.each do |h|
+        # NB: This adds a nil if h is not in row.
+        column(h) << row[h]
       end
-      @boundaries << (size - 1) if mark
       self
     end
 
@@ -1353,9 +1386,9 @@ module FatTable
 
       method = "to_#{fmt}"
       if block_given?
-        send method, options, &Proc.new
+        send(method, options, &Proc.new)
       else
-        send method, options
+        send(method, options)
       end
     end
 

data/lib/fat_table/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module FatTable
   # The current version of FatTable
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'
 end

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,
@@ -29,7 +31,7 @@ module FatTable
     path = Dir.glob("#{ENV['GEM_HOME']}/gems/#{gem_name}*").sort.last
     if path
       path = File.join(path, 'lib')
-      $: << path unless $:.include?(path)
+      $LOAD_PATH << path unless $LOAD_PATH.include?(path)
     end
   end
 
@@ -158,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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat_table
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Daniel E. Doherty
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-10 00:00:00.000000000 Z
+date: 2022-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: pry-doc
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,35 +67,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-doc
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: redcarpet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: redcarpet
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -184,14 +184,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: 4.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: 4.9.0
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -306,7 +306,7 @@ licenses: []
 metadata:
   allowed_push_host: https://rubygems.org
   yard.run: yri
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -321,8 +321,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Provides tools for working with tables as a data type.
 test_files: []