object_table 0.1.0 → 0.2.0

data/spec/subclassing_spec.rb

@@ -0,0 +1,164 @@
+require 'object_table'
+
+#
+# spec: kind of proof of concept on how to extend a table
+#   and any children views, groups etc.
+#
+# the idea is that we can make a mixin and make it available
+#   to the table and also whenever we filter (#where), group (#group)
+#   or #clone
+#
+describe 'Subclassing ObjectTable and friends' do
+
+  class MyTable < ObjectTable
+    module Mixin
+      Table = MyTable
+
+      def a_plus_b
+        a + b
+      end
+    end
+
+    include Mixin
+
+    class StaticView < StaticView; include Mixin; end
+    class View < View; include Mixin; end
+    class Group < Group; include Mixin; end
+  end
+
+  let(:table){ MyTable.new(a: 0...100, b: 100.times.map{rand}) }
+
+  subject{ table }
+
+  it 'should have the mixin method available' do
+    expect(subject.a_plus_b).to eq (subject.a + subject.b)
+  end
+
+  describe '#clone' do
+    it 'should be an instance of the table subclass' do
+      expect(table.clone).to be_a MyTable
+    end
+  end
+
+  describe '#apply' do
+    context 'with a block returning a grid' do
+      subject{ table.apply{ ObjectTable::BasicGrid[col1: [4, 5, 6]] } }
+
+      it 'should coerce to the table subclass' do
+        expect(subject).to be_a MyTable
+      end
+    end
+  end
+
+  describe '#where' do
+    subject{ table.where{a > 50} }
+
+    it 'should create view extending the mixin' do
+      expect(subject).to be_a ObjectTable::View
+      expect(subject).to be_a MyTable::Mixin
+    end
+
+    it 'should have the mixin method available' do
+      expect(subject.a_plus_b).to eq (subject.a + subject.b)
+    end
+
+    describe '#clone' do
+      it 'should be an instance of the subclass' do
+        expect(subject.clone).to be_a MyTable
+      end
+    end
+
+    describe '#apply' do
+      subject{ table.where{a > 50}.apply{self} }
+
+      it 'should create static view extending the mixin' do
+        expect(subject).to be_a ObjectTable::StaticView
+        expect(subject).to be_a MyTable::Mixin
+      end
+
+      describe '#clone' do
+        it 'should be an instance of the table subclass' do
+          expect(subject.clone).to be_a MyTable
+        end
+      end
+
+    end
+  end
+
+  describe '#group_by' do
+    subject{ table.group_by{{gt_50: a > 50}} }
+
+    describe '#each' do
+      let(:groups) do
+        _groups = []
+        subject.each{ _groups << self }
+        _groups
+      end
+
+      it 'should give groups extending the Mixin' do
+        groups.each do |g|
+          expect(g).to be_a ObjectTable::Group
+          expect(g).to be_a MyTable::Mixin
+        end
+      end
+
+      it 'should have the mixin method available to the groups' do
+        groups.each do |g|
+          expect(g.a_plus_b).to eql (g.a + g.b)
+        end
+      end
+
+      describe '#clone' do
+        it 'should be an instance of the table subclass' do
+          groups.each do |g|
+            expect(g.clone).to be_a MyTable
+          end
+        end
+      end
+    end
+
+    describe '#apply' do
+      let(:groups) do
+        _groups = []
+        subject.apply{ _groups << self; nil }
+        _groups
+      end
+
+      it 'should give groups extending the mixin' do
+        groups.each do |g|
+          expect(g).to be_a ObjectTable::Group
+          expect(g).to be_a MyTable::Mixin
+        end
+      end
+
+      it 'should have the mixin method available to the groups' do
+        groups.each do |g|
+          expect(g.a_plus_b).to eql (g.a + g.b)
+        end
+      end
+
+      it 'should aggregate into a subclassed table' do
+        expect(subject.apply{nil}).to be_a MyTable
+      end
+
+      describe '#clone' do
+        it 'should be an instance of the table subclass' do
+          groups.each do |g|
+            expect(g.clone).to be_a MyTable
+          end
+        end
+      end
+
+    end
+
+  end
+
+  describe '#sort_by' do
+    let(:sorted){ table.sort_by(table.b) }
+
+    it 'should return an instance of the table subclass' do
+      expect(sorted).to be_a MyTable
+    end
+  end
+
+end

data/spec/support/object_table_example.rb

@@ -9,13 +9,15 @@ RSpec.shared_examples 'an object table' do |cls|
     if @cls == ObjectTable
       table
 
-    elsif @cls == ObjectTable::TempView
+#       for views, basically add one row to the parent and mask the view
+#       so that it only includes the original rows
+    elsif @cls == ObjectTable::View
       table.stack! ObjectTable::BasicGrid[table.columns.map{|k, v| [k, v.max]}]
       column = table.colnames.first
       table[column][-1] += 1
       table.where{table[column] < table[column][-1]}
 
-    elsif @cls == ObjectTable::View
+    elsif @cls == ObjectTable::StaticView
       table.stack! ObjectTable::BasicGrid[table.columns.map{|k, v| [k, v.max]}]
       column = table.colnames.first
       table[column][-1] += 1
@@ -159,6 +161,14 @@ EOS
         expect(table.nrows).to eql 0
       end
     end
+
+    context 'on a table with empty columns' do
+      let(:table){ ObjectTable.new(a: []) }
+
+      it 'should return 0' do
+        expect(table.nrows).to eql 0
+      end
+    end
   end
 
   describe 'column methods' do
@@ -230,24 +240,52 @@ EOS
   describe '#apply' do
     let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
 
-    it 'should evaluate in the context of the table' do
+    it 'should return the results of the block' do
       expect(subject.apply{ col1 }).to eql subject.col1
-      expect(subject.apply{ col2.sum }).to eql subject.col2.sum
     end
 
     context 'with a block returning a grid' do
-      subject{ table.apply{ ObjectTable::BasicGrid[col1: [4, 5, 6]] } }
+      let(:result)  { subject.apply{ ObjectTable::BasicGrid[col1: [4, 5, 6]] } }
 
       it 'should coerce to a table' do
-        expect(subject).to be_a ObjectTable
+        expect(result).to be_a ObjectTable
       end
     end
 
     it 'should have access to a BasicGrid shortcut' do
-      result = table.apply{ @R[value: col1 + 5] }
+      result = subject.apply{ @R[value: col1 + 5] }
       expect(result).to be_a ObjectTable
-      expect(result.value).to eql (table.col1 + 5)
+      expect(result.value).to eql (subject.col1 + 5)
     end
+
+    context 'when the block takes an argument' do
+      it 'should not evaluate in the context of the table' do
+        rspec_context = self
+
+        subject.apply do |tbl|
+          receiver = eval('self', binding)
+          expect(receiver).to_not be subject
+          expect(receiver).to be rspec_context
+        end
+      end
+
+      it 'should pass the table into the block' do
+        subject.apply do |tbl|
+          expect(tbl).to eq subject
+        end
+      end
+    end
+
+    context 'when the block takes no arguments' do
+      it 'should call the block in the context of the table' do
+        _ = self
+        subject.apply do
+          receiver = eval('self', binding)
+          _.expect(receiver).to _.eq _.subject
+        end
+      end
+    end
+
   end
 
   describe '#where' do
@@ -256,15 +294,15 @@ EOS
     let(:filtered){ subject.where &block }
 
     it 'should return a temp view' do
-      expect(filtered).to be_a ObjectTable::TempView
+      expect(filtered).to be_a ObjectTable::View
       expect(filtered.instance_eval('@filter')).to eql block
     end
   end
 
-  describe '#group' do
+  describe '#group_by' do
     let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
     let(:block){ Proc.new{col1 > 1} }
-    let(:grouped){ subject.group &block }
+    let(:grouped){ subject.group_by &block }
 
     it 'should return groups' do
       expect(grouped).to be_a ObjectTable::TempGrouped

data/spec/{object_table/temp_view_spec.rb → support/view_example.rb}

@@ -1,100 +1,62 @@
 require 'object_table'
-require 'object_table/temp_view'
 
-require 'support/object_table_example'
+RSpec.shared_examples 'a table view' do |cls|
+  before do
+    @cls = cls
+  end
 
-describe ObjectTable::TempView do
-  it_behaves_like 'an object table', ObjectTable::TempView
+  def _make_relevant_view(table, block)
+    if @cls == ObjectTable::View
+      @cls.new(table, &block)
 
-  context 'with changes to the parent' do
-    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
-    subject{ ObjectTable::TempView.new(table){ col1 > 2 } }
+    elsif @cls == ObjectTable::StaticView
+      indices = table.apply(&block).where
+      @cls.new(table, indices)
 
-    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)
+    else
+      nil
     end
   end
 
-  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
+  subject{ _make_relevant_view(table, block) }
 
-  describe '#apply' do
+  describe '#columns' do
     let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
-    let(:block){ Proc.new{col1 + 100} }
+    let(:block){ Proc.new{col1 > 2} }
 
-    subject{ ObjectTable::TempView.new(table){ col1 > 2 } }
-
-    it 'should create a view' do
-      view = spy('view')
-      expect(ObjectTable::View).to receive(:new).with(table, (table.col1 > 2).where){ view }
-      subject.apply(&block)
+    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 call #apply on the view' do
-      view = spy('view')
-      expect(ObjectTable::View).to receive(:new){ view }
-      expect(view).to receive(:apply) do |&b|
-        expect(b).to be block
+    it 'should make masked columns' do
+      subject.columns.each do |k, v|
+        expect(v).to be_a ObjectTable::MaskedColumn
       end
-
-      subject.apply(&block)
     end
-  end
 
-  describe '#group' do
-    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
-    let(:block){ Proc.new{col1 + 100} }
-
-    subject{ ObjectTable::TempView.new(table){ col1 > 2 } }
+    context 'with a matrixy narray in a column' do
+      let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: NArray[[1,2,3], [4, 5, 6], [7, 8, 9]] ) }
 
-    it 'should create a view' do
-      view = spy('view')
-      expect(ObjectTable::View).to receive(:new).with(table, (table.col1 > 2).where){ view }
-      subject.group(&block)
-    end
-
-    it 'should call #group on the view' do
-      view = spy('view')
-      expect(ObjectTable::View).to receive(:new){ view }
-      expect(view).to receive(:group) do |&b|
-        expect(b).to be block
+      it 'should mask the matrixy narray too' do
+        indices = (table.col1 > 2).where
+        expect(subject.columns[:col2]).to eq table.col2[nil, indices]
       end
 
-      subject.group(&block)
     end
   end
 
-  describe '#columns' do
-    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
-
-    subject{ ObjectTable::TempView.new(table){ col1 > 2 } }
-
-    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
-  end
 
   describe '#set_column' do
     let(:table) { ObjectTable.new(col1: [0, 1, 2, 3], col2: 5) }
-    let(:view)  { ObjectTable::TempView.new(table){ col1 > 0 } }
+    let(:block) { Proc.new{col1 > 0} }
+    let(:view)  { _make_relevant_view(table, block) }
 
-    let(:column){ :col2 }
+    let(:column){ :col1 }
     let(:value) { [10, 20, 30] }
+
     let(:args)  { [] }
 
     subject{ view.set_column(column, value, *args) }
@@ -107,7 +69,7 @@ describe ObjectTable::TempView do
 
       it 'should not modify anything outside the view' do
         subject
-        expect(table.columns[column].to_a).to eql [5] + value
+        expect(table.columns[column].to_a).to eql [0] + value
       end
 
     end
@@ -120,17 +82,8 @@ describe ObjectTable::TempView do
       end
     end
 
-    context 'with a range' do
-      let(:value){ 0...3 }
-      it 'should assign the range values' do
-        subject
-        expect(view.columns[column].to_a).to eql value.to_a
-      end
-    end
-
     context 'with the wrong length' do
       let(:value) { [1, 2] }
-
       it 'should fail' do
         expect{subject}.to raise_error
       end
@@ -150,7 +103,7 @@ describe ObjectTable::TempView do
         expect(table.columns).to include column
       end
 
-      it 'should fill values outside the view with a default value' do
+      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
@@ -165,13 +118,13 @@ describe ObjectTable::TempView do
         end
       end
 
-       context 'when failed to add column' do
+      context 'when failed to add column' do
         let(:value){ NArray[1, 2, 3] }
 
         it 'should not have that column' do
           expect(view).to receive(:add_column).with(column, value.typecode) do
-            view.columns[column] = ObjectTable::Column.make([0] * 10)
             table.columns[column] = ObjectTable::Column.make([0] * 10)
+            view.columns[column] = ObjectTable::Column.make([0] * 10)
           end
 
 #           the assignment is going to chuck an error
@@ -180,16 +133,27 @@ describe ObjectTable::TempView do
           expect(table.columns).to_not include column
         end
       end
+    end
 
+    context 'with an empty view' do
+      let(:block) { Proc.new{col1 < 0} }
+
+      context 'adding an empty column' do
+        let(:value) { [] }
+        it 'should add the column' do
+          subject
+          expect(view.columns[column].to_a).to eq value
+        end
+      end
     end
 
   end
 
   describe '#pop_column' do
     let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
-
-    let(:view) { ObjectTable::TempView.new(table){ col1 > 2 } }
-    let(:name)    { :col2 }
+    let(:block){ Proc.new{col1 > 2} }
+    let(:view) { _make_relevant_view(table, block) }
+    let(:name) { :col2 }
 
     subject{ view.pop_column(name) }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_table
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Cheney Lin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-08 00:00:00.000000000 Z
+date: 2015-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -81,11 +81,12 @@ files:
 - lib/object_table.rb
 - lib/object_table/basic_grid.rb
 - lib/object_table/column.rb
+- lib/object_table/group.rb
 - lib/object_table/grouped.rb
 - lib/object_table/masked_column.rb
+- lib/object_table/static_view.rb
 - lib/object_table/table_methods.rb
 - lib/object_table/temp_grouped.rb
-- lib/object_table/temp_view.rb
 - lib/object_table/version.rb
 - lib/object_table/view.rb
 - lib/object_table/view_methods.rb
@@ -94,11 +95,13 @@ files:
 - spec/object_table/column_spec.rb
 - 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/temp_view_spec.rb
 - spec/object_table/view_spec.rb
 - spec/object_table_spec.rb
+- spec/subclassing_spec.rb
 - spec/support/object_table_example.rb
+- spec/support/view_example.rb
 homepage: https://github.com/lincheney/ruby-object-table
 licenses:
 - MIT
@@ -128,8 +131,10 @@ test_files:
 - spec/object_table/column_spec.rb
 - 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/temp_view_spec.rb
 - spec/object_table/view_spec.rb
 - spec/object_table_spec.rb
+- spec/subclassing_spec.rb
 - spec/support/object_table_example.rb
+- spec/support/view_example.rb

data/lib/object_table/temp_view.rb

@@ -1,63 +0,0 @@
-require 'forwardable'
-require_relative 'view_methods'
-require_relative 'masked_column'
-require_relative 'view'
-
-class ObjectTable::TempView
-  include ObjectTable::ViewMethods
-
-  extend Forwardable
-  def_delegators :make_view, :group, :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
-    ObjectTable::View.new @parent, indices
-  end
-
-  def clone
-    cols = ObjectTable::BasicGrid[@parent.columns.map{|k, v| [k, v[indices]]}]
-    ObjectTable.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
-    value = block.call()
-    @indices = nil
-    value
-  end
-
-  def columns
-    @columns or super
-  end
-
-  def cache_columns(&block)
-    @columns = columns
-    value = block.call()
-    @columns = nil
-    value
-  end
-
-end