tabularize 0.2.7 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b74dc849febd7f37efc2f8123dff4bdc6c484df88235e0d36f886ad879173703
+  data.tar.gz: 81e92767c11e10162510374afca7b09d6305b8cce1d6e67bd86b535138b4b4a1
+SHA512:
+  metadata.gz: fd686051d7803dbae825bd1172fd1e8e67ba3bc19f0d162ce1b7cff550c981f58fb072aa24fe2595a62c409e72a0db272407385249cf8b0ac7ad56d0fff50fab
+  data.tar.gz: 58c62bb1919eade8506fad4e666edfdf7cb09e81b7870577edc3b0f790091f3db00b8779b2b04881603cf0a1e61b7c197e77155d7ec9a1a7e96f0cb1a5a49e77

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+0.2.9
+-----
+- Bug fix: exception on empty column
+
+0.2.8
+-----
+- 1.8 compatibility
+
 0.2.7
 -----
 - Customizable border

data/Gemfile.lock

@@ -1,21 +1,23 @@
 PATH
   remote: .
   specs:
-    tabularize (0.2.7)
-      unicode-display_width (~> 0.1.1)
+    tabularize (0.3.0)
+      unicode-display_width (>= 2.0.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    ansi (1.4.3)
-    awesome_print (1.0.2)
-    unicode-display_width (0.1.1)
+    minitest (5.14.4)
+    rake (13.0.6)
+    unicode-display_width (2.0.0)
 
 PLATFORMS
-  java
-  ruby
+  x86_64-darwin-20
 
 DEPENDENCIES
-  ansi
-  awesome_print
+  minitest
+  rake
   tabularize!
+
+BUNDLED WITH
+   2.2.25

data/README.md

@@ -54,7 +54,7 @@ puts table
 * Alignment
  * `:align` Horizontal alignment. `:left`, `:center`, `:right`, or Array of the three options
  * `:valign` Vertical alignment. `:top`, `:middle`, `:bottom`, or Array of the three options
-* Ellipses: Cut off trailing cells if the total width exceeds the specified screen width
+* Ellipsis: Cut off trailing cells if the total width exceeds the specified screen width
  * `:screen_width` The number of columns for the current terminal. Default: unlimited.
  * `:ellipsis` Ellipsis string when cells are cut off. Default: `>`
 
@@ -64,10 +64,9 @@ require 'ansi'
 table = Tabularize.new :pad     => '.', :pad_left => 2,  :pad_right => 0,
                        :border_style => :unicode,
                        :border_color => ANSI::Code.red,
-                       :hborder => '~', :vborder => 'I', :iborder => '#',
                        :align   => [:left, :center, :right],
                        :valign  => [:top, :bottom, :middle, :middle],
-                       :screen_width => 75, :ellipsis => 'X'
+                       :screen_width => 75, :ellipsis => '~'
 table << %w[Name Dept Location Phone Description]
 table.separator!
 table << ['John Doe', 'Finance', 'Los Angeles CA 90089', '555-1555', 'Just a guy']

data/lib/tabularize.rb

@@ -1,8 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
-require "tabularize/version"
+# rubocop:disable Style/HashSyntax
+
+require 'tabularize/version'
 require 'stringio'
 require 'unicode/display_width'
+require 'English'
 
 class Tabularize
   DEFAULT_OPTIONS = {
@@ -19,34 +23,34 @@ class Tabularize
     :ansi         => true,
 
     :ellipsis     => '>',
-    :screen_width => nil,
-  }
+    :screen_width => nil
+  }.freeze
 
   DEFAULT_OPTIONS_GENERATOR = {
     :pad_left  => 1,
-    :pad_right => 1,
-  }
+    :pad_right => 1
+  }.freeze
 
   BORDER_STYLE = {
     :ascii => {
       :hborder      => '-',
       :vborder      => '|',
-      :iborder      => %w[+ + + + + + + + +],
+      :iborder      => %w[+ + + + + + + + +]
     },
     :unicode => {
       :hborder      => '─',
       :vborder      => '│',
-      :iborder      => %w[┌ ┬ ┐ ├ ┼ ┤ └ ┴ ┘],
+      :iborder      => %w[┌ ┬ ┐ ├ ┼ ┤ └ ┴ ┘]
     }
-  }
+  }.freeze
 
   # @since 0.2.0
-  def initialize options = {}
+  def initialize(options = {})
     @rows    = []
     @seps    = Hash.new { |h, k| h[k] = 0 }
-    @options = DEFAULT_OPTIONS.
-               merge(DEFAULT_OPTIONS_GENERATOR).
-               merge(options)
+    @options = DEFAULT_OPTIONS
+               .merge(DEFAULT_OPTIONS_GENERATOR)
+               .merge(options)
     if @options[:border_style]
       @options = BORDER_STYLE[@options[:border_style]].merge(@options)
 
@@ -55,7 +59,7 @@ class Tabularize
         @options[:iborder] = [@options[:iborder]] * 9
       end
     end
-    @cache   = {}
+    @cache = {}
   end
 
   # @since 0.2.0
@@ -63,10 +67,10 @@ class Tabularize
     @seps[@rows.length] += 1
     nil
   end
-  
+
   # @param [Array] row
   # @since 0.2.0
-  def << row
+  def <<(row)
     @rows << row
     nil
   end
@@ -78,7 +82,9 @@ class Tabularize
 
     # Invalidate cache if needed
     num_cached_rows = @cache[:num_rows] || 0
-    analysis = Tabularize.analyze(@rows[num_cached_rows..-1], @options.merge(@cache[:analysis] || {}))
+    analysis = Tabularize.analyze(
+      @rows[num_cached_rows..-1], @options.merge(@cache[:analysis] || {})
+    )
 
     unless @cache.empty?
       cmw = @cache[:analysis][:max_widths]
@@ -97,7 +103,7 @@ class Tabularize
         end
       end
     end
-    
+
     rows = Tabularize.it(@rows[num_cached_rows..-1], @options.merge(analysis))
 
     h  = @options[:hborder]
@@ -114,12 +120,14 @@ class Tabularize
 
     separators = @cache[:separators]
     col_count = @cache[:col_count]
-    separators ||= 
-      Array.new(3) {''}.zip(i9.each_slice(3).to_a).map { |separator, i3|
+    separators ||=
+      Array.new(3) { '' }.zip(i9.each_slice(3).to_a).map do |separator, i3|
         rows[0].each_with_index do |ch, idx|
-          new_sep = separator + i3[idx == 0 ? 0 : 1] + h * Tabularize.cell_width(ch, u, a)
+          new_sep = separator +
+                    i3[idx.zero? ? 0 : 1] +
+                    h * Tabularize.cell_width(ch, u, a)
 
-          if sw && Tabularize.cell_width(new_sep, u, a) > sw - el
+          if sw && Tabularize.cell_width(new_sep, true, true) > sw - el
             col_count = idx
             break
           else
@@ -132,12 +140,12 @@ class Tabularize
         else
           separator
         end
-      }
+      end
 
-    output = @cache[:string_io] || StringIO.new.tap { |io| 
+    output = @cache[:string_io] || StringIO.new.tap do |io|
       io.set_encoding 'UTF-8' if io.respond_to? :set_encoding
       io.puts separators.first
-    }
+    end
     if col_count
       rows = rows.map { |line| line[0, col_count] }
       vl = e
@@ -169,24 +177,26 @@ class Tabularize
       :last_seps  => @seps[rows.length]
     }
     output.string + separators.last
-  rescue Exception
+  rescue StandardError
     @cache = {}
     raise
   end
 
   # Returns the display width of a String
   # @param [String] str Input String
-  # @param [Boolean] unicode Set to true when the given String can include CJK wide characters
-  # @param [Boolean] ansi Set to true When the given String can include ANSI codes
-  # @return [Fixnum] Display width of the given String
+  # @param [Boolean] unicode Set to true when the given String can include CJK
+  #   wide characters
+  # @param [Boolean] ansi Set to true When the given String can include ANSI
+  #   codes
+  # @return [Integer] Display width of the given String
   # @since 0.2.0
-  def self.cell_width str, unicode, ansi
+  def self.cell_width(str, unicode, ansi)
     str = str.gsub(/\e\[\d*(?:;\d+)*m/, '') if ansi
-    str.send(unicode ? :display_width : :length)
+    unicode ? Unicode::DisplayWidth.of(str) : str.length
   end
 
   # Determines maximum widths of cells and maximum heights of rows
-  def self.analyze data, options = {}
+  def self.analyze(data, options = {})
     unicode     = options[:unicode]
     ansi        = options[:ansi]
     max_widths  = (options[:max_widths] || []).dup
@@ -198,11 +208,13 @@ class Tabularize
 
       row.each_with_index do |cell, idx|
         nlines = 0
-        cell.lines do |c|
-          max_widths[idx] = [ Tabularize.cell_width(c.chomp, unicode, ansi), max_widths[idx] || 0 ].max
+        (cell.empty? ? [''] : cell.lines).each do |c|
+          max_widths[idx] =
+            [Tabularize.cell_width(c.chomp, unicode, ansi),
+             max_widths[idx] || 0].max
           nlines += 1
         end
-        max_heights[ridx] = [ nlines, max_heights[ridx] || 1 ].max
+        max_heights[ridx] = [nlines, max_heights[ridx] || 1].max
       end
     end
 
@@ -216,18 +228,18 @@ class Tabularize
     {
       :rows        => rows,
       :max_widths  => max_widths,
-      :max_heights => max_heights,
+      :max_heights => max_heights
     }
   end
 
   # Formats two-dimensional tabular data.
-  # One-dimensional data (e.g. Array of Strings) is treated as tabular data 
+  # One-dimensional data (e.g. Array of Strings) is treated as tabular data
   # of which each row has only one column.
   # @param [Enumerable] table_data
   # @param [Hash] options Formatting options.
   # @return [Array] Two-dimensional Array of formatted cells.
-  def self.it table_data, options = {}
-    raise ArgumentError.new("Not enumerable") unless 
+  def self.it(table_data, options = {})
+    raise ArgumentError, 'Not enumerable' unless
         table_data.respond_to?(:each)
 
     options = DEFAULT_OPTIONS.merge(options)
@@ -240,36 +252,34 @@ class Tabularize
     ansi    = options[:ansi]
     screenw = options[:screen_width]
 
-    unless pad.length == 1
-      raise ArgumentError.new("Invalid padding") 
-    end
-    unless padl.is_a?(Fixnum) && padl >= 0
-      raise ArgumentError.new(":pad_left must be a non-negative integer")
+    raise ArgumentError, 'Invalid padding' unless pad.length == 1
+    unless padl.is_a?(Integer) && padl >= 0
+      raise ArgumentError, ':pad_left must be a non-negative integer'
     end
-    unless padr.is_a?(Fixnum) && padr >= 0
-      raise ArgumentError.new(":pad_right must be a non-negative integer")
+    unless padr.is_a?(Integer) && padr >= 0
+      raise ArgumentError, ':pad_right must be a non-negative integer'
     end
-    unless align.all? { |a| [:left, :right, :center].include?(a) }
-      raise ArgumentError.new("Invalid alignment")
+    unless align.all? { |a| %i[left right center].include?(a) }
+      raise ArgumentError, 'Invalid alignment'
     end
-    unless valign.all? { |a| [:top, :bottom, :middle].include?(a) }
-      raise ArgumentError.new("Invalid vertical alignment")
+    unless valign.all? { |a| %i[top bottom middle].include?(a) }
+      raise ArgumentError, 'Invalid vertical alignment'
     end
-    unless screenw.nil? || (screenw.is_a?(Fixnum) && screenw > 0)
-      raise ArgumentError.new(":screen_width must be a positive integer")
+    unless screenw.nil? || (screenw.is_a?(Integer) && screenw > 0)
+      raise ArgumentError, ':screen_width must be a positive integer'
     end
 
     # Analyze data
     ret = options[:analysis] || Tabularize.analyze(table_data, options)
     rows, max_widths, max_heights =
-      [:rows, :max_widths, :max_heights].map { |k| ret[k] }
+      %i[rows max_widths max_heights].map { |k| ret[k] }
 
     ridx = -1
-    rows.map { |row| 
+    rows.map do |row|
       ridx += 1
       idx = -1
       max_height = max_heights[ridx]
-      row.map { |cell|
+      row.map do |cell|
         idx += 1
         lines = cell.to_s.lines.to_a
         offset =
@@ -282,10 +292,10 @@ class Tabularize
             (max_height - lines.length) / 2
           end
 
-        (0...max_height).map { |ln|
+        (0...max_height).map do |ln|
           ln -= offset
-          str = (ln >= 0 && lines[ln]) ? lines[ln].chomp : (pad * max_widths[idx])
-          alen = 
+          str = ln >= 0 && lines[ln] ? lines[ln].chomp : (pad * max_widths[idx])
+          alen =
             if ansi
               Tabularize.cell_width(str, false, false) -
                 Tabularize.cell_width(str, false, true)
@@ -295,8 +305,8 @@ class Tabularize
           slen = str.length - alen
 
           w = max_widths[idx]
-          w += str.length - str.display_width if unicode
-          pad * padl + 
+          w += str.length - Unicode::DisplayWidth.of(str) if unicode
+          pad * padl +
             case align[idx] || align.last
             when :left
               str.ljust(w + alen, pad)
@@ -305,9 +315,9 @@ class Tabularize
             when :center
               str.rjust((w - slen) / 2 + slen + alen, pad).ljust(w + alen, pad)
             end +
-              pad * padr
-        }.join($/)
-      }
-    }
+            pad * padr
+        end.join($RS)
+      end
+    end
   end
 end

data/lib/tabularize/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Tabularize
-  VERSION = "0.2.7"
+  VERSION = '0.3.0'
 end

data/tabularize.gemspec

@@ -1,25 +1,25 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "tabularize/version"
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'tabularize/version'
 
 Gem::Specification.new do |s|
-  s.name        = "tabularize"
+  s.name        = 'tabularize'
   s.version     = Tabularize::VERSION
-  s.authors     = ["Junegunn Choi"]
-  s.email       = ["junegunn.c@gmail.com"]
-  s.homepage    = ""
-  s.summary     = %q{Formatting tabular data}
-  s.description = %q{Formatting tabular data with paddings and alignments}
+  s.authors     = ['Junegunn Choi']
+  s.email       = ['junegunn.c@gmail.com']
+  s.homepage    = 'https://github.com/junegunn/tabularize'
+  s.summary     = 'Formatting tabular data'
+  s.description = 'Formatting tabular data with paddings and alignments'
 
-  s.rubyforge_project = "tabularize"
+  s.rubyforge_project = 'tabularize'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 
   # specify any dependencies here; for example:
-  s.add_development_dependency 'awesome_print'
-  s.add_development_dependency 'ansi'
-  s.add_runtime_dependency 'unicode-display_width', '~> 0.1.1'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rake'
+  s.add_runtime_dependency 'unicode-display_width', '>= 2.0.0'
 end

data/test/test_tabularize.rb

@@ -1,102 +1,96 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 require 'rubygems'
-require 'bundler'
-Bundler.setup(:default, :development)
-require 'test/unit'
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bundler/setup'
+require 'minitest/autorun'
 require 'tabularize'
-require 'awesome_print'
 require 'csv'
-require 'ansi'
+require 'English'
 
-class TestTabularize < Test::Unit::TestCase
-  DATA0 = %w[a aa aaa aaaa aaaaa]
-  DATA1 = 
+class TestTabularize < Minitest::Test
+  DATA0 = %w[a aa aaa aaaa aaaaa].freeze
+  DATA1 =
     [
       %w[a aa aaa aaaa],
       %w[bbbb bbb bb b]
-    ]
-  DATA2 = 
+    ].freeze
+  DATA2 =
     [
       %w[a aa aaa aaaa],
       %w[cccccccccccccccccccc],
       %w[ddd dddd d],
       %w[bbbb bbb bb b]
-    ]
+    ].freeze
   RESULT = {
     DATA0 => {
-      :left => [
-        "a    ",
-        "aa   ",
-        "aaa  ",
-        "aaaa ",
-        "aaaaa",
-      ],
-      :right => [
-        "    a",
-        "   aa",
-        "  aaa",
-        " aaaa",
-        "aaaaa",
+      left: [
+        'a    ',
+        'aa   ',
+        'aaa  ',
+        'aaaa ',
+        'aaaaa'
       ],
-      :center => [
-        "  a  ",
-        " aa  ",
-        " aaa ",
-        "aaaa ",
-        "aaaaa",
+      right: [
+        '    a',
+        '   aa',
+        '  aaa',
+        ' aaaa',
+        'aaaaa'
       ],
+      center: [
+        '  a  ',
+        ' aa  ',
+        ' aaa ',
+        'aaaa ',
+        'aaaaa'
+      ]
     },
     DATA1 => {
-      :left => 
-        [
-          "a   |aa |aaa|aaaa",
-          "bbbb|bbb|bb |b   "
-        ],
-      :right => 
-        [
-          "   a| aa|aaa|aaaa",
-          "bbbb|bbb| bb|   b"
-        ],
-      :center => 
-        [
-          " a  |aa |aaa|aaaa",
-          "bbbb|bbb|bb | b  "
-        ]
+      left:         [
+        'a   |aa |aaa|aaaa',
+        'bbbb|bbb|bb |b   '
+      ],
+      right:         [
+        '   a| aa|aaa|aaaa',
+        'bbbb|bbb| bb|   b'
+      ],
+      center:         [
+        ' a  |aa |aaa|aaaa',
+        'bbbb|bbb|bb | b  '
+      ]
     },
     DATA2 => {
-      :left =>
-        [
-          "a                   |aa  |aaa|aaaa",
-          "cccccccccccccccccccc|    |   |    ",
-          "ddd                 |dddd|d  |    ",
-          "bbbb                |bbb |bb |b   "
-        ],
-      :right =>
-        [
-          "                   a|  aa|aaa|aaaa",
-          "cccccccccccccccccccc|    |   |    ",
-          "                 ddd|dddd|  d|    ",
-          "                bbbb| bbb| bb|   b"
-        ],
-      :center =>
-        [
-          "         a          | aa |aaa|aaaa",
-          "cccccccccccccccccccc|    |   |    ",
-          "        ddd         |dddd| d |    ",
-          "        bbbb        |bbb |bb | b  "
-        ]
+      left:         [
+        'a                   |aa  |aaa|aaaa',
+        'cccccccccccccccccccc|    |   |    ',
+        'ddd                 |dddd|d  |    ',
+        'bbbb                |bbb |bb |b   '
+      ],
+      right:         [
+        '                   a|  aa|aaa|aaaa',
+        'cccccccccccccccccccc|    |   |    ',
+        '                 ddd|dddd|  d|    ',
+        '                bbbb| bbb| bb|   b'
+      ],
+      center:         [
+        '         a          | aa |aaa|aaaa',
+        'cccccccccccccccccccc|    |   |    ',
+        '        ddd         |dddd| d |    ',
+        '        bbbb        |bbb |bb | b  '
+      ]
     }
-  }
+  }.freeze
 
   def test_tabularize
-    data_lines = DATA0.join($/).lines
-    RESULT[data_lines] = RESULT[DATA0]
+    data_lines = DATA0.join($RS).lines
+    output = RESULT.dup
+    output[data_lines] = output[DATA0]
     [DATA0, data_lines, DATA1, DATA2].each do |data|
-      [ '.', '_' ].each do |pad|
-        [:left, :right, :center].each do |align|
-          result = Tabularize.it(data, :pad => pad, :align => align)
-          assert_equal RESULT[data][align], result.map { |row| row.join('|').gsub(pad, ' ') }
+      ['.', '_'].each do |pad|
+        %i[left right center].each do |align|
+          result = Tabularize.it(data, pad: pad, align: align)
+          assert_equal output[data][align], result.map { |row| row.join('|').gsub(pad, ' ') }
         end
       end
     end
@@ -109,7 +103,7 @@ class TestTabularize < Test::Unit::TestCase
     data << %w[aaa bb cc]
     data << %w[aaa bb cc] + ["dddd\neee"]
     data << %w[f]
-    ret = Tabularize.analyze(data, :unicode => true, :ansi => true)
+    ret = Tabularize.analyze(data, unicode: true, ansi: true)
     assert_equal [%w[a bb ccc].push(''), %w[aa bb cc].push(''), %w[aaa bb cc].push(''),
                   %w[aaa bb cc] + ["dddd\neee"], %w[f] + [''] * 3], ret[:rows]
     assert_equal [1, 1, 1, 2, 1], ret[:max_heights]
@@ -118,7 +112,7 @@ class TestTabularize < Test::Unit::TestCase
 
   # TODO: Need assertion
   def test_tabularize_csv
-    return if RUBY_VERSION =~ /^1\.8\./
+    return if RUBY_VERSION.match?(/^1\.8\./)
 
     sio = StringIO.new
 
@@ -128,37 +122,37 @@ class TestTabularize < Test::Unit::TestCase
       'fixture/test_unicode_ansi.csv' => [true, true]
     }.each do |file, unicode_ansi|
       unicode, ansi = unicode_ansi
-      opts = { :unicode => unicode, :ansi => ansi }
-      data = CSV.read(File.join(File.dirname(__FILE__), file), :col_sep => '|')
+      opts = { unicode: unicode, ansi: ansi }
+      data = CSV.read(File.join(File.dirname(__FILE__), file), col_sep: '|')
       output = Tabularize.it(data, opts).map { |row| row.join '|' }
 
       sio.puts output
-      sio.puts Tabularize.it(data, opts.merge(:align => :right)).map { |row| row.join '|' }
-      sio.puts Tabularize.it(data, opts.merge(:align => :center)).map { |row| row.join '|' }
-      sio.puts Tabularize.it(data, opts.merge(:pad => '_')).map { |row| row.join '|' }
+      sio.puts Tabularize.it(data, opts.merge(align: :right)).map { |row| row.join '|' }
+      sio.puts Tabularize.it(data, opts.merge(align: :center)).map { |row| row.join '|' }
+      sio.puts Tabularize.it(data, opts.merge(pad: '_')).map { |row| row.join '|' }
     end
 
     assert_equal File.read(File.join(File.dirname(__FILE__), 'fixture/tabularize_csv.txt')), sio.string
   end
 
   def test_invalid_arguments
-    assert_raise(ArgumentError) { Tabularize.it(5) }
-    assert_raise(ArgumentError) { Tabularize.it("hello") } unless RUBY_VERSION =~ /^1\.8\./
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :align => :noidea) }
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :valign => :noidea) }
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :align => [:center, :top]) }
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :valign => [:left, :right]) }
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :pad => 'long') }
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :pad => ' ', :pad_left => -1) }
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :pad => ' ', :pad_left => '') }
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :pad => ' ', :pad_right => -1) }
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :pad => ' ', :pad_right => '') }
-    assert_raise(ArgumentError) { Tabularize.it([1, 2, 3], :screen_width => -2) }
+    assert_raises(ArgumentError) { Tabularize.it(5) }
+    assert_raises(ArgumentError) { Tabularize.it('hello') } unless RUBY_VERSION.match?(/^1\.8\./)
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], align: :noidea) }
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], valign: :noidea) }
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], align: %i[center top]) }
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], valign: %i[left right]) }
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], pad: 'long') }
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], pad: ' ', pad_left: -1) }
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], pad: ' ', pad_left: '') }
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], pad: ' ', pad_right: -1) }
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], pad: ' ', pad_right: '') }
+    assert_raises(ArgumentError) { Tabularize.it([1, 2, 3], screen_width: -2) }
   end
 
   def test_table
-    table = Tabularize.new :align => :center, :pad => ',',
-      :pad_left => 3, :pad_right => 5, :hborder => '=', :vborder => 'I', :iborder => '#'
+    table = Tabularize.new align: :center, pad: ',',
+                           pad_left: 3, pad_right: 5, hborder: '=', vborder: 'I', iborder: '#'
     table << DATA2[0]
     table.separator!
     table << DATA2[0]
@@ -169,43 +163,47 @@ class TestTabularize < Test::Unit::TestCase
     table << DATA2[2]
     table << DATA2[3]
 
-    assert_equal(
-'#============================#============#===========#============#
-I,,,,,,,,,,,,a,,,,,,,,,,,,,,,I,,,,aa,,,,,,I,,,aaa,,,,,I,,,aaaa,,,,,I
-#============================#============#===========#============#
-I,,,,,,,,,,,,a,,,,,,,,,,,,,,,I,,,,aa,,,,,,I,,,aaa,,,,,I,,,aaaa,,,,,I
-#============================#============#===========#============#
-#============================#============#===========#============#
-I,,,cccccccccccccccccccc,,,,,I,,,,,,,,,,,,I,,,,,,,,,,,I,,,,,,,,,,,,I
-#============================#============#===========#============#
-I,,,,,,,,,,,ddd,,,,,,,,,,,,,,I,,,dddd,,,,,I,,,,d,,,,,,I,,,,,,,,,,,,I
-I,,,,,,,,,,,bbbb,,,,,,,,,,,,,I,,,bbb,,,,,,I,,,bb,,,,,,I,,,,b,,,,,,,I
-#============================#============#===========#============#', table.to_s)
+    expected = <<~EOF
+      #============================#============#===========#============#
+      I,,,,,,,,,,,,a,,,,,,,,,,,,,,,I,,,,aa,,,,,,I,,,aaa,,,,,I,,,aaaa,,,,,I
+      #============================#============#===========#============#
+      I,,,,,,,,,,,,a,,,,,,,,,,,,,,,I,,,,aa,,,,,,I,,,aaa,,,,,I,,,aaaa,,,,,I
+      #============================#============#===========#============#
+      #============================#============#===========#============#
+      I,,,cccccccccccccccccccc,,,,,I,,,,,,,,,,,,I,,,,,,,,,,,I,,,,,,,,,,,,I
+      #============================#============#===========#============#
+      I,,,,,,,,,,,ddd,,,,,,,,,,,,,,I,,,dddd,,,,,I,,,,d,,,,,,I,,,,,,,,,,,,I
+      I,,,,,,,,,,,bbbb,,,,,,,,,,,,,I,,,bbb,,,,,,I,,,bb,,,,,,I,,,,b,,,,,,,I
+      #============================#============#===========#============#
+    EOF
+    assert_equal expected.chomp, table.to_s
   end
 
   def test_table_complex
-    separator = '#~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#'
-    output = "
-#~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-I..Name.......I.....Dept....I.....................LocationI.....PhoneI
-#~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-I..John Doe...I....Finance..I.........Los Angeles CA 90089I..555-1555I
-I..Average JoeI..EngineeringI...Somewhere over the rainbowI.......N/AI
-I..1..........I.............I.............................I..........I
-#~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-#~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-I..홍길동.....I.............I..서울역 3번 출구 김씨 옆자리I..........I
-I.............I.............I.............................I.......N/AI
-I.............I...탁상 3부..I.....................맞습니다I..........I
-#~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-#~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-#~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-    ".strip
+    separator =
+      '#~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#'
+    output = <<~EOF
+      #~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      I..Name.......I.....Dept....I.....................LocationI.....PhoneI
+      #~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      I..John Doe...I....Finance..I.........Los Angeles CA 90089I..555-1555I
+      I..Average JoeI..EngineeringI...Somewhere over the rainbowI.......N/AI
+      I..1..........I.............I.............................I..........I
+      #~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      #~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      I..홍길동.....I.............I..서울역 3번 출구 김씨 옆자리I..........I
+      I.............I.............I.............................I.......N/AI
+      I.............I...탁상 3부..I.....................맞습니다I..........I
+      #~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      #~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      #~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+    EOF
+    output = output.strip
 
-    table = Tabularize.new :pad     => '.', :pad_left => 2,  :pad_right => 0,
-                           :hborder => '~', :vborder => 'I', :iborder => '#',
-                           :align   => [:left, :center, :right],
-                           :valign  => [:top, :bottom, :middle, :middle]
+    table = Tabularize.new pad: '.', pad_left: 2, pad_right: 0,
+                           hborder: '~', vborder: 'I', iborder: '#',
+                           align: %i[left center right],
+                           valign: %i[top bottom middle middle]
     table << %w[Name Dept Location Phone]
     table.separator!
     table << ['John Doe', 'Finance', 'Los Angeles CA 90089', '555-1555']
@@ -222,27 +220,29 @@ I.............I...탁상 3부..I.....................맞습니다I..........I
     end
     table.separator!
     table.separator!
-    assert_equal [output, separator, separator].join($/), table.to_s.strip
-    assert_equal [output, separator, separator].join($/), table.to_s.strip
-    table << "This should change everything doh!"
-    output = "
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-I..Name..............................I.....Dept....I.....................LocationI.....PhoneI
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-I..John Doe..........................I....Finance..I.........Los Angeles CA 90089I..555-1555I
-I..Average Joe.......................I..EngineeringI...Somewhere over the rainbowI.......N/AI
-I..1.................................I.............I.............................I..........I
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-I..홍길동............................I.............I..서울역 3번 출구 김씨 옆자리I..........I
-I....................................I.............I.............................I.......N/AI
-I....................................I...탁상 3부..I.....................맞습니다I..........I
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
-I..This should change everything doh!I.............I.............................I..........I
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#".strip
+    assert_equal [output, separator, separator].join($RS), table.to_s.strip
+    assert_equal [output, separator, separator].join($RS), table.to_s.strip
+    table << 'This should change everything doh!'
+    output = <<~EOF
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      I..Name..............................I.....Dept....I.....................LocationI.....PhoneI
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      I..John Doe..........................I....Finance..I.........Los Angeles CA 90089I..555-1555I
+      I..Average Joe.......................I..EngineeringI...Somewhere over the rainbowI.......N/AI
+      I..1.................................I.............I.............................I..........I
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      I..홍길동............................I.............I..서울역 3번 출구 김씨 옆자리I..........I
+      I....................................I.............I.............................I.......N/AI
+      I....................................I...탁상 3부..I.....................맞습니다I..........I
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+      I..This should change everything doh!I.............I.............................I..........I
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~~~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#~~~~~~~~~~#
+    EOF
+    output = output.strip
     assert_equal output, table.to_s.strip
     assert_equal output, table.to_s.strip
 
@@ -250,32 +250,31 @@ I..This should change everything doh!I.............I............................
     line = 'I..a.................................I.......b.....I............................cI.........dI'
     10.times do |i|
       table << %w[a b c d]
-      expected = (output.lines.to_a[0..-2].map(&:chomp) + [line] * (i+1) + [separator]).join($/)
+      expected = (output.lines.to_a[0..-2].map(&:chomp) + [line] * (i + 1) + [separator]).join($RS)
       assert_equal expected, table.to_s
     end
   end
 
   def test_screen_width
     [1, 3, 9, 50, 80].each do |w|
-      t = Tabularize.new :screen_width => w
+      t = Tabularize.new screen_width: w
       10.times do
         t << ['12345'] * 20
       end
-      assert t.to_s.lines.all? { |line| line.chomp.length <= w }
+      assert(t.to_s.lines.all? { |line| (w - 9..w).cover? line.chomp.length })
       t << %w[12345]
       puts t.to_s
-      assert t.to_s.lines.all? { |line| line.chomp.length <= w }
-      assert t.to_s.lines.all? { |line| line.chomp.reverse[0, 1] == '>' }
+      assert(t.to_s.lines.all? { |line| (w - 9..w).cover? line.chomp.length })
+      assert(t.to_s.lines.all? { |line| line.chomp.reverse[0, 1] == '>' })
     end
   end
 
   def test_readme
-    table = Tabularize.new
-    table = Tabularize.new :pad     => '.', :pad_left => 2,  :pad_right => 0,
-                           :border_style => :unicode,
-                           :align   => [:left, :center, :right],
-                           :valign  => [:top, :bottom, :middle, :middle],
-                           :screen_width => 75, :ellipsis => '~'
+    table = Tabularize.new pad: '.', pad_left: 2, pad_right: 0,
+                           border_style: :unicode,
+                           align: %i[left center right],
+                           valign: %i[top bottom middle middle],
+                           screen_width: 75, ellipsis: '~'
     table << %w[Name Dept Location Phone Description]
     table.separator!
     table << ['John Doe', 'Finance', 'Los Angeles CA 90089', '555-1555', 'Just a guy']
@@ -293,4 +292,29 @@ I..This should change everything doh!I.............I............................
 └─────────────┴─────────────┴─────────────────────────────┴──────────~
 ".strip, table.to_s
   end
+
+  def test_unicode_border_with_screen_width
+    table = Tabularize.new(
+      border_style: :unicode, unicode: false, screen_width: 200
+    )
+    table << %w[abcde] * 100
+    assert Unicode::DisplayWidth.of(table.to_s.lines.first) > 190
+  end
+
+  def test_it_nil_column
+    assert_equal [['1 ', '', '2 '], ['11', '', '22']],
+                 Tabularize.it([[1, nil, 2], [11, nil, 22]])
+  end
+
+  def test_analyze_nil_column
+    assert_equal [2, 0, 2],
+                 Tabularize.analyze([[1, nil, 2], [11, nil, 22]])[:max_widths]
+  end
+
+  def test_tabualarize_nil_column
+    table = Tabularize.new
+    table << [1, nil, 2]
+    table << [11, nil, 22]
+    table.to_s
+  end
 end

metadata

@@ -1,64 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: tabularize
 version: !ruby/object:Gem::Version
-  version: 0.2.7
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Junegunn Choi
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-08-01 00:00:00.000000000 Z
+date: 2021-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: awesome_print
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ansi
+  name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: unicode-display_width
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 2.0.0
 description: Formatting tabular data with paddings and alignments
 email:
 - junegunn.c@gmail.com
@@ -66,7 +59,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -82,29 +75,27 @@ files:
 - test/fixture/test_unicode_ansi.csv
 - test/readme.rb
 - test/test_tabularize.rb
-homepage: ''
+homepage: https://github.com/junegunn/tabularize
 licenses: []
-post_install_message: 
+metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: tabularize
-rubygems_version: 1.8.24
-signing_key: 
-specification_version: 3
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
 summary: Formatting tabular data
 test_files:
 - test/fixture/tabularize_csv.txt