tabulo 2.3.0 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87e2e8bb108886b594c80a32396ab586c90792ae6e5efeb5769e457b13d6c96d
-  data.tar.gz: 03c93ac0d5419fb654244ab574d9e7aa43263f40ca71e008f6d43772a76ffece
+  metadata.gz: 1aa563982fa70661534282898690138b6ee57a9aacf74edec622e148d4c3cfdb
+  data.tar.gz: 5d4265a55ba3add10cdcef1408a81446fb4a9aa8a48da6997ac6f193eeba0f05
 SHA512:
-  metadata.gz: ae04026433b44638cd777f483fb0e8b0494370cc71fb84c5bc91cc38c65c92aa4e68183b48db1e92e53b3e3ede6b680975190d2626510f0ad31b6f651bb9538d
-  data.tar.gz: 5a543577d7d678ccee445789d588147a778fa45899876872749ad1ced9119e99369b43b1e7b642d2f9eae27c41d2e904de9d7765513b9b813824deac5e8d958c
+  metadata.gz: b8737456dfe272f6b7cf3714ee17dede09be428101ea05ba7f8eef3fdd3bb7e4e9d19c121d499c40374b48ae6b92ceda341ce39c05884f624c19bfa0309f307c
+  data.tar.gz: 3222d37f42ea2568d6d3e6f9901fbfcf0cae94eeb10440051186f2caab375ab1effb6eafe95ba7dc43c4810fbfc905cbe5095befa264d612e4f0ef20f31ac61e

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+### v2.3.1
+
+* Documentation improvements
+* Update dependency versions
+* Minor refactoring
+* Update Ruby gem description and summary
+
 ### v2.3.0
 
 * Provide `#remove_column` method.

data/README.md

@@ -43,7 +43,7 @@ end
 
 ## Features
 
-* Presents a [DRY initialization interface](#configuring-columns): by being “column based” rather than
+* Presents a [DRY initialization interface](#adding-columns): by being “column based” rather than
   “row based”, it spares the developer the burden of syncing the ordering within the header row
   with that of the body rows.
 * Lets you set [fixed column widths](#fixed-column-widths), then either [wrap](#overflow-handling)
@@ -75,12 +75,18 @@ Tabulo has also been ported to Crystal (with some modifications): see [Tablo](ht
   * [Installation](#installation)
   * [Detailed usage](#detailed-usage)
      * [Requiring the gem](#requiring-the-gem)
-     * [Configuring columns](#configuring-columns)
+     * [Creating a table](#table-initialization)
+     * [Adding columns](#adding-columns)
+        * [Quick API](#quick-api)
+        * [Full API](#quick-api)
+        * [Column labels _vs_ headers](#labels-headers)
+        * [Positioning columns](#column-positioning)
+     * [Removing columns](#removing-columns)
      * [Cell alignment](#cell-alignment)
      * [Column width, wrapping and truncation](#column-width-wrapping-and-truncation)
         * [Configuring fixed widths](#configuring-fixed-widths)
-        * [Configuring padding](#configuring-padding)
         * [Automating column widths](#automating-column-widths)
+        * [Configuring padding](#configuring-padding)
         * [Overflow handling](#overflow-handling)
      * [Formatting cell values](#formatting-cell-values)
      * [Colours and other styling](#colours-and-styling)
@@ -124,33 +130,30 @@ Or install it yourself:
 require 'tabulo'
 ```
 
-### Configuring columns
-
-You instantiate a `Tabulo::Table` by passing it an underlying `Enumerable` and then telling it
-the columns you want to generate.
+<a name="table-initialization"></a>
+### Creating a table
 
-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:
+You instantiate a `Tabulo::Table` by passing it an underlying `Enumerable`, being the collection of
+things that you want to tabulate. Each member of this collection will end up
+corresponding to a row of the table. The collection can be any `Enumerable`, for example a Ruby
+`Array`, or an ActiveRecord relation:
 
 ```ruby
 table = Tabulo::Table.new([1, 2, 5])
-table.add_column(:itself)
-table.add_column(:even?)
-table.add_column(:odd?)
+other_table = Tabulo::Table.new(User.all)
 ```
 
-Alternatively, you can pass an initialization block to `new`:
+For the table to be useful, however, it must also contain columns&hellip;
 
-```ruby
-table = Tabulo::Table.new([1, 2, 5]) do |t|
-  t.add_column(:itself)
-  t.add_column(:even?)
-  t.add_column(:odd?)
-end
-```
+<a name="adding-columns"></a>
+### Adding columns
+
+<a name="quick-api"></a>
+#### Quick API
 
-When the columns correspond to methods, you can also use the &ldquo;quick API&rdquo;, by passing a symbol
-directly to `new` for each column:
+When the columns correspond to methods on members of the underlying enumerable, you can use
+the &ldquo;quick API&rdquo;, by passing a symbol directly to `Tabulo::Table.new` for each column.
+This symbol also provides the column header:
 
 ```ruby
 table = Tabulo::Table.new([1, 2, 5], :itself, :even?, :odd?)
@@ -167,9 +170,32 @@ table = Tabulo::Table.new([1, 2, 5], :itself, :even?, :odd?)
 +--------------+--------------+--------------+
 ```
 
-Columns can also be initialized using a callable to which each object will be passed to determine
-the value to be displayed in the table. In this case, the first argument to `add_column` provides
-the header text:
+<a name="full-api"></a>
+#### Full API
+
+Columns can also be added to the table one-by-one using `add_column`. This &ldquo;full API&rdquo; is
+more verbose, but provides greater configurability:
+
+```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)
+  t.add_column(:even?)
+  t.add_column(:odd?)
+end
+```
+
+With the full API, columns can also be initialized using a callable to which each object will be
+passed to determine the value to be displayed in the table. In this case, the first argument to
+`add_column` provides the header text:
 
 ```ruby
 table = Tabulo::Table.new([1, 2, 5]) do |t|
@@ -190,6 +216,23 @@ end
 +--------------+--------------+--------------+
 ```
 
+<a name="labels-headers"></a>
+#### Column labels _vs_ headers
+
+The first argument to `add_column` is the called the _label_ for that column. It serves as the
+column&#8217;s unique identifier: only one column may have a given label per table.
+(`String`s and `Symbol`s are interchangeable for this purpose.) The label also forms the header shown
+at the top of the column, unless a separate `header:` argument is explicitly passed:
+
+```ruby
+table.add_column(:itself, header: "N")
+table.add_column(:itself2, header: "N", &:itself)  # header need not be unique
+# table.add_column(:itself)  # would raise Tabulo::InvalidColumnLabelError, as label must be unique
+```
+
+<a name="column-positioning"></a>
+#### Positioning columns
+
 By default, each new column is added to the right of all the other columns so far added to the
 table. However, if you want to insert a new column into some other position, you can use the
 `before` option, passing the label of the column to the left of which you want the new column to be added:
@@ -210,9 +253,15 @@ table.add_column(:even?, before: :odd?)
 +--------------+--------------+--------------+
 ```
 
-There is also a `#remove_column` method, for deleting an existing column from a table; see the
-[documentation](https://www.rubydoc.info/gems/tabulo/2.3.0/Tabulo/Table#remove_column-instance_method)
-for details.
+<a name="removing-columns"></a>
+### Removing columns
+
+There is also a `#remove_column` method, for deleting an existing column from a table. Pass it
+the label of the column you want to remove:
+
+```ruby
+table.remove_column(:even?)
+```
 
 <a name="cell-alignment"></a>
 ### Cell alignment
@@ -279,92 +328,49 @@ table = Tabulo::Table.new([1, 2], :itself, :even?, column_width: 6)
 
 Widths set for individual columns always override the default column width for the table.
 
-<a name="configuring-padding"></a>
-#### Configuring padding
-
-The single character of padding either side of each column is not counted in the column width.
-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
 
 Instead of setting column widths &ldquo;manually&rdquo;, you can tell the table to sort out the widths
 itself, so that each column is just wide enough for its header and contents (plus a character
-of padding):
+of padding on either side):
 
 ```ruby
-table = Tabulo::Table.new([1, 2], :itself, :even?)
+table = Tabulo::Table.new(["short", "here is a longer phrase"], :itself, :size)
 table.pack
 ```
 
 ```
 > puts table
-+--------+-------+
-| itself | even? |
-+--------+-------+
-|      1 | false |
-|      2 |  true |
-+--------+-------+
++-------------------------+------+
+|          itself         | size |
++-------------------------+------+
+| short                   |    5 |
+| here is a longer phrase |   23 |
++-------------------------+------+
 ```
 
 The `pack` method returns the table itself, so you can &ldquo;pack-and-print&rdquo; in one go:
 
 ```ruby
-puts Tabulo::Table.new([1, 2], :itself, :even?).pack
+puts Tabulo::Table.new(["short", "here is a longer phrase"], :itself, :size).pack
 ```
 
 <a name="max-table-width"></a>
 You can manually place an upper limit on the total width of the table when packing:
 
 ```ruby
-puts Tabulo::Table.new([1, 2], :itself, :even?).pack(max_table_width: 17)
+puts Tabulo::Table.new(["short", "here is a longer phrase"], :itself, :size).pack(max_table_width: 24)
 ```
 
 ```
-+-------+-------+
-| itsel | even? |
-| f     |       |
-+-------+-------+
-|     1 | false |
-|     2 |  true |
-+-------+-------+
++---------------+------+
+|     itself    | size |
++---------------+------+
+| short         |    5 |
+| here is a lon |   23 |
+| ger phrase    |      |
++---------------+------+
 ```
 
 Or if you simply call `pack` with no arguments (or if you explicitly call
@@ -391,6 +397,49 @@ resized yet again on printing. This is a consequence of the table always being e
 table itself. There are [ways around this](#freezing-a-table), however, if this is not the desired
 behaviour&mdash;see [below](#freezing-a-table).
 
+<a name="configuring-padding"></a>
+#### Configuring padding
+
+The single character of padding either side of each column is not counted in the column width.
+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="overflow-handling"></a>
 #### Overflow handling
 
@@ -669,11 +718,8 @@ table.each do |row|
 end
 ```
 
-The first argument to `add_column` always provides the key for the purpose of accessing the `Hash`
-form of a `Tabulo::Row`. (If the provided argument was a `String`, it will be converted to a
-`Symbol` for purposes of accessing this `Hash`.) This key serves as a sort of &ldquo;logical label&rdquo;
-for the column; and it need not be the same as the column header. If we want the header to be different
-to the label, we can achieve this using the `header` option to `add_column`:
+The column label (being the first argument that was passed to `add_column`, converted if necessary
+to a `Symbol`), always forms the key for the purposes of this `Hash`:
 
 ```ruby
 table = Tabulo::Table.new(1..3) do |t|
@@ -752,7 +798,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`&#8217;s behaviour. For details, see the
-[documentation](https://www.rubydoc.info/gems/tabulo/2.3.0/Tabulo/Table#transpose-instance_method).
+[documentation](https://www.rubydoc.info/gems/tabulo/2.3.1/Tabulo/Table#transpose-instance_method).
 
 <a name="borders"></a>
 ### Configuring borders
@@ -1061,14 +1107,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/2.3.0
+[Documentation]: http://www.rubydoc.info/gems/tabulo/2.3.1
 [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-v2.3.0-blue.svg
+[DC img]: https://img.shields.io/badge/documentation-v2.3.1-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 @@
-2.3.0
+2.3.1

data/lib/tabulo/table.rb

@@ -107,23 +107,10 @@ module Tabulo
     # @return [Table] a new {Table}
     # @raise [InvalidColumnLabelError] if non-unique Symbols are provided to columns.
     # @raise [InvalidBorderError] if invalid option passed to `border` parameter.
-    def initialize(
-      sources,
-      *columns,
-      align_body:            :auto,
-      align_header:          :center,
-      border:                nil,
-      border_styler:         nil,
-      column_padding:        nil,
-      column_width:          nil,
-      formatter:             :to_s.to_proc,
-      header_frequency:      :start,
-      header_styler:         nil,
-      row_divider_frequency: nil,
-      styler:                nil,
-      truncation_indicator:  nil,
-      wrap_body_cells_to:    nil,
-      wrap_header_cells_to:  nil)
+    def initialize(sources, *columns, align_body: :auto, align_header: :center, border: nil,
+      border_styler: nil, column_padding: nil, column_width: nil, formatter: :to_s.to_proc,
+      header_frequency: :start, header_styler: nil, row_divider_frequency: nil, styler: nil,
+      truncation_indicator: nil, wrap_body_cells_to: nil, wrap_header_cells_to: nil)
 
       @sources = sources
 
@@ -135,12 +122,7 @@ module Tabulo
       @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
+        Array === @column_padding ? @column_padding : [@column_padding, @column_padding]
 
       @column_width = (column_width || DEFAULT_COLUMN_WIDTH)
       @formatter = formatter
@@ -230,25 +212,10 @@ module Tabulo
     # @raise [InvalidColumnLabelError] if label has already been used for another column in this
     #   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)
-
-      column_label =
-        case label
-        when Integer, Symbol
-          label
-        when String
-          label.to_sym
-        end
+    def add_column(label, align_body: nil, align_header: nil, before: nil, formatter: nil,
+      header: nil, header_styler: nil, styler: nil, width: nil, &extractor)
+
+      column_label = normalize_column_label(label)
 
       if column_registry.include?(column_label)
         raise InvalidColumnLabelError, "Column label already used in this table."
@@ -267,7 +234,11 @@ module Tabulo
         width: width || @column_width,
       )
 
-      add_column_before(column, column_label, before)
+      if before == nil
+        add_column_final(column, column_label)
+      else
+        add_column_before(column, column_label, before)
+      end
     end
 
     # Removes the column identifed by the passed label.
@@ -315,22 +286,17 @@ module Tabulo
     # Note that when printed, the first row will visually include the headers (assuming these
     # were not disabled when the Table was initialized).
     def each
+      header_frequency_is_integer = (Integer === @header_frequency)
       @sources.each_with_index do |source, index|
+        is_first_row = (index == 0)
         header =
-          case @header_frequency
-          when :start
-            :top if index == 0
-          when Integer
-            if index == 0
-              :top
-            elsif index % @header_frequency == 0
-              :middle
-            end
-          else
-            @header_frequency
+          if is_first_row && (@header_frequency == :start || header_frequency_is_integer)
+            :top
+          elsif header_frequency_is_integer && (index % @header_frequency == 0)
+            :middle
           end
 
-        show_divider = @row_divider_frequency && (index != 0) && (index % @row_divider_frequency == 0)
+        show_divider = @row_divider_frequency && !is_first_row && (index % @row_divider_frequency == 0)
 
         yield Row.new(self, source, header: header, divider: show_divider)
       end
@@ -338,7 +304,7 @@ module Tabulo
 
     # @return [String] an "ASCII" graphical representation of the Table column headers.
     def formatted_header
-      cells = column_registry.map { |_, column| column.header_cell }
+      cells = get_columns.map(&:header_cell)
       format_row(cells, @wrap_header_cells_to)
     end
 
@@ -360,7 +326,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 = column_registry.map { |_, column| column.width + total_column_padding }
+      column_widths = get_columns.map { |column| column.width + total_column_padding }
       @border_instance.horizontal_rule(column_widths, position)
     end
 
@@ -393,15 +359,12 @@ module Tabulo
     #   Table will refuse to shrink itself.
     # @return [Table] the Table itself
     def pack(max_table_width: :auto)
-      return self if column_registry.none?
-      columns = column_registry.values
-
-      columns.each { |column| column.width = wrapped_width(column.header) }
+      get_columns.each { |column| column.width = wrapped_width(column.header) }
 
       @sources.each do |source|
-        columns.each do |column|
+        get_columns.each do |column|
           width = wrapped_width(column.body_cell(source).formatted_content)
-          column.width = width if width > column.width
+          column.width = [width, column.width].max
         end
       end
 
@@ -492,20 +455,27 @@ module Tabulo
 
     # @!visibility private
     def formatted_body_row(source, header:, divider:)
-      cells = column_registry.map { |_, column| column.body_cell(source) }
+      cells = get_columns.map { |column| column.body_cell(source) }
       inner = format_row(cells, @wrap_body_cells_to)
 
-      if header
+      if header == :top
+        join_lines([
+          horizontal_rule(:top),
+          formatted_header,
+          horizontal_rule(:middle),
+          inner
+        ].reject(&:empty?))
+      elsif header
         join_lines([
-          horizontal_rule(header == :top ? :top : :middle),
+          horizontal_rule(:middle),
           formatted_header,
           horizontal_rule(:middle),
-          inner,
+          inner
         ].reject(&:empty?))
       elsif divider
         join_lines([
           horizontal_rule(:middle),
-          inner,
+          inner
         ].reject(&:empty?))
       else
         inner
@@ -514,39 +484,49 @@ module Tabulo
 
     private
 
+    # @!visibility private
+    def get_columns
+      column_registry.values
+    end
+
     # @!visibility private
     def add_column_before(column, label, before)
-      if before == nil
-        @column_registry[label] = column
-      else
-        old_column_entries = @column_registry.to_a
-        new_column_entries = []
-        found = false
-        old_column_entries.each do |entry|
-          if entry[0] == before
-            found = true
-            new_column_entries << [label, column]
-          end
-          new_column_entries << entry
-        end
-        unless found
-          raise InvalidColumnLabelError, "There is no column with label #{before}"
-        end
-        @column_registry = new_column_entries.to_h
+      old_column_entries = @column_registry.to_a
+      new_column_entries = []
+
+      old_column_entries.each do |entry|
+        new_column_entries << [label, column] if entry[0] == before
+        new_column_entries << entry
       end
+
+      found = (new_column_entries.size == old_column_entries.size + 1)
+      raise InvalidColumnLabelError, "There is no column with label #{before}" unless found
+
+      @column_registry = new_column_entries.to_h
     end
 
     # @!visibility private
-    def total_column_padding
-      @left_column_padding + @right_column_padding
+    def add_column_final(column, label)
+      @column_registry[label] = column
+    end
+
+    # @!visibility private
+    def normalize_column_label(label)
+      case label
+      when Integer, Symbol
+        label
+      when String
+        label.to_sym
+      end
     end
 
     # @!visibility private
     def shrink_to(max_table_width)
-      columns = column_registry.values
+      columns = get_columns
+      num_columns = columns.count
       total_columns_width = columns.inject(0) { |sum, column| sum + column.width }
-      total_padding = column_registry.count * total_column_padding
-      total_borders = column_registry.count + 1
+      total_padding = num_columns * total_column_padding
+      total_borders = num_columns + 1
       unadjusted_table_width = total_columns_width + total_padding + total_borders
 
       # Ensure max table width is at least wide enough to accommodate table borders and padding
@@ -564,6 +544,11 @@ 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.
@@ -615,8 +600,7 @@ module Tabulo
     def wrapped_width(str)
       segments = str.split($/)
       segments.inject(1) do |longest_length_so_far, segment|
-        length = Unicode::DisplayWidth.of(segment)
-        longest_length_so_far > length ? longest_length_so_far : length
+        [longest_length_so_far, Unicode::DisplayWidth.of(segment)].max
       end
     end
   end

data/lib/tabulo/version.rb

@@ -1,3 +1,3 @@
 module Tabulo
-  VERSION = "2.3.0"
+  VERSION = "2.3.1"
 end

data/tabulo.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Matthew Harvey"]
   spec.email         = ["software@matthewharvey.net"]
 
-  spec.summary       = "Enumerable ASCII terminal table"
-  spec.description   = "Enumerable ASCII terminal table"
+  spec.summary       = "Terminal table generator"
+  spec.description   = "Plain text table generator with a column-based API"
   spec.homepage      = "https://github.com/matt-harvey/tabulo"
   spec.license       = "MIT"
 
@@ -28,8 +28,8 @@ Gem::Specification.new do |spec|
     "changelog_uri"   => "https://raw.githubusercontent.com/matt-harvey/tabulo/master/CHANGELOG.md"
   }
 
-  spec.add_runtime_dependency "tty-screen", "0.7.0"
-  spec.add_runtime_dependency "unicode-display_width", "1.6.0"
+  spec.add_runtime_dependency "tty-screen", "0.7.1"
+  spec.add_runtime_dependency "unicode-display_width", "1.6.1"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 11.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tabulo
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.3.1
 platform: ruby
 authors:
 - Matthew Harvey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-03 00:00:00.000000000 Z
+date: 2020-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tty-screen
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.7.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.7.1
 - !ruby/object:Gem::Dependency
   name: unicode-display_width
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.6.0
+        version: 1.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.6.0
+        version: 1.6.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -164,7 +164,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: Enumerable ASCII terminal table
+description: Plain text table generator with a column-based API
 email:
 - software@matthewharvey.net
 executables: []
@@ -222,5 +222,5 @@ rubyforge_project:
 rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: Enumerable ASCII terminal table
+summary: Terminal table generator
 test_files: []