fat_table 0.4.0 → 0.5.3

data/lib/fat_table/convert.rb

@@ -0,0 +1,174 @@
+module FatTable
+  module Convert
+    # Convert val to the type of key, a ruby class constant, such as Date,
+    # Numeric, etc. If type is NilClass, the type is open, and a non-blank val
+    # will attempt conversion to one of the allowed types, typing it as a String
+    # if no other type is recognized. If the val is blank, and the type is nil,
+    # the Column type remains open. If the val is nil or a blank and the type is
+    # already determined, the val is set to nil, and should be filtered from any
+    # Column computations. If the val is non-blank and the Column type
+    # 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)
+      case type
+      when 'NilClass'
+        if val != false && val.blank?
+          # Leave the type of the Column open. Unfortunately, false counts as
+          # blank and we don't want it to. It should be classified as a boolean.
+          new_val = nil
+        else
+          # Only non-blank values are allowed to set the type of the Column
+          bool_val = convert_to_boolean(val)
+          new_val =
+            if bool_val.nil?
+              convert_to_date_time(val) ||
+                convert_to_numeric(val) ||
+                convert_to_string(val)
+            else
+              bool_val
+            end
+        end
+        new_val
+      when 'Boolean'
+        if val.is_a?(String) && val.blank? || val.nil?
+          nil
+        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
+          end
+          new_val
+        end
+      when 'DateTime'
+        if val.blank?
+          nil
+        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
+          end
+          new_val
+        end
+      when 'Numeric'
+        if val.blank?
+          nil
+        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
+          end
+          new_val
+        end
+      when 'String'
+        if val.nil?
+          nil
+        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
+          end
+          new_val
+        end
+      else
+        raise LogicError, "Mysteriously, column has unknown type '#{type}'"
+      end
+    end
+
+    # Convert the val to a boolean if it looks like one, otherwise return nil.
+    # Any boolean or a string of t, f, true, false, y, n, yes, or no, regardless
+    # of case is assumed to be a boolean.
+    def self.convert_to_boolean(val)
+      return val if val.is_a?(TrueClass) || val.is_a?(FalseClass)
+      val = val.to_s.clean
+      return nil if val.blank?
+      if val.match?(/\A(false|f|n|no)\z/i)
+        false
+      elsif val.match?(/\A(true|t|y|yes)\z/i)
+        true
+      end
+    end
+
+    ISO_DATE_RE = %r{(?<yr>\d\d\d\d)[-\/]
+                (?<mo>\d\d?)[-\/]
+                (?<dy>\d\d?)\s*
+                (T?\s*\d\d:\d\d(:\d\d)?
+                ([-+](\d\d?)(:\d\d?))?)?}x
+
+    AMR_DATE_RE = %r{(?<dy>\d\d?)[-/](?<mo>\d\d?)[-/](?<yr>\d\d\d\d)\s*
+                     (?<tm>T\d\d:\d\d:\d\d(\+\d\d:\d\d)?)?}x
+
+    # A Date like 'Tue, 01 Nov 2016' or 'Tue 01 Nov 2016' or '01 Nov 2016'.
+    # These are emitted by Postgresql, so it makes from_sql constructor
+    # possible without special formatting of the dates.
+    INV_DATE_RE = %r{((mon|tue|wed|thu|fri|sat|sun)[a-zA-z]*,?)?\s+  # looks like dow
+    (?<dy>\d\d?)\s+  # one or two-digit day
+    (?<mo_name>[jfmasondJFMASOND][A-Za-z]{2,})\s+  # looks like a month name
+    (?<yr>\d\d\d\d) # and a 4-digit year
+    }xi
+
+    # Convert the val to a DateTime if it is either a DateTime, a Date, a Time, or a
+    # String that can be parsed as a DateTime, otherwise return nil. It only
+    # recognizes strings that contain a something like '2016-01-14' or '2/12/1985'
+    # within them, otherwise DateTime.parse would treat many bare numbers as dates,
+    # such as '2841381', which it would recognize as a valid date, but the user
+    # probably does not intend it to be so treated.
+    def self.convert_to_date_time(val)
+      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?
+
+        if str.match(ISO_DATE_RE)
+          date = DateTime.parse(val)
+        elsif str =~ AMR_DATE_RE
+          date = DateTime.new(Regexp.last_match[:yr].to_i,
+                              Regexp.last_match[:mo].to_i,
+                              Regexp.last_match[:dy].to_i)
+        elsif str =~ INV_DATE_RE
+          mo = Date.mo_name_to_num(last_match[:mo_name])
+          date = DateTime.new(Regexp.last_match[:yr].to_i, mo,
+                              Regexp.last_match[:dy].to_i)
+        else
+          return nil
+        end
+        # val = val.to_date if
+        date.seconds_since_midnight.zero? ? date.to_date : date
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Convert the val to a Numeric if is already a Numeric or is a String that
+    # looks like one. Any Float is promoted to a BigDecimal. Otherwise return
+    # nil.
+    def self.convert_to_numeric(val)
+      return BigDecimal(val, Float::DIG) if val.is_a?(Float)
+      return val if val.is_a?(Numeric)
+      # Eliminate any commas, $'s (or other currency symbol), or _'s.
+      cursym = Regexp.quote(FatTable.currency_symbol)
+      clean_re = /[,_#{cursym}]/
+      val = val.to_s.clean.gsub(clean_re, '')
+      return nil if val.blank?
+      case val
+      when /(\A[-+]?\d+\.\d*\z)|(\A[-+]?\d*\.\d+\z)/
+        BigDecimal(val.to_s.clean)
+      when /\A[-+]?[\d]+\z/
+        val.to_i
+      when %r{\A(?<nm>[-+]?\d+)\s*[:/]\s*(?<dn>[-+]?\d+)\z}
+        Rational(Regexp.last_match[:nm], Regexp.last_match[:dn])
+      end
+    end
+
+    def self.convert_to_string(val)
+      val.to_s
+    end
+  end
+end

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

@@ -49,6 +49,13 @@ module FatTable
     # Hash parameter +locals+ are available to the expression.
     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
     end
 
     private

data/lib/fat_table/footer.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module FatTable
+  class Footer
+    attr_reader :table, :label, :label_col, :values, :group
+
+    ###########################################################################
+    # Constructors
+    ###########################################################################
+
+    # :category: Constructors
+
+    # Initialize a labeled footer, optionally specifying a column for the
+    # label and whether the footer is to be a group footer. One or more values
+    # 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
+      if label_col.nil?
+        @label_col = table.headers.first
+      else
+        unless table.headers.include?(label_col.as_sym)
+          raise ArgumentError, "Footer.new label column '#{label_col}' not a header of table."
+        end
+        @label_col = label_col.as_sym
+      end
+      @table = table
+      @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
+      make_accessor_methods
+    end
+
+    # :category: Constructors
+
+    # Add a value to a footer for the footer's table at COL.  The value of the
+    # footer is determined by AGG.  If it is a symbol, such as :sum or :avg,
+    # it must be a valid aggregating function and the value is determined by
+    # applying the aggregate to the columns in the table, or in a group
+    # footer, to the rows in the group.  If AGG is not a symbol, but it can be
+    # converted to a valid type for a FatTable::Table column, then it is so
+    # converted and the value set to it directly without invoking an aggregate
+    # function.
+    def add_value(col, agg)
+      col = col.as_sym
+      if col.nil?
+        raise ArgumentError, 'Footer#add_value col is nil but must name a table column.'
+      else
+        unless table.headers.include?(col.as_sym)
+          raise ArgumentError, "Footer#add_value col '#{col}' not a header of the table."
+        end
+      end
+
+      if group
+        number_of_groups.times do |k|
+          values[col] ||= []
+          values[col] << calc_val(agg, col, k)
+        end
+      else
+        values[col] = [calc_val(agg, col)]
+      end
+    end
+
+    # :category: Accessors
+
+    # Return the value of under the +key+ header, or if this is a group
+    # footer, return an array of the values for all the groups under the +key+
+    # header.
+    def [](key)
+      key = key.as_sym
+      if values.keys.include?(key)
+        if group
+          values[key]
+        else
+          values[key].last
+        end
+      elsif table.headers.include?(label_col.as_sym)
+        nil
+      else
+        raise ArgumentError, "No column header '#{key}' in footer table"
+      end
+    end
+
+    # :category: Accessors
+
+    # Return the total number of groups in the table to which this footer
+    # belongs.  Note that if the table has both group footers and normal
+    # footers, this will return the number of groups even for a normal footer.
+    def number_of_groups
+      table.number_of_groups
+    end
+
+    # :category: Accessors
+
+    # Return a FatTable::Column object for the header h and, if a group, the
+    # kth group.
+    def column(h, k = nil)
+      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]
+      else
+        table.column(h)
+      end
+    end
+
+    # :category: Accessors
+
+    # Return an Array of the values for the header h and, if a group, for the
+    # kth group.
+    def items(h, k = nil)
+      column(h, k).items
+    end
+
+    # :category: Accessors
+
+    # Return a Hash with a key for each column header mapped to the footer
+    # value for that column, nil for unused columns.  Use the key +k+ to
+    # specify which group to access in the case of a group footer.
+    def to_h(k = nil)
+      hsh = {}
+      if group
+        table.headers.each do |h|
+          hsh[h] = values[h] ? values[h][k] : nil
+        end
+      else
+        table.headers.each do |h|
+          hsh[h] =
+            if values[h]
+              values[h].first
+            else
+              nil
+            end
+        end
+      end
+      hsh
+    end
+
+    private
+
+    # 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
+
+      case agg
+      when Symbol
+        column.send(agg)
+      when String
+        begin
+          converted_val = Convert.convert_to_type(agg, column.type)
+        rescue UserError
+          converted_val = false
+        end
+        if converted_val
+          converted_val
+        else
+          agg
+        end
+      when column.type.constantize
+        agg
+      when Proc
+        result =
+          if group
+            unless agg.arity == 3
+              msg = 'a lambda used in a group footer must have three arguments: (f, c, k)'
+              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)'
+              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
+        else
+          raise ArgumentError, "lambda cannot return an object of class #{result.class}"
+        end
+      else
+        agg
+      end
+    end
+
+    # Define an accessor method for each table header that returns the footer
+    # value for that column, and in the case of a group footer, either returns
+    # the array of values or take an optional index k to return the value for
+    # the k-th group.
+    def make_accessor_methods
+      table.headers.each do |attribute|
+        self.class.define_method attribute do |k = nil|
+          if group
+            if k.nil?
+              values[attribute]
+            else
+              values[attribute][k]
+            end
+          else
+            values[attribute].last
+          end
+        end
+      end
+    end
+  end
+end