object_table 0.3.0 → 0.3.2

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZTUwZmM3Nzk5N2I3NmE4ZGYwZmE0M2IzMjBkZDEyZTk0NTcxNzliNQ==
-  data.tar.gz: !binary |-
-    ODg5Zjc3Nzk5ZGIyMjk1OWNjYjFlYzhjMzhlMGNlNzdjMGI3ZWE0OQ==
+SHA1:
+  metadata.gz: 8b283bc238922ed7b80fc82225cbb758c6a0bf44
+  data.tar.gz: 144b36aec60ae08d7ef391351dc6ec5e14d4c33c
 SHA512:
-  metadata.gz: !binary |-
-    OWFlMzcwN2U2MTQ4Y2ZkNWQyY2I2Y2I1YWFkM2ZjMDIzNTgzYTAxOTNhZDVl
-    NmIxMDRkY2I0NjQ3NTAwZGYxYzU3MjRiZGFkMjU5ODg2ODdjNzBmMjEwNGNh
-    ZTRmODBiOWRiM2Y2Zjc5ZjY3OWYwZTk4YzgxY2UzZDdkY2YyMDI=
-  data.tar.gz: !binary |-
-    NjkwZWRiM2FlYmVhNjgyNzRhYmZmN2I1YzVhYzJjYTVlYzVlMDFmZTFiNGM0
-    NjcyMzdlYTIwMDM2MjljN2VkNmM2OTM1MzBjOWZiOWJiMTlhYmE5MWQxMTI2
-    YmQxMmYxNzQ2MjhjMTc4ZTk3ODhhYTcyZTM2OGE4ZjMwOTNkNDY=
+  metadata.gz: 4ae62ff61696c06ab3c4edd2974dc68cd4508de97388a0194d347865c2f617a3cd1694f87f6afdaa6cafd4fadca011e131cebf2f09925e6ea46de959b5eab2ea
+  data.tar.gz: 38110c1fc518f9d8bc5d0ab4b964eab0a266fb94641ee71c636510bcd1ab710901f9af64c61a677800e4617ac993e74610e69e3eff704079e503d38e499e72ad

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/README.md

@@ -1,6 +1,21 @@
 ruby-object-table
 =================
 
+[![Gem Version][GV img]][Gem Version]
+[![Build Status][BS img]][Build Status]
+[![Code Climate][CC img]][Code Climate]
+[![Coverage Status][CS img]][Coverage Status]
+
+[Gem Version]: https://rubygems.org/gems/object_table
+[Build Status]: https://travis-ci.org/lincheney/ruby-object-table
+[Code Climate]: https://codeclimate.com/github/lincheney/ruby-object-table
+[Coverage Status]: https://coveralls.io/r/lincheney/ruby-object-table
+
+[GV img]: https://badge.fury.io/rb/object_table.png
+[BS img]: https://travis-ci.org/lincheney/ruby-object-table.png
+[CC img]: https://codeclimate.com/github/lincheney/ruby-object-table.png
+[CS img]: https://coveralls.io/repos/lincheney/ruby-object-table/badge.png?branch=master
+
 Simple data table/frame implementation in ruby
 Probably slow and extremely inefficient, but it works and that's all that matters.
 Uses NArrays (https://github.com/masa16/narray) for storing data.

data/lib/object_table/basic_grid.rb

@@ -8,14 +8,7 @@ class ObjectTable::BasicGrid < Hash
 
   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
+    rows = map{|k, v| ObjectTable::Column.length_of(v) rescue nil}.compact.uniq
   end
 
   def _ensure_uniform_columns!(rows = nil)
@@ -29,7 +22,7 @@ class ObjectTable::BasicGrid < Hash
       self[k] = [v] * rows unless (v.is_a?(Array) || v.is_a?(NArray))
     end
 
-    self
+    rows
   end
 
 end

data/lib/object_table/column.rb

@@ -2,7 +2,19 @@ require 'narray'
 
 module ObjectTable::Column
 
+  def self.length_of(array)
+    case array
+    when Array
+      array.length
+    when NArray
+      array.shape.last or 0
+    else
+      raise "Expected Array or NArray, got #{array}"
+    end
+  end
+
   def self.stack(*columns)
+    columns = columns.reject(&:empty?)
     return NArray[] if columns.empty?
     return columns[0].clone if columns.length == 1
 
@@ -10,12 +22,10 @@ module ObjectTable::Column
     first_col = columns.first
     new_col = NArray.new(first_col.typecode, *first_col.shape[0...-1], new_rows)
 
-    padding = [nil] * (first_col.rank - 1)
-
-    row = 0
-    columns.each do |col|
-      new_col[*padding, row ... (row + col.shape[-1])] = col
-      row += col.shape[-1]
+    columns.reduce(0) do |row, col|
+      end_row = row + col.shape[-1]
+      new_col[false, row ... end_row] = col
+      end_row
     end
 
     new_col

data/lib/object_table/grouped.rb

@@ -37,15 +37,7 @@ class ObjectTable::Grouped
 
   def each(&block)
     names, groups = _groups()
-
-    enumerator = Enumerator.new do |y|
-      groups.each do |k, v|
-        keys = names.zip(k)
-        y.yield __group_cls__.new(@parent, Hash[keys], v)
-      end
-      @parent
-    end
-
+    enumerator = _make_groups(names, groups)
     return enumerator unless block
     enumerator.each{|grp| grp._apply_block(&block)}
   end
@@ -53,37 +45,41 @@ class ObjectTable::Grouped
   def apply(&block)
     names, groups = _groups()
     value_key = self.class._generate_name(DEFAULT_VALUE_PREFIX, names).to_sym
+    nrows = []
 
-    data = groups.map do |k, v|
-      keys = names.zip(k)
-      value = __group_cls__.new(@parent, Hash[keys], v)._apply_block &block
+    data = _make_groups(names, groups).map do |group|
+      value = group._apply_block(&block)
 
       case value
       when ObjectTable::TableMethods
-        nrows = value.nrows
+        nrows.push(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
+        nrows.push(value._ensure_uniform_columns!)
       else
-        nrows = 1
+        nrows.push( (ObjectTable::Column.length_of(value) rescue 1) )
       end
 
-      keys = names.zip(k.map{|x| [x] * nrows})
+      value = ObjectTable::BasicGrid[value_key, value] unless value.is_a?(ObjectTable::BasicGrid)
+      value
+    end
 
-      grid = case value
-      when ObjectTable::BasicGrid
-        ObjectTable::BasicGrid[keys].merge!(value)
-      else
-        ObjectTable::BasicGrid[keys + [[value_key, value]]]
+    keys = groups.keys.transpose.map{|col| col.zip(nrows).flat_map{|key, rows| [key] * rows}}
+    keys = ObjectTable::BasicGrid[names.zip(keys)]
+
+    result = __table_cls__.stack(*data)
+    __table_cls__.new(keys.merge!(result.columns))
+  end
+
+
+  def _make_groups(names, groups)
+    key_struct = Struct.new(*names.map(&:to_sym))
+    enumerator = Enumerator.new do |y|
+      groups.each do |k, v|
+        y.yield __group_cls__.new(@parent, key_struct.new(*k), v)
       end
+      @parent
     end
-
-    __table_cls__.stack(*data)
   end
 
   def self._generate_name(prefix, existing_names)

data/lib/object_table/masked_column.rb

@@ -1,41 +1,31 @@
 require_relative 'column'
 
 class ObjectTable::MaskedColumn < NArray
-  attr_accessor :indices, :parent, :padded_dims
+  attr_accessor :indices, :parent
 
   EMPTY = NArray[]
 
   def self.mask(parent, indices)
-    if parent.rank > 1
-      padded_dims = [nil] * (parent.rank - 1)
+    if parent.empty?
+      masked = parent.slice(indices)
     else
-      padded_dims = []
+      masked = parent.slice(false, indices)
     end
-    masked = parent.slice(*padded_dims, indices)
 
     if masked.rank <= 0
       column = self.new(masked.typecode, 0)
     else
-      column = self.new(masked.typecode, *masked.shape)
-      column.super_slice_assign(masked)
+      column = self.cast(masked)
     end
 
     column.parent = parent
     column.indices = indices
-    column.padded_dims = padded_dims
     column
   end
 
-# let ObjectTable::Column do this, since we've overriden []=
-  def self.make(*args)
-    ObjectTable::Column.make(*args)
-  end
-
-  alias_method :super_slice_assign, :[]=
-
   def []=(*keys, value)
     unless parent.nil? or ((value.is_a?(Array) or value.is_a?(NArray)) and value.empty?)
-      parent[*padded_dims, indices[*keys]] = value
+      parent[false, indices[*keys]] = value
     end
     super
   end
@@ -44,7 +34,7 @@ class ObjectTable::MaskedColumn < NArray
   %w{ fill! indgen! indgen random! map! collect! conj! imag= mod! add! div! sbt! mul! }.each do |op|
     define_method(op) do |*args, &block|
       result = super(*args, &block)
-      parent[*padded_dims, indices] = result if parent
+      parent[false, indices] = result if parent
       result
     end
   end

data/lib/object_table/printable.rb

@@ -1,23 +1,38 @@
 module ObjectTable::Printable
 
-  def self.get_printable_column(name, column)
-    padding = [nil] * (column.rank - 1)
-    rows = column.shape[-1].times.map do |i|
-      row = column[*padding, i]
+  def self.get_printable_column(column)
+    column.shape[-1].times.map do |i|
+      row = column[false, i]
       str = row.is_a?(NArray) ? row.inspect.partition("\n")[-1].strip : row.inspect
       str.split("\n")
     end
+  end
 
-    name = name.to_s
-    [[name]] + rows + [[name]]
+  def self.calc_column_widths(columns)
+    columns.map{|col| col.flatten.map(&:length).max}
   end
 
-  def self.get_printable_line_numbers(numbers)
-    rows = numbers.map do |i|
-      ["#{i}: "]
+  def _format_section(row_slice)
+    numbers = row_slice.map{|i| ["#{i}: "]}
+    section = columns.map do |name, c|
+      c = c.slice(false, row_slice)
+      ObjectTable::Printable.get_printable_column(c)
     end
 
-    [['']] + rows + [['']]
+    [numbers] + section
+  end
+
+  def _format_rows(rows, widths)
+    rows.flat_map do |row|
+      height = row.map(&:length).max
+
+      row = row.zip(widths).map do |cell, width|
+        cell += [" "] * (height - cell.length)
+        cell.map{|i| i.rjust(width)}
+      end
+
+      row.transpose.map(&:join)
+    end
   end
 
   def inspect(max_section = 5, col_padding = 2)
@@ -26,47 +41,32 @@ module ObjectTable::Printable
     return (header + "(empty table)") if ncols == 0
     return (header + "(empty table with columns: #{colnames.join(", ")})") if nrows == 0
 
-    printed_columns = []
+    column_headers = [''] + colnames.map(&:to_s)
 
     if nrows > max_section * 2
-      head = (0...max_section)
-      tail = ((nrows - max_section)...nrows)
+      head = _format_section(0 ... max_section)
+      tail = _format_section((nrows - max_section) ... nrows)
 
-      printed_columns.push ObjectTable::Printable.get_printable_line_numbers(head.to_a + tail.to_a)
+      columns = [column_headers, head, tail].transpose
+      widths = NArray.to_na(ObjectTable::Printable.calc_column_widths(columns)) + col_padding
+      total_width = widths.sum
+
+      rows = _format_rows(head.transpose, widths)
+      rows.push('-' * total_width)
+      rows += _format_rows(tail.transpose, widths)
 
-      printed_columns += columns.map do |name, c|
-        padding = [nil] * (c.rank - 1)
-        c = c.slice(*padding, [head, tail])
-        ObjectTable::Printable.get_printable_column(name, c)
-      end
     else
-      max_section = -1
-      printed_columns.push ObjectTable::Printable.get_printable_line_numbers(0...nrows)
-      printed_columns += columns.map do |name, c|
-        ObjectTable::Printable.get_printable_column(name, c)
-      end
+      section = _format_section(0...nrows)
+      columns = [column_headers, section].transpose
+      widths = NArray.to_na(ObjectTable::Printable.calc_column_widths(columns)) + col_padding
+      rows = _format_rows(section.transpose, widths)
     end
 
-    widths = printed_columns.map{|row| row.flat_map{|c| c.map(&:length)}.max + col_padding}
-
-    header + printed_columns.transpose.each_with_index.map do |row, index|
-      height = row.map(&:length).max
-
-      row = row.zip(widths).map do |cell, width|
-        cell += [" "] * (height - cell.length)
-        cell.map{|i| i.rjust(width)}
-      end
-
-      row = row.transpose.map{|i| i.join('')}.join("\n")
-
-      if index == max_section
-        row += "\n" + '-'*widths.reduce(:+)
-      end
-      row
-    end.join("\n")
+    column_headers = _format_rows([[column_headers].transpose], widths).join
+    header + ([column_headers] + rows + [column_headers]).join("\n")
 
   rescue NoMethodError => e
     raise Exception.new(e)
   end
 
-end
+end

data/lib/object_table/stacker.rb

@@ -0,0 +1,63 @@
+module ObjectTable::Stacker
+
+  def stack!(*others)
+    @columns.replace( self.class.stack(self, *others).columns )
+    self
+  end
+
+  module ClassMethods
+    def stack(*grids)
+      keys = nil
+
+      grids = grids.map do |grid|
+        grid = _process_stackable_grid(grid, keys)
+        keys ||= grid.keys if grid
+        grid
+      end.compact
+      return self.new if grids.empty?
+
+      result = keys.map do |k|
+        segments = grids.map{|grid| grid[k]}
+        [k, _stack_segments(segments)]
+      end
+
+      self.new(ObjectTable::BasicGrid[result])
+    end
+
+    def _stack_segments(segments)
+      if segments.all?{|seg| seg.is_a? Array}
+        column = NArray.to_na(segments.flatten(1))
+
+      elsif segments.all?{|seg| seg.is_a? NArray} and segments.map{|seg| seg.shape}.uniq.length == 1
+        column = NArray.to_na(segments)
+        column = column.reshape(*column.shape[0...-2], column.shape[-2] * column.shape[-1])
+
+      else
+        segments.map!{|seg| NArray.to_na seg}
+        column = ObjectTable::Column.stack(*segments)
+
+      end
+    end
+
+    def _process_stackable_grid(grid, keys)
+      case grid
+      when ObjectTable::TableMethods
+        grid = grid.columns
+      when ObjectTable::BasicGrid
+        grid._ensure_uniform_columns!
+      end
+
+      raise "Don't know how to join a #{grid.class}" unless grid.is_a?(ObjectTable::BasicGrid)
+      return if grid.empty?
+      raise 'Mismatch in column names' unless !keys or ( (keys - grid.keys).empty? and (grid.keys - keys).empty? )
+      return grid
+    end
+
+  end
+
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+end

data/lib/object_table/table_methods.rb

@@ -35,29 +35,30 @@ module ObjectTable::TableMethods
 
   def set_column(name, value, *args)
     column = get_column(name)
+    new_column = column.nil?
+
     value = value.to_a if value.is_a?(Range)
+    is_vector = (value.is_a?(Array) or value.is_a?(NArray))
 
-    if column
-      return value if column.empty? and value.empty?
-      return (column[] = value)
-    end
+    if new_column
+      if is_vector and args.empty?
+        value =  NArray.to_na(value)
+        unless (value.shape[-1] or 0) == nrows
+          raise ArgumentError.new("Expected size of last dimension to be #{nrows}, was #{value.shape[-1].inspect}")
+        end
 
-    if (value.is_a?(Array) or value.is_a?(NArray)) and args.empty?
-      value =  NArray.to_na(value)
-      unless (value.shape[-1] or 0) == nrows
-        raise ArgumentError.new("Expected size of last dimension to be #{nrows}, was #{value.shape[-1].inspect}")
+        args = [value.typecode] + value.shape[0...-1]
       end
 
-      args = [value.typecode] + value.shape[0...-1]
+      column = add_column(name, *args)
     end
 
-    column = add_column(name, *args)
-    return column if value.is_a?(NArray) and value.empty?
+    return column if column.empty? and (!is_vector or value.empty?)
 
     begin
       column[] = value
     rescue Exception => e
-      pop_column(name)
+      pop_column(name) if new_column
       raise e
     end
   end
@@ -100,7 +101,7 @@ module ObjectTable::TableMethods
     get_column(meth) or super
   end
 
-  def respond_to?(meth)
+  def respond_to?(meth, include_all = false)
     super or has_column?(meth)
   end
 

data/lib/object_table/version.rb

@@ -1,3 +1,3 @@
 class ObjectTable
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

data/lib/object_table/view.rb

@@ -14,14 +14,13 @@ class ObjectTable::View
     @filter = block
   end
 
-  def_delegators :@parent, :has_column?
-
   def make_view
     __static_view_cls__.new @parent, indices
   end
 
   def clone
-    __table_cls__.new(columns)
+    cols = ObjectTable::BasicGrid[@parent.columns.map{|k, v| [k, v[false, indices]]}]
+    __table_cls__.new(cols)
   end
 
   def inspect(*args)

data/lib/object_table/view_methods.rb

@@ -7,6 +7,8 @@ module ObjectTable::ViewMethods
   include ObjectTable::TableMethods
   include ObjectTable::TableChild
 
+  def_delegators :@parent, :has_column?
+
   def nrows
     indices.length
   end

data/lib/object_table.rb

@@ -5,9 +5,11 @@ require_relative "object_table/view"
 require_relative "object_table/static_view"
 require_relative "object_table/column"
 require_relative "object_table/grouped"
+require_relative "object_table/stacker"
 
 class ObjectTable
   include TableMethods
+  include Stacker
 
   attr_reader :columns
 
@@ -30,51 +32,6 @@ class ObjectTable
     columns[name] = col
   end
 
-  def stack!(*others)
-    new_values = Hash[colnames.zip(ncols.times.map{[]})]
-
-    others.each do |x|
-      case x
-      when ObjectTable::TableMethods
-        x = x.columns
-      when ObjectTable::BasicGrid
-        x._ensure_uniform_columns!
-      end
-
-      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).empty?
-
-      x.each do |k, 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.values.first.empty?
-
-    new_values.each do |k, v|
-      @columns[k] = ObjectTable::Column.stack(@columns[k], *v)
-    end
-    self
-  end
-
-  def self.stack(*values)
-    return self.new if values.empty?
-    base = values.shift
-
-    case base
-    when ObjectTable::BasicGrid
-      base = self.new(base.clone)
-    when ObjectTable, ObjectTable::View
-      base = base.clone
-    else
-      raise "Don't know how to join a #{base.class}"
-    end
-    base.stack!(*values)
-  end
-
   def sort_by!(*keys)
     sort_index = _get_sort_index(keys)
 
@@ -84,73 +41,6 @@ class ObjectTable
     self
   end
 
-  def join(other, key, options={})
-    type = (options[:type] || 'inner')
-    key = [key] unless key.is_a?(Array)
-
-    right_cols = other.colnames - key
-    left_cols = colnames
-
-    lkeys = key.map{|k| get_column(k).to_a}.transpose
-    rkeys = key.map{|k| other[k].to_a}.transpose
-
-    rgroups = rkeys.length.times.group_by{|i| rkeys[i]}
-    rindex = rgroups.values_at(*lkeys)
-
-    if type == 'left' or type == 'outer'
-      common, lmissing = rindex.each_with_index.partition(&:first)
-      lmissing = lmissing.transpose[-1]
-      lindex = common.flat_map{|r, i| [i] * r.length}
-      rindex.flatten!.compact!
-
-      lindex += lmissing
-      rindex += [-1] * lmissing.length
-    else
-      lindex = rindex.each_with_index.flat_map{|r, i| [i] * r.length if r}.compact
-      rindex.flatten!.compact!
-    end
-
-
-    if type == 'right' or type == 'outer'
-      left_cols -= key
-      rmissing = (0...other.nrows).to_a - rindex
-      lindex += [-1] * rmissing.length
-      rindex += rmissing
-    end
-
-    lindex = NArray.to_na(lindex)
-    rindex = NArray.to_na(rindex)
-    lblank = lindex.eq(-1)
-    rblank = rindex.eq(-1)
-
-    data = [
-      [left_cols, lindex, lblank, self],
-      [right_cols, rindex, rblank, other],
-    ].flat_map do |cols, index, blanks, table|
-      cols.map do |k|
-        col = table.get_column(k)
-        padding = [nil] * (col.rank - 1)
-        col = col[*padding, index]
-        col[*padding, blanks] = [nil]
-        [k, col]
-      end
-    end
-
-    keys = []
-    if type == 'right' or type == 'outer'
-      keys = key.map do |k|
-        col = get_column(k)
-        padding = [nil] * (col.rank - 1)
-        col = col[*padding, lindex]
-        col[*padding, lblank] = other[k][*padding, rmissing]
-        [k, col]
-      end
-    end
-
-    self.class.new(keys + data)
-  end
-
-
   def __static_view_cls__
     self.class::StaticView
   end

data/object_table.gemspec

@@ -23,5 +23,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency 'rspec', "~> 3.1"
+  spec.add_development_dependency 'coveralls', ">= 0.7"
 end