tablesmith 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b2cd809d21c4144fbb28e472f12e4f77510817d
+  data.tar.gz: 664d3bb41153050b8476ac761e1b4063594c7327
+SHA512:
+  metadata.gz: 9ef5411a7defaefa9dd1246d985a6a063479832836d41a48a1f715aa9922833f049163ccb2e3cf44b5679a1acf212bdfa7bac9c6776eefe6f752de0ecb0367f0
+  data.tar.gz: 972584036fd2a3a4208a4aa82c06e39686c5cab70c9e47b53594d95d52f9120f5da4ff2d6b98f14bd776ee681534062d77c0fc558d76695b1e7184545afdfd0c

data/.gitignore

@@ -0,0 +1,3 @@
+.bundle/
+bin/
+pkg/

data/.rspec

@@ -0,0 +1,2 @@
+--backtrace
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.3.4

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+source "http://geminabox.lsqa.net"
+
+# Specify your gem's dependencies in tablesmith.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    tablesmith (0.1.0)
+      text-table
+
+GEM
+  remote: https://rubygems.org/
+  remote: http://geminabox.lsqa.net/
+  specs:
+    activemodel (3.2.22.5)
+      activesupport (= 3.2.22.5)
+      builder (~> 3.0.0)
+    activerecord (3.2.22.5)
+      activemodel (= 3.2.22.5)
+      activesupport (= 3.2.22.5)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.22.5)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    arel (3.0.3)
+    builder (3.0.4)
+    coderay (1.1.1)
+    diff-lcs (1.3)
+    docile (1.1.5)
+    i18n (0.8.6)
+    json (2.1.0)
+    method_source (0.8.2)
+    multi_json (1.12.1)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.5.0)
+    rspec (2.99.0)
+      rspec-core (~> 2.99.0)
+      rspec-expectations (~> 2.99.0)
+      rspec-mocks (~> 2.99.0)
+    rspec-core (2.99.2)
+    rspec-expectations (2.99.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.99.4)
+    simplecov (0.14.1)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.1)
+    slop (3.6.0)
+    sqlite3 (1.3.13)
+    text-table (1.2.4)
+    tzinfo (0.3.53)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.0)
+  pry
+  rake (~> 10.0)
+  rspec (~> 2.0)
+  simplecov
+  sqlite3
+  tablesmith!
+
+BUNDLED WITH
+   1.15.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012-2015 LivingSocial, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# Tablesmith
+
+Drop-in gem for console tables for Hash, Array and ActiveRecord.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tablesmith'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tablesmith
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Why Not #{other_gem}?
+
+Happy to learn about something else already out there, but have struggled to find something
+that doesn't require some sort of setup. I want drop-in ready-to-go table output for Hashes,
+Arrays and ActiveRecord objects.
+
+Other gems that I've tried out that are awesome and do much more than what Tablesmith does,
+but don't seem to specialize in what I want.
+
+  - Hirb
+  - text-table
+  - table_print
+  - awesome_print

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+FileList['tasks/*.rake'].each { |task| load task }
+
+task :default => :spec
+
+desc 'Run the specs.'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = '*_spec.rb'
+end

data/lib/tablesmith.rb

@@ -0,0 +1,4 @@
+require 'tablesmith/batch'
+require 'tablesmith/active_record_source'
+require 'tablesmith/hash_rows_source'
+require 'tablesmith/version'

data/lib/tablesmith/active_record_source.rb

@@ -0,0 +1,97 @@
+module Tablesmith::ActiveRecordSource
+  def convert_item_to_hash_row(item)
+    # TODO: reload ActiveRecords automagically
+    if item.respond_to? :serializable_hash
+      hash = item.serializable_hash(process_all_columns(serializable_options))
+      hash = fold_un_sourced_attributes_into_source_hash(first.class.name.underscore.to_sym, hash)
+      flatten_inner_hashes(hash)
+    else
+      super
+    end
+  end
+
+  def column_order
+    @columns.map(&:full_unaliased_name)
+  end
+
+  # allows overriding
+  def serializable_options
+    {}
+  end
+
+  # TODO: memoize
+  def process_all_columns(serializable_options)
+    @columns = []
+
+    process_columns(serializable_options, first.class)
+
+    include = serializable_options[:include]
+
+    # swiped from activemodel-3.2.17/lib/active_model/serialization.rb
+    unless include.is_a?(Hash)
+      include = Hash[Array.wrap(include).map { |n| n.is_a?(Hash) ? n.to_a.first : [n, {}] }]
+    end
+
+    include.each do |association, opts|
+      ar_class = first.class.reflections[association].klass
+      process_columns(opts, ar_class)
+    end
+
+    serializable_options
+  end
+
+  def process_columns(serializable_options, ar_class)
+    only = serializable_options[:only]
+    ar_columns = ar_class.columns.map { |c| Tablesmith::Column.new(name: c.name.to_s, source: ar_class.name.underscore) }
+    @columns += ar_columns
+    de_alias_columns(only, ar_columns) if only
+    @columns += (serializable_options[:methods] || []).map do |meth_sym|
+      Tablesmith::Column.new(name: meth_sym.to_s, source: ar_class.name.underscore)
+    end
+  end
+
+  def de_alias_columns(only, ar_columns)
+    only.map! do |attr|
+      hits = ar_columns.select { |c| c.name =~ /#{attr.to_s.gsub(/_/, '.*')}/ }
+      if hits.present?
+        hit = hits[0] # TODO: support multiple hits
+        if attr != hit
+          hit.alias = attr
+          hit.name
+        else
+          attr
+        end
+      else
+        attr
+      end
+    end
+  end
+
+  def flatten_inner_hashes(hash)
+    new_hash = {}
+    stack = hash.each_pair.to_a
+    while ary = stack.shift
+      key, value = ary
+      if value.is_a?(Hash)
+        value.each_pair do |assoc_key, assoc_value|
+          new_hash["#{key}.#{assoc_key}"] = assoc_value.to_s
+        end
+      else
+        new_hash[key] = value
+      end
+    end
+    new_hash
+  end
+
+  # Top-level attributes aren't nested in their own hash by default, this
+  # normalizes the overall hash by grouping those together:
+  #
+  # converts {"name"=>"supplier",               "account"=>{"name"=>'account'}}
+  #     into {"supplier"=>{"name"=>'supplier'}, "account"=>{"name"=>'account'}}
+  def fold_un_sourced_attributes_into_source_hash(source_sym, hash)
+    new_hash = {}
+    new_hash[source_sym] = hash
+    hash.delete_if { |k, v| new_hash[k] = v if v.is_a?(Hash) }
+    new_hash
+  end
+end

data/lib/tablesmith/batch.rb

@@ -0,0 +1,145 @@
+require 'text-table'
+
+module Tablesmith
+  class Batch < Array
+    def method_missing(meth_id, *args)
+      count = 1
+      self.map do |t|
+        $stderr.print '.' if count.divmod(100)[1] == 0
+        count += 1
+        t.send(meth_id, *args)
+      end
+    end
+
+    # irb
+    def inspect
+      pretty_inspect
+    end
+
+    # Pry 0.9 calls this
+    def pretty_inspect
+      text_table.to_s
+    end
+
+    # Pry 0.10 eventually uses PP, and this is the PP way to provide custom output
+    def pretty_print(pp)
+      pp.text pretty_inspect
+    end
+
+    def text_table
+      return ['(empty)'].to_text_table if self.empty?
+
+      rows = self.map { |item| convert_item_to_hash_row(item) }.compact
+
+      normalize_keys(rows)
+
+      rows.map! do |row|
+        # this sort gives preference to column_order then falls back to alphabetic for leftovers.
+        # this is handy when columns auto-generate based on hash data.
+        row.sort do |a, b|
+          a_col_name, b_col_name = [a.first, b.first]
+          a_col_index, b_col_index = [column_order.index(a_col_name), column_order.index(b_col_name)]
+
+          if a_col_index.nil? && b_col_index.nil?
+            a_col_name <=> b_col_name
+          else
+            (a_col_index || 999) <=> (b_col_index || 999)
+          end
+        end
+      end
+
+      rows = create_headers(rows) + (rows.map { |r| r.map(&:last) })
+      rows.to_text_table
+    end
+
+    # override in subclass or mixin
+    def convert_item_to_hash_row(item)
+      item
+    end
+
+    # override in subclass or mixin
+    def column_order
+      []
+    end
+
+
+    # TODO: resolve with column_order
+    def columns
+      @columns
+    end
+
+    def create_headers(rows)
+      column_names = rows.first.map(&:first)
+      grouped_headers(column_names) + [apply_column_aliases(column_names), :separator]
+    end
+
+    def grouped_headers(column_names)
+      groups = Hash.new { |h, k| h[k] = 0 }
+      column_names.map! do |name|
+        group, col = name.to_s.split(/\./)
+        col, group = [group, ''] if col.nil?
+        groups[group] += 1
+        col
+      end
+      if groups.keys.length == 1 # TODO: add option to show group header row when only one exists
+        []
+      else
+        row = []
+        # this relies on Ruby versions where hash retains add order
+        groups.each_pair do |name, span|
+          row << {value: name, align: :center, colspan: span}
+        end
+        [row, :separator]
+      end
+    end
+
+    def apply_column_aliases(column_names)
+      column_names.map do |name|
+        instance = columns.detect { |ca| ca.name.to_s == name.to_s }
+        value = instance ? instance.display_name : name
+        {:value => value, :align => :center}
+      end
+    end
+
+    # not all resulting rows will have data in all columns, so make sure all rows pad out missing columns
+    def normalize_keys(rows)
+      all_keys = rows.map { |hash_row| hash_row.keys }.flatten.uniq
+      rows.map { |hash_row| all_keys.each { |key| hash_row[key] ||= '' } }
+    end
+  end
+
+  class Column
+    attr_accessor :source, :name, :alias
+
+    def initialize(attributes={})
+      @source = attributes.delete(:source)
+      @name = attributes.delete(:name)
+      @alias = attributes.delete(:alias)
+    end
+
+    def display_name
+      "#{@alias || @name}"
+    end
+
+    def full_unaliased_name
+      "#{@source ? "#{@source}." : ''}#{@name}"
+    end
+  end
+end
+
+class Array
+  def to_batch
+    b = Tablesmith::Batch.new(self)
+
+    if b.first && b.first.is_a?(ActiveRecord::Base)
+      b.extend Tablesmith::ActiveRecordSource
+    end
+
+    if b.first && b.first.is_a?(Hash)
+      b.extend Tablesmith::HashRowsSource
+    end
+
+    b
+  end
+end
+

data/lib/tablesmith/hash_rows_source.rb

@@ -0,0 +1,63 @@
+module Tablesmith::HashRowsSource
+  def text_table
+    build_columns if columns.nil?
+    super
+  end
+
+  def convert_item_to_hash_row(item)
+    flatten_hash_to_row(item, columns)
+  end
+
+  def flatten_hash_to_row(deep_hash, columns)
+    row = ActiveSupport::OrderedHash.new
+    columns.each do |col_or_hash|
+      value_from_hash(row, deep_hash, col_or_hash)
+    end
+    row
+  end
+
+  # TODO: no support for deep
+  def build_columns
+    @columns ||= []
+    self.map do |hash_row|
+      @columns << hash_row.keys.map { |k| Tablesmith::Column.new(name: k) }
+    end 
+    @columns.flatten!
+  end
+
+  def value_from_hash(row, deep_hash, col_or_hash)
+    case col_or_hash
+    when Tablesmith::Column
+      row[col_or_hash.display_name] = deep_hash[col_or_hash.name]
+    when Hash
+      col_or_hash.each_pair do |sub_hash_key, cols_or_hash|
+        [cols_or_hash].flatten.each do |inner_col_or_hash|
+          value_from_hash(row, deep_hash[sub_hash_key], inner_col_or_hash)
+        end
+      end
+    else
+      nil
+    end
+  rescue => e
+    $stderr.puts "#{e.message}: #{col_or_hash}" if @debug
+  end
+
+  def hash_rows_to_text_table(hash_rows)
+    require 'text-table'
+
+    header_row = hash_rows.first.keys
+    table = []
+    table << header_row
+
+    hash_rows.each do |hash_row|
+      row = []
+      header_row.each do |header|
+        row << hash_row[header]
+      end
+      table << row
+    end
+
+    # Array addition from text-table
+    table.to_table(:first_row_is_head => true)
+  end
+end

data/lib/tablesmith/version.rb

@@ -0,0 +1,3 @@
+module Tablesmith
+  VERSION = '0.1.0'
+end

data/spec/active_record_batch_spec.rb

@@ -0,0 +1,330 @@
+require 'spec_helper'
+
+describe 'ActiveRecordSource' do
+  it 'outputs text table of multiple ActiveRecords' do
+    a = Person.new.tap { |c| c.first_name = 'A' }
+    b = Person.new.tap { |c| c.first_name = 'B' }
+    expected = <<-TABLE
++----+------------+-----------+-----+-------------------+
+| id | first_name | last_name | age | custom_attributes |
++----+------------+-----------+-----+-------------------+
+|    | A          |           |     |                   |
+|    | B          |           |     |                   |
++----+------------+-----------+-----+-------------------+
+    TABLE
+    [a, b].to_batch.text_table.to_s.should == expected
+  end
+
+  it 'outputs ActiveRecord in column order' do
+    p = Person.create(:first_name => 'chris', :last_name => 'mo', :age => 43)
+    expected = <<-TABLE
++----+------------+-----------+-----+-------------------+
+| id | first_name | last_name | age | custom_attributes |
++----+------------+-----------+-----+-------------------+
+| 1  | chris      | mo        | 43  |                   |
++----+------------+-----------+-----+-------------------+
+    TABLE
+    [p].to_batch.text_table.to_s.should == expected
+  end
+
+  it 'handles custom serialization options in batch' do
+    p = Person.create(:first_name => 'chrismo', :age => 43)
+
+    expected = <<-TABLE
++------------+-----+-----------+
+| first_name | age | year_born |
++------------+-----+-----------+
+| chrismo    | 43  | 1971      |
++------------+-----+-----------+
+    TABLE
+    b = [p].to_batch
+
+    def b.serializable_options
+      {:only => [:first_name, :age], :methods => [:year_born]}
+    end
+
+    b.text_table.to_s.should == expected
+  end
+
+  it 'handles column name partials' do
+    p = Person.create(:first_name => 'chris', :last_name => 'mo', :age => 43)
+    expected = <<-TABLE
++-------+------+-----+
+| first | last | age |
++-------+------+-----+
+| chris | mo   | 43  |
++-------+------+-----+
+    TABLE
+    b = [p].to_batch
+
+    def b.serializable_options
+      {:only => [:first, :last, :age]}
+    end
+
+    b.text_table.to_s.should == expected
+  end
+
+  it 'handles column name partials across words' do
+    p = Person.create(:first_name => 'chris', :last_name => 'mo', :age => 43)
+    expected = <<-TABLE
++--------+--------+-----+
+| f_name | l_name | age |
++--------+--------+-----+
+| chris  | mo     | 43  |
++--------+--------+-----+
+    TABLE
+    b = [p].to_batch
+
+    def b.serializable_options
+      {:only => [:f_name, :l_name, :age]}
+    end
+
+    b.text_table.to_s.should == expected
+  end
+
+  it 'handles explicit column aliases' do
+    p = Person.create(:first_name => 'chris', :last_name => 'mo', :age => 43)
+    expected = <<-TABLE
++---------------+----------+-----+
+| primer_nombre | apellido | age |
++---------------+----------+-----+
+| chris         | mo       | 43  |
++---------------+----------+-----+
+    TABLE
+    b = [p].to_batch
+
+    def b.columns
+      [Tablesmith::Column.new(name: :first_name, alias: :primer_nombre),
+       Tablesmith::Column.new(name: :last_name, alias: :apellido)]
+    end
+
+    def b.serializable_options
+      {:only => [:first_name, :last_name, :age]}
+    end
+
+    b.text_table.to_s.should == expected
+  end
+
+  it 'handles associations without aliases' do
+    s = Supplier.create(name: 'supplier')
+    s.account = Account.create(name: 'account', tax_identification_number: '123456')
+    b = [s].to_batch
+
+    def b.serializable_options
+      {:only => [:name], :include => {:account => {:only => [:name, :tax_identification_number]}}}
+    end
+
+    expected = <<-TABLE
++----------+---------+---------------------------+
+| supplier |               account               |
++----------+---------+---------------------------+
+|   name   |  name   | tax_identification_number |
++----------+---------+---------------------------+
+| supplier | account | 123456                    |
++----------+---------+---------------------------+
+    TABLE
+
+    b.text_table.to_s.should == expected
+  end
+
+  it 'handles associations with aliases' do
+    s = Supplier.create(name: 'supplier')
+    s.account = Account.create(name: 'account', tax_identification_number: '123456')
+    b = [s].to_batch
+
+    def b.serializable_options
+      {:only => [:name], :include => {:account => {:only => [:name, :tax_id]}}}
+    end
+
+    expected = <<-TABLE
++----------+---------+--------+
+| supplier |     account      |
++----------+---------+--------+
+|   name   |  name   | tax_id |
++----------+---------+--------+
+| supplier | account | 123456 |
++----------+---------+--------+
+    TABLE
+
+    b.text_table.to_s.should == expected
+  end
+
+  it 'retains serializable_options ordering'
+
+  it 'supports multiple associations'
+
+  it 'supports nested associations'
+
+  # may need/want to handle the hash resulting from an association differently from the hash resulting from a method/attr
+  it 'supports field with hash contents' do
+    p = Person.create(first_name: 'chrismo', custom_attributes: {skills: {instrument: 'piano', style: 'jazz'}})
+    b = [p].to_batch
+
+    a = format_ids([p.id])[0]
+    expected = <<-TABLE
++----+------------+-----------+-----+----------------------------------------+
+|              person               |           custom_attributes            |
++----+------------+-----------+-----+----------------------------------------+
+| id | first_name | last_name | age |                 skills                 |
++----+------------+-----------+-----+----------------------------------------+
+|#{a}| chrismo    |           |     | {:instrument=>"piano", :style=>"jazz"} |
++----+------------+-----------+-----+----------------------------------------+
+    TABLE
+
+    b.text_table.to_s.should == expected
+  end
+
+  it 'supports multiple rows with different column counts' do
+    p2 = Person.create(first_name: 'romer', custom_attributes: {instrument: 'kazoo'})
+    p1 = Person.create(first_name: 'chrismo', custom_attributes: {instrument: 'piano', style: 'jazz'})
+    p3 = Person.create(first_name: 'glv', custom_attributes: {})
+    batch = [p2, p1, p3].to_batch
+
+    a, b, c = format_ids([p2.id, p1.id, p3.id])
+
+    expected = <<-TABLE
++----+------------+-----------+-----+------------+-----------+
+|              person               |   custom_attributes    |
++----+------------+-----------+-----+------------+-----------+
+| id | first_name | last_name | age | instrument |   style   |
++----+------------+-----------+-----+------------+-----------+
+|#{a}| romer      |           |     | kazoo      |           |
+|#{b}| chrismo    |           |     | piano      | jazz      |
+|#{c}| glv        |           |     |            |           |
++----+------------+-----------+-----+------------+-----------+
+    TABLE
+
+    batch.text_table.to_s.should == expected
+  end
+
+  it 'supports consistent ordering of dynamic columns' do
+    p1 = Person.create(first_name: 'chrismo', custom_attributes: {instrument: 'piano', style: 'jazz'})
+    p2 = Person.create(first_name: 'romer', custom_attributes: {hobby: 'games'})
+    batch = [p1, p2].to_batch
+
+    a, b = format_ids([p1.id, p2.id])
+
+    expected = <<-TABLE
++----+------------+-----------+-----+--------+------------+--------+
+|              person               |      custom_attributes       |
++----+------------+-----------+-----+--------+------------+--------+
+| id | first_name | last_name | age | hobby  | instrument | style  |
++----+------------+-----------+-----+--------+------------+--------+
+|#{a}| chrismo    |           |     |        | piano      | jazz   |
+|#{b}| romer      |           |     | games  |            |        |
++----+------------+-----------+-----+--------+------------+--------+
+    TABLE
+
+    batch.text_table.to_s.should == expected
+  end
+
+  it 'handles AR instance without an association present' do
+    s = Supplier.create(name: 'supplier')
+    b = [s].to_batch
+
+    def b.serializable_options
+      {:only => [:name], :include => {:account => {:only => [:name, :tax_id]}}}
+    end
+
+    expected = <<-TABLE
++----------+
+|   name   |
++----------+
+| supplier |
++----------+
+    TABLE
+
+    b.text_table.to_s.should == expected
+  end
+
+  it 'properly groups when original columns not sequential' do
+    s2 = Supplier.create(name: 'sup. two', custom_attributes: {a: 1})
+
+    def s2.foo
+      ''
+    end
+
+    b = [s2].to_batch
+
+    # methods need Columns as well
+    def b.serializable_options
+      {:only => [:name, :custom_attributes], :methods => [:foo]}
+    end
+
+    expected = <<-TABLE
++----------+------+-------------------+
+|    supplier     | custom_attributes |
++----------+------+-------------------+
+|   name   | foo  |         a         |
++----------+------+-------------------+
+| sup. two |      | 1                 |
++----------+------+-------------------+
+    TABLE
+
+    b.text_table.to_s.should == expected
+  end
+
+  it 'supports one to many association' do
+    p = Parent.create(name: 'parent')
+    c = Child.create(name: 'child', parent: p)
+
+    b = [p].to_batch
+
+    # little weird looking at this point, but at least not broken
+    expected = <<-TABLE
++----+--------+-------------------+---------------------+
+| id |  name  | custom_attributes |      children       |
++----+--------+-------------------+---------------------+
+| 1  | parent |                   | [{"name"=>"child"}] |
++----+--------+-------------------+---------------------+
+    TABLE
+
+    def b.serializable_options
+      {:include => {:children => {:only => [:name]}}}
+    end
+
+    b.text_table.to_s.should == expected
+  end
+
+  def format_ids(ary)
+    ary.map {|value| " #{value.to_s.ljust(3)}" }
+  end
+
+  describe 'fold un-sourced attributes into source hash' do
+    let(:obj) { Object.new.extend Tablesmith::ActiveRecordSource }
+
+    it 'should handle simple hash' do
+      obj.fold_un_sourced_attributes_into_source_hash(:foo, {a: 1, b: 2}).should == {foo: {a: 1, b: 2}}
+    end
+
+    it 'should handle nested hashes' do
+      before = {'name' => 'chris', account: {'name' => 'account_name'}}
+      expected = {foo: {'name' => 'chris'}, account: {'name' => 'account_name'}}
+      obj.fold_un_sourced_attributes_into_source_hash(:foo, before).should == expected
+    end
+
+    it 'should handle deep nested hashes' do
+      before = {'name' => 'chris', account: {'id' => {'name' => 'account_name', 'number' => 123456}}}
+      expected = {foo: {'name' => 'chris'}, account: {'id' => {'name' => 'account_name', 'number' => 123456}}}
+      obj.fold_un_sourced_attributes_into_source_hash(:foo, before).should == expected
+    end
+  end
+
+  describe 'flatten_inner_hashes' do
+    let(:obj) { Object.new.extend Tablesmith::ActiveRecordSource }
+
+    it 'should flatten inner hash' do
+      before = {foo: {'name' => 'chris'}, account: {'name' => 'account_name'}}
+      expected = {'foo.name' => 'chris', 'account.name' => 'account_name'}
+
+      obj.flatten_inner_hashes(before).should == expected
+    end
+
+    it 'should to_s deep nested hashes' do
+      before = {foo: {'name' => 'chris'}, account: {'id' => {'name' => 'account_name', 'number' => 123456}}}
+      expected = {'foo.name' => 'chris', "account.id" => "{\"name\"=>\"account_name\", \"number\"=>123456}"}
+
+      obj.flatten_inner_hashes(before).should == expected
+    end
+  end
+end

data/spec/array_spec.rb

@@ -0,0 +1 @@
+# Want stuff to work with plain Arrays

data/spec/batch_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+include Tablesmith
+
+describe Batch do
+  it 'should subclass array' do
+    b = Batch.new
+    b.length.should == 0
+    b << 1
+    b << 'a'
+    b[0].should == 1
+    b[1].should == 'a'
+    b.class.should == Batch
+  end
+
+  it 'should pass unmatched Array messages to all items' do
+    b = Batch.new
+    b.length.should == 0
+    b << 1
+    b << '2'
+    b.to_i.should == [1, 2]
+  end
+
+  it 'should handle empty Array' do
+    expected = <<-TEXT
++---------+
+| (empty) |
++---------+
+    TEXT
+    [].to_batch.text_table.to_s.should == expected
+  end
+end

data/spec/fixtures.rb

@@ -0,0 +1,70 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+
+class Person < ActiveRecord::Base
+  connection.create_table table_name, :force => true do |t|
+    t.string :first_name
+    t.string :last_name
+    t.integer :age
+    t.text :custom_attributes
+  end
+
+  def year_born
+    Time.local(2014, 1, 1).year - self.age
+  end
+end
+
+class Parent < ActiveRecord::Base
+  has_many :children
+
+  connection.create_table table_name, :force => true do |t|
+    t.string :name
+    t.text :custom_attributes
+  end
+end
+
+class Child < ActiveRecord::Base
+  belongs_to :parent
+
+  connection.create_table table_name, :force => true do |t|
+    t.integer :parent_id
+    t.string :name
+  end
+end
+
+class Supplier < ActiveRecord::Base
+  has_one :account
+  has_one :account_history, :through => :account
+
+  accepts_nested_attributes_for :account, :account_history
+
+  connection.create_table table_name, :force => true do |t|
+    t.integer :account_id
+    t.integer :account_history_id
+    t.string :name
+    t.text :custom_attributes
+  end
+end
+
+class Account < ActiveRecord::Base
+  belongs_to :supplier
+  has_one :account_history
+
+  accepts_nested_attributes_for :account_history
+
+  connection.create_table table_name, :force => true do |t|
+    t.integer :supplier_id
+    t.string :name
+    t.integer :tax_identification_number
+  end
+end
+
+class AccountHistory < ActiveRecord::Base
+  belongs_to :account
+
+  connection.create_table table_name, :force => true do |t|
+    t.integer :account_id
+    t.integer :credit_rating
+  end
+end

data/spec/hash_rows_batch_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'HashRowsSource' do
+  it 'outputs text table of simple hash row with default columns' do
+    expected = <<-TABLE
++---+---+
+| a | b |
++---+---+
+| 1 | 2 |
++---+---+
+    TABLE
+    [{a: 1, b: 2}].to_batch.text_table.to_s.should == expected
+  end
+
+  it 'outputs text table of mixed columns hash rows with default columns' do
+    expected = <<-TABLE
++---+---+---+
+| a | b | c |
++---+---+---+
+| 1 | 2 |   |
+| 2 |   | ! |
++---+---+---+
+    TABLE
+    [
+      {a: 1, b: 2},
+      {a: 2, c: '!'}
+    ].to_batch.text_table.to_s.should == expected
+  end
+
+  it 'outputs text table of deep hash rows with defined columns' do
+    expected = <<-TABLE
++---+---+---+
+|   |   b   |
++---+---+---+
+| a | c | d |
++---+---+---+
+| 1 | 2 | 2 |
++---+---+---+
+    TABLE
+    b = [{a: 1, b: {c: 2, d: 2}}].to_batch
+    def b.columns
+      [
+        Column.new(name: :a),
+        {b: [
+          Column.new(name: :c)
+        ]}
+      ]
+    end
+    # this would be nice. Payments has some code along these lines for BraintreeBatch? or some ActiveRecordSource re-use?
+    # b.text_table.to_s.should == expected
+    pending
+  end
+
+  it 'outputs text table of deep hash rows with default columns'
+end

data/spec/hash_spec.rb

@@ -0,0 +1 @@
+# Want stuff to work with a plain Hash

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require File.expand_path('../../lib/tablesmith', __FILE__)
+
+require File.expand_path('../fixtures', __FILE__)

data/tablesmith.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tablesmith/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'tablesmith'
+  gem.version       = Tablesmith::VERSION
+  gem.authors       = ['chrismo']
+  gem.email         = ['chrismo@clabs.org']
+  gem.description   = %q{Minimal console table}
+  gem.summary       = %q{Minimal console table}
+  gem.homepage      = 'http://github.com/livingsocial/tablesmith'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'text-table'
+
+  gem.add_development_dependency 'activerecord', '~> 3.0'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'rake', '~> 10.0'
+  gem.add_development_dependency 'rspec', '~> 2.0'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'sqlite3'
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: tablesmith
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- chrismo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: text-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: sqlite3
+  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'
+description: Minimal console table
+email:
+- chrismo@clabs.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/tablesmith.rb
+- lib/tablesmith/active_record_source.rb
+- lib/tablesmith/batch.rb
+- lib/tablesmith/hash_rows_source.rb
+- lib/tablesmith/version.rb
+- spec/active_record_batch_spec.rb
+- spec/array_spec.rb
+- spec/batch_spec.rb
+- spec/fixtures.rb
+- spec/hash_rows_batch_spec.rb
+- spec/hash_spec.rb
+- spec/spec_helper.rb
+- tablesmith.gemspec
+homepage: http://github.com/livingsocial/tablesmith
+licenses: []
+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.6.12
+signing_key: 
+specification_version: 4
+summary: Minimal console table
+test_files:
+- spec/active_record_batch_spec.rb
+- spec/array_spec.rb
+- spec/batch_spec.rb
+- spec/fixtures.rb
+- spec/hash_rows_batch_spec.rb
+- spec/hash_spec.rb
+- spec/spec_helper.rb