columnize 0.3.6 → 0.8.9

data/lib/columnize/columnize.rb

@@ -0,0 +1,159 @@
+# Copyright (C) 2007-2011, 2013 Rocky Bernstein
+# <rockyb@rubyforge.net>
+#
+# Part of Columnize to format in either direction
+module Columnize
+  class Columnizer
+    ARRANGE_ARRAY_OPTS = {:array_prefix => '[', :line_prefix => ' ', :line_suffix => ',', :array_suffix => ']', :colsep => ', ', :arrange_vertical => false}
+    OLD_AND_NEW_KEYS = {:lineprefix => :line_prefix, :linesuffix => :line_suffix}
+    # TODO: change colfmt to cell_format; change colsep to something else
+    ATTRS = [:arrange_vertical, :array_prefix, :array_suffix, :line_prefix, :line_suffix, :colfmt, :colsep, :displaywidth, :ljust]
+
+    attr_reader :list, :opts
+
+    def initialize(list=[], opts={})
+      self.list = list
+      self.opts = DEFAULT_OPTS.merge(opts)
+    end
+
+    def list=(list)
+      @list = list
+      if @list.is_a? Array
+        @short_circuit = @list.empty? ? "<empty>\n" : nil
+      else
+        @short_circuit = ''
+        @list = []
+      end
+    end
+
+    # TODO: freeze @opts
+    def opts=(opts)
+      @opts = opts
+      OLD_AND_NEW_KEYS.each {|old, new| @opts[new] = @opts.delete(old) if @opts.keys.include?(old) and !@opts.keys.include?(new) }
+      @opts.merge!(ARRANGE_ARRAY_OPTS) if @opts[:arrange_array]
+      set_attrs_from_opts
+    end
+
+    def update_opts(opts)
+      self.opts = @opts.merge(opts)
+    end
+
+    def columnize
+      return @short_circuit if @short_circuit
+
+      rows, colwidths = min_rows_and_colwidths
+      ncols = colwidths.length
+      justify = lambda {|t, c|
+          @ljust ? t.ljust(colwidths[c]) : t.rjust(colwidths[c])
+      }
+      textify = lambda do |row|
+        row.map!.with_index(&justify) unless ncols == 1 && @ljust
+        "#{@line_prefix}#{row.join(@colsep)}#{@line_suffix}"
+      end
+
+      text = rows.map(&textify)
+      text.first.sub!(/^#{@line_prefix}/, @array_prefix) unless @array_prefix.empty?
+      text.last.sub!(/#{@line_suffix}$/, @array_suffix) unless @array_suffix.empty?
+      text.join("\n") # + "\n" # if we want extra separation
+    end
+
+    # TODO: make this a method, rather than a function (?)
+    # compute the smallest number of rows and the max widths for each column
+    def min_rows_and_colwidths
+      list = @list.map &@stringify
+      cell_widths = list.map(&@term_adjuster).map(&:size)
+
+      # Set default arrangement: one atom per row
+      cell_width_max = cell_widths.max
+      result = [arrange_by_row(list, list.size, 1), [cell_width_max]]
+
+      # If any atom > @displaywidth, stop and use one atom per row.
+      return result if cell_width_max > @displaywidth
+
+      # For horizontal arrangement, we want to *maximize* the number
+      # of columns. Thus the candidate number of rows (+sizes+) starts
+      # at the minumum number of rows, 1, and increases.
+
+      # For vertical arrangement, we want to *minimize* the number of
+      # rows. So here the candidate number of columns (+sizes+) starts
+      # at the maximum number of columns, list.length, and
+      # decreases. Also the roles of columns and rows are reversed
+      # from horizontal arrangement.
+
+      # Loop from most compact arrangement to least compact, stopping
+      # at the first successful packing.  The below code is tricky,
+      # but very cool.
+      #
+      # FIXME: In the below code could be DRY'd. (The duplication got
+      # introduced when I revised the code - rocky)
+      if @arrange_vertical
+        (1..list.length).each do |size|
+          other_size = (list.size + size - 1) / size
+          colwidths = arrange_by_row(cell_widths, other_size, size).map(&:max)
+          totwidth = colwidths.inject(&:+) + ((colwidths.length-1) * @colsep.length)
+          return [arrange_by_column(list, other_size, size), colwidths] if
+            totwidth <= @displaywidth
+        end
+      else
+        list.length.downto(1).each do |size|
+          other_size = (list.size + size - 1) / size
+          colwidths = arrange_by_column(cell_widths, other_size, size).map(&:max)
+          totwidth = colwidths.inject(&:+) + ((colwidths.length-1) * @colsep.length)
+          return [arrange_by_row(list, other_size, size), colwidths] if
+            totwidth <= @displaywidth
+        end
+      end
+      result
+    end
+
+    # Given +list+, +ncols+, +nrows+, arrange the one-dimensional
+    # array into a 2-dimensional lists of lists organized by rows.
+    #
+    # In either horizontal or vertical arrangement, we will need to
+    # access this for the list data or for the width
+    # information.
+    #
+    # Here is an example:
+    # arrange_by_row((1..5).to_a, 3, 2) =>
+    #    [[1,2], [3,4], [5]],
+    def arrange_by_row(list, nrows, ncols)
+      (0...nrows).map {|r| list[r*ncols, ncols] }.compact
+    end
+
+    # Given +list+, +ncols+, +nrows+, arrange the one-dimensional
+    # array into a 2-dimensional lists of lists organized by columns.
+    #
+    # In either horizontal or vertical arrangement, we will need to
+    # access this for the list data or for the width
+    # information.
+    #
+    # Here is an example:
+    # arrange_by_column((1..5).to_a, 2, 3) =>
+    #    [[1,3,5], [2,4]]
+    def arrange_by_column(list, nrows, ncols)
+      (0...ncols).map do |i|
+        (0..nrows-1).inject([]) do |row, j|
+          k = i + (j * ncols)
+          k < list.length ? row << list[k] : row
+        end
+      end
+    end
+
+    def set_attrs_from_opts
+      ATTRS.each {|attr| self.instance_variable_set "@#{attr}", @opts[attr] }
+
+      @ljust = !@list.all? {|datum| datum.kind_of?(Numeric)} if @ljust == :auto
+      @displaywidth -= @line_prefix.length
+      @displaywidth = @line_prefix.length + 4 if @displaywidth < 4
+      @stringify = @colfmt ? lambda {|li| @colfmt % li } : lambda {|li| li.to_s }
+      @term_adjuster = @opts[:term_adjust] ? lambda {|c| c.gsub(/\e\[.*?m/, '') } : lambda {|c| c }
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  Columnize::DEFAULT_OPTS = {:line_prefix => '', :displaywidth => 80}
+  puts Columnize::Columnizer.new.arrange_by_row((1..5).to_a, 2, 3).inspect
+  puts Columnize::Columnizer.new.arrange_by_column((1..5).to_a, 2, 3).inspect
+end

data/lib/columnize/opts.rb

@@ -0,0 +1,35 @@
+module Columnize
+  computed_displaywidth = (ENV['COLUMNS'] || '80').to_i
+  computed_displaywidth = 80 unless computed_displaywidth >= 10
+
+  # When an option is not specified for the below keys, these are the defaults.
+  DEFAULT_OPTS = {
+    :arrange_array     => false,
+    :arrange_vertical  => true,
+    :array_prefix      => '',
+    :array_suffix      => '',
+    :colfmt            => nil,
+    :colsep            => '  ',
+    :displaywidth      => computed_displaywidth,
+    :line_prefix        => '',
+    :line_suffix        => '',
+    :ljust             => :auto,
+    :term_adjust       => false
+  }
+
+  # Options parsing routine for Columnize::columnize. In the preferred
+  # newer style, +args+ is a hash where each key is one of the option names.
+  #
+  # In the older style positional arguments are used and the positions
+  # are in the order: +displaywidth+, +colsep+, +arrange_vertical+,
+  # +ljust+, and +line_prefix+.
+  def self.parse_columnize_options(args)
+    if 1 == args.size && args[0].kind_of?(Hash) # explicitly passed as a hash
+      args[0]
+    elsif !args.empty? # passed as ugly positional parameters.
+      Hash[args.zip([:displaywidth, :colsep, :arrange_vertical, :ljust, :line_prefix]).map(&:reverse)]
+    else
+      {}
+    end
+  end
+end

data/lib/columnize/version.rb

@@ -3,5 +3,5 @@
 # require'ing 'columnize'.
 module Columnize
   # The current version of this package
-  VERSION = '0.3.6'
+  VERSION = '0.8.9'
 end

data/test/test-columnize-array.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# Test of Columnize module
+class TestColumnizeArray < Test::Unit::TestCase
+  # Ruby 1.8 form of require_relative
+  TOP_SRC_DIR = File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+  ENV['COLUMNS'] = '80'
+  require File.join(TOP_SRC_DIR, 'columnize.rb')
+
+  # test columnize
+  def test_arrange_array
+    data = (1..80).to_a
+    expect = "[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,\n" +
+             " 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,\n" +
+             " 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,\n" +
+             " 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80]"
+    assert_equal(expect,
+                 data.columnize(:arrange_array => true, :displaywidth => 80),
+                 "columnize_opts -> arrange_array")
+  end
+
+  def test_displaywidth
+    expect = "1  5   9\n" +
+             "2  6  10\n" +
+             "3  7\n" +
+             "4  8"
+    data = (1..10).to_a
+    assert_equal(expect, data.columnize(:displaywidth => 10), "displaywidth")
+  end
+
+  def test_colfmt
+    expect = "[01, 02,\n" +
+             " 03, 04,\n" +
+             " 05, 06,\n" +
+             " 07, 08,\n" +
+             " 09, 10]"
+    data = (1..10).to_a
+    assert_equal(expect, data.columnize(:arrange_array => true, :colfmt => '%02d', :displaywidth => 10), "arrange_array, colfmt, displaywidth")
+  end
+
+  def test_backwards_compatiblity
+    foo = []
+    data = (1..11).to_a
+    expect = " 1   2  3\n 4   5  6\n 7   8  9\n10  11"
+    assert_equal expect, foo.columnize(data, :displaywidth => 10, :arrange_vertical => false)
+  end
+end

data/test/test-columnize.rb

@@ -3,42 +3,29 @@ require 'test/unit'
 
 # Test of Columnize module
 class TestColumnize < Test::Unit::TestCase
-  @@TOP_SRC_DIR = File.join(File.expand_path(File.dirname(__FILE__)), 
-                            '..', 'lib')
-  require File.join(@@TOP_SRC_DIR, 'columnize.rb')
-  include Columnize
-  
-  def test_cell_size
-    assert_equal(3, cell_size('abc', false))
-    assert_equal(3, cell_size('abc', true))
-    assert_equal(6, cell_size("\e[0;31mObject\e[0;4m", true))
-    assert_equal(19, cell_size("\e[0;31mObject\e[0;4m", false))
-  end
+  # Ruby 1.8 form of require_relative
+  TOP_SRC_DIR = File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+  require File.join(TOP_SRC_DIR, 'columnize.rb')
 
   # test columnize
   def test_basic
-    # Try at least one test where we give the module name explicitely.
-    assert_equal("1, 2, 3\n", 
-                 Columnize::columnize([1, 2, 3], 10, ', '))
-    assert_equal("", columnize(5))
-    assert_equal("1  3\n2  4\n", 
-                 columnize(['1', '2', '3', '4'], 4))
-    assert_equal("1  2\n3  4\n", 
-                 columnize(['1', '2', '3', '4'], 4, '  ', false))
-    assert_equal("<empty>\n", columnize([]))
-    
-    
-    assert_equal("oneitem\n", columnize(["oneitem"]))
-    
+    assert_equal("1, 2, 3", Columnize::columnize([1, 2, 3], 10, ', '))
+    assert_equal("", Columnize::columnize(5))
+    assert_equal("1  3\n2  4", Columnize::columnize(['1', '2', '3', '4'], 4))
+    assert_equal("1  2\n3  4", Columnize::columnize(['1', '2', '3', '4'], 4, '  ', false))
+    assert_equal("<empty>\n", Columnize::columnize([]))
+
+    assert_equal("oneitem", Columnize::columnize(["oneitem"]))
+
     data = (0..54).map{|i| i.to_s}
     assert_equal(
-            "0,  6, 12, 18, 24, 30, 36, 42, 48, 54\n" + 
+            "0,  6, 12, 18, 24, 30, 36, 42, 48, 54\n" +
             "1,  7, 13, 19, 25, 31, 37, 43, 49\n" +
             "2,  8, 14, 20, 26, 32, 38, 44, 50\n" +
             "3,  9, 15, 21, 27, 33, 39, 45, 51\n" +
             "4, 10, 16, 22, 28, 34, 40, 46, 52\n" +
-            "5, 11, 17, 23, 29, 35, 41, 47, 53\n",
-            columnize(data, 39, ', ', true, false))
+            "5, 11, 17, 23, 29, 35, 41, 47, 53",
+            Columnize::columnize(data, 39, ', ', true, false))
 
     assert_equal(
             " 0,  1,  2,  3,  4,  5,  6,  7,  8,  9\n" +
@@ -46,8 +33,8 @@ class TestColumnize < Test::Unit::TestCase
             "20, 21, 22, 23, 24, 25, 26, 27, 28, 29\n" +
             "30, 31, 32, 33, 34, 35, 36, 37, 38, 39\n" +
             "40, 41, 42, 43, 44, 45, 46, 47, 48, 49\n" +
-            "50, 51, 52, 53, 54\n",
-            columnize(data, 39, ', ', false, false))
+            "50, 51, 52, 53, 54",
+            Columnize::columnize(data, 39, ', ', false, false))
 
 
     assert_equal(
@@ -57,8 +44,8 @@ class TestColumnize < Test::Unit::TestCase
             "  27, 28, 29, 30, 31, 32, 33, 34, 35\n" +
             "  36, 37, 38, 39, 40, 41, 42, 43, 44\n" +
             "  45, 46, 47, 48, 49, 50, 51, 52, 53\n" +
-            "  54\n",
-            columnize(data, 39, ', ', false, false, '  '))
+            "  54",
+            Columnize::columnize(data, 39, ', ', false, false, '  '))
 
 
     data = ["one",       "two",         "three",
@@ -72,17 +59,16 @@ class TestColumnize < Test::Unit::TestCase
             "twentyfive","twentysix",   "twentyseven"]
 
      assert_equal(
-"one         two         three        for          five         six        \n" +
-"seven       eight       nine         ten          eleven       twelve     \n" +
-"thirteen    fourteen    fifteen      sixteen      seventeen    eightteen  \n" +
-"nineteen    twenty      twentyone    twentytwo    twentythree  twentyfour \n" +
-"twentyfive  twentysix   twentyseven\n", columnize(data, 80, '  ', false))
+"one         two        three        for        five         six       \n" +
+"seven       eight      nine         ten        eleven       twelve    \n" +
+"thirteen    fourteen   fifteen      sixteen    seventeen    eightteen \n" +
+"nineteen    twenty     twentyone    twentytwo  twentythree  twentyfour\n" +
+"twentyfive  twentysix  twentyseven", Columnize::columnize(data, 80, '  ', false))
 
     assert_equal(
 "one    five   nine    thirteen  seventeen  twentyone    twentyfive \n" +
 "two    six    ten     fourteen  eightteen  twentytwo    twentysix  \n" +
 "three  seven  eleven  fifteen   nineteen   twentythree  twentyseven\n" +
-"for    eight  twelve  sixteen   twenty     twentyfour \n", columnize(data))
-
+"for    eight  twelve  sixteen   twenty     twentyfour ", Columnize::columnize(data, 80))
   end
 end

data/test/test-columnizer.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# Test of Columnizer class
+class TestColumnizer < Test::Unit::TestCase
+  TOP_SRC_DIR = File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+  require File.join(TOP_SRC_DIR, 'columnize.rb')
+
+  Columnize::Columnizer.class_eval 'attr_reader :stringify, :short_circuit, :term_adjuster'
+  Columnize::Columnizer.class_eval 'attr_reader *ATTRS'
+
+  # SETTING OPTS IN INITIALIZE
+  def test_passed_in_opts
+    # passed in opts should be merged with DEFAULT_OPTS
+    c = Columnize::Columnizer.new([], :displaywidth => 15)
+    assert_equal false, c.opts[:term_adjust], 'term_adjust comes from DEFAULT_OPTS'
+    assert_equal 15, c.opts[:displaywidth], 'displaywidth should override DEFAULT_OPTS'
+  end
+
+  def test_ljust_attr
+    c = Columnize::Columnizer.new([1,2,3], {:ljust => :auto})
+    assert_equal false, c.ljust, 'ljust: :auto should transform to false when all values are numeric'
+    c = Columnize::Columnizer.new(['1', 2, 3], {:ljust => :auto})
+    assert_equal true, c.ljust, 'ljust: :auto should transform to true when not all values are numeric'
+    c = Columnize::Columnizer.new([], {:ljust => false})
+    assert_equal false, c.ljust, 'ljust: false should stay false'
+    c = Columnize::Columnizer.new([], {:ljust => true})
+    assert_equal true, c.ljust, 'ljust: true should stay true'
+  end
+
+  def test_stringify_attr
+    c = Columnize::Columnizer.new
+    assert_equal '1.0', c.stringify[1.0], 'without colfmt, should be to_s'
+    c.update_opts :colfmt => '%02d'
+    assert_equal '01', c.stringify[1.0], 'without colfmt, should be to_s'
+  end
+
+  def test_short_circuit_attr
+    c = Columnize::Columnizer.new
+    assert_equal "<empty>\n", c.short_circuit, 'should explicitly state when empty'
+    c.list = 1
+    assert_equal '', c.short_circuit, 'should be an empty string when not an array'
+    c.list = [1]
+    assert_equal nil, c.short_circuit, 'should be nil when list is good'
+  end
+
+  def test_term_adjuster_attr
+    c = Columnize::Columnizer.new
+    assert_equal 'abc', c.term_adjuster['abc']
+    assert_equal "\e[0;31mObject\e[0;4m", c.term_adjuster["\e[0;31mObject\e[0;4m"]
+    c.update_opts :term_adjust => true
+    assert_equal 'abc', c.term_adjuster['abc']
+    assert_equal 'Object', c.term_adjuster["\e[0;31mObject\e[0;4m"]
+  end
+
+  def test_displaywidth_attr
+    c = Columnize::Columnizer.new [], :displaywidth => 10, :line_prefix => '        '
+    assert_equal 12, c.displaywidth, 'displaywidth within 4 of line_prefix.length'
+    c.update_opts :line_prefix => '  '
+    assert_equal 8, c.displaywidth, 'displaywidth not within 4 of line_prefix.length'
+  end
+
+  # COLUMNIZE
+  def test_columnize_with_short_circuit
+    msg = 'Johnny 5 is alive!'
+    c = Columnize::Columnizer.new
+    c.instance_variable_set(:@short_circuit, msg)
+    assert_equal msg, c.columnize, 'columnize should return short_circuit message if set'
+  end
+
+  def test_columnize_applies_ljust
+    c = Columnize::Columnizer.new [1,2,3,10,20,30], :displaywidth => 10, :ljust => false, :arrange_vertical => false
+    assert_equal " 1   2   3\n10  20  30", c.columnize, "ljust: #{c.ljust}"
+    c.update_opts :ljust => true
+    assert_equal "1   2   3 \n10  20  30", c.columnize, "ljust: #{c.ljust}"
+  end
+
+  def no_test_columnize_applies_colsep_and_prefix_and_suffix
+    c = Columnize::Columnizer.new [1,2,3]
+    assert_equal "1  2  3", c.columnize
+    c.update_opts :line_prefix => '>', :colsep => '-', :line_suffix => '<'
+    assert_equal ">1-2-3<", c.columnize
+  end
+
+  def test_columnize_applies_array_prefix_and_suffix
+    c = Columnize::Columnizer.new [1,2,3]
+    assert_equal "1  2  3", c.columnize
+    c.update_opts :array_prefix => '>', :array_suffix => '<'
+    assert_equal ">1  2  3<", c.columnize
+  end
+
+  # NOTE: min_rows_and_colwidths tested in test-min_rows_and_colwidths.rb
+
+  # arrange_rows_and_cols
+  def test_arrange_rows_and_cols
+    rows = Columnize::Columnizer.new.arrange_by_row((1..9).to_a, 3, 3)
+    assert_equal [[1,2,3],[4,5,6],[7,8,9]], rows, 'rows for (1..9), 3, 3'
+
+    cols = Columnize::Columnizer.new.arrange_by_column((1..9).to_a, 3, 3)
+    assert_equal [[1,4,7],[2,5,8],[3,6,9]], cols, 'cols for (1..9), 3, 3'
+
+    rows = Columnize::Columnizer.new.arrange_by_row((1..5).to_a, 3, 2)
+    assert_equal [[1,2],[3,4],[5]], rows, 'rows for (1..5, 2, 3)'
+
+    cols = Columnize::Columnizer.new.arrange_by_column((1..5).to_a, 3, 2)
+    assert_equal [[1,3,5],[2,4]],   cols, 'cols for (1..5, 2, 3)'
+  end
+
+  def test_set_attrs_from_opts
+    assert(true, 'test set_attrs_from_opts')
+  end
+end