object_table 0.2.0 → 0.2.2

data/spec/support/object_table_example.rb

@@ -134,6 +134,40 @@ EOS
 EOS
         end
       end
+
+      context 'with > 3 dimensions in the matrix' do
+        let(:table){ ObjectTable.new(col1: 1..100, col2: NArray.int(2, 2, 100).indgen! ) }
+
+        it 'should align the columns' do
+          table = subject.inspect.split("\n")[1..-1].map(&:rstrip).join("\n") + "\n"
+          expect(table).to eql <<EOS
+        col1              col2
+   0:      1      [ [ 0, 1 ],
+                    [ 2, 3 ] ]
+   1:      2      [ [ 4, 5 ],
+                    [ 6, 7 ] ]
+   2:      3      [ [ 8, 9 ],
+                  [ 10, 11 ] ]
+   3:      4    [ [ 12, 13 ],
+                  [ 14, 15 ] ]
+   4:      5    [ [ 16, 17 ],
+                  [ 18, 19 ] ]
+------------------------------
+  95:     96  [ [ 380, 381 ],
+                [ 382, 383 ] ]
+  96:     97  [ [ 384, 385 ],
+                [ 386, 387 ] ]
+  97:     98  [ [ 388, 389 ],
+                [ 390, 391 ] ]
+  98:     99  [ [ 392, 393 ],
+                [ 394, 395 ] ]
+  99:    100  [ [ 396, 397 ],
+                [ 398, 399 ] ]
+        col1              col2
+EOS
+        end
+      end
+
     end
 
     context 'when raising a no method error' do
@@ -145,6 +179,7 @@ EOS
         end
       end
     end
+
   end
 
   describe '#nrows' do
@@ -305,7 +340,7 @@ EOS
     let(:grouped){ subject.group_by &block }
 
     it 'should return groups' do
-      expect(grouped).to be_a ObjectTable::TempGrouped
+      expect(grouped).to be_a ObjectTable::Grouped
       expect(grouped.instance_eval('@grouper')).to eql block
     end
   end

data/spec/support/view_example.rb

@@ -170,4 +170,28 @@ RSpec.shared_examples 'a table view' do |cls|
     end
   end
 
+  describe '#inspect' do
+    context 'with an empty table' do
+      let(:table){ ObjectTable.new }
+      let(:block){ Proc.new{nil} }
+
+      subject{ table.where{ nil } }
+
+      it 'should say it is empty' do
+        text = subject.inspect.split("\n")[1..-1].map(&:rstrip).join("\n")
+        expect(text).to eql "(empty table)"
+      end
+    end
+
+    context 'with table with no rows' do
+      subject{ ObjectTable.new(col1: [], col2: []) }
+      let(:block){ Proc.new{nil} }
+
+      it 'should give the columns' do
+        text = subject.inspect.split("\n")[1..-1].map(&:rstrip).join("\n")
+        expect(text).to eql "(empty table with columns: col1, col2)"
+      end
+    end
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_table
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Cheney Lin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-09 00:00:00.000000000 Z
+date: 2015-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -84,9 +84,10 @@ files:
 - lib/object_table/group.rb
 - lib/object_table/grouped.rb
 - lib/object_table/masked_column.rb
+- lib/object_table/printable.rb
 - lib/object_table/static_view.rb
+- lib/object_table/table_child.rb
 - lib/object_table/table_methods.rb
-- lib/object_table/temp_grouped.rb
 - lib/object_table/version.rb
 - lib/object_table/view.rb
 - lib/object_table/view_methods.rb
@@ -96,7 +97,6 @@ files:
 - spec/object_table/grouped_spec.rb
 - spec/object_table/masked_column_spec.rb
 - spec/object_table/static_view_spec.rb
-- spec/object_table/temp_grouped_spec.rb
 - spec/object_table/view_spec.rb
 - spec/object_table_spec.rb
 - spec/subclassing_spec.rb
@@ -132,7 +132,6 @@ test_files:
 - spec/object_table/grouped_spec.rb
 - spec/object_table/masked_column_spec.rb
 - spec/object_table/static_view_spec.rb
-- spec/object_table/temp_grouped_spec.rb
 - spec/object_table/view_spec.rb
 - spec/object_table_spec.rb
 - spec/subclassing_spec.rb

data/lib/object_table/temp_grouped.rb

@@ -1,43 +0,0 @@
-require 'forwardable'
-require_relative 'grouped'
-
-class ObjectTable::TempGrouped
-  extend Forwardable
-  def_delegators :make_grouped, :each, :apply
-
-  def initialize(parent, *names, &grouper)
-    @parent = parent
-    @grouper = grouper
-    @names = names
-  end
-
-  def _groups
-    names, keys = _keys()
-    groups = (0...@parent.nrows).zip(keys).group_by{|row, key| key}
-    groups.each do |k, v|
-      groups[k] = NArray.to_na(v.map(&:first))
-    end
-    [names, groups]
-  end
-
-  def _keys
-    if @names.empty?
-      keys = @parent.apply(&@grouper)
-      raise 'Group keys must be hashes' unless keys.is_a?(Hash)
-      keys = ObjectTable::BasicGrid.new.replace keys
-    else
-      keys = ObjectTable::BasicGrid[@names.map{|n| [n, @parent.get_column(n)]}]
-    end
-
-    keys._ensure_uniform_columns!(@parent.nrows)
-    names = keys.keys
-    keys = keys.values.map(&:to_a).transpose
-    [names, keys]
-  end
-
-  def make_grouped
-    names, groups = _groups()
-    ObjectTable::Grouped.new(@parent, names, groups)
-  end
-
-end

data/spec/object_table/temp_grouped_spec.rb

@@ -1,143 +0,0 @@
-require 'object_table'
-require 'object_table/temp_grouped'
-
-describe ObjectTable::TempGrouped do
-  let(:table){ ObjectTable.new(col1: [1, 2, 3, 4], col2: [5, 6, 7, 8] ) }
-#     group based on parity (even vs odd)
-  let(:grouped){ ObjectTable::TempGrouped.new(table){ {parity: col1 % 2} } }
-
-  let(:even){ (table.col1 % 2).eq(0).where }
-  let(:odd) { (table.col1 % 2).eq(1).where }
-
-  describe '#initialize' do
-
-    context 'when the block takes an argument' do
-      it 'should not evaluate in the context of the table' do
-        rspec_context = self
-
-        grouped = ObjectTable::TempGrouped.new(table) do |tbl|
-          receiver = eval('self', binding)
-          expect(receiver).to_not be table
-          expect(receiver).to be rspec_context
-          {}
-        end
-        grouped._groups # call _groups to make it call the block
-      end
-
-      it 'should pass the table into the block' do
-        grouped = ObjectTable::TempGrouped.new(table) do |tbl|
-          expect(tbl).to be table
-          {}
-        end
-        grouped._groups # call _groups to make it call the block
-      end
-    end
-
-    context 'when the block takes no arguments' do
-      it 'should call the block in the context of the table' do
-        _ = self
-        grouped = ObjectTable::TempGrouped.new(table) do
-          receiver = eval('self', binding)
-          _.expect(receiver).to _.be _.table
-          {}
-        end
-        grouped._groups # call _groups to make it call the block
-      end
-    end
-
-  end
-
-  context 'with changes to the parent' do
-    subject{ grouped }
-
-    it 'should mirror changes to the parent' do
-      expect(subject._groups[1]).to eql ({[0] => NArray[1, 3], [1] => NArray[0, 2]})
-      table[:col1] = [2, 3, 4, 5]
-      expect(subject._groups[1]).to eql ({[0] => NArray[0, 2], [1] => NArray[1, 3]})
-    end
-  end
-
-  describe '#_groups' do
-    subject{ grouped._groups }
-
-    it 'should return the names' do
-      expect(subject[0]).to eql [:parity]
-    end
-
-    it 'should return the group key => row mapping' do
-      groups = subject[1]
-      expect(groups[[0]]).to eql even
-      expect(groups[[1]]).to eql odd
-    end
-
-    context 'when grouping by columns' do
-      let(:table){ ObjectTable.new(key1: [0]*4 + [1]*4, key2: [0, 0, 1, 1]*2, data: 1..8 ) }
-      let(:grouped){ ObjectTable::TempGrouped.new(table, :key1, :key2) }
-
-      it 'should use the columns as group names' do
-        expect(subject[0]).to eql [:key1, :key2]
-      end
-
-      it 'should use the columns as groups' do
-        groups = subject[1]
-        expect(groups[[0, 0]]).to eql (table.key1.eq(0) & table.key2.eq(0)).where
-        expect(groups[[0, 1]]).to eql (table.key1.eq(0) & table.key2.eq(1)).where
-        expect(groups[[1, 0]]).to eql (table.key1.eq(1) & table.key2.eq(0)).where
-        expect(groups[[1, 1]]).to eql (table.key1.eq(1) & table.key2.eq(1)).where
-      end
-    end
-  end
-
-  describe '#each' do
-    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
-    let(:block){ Proc.new{col1 + 100} }
-
-    let(:names){ subject._groups[0] }
-    let(:groups){ subject._groups[1] }
-
-    subject{ ObjectTable::TempGrouped.new(table){ {parity: col1 % 2} } }
-
-    it 'should create a group' do
-      group = spy('group')
-      expect(ObjectTable::Grouped).to receive(:new).with(table, names, groups){ group }
-      subject.each(&block)
-    end
-
-    it 'should call #each on the view' do
-      group = spy('group')
-      expect(ObjectTable::Grouped).to receive(:new){ group }
-      expect(group).to receive(:each) do |&b|
-        expect(b).to be block
-      end
-
-      subject.each(&block)
-    end
-  end
-
-  describe '#apply' do
-    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
-    let(:block){ Proc.new{col1 + 100} }
-
-    let(:names){ subject._groups[0] }
-    let(:groups){ subject._groups[1] }
-
-    subject{ ObjectTable::TempGrouped.new(table){ {parity: col1 % 2} } }
-
-    it 'should create a group' do
-      group = spy('group')
-      expect(ObjectTable::Grouped).to receive(:new).with(table, names, groups){ group }
-      subject.apply(&block)
-    end
-
-    it 'should call #apply on the view' do
-      group = spy('group')
-      expect(ObjectTable::Grouped).to receive(:new){ group }
-      expect(group).to receive(:apply) do |&b|
-        expect(b).to be block
-      end
-
-      subject.apply(&block)
-    end
-  end
-
-end