object_table 0.3.4 → 0.4.0

data/spec/support/joining_example.rb

@@ -0,0 +1,171 @@
+require 'object_table'
+require_relative 'utils'
+
+RSpec.shared_examples 'a join operation' do |all_left, all_right|
+  let(:total_groups)  { 50 }
+  let(:groups)        { 40 }
+  let(:lsize)         { 10 }
+  let(:rsize)         { 5 }
+
+  let(:key1)    { (0...total_groups).map{|i| "key1_#{i}"} }
+  let(:key2)    { (0...total_groups).map{|i| "key2_#{i}"} * 2 }
+
+  let(:__left__) do
+    ObjectTable.new(
+      key1:   key1[0, groups] * lsize,
+      key2:   key2[0, groups/2] * 2 * lsize,
+      lval1:  NArray.object(groups * lsize).map!{rand},
+      lval2:  NArray.object(10, groups * lsize).map!{rand},
+      )
+  end
+
+  let(:__right__) do
+    ObjectTable.new(
+      key1:   key1[-groups, groups] * rsize,
+      key2:   key2[-groups, groups/2] * 2 * rsize,
+      rval1:  NArray.object(groups * rsize).map!{rand},
+      )
+  end
+
+  let(:left)  { make_table(__left__, described_class) }
+  let(:right) { make_table(__right__, described_class) }
+
+  let(:common)      { subject.where{lval1.ne(nil).and(rval1.ne(nil))}.clone }
+  let(:left_only)   { subject.where{rval1.eq nil}.clone }
+  let(:right_only)  { subject.where{lval1.eq nil}.clone }
+
+  let(:lkeys) { ObjectTable::Util.get_rows(left, [:key1, :key2]) }
+  let(:rkeys) { ObjectTable::Util.get_rows(right, [:key1, :key2]) }
+
+  let(:expected_left_only) do
+    mask = lkeys.map{|k| rkeys.include?(k) ? 0 : 1}
+    left.where{NArray.to_na(mask).to_type('byte')}
+  end
+
+  let(:expected_right_only) do
+    mask = rkeys.map{|k| lkeys.include?(k) ? 0 : 1}
+    right.where{NArray.to_na(mask).to_type('byte')}
+  end
+
+  it 'shold have all columns' do
+    expect(subject.colnames).to eql [:key1, :key2, :lval1, :lval2, :rval1]
+  end
+
+  it 'should have the correct keys' do
+    join_keys = ObjectTable::Util.get_rows(subject, [:key1, :key2])
+
+    unless all_left
+      expect(join_keys & (lkeys - rkeys)).to be_empty
+    end
+
+    unless all_right
+      expect(join_keys & (rkeys - lkeys)).to be_empty
+    end
+  end
+
+  it 'should duplicate keys correctly' do
+    keys = lkeys & rkeys
+    counts = common.group_by(:key1, :key2).apply{ nrows }
+    expect(ObjectTable::Util.get_rows(counts, [:key1, :key2])).to match_array(keys)
+    expect(counts.v_0.to_a).to eq ([lsize * rsize] * keys.size)
+  end
+
+  it 'should cross product the values' do
+    common.group_by(:key1, :key2).each do |grp|
+      filter = Proc.new{|t| t.key1.eq(grp.K.key1).and(t.key2.eq(grp.K.key2)) }
+      lgroup = left.where(&filter)
+      rgroup = right.where(&filter)
+
+      lvalues = lgroup.apply{[lval1.to_a, lval2.to_a]}.transpose
+      rvalues = rgroup.apply{[rval1.to_a]}.transpose
+      joined_values = grp.apply{[lval1, lval2, rval1]}.map(&:to_a).transpose
+
+      expected = lvalues.product(rvalues).map{|row| row.flatten(1)}
+      expect(joined_values).to eq expected
+    end
+  end
+
+  describe 'missing left keys' do
+    if all_right
+      it 'should have the right keys' do
+        keys = rkeys - lkeys
+        expect(right_only.key1.to_a).to eq keys.transpose[0]
+        expect(right_only.key2.to_a).to eq keys.transpose[1]
+      end
+
+      it 'should fill the right values with nil' do
+        expect(right_only.lval1.to_a).to eq [nil] * right_only.nrows
+        expect(right_only.lval2.to_a).to eq [[nil] * 10] * right_only.nrows
+      end
+
+      it 'should keep the right columns' do
+        right_only.pop_column(:lval1)
+        right_only.pop_column(:lval2)
+        expect(right_only).to eq expected_right_only
+      end
+
+    else
+      it 'should not have any' do
+        expect(right_only.nrows).to eq 0
+      end
+    end
+  end
+
+  describe 'with missing right keys' do
+    if all_left
+      it 'should have the left keys' do
+        keys = lkeys - rkeys
+        expect(left_only.key1.to_a).to eq keys.transpose[0]
+        expect(left_only.key2.to_a).to eq keys.transpose[1]
+      end
+
+      it 'should fill the right values with nil' do
+        expect(left_only.rval1.to_a).to eq [nil] * left_only.nrows
+      end
+
+      it 'should keep the left columns' do
+        left_only.pop_column(:rval1)
+        expect(left_only).to eq expected_left_only
+      end
+
+    else
+      it 'should not have any' do
+        expect(left_only.nrows).to eq 0
+      end
+    end
+  end
+end
+
+
+RSpec.shared_examples 'a table joiner' do
+  context 'inner join' do
+    let(:join_type) { 'inner' }
+    it_behaves_like 'a join operation', false, false
+  end
+
+  context 'left join' do
+    let(:join_type) { 'left' }
+    it_behaves_like 'a join operation', true, false
+  end
+
+  context 'right join' do
+    let(:join_type) { 'right' }
+    it_behaves_like 'a join operation', false, true
+  end
+
+  context 'outer join' do
+    let(:join_type) { 'outer' }
+    it_behaves_like 'a join operation', true, true
+  end
+
+  context 'with invalid join' do
+    let(:left)      { ObjectTable.new(key1: 1, key2: 2, value: 3) }
+    let(:right)     { ObjectTable.new(key1: 1, key2: 2, value: 4) }
+    let(:join_type) { 'asklj' }
+
+    it 'should fail' do
+      expect{subject}.to raise_error
+    end
+  end
+
+end

data/spec/support/object_table_example.rb

@@ -1,34 +1,11 @@
 require 'object_table'
+require_relative 'utils'
 
-RSpec.shared_examples 'an object table' do |cls|
-  before do
-    @cls = cls
-  end
-
-  def _make_relevant_table(table)
-    if @cls == ObjectTable
-      table
-
-#       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]}
+require 'support/joining_example'
+require 'support/stacking_example'
 
-    elsif @cls == ObjectTable::StaticView
-      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]}.apply{ self }
-
-    else
-      nil
-    end
-  end
-
-  subject{ _make_relevant_table(table) }
+RSpec.shared_examples 'an object table' do
+  subject{ make_table(table, described_class) }
 
   describe '#inspect' do
     let(:table){ ObjectTable.new(col1: 1..10, col2: 5) }
@@ -67,6 +44,36 @@ EOS
       end
     end
 
+    context 'with an odd number of rows' do
+      let(:table){ ObjectTable.new(col1: 1..5, col2: 5) }
+
+      it 'should include all the rows' do
+        table = subject.inspect.lines.to_a[1..-1].join + "\n"
+        expect(table).to eql <<EOS
+       col1  col2
+  0:      1     5
+  1:      2     5
+  2:      3     5
+  3:      4     5
+  4:      5     5
+       col1  col2
+EOS
+      end
+    end
+
+    context 'with one row' do
+      let(:table){ ObjectTable.new(col1: 1, col2: 5) }
+
+      it 'should include all the rows' do
+        table = subject.inspect.lines.to_a[1..-1].join + "\n"
+        expect(table).to eql <<EOS
+       col1  col2
+  0:      1     5
+       col1  col2
+EOS
+      end
+    end
+
     context 'with many rows' do
       let(:table){ ObjectTable.new(col1: 1..100, col2: 5) }
 
@@ -354,7 +361,7 @@ EOS
     let(:grouped){ subject.group_by &block }
 
     it 'should return groups' do
-      expect(grouped).to be_a ObjectTable::Grouped
+      expect(grouped).to be_a ObjectTable::Grouping
       expect(grouped.instance_eval('@grouper')).to eql block
     end
   end
@@ -406,4 +413,92 @@ EOS
     end
   end
 
+  describe '#each_row' do
+    let(:col1)  { [1, 2, 3, 4] }
+    let(:col2)  { [NArray[1, -1], NArray[2, -2], NArray[3, -3], NArray[4, -4]] }
+    let(:col3)  { %w{ a b c d } }
+
+    let(:table) { ObjectTable.new(col1: col1, col2: col2, col3: col3) }
+
+    context 'with a block' do
+      it 'should yield successive rows' do
+        rows = []
+        subject.each_row{|row| rows.push row}
+        expect(rows.map(&:col1)).to eq col1
+        expect(rows.map(&:col2)).to eq col2
+        expect(rows.map(&:col3)).to eq col3
+      end
+    end
+
+    context 'without a block' do
+      it 'should return an enumerator' do
+        enum = subject.each_row
+        expect(enum).to be_a Enumerator
+      end
+
+      it 'should yield successive rows' do
+        rows = subject.each_row.to_a
+        expect(rows.map(&:col1)).to eq col1
+        expect(rows.map(&:col2)).to eq col2
+        expect(rows.map(&:col3)).to eq col3
+      end
+    end
+
+    context 'with specific columns' do
+      it 'should yield those columns' do
+        rows = subject.each_row(:col1, :col3).to_a.transpose
+        expect(rows).to eql [col1, col3]
+      end
+    end
+
+    context 'with an empty table' do
+      let(:table) { ObjectTable.new }
+      it 'should do nothing' do
+        expect(subject.each_row.to_a).to be_empty
+      end
+    end
+
+    context 'with a row factory' do
+      it 'should use the row factory' do
+        tmp_cls = Class.new(Struct)
+        subject.each_row(row_factory: tmp_cls) do |row|
+          expect(row).to be_a tmp_cls
+        end
+      end
+    end
+
+  end
+
+  describe '#stack' do
+    it_behaves_like 'a stacking operation' do
+      subject{ grids[0].stack *grids[1..-1] }
+
+      it 'should make a new table' do
+        expect(subject).to_not be grids[0]
+      end
+
+      it 'should duplicate the contents' do
+        grids.each do |chunk|
+          expect(subject).to_not be chunk
+        end
+      end
+
+      context 'with no arguments' do
+        let(:table){ ObjectTable.new(col1: 1..100, col2: 5) }
+        let(:grids){ [table] }
+
+        it 'should make a copy' do
+          expect(subject).to eql table
+          expect(subject).to_not be table
+        end
+      end
+    end
+  end
+
+  describe '#join' do
+    it_behaves_like 'a table joiner' do
+      subject{ left.join(right, :key1, :key2, type: join_type) }
+    end
+  end
+
 end

data/spec/support/stacking_example.rb

@@ -0,0 +1,111 @@
+require 'object_table'
+require_relative 'utils'
+
+RSpec.shared_examples 'a stacking operation' do
+
+  let(:grids) 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
+
+  before do
+    grids[0] = make_table(grids[0], described_class) unless grids.empty?
+  end
+
+  let(:segment)     { NArray.float(10, 10, 10).indgen }
+
+  let!(:grids_copy) { grids.map(&:clone) }
+
+  it 'should stack the tables and grids together' do
+    expect(subject).to be_a grids[0].__table_cls__
+    expect(subject).to eql grids[0].__table_cls__.new(
+      col1: grids_copy.flat_map{|x| x[:col1].to_a},
+      col2: grids_copy.flat_map{|x| x[:col2].to_a},
+      )
+  end
+
+  context 'with non grids/tables' do
+    let(:grids){ [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(:grids){ [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(:grids){ [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(:grids) { [ ObjectTable.new(col1: [1, 2, 3], col2: 5), ObjectTable.new ] }
+
+    it 'should ignore empty tables' do
+      expect(subject).to eql grids[0]
+    end
+
+    context 'with only empty tables' do
+      let(:grids) { [ObjectTable.new] * 3 }
+
+      it 'should return an empty table' do
+        expect(subject).to eql grids[0].__table_cls__.new
+      end
+    end
+  end
+
+  context 'with tables with empty rows' do
+    let(:grids) { [ ObjectTable.new(col1: [1, 2, 3], col2: 5), ObjectTable.new(col1: [], col2: []) ] }
+
+    it 'should ignore empty tables' do
+      expect(subject).to eql grids_copy[0]
+    end
+  end
+
+  context 'with empty grids' do
+    let(:grids) { [ ObjectTable.new(col1: [1, 2, 3], col2: 5), ObjectTable::BasicGrid.new ] }
+
+    it 'should ignore empty grids' do
+      expect(subject).to eql grids_copy[0]
+    end
+  end
+
+  context 'with only narray segments' do
+    let(:grids) { [ObjectTable.new(col1: segment)] * 3  }
+
+    it 'should work' do
+      expect(subject.col1).to eql NArray.to_na(segment.to_a * 3)
+    end
+  end
+
+  context 'with a mixture of segment types' do
+    let(:grids) { [ObjectTable.new(col1: segment)] * 2 + [ObjectTable::BasicGrid[col1: segment.to_a]] * 3 }
+
+    it 'should work' do
+      expect(subject.col1).to eql NArray.to_na(segment.to_a * 5)
+    end
+  end
+
+  context 'with only array segments' do
+    let(:grids) { [ObjectTable.new(col1: segment.to_a)] * 3  }
+
+    it 'should work' do
+      expect(subject.col1).to eql NArray.to_na(segment.to_a * 3)
+    end
+  end
+
+end

data/spec/support/utils.rb

@@ -0,0 +1,8 @@
+def make_table(table, cls)
+  case [cls]
+  when [ObjectTable] then table
+  when [ObjectTable::View] then table.where{true}
+  when [ObjectTable::StaticView] then table.where{true}.apply{self}
+  else raise "Could not make a a #{cls.inspect} table"
+  end
+end

data/spec/support/view_example.rb

@@ -1,24 +1,21 @@
 require 'object_table'
 
-RSpec.shared_examples 'a table view' do |cls|
-  before do
-    @cls = cls
-  end
+RSpec.shared_examples 'a table view' do
 
-  def _make_relevant_view(table, block)
-    if @cls == ObjectTable::View
-      @cls.new(table, &block)
+  def _make_relevant_view(table, block, cls)
+    if cls == ObjectTable::View
+      cls.new(table, &block)
 
-    elsif @cls == ObjectTable::StaticView
+    elsif cls == ObjectTable::StaticView
       indices = table.apply(&block).where
-      @cls.new(table, indices)
+      cls.new(table, indices)
 
     else
-      nil
+      raise "Could not make a a #{cls.inspect} view"
     end
   end
 
-  subject{ _make_relevant_view(table, block) }
+  subject{ _make_relevant_view(table, block, described_class) }
 
   describe '#columns' do
     let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
@@ -52,7 +49,7 @@ RSpec.shared_examples 'a table view' do |cls|
   describe '#set_column' do
     let(:table) { ObjectTable.new(col1: [0, 1, 2, 3], col2: 5) }
     let(:block) { Proc.new{col1 > 0} }
-    let(:view)  { _make_relevant_view(table, block) }
+    let(:view)  { _make_relevant_view(table, block, described_class) }
 
     let(:value) { [10, 20, 30] }
     let(:args)  { [] }
@@ -189,7 +186,7 @@ RSpec.shared_examples 'a table view' do |cls|
   describe '#pop_column' do
     let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
     let(:block){ Proc.new{col1 > 2} }
-    let(:view) { _make_relevant_view(table, block) }
+    let(:view) { _make_relevant_view(table, block, described_class) }
     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.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Cheney Lin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-22 00:00:00.000000000 Z
+date: 2015-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -97,29 +97,34 @@ 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/factory.rb
+- lib/object_table/grouping.rb
+- lib/object_table/grouping/grid.rb
+- lib/object_table/joining.rb
 - lib/object_table/masked_column.rb
-- lib/object_table/printable.rb
-- lib/object_table/stacker.rb
+- lib/object_table/printing.rb
+- lib/object_table/stacking.rb
 - lib/object_table/static_view.rb
-- lib/object_table/table_child.rb
 - lib/object_table/table_methods.rb
+- lib/object_table/util.rb
 - lib/object_table/version.rb
 - lib/object_table/view.rb
 - lib/object_table/view_methods.rb
 - object_table.gemspec
 - spec/object_table/basic_grid_spec.rb
 - spec/object_table/column_spec.rb
-- spec/object_table/grouped_spec.rb
+- spec/object_table/grouping_spec.rb
 - spec/object_table/masked_column_spec.rb
 - spec/object_table/static_view_spec.rb
+- spec/object_table/util_spec.rb
 - spec/object_table/view_spec.rb
 - spec/object_table_spec.rb
 - spec/spec_helper.rb
 - spec/subclassing_spec.rb
+- spec/support/joining_example.rb
 - spec/support/object_table_example.rb
-- spec/support/stacker_example.rb
+- spec/support/stacking_example.rb
+- spec/support/utils.rb
 - spec/support/view_example.rb
 homepage: https://github.com/lincheney/ruby-object-table
 licenses:
@@ -133,7 +138,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
@@ -148,13 +153,16 @@ summary: Simple data table table implementation in ruby
 test_files:
 - spec/object_table/basic_grid_spec.rb
 - spec/object_table/column_spec.rb
-- spec/object_table/grouped_spec.rb
+- spec/object_table/grouping_spec.rb
 - spec/object_table/masked_column_spec.rb
 - spec/object_table/static_view_spec.rb
+- spec/object_table/util_spec.rb
 - spec/object_table/view_spec.rb
 - spec/object_table_spec.rb
 - spec/spec_helper.rb
 - spec/subclassing_spec.rb
+- spec/support/joining_example.rb
 - spec/support/object_table_example.rb
-- spec/support/stacker_example.rb
+- spec/support/stacking_example.rb
+- spec/support/utils.rb
 - spec/support/view_example.rb

data/lib/object_table/group.rb

@@ -1,10 +0,0 @@
-require_relative 'static_view'
-
-class ObjectTable::Group < ObjectTable::StaticView
-  attr_reader :K
-
-  def initialize(parent, keys, value)
-    super(parent, value)
-    @K = keys
-  end
-end