fat_table 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7870805173324438b3a4c2416e4f59fc3830cd7dc9272b30237cfa1a9ac9d20
-  data.tar.gz: 31e1d6f2c8fdabe9459850e8ca1c570028c63eec1c0c2f61a030421e943d9d66
+  metadata.gz: 3cff489c9e921eff2138fb44b260b96d548819b7ee1479f9bf89675f2199c9ea
+  data.tar.gz: 7ad900e458b8d95baaf8044a4d25e742b1796ae9677d9f667180f034760e8a55
 SHA512:
-  metadata.gz: fd60f7879416e544c64c2e1d0efdc4cd349bf496a9c907bf7814d0ddc62c2b170ec46cc9bdb1d241fde7f50c6434233b0b2f4609adce5ec8c2073f32f52fd36e
-  data.tar.gz: f493a05c1b17640a41fffa5bceda6ff01047391a5f9ccb15abca1508e54a2701193912d2a6f5fc40d707b80209c93cf3c1524fd60f9cc55bdb9518b9383a3fec
+  metadata.gz: 061ddacf0132d62f7d428f513c7a14277a4668c5a37148f80ef87dc484163ee4c001164e20a854d61761f21d6df025a700171e85c33e4f53c548014d7804b4e2
+  data.tar.gz: 11351e7a9c73624c4395960c226733b2c1ccaa126f0a0f1c2eee042b83f5adacbcea52e303b8566d5746c16648e202441d5df2216cc818799864600c7ee3bf69

data/.rubocop.yml

@@ -1,3 +1,18 @@
-inherit_from: ~/.rubocop.yml
+inherit_gem:
+    rubocop-shopify: rubocop.yml
 require: rubocop-rspec
 require: rubocop-performance
+
+AllCops:
+  TargetRubyVersion: 2.7
+  Exclude:
+    - 'test/tmp/**/*'
+    - 'vendor/bundle/**/*'
+
+Style/MethodCallWithArgsParentheses:
+  Exclude:
+    - '**/Gemfile'
+
+Style/ClassAndModuleChildren:
+  Exclude:
+    - 'test/**/*'

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

@@ -68,6 +68,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'pry-doc'
+  spec.add_development_dependency 'ruby_jard'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'redcarpet'
   spec.add_development_dependency 'rspec', '~> 3.0'

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
 

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
@@ -483,34 +485,41 @@ module FatTable
       end
     end
 
-    IS0_DATE_RE = %r{\b(\d\d\d\d)[-/](\d\d?)[-/](\d\d?)\s*
-                     (T\d\d:\d\d:\d\d(\+\d\d:\d\d)?)?\b}x
-    AMR_DATE_RE = %r{\b(\d\d?)[-/](\d\d?)[-/](\d\d\d\d)\s*
-                     (T\d\d:\d\d:\d\d(\+\d\d:\d\d)?)?\b}x
+    ISO_DATE_RE = %r{(?<yr>\d\d\d\d)[-\/]
+                (?<mo>\d\d?)[-\/]
+                (?<dy>\d\d?)\s*
+                (T?\s*\d\d:\d\d(:\d\d)?
+                ([-+](\d\d?)(:\d\d?))?)?}x
+
+    AMR_DATE_RE = %r{(?<dy>\d\d?)[-/](?<mo>\d\d?)[-/](?<yr>\d\d\d\d)\s*
+                     (?<tm>T\d\d:\d\d:\d\d(\+\d\d:\d\d)?)?}x
 
-    # Convert the val to a DateTime if it is either a DateTime, a Date, or a
+    # Convert the val to a DateTime if it is either a DateTime, a Date, a Time, or a
     # String that can be parsed as a DateTime, otherwise return nil. It only
-    # recognizes strings that contain a something like '2016-01-14' or
-    # '2/12/1985' within them, otherwise DateTime.parse would treat many bare
-    # numbers as dates, such as '2841381', which it would recognize as a valid
-    # date, but the user probably does not intend it to be so treated.
+    # recognizes strings that contain a something like '2016-01-14' or '2/12/1985'
+    # within them, otherwise DateTime.parse would treat many bare numbers as dates,
+    # such as '2841381', which it would recognize as a valid date, but the user
+    # probably does not intend it to be so treated.
     def convert_to_date_time(val)
       return val if val.is_a?(DateTime)
       return val if val.is_a?(Date)
       begin
-        val = val.to_s.clean
-        return nil if val.blank?
-        if val.match?(IS0_DATE_RE)
-          val = DateTime.parse(val)
-        elsif val =~ AMR_DATE_RE
-          val = DateTime.new($3.to_i, $1.to_i, $2.to_i)
+        str = val.to_s.clean
+        return nil if str.blank?
+
+        if str.match(ISO_DATE_RE)
+          date = DateTime.parse(val)
+        elsif str =~ AMR_DATE_RE
+          date = DateTime.new(Regexp.last_match[:yr].to_i,
+                         Regexp.last_match[:mo].to_i,
+                         Regexp.last_match[:dy].to_i)
         else
           return nil
         end
-        val = val.to_date if val.seconds_since_midnight.zero?
-        val
+        # val = val.to_date if
+        date.seconds_since_midnight.zero? ? date.to_date : date
       rescue ArgumentError
-        return nil
+        nil
       end
     end
 
@@ -530,8 +539,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.rb

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

data/lib/fat_table/formatters/aoa_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FatTable
   # A subclass of Formatter for rendering the table as a Ruby Array of Arrays.
   # Each cell is formatted as a string in accordance with the formatting

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}'"

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/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
@@ -880,10 +882,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
@@ -1083,10 +1082,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 +1124,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 +1132,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 +1148,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 +1167,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
@@ -1353,9 +1352,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.3.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat_table
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Daniel E. Doherty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-10 00:00:00.000000000 Z
+date: 2020-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby_jard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -321,7 +335,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Provides tools for working with tables as a data type.