fat_table 0.5.2 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f35f99181e39d7569ce7df958ae92742617826e54b8ed2c6352b73c5723a3d44
-  data.tar.gz: d37acb3f0be27191bafa17ae30b51dfd2db2c4a5d97e6c80fa5399f2618ea98b
+  metadata.gz: 2f391d5e4ad9d7a4dcb303098b90f6fb42379d9df382192c4bacaf169523dab1
+  data.tar.gz: ea75f906fcd164752a3ca2220324ad10d8438562bb31c4846bc6575723e834fa
 SHA512:
-  metadata.gz: eafd2077939c57673358a680490ccbe48218e8b290540790f3526b5945337e53c9366369c255adcc85e01916ad012cbad12132593def15350fd3993304bc5a30
-  data.tar.gz: e7a542986752ac4f632e7344c49080786e0e52ecbe224a0644a6da7b4ec65dd8ca2b9abe842ee295ad7cf19a7a0ccd0e93b22632716c95533665a21d14b5cc83
+  metadata.gz: 2914c40a497cf24bcdba8868c4a4607ea1bdb0a94fba8caa3d6e31407ff6832621df2a0b4a8a2bb98c3b40080fed6d752f8e936f66a96270fe675e93d5a852d6
+  data.tar.gz: dbc43f4d2bac4a2a19bc7cc90d1fbfbf739a12f0f280a543670af588cfcf2bb0df74d50cfb7ded76b851f5470fd30d4f971659cead5131f9ea15e24b492e5823

data/README.org

@@ -25,6 +25,16 @@ The following is for org.
 
 [[https://travis-ci.org/ddoherty03/fat_table.svg?branch=master]]
 
+* Version
+#+begin_src ruby :wrap EXAMPLE
+  require 'fat_table'
+  "Current version is: #{FatTable::VERSION}"
+#+end_src
+
+#+begin_EXAMPLE
+Current version is: 0.5.4
+#+end_EXAMPLE
+
 * Introduction
 
 ~FatTable~ is a gem that treats tables as a data type. It provides methods for
@@ -57,6 +67,7 @@ array of arrays with its ~.to_aoa~ output function will be rendered in an
 org-mode buffer as an org-table, ready for processing by other code blocks.
 
 * Table of Contents                                            :toc:noexport:
+- [[#version][Version]]
 - [[#introduction][Introduction]]
 - [[#installation][Installation]]
   - [[#using-in-a-gem][Using in a gem]]
@@ -74,6 +85,7 @@ org-mode buffer as an org-table, ready for processing by other code blocks.
       - [[#without-headers][Without Headers]]
       - [[#with-headers][With Headers]]
       - [[#forcing-string-type][Forcing String Type]]
+      - [[#designating-tolerant-columns][Designating "Tolerant" Columns]]
     - [[#from-csv-or-org-mode-files-or-strings][From CSV or Org Mode files or strings]]
     - [[#from-arrays-of-arrays][From Arrays of Arrays]]
       - [[#in-ruby-code][In Ruby Code]]
@@ -430,11 +442,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
@@ -591,10 +618,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)
@@ -619,8 +654,83 @@ converted to strings with the #to_s method.
 +======+======+============+===+=======+===+
 #+end_EXAMPLE
 
+**** Designating "Tolerant" Columns
+Related to the problem just discussed is the problem of reading files in from
+the wild where a column may get typed as, say Numeric, but then contain
+something that can't be parsed as a Numeric.  ~FatTable~ raises an exception
+is such cases, and that may be what you want if you can control the input.
+But, especially when you cannot do so, it can be helpful to designate one or
+more columns as "tolerant."  This means that when a conversion problem occurs,
+the column item is retained as a string type in a column that is otherwise of
+one of the types Numeric, DateTime, or Boolean.  Those string items are
+treated as nils for purposes of sorting or evaluation in a ~select~ method.
+When formatted, they participate in string formatting directive, but not those
+for other types.
+
+All of the table construction methods, allow a keyword parameter,
+~tolerant_columns~, where you can designate what columns should be convert to
+String type when conversion to the auto-typed column type is not possible.
+The parameter should be an array of headers, in either string or symbol form,
+for which this behavior is desired.  In addition, it can be set to the special
+string '*' or symbol ~:*~ to indicate that all the columns should be made
+tolerant.
+
+#+begin_src ruby :wrap EXAMPLE
+  require 'fat_table'
+  tab = FatTable.new(:a, 'b', 'C', :d, :zip, tolerant_columns: [:zip])
+  tab << { a: 1, b: 2, c: "<2017-01-21>", d: 'f', e: '', zip: 18552 }
+  tab << { a: 3.14, b: 2.17, c: '[2016-01-21 Thu]', d: 'Y', e: nil }
+  tab << { zip: '01879--7884' }
+  tab << { zip: '66210' }
+  tab << { zip: '90210' }
+  tab.to_text
+#+end_src
+
+#+RESULTS:
+#+begin_EXAMPLE
++======+======+============+===+=============+===+
+| A    | B    | C          | D | Zip         | E |
++------+------+------------+---+-------------+---+
+| 1    | 2    | 2017-01-21 | F | 18552       |   |
+| 3.14 | 2.17 | 2016-01-21 | T |             |   |
+|      |      |            |   | 01879--7884 |   |
+|      |      |            |   | 66210       |   |
+|      |      |            |   | 90210       |   |
++======+======+============+===+=============+===+
+#+end_EXAMPLE
+
+Another way to designate a column as tolerant is to end a column you want to
+designate as tolerant with a ~!~.  The ~!~ will be stripped from the header,
+but it will be marked as tolerant.
+#+begin_src ruby :wrap EXAMPLE
+  require 'fat_table'
+  tab = FatTable.new(:a, 'b!', 'C', :d, :zip!)
+  tab << { a: 1, b: 2, c: "<2017-01-21>", d: 'f', e: '', zip: 18552 }
+  tab << { a: 3.14, b: 2.17, c: '[2016-01-21 Thu]', d: 'Y', e: nil }
+  tab << { zip: '01879--7884' }
+  tab << { zip: '66210', b: 'Not a Number' }
+  tab << { zip: '90210' }
+  tab.to_text
+#+end_src
+
+#+RESULTS:
+#+begin_EXAMPLE
++======+==============+============+===+=============+===+
+| A    | B            | C          | D | Zip         | E |
++------+--------------+------------+---+-------------+---+
+| 1    | 2            | 2017-01-21 | F | 18552       |   |
+| 3.14 | 2.17         | 2016-01-21 | T |             |   |
+|      |              |            |   | 01879--7884 |   |
+|      | Not a Number |            |   | 66210       |   |
+|      |              |            |   | 90210       |   |
++======+==============+============+===+=============+===+
+#+end_EXAMPLE
+
 *** From CSV or Org Mode files or strings
-Tables can also be read from ~.csv~ files or files containing ~org-mode~ tables.
+Tables can also be read from ~.csv~ files or files containing ~org-mode~
+tables.  Remember that you can make any column tolerant with a
+~tolerant_columns:~ keyword argument or make them all tolerant by designating
+the pseudo-column ~:*~ as tolerant.
 
 In the case of org-mode files, ~FatTable~ skips through the file until it finds
 a line that look like a table, that is, it begins with any number of spaces
@@ -677,8 +787,10 @@ header row, and the headers are converted to symbols as described above.
 
 *** From Arrays of Arrays
 **** In Ruby Code
-You can also initialize a table directly from ruby data structures. You can, for
-example, build a table from an array of arrays:
+You can also initialize a table directly from ruby data structures. You can,
+for example, build a table from an array of arrays.  Remember that you can
+make any column tolerant with a ~tolerant_columns:~ keyword argument or make
+them all tolerant by designating the pseudo-column ~:*~ as tolerant.
 
 #+BEGIN_SRC ruby
   aoa = [
@@ -772,8 +884,10 @@ 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 must have the same keys.
+headers of the table are taken from the keys of the hashes. Accordingly, all
+the hashes must have the same keys.  Remember that you can make any column
+tolerant with a ~tolerant_columns:~ keyword argument or make them all tolerant
+by designating the pseudo-column ~:*~ as tolerant.
 
 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
@@ -862,6 +976,10 @@ The ~.connect~ function need only be called once, and the database handle it
 creates will be used for all subsequent ~.from_sql~ calls until ~.connect~ is
 called again.
 
+Remember that you can make any column tolerant with a ~tolerant_columns:~
+keyword argument or make them all tolerant by designating the pseudo-column
+~:*~ as tolerant.
+
 *** Marking Groups in Input
 **** Manually
 At any point, you can add a boundary to a table by invokong the
@@ -2549,9 +2667,10 @@ the table, but they can be overridden by more specific directives given in a
 ~format_for~ directive.
 
 **** Type and Column priority
-A directive based on type applies to all columns having that type unless
-overridden by a directive specific to a named column; a directive based on a
-column name applies only to cells in that column.
+A directive based the column name overrides any directive based on type.  If
+any cell has both a type-based formatting and column-based, the column
+instructions prevail.  In earlier versions the instuctions were "merged" but
+that is no longer the case.
 
 However, there is a twist.  Since the end result of formatting is to convert
 all columns to strings, the formatting directives for the ~String~ type can

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/ext/array.rb

@@ -12,4 +12,21 @@ class Array
       end
     end
   end
+
+  def filter_to_type(typ)
+    if typ == 'Boolean'
+      compact.select { |i| i.is_a?(TrueClass) || i.is_a?(FalseClass) }
+    elsif typ == 'DateTime'
+      compact.select { |i| i.is_a?(Date) || i.is_a?(DateTime) || i.is_a?(Time) }
+        .map { |i| i.to_datetime }
+    elsif typ == 'Numeric'
+      compact.select { |i| i.is_a?(Numeric) }
+    elsif typ == 'String'
+      map { |i| i.to_s }
+    elsif typ == 'NilClass'
+      self
+    else
+      raise ArgumentError, "cannot filter_to_type for type '#{typ}'"
+    end
+  end
 end

data/lib/fat_table/column.rb

@@ -83,7 +83,7 @@ module FatTable
     #   col.type #=> 'Numeric'
     #   col.header #=> :prices
     #   col.sum #=> 18376.75
-    def initialize(header:, items: [], type: 'NilClass')
+    def initialize(header:, items: [], type: 'NilClass', tolerant: false)
       @raw_header = header
       @header =
         if @raw_header.is_a?(Symbol)
@@ -92,6 +92,7 @@ module FatTable
           @raw_header.to_s.as_sym
         end
       @type = type
+      @tolerant = tolerant
       msg = "unknown column type '#{type}"
       raise UserError, msg unless TYPES.include?(@type.to_s)
 
@@ -141,6 +142,14 @@ module FatTable
 
     # :category: Attributes
 
+    # Is this column tolerant of type incompatibilities?  If so, the Column
+    # type will be forced to String if an incompatible type is found.
+    def tolerant?
+      @tolerant
+    end
+
+    # :category: Attributes
+
     # Force the column to have String type and then convert all items to
     # strings.
     def force_string!
@@ -182,12 +191,15 @@ 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
-        items.compact.first
+        items.filter_to_type(type).first
       end
     end
 
@@ -195,83 +207,94 @@ 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
-        items.compact.last
+        items.filter_to_type(type).last
       end
     end
 
     # :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
-        items.compact.count.to_d
+        items.filter_to_type(type).count.to_d
       end
     end
 
     # :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'
         items.reject(&:blank?).min
       else
-        items.compact.min
+        items.filter_to_type(type).min
       end
     end
 
     # :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'
         items.reject(&:blank?).max
       else
-        items.compact.max
+        items.filter_to_type(type).max
       end
     end
 
     # :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(' ')
       else
-        items.compact.sum
+        items.filter_to_type(type).sum
       end
     end
 
     # :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.compact
+      itms = items.filter_to_type(type)
       size = itms.size.to_d
       if type == 'DateTime'
         avg_jd = itms.map(&:jd).sum / size
@@ -284,17 +307,20 @@ 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'
-          items.compact.map(&:jd)
+          items.filter_to_type(type).map(&:jd)
         else
-          items.compact
+          items.filter_to_type(type)
         end
       n = count
       return BigDecimal('0.0') if n <= 1
@@ -310,12 +336,15 @@ 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.compact.size.to_d
+      n = items.filter_to_type(type).size.to_d
       return BigDecimal('0.0') if n <= 1
       var * ((n - 1) / n)
     end
@@ -324,11 +353,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
@@ -336,12 +367,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
@@ -349,28 +382,35 @@ 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.compact.any?
+      items.filter_to_type(type).any?
     end
 
     # :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.compact.all?
+      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.compact.none?
+      items.filter_to_type(type).none?
     end
 
     # :category: Aggregates
@@ -378,14 +418,17 @@ 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.compact.one?
+      items.filter_to_type(type).one?
     end
 
     private
 
     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
@@ -400,9 +443,17 @@ module FatTable
 
     # Append +itm+ to end of the Column after converting it to the Column's
     # type. If the Column's type is still open, i.e. NilClass, attempt to fix
-    # the Column's type based on the type of +itm+ as with Column.new.
+    # the Column's type based on the type of +itm+ as with Column.new.  If its
+    # a tolerant column, respond to type errors by converting the column to a
+    # String type.
     def <<(itm)
-      items << convert_to_type(itm)
+      items << convert_and_set_type(itm)
+    rescue IncompatibleTypeError => ex
+      if tolerant?
+        items << Convert.convert_to_string(itm)
+      else
+        raise ex
+      end
     end
 
     # :category: Constructors
@@ -418,9 +469,14 @@ module FatTable
 
     private
 
-    def convert_to_type(val)
-      new_val = Convert.convert_to_type(val, type)
-      if new_val && type == 'NilClass'
+    def convert_and_set_type(val)
+      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)
             'Boolean'

data/lib/fat_table/convert.rb

@@ -10,7 +10,7 @@ module FatTable
     # determined, raise an error if the val cannot be converted to the Column
     # type. Otherwise, returns the converted val as an object of the correct
     # class.
-    def self.convert_to_type(val, type)
+    def self.convert_to_type(val, type, tolerant: false)
       case type
       when 'NilClass'
         if val != false && val.blank?
@@ -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 UserError, 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 UserError, msg
+            raise IncompatibleTypeError
           end
           new_val
         end
@@ -58,24 +56,35 @@ 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 UserError, msg
+            raise IncompatibleTypeError
           end
           new_val
         end
       when 'String'
         if val.nil?
           nil
+        elsif tolerant
+          # Allow String to upgrade to one of Numeric, DateTime, or Boolean if
+          # possible.
+          if (new_val = convert_to_numeric(val))
+            new_val
+          elsif (new_val = convert_to_date_time(val))
+            new_val
+          elsif (new_val = convert_to_boolean(val))
+            new_val
+          else
+            new_val = convert_to_string(val)
+          end
+          new_val
         else
           new_val = convert_to_string(val)
           if new_val.nil?
-            msg = "attempt to add '#{val}' to a column already typed as #{type}"
-            raise UserError, msg
+            raise IncompatibleTypeError
           end
           new_val
         end
       else
-        raise UserError, "Mysteriously, column has unknown type '#{type}'"
+        raise LogicError, "Mysteriously, column has unknown type '#{type}'"
       end
     end
 
@@ -121,6 +130,7 @@ module FatTable
       return val if val.is_a?(DateTime)
       return val if val.is_a?(Date)
       return val.to_datetime if val.is_a?(Time)
+
       begin
         str = val.to_s.clean
         return nil if str.blank?

data/lib/fat_table/errors.rb

@@ -9,6 +9,10 @@ module FatTable
   # cannot correct.
   class LogicError < StandardError; end
 
+  # Raised when attempting to add an incompatible type to an already-typed
+  # Column.
+  class IncompatibleTypeError < UserError; end
+
   # Raised when an external resource is not available due to caller or
   # programmer error or some failure of the external resource to be available.
   class TransientError < StandardError; end

data/lib/fat_table/evaluator.rb

@@ -45,17 +45,15 @@ module FatTable
     end
 
     # Return the result of evaluating +expr+ as a Ruby expression in which the
-    # instance variables set in Evaluator.new and any local variables set in the
-    # Hash parameter +locals+ are available to the expression.
+    # instance variables set in Evaluator.new and any local variables set in
+    # the Hash parameter +locals+ are available to the expression.  Certain
+    # errors simply return nil as the result.  This can happen, for example,
+    # when a string gets into an otherwise numeric column because the column
+    # is set to tolerant.
     def evaluate(expr = '', locals: {})
       eval(expr, local_vars(binding, locals))
     rescue NoMethodError, TypeError => ex
-      if ex.to_s =~ /for nil:NilClass|nil can't be coerced/
-        # Likely one of the locals was nil, so let nil be the result.
-        return nil
-      else
-        raise ex
-      end
+      nil
     end
 
     private

data/lib/fat_table/footer.rb

@@ -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

data/lib/fat_table/formatters/formatter.rb

@@ -532,7 +532,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
 
@@ -562,20 +562,21 @@ module FatTable
           end
         end
 
-        # Merge in formatting for column h based on the column type, or based
-        # on the string type for the header location.
+        # Merge in formatting instructions for column h based on the column
+        # name, or if there is no formatting instructions for the column by
+        # name, merge in the formatting instructions based on the column's
+        # type.  Insist on only the string type for the header location.
         typ = (location == :header ? :string : table.type(h).as_sym)
         parse_typ_method_name = 'parse_' + typ.to_s + '_fmt'
-        if fmts.key?(typ)
-          # Merge in type-based formatting
-          typ_fmt = send(parse_typ_method_name, fmts[typ]).first
-          format_h = format_h.merge(typ_fmt)
-        end
         if fmts[h]
           # Merge in column formatting
           col_fmt = send(parse_typ_method_name, fmts[h],
                          strict: location != :header).first
           format_h = format_h.merge(col_fmt)
+        elsif fmts.key?(typ)
+          # Merge in type-based formatting
+          typ_fmt = send(parse_typ_method_name, fmts[typ]).first
+          format_h = format_h.merge(typ_fmt)
         end
 
         # Copy :body formatting for column h to :bfirst and :gfirst if they
@@ -1003,9 +1004,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

@@ -62,19 +62,53 @@ module FatTable
     # method call.
     attr_accessor :explicit_boundaries
 
+    # An Array of FatTable::Columns that should be tolerant.
+    attr_reader :tolerant_columns
+
     ###########################################################################
     # Constructors
     ###########################################################################
 
     # :category: Constructors
 
-    # Return an empty FatTable::Table object.
-    def initialize(*heads)
+    # Return an empty FatTable::Table object.  Specifying headers is optional.
+    # Any headers ending with a ! are marked as tolerant, in that, if an
+    # incompatible type is added to it, the column is re-typed as a String
+    # column, and construction proceeds.  The ! is stripped from the header to
+    # form the column key, though.  You can also provide the names of columns
+    # that should be tolerant by using the +tolerant_columns key-word to
+    # provide an array of headers that should be tolerant.  The special string
+    # '*' or the symbol :* indicates that all columns should be created
+    # tolerant.
+    def initialize(*heads, tolerant_columns: [])
       @columns = []
       @explicit_boundaries = []
+      @tolerant_columns =
+        case tolerant_columns
+        when Array
+          tolerant_columns.map { |h| h.to_s.as_sym }
+        when String
+          if tolerant_columns.strip == '*'
+            ['*'.to_sym]
+          else
+            [tolerant_columns.as_sym]
+          end
+        when Symbol
+          if tolerant_columns.to_s.strip == '*'
+            ['*'.to_sym]
+          else
+            [tolerant_columns.to_s.as_sym]
+          end
+        else
+          raise ArgumentError, "set tolerant_columns to String, Symbol, or an Array of either"
+        end
       unless heads.empty?
         heads.each do |h|
-          @columns << Column.new(header: h)
+          if h.to_s.end_with?('!') || @tolerant_columns.include?(h)
+            @columns << Column.new(header: h.to_s.sub(/!\s*\z/, ''), type: 'String')
+          else
+            @columns << Column.new(header: h)
+          end
         end
       end
     end
@@ -86,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!
@@ -99,9 +133,9 @@ module FatTable
 
     # Construct a Table from the contents of a CSV file named +fname+. Headers
     # will be taken from the first CSV row and converted to symbols.
-    def self.from_csv_file(fname)
+    def self.from_csv_file(fname, tolerant_columns: [])
       File.open(fname, 'r') do |io|
-        from_csv_io(io)
+        from_csv_io(io, tolerant_columns: tolerant_columns)
       end
     end
 
@@ -109,8 +143,8 @@ module FatTable
 
     # Construct a Table from a CSV string +str+, treated in the same manner as
     # the input from a CSV file in ::from_org_file.
-    def self.from_csv_string(str)
-      from_csv_io(StringIO.new(str))
+    def self.from_csv_string(str, tolerant_columns: [])
+      from_csv_io(StringIO.new(str), tolerant_columns: tolerant_columns)
     end
 
     # :category: Constructors
@@ -119,9 +153,9 @@ module FatTable
     # file named +fname+. Headers are taken from the first row if the second row
     # is an hrule. Otherwise, synthetic headers of the form +:col_1+, +:col_2+,
     # etc. are created.
-    def self.from_org_file(fname)
+    def self.from_org_file(fname, tolerant_columns: [])
       File.open(fname, 'r') do |io|
-        from_org_io(io)
+        from_org_io(io, tolerant_columns: tolerant_columns)
       end
     end
 
@@ -129,8 +163,8 @@ module FatTable
 
     # Construct a Table from a string +str+, treated in the same manner as the
     # contents of an org-mode file in ::from_org_file.
-    def self.from_org_string(str)
-      from_org_io(StringIO.new(str))
+    def self.from_org_string(str, tolerant_columns: [])
+      from_org_io(StringIO.new(str), tolerant_columns: tolerant_columns)
     end
 
     # :category: Constructors
@@ -149,8 +183,8 @@ module FatTable
     # :hlines no +) org-mode strips all hrules from the table; otherwise (+
     # HEADER: :hlines yes +) they are indicated with nil elements in the outer
     # array.
-    def self.from_aoa(aoa, hlines: false)
-      from_array_of_arrays(aoa, hlines: hlines)
+    def self.from_aoa(aoa, hlines: false, tolerant_columns: [])
+      from_array_of_arrays(aoa, hlines: hlines, tolerant_columns: tolerant_columns)
     end
 
     # :category: Constructors
@@ -160,9 +194,9 @@ module FatTable
     # keys, which, when converted to symbols will become the headers for the
     # Table. If hlines is set true, mark a group boundary whenever a nil, rather
     # than a hash appears in the outer array.
-    def self.from_aoh(aoh, hlines: false)
+    def self.from_aoh(aoh, hlines: false, tolerant_columns: [])
       if aoh.first.respond_to?(:to_h)
-        from_array_of_hashes(aoh, hlines: hlines)
+        from_array_of_hashes(aoh, hlines: hlines, tolerant_columns: tolerant_columns)
       else
         raise UserError,
               "Cannot initialize Table with an array of #{input[0].class}"
@@ -181,7 +215,7 @@ module FatTable
 
     # Construct a Table by running a SQL +query+ against the database set up
     # with FatTable.connect, with the rows of the query result as rows.
-    def self.from_sql(query)
+    def self.from_sql(query, tolerant_columns: [])
       msg = 'FatTable.db must be set with FatTable.connect'
       raise UserError, msg if FatTable.db.nil?
 
@@ -203,8 +237,8 @@ module FatTable
       # Construct table from an array of hashes or an array of any object that
       # can respond to #to_h. If an array element is a nil, mark it as a group
       # boundary in the Table.
-      def from_array_of_hashes(hashes, hlines: false)
-        result = new
+      def from_array_of_hashes(hashes, hlines: false, tolerant_columns: [])
+        result = new(tolerant_columns: tolerant_columns)
         hashes.each do |hsh|
           if hsh.nil?
             unless hlines
@@ -232,8 +266,8 @@ module FatTable
       # hlines are stripped from the table, otherwise (:hlines yes) they are
       # indicated with nil elements in the outer array as expected by this
       # method when hlines is set true.
-      def from_array_of_arrays(rows, hlines: false)
-        result = new
+      def from_array_of_arrays(rows, hlines: false, tolerant_columns: [])
+        result = new(tolerant_columns: tolerant_columns)
         headers = []
         if !hlines
           # Take the first row as headers
@@ -269,8 +303,8 @@ module FatTable
         result
       end
 
-      def from_csv_io(io)
-        result = new
+      def from_csv_io(io, tolerant_columns: [])
+        result = new(tolerant_columns: tolerant_columns)
         ::CSV.new(io, headers: true, header_converters: :symbol,
                   skip_blanks: true).each do |row|
           result << row.to_h
@@ -283,7 +317,7 @@ module FatTable
       # header row must be marked with an hline (i.e, a row that looks like
       # '|---+--...--|') and groups of rows may be marked with hlines to
       # indicate group boundaries.
-      def from_org_io(io)
+      def from_org_io(io, tolerant_columns: [])
         table_re = /\A\s*\|/
         hrule_re = /\A\s*\|[-+]+/
         rows = []
@@ -318,7 +352,7 @@ module FatTable
             rows << line.split('|').map(&:clean)
           end
         end
-        from_array_of_arrays(rows, hlines: true)
+        from_array_of_arrays(rows, hlines: true, tolerant_columns: tolerant_columns)
       end
     end
 
@@ -412,6 +446,15 @@ module FatTable
 
     # :category: Attributes
 
+    # Return whether the column with the given head should be made tolerant.
+    def tolerant_col?(h)
+      return true if tolerant_columns.include?(:'*')
+
+      tolerant_columns.include?(h)
+    end
+
+    # :category: Attributes
+
     # Return the number of rows in the Table.
     def size
       return 0 if columns.empty?
@@ -571,7 +614,8 @@ module FatTable
         range = group_row_range(k)
         tab_col = column(col)
         gitems = tab_col.items[range]
-        cols << Column.new(header: col, items: gitems, type: tab_col.type)
+        cols << Column.new(header: col, items: gitems,
+                           type: tab_col.type, tolerant: tab_col.tolerant?)
       end
       cols
     end
@@ -735,7 +779,6 @@ module FatTable
       last_key = nil
       new_rows.each_with_index do |nrow, k|
         new_tab << nrow
-        # key = nrow.fetch_values(*sort_heads)
         key = nrow.fetch_values(*key_hash.keys)
         new_tab.mark_boundary(k - 1) if last_key && key != last_key
         last_key = key
@@ -941,7 +984,12 @@ module FatTable
       expr = expr.to_s
       result = empty_dup
       headers.each do |h|
-        col = Column.new(header: h)
+        col =
+        if tolerant_col?(h)
+          Column.new(header: h, tolerant: true)
+        else
+          Column.new(header: h)
+        end
         result.add_column(col)
       end
       ev = Evaluator.new(ivars: { row: 0, group: 0 })
@@ -1406,6 +1454,9 @@ module FatTable
 
     private
 
+    # Collapse a group of rows to a single row by applying the aggregator from
+    # the +agg_cols+ to the items in that column and the presumably identical
+    # value in the +grp_cols to those columns.
     def row_from_group(rows, grp_cols, agg_cols)
       new_row = {}
       grp_cols.each do |h|
@@ -1440,7 +1491,7 @@ module FatTable
         # 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)
+        columns << Column.new(header: h, items: items, tolerant: tolerant_col?(h))
       end
       headers.each do |h|
         # NB: This adds a nil if h is not in row.
@@ -1660,11 +1711,19 @@ module FatTable
     end
 
     # The <=> operator cannot handle nils without some help.  Treat a nil as
-    # smaller than any other value, but equal to other nils.  The two keys are assumed to be arrays of values to be
-    # compared with <=>.
+    # smaller than any other value, but equal to other nils.  The two keys are
+    # assumed to be arrays of values to be compared with <=>.  Since
+    # tolerant_columns permit strings to be mixed in with columns of type
+    # Numeric, DateTime, and Boolean, treat strings mixed with another type
+    # the same as nils.
     def compare_with_nils(key1, key2)
       result = nil
       key1.zip(key2) do |k1, k2|
+        if k1.is_a?(String) && !k2.is_a?(String)
+          k1 = nil
+        elsif !k1.is_a?(String) && k2.is_a?(String)
+          k2 = nil
+        end
         if k1.nil? && k2.nil?
           result = 0
           next

data/lib/fat_table/version.rb

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

data/lib/fat_table.rb

@@ -61,22 +61,22 @@ module FatTable
 
   # Return an empty FatTable::Table object. You can use FatTable::Table#add_row
   # or FatTable::Table#add_column to populate the table with data.
-  def self.new(*args)
-    Table.new(*args)
+  def self.new(*args, tolerant_columns: [])
+    Table.new(*args, tolerant_columns: tolerant_columns)
   end
 
   # Construct a FatTable::Table from the contents of a CSV file given by the
   # file name +fname+. Headers will be taken from the first row and converted to
   # symbols.
-  def self.from_csv_file(fname)
-    Table.from_csv_file(fname)
+  def self.from_csv_file(fname, tolerant_columns: [])
+    Table.from_csv_file(fname, tolerant_columns: tolerant_columns)
   end
 
   # Construct a FatTable::Table from the string +str+, treated in the same
   # manner as if read the input from a CSV file. Headers will be taken from the
   # first row and converted to symbols.
-  def self.from_csv_string(str)
-    Table.from_csv_string(str)
+  def self.from_csv_string(str, tolerant_columns: [])
+    Table.from_csv_string(str, tolerant_columns: tolerant_columns)
   end
 
   # Construct a FatTable::Table from the first table found in the Emacs org-mode
@@ -84,8 +84,8 @@ module FatTable
   # is an hline. Otherwise, synthetic headers of the form +:col_1+, +:col_2+,
   # etc. are created. Any other hlines will be treated as marking a boundary in
   # the table.
-  def self.from_org_file(fname)
-    Table.from_org_file(fname)
+  def self.from_org_file(fname, tolerant_columns: [])
+    Table.from_org_file(fname, tolerant_columns: tolerant_columns)
   end
 
   # Construct a FatTable::Table from the first table found in the string +str+,
@@ -93,8 +93,8 @@ module FatTable
   # are taken from the first row if the second row is an hrule. Otherwise,
   # synthetic headers of the form :col_1, :col_2, etc. are created. Any other
   # hlines will be treated as marking a boundary in the table.
-  def self.from_org_string(str)
-    Table.from_org_string(str)
+  def self.from_org_string(str, tolerant_columns: [])
+    Table.from_org_string(str, tolerant_columns: tolerant_columns)
   end
 
   # Construct a FatTable::Table from the array of arrays +aoa+. By default, with
@@ -108,8 +108,8 @@ module FatTable
   # org-mode code blocks, by default (+:hlines no+) all hlines are stripped from
   # the table, otherwise (+:hlines yes+) they are indicated with nil elements in
   # the outer array.
-  def self.from_aoa(aoa, hlines: false)
-    Table.from_aoa(aoa, hlines: hlines)
+  def self.from_aoa(aoa, hlines: false, tolerant_columns: [])
+    Table.from_aoa(aoa, hlines: hlines, tolerant_columns: tolerant_columns)
   end
 
   # Construct a FatTable::Table from the array of hashes +aoh+, which can be an
@@ -117,8 +117,8 @@ module FatTable
   # interpret nil separators as marking boundaries in the new Table. All hashes
   # must have the same keys, which, converted to symbols, become the headers for
   # the new Table.
-  def self.from_aoh(aoh, hlines: false)
-    Table.from_aoh(aoh, hlines: hlines)
+  def self.from_aoh(aoh, hlines: false, tolerant_columns: [])
+    Table.from_aoh(aoh, hlines: hlines, tolerant_columns: tolerant_columns)
   end
 
   # Construct a FatTable::Table from another FatTable::Table. Inherit any group
@@ -130,8 +130,8 @@ module FatTable
   # Construct a Table by running a SQL query against the database set up with
   # FatTable.connect. Return the Table with the query results as rows and the
   # headers from the query, converted to symbols, as headers.
-  def self.from_sql(query)
-    Table.from_sql(query)
+  def self.from_sql(query, tolerant_columns: [])
+    Table.from_sql(query, tolerant_columns: tolerant_columns)
   end
 
   ########################################################################

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat_table
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.5
 platform: ruby
 authors:
 - Daniel E. Doherty
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-22 00:00:00.000000000 Z
+date: 2022-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler