command_line_reporter 3.3.6 → 4.0.0

data/lib/command_line_reporter/table.rb

@@ -2,11 +2,11 @@ module CommandLineReporter
   class Table
     include OptionsValidator
 
-    VALID_OPTIONS = [:border, :width, :encoding]
+    VALID_OPTIONS = %i[border width encoding].freeze
     attr_accessor :rows, *VALID_OPTIONS
 
     def initialize(options = {})
-      self.validate_options(options, *VALID_OPTIONS)
+      validate_options(options, *VALID_OPTIONS)
 
       self.border = options[:border] || false
       self.width = options[:width] || false
@@ -14,41 +14,47 @@ module CommandLineReporter
 
       @rows = []
 
-      raise ArgumentError, "Invalid encoding" unless [ :ascii, :unicode ].include? self.encoding
+      raise ArgumentError, 'Invalid encoding' unless %i[ascii unicode].include? encoding
     end
 
     def add(row)
       # Inheritance from the table
-      row.border = self.border
+      row.border = border
 
       # Inherit properties from the appropriate row
-      inherit_column_attrs(row) if self.rows[0]
+      inherit_column_attrs(row) if rows[0]
 
-      self.rows << row
+      rows << row
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
     def output
-      return if self.rows.size == 0 # we got here with nothing to print to the screen
-      auto_adjust_widths if self.width == :auto
+      return if rows.empty? # we got here with nothing to print to the screen
+      auto_adjust_widths if width == :auto
 
-      puts separator('first') if self.border
-      self.rows.each_with_index do |row, index|
+      puts separator('first') if border
+
+      rows.each_with_index do |row, index|
         row.output
-        puts separator('middle') if self.border && (index != self.rows.size - 1)
+        puts separator('middle') if border && (index != rows.size - 1)
       end
-      puts separator('last') if self.border
+
+      puts separator('last') if border
     end
 
+    # TODO: This doesn't appear to be used and if it is, it will not handle span appropriately
     def auto_adjust_widths
       column_widths = []
 
-      self.rows.each do |row|
+      rows.each do |row|
         row.columns.each_with_index do |col, i|
-          column_widths[i] = [ col.required_width, ( column_widths[i] || 0 ) ].max
+          column_widths[i] = [col.required_width, (column_widths[i] || 0)].max
         end
       end
 
-      self.rows.each do |row|
+      rows.each do |row|
         row.columns.each_with_index do |col, i|
           col.width = column_widths[i]
         end
@@ -60,11 +66,11 @@ module CommandLineReporter
     def separator(type = 'middle')
       left, center, right, bar = use_utf8? ? utf8_separator(type) : ascii_separator
 
-      left + self.rows[0].columns.map {|c| bar * (c.width + 2)}.join(center) + right
+      left + rows[0].columns.map { |c| bar * (c.width + 2) }.join(center) + right
     end
 
     def use_utf8?
-      self.encoding == :unicode && "\u2501" != "u2501"
+      encoding == :unicode && "\u2501" != 'u2501'
     end
 
     def ascii_separator
@@ -89,7 +95,7 @@ module CommandLineReporter
     end
 
     def inherit_column_attrs(row)
-      row.columns.each_with_index do |c,i|
+      row.columns.each_with_index do |c, i|
         use_positional_attrs(c, i)
         use_color(row, c, i)
         use_bold(row, c, i)
@@ -97,16 +103,22 @@ module CommandLineReporter
     end
 
     def use_positional_attrs(c, i)
-      # The positional attributes are always required to inheret to make sure the table
+      return if c.span > 1
+
+      # The positional attributes are always required to inherit to make sure the table
       # displays properly
-      %w{align padding width}.each do |attr|
-        val = self.rows[0].columns[i].send(attr)
-        c.send(attr + "=", val)
+      %w[align padding width].each do |attr|
+        val = rows[0].columns[i].send(attr)
+        c.send(attr + '=', val)
       end
+
+      # spanning columns overrides inheritance for width
+      # val = rows[0].columns[i].width
+      # c.width = val unless c.span > 1
     end
 
     def inherit_from
-      self.rows[0].header ? 1 : 0
+      rows[0].header ? 1 : 0
     end
 
     def use_color(row, c, i)
@@ -115,7 +127,7 @@ module CommandLineReporter
       elsif row.color
         c.color = row.color
       elsif inherit_from != 1
-        c.color = self.rows[inherit_from].columns[i].color
+        c.color = rows[inherit_from].columns[i].color
       end
     end
 
@@ -123,7 +135,7 @@ module CommandLineReporter
       if row.bold
         c.bold = row.bold
       elsif inherit_from != 1
-        c.bold = self.rows[inherit_from].columns[i].bold
+        c.bold = rows[inherit_from].columns[i].bold
       end
     end
   end

data/lib/command_line_reporter/version.rb

@@ -1,3 +1,3 @@
 module CommandLineReporter
-  VERSION = '3.3.6'
+  VERSION = '4.0.0'.freeze
 end

data/spec/column_spec.rb

@@ -1,94 +1,159 @@
 require 'spec_helper'
 
 describe CommandLineReporter::Column do
-  describe '#initialize' do
+  subject { CommandLineReporter::Column }
+
+  context '#initialize' do
     it 'rejects invalid options' do
-      expect {
-        CommandLineReporter::Column.new('test', :asdf => '1234')
-      }.to raise_error ArgumentError
+      expect do
+        subject.new('test', asdf: '1234')
+      end.to raise_error ArgumentError
     end
 
     it 'defaults options hash' do
-      expect {
-        CommandLineReporter::Column.new('test')
-      }.to_not raise_error
+      expect do
+        subject.new('test')
+      end.to_not raise_error Exception
     end
 
     it 'defaults the width' do
-      expect(CommandLineReporter::Column.new('test').width).to eq(10)
+      c = subject.new('test')
+      expect(c.width).to eq(10)
     end
 
     it 'accepts the width' do
-      expect(CommandLineReporter::Column.new('test', :width => 50).width).to eq(50)
+      c = subject.new('test', width: 50)
+      expect(c.width).to eq(50)
     end
 
     it 'requires valid width' do
-      expect {
-        CommandLineReporter::Column.new('test', :width => 'asdf')
-      }.to raise_error ArgumentError
+      expect do
+        subject.new('test', width: 'asdf')
+      end.to raise_error ArgumentError
     end
 
     it 'accepts text' do
-      expect(CommandLineReporter::Column.new('asdf').text).to eq('asdf')
+      c = subject.new('asdf')
+      expect(c.text).to eq('asdf')
     end
 
     it 'accepts color' do
-      expect(CommandLineReporter::Column.new('asdf', :color => 'red').color).to eq('red')
+      c = subject.new('asdf', color: 'red')
+      expect(c.color).to eq('red')
     end
 
     it 'accepts bold' do
-      expect(CommandLineReporter::Column.new('asdf', :bold => true).bold).to be true
+      c = subject.new('asdf', bold: true)
+      expect(c.bold).to be true
     end
 
     it 'defaults the padding' do
-      expect(CommandLineReporter::Column.new('test').padding).to eq(0)
+      c = subject.new('test')
+      expect(c.padding).to eq(0)
     end
 
     it 'accepts the padding' do
-      expect(CommandLineReporter::Column.new('test', :padding => 5).padding).to eq(5)
+      c = subject.new('test', padding: 5)
+      expect(c.padding).to eq(5)
     end
 
     it 'requires valid width' do
-      expect {
-        CommandLineReporter::Column.new('test', :padding => 'asdf')
-      }.to raise_error ArgumentError
+      expect do
+        subject.new('test', padding: 'asdf')
+      end.to raise_error ArgumentError
     end
   end
 
-  describe '#size' do
-    it 'is the width less twice the padding' do
-      expect(CommandLineReporter::Column.new('test').size).to eq(10)
-      expect(CommandLineReporter::Column.new('test', :width => 5).size).to eq(5)
-      expect(CommandLineReporter::Column.new('test', :width => 5, :padding => 1).size).to eq(3)
+  context '#size' do
+    it 'should have default width' do
+      c = subject.new('test')
+      expect(c.size).to eq(10)
+    end
+
+    it 'should have custom width' do
+      c = subject.new('test', width: 5)
+      expect(c.size).to eq(5)
+    end
+
+    it 'should be reduced by the padding' do
+      c = subject.new('test', width: 5, padding: 1)
+      expect(c.size).to eq(3)
     end
   end
 
-  describe '#required_width' do
+  context '#required_width' do
     it 'is the length of the text plus twice the padding' do
-      expect(CommandLineReporter::Column.new('test').required_width).to eq(4)
-      expect(CommandLineReporter::Column.new('test', :padding => 1).required_width).to eq(6)
-      expect(CommandLineReporter::Column.new('test', :padding => 5).required_width).to eq(14)
+      c = subject.new('test')
+      expect(c.required_width).to eq(4)
+    end
+
+    it 'should be length of string plus twice default padding' do
+      c = subject.new('test', padding: 1)
+      expect(c.required_width).to eq(6)
+    end
+
+    it 'should be length of string plus twice custom padding' do
+      c = subject.new('test', padding: 5)
+      expect(c.required_width).to eq(14)
+    end
+  end
+
+  context 'spanning columns' do
+    it 'should adjust width for 2 default columns' do
+      col = subject.new('test', span: 2)
+      expect(col.width).to eq(20)
+      expect(col.size).to eq(23)
+    end
+
+    it 'should adjust width for 2 custom sized columns' do
+      col = subject.new('test', width: 20, span: 2)
+      expect(col.width).to eq(40)
+      expect(col.size).to eq(43)
+    end
+
+    it 'should adjust width for 3 default columns' do
+      col = subject.new('test', span: 3)
+      expect(col.width).to eq(30)
+      expect(col.size).to eq(36)
+    end
+
+    it 'should adjust width for 3 custom sized columns' do
+      col = subject.new('test', width: 20, span: 3)
+      expect(col.width).to eq(60)
+      expect(col.size).to eq(66)
+    end
+
+    it 'should adjust width for 4 default columns' do
+      col = subject.new('test', span: 4)
+      expect(col.width).to eq(40)
+      expect(col.size).to eq(49)
+    end
+
+    it 'should adjust width for 2 custom sized columns' do
+      col = subject.new('test', width: 20, span: 4)
+      expect(col.width).to eq(80)
+      expect(col.size).to eq(89)
     end
   end
 
-  describe '#screen_rows' do
+  context '#screen_rows' do
     let :controls do
       {
-        :clear => "\e[0m",
-        :bold => "\e[1m",
-        :red => "\e[31m",
+        clear: "\e[0m",
+        bold: "\e[1m",
+        red: "\e[31m"
       }
     end
 
     context 'no wrapping' do
       context 'no padding' do
         it 'gives a single row' do
-          c = CommandLineReporter::Column.new('x' * 5)
+          c = subject.new('x' * 5)
           c.screen_rows.size == 1
         end
 
         it 'handles empty text' do
-          c = CommandLineReporter::Column.new
+          c = subject.new
           expect(c.screen_rows[0]).to eq(' ' * 10)
         end
 
@@ -97,17 +162,17 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 10 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :width => 20)
+            c = subject.new(text, width: 20)
             expect(c.screen_rows[0]).to eq(text + filler)
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :align => 'left', :width => 20, :color => 'red')
+            c = subject.new(text, align: 'left', width: 20, color: 'red')
             expect(c.screen_rows[0]).to eq(controls[:red] + text + filler + controls[:clear])
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :align => 'left', :width => 20, :bold => true)
+            c = subject.new(text, align: 'left', width: 20, bold: true)
             expect(c.screen_rows[0]).to eq(controls[:bold] + text + filler + controls[:clear])
           end
         end
@@ -117,17 +182,17 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 10 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :width => 20)
+            c = subject.new(text, align: 'right', width: 20)
             expect(c.screen_rows[0]).to eq(filler + text)
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :width => 20, :color => 'red')
-            expect(c.screen_rows[0]).to eq(controls[:red] + filler + text  + controls[:clear])
+            c = subject.new(text, align: 'right', width: 20, color: 'red')
+            expect(c.screen_rows[0]).to eq(controls[:red] + filler + text + controls[:clear])
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :width => 20, :bold => true)
+            c = subject.new(text, align: 'right', width: 20, bold: true)
             expect(c.screen_rows[0]).to eq(controls[:bold] + filler + text + controls[:clear])
           end
         end
@@ -137,17 +202,17 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 5 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :align => 'center', :width => 20)
+            c = subject.new(text, align: 'center', width: 20)
             expect(c.screen_rows[0]).to eq(filler + text + filler)
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :align => 'center', :width => 20, :color => 'red')
+            c = subject.new(text, align: 'center', width: 20, color: 'red')
             expect(c.screen_rows[0]).to eq(controls[:red] + filler + text + filler + controls[:clear])
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :align => 'center', :width => 20, :bold => true)
+            c = subject.new(text, align: 'center', width: 20, bold: true)
             expect(c.screen_rows[0]).to eq(controls[:bold] + filler + text + filler + controls[:clear])
           end
         end
@@ -160,17 +225,17 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 10 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :padding => 5, :width => 30)
+            c = subject.new(text, padding: 5, width: 30)
             expect(c.screen_rows[0]).to eq(padding + text + filler + padding)
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :padding => 5, :width => 30, :color => 'red')
+            c = subject.new(text, padding: 5, width: 30, color: 'red')
             expect(c.screen_rows[0]).to eq(padding + controls[:red] + text + filler + controls[:clear] + padding)
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :padding => 5, :width => 30, :bold => true)
+            c = subject.new(text, padding: 5, width: 30, bold: true)
             expect(c.screen_rows[0]).to eq(padding + controls[:bold] + text + filler + controls[:clear] + padding)
           end
         end
@@ -181,17 +246,17 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 10 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 5, :width => 30)
+            c = subject.new(text, align: 'right', padding: 5, width: 30)
             expect(c.screen_rows[0]).to eq(padding + filler + text + padding)
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 5, :width => 30, :color => 'red')
+            c = subject.new(text, align: 'right', padding: 5, width: 30, color: 'red')
             expect(c.screen_rows[0]).to eq(padding + controls[:red] + filler + text + controls[:clear] + padding)
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 5, :width => 30, :bold => true)
+            c = subject.new(text, align: 'right', padding: 5, width: 30, bold: true)
             expect(c.screen_rows[0]).to eq(padding + controls[:bold] + filler + text + controls[:clear] + padding)
           end
         end
@@ -202,17 +267,17 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 5 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :align => 'center', :padding => 5, :width => 30)
+            c = subject.new(text, align: 'center', padding: 5, width: 30)
             expect(c.screen_rows[0]).to eq(padding + filler + text + filler + padding)
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :align => 'center', :padding => 5, :width => 30, :color => 'red')
+            c = subject.new(text, align: 'center', padding: 5, width: 30, color: 'red')
             expect(c.screen_rows[0]).to eq(padding + controls[:red] + filler + text + filler + controls[:clear] + padding)
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :align => 'center', :padding => 5, :width => 30, :bold => true)
+            c = subject.new(text, align: 'center', padding: 5, width: 30, bold: true)
             expect(c.screen_rows[0]).to eq(padding + controls[:bold] + filler + text + filler + controls[:clear] + padding)
           end
         end
@@ -228,26 +293,30 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 5 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :width => 10)
+            c = subject.new(text, width: 10)
             expect(c.screen_rows).to eq([full_line, full_line, remainder + filler])
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :width => 10, :color => 'red')
-            expect(c.screen_rows).to eq([
-              controls[:red] + full_line + controls[:clear],
-              controls[:red] + full_line + controls[:clear],
-              controls[:red] + remainder + filler + controls[:clear],
-            ])
+            c = subject.new(text, width: 10, color: 'red')
+            expect(c.screen_rows).to eq(
+              [
+                controls[:red] + full_line + controls[:clear],
+                controls[:red] + full_line + controls[:clear],
+                controls[:red] + remainder + filler + controls[:clear]
+              ]
+            )
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :width => 10, :bold => true)
-            expect(c.screen_rows).to eq([
-              controls[:bold] + full_line + controls[:clear],
-              controls[:bold] + full_line + controls[:clear],
-              controls[:bold] + remainder + filler + controls[:clear],
-            ])
+            c = subject.new(text, width: 10, bold: true)
+            expect(c.screen_rows).to eq(
+              [
+                controls[:bold] + full_line + controls[:clear],
+                controls[:bold] + full_line + controls[:clear],
+                controls[:bold] + remainder + filler + controls[:clear]
+              ]
+            )
           end
         end
 
@@ -258,26 +327,30 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 5 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :width => 10)
+            c = subject.new(text, align: 'right', width: 10)
             expect(c.screen_rows).to eq([full_line, full_line, filler + remainder])
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :width => 10, :color => 'red')
-            expect(c.screen_rows).to eq([
-              controls[:red] + full_line + controls[:clear],
-              controls[:red] + full_line + controls[:clear],
-              controls[:red] + filler + remainder + controls[:clear],
-            ])
+            c = subject.new(text, align: 'right', width: 10, color: 'red')
+            expect(c.screen_rows).to eq(
+              [
+                controls[:red] + full_line + controls[:clear],
+                controls[:red] + full_line + controls[:clear],
+                controls[:red] + filler + remainder + controls[:clear]
+              ]
+            )
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :width => 10, :bold => true)
-            expect(c.screen_rows).to eq([
-              controls[:bold] + full_line + controls[:clear],
-              controls[:bold] + full_line + controls[:clear],
-              controls[:bold] + filler + remainder + controls[:clear],
-            ])
+            c = subject.new(text, align: 'right', width: 10, bold: true)
+            expect(c.screen_rows).to eq(
+              [
+                controls[:bold] + full_line + controls[:clear],
+                controls[:bold] + full_line + controls[:clear],
+                controls[:bold] + filler + remainder + controls[:clear]
+              ]
+            )
           end
         end
 
@@ -289,26 +362,30 @@ describe CommandLineReporter::Column do
           let(:right_filler) { ' ' * 2 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :align => 'center', :width => 10)
+            c = subject.new(text, align: 'center', width: 10)
             expect(c.screen_rows).to eq([full_line, full_line, ' ' * 3 + remainder + right_filler])
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :align => 'center', :width => 10, :color => 'red')
-            expect(c.screen_rows).to eq([
-              controls[:red] + full_line + controls[:clear],
-              controls[:red] + full_line + controls[:clear],
-              controls[:red] + left_filler + remainder + right_filler + controls[:clear],
-            ])
+            c = subject.new(text, align: 'center', width: 10, color: 'red')
+            expect(c.screen_rows).to eq(
+              [
+                controls[:red] + full_line + controls[:clear],
+                controls[:red] + full_line + controls[:clear],
+                controls[:red] + left_filler + remainder + right_filler + controls[:clear]
+              ]
+            )
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :align => 'center', :width => 10, :bold => true)
-            expect(c.screen_rows).to eq([
-              controls[:bold] + full_line + controls[:clear],
-              controls[:bold] + full_line + controls[:clear],
-              controls[:bold] + left_filler + remainder + right_filler + controls[:clear],
-            ])
+            c = subject.new(text, align: 'center', width: 10, bold: true)
+            expect(c.screen_rows).to eq(
+              [
+                controls[:bold] + full_line + controls[:clear],
+                controls[:bold] + full_line + controls[:clear],
+                controls[:bold] + left_filler + remainder + right_filler + controls[:clear]
+              ]
+            )
           end
         end
       end
@@ -322,27 +399,33 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 7 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :padding => 2, :width => 20)
-            expect(c.screen_rows).to eq([
-              padding + full_line + padding,
-              padding + remainder + filler + padding,
-            ])
+            c = subject.new(text, padding: 2, width: 20)
+            expect(c.screen_rows).to eq(
+              [
+                padding + full_line + padding,
+                padding + remainder + filler + padding
+              ]
+            )
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :padding => 2, :width => 20, :color => 'red')
-            expect(c.screen_rows).to eq([
-              padding + controls[:red] + full_line + controls[:clear] + padding,
-              padding + controls[:red] + remainder + filler + controls[:clear] + padding,
-            ])
+            c = subject.new(text, padding: 2, width: 20, color: 'red')
+            expect(c.screen_rows).to eq(
+              [
+                padding + controls[:red] + full_line + controls[:clear] + padding,
+                padding + controls[:red] + remainder + filler + controls[:clear] + padding
+              ]
+            )
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :padding => 2, :width => 20, :bold => true)
-            expect(c.screen_rows).to eq([
-              padding + controls[:bold] + full_line + controls[:clear] + padding,
-              padding + controls[:bold] + remainder + filler + controls[:clear] + padding,
-            ])
+            c = subject.new(text, padding: 2, width: 20, bold: true)
+            expect(c.screen_rows).to eq(
+              [
+                padding + controls[:bold] + full_line + controls[:clear] + padding,
+                padding + controls[:bold] + remainder + filler + controls[:clear] + padding
+              ]
+            )
           end
         end
 
@@ -354,27 +437,33 @@ describe CommandLineReporter::Column do
           let(:filler) { ' ' * 7 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :padding => 2, :align => 'right', :width => 20)
-            expect(c.screen_rows).to eq([
-              padding + full_line + padding,
-              padding + filler + remainder + padding,
-            ])
+            c = subject.new(text, padding: 2, align: 'right', width: 20)
+            expect(c.screen_rows).to eq(
+              [
+                padding + full_line + padding,
+                padding + filler + remainder + padding
+              ]
+            )
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 2, :width => 20, :color => 'red')
-            expect(c.screen_rows).to eq([
-              padding + controls[:red] + full_line + controls[:clear] + padding,
-              padding + controls[:red] + filler + remainder + controls[:clear] + padding,
-            ])
+            c = subject.new(text, align: 'right', padding: 2, width: 20, color: 'red')
+            expect(c.screen_rows).to eq(
+              [
+                padding + controls[:red] + full_line + controls[:clear] + padding,
+                padding + controls[:red] + filler + remainder + controls[:clear] + padding
+              ]
+            )
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 2, :width => 20, :bold => true)
-            expect(c.screen_rows).to eq([
-              padding + controls[:bold] + full_line + controls[:clear] + padding,
-              padding + controls[:bold] + filler + remainder + controls[:clear] + padding,
-            ])
+            c = subject.new(text, align: 'right', padding: 2, width: 20, bold: true)
+            expect(c.screen_rows).to eq(
+              [
+                padding + controls[:bold] + full_line + controls[:clear] + padding,
+                padding + controls[:bold] + filler + remainder + controls[:clear] + padding
+              ]
+            )
           end
         end
 
@@ -387,27 +476,33 @@ describe CommandLineReporter::Column do
           let(:right_filler) { ' ' * 3 }
 
           it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :padding => 2, :align => 'center', :width => 20)
-            expect(c.screen_rows).to eq([
-              padding + full_line + padding,
-              padding + left_filler + remainder + right_filler + padding,
-            ])
+            c = subject.new(text, padding: 2, align: 'center', width: 20)
+            expect(c.screen_rows).to eq(
+              [
+                padding + full_line + padding,
+                padding + left_filler + remainder + right_filler + padding
+              ]
+            )
           end
 
           it 'outputs red' do
-            c = CommandLineReporter::Column.new(text, :padding => 2, :align => 'center', :width => 20, :color => 'red')
-            expect(c.screen_rows).to eq([
-              padding + controls[:red] + full_line + controls[:clear] + padding,
-              padding + controls[:red] + left_filler + remainder + right_filler + controls[:clear] + padding,
-            ])
+            c = subject.new(text, padding: 2, align: 'center', width: 20, color: 'red')
+            expect(c.screen_rows).to eq(
+              [
+                padding + controls[:red] + full_line + controls[:clear] + padding,
+                padding + controls[:red] + left_filler + remainder + right_filler + controls[:clear] + padding
+              ]
+            )
           end
 
           it 'outputs bold' do
-            c = CommandLineReporter::Column.new(text, :padding => 2, :align => 'center', :width => 20, :bold => true)
-            expect(c.screen_rows).to eq([
-              padding + controls[:bold] + full_line + controls[:clear] + padding,
-              padding + controls[:bold] + left_filler + remainder + right_filler + controls[:clear] + padding,
-            ])
+            c = subject.new(text, padding: 2, align: 'center', width: 20, bold: true)
+            expect(c.screen_rows).to eq(
+              [
+                padding + controls[:bold] + full_line + controls[:clear] + padding,
+                padding + controls[:bold] + left_filler + remainder + right_filler + controls[:clear] + padding
+              ]
+            )
           end
         end
       end