object_table 0.2.0 → 0.2.2

data/spec/object_table/column_spec.rb

@@ -26,11 +26,39 @@ shared_examples 'a NArray' do |operator, options={}|
     let(:expected_result){ x_na.send(operator, y_na) }
   end
 
-  it "should give the correct result for :#{operator}" do
-    expect(subject.to_a).to eql expected_result.to_a
+  describe "#{operator}" do
+    it "should give the correct result" do
+      expect(subject).to eq expected_result
+    end
+
+    it 'should return a column' do
+      expect(subject).to be_a ObjectTable::Column
+    end
   end
 end
 
+shared_examples 'NArray slicing' do |is_column, *args|
+  let(:x_na)            { NArray.to_na(x.to_a) }
+
+  %w{ [] slice }.each do |method|
+    describe "##{method}" do
+      let(:result)          { x.send(method, *args) }
+      let(:expected_result) { x_na.send(method, *args) }
+
+      it "should give the correct result" do
+        expect(result).to eq expected_result
+      end
+
+      if is_column
+        it 'should return a column' do
+          expect(result).to be_a ObjectTable::Column
+        end
+      end
+    end
+  end
+end
+
+
 shared_examples 'a vectorized operator' do |method|
   it "should vectorize :#{method} over the array" do
     expect(subject.send(method).to_a).to eql subject.to_a.map{|x| x.send(method)}
@@ -64,15 +92,23 @@ describe ObjectTable::Column do
 
   end
 
-  describe '#get_rows' do
-    let(:value)   { NArray.float(50, 50, 50, 50).random! }
-    let(:column)  { ObjectTable::Column.make(value) }
-    let(:index)   { 30 }
+  describe '#to_object' do
+    let(:column){ ObjectTable::Column[1, 2, 3] }
 
-    subject{ column.get_rows(index) }
+    it 'should coerce the column into objects' do
+      expect(column.typecode).to eql NArray.int(0).typecode
+      expect(column.to_object.typecode).to eql NArray.object(0).typecode
+      expect(column.to_object).to eq column
+    end
+  end
 
-    it 'should retrieve the row from the last dimension' do
-      expect(subject).to eql column[nil, nil, nil, index]
+  describe '#to_bool' do
+    let(:column){ ObjectTable::Column.cast([true, false, nil, 'abcd', 1234], 'object') }
+
+    it 'should coerce the column into objects' do
+      expect(column.typecode).to eql NArray.object(0).typecode
+      expect(column.to_bool.typecode).to eql NArray.byte(0).typecode
+      expect(column.to_bool).to eq column.map{|i| i ? 1 : 0}
     end
   end
 
@@ -123,6 +159,100 @@ describe ObjectTable::Column do
     it_behaves_like 'a NArray', '-@', unary: true
     it_behaves_like 'a NArray', 'abs', unary: true
     it_behaves_like 'a NArray', 'not', unary: true
+
+  end
+
+  describe 'slicing' do
+    let(:x){ ObjectTable::Column.float(10, 10, 10).random! }
+
+    it_behaves_like 'NArray slicing', false, 0
+    it_behaves_like 'NArray slicing', true, nil
+    it_behaves_like 'NArray slicing', false, 1, 2, 3
+    it_behaves_like 'NArray slicing', true, nil, nil, 5
+    it_behaves_like 'NArray slicing', true, nil, 5, 5
+    it_behaves_like 'NArray slicing', true, nil, true, false
+    it_behaves_like 'NArray slicing', true, [1, 2, 3, 4], nil, nil
+    it_behaves_like 'NArray slicing', true, [1, 2, 3, 4], nil, [1, 2]
+    it_behaves_like 'NArray slicing', true, 3...6
+    it_behaves_like 'NArray slicing', true, nil, nil, 3...6
+    it_behaves_like 'NArray slicing', true, 6...3, nil, 3...6
+    it_behaves_like 'NArray slicing', true, NArray[1..10] > 5, nil, nil
+  end
+
+  describe "#mask" do
+    let(:x)     { ObjectTable::Column.float(10, 10, 10).random! }
+    let(:mask)  { x < 0.5 }
+
+    let(:expected_result) { NArray.to_na(x.to_a)[mask] }
+
+    subject{ x.mask(mask) }
+
+    it "should give the correct result" do
+      expect(subject).to eq expected_result
+    end
+
+    it 'should return a column' do
+      expect(subject).to be_a ObjectTable::Column
+    end
+  end
+
+  context 'when empty' do
+    let(:col) { ObjectTable::Column.float(0) }
+
+    describe '#[]=' do
+      context 'on an empty array' do
+        subject{ col[] = [] }
+
+        it 'should work' do
+          expect{subject}.to_not raise_error
+        end
+      end
+
+      context 'on an empty narray' do
+        subject{ col[] = NArray[] }
+
+        it 'should work' do
+          expect{subject}.to_not raise_error
+        end
+      end
+
+      context 'on anything else' do
+        subject{ col[] = 3 }
+
+        it 'should not work' do
+          expect{subject}.to raise_error
+        end
+      end
+
+    end
+  end
+
+  describe '#stack' do
+    let(:columns) do
+      [
+        ObjectTable::Column.float(10, 10).random!,
+        NArray.float(10, 30).random!,
+        ObjectTable::Column.to_na([[100] * 10] * 5),
+      ]
+    end
+
+    subject{ columns[0].stack(*columns[1..-1]) }
+
+    it 'should return a column in the correct format' do
+      expect(subject).to be_a ObjectTable::Column
+      expect(subject.typecode).to eql columns[0].typecode
+    end
+
+    it 'should return a column with the correct size' do
+      expect(subject.shape[0...-1]).to eql columns[0].shape[0...-1]
+      expect(subject.shape[-1]).to eql (10 + 30 + 5)
+    end
+
+    it 'should stack the columns' do
+      expect(subject[nil, 0...10]).to eq columns[0]
+      expect(subject[nil, 10...40]).to eq columns[1]
+      expect(subject[nil, 40...45]).to eq columns[2]
+    end
   end
 
 end

data/spec/object_table/grouped_spec.rb

@@ -4,9 +4,7 @@ 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(:grouped){ ObjectTable::Grouped.new(table){ {parity: col1 % 2} } }
 
   let(:even){ (table.col1 % 2).eq(0).where }
   let(:odd) { (table.col1 % 2).eq(1).where }
@@ -31,6 +29,85 @@ describe ObjectTable::Grouped do
 
   end
 
+  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::Grouped.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::Grouped.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::Grouped.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::Grouped.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(:even_group){ table.where{ (col1 % 2).eq(0) } }
     let(:odd_group) { table.where{ (col1 % 2).eq(1) } }
@@ -103,14 +180,16 @@ describe ObjectTable::Grouped do
 
     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]})
+        grouped = ObjectTable::Grouped.new(table){{parity: 1}}
         result = grouped.apply{|group| group.col1.sum}
+        expect(result).to have_column :v_0
         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]})
+        grouped = ObjectTable::Grouped.new(table){{v_0: 1}}
         result = grouped.apply{|group| group.col1.sum}
+        expect(result).to have_column :v_1
         expect(result.v_1.to_a).to eql [table.col1.sum]
       end
     end
@@ -157,4 +236,54 @@ describe ObjectTable::Grouped do
     end
   end
 
+  describe 'enumerators' do
+    shared_examples 'enumerator method' do |method, *args, block, _expected|
+      let(:expected){ _expected }
+
+      describe "##{method}" do
+
+        it 'should work with a block without args' do
+          result = grouped.send(method, *args){ block.call(self) }
+          if result.is_a? Array
+            expect(result).to match_array expected
+          else
+            expect(result).to eql expected
+          end
+        end
+
+        it 'should work with a block with args' do
+          result = grouped.send(method, *args, &block)
+          if result.is_a? Array
+            expect(result).to match_array expected
+          else
+            expect(result).to eql expected
+          end
+        end
+
+      end
+
+    end
+
+    it_behaves_like 'enumerator method', 'all?', lambda{|grp| grp.col1[0] == 1}, false
+    it_behaves_like 'enumerator method', 'any?', lambda{|grp| grp.col1[0] == 1}, true
+
+    it_behaves_like 'enumerator method', 'collect', lambda{|grp| grp.nrows} do
+      let(:expected){ [even.length, odd.length] }
+    end
+    it_behaves_like 'enumerator method', 'map', lambda{|grp| grp.nrows} do
+      let(:expected){ [even.length, odd.length] }
+    end
+
+    it_behaves_like 'enumerator method', 'collect_concat', lambda{|grp| grp.col1.to_a} do
+      let(:expected){ table.col1 }
+    end
+    it_behaves_like 'enumerator method', 'flat_map', lambda{|grp| grp.col1.to_a} do
+      let(:expected){ table.col1 }
+    end
+
+    it_behaves_like 'enumerator method', 'count', lambda{|grp| grp.col1[0] == 1}, 1
+    it_behaves_like 'enumerator method', 'none?', lambda{|grp| grp.col1[0] > 100}, true
+    it_behaves_like 'enumerator method', 'one?', lambda{|grp| grp.col1[0] < 100}, false
+  end
+
 end

data/spec/object_table/masked_column_spec.rb

@@ -2,11 +2,12 @@ require 'object_table/masked_column'
 
 describe ObjectTable::MaskedColumn do
 
-  let(:parent)    { ObjectTable::Column.make([0, 1, 2, Complex(2, 3), *(4...10)]) }
+  let(:parent)    { ObjectTable::Column.float(10).random! }
   let(:indices)   { NArray[1, 3, 4, 6] }
   let(:other_indices) { NArray.to_na((0...parent.length).to_a - indices.to_a) }
+  let(:masked)    { ObjectTable::MaskedColumn.mask(parent, indices) }
 
-  subject{ ObjectTable::MaskedColumn.mask(parent, indices) }
+  subject{ masked }
 
   describe '.mask' do
     it 'should mask the parent' do
@@ -29,91 +30,98 @@ describe ObjectTable::MaskedColumn do
         expect(subject.rank).to eql 0
       end
     end
+
+    context 'with an empty parent' do
+      let(:parent) { NArray.int(0) }
+      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|
+  shared_examples '#[]=' 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
+    context "slicing with a #{slice.class}" do
+
+      it "should modify the parent" 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
+
+      context 'without a parent' do
+        subject{ ObjectTable::MaskedColumn[1, 2, 3, 4] }
+
+        it 'should still work' do
+          expect{subject[slice] = value}.to_not raise_error
+        end
+      end
+
     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
+  include_examples '#[]=', 0
+  include_examples '#[]=', NArray.cast([1, 0, 0, 1], 'byte')
+  include_examples '#[]=', 1...4
+  include_examples '#[]=', [0, 2]
+  include_examples '#[]=', true
+  include_examples '#[]=', nil
 
 
-  shared_examples 'a parent modifier' do |method, *args|
+  shared_examples 'destructive methods' do |method, *args|
     let!(:original) { parent.clone }
-    it "should affect the parent table on #{method}" do
+
+    let(:perform) do
       if defined? block
         subject.send(method, *args, &block)
       else
         subject.send(method, *args)
       end
+    end
 
+    it "#{method} should affect the parent" do
+      perform
       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
+    context 'without a parent' do
+      subject{ ObjectTable::MaskedColumn[1, 2, 3, 4] }
 
-      it 'should not be a masked' do
-        expect(subject.send(op, subject)).to_not be_a ObjectTable::MaskedColumn
+      it "#{method} should still work" do
+        expect{perform}.to_not raise_error
       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
+  include_examples 'destructive methods', 'indgen!'
+  include_examples 'destructive methods', 'indgen'
+  include_examples 'destructive methods', 'fill!', 100
+  include_examples 'destructive methods', 'random!'
+  include_examples 'destructive methods', 'mod!', 2
+  include_examples 'destructive methods', 'add!', 56
+  include_examples 'destructive methods', 'sbt!', 56
+  include_examples 'destructive methods', 'mul!', 56
+  include_examples 'destructive methods', 'div!', 56
+  include_examples 'destructive methods', 'map!' do
+    let(:block) { proc{|x| x + 1} }
+  end
+  include_examples 'destructive methods', 'collect!' do
+    let(:block) { proc{|x| x + 1} }
   end
 
-  context 'with real values' do
-    let(:parent)    { ObjectTable::Column.make(0...10) }
-    it_behaves_like 'a parent modifier', 'mod!', 2
+  context 'with complex numbers' do
+    let(:parent)    { ObjectTable::Column.complex(10).indgen! }
+
+    include_examples 'destructive methods', 'imag=', 56
+    include_examples 'destructive methods', 'conj!'
   end
 
   describe '#clone' do

data/spec/object_table_spec.rb

@@ -49,6 +49,24 @@ describe ObjectTable do
 
   end
 
+  describe '#inspect' do
+    context 'with an empty table' do
+      subject{ ObjectTable.new }
+      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: []) }
+      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
+
   context '#set_column' do
     let(:value){ [4, 5, 6] }
     let(:args) { [] }
@@ -162,6 +180,15 @@ describe ObjectTable do
           subject
           expect(table.columns[column].to_a).to eq value
         end
+
+        context 'and setting an empty array to the column' do
+          it 'should work' do
+            subject
+            expect{table[column] = []}.to_not raise_error
+            expect(table[column]).to be_empty
+          end
+        end
+
       end
     end
 
@@ -235,6 +262,14 @@ describe ObjectTable do
       end
     end
 
+    context 'with tables with empty rows' do
+      let(:others) { [ ObjectTable.new(col1: [1, 2, 3], col2: 5), ObjectTable.new(col1: [], col2: []) ] }
+
+      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 ] }
 
@@ -258,4 +293,85 @@ describe ObjectTable do
     end
   end
 
+  describe '#join' do
+    let(:left) do
+      ObjectTable.new(
+        key1:   [ "a",  "b",  "a",  "b",  "c"],
+        lvalue: [   0,    1,    2,    3,    4],
+        )
+    end
+
+    let(:right) do
+      ObjectTable.new(
+        key1:   [ "d",  "c",  "b"],
+        rvalue: [   0,    1,    2],
+        )
+    end
+
+    context 'inner join' do
+      subject{ left.join(right, key=:key1, type: 'inner') }
+
+      let(:result) do
+        ObjectTable.new(
+          key1:   [ "b",  "b",  "c"],
+          lvalue: [   1,    3,    4],
+          rvalue: [   2,    2,    1],
+          )
+      end
+
+      it 'should return the joined result' do
+        expect(subject).to eql result
+      end
+    end
+
+    context 'left join' do
+      subject{ left.join(right, key=:key1, type: 'left') }
+
+      let(:result) do
+        ObjectTable.new(
+          key1:   [ "b",  "b",  "c",  "a",  "a"],
+          lvalue: [   1,    3,    4,    0,    2],
+          rvalue: [   2,    2,    1,    0,    0],
+          )
+      end
+
+      it 'should return the joined result' do
+        expect(subject).to eql result
+      end
+    end
+
+    context 'right join' do
+      subject{ left.join(right, key=:key1, type: 'right') }
+
+      let(:result) do
+        ObjectTable.new(
+          key1:   [ "b",  "b",  "c",  "d"],
+          lvalue: [   1,    3,    4,    0],
+          rvalue: [   2,    2,    1,    0],
+          )
+      end
+
+      it 'should return the joined result' do
+        expect(subject).to eql result
+      end
+    end
+
+    context 'outer join' do
+      subject{ left.join(right, key=:key1, type: 'outer') }
+
+      let(:result) do
+        ObjectTable.new(
+          key1:   [ "b",  "b",  "c",  "a",  "a",  "d"],
+          lvalue: [   1,    3,    4,    0,    2,    0],
+          rvalue: [   2,    2,    1,    0,    0,    0],
+          )
+      end
+
+      it 'should return the joined result' do
+        expect(subject).to eql result
+      end
+    end
+
+  end
+
 end

data/spec/subclassing_spec.rb

@@ -12,8 +12,6 @@ describe 'Subclassing ObjectTable and friends' do
 
   class MyTable < ObjectTable
     module Mixin
-      Table = MyTable
-
       def a_plus_b
         a + b
       end