tabulo 1.5.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdbbbcb7f1eb925be546ddb8b798f2c2aa949e737aa221018cfffeb25352458a
-  data.tar.gz: 6960e851a8086dc345d4f4db2d3867893b4a0772c748336b2341dd22f9c862be
+  metadata.gz: 02cf8fc58fb0164abdbf0fda2d80c4487c9be3bb17ecccfefc05bdf4bd381dd4
+  data.tar.gz: 826091614ae6734712d7320a6ab5c5fe169555646dd0f34e398cbc6fcbc414fc
 SHA512:
-  metadata.gz: b4488086be31ac7f659110c3f55c1a6ecce1ccfa59406ba165490622b86167bc61a666a3c42d4ae8c12a5ad4975141ea418242bcd971a4930fbc75a991797cc4
-  data.tar.gz: 1de32be32999408268de863e94c79fed536e6844a658f135288c4469c8081d3bce7461c90ef809d67f9a2cf5a1fd6c36f323da4c64a40d20d2fff336bf65d2eb
+  metadata.gz: ff79da1b58dd5cfe72214041b271a962ae43ad398cd00e4ac42b10af113128ade8e4a9026a09144f8d1dabffcb511c54740d4358d8ba57fcde060f81c7512835
+  data.tar.gz: f9b7dbabe3dbe44732b0e914a42b5be28ec5989183f4e576b7ece3227b36cfbd7508a659f78f804153c8de2512135496c5a9dd3f165144254841153f738328b8

data/.travis.yml

@@ -4,6 +4,6 @@ rvm:
   - 2.1.10
   - 2.2.10
   - 2.3.8
-  - 2.4.6
-  - 2.5.5
-  - 2.6.3
+  - 2.4.9
+  - 2.5.7
+  - 2.6.5

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+### v2.0.0
+
+#### New features
+
+* New `border` option for `Tabulo::Table` initializer allows for better customization of border and
+  divider characters, using a preset list of options, viz.: `:ascii`, `:modern`, `:markdown`,
+  `:blank` and `:classic`. In particular, the `:modern` border option uses smoothly drawn Unicode
+  line characters; and the `:markdown` option renders a GitHub-flavoured Markdown table.
+* `Tabulo::Table#horizontal_rule` method accepts `:top`, `:bottom` and `:middle` options to allow
+  the appropriate border characters to be used depending on its intended position in the table.
+* When iterating a `Tabulo::Row`, it's now possible to get the formatted string value of an individual
+  `Tabulo::Cell`, not just its underlying "raw" value.
+* Column padding can now optionally be configured separately for left and right column sides, by
+  passing a 2-element Array to the `column_padding` option of the `Tabulo::Table` initializer.
+
+#### Breaking changes
+
+* A `Tabulo::Row` is now a collection of `Tabulo::Cell`, not a collection of underlying "raw"
+  values. This makes it easier to get at both formatted string values and underlying "raw" values of
+  `Cell`s when traversing a `Row`. To get at the raw underlying value, call `Tabulo::Cell#value`.
+* Remove deprecated `columns` option from `Tabulo::Table` initializer
+  (existing `cols` positional parameter now renamed to `columns`).
+* Remove deprecated `shrinkwrap!` method (use `pack` instead).
+* By default, table now has a border line at the bottom. Pass `:classic` to the `border` option of
+  the `Tabulo::Table` initializer to get the old behaviour.
+* Removal of `horizontal_rule_character`, `vertical_rule_character` and `intersection` character
+  options from `Tabulo::Table` initializer, and from `Tabulo::Table#transpose` method. Use the
+  `border` option instead.
+
+#### Other noteworthy changes
+
+* Test coverage is now at exactly 100%
+* `hirb` gem now mentioned in README
+
 ### v1.5.1
 
 * Dependency version upgrades

data/README.md

@@ -12,38 +12,17 @@ Tabulo is a terminal table generator for Ruby.
 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
+Tabulo is both easy to use and feature rich, allowing you to quickly tabulate any enumerable
+collection, with options for automatic column sizing, a variety of border styles, and more.
 
-*Quick API:*
-
-```
-> puts Tabulo::Table.new(User.all, :id, :first_name, :last_name)
-+--------------+--------------+--------------+
-|      id      |  first_name  |   last_name  |
-+--------------+--------------+--------------+
-|            1 | John         | Citizen      |
-|            2 | Jane         | Doe          |
 ```
-
-*Full API:*
-
-```ruby
-underyling_enumerable = [1, 2, 50000000]
-
-table = Tabulo::Table.new(underlying_enumerable) do |t|
-  t.add_column("N") { |n| n }
-  t.add_column("Doubled") { |n| n * 2 }
-end
-```
-
-```
-> puts table
-+--------------+--------------+
-|       N      |    Doubled   |
-+--------------+--------------+
-|            1 |            2 |
-|            2 |            4 |
-|      5000000 |     10000000 |
+> puts Tabulo::Table.new(User.all, :id, :first_name, :last_name, border: :modern).pack
+┌────┬────────────┬───────────┐
+│ id │ first_name │ last_name │
+├────┼────────────┼───────────┤
+│  1 │ John       │ Citizen   │
+│  2 │ Jane       │ Doe       │
+└────┴────────────┴───────────┘
 ```
 
 ## Features
@@ -62,10 +41,10 @@ end
   underlying cell values.
 * 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.
+* Multibyte Unicode characters are correctly handled.
+* Apply [colours](#colours-and-styling) and other styling to table content and borders, without breaking the table.
 * Easily [transpose](#transposition) the table, so that rows are swapped with columns.
-* [Customize](#additional-configuration-options) border and divider characters.
+* Choose from multiple [border configurations](#borders), including Markdown, "ASCII", and smoothly joined Unicode border characters.
 * Use a [DRY initialization interface](#configuring-columns): by being "column based", it is
   designed to spare the developer the burden of syncing the ordering within the header row with that of the body rows.
 
@@ -93,8 +72,8 @@ Tabulo has also been ported to Crystal (with some modifications): see [Tablo](ht
      * [Accessing cell values](#accessing-cell-values)
      * [Accessing the underlying enumerable](#accessing-sources)
      * [Transposing rows and columns](#transposition)
-     * [Additional configuration options](#additional-configuration-options)
-  * [Motivation](#motivation)
+     * [Border configuration](#borders)
+  * [Comparison with other libraries](#motivation)
   * [Contributing](#contributing)
   * [License](#license)
 
@@ -162,6 +141,7 @@ table = Tabulo::Table.new([1, 2, 5], :itself, :even?, :odd?)
 |            1 |     false    |     true     |
 |            2 |     true     |     false    |
 |            5 |     false    |     true     |
++--------------+--------------+--------------+
 ```
 
 Columns can also be initialized using a callable to which each object will be passed to determine
@@ -184,6 +164,7 @@ end
 |            1 |            2 |     true     |
 |            2 |            4 |     false    |
 |            5 |           10 |     true     |
++--------------+--------------+--------------+
 ```
 
 <a name="cell-alignment"></a>
@@ -229,6 +210,7 @@ end
 +--------+-----------+
 |      1 |   false   |
 |      2 |    true   |
++--------+-----------+
 ```
 
 If you want to set the default column width for all columns of the table to something other
@@ -245,6 +227,7 @@ table = Tabulo::Table.new([1, 2], :itself, :even?, column_width: 6)
 +--------+--------+
 |      1 |  false |
 |      2 |  true  |
++--------+--------+
 ```
 
 Widths set for individual columns always override the default column width for the table.
@@ -253,8 +236,44 @@ Widths set for individual columns always override the default column width for t
 #### Configuring padding
 
 The single character of padding either side of each column is not counted in the column width.
-The amount of this padding can be configured for the table as a whole, using the `column_padding`
-option passed to `Table.new`.
+The amount of this extra padding can be configured for the table as a whole, using the `column_padding`
+option passed to `Table.new`&mdash;the default value of this option being `1`.
+
+Passing a single integer to this option causes the given amount of padding to be applied to each
+side of each column. For example:
+
+```ruby
+table = Tabulo::Table.new([1, 2, 5], :itself, :even?, :odd?, column_padding: 0)
+```
+
+```
+> puts table
++------------+------------+------------+
+|   itself   |    even?   |    odd?    |
++------------+------------+------------+
+|           1|    false   |    true    |
+|           2|    true    |    false   |
+|           5|    false   |    true    |
++------------+------------+------------+
+```
+
+Passing an array of _two_ integers to this option configures the left and right padding for each
+column, according to the first and second element of the array, respectively. For example:
+
+```ruby
+table = Tabulo::Table.new([1, 2, 5], :itself, :even?, :odd?, column_padding: [0, 2])
+```
+
+```
+> puts table
++--------------+--------------+--------------+
+|   itself     |    even?     |    odd?      |
++--------------+--------------+--------------+
+|           1  |    false     |    true      |
+|           2  |    true      |    false     |
+|           5  |    false     |    true      |
++--------------+--------------+--------------+
+```
 
 <a name="pack"></a>
 #### Automating column widths
@@ -275,6 +294,7 @@ table.pack
 +--------+-------+
 |      1 | false |
 |      2 |  true |
++--------+-------+
 ```
 
 The `pack` method returns the table itself, so you can "pack-and-print" in one go:
@@ -297,6 +317,7 @@ puts Tabulo::Table.new([1, 2], :itself, :even?).pack(max_table_width: 17)
 +-------+-------+
 |     1 | false |
 |     2 |  true |
++-------+-------+
 ```
 
 Or if you simply call `pack` with no arguments (or if you explicitly call
@@ -342,6 +363,7 @@ table = Tabulo::Table.new(
 | abcdefghijkl |           26 |
 | mnopqrstuvwx |              |
 | yz           |              |
++--------------+--------------+
 ```
 
 Wrapping behaviour is configured for the table as a whole using the `wrap_header_cells_to` option
@@ -365,6 +387,7 @@ table = Tabulo::Table.new(
 +--------------+--------------+
 | hello        |            5 |
 | abcdefghijkl~|           26 |
++--------------+--------------+
 ```
 
 <a name="formatting-cell-values"></a>
@@ -393,6 +416,7 @@ end
 |            1 |         1.00 |
 |            2 |         0.50 |
 |            3 |         0.33 |
++--------------+--------------+
 ```
 
 Note the numbers in the "Reciprocal" column in this example are still right-aligned, even though
@@ -493,6 +517,7 @@ table = Tabulo::Table.new(1..10, :itself, :even?, header_frequency: 5)
 |            8 |     true     |
 |            9 |     false    |
 |           10 |     true     |
++--------------+--------------+
 ```
 
 <a name="enumerator"></a>
@@ -526,16 +551,21 @@ 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 values of each cell. A `Tabulo::Row` can also
+is itself an `Enumerable`, of `Tabulo::Cell`. The `Tabulo::Cell#value` method will return the
+underlying value of the cell; while `Tabulo::Cell#formatted_value` will return its formatted content
+as a string.
+
+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?)
 
 table.each do |row|
-  row.each { |cell| puts cell } # 1...2...3...4...5
-  puts row.to_h[:even?]         # false...true...false...true...false
+  row.each { |cell| puts cell.value } # 1...2...3...4...5
+  puts row.to_h[:even?].value         # false...true...false...true...false
 end
 ```
 
@@ -553,8 +583,8 @@ end
 
 table.each do |row|
   cells = row.to_h
-  puts cells[:Number]  # 1...2...3...4...5
-  puts cells[:doubled] # 2...4...6...8...10
+  puts cells[:Number].value  # 1...2...3...4...5
+  puts cells[:doubled].value # 2...4...6...8...10
 end
 ```
 
@@ -616,59 +646,95 @@ a new table in which the rows and columns are swapped:
 |  pred |           -2 |           -1 |            0 |
 |  succ |            0 |            1 |            2 |
 |   abs |            1 |            0 |            1 |
++-------+--------------+--------------+--------------+
 ```
 
 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.5.1/Tabulo/Table#transpose-instance_method).
+[documentation](https://www.rubydoc.info/gems/tabulo/2.0.0/Tabulo/Table#transpose-instance_method).
 
-<a name="additional-configuration-options"></a>
-### Additional configuration options
+<a name="borders"></a>
+### Configuring borders
 
-The characters used for horizontal dividers, vertical dividers and corners, which default to `-`,
-`|` and `+` respectively, can be configured using the using the `horizontal_rule_character`,
-`vertical_rule_character` and `intersection_character` options passed to `Table.new`.
+You can configure the kind of border and divider characters that are used when the table is printed.
+This is done using the `border` option passed to `Table.new`. The options are as follows.
 
-The character used to indicate truncation, which defaults to `~`, can be configured using the
-`truncation_indicator` option passed to `Table.new`.
+`:ascii`&mdash;this is the default; the table is drawn entirely with characters in the ASCII set:
 
-A bottom border can be added to the table when printing, as follows:
+```
+> puts Tabulo::Table.new(1...3, :itself, :even?, :odd?, border: :ascii)
++--------------+--------------+--------------+
+|    itself    |     even?    |     odd?     |
++--------------+--------------+--------------+
+|            1 |     false    |     true     |
+|            2 |     true     |     false    |
+|            3 |     false    |     true     |
++--------------+--------------+--------------+
+```
 
-```ruby
-puts table
-puts table.horizontal_rule
+`:modern`&mdash;uses smoothly joined Unicode characters:
+
+```
+> puts Tabulo::Table.new(1..3, :itself, :even?, :odd?, border: :modern)
+┌──────────────┬──────────────┬──────────────┐
+│    itself    │     even?    │     odd?     │
+├──────────────┼──────────────┼──────────────┤
+│            1 │     false    │     true     │
+│            2 │     true     │     false    │
+│            3 │     false    │     true     │
+└──────────────┴──────────────┴──────────────┘
 ```
 
-This will output a bottom border that's appropriately sized for the table.
+`:markdown`&mdash;renders a GitHub flavoured Markdown table:
 
-This mechanism can also be used to output a horizontal divider after each row:
+```
+> puts Tabulo::Table.new(1..3, :itself, :even?, :odd?, border: :markdown)
+|    itself    |     even?    |     odd?     |
+|--------------|--------------|--------------|
+|            1 |     false    |     true     |
+|            2 |     true     |     false    |
+|            3 |     false    |     true     |
+```
 
-```ruby
-table = Tabulo::Table.new(1..3, :itself, :even?)
+`:blank`&mdash;no border or divider characters are printed:
+
+```
+> puts Tabulo::Table.new(1...3, :itself, :even?, :odd?, border: :blank)
+    itself         even?         odd?     
+            1      false         true     
+            2      true          false    
+            3      false         true     
 ```
 
+`:classic`&mdash;reproduces the default behaviour in Tabulo v1; this is like the `:ascii` option,
+but without a bottom border:
+
 ```
-> table.each { |row| puts row ; puts table.horizontal_rule }
-+--------------+--------------+
-|    itself    |     even?    |
-+--------------+--------------+
-|            1 |     false    |
-+--------------+--------------+
-|            2 |     true     |
-+--------------+--------------+
-|            3 |     false    |
-+--------------+--------------+
+> puts Tabulo::Table.new(1...3, :itself, :even?, :odd?, border: :classic)
++--------------+--------------+--------------+
+|    itself    |     even?    |     odd?     |
++--------------+--------------+--------------+
+|            1 |     false    |     true     |
+|            2 |     true     |     false    |
+|            3 |     false    |     true     |
 ```
 
+<a name="additional-configuration-options"></a>
+### Other configuration options
+
+The character used to indicate truncation, which defaults to `~`, can be configured using the
+`truncation_indicator` option passed to `Table.new`.
+
 <a name="motivation"></a>
-## Motivation
+## Comparison with other libraries
 
-There are other terminal table generators for Ruby. Popular among these are:
+There are other libraries for generating plain text tables in Ruby. Popular among these are:
 
 * [terminal-table](https://github.com/tj/terminal-table)
 * [tty-table](https://github.com/piotrmurach/tty-table)
 * [table\_print](https://github.com/arches/table_print)
+* [hirb](https://github.com/cldwalker/hirb)
 
 *DISCLAIMER: My comments regarding these other libraries are based only on my own, possibly flawed
 reading of the documentation for, and experimentation with, these libraries at the time of my
@@ -676,15 +742,15 @@ writing this. Their APIs, features or documentation may well change between when
 when you read it. Please consult the libraries' own documentation for yourself, rather than relying
 on these comments.*
 
-While these libraries have their strengths, I personally found that for the common use case of
+While these libraries have their strengths, I have personally found that, for the common use case of
 printing a table on the basis of some underlying enumerable collection (such as an ActiveRecord
-query result), using these libraries felt more cumbersome than it needed to be.
+query result), using these libraries feels more cumbersome than it could be.
 
 For example, suppose we have called `User.all` from the Rails console, and want to print
 a table showing the email, first name, last name and ID of each user,
 with column headings. Also, we want the ID column to be right-aligned, because it's a number.
 
-In `terminal-table`, we could achieve this as follows:
+In **terminal-table**, we could achieve this as follows:
 
 ```ruby
 rows = User.all.map { |u| [u.email, u.first_name, u.last_name, u.id] }
@@ -702,7 +768,7 @@ tables, but for tables that have many columns, or that are constructed
 dynamically based on user input or other runtime factors determining the columns
 to be included, this can be a hassle and a source of brittleness.
 
-`tty-table` has a somewhat different API to `terminal-table`. It offers both a
+**tty-table** has a somewhat different API to `terminal-table`. It offers both a
 "row-based" and a "column-based" method of initializing a table. The row-based method
 is similar to `terminal-table`'s in that it burdens the developer with syncing the
 column ordering across multiple code locations. The "column-based" API for `tty-table`, on
@@ -729,20 +795,20 @@ this, but if there is, it doesn't seem to be documented.) So it seems we still h
 `table.align_column(3, :right)`, which again burdens us with keeping the column index
 passed to `align_column` in sync.
 
-Finally, there is [table\_print](https://github.com/arches/table_print). This is a
-handy gem for quickly tabulating ActiveRecord collections from the Rails
-console. `table_print` is similar to `tabulo` in that it has a column-based API, so it doesn't
-suffer from the multiple-source-of-knowledge issue in regards to column orderings. However, as far
-as I can tell, it lacks certain other useful features, such as the ability to repeat headers every N
-rows, the automatic alignment of columns based on cell content (numbers right, strings left), and a
-quick and easy way to automatically resize columns to accommodate cell content without overflowing
-the terminal. Also, as of the time of writing, `table_print`'s last significant commit (ignoring a
-deprecation warning fix in April 2018) was in March 2016.
-
-I don't mean to disparage any of these other projects&mdash;they each have their strengths&mdash;but
-rather to explain my motivation for developing and maintaining Tabulo despite their existence, and
-to provide reasons one might consider for using `tabulo` rather than another terminal table
-gem.
+As for **table\_print**, this is a handy gem for quickly tabulating ActiveRecord
+collections from the Rails console. `table_print` is similar to `tabulo` in that it has a
+column-based API, so it doesn't suffer from the multiple-source-of-knowledge issue in regards to
+column orderings. However, it lacks certain other useful features, such as the ability to repeat
+headers every N rows, the automatic alignment of columns based on cell content (numbers right,
+strings left), and a quick and easy way to automatically resize columns to accommodate cell content
+without overflowing the terminal. Also, as of the time of writing, `table_print`'s last significant
+commit (ignoring a deprecation warning fix in April 2018) was in March 2016.
+
+Finally, it is worth mentioning the **hirb** library. This is similar to `table_print`, in that it's
+well suited to quickly displaying ActiveRecord collections from the Rails console. However, like
+`table_print`, there are certain useful features it's lacking; and using it outside the console
+environment seems cumbersome. Moreover, it seems no longer to be maintained. At the time of writing,
+its last commit was in March 2015.
 
 <a name="contributing"></a>
 ## Contributing
@@ -752,9 +818,9 @@ Issues and pull requests are welcome on GitHub at https://github.com/matt-harvey
 To start working on Tabulo, `git clone` and `cd` into your fork of the repo, then run `bin/setup` to
 install dependencies.
 
-`bin/console` will give you an interactive prompt that will allow you to experiment; and `rake spec`
-will run the test suite. For a list of other Rake tasks that are available in the development
-environment, run `rake -T`.
+`bin/console` will give you an interactive prompt that will allow you to experiment; and
+`bundle exec rake spec` will run the test suite. For a list of other Rake tasks that are available in
+the development environment, run `bundle exec rake -T`.
 
 ## License
 
@@ -762,14 +828,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.5.1
+[Documentation]: http://www.rubydoc.info/gems/tabulo/2.0.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.5.1-blue.svg
+[DC img]: https://img.shields.io/badge/documentation-v2.0.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.5.1
+2.0.0

data/lib/tabulo.rb

@@ -6,3 +6,4 @@ require "tabulo/version"
 require "tabulo/row"
 require "tabulo/cell"
 require "tabulo/column"
+require "tabulo/border"

data/lib/tabulo/border.rb

@@ -0,0 +1,166 @@
+module Tabulo
+
+  # @!visibility private
+  class Border
+
+    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: "+",
+      },
+      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: {
+      },
+    }
+
+    # @!visibility private
+    def self.from(initializer, styler = nil)
+      new(options(initializer).merge(styler: styler))
+    end
+
+    # @!visibility private
+    def horizontal_rule(column_widths, position = :bottom)
+      left, center, right, segment =
+        case position
+        when :top
+          [@corner_top_left, @tee_top, @corner_top_right, @edge_top]
+        when :middle
+          [@tee_left, @intersection, @tee_right, @divider_horizontal]
+        when :bottom
+          [@corner_bottom_left, @tee_bottom, @corner_bottom_right, @edge_bottom]
+        end
+      segments = column_widths.map { |width| segment * width }
+      style("#{left}#{segments.join(center)}#{right}")
+    end
+
+    # @!visibility private
+    def join_cell_contents(cells)
+      styled_divider_vertical = style(@divider_vertical)
+      styled_edge_left = style(@edge_left)
+      styled_edge_right = style(@edge_right)
+      styled_edge_left + cells.join(styled_divider_vertical) + styled_edge_right
+    end
+
+    private
+
+    def self.options(kind)
+      opts = STYLES[kind]
+      return opts if opts
+      raise InvalidBorderError
+    end
+
+    # @param [nil, #to_proc] 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), and returning a string.
+    #   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
+    #   {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 [Border] a new {Border}
+    def initialize(
+      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: "",
+      styler: nil)
+
+      @corner_top_left = corner_top_left
+      @corner_top_right = corner_top_right
+      @corner_bottom_right = corner_bottom_right
+      @corner_bottom_left = corner_bottom_left
+
+      @edge_top = edge_top
+      @edge_right = edge_right
+      @edge_bottom = edge_bottom
+      @edge_left = edge_left
+
+      @tee_top = tee_top
+      @tee_right = tee_right
+      @tee_bottom = tee_bottom
+      @tee_left = tee_left
+
+      @divider_vertical = divider_vertical
+      @divider_horizontal = divider_horizontal
+
+      @intersection = intersection
+
+      @styler = styler
+    end
+
+    def style(s)
+      @styler ? @styler.call(s) : s
+    end
+  end
+end

data/lib/tabulo/cell.rb

@@ -2,9 +2,13 @@ require "unicode/display_width"
 
 module Tabulo
 
-  # @!visibility private
+  # Represents a single cell within the body of a {Table}.
   class Cell
 
+    # @return the underlying value for this Cell
+    attr_reader :value
+
+    # @!visibility private
     def initialize(value:, formatter:, alignment:, width:, styler:, truncation_indicator:, padding_character:)
       @value = value
       @formatter = formatter
@@ -15,18 +19,23 @@ module Tabulo
       @padding_character = padding_character
     end
 
+    # @!visibility private
     def height
       subcells.size
     end
 
-    def padded_truncated_subcells(target_height, padding_amount)
+    # @!visibility private
+    def padded_truncated_subcells(target_height, padding_amount_left, padding_amount_right)
+      total_padding_amount = padding_amount_left + padding_amount_right
       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)
+        append_truncator = (truncated && (total_padding_amount != 0) && (subcell_index + 1 == target_height))
+        padded_subcell(subcell_index, padding_amount_left, padding_amount_right, append_truncator)
       end
     end
 
+    # @return [String] the content of the Cell, after applying the formatter for this Column (but
+    #   without applying any wrapping or the styler).
     def formatted_content
       @formatted_content ||= @formatter.call(@value)
     end
@@ -37,9 +46,14 @@ module Tabulo
       @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)
+    def padded_subcell(subcell_index, padding_amount_left, padding_amount_right, append_truncator)
+      lpad = @padding_character * padding_amount_left
+      rpad =
+        if append_truncator
+          styled_truncation_indicator + padding(padding_amount_right - 1)
+        else
+          padding(padding_amount_right)
+        end
       inner = subcell_index < height ? subcells[subcell_index] : padding(@width)
       "#{lpad}#{inner}#{rpad}"
     end

data/lib/tabulo/exceptions.rb

@@ -3,19 +3,10 @@ module Tabulo
   # Error indicating that the label of a column is invalid.
   class InvalidColumnLabelError < StandardError; end
 
-  # Error indicating that an attempt was made to use an invalid horizontal rule character
-  # for the table.
-  class InvalidHorizontalRuleCharacterError < StandardError; end
-
-  # Error indicating that an attempt was made to use an invalid vertical rule character
-  # for the table.
-  class InvalidVerticalRuleCharacterError < StandardError; end
-
-  # Error indicating that an attempt was made to use an invalid intersection character for
-  # the table.
-  class InvalidIntersectionCharacterError < StandardError; end
-
   # Error indicating that an attempt was made to use an invalid truncation indicator for
   # the table.
   class InvalidTruncationIndicatorError < StandardError; end
+
+  # Error indicating the table border configuration is invalid.
+  class InvalidBorderError < StandardError; end
 end

data/lib/tabulo/row.rb

@@ -7,10 +7,10 @@ module Tabulo
     attr_reader :source
 
     # @!visibility private
-    def initialize(table, source, with_header: true)
+    def initialize(table, source, header: :top)
       @table = table
       @source = source
-      @with_header = with_header
+      @header = header
     end
 
     # Calls the given block once for each cell in the {Row}, passing that cell as parameter.
@@ -25,7 +25,7 @@ module Tabulo
     #   end
     def each
       @table.column_registry.each do |_, column|
-        yield column.body_cell_value(@source)
+        yield column.body_cell(@source)
       end
     end
 
@@ -34,20 +34,15 @@ module Tabulo
     #   in the {Table} and how the {Table} was configured with respect to header frequency).
     def to_s
       if @table.column_registry.any?
-        @table.formatted_body_row(@source, with_header: @with_header)
+        @table.formatted_body_row(@source, header: @header)
       else
         ""
       end
     end
 
-    # @return a Hash representation of the {Row}, with column labels acting
-    #   as keys and the calculated cell values (before formatting) providing the values.
-    # @example
-    #   table = Tabulo::Table.new([1, 10], columns: %i[itself even?])
-    #   row = table.first
-    #   row.to_h  # => { :itself => 1, :even? => false }
+    # @return a Hash representation of the {Row}, with column labels acting as keys and the {Cell}s the values.
     def to_h
-      @table.column_registry.map { |label, column| [label, column.body_cell_value(@source)] }.to_h
+      @table.column_registry.map { |label, column| [label, column.body_cell(@source)] }.to_h
     end
   end
 end

data/lib/tabulo/table.rb

@@ -10,19 +10,13 @@ module Tabulo
     include Enumerable
 
     # @!visibility public
-    DEFAULT_COLUMN_WIDTH = 12
-
-    # @!visibility public
-    DEFAULT_COLUMN_PADDING = 1
+    DEFAULT_BORDER = :ascii
 
     # @!visibility public
-    DEFAULT_HORIZONTAL_RULE_CHARACTER = "-"
-
-    # @!visibility public
-    DEFAULT_VERTICAL_RULE_CHARACTER = "|"
+    DEFAULT_COLUMN_WIDTH = 12
 
     # @!visibility public
-    DEFAULT_INTERSECTION_CHARACTER = "+"
+    DEFAULT_COLUMN_PADDING = 1
 
     # @!visibility public
     DEFAULT_TRUNCATION_INDICATOR = "~"
@@ -37,11 +31,10 @@ module Tabulo
     attr_accessor :sources
 
     # @param [Enumerable] sources the underlying Enumerable from which the table will derive its data
-    # @param [Array[Symbol]] cols Specifies the initial columns. The Symbols provided must
+    # @param [Array[Symbol]] columns Specifies the initial columns. The Symbols provided must
     #   be unique. Each element of the Array  will be used to create a column whose content is
     #   created by calling the corresponding method on each element of sources. Note
     #   the {#add_column} method is a much more flexible way to set up columns on the table.
-    # @param [Array[Symbol]] columns <b>DEPRECATED</b> Use <tt>cols</tt> instead.
     # @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 [:start, nil, Integer] header_frequency Controls the display of column headers.
@@ -59,24 +52,15 @@ module Tabulo
     #   headers), if their content is longer than the column's fixed width. If passed <tt>nil</tt>, content will
     #   be wrapped for as many rows as required to accommodate it. If passed an Integer N (> 0), content will be
     #   wrapped up to N rows and then truncated thereafter.
-    # @param [nil, String] horizontal_rule_character Determines the character used to draw
-    #   horizontal lines where required in the table. If omitted or passed <tt>nil</tt>, defaults to
-    #   {DEFAULT_HORIZONTAL_RULE_CHARACTER}. If passed something other than <tt>nil</tt> or a single-character
-    #   String, raises {InvalidHorizontalRuleCharacterError}.
-    # @param [nil, String] vertical_rule_character Determines the character used to draw
-    #   vertical lines where required in the table. If omitted or passed <tt>nil</tt>, defaults to
-    #   {DEFAULT_VERTICAL_RULE_CHARACTER}. If passed something other than <tt>nil</tt> or a single-character
-    #   String, raises {InvalidVerticalRuleCharacterError}.
-    # @param [nil, String] intersection_character Determines the character used to draw
-    #   line intersections and corners where required in the table. If omitted or passed <tt>nil</tt>,
-    #   defaults to {DEFAULT_INTERSECTION_CHARACTER}. If passed something other than <tt>nil</tt> or
-    #   a single-character String, raises {InvalidIntersectionCharacterError}.
     # @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
     #   a single-character String, raises {InvalidTruncationIndicatorError}.
-    # @param [nil, Integer] column_padding Determines the amount of blank space with which to pad either
-    #   of each column. Defaults to 1.
+    # @param [nil, Integer, Array] column_padding (1) Determines the amount of blank space with which to pad
+    #   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.
     # @param [:left, :right, :center] align_header (:center) Determines the alignment of header text
     #   for columns in this Table. Can be overridden for individual columns using the
     #   <tt>align_header</tt> option passed to {#add_column}
@@ -85,9 +69,20 @@ 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 [:ascii, :markdown, :modern, :blank, nil] border (nil) Determines the characters used
+    #   for the Table border, including both the characters around the outside of table, and the lines drawn
+    #   within the table to separate columns from each other and the header row from the Table body.
+    #   Possible values are:
+    #   - `:ascii`     Uses ASCII characters only
+    #   - `:markdown`  Produces as a GitHub-flavoured Markdown table
+    #   - `:modern`    Uses non-ASCII Unicode characters to render a border with smooth continuous lines
+    #   - `:blank`     No border characters are rendered
+    #   - `:classic`   Like `:ascii`, but does not have a horizontal line at the bottom of the
+    #                  table. This reproduces the default behaviour in `tabulo` v1.
+    #   If <tt>nil</tt>, then {DEFAULT_BORDER} will be used.
     # @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).
+    #   include any horizontal and vertical lines inside the table), and returning a string.
     #   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
@@ -96,38 +91,36 @@ module Tabulo
     #   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.
-    # @raise [InvalidVerticalRuleCharacterError] if invalid argument passed to vertical_rule_character.
-    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, border_styler: nil)
-
-      if columns.any?
-        Deprecation.warn("`columns' option to Tabulo::Table#initialize", "the variable length parameter `cols'", 2)
-      end
+    # @raise [InvalidBorderError] if invalid option passed to `border` parameter.
+    def initialize(sources, *columns, column_width: nil, column_padding: nil, header_frequency: :start,
+      wrap_header_cells_to: nil, wrap_body_cells_to: nil, truncation_indicator: nil, align_header: :center,
+      align_body: :auto, border: nil, border_styler: nil)
 
       @sources = sources
       @header_frequency = header_frequency
       @wrap_header_cells_to = wrap_header_cells_to
       @wrap_body_cells_to = wrap_body_cells_to
       @default_column_width = (column_width || DEFAULT_COLUMN_WIDTH)
-      @column_padding = (column_padding || DEFAULT_COLUMN_PADDING)
       @align_header = align_header
       @align_body = align_body
+
+      @column_padding = (column_padding || DEFAULT_COLUMN_PADDING)
+      @left_column_padding, @right_column_padding =
+        case @column_padding
+        when Array
+          @column_padding
+        else
+          [@column_padding, @column_padding]
+        end
+
+      @border = (border || DEFAULT_BORDER)
       @border_styler = border_styler
+      @border_instance = Border.from(@border, @border_styler)
 
-      @horizontal_rule_character = validate_character(horizontal_rule_character,
-        DEFAULT_HORIZONTAL_RULE_CHARACTER, InvalidHorizontalRuleCharacterError, "horizontal rule character")
-      @vertical_rule_character = validate_character(vertical_rule_character,
-        DEFAULT_VERTICAL_RULE_CHARACTER, InvalidVerticalRuleCharacterError, "vertical rule character")
-      @intersection_character = validate_character(intersection_character,
-        DEFAULT_INTERSECTION_CHARACTER, InvalidIntersectionCharacterError, "intersection character")
       @truncation_indicator = validate_character(truncation_indicator,
         DEFAULT_TRUNCATION_INDICATOR, InvalidTruncationIndicatorError, "truncation indicator")
 
       @column_registry = { }
-      cols.each { |item| add_column(item) }
       columns.each { |item| add_column(item) }
 
       yield self if block_given?
@@ -233,7 +226,9 @@ module Tabulo
     #   display in a fixed-width font.
     def to_s
       if column_registry.any?
-        join_lines(map(&:to_s))
+        bottom_edge = horizontal_rule(:bottom)
+        rows = map(&:to_s)
+        bottom_edge.empty? ? join_lines(rows) : join_lines(rows + [bottom_edge])
       else
         ""
       end
@@ -250,16 +245,20 @@ module Tabulo
     # were not disabled when the Table was initialized).
     def each
       @sources.each_with_index do |source, index|
-        include_header =
+        header =
           case @header_frequency
           when :start
-            index == 0
+            :top if index == 0
           when Integer
-            index % @header_frequency == 0
+            if index == 0
+              :top
+            elsif index % @header_frequency == 0
+              :middle
+            end
           else
             @header_frequency
           end
-        yield body_row(source, with_header: include_header)
+        yield body_row(source, header: header)
       end
     end
 
@@ -269,20 +268,26 @@ module Tabulo
       format_row(cells, @wrap_header_cells_to)
     end
 
+    # @param [:top, :middle, :bottom] align_body (:bottom) Specifies the position
+    #   for which the resulting horizontal dividing line is intended to be printed.
+    #   This determines the border characters that are used to construct the line.
     # @return [String] an "ASCII" graphical representation of a horizontal
-    #   dividing line suitable for printing at any point in the table.
-    # @example Print a horizontal divider after every row:
-    #   table.each do |row|
+    #   dividing line suitable for printing at the top, bottom or middle of the
+    #   table.
+    # @example Print a horizontal divider between each pair of rows, and again
+    #   at the bottom:
+    #
+    #   table.each_with_index do |row, i|
+    #     puts table.horizontal_rule(:middle) unless i == 0
     #     puts row
-    #     puts table.horizontal_rule
     #   end
+    #   puts table.horizontal_rule(:bottom)
     #
-    def horizontal_rule
-      inner = column_registry.map do |_, column|
-        @horizontal_rule_character * (column.width + @column_padding * 2)
-      end
-
-      styled_border(surround_join(inner, @intersection_character))
+    # 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 = column_registry.map { |_, column| column.width + total_column_padding }
+      @border_instance.horizontal_rule(column_widths, position)
     end
 
     # Reset all the column widths so that each column is *just* wide enough to accommodate
@@ -352,9 +357,8 @@ module Tabulo
     # @param [Hash] opts Options for configuring the new, transposed {Table}.
     #   The following options are the same as the keyword params for the {#initialize} method for
     #   {Table}: <tt>column_width</tt>, <tt>column_padding</tt>, <tt>header_frequency</tt>,
-    #   <tt>wrap_header_cells_to</tt>, <tt>wrap_body_cells_to</tt>, <tt>horizontal_rule_character</tt>,
-    #   <tt>vertical_rule_character</tt>, <tt>intersection_character</tt>, <tt>truncation_indicator</tt>,
-    #   <tt>align_header</tt>, <tt>align_body</tt>.
+    #   <tt>wrap_header_cells_to</tt>, <tt>wrap_body_cells_to</tt>, <tt>border</tt>,
+    #   <tt>border_styler</tt>, <tt>truncation_indicator</tt>, <tt>align_header</tt>, <tt>align_body</tt>.
     #   These are applied in the same way as documented for {#initialize}, when creating the
     #   new, transposed Table. Any options not specified explicitly in the call to {#transpose}
     #   will inherit their values from the original {Table} (with the exception of settings
@@ -376,12 +380,11 @@ module Tabulo
     #   new Table (other than the left-most column's header, which is determined as described
     #   above).
     # @return [Table] a new {Table}
-    # @raise [InvalidHorizontalRuleCharacterError] if invalid argument passed to horizontal_rule_character.
-    # @raise [InvalidVerticalRuleCharacterError] if invalid argument passed to vertical_rule_character.
+    # @raise [InvalidBorderError] if invalid argument passed to `border` parameter.
     def transpose(opts = {})
       default_opts = [:column_width, :column_padding, :header_frequency, :wrap_header_cells_to,
-        :wrap_body_cells_to, :horizontal_rule_character, :vertical_rule_character,
-        :intersection_character, :truncation_indicator, :align_header, :align_body].map do |sym|
+        :wrap_body_cells_to, :truncation_indicator, :align_header, :align_body, :border,
+        :border_styler].map do |sym|
         [sym, instance_variable_get("@#{sym}")]
       end.to_h
 
@@ -411,47 +414,17 @@ module Tabulo
       end
     end
 
-    # @deprecated Use {#pack} instead.
-    #
-    # Reset all the column widths so that each column is *just* wide enough to accommodate
-    # its header text as well as the formatted content of each its cells for the entire
-    # collection, together with a single character of padding on either side of the column,
-    # without any wrapping.
-    #
-    # Note that calling this method will cause the entire source Enumerable to
-    # be traversed and all the column extractors and formatters to be applied in order
-    # to calculate the required widths.
-    #
-    # Note also that this method causes column widths to be fixed as appropriate to the
-    # formatted cell contents given the state of the source Enumerable at the point it
-    # is called. If the source Enumerable changes between that point, and the point when
-    # the Table is printed, then columns will *not* be resized yet again on printing.
-    #
-    # @param [nil, Numeric] max_table_width (nil) If provided, stops the total table
-    #   width (including padding and borders) from expanding beyond this number of characters.
-    #   If passed <tt>:auto</tt>, the table width will automatically be capped at the current
-    #   terminal width.
-    #   Width is deducted from columns if required to achieve this, with one character progressively
-    #   deducted from the width of the widest column until the target is reached. When the
-    #   table is printed, wrapping or truncation will then occur in these columns as required
-    #   (depending on how they were configured).
-    #   Note that regardless of the value passed to max_table_width, the table will always be left wide
-    #   enough to accommodate at least 1 character's width of content, 1 character of left padding and
-    #   1 character of right padding in each column, together with border characters (1 on each side
-    #   of the table and 1 between adjacent columns). I.e. there is a certain width below width the
-    #   Table will refuse to shrink itself.
-    # @return [Table] the Table itself
-    def shrinkwrap!(max_table_width: nil)
-      Deprecation.warn("`Tabulo::Table#shrinkwrap!'", "`#pack'")
-      pack(max_table_width: max_table_width)
-    end
-
     # @!visibility private
-    def formatted_body_row(source, with_header: false)
+    def formatted_body_row(source, header: nil)
       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])
+      if header
+        join_lines([
+          horizontal_rule(header == :top ? :top : :middle),
+          formatted_header,
+          horizontal_rule(:middle),
+          inner,
+        ].reject(&:empty?))
       else
         inner
       end
@@ -459,11 +432,16 @@ module Tabulo
 
     private
 
+    # @!visibility private
+    def total_column_padding
+      @left_column_padding + @right_column_padding
+    end
+
     # @!visibility private
     def shrink_to(max_table_width)
       columns = column_registry.values
       total_columns_width = columns.inject(0) { |sum, column| sum + column.width }
-      total_padding = column_registry.count * @column_padding * 2
+      total_padding = column_registry.count * total_column_padding
       total_borders = column_registry.count + 1
       unadjusted_table_width = total_columns_width + total_padding + total_borders
 
@@ -483,8 +461,8 @@ module Tabulo
     end
 
     # @!visibility private
-    def body_row(source, with_header: false)
-      Row.new(self, source, with_header: with_header)
+    def body_row(source, header: nil)
+      Row.new(self, source, header: header)
     end
 
     # @!visibility private
@@ -503,25 +481,14 @@ module Tabulo
     def format_row(cells, wrap_cells_to)
       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 styled_border(str)
-      @border_styler ? @border_styler.call(str) : str
-    end
-
-    # @!visibility private
-    def surround(str, ch)
-      "#{ch}#{str}#{ch}"
-    end
+      subcell_stacks = cells.map do |cell|
+        cell.padded_truncated_subcells(row_height, @left_column_padding, @right_column_padding)
+      end
+      subrows = subcell_stacks.transpose.map do |subrow_components|
+        @border_instance.join_cell_contents(subrow_components)
+      end
 
-    # @!visibility private
-    def surround_join(arr, ch)
-      surround(arr.join(ch), ch)
+      join_lines(subrows)
     end
 
     # @!visibility private

data/lib/tabulo/version.rb

@@ -1,3 +1,3 @@
 module Tabulo
-  VERSION = "1.5.1"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tabulo
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Matthew Harvey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-23 00:00:00.000000000 Z
+date: 2019-11-04 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/border.rb
 - lib/tabulo/cell.rb
 - lib/tabulo/column.rb
 - lib/tabulo/deprecation.rb