tafel 0.1.0 → 0.3.0

data/CHANGELOG.txt

@@ -2,6 +2,11 @@
 = tafel CHANGELOG.txt
 
 
+== tafel 0.3.0  released 2016-05-02
+
+- settle on .flatten, .to_vtable and to_htable
+
+
 == tafel 0.1.0  released 2016-04-10
 
 - initial (empty) release

data/README.md

@@ -1,7 +1,120 @@
 
 # tafel
 
-# license
+[![Build Status](https://secure.travis-ci.org/jmettraux/tafel.svg)](http://travis-ci.org/jmettraux/tafel)
+[![Gem Version](https://badge.fury.io/rb/tafel.svg)](http://badge.fury.io/rb/tafel)
+
+A Ruby library to turn pieces of data into arrays of arrays (tables).
+
+## interface
+
+### Tafel .to_htable .to_h
+
+Turns the argument into a table where keys are arrayed horizontally.
+
+```ruby
+  require 'tafel'
+
+  #
+  # hash of hashes
+
+  Tafel.to_h(
+    {
+      'USD' => { code: 'USD', change: 1.0, min: 500, status: 'active' },
+      'EUR' => { code: 'EUR', change: 1.07, status: 'active' },
+      'CHF' => { code: 'CHF', change: 1.08, min: 700 }
+    }
+  )
+    # ==>
+      [
+        [ :key, :code, :change, :min, :status ],
+        [ 'USD', 'USD', 1.0, 500, 'active' ],
+        [ 'EUR', 'EUR', 1.07, nil, 'active' ],
+        [ 'CHF', 'CHF', 1.08, 700, nil ]
+      ]
+
+  #
+  # array of hashes
+
+  Tafel.to_htable(
+    [
+      { a: 1, b: 2 },
+      { a: 3, b: 4, c: 5 },
+      { a: 6, c: 7 }
+    ]
+  )
+    # ==>
+      [
+        [ :a, :b, :c ],
+        [ 1, 2, nil ],
+        [ 3, 4, 5 ],
+        [ 6, nil, 7 ]
+      ]
+
+  #
+  # plain hash
+
+  Tafel.to_htable(
+    { a: 3, b: 4, c: 5 }
+  )
+    # ==>
+      [
+        [ :a, :b, :c ],
+        [ 3, 4, 5 ]
+      ]
+```
+
+### Tafel .to_vtable .to_v
+
+Turns the argument into a table where keys are arrayed vertically.
+
+It leaves non-array and no-hash instances as is.
+
+```ruby
+  require 'tafel'
+
+  Tafel.to_v(
+    { interpreter: 'Leo Ferre', song: { name: "C'est extra", year: 1969 } }
+  )
+    # ==>
+      [
+        [ :interpret, 'Leo Ferre' ],
+        [ :song, [ [ :name, "C'est extra" ], [ :year, 1969 ] ] ]
+      ]
+```
+
+It accepts a limit integer parameter defaulting to -1 (recurse entirely). For example:
+
+```ruby
+  Tafel.to_v(
+    { interpreter: 'Leo Ferre', song: { name: "C'est extra", year: 1969 } },
+    1
+  )
+    # ==>
+      [
+        [ :interpret, 'Leo Ferre' ],
+        [ :song, { name: "C'est extra", year: 1969 } ]
+      ]
+```
+
+### Tafel.flatten
+
+Turns nested tables into a single table.
+
+```ruby
+  require 'tafel'
+
+  Tafel.flatten(
+    [ [ 0, 1 ],
+      [ 2, [ [ 3, 4 ], [ 5, 6 ] ] ] ]
+  )
+    # -->
+      [ [ 0, 1, nil ],
+        [ 2, 3, 4 ],
+        [ nil, 5, 6 ] ]
+```
+
+## license
 
 MIT, see LICENSE.txt
 

data/lib/tafel.rb

@@ -25,35 +25,158 @@
 
 module Tafel
 
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 
-  def self.turn(data)
+  def self.table?(o)
 
-    data = to_array(data)
+    o.is_a?(Array) && o.all? { |r| r.is_a?(Array) }
+  end
+
+  # .to_vtable: keys are arrayed vertically (y explosion)
+  # .to_htable: keys are arrayed horizontally (x explosion)
+
+  def self.to_vtable(x, limit=-1)
+
+    return x if limit == 0
+
+    case x
+      when Hash then x.to_a.collect { |k, v| [ k, to_vtable(v, limit - 1) ] }
+      when Array then x.collect { |e| [ to_vtable(e) ] }
+      else x
+    end
+  end
+
+  def self.to_htable(x)
+
+    kla0 = narrow_class(x)
+
+    kla1 = nil
+    if kla0
+      vs = x.respond_to?(:values) ? x.values : x
+      kla = narrow_class(vs.first)
+      kla1 = vs.all? { |v| kla ? v.is_a?(kla) : false } ? kla : nil
+    end
+
+#p [ kla0, kla1 ]
+    case [ kla0, kla1 ]
+      when [ Hash, Hash ] then to_h_hash_hash(x)
+      when [ Array, Hash ] then to_h_array_hash(x)
+      when [ Hash, nil ] then to_h_hash(x)
+      else x
+    end
+  end
+
+  class << self
+    alias to_v to_vtable
+    alias to_h to_htable
+  end
+
+  def self.flatten(table)
+
+    fail ArgumentError.new('not a table') unless table?(table)
+
+    flat = true
+
+    table =
+      table.collect { |r|
+        r.collect { |c| next c unless table?(c); flat = false; flatten(c) }
+      }
+
+    return table if flat
+
+    ss = table.collect { |r| r.collect { |c| size(c) } }
+
+    ss.each do |row|
+      maxh = row.collect { |cell| cell[1] }.max
+      maxh = maxh < 1 ? 1 : maxh
+      row.each { |cell| cell[1] = maxh }
+    end
+    ss.collect { |row| row.size }.max.times do |x|
+      maxw = ss.collect { |row| cell = row[x]; cell ? cell[0] : 1 }.max
+      maxw = maxw < 1 ? 1 : maxw
+      ss.each { |row| cell = row[x]; cell[0] = maxw if cell }
+    end
+
+    w = ss.first.collect(&:first).reduce(&:+)
+    h = ss.collect { |row| row[0].last }.reduce(&:+)
+
+    a = Array.new(h) { Array.new(w) }
 
-    if data.all? { |row| row.is_a?(Array) }
-      data
-    elsif data.all? { |row| row.is_a?(Hash) }
-      turn_array_of_hashes(data)
+    iterate(ss) do |x, y, s|
+
+      left = x > 0 ? ss[y][x - 1] : nil
+      above = y > 0 ? ss[y - 1][x] : nil
+
+      woff = left ? left[2] + left[0] : 0
+      hoff = above ? above[3] + above[1] : 0
+
+      s.push(woff, hoff)
+
+      copy(a, woff, hoff, table[y][x])
+    end
+
+    a
+  end
+
+  protected # well...
+
+  def self.size(o)
+
+    table?(o) ? [ o.collect { |r| r.size }.max, o.size ] : [ 0, 0 ]
+  end
+
+  def self.copy(target, woff, hoff, source)
+
+    if table?(source)
+      iterate(source) { |x, y, v| target[hoff + y][woff + x] = v }
     else
-      nil
+      target[hoff][woff] = source
     end
   end
 
-  protected
+  def self.iterate(table)
 
-  def self.to_array(data)
+    table.first.size.times do |x|
+      table.size.times do |y|
+        yield(x, y, table[y][x])
+      end
+    end
+  end
+
+  def self.narrow_class(x)
 
-    data
-    #return data.values if data.is_a?(Hash)
-    #return Array[data]
+    return Array if x.is_a?(Array)
+    return Hash if x.is_a?(Hash)
+    nil
   end
 
-  def self.turn_array_of_hashes(data)
+  def self.to_h_hash_hash(h)
+
+    keys = h.values.inject([ :key ]) { |ks, v| ks.concat(v.keys) }.uniq
+    table = [ keys ]
+
+    h.each do |k, v|
+      table << keys[1..-1].inject([ k ]) { |row, key| row << v[key]; row }
+    end
+
+    table
+  end
 
-    keys = data.inject([]) { |a, row| a.concat(row.keys) }.uniq
+  def self.to_h_hash(h)
+
+    [ h.keys, h.inject([]) { |a, (k, v)| a << v; a } ]
+  end
+
+  def self.to_h_array_hash(a)
+
+    keys = a.inject([]) { |ks, h| ks.concat(h.keys) }.uniq
+    table = [ keys ]
+
+    a.each do |h|
+      table << keys.inject([]) { |row, key| row << h[key]; row }
+    end
 
-    [ keys ] + data.collect { |row| keys.collect { |k| row[k] } }
+    table
   end
 end
 

data/tafel.gemspec

@@ -10,13 +10,13 @@ Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.authors = [ 'John Mettraux' ]
   s.email = [ 'jmettraux@gmail.com' ]
-  s.homepage = 'http://github.com/jmettraux/raabro'
+  s.homepage = 'http://github.com/jmettraux/tafel'
   s.rubyforge_project = 'rufus'
   s.license = 'MIT'
-  s.summary = 'something to turn data into an array of arrays'
+  s.summary = 'something to turn data into arrays of arrays'
 
   s.description = %{
-Something to turn data (JSON) into an array of arrays (CSV)
+Something to turn data into arrays of arrays (suitable for CSV).
   }.strip
 
   #s.files = `git ls-files`.split("\n")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tafel
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-09 00:00:00.000000000 Z
+date: 2016-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -27,7 +27,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.13.0
-description: Something to turn data (JSON) into an array of arrays (CSV)
+description: Something to turn data into arrays of arrays (suitable for CSV).
 email:
 - jmettraux@gmail.com
 executables: []
@@ -40,7 +40,7 @@ files:
 - CHANGELOG.txt
 - LICENSE.txt
 - README.md
-homepage: http://github.com/jmettraux/raabro
+homepage: http://github.com/jmettraux/tafel
 licenses:
 - MIT
 post_install_message: 
@@ -64,5 +64,5 @@ rubyforge_project: rufus
 rubygems_version: 1.8.23.2
 signing_key: 
 specification_version: 3
-summary: something to turn data into an array of arrays
+summary: something to turn data into arrays of arrays
 test_files: []