fat_table 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f35f99181e39d7569ce7df958ae92742617826e54b8ed2c6352b73c5723a3d44
-  data.tar.gz: d37acb3f0be27191bafa17ae30b51dfd2db2c4a5d97e6c80fa5399f2618ea98b
+  metadata.gz: fa339300269582eedb57d26138bd3fa2de68d526ed4cc94e4c3a369a67989ddb
+  data.tar.gz: b35cc4785b208b670d6f039de8ef12351ea0533c37d8802fbf89f57763e63330
 SHA512:
-  metadata.gz: eafd2077939c57673358a680490ccbe48218e8b290540790f3526b5945337e53c9366369c255adcc85e01916ad012cbad12132593def15350fd3993304bc5a30
-  data.tar.gz: e7a542986752ac4f632e7344c49080786e0e52ecbe224a0644a6da7b4ec65dd8ca2b9abe842ee295ad7cf19a7a0ccd0e93b22632716c95533665a21d14b5cc83
+  metadata.gz: 49fbab273c609035f9c2a179b0b97cdca067a8a30db754916e7b17d03a435b4d3a4eefb89ddb326ef07c6e5b91632f764ce101de0acbc79fcf6bd876741da4cf
+  data.tar.gz: 76f87e5b342da743ea3e0c2000273de35d081ad4835c2423d6342278ebbced67d3a34bd11526c7f32185ac19e0b225356baa02fbcb8b7b630868739a944f0ecb

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.3
+#+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]]
@@ -619,8 +631,80 @@ 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 is forced to String type instead of throwing an exception, and the
+table can continue to be read.
+
+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 +761,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 +858,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 +950,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

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!
@@ -400,9 +409,18 @@ 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)
+    rescue IncompatibleTypeError => ex
+      if tolerant?
+        force_string!
+        retry
+      else
+        raise ex
+      end
     end
 
     # :category: Constructors

data/lib/fat_table/convert.rb

@@ -37,7 +37,7 @@ module FatTable
           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, msg
           end
           new_val
         end
@@ -48,7 +48,7 @@ module FatTable
           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, msg
           end
           new_val
         end
@@ -59,7 +59,7 @@ module FatTable
           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, msg
           end
           new_val
         end
@@ -70,12 +70,12 @@ module FatTable
           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, msg
           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 +121,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/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/, ''), tolerant: true)
+          else
+            @columns << Column.new(header: h)
+          end
         end
       end
     end
@@ -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
@@ -941,7 +985,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 +1455,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 +1492,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.

data/lib/fat_table/version.rb

@@ -2,5 +2,5 @@
 
 module FatTable
   # The current version of FatTable
-  VERSION = '0.5.2'
+  VERSION = '0.5.3'
 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.3
 platform: ruby
 authors:
 - Daniel E. Doherty
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-22 00:00:00.000000000 Z
+date: 2022-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -332,7 +332,7 @@ licenses: []
 metadata:
   allowed_push_host: https://rubygems.org
   yard.run: yri
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -348,7 +348,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.3
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Provides tools for working with tables as a data type.
 test_files: []