command_line_reporter 3.3.4 → 4.0.2

data/lib/command_line_reporter/column.rb

@@ -4,71 +4,105 @@ module CommandLineReporter
   class Column
     include OptionsValidator
 
-    VALID_OPTIONS = [:width, :padding, :align, :color, :bold, :underline, :reversed]
+    VALID_OPTIONS = %i[width padding align color bold underline reversed span wrap].freeze
     attr_accessor :text, :size, *VALID_OPTIONS
 
     def initialize(text = nil, options = {})
-      self.validate_options(options, *VALID_OPTIONS)
+      validate_options(options, *VALID_OPTIONS)
+      assign_alignment_defaults(options)
+      assign_color_defaults(options)
 
       self.text = text.to_s
 
-      self.width = options[:width]  || 10
-      self.align = options[:align] || 'left'
-      self.padding = options[:padding] || 0
-      self.color = options[:color] || nil
-      self.bold = options[:bold] || false
-      self.underline = options[:underline] || false
-      self.reversed = options[:reversed] || false
-
-      raise ArgumentError unless self.width > 0
-      raise ArgumentError unless self.padding.to_s.match(/^\d+$/)
+      self.wrap = (options.fetch(:wrap, :character).to_s)
+      raise(ArgumentError, ":wrap must be word or character (got #{options[:wrap].inspect})") unless %w(word character).include?(self.wrap)
     end
 
     def size
-      self.width - 2 * self.padding
+      width - (2 * padding) + (3 * (span - 1))
     end
 
     def required_width
-      self.text.to_s.size + 2 * self.padding
+      text.to_s.size + 2 * padding
     end
 
     def screen_rows
-      if self.text.nil? || self.text.empty?
-        [' ' * self.width]
+      if text.nil? || text.empty?
+        [' ' * width]
       else
-        self.text.scan(/.{1,#{self.size}}/m).map {|s| to_cell(s)}
+        reformat_wrapped(text).map { |line| to_cell(line) }
       end
     end
 
     private
 
+    def reformat_wrapped(text)
+      lines = []
+      text.lines.each do |line|
+        line_words = (wrap == 'word') ? line.split(/\s+/) : [line]
+        line_words.each do |word|
+          current_line = lines.last
+          if current_line.nil? || current_line.size + word.size >= size
+            # word does not fit on current line. Add new line(s) handling the case where current
+            # word is longer than line width.
+            lines.concat(word.scan(/.{1,#{size}}/))
+          else
+            # Word fits on current line.
+            (current_line << ' ' << word).strip!
+          end
+        end
+        lines << ''
+      end
+      lines[0..-2]
+    end
+
+    def assign_alignment_defaults(options)
+      self.span = options[:span] || 1
+
+      self.width = options[:width] || 10
+      self.width = Integer(width)
+      self.width *= span
+
+      self.align = options[:align] || 'left'
+
+      self.padding = options[:padding] || 0
+      self.padding = Integer(padding)
+    end
+
+    def assign_color_defaults(options)
+      self.color = options[:color] || nil
+      self.bold = options[:bold] || false
+      self.underline = options[:underline] || false
+      self.reversed = options[:reversed] || false
+    end
+
     def to_cell(str)
       # NOTE: For making underline and reversed work Change so that based on the
       # unformatted text it determines how much spacing to add left and right
       # then colorize the cell text
       cell =  str.empty? ? blank_cell : aligned_cell(str)
-      padding_str = ' ' * self.padding
+      padding_str = ' ' * padding
       padding_str + colorize(cell) + padding_str
     end
 
     def blank_cell
-      ' ' * self.size
+      ' ' * size
     end
 
     def aligned_cell(str)
-      case self.align
+      case align
       when 'left'
-        str.ljust(self.size)
+        str.ljust(size)
       when 'right'
-        str.rjust(self.size)
+        str.rjust(size)
       when 'center'
-        str.ljust((self.size - str.size)/2.0 + str.size).rjust(self.size)
+        str.ljust((size - str.size) / 2.0 + str.size).rjust(size)
       end
     end
 
     def colorize(str)
-      str = str.send(color) if self.color
-      str = str.send('bold') if self.bold
+      str = str.send(color) if color
+      str = str.send('bold') if bold
       str
     end
   end

data/lib/command_line_reporter/formatter/nested.rb

@@ -6,18 +6,18 @@ module CommandLineReporter
     include Singleton
     include OptionsValidator
 
-    VALID_OPTIONS = [:message, :type, :complete, :indent_size, :color, :bold]
+    VALID_OPTIONS = %i[message type complete indent_size color bold].freeze
     attr_accessor :indent_size, :complete_string, :message_string, :color, :bold
 
     def format(options, block)
-      self.validate_options(options, *VALID_OPTIONS)
+      validate_options(options, *VALID_OPTIONS)
 
       indent_level :incr
 
-      padding = ' ' * @indent_level * (options[:indent_size] || self.indent_size)
+      padding = ' ' * @indent_level * (options[:indent_size] || indent_size)
 
-      message_str = padding + (options[:message] || self.message_string)
-      complete_str = options[:complete] || self.complete_string
+      message_str = padding + (options[:message] || message_string)
+      complete_str = options[:complete] || complete_string
 
       if options[:type] == 'inline'
         colorize("#{message_str}...", true, options)
@@ -51,17 +51,13 @@ module CommandLineReporter
       str = str.send(options[:color]) if options[:color]
       str = str.bold if options[:bold]
 
-      if inline
-        print str
-      else
-        puts str
-      end
+      inline ? print(str) : puts(str)
     end
 
     def indent_level(value)
       case value
       when :incr
-        @indent_level = (@indent_level) ? @indent_level + 1 : 0
+        @indent_level = @indent_level ? @indent_level + 1 : 0
       when :decr
         @indent_level -= 1
       end

data/lib/command_line_reporter/formatter/progress.rb

@@ -6,11 +6,11 @@ module CommandLineReporter
     include Singleton
     include OptionsValidator
 
-    VALID_OPTIONS = [:indicator, :color, :bold]
+    VALID_OPTIONS = %i[indicator color bold].freeze
     attr_accessor *VALID_OPTIONS
 
     def format(options, block)
-      self.validate_options(options, *VALID_OPTIONS)
+      validate_options(options, *VALID_OPTIONS)
 
       self.indicator = options[:indicator] if options[:indicator]
       self.color = options[:color]
@@ -22,10 +22,10 @@ module CommandLineReporter
     end
 
     def progress(override = nil)
-      str = override || self.indicator
+      str = override || indicator
 
-      str = str.send(self.color) if self.color
-      str = str.send('bold') if self.bold
+      str = str.send(color) if color
+      str = str.send('bold') if bold
 
       print str
     end

data/lib/command_line_reporter/row.rb

@@ -2,11 +2,11 @@ module CommandLineReporter
   class Row
     include OptionsValidator
 
-    VALID_OPTIONS = [:header, :color, :bold, :encoding]
+    VALID_OPTIONS = %i[header color bold encoding].freeze
     attr_accessor :columns, :border, *VALID_OPTIONS
 
     def initialize(options = {})
-      self.validate_options(options, *VALID_OPTIONS)
+      validate_options(options, *VALID_OPTIONS)
 
       self.columns = []
       self.border = false
@@ -17,29 +17,23 @@ module CommandLineReporter
     end
 
     def add(column)
-      if column.color.nil? && self.color
-        column.color = self.color
-      end
-
-      if self.bold || self.header
-        column.bold = true
-      end
-
-      self.columns << column
+      column.color = color if column.color.nil? && color
+      column.bold = true if bold || header
+      columns << column
     end
 
     def output
       screen_count.times do |sr|
         border_char = use_utf8? ? "\u2503" : '|'
 
-        line = (self.border) ? "#{border_char} " : ''
+        line = border ? "#{border_char} " : ''
 
-        self.columns.size.times do |mc|
-          col = self.columns[mc]
+        columns.size.times do |mc|
+          col = columns[mc]
           # Account for the fact that some columns will have more screen rows than their
           # counterparts in the row.  An example being:
-          # c1 = Column.new('x' * 50, :width => 10)
-          # c2 = Column.new('x' * 20, :width => 10)
+          # c1 = Column.new('x' * 50, width: 10)
+          # c2 = Column.new('x' * 20, width: 10)
           #
           # c1.screen_rows.size == 5
           # c2.screen_rows.size == 2
@@ -58,12 +52,12 @@ module CommandLineReporter
           if col.screen_rows[sr].nil?
             line << ' ' * col.width << ' '
           else
-            line << self.columns[mc].screen_rows[sr] << ' '
+            line << columns[mc].screen_rows[sr] << ' '
           end
 
-          if self.border
+          if border
             line << border_char
-            line << ' ' if mc < self.columns.size - 1
+            line << ' ' if mc < columns.size - 1
           end
         end
 
@@ -74,11 +68,11 @@ module CommandLineReporter
     private
 
     def screen_count
-      @sc ||= self.columns.inject(0) {|max,column| column.screen_rows.size > max ? column.screen_rows.size : max}
+      @sc ||= columns.inject(0) { |a, e| e.screen_rows.size > a ? e.screen_rows.size : a }
     end
 
     def use_utf8?
-      self.encoding == :unicode && "\u2501" != "u2501"
+      encoding == :unicode && "\u2501" != 'u2501'
     end
   end
 end

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.4'
+  VERSION = '4.0.2'.freeze
 end

data/spec/column_spec.rb

@@ -1,94 +1,163 @@
 require 'spec_helper'
 
 describe CommandLineReporter::Column do
-  describe '#initialize' do
+  subject { CommandLineReporter::Column }
+
+  def screen_rows(args = {})
+    described_class.new(text, {width: 5}.merge(args)).screen_rows
+  end
+
+  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
 
-  describe '#screen_rows' do
+  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
+
+  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 +166,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 +186,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 +206,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 +229,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 +250,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 +271,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
@@ -222,32 +291,42 @@ describe CommandLineReporter::Column do
     context 'with wrapping' do
       context 'no padding' do
         context 'left justifies' do
-          let(:text) { 'x' * 25 }
-          let(:full_line) { 'x' * 10 }
-          let(:remainder) { 'x' * 5 }
-          let(:filler) { ' ' * 5 }
+          let(:text) { "one cooperative\n\nbag copy" }
 
-          it 'plain text' do
-            c = CommandLineReporter::Column.new(text, :width => 10)
-            expect(c.screen_rows).to eq([full_line, full_line, remainder + filler])
+          describe 'line-breaks' do
+            it 'do not break output' do
+              expect(screen_rows(width: 20)).to eq(['one cooperative     ', ' ' * 20, 'bag copy            '])
+            end
           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],
-            ])
+          describe 'wrap: word' do
+            it 'tries to break lines between words' do
+              expect(screen_rows(wrap: :word)).to eq(['one  ', 'coope', 'rativ', 'e    ', '     ', 'bag  ', 'copy '])
+            end
+          end
+
+          describe 'wrap: character' do
+            it 'uses "character"-based wrapping by default' do
+              expect(screen_rows).to eq(screen_rows(wrap: :character))
+            end
+
+            it 'ignores word-breaks' do
+              expect(screen_rows).to eq(['one c', 'ooper', 'ative', '     ', '     ', 'bag c', 'opy  '])
+            end
+          end
+
+          it 'outputs color' do
+            screen_rows(color: 'red').each do |row|
+              expect(row).to start_with(controls[:red])
+              expect(row).to end_with(controls[:clear])
+            end
           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],
-            ])
+            screen_rows(bold: true).each do |row|
+              expect(row).to start_with(controls[:bold])
+              expect(row).to end_with(controls[:clear])
+            end
           end
         end
 
@@ -258,26 +337,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 +372,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 +409,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 +447,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 +486,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