highline 2.0.0.pre.develop.9 → 2.0.0.pre.develop.11

data/lib/highline/builtin_styles.rb

@@ -1,4 +1,4 @@
-#coding: utf-8
+# coding: utf-8
 
 class HighLine
   # Builtin Styles that are included at HighLine initialization.
@@ -23,17 +23,19 @@ class HighLine
       blink:      "\e[5m",
       reverse:    "\e[7m",
       concealed:  "\e[8m"
-    }
+    }.freeze
 
     STYLE_LIST.each do |style_name, code|
-     style = String(style_name).upcase
+      style = String(style_name).upcase
 
-     const_set style, code
-     const_set style + "_STYLE", Style.new(name: style_name, code: code, builtin: true)
+      const_set style, code
+      const_set style + "_STYLE",
+                Style.new(name: style_name, code: code, builtin: true)
     end
 
     # Basic Style names like CLEAR, BOLD, UNDERLINE
-    STYLES = %w{CLEAR RESET BOLD DARK UNDERLINE UNDERSCORE BLINK REVERSE CONCEALED}
+    STYLES = %w[CLEAR RESET BOLD DARK UNDERLINE
+                UNDERSCORE BLINK REVERSE CONCEALED].freeze
 
     # A Hash with the basic colors an their ANSI escape codes.
     COLOR_LIST = {
@@ -48,33 +50,35 @@ class HighLine
       gray:    { code: "\e[37m", rgb: [192, 192, 192] },
       grey:    { code: "\e[37m", rgb: [192, 192, 192] },
       none:    { code: "\e[38m", rgb: [0, 0, 0] }
-    }
+    }.freeze
 
     COLOR_LIST.each do |color_name, attributes|
-     color = String(color_name).upcase
+      color = String(color_name).upcase
 
-     style = Style.new(
-      name: color_name,
-      code: attributes[:code],
-      rgb:  attributes[:rgb],
-      builtin: true
-     )
+      style = Style.new(
+        name: color_name,
+        code: attributes[:code],
+        rgb:  attributes[:rgb],
+        builtin: true
+      )
 
-     const_set color + "_STYLE", style
+      const_set color + "_STYLE", style
     end
 
     # The builtin styles basic colors like black, red, green.
-    BASIC_COLORS = %w{BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE GRAY GREY NONE}
+    BASIC_COLORS =
+      %w[BLACK RED GREEN YELLOW BLUE
+         MAGENTA CYAN WHITE GRAY GREY NONE].freeze
 
     colors = BASIC_COLORS.dup
     BASIC_COLORS.each do |color|
       bright_color = "BRIGHT_#{color}"
       colors << bright_color
-      const_set bright_color + '_STYLE', const_get(color + '_STYLE').bright
+      const_set bright_color + "_STYLE", const_get(color + "_STYLE").bright
 
       light_color = "LIGHT_#{color}"
       colors << light_color
-      const_set light_color + '_STYLE', const_get(color + '_STYLE').light
+      const_set light_color + "_STYLE", const_get(color + "_STYLE").light
     end
 
     # The builtin styles' colors like LIGHT_RED and BRIGHT_BLUE.
@@ -86,11 +90,10 @@ class HighLine
       const_set "ON_#{color}", const_get("ON_#{color}_STYLE").code
     end
 
-    ON_NONE_STYLE.rgb = [255,255,255] # Override; white background
+    ON_NONE_STYLE.rgb = [255, 255, 255] # Override; white background
 
     # BuiltinStyles class methods to be extended.
     module ClassMethods
-
       # Regexp to match against RGB style constant names.
       RGB_COLOR_PATTERN = /^(ON_)?(RGB_)([A-F0-9]{6})(_STYLE)?$/
 
@@ -98,27 +101,28 @@ class HighLine
       # builtin constants (without explicitly defining them)
       # @param name [Symbol] missing constant name
       def const_missing(name)
-        if name.to_s =~ RGB_COLOR_PATTERN
-          on = $1
-          suffix = $4
-
-          if suffix
-            code_name = $1.to_s + $2 + $3
-          else
-            code_name = name.to_s
-          end
-
-          style_name = code_name + '_STYLE'
-          style = Style.rgb($3)
-          style = style.on if on
-
-          const_set(style_name, style)
-          const_set(code_name, style.code)
-
-          suffix ? style : style.code
-        else
-          raise NameError, "Bad color or uninitialized constant #{name}"
-        end
+        raise NameError, "Bad color or uninitialized constant #{name}" unless
+          name.to_s =~ RGB_COLOR_PATTERN
+
+        on = Regexp.last_match(1)
+        suffix = Regexp.last_match(4)
+
+        code_name = if suffix
+                      Regexp.last_match(1).to_s +
+                        Regexp.last_match(2) +
+                        Regexp.last_match(3)
+                    else
+                      name.to_s
+                    end
+
+        style_name = code_name + "_STYLE"
+        style = Style.rgb(Regexp.last_match(3))
+        style = style.on if on
+
+        const_set(style_name, style)
+        const_set(code_name, style.code)
+
+        suffix ? style : style.code
       end
     end
   end

data/lib/highline/color_scheme.rb

@@ -8,7 +8,6 @@
 #
 # This is Free Software.  See LICENSE and COPYING for details
 
-
 class HighLine
   #
   # ColorScheme objects encapsulate a named set of colors to be used in the
@@ -19,7 +18,8 @@ class HighLine
   #
   # A ColorScheme contains named sets of HighLine color constants.
   #
-  # @example Instantiating a color scheme, applying it to HighLine, and using it:
+  # @example Instantiating a color scheme, applying it to HighLine,
+  #   and using it:
   #   ft = HighLine::ColorScheme.new do |cs|
   #          cs[:headline]        = [ :bold, :yellow, :on_black ]
   #          cs[:horizontal_line] = [ :bold, :white ]
@@ -49,15 +49,15 @@ class HighLine
     # constants.
     #
     # @param h [Hash]
-    def initialize( h = nil )
-      @scheme = Hash.new
+    def initialize(h = nil)
+      @scheme = {}
       load_from_hash(h) if h
       yield self if block_given?
     end
 
     # Load multiple colors from key/value pairs.
     # @param h [Hash]
-    def load_from_hash( h )
+    def load_from_hash(h)
       h.each_pair do |color_tag, constants|
         self[color_tag] = constants
       end
@@ -66,20 +66,20 @@ class HighLine
     # Does this color scheme include the given tag name?
     # @param color_tag [#to_sym]
     # @return [Boolean]
-    def include?( color_tag )
+    def include?(color_tag)
       @scheme.keys.include?(to_symbol(color_tag))
     end
 
     # Allow the scheme to be accessed like a Hash.
     # @param color_tag [#to_sym]
     # @return [Style]
-    def []( color_tag )
+    def [](color_tag)
       @scheme[to_symbol(color_tag)]
     end
 
     # Retrieve the original form of the scheme
     # @param color_tag [#to_sym]
-    def definition( color_tag )
+    def definition(color_tag)
       style = @scheme[to_symbol(color_tag)]
       style && style.list
     end
@@ -93,29 +93,33 @@ class HighLine
     # Allow the scheme to be set like a Hash.
     # @param color_tag [#to_sym]
     # @param constants [Array<Symbol>] Array of Style symbols
-    def []=( color_tag, constants )
-      @scheme[to_symbol(color_tag)] = HighLine::Style.new(:name=>color_tag.to_s.downcase.to_sym,
-                                                          :list=>constants, :no_index=>true)
+    def []=(color_tag, constants)
+      @scheme[to_symbol(color_tag)] =
+        HighLine::Style.new(name: color_tag.to_s.downcase.to_sym,
+                            list: constants,
+                            no_index: true)
     end
 
     # Retrieve the color scheme hash (in original definition format)
     # @return [Hash] scheme as Hash. It may be reused in a new ColorScheme.
     def to_hash
-      @scheme.inject({}) { |hsh, pair| key, value = pair; hsh[key] = value.list; hsh }
+      @scheme.each_with_object({}) do |pair, hsh|
+        key, value = pair
+        hsh[key] = value.list
+      end
     end
 
-
     private
 
     # Return a normalized representation of a color name.
-    def to_symbol( t )
+    def to_symbol(t)
       t.to_s.downcase
     end
 
     # Return a normalized representation of a color setting.
-    def to_constant( v )
+    def to_constant(v)
       v = v.to_s if v.is_a?(Symbol)
-      if v.is_a?(::String) then
+      if v.is_a?(::String)
         HighLine.const_get(v.upcase)
       else
         v
@@ -125,23 +129,23 @@ class HighLine
 
   # A sample ColorScheme.
   class SampleColorScheme < ColorScheme
+    SAMPLE_SCHEME = {
+      critical: [:yellow, :on_red],
+      error: [:bold, :red],
+      warning: [:bold, :yellow],
+      notice: [:bold, :magenta],
+      info: [:bold, :cyan],
+      debug: [:bold, :green],
+      row_even: [:cyan],
+      row_odd: [:magenta]
+    }.freeze
     #
     # Builds the sample scheme with settings for <tt>:critical</tt>,
     # <tt>:error</tt>, <tt>:warning</tt>, <tt>:notice</tt>, <tt>:info</tt>,
     # <tt>:debug</tt>, <tt>:row_even</tt>, and <tt>:row_odd</tt> colors.
     #
-    def initialize( h = nil )
-      scheme = {
-        :critical => [ :yellow, :on_red  ],
-        :error    => [ :bold,   :red     ],
-        :warning  => [ :bold,   :yellow  ],
-        :notice   => [ :bold,   :magenta ],
-        :info     => [ :bold,   :cyan    ],
-        :debug    => [ :bold,   :green   ],
-        :row_even => [ :cyan    ],
-        :row_odd  => [ :magenta ]
-      }
-      super(scheme)
+    def initialize(_h = nil)
+      super(SAMPLE_SCHEME)
     end
   end
 end

data/lib/highline/compatibility.rb

@@ -4,13 +4,13 @@ unless STDIN.respond_to? :getbyte
   # HighLine adds #getbyte alias to #getc when #getbyte is not available.
   class IO
     # alias to #getc when #getbyte is not available
-    alias_method :getbyte, :getc
+    alias getbyte getc
   end
 
   # HighLine adds #getbyte alias to #getc when #getbyte is not available.
   class StringIO
     # alias to #getc when #getbyte is not available
-    alias_method :getbyte, :getc
+    alias getbyte getc
   end
 end
 
@@ -18,6 +18,6 @@ unless "".respond_to? :each_line
   # HighLine adds #each_line alias to #each when each_line is not available.
   class String
     # alias to #each when each_line is not available.
-    alias_method :each_line, :each
+    alias each_line each
   end
 end

data/lib/highline/custom_errors.rb

@@ -1,5 +1,6 @@
-class HighLine
+# encoding: utf-8
 
+class HighLine
   # Internal HighLine errors.
   module CustomErrors
     # An error that responds to :explanation_key

data/lib/highline/import.rb

@@ -10,22 +10,19 @@
 require "highline"
 require "forwardable"
 
-$terminal = HighLine.new
-
 #
 # <tt>require "highline/import"</tt> adds shortcut methods to Kernel, making
 # {HighLine#agree}, {HighLine#ask}, {HighLine#choose} and {HighLine#say}
 # globally available.  This is handy for
-# quick and dirty input and output.  These methods use the HighLine object in
-# the global variable <tt>$terminal</tt>, which is initialized to use
-# <tt>$stdin</tt> and <tt>$stdout</tt> (you are free to change this).
-# Otherwise, these methods are identical to their {HighLine} counterparts, see that
-# class for detailed explanations.
+# quick and dirty input and output.  These methods use HighLine.default_instance
+# which is initialized to use <tt>$stdin</tt> and <tt>$stdout</tt> (you are free
+# to change this).
+# Otherwise, these methods are identical to their {HighLine} counterparts,
+# see that class for detailed explanations.
 #
 module Kernel
   extend Forwardable
-  def_delegators :$terminal, :agree, :ask, :choose, :say,
-                 :use_color=, :use_color?, :reset_use_color
+  def_instance_delegators :HighLine, :agree, :ask, :choose, :say
 end
 
 # When requiring 'highline/import' HighLine adds {#or_ask} to Object so
@@ -41,11 +38,11 @@ class Object
   # @param details [lambda] block to be called with the question
   #   instance as argument.
   # @return [String] answer
-  def or_ask( *args, &details )
+  def or_ask(*args, &details)
     ask(*args) do |question|
       question.first_answer = String(self)
 
-      details.call(question) if details
+      yield(question) if details
     end
   end
 end

data/lib/highline/list.rb

@@ -1,10 +1,8 @@
 # coding: utf-8
 
 class HighLine
-
   # List class with some convenience methods like {#col_down}.
   class List
-
     # Original given *items* argument.
     # It's frozen at initialization time and
     # all later transformations will happen on {#list}.
@@ -33,7 +31,6 @@ class HighLine
 
     attr_reader :transpose_mode
 
-
     # Content are distributed first by column in col down mode.
     # @return [Boolean]
     #
@@ -69,7 +66,8 @@ class HighLine
       build
     end
 
-    # Transpose the (already sliced by rows) list, turning its rows into columns.
+    # Transpose the (already sliced by rows) list,
+    #   turning its rows into columns.
     # @return [self]
     def transpose
       first_row = @list[0]
@@ -141,9 +139,7 @@ class HighLine
 
     # Set the {#row_join_string}.
     # @see #row_join_string
-    def row_join_string=(string)
-      @row_join_string = string
-    end
+    attr_writer :row_join_string
 
     # Returns the row join string size.
     # Useful for calculating the actual size of
@@ -178,4 +174,4 @@ class HighLine
       row.compact.join(row_join_string) + "\n"
     end
   end
-end
+end

data/lib/highline/list_renderer.rb

@@ -1,251 +1,257 @@
 # coding: utf-8
 
-require 'highline/template_renderer'
-require 'highline/wrapper'
-require 'highline/list'
-
-#
-# This class is a utility for quickly and easily laying out lists
-# to be used by HighLine.
-#
-class HighLine::ListRenderer
-  # Items list
-  # @return [Array]
-  attr_reader :items
-
-  # @return [Symbol] the current mode the List is being rendered
-  # @see #initialize for more details see mode parameter of #initialize
-  attr_reader :mode
-
-  # Changes the behaviour of some modes. Example, in :inline mode
-  # the option is treated as the 'end separator' (defaults to " or ")
-  # @return option parameter that changes the behaviour of some modes.
-  attr_reader :option
-
-  # @return [HighLine] context
-  attr_reader :highline
-
-  # The only required parameters are _items_ and _highline_.
-  # @param items [Array] the Array of items to list
-  # @param mode [Symbol] controls how that list is formed
-  # @param option has different effects, depending on the _mode_.
-  # @param highline [HighLine] a HighLine instance to direct the output to.
-  #
-  # Recognized modes are:
+require "highline/template_renderer"
+require "highline/wrapper"
+require "highline/list"
+
+class HighLine
   #
-  # <tt>:columns_across</tt>::         _items_ will be placed in columns,
-  #                                    flowing from left to right.  If given,
-  #                                    _option_ is the number of columns to be
-  #                                    used.  When absent, columns will be
-  #                                    determined based on _wrap_at_ or a
-  #                                    default of 80 characters.
-  # <tt>:columns_down</tt>::           Identical to <tt>:columns_across</tt>,
-  #                                    save flow goes down.
-  # <tt>:uneven_columns_across</tt>::  Like <tt>:columns_across</tt> but each
-  #                                    column is sized independently.
-  # <tt>:uneven_columns_down</tt>::    Like <tt>:columns_down</tt> but each
-  #                                    column is sized independently.
-  # <tt>:inline</tt>::                 All _items_ are placed on a single line.
-  #                                    The last two _items_ are separated by
-  #                                    _option_ or a default of " or ".  All
-  #                                    other _items_ are separated by ", ".
-  # <tt>:rows</tt>::                   The default mode.  Each of the _items_ is
-  #                                    placed on its own line.  The _option_
-  #                                    parameter is ignored in this mode.
+  # This class is a utility for quickly and easily laying out lists
+  # to be used by HighLine.
   #
-  # Each member of the _items_ Array is passed through ERb and thus can contain
-  # their own expansions.  Color escape expansions do not contribute to the
-  # final field width.
-
-  def initialize(items, mode = :rows, option = nil, highline)
-    @highline = highline
-    @mode     = mode
-    @option   = option
-    @items    = render_list_items(items)
-  end
+  class ListRenderer
+    # Items list
+    # @return [Array]
+    attr_reader :items
+
+    # @return [Symbol] the current mode the List is being rendered
+    # @see #initialize for more details see mode parameter of #initialize
+    attr_reader :mode
+
+    # Changes the behaviour of some modes. Example, in :inline mode
+    # the option is treated as the 'end separator' (defaults to " or ")
+    # @return option parameter that changes the behaviour of some modes.
+    attr_reader :option
+
+    # @return [HighLine] context
+    attr_reader :highline
+
+    # The only required parameters are _items_ and _highline_.
+    # @param items [Array] the Array of items to list
+    # @param mode [Symbol] controls how that list is formed
+    # @param option has different effects, depending on the _mode_.
+    # @param highline [HighLine] a HighLine instance to direct the output to.
+    #
+    # Recognized modes are:
+    #
+    # <tt>:columns_across</tt>::         _items_ will be placed in columns,
+    #                                    flowing from left to right.  If given,
+    #                                    _option_ is the number of columns to be
+    #                                    used.  When absent, columns will be
+    #                                    determined based on _wrap_at_ or a
+    #                                    default of 80 characters.
+    # <tt>:columns_down</tt>::           Identical to <tt>:columns_across</tt>,
+    #                                    save flow goes down.
+    # <tt>:uneven_columns_across</tt>::  Like <tt>:columns_across</tt> but each
+    #                                    column is sized independently.
+    # <tt>:uneven_columns_down</tt>::    Like <tt>:columns_down</tt> but each
+    #                                    column is sized independently.
+    # <tt>:inline</tt>::                 All _items_ are placed on a single
+    #                                    line. The last two _items_ are
+    #                                    separated by _option_ or a default of
+    #                                    " or ".  All other _items_ are
+    #                                    separated by ", ".
+    # <tt>:rows</tt>::                   The default mode.  Each of the _items_
+    #                                    is placed on its own line. The _option_
+    #                                    parameter is ignored in this mode.
+    #
+    # Each member of the _items_ Array is passed through ERb and thus can
+    # contain their own expansions. Color escape expansions do not contribute to
+    # the final field width.
+
+    def initialize(items, mode = :rows, option = nil, highline)
+      @highline = highline
+      @mode     = mode
+      @option   = option
+      @items    = render_list_items(items)
+    end
 
-  # Render the list using the appropriate mode and options.
-  # @return [String] rendered list as String
-  def render
-    return "" if items.empty?
-
-    case mode
-    when :inline
-      list_inline_mode
-    when :columns_across
-      list_columns_across_mode
-    when :columns_down
-      list_columns_down_mode
-    when :uneven_columns_across
-      list_uneven_columns_mode
-    when :uneven_columns_down
-      list_uneven_columns_down_mode
-    else
-      list_default_mode
+    # Render the list using the appropriate mode and options.
+    # @return [String] rendered list as String
+    def render
+      return "" if items.empty?
+
+      case mode
+      when :inline
+        list_inline_mode
+      when :columns_across
+        list_columns_across_mode
+      when :columns_down
+        list_columns_down_mode
+      when :uneven_columns_across
+        list_uneven_columns_mode
+      when :uneven_columns_down
+        list_uneven_columns_down_mode
+      else
+        list_default_mode
+      end
     end
-  end
 
-  private
+    private
 
-  def render_list_items(items)
-    items.to_ary.map do |item|
-      item = String(item)
-      template = ERB.new(item, nil, "%")
-      template_renderer = HighLine::TemplateRenderer.new(template, self, highline)
-      template_renderer.render
+    def render_list_items(items)
+      items.to_ary.map do |item|
+        item = String(item)
+        template = ERB.new(item, nil, "%")
+        template_renderer =
+          HighLine::TemplateRenderer.new(template, self, highline)
+        template_renderer.render
+      end
     end
-  end
 
-  def list_default_mode
-    items.map { |i| "#{i}\n" }.join
-  end
+    def list_default_mode
+      items.map { |i| "#{i}\n" }.join
+    end
 
-  def list_inline_mode
-    end_separator = option || " or "
+    def list_inline_mode
+      end_separator = option || " or "
 
-    if items.size == 1
-      items.first
-    else
-      items[0..-2].join(", ") + "#{end_separator}#{items.last}"
+      if items.size == 1
+        items.first
+      else
+        items[0..-2].join(", ") + "#{end_separator}#{items.last}"
+      end
     end
-  end
 
-  def list_columns_across_mode
-    HighLine::List.new(right_padded_items, cols: col_count).to_s
-  end
+    def list_columns_across_mode
+      HighLine::List.new(right_padded_items, cols: col_count).to_s
+    end
 
-  def list_columns_down_mode
-    HighLine::List.new(right_padded_items, cols: col_count, col_down: true).to_s
-  end
+    def list_columns_down_mode
+      HighLine::List.new(
+        right_padded_items,
+        cols: col_count,
+        col_down: true
+      ).to_s
+    end
 
-  def list_uneven_columns_mode(list=nil)
-    list ||= HighLine::List.new(items)
+    def list_uneven_columns_mode(list = nil)
+      list ||= HighLine::List.new(items)
 
-    col_max = option || items.size
-    col_max.downto(1) do |column_count|
-      list.cols = column_count
-      widths = get_col_widths(list)
+      col_max = option || items.size
+      col_max.downto(1) do |column_count|
+        list.cols = column_count
+        widths = get_col_widths(list)
 
-      if column_count == 1 or # last guess
-        inside_line_size_limit?(widths) or # good guess
-        option # defined by user
-        return pad_uneven_rows(list, widths)
+        if column_count == 1 || # last guess
+           inside_line_size_limit?(widths) || # good guess
+           option # defined by user
+          return pad_uneven_rows(list, widths)
+        end
       end
     end
-  end
 
-  def list_uneven_columns_down_mode
-    list = HighLine::List.new(items, col_down: true)
-    list_uneven_columns_mode(list)
-  end
+    def list_uneven_columns_down_mode
+      list = HighLine::List.new(items, col_down: true)
+      list_uneven_columns_mode(list)
+    end
 
-  def pad_uneven_rows(list, widths)
-    right_padded_list = Array(list).map do |row|
-      right_pad_row(row.compact, widths)
+    def pad_uneven_rows(list, widths)
+      right_padded_list = Array(list).map do |row|
+        right_pad_row(row.compact, widths)
+      end
+      stringfy_list(right_padded_list)
     end
-    stringfy_list(right_padded_list)
-  end
 
-  def stringfy_list(list)
-    list.map { |row| row_to_s(row) }.join
-  end
+    def stringfy_list(list)
+      list.map { |row| row_to_s(row) }.join
+    end
 
-  def row_to_s(row)
-    row.compact.join(row_join_string) + "\n"
-  end
+    def row_to_s(row)
+      row.compact.join(row_join_string) + "\n"
+    end
 
-  def right_pad_row(row, widths)
-    row.zip(widths).map do |field, width|
-      right_pad_field(field, width)
+    def right_pad_row(row, widths)
+      row.zip(widths).map do |field, width|
+        right_pad_field(field, width)
+      end
     end
-  end
 
-  def right_pad_field(field, width)
-    field = String(field) # nil protection
-    pad_size = width - actual_length(field)
-    field + (pad_char * pad_size)
-  end
+    def right_pad_field(field, width)
+      field = String(field) # nil protection
+      pad_size = width - actual_length(field)
+      field + (pad_char * pad_size)
+    end
 
-  def get_col_widths(lines)
-    lines = transpose(lines)
-    get_segment_widths(lines)
-  end
+    def get_col_widths(lines)
+      lines = transpose(lines)
+      get_segment_widths(lines)
+    end
 
-  def get_row_widths(lines)
-    get_segment_widths(lines)
-  end
+    def get_row_widths(lines)
+      get_segment_widths(lines)
+    end
 
-  def get_segment_widths(lines)
-    lines.map do |col|
-      actual_lengths_for(col).max
+    def get_segment_widths(lines)
+      lines.map do |col|
+        actual_lengths_for(col).max
+      end
     end
-  end
 
-  def actual_lengths_for(line)
-    line.map do |item|
-      actual_length(item)
+    def actual_lengths_for(line)
+      line.map do |item|
+        actual_length(item)
+      end
     end
-  end
 
-  def transpose(lines)
-    lines = Array(lines)
-    first_line = lines.shift
-    first_line.zip(*lines)
-  end
+    def transpose(lines)
+      lines = Array(lines)
+      first_line = lines.shift
+      first_line.zip(*lines)
+    end
 
-  def inside_line_size_limit?(widths)
-    line_size = widths.inject(0) { |sum, n| sum + n + row_join_str_size }
-    line_size <= line_size_limit + row_join_str_size
-  end
+    def inside_line_size_limit?(widths)
+      line_size = widths.reduce(0) { |sum, n| sum + n + row_join_str_size }
+      line_size <= line_size_limit + row_join_str_size
+    end
 
-  def actual_length(text)
-    HighLine::Wrapper.actual_length text
-  end
+    def actual_length(text)
+      HighLine::Wrapper.actual_length text
+    end
 
-  def items_max_length
-    @items_max_length ||= max_length(items)
-  end
+    def items_max_length
+      @items_max_length ||= max_length(items)
+    end
 
-  def max_length(items)
-    items.map { |item| actual_length(item) }.max
-  end
+    def max_length(items)
+      items.map { |item| actual_length(item) }.max
+    end
 
-  def line_size_limit
-    @line_size_limit ||= ( highline.wrap_at || 80 )
-  end
+    def line_size_limit
+      @line_size_limit ||= (highline.wrap_at || 80)
+    end
 
-  def row_join_string
-    @row_join_string ||= "  "
-  end
+    def row_join_string
+      @row_join_string ||= "  "
+    end
 
-  def row_join_string=(string)
-    @row_join_string = string
-  end
+    attr_writer :row_join_string
 
-  def row_join_str_size
-    row_join_string.size
-  end
+    def row_join_str_size
+      row_join_string.size
+    end
 
-  def get_col_count
-    (line_size_limit + row_join_str_size) /
-      (items_max_length + row_join_str_size)
-  end
+    def col_count_calculate
+      (line_size_limit + row_join_str_size) /
+        (items_max_length + row_join_str_size)
+    end
 
-  def col_count
-    option || get_col_count
-  end
+    def col_count
+      option || col_count_calculate
+    end
 
-  def right_padded_items
-    items.map do |item|
-      right_pad_field(item, items_max_length)
+    def right_padded_items
+      items.map do |item|
+        right_pad_field(item, items_max_length)
+      end
     end
-  end
 
-  def pad_char
-    " "
-  end
+    def pad_char
+      " "
+    end
 
-  def row_count
-    (items.count / col_count.to_f).ceil
+    def row_count
+      (items.count / col_count.to_f).ceil
+    end
   end
-end
+end