tablesmith 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45818202ea467196502cd88dabbba91262f0476d
-  data.tar.gz: b6ece78a22c856daee3f1aab6b1eeb13cfe0201f
+  metadata.gz: 422060113ff10de9d77319825d7c0584b1389e3e
+  data.tar.gz: c2672e0136fe3ccad708644232db70a7f3112ddd
 SHA512:
-  metadata.gz: 43d69277e17bb8909aa962b96f97a6d02a14bdce203bacd37e4be3d07031fa8a8fa8adec62a58ca2b9ff0fa66a30cd0dba750ee5057c6b13157b264f0bf93ee9
-  data.tar.gz: b6345a15062ebcb554494558880bff872fba9f96424bc4ae1ddeb43003d3137da96afbce0ea1210a0cc0e0c1ed4334895bb43a117517c932aaeb51440d867db8
+  metadata.gz: 362ffe3c1d3cb37c26a521de9eea14cc4bcfb5ec42534930486d05238ecb2fb1fb90621318eb2bab75d979d9040c274601626a456464317cd6f8e2d7e8f1e340
+  data.tar.gz: 7df00f39dc421aaa159900710dc2af3de41d4d8805a8936818fbca388d64cf3dca682cbfa08b900d28616cbd9dd10136979dd06d1214bf84a1155fe9fa606280

data/.rubocop.yml

@@ -0,0 +1,5 @@
+AllCops:
+  TargetRubyVersion: 2.3
+
+Layout/IndentHeredoc:
+  Enabled: true

data/.travis.yml

@@ -0,0 +1 @@
+language: ruby

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tablesmith (0.1.2)
+    tablesmith (0.2.1)
       text-table
 
 GEM
@@ -63,4 +63,4 @@ DEPENDENCIES
   tablesmith!
 
 BUNDLED WITH
-   1.15.3
+   1.15.4

data/README.md

@@ -26,8 +26,8 @@ Happy to learn about something else already out there, but have struggled to fin
 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.
+Here's a quick list of 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

data/lib/tablesmith.rb

@@ -1,5 +1,6 @@
-require 'tablesmith/batch'
-require 'tablesmith/active_record_source'
+require 'tablesmith/table'
 require 'tablesmith/array_rows_source'
+require 'tablesmith/hash_rows_base'
 require 'tablesmith/hash_rows_source'
+require 'tablesmith/active_record_source'
 require 'tablesmith/version'

data/lib/tablesmith/active_record_source.rb

@@ -1,13 +1,11 @@
 module Tablesmith::ActiveRecordSource
+  include Tablesmith::HashRowsBase
+
   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
+    item.reload unless item.new_record?
+    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)
   end
 
   def column_order
@@ -19,25 +17,30 @@ module Tablesmith::ActiveRecordSource
     {}
   end
 
-  # TODO: memoize
   def process_all_columns(serializable_options)
-    @columns = []
+    build_columns(serializable_options)
 
-    process_columns(serializable_options, first.class)
+    serializable_options
+  end
 
-    include = serializable_options[:include]
+  def build_columns(serializable_options)
+    @columns || begin
+      @columns = []
 
-    # 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
+      process_columns(serializable_options, first.class)
 
-    include.each do |association, opts|
-      ar_class = first.class.reflections[association].klass
-      process_columns(opts, ar_class)
-    end
+      include = serializable_options[:include]
 
-    serializable_options
+      # 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
+    end
   end
 
   def process_columns(serializable_options, ar_class)

data/lib/tablesmith/hash_rows_base.rb

@@ -0,0 +1,34 @@
+# ActiveRecord and HashRowsSource share a lot, but not everything.
+module Tablesmith::HashRowsBase
+  # 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(&:keys).flatten.uniq
+    rows.map { |hash_row| all_keys.each { |key| hash_row[key] ||= '' } }
+  end
+
+  def sort_columns(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
+  end
+
+  def row_values(row)
+    row.map(&:last)
+  end
+
+  def create_headers(rows)
+    column_names = rows.first.map(&:first)
+    grouped_headers(column_names) + [apply_column_aliases(column_names), :separator]
+  end
+end

data/lib/tablesmith/hash_rows_source.rb

@@ -1,4 +1,6 @@
 module Tablesmith::HashRowsSource
+  include Tablesmith::HashRowsBase
+
   def text_table
     build_columns if columns.nil?
     super
@@ -60,36 +62,4 @@ module Tablesmith::HashRowsSource
     # Array addition from text-table
     table.to_table(:first_row_is_head => true)
   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
-
-  def sort_columns(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
-  end
-
-  def row_values(row)
-    row.map(&:last)
-  end
-
-  def create_headers(rows)
-    column_names = rows.first.map(&:first)
-    grouped_headers(column_names) + [apply_column_aliases(column_names), :separator]
-  end
 end

data/lib/tablesmith/{batch.rb → table.rb}

@@ -1,7 +1,7 @@
 require 'text-table'
 
 module Tablesmith
-  class Batch < Array
+  class Table < Array
     def method_missing(meth_id, *args)
       count = 1
       self.map do |t|
@@ -62,7 +62,6 @@ module Tablesmith
       []
     end
 
-    # TODO: resolve with column_order
     def columns
       @columns
     end
@@ -118,12 +117,16 @@ module Tablesmith
     def full_unaliased_name
       "#{@source ? "#{@source}." : ''}#{@name}"
     end
+
+    def to_s
+      "#{@source}.#{@name}#{' as ' + @alias if @alias}"
+    end
   end
 end
 
 class Array
-  def to_batch
-    b = Tablesmith::Batch.new(self)
+  def to_table
+    b = Tablesmith::Table.new(self)
 
     if defined?(ActiveRecord) && defined?(ActiveRecord::Base)
       if b.first && b.first.is_a?(ActiveRecord::Base)
@@ -143,3 +146,9 @@ class Array
   end
 end
 
+class Hash
+  def to_table
+    b = Tablesmith::Table.new([self])
+    b.extend Tablesmith::HashRowsSource
+  end
+end

data/lib/tablesmith/version.rb

@@ -1,3 +1,3 @@
 module Tablesmith
-  VERSION = '0.1.2'
+  VERSION = '0.2.1'.freeze
 end

data/spec/{active_record_batch_spec.rb → active_record_table_spec.rb}

@@ -4,40 +4,40 @@ 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          |           |     |                   |
-+----+------------+-----------+-----+-------------------+
+    expected = <<~TABLE
+      +----+------------+-----------+-----+-------------------+
+      | id | first_name | last_name | age | custom_attributes |
+      +----+------------+-----------+-----+-------------------+
+      |    | A          |           |     |                   |
+      |    | B          |           |     |                   |
+      +----+------------+-----------+-----+-------------------+
     TABLE
-    [a, b].to_batch.text_table.to_s.should == expected
+    [a, b].to_table.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  |                   |
-+----+------------+-----------+-----+-------------------+
+    expected = <<~TABLE
+      +----+------------+-----------+-----+-------------------+
+      | id | first_name | last_name | age | custom_attributes |
+      +----+------------+-----------+-----+-------------------+
+      | 1  | chris      | mo        | 43  |                   |
+      +----+------------+-----------+-----+-------------------+
     TABLE
-    [p].to_batch.text_table.to_s.should == expected
+    [p].to_table.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      |
-+------------+-----+-----------+
+    expected = <<~TABLE
+      +------------+-----+-----------+
+      | first_name | age | year_born |
+      +------------+-----+-----------+
+      | chrismo    | 43  | 1971      |
+      +------------+-----+-----------+
     TABLE
-    b = [p].to_batch
+    b = [p].to_table
 
     def b.serializable_options
       {:only => [:first_name, :age], :methods => [:year_born]}
@@ -46,16 +46,46 @@ describe 'ActiveRecordSource' do
     b.text_table.to_s.should == expected
   end
 
+  it 'auto reloads records' do
+    p = Person.create(:first_name => 'chrismo', :age => 43)
+
+    expected = <<~TABLE
+      +------------+-----+-----------+
+      | first_name | age | year_born |
+      +------------+-----+-----------+
+      | chrismo    | 43  | 1971      |
+      +------------+-----+-----------+
+    TABLE
+    b = [p].to_table
+
+    def b.serializable_options
+      {:only => [:first_name, :age], :methods => [:year_born]}
+    end
+    b.text_table.to_s.should == expected
+
+    # update the value through another instance.
+    Person.last.update_column(:age, 46)
+
+    expected = <<~TABLE
+      +------------+-----+-----------+
+      | first_name | age | year_born |
+      +------------+-----+-----------+
+      | chrismo    | 46  | 1968      |
+      +------------+-----+-----------+
+    TABLE
+    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  |
-+-------+------+-----+
+    expected = <<~TABLE
+      +-------+------+-----+
+      | first | last | age |
+      +-------+------+-----+
+      | chris | mo   | 43  |
+      +-------+------+-----+
     TABLE
-    b = [p].to_batch
+    b = [p].to_table
 
     def b.serializable_options
       {:only => [:first, :last, :age]}
@@ -66,14 +96,14 @@ describe 'ActiveRecordSource' do
 
   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  |
-+--------+--------+-----+
+    expected = <<~TABLE
+      +--------+--------+-----+
+      | f_name | l_name | age |
+      +--------+--------+-----+
+      | chris  | mo     | 43  |
+      +--------+--------+-----+
     TABLE
-    b = [p].to_batch
+    b = [p].to_table
 
     def b.serializable_options
       {:only => [:f_name, :l_name, :age]}
@@ -84,14 +114,14 @@ describe 'ActiveRecordSource' do
 
   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  |
-+---------------+----------+-----+
+    expected = <<~TABLE
+      +---------------+----------+-----+
+      | primer_nombre | apellido | age |
+      +---------------+----------+-----+
+      | chris         | mo       | 43  |
+      +---------------+----------+-----+
     TABLE
-    b = [p].to_batch
+    b = [p].to_table
 
     def b.columns
       [Tablesmith::Column.new(name: :first_name, alias: :primer_nombre),
@@ -108,20 +138,20 @@ describe 'ActiveRecordSource' do
   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
+    b = [s].to_table
 
     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                    |
-+----------+---------+---------------------------+
+    expected = <<~TABLE
+      +----------+---------+---------------------------+
+      | supplier |               account               |
+      +----------+---------+---------------------------+
+      |   name   |  name   | tax_identification_number |
+      +----------+---------+---------------------------+
+      | supplier | account | 123456                    |
+      +----------+---------+---------------------------+
     TABLE
 
     b.text_table.to_s.should == expected
@@ -130,20 +160,20 @@ describe 'ActiveRecordSource' do
   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
+    b = [s].to_table
 
     def b.serializable_options
       {:only => [:name], :include => {:account => {:only => [:name, :tax_id]}}}
     end
 
-    expected = <<-TABLE
-+----------+---------+--------+
-| supplier |     account      |
-+----------+---------+--------+
-|   name   |  name   | tax_id |
-+----------+---------+--------+
-| supplier | account | 123456 |
-+----------+---------+--------+
+    expected = <<~TABLE
+      +----------+---------+--------+
+      | supplier |     account      |
+      +----------+---------+--------+
+      |   name   |  name   | tax_id |
+      +----------+---------+--------+
+      | supplier | account | 123456 |
+      +----------+---------+--------+
     TABLE
 
     b.text_table.to_s.should == expected
@@ -158,17 +188,17 @@ describe 'ActiveRecordSource' do
   # 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
+    b = [p].to_table
 
     a = format_ids([p.id])[0]
-    expected = <<-TABLE
-+----+------------+-----------+-----+----------------------------------------+
-|              person               |           custom_attributes            |
-+----+------------+-----------+-----+----------------------------------------+
-| id | first_name | last_name | age |                 skills                 |
-+----+------------+-----------+-----+----------------------------------------+
-|#{a}| chrismo    |           |     | {:instrument=>"piano", :style=>"jazz"} |
-+----+------------+-----------+-----+----------------------------------------+
+    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
@@ -178,20 +208,20 @@ describe 'ActiveRecordSource' 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
+    batch = [p2, p1, p3].to_table
 
     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        |           |     |            |           |
-+----+------------+-----------+-----+------------+-----------+
+    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
@@ -200,19 +230,19 @@ describe 'ActiveRecordSource' do
   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
+    batch = [p1, p2].to_table
 
     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  |            |        |
-+----+------------+-----------+-----+--------+------------+--------+
+    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
@@ -220,18 +250,18 @@ describe 'ActiveRecordSource' do
 
   it 'handles AR instance without an association present' do
     s = Supplier.create(name: 'supplier')
-    b = [s].to_batch
+    b = [s].to_table
 
     def b.serializable_options
       {:only => [:name], :include => {:account => {:only => [:name, :tax_id]}}}
     end
 
-    expected = <<-TABLE
-+----------+
-|   name   |
-+----------+
-| supplier |
-+----------+
+    expected = <<~TABLE
+      +----------+
+      |   name   |
+      +----------+
+      | supplier |
+      +----------+
     TABLE
 
     b.text_table.to_s.should == expected
@@ -244,21 +274,21 @@ describe 'ActiveRecordSource' do
       ''
     end
 
-    b = [s2].to_batch
+    b = [s2].to_table
 
     # 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                 |
-+----------+------+-------------------+
+    expected = <<~TABLE
+      +----------+------+-------------------+
+      |    supplier     | custom_attributes |
+      +----------+------+-------------------+
+      |   name   | foo  |         a         |
+      +----------+------+-------------------+
+      | sup. two |      | 1                 |
+      +----------+------+-------------------+
     TABLE
 
     b.text_table.to_s.should == expected
@@ -268,15 +298,15 @@ describe 'ActiveRecordSource' do
     p = Parent.create(name: 'parent')
     c = Child.create(name: 'child', parent: p)
 
-    b = [p].to_batch
+    b = [p].to_table
 
     # little weird looking at this point, but at least not broken
-    expected = <<-TABLE
-+----+--------+-------------------+---------------------+
-| id |  name  | custom_attributes |      children       |
-+----+--------+-------------------+---------------------+
-| 1  | parent |                   | [{"name"=>"child"}] |
-+----+--------+-------------------+---------------------+
+    expected = <<~TABLE
+      +----+--------+-------------------+---------------------+
+      | id |  name  | custom_attributes |      children       |
+      +----+--------+-------------------+---------------------+
+      | 1  | parent |                   | [{"name"=>"child"}] |
+      +----+--------+-------------------+---------------------+
     TABLE
 
     def b.serializable_options

data/spec/array_table_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Array Source' do
+  it 'just works in a console' do
+    expected = <<~TABLE
+      +---+---+---+
+      | a | b | c |
+      +---+---+---+
+      | d | e | f |
+      +---+---+---+
+    TABLE
+    [%w(a b c), %w(d e f)].to_table.text_table.to_s.should == expected
+  end
+end

data/spec/fixtures.rb

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

data/spec/{hash_rows_batch_spec.rb → hash_rows_table_spec.rb}

@@ -2,42 +2,42 @@ require 'spec_helper'
 
 describe 'HashRowsSource' do
   it 'outputs text table of simple hash row with default columns' do
-    expected = <<-TABLE
-+---+---+
-| a | b |
-+---+---+
-| 1 | 2 |
-+---+---+
+    expected = <<~TABLE
+      +---+---+
+      | a | b |
+      +---+---+
+      | 1 | 2 |
+      +---+---+
     TABLE
-    [{a: 1, b: 2}].to_batch.text_table.to_s.should == expected
+    [{a: 1, b: 2}].to_table.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 |   | ! |
-+---+---+---+
+    expected = <<~TABLE
+      +---+---+---+
+      | a | b | c |
+      +---+---+---+
+      | 1 | 2 |   |
+      | 2 |   | ! |
+      +---+---+---+
     TABLE
     [
       {a: 1, b: 2},
       {a: 2, c: '!'}
-    ].to_batch.text_table.to_s.should == expected
+    ].to_table.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 |
-+---+---+---+
+    expected = <<~TABLE
+      +---+---+---+
+      |   |   b   |
+      +---+---+---+
+      | a | c | d |
+      +---+---+---+
+      | 1 | 2 | 2 |
+      +---+---+---+
     TABLE
-    b = [{a: 1, b: {c: 2, d: 2}}].to_batch
+    b = [{a: 1, b: {c: 2, d: 2}}].to_table
     def b.columns
       [
         Column.new(name: :a),

data/spec/hash_table_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Hash Source' do
+  it 'just works in a console' do
+    expected = <<~TABLE
+      +---+---+---+
+      | a | b | c |
+      +---+---+---+
+      | 1 | 2 | 3 |
+      +---+---+---+
+    TABLE
+    {a: 1, b: 2, c: 3}.to_table.text_table.to_s.should == expected
+  end
+end

data/spec/{batch_spec.rb → table_spec.rb}

@@ -2,19 +2,19 @@ require 'spec_helper'
 
 include Tablesmith
 
-describe Batch do
+describe Table do
   it 'should subclass array' do
-    b = Batch.new
+    b = Table.new
     b.length.should == 0
     b << 1
     b << 'a'
     b[0].should == 1
     b[1].should == 'a'
-    b.class.should == Batch
+    b.class.should == Table
   end
 
   it 'should pass unmatched Array messages to all items' do
-    b = Batch.new
+    b = Table.new
     b.length.should == 0
     b << 1
     b << '2'
@@ -22,24 +22,24 @@ describe Batch do
   end
 
   it 'should handle empty Array' do
-    expected = <<-TEXT
-+---------+
-| (empty) |
-+---------+
+    expected = <<~TEXT
+      +---------+
+      | (empty) |
+      +---------+
     TEXT
-    [].to_batch.text_table.to_s.should == expected
+    [].to_table.text_table.to_s.should == expected
   end
 
   it 'should handle a simple two row Array' do
     a = [%w(a b c), %w(d e f)]
     actual = a
-    expected = <<-TABLE
-+---+---+---+
-| a | b | c |
-+---+---+---+
-| d | e | f |
-+---+---+---+
+    expected = <<~TABLE
+      +---+---+---+
+      | a | b | c |
+      +---+---+---+
+      | d | e | f |
+      +---+---+---+
     TABLE
-    actual.to_batch.text_table.to_s.should == expected
+    actual.to_table.text_table.to_s.should == expected
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tablesmith
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - chrismo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-18 00:00:00.000000000 Z
+date: 2017-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: text-table
@@ -117,7 +117,9 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".ruby-version"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -126,16 +128,17 @@ files:
 - lib/tablesmith.rb
 - lib/tablesmith/active_record_source.rb
 - lib/tablesmith/array_rows_source.rb
-- lib/tablesmith/batch.rb
+- lib/tablesmith/hash_rows_base.rb
 - lib/tablesmith/hash_rows_source.rb
+- lib/tablesmith/table.rb
 - lib/tablesmith/version.rb
-- spec/active_record_batch_spec.rb
-- spec/array_batch_spec.rb
-- spec/batch_spec.rb
+- spec/active_record_table_spec.rb
+- spec/array_table_spec.rb
 - spec/fixtures.rb
-- spec/hash_rows_batch_spec.rb
-- spec/hash_spec.rb
+- spec/hash_rows_table_spec.rb
+- spec/hash_table_spec.rb
 - spec/spec_helper.rb
+- spec/table_spec.rb
 - tablesmith.gemspec
 homepage: http://github.com/livingsocial/tablesmith
 licenses: []
@@ -161,10 +164,10 @@ signing_key:
 specification_version: 4
 summary: Minimal console table
 test_files:
-- spec/active_record_batch_spec.rb
-- spec/array_batch_spec.rb
-- spec/batch_spec.rb
+- spec/active_record_table_spec.rb
+- spec/array_table_spec.rb
 - spec/fixtures.rb
-- spec/hash_rows_batch_spec.rb
-- spec/hash_spec.rb
+- spec/hash_rows_table_spec.rb
+- spec/hash_table_spec.rb
 - spec/spec_helper.rb
+- spec/table_spec.rb

data/spec/array_batch_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe 'Array Source' do
-  it 'just works in a console' do
-    expected = <<-TABLE
-+---+---+---+
-| a | b | c |
-+---+---+---+
-| d | e | f |
-+---+---+---+
-    TABLE
-    [%w(a b c), %w(d e f)].to_batch.text_table.to_s.should == expected
-  end
-end

data/spec/hash_spec.rb

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