object_table 0.1.0

data/spec/object_table/grouped_spec.rb

@@ -0,0 +1,115 @@
+require 'object_table'
+require 'object_table/grouped'
+
+describe ObjectTable::Grouped do
+  let(:table){ ObjectTable.new(col1: [1, 2, 3, 4], col2: [5, 6, 7, 8] ) }
+#     group based on parity (even vs odd)
+  let(:names){ [:parity] }
+  let(:groups){ {[0] => even, [1] => odd} }
+  let(:grouped){ ObjectTable::Grouped.new(table, names, groups) }
+
+  let(:even){ (table.col1 % 2).eq(0).where }
+  let(:odd) { (table.col1 % 2).eq(1).where }
+
+  describe '._generate_name' do
+    let(:prefix){ 'key_' }
+    subject{ ObjectTable::Grouped._generate_name(prefix, existing_keys) }
+
+    context 'with no matching keys' do
+      let(:existing_keys){ ['a', 'b', 'c'] }
+      it 'should suffix the key with 0' do
+        expect(subject).to eql "key_0"
+      end
+    end
+
+    context 'with matching keys' do
+      let(:existing_keys){ ['key_1', 'key_67', 'key_8', 'abcd'] }
+      it 'should suffix the key with the next available number' do
+        expect(subject).to eql "key_68"
+      end
+    end
+
+  end
+
+  describe '#each' do
+    let(:even_group){ table.where{ (col1 % 2).eq(0) } }
+    let(:odd_group) { table.where{ (col1 % 2).eq(1) } }
+
+    it 'should yield the groups' do
+      groups = []
+      grouped.each do |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|
+        keys << @K
+      end
+
+      expect(keys).to match_array [{parity: 0}, {parity: 1}]
+    end
+
+    it 'should give access to the correct key' do
+      keys = []
+      correct_keys = []
+      grouped.each do |group|
+        keys << [@K[:parity]]
+        correct_keys << (self.col1 % 2).uniq.to_a
+      end
+
+      expect(keys).to match_array(correct_keys)
+    end
+  end
+
+  describe '#apply' do
+    let(:even_group){ table.where{ (col1 % 2).eq(0) } }
+    let(:odd_group) { table.where{ (col1 % 2).eq(1) } }
+
+    subject{ grouped.apply{|group| group.col1.sum} }
+
+    it 'should return a table with the group keys' do
+      expect(subject).to be_a ObjectTable
+      expect(subject.colnames).to include :parity
+    end
+
+    it 'should concatenate the results of the block' do
+      expect(subject.sort_by(subject.parity)).to eql ObjectTable.new(parity: [0, 1], v_0: [6, 4])
+    end
+
+    describe 'value column auto naming' do
+      it 'should auto name the value column' do
+        grouped = ObjectTable::Grouped.new(table, names, {[123] => NArray[0, 1, 2, 3]})
+        result = grouped.apply{|group| group.col1.sum}
+        expect(result.v_0.to_a).to eql [table.col1.sum]
+      end
+
+      it 'should auto name the value column' do
+        grouped = ObjectTable::Grouped.new(table, [:v_0], {[123] => NArray[0, 1, 2, 3]})
+        result = grouped.apply{|group| group.col1.sum}
+        expect(result.v_1.to_a).to eql [table.col1.sum]
+      end
+    end
+
+    context 'with results that are grids' do
+      subject{ grouped.apply{|g| @R[sum: g.col1.sum, mean: g.col2.mean]} }
+
+      it 'should return a table with the group keys' do
+        expect(subject).to be_a ObjectTable
+        expect(subject.colnames).to include :parity
+      end
+
+      it 'should stack the grids' do
+        expect(subject.sort_by(subject.parity)).to eql ObjectTable.new(
+          parity: [0, 1],
+          sum:    [even_group.col1.sum, odd_group.col1.sum],
+          mean:   [even_group.col2.mean, odd_group.col2.mean],
+        )
+      end
+    end
+  end
+
+end

data/spec/object_table/masked_column_spec.rb

@@ -0,0 +1,132 @@
+require 'object_table/masked_column'
+
+describe ObjectTable::MaskedColumn do
+
+  let(:parent)    { ObjectTable::Column.make([0, 1, 2, Complex(2, 3), *(4...10)]) }
+  let(:indices)   { NArray[1, 3, 4, 6] }
+  let(:other_indices) { NArray.to_na((0...parent.length).to_a - indices.to_a) }
+
+  subject{ ObjectTable::MaskedColumn.mask(parent, indices) }
+
+  describe '.mask' do
+    it 'should mask the parent' do
+      expect(subject.to_a).to eql parent[indices].to_a
+    end
+
+    it 'should set the parent' do
+      expect(subject.parent).to eql parent
+    end
+
+    it 'should set the indices' do
+      expect(subject.indices).to eql indices
+    end
+
+    context 'with no indices' do
+      let(:indices)   { NArray.int(0) }
+
+      it 'should still work' do
+        expect{subject}.to_not raise_error
+        expect(subject.rank).to eql 0
+      end
+    end
+  end
+
+
+  shared_examples 'a parent slice modifier' do |slice|
+    let(:value) { 1000 }
+    let!(:original){ parent.clone }
+    let(:slice){ slice }
+
+    it "should modify the parent with a #{slice.class} slice" do
+      subject[slice] = value
+      expect(parent[indices].to_a).to eql subject.to_a
+      expect(parent[other_indices].to_a).to eql original[other_indices].to_a
+    end
+  end
+
+  it_behaves_like 'a parent slice modifier', 0
+  it_behaves_like 'a parent slice modifier', NArray.cast([1, 0, 0, 1], 'byte')
+  it_behaves_like 'a parent slice modifier', 1...4
+  it_behaves_like 'a parent slice modifier', [0, 2]
+  it_behaves_like 'a parent slice modifier', true
+  it_behaves_like 'a parent slice modifier', nil
+
+
+  shared_examples 'a parent modifier' do |method, *args|
+    let!(:original) { parent.clone }
+    it "should affect the parent table on #{method}" do
+      if defined? block
+        subject.send(method, *args, &block)
+      else
+        subject.send(method, *args)
+      end
+
+      expect(parent[indices].to_a).to eql subject.to_a
+      expect(parent[other_indices].to_a).to eql original[other_indices].to_a
+    end
+  end
+
+  it_behaves_like 'a parent modifier', 'indgen!'
+  it_behaves_like 'a parent modifier', 'indgen'
+  it_behaves_like 'a parent modifier', 'fill!', 100
+  it_behaves_like 'a parent modifier', 'random!'
+  it_behaves_like 'a parent modifier', 'conj!'
+  it_behaves_like 'a parent modifier', 'map!' do
+    let(:block) { proc{|x| x + 1} }
+  end
+  it_behaves_like 'a parent modifier', 'collect!' do
+    let(:block) { proc{|x| x + 1} }
+  end
+  it_behaves_like 'a parent modifier', 'imag=', 56
+  it_behaves_like 'a parent modifier', 'add!', 56
+  it_behaves_like 'a parent modifier', 'sbt!', 56
+  it_behaves_like 'a parent modifier', 'mul!', 56
+  it_behaves_like 'a parent modifier', 'div!', 56
+
+  %w{ * + / - xor or and <= >= le ge < > gt lt % ** ne eq & | ^ to_type }.each do |op|
+    context "when performing '#{op}'" do
+      let(:parent)    { ObjectTable::Column.make([0, 1, 2, 3, *(4...10)]) }
+
+      it 'should return a ObjectTable::Column' do
+        expect(subject.send(op, subject)).to be_a ObjectTable::Column
+      end
+
+      it 'should not be a masked' do
+        expect(subject.send(op, subject)).to_not be_a ObjectTable::MaskedColumn
+      end
+    end
+  end
+
+  %w{ not abs -@ ~ }.each do |op|
+    context "when performing '#{op}'" do
+      let(:parent)    { ObjectTable::Column.make([0, 1, 2, 3, *(4...10)]) }
+
+      it 'should return a ObjectTable::Column' do
+        expect(subject.send(op)).to be_a ObjectTable::Column
+      end
+
+      it 'should not be a masked' do
+        expect(subject.send(op)).to_not be_a ObjectTable::MaskedColumn
+      end
+    end
+  end
+
+  context 'with real values' do
+    let(:parent)    { ObjectTable::Column.make(0...10) }
+    it_behaves_like 'a parent modifier', 'mod!', 2
+  end
+
+  describe '#clone' do
+    let(:clone){ subject.clone }
+
+    it 'returns a Column' do
+      expect(clone).to be_an_instance_of ObjectTable::Column
+      expect(clone).to_not be_an_instance_of ObjectTable::MaskedColumn
+    end
+
+    it 'should clone the data' do
+      expect(clone.to_a).to eql subject.to_a
+    end
+  end
+
+end

data/spec/object_table/temp_grouped_spec.rb

@@ -0,0 +1,105 @@
+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 }
+
+  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

data/spec/object_table/temp_view_spec.rb

@@ -0,0 +1,209 @@
+require 'object_table'
+require 'object_table/temp_view'
+
+require 'support/object_table_example'
+
+describe ObjectTable::TempView do
+  it_behaves_like 'an object table', ObjectTable::TempView
+
+  context 'with changes to the parent' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    subject{ ObjectTable::TempView.new(table){ col1 > 2 } }
+
+    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
+
+  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
+
+  describe '#apply' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    let(:block){ Proc.new{col1 + 100} }
+
+    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)
+    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
+      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 } }
+
+    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
+      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(:column){ :col2 }
+    let(:value) { [10, 20, 30] }
+    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 [5] + 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)
+      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
+    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 value' 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
+        end
+      end
+
+       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)
+          end
+
+#           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
+
+    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 }
+
+    subject{ view.pop_column(name) }
+
+    it 'should remove the column' do
+      subject
+      expect(view.colnames).to_not include name
+      expect(view.columns).to_not include name
+    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
+    end
+  end
+
+end

data/spec/object_table/view_spec.rb

@@ -0,0 +1,140 @@
+require 'object_table'
+require 'object_table/view'
+
+require 'support/object_table_example'
+
+describe ObjectTable::View do
+  it_behaves_like 'an object table', 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 '#set_column' do
+    let(:table) { ObjectTable.new(col1: [0, 1, 2, 3], col2: 5) }
+    let(:view)  { ObjectTable::View.new(table, (table.col1 > 0).where) }
+
+    let(:column){ :col1 }
+    let(:value) { [10, 20, 30] }
+
+    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)
+      end
+    end
+
+    context 'with the wrong length' do
+      let(:value) { [1, 2] }
+      it 'should fail' do
+        expect{subject}.to raise_error
+      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
+        end
+      end
+
+      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
+            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
+          subject rescue nil
+          expect(view.columns).to_not include column
+          expect(table.columns).to_not include column
+        end
+      end
+    end
+
+  end
+
+  describe '#pop_column' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+
+    let(:view) { ObjectTable::View.new(table, (table.col1 > 2).where) }
+    let(:name)    { :col2 }
+
+    subject{ view.pop_column(name) }
+
+    it 'should remove the column' do
+      subject
+      expect(view.colnames).to_not include name
+      expect(view.columns).to_not include name
+    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
+    end
+  end
+
+end