fat_table 0.5.4 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ecb8cb3fb29acb95b0fe11e65c5b587379a5a3070ab68acbc6a2c1785c8f229
-  data.tar.gz: f3cc9e7242ded9fd0970159eee8da4208faade0e6e4c37a324a45e1596c4eeae
+  metadata.gz: f045f2196dd5d6ad7584b877d847945f99cc8079b86b8a810af8528d2c18074c
+  data.tar.gz: cb8f031c4f48d472af658f111221524882f5d2bb6574858b1e988e2384d7ba56
 SHA512:
-  metadata.gz: 8d404bd69ba3a1c3c9774f634e4f0935987ff4827803d59e89b9adbdc4806b25ef87e5dbcb9f22d7e3475c86dceebf097cf73e0ad1287f91d21415e5b0a5a3b3
-  data.tar.gz: 8d8df3651b9cdcdeaefa0527cd4fc1987c1ec491bca2a88651b255032eea16ee29c82285b9d7f9bae2ecb9b6d90c6fc4d766980af5362dc89045d553e66dec03
+  metadata.gz: f906e8841e268263635dc4231573b07cb48cd48b1f33fd2a0d7812e65f1e9720ac8f8556129601b702a828c5c6a7a7a04c00344016c2ebe0004a892d1f524ab9
+  data.tar.gz: 694f65455ed63c1304f0bc626192c2770968278ec0599c0e9c5f57c5fcb091a351ed4e09d28fe6cbda12278f1f9ed669e128339e6e99b4fc2a1a21467d182892

data/README.org

@@ -32,7 +32,7 @@ The following is for org.
 #+end_src
 
 #+begin_EXAMPLE
-Current version is: 0.5.3
+Current version is: 0.6.0
 #+end_EXAMPLE
 
 * Introduction
@@ -148,6 +148,7 @@ org-mode buffer as an org-table, ready for processing by other code blocks.
       - [[#type-and-column-priority][Type and Column priority]]
     - [[#footers][Footers]]
       - [[#adding-footers][Adding Footers]]
+      - [[#dynamic-labels][Dynamic Labels]]
       - [[#aggregators][Aggregators]]
       - [[#footer-objects][Footer objects]]
       - [[#footer-examples][Footer Examples]]
@@ -442,11 +443,26 @@ or nil. There are only five permissible types for a ~Column~:
 5. *NilClass* (for the undetermined column type).
 
 When a ~Table~ is constructed from an external source, all ~Columns~ start out
-having a type of ~NilClass~, that is, their type is as yet undetermined. When a
-string or object of one of the four determined types is added to a ~Column~, it
-fixes the type of the column and all further items added to the ~Column~ must
-either be ~nil~ (indicating no value) or be capable of being coerced to the
-column's type. Otherwise, ~FatTable~ raises an exception.
+having a type of ~NilClass~, that is, their type is as yet undetermined. When
+a string or object of one of the four determined types is added to a ~Column~
+and it can be converted into one of the permissible types, it fixes the type
+of the column, and all further items added to the ~Column~ must either be
+~nil~ (indicating no value) or be capable of being coerced to the column's
+type. Otherwise, ~FatTable~ raises an exception.
+
+The strictness of requiring all items to be of the same type can be relaxed by
+declaring a column to be "tolerant."  You can do so when you create the table
+by adding a tolerant_columns keyword parameter.  If a Column is tolerant,
+~FatTable~ tries to convert new items into a type other than a ~String~ and,
+if it can do so, sets /that/ as the Column's type.  Any later items that
+cannot be converted into the Column's type are converted to strings.  These
+interloper strings are treated like nils for purposes of sorting and
+evaluation, but are displayed according to any string formatting on output.
+See [[*Designating "Tolerant" Columns][Designating "Tolerant" Columns]] below.
+
+It is also possible to force ~FatTable~ to treat a column as a String type,
+even its items look like one of the other types.  See [[*Forcing String Type][Forcing String Type]]
+below.
 
 Items of input must be either one of the permissible ruby objects or strings. If
 they are strings, ~FatTable~ attempts to parse them as one of the permissible
@@ -519,6 +535,7 @@ You can create an empty table with ~FatTable::Table.new~ or, the shorter form,
 in the added rows determine the names of the headers:
 
 #+BEGIN_SRC ruby :results silent
+  require 'fat_table'
   tab = FatTable.new
   tab << { a: 1, b: 2, c: "<2017-01-21>", d: 'f', e: '' }
   tab << { a: 3.14, b: 2.17, c: '[2016-01-21 Thu]', d: 'Y', e: nil }
@@ -603,10 +620,18 @@ columns to be created:
 **** Forcing String Type
 Occasionally, ~FatTable~'s automatic type detection can get in the way and you
 just want it to treat one or more columns as Strings regardless of their
-appearance.  Think, for example, of zip codes.  At any time after creating a
-table, you can have it force the String type on any number of columns with the
-~force_string!~ method.  When you do so, all exisiting items in the column are
-converted to strings with the #to_s method.
+appearance.  Think, for example, of zip codes.  If headers are given when a
+table is contructed, you can designate a forced-string column by appending a
+~!~ to the end of the header.  It will not become part of the header, it will
+just mark it as a forced-string Column.
+
+#+begin_SRC emacs-lisp :wrap EXAMPLE
+  tab = FatTable.new(:a, 'b', 'C!', :d, :zip!)
+#+end_SRC
+
+In addition, at any time after creating a table, you can force the String type
+on any number of columns with the ~force_string!~ method.  When you do so, all
+exisiting items in the column are converted to strings with the #to_s method.
 
 #+begin_src ruby :wrap EXAMPLE
   tab = FatTable.new(:a, 'b', 'C', :d, :zip)
@@ -1731,8 +1756,6 @@ available in ~ft_console~ as ~@tab_a~ and ~@tab_b~:
     |  2 | Engineering |      2 |
     |  3 | Finance     |      7 |
     EOS
-
-  tab_b = FatTable.from_org_string(tab_b_str)
 #+END_SRC
 
 Here is ~tab_a~:
@@ -2442,7 +2465,6 @@ Finance&
  {:id=>"3", :dept=>"Finance", :emp_id=>"7"}]
 #+end_EXAMPLE
 
-
 *** Formatting Directives
 The formatting methods explained in the next section all take formatting
 directives as strings in which letters and other characters signify what
@@ -2683,12 +2705,27 @@ but not for other nils, such as in the last row of the ~:join_date~ column.
 
 *** Footers
 **** Adding Footers
-You can call the ~footer,~ ~gfooter, foot, and gfoot~ methods on ~Formatter~
-objects to add footers and group footers. Note that all of these methods
-return a ~Footer~ object that can be accessed to extract the computed values.
-All of these methods return the ~FatTable::Footer~ object so constructed. It
-can be used to access the values and other attributes of the footer
-computed. Their signatures are:
+You can call the ~foot~, ~gfoot~, ~footer,~ or ~gfooter~, methods on
+~Formatter~ objects to add footers and group footers. Note that all of these
+methods return a ~Footer~ object that can be accessed to extract the computed
+values.  All of these methods return the ~FatTable::Footer~ object so
+constructed. It can be used to access the values and other attributes of the
+footer computed. Their signatures are:
+
+- ~foot(label: label, label_col: nil, **agg_cols)~ :: where ~label~ is a label
+  to be placed in the column with header ~label_col~, or, if ommitted, in the
+  first cell of the footer (unless that column is named as one of the
+  ~agg_cols~, in which case the label is ignored), and ~**agg_cols~ is zero or
+  more hash-like parameters with a column symbol as a key and a valid
+  aggregate as the value. This causes a table-wide header to be added at the
+  bottom of the table applying ~agg~, to the ~agg_cols~. A table can have any
+  number of footers attached, and they will appear at the bottom of the output
+  table in the order they are given.
+
+- ~gfoot(label: 'Group Total', label_col: nil, **agg_cols)~ :: where the
+  parameters have the same meaning as for the ~foot~ method, but results in a
+  footer for each group in the table rather than the table as a whole. These
+  will appear in the output table just below each group.
 
 - ~footer(label, *sum_cols, **agg_cols)~ :: where ~label~ is a label to be
   placed in the first cell of the footer (unless that column is named as one
@@ -2701,26 +2738,11 @@ computed. Their signatures are:
   number of footers attached, and they will appear at the bottom of the output
   table in the order they are given.
 
-- ~foot(label, label_col, **agg_cols)~ :: where ~label~ is a label to be
-  placed in the column with header ~label_col~, or, if ommitted, in the first
-  cell of the footer (unless that column is named as one of the ~agg_cols~, in
-  which case the label is ignored), and ~**agg_cols~ is zero or more hash-like
-  parameters with a column symbol as a key and a valid aggregate as the
-  value. This causes a table-wide header to be added at the bottom of the
-  table applying ~agg~, to the ~agg_cols~. A table can have any number of
-  footers attached, and they will appear at the bottom of the output table in
-  the order they are given.
-
 - ~gfooter(label, *sum_cols, **agg_cols)~ :: where the parameters have the
   same meaning as for the ~footer~ method, but results in a footer for each
   group in the table rather than the table as a whole. These will appear in
   the output table just below each group.
 
-- ~gfoot(label, label_col, **agg_cols)~ :: where the parameters have the same
-  meaning as for the ~foot~ method, but results in a footer for each group in
-  the table rather than the table as a whole. These will appear in the output
-  table just below each group.
-
 There are also a number of convenience methods for adding common footers:
 - ~sum_footer(*cols)~ :: Add a footer summing the given columns with the label
      'Total'.
@@ -2739,6 +2761,39 @@ There are also a number of convenience methods for adding common footers:
 - ~max_gfooter(*cols)~ :: Add a group footer showing the maximum for the given
      columns with the label 'Group Maximum'.
 
+**** Dynamic Labels
+Most of the time, you will want a fixed string as the label.  However,
+especially in the case of a group footer, you might want a dynamically
+contructed label.  You can use a proc or lambda for a label, and it will be
+computed for you.  In the case of non-group footers, the proc takes a single
+parameter, the footer object itself.  This allows you to make the label a
+function of other footer values, for example, you could make the label
+include the most recent year from the date column:
+
+#+begin_src ruby
+  fmtr.foot(label: -> (f) { "Average (latest year #{f.column(:date).max.year})" },
+  temp: :avg)
+#+end_src
+
+In the case of a group footer, the lambda or proc may take either one or qtwo parameters.
+If it takes one, the parameter is simply the 0-based number of the group:
+
+#+begin_src ruby
+  fmtr.gfoot(label: -> (k) { "Group #{(k+1).to_roman} Average" }, temp: :avg)
+#+end_src
+This would format the label with a roman numeral (assuming you defined a
+method to do so) for the group number.
+
+If it takes two arguments, the second argument is the footer itself, as with
+non-group footers:
+
+#+begin_src ruby
+    fmtr.gfoot(label: -> (k, f) { "Year #{f.column(:date, k).max.year} Group #{(k+1).to_roman} Average" },
+               temp: :avg)
+#+end_src
+This would add the group's year to label, assuming the :date column of the
+footer's table had the same year for each item in the group.
+
 **** Aggregators
 When adding a footer with the above methods, you can specify an aggregator for
 each column named in the ~agg_cols~ parameter.  There are several candidates
@@ -2755,6 +2810,9 @@ for what you can use for an aggregator:
     In the case of datetime columns, these aggrgators convert the dates to
     julian date numbers, perform the calculation, then convert the result back
     to a datetime object.
+    Apart from the built-in aggrgators, you could define your own by opening the
+    FatTable::Column class and adding a suitable instance method.  In that
+    case, the symbol could also refer to the method you defined.
 - String :: using a string as an aggrgegator can result in:
   + the string being converted to an object matching the type of the column
     (for example, using '$1,888' in a numeric column puts the constant number
@@ -2769,11 +2827,16 @@ for what you can use for an aggregator:
 - A Lambda :: finally, you can provide a lambda for performing arbitrary
   calculations and placing the result in the footer field.  The number of
   arguments the lambda takes can vary:
-  * If the lambda is used in a group footer, it must take a single integer
-    argument that is set to the group number being calculated and /can/ take a
-    second argument for the column symbol in which it appears, or
-  * If the lambda is used in an ordinary footer, it either takes no arguments,
-    or a single argument for the column symbol in which it appears.
+  * If the lambda is used in an ordinary footer column, it can take 0, 1, or 2
+    arguments: (1) the first argument, if given, will be set to the
+    FatTable::Column object for that column and (2) the second argument, if
+    given, will be set to the Footer object itself.
+  * If the lambda is used in a group footer column, it can 0, 1, 2, or 3
+    arguments: (1) the first argument, if given, will be set to the group's
+    0-based index number, (2) the second argument, if given, will be set to a
+    FatTable::Column object consisting of those items in the group's column,
+    and (3) the third argument, if given, will be set to the Footer object
+    itself.
 
 **** Footer objects
 Each of the methods for adding a footer to a ~Formatter~ returns a ~Footer~ object
@@ -2797,7 +2860,6 @@ their computed values.  Here are the accessors available on a
   to the footer value for that column, nil for unused columns.  Use the index
   ~k~ to specify which group to access in the case of a group footer.
 
-
 **** Footer Examples
 As a reminder, here is the table, ~tab_a~ defined earlier:
 
@@ -2958,18 +3020,20 @@ But it can be any type.  Here we pick a lottery winner from the employee ids.
 #+end_EXAMPLE
 
 ***** Lambdas
-Perhaps the most flexible form of aggregator is a lambda form.  They require 2
-or 3 parameters in non-group and group footers, respectively:
-
-- ~->(f, c) {...}~ :: in a normal, non-group footer, you must provide for two
-  paramters: the first, ~f~, will be bound to the footer in which the lambda
-  appears and the second, ~c~, will be bound to the column header to which the
-  lambda is attached.
-- ~->(f, c, k)~ :: in a group footer, you must provide for three paramters:
-  the first, ~f~, will be bound to the footer in which the lambda appears, the
-  second, ~c~, will be bound to the column header to which the lambda is
-  attached, and the third, ~k~ will be bound to the group number of the group
-  being evaluated.
+Perhaps the most flexible form of aggregator is a lambda form.  They can take
+up to 2 or up to 3 parameters in non-group and group footers, respectively:
+
+- ~->(c, f) {...}~ :: in a normal, non-group footer, you may provide for up to
+  two paramters: the first, ~c~, if given, will be bound to the column header
+  to which the lambda is attached and and the second, ~f~, if given will be
+  bound to the footer in which the lambda appears.  A lambda with no
+  parameters can be provided as well if none are needed.
+- ~->(k, c, f)~ :: in a group footer, you may provide for up to three
+  paramters: the the first, ~k~, if provided, will be bound to the group
+  number of the group being evaluated, the second, ~c~, if provided, will be
+  bound to the column header to which the lambda is attached, and the third,
+  ~f~, will be bound to the footer in which the lambda appears. A lambda with
+  no parameters can be provided as well if none are needed.
 
 With the first argument, the footer itself becomes available and with it all
 the things accessible with the footers, including the items in the current
@@ -2980,7 +3044,7 @@ Compute the summ of the squares if the items in the ~:age~ column:
   tab_a.to_text do |f|
     f.format(numeric: '0.0R,', datetime: 'd[%v]D[%v]')
     f.footer('Average', age: :avg, salary: :avg, join_date: :avg)
-    f.footer('SSQ', age: ->(f, c) { sa = f.items(c).map {|x| x * x}.sum; Math.sqrt(sa) })
+    f.footer('SSQ', age: ->(c) { sa = c.items.map {|x| x * x}.sum; Math.sqrt(sa) })
   end
 #+END_SRC
 
@@ -3009,8 +3073,8 @@ summ of the squares if the ages in each group:
   tab_a.order_with('join_date.year').to_text do |f|
     f.format(numeric: '0.0R,', datetime: 'd[%v]D[%v]', sort_key: '0.0~,')
     f.footer('Average', age: :avg, salary: :avg, join_date: :avg)
-    f.gfooter('Group SSQ', age: ->(f, c, k) { sa = f.items(c, k).map {|x| x * x}.sum; Math.sqrt(sa) })
-    f.footer('Total SSQ', age: ->(f, c) { sa = f.items(c).map {|x| x * x}.sum; Math.sqrt(sa) })
+    f.gfooter('Group SSQ', age: ->(k, c, f) { sa = c.items.map {|x| x * x}.sum; Math.sqrt(sa) })
+    f.footer('Total SSQ', age: ->(c, f) { sa = c.items.map {|x| x * x}.sum; Math.sqrt(sa) })
   end
 #+END_SRC
 
@@ -3022,19 +3086,19 @@ summ of the squares if the ages in each group:
 +-----------+-------+-----+------------+--------+-------------+----------+
 | Group SSQ |       |  45 |            |        |             |          |
 +-----------+-------+-----+------------+--------+-------------+----------+
-|         1 | Paul  |  32 | California | 20,000 | 13-JUL-2001 |     2001 |
+|         1 | Paul  |  32 | California | 20,000 | 13-JUL-2001 | 2001     |
 +-----------+-------+-----+------------+--------+-------------+----------+
 | Group SSQ |       |  32 |            |        |             |          |
 +-----------+-------+-----+------------+--------+-------------+----------+
-|         2 | Allen |  25 | Texas      |        | 13-JUL-2005 |     2005 |
-|         8 | Paul  |  24 | Houston    | 20,000 | 13-JUL-2005 |     2005 |
-|         9 | James |  44 | Norway     |  5,000 | 13-JUL-2005 |     2005 |
+|         2 | Allen |  25 | Texas      |        | 13-JUL-2005 | 2005     |
+|         8 | Paul  |  24 | Houston    | 20,000 | 13-JUL-2005 | 2005     |
+|         9 | James |  44 | Norway     |  5,000 | 13-JUL-2005 | 2005     |
 +-----------+-------+-----+------------+--------+-------------+----------+
 | Group SSQ |       |  56 |            |        |             |          |
 +-----------+-------+-----+------------+--------+-------------+----------+
-|         3 | Teddy |  23 | Norway     | 20,000 | 13-DEC-2007 |     2007 |
-|         4 | Mark  |  25 | Rich-Mond  | 65,000 | 13-DEC-2007 |     2007 |
-|         5 | David |  27 | Texas      | 85,000 | 13-DEC-2007 |     2007 |
+|         3 | Teddy |  23 | Norway     | 20,000 | 13-DEC-2007 | 2007     |
+|         4 | Mark  |  25 | Rich-Mond  | 65,000 | 13-DEC-2007 | 2007     |
+|         5 | David |  27 | Texas      | 85,000 | 13-DEC-2007 | 2007     |
 +-----------+-------+-----+------------+--------+-------------+----------+
 | Group SSQ |       |  43 |            |        |             |          |
 +-----------+-------+-----+------------+--------+-------------+----------+

data/TODO.org

@@ -1,10 +1,37 @@
+
+* TODO Specify Column Widths
+Allow a formatter to specify column widths.  This could be a number of
+characters, which would be interpreted as a number of "ems" for LaTeX.
+Cell content larger than the width would be truncated.  Any column without a
+width specified would be set at the width of the longest value in that cell,
+after initial formatting.
+
+#+begin_SRC ruby
+  tab.to_text do |f|
+    f.widths(a: 13, b: 30)
+  end
+#+end_SRC
+
+Possible enhancements:
+- specify an overall width and column widths as decimal or fractions, so that
+  a column's width would be that fraction of the overall width.
+- specify a Range for a width, so that the column would at least min and at
+  most max, otherwise the width of its largest cell.
+
 * TODO Conversion to Spreadsheets
 - State "TODO"       from              [2017-04-21 Fri 10:36]
 This is a [[https://github.com/westonganger/spreadsheet_architect][gem]] that I can include into the Table model to convert a table into
 a spread-sheet, or even a sheet in a multi-sheet spreadsheet file.
 
-* TODO Add from_yql for fetching from Yahoo
+* TODO Add Quandl or EODDATA Queries
+Possible replacements for YQL.
+
+* CNCL Add from_yql for fetching from Yahoo
+CLOSED: [2022-01-30 Sun 06:03]
 - State "TODO"       from              [2017-04-21 Fri 10:35]
+
+Cancelled because Yahoo shut down the YQL api service.
+
 Add a constructor to allow fetching stock data from yql.  Perhaps grab all
 available fields, then allow a select of those of interest.
 

data/lib/fat_table/column.rb

@@ -173,7 +173,12 @@ module FatTable
     # Column. This makes Columns Enumerable, so all the Enumerable methods are
     # available on a Column.
     def each
-      items.each { |itm| yield itm }
+      if block_given?
+        items.each { |itm| yield itm }
+        self
+      else
+        to_enum(:each)
+      end
     end
 
     ##########################################################################
@@ -191,8 +196,11 @@ module FatTable
 
     # :category: Aggregates
 
-    # Return the first non-nil item in the Column.  Works with any Column type.
+    # Return the first non-nil item in the Column, or nil if all items are
+    # nil.  Works with any Column type.
     def first
+      return nil if items.all?(&:nil?)
+
       if type == 'String'
         items.reject(&:blank?).first
       else
@@ -204,6 +212,8 @@ module FatTable
 
     # Return the last non-nil item in the Column.  Works with any Column type.
     def last
+      return nil if items.all?(&:nil?)
+
       if type == 'String'
         items.reject(&:blank?).last
       else
@@ -213,9 +223,11 @@ module FatTable
 
     # :category: Aggregates
 
-    # Return a count of the non-nil items in the Column.  Works with any Column
-    # type.
+    # Return a count of the non-nil items in the Column, or the size of the
+    # column if all items are nil.  Works with any Column type.
     def count
+      return items.size if items.all?(&:nil?)
+
       if type == 'String'
         items.reject(&:blank?).count.to_d
       else
@@ -225,8 +237,8 @@ module FatTable
 
     # :category: Aggregates
 
-    # Return the smallest non-nil, non-blank item in the Column.  Works with
-    # numeric, string, and datetime Columns.
+    # Return the smallest non-nil, non-blank item in the Column, or nil if all
+    # items are nil.  Works with numeric, string, and datetime Columns.
     def min
       only_with('min', 'NilClass', 'Numeric', 'String', 'DateTime')
       if type == 'String'
@@ -238,8 +250,8 @@ module FatTable
 
     # :category: Aggregates
 
-    # Return the largest non-nil, non-blank item in the Column.  Works with
-    # numeric, string, and datetime Columns.
+    # Return the largest non-nil, non-blank item in the Column, or nil if all
+    # items are nil.  Works with numeric, string, and datetime Columns.
     def max
       only_with('max', 'NilClass', 'Numeric', 'String', 'DateTime')
       if type == 'String'
@@ -251,19 +263,24 @@ module FatTable
 
     # :category: Aggregates
 
-    # Return a Range object for the smallest to largest value in the column.
-    # Works with numeric, string, and datetime Columns.
+    # Return a Range object for the smallest to largest value in the column,
+    # or nil if all items are nil.  Works with numeric, string, and datetime
+    # Columns.
     def range
       only_with('range', 'NilClass', 'Numeric', 'String', 'DateTime')
+      return nil if items.all?(&:nil?)
+
       Range.new(min, max)
     end
 
     # :category: Aggregates
 
-    # Return the sum of the non-nil items in the Column.  Works with numeric and
-    # string Columns. For a string Column, it will return the concatenation of
-    # the non-nil items.
+    # Return the sum of the non-nil items in the Column, or 0 if all items are
+    # nil.  Works with numeric and string Columns. For a string Column, it
+    # will return the concatenation of the non-nil items.
     def sum
+      return 0 if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('sum', 'Numeric', 'String')
       if type == 'String'
         items.reject(&:blank?).join(' ')
@@ -274,11 +291,13 @@ module FatTable
 
     # :category: Aggregates
 
-    # Return the average value of the non-nil items in the Column.  Works with
-    # numeric and datetime Columns.  For datetime Columns, it converts each date
-    # to its Julian day number, computes the average, and then converts the
-    # average back to a DateTime.
+    # Return the average value of the non-nil items in the Column, or 0 if all
+    # items are nil.  Works with numeric and datetime Columns.  For datetime
+    # Columns, it converts each date to its Julian day number, computes the
+    # average, and then converts the average back to a DateTime.
     def avg
+      return 0 if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('avg', 'DateTime', 'Numeric')
       itms = items.filter_to_type(type)
       size = itms.size.to_d
@@ -293,11 +312,14 @@ module FatTable
     # :category: Aggregates
 
     # Return the sample variance (the unbiased estimator of the population
-    # variance using a divisor of N-1) as the average squared deviation from the
-    # mean, of the non-nil items in the Column. Works with numeric and datetime
-    # Columns. For datetime Columns, it converts each date to its Julian day
-    # number and computes the variance of those numbers.
+    # variance using a divisor of N-1) as the average squared deviation from
+    # the mean, of the non-nil items in the Column, or 0 if all items are
+    # nil. Works with numeric and datetime Columns. For datetime Columns, it
+    # converts each date to its Julian day number and computes the variance of
+    # those numbers.
     def var
+      return 0 if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('var', 'DateTime', 'Numeric')
       all_items =
         if type == 'DateTime'
@@ -319,10 +341,13 @@ module FatTable
 
     # Return the population variance (the biased estimator of the population
     # variance using a divisor of N) as the average squared deviation from the
-    # mean, of the non-nil items in the Column. Works with numeric and datetime
-    # Columns. For datetime Columns, it converts each date to its Julian day
-    # number and computes the variance of those numbers.
+    # mean, of the non-nil items in the Column, or 0 if all items are
+    # nil. Works with numeric and datetime Columns. For datetime Columns, it
+    # converts each date to its Julian day number and computes the variance of
+    # those numbers.
     def pvar
+      return 0 if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('var', 'DateTime', 'Numeric')
       n = items.filter_to_type(type).size.to_d
       return BigDecimal('0.0') if n <= 1
@@ -333,11 +358,13 @@ module FatTable
 
     # Return the sample standard deviation (the unbiased estimator of the
     # population standard deviation using a divisor of N-1) as the square root
-    # of the sample variance, of the non-nil items in the Column. Works with
-    # numeric and datetime Columns. For datetime Columns, it converts each date
-    # to its Julian day number and computes the standard deviation of those
-    # numbers.
+    # of the sample variance, of the non-nil items in the Column, or 0 if all
+    # items are nil. Works with numeric and datetime Columns. For datetime
+    # Columns, it converts each date to its Julian day number and computes the
+    # standard deviation of those numbers.
     def dev
+      return 0 if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('dev', 'DateTime', 'Numeric')
       var.sqrt(20)
     end
@@ -345,12 +372,14 @@ module FatTable
     # :category: Aggregates
 
     # Return the population standard deviation (the biased estimator of the
-    # population standard deviation using a divisor of N) as the square root of
-    # the population variance, of the non-nil items in the Column. Works with
-    # numeric and datetime Columns. For datetime Columns, it converts each date
-    # to its Julian day number and computes the standard deviation of those
-    # numbers.
+    # population standard deviation using a divisor of N) as the square root
+    # of the population variance, of the non-nil items in the Column, or 0 if
+    # all items are nil. Works with numeric and datetime Columns. For datetime
+    # Columns, it converts each date to its Julian day number and computes the
+    # standard deviation of those numbers.
     def pdev
+      return 0 if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('dev', 'DateTime', 'Numeric')
       Math.sqrt(pvar)
     end
@@ -358,8 +387,10 @@ module FatTable
     # :category: Aggregates
 
     # Return true if any of the items in the Column are true; otherwise return
-    # false.  Works only with boolean Columns.
+    # false, or false if all items are nil.  Works only with boolean Columns.
     def any?
+      return false if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('any?', 'Boolean')
       items.filter_to_type(type).any?
     end
@@ -367,17 +398,22 @@ module FatTable
     # :category: Aggregates
 
     # Return true if all of the items in the Column are true; otherwise return
-    # false.  Works only with boolean Columns.
+    # false, or false if all items are nil.  Works only with boolean Columns.
     def all?
+      return false if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('all?', 'Boolean')
       items.filter_to_type(type).all?
     end
 
     # :category: Aggregates
 
-    # Return true if none of the items in the Column are true; otherwise return
-    # false.  Works only with boolean Columns.
+    # Return true if none of the items in the Column are true; otherwise
+    # return false, or true if all items are nil.  Works only with boolean
+    # Columns.
     def none?
+      return true if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('none?', 'Boolean')
       items.filter_to_type(type).none?
     end
@@ -387,6 +423,8 @@ module FatTable
     # Return true if precisely one of the items in the Column is true;
     # otherwise return false.  Works only with boolean Columns.
     def one?
+      return false if type == 'NilClass' || items.all?(&:nil?)
+
       only_with('one?', 'Boolean')
       items.filter_to_type(type).one?
     end
@@ -395,6 +433,7 @@ module FatTable
 
     def only_with(agg, *valid_types)
       return self if valid_types.include?(type)
+
       msg = "aggregate '#{agg}' cannot be applied to a #{type} column"
       raise UserError, msg
     end
@@ -436,7 +475,12 @@ module FatTable
     private
 
     def convert_and_set_type(val)
-      new_val = Convert.convert_to_type(val, type, tolerant: tolerant?)
+      begin
+        new_val = Convert.convert_to_type(val, type, tolerant: tolerant?)
+      rescue IncompatibleTypeError
+        err_msg = "attempt to add '#{val}' to column '#{header}' already typed as #{type}"
+        raise IncompatibleTypeError, err_msg
+      end
       if new_val && (type == 'NilClass' || type == 'String')
         @type =
           if [true, false].include?(new_val)

data/lib/fat_table/convert.rb

@@ -36,8 +36,7 @@ module FatTable
         else
           new_val = convert_to_boolean(val)
           if new_val.nil?
-            msg = "attempt to add '#{val}' to a column already typed as #{type}"
-            raise IncompatibleTypeError, msg
+            raise IncompatibleTypeError
           end
           new_val
         end
@@ -47,8 +46,7 @@ module FatTable
         else
           new_val = convert_to_date_time(val)
           if new_val.nil?
-            msg = "attempt to add '#{val}' to a column already typed as #{type}"
-            raise IncompatibleTypeError, msg
+            raise IncompatibleTypeError
           end
           new_val
         end
@@ -58,8 +56,7 @@ module FatTable
         else
           new_val = convert_to_numeric(val)
           if new_val.nil?
-            msg = "attempt to add '#{val}' to a column already typed as #{type}"
-            raise IncompatibleTypeError, msg
+            raise IncompatibleTypeError
           end
           new_val
         end
@@ -82,8 +79,7 @@ module FatTable
         else
           new_val = convert_to_string(val)
           if new_val.nil?
-            msg = "attempt to add '#{val}' to a column already typed as #{type}"
-            raise IncompatibleTypeError, msg
+            raise IncompatibleTypeError
           end
           new_val
         end

data/lib/fat_table/footer.rb

@@ -2,7 +2,7 @@
 
 module FatTable
   class Footer
-    attr_reader :table, :label, :label_col, :values, :group
+    attr_reader :table, :label_col, :values, :group
 
     ###########################################################################
     # Constructors
@@ -15,6 +15,7 @@ module FatTable
     # for the footer are added later with the #add_value method.
     def initialize(label = 'Total', table, label_col: nil, group: false)
       @label = label
+
       unless table.is_a?(Table)
         raise ArgumentError, 'Footer.new needs a table argument'
       end
@@ -30,14 +31,7 @@ module FatTable
       @group = group
       @group_cols = {}
       @values = {}
-      if group
-        @values[@label_col] = []
-        table.number_of_groups.times do
-          @values[@label_col] << @label
-        end
-      else
-        @values[@label_col] = [@label]
-      end
+      insert_labels_in_label_col
       make_accessor_methods
     end
 
@@ -71,6 +65,11 @@ module FatTable
       end
     end
 
+    # Return the value of the label, for the kth group if grouped.
+    def label(k = 0)
+      @values[@label_col][k]
+    end
+
     # :category: Accessors
 
     # Return the value of under the +key+ header, or if this is a group
@@ -108,8 +107,10 @@ module FatTable
       if group && k.nil?
         raise ArgumentError, 'Footer#column(h, k) missing the group number argument k'
       end
+
       if group
-        k.nil? ? @group_cols[h] : @group_cols[h][k]
+        @group_cols[h] ||= table.group_cols(h)
+        @group_cols[h][k]
       else
         table.column(h)
       end
@@ -151,14 +152,13 @@ module FatTable
 
     # Evaluate the given agg for the header col and, in the case of a group
     # footer, the group k.
-    def calc_val(agg, col, k = nil)
-      column =
-        if group
-          @group_cols[col] ||= table.group_cols(col)
-          @group_cols[col][k]
-        else
-          table.column(col)
-        end
+    def calc_val(agg, h, k = nil)
+      column = column(h, k)
+
+      # Convert Date and Time objects to DateTime
+      if [Date, Time].include?(agg.class)
+        agg = agg.to_datetime
+      end
 
       case agg
       when Symbol
@@ -166,7 +166,7 @@ module FatTable
       when String
         begin
           converted_val = Convert.convert_to_type(agg, column.type)
-        rescue UserError
+        rescue UserError, IncompatibleTypeError
           converted_val = false
         end
         if converted_val
@@ -179,29 +179,77 @@ module FatTable
       when Proc
         result =
           if group
-            unless agg.arity == 3
-              msg = 'a lambda used in a group footer must have three arguments: (f, c, k)'
+            case agg.arity
+            when 0
+              agg.call
+            when 1
+              agg.call(k)
+            when 2
+              agg.call(k, column)
+            when 3
+              agg.call(k, column, self)
+            else
+              msg = 'a lambda used in a group footer may have 0 to 3  three arguments: (k, c, f)'
               raise ArgumentError, msg
             end
-            agg.call(self, col, k)
           else
-            unless agg.arity == 2
-              msg = 'a lambda used in a non-group footer must have two arguments: (f, c)'
+            case agg.arity
+            when 0
+              agg.call
+            when 1
+              agg.call(column)
+            when 2
+              agg.call(column, self)
+            else
+              msg = 'a lambda used in a non-group footer may have 0 to 2 arguments: (c, f)'
               raise ArgumentError, msg
             end
-            agg.call(self, col)
           end
-        # Make sure the result returned can be inserted into footer field.
-        case result
-        when Symbol, String
-          calc_val(result, col, k)
-        when column.type.constantize
-          result
+        # Pass the result back into this method as the new agg
+        calc_val(result, h, k)
+      else
+        agg.to_s
+      end
+    end
+
+    # Insert a possibly calculated value for the label in the appropriate
+    # @values column.
+    def insert_labels_in_label_col
+      if group
+        @values[@label_col] = []
+        table.number_of_groups.times do |k|
+          @values[@label_col] << calc_label(k)
+        end
+      else
+        @values[@label_col] = [calc_label]
+      end
+    end
+
+    # Calculate the label for the kth group, using k = nil for non-group
+    # footers.  If the label is a proc, call it with the group number.
+    def calc_label(k = nil)
+      case @label
+      when Proc
+        case @label.arity
+        when 0
+          @label.call
+        when 1
+          k ? @label.call(k) : @label.call(self)
+        when 2
+          if k
+            @label.call(k, self)
+          else
+            raise ArgumentError, "a non-group footer label proc may only have 1 argument for the containing footer f"
+          end
         else
-          raise ArgumentError, "lambda cannot return an object of class #{result.class}"
+          if k
+            raise ArgumentError, "group footer label proc may only have 0, 1, or 2 arguments for group number k and containing footer f"
+          else
+            raise ArgumentError, "a non-group footer label proc may only have 0 or 1 arguments for the containing footer f"
+          end
         end
       else
-        agg
+        @label.to_s
       end
     end
 

data/lib/fat_table/formatters/formatter.rb

@@ -181,41 +181,74 @@ module FatTable
     end
 
     # :category: Add Footers
-
-    # A simpler method for adding a footer to the formatted output having the
-    # label +label+ placed in the column with the header +label_col+ or in the
-    # first column if +label_col+ is ommitted.  The remaining hash arguments
-    # apply an aggregate to the values of the column, which can be:
-    #
-    # (1) a symbol representing one of the builtin aggregates, i.e., :first,
-    # :last, :range, :sum, :count, :min, :max, :avg, :var, :pvar, :dev, :pdev,
-    # :any?, :all?, :none?, and :one?,
     #
-    # (2) an arbitrary value of one of the four supported types: Boolean,
-    # DateTime, Numeric, or String: true, false, 3.14159, 'Total debits', or a
-    # string that is convertible into one of these types by the usual methods
-    # used in contructing a table,
+    # A keyword method for adding a footer to the formatted output having the
+    # label +label:+ (default 'Total') placed in the column with the header
+    # +label_col:+ or in the first column if +label_col+ is ommitted.
+    # This assigns a fixed group label to be placed in the :date column:
+    # #+begin_src ruby
+    #   fmtr.foot(label: "Year's Average", label_col: :date, temp: avg)
+    # #+end_src
+    #
+    # Besides being a fixed string, the +label:+ can also be a proc or lambda
+    # taking one argument, the foooter itself.
+    # Thus, a label such as:
+    #
+    # #+begin_src ruby
+    #     fmtr.foot(label: -> (f) { "Average (latest year #{f.column(:date).max.year})" },
+    #                temp: :avg)
+    # #+end_src
+    # And this would add the highest number to label, assuming the :date column
+    # of the footer's table had the year for each item.
+    #
+    # The remaining hash arguments apply an aggregate to the values of the
+    # column, which can be:
+    #
+    # 1. a symbol representing one of the builtin aggregates, i.e., :first,
+    #    :last, :range, :sum, :count, :min, :max, :avg, :var, :pvar, :dev,
+    #    :pdev, :any?, :all?, :none?, and :one?, or a symbol for your own
+    #    aggregate defined as an instance method on FatTable::Column.
+    # 2. a fixed string, but it the string can be converted into the Column's
+    #    type, it will be converted, so the string '3.14159' will be converted
+    #    to 3.14159 in a Numeric column.
+    # 3. a value of the Column's type, so Date.today would simply be evaluated
+    #    for a Numeric column.
+    # 4. most flexibly of all, a proc or lambda taking arguments: f, the
+    #    footer object itself; c, the column (or in the case of a group
+    #    footer, the sub-column) corresponding to the current header, and in
+    #    the case of a group footer, k, the number of the group (0-based).
+    # 5. Any other value is converted to a string with #to_s.
     #
     # Examples:
     #
     # Put the label in the :dickens column of the footer and the maximum value
     # from the :alpha column in the :alpha column of the footer.
     #
-    #   fmtr.foot('Best', :dickens, alpha: :max)
+    #   fmtr.foot(label: 'Best', label_col: :dickens, alpha: :max)
     #
     # Put the label 'Today' in the first column of the footer and today's date
     # in the :beta column.
     #
-    #   fmtr.foot('Today', beta: Date.today)
+    #   fmtr.foot(label: 'Today', beta: Date.today)
     #
     # Put the label 'Best' in the :dickens column of the footer and the string
     # 'Tale of Two Cities' in the :alpha column of the footer.  Since it can't
     # be interpreted as Boolean, Numeric, or DateTime, it is placed in the
     # footer literally.
     #
-    #   fmtr.foot('Best', :dickens, alpha: 'A Tale of Two Cities')
+    #   fmtr.foot(label: 'Best', label_col: :dickens, alpha: 'A Tale of Two
+    #   Cities')
+    #
+    # Use a lambda to calculate the value to be placed in the column :gamma.
+    #
+    #   fmtr.foot(label: 'Gamma', beta: :avg, gamma: ->(f, c) {
+    #     (Math.gamma(c.count) + f[:beta] } )
     #
-    def foot(label, label_col = nil, **agg_cols)
+    # Note that this way a footer can be made a function of the other footer
+    # values (using f[:other_col]) as well as the Column object corresponding
+    # to the lamda's column.
+    #
+    def foot(label: 'Total', label_col: nil, **agg_cols)
       foot = Footer.new(label, table, label_col: label_col)
       agg_cols.each_pair do |h, agg|
         foot.add_value(h, agg)
@@ -255,9 +288,92 @@ module FatTable
       foot
     end
 
-    # Add a group footer to the formatted output.  This method has the same
-    # usage as the #foot method, but it adds group footers.
-    def gfoot(label, label_col = nil, **agg_cols)
+    # :category: Add Footers
+    #
+    # A keyword method for adding a group footer to the formatted output
+    # having the label +label:+ (default 'Total') placed in the column with
+    # the header +label_col:+ or in the first column if +label_col+ is
+    # ommitted.
+    #
+    # This assigns a fixed group label to be placed in the :date column:
+    # #+begin_src ruby
+    #   fmtr.gfoot(label: "Year's Average", label_col: :date, temp: avg)
+    # #+end_src
+    #
+    # Besides being a fixed string, the +label:+ can also be a proc or lambda
+    # taking one or two arguments.  In the one argument form, the argument is
+    # the group number k.  If a second argument is specified, the foooter
+    # itself is passed as the argument.  Thus, a label such as:
+    #
+    # #+begin_src ruby
+    #   fmtr.gfoot(label: -> (k) { "Group #{(k+1).to_roman} Average" }, temp: :avg)
+    # #+end_src
+    # This would format the label with a roman numeral (assuming you defined a
+    # method to do so) for the group number.
+    #
+    # #+begin_src ruby
+    #     fmtr.gfoot(label: -> (k, f) { "Year #{f.column(:date, k).max.year} Group #{(k+1).to_roman} Average" },
+    #                temp: :avg)
+    # #+end_src
+    # And this would add the group's year to label, assuming the :date column
+    # of the footer's table had the same year for each item in the group.
+    #
+    #
+    # The remaining hash arguments apply an aggregate to the values
+    # of the column, which can be:
+    #
+    # 1. a symbol representing one of the builtin aggregates, i.e., :first,
+    #    :last, :range, :sum, :count, :min, :max, :avg, :var, :pvar, :dev,
+    #    :pdev, :any?, :all?, :none?, and :one?, or a symbol for your own
+    #    aggregate defined as an instance method on FatTable::Column.
+    # 2. a fixed string, but it the string can be converted into the Column's
+    #    type, it will be converted, so the string '3.14159' will be converted
+    #    to 3.14159 in a Numeric column.
+    # 3. a value of the Column's type, so Date.today would simply be evaluated
+    #    for a Numeric column.
+    # 4. most flexibly of all, a proc or lambda taking arguments: f, the
+    #    footer object itself; c, the column (or in the case of a group
+    #    footer, the sub-column) corresponding to the current header, and k,
+    #    this group's group number (0-based).
+    # 5. Any other value is converted to a string with #to_s.
+    #
+    # Examples:
+    #
+    # Put the label in the :dickens column of the footer and the maximum value
+    # from the :alpha column in the :alpha column of the footer.
+    #
+    # #+begin_src ruby
+    #   fmtr.gfoot(label: 'Best', label_col: :dickens, alpha: :max)
+    # #+end_src
+    #
+    # Put the label 'Today' in the first column of the footer and today's date
+    # in the :beta column.
+    #
+    # #+begin_src ruby
+    #   fmtr.gfoot(label: 'Today', beta: Date.today)
+    # #+end_src
+    #
+    # Put the label 'Best' in the :dickens column of the footer and the string
+    # 'Tale of Two Cities' in the :alpha column of the footer.  Since it can't
+    # be interpreted as Boolean, Numeric, or DateTime, it is placed in the
+    # footer literally.
+    #
+    # #+begin_src ruby
+    #   fmtr.gfoot(label: 'Best', label_col: :dickens, alpha: 'A Tale of Two
+    #   Cities')
+    # #+end_src
+    #
+    # Use a lambda to calculate the value to be placed in the column :gamma.
+    #
+    # #+begin_src ruby
+    #   fmtr.gfoot(label: 'Gamma', beta: :avg, gamma: ->(f, c) {
+    #     (Math.gamma(c.count) + f[:beta] } )
+    # #+end_src
+    #
+    # Note that this way a footer can be made a function of the other footer
+    # values (using f[:other_col]) as well as the Column object corresponding
+    # to the lamda's column.
+    def gfoot(label: 'Group Total', label_col: nil, **agg_cols)
       foot = Footer.new(label, table, label_col: label_col, group: true)
       agg_cols.each_pair do |h, agg|
         foot.add_value(h, agg)
@@ -532,7 +648,7 @@ module FatTable
       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(',')}"
+        msg = "invalid #{location} column or type: #{invalid_keys.join(', ')}"
         raise UserError, msg
       end
 
@@ -1004,9 +1120,14 @@ module FatTable
     # converted to strings formatted according to the Formatter's formatting
     # directives given in Formatter.format_for or Formatter.format.
     def output
-      # This results in a hash of two-element arrays. The key is the header and
-      # the value is an array of the header and formatted header. We do the
-      # latter so the structure parallels the structure for rows explained next.
+      # If there are neither headers nor any rows in the table, return an
+      # empty string.
+      return '' if table.empty? && table.headers.empty?
+
+      # This results in a hash of two-element arrays. The key
+      # is the header and the value is an array of the header and formatted
+      # header. We do the latter so the structure parallels the structure for
+      # rows explained next.
       formatted_headers = build_formatted_headers
 
       # These produce an array with each element representing a row of the

data/lib/fat_table/formatters/org_formatter.rb

@@ -20,7 +20,7 @@ module FatTable
     end
 
     def pre_header(widths)
-      result = '|'
+      result = +'|'
       widths.each_value do |w|
         result += '-' * (w + 2) + '+'
       end
@@ -53,7 +53,7 @@ module FatTable
     end
 
     def hline(widths)
-      result = '|'
+      result = +'|'
       widths.each_value do |w|
         result += '-' * (w + 2) + '+'
       end
@@ -62,7 +62,7 @@ module FatTable
     end
 
     def post_footers(widths)
-      result = '|'
+      result = +'|'
       widths.each_value do |w|
         result += '-' * (w + 2) + '+'
       end

data/lib/fat_table/formatters/term_formatter.rb

@@ -221,7 +221,7 @@ module FatTable
     end
 
     def pre_header(widths)
-      result = upper_left
+      result = +upper_left
       widths.each_value do |w|
         result += double_rule * (w + 2) + upper_tee
       end
@@ -255,7 +255,7 @@ module FatTable
     end
 
     def hline(widths)
-      result = left_tee
+      result = +left_tee
       widths.each_value do |w|
         result += horizontal_rule * (w + 2) + single_cross
       end
@@ -289,7 +289,7 @@ module FatTable
     end
 
     def post_footers(widths)
-      result = lower_left
+      result = +lower_left
       widths.each_value do |w|
         result += double_rule * (w + 2) + lower_tee
       end

data/lib/fat_table/formatters/text_formatter.rb

@@ -16,7 +16,7 @@ module FatTable
     end
 
     def pre_header(widths)
-      result = '+'
+      result = +'+'
       widths.each_value do |w|
         result += '=' * (w + 2) + '+'
       end
@@ -49,7 +49,7 @@ module FatTable
     end
 
     def hline(widths)
-      result = '+'
+      result = +'+'
       widths.each_value do |w|
         result += '-' * (w + 2) + '+'
       end
@@ -82,7 +82,7 @@ module FatTable
     end
 
     def post_footers(widths)
-      result = '+'
+      result = +'+'
       widths.each_value do |w|
         result += '=' * (w + 2) + '+'
       end

data/lib/fat_table/table.rb

@@ -105,7 +105,7 @@ module FatTable
       unless heads.empty?
         heads.each do |h|
           if h.to_s.end_with?('!') || @tolerant_columns.include?(h)
-            @columns << Column.new(header: h.to_s.sub(/!\s*\z/, ''), tolerant: true)
+            @columns << Column.new(header: h.to_s.sub(/!\s*\z/, ''), type: 'String')
           else
             @columns << Column.new(header: h)
           end
@@ -120,7 +120,7 @@ module FatTable
     # though FatTable::Table objects have no instance variables, a class that
     # inherits from it might.
     def empty_dup
-      self.dup.__empty!
+      dup.__empty!
     end
 
     def __empty!
@@ -530,8 +530,13 @@ module FatTable
 
     # Yield each row of the table as a Hash with the column symbols as keys.
     def each
-      rows.each do |row|
-        yield row
+      if block_given?
+        rows.each do |row|
+          yield row
+        end
+        self
+      else
+        to_enum(:each)
       end
     end
 

data/lib/fat_table/version.rb

@@ -2,5 +2,5 @@
 
 module FatTable
   # The current version of FatTable
-  VERSION = '0.5.4'
+  VERSION = '0.6.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat_table
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.1
 platform: ruby
 authors:
 - Daniel E. Doherty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-27 00:00:00.000000000 Z
+date: 2022-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler