object_table 0.2.4 → 0.2.8

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: fcf93afcb7a81c3a9fb40c8ffc7d8b1bd506c845
-  data.tar.gz: 9d6a155f502215a3f57639108bfe908ea4e853f8
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzA3YzQ3OTc1OGZiMzYwN2NlNGM0Y2UxN2ExOTJjNjQxODdiZTdkNQ==
+  data.tar.gz: !binary |-
+    MzdhYWU4NmI2MWNhOGM2YTk4MzAwNGRiYTAyZDg1OWE4YWM2ZWZmNg==
 SHA512:
-  metadata.gz: 0a4a23f3e527ee524e2d528637ed939caaa0e48bde230df277cfaccbb50a4f62824081be6990fd3307cc5108f485066ecb05f2d79563999b6365154ab04151e7
-  data.tar.gz: b23605bf82b78fb04fce0a4f0f4a8f6e049a2f3b15fbf3c9ee2029f71370f9b0fc2e064269edbe7bbb110cfa6a79ca8d3acfb2450292efe36df34a0c4676a23e
+  metadata.gz: !binary |-
+    MmU2MTA0NGY3NzA1ZGM3NDVlOWJiOTBmM2NiYWM3OTNkZjdiM2NhZTQzMDUz
+    Zjg5NzYwOWZmMzUyMzE3MWIyZjE2ZGEwNTRhZTI2ZjlhMjhkZDNhNzgyNWNj
+    N2Y0YWExNDQ5NzU2MGFjNzdhMmY1NWY1ZTYxOWVhNGU5YjliODc=
+  data.tar.gz: !binary |-
+    YTZjYTFmMjljNGQzYjkzY2U1OTU5MTQ3ZjllMDkyMDBiYjgxYzE2NDk5NmE3
+    MDU2YWNhNTkzOGUzZTc2ZTk2MGIyYjUwOTIzZjI0NmI0M2RkNmRlNDZjMjAz
+    M2VkZWMzYWE4MDI3MmVkOWE5ZmRhZTg0ZWFlODEwMDllMGE5YjQ=

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/lib/object_table.rb

@@ -43,17 +43,16 @@ class ObjectTable
 
       raise "Don't know how to append a #{x.class}" unless x.is_a?(ObjectTable::BasicGrid)
       next if x.empty?
-      raise 'Mismatch in column names' unless (colnames | x.keys) == (colnames & x.keys)
+      raise 'Mismatch in column names' unless (colnames - x.keys).empty?
 
       x.each do |k, v|
-        v = v.to_a if v.is_a?(Range)
-        new_values[k].push NArray.to_na(v)
+        unless new_values.include?(k) and v.empty?
+          new_values[k].push(NArray.to_na(v))
+        end
       end
     end
 
-    return self if new_values.empty?
-    new_rows = new_values.values.first.map{|x| x.shape[-1]}.reduce(:+)
-    return self unless (new_rows and new_rows != 0)
+    return self if new_values.values.first.empty?
 
     new_values.each do |k, v|
       @columns[k] = @columns[k].stack(*v)

data/lib/object_table/basic_grid.rb

@@ -1,30 +1,32 @@
 require 'narray'
 
 class ObjectTable::BasicGrid < Hash
-  ARRAY_LIKE = [Array, Range]
-
 #   def self.[](*args)
 #     grid = super
 #     grid._ensure_uniform_columns!
 #   end
 
-  def _ensure_uniform_columns!(rows = nil)
-    arrays, scalars = partition{|k, v| ARRAY_LIKE.any?{|cls| v.is_a?(cls)} }
-    narrays, scalars = scalars.partition{|k, v| v.is_a?(NArray) }
+  def _get_number_rows!
+    each{|k, v| self[k] = v.to_a if v.is_a?(Range)}
+    rows = map do |k, v|
+      case v
+      when Array
+        v.length
+      when NArray
+        v.shape.last or 0
+      end
+    end.compact.uniq
+  end
 
-    unique_rows = arrays.map{|k, v| v.count}
-    unique_rows += narrays.map{|k, v| v.shape.last or 0}
-    unique_rows = unique_rows.uniq
+  def _ensure_uniform_columns!(rows = nil)
+    unique_rows = _get_number_rows!
+    unique_rows |= [rows] if rows
 
-    if rows
-      raise "Differing number of rows: #{unique_rows}" unless unique_rows.empty? or unique_rows == [rows]
-    else
-      raise "Differing number of rows: #{unique_rows}" if unique_rows.length > 1
-      rows = (unique_rows[0] or 1)
-    end
+    raise "Differing number of rows: #{unique_rows}" if unique_rows.length > 1
+    rows = (unique_rows[0] or 1)
 
-    scalars.each do |k, v|
-      self[k] = [v] * rows
+    each do |k, v|
+      self[k] = [v] * rows unless (v.is_a?(Array) || v.is_a?(NArray))
     end
 
     self

data/lib/object_table/grouped.rb

@@ -11,12 +11,11 @@ class ObjectTable::Grouped
     @names = names
   end
 
-
   def _groups
     names, keys = _keys()
     groups = keys.length.times.group_by{|i| keys[i]}
     groups.each do |k, v|
-      groups[k] = NArray.to_na(v)
+      groups[k] = v
     end
     [names, groups]
   end
@@ -26,11 +25,11 @@ class ObjectTable::Grouped
       keys = @parent.apply(&@grouper)
       raise 'Group keys must be hashes' unless keys.is_a?(Hash)
       keys = ObjectTable::BasicGrid.new.replace keys
+      keys._ensure_uniform_columns!(@parent.nrows)
     else
       keys = ObjectTable::BasicGrid[@names.map{|n| [n, @parent.get_column(n)]}]
     end
 
-    keys._ensure_uniform_columns!(@parent.nrows)
     names = keys.keys
     keys = keys.values.map(&:to_a).transpose
     [names, keys]
@@ -38,15 +37,8 @@ class ObjectTable::Grouped
 
   def each(&block)
     names, groups = _groups()
-    if block
-      groups.each do |k, v|
-        keys = names.zip(k)
-        __group_cls__.new(@parent, Hash[keys], v).apply &block
-      end
-      return @parent
-    end
 
-    Enumerator.new(groups.length) do |y|
+    enumerator = Enumerator.new do |y|
       groups.each do |k, v|
         keys = names.zip(k)
         y.yield __group_cls__.new(@parent, Hash[keys], v)
@@ -54,6 +46,8 @@ class ObjectTable::Grouped
       @parent
     end
 
+    return enumerator unless block
+    enumerator.each{|grp| grp._apply_block(&block)}
   end
 
   def apply(&block)
@@ -62,19 +56,31 @@ class ObjectTable::Grouped
 
     data = groups.map do |k, v|
       keys = names.zip(k)
-      value = __group_cls__.new(@parent, Hash[keys], v).apply &block
+      value = __group_cls__.new(@parent, Hash[keys], v)._apply_block &block
 
-      if value.is_a?(ObjectTable::TableMethods)
+      case value
+      when ObjectTable::TableMethods
+        nrows = value.nrows
         value = value.columns
+      when ObjectTable::BasicGrid
+        value._ensure_uniform_columns!
+        nrows = NArray.to_na(value.values.first).shape[-1]
+      when Array
+        nrows = value.length
+      when NArray
+        nrows = value.shape.last
+      else
+        nrows = 1
       end
 
+      keys = names.zip(k.map{|x| [x] * nrows})
+
       grid = case value
       when ObjectTable::BasicGrid
         ObjectTable::BasicGrid[keys].merge!(value)
       else
         ObjectTable::BasicGrid[keys + [[value_key, value]]]
       end
-      grid._ensure_uniform_columns!
     end
 
     __table_cls__.stack(*data)

data/lib/object_table/static_view.rb

@@ -10,11 +10,23 @@ class ObjectTable::StaticView
     super()
     @parent = parent
     @indices = indices
-    columns
+    @columns = ObjectTable::BasicGrid.new
+    @fully_cached = false
   end
 
   def columns
-    @columns ||= super
+    unless @fully_cached
+      @parent.columns.map{|k, v| get_column(k)}
+      @fully_cached = true
+    end
+    @columns
+  end
+
+  def get_column(name)
+    @columns.fetch(name) do
+      col = super
+      @columns[name] = col if col
+    end
   end
 
   def add_column(name, *args)

data/lib/object_table/table_methods.rb

@@ -67,16 +67,18 @@ module ObjectTable::TableMethods
   end
 
   def apply(&block)
+    result = _apply_block(&block)
+
+    return result unless result.is_a? ObjectTable::BasicGrid
+    __table_cls__.new(result)
+  end
+
+  def _apply_block(&block)
     if block.arity == 0
       result = instance_eval &block
     else
       result = block.call(self)
     end
-
-    if result.is_a? ObjectTable::BasicGrid
-      result = __table_cls__.new(result)
-    end
-    result
   end
 
   def where(&block)

data/lib/object_table/version.rb

@@ -1,3 +1,3 @@
 class ObjectTable
-  VERSION = "0.2.4"
+  VERSION = "0.2.8"
 end

data/lib/object_table/view.rb

@@ -16,12 +16,6 @@ class ObjectTable::View
 
   def_delegators :@parent, :has_column?
 
-  def get_column(name)
-    col = @parent.get_column(name)
-    ObjectTable::MaskedColumn.mask(col, indices) if col
-  end
-  alias_method :[], :get_column
-
   def make_view
     __static_view_cls__.new @parent, indices
   end
@@ -37,7 +31,7 @@ class ObjectTable::View
   end
 
   def indices
-    @indices or NArray.int(@parent.nrows).indgen![@parent.apply &@filter]
+    @indices or NArray.int(@parent.nrows).indgen![@parent._apply_block &@filter]
   end
 
   def cache_indices(&block)

data/lib/object_table/view_methods.rb

@@ -7,10 +7,20 @@ module ObjectTable::ViewMethods
   include ObjectTable::TableMethods
   include ObjectTable::TableChild
 
+  def nrows
+    indices.length
+  end
+
   def columns
     ObjectTable::BasicGrid[@parent.columns.map{|k, v| [k, ObjectTable::MaskedColumn.mask(v, indices)]}]
   end
 
+  def get_column(name)
+    col = @parent.get_column(name)
+    ObjectTable::MaskedColumn.mask(col, indices) if col
+  end
+  alias_method :[], :get_column
+
   def add_column(name, *args)
     col = @parent.add_column(name, *args)
     ObjectTable::MaskedColumn.mask(col, indices)

data/spec/object_table/basic_grid_spec.rb

@@ -10,12 +10,85 @@ describe ObjectTable::BasicGrid do
 #     end
 #   end
 
+  describe '#_get_number_rows!' do
+    let(:grid){ ObjectTable::BasicGrid[columns] }
+
+    subject{ grid._get_number_rows! }
+
+    context 'with columns of the same length' do
+      let(:columns){ {col1: [1, 2, 3], col2: [1, 2, 3]} }
+      it 'should give unique column lengths' do
+        expect(subject).to match_array [3]
+      end
+    end
+
+    context 'with columns of differing length' do
+      let(:columns){ {col1: [1, 2, 3], col2: [1, 2, 3, 4]} }
+      it 'should return the column lengths' do
+        expect(subject).to match_array [3, 4]
+      end
+    end
+
+    context 'with a mix of scalars and columns' do
+      let(:columns){ {col1: [1, 2, 3], col2: [1, 2, 3], col3: 6} }
+      it 'should ignore the scalars' do
+        expect(subject).to match_array [3]
+      end
+    end
+
+    context 'with scalars only' do
+      let(:columns){ {col1: 1, col2: 2} }
+      it 'should be empty' do
+        expect(subject).to be_empty
+      end
+    end
+
+    context 'with ranges' do
+      let(:columns){ {col1: 0...3} }
+      it 'should convert them to arrays' do
+        subject
+        expect(grid[:col1]).to eql columns[:col1].to_a
+      end
+
+      it 'should use the length of the range' do
+        expect(subject).to match_array [3]
+      end
+    end
+
+    context 'with multi dimensional narrays' do
+      context 'with the same last dimension' do
+        let(:columns) { {col1: NArray[[1, 1], [2, 2], [3, 3]], col2: [1, 2, 3]} }
+
+        it 'should include the last dimension' do
+          expect(subject).to match_array [3]
+        end
+      end
+
+      context 'with a different last dimension' do
+        let(:columns) { {col1: NArray[[1, 2, 3]], col2: [1, 2, 3]} }
+
+        it 'should include the last dimension' do
+          expect(subject).to match_array [1, 3]
+        end
+      end
+    end
+
+    context 'with empty narrays' do
+      let(:columns) { {col1: [1, 2, 3], col2: NArray[]} }
+
+      it 'should treat them as having zero length' do
+        expect(subject).to match_array [3, 0]
+      end
+    end
+
+  end
+
   describe '#_ensure_uniform_columns!' do
     let(:grid){ ObjectTable::BasicGrid[columns] }
 
     subject{ grid._ensure_uniform_columns! }
 
-    context 'with rows of the same length' do
+    context 'with columns of the same length' do
       let(:columns){ {col1: [1, 2, 3], col2: [1, 2, 3]} }
       it 'should succeed' do
         subject
@@ -24,14 +97,14 @@ describe ObjectTable::BasicGrid do
       end
     end
 
-    context 'with rows of differing length' do
+    context 'with columns of differing length' do
       let(:columns){ {col1: [1, 2, 3], col2: [1, 2, 3, 4]} }
       it 'should fail' do
         expect{subject}.to raise_error
       end
     end
 
-    context 'with a mix of scalars and rows' do
+    context 'with a mix of scalars and columns' do
       let(:columns){ {col1: [1, 2, 3], col2: [1, 2, 3], col3: 6} }
       it 'should recycle the scalar into a full column' do
         subject
@@ -41,7 +114,7 @@ describe ObjectTable::BasicGrid do
 
     context 'with scalars only' do
       let(:columns){ {col1: 1, col2: 2} }
-      it 'should assume there is one row' do
+      it 'should assume there is one column' do
         subject
         expect(grid[:col1]).to eql [columns[:col1]]
         expect(grid[:col2]).to eql [columns[:col2]]
@@ -51,12 +124,11 @@ describe ObjectTable::BasicGrid do
     context 'with ranges' do
       let(:columns){ {col1: 0...3} }
       it 'should succeed' do
-        subject
-        expect(grid[:col1]).to eql columns[:col1]
+        expect{subject}.to_not raise_error
       end
     end
 
-    context 'with rank>2 narrays' do
+    context 'with multi dimensional narrays' do
       context 'with the correct last dimension' do
         let(:columns) { {col1: NArray[[1, 1], [2, 2], [3, 3]], col2: [1, 2, 3]} }
 
@@ -87,10 +159,10 @@ describe ObjectTable::BasicGrid do
 
 
       context 'with other non-empty columns' do
-        let(:columns) { {col1: [], col2: NArray[]} }
+        let(:columns) { {col1: [], col2: NArray[], col3: [1, 2, 3]} }
 
         it 'should fail' do
-          expect{subject}.to_not raise_error
+          expect{subject}.to raise_error
         end
       end
     end

data/spec/object_table/grouped_spec.rb

@@ -71,9 +71,9 @@ describe ObjectTable::Grouped 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]})
+      expect(subject._groups[1]).to eql ({[0] => [1, 3], [1] => [0, 2]})
       table[:col1] = [2, 3, 4, 5]
-      expect(subject._groups[1]).to eql ({[0] => NArray[0, 2], [1] => NArray[1, 3]})
+      expect(subject._groups[1]).to eql ({[0] => [0, 2], [1] => [1, 3]})
     end
   end
 
@@ -86,8 +86,8 @@ describe ObjectTable::Grouped do
 
     it 'should return the group key => row mapping' do
       groups = subject[1]
-      expect(groups[[0]]).to eql even
-      expect(groups[[1]]).to eql odd
+      expect(groups[[0]]).to eql even.to_a
+      expect(groups[[1]]).to eql odd.to_a
     end
 
     context 'when grouping by columns' do
@@ -100,10 +100,10 @@ describe ObjectTable::Grouped do
 
       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
+        expect(groups[[0, 0]]).to eql (table.key1.eq(0) & table.key2.eq(0)).where.to_a
+        expect(groups[[0, 1]]).to eql (table.key1.eq(0) & table.key2.eq(1)).where.to_a
+        expect(groups[[1, 0]]).to eql (table.key1.eq(1) & table.key2.eq(0)).where.to_a
+        expect(groups[[1, 1]]).to eql (table.key1.eq(1) & table.key2.eq(1)).where.to_a
       end
     end
   end
@@ -249,6 +249,40 @@ describe ObjectTable::Grouped do
         end
       end
     end
+
+    context 'with a matrix key' do
+      let(:ngroups) { 10 }
+      let(:table) do
+        ObjectTable.new(
+          key1: 10.times.map{[rand, 'abc']} * ngroups,
+          key2: 10.times.map{[rand, 'def', 'ghi']} * ngroups,
+          value: (ngroups*10).times.map{rand},
+        )
+      end
+
+      let(:grouped) { ObjectTable::Grouped.new(table, :key1, :key2) }
+      subject{ grouped.apply{|group| group.value.sum} }
+
+      it 'should return a table with the group keys' do
+        expect(subject).to be_a ObjectTable
+        expect(subject.colnames).to include :key1
+        expect(subject.colnames).to include :key2
+      end
+
+      it 'should preserve the dimensions of the keys' do
+        expect(subject.key1.shape[0...-1]).to eql table.key1.shape[0...-1]
+        expect(subject.key2.shape[0...-1]).to eql table.key2.shape[0...-1]
+      end
+
+      context 'with vector values' do
+        subject{ grouped.apply{|group| group.value[0...10]} }
+
+        it 'should work' do
+          expect{subject}.to_not raise_error
+        end
+      end
+    end
+
   end
 
 end

data/spec/object_table_spec.rb

@@ -246,8 +246,16 @@ describe ObjectTable do
       end
     end
 
-    context 'with differing column names' do
-      let(:others){ [ObjectTable.new(col1: 10, col2: 50), ObjectTable.new(col1: 10, col3: 50)] }
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_table
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.8
 platform: ruby
 authors:
 - Cheney Lin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-20 00:00:00.000000000 Z
+date: 2015-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -42,14 +42,14 @@ dependencies:
   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
@@ -74,6 +74,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
@@ -112,12 +113,12 @@ 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: []