tablesmith 0.4.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 96ab0a18c776e80aa103908884db53eb98cf7a89
-  data.tar.gz: a645ccf65e779cd8b5311b7bd6429d3a48ea752d
+SHA256:
+  metadata.gz: e087948276046a5d4ca9af901465ce4afe11c627acd172b1be29d6a46e018672
+  data.tar.gz: 1f366c3de38e86d801d38a8f1356fa76f11d6b71eb5b5d1c8df59331be3dafcc
 SHA512:
-  metadata.gz: 8e1d90632da2e260c393346d9a4a230dc747bdf1820ab3a95243efd612ad14f6578ba0ae6062300d1685f3dc811617d5c65eaa0e93caca67c37ad7739570985f
-  data.tar.gz: 5162cfc4edc75df6c4019333a87ecd3b867f57f923b9b13cd96b7c6952880cd4202c01cce5a2e145e697eaaec5e3a94c9e31aa5f49ab774dcac8bd64149e781d
+  metadata.gz: b2f5bd5a0c206007be448a651aaf9de768615d526640c0bf3edd760b3e369303da06554aa18cc304faaf4d2940a9dfa824a25a0bbba06f4273e2b6680fb785a2
+  data.tar.gz: effe9b8dcfaa3d1f747006aa05af31d4eb92586af0ab358a17e36ece76b019cc2698178af52a98bd219b3366af1e8051c7c0a012b915fa7da33793bb314e82ad

data/lib/tablesmith.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'tablesmith/delegated_array_class'
 require 'tablesmith/table'
 require 'tablesmith/array_rows_source'
 require 'tablesmith/hash_rows_base'

data/lib/tablesmith/active_record_source.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tablesmith::ActiveRecordSource
   include Tablesmith::HashRowsBase
 
@@ -37,7 +39,7 @@ module Tablesmith::ActiveRecordSource
       end
 
       include.each do |association, opts|
-        ar_class = first.class.reflections[association].klass
+        ar_class = first.class.reflections[association.to_s].klass
         process_columns(opts, ar_class)
       end
     end
@@ -73,7 +75,7 @@ module Tablesmith::ActiveRecordSource
   def flatten_inner_hashes(hash)
     new_hash = {}
     stack = hash.each_pair.to_a
-    while ary = stack.shift
+    while (ary = stack.shift)
       key, value = ary
       if value.is_a?(Hash)
         value.each_pair do |assoc_key, assoc_value|

data/lib/tablesmith/array_rows_source.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tablesmith::ArrayRowsSource
   def text_table
     build_columns if columns.nil?
@@ -11,7 +13,7 @@ module Tablesmith::ArrayRowsSource
   # TODO: no support for deep
   def build_columns
     @columns ||= []
-    self.map do |array_row|
+    map do |array_row|
       @columns << array_row.map { |item| Tablesmith::Column.new(name: item) }
     end
     @columns.flatten!

data/lib/tablesmith/delegated_array_class.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Tablesmith
+  # This adjustment to `DelegateClass(Array)` is necessary to allow calling puts
+  # on a `Tablesmith::Table` and still get the table output, rather than the
+  # default puts output of the underlying `Array`.
+  #
+  # Explaining why requires breaking some things down.
+  #
+  # The implementation of `Kernel::puts` has special code for an `Array`. The
+  # code inside `rb_io_puts` (in io.c) first checks to see if the object passed
+  # to it is a `String`. If not, it then calls `io_puts_ary`, which in turn
+  # calls `rb_check_array_type`. If `rb_check_array_type` confirms the passed
+  # object is an `Array`, then `io_puts_ary` loops over the elements of the
+  # `Array` and passes it to `rb_io_puts`. If the `Array` check fails in the
+  # original `rb_io_puts`, `rb_obj_as_string` is used.
+  #
+  # Early versions of `Tablesmith::Table` subclassed `Array`, but even after
+  # changing `Tablesmith::Table` to use any of the `Delegator` options, the code
+  # in `rb_check_array_type` still detected `Tablesmith::Table` as an `Array`.
+  # How does it do this?
+  #
+  # `rb_check_array_type` calls:
+  #
+  #   `return rb_check_convert_type_with_id(ary, T_ARRAY, "Array", idTo_ary);`
+  #
+  # If a straight up type check fails, then it attempts to convert the object to
+  # an `Array` via the `to_ary` method.
+  #
+  # And wha-lah. We simply need to undefine the `to_ary` method added to
+  # `Tablesmith::Table` by `DelegateClass(Array)` and `rb_io_puts` will no
+  # longer output `Table` as an `Array` and will use its `to_s` method, the same
+  # as `print`.
+  def self.delegated_array_class
+    DelegateClass(Array).tap do |klass|
+      klass.undef_method(:to_ary)
+    end
+  end
+end

data/lib/tablesmith/hash_rows_base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # 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
@@ -8,6 +10,7 @@ module Tablesmith::HashRowsBase
 
   def sort_columns(rows)
     return if column_order.empty?
+
     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.
@@ -32,4 +35,4 @@ module Tablesmith::HashRowsBase
     column_names = rows.first.map(&:first)
     grouped_headers(column_names) + [apply_column_aliases(column_names), :separator]
   end
-end
+end

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

@@ -21,34 +21,32 @@ class HtmlFormatter
 
   def append_table_head
     @lines << "#{indent}<thead>"
-    @lines << "#{indent}<tr>"
     unless @table.empty?
       rows = @table.text_table.rows[0..0]
       append_rows(rows, 'th')
     end
-    @lines << "#{indent}</tr>"
     @lines << "#{indent}</thead>"
   end
 
   def append_table_body
     @lines << "#{indent}<tbody>"
-    @lines << "#{indent}<tr>"
-
     unless @table.empty?
       rows = @table.text_table.rows[2..-1]
       append_rows(rows, 'td')
     end
-    @lines << "#{indent}</tr>"
     @lines << "#{indent}</tbody>"
   end
 
   def append_rows(rows, tag)
     rows.each do |row|
       next if row == :separator
+
+      @lines << "#{indent}<tr>"
       row.map do |cell|
         value = cell_value(cell)
         @lines << "#{indent}#{indent}<#{tag}>#{value}</#{tag}>"
       end
+      @lines << "#{indent}</tr>"
     end
   end
 

data/lib/tablesmith/table.rb

@@ -1,21 +1,40 @@
+# frozen_string_literal: true
+
 require 'text-table'
 require 'csv'
 
 module Tablesmith
-  class Table < Array
+  class Table < Tablesmith.delegated_array_class
+    def initialize(array = [])
+      super(array)
+      @array = array
+    end
+
     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
+      # In order to support `Kernel::puts` of a `Table`, we need to ignore
+      # `to_ary` calls here as well. See comments on `delegated_array_class`.
+      #
+      # While `DelegatorClass(Array)` proactively defines methods on `Table`
+      # that come from `Array`, it _also_ will pass calls through method_missing
+      # to the target object if it says it will respond to it.
+      #
+      # It seems a little redundant, but it is what it is, and so we must also
+      # cut off calls to `to_ary` in both places.
+      return nil if meth_id.to_sym == :to_ary
+
+      super
     end
 
-    def respond_to_missing?
+    def respond_to_missing?(meth_id, _include_all)
+      return false if meth_id.to_sym == :to_ary
+
       super
     end
 
+    def to_s
+      text_table.to_s
+    end
+
     # irb
     def inspect
       pretty_inspect
@@ -32,9 +51,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 +67,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 +90,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 +98,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)
@@ -110,9 +131,7 @@ module Tablesmith
       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
+        groups.each { |name, span| row << {value: name, align: :center, colspan: span} }
         [row, :separator]
       end
     end
@@ -121,7 +140,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 +148,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 +176,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 +192,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.0'.freeze
+  VERSION = '0.6.2'
 end

data/spec/active_record_table_spec.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
+# rubocop:disable Rails/SkipsModelValidations
 describe 'ActiveRecordSource' do
   it 'outputs text table of multiple ActiveRecords' do
     a = Person.new.tap { |c| c.first_name = 'A' }
@@ -12,11 +15,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 +27,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 +43,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 +62,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 +76,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 +91,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 +109,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 +132,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 +144,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 +157,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 +166,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 +179,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 +190,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 +204,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 +227,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 +248,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 +256,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 +267,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 +281,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 +294,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 +313,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,17 +347,18 @@ 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
   end
 end
+# rubocop:enable Rails/SkipsModelValidations