fat_core 1.2.5 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e598f2e37937104a57320a950be61c8555e86cf
-  data.tar.gz: bbac42039a8ec51f82b302c7c20198757c8556e0
+  metadata.gz: 5c93e591807760bad4ae026e144c216d03fbe3d7
+  data.tar.gz: 0a7bcf980e22635bdb4880e5ba140544ce03530d
 SHA512:
-  metadata.gz: 3089937ca40448ae1b1350b4492aa47e21ee3bff6b0c043326b33a544fba3d17167bbd89c7e953b9a7aab48eee240df6809b55d84b3e7d1224fee2f5ba382684
-  data.tar.gz: 68786a6dfe2114b1ff21e650d23ec3f476b79012d0cae7f9173f99eba65431850b4cb44799984d661cb9215e55cb2a2e8c2fb8db1875cc81e3244c8fbdb9c55a
+  metadata.gz: 91bdb2d5b8cf2dc577967462433c73fa18f6de41c72ed27564e3cf5dacecc60825ecac131aea4f1a6182e24fbecd18b3b0d752a27bee0de258446baa705dd421
+  data.tar.gz: aa85f79b609f356e333adb6816a9764b2bcf1cad2f7bd5e7ba1a00ef83c81310302d450b81d403890c9d5c808b208435d3fa10db97aa778a5938e3d5b0eba817

data/lib/fat_core/column.rb

@@ -6,18 +6,19 @@ module FatCore
   class Column
     attr_reader :header, :type, :items
 
-    TYPES = %w(NilClass TrueClass FalseClass Date DateTime Numeric String)
+    TYPES = %w(NilClass Boolean DateTime Numeric String)
 
-    def initialize(header:, type: 'NilClass', items: [])
+    def initialize(header:, items: [])
       @header = header.as_sym
-      @type = type
+      @type = 'NilClass'
       raise "Unknown column type '#{type}" unless TYPES.include?(@type.to_s)
-      @items = items
+      @items = []
+      items.each { |i| self << i }
     end
 
-    def <<(itm)
-      items << convert_to_type(itm)
-    end
+    ##########################################################################
+    # Attributes
+    ##########################################################################
 
     def [](k)
       items[k]
@@ -31,16 +32,17 @@ module FatCore
       items.size
     end
 
+    def empty?
+      items.empty?
+    end
+
     def last_i
       size - 1
     end
 
-    # Return a new Column appending the items of other to our items, checking
-    # for type compatibility.
-    def +(other)
-      raise 'Cannot combine columns with different types' unless type == other.type
-      Column.new(header: header, type: type, items: items + other.items)
-    end
+    ##########################################################################
+    # Aggregates
+    ##########################################################################
 
     def first
       items.compact.first
@@ -56,21 +58,78 @@ module FatCore
     end
 
     def sum
+      only_with('sum', 'Numeric', 'String')
       items.compact.sum
     end
 
     def min
+      only_with('min', 'NilClass', 'Numeric', 'String', 'DateTime')
       items.compact.min
     end
 
     def max
+      only_with('max', 'NilClass', 'Numeric', 'String', 'DateTime')
       items.compact.max
     end
 
     def avg
-      sum / items.compact.size.to_d
+      only_with('avg', 'DateTime', 'Numeric')
+      if type == 'DateTime'
+        avg_jd = items.compact.map(&:jd).sum / items.compact.size.to_d
+        DateTime.jd(avg_jd)
+      else
+        sum / items.compact.size.to_d
+      end
     end
 
+    def any?
+      only_with('any?', 'Boolean')
+      items.compact.any?
+    end
+
+    def all?
+      only_with('all?', 'Boolean')
+      items.compact.all?
+    end
+
+    def none?
+      only_with('any?', 'Boolean')
+      items.compact.none?
+    end
+
+    def one?
+      only_with('any?', 'Boolean')
+      items.compact.one?
+    end
+
+    private
+
+    def only_with(agg, *types)
+      unless types.include?(type)
+        raise "Aggregate '#{agg}' cannot be applied to a #{type} column"
+      end
+    end
+
+    public
+
+    ##########################################################################
+    # Construction
+    ##########################################################################
+
+    # Append item to end of the column
+    def <<(itm)
+      items << convert_to_type(itm)
+    end
+
+    # Return a new Column appending the items of other to our items, checking
+    # for type compatibility.
+    def +(other)
+      raise 'Cannot combine columns with different types' unless type == other.type
+      Column.new(header: header, items: items + other.items)
+    end
+
+    private
+
     # 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
@@ -87,12 +146,11 @@ module FatCore
         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.
-          val = nil
+          new_val = nil
         else
           # Only non-blank values are allowed to set the type of the column
-          val_class = val.class
           bool_val = convert_to_boolean(val)
-          val =
+          new_val =
             if bool_val.nil?
               convert_to_date_time(val) ||
                 convert_to_numeric(val) ||
@@ -101,45 +159,61 @@ module FatCore
               bool_val
             end
           @type =
-            if val == true || val == false
+            if new_val == true || new_val == false
               'Boolean'
-            elsif val.is_a?(Numeric)
+            elsif new_val.is_a?(Date) || new_val.is_a?(DateTime)
+              'DateTime'
+            elsif new_val.is_a?(Numeric)
               'Numeric'
+            elsif new_val.is_a?(String)
+              'String'
             else
-              val.class.name
+              raise "Cannot add #{val} of type #{new_val.class.name} to a column"
             end
         end
-        val
-      when 'Boolean', 'TrueClass', 'FalseClass'
-        val_class = val.class
-        val = convert_to_boolean(val)
+        new_val
+      when 'Boolean'
         if val.nil?
-          raise "Inconsistent value in a Boolean column #{header} has class #{val_class}"
+          nil
+        else
+          new_val = convert_to_boolean(val)
+          if new_val.nil?
+            raise "Attempt to add '#{val}' to a column already typed as #{type}"
+          end
+          new_val
         end
-        val
-      when 'DateTime', 'Date'
-        val_class = val.class
-        val = convert_to_date_time(val)
-        unless val
-          raise "Inconsistent value in a DateTime column #{key} has class #{val_class}"
+      when 'DateTime'
+        if val.nil?
+          nil
+        else
+          new_val = convert_to_date_time(val)
+          if new_val.nil?
+            raise "Attempt to add '#{val}' to a column already typed as #{type}"
+          end
+          new_val
         end
-        val
       when 'Numeric'
-        val_class = val.class
-        val = convert_to_numeric(val)
-        unless val
-          raise "Inconsistent value in a Numeric column #{key} has class #{val_class}"
+        if val.nil?
+          nil
+        else
+          new_val = convert_to_numeric(val)
+          if new_val.nil?
+            raise "Attempt to add '#{val}' to a column already typed as #{type}"
+          end
+          new_val
         end
-        val
       when 'String'
-        val_class = val.class
-        val = convert_to_string(val)
-        unless val
-          raise "Inconsistent value in a String column #{key} has class #{val_class}"
+        if val.nil?
+          nil
+        else
+          new_val = convert_to_string(val)
+          if new_val.nil?
+            raise "Attempt to add '#{val}' to a column already typed as #{type}"
+          end
+          new_val
         end
-        val
       else
-        raise "Unknown object of class #{type} in Table"
+        raise "Mysteriously, column has unknown type '#{type}'"
       end
     end
 

data/lib/fat_core/table.rb

@@ -174,7 +174,6 @@ module FatCore
           raise "Header #{h} does not exist" unless headers.include?(h)
           new_heads << h
           new_cols[h] = Column.new(header: h,
-                                   type: column(h).type,
                                    items: column(h).items)
         when Hash
           exp.each_pair do |key, xp|
@@ -184,7 +183,6 @@ module FatCore
               raise "Header #{key} does not exist" unless column?(key)
               new_heads << h
               new_cols[h] = Column.new(header: h,
-                                       type: column(key).type,
                                        items: column(key).items)
             when String
               # Evaluate xp in the context of a binding including a local
@@ -314,8 +312,7 @@ module FatCore
         items = rows.map { |r| r[h] }
         new_h = "#{agg_func}_#{h}"
         new_row[new_h] = Column.new(header: h,
-                                items: items,
-                                type: column(h).type).send(agg_func)
+                                    items: items).send(agg_func)
       end
       new_row
     end

data/lib/fat_core/version.rb

@@ -1,7 +1,7 @@
 module FatCore
   MAJOR = 1
   MINOR = 2
-  PATCH = 5
+  PATCH = 6
 
   VERSION = [MAJOR, MINOR, PATCH].compact.join('.')
 end

data/spec/lib/column_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+module FatCore
+  describe Column do
+    describe 'construction' do
+      it 'should be able to append items to the column' do
+        c = Column.new(header: 'junk')
+        expect(c.type).to eq('NilClass')
+        c << '2.71828'
+        expect(c.items).to eq([2.71828])
+        expect(c.type).to eq('Numeric')
+      end
+
+      it 'should leave the type of an all-nil column open' do
+        c = Column.new(header: :bool, items: [nil, nil, nil, nil])
+        expect(c.type).to eq('NilClass')
+        expect(c[0]).to eq(nil)
+        expect(c[1]).to eq(nil)
+        expect(c[2]).to eq(nil)
+        expect(c[3]).to eq(nil)
+        # But then, assign a type when a recognizable type comes along.
+        c << '625.18'
+        expect(c.type).to eq('Numeric')
+        expect { c << '2018-05-06' }.to raise_error /already typed as Numeric/
+      end
+
+      it 'should recognize boolean columns' do
+        c = Column.new(header: :bool, items: [nil, 'F', 'F', 'T'])
+        expect(c.type).to eq('Boolean')
+        c = Column.new(header: :bool,
+                       items: [nil, 'N', 'no', 'yes', 'false', 'TRUE', nil])
+        expect(c.type).to eq('Boolean')
+        expect(c[0]).to eq(nil)
+        expect(c[1]).to eq(false)
+        expect(c[2]).to eq(false)
+        expect(c[3]).to eq(true)
+        expect(c[4]).to eq(false)
+        expect(c[5]).to eq(true)
+        expect(c[6]).to eq(nil)
+      end
+
+      it 'should recognize DateTime columns but allow Date and nil' do
+        c = Column.new(header: :when,
+                       items: [nil, '2015-01-21', '[2015-01-12]',
+                               '<2011-01-06>', nil, '<2017-01-25 Wed 10:00>'])
+        expect(c.type).to eq('DateTime')
+        expect(c[0]).to eq(nil)
+        expect(c[1]).to eq(Date.parse('2015-01-21'))
+        expect(c[2]).to eq(Date.parse('2015-01-12'))
+        expect(c[3]).to eq(Date.parse('2011-01-06'))
+        expect(c[4]).to eq(nil)
+        expect(c[5]).to eq(DateTime.parse('2017-01-25 Wed 10:00'))
+        expect(c[1].class).to eq(Date)
+        expect(c[5].class).to eq(DateTime)
+      end
+
+      it 'should recognize Numeric columns but allow nils and Integers' do
+        c = Column.new(header: :when,
+                       items: [nil, '20151', '3.14159',
+                               BigDecimal('2.718281828'), nil,
+                               '45024098204982340982049802348'])
+        expect(c.type).to eq('Numeric')
+        expect(c[0]).to eq(nil)
+        expect(c[1]).to eq(20151)
+        expect(c[2]).to eq(3.14159)
+        expect(c[3]).to eq(2.718281828)
+        expect(c[4]).to eq(nil)
+        expect(c[5]).to eq(45024098204982340982049802348)
+        expect(c[0].class).to eq(NilClass)
+        expect(c[1].class).to eq(Fixnum)
+        expect(c[2].class).to eq(BigDecimal)
+        expect(c[3].class).to eq(BigDecimal)
+        expect(c[4].class).to eq(NilClass)
+        expect(c[5].class).to eq(Bignum)
+      end
+
+      it 'should recognize String columns but allow nils and Integers' do
+        c = Column.new(header: :when,
+                       items: [nil, 'Four', 'score', 'and', nil, '7 years'])
+        expect(c.type).to eq('String')
+        expect(c[0]).to eq(nil)
+        expect(c[1]).to eq('Four')
+        expect(c[2]).to eq('score')
+        expect(c[3]).to eq('and')
+        expect(c[4]).to eq(nil)
+        expect(c[5]).to eq('7 years')
+        expect(c[0].class).to eq(NilClass)
+        expect(c[1].class).to eq(String)
+        expect(c[2].class).to eq(String)
+        expect(c[3].class).to eq(String)
+        expect(c[4].class).to eq(NilClass)
+        expect(c[5].class).to eq(String)
+      end
+    end
+
+    describe 'attribute getting and setting' do
+      it 'should be able to retrieve items by index number' do
+        c = Column.new(header: :when,
+                       items: [nil, '20151', '3.14159',
+                               BigDecimal('2.718281828'), nil,
+                               '45024098204982340982049802348'])
+        expect(c[0]).to eq(nil)
+        expect(c[1]).to eq(20151)
+        expect(c[2]).to eq(3.14159)
+        expect(c[3]).to eq(2.718281828)
+        expect(c[4]).to eq(nil)
+        expect(c[5]).to eq(45024098204982340982049802348)
+      end
+
+      it 'should respond to to_a, size, empty?, and last_i' do
+        arr = [nil, '20151', '3.14159',
+               BigDecimal('2.718281828'), nil,
+               '45024098204982340982049802348']
+        c = Column.new(header: :when, items: arr)
+        expect(c.to_a).to eq([nil, 20151, 3.14159, 2.718281828,
+                              nil, 45024098204982340982049802348])
+        expect(c.to_a.class).to eq(Array)
+        expect(c.size).to eq(6)
+        expect(c.empty?).to eq(false)
+        expect(c.last_i).to eq(5)
+      end
+    end
+
+    describe 'aggregates' do
+      before :each do
+        @nil_col =
+          Column.new(header: :none, items: [nil, nil, nil, nil])
+        @bool_col =
+          Column.new(header: :bool,
+                     items: [nil, 'N', 'no', 'yes', 'false', 'TRUE', nil])
+        @date_col =
+          Column.new(header: :when,
+                     items: [nil, '2015-01-21', '[2015-01-12]',
+                             '<2011-01-06>', nil, '<2017-01-25 Wed 10:00>'])
+        @num_col =
+          Column.new(header: :nums,
+                     items: [nil, '20151', '3.14159',
+                             BigDecimal('2.718281828'), nil, '45024'])
+        @str_col =
+          Column.new(header: :strs,
+                     items: [nil, 'Four', 'score', 'and', nil, '7 years'])
+      end
+
+      it 'should be able apply to first to appropriate columns' do
+        expect(@nil_col.first).to eq(nil)
+        expect(@bool_col.first).to eq(false)
+        expect(@date_col.first).to eq(Date.parse('2015-01-21'))
+        expect(@num_col.first).to eq(20151)
+        expect(@str_col.first).to eq('Four')
+      end
+
+      it 'should be able to apply last to appropriate columns' do
+        expect(@nil_col.last).to eq(nil)
+        expect(@bool_col.last).to eq(true)
+        expect(@date_col.last).to eq(DateTime.parse('2017-01-25 10am'))
+        expect(@num_col.last).to eq(45024)
+        expect(@str_col.last).to eq('7 years')
+      end
+
+      it 'should be able to apply rng_s to appropriate columns' do
+        expect(@nil_col.rng_s).to eq('..')
+        expect(@bool_col.rng_s).to eq('false..true')
+        expect(@date_col.rng_s).to eq('2015-01-21..2017-01-25T10:00:00+00:00')
+        expect(@num_col.rng_s).to eq('20151..45024')
+        expect(@str_col.rng_s).to eq('Four..7 years')
+      end
+
+      it 'should be able to sum to appropriate columns' do
+        expect { @nil_col.sum }.to raise_error(/cannot be applied/)
+        expect { @bool_col.sum }.to raise_error(/cannot be applied/)
+        expect { @date_col.sum }.to raise_error(/cannot be applied/)
+        expect(@num_col.sum).to eq(65180.859871828)
+        expect(@str_col.sum).to eq('Fourscoreand7 years')
+      end
+
+      it 'should be able to min to appropriate columns' do
+        expect(@nil_col.min).to eq(nil)
+        expect { @bool_col.min }.to raise_error(/cannot be applied/)
+        expect(@date_col.min).to eq(Date.parse('2011-01-06'))
+        expect(@num_col.min).to eq(BigDecimal('2.718281828'))
+        expect(@str_col.min).to eq('7 years')
+      end
+
+      it 'should be able to max to appropriate columns' do
+        expect(@nil_col.max).to eq(nil)
+        expect { @bool_col.max }.to raise_error(/cannot be applied/)
+        expect(@date_col.max).to eq(DateTime.parse('2017-01-25 10am'))
+        expect(@num_col.max).to eq(45024)
+        expect(@str_col.max).to eq('score')
+      end
+
+      it 'should be able to apply avg to appropriate columns' do
+        expect { @nil_col.avg }.to raise_error(/cannot be applied/)
+        expect { @bool_col.avg }.to raise_error(/cannot be applied/)
+        expect(@date_col.avg).to eq(DateTime.parse('2014-07-17 12pm'))
+        expect(@num_col.avg).to eq(16295.214967957)
+        expect{ @str_col.avg }.to raise_error(/cannot be applied/)
+      end
+
+      it 'should be able to apply boolean aggregates to boolean columns' do
+        expect(@bool_col.any?).to eq(true)
+        expect(@bool_col.all?).to eq(false)
+        expect(@bool_col.none?).to eq(false)
+        expect(@bool_col.one?).to eq(false)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fat_core
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.2.6
 platform: ruby
 authors:
 - Daniel E. Doherty
@@ -222,6 +222,7 @@ files:
 - spec/example_files/goldberg.org
 - spec/example_files/wpcs.csv
 - spec/lib/array_spec.rb
+- spec/lib/column_spec.rb
 - spec/lib/date_spec.rb
 - spec/lib/enumerable_spec.rb
 - spec/lib/evaluator_spec.rb
@@ -264,6 +265,7 @@ test_files:
 - spec/example_files/goldberg.org
 - spec/example_files/wpcs.csv
 - spec/lib/array_spec.rb
+- spec/lib/column_spec.rb
 - spec/lib/date_spec.rb
 - spec/lib/enumerable_spec.rb
 - spec/lib/evaluator_spec.rb