object_table 0.1.0

data/spec/object_table_spec.rb

@@ -0,0 +1,232 @@
+require 'object_table'
+
+require 'support/object_table_example'
+
+describe ObjectTable do
+  it_behaves_like 'an object table', ObjectTable
+
+  describe '#initialize' do
+    let(:columns){ {col1: [1, 2, 3], col2: NArray[4, 5, 6], col3: 7..9, col4: 10} }
+    subject{ ObjectTable.new columns }
+
+    it 'should convert all columns into ObjectTable::Columns' do
+      subject.columns.values.each do |v|
+        expect(v).to be_a ObjectTable::Column
+      end
+    end
+
+    it 'should include all the columns' do
+      grid = ObjectTable::BasicGrid[columns]
+      grid._ensure_uniform_columns!
+
+      grid.each do |k, v|
+        expect(subject[k].to_a).to eql v.to_a
+      end
+    end
+
+    context 'with multi dimensional columns' do
+      let(:columns){ {col1: [1, 2, 3], col2: NArray[[4, 4], [5, 5], [6, 6]]} }
+
+      it 'should convert all columns into ObjectTable::Columns' do
+        subject.columns.values.each do |v|
+          expect(v).to be_a ObjectTable::Column
+        end
+      end
+
+      it 'should include all the columns' do
+        grid = ObjectTable::BasicGrid[columns]
+        grid._ensure_uniform_columns!
+
+        grid.each do |k, v|
+          expect(subject[k].to_a).to eql v.to_a
+        end
+      end
+
+      it 'should preserve the dimensions' do
+        expect(subject[:col2].shape).to eql columns[:col2].shape
+      end
+    end
+
+  end
+
+  context '#set_column' do
+    let(:value){ [4, 5, 6] }
+    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
+
+    it 'should coerce the value to a column' do
+      subject
+      expect(table.columns[column]).to be_a ObjectTable::Column
+    end
+
+    context 'with the wrong length' do
+      let(:value) { [1, 2] }
+      it 'should fail' do
+        expect{subject}.to raise_error
+      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)
+      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
+      end
+    end
+
+    context 'for a new column' do
+      let(:column) { :col3 }
+
+      it 'should create a new column' do
+        subject
+        expect(table.columns).to include column
+        expect(table.columns[column].to_a).to eql value
+      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
+        end
+      end
+
+      context 'with an NArray' do
+        let(:value){ NArray.int(3, 4, table.nrows) }
+
+        it 'should use the narray parameters' do
+          subject
+          expect(table.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(table).to receive(:add_column).with(column, value.typecode) do
+            table.columns[column] = 12345
+          end
+
+#           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 }
+
+        it 'should create a column with the typecode' do
+          subject
+          expect(table.columns[column].typecode).to eql NArray.new(*args).typecode
+        end
+
+        it 'should create a column with the correct size' do
+          subject
+          expect(table.columns[column].shape[-1]).to eql table.nrows
+          expect(table.columns[column].shape[0...-1]).to eql args[1..-1]
+        end
+      end
+
+    end
+
+  end
+
+  describe '#pop_column' do
+    let(:table)   { ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    let(:name)    { :col2 }
+
+    subject{ table.pop_column(name) }
+
+    it 'should remove the column' do
+      subject
+      expect(table.colnames).to_not include name
+      expect(table.columns).to_not include name
+    end
+
+    it 'should return the column' do
+      column = table[name]
+      expect(subject).to be column
+    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 differing column names' do
+      let(:others){ [ObjectTable.new(col1: 10, col2: 50), ObjectTable.new(col1: 10, col3: 50)] }
+
+      it 'should fail' do
+        expect{subject}.to raise_error
+      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) }
+
+    it 'should modify the table' do
+      expect(subject).to be table
+    end
+
+    it 'should sort by the given columns' do
+      expect(subject).to eql table.sort_by(table.col1, table.col2)
+    end
+  end
+
+end

data/spec/support/object_table_example.rb

@@ -0,0 +1,314 @@
+require 'object_table'
+
+RSpec.shared_examples 'an object table' do |cls|
+  before do
+    @cls = cls
+  end
+
+  def _make_relevant_table(table)
+    if @cls == ObjectTable
+      table
+
+    elsif @cls == ObjectTable::TempView
+      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
+      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) }
+
+  describe '#inspect' do
+    let(:table){ ObjectTable.new(col1: 1..10, col2: 5) }
+    it 'should succeed' do
+      expect{subject.inspect}.to_not raise_error
+    end
+
+    it 'should have a header listing the dimensions' do
+      expect(subject.inspect.lines.to_a.first).to eql "#{subject.class}(#{subject.nrows}, #{subject.ncols})\n"
+    end
+
+    it 'should include the column names at the top and bottom' do
+      expect(subject.inspect.lines.to_a[1].split).to eql subject.colnames.map(&:to_s)
+      expect(subject.inspect.lines.to_a[-1].split).to eql subject.colnames.map(&:to_s)
+    end
+
+    context 'with few rows' do
+      let(:table){ ObjectTable.new(col1: 1..10, 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
+  5:      6     5
+  6:      7     5
+  7:      8     5
+  8:      9     5
+  9:     10     5
+       col1  col2
+EOS
+      end
+    end
+
+    context 'with many rows' do
+      let(:table){ ObjectTable.new(col1: 1..100, col2: 5) }
+
+      it 'should only include the top and bottom 5 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
+------------------
+  95:     96     5
+  96:     97     5
+  97:     98     5
+  98:     99     5
+  99:    100     5
+        col1  col2
+EOS
+      end
+    end
+
+    context 'with matrixy columns' do
+      let(:table){ ObjectTable.new(col1: 1..100, col2: NArray.to_na([[1, 2]] * 100) ) }
+
+      it 'should handle the matrixy columns' do
+        table = subject.inspect.lines.to_a[1..-1].join + "\n"
+        expect(table).to eql <<EOS
+        col1      col2
+   0:      1  [ 1, 2 ]
+   1:      2  [ 1, 2 ]
+   2:      3  [ 1, 2 ]
+   3:      4  [ 1, 2 ]
+   4:      5  [ 1, 2 ]
+----------------------
+  95:     96  [ 1, 2 ]
+  96:     97  [ 1, 2 ]
+  97:     98  [ 1, 2 ]
+  98:     99  [ 1, 2 ]
+  99:    100  [ 1, 2 ]
+        col1      col2
+EOS
+      end
+
+      context 'with long rows in the matrix' do
+        let(:table){ ObjectTable.new(col1: 1..100, col2: NArray.to_na([(0...100).to_a] * 100) ) }
+
+        it 'should let NArray truncate them' do
+          table = subject.inspect.lines.to_a[1..-1].join + "\n"
+        expect(table).to eql <<EOS
+        col1                                                                           col2
+   0:      1  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+   1:      2  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+   2:      3  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+   3:      4  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+   4:      5  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+-------------------------------------------------------------------------------------------
+  95:     96  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+  96:     97  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+  97:     98  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+  98:     99  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+  99:    100  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ... ]
+        col1                                                                           col2
+EOS
+        end
+      end
+    end
+
+    context 'when raising a no method error' do
+      it 'should propagate it as some other exception' do
+        expect(subject).to receive(:columns){ raise NoMethodError.new('asd') }
+        expect{subject.inspect}.to raise_error do |error|
+          expect(error).to_not be_a NoMethodError
+          expect(error.message).to eql 'asd'
+        end
+      end
+    end
+  end
+
+  describe '#nrows' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: [5, 5, 5]) }
+
+    it 'should return the number of rows' do
+      expect(table.nrows).to eql 3
+    end
+
+    context 'on an empty table' do
+      let(:table){ ObjectTable.new }
+
+      it 'should return 0' do
+        expect(table.nrows).to eql 0
+      end
+    end
+  end
+
+  describe 'column methods' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: [5, 5, 5]) }
+
+    it 'should respond to the column names as methods' do
+      subject.columns.keys.each do |key|
+        expect(subject).to respond_to key
+        expect(subject.send(key)).to eql subject.columns[key]
+      end
+    end
+
+    describe '#[]' do
+      it 'should allow access to columns through []' do
+        subject.columns.keys.each do |key|
+          expect(subject[key]).to eql subject.columns[key]
+        end
+      end
+    end
+  end
+
+  describe '==' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: [5, 5, 5]) }
+
+    it 'should fail for non-tables' do
+      expect(subject == 'not a table').to be_falsey
+    end
+
+    context 'against a ObjectTable' do
+      context 'with different contents' do
+        let(:other){ ObjectTable.new(col1: [1, 2, 3], col2: 10000) }
+
+        it 'should fail' do
+          expect(subject == other).to be_falsey
+        end
+      end
+
+      context 'with the same contents' do
+        let(:other){ ObjectTable.new(col1: [1, 2, 3], col2: [5, 5, 5]) }
+
+        it 'should succeed' do
+          expect(subject == other).to be_truthy
+        end
+      end
+    end
+
+    context 'against a ObjectTable::View' do
+      let(:view_parent){ ObjectTable.new(col2: [5, 5, 5, 1000], col1: [1, 2, 3, 4]) }
+
+      context 'with different contents' do
+        let(:other){ view_parent.where{ col1 > 1} }
+
+        it 'should fail' do
+          expect(subject == other).to be_falsey
+        end
+      end
+
+      context 'with the same contents' do
+        let(:other){ view_parent.where{ col1 < 4} }
+
+        it 'should succeed' do
+          expect(subject == other).to be_truthy
+        end
+      end
+    end
+
+  end
+
+  describe '#apply' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+
+    it 'should evaluate in the context of the table' 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]] } }
+
+      it 'should coerce to a table' do
+        expect(subject).to be_a ObjectTable
+      end
+    end
+
+    it 'should have access to a BasicGrid shortcut' do
+      result = table.apply{ @R[value: col1 + 5] }
+      expect(result).to be_a ObjectTable
+      expect(result.value).to eql (table.col1 + 5)
+    end
+  end
+
+  describe '#where' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    let(:block){ Proc.new{col1 > 1} }
+    let(:filtered){ subject.where &block }
+
+    it 'should return a temp view' do
+      expect(filtered).to be_a ObjectTable::TempView
+      expect(filtered.instance_eval('@filter')).to eql block
+    end
+  end
+
+  describe '#group' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    let(:block){ Proc.new{col1 > 1} }
+    let(:grouped){ subject.group &block }
+
+    it 'should return groups' do
+      expect(grouped).to be_a ObjectTable::TempGrouped
+      expect(grouped.instance_eval('@grouper')).to eql block
+    end
+  end
+
+  describe '.clone' do
+    let(:table){ ObjectTable.new(col1: [1, 2, 3], col2: 5) }
+    let(:clone){ subject.clone }
+
+    it 'should return a new table' do
+      expect(clone).to be_a ObjectTable
+      expect(clone).to_not be subject
+    end
+
+    it 'should be equivalent to the original table' do
+      expect(clone).to eql subject
+    end
+
+    it 'should have cloned columns' do
+      subject.columns.each do |k, v|
+        expect(clone.columns[k].to_a).to eql v.to_a
+        expect(clone.columns[k]).to_not be v
+      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]) }
+    let(:sorted){ subject.sort_by(subject.col1, subject.col2) }
+
+    it 'should return a new table' do
+      expect(sorted).to be_a ObjectTable
+      expect(sorted).to_not be subject
+    end
+
+    it 'should sort by the given columns' do
+      expect(sorted).to eql ObjectTable.new(
+        col1: [1, 1, 2, 2],
+        col2: [0, 1, 0, 1],
+        col3: [7, 8, 5, 6],
+      )
+    end
+  end
+
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: object_table
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cheney Lin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Simple data table table implementation in ruby
+email:
+- lincheney@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/object_table.rb
+- lib/object_table/basic_grid.rb
+- lib/object_table/column.rb
+- lib/object_table/grouped.rb
+- lib/object_table/masked_column.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
+- 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/masked_column_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/support/object_table_example.rb
+homepage: https://github.com/lincheney/ruby-object-table
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+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/masked_column_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/support/object_table_example.rb