tabulo 2.5.0 → 2.6.0

data/VERSION

@@ -1 +1 @@
-2.5.0
+2.6.0

data/lib/tabulo/border.rb

@@ -3,107 +3,62 @@ module Tabulo
   # @!visibility private
   class Border
 
+    Style = Struct.new(
+        :corner_top_left, :corner_top_right, :corner_bottom_right, :corner_bottom_left,
+        :edge_top, :edge_right, :edge_bottom, :edge_left,
+        :tee_top, :tee_right, :tee_bottom, :tee_left,
+        :divider_vertical, :divider_horizontal, :intersection)
+
     STYLES = {
-      ascii: {
-        corner_top_left: "+",
-        corner_top_right: "+",
-        corner_bottom_right: "+",
-        corner_bottom_left: "+",
-        edge_top: "-",
-        edge_right: "|",
-        edge_bottom: "-",
-        edge_left: "|",
-        tee_top: "+",
-        tee_right: "+",
-        tee_bottom: "+",
-        tee_left: "+",
-        divider_vertical: "|",
-        divider_horizontal: "-",
-        intersection: "+",
-      },
-      classic: {
-        corner_top_left: "+",
-        corner_top_right: "+",
-        edge_top: "-",
-        edge_right: "|",
-        edge_left: "|",
-        tee_top: "+",
-        tee_right: "+",
-        tee_left: "+",
-        divider_vertical: "|",
-        divider_horizontal: "-",
-        intersection: "+",
-      },
-      reduced_ascii: {
-        corner_top_left: "",
-        corner_top_right: "",
-        corner_bottom_right: "",
-        corner_bottom_left: "",
-        edge_top: "-",
-        edge_right: "",
-        edge_bottom: "-",
-        edge_left: "",
-        tee_top: " ",
-        tee_right: "",
-        tee_bottom: " ",
-        tee_left: "",
-        divider_vertical: " ",
-        divider_horizontal: "-",
-        intersection: " ",
-      },
-      reduced_modern: {
-        corner_top_left: "",
-        corner_top_right: "",
-        corner_bottom_right: "",
-        corner_bottom_left: "",
-        edge_top: "─",
-        edge_right: "",
-        edge_bottom: "─",
-        edge_left: "",
-        tee_top: " ",
-        tee_right: "",
-        tee_bottom: " ",
-        tee_left: "",
-        divider_vertical: " ",
-        divider_horizontal: "─",
-        intersection: " ",
-      },
-      markdown: {
-        corner_top_left: "",
-        corner_top_right: "",
-        corner_bottom_right: "",
-        corner_bottom_left: "",
-        edge_top: "",
-        edge_right: "|",
-        edge_bottom: "",
-        edge_left: "|",
-        tee_top: "",
-        tee_right: "|",
-        tee_bottom: "",
-        tee_left: "|",
-        divider_vertical: "|",
-        divider_horizontal: "-",
-        intersection: "|",
-      },
-      modern: {
-        corner_top_left: "┌",
-        corner_top_right: "┐",
-        corner_bottom_right: "┘",
-        corner_bottom_left: "└",
-        edge_top: "─",
-        edge_right: "│",
-        edge_bottom: "─",
-        edge_left: "│",
-        tee_top: "┬",
-        tee_right: "┤",
-        tee_bottom: "┴",
-        tee_left: "├",
-        divider_vertical: "│",
-        divider_horizontal: "─",
-        intersection: "┼",
-      },
-      blank: {
-      },
+      ascii:
+        Style.new(
+          "+", "+", "+", "+",
+          "-", "|", "-", "|",
+          "+", "+", "+", "+",
+          "|", "-", "+",
+        ),
+      classic:
+        Style.new(
+          "+", "+", "", "",
+          "-", "|", "", "|",
+          "+", "+", "", "+",
+          "|", "-", "+",
+        ),
+      reduced_ascii:
+        Style.new(
+          "", "", "", "",
+          "-", "", "-", "",
+          " ", "", " ", "",
+          " ", "-", " ",
+        ),
+      reduced_modern:
+        Style.new(
+          "", "", "", "",
+          "─", "", "─", "",
+          " ", "", " ", "",
+          " ", "─", " ",
+        ),
+      markdown:
+        Style.new(
+          "", "", "", "",
+          "", "|", "", "|",
+          "", "|", "", "|",
+          "|", "-", "|",
+        ),
+      modern:
+        Style.new(
+          "┌", "┐", "┘", "└",
+          "─", "│", "─", "│",
+          "┬", "┤", "┴", "├",
+          "│", "─", "┼",
+        ),
+      blank:
+        Style.new(
+          "", "", "", "",
+          "", "", "", "",
+          "", "", "", "",
+          "", "", "",
+        ),
     }
 
     # @!visibility private
@@ -147,7 +102,7 @@ module Tabulo
 
     def self.options(kind)
       opts = STYLES[kind]
-      return opts if opts
+      return opts.to_h if opts
       raise InvalidBorderError
     end
 

data/lib/tabulo/cell.rb

@@ -13,7 +13,9 @@ module Tabulo
       alignment:,
       cell_data:,
       formatter:,
+      left_padding:,
       padding_character:,
+      right_padding:,
       styler:,
       truncation_indicator:,
       value:,
@@ -21,8 +23,10 @@ module Tabulo
 
       @alignment = alignment
       @cell_data = cell_data
-      @padding_character = padding_character
       @formatter = formatter
+      @left_padding = left_padding
+      @padding_character = padding_character
+      @right_padding = right_padding
       @styler = styler
       @truncation_indicator = truncation_indicator
       @value = value
@@ -35,12 +39,12 @@ module Tabulo
     end
 
     # @!visibility private
-    def padded_truncated_subcells(target_height, padding_amount_left, padding_amount_right)
-      total_padding_amount = padding_amount_left + padding_amount_right
+    def padded_truncated_subcells(target_height)
+      total_padding_amount = @left_padding + @right_padding
       truncated = (height > target_height)
       (0...target_height).map do |subcell_index|
         append_truncator = (truncated && (total_padding_amount != 0) && (subcell_index + 1 == target_height))
-        padded_subcell(subcell_index, padding_amount_left, padding_amount_right, append_truncator)
+        padded_subcell(subcell_index, append_truncator)
       end
     end
 
@@ -60,8 +64,11 @@ module Tabulo
       end
     end
 
-    def apply_styler(content)
-      if @styler.arity == 3
+    def apply_styler(content, line_index)
+      case @styler.arity
+      when 4
+        @styler.call(@value, content, @cell_data, line_index)
+      when 3
         @styler.call(@value, content, @cell_data)
       else
         @styler.call(@value, content)
@@ -72,13 +79,13 @@ module Tabulo
       @subcells ||= calculate_subcells
     end
 
-    def padded_subcell(subcell_index, padding_amount_left, padding_amount_right, append_truncator)
-      lpad = @padding_character * padding_amount_left
+    def padded_subcell(subcell_index, append_truncator)
+      lpad = @padding_character * @left_padding
       rpad =
         if append_truncator
-          styled_truncation_indicator + padding(padding_amount_right - 1)
+          styled_truncation_indicator(subcell_index) + padding(@right_padding - 1)
         else
-          padding(padding_amount_right)
+          padding(@right_padding)
         end
       inner = subcell_index < height ? subcells[subcell_index] : padding(@width)
       "#{lpad}#{inner}#{rpad}"
@@ -88,31 +95,35 @@ module Tabulo
       @padding_character * amount
     end
 
-    def styled_truncation_indicator
-      apply_styler(@truncation_indicator)
+    def styled_truncation_indicator(line_index)
+      apply_styler(@truncation_indicator, line_index)
     end
 
     def calculate_subcells
+      line_index = 0
       formatted_content.split($/, -1).flat_map do |substr|
         subsubcells, subsubcell, subsubcell_width = [], String.new(""), 0
 
         substr.scan(/\X/).each do |grapheme_cluster|
           grapheme_cluster_width = Unicode::DisplayWidth.of(grapheme_cluster)
           if subsubcell_width + grapheme_cluster_width > @width
-            subsubcells << style_and_align_cell_content(subsubcell)
+            subsubcells << style_and_align_cell_content(subsubcell, line_index)
             subsubcell_width = 0
             subsubcell.clear
+            line_index += 1
           end
 
           subsubcell << grapheme_cluster
           subsubcell_width += grapheme_cluster_width
         end
 
-        subsubcells << style_and_align_cell_content(subsubcell)
+        subsubcells << style_and_align_cell_content(subsubcell, line_index)
+        line_index += 1
+        subsubcells
       end
     end
 
-    def style_and_align_cell_content(content)
+    def style_and_align_cell_content(content, line_index)
       padding = Util.max(@width - Unicode::DisplayWidth.of(content), 0)
       left_padding, right_padding =
         case real_alignment
@@ -125,7 +136,7 @@ module Tabulo
           [padding, 0]
         end
 
-      "#{' ' * left_padding}#{apply_styler(content)}#{' ' * right_padding}"
+      "#{' ' * left_padding}#{apply_styler(content, line_index)}#{' ' * right_padding}"
     end
 
     def real_alignment

data/lib/tabulo/column.rb

@@ -6,6 +6,8 @@ module Tabulo
     attr_accessor :width
     attr_reader :header
     attr_reader :index
+    attr_reader :left_padding
+    attr_reader :right_padding
 
     def initialize(
       align_body:,
@@ -15,7 +17,9 @@ module Tabulo
       header:,
       header_styler:,
       index:,
+      left_padding:,
       padding_character:,
+      right_padding:,
       styler:,
       truncation_indicator:,
       width:)
@@ -26,12 +30,19 @@ module Tabulo
       @formatter = formatter
       @header = header
       @index = index
+      @left_padding = left_padding
+      @right_padding = right_padding
 
       @header_styler =
-        if header_styler && (header_styler.arity == 2)
-          -> (_, str, cell_data) { header_styler.call(str, cell_data.column_index) }
-        elsif header_styler
-          -> (_, str) { header_styler.call(str) }
+        if header_styler
+          case header_styler.arity
+          when 3
+            -> (_, str, cell_data, line_index) { header_styler.call(str, cell_data.column_index, line_index) }
+          when 2
+            -> (_, str, cell_data) { header_styler.call(str, cell_data.column_index) }
+          else
+            -> (_, str) { header_styler.call(str) }
+          end
         else
           -> (_, str) { str }
         end
@@ -43,14 +54,16 @@ module Tabulo
     end
 
     def header_cell
-      if @header_styler.arity == 3
+      if @header_styler.arity >= 3
         cell_data = CellData.new(nil, nil, @index)
       end
       Cell.new(
         alignment: @align_header,
         cell_data: cell_data,
         formatter: -> (s) { s },
+        left_padding: @left_padding,
         padding_character: @padding_character,
+        right_padding: @right_padding,
         styler: @header_styler,
         truncation_indicator: @truncation_indicator,
         value: @header,
@@ -66,7 +79,9 @@ module Tabulo
         alignment: @align_body,
         cell_data: cell_data,
         formatter: @formatter,
+        left_padding: @left_padding,
         padding_character: @padding_character,
+        right_padding: @right_padding,
         styler: @styler,
         truncation_indicator: @truncation_indicator,
         value: body_cell_value(source, row_index: row_index, column_index: column_index),
@@ -82,6 +97,14 @@ module Tabulo
       end
     end
 
+    def padded_width
+      width + total_padding
+    end
+
+    def total_padding
+      @left_padding + @right_padding
+    end
+
     private
 
     def body_cell_data_required?

data/lib/tabulo/table.rb

@@ -76,7 +76,8 @@ module Tabulo
     #   either side of each column. If passed an Integer, then the given amount of padding is
     #   applied to each side of each column. If passed a two-element Array, then the first element of the
     #   Array indicates the amount of padding to apply to the left of each column, and the second
-    #   element indicates the amount to apply to the right.
+    #   element indicates the amount to apply to the right. This setting can be overridden for
+    #   individual columns using the `padding` option of {#add_column}.
     # @param [Integer, nil] column_width The default column width for columns in this
     #   table, not excluding padding. If <tt>nil</tt>, then {DEFAULT_COLUMN_WIDTH} will be used.
     # @param [nil, #to_proc] formatter (:to_s.to_proc) The default formatter for columns in this
@@ -99,14 +100,26 @@ module Tabulo
     #   will cause it to cease being valid Markdown when rendered, since Markdown engines do not generally
     #   support adding a caption element (i.e. title) to tables.
     # @param [nil, #to_proc] title_styler (nil) A lambda or other callable object that will
-    #   determine the colors or other styling applied to the table title. If the table doesn't have
-    #   a title, this parameter has no effect. If passed a single-parameter callable, then that
-    #   callable will be called for each line of content within the title, and the resulting string
-    #   rendered in place of that line.
-    #   The extra width of the string returned by the <tt>title_styler</tt> is not taken into
-    #   consideration by the internal table width calculations involved in rendering the
-    #   table. Thus it can be used to apply ANSI escape codes to title content, to color the
-    #   title for example, without breaking the table formatting.
+    #   determine the colors or other styling applied to the table title. Can be passed
+    #   <tt>nil</tt>, or can be passed a callable that takes either 1 or 2 parametes:
+    #   * If passed <tt>nil</tt>, then no additional styling will be applied to the title.
+    #   * If passed a callable, then that callable will be called for each line of
+    #     the title, and the resulting string rendered in place of that line.
+    #     The extra width of the string returned by the <tt>title_styler</tt> is not taken into
+    #     consideration by the internal table and cell width calculations involved in rendering the
+    #     table. Thus it can be used to apply ANSI escape codes to title content, to color the
+    #     content for example, without breaking the table formatting.
+    #     * If the passed callable takes 1 parameter, then the first parameter is a string
+    #       representing a single line within the title. For example, if the title
+    #       is wrapped over three lines, then the <tt>title_styler</tt> will be called
+    #       three times, once for each line of content.
+    #     * If the passed callable takes 2 parameters, then the first parameter is as above, and the
+    #       second parameter is an Integer representing the index of the line within the
+    #       title that is currently being styled. For example, if the title is wrapped over 3
+    #       lines, then the callable will be called first with a line index of 0, to style the first line,
+    #       then with a line index of 1, to style the second line, and finally with a line index of 2, for
+    #       the third and final wrapped line of the cell.
+    #
     # @param [nil, String] truncation_indicator Determines the character used to indicate that a
     #   cell's content has been truncated. If omitted or passed <tt>nil</tt>,
     #   defaults to {DEFAULT_TRUNCATION_INDICATOR}. If passed something other than <tt>nil</tt> or
@@ -142,7 +155,7 @@ module Tabulo
       @column_padding = (column_padding || DEFAULT_COLUMN_PADDING)
 
       @left_column_padding, @right_column_padding =
-        Array === @column_padding ? @column_padding : [@column_padding, @column_padding]
+        (Array === @column_padding ? @column_padding : [@column_padding, @column_padding])
 
       @column_width = (column_width || DEFAULT_COLUMN_WIDTH)
       @formatter = formatter
@@ -210,7 +223,7 @@ module Tabulo
     #   the column's label will also be used as its header text.
     # @param [nil, #to_proc] header_styler (nil) A lambda or other callable object that will
     #   determine the colors or other styling applied to the header content. Can be passed
-    #   <tt>nil</tt>, or can be passed a callable that takes either 1 or 2 parameters:
+    #   <tt>nil</tt>, or can be passed a callable that takes 1, 2 or 3 parameters:
     #   * If passed <tt>nil</tt>, then no additional styling will be applied to the cell content
     #     (other than what was already applied by the <tt>formatter</tt>).
     #   * If passed a callable, then that callable will be called for each line of content within
@@ -227,9 +240,22 @@ module Tabulo
     #       second parameter is an Integer representing the positional index of this header's {Column},
     #       with the leftmost column having index 0, the next having index 1 etc.. This can be
     #       used, for example, to apply different styles to alternating {Column}s.
+    #     * If the passed callable takes 3 parameters, then the first and second parameters are as above,
+    #       and the third parameter is an Integer representing the index of the line within the
+    #       header cell that is currently being styled. For example, if the cell content is wrapped over 3
+    #       lines, then the callable will be called first with a line index of 0, to style the first line,
+    #       then with a line index of 1, to style the second line, and finally with a line index of 2, for
+    #       the third and final wrapped line of the cell.
     #
     #   Note that if the header content is truncated, then any <tt>header_styler</tt> will be applied to the
     #   truncation indicator character as well as to the truncated content.
+    # @param [nil, Integer, Array] padding (nil) Determines the amount of blank space with which to
+    #   pad either side of the column. If passed nil, then the `column_padding` setting of the
+    #   {Table} will determine the column's padding. (See {#initialize}.) Otherwise, this option
+    #   overrides, for this column, the `column_padding` that was set at the table level: if passed an Integer,
+    #   then the given amount of padding is applied to either side of the column; or if passed a two-element Array,
+    #   then the first element of the Array indicates the amount of padding to apply to the left of the column,
+    #   and the second element indicates the amount to apply to the right.
     # @param [nil, #to_proc] styler (nil) A lambda or other callable object that will determine
     #   the colors or other styling applied to the formatted value of the cell. Can be passed
     #   <tt>nil</tt>, or can be passed a callable that takes either 2 or 3 parameters:
@@ -253,6 +279,12 @@ module Tabulo
     #       {CellData#row_index} attribute can be inspected to determine whether the {Cell} is an
     #       odd- or even-numbered {Row}, to arrange for different styling to be applied to
     #       alternating rows. See the documentation for {CellData} for more.
+    #     * If the passed callable takes 4 parameters, then the first three parameters are as above,
+    #       and the fourth parameter is an Integer representing the index of the line within the
+    #       cell that is currently being styled. For example, if the cell content is wrapped over 3
+    #       lines, then the callable will be called first with a line index of 0, to style the first
+    #       line, then with a line index of 1, to style the second line, and finally with a line
+    #       index of 2, to style the third and final wrapped line of the cell.
     #
     #   Note that if the content of a cell is truncated, then the whatever styling is applied by the
     #   <tt>styler</tt> to the cell content will also be applied to the truncation indicator character.
@@ -273,10 +305,17 @@ module Tabulo
     #   Table. (This is case-sensitive, but is insensitive to whether a String or Symbol is passed
     #   to the label parameter.)
     def add_column(label, align_body: nil, align_header: nil, before: nil, formatter: nil,
-      header: nil, header_styler: nil, styler: nil, width: nil, &extractor)
+      header: nil, header_styler: nil, padding: nil, styler: nil, width: nil, &extractor)
 
       column_label = normalize_column_label(label)
 
+      left_padding, right_padding =
+        if padding
+          Array === padding ? padding : [padding, padding]
+        else
+          [@left_column_padding, @right_column_padding]
+        end
+
       if column_registry.include?(column_label)
         raise InvalidColumnLabelError, "Column label already used in this table."
       end
@@ -289,7 +328,9 @@ module Tabulo
         header: (header || label).to_s,
         header_styler: header_styler || @header_styler,
         index: column_registry.count,
+        left_padding: left_padding,
         padding_character: PADDING_CHARACTER,
+        right_padding: right_padding,
         styler: styler || @styler,
         truncation_indicator: @truncation_indicator,
         width: width || @column_width,
@@ -331,7 +372,7 @@ module Tabulo
       if column_registry.any?
         bottom_edge = horizontal_rule(:bottom)
         rows = map(&:to_s)
-        bottom_edge.empty? ? join_lines(rows) : join_lines(rows + [bottom_edge])
+        bottom_edge.empty? ? Util.join_lines(rows) : Util.join_lines(rows + [bottom_edge])
       else
         ""
       end
@@ -389,7 +430,7 @@ module Tabulo
     # It may be that `:top`, `:middle` and `:bottom` all look the same. Whether
     # this is the case depends on the characters used for the table border.
     def horizontal_rule(position = :bottom)
-      column_widths = get_columns.map { |column| column.width + total_column_padding }
+      column_widths = get_columns.map { |column| column.width + column.total_padding }
       @border_instance.horizontal_rule(column_widths, position)
     end
 
@@ -425,22 +466,27 @@ module Tabulo
     #   Table will refuse to shrink itself.
     # @return [Table] the Table itself
     def pack(max_table_width: :auto)
-      get_columns.each { |column| column.width = wrapped_width(column.header) }
+      get_columns.each { |column| column.width = Util.wrapped_width(column.header) }
 
       @sources.each_with_index do |source, row_index|
         get_columns.each_with_index do |column, column_index|
           cell = column.body_cell(source, row_index: row_index, column_index: column_index)
-          cell_width = wrapped_width(cell.formatted_content)
+          cell_width = Util.wrapped_width(cell.formatted_content)
           column.width = Util.max(column.width, cell_width)
         end
       end
 
-      if max_table_width
-        shrink_to(max_table_width == :auto ? TTY::Screen.width : max_table_width)
-      end
+      shrink_to(max_table_width == :auto ? TTY::Screen.width : max_table_width) if max_table_width
 
       if @title
-        expand_to(Unicode::DisplayWidth.of(@title) + total_column_padding + (@border == :blank ? 0 : 2))
+        border_edge_width = (@border == :blank ? 0 : 2)
+        columns = get_columns
+        expand_to(
+          Unicode::DisplayWidth.of(@title) +
+          columns.first.left_padding +
+          columns.last.right_padding +
+          border_edge_width
+        )
       end
 
       self
@@ -530,33 +576,14 @@ module Tabulo
       inner = format_row(cells, @wrap_body_cells_to)
 
       if @title && header == :top
-        join_lines([
-          horizontal_rule(:title_top),
-          formatted_title,
-          horizontal_rule(:title_bottom),
-          formatted_header,
-          horizontal_rule(:middle),
-          inner
-        ].reject(&:empty?))
+        Util.condense_lines([horizontal_rule(:title_top), formatted_title, horizontal_rule(:title_bottom),
+          formatted_header, horizontal_rule(:middle), inner])
       elsif header == :top
-        join_lines([
-          horizontal_rule(:top),
-          formatted_header,
-          horizontal_rule(:middle),
-          inner
-        ].reject(&:empty?))
+        Util.condense_lines([horizontal_rule(:top), formatted_header, horizontal_rule(:middle), inner])
       elsif header
-        join_lines([
-          horizontal_rule(:middle),
-          formatted_header,
-          horizontal_rule(:middle),
-          inner
-        ].reject(&:empty?))
+        Util.condense_lines([horizontal_rule(:middle), formatted_header, horizontal_rule(:middle), inner])
       elsif divider
-        join_lines([
-          horizontal_rule(:middle),
-          inner
-        ].reject(&:empty?))
+        Util.condense_lines([horizontal_rule(:middle), inner])
       else
         inner
       end
@@ -593,23 +620,34 @@ module Tabulo
     # @visibility private
     def formatted_title
       columns = get_columns
-      num_fudged_columns = columns.count - 1
-      basic_width = columns.inject(0) { |total_width, column| total_width + column.width }
+
       extra_for_internal_dividers = (@border == :blank ? 0 : 1)
-      extra_for_internal_padding = @left_column_padding + @right_column_padding
-      extra_total = num_fudged_columns * (extra_for_internal_dividers + extra_for_internal_padding)
-      title_cell_width = basic_width + extra_total
+
+      title_cell_width = columns.inject(0) do |total_width, column|
+        total_width + column.padded_width + extra_for_internal_dividers
+      end
+
+      title_cell_width -= (columns.first.left_padding + columns.last.right_padding + extra_for_internal_dividers)
+
       styler =
         if @title_styler
-          -> (v, s) { @title_styler.call(s) }
+          case @title_styler.arity
+          when 1
+            -> (_val, str) { @title_styler.call(str) }
+          when 2
+            -> (_val, str, _cell_data, line_index) { @title_styler.call(str, line_index) }
+          end
         else
-          -> (v, s) { s }
+          -> (_val, str) { str }
         end
+
       title_cell = Cell.new(
         alignment: @align_title,
         cell_data: nil,
         formatter: -> (s) { s },
+        left_padding: columns.first.left_padding,
         padding_character: PADDING_CHARACTER,
+        right_padding: columns.last.right_padding,
         styler: styler,
         truncation_indicator: @truncation_indicator,
         value: @title,
@@ -619,13 +657,13 @@ module Tabulo
       max_cell_height = cells.map(&:height).max
       row_height = ([nil, max_cell_height].compact.min || 1)
       subcell_stacks = cells.map do |cell|
-        cell.padded_truncated_subcells(row_height, @left_column_padding, @right_column_padding)
+        cell.padded_truncated_subcells(row_height)
       end
       subrows = subcell_stacks.transpose.map do |subrow_components|
         @border_instance.join_cell_contents(subrow_components)
       end
 
-      join_lines(subrows)
+      Util.join_lines(subrows)
     end
 
     # @!visibility private
@@ -642,10 +680,9 @@ module Tabulo
     def expand_to(min_table_width)
       columns = get_columns
       num_columns = columns.count
-      total_columns_width = columns.inject(0) { |sum, column| sum + column.width }
-      total_padding = num_columns * total_column_padding
+      total_columns_padded_width = columns.inject(0) { |sum, column| sum + column.padded_width }
       total_borders = num_columns + 1
-      unadjusted_table_width = total_columns_width + total_padding + total_borders
+      unadjusted_table_width = total_columns_padded_width + total_borders
       required_increase = Util.max(min_table_width - unadjusted_table_width, 0)
 
       required_increase.times do
@@ -661,10 +698,10 @@ module Tabulo
     def shrink_to(max_table_width)
       columns = get_columns
       num_columns = columns.count
-      total_columns_width = columns.inject(0) { |sum, column| sum + column.width }
-      total_padding = num_columns * total_column_padding
+      total_columns_padded_width = columns.inject(0) { |sum, column| sum + column.padded_width }
+      total_padding = columns.inject(0) { |sum, column| sum + column.total_padding }
       total_borders = num_columns + 1
-      unadjusted_table_width = total_columns_width + total_padding + total_borders
+      unadjusted_table_width = total_columns_padded_width + total_borders
 
       # Ensure max table width is at least wide enough to accommodate table borders and padding
       # and one character of content.
@@ -681,11 +718,6 @@ module Tabulo
       end
     end
 
-    # @!visibility private
-    def total_column_padding
-      @left_column_padding + @right_column_padding
-    end
-
     # @!visibility private
     #
     # Formats a single header row or body row as a String.
@@ -703,18 +735,13 @@ module Tabulo
       max_cell_height = cells.map(&:height).max
       row_height = ([wrap_cells_to, max_cell_height].compact.min || 1)
       subcell_stacks = cells.map do |cell|
-        cell.padded_truncated_subcells(row_height, @left_column_padding, @right_column_padding)
+        cell.padded_truncated_subcells(row_height)
       end
       subrows = subcell_stacks.transpose.map do |subrow_components|
         @border_instance.join_cell_contents(subrow_components)
       end
 
-      join_lines(subrows)
-    end
-
-    # @!visibility private
-    def join_lines(lines)
-      lines.join($/)  # join strings with cross-platform newline
+      Util.join_lines(subrows)
     end
 
     # @!visibility private
@@ -732,13 +759,5 @@ module Tabulo
       c
     end
 
-    # @!visibility private
-    # @return [Integer] the length of the longest segment of str when split by newlines
-    def wrapped_width(str)
-      segments = str.split($/)
-      segments.inject(1) do |longest_length_so_far, segment|
-        Util.max(longest_length_so_far, Unicode::DisplayWidth.of(segment))
-      end
-    end
   end
 end