tabulo 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91b39d66ae733e33e28f3c16b9a8aee6fcf734db34b404429b1bba72063c1cb8
-  data.tar.gz: aa5b690e3b1d6ee9819e2a097c20fefffcf4559149d3574ca6d5514dab78f86e
+  metadata.gz: edb6043945662b09cf500a65acec2fa51eac9c9397e7c58a890379bc174424cd
+  data.tar.gz: f7866a1ac405b431752ccba6a81678c9533b245384290c913bb015267ff8f7cd
 SHA512:
-  metadata.gz: 690f7c809c3dc9a47ec6e7f736f46fdbc129e21c23723d163ff6dc545c97b1b068c622ee88a943c5e858ff2f53bc59d490680b02a85b521652db8cfd6b5194ff
-  data.tar.gz: aaec0cb5f11f9724ba084bd3af961fca69a054601d1c86b6cc8a1fdf22a193f6de12abe25b2c41838db583dff06e4397036a3bade37da4ceb71d9494b7c659e6
+  metadata.gz: e67b0006b767a5dbe884bad9296636a01e1d5bdc57c6ffd2689f9315a9465e899e79e74508e2ae7c83c37869bfb3a523931accd2e5d6db346e104794a6c844ec
+  data.tar.gz: 663b95287868f59f2c29f75564cb660b5c1b2462984f351d6abd6ff057228fd1f8af5a3c7a99d68ed99740b90a493fe18bd9e4a7228f45dc312c929aeb7308a3

data/.travis.yml

@@ -6,4 +6,4 @@ rvm:
   - 2.3.8
   - 2.4.6
   - 2.5.5
-  - 2.6.2
+  - 2.6.3

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+### v1.5.0
+
+* Support use of ANSI escape sequences to add colours and
+  other styling to table elements without breaking the formatting.
+* Major refactor, moving various computations into a new Cell class.
+
 ### v1.4.1
 
 * Minor documentation fix

data/README.md

@@ -9,7 +9,7 @@
 
 Tabulo is a terminal table generator for Ruby.
 
-It offers a DRY, "column-centric" interface, and is designed to make it very easy it produce highly
+It offers a DRY, "column-centric" interface, and is designed to make it very easy to produce highly
 readable tables, even from large and unwieldy data sets and streams.
 
 ## Overview
@@ -63,6 +63,7 @@ end
 * The header row can be [repeated](#repeating-headers) at arbitrary intervals.
 * Newlines within cell content are correctly handled.
 * Multibyte characters are correctly handled.
+* Apply [colours](#colours-and-styling) and other styling to table content without breaking the table.
 * Easily [transpose](#transposition) the table, so that rows are swapped with columns.
 * [Customize](#additional-configuration-options) border and divider characters.
 * Use a [DRY initialization interface](#configuring-columns): by being "column based", it is
@@ -86,6 +87,7 @@ Tabulo has also been ported to Crystal (with some modifications): see [Tablo](ht
         * [Automating column widths](#automating-column-widths)
         * [Overflow handling](#overflow-handling)
      * [Formatting cell values](#formatting-cell-values)
+     * [Colours and stying[(#colours-and-styling)
      * [Repeating headers](#repeating-headers)
      * [Using a Table Enumerator](#using-a-table-enumerator)
      * [Accessing cell values](#accessing-cell-values)
@@ -128,6 +130,15 @@ the columns you want to generate.
 A simple case involves initializing columns from symbols corresponding to methods on members of the
 underlying `Enumerable`. In this case the symbol also provides the header for each column:
 
+```ruby
+table = Tabulo::Table.new([1, 2, 5])
+table.add_column(:itself)
+table.add_column(:even?)
+table.add_column(:odd?)
+```
+
+Alternatively, you can pass an initialization block to `new`:
+
 ```ruby
 table = Tabulo::Table.new([1, 2, 5]) do |t|
   t.add_column(:itself)
@@ -136,7 +147,8 @@ table = Tabulo::Table.new([1, 2, 5]) do |t|
 end
 ```
 
-Or equivalently, using the "quick API":
+When the columns correspond to methods, you can also use the "quick API", by passing a symbol
+directly to `new` for each column:
 
 ```ruby
 table = Tabulo::Table.new([1, 2, 5], :itself, :even?, :odd?)
@@ -355,6 +367,7 @@ table = Tabulo::Table.new(
 | abcdefghijkl~|           26 |
 ```
 
+<a name="formatting-cell-values"></a>
 ### Formatting cell values
 
 While the callable passed to `add_column` determines the underyling, calculated value in each
@@ -389,6 +402,67 @@ of the underlying cell value, not the way it is formatted. This is usually the d
 Note also that the item yielded to `.each` for each cell when enumerating over a `Tabulo::Row` is
 the underlying value of that cell, not its formatted value.
 
+<a name="colours-and-styling"></a>
+### Colours and styling
+
+In most terminals, if you want print text that is coloured, or has other styles
+such as underlining, you need to use ANSI escape sequences, either directly, or by means of a library
+such as [Rainbow](http://github.com/sickill/rainbow) that uses them under the hood. When added
+to a string, ANSI escape codes increase a string's length without increasing the width
+it visually occupies in the terminal. So that Tabulo can perform the width calculations required to
+render the table correctly, the `styler` option should be passed to `add_column` to apply colours
+or other styling that require escape sequences.
+
+For example, suppose you have a table to which you want to add a column that
+displays `true` in green if a given number is even, or else displays `false` in red.
+You can achieve this as follows using raw ANSI escape codes:
+
+```ruby
+table.add_column(
+  :even?,
+  styler: -> (n, s) { n.even? ? "\033[32m#{s}\033[0m" : "\033[31m#{s}\033[0m" }
+)
+```
+
+Or, if you are using the [rainbow](https://github.com/sickill/rainbow) gem for colouring, you
+could do the following:
+
+```ruby
+require "rainbow"
+
+# ...
+
+table.add_column(
+  :even?,
+  styler: -> (n, s) { n.even? ? Rainbow(s).red : Rainbow(s).green }
+)
+```
+
+The `styler` option should be passed a callable that takes two parameters: the
+first represents the element of the underlying enumerable for a given table
+row; and the second the represents formatted string value of that cell, i.e. the
+cell content after any processing by the [formatter](#formatting-cell-values) (if any).
+If the content of a cell is wrapped over multiple lines, then the `styler` will be called
+once per line, so that each line of the cell will have the escape sequence applied to it
+separately (ensuring the stying doesn't bleed into neighbouring cells).
+
+If you want to apply colours or other styling to the content of a column header, as opposed
+to cells in the table body, use the `header_styler` option, e.g.:
+
+```ruby
+table.add_column(:even?, header_styler: -> (s) { "\033[32m#{s}\033[0m" })
+```
+
+To apply colours or other styling to the row divider, column divider, corner and border
+characters of the table, use the `border_styler` option when initializing the table, e.g.:
+
+```ruby
+table = Tabulo::Table.new(1..5, :itself, :even?, :odd?, border_styler: -> (s) { "\033[32m#{s}\033[0m" })
+```
+
+If the content of a cell has been [truncated](#overflow-handling), then whatever colours or other styling
+apply to the cell content will also be applied the truncation indicator character.
+
 <a name="repeating-headers"></a>
 ### Repeating headers
 
@@ -455,8 +529,8 @@ calculated.)
 <a name="accessing-cell-values"></a>
 ### Accessing cell values
 Each `Tabulo::Table` is an `Enumerable` of which each element is a `Tabulo::Row`. Each `Tabulo::Row`
-is itself an `Enumerable` comprising the underlying the values of each cell. A `Tabulo::Row` can
-also be converted to a `Hash` for keyed access. For example:
+is itself an `Enumerable` comprising the underlying values of each cell. A `Tabulo::Row` can also
+be converted to a `Hash` for keyed access. For example:
 
 ```ruby
 table = Tabulo::Table.new(1..5, :itself, :even?, :odd?)
@@ -549,7 +623,7 @@ a new table in which the rows and columns are swapped:
 By default, a header row is added to the new table, showing the string value of the element
 represented in that column. This can be configured, however, along with other aspects of
 `transpose`'s behaviour. For details, see the
-[documentation](https://www.rubydoc.info/gems/tabulo/1.4.1/Tabulo/Table#transpose-instance_method).
+[documentation](https://www.rubydoc.info/gems/tabulo/1.5.0/Tabulo/Table#transpose-instance_method).
 
 <a name="additional-configuration-options"></a>
 ### Additional configuration options
@@ -690,14 +764,14 @@ The gem is available as open source under the terms of the [MIT
 License](http://opensource.org/licenses/MIT).
 
 [Gem Version]: https://rubygems.org/gems/tabulo
-[Documentation]: http://www.rubydoc.info/gems/tabulo/1.4.1
+[Documentation]: http://www.rubydoc.info/gems/tabulo/1.5.0
 [Build Status]: https://travis-ci.org/matt-harvey/tabulo
 [Coverage Status]: https://coveralls.io/r/matt-harvey/tabulo
 [Code Climate]: https://codeclimate.com/github/matt-harvey/tabulo
 [Awesome Ruby]: https://github.com/markets/awesome-ruby#cli-utilities
 
 [GV img]: https://img.shields.io/gem/v/tabulo.svg
-[DC img]: https://img.shields.io/badge/documentation-v1.4.1-blue.svg
+[DC img]: https://img.shields.io/badge/documentation-v1.5.0-blue.svg
 [BS img]: https://img.shields.io/travis/matt-harvey/tabulo.svg
 [CS img]: https://img.shields.io/coveralls/matt-harvey/tabulo.svg
 [CC img]: https://codeclimate.com/github/matt-harvey/tabulo/badges/gpa.svg

data/VERSION

@@ -1 +1 @@
-1.4.1
+1.5.0

data/lib/tabulo.rb

@@ -4,4 +4,5 @@ require "tabulo/util"
 require "tabulo/table"
 require "tabulo/version"
 require "tabulo/row"
+require "tabulo/cell"
 require "tabulo/column"

data/lib/tabulo/cell.rb

@@ -0,0 +1,104 @@
+require "unicode/display_width"
+
+module Tabulo
+
+  # @!visibility private
+  class Cell
+
+    def initialize(value:, formatter:, alignment:, width:, styler:, truncation_indicator:, padding_character:)
+      @value = value
+      @formatter = formatter
+      @alignment = alignment
+      @width = width
+      @styler = styler
+      @truncation_indicator = truncation_indicator
+      @padding_character = padding_character
+    end
+
+    def height
+      subcells.size
+    end
+
+    def padded_truncated_subcells(target_height, padding_amount)
+      truncated = (height > target_height)
+      (0...target_height).map do |subcell_index|
+        append_truncator = (truncated && (padding_amount != 0) && (subcell_index + 1 == target_height))
+        padded_subcell(subcell_index, padding_amount, append_truncator)
+      end
+    end
+
+    def formatted_content
+      @formatted_content ||= @formatter.call(@value)
+    end
+
+    private
+
+    def subcells
+      @subcells ||= calculate_subcells
+    end
+
+    def padded_subcell(subcell_index, padding_amount, append_truncator)
+      lpad = @padding_character * padding_amount
+      rpad = append_truncator ? styled_truncation_indicator + padding(padding_amount - 1) : padding(padding_amount)
+      inner = subcell_index < height ? subcells[subcell_index] : padding(@width)
+      "#{lpad}#{inner}#{rpad}"
+    end
+
+    def padding(amount)
+      @padding_character * amount
+    end
+
+    def styled_truncation_indicator
+      @styler.call(@value, @truncation_indicator)
+    end
+
+    def calculate_subcells
+      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)
+            subsubcell_width = 0
+            subsubcell.clear
+          end
+
+          subsubcell << grapheme_cluster
+          subsubcell_width += grapheme_cluster_width
+        end
+
+        subsubcells << style_and_align_cell_content(subsubcell)
+      end
+    end
+
+    def style_and_align_cell_content(content)
+      padding = [@width - Unicode::DisplayWidth.of(content), 0].max
+      left_padding, right_padding =
+        case real_alignment
+        when :center
+          half_padding = padding / 2
+          [padding - half_padding, half_padding]
+        when :left
+          [0, padding]
+        when :right
+          [padding, 0]
+        end
+
+      "#{' ' * left_padding}#{@styler.call(@value, content)}#{' ' * right_padding}"
+    end
+
+    def real_alignment
+      return @alignment unless @alignment == :auto
+
+      case @value
+      when Numeric
+        :right
+      when TrueClass, FalseClass
+        :center
+      else
+        :left
+      end
+    end
+  end
+end

data/lib/tabulo/column.rb

@@ -1,5 +1,3 @@
-require "unicode/display_width"
-
 module Tabulo
 
   # @!visibility private
@@ -8,83 +6,54 @@ module Tabulo
     attr_accessor :width
     attr_reader :header
 
-    def initialize(header:, width:, align_header:, align_body:, formatter:, extractor:)
+    def initialize(header:, width:, align_header:, align_body:, formatter:, extractor:, styler:,
+      header_styler:, truncation_indicator:, padding_character:)
+
       @header = header
       @width = width
       @align_header = align_header
       @align_body = align_body
       @formatter = formatter
       @extractor = extractor
-    end
+      @styler = styler || -> (_, s) { s }
+
+      @header_styler =
+        if header_styler
+          -> (_, s) { header_styler.call(s) }
+        else
+          -> (_, s) { s }
+        end
 
-    def header_subcells
-      infilled_subcells(@header, @align_header)
+      @truncation_indicator = truncation_indicator
+      @padding_character = padding_character
     end
 
-    def body_subcells(source)
-      cell_datum = body_cell_value(source)
-      formatted_content = @formatter.call(cell_datum)
-      real_alignment = (@align_body == :auto ? infer_alignment(cell_datum) : @align_body)
-      infilled_subcells(formatted_content, real_alignment)
+    def header_cell
+      Cell.new(
+        value: @header,
+        formatter: -> (s) { s },
+        alignment: @align_header,
+        width: @width,
+        styler: @header_styler,
+        truncation_indicator: @truncation_indicator,
+        padding_character: @padding_character,
+      )
     end
 
-    def formatted_cell_content(source)
-      @formatter.call(body_cell_value(source))
+    def body_cell(source)
+      Cell.new(
+        value: body_cell_value(source),
+        formatter: @formatter,
+        alignment: @align_body,
+        width: @width,
+        styler: @styler,
+        truncation_indicator: @truncation_indicator,
+        padding_character: @padding_character,
+      )
     end
 
     def body_cell_value(source)
       @extractor.call(source)
     end
-
-    private
-
-    def infilled_subcells(str, real_alignment)
-      str.split($/, -1).flat_map do |substr|
-        substr_grapheme_clusters = substr.scan(/\X/)
-        subsubcells = []
-        current_subsubcell_grapheme_clusters = []
-        current_subsubcell_display_width = 0
-        substr_grapheme_clusters.each do |sgc|
-          sgc_display_width = Unicode::DisplayWidth.of(sgc)
-          if sgc_display_width + current_subsubcell_display_width > width
-            subsubcells << current_subsubcell_grapheme_clusters.join("")
-            current_subsubcell_grapheme_clusters.clear
-            current_subsubcell_display_width = 0
-          end
-
-          current_subsubcell_grapheme_clusters << sgc
-          current_subsubcell_display_width += sgc_display_width
-        end
-        subsubcells << current_subsubcell_grapheme_clusters.join("")
-        subsubcells.map { |s| align_cell_content(s, real_alignment) }
-      end
-    end
-
-    def align_cell_content(content, real_alignment)
-      padding = [@width - Unicode::DisplayWidth.of(content), 0].max
-      left_padding, right_padding =
-        case real_alignment
-        when :center
-          half_padding = padding / 2
-          [padding - half_padding, half_padding]
-        when :left
-          [0, padding]
-        when :right
-          [padding, 0]
-        end
-
-      "#{' ' * left_padding}#{content}#{' ' * right_padding}"
-    end
-
-    def infer_alignment(cell_datum)
-      case cell_datum
-      when Numeric
-        :right
-      when TrueClass, FalseClass
-        :center
-      else
-        :left
-      end
-    end
   end
 end

data/lib/tabulo/table.rb

@@ -85,6 +85,15 @@ module Tabulo
     #   using the <tt>align_body</tt> option passed to {#add_column}. If passed <tt>:auto</tt>,
     #   alignment is determined by cell content, with numbers aligned right, booleans
     #   center-aligned, and other values left-aligned.
+    # @param [nil, #to_proc] border_styler (nil) A lambda or other callable object taking
+    #   a single parameter, representing a section of the table's borders (which for this purpose
+    #   include any horizontal and vertical lines inside the table).
+    #   If passed <tt>nil</tt>, then no additional styling will be applied to borders. If passed a
+    #   callable, then that callable will be called for each border section, with the
+    #   resulting string rendered in place of that border. The extra width of the string returned by the
+    #   {border_styler} is not taken into consideration by the internal table rendering calculations
+    #   Thus it can be used to apply ANSI escape codes to border characters, to colour the borders
+    #   for example, without breaking the table formatting.
     # @return [Table] a new {Table}
     # @raise [InvalidColumnLabelError] if non-unique Symbols are provided to columns.
     # @raise [InvalidHorizontalRuleCharacterError] if invalid argument passed to horizontal_rule_character.
@@ -92,11 +101,10 @@ module Tabulo
     def initialize(sources, *cols, columns: [], column_width: nil, column_padding: nil, header_frequency: :start,
       wrap_header_cells_to: nil, wrap_body_cells_to: nil, horizontal_rule_character: nil,
       vertical_rule_character: nil, intersection_character: nil, truncation_indicator: nil,
-      align_header: :center, align_body: :auto)
+      align_header: :center, align_body: :auto, border_styler: nil)
 
       if columns.any?
-        Deprecation.warn("`columns' option to Tabulo::Table#initialize",
-                               "the variable length parameter `cols'", 2)
+        Deprecation.warn("`columns' option to Tabulo::Table#initialize", "the variable length parameter `cols'", 2)
       end
 
       @sources = sources
@@ -107,6 +115,7 @@ module Tabulo
       @column_padding = (column_padding || DEFAULT_COLUMN_PADDING)
       @align_header = align_header
       @align_body = align_body
+      @border_styler = border_styler
 
       @horizontal_rule_character = validate_character(horizontal_rule_character,
         DEFAULT_HORIZONTAL_RULE_CHARACTER, InvalidHorizontalRuleCharacterError, "horizontal rule character")
@@ -155,6 +164,34 @@ module Tabulo
     #   generates a Date, then the formatter might format that Date in a particular way.
     #   If no formatter is provided, then <tt>.to_s</tt> will be called on
     #   the extracted value of each cell to determine its displayed content.
+    # @param [nil, #to_proc] styler (nil) A lambda or other callable object that will be passed
+    #   two arguments: the calculated value of the cell (prior to the {formatter} being applied);
+    #   and a string representing a single formatted line within the cell. For example, if the
+    #   cell content is wrapped over three lines, then for that cell, the {styler} will be called
+    #   three times, once for each line of content within the cell. If passed <tt>nil</tt>, then
+    #   no additional styling will be applied to the cell content (other than what was already
+    #   applied by the {formatter}). If passed a callable, then that callable will be called for
+    #   each line of content within the cell, and the resulting string rendered in place of that
+    #   line. The {styler} option differs from the {formatter} option in that the extra width of the
+    #   string returned by {styler} 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 cell content, to colour the cell content for example, without
+    #   breaking the table formatting.
+    #   Note that if the content of a cell is truncated, then the whatever styling is applied by the
+    #   {styler} to the cell content will also be applied to the truncation indicator character.
+    # @param [nil, #to_proc] header_styler (nil) A lambda or other callable object taking
+    #   a single parameter, representing a single line of within the header content for
+    #   this column. For example, if the header cell content is wrapped over three lines, then
+    #   the {header_styler} will be called once for each line. If passed <tt>nil</tt>, then
+    #   no additional styling will be applied to the header cell content. If passed a callable,
+    #   then that callable will be called for each line of content within the header cell, and the
+    #   resulting string rendered in place of that line. The extra width of the string returned by the
+    #   {header_styler} 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 header cell content, to colour the cell content for example, without
+    #   breaking the table formatting.
+    #   Note that if the header content is truncated, then any {header_styler} will be applied to the
+    #   truncation indicator character as well as to the truncated content.
     # @param [#to_proc] extractor A block or other callable
     #   that will be passed each of the Table sources to determine the value in each cell of this
     #   column. If this is not provided, then the column label will be treated as a method to be
@@ -163,7 +200,7 @@ 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, header: nil, align_header: nil, align_body: nil,
-      width: nil, formatter: :to_s.to_proc, &extractor)
+      width: nil, formatter: :to_s.to_proc, styler: nil, header_styler: nil, &extractor)
 
       column_label =
         case label
@@ -184,7 +221,11 @@ module Tabulo
           align_body: align_body || @align_body,
           width: (width || @default_column_width),
           formatter: formatter,
-          extractor: (extractor || label.to_proc)
+          extractor: (extractor || label.to_proc),
+          styler: styler,
+          header_styler: header_styler,
+          truncation_indicator: @truncation_indicator,
+          padding_character: PADDING_CHARACTER,
         )
     end
 
@@ -224,7 +265,7 @@ module Tabulo
 
     # @return [String] an "ASCII" graphical representation of the Table column headers.
     def formatted_header
-      cells = column_registry.map { |_, column| column.header_subcells }
+      cells = column_registry.map { |_, column| column.header_cell }
       format_row(cells, @wrap_header_cells_to)
     end
 
@@ -240,7 +281,8 @@ module Tabulo
       inner = column_registry.map do |_, column|
         @horizontal_rule_character * (column.width + @column_padding * 2)
       end
-      surround_join(inner, @intersection_character)
+
+      styled_border(surround_join(inner, @intersection_character))
     end
 
     # Reset all the column widths so that each column is *just* wide enough to accommodate
@@ -279,7 +321,7 @@ module Tabulo
 
       @sources.each do |source|
         columns.each do |column|
-          width = wrapped_width(column.formatted_cell_content(source))
+          width = wrapped_width(column.body_cell(source).formatted_content)
           column.width = width if width > column.width
         end
       end
@@ -406,7 +448,7 @@ module Tabulo
 
     # @!visibility private
     def formatted_body_row(source, with_header: false)
-      cells = column_registry.map { |_, column| column.body_subcells(source) }
+      cells = column_registry.map { |_, column| column.body_cell(source) }
       inner = format_row(cells, @wrap_body_cells_to)
       if with_header
         join_lines([horizontal_rule, formatted_header, horizontal_rule, inner])
@@ -459,41 +501,22 @@ module Tabulo
     #   before truncating.
     # @return [String] the entire formatted row including all padding and borders.
     def format_row(cells, wrap_cells_to)
-      row_height = ([wrap_cells_to, cells.map(&:size).max].compact.min || 1)
-
-      subrows = (0...row_height).map do |subrow_index|
-        subrow_components = cells.zip(column_registry.values).map do |cell, column|
-          num_subcells = cell.size
-          cell_truncated = (num_subcells > row_height)
-          append_truncator = (cell_truncated && subrow_index + 1 == row_height)
-
-          lpad = PADDING_CHARACTER * @column_padding
-          rpad =
-            if append_truncator && @column_padding != 0
-              @truncation_indicator + PADDING_CHARACTER * (@column_padding - 1)
-            else
-              PADDING_CHARACTER * @column_padding
-            end
-
-          inner =
-            if subrow_index < num_subcells
-              cell[subrow_index]
-            else
-              PADDING_CHARACTER * column.width
-            end
-
-          "#{lpad}#{inner}#{rpad}"
-        end
-
-        surround_join(subrow_components, @vertical_rule_character)
-      end
-
+      max_cell_height = cells.map(&:height).max
+      row_height = ([wrap_cells_to, max_cell_height].compact.min || 1)
+      vertical = styled_border(@vertical_rule_character)
+      subcell_stacks = cells.map { |cell| cell.padded_truncated_subcells(row_height, @column_padding) }
+      subrows = subcell_stacks.transpose.map { |subrow_components| surround_join(subrow_components, vertical) }
       join_lines(subrows)
     end
 
     # @!visibility private
-    def surround(str, ch0)
-      "#{ch0}#{str}#{ch0}"
+    def styled_border(str)
+      @border_styler ? @border_styler.call(str) : str
+    end
+
+    # @!visibility private
+    def surround(str, ch)
+      "#{ch}#{str}#{ch}"
     end
 
     # @!visibility private

data/lib/tabulo/version.rb

@@ -1,3 +1,3 @@
 module Tabulo
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tabulo
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Matthew Harvey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-03 00:00:00.000000000 Z
+date: 2019-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tty-screen
@@ -187,6 +187,7 @@ files:
 - bin/console
 - bin/setup
 - lib/tabulo.rb
+- lib/tabulo/cell.rb
 - lib/tabulo/column.rb
 - lib/tabulo/deprecation.rb
 - lib/tabulo/exceptions.rb