object_table 0.3.0 → 0.3.2

data/spec/object_table/basic_grid_spec.rb

@@ -95,6 +95,10 @@ describe ObjectTable::BasicGrid do
         expect(grid[:col1]).to eql columns[:col1]
         expect(grid[:col2]).to eql columns[:col2]
       end
+
+      it 'should return the number of rows' do
+        expect(subject).to eql 3
+      end
     end
 
     context 'with columns of differing length' do
@@ -110,15 +114,23 @@ describe ObjectTable::BasicGrid do
         subject
         expect(grid[:col3]).to eql [6] * 3
       end
+
+      it 'should return the number of rows' do
+        expect(subject).to eql 3
+      end
     end
 
     context 'with scalars only' do
       let(:columns){ {col1: 1, col2: 2} }
-      it 'should assume there is one column' do
+      it 'should assume there is one row' do
         subject
         expect(grid[:col1]).to eql [columns[:col1]]
         expect(grid[:col2]).to eql [columns[:col2]]
       end
+
+      it 'should return the number of rows' do
+        expect(subject).to eql 1
+      end
     end
 
     context 'with ranges' do
@@ -126,6 +138,10 @@ describe ObjectTable::BasicGrid do
       it 'should succeed' do
         expect{subject}.to_not raise_error
       end
+
+      it 'should return the number of rows' do
+        expect(subject).to eql 3
+      end
     end
 
     context 'with multi dimensional narrays' do
@@ -136,6 +152,10 @@ describe ObjectTable::BasicGrid do
           subject
           expect(grid).to eql columns
         end
+
+        it 'should return the number of rows' do
+        expect(subject).to eql 3
+      end
       end
 
       context 'with an incorrect last dimension' do
@@ -155,6 +175,10 @@ describe ObjectTable::BasicGrid do
         it 'should succeed' do
           expect{subject}.to_not raise_error
         end
+
+        it 'should return the number of rows' do
+          expect(subject).to eql 0
+        end
       end
 
 

data/spec/object_table/column_spec.rb

@@ -2,6 +2,24 @@ require 'object_table/column'
 
 describe ObjectTable::Column do
 
+  describe '.length_of' do
+    it 'should return the length of narrays' do
+      expect(described_class.length_of NArray.float(10, 20, 30)).to eql 30
+    end
+
+    it 'should return the length of arrays' do
+      expect(described_class.length_of [ [0] * 20 ] * 30).to eql 30
+    end
+
+    it 'should return the length of empty narrays' do
+      expect(described_class.length_of NArray.float(0)).to eql 0
+    end
+
+    it 'should fail on other inputs' do
+      expect{described_class.length_of 123456}.to raise_error
+    end
+  end
+
   describe '.stack' do
     let(:columns) do
       [
@@ -36,6 +54,22 @@ describe ObjectTable::Column do
         expect(subject).to eq NArray[]
       end
     end
+
+    context 'with empty narrays' do
+      let(:columns) do
+        [
+          NArray.float(10, 10).random!,
+          NArray.float(10, 30).random!,
+          NArray[],
+          NArray.to_na([[100] * 10] * 5),
+        ]
+      end
+
+      it 'should skip empty narrays' do
+        expect(subject).to eq ObjectTable::Column.stack(columns[0], columns[1], columns[3])
+      end
+    end
+
   end
 
 end

data/spec/object_table/grouped_spec.rb

@@ -144,18 +144,26 @@ describe ObjectTable::Grouped do
 
     it 'should give access to the keys' do
       keys = []
+      grouped.each{ keys << Hash[@K.each_pair.to_a] }
+      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
-        keys << @K
+        keys << [@K[:parity]]
+        correct_keys << (self.col1 % 2).to_a.uniq
       end
 
-      expect(keys).to match_array [{parity: 0}, {parity: 1}]
+      expect(keys).to match_array(correct_keys)
     end
 
     it 'should give access to the correct key' do
       keys = []
       correct_keys = []
       grouped.each do
-        keys << [@K[:parity]]
+        keys << [@K.parity]
         correct_keys << (self.col1 % 2).to_a.uniq
       end
 
@@ -226,6 +234,51 @@ describe ObjectTable::Grouped do
       end
     end
 
+    context 'with results that are tables' do
+      subject{ grouped.apply{ ObjectTable.new(sum: col1.sum, mean: 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
+
+    context 'with results that are arrays' do
+      subject{ grouped.apply{ [col1[0], col1[-1]] } }
+
+      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.where{parity.eq 0}.v_0).to eq even_group.col1[[0, -1]]
+        expect(subject.where{parity.eq 1}.v_0).to eq odd_group.col1[[0, -1]]
+      end
+    end
+
+    context 'with results that are narrays' do
+      subject{ grouped.apply{ col1 < 2 } }
+
+      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.where{parity.eq 0}.v_0).to eq (even_group.col1 < 2)
+        expect(subject.where{parity.eq 1}.v_0).to eq (odd_group.col1 < 2)
+      end
+    end
+
     context 'when the block takes an argument' do
       it 'should not evaluate in the context of the group' do
         rspec_context = self

data/spec/object_table/masked_column_spec.rb

@@ -135,19 +135,19 @@ describe ObjectTable::MaskedColumn do
     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
+  it_behaves_like 'destructive methods', 'indgen!'
+  it_behaves_like 'destructive methods', 'indgen'
+  it_behaves_like 'destructive methods', 'fill!', 100
+  it_behaves_like 'destructive methods', 'random!'
+  it_behaves_like 'destructive methods', 'mod!', 2
+  it_behaves_like 'destructive methods', 'add!', 56
+  it_behaves_like 'destructive methods', 'sbt!', 56
+  it_behaves_like 'destructive methods', 'mul!', 56
+  it_behaves_like 'destructive methods', 'div!', 56
+  it_behaves_like 'destructive methods', 'map!' do
     let(:block) { proc{|x| x + 1} }
   end
-  include_examples 'destructive methods', 'collect!' do
+  it_behaves_like 'destructive methods', 'collect!' do
     let(:block) { proc{|x| x + 1} }
   end
 

data/spec/object_table/view_spec.rb

@@ -92,4 +92,32 @@ describe ObjectTable::View do
     end
   end
 
+  describe '#cache_indices' do
+    let(:table) { ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    let(:view)  { ObjectTable::View.new(table){ col1 > 2 } }
+
+    let(:block) { Proc.new{'success!'} }
+
+    subject{ view.cache_indices(&block) }
+
+    it 'should call the block' do
+      expect(block).to receive(:call)
+      subject
+    end
+  end
+
+  describe '#cache_columns' do
+    let(:table) { ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    let(:view)  { ObjectTable::View.new(table){ col1 > 2 } }
+
+    let(:block) { Proc.new{'success!'} }
+
+    subject{ view.cache_columns(&block) }
+
+    it 'should call the block' do
+      expect(block).to receive(:call)
+      subject
+    end
+  end
+
 end

data/spec/object_table_spec.rb

@@ -1,9 +1,11 @@
 require 'object_table'
 
 require 'support/object_table_example'
+require 'support/stacker_example'
 
 describe ObjectTable do
   it_behaves_like 'an object table', ObjectTable
+  it_behaves_like 'a table stacker'
 
   describe '#initialize' do
     let(:columns){ {col1: [1, 2, 3], col2: NArray[4, 5, 6], col3: 7..9, col4: 10} }
@@ -72,46 +74,70 @@ describe ObjectTable do
     let(:args) { [] }
     let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
 
-    let(:column) { table.colnames[0] }
-
     subject{ table.set_column(column, value, *args) }
 
-    it 'should allow assigning columns' do
-      subject
-      expect(table.columns[column].to_a).to eql value
-    end
+    shared_examples 'a column setter' do
+      it 'should allow assigning columns' do
+        subject
+        expect(table.columns[column].to_a).to eql value
+      end
 
-    it 'should coerce the value to a narray' do
-      subject
-      expect(table.columns[column]).to be_a NArray
-    end
+      it 'should coerce the value to a narray' do
+        subject
+        expect(table.columns[column]).to be_a NArray
+      end
 
-    context 'with the wrong length' do
-      let(:value) { [1, 2] }
-      it 'should fail' do
-        expect{subject}.to raise_error
+      context 'with the wrong length' do
+        let(:value) { [1, 2] }
+        it 'should fail' do
+          expect{subject}.to raise_error
+        end
       end
-    end
 
-    context 'with a scalar' do
-      let(:value){ 10 }
-      it 'should fill the column with that value' do
-        subject
-        expect(table.columns[column].to_a).to eql ([value] * table.nrows)
+      context 'with a scalar' do
+        let(:value){ 10 }
+        it 'should fill the column with that value' do
+          subject
+          expect(table.columns[column].to_a).to eql ([value] * table.nrows)
+        end
       end
-    end
 
-    context 'with a range' do
-      let(:value){ 0...3 }
-      it 'should assign the range values' do
-        subject
-        expect(table.columns[column].to_a).to eql value.to_a
+      context 'with a range' do
+        let(:value){ 0...3 }
+        it 'should assign the range values' do
+          subject
+          expect(table.columns[column].to_a).to eql value.to_a
+        end
       end
+
+      context 'with an empty table' do
+        let(:table) { ObjectTable.new }
+        let(:value) { 3 }
+
+        context 'adding an empty column' do
+          it 'should add the column' do
+            subject
+            expect(table.columns[column]).to eq NArray[]
+          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
+
     end
 
     context 'for a new column' do
       let(:column) { :col3 }
 
+      it_behaves_like 'a column setter'
+
       it 'should create a new column' do
         subject
         expect(table.columns).to include column
@@ -136,26 +162,23 @@ describe ObjectTable do
       end
 
       context 'when failed to add column' do
-        let(:value){ NArray[1, 2, 3] }
+        let(:value) { 'a' }
+        let(:args)  { ['int'] }
 
-        it 'should not have that column' do
-          expect(table).to receive(:add_column).with(column, value.typecode) do
-            table.columns[column] = 12345
-          end
+        it 'should fail' do
+          expect{subject}.to raise_error
+        end
 
+        it 'should not have that column' do
 #           the assignment is going to chuck an error
           subject rescue nil
           expect(table.columns).to_not include column
         end
       end
-    end
-
-    context 'with narray args' do
-      let(:args) { ['int', 3, 4] }
-      let(:value){ NArray.float(3, 4, table.nrows) }
 
-      context 'for a new column' do
-        let(:column) { :col3 }
+      context 'with narray args' do
+        let(:args) { ['int', 3, 4] }
+        let(:value){ NArray.float(3, 4, table.nrows) }
 
         it 'should create a column with the typecode' do
           subject
@@ -171,24 +194,29 @@ describe ObjectTable do
 
     end
 
-    context 'with an empty table' do
-      let(:table) { ObjectTable.new }
-      let(:value) { [] }
+    context 'on an existing column' do
+      let(:column) { table.colnames[0] }
+      it_behaves_like 'a column setter'
 
-      context 'adding an empty column' do
-        it 'should add the column' do
-          subject
-          expect(table.columns[column].to_a).to eq value
+      context 'when failed to set column' do
+        let(:value) { 'a' }
+
+        it 'should fail' do
+          expect{subject}.to raise_error
         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
+        it 'should still have the column' do
+#           the assignment is going to chuck an error
+          subject rescue nil
+          expect(table.columns).to include column
         end
 
+        it 'should make no changes' do
+          original = table.clone
+          subject rescue nil
+#           the assignment is going to chuck an error
+          expect(table).to eql original
+        end
       end
     end
 
@@ -212,82 +240,6 @@ describe ObjectTable do
     end
   end
 
-  describe '.stack' do
-    let(:others) do
-      [
-        ObjectTable.new(col1: [1, 2, 3], col2: 5),
-        ObjectTable.new(col1: 10, col2: 50),
-        ObjectTable.new(col2: [10, 30], col1: 15).where{col2.eq 10},
-        ObjectTable::BasicGrid[col2: [1, 2], col1: 3..4],
-      ]
-    end
-
-    subject{ ObjectTable.stack *others }
-
-    it 'should join the tables and grids together' do
-      expect(subject).to be_a ObjectTable
-      expect(subject).to eql ObjectTable.new(
-        col1: others.flat_map{|x| x[:col1].to_a},
-        col2: others.flat_map{|x| x[:col2].to_a},
-        )
-    end
-
-    it 'should duplicate the contents' do
-      others.each do |chunk|
-        expect(subject).to_not be chunk
-      end
-    end
-
-    context 'with non grids/tables' do
-      let(:others){ [ObjectTable.new(col1: 10, col2: 50), 'not a table'] }
-
-      it 'should fail' do
-        expect{subject}.to raise_error
-      end
-    end
-
-    context 'with extra column names' do
-      let(:others){ [ObjectTable.new(col1: 10, col2: 50), ObjectTable.new(col1: 10, col2: 30, col3: 50)] }
-
-      it 'should fail' do
-        expect{subject}.to raise_error
-      end
-    end
-
-    context 'with missing column names' do
-      let(:others){ [ObjectTable.new(col1: 10, col2: 50), ObjectTable.new(col1: 10)] }
-
-      it 'should fail' 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 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 ] }
-
-      it 'should ignore empty grids' do
-        expect(subject).to eql others[0]
-      end
-    end
-
-  end
-
   describe '#sort_by!' do
     let(:table){ ObjectTable.new(col1: [2, 2, 1, 1], col2: [0, 1, 0, 1], col3: [5, 6, 7, 8]) }
     subject{ table.sort_by!(table.col1, table.col2) }
@@ -301,85 +253,4 @@ 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