tty-table 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e62b5af0c89b3acf1aa73598053bc5b5f364d9f346fc40e20129d2a639c3919
-  data.tar.gz: 812b92b6eccf2743f121bfd85c069f833e0e3d80507526a8c1cabfacb776df15
+  metadata.gz: d1de8ba17e3ea8c4b575292757c2d9908abbbeec7511fda9692b4718bb423fbd
+  data.tar.gz: 5208f9766c7309b44f97b54282b6cd9bb7d5bf8966fdd8db337bd653e65696af
 SHA512:
-  metadata.gz: bdc6608e3633b35eaed9481e545732c6d55f9ec43823ca111b08b177edb03046e1710221d36e7e4b6df8980d8555ebfecfdfc07535786199ae04f37e18423228
-  data.tar.gz: 1a77ffd2f0ef11427c5bb4769edb6ec41f691f0226f6f216c3988abd19519ce5ab84685de4b90d7a2f590023b3fedde2a075a4b80f7992b74a6160be909280a6
+  metadata.gz: 7547f09416d4e89f7292c6505554c3bbde7f6b83531acbad831a8e0ba96012c2e806611f9a0162e97610e3ed85c98d67b3b96f936e279546145d44ae74cbdbf2
+  data.tar.gz: 3a7daadb0f83bd72dc99c3992b1b9f82684714b20e9bcb55b16bb8a3eee87cd3e2c88bd175eff5af5d7dc5f270cc82e386979fd90cd4d3ec06e6ac6af73c14fd

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Change log
 
+## [v0.12.0] - 2020-09-20
+
+### Changed
+* Optimize adding rows by Tim Craft(@timcraft)
+* Remove the equatable and necromancer dependencies
+* Update the pastel, tty-screen and strings dependencies
+* Change Border to use BorderDSL exclusively for handling options
+
+### Fixed
+* Fix resize option raising an error for small terminal sizes by Katelyn Schiesser(@slowbro)
+* Fix Table::Indentation to check for map method support by @deemytch
+
 ## [v0.11.0] - 2019-08-01
 
 ### Add
@@ -103,6 +115,7 @@
 
 * Initial implementation and release
 
+[v0.12.0]: https://github.com/piotrmurach/tty-table/compare/v0.11.0...v0.12.0
 [v0.11.0]: https://github.com/piotrmurach/tty-table/compare/v0.10.0...v0.11.0
 [v0.10.0]: https://github.com/piotrmurach/tty-table/compare/v0.9.0...v0.10.0
 [v0.9.0]: https://github.com/piotrmurach/tty-table/compare/v0.8.0...v0.9.0

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Piotr Murach
+Copyright (c) 2015 Piotr Murach (piotrmurach.com)
 
 MIT License
 

data/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <a href="https://piotrmurach.github.io/tty" target="_blank"><img width="130" src="https://github.com/piotrmurach/tty/blob/master/images/tty.png" alt="tty logo" /></a>
+  <a href="https://ttytoolkit.org" target="_blank"><img width="130" src="https://github.com/piotrmurach/tty/blob/master/images/tty.png" alt="TTY Toolkit logo" /></a>
 </div>
 
 # TTY::Table [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
@@ -36,7 +36,7 @@
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tty-table'
+gem "tty-table"
 ```
 
 And then execute:
@@ -58,9 +58,9 @@ Or install it yourself as:
 * [3. Rendering](#3-rendering)
   * [3.1 Render](#31-render)
   * [3.2 Renderer](#32-renderer)
-    * [3.1.1 Basic renderer](#311-basic)
-    * [3.1.2 ASCII renderer](#312-ascii-renderer)
-    * [3.1.3 Unicode renderer](#313-unicode-renderer)
+    * [3.2.1 Basic renderer](#321-basic-renderer)
+    * [3.2.2 ASCII renderer](#322-ascii-renderer)
+    * [3.2.3 Unicode renderer](#323-unicode-renderer)
   * [3.3 Options](#33-options)
   * [3.4 Alignment](#34-alignment)
   * [3.5 Border](#35-border)
@@ -76,16 +76,16 @@ Or install it yourself as:
 
 ## 1. Usage
 
-First, provide **TTY::Table** with headers and data:
+First, provide **TTY::Table** with data, for example, two headers and two rows:
 
 ```ruby
-table = TTY::Table.new ['header1','header2'], [['a1', 'a2'], ['b1', 'b2']]
+table = TTY::Table.new(["header1","header2"], [["a1", "a2"], ["b1", "b2"]])
 ```
 
-Then simply call `render` on the instance with with border type as first argument:
+Then to print to the console, call the `render` method with border type as a first argument:
 
 ```ruby
-table.render(:ascii)
+puts table.render(:ascii)
 # =>
 #  +-------+-------+
 #  |header1|header2|
@@ -103,39 +103,39 @@ table.render(:ascii)
 **TTY::Table** can be created in variety of ways. The easiest way is to pass 2-dimensional array:
 
 ```ruby
-table = TTY::Table[['a1', 'a2'], ['b1', 'b2']]
-table = TTY::Table.new [['a1', 'a2'], ['b1', 'b2']]
-table = TTY::Table.new rows: [['a1', 'a2'], ['b1', 'b2']]
+table = TTY::Table[["a1", "a2"], ["b1", "b2"]]
+table = TTY::Table.new([["a1", "a2"], ["b1", "b2"]])
+table = TTY::Table.new(rows: [["a1", "a2"], ["b1", "b2"]])
 ```
 
-Alternatively you can specify rows one by one inside block:
+Alternatively you can specify the rows one by one inside a block:
 
 ```ruby
 table = TTY::Table.new do |t|
-  t << ['a1', 'a2']
-  t << ['b1', 'b2']
+  t << ["a1", "a2"]
+  t << ["b1", "b2"]
 end
 ```
 
-You can add rows of data after initialization:
+You can add rows of data after initialization with `<<` operator:
 
 ```ruby
 table = TTY::Table.new
-table << ['a1','a2']
-table << ['b1','b2']
+table << ["a1","a2"]
+table << ["b1","b2"]
 ```
 
-In addition to rows you can specify table header:
+In addition to rows, you can specify table header:
 
 ```ruby
-table = TTY::Table.new ['h1', 'h2'], [['a1', 'a2'], ['b1', 'b2']]
-table = TTY::Table.new header: ['h1', 'h2'], rows: [['a1', 'a2'], ['b1', 'b2']]
+table = TTY::Table.new(["h1", "h2"], [["a1", "a2"], ["b1", "b2"]])
+table = TTY::Table.new(header: ["h1", "h2"], rows: [["a1", "a2"], ["b1", "b2"]])
 ```
 
-or cross header with rows inside a hash like so
+You can also mix header with rows inside a hash like so:
 
 ```ruby
-table = TTY::Table.new [{'h1' => ['a1', 'a2'], 'h2' => ['b1', 'b2']}]
+table = TTY::Table.new([{"h1" => ["a1", "a2"], "h2" => ["b1", "b2"]}])
 ```
 
 ### 2.2 Iteration
@@ -143,9 +143,9 @@ table = TTY::Table.new [{'h1' => ['a1', 'a2'], 'h2' => ['b1', 'b2']}]
 Table behaves like an Array so `<<`, `each` and familiar methods can be used:
 
 ```ruby
-table << ['a1', 'a2', 'a3']
-table << ['b1', 'b2', 'b3']
-table << ['a1', 'a2'] << ['b1', 'b2']  # chain rows assignment
+table << ["a1", "a2", "a3"]
+table << ["b1", "b2", "b3"]
+table << ["a1", "a2"] << ["b1", "b2"]  # chain rows assignment
 ```
 
 In order to iterate over table rows including headers do:
@@ -160,30 +160,30 @@ table.each_with_index  { |row, index| ... }    # iterate over rows with an index
 In order to reference the row at `index` do:
 
 ```ruby
-table = TTY::Table.new [['a1','a2'], ['b1','b2']]
-table[0]                    # => ['a1','a2']
-table.row(0)                # => ['a1','a2']
+table = TTY::Table.new [["a1","a2"], ["b1","b2"]]
+table[0]                    # => ["a1","a2"]
+table.row(0)                # => ["a1","a2"]
 table.row(i) { |row| ... }  # return array for row(i)
 ```
 
 Negative indices count backwards from the end of table data (`-1` is the last element):
 
 ```ruby
-table[-1]   # => ['b1','b2']
+table[-1]   # => ["b1","b2"]
 ```
 
 To reference element at given row(i) and column(j) do:
 
 ```ruby
 table[i, j]   # return element at row(i) and column(j)
-table[0,0]    # => 'a1'
+table[0,0]    # => "a1"
 ```
 
 To specifically reference column(j) do:
 
 ```ruby
 table.column(j) { ... }   # return array for column(j)
-table.column(0)           # => ['a1','b1']
+table.column(0)           # => ["a1","b1"]
 table.column(name)        # return array for column(name), name of header
 ```
 
@@ -210,7 +210,7 @@ table.size             # return an array of [row_size, column_size]
 Given a table:
 
 ```ruby
-table = TTY::Table.new ['header1','header2'], [['a1', 'a2'], ['b1', 'b2']]
+table = TTY::Table.new(["header1","header2"], [["a1", "a2"], ["b1", "b2"]])
 ```
 
 Once you have an instance of `TTY::Table` you can decorate the content using the `render` method. In order to display a basic whitespace delimited view do:
@@ -246,7 +246,7 @@ end
 Given a table of data:
 
 ```ruby
-table = TTY::Table.new ['header1','header2'], [['a1', 'a2'], ['b1', 'b2']]
+table = TTY::Table.new ["header1","header2"], [["a1", "a2"], ["b1", "b2"]]
 ```
 
 You can create a special renderer for it:
@@ -347,25 +347,16 @@ table.render(:unicode)
 
 Rendering of **TTY-Table** includes numerous customization options:
 
-```ruby
-alignments     # array of cell alignments out of :left, :center and :right,
-               # default :left
-border         # hash of border options - :characters, :style and :separator
-border_class   # a type of border to use such as TTY::Table::Border::Null,
-               # TTY::Table::Border::ASCII, TTY::Table::Border::Unicode
-column_widths  # array of maximum column widths
-filter         # a proc object that is applied to every field in a row
-indent         # indentation applied to rendered table, by default 0
-multiline      # if true will wrap text at new line or column width,
-               # when false will escape special characters
-padding        # array of integers to set table fields padding,
-               # by default [0,0,0,0]
-resize         # if true will expand/shrink table column sizes to match
-               # the terminal width, otherwise if false will rotate
-               # table vertically. By default set to false
-width          # constrain the table total width, by default dynamically
-               # calculated based on content and terminal size
-```
+* `:alignments` - array of cell alignments out of `:left`, `:center` and `:righit`. Defaults to `:left`.
+* `:border` - hash of border options out of `:characters`, `:style` and `:separator`
+* `:border_class` - a type of border to use such as `TTY::Table::Border::Null`, `TTY::Table::Border::ASCII` and `TTY::Table::Border::Unicode`
+* `:column_widths` - array of maximum column widths
+* `:filter` - a `proc` object that is applied to every field in a row
+* `:indent` - indentation applied to rendered table, by default 0
+* `:multiline` - when `true` will wrap text at new line or column width, when `false` will escape special characters
+* `:padding` - array of integers to set table fields padding. Defaults to `[0,0,0,0]`.
+* `:resize` - when `true` will expand/shrink table column sizes to match the terminal width, otherwise when `false` will rotate table vertically. Defaults to `false`.
+* `:width` - constrains the table total width. Defaults to value automatically calculated based on the content and terminal size.
 
 The `render` method can accept as a second argument the above options either as hash value:
 
@@ -373,11 +364,11 @@ The `render` method can accept as a second argument the above options either as
 table.render(:basic, alignments: [:left, :center])
 ```
 
-or inside a block:
+Or inside a block as a property:
 
 ```ruby
 table.render(:basic) do |renderer|
-  renderer.alignments= [:left, :center]
+  renderer.alignments = [:left, :center]
 end
 ```
 
@@ -385,10 +376,10 @@ end
 
 By default all columns are `:left` aligned.
 
-You can align each column individuall by passing `alignments` option to table renderer:
+You can align each column individually by passing `:alignments` option to table renderer:
 
 ```ruby
-table.render :ascii, alignments: [:center, :right]
+table.render(:ascii, alignments: [:center, :right])
 # =>
 #  +-------+-------+
 #  |header1|header2|
@@ -398,10 +389,10 @@ table.render :ascii, alignments: [:center, :right]
 #  +-------+-------+
 ```
 
-Alternatively you can align all columns with `alignment` option:
+Alternatively you can align all columns with `:alignment` option:
 
 ```ruby
-table.render :ascii, alignment: [:center]
+table.render(:ascii, alignment: [:center])
 # =>
 #  +-------+-------+
 #  |header1|header2|
@@ -414,9 +405,9 @@ table.render :ascii, alignment: [:center]
 If you require a more granular alignment you can align individual fields in a row by passing `:alignment` option like so:
 
 ```ruby
-table = TTY::Table.new header: ['header1', 'header2']
-table << [{value: 'a1', alignment: :right}, 'a2']
-table << ['b1', {value: 'b2', alignment: :center}]
+table = TTY::Table.new(header: ["header1", "header2"])
+table << [{value: "a1", alignment: :right}, "a2"]
+table << ["b1", {value: "b2", alignment: :center}]
 ```
 
 and then simply render:
@@ -437,7 +428,7 @@ table.render(:ascii)
 To print border around data table you need to specify `renderer` type out of `basic`, `ascii`, `unicode`. By default `basic` is used. For instance, to output unicode border:
 
 ```ruby
-table = TTY::Table.new ['header1', 'header2'], [['a1', 'a2'], ['b1', 'b2']]
+table = TTY::Table.new ["header1", "header2"], [["a1", "a2"], ["b1", "b2"]]
 table.render :unicode
 # =>
 #  ┌───────┬───────┐
@@ -480,11 +471,11 @@ The following are available border parts:
 Using the above border parts you can create your own border with the `border` helper:
 
 ```ruby
-table = TTY::Table.new ['header1', 'header2'], [['a1', 'a2'], ['b1', 'b2']
+table = TTY::Table.new ["header1", "header2"], [["a1", "a2"], ["b1", "b2"]
 table.render do |renderer|
   renderer.border do
-    mid          '='
-    mid_mid      ' '
+    mid          "="
+    mid_mid      " "
   end
 end
 # =>
@@ -501,13 +492,13 @@ You can also create your own custom border by subclassing `TTY::Table::Border` a
 ```ruby
 class MyBorder < TTY::Table::Border
   def_border do
-    left         '$'
-    center       '$'
-    right        '$'
-    bottom       ' '
-    bottom_mid   '*'
-    bottom_left  '*'
-    bottom_right '*'
+    left         "$"
+    center       "$"
+    right        "$"
+    bottom       " "
+    bottom_mid   "*"
+    bottom_left  "*"
+    bottom_right "*"
   end
 end
 ```
@@ -515,7 +506,7 @@ end
 Next pass the border class to your table instance `render_with` method
 
 ```ruby
-table = TTY::Table.new ['header1', 'header2'], [['a1', 'a2'], ['b1', 'b2']
+table = TTY::Table.new ["header1", "header2"], [["a1", "a2"], ["b1", "b2"]
 table.render_with MyBorder
 # =>
 #  $header1$header2$
@@ -528,7 +519,7 @@ table.render_with MyBorder
 In addition to specifying border characters you can force the table to render a separator line on each row like:
 
 ```ruby
-table = TTY::Table.new ['header1', 'header2'], [['a1', 'a2'], ['b1', 'b2']]
+table = TTY::Table.new ["header1", "header2"], [["a1", "a2"], ["b1", "b2"]]
 table.render do |renderer|
   renderer.border.separator = :each_row
 end
@@ -545,7 +536,7 @@ end
 If you want more control you can provide an array of rows *after* which a separator will be added:
 
 ```ruby
-table = TTY::Table.new ['header1', 'header2'], [['a1', 'a2'], ['b1', 'b2'], ['c1', 'c2']]
+table = TTY::Table.new ["header1", "header2"], [["a1", "a2"], ["b1", "b2"], ["c1", "c2"]]
 table.render do |renderer|
   renderer.border.separator = [0, 2]
 end
@@ -566,8 +557,8 @@ will not be automatically added.
 You can also give the separator option a proc to control where the separators are:
 
 ```ruby
-table = TTY::Table.new ['header1', 'header2'],
-                       [['a1', 'a2'], ['b1', 'b2'], ['c1', 'c2'], ['d1', 'd2']]
+table = TTY::Table.new ["header1", "header2"],
+                       [["a1", "a2"], ["b1", "b2"], ["c1", "c2"], ["d1", "d2"]]
 table.render do |renderer|
   renderer.border.separator = ->(row) { row == 0 || (row+1) % 2 == 0} # separate every two rows
 end
@@ -586,9 +577,9 @@ end
 Finally you can also position a separator using the `:separator` key word in place of a row:
 
 ```ruby
-table = TTY::Table.new ['header1', 'header2'],
-                       [:separator, ['a1', 'a2'], ['b1', 'b2']]
-table << :separator << ['c1', 'c2']  # you can push separators on too!
+table = TTY::Table.new ["header1", "header2"],
+                       [:separator, ["a1", "a2"], ["b1", "b2"]]
+table << :separator << ["c1", "c2"]  # you can push separators on too!
 table.render
 # =>
 #  +-------+-------+
@@ -615,12 +606,14 @@ All [supported colors](https://github.com/piotrmurach/pastel#3-supported-colors)
 
 ### 3.6 Filter
 
-You can define filters that will modify individual table fields value before they are rendered. A filter can be a callable such as proc. Here's an example that formats
+You can define filters that will modify individual table field value before it is rendered. A filter can be a callable such as proc.
+
+Here's an example that formats capitalizes each field in second column skipping the header:
 
 ```ruby
-table = TTY::Table.new ['header1', 'header2'], [['a1', 'a2'], ['b1', 'b2']]
+table = TTY::Table.new(["header1", "header2"], [["a1", "a2"], ["b1", "b2"]])
 table.render do |renderer|
-  renderer.filter = Proc.new do |val, row_index, col_index|
+  renderer.filter = ->(val, row_index, col_index) do
     if col_index == 1 and !(row_index == 0)
       val.capitalize
     else
@@ -638,13 +631,13 @@ end
 #  +-------+-------+
 ```
 
-To color even fields red on green background add filter like so
+To color even fields red on green background add filter like so:
 
 ```ruby
 pastel = Pastel.new
 
 table.render do |renderer|
-  renderer.filter = proc do |val, row_index, col_index|
+  renderer.filter = ->(val, row_index, col_index) do
     col_index % 2 == 1 ? pastel.red.on_green(val) : val
   end
 end
@@ -652,11 +645,11 @@ end
 
 ### 3.7 Multiline
 
-Renderer options may include `multiline` parameter. When set to `true`, table fields will wrap at their natural line breaks or the column widths(if provided).
+Renderer options may include `:multiline` parameter. When set to `true`, table fields will wrap at their natural line breaks or the column widths(if provided).
 
 ```ruby
-table = TTY::Table.new [ ["First", '1'], ["Multi\nLine\nContent", '2'], ["Third", '3']]
-table.render :ascii, multiline: true
+table = TTY::Table.new([["First", "1"], ["Multi\nLine\nContent", "2"], ["Third", "3"]])
+table.render(:ascii, multiline: true)
 # =>
 #  +-------+-+
 #  |First  |1|
@@ -670,7 +663,7 @@ table.render :ascii, multiline: true
 When `multiline` is set to `false`, all line break characters will be escaped. In cases when the column widths are set, the content will be truncated.
 
 ```ruby
-table = TTY::Table.new [["First", '1'], ["Multiline\nContent", '2'], ["Third", '3']]
+table = TTY::Table.new [["First", "1"], ["Multiline\nContent", "2"], ["Third", "3"]]
 table.render :ascii, multiline: false
 # =>
 #  +------------------+-+
@@ -712,15 +705,15 @@ table.render(:ascii, padding: [1,2,1,2])
 However, when adding top or bottom padding to content with line breaks, the `multiline` option needs to be set to `true` to allow for rows to span multiple lines. For example:
 
 ```ruby
-table = TTY::Table.new header: ['head1', 'head2']
+table = TTY::Table.new(header: ["head1", "head2"])
 table << ["Multi\nLine", "Text\nthat\nwraps"]
-table << ["Some\nother\ntext", 'Simple']
+table << ["Some\nother\ntext", "Simple"]
 ```
 
-would render as:
+This would render as:
 
 ```ruby
-table.render :ascii, multiline: true, padding: [1,2,1,2]
+table.render(:ascii, multiline: true, padding: [1,2,1,2])
 # =>
 #  +---------+----------+
 #  |         |          |
@@ -742,17 +735,30 @@ table.render :ascii, multiline: true, padding: [1,2,1,2]
 
 ### 3.9 Resize
 
+You can force table to resize to the terminal full width using the `:resize` option:
+
+```ruby
+table.render(:ascii, resize: true)
+```
+
 ### 3.10 Width
 
 To control table's column sizes pass `width`, `resize` options. By default table's natural column widths are calculated from the content. If the total table width does not fit in terminal window then the table is rotated vertically to preserve content.
 
 The `resize` property will force the table to expand/shrink to match the terminal width or custom `width`. On its own the `width` property will not resize table but only enforce table vertical rotation if content overspills.
 
+For example, given the following table:
+
+```ruby
+header = ["h1", "h2", "h3"]
+rows   = [["aaa1", "aa2", "aaaaaaa3"], ["b1", "b2", "b3"]]
+table = TTY::Table.new(header, rows)
+```
+
+The result of rending to `80` columns width will produce:
+
 ```ruby
-header = ['h1', 'h2', 'h3']
-rows   = [['aaa1', 'aa2', 'aaaaaaa3'], ['b1', 'b2', 'b3']]
-table = TTY::Table.new header, rows
-table.render width: 80, resize: true
+table.render(width: 80, resize: true)
 # =>
 #  +---------+-------+------------+
 #  |h1       |h2     |h3          |