object_table 0.1.0 → 0.2.0

data/lib/object_table/view.rb

@@ -1,24 +1,63 @@
+require 'forwardable'
 require_relative 'view_methods'
-require_relative 'basic_grid'
 require_relative 'masked_column'
 
 class ObjectTable::View
+  Table = ObjectTable
   include ObjectTable::ViewMethods
-  attr_reader :indices
 
-  def initialize(parent, indices)
+  extend Forwardable
+  def_delegators :make_view, :apply
+
+  def initialize(parent, &block)
     super()
     @parent = parent
+    @filter = block
+  end
+
+  def_delegators :@parent, :has_column?
+
+  def get_column(name)
+    col = @parent.get_column(name)
+    ObjectTable::MaskedColumn.mask(col, indices) if col
+  end
+  alias_method :[], :get_column
+
+  def make_view
+    self.class::Table::StaticView.new @parent, indices
+  end
+
+  def clone
+    cols = ObjectTable::BasicGrid[@parent.columns.map{|k, v| [k, v[indices]]}]
+    self.class::Table.new(cols)
+  end
+
+  def inspect(*args)
+    cache_columns{ super }
+  rescue NoMethodError => e
+    raise Exception.new(e)
+  end
+
+  def indices
+    @indices or NArray.int(@parent.nrows).indgen![@parent.apply &@filter]
+  end
+
+  def cache_indices(&block)
     @indices = indices
-    columns
+    value = block.call()
+    @indices = nil
+    value
   end
 
   def columns
-    @columns ||= super
+    @columns or super
   end
 
-  def add_column(name, *args)
-    @columns[name] = super
+  def cache_columns(&block)
+    @columns = columns
+    value = block.call()
+    @columns = nil
+    value
   end
 
 end

data/lib/object_table.rb

@@ -2,7 +2,7 @@ require_relative "object_table/version"
 require_relative "object_table/basic_grid"
 require_relative "object_table/table_methods"
 require_relative "object_table/view"
-require_relative "object_table/temp_view"
+require_relative "object_table/static_view"
 require_relative "object_table/column"
 require_relative "object_table/grouped"
 require_relative "object_table/temp_grouped"
@@ -22,7 +22,7 @@ class ObjectTable
     @columns = columns
 
     @columns.each do |k, v|
-      @columns[k] = Column.make(v)
+      @columns[k] = ObjectTable::Column.make(v)
     end
   end
 
@@ -38,12 +38,13 @@ class ObjectTable
       case x
       when ObjectTable::TableMethods
         x = x.columns
-      when BasicGrid
+      when ObjectTable::BasicGrid
         x._ensure_uniform_columns!
       end
 
-      raise "Don't know how to append a #{x.class}" unless x.is_a?(BasicGrid)
-      raise 'Mismatch in column names' unless (colnames | x.keys).length == colnames.length
+      raise "Don't know how to append a #{x.class}" unless x.is_a?(ObjectTable::BasicGrid)
+      next if x.empty?
+      raise 'Mismatch in column names' unless (colnames | x.keys) == (colnames & x.keys)
 
       x.each do |k, v|
         v = v.to_a if v.is_a? NArray
@@ -54,7 +55,7 @@ class ObjectTable
     return self if new_values.empty?
 
     new_values.each do |k, v|
-      @columns[k] = Column.make(@columns[k].to_a + v)
+      @columns[k] = ObjectTable::Column.make(@columns[k].to_a + v)
     end
     self
   end
@@ -64,7 +65,7 @@ class ObjectTable
     base = values.shift
 
     case base
-    when BasicGrid
+    when ObjectTable::BasicGrid
       base = self.new(base.clone)
     when ObjectTable, ObjectTable::View
       base = base.clone

data/spec/object_table/basic_grid_spec.rb

@@ -75,6 +75,26 @@ describe ObjectTable::BasicGrid do
       end
     end
 
+    context 'with empty narrays' do
+
+      context 'with all other columns empty' do
+        let(:columns) { {col1: [], col2: NArray[]} }
+
+        it 'should succeed' do
+          expect{subject}.to_not raise_error
+        end
+      end
+
+
+      context 'with other non-empty columns' do
+        let(:columns) { {col1: [], col2: NArray[]} }
+
+        it 'should fail' do
+          expect{subject}.to_not raise_error
+        end
+      end
+    end
+
   end
 
 end

data/spec/object_table/grouped_spec.rb

@@ -35,18 +35,39 @@ describe ObjectTable::Grouped do
     let(:even_group){ table.where{ (col1 % 2).eq(0) } }
     let(:odd_group) { table.where{ (col1 % 2).eq(1) } }
 
+    context 'when the block takes an argument' do
+      it 'should not evaluate in the context of the group' do
+        rspec_context = self
+
+        grouped.each do |group|
+          receiver = eval('self', binding)
+          expect(receiver).to_not be_a ObjectTable::Group
+          expect(receiver).to be rspec_context
+        end
+      end
+    end
+
+    context 'when the block takes no arguments' do
+      it 'should call the block in the context of the group' do
+        _ = self
+        grouped.each do
+          receiver = eval('self', binding)
+          _.expect(receiver).to _.be_a ObjectTable::Group
+        end
+      end
+    end
+
     it 'should yield the groups' do
-      groups = []
+      groups = [even_group, odd_group]
       grouped.each do |group|
-        groups << group
+        expect(groups).to include group
+        groups -= [group]
       end
-
-      expect(groups).to match_array [even_group, odd_group]
     end
 
     it 'should give access to the keys' do
       keys = []
-      grouped.each do |group|
+      grouped.each do
         keys << @K
       end
 
@@ -56,7 +77,7 @@ describe ObjectTable::Grouped do
     it 'should give access to the correct key' do
       keys = []
       correct_keys = []
-      grouped.each do |group|
+      grouped.each do
         keys << [@K[:parity]]
         correct_keys << (self.col1 % 2).uniq.to_a
       end
@@ -95,7 +116,7 @@ describe ObjectTable::Grouped do
     end
 
     context 'with results that are grids' do
-      subject{ grouped.apply{|g| @R[sum: g.col1.sum, mean: g.col2.mean]} }
+      subject{ grouped.apply{ @R[sum: col1.sum, mean: col2.mean] } }
 
       it 'should return a table with the group keys' do
         expect(subject).to be_a ObjectTable
@@ -110,6 +131,30 @@ describe ObjectTable::Grouped do
         )
       end
     end
+
+    context 'when the block takes an argument' do
+      it 'should not evaluate in the context of the group' do
+        rspec_context = self
+
+        grouped.apply do |group|
+          receiver = eval('self', binding)
+          expect(receiver).to_not be_a ObjectTable::Group
+          expect(receiver).to be rspec_context
+          nil
+        end
+      end
+    end
+
+    context 'when the block takes no arguments' do
+      it 'should call the block in the context of the group' do
+        _ = self
+        grouped.apply do
+          receiver = eval('self', binding)
+          _.expect(receiver).to _.be_a ObjectTable::Group
+          nil
+        end
+      end
+    end
   end
 
 end

data/spec/object_table/static_view_spec.rb

@@ -0,0 +1,10 @@
+require 'object_table'
+require 'object_table/static_view'
+
+require 'support/object_table_example'
+require 'support/view_example'
+
+describe ObjectTable::StaticView do
+  it_behaves_like 'an object table', ObjectTable::StaticView
+  it_behaves_like 'a table view', ObjectTable::StaticView
+end

data/spec/object_table/temp_grouped_spec.rb

@@ -9,6 +9,44 @@ describe ObjectTable::TempGrouped do
   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 }
 

data/spec/object_table/view_spec.rb

@@ -2,138 +2,93 @@ require 'object_table'
 require 'object_table/view'
 
 require 'support/object_table_example'
+require 'support/view_example'
 
 describe ObjectTable::View do
   it_behaves_like 'an object table', ObjectTable::View
+  it_behaves_like 'a table view', ObjectTable::View
 
-  describe '#columns' do
-    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
-
-    subject{ ObjectTable::View.new(table, (table.col1 > 2).where) }
-
-    it 'should mask the columns of the parent table' do
-      mask = table.col1 > 2
-      table.columns.each do |k, v|
-        expect(subject.columns[k].to_a).to eql v[mask].to_a
-      end
-    end
-
-    it 'should make masked columns' do
-      subject.columns.each do |k, v|
-        expect(v).to be_a ObjectTable::MaskedColumn
-      end
-    end
-
-    context 'with a matrix in a column' do
-      let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
-    end
-  end
+  describe '#initialize' do
+    let(:table) { ObjectTable.new(col1: [1, 2, 3], col2: 5) }
 
-  describe '#set_column' do
-    let(:table) { ObjectTable.new(col1: [0, 1, 2, 3], col2: 5) }
-    let(:view)  { ObjectTable::View.new(table, (table.col1 > 0).where) }
+    context 'when the block takes an argument' do
 
-    let(:column){ :col1 }
-    let(:value) { [10, 20, 30] }
+      it 'should not evaluate in the context of the table' do
+        rspec_context = self
 
-    let(:args)  { [] }
-
-    subject{ view.set_column(column, value, *args) }
-
-    context 'on an existing column' do
-      it 'should assign values to the column' do
-        subject
-        expect(view.columns[column].to_a).to eql value
-      end
-
-      it 'should not modify anything outside the view' do
-        subject
-        expect(table.columns[column].to_a).to eql [0] + value
-      end
-
-    end
-
-    context 'with a scalar' do
-      let(:value){ 10 }
-      it 'should fill the column with that value' do
-        subject
-        expect(view.columns[column].to_a).to eql ([value] * view.nrows)
+        view = ObjectTable::View.new(table) do |tbl|
+          receiver = eval('self', binding)
+          expect(receiver).to_not be table
+          expect(receiver).to be rspec_context
+        end
+        view.columns # call columns to make it call the block
       end
-    end
 
-    context 'with the wrong length' do
-      let(:value) { [1, 2] }
-      it 'should fail' do
-        expect{subject}.to raise_error
+      it 'should pass the table into the block' do
+        view = ObjectTable::View.new(table) do |tbl|
+          expect(tbl).to be table
+        end
+        view.columns # call columns to make it call the block
       end
     end
 
-    context 'for a new column' do
-      let(:column){ :col3 }
-
-      it 'should create a new column' do
-        subject
-        expect(view.columns).to include column
-        expect(view.columns[column].to_a).to eql value
-      end
-
-      it 'should affect the parent table' do
-        subject
-        expect(table.columns).to include column
-      end
-
-      it 'should fill values outside the view with a default' do
-        subject
-        default = NArray.new(table.columns[column].typecode, 1)[0]
-        expect(table.columns[column].to_a).to eql [default] + value
-      end
-
-      context 'with an NArray' do
-        let(:value){ NArray.int(3, 4, view.nrows).random! }
-
-        it 'should use the narray parameters' do
-          subject
-          expect(view.columns[column].to_a).to eql value.to_a
+    context 'when the block takes no arguments' do
+      it 'should call the block in the context of the table' do
+        _ = self
+        view = ObjectTable::View.new(table) do
+          receiver = eval('self', binding)
+          _.expect(receiver).to _.be _.table
         end
+        view.columns # call columns to make it call the block
       end
+    end
 
-      context 'when failed to add column' do
-        let(:value){ NArray[1, 2, 3] }
+  end
 
-        it 'should not have that column' do
-          expect(view).to receive(:add_column).with(column, value.typecode) do
-            table.columns[column] = ObjectTable::Column.make([0] * 10)
-            view.columns[column] = ObjectTable::Column.make([0] * 10)
-          end
+  context 'with changes to the parent' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    subject{ ObjectTable::View.new(table){ col1 > 2 } }
 
-#           the assignment is going to chuck an error
-          subject rescue nil
-          expect(view.columns).to_not include column
-          expect(table.columns).to_not include column
-        end
-      end
+    it 'should mirror changes to the parent' do
+      expect(subject).to eql ObjectTable.new(col1: 3, col2: 5)
+      table[:col1] = [5, 6, 7]
+      expect(subject).to eql ObjectTable.new(col1: [5, 6, 7], col2: 5)
     end
-
   end
 
-  describe '#pop_column' do
+  context 'with nested views' do
     let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    let(:view1){ table.where{col1 > 1} }
+    let(:view2){ view1.where{col1 < 3} }
+
+    it 'should add columns correctly' do
+      view2[:col3] = 5
+      expect(view2.col3.to_a).to eql [5]
+      expect(view1.col3.to_a).to eql [5, nil]
+      expect(table.col3.to_a).to eql [nil, 5, nil]
+    end
+  end
 
-    let(:view) { ObjectTable::View.new(table, (table.col1 > 2).where) }
-    let(:name)    { :col2 }
+  describe '#apply' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    let(:block){ Proc.new{col1 + 100} }
 
-    subject{ view.pop_column(name) }
+    subject{ ObjectTable::View.new(table){ col1 > 2 } }
 
-    it 'should remove the column' do
-      subject
-      expect(view.colnames).to_not include name
-      expect(view.columns).to_not include name
+    it 'should create a view' do
+      view = spy('view')
+      expect(ObjectTable::StaticView).to receive(:new).with(table, (table.col1 > 2).where){ view }
+      subject.apply(&block)
     end
 
-    it 'should remove the column from the parent too' do
-      subject
-      expect(table.colnames).to_not include name
-      expect(table.columns).to_not include name
+    it 'should call #apply on the view' do
+      view = spy('view')
+      expect(ObjectTable::StaticView).to receive(:new){ view }
+      expect(view).to receive(:apply) do |&b|
+        expect(b).to be block
+      end
+
+      subject.apply(&block)
     end
   end
 

data/spec/object_table_spec.rb

@@ -153,6 +153,18 @@ describe ObjectTable do
 
     end
 
+    context 'with an empty table' do
+      let(:table) { ObjectTable.new }
+      let(:value) { [] }
+
+      context 'adding an empty column' do
+        it 'should add the column' do
+          subject
+          expect(table.columns[column].to_a).to eq value
+        end
+      end
+    end
+
   end
 
   describe '#pop_column' do
@@ -214,6 +226,23 @@ describe ObjectTable do
         expect{subject}.to raise_error
       end
     end
+
+    context 'with empty tables' do
+      let(:others) { [ ObjectTable.new(col1: [1, 2, 3], col2: 5), ObjectTable.new ] }
+
+      it 'should ignore empty tables' do
+        expect(subject).to eql others[0]
+      end
+    end
+
+    context 'with empty grids' do
+      let(:others) { [ ObjectTable.new(col1: [1, 2, 3], col2: 5), ObjectTable::BasicGrid.new ] }
+
+      it 'should ignore empty grids' do
+        expect(subject).to eql others[0]
+      end
+    end
+
   end
 
   describe '#sort_by!' do