tablesmith 0.4.1 → 0.5.0

data/lib/tablesmith/hash_rows_source.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tablesmith::HashRowsSource
   include Tablesmith::HashRowsBase
 
@@ -11,7 +13,7 @@ module Tablesmith::HashRowsSource
   end
 
   def flatten_hash_to_row(deep_hash, columns)
-    row = ActiveSupport::OrderedHash.new
+    row = {}
     columns.each do |col_or_hash|
       value_from_hash(row, deep_hash, col_or_hash)
     end
@@ -21,9 +23,9 @@ module Tablesmith::HashRowsSource
   # TODO: no support for deep
   def build_columns
     @columns ||= []
-    self.map do |hash_row|
+    map do |hash_row|
       @columns << hash_row.keys.map { |k| Tablesmith::Column.new(name: k) }
-    end 
+    end
     @columns.flatten!
   end
 
@@ -37,11 +39,9 @@ module Tablesmith::HashRowsSource
           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
+  rescue StandardError => e
+    warn "#{e.message}: #{col_or_hash}" if @debug
   end
 
   def hash_rows_to_text_table(hash_rows)
@@ -60,6 +60,6 @@ module Tablesmith::HashRowsSource
     end
 
     # Array addition from text-table
-    table.to_table(:first_row_is_head => true)
+    table.to_table(first_row_is_head: true)
   end
 end

data/lib/tablesmith/html_formatter.rb

@@ -40,6 +40,7 @@ class HtmlFormatter
   def append_rows(rows, tag)
     rows.each do |row|
       next if row == :separator
+
       @lines << "#{indent}<tr>"
       row.map do |cell|
         value = cell_value(cell)

data/lib/tablesmith/table.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'text-table'
 require 'csv'
 
@@ -5,8 +7,8 @@ module Tablesmith
   class Table < Array
     def method_missing(meth_id, *args)
       count = 1
-      self.map do |t|
-        $stderr.print '.' if count.divmod(100)[1] == 0
+      map do |t|
+        $stderr.print '.' if (count.divmod(100)[1]).zero?
         count += 1
         t.send(meth_id, *args)
       end
@@ -16,6 +18,10 @@ module Tablesmith
       super
     end
 
+    def to_s
+      text_table.to_s
+    end
+
     # irb
     def inspect
       pretty_inspect
@@ -32,9 +38,9 @@ module Tablesmith
     end
 
     def text_table
-      return ['(empty)'].to_text_table if self.empty?
+      return ['(empty)'].to_text_table if empty?
 
-      rows = self.map { |item| convert_item_to_hash_row(item) }.compact
+      rows = map { |item| convert_item_to_hash_row(item) }.compact
 
       normalize_keys(rows)
 
@@ -48,12 +54,13 @@ module Tablesmith
       CSV.generate do |csv|
         text_table.rows.each do |row|
           next if row == :separator
+
           csv << row.map do |cell|
             case cell
-              when Hash
-                cell[:value]
-              else
-                cell
+            when Hash
+              cell[:value]
+            else
+              cell
             end
           end
         end
@@ -70,8 +77,7 @@ module Tablesmith
     end
 
     # override in subclass or mixin
-    def sort_columns(rows)
-    end
+    def sort_columns(rows); end
 
     # override in subclass or mixin
     def convert_item_to_hash_row(item)
@@ -79,22 +85,24 @@ module Tablesmith
     end
 
     # override in subclass or mixin
-    def normalize_keys(rows)
-    end
+    def normalize_keys(rows); end
 
     # override in subclass or mixin
     def column_order
       []
     end
 
-    def columns
-      @columns
-    end
+    attr_reader :columns
 
     def create_headers(rows)
-      top_row = rows.first
-      column_names = top_row.first.is_a?(Array) ? top_row.map(&:first) : top_row
-      grouped_headers(column_names) + [apply_column_aliases(column_names), :separator]
+      first_element = rows.first
+      if first_element.is_a?(Array)
+        top_row = first_element
+        column_names = top_row.first.is_a?(Array) ? top_row.map(&:first) : top_row
+        grouped_headers(column_names) + [apply_column_aliases(column_names), :separator]
+      else
+        []
+      end
     end
 
     def grouped_headers(column_names)
@@ -111,7 +119,7 @@ module Tablesmith
         row = []
         # this relies on Ruby versions where hash retains add order
         groups.each_pair do |name, span|
-          row << {value: name, align: :center, colspan: span}
+          row << { value: name, align: :center, colspan: span }
         end
         [row, :separator]
       end
@@ -121,7 +129,7 @@ module Tablesmith
       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}
+        { value: value, align: :center }
       end
     end
   end
@@ -129,14 +137,14 @@ module Tablesmith
   class Column
     attr_accessor :source, :name, :alias
 
-    def initialize(attributes={})
+    def initialize(attributes = {})
       @source = attributes.delete(:source)
       @name = attributes.delete(:name)
       @alias = attributes.delete(:alias)
     end
 
     def display_name
-      "#{@alias || @name}"
+      (@alias || @name).to_s
     end
 
     def full_unaliased_name
@@ -157,18 +165,12 @@ class Array
     # so mixed content could be supported. Maybe every cell could be
     # rendered appropriately, with nested tables.
     if defined?(ActiveRecord) && defined?(ActiveRecord::Base)
-      if b.first && b.first.is_a?(ActiveRecord::Base)
-        b.extend Tablesmith::ActiveRecordSource
-      end
+      b.extend Tablesmith::ActiveRecordSource if b.first&.is_a?(ActiveRecord::Base)
     end
 
-    if b.first && b.first.is_a?(Hash)
-      b.extend Tablesmith::HashRowsSource
-    end
+    b.extend Tablesmith::HashRowsSource if b.first&.is_a?(Hash)
 
-    if b.first && b.first.is_a?(Array)
-      b.extend Tablesmith::ArrayRowsSource
-    end
+    b.extend Tablesmith::ArrayRowsSource if b.first&.is_a?(Array)
 
     b
   end
@@ -179,4 +181,4 @@ class Hash
     b = Tablesmith::Table.new([self])
     b.extend Tablesmith::HashRowsSource
   end
-end
+end

data/lib/tablesmith/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tablesmith
-  VERSION = '0.4.1'.freeze
+  VERSION = '0.5.0'
 end

data/spec/active_record_table_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe 'ActiveRecordSource' do
@@ -12,11 +14,11 @@ describe 'ActiveRecordSource' do
       |    | B          |           |     |                   |
       +----+------------+-----------+-----+-------------------+
     TABLE
-    [a, b].to_table.text_table.to_s.should == expected
+    [a, b].to_table.to_s.should == expected
   end
 
   it 'outputs ActiveRecord in column order' do
-    p = Person.create(:first_name => 'chris', :last_name => 'mo', :age => 43)
+    p = Person.create(first_name: 'chris', last_name: 'mo', age: 43)
     expected = <<~TABLE
       +----+------------+-----------+-----+-------------------+
       | id | first_name | last_name | age | custom_attributes |
@@ -24,11 +26,11 @@ describe 'ActiveRecordSource' do
       | 1  | chris      | mo        | 43  |                   |
       +----+------------+-----------+-----+-------------------+
     TABLE
-    [p].to_table.text_table.to_s.should == expected
+    [p].to_table.to_s.should == expected
   end
 
   it 'handles custom serialization options in batch' do
-    p = Person.create(:first_name => 'chrismo', :age => 43)
+    p = Person.create(first_name: 'chrismo', age: 43)
 
     expected = <<~TABLE
       +------------+-----+-----------+
@@ -40,14 +42,14 @@ describe 'ActiveRecordSource' do
     b = [p].to_table
 
     def b.serializable_options
-      {:only => [:first_name, :age], :methods => [:year_born]}
+      { only: %i[first_name age], methods: [:year_born] }
     end
 
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   it 'auto reloads records' do
-    p = Person.create(:first_name => 'chrismo', :age => 43)
+    p = Person.create(first_name: 'chrismo', age: 43)
 
     expected = <<~TABLE
       +------------+-----+-----------+
@@ -59,9 +61,9 @@ describe 'ActiveRecordSource' do
     b = [p].to_table
 
     def b.serializable_options
-      {:only => [:first_name, :age], :methods => [:year_born]}
+      { only: %i[first_name age], methods: [:year_born] }
     end
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
 
     # update the value through another instance.
     Person.last.update_column(:age, 46)
@@ -73,11 +75,11 @@ describe 'ActiveRecordSource' do
       | chrismo    | 46  | 1968      |
       +------------+-----+-----------+
     TABLE
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   it 'handles column name partials' do
-    p = Person.create(:first_name => 'chris', :last_name => 'mo', :age => 43)
+    p = Person.create(first_name: 'chris', last_name: 'mo', age: 43)
     expected = <<~TABLE
       +-------+------+-----+
       | first | last | age |
@@ -88,14 +90,14 @@ describe 'ActiveRecordSource' do
     b = [p].to_table
 
     def b.serializable_options
-      {:only => [:first, :last, :age]}
+      { only: %i[first last age] }
     end
 
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   it 'handles column name partials across words' do
-    p = Person.create(:first_name => 'chris', :last_name => 'mo', :age => 43)
+    p = Person.create(first_name: 'chris', last_name: 'mo', age: 43)
     expected = <<~TABLE
       +--------+--------+-----+
       | f_name | l_name | age |
@@ -106,14 +108,14 @@ describe 'ActiveRecordSource' do
     b = [p].to_table
 
     def b.serializable_options
-      {:only => [:f_name, :l_name, :age]}
+      { only: %i[f_name l_name age] }
     end
 
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   it 'handles explicit column aliases' do
-    p = Person.create(:first_name => 'chris', :last_name => 'mo', :age => 43)
+    p = Person.create(first_name: 'chris', last_name: 'mo', age: 43)
     expected = <<~TABLE
       +---------------+----------+-----+
       | primer_nombre | apellido | age |
@@ -129,10 +131,10 @@ describe 'ActiveRecordSource' do
     end
 
     def b.serializable_options
-      {:only => [:first_name, :last_name, :age]}
+      { only: %i[first_name last_name age] }
     end
 
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   it 'handles associations without aliases' do
@@ -141,7 +143,7 @@ describe 'ActiveRecordSource' do
     b = [s].to_table
 
     def b.serializable_options
-      {:only => [:name], :include => {:account => {:only => [:name, :tax_identification_number]}}}
+      { only: [:name], include: { account: { only: %i[name tax_identification_number] } } }
     end
 
     expected = <<~TABLE
@@ -154,7 +156,7 @@ describe 'ActiveRecordSource' do
       +----------+---------+---------------------------+
     TABLE
 
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   it 'handles associations with aliases' do
@@ -163,7 +165,7 @@ describe 'ActiveRecordSource' do
     b = [s].to_table
 
     def b.serializable_options
-      {:only => [:name], :include => {:account => {:only => [:name, :tax_id]}}}
+      { only: [:name], include: { account: { only: %i[name tax_id] } } }
     end
 
     expected = <<~TABLE
@@ -176,7 +178,7 @@ describe 'ActiveRecordSource' do
       +----------+---------+--------+
     TABLE
 
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   it 'retains serializable_options ordering'
@@ -187,7 +189,7 @@ 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'}})
+    p = Person.create(first_name: 'chrismo', custom_attributes: { skills: { instrument: 'piano', style: 'jazz' } })
     b = [p].to_table
 
     a = format_ids([p.id])[0]
@@ -201,12 +203,12 @@ describe 'ActiveRecordSource' do
       +----+------------+-----------+-----+----------------------------------------+
     TABLE
 
-    b.text_table.to_s.should == expected
+    b.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'})
+    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_table
 
@@ -224,12 +226,12 @@ describe 'ActiveRecordSource' do
       +----+------------+-----------+-----+------------+-----------+
     TABLE
 
-    batch.text_table.to_s.should == expected
+    batch.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'})
+    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_table
 
     a, b = format_ids([p1.id, p2.id])
@@ -245,7 +247,7 @@ describe 'ActiveRecordSource' do
       +----+------------+-----------+-----+--------+------------+--------+
     TABLE
 
-    batch.text_table.to_s.should == expected
+    batch.to_s.should == expected
   end
 
   it 'handles AR instance without an association present' do
@@ -253,7 +255,7 @@ describe 'ActiveRecordSource' do
     b = [s].to_table
 
     def b.serializable_options
-      {:only => [:name], :include => {:account => {:only => [:name, :tax_id]}}}
+      { only: [:name], include: { account: { only: %i[name tax_id] } } }
     end
 
     expected = <<~TABLE
@@ -264,11 +266,11 @@ describe 'ActiveRecordSource' do
       +----------+
     TABLE
 
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   it 'properly groups when original columns not sequential' do
-    s2 = Supplier.create(name: 'sup. two', custom_attributes: {a: 1})
+    s2 = Supplier.create(name: 'sup. two', custom_attributes: { a: 1 })
 
     def s2.foo
       ''
@@ -278,7 +280,7 @@ describe 'ActiveRecordSource' do
 
     # methods need Columns as well
     def b.serializable_options
-      {:only => [:name, :custom_attributes], :methods => [:foo]}
+      { only: %i[name custom_attributes], methods: [:foo] }
     end
 
     expected = <<~TABLE
@@ -291,12 +293,12 @@ describe 'ActiveRecordSource' do
       +----------+------+-------------------+
     TABLE
 
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   it 'supports one to many association' do
     p = Parent.create(name: 'parent')
-    c = Child.create(name: 'child', parent: p)
+    Child.create(name: 'child', parent: p)
 
     b = [p].to_table
 
@@ -310,32 +312,32 @@ describe 'ActiveRecordSource' do
     TABLE
 
     def b.serializable_options
-      {:include => {:children => {:only => [:name]}}}
+      { include: { children: { only: [:name] } } }
     end
 
-    b.text_table.to_s.should == expected
+    b.to_s.should == expected
   end
 
   def format_ids(ary)
-    ary.map {|value| " #{value.to_s.ljust(3)}" }
+    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}}
+      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'}}
+      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}}}
+      before = { 'name' => 'chris', account: { 'id' => { 'name' => 'account_name', 'number' => 123_456 } } }
+      expected = { foo: { 'name' => 'chris' }, account: { 'id' => { 'name' => 'account_name', 'number' => 123_456 } } }
       obj.fold_un_sourced_attributes_into_source_hash(:foo, before).should == expected
     end
   end
@@ -344,15 +346,15 @@ describe 'ActiveRecordSource' 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'}
+      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}"}
+      before = { foo: { 'name' => 'chris' }, account: { 'id' => { 'name' => 'account_name', 'number' => 123_456 } } }
+      expected = { 'foo.name' => 'chris', 'account.id' => '{"name"=>"account_name", "number"=>123456}' }
 
       obj.flatten_inner_hashes(before).should == expected
     end