fat_table 0.5.3 → 0.6.0

data/lib/fat_table/column.rb

@@ -191,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
 
@@ -204,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
@@ -293,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
@@ -319,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
@@ -333,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
@@ -345,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
@@ -358,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
@@ -387,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
@@ -413,11 +447,10 @@ module FatTable
     # 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?
-        force_string!
-        retry
+        items << Convert.convert_to_string(itm)
       else
         raise ex
       end
@@ -436,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 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,19 +56,30 @@ 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
       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 IncompatibleTypeError, msg
+            raise IncompatibleTypeError
           end
           new_val
         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

@@ -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)
+      calc_label(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,69 @@ 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(0)]
+      end
+    end
+
+    # Calculate the label for the kth group, using k = 0 for non-group
+    # footers.  If the label is a proc, call it with the group number.
+    def calc_label(k)
+      case @label
+      when Proc
+        case @label.arity
+        when 0
+          @label.call
+        when 1
+          @label.call(k)
+        when 2
+          @label.call(k, self)
         else
-          raise ArgumentError, "lambda cannot return an object of class #{result.class}"
+          raise ArgumentError, "footer label proc may only have 1 argument for group number k"
         end
       else
-        agg
+        @label.to_s
       end
     end