object_table 0.3.4 → 0.4.0

data/lib/object_table/joining.rb

@@ -0,0 +1,71 @@
+require_relative 'util'
+
+class ObjectTable
+  module Joining
+
+    def join(*args)
+      __table_cls__.join(self, *args)
+    end
+
+    module ClassMethods
+
+      # -1 in an index indicates a missing value
+      def join(left, right, *keys, type: 'inner')
+        incl_left = incl_right = false
+        case type
+        when 'left' then incl_left = true
+        when 'right' then incl_right = true
+        when 'outer' then incl_left = incl_right = true
+        when 'inner'
+        else raise "Expected one of (inner, left, outer, right), got #{type.inspect}"
+        end
+
+        lkeys = Util.get_rows(left, keys)
+        rkeys = Util.get_rows(right, keys)
+
+        rgroups = Util.group_indices(rkeys)
+        rgroups.default = (incl_left ? [-1] : []) # keep left missing values if incl_left
+
+        lindex = rgroups.values_at(*lkeys)
+        rindex = lindex.flatten
+        lindex = lindex.each_with_index.flat_map{|r, i| r.fill(i)}
+
+        if incl_right
+          # rindex may have missing values
+          # so add a dud value at the end ...
+          missing = NArray.int(right.nrows + 1).fill!(1)
+          missing[rindex] = 0
+          missing[-1] = 0 # ... that we always exclude
+          missing = missing.where
+          rindex.concat( missing.to_a )
+          lindex.concat( Array.new(missing.length, -1) )
+        end
+
+        index = [lindex, rindex].map{|ix| NArray.to_na(ix)}
+        blanks = index.map{|ix| ix.eq(-1).where}
+
+        colnames = [left.colnames, right.colnames - left.colnames]
+        data = [left, right].zip(index, blanks).zip(colnames).flat_map do |args, cols|
+          cols.map{|k| [k, Joining.copy_column(k, *args)] }
+        end
+
+        table = __table_cls__.new(data)
+        if incl_right
+          keys.each do |k|
+            table[k][false, blanks[0]] = right[k][false, missing]
+          end
+        end
+
+        table
+      end
+    end
+
+    def self.copy_column(name, table, slice, blanks)
+      column = table[name][false, slice]
+      column[false, blanks] = [nil]
+      column
+    end
+
+  end
+
+end

data/lib/object_table/masked_column.rb

@@ -13,9 +13,9 @@ class ObjectTable::MaskedColumn < NArray
     end
 
     if masked.rank <= 0
-      column = self.new(masked.typecode, 0)
+      column = new(masked.typecode, 0)
     else
-      column = self.cast(masked)
+      column = cast(masked)
     end
 
     column.parent = parent

data/lib/object_table/printing.rb

@@ -0,0 +1,69 @@
+class ObjectTable
+  module Printing
+
+    def inspect(max_section=5, col_padding=2)
+      header = "#{self.class}(#{nrows}, #{ncols})\n"
+
+      return "#{header}(empty table)" if ncols == 0
+      return "#{header}(empty table with columns: #{colnames.join(", ")})" if nrows == 0
+
+      separated = (nrows > max_section * 2)
+      max_section = (nrows / 2.0) unless separated
+
+      head = Printing.format_section(columns, 0...max_section.to_i).transpose[0...-1]
+      tail = Printing.format_section(columns, (nrows - max_section).to_i...nrows).transpose[1..-1]
+      widths = Printing.calc_column_widths(head + tail, col_padding)
+
+      rows = Printing.format_rows(head, widths)
+      rows.push('-' * widths.reduce(:+)) if separated
+      rows.concat Printing.format_rows(tail, widths)
+
+      header + rows.join("\n")
+
+    rescue NoMethodError => e
+      raise Exception.new(e)
+    end
+
+
+    def self.format_column(column)
+      return column.to_a.map(&:inspect) if column.rank < 2
+      column.shape[-1].times.map do |i|
+        row = column[false, i]
+        row.inspect.partition("\n")[-1].strip
+      end
+    end
+
+    def self.split_column_lines(name, column)
+      [name, *column, name].map{|i| i.split("\n")}
+    end
+
+    def self.calc_column_widths(rows, padding)
+      columns = rows.transpose
+      columns.map{|col| col.flatten.map(&:length).max + padding}
+    end
+
+    def self.format_rows(rows, widths)
+      rows = rows.flat_map do |row|
+        height = row.map(&:length).max
+        row.map{|cell| cell.fill('', cell.length...height)}.transpose
+      end
+
+      format = widths.to_a.map{|w| "%#{w}s"}.join
+      rows.map{|row| format % row }
+    end
+
+    def self.format_section(columns, row_slice)
+      row_slice = row_slice.to_a
+      numbers = split_column_lines('', row_slice.map{|i| "#{i}: "})
+
+      section = columns.map do |name, c|
+        c = (row_slice.empty? ? NArray[] : c.slice(false, row_slice))
+        c = format_column(c)
+        c = split_column_lines(name.to_s, c)
+      end
+
+      [numbers] + section
+    end
+
+  end
+end

data/lib/object_table/stacking.rb

@@ -0,0 +1,66 @@
+class ObjectTable
+  module Stacking
+
+    def stack(*others)
+      __table_cls__.stack(self, *others)
+    end
+
+    module InPlace
+      def stack!(*others)
+        @columns.replace( __table_cls__.stack(self, *others).columns )
+        self
+      end
+    end
+
+    module ClassMethods
+      def stack(*grids); _stack(grids); end
+
+      def _stack(grids)
+        keys = nil
+
+        grids = grids.map do |grid|
+          grid = Stacking.process_stackable_grid(grid, keys)
+          keys ||= grid.keys if grid
+          grid
+        end.compact
+        return __table_cls__.new if grids.empty?
+
+        result = keys.map do |k|
+          segments = grids.map{|grid| grid[k]}
+          [k, Stacking.stack_segments(segments)]
+        end
+
+        __table_cls__.new(BasicGrid[result])
+      end
+
+    end
+
+
+    def self.stack_segments(segments)
+      if segments.all?{|seg| seg.is_a? Array}
+        column = NArray.to_na(segments.flatten(1))
+
+      else
+        segments.map!{|seg| NArray.to_na seg}
+        column = Column._stack(segments)
+
+      end
+    end
+
+    def self.process_stackable_grid(grid, keys)
+      case grid
+      when TableMethods
+        grid = grid.columns
+      when BasicGrid
+        grid._ensure_uniform_columns!
+      end
+
+      raise "Don't know how to join a #{grid.class}" unless grid.is_a?(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
+
+end

data/lib/object_table/static_view.rb

@@ -16,17 +16,14 @@ class ObjectTable::StaticView
 
   def columns
     unless @fully_cached
-      @parent.columns.map{|k, v| get_column(k)}
+      @parent.columns.each_key{|k| 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
+    @columns[name] ||= super
   end
 
   def add_column(name, *args)

data/lib/object_table/table_methods.rb

@@ -1,9 +1,17 @@
 require 'forwardable'
-require_relative 'printable'
+
+require_relative 'printing'
+require_relative 'util'
+require_relative "joining"
+require_relative "stacking"
 
 module ObjectTable::TableMethods
-  include ObjectTable::Printable
+  include ObjectTable::Printing
+  include ObjectTable::Joining
+  include ObjectTable::Stacking
+
   extend Forwardable
+  Util = ObjectTable::Util
 
   attr_reader :R
   def initialize
@@ -16,20 +24,17 @@ module ObjectTable::TableMethods
   end
   alias_method :eql?, :==
 
-  def colnames
-    columns.keys
-  end
-
   def nrows
-    columns.empty? ? 0 : (columns.values.first.shape[-1] or 0)
+    columns.empty? ? 0 : ObjectTable::Column.length_of(columns.first[1])
   end
 
   def ncols
     columns.keys.length
   end
 
+  def_delegator :columns, :keys, :colnames
   def_delegator :columns, :include?, :has_column?
-
+  def_delegator :columns, :delete, :pop_column
   def_delegator :columns, :[], :get_column
   alias_method :[], :get_column
 
@@ -64,31 +69,19 @@ module ObjectTable::TableMethods
   end
   alias_method :[]=, :set_column
 
-  def pop_column(name)
-    columns.delete name
-  end
 
   def apply(&block)
-    result = _apply_block(&block)
-
+    result = Util.apply_block(self, 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
-  end
-
   def where(&block)
     __view_cls__.new(self, &block)
   end
 
   def group_by(*args, &block)
-    ObjectTable::Grouped.new(self, *args, &block)
+    ObjectTable::Grouping.new(self, *args, &block)
   end
 
   def sort_by(*keys)
@@ -114,4 +107,24 @@ module ObjectTable::TableMethods
     (0...nrows).zip(columns.map(&:to_a).transpose).sort_by(&:last).map(&:first)
   end
 
+  def each_row(*cols, row_factory: Struct)
+    return to_enum(:each_row, *cols, row_factory: row_factory) unless block_given?
+    return if ncols == 0
+
+    cls = nil
+    if cols.empty?
+      cls = row_factory.new(*colnames)
+      cols = colnames
+    end
+
+    columns = cols.map{|c| get_column(c)}
+    nrows.times do |i|
+      row = columns.map{|c| c[false, i]}
+      row = cls.new(*row) if cls
+      yield row
+    end
+  end
+
 end
+
+require_relative "grouping" # put here to avoid circular dependency

data/lib/object_table/util.rb

@@ -0,0 +1,19 @@
+module ObjectTable::Util
+
+  def self.apply_block(object, block)
+    if block.arity == 0
+      object.instance_eval(&block)
+    else
+      block.call(object)
+    end
+  end
+
+  def self.get_rows(table, columns)
+    columns.map{|n| table[n].to_a}.transpose
+  end
+
+  def self.group_indices(keys)
+    keys.length.times.group_by{|i| keys[i]}
+  end
+
+end

data/lib/object_table/version.rb

@@ -1,3 +1,3 @@
 class ObjectTable
-  VERSION = "0.3.4"
+  VERSION = "0.4.0"
 end

data/lib/object_table/view.rb

@@ -1,9 +1,11 @@
 require 'forwardable'
 require_relative 'view_methods'
 require_relative 'masked_column'
+require_relative 'util'
 
 class ObjectTable::View
   include ObjectTable::ViewMethods
+  Util = ObjectTable::Util
 
   extend Forwardable
   def_delegators :make_view, :apply
@@ -34,12 +36,12 @@ class ObjectTable::View
   end
 
   def indices
-    @indices or NArray.int(@parent.nrows).indgen![@parent._apply_block &@filter]
+    @indices or NArray.int(@parent.nrows).indgen![Util.apply_block(@parent, @filter)]
   end
 
-  def cache_indices(&block)
+  def cache_indices
     @indices = indices
-    value = block.call()
+    value = yield
     @indices = nil
     value
   end
@@ -48,9 +50,9 @@ class ObjectTable::View
     @columns or super
   end
 
-  def cache_columns(&block)
+  def cache_columns
     @columns = columns
-    value = block.call()
+    value = yield
     @columns = nil
     value
   end

data/lib/object_table/view_methods.rb

@@ -1,11 +1,12 @@
 require 'forwardable'
+
 require_relative 'table_methods'
-require_relative 'table_child'
+require_relative 'factory'
 
 module ObjectTable::ViewMethods
   extend Forwardable
   include ObjectTable::TableMethods
-  include ObjectTable::TableChild
+  include ObjectTable::Factory::SubFactory
 
   def_delegators :@parent, :has_column?
 

data/lib/object_table.rb

@@ -4,12 +4,17 @@ require_relative "object_table/table_methods"
 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"
+require_relative "object_table/stacking"
+require_relative "object_table/factory"
+require_relative "object_table/joining"
 
 class ObjectTable
   include TableMethods
-  include Stacker
+  include Stacking::InPlace
+  include Factory
+
+  extend Stacking::ClassMethods
+  extend Joining::ClassMethods
 
   attr_reader :columns
 
@@ -41,20 +46,4 @@ class ObjectTable
     self
   end
 
-  def __static_view_cls__
-    self.class::StaticView
-  end
-
-  def __view_cls__
-    self.class::View
-  end
-
-  def __group_cls__
-    self.class::Group
-  end
-
-  def __table_cls__
-    self.class
-  end
-
 end

data/object_table.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 2.0'
+
   spec.add_runtime_dependency 'narray', "~> 0.6.1"
 
   spec.add_development_dependency "bundler", "~> 1.3"

data/spec/object_table/column_spec.rb

@@ -15,8 +15,8 @@ describe ObjectTable::Column 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
+    it 'should return nil on other inputs' do
+      expect(described_class.length_of 123456).to be_nil
     end
   end