text_layout 0.1.1 → 0.2.0

data/Manifest.txt

@@ -6,3 +6,4 @@ Manifest.txt
 Rakefile
 README.rdoc
 test/test_text_layout.rb
+test/test_wrap.rb

data/README.rdoc

@@ -4,13 +4,14 @@
 
 == DESCRIPTION:
 
-Text layout engine for CUI apps.
+Text layout engine for CUI apps with a pretty table.
 
 == FEATURES/PROBLEMS:
 
 * Full-width character support.
 * Line wrapping.
 * Table layout with colspan and rowspan.
+* Table with border.
 
 == SYNOPSIS:
 
@@ -24,21 +25,27 @@ Text layout engine for CUI apps.
       [{:colspan => 2, :value => "37Wh(13\")"}, "40Wh(13\")", {:colspan => 2, :value => "50Wh(13\")"}]
     ]
 
-    puts TextLayout::Table.new(table).layout
+    puts TextLayout::Table.new(table, :border => true).layout
 
     ---
 
-    |                                                                                    Table of models |
+    +----------------------------------------------------------------------------------------------------+
+    |                                          Table of models                                           |
+    +------------------+---------------+-----------+-----------+--------------------+--------------------+
     |            Model |    Early 2008 | Late 2008 |  Mid 2009 |          Late 2010 |           Mid 2011 |
+    +------------------+---------------+-----------+-----------+--------------------+--------------------+
     | Model Identifier | MacBookAir1,1 |         MacBookAir2,1 | MacBookAir3,1(11") | MacBookAir4,1(11") |
     |                  |               |                       | MacBookAir3,2(13") | MacBookAir4,2(13") |
+    +------------------+---------------+-----------+-----------+--------------------+--------------------+
     |     Model number |     MB003LL/A | MB543LL/A | MC233LL/A |          MC505LL/A |          MC968ZP/A |
     |                  |               | MB940LL/A | MC234LL/A |          MC503LL/A |          MC969ZP/A |
     |                  |               |           |           |                    |          MC965ZP/A |
     |                  |               |           |           |                    |          MC966ZP/A |
-    |          Battery |                                   N/A |                               35Wh(11") |
+    +------------------+---------------+-----------+-----------+--------------------+--------------------+
+    |          Battery |                  N/A                  |                               35Wh(11") |
+    |                  +---------------------------+-----------+-----------------------------------------+
     |                  |                 37Wh(13") | 40Wh(13") |                               50Wh(13") |
-
+    +------------------+---------------------------+-----------+-----------------------------------------+
 
 == REQUIREMENTS:
 
@@ -48,6 +55,13 @@ Text layout engine for CUI apps.
 
 * $ gem install text_layout
 
+== OTHER CHOICES
+
+* https://github.com/aptinio/text-table
+* https://github.com/jwulff/pretty_table
+* https://github.com/visionmedia/terminal-table
+* http://rubyworks.github.com/ansi/docs/api/ANSI/Table.html
+
 == DEVELOPERS:
 
 After checking out the source, run:
@@ -61,7 +75,7 @@ and generate the RDoc.
 
 (The MIT License)
 
-Copyright (c) 2011 FIX
+Copyright (c) 2011 NANKI Haruo
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/text_layout.rb

@@ -1,7 +1,7 @@
 require 'unicode/display_width'
 
 module TextLayout
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 
   autoload :Wrap, 'text_layout/wrap'
   autoload :Table, 'text_layout/table'

data/lib/text_layout/table.rb

@@ -1,27 +1,42 @@
 class TextLayout::Table
-  def initialize(array)
-    @array = array
-  end
+  def initialize(table, options = {})
+    @table = table
+    @options = {
+      :align => :auto,
+      :col_border => "|",
+      :row_border => "-",
+      :cross => "+",
+      :border => false,
+      :padding => " "
+    }.merge(options)
 
-  def normalize(cell)
-    unless Hash === cell
-      cell = {:value => cell}
+    if @options[:border] == true
+      @options[:border] = [:top, :bottom, :left, :right, :cell].inject({}){|r, i|r[i] = true;r}
     end
+  end
 
-    cell[:value] = cell[:value].to_s.lines.map(&:strip)
-    cell
+  def column_border_width
+    @column_border_width ||= (@options[:padding] + @options[:col_border] + @options[:padding]).display_width
+  end
+
+  def cell_format
+    @cell_format ||= @options[:padding] + "%s" + @options[:padding]
+  end
+
+  def line_format
+    @line_format ||= @options[:col_border] + "%s" + @options[:col_border]
   end
 
   class Cell < Struct.new(:col, :row, :attr)
     def width
-      attr[:value].map(&:display_width).max
+      attr[:value].map(&:display_width).max || 0
     end
 
     def height
-      attr[:value].size
+      [attr[:value].size, 1].max
     end
   end
-  
+
   class Span < Cell
     def main?(col, row)
       self.col == col && self.row == row
@@ -29,110 +44,239 @@ class TextLayout::Table
   end
 
   def layout
-    spanss = {:row => Hash.new{[]}, :col => Hash.new{[]}}
-    layout = @array.map{[]}
+    unknot
+    calculate_cell_size
+    expand_cell_size
+    build_string.join("\n")
+  end
 
-    @array.each_with_index do |cols, row|
+  private
+  def unknot
+    @unknotted = @table.map{[]}
+    @spanss = {:row => Hash.new{[]}, :col => Hash.new{[]}}
+    @border = {:row => [], :col => []}
+
+    @table.each_with_index do |cols, row|
       cols.each_with_index do |attr, col|
         attr = normalize(attr)
+        col = @unknotted[row].index(nil) || @unknotted[row].size
+        rowspan, colspan = attr[:rowspan], attr[:colspan]
 
-        unless col = layout[row].index(nil)
-          col = layout[row].size
-        end
-
-        if !attr[:rowspan] && !attr[:colspan]
-          layout[row][col] = Cell.new(col, row, attr)
+        if !rowspan && !colspan
+          @unknotted[row][col] = Cell.new(col, row, attr)
         else
           span = Span.new(col, row, attr)
-          spanss[:row][row...row+attr[:rowspan]] <<= span if attr[:rowspan]
-          spanss[:col][col...col+attr[:colspan]] <<= span if attr[:colspan]
-          
-          (attr[:rowspan] || 1).times do |rr|
-            (attr[:colspan] || 1).times do |cc|
-              layout[row+rr][col+cc] = span
+          @spanss[:row][[row, rowspan]] <<= span if rowspan
+          @spanss[:col][[col, colspan]] <<= span if colspan
+
+          (rowspan || 1).times do |rr|
+            (colspan || 1).times do |cc|
+              @unknotted[row+rr][col+cc] = span
             end
           end
         end
+
+        @border[:row][row - 1] ||= @unknotted[row][col] != @unknotted[row - 1][col] if row > 0
+        @border[:col][col - 1] ||= @unknotted[row][col] != @unknotted[row][col - 1] if col > 0
       end
     end
 
-    max = {:row => [], :col => []}
+    [:row, :col].each{|dir| @border[dir].map!{|v| v ? 1 : 0 } }
+    @num_rows = @unknotted.size
+    @num_cols = @unknotted.first.size
+  end
 
-    layout.each_with_index do |cols, row|
+  def calculate_cell_size
+    @cell_size = {:row => [0] * @num_rows, :col => [0] * @num_cols}
+
+    @unknotted.each_with_index do |cols, row|
       cols.each_with_index do |cell, col|
         next if Span === cell && !cell.main?(col, row)
 
-        unless cell.attr[:colspan]
-          max[:col][col] = [max[:col][col] || 0, cell.width].max
-        end
-        
-        unless cell.attr[:rowspan]
-          max[:row][row] = [max[:row][row] || 0, cell.height].max
-        end
+        @cell_size[:col][col] = [@cell_size[:col][col], cell.width ].max unless cell.attr[:colspan]
+        @cell_size[:row][row] = [@cell_size[:row][row], cell.height].max unless cell.attr[:rowspan]
       end
     end
+  end
 
-    [[:col, 3], [:row, 0]].each do |dir, margin|
-      spanss[dir].each do |range, spans|
-        range_size = range.end - range.begin
+  def expand_cell_size
+    [[:col, column_border_width], [:row, @options[:border] ? 1 : 0]].each do |dir, margin|
+      @spanss[dir].each do |range, spans|
+        rstart, rsize = range
         spans.each do |span|
-          size = sum(max[dir][range]) + margin * (range_size - 1)
+          borders = sum(@border[dir][rstart, rsize-1])
+          size = sum(@cell_size[dir][*range]) + margin * borders
           diff = (dir == :col ? span.width : span.height) - size
 
           next unless diff > 0
-          q, r = diff.divmod range_size 
-          range.each_with_index do |i, rr|
-            max[dir][i] += q + (rr < r ? 1 : 0)
+
+          q, r = diff.divmod rsize
+          rsize.times do |i|
+            @cell_size[dir][rstart + i] += q + (i < r ? 1 : 0)
           end
         end
       end
     end
+  end
 
-    result = ""
-    sum(max[:row]).times do |layout_row|
-      n = layout_row
-      row = max[:row].each_with_index do |height, i|
-        if n - height >= 0
-          n -= height
-        else
-          break i 
-        end
+  def build_string
+    lines = []
+
+    total_lines = sum(@cell_size[:row])
+
+    if @options[:border]
+      total_lines += sum(@border[:row])
+      lines << row_border(-1) if @options[:border][:top]
+    end
+
+    total_lines.times do |display_row|
+      n = display_row
+      row, on_border = @cell_size[:row].each_with_index do |height, i|
+        n -= height
+        break i, false if n < 0
+
+        next unless @options[:border] && @options[:border][:cell]
+
+        n -= @border[:row][i] || 1
+        break i, true if n < 0
       end
 
       line = []
-      layout[row].each_with_index do |cell, col|
-        next unless cell.col == col
-        n = layout_row - sum(max[:row][0...cell.row])
-        width = 
-          if Span === cell && colspan = cell.attr[:colspan]
-            sum(max[:col][col...col+colspan]) + 3 * (colspan - 1)
+
+      line << cross(-1, row) if on_border
+
+      @unknotted[row].each_with_index do |cell, col|
+        n = display_row - sum(@cell_size[:row][0, cell.row])
+        n -= sum(@border[:row][0, cell.row]) if @options[:border]
+        value = cell.attr[:value][n]
+
+        type =
+          unless on_border
+            :value
           else
-            max[:col][col]
+            if row_border_visible?(col, row)
+              :cell_border
+            elsif !value
+              :blank
+            else
+              :value
+            end
           end
 
-        line << justify(cell.attr[:value][n].to_s, width)
+        case type
+        when :cell_border
+          line << cell_border(col)
+        when :blank
+          line << " " * cell_width(col)
+        when :value
+          next unless cell.col == col
+          line << cell_format % align(value.to_s, width_with_colspan(cell), cell.attr[:align] || @options[:align])
+        end
+
+        line << cross(col, row) if on_border
       end
 
-      result += "| " + line.join(" | ") + " |\n"
+      if on_border
+        lines << line.join
+      else
+        lines << line_format % line.join(@options[:col_border])
+      end
+    end
+
+    lines << row_border(@num_rows - 1) if @options[:border] && @options[:border][:bottom]
+
+    lines
+  end
+
+  def width_with_colspan(cell)
+    col = cell.col
+    if Span === cell && colspan = cell.attr[:colspan]
+      borders = sum(@border[:col][col, colspan - 1])
+      sum(@cell_size[:col][col, colspan]) + column_border_width * borders
+    else
+      @cell_size[:col][col]
     end
+  end
 
-    result
+  def row_border(row)
+    line = ""
+    line << cross(-1, row)
+    @num_cols.times do |col|
+      line << cell_border(col)
+      line << cross(col, row)
+    end
+    line
+  end
+
+  def cell_width(col)
+      @cell_size[:col][col] + @options[:padding].display_width * 2
+  end
+
+  def cell_border(col)
+    @options[:row_border] * cell_width(col)
+  end
+
+  def row_border_visible?(col, row)
+    !@unknotted[row + 1] || @unknotted[row][col] != @unknotted[row + 1][col]
+  end
+
+  def cross(col, row)
+    if @unknotted[row+1]
+      sw = @unknotted[row+1][col]
+      se = @unknotted[row+1][col+1]
+    else
+      sw = se = nil
+    end
+
+    nw = @unknotted[row][col]
+    ne = @unknotted[row][col+1]
+
+    nw = ne = nil if row < 0
+    sw = nw = nil if col < 0
+
+    case
+    when nw == ne && sw == se
+      @options[:row_border]
+    when nw == sw && ne == se
+      @options[:col_border]
+    else
+      @options[:cross]
+    end
+  end
+
+  def normalize(cell)
+    unless Hash === cell
+      cell = {:value => cell}
+    end
+
+    cell.delete :colspan if cell[:colspan] == 1
+    cell.delete :rowspan if cell[:rowspan] == 1
+
+    cell[:value] = cell[:value].to_s.lines.map(&:strip)
+
+    cell
   end
 
   def sum(array)
-    array.inject(0) {|r, i| r + i }
+    array.to_a.inject(0) {|r, i| r + i }
   end
 
-  def justify(str, width, type=:right)
+  def align(str, width, type=:auto)
     pad = width - str.display_width
-    pad = 0 if pad < 0 
+    pad = 0 if pad < 0
     case type
-    when :right
-      " " * pad + str
+    when :auto
+      if width * 0.85 < pad
+        align(str, width, :center)
+      else
+        align(str, width, :right)
+      end
     when :left
       str + " " * pad
     when :center
       " " * (pad / 2) + str + " " * (pad - pad / 2)
+    else # :right
+      " " * pad + str
     end
   end
 end

data/test/test_text_layout.rb

@@ -1,28 +1,26 @@
+#!ruby -Ku -I../lib -rubygems
 # -*- coding: UTF-8 -*-;
 require "test/unit"
 require "text_layout"
 
-$KCODE = 'u'
-
 class TestTextLayout < Test::Unit::TestCase
-  def test_wrap_private
-    wrap = TextLayout::Wrap.new("")
-    assert_equal %w(linew rap), wrap.send(:split_word, "linewrap", 5)
-    assert_equal %w(あい うえ), wrap.send(:split_word, "あいうえ", 5)
-  end
-
-  def test_wrap
-    assert_equal (["+"*20] * 4).join("\n"), TextLayout::Wrap.new("+"*80).layout(20)
-    assert_equal "line-\nwrap", TextLayout::Wrap.new("linewrap").layout(5)
+  def test_span_1
+    assert_table [
+      [{:value => 1, :colspan => 1, :rowspan => 1}],
+    ], <<-RESULT
+| 1 |
+    RESULT
   end
 
   def test_table_simple
     assert_table [
       [1, 2],
-      [3, 4]
+      [3, 4],
+      [5, 6]
     ], <<-RESULT
 | 1 | 2 |
 | 3 | 4 |
+| 5 | 6 |
     RESULT
   end
 
@@ -57,7 +55,49 @@ class TestTextLayout < Test::Unit::TestCase
     RESULT
   end
 
-  def assert_table(array, result)
-    assert_equal result, TextLayout::Table.new(array).layout
+  def test_align
+    assert_table [
+      [{:value => 1, :align => :left}, {:value => 2, :align => :center}, {:value => 3, :align => :right}],
+      [ {:value => "oooooooooooooooooooo", :colspan => 3}]
+    ], <<-RESULT
+| 1     |   2   |    3 |
+| oooooooooooooooooooo |
+    RESULT
+  end
+
+  def test_successive_colspan
+    assert_table [[{:colspan => 2, :value => "a"}] * 2], <<-RESULT
+| a | a |
+    RESULT
+  end
+
+  def test_border
+    assert_table [
+      [{:value => "", :colspan => 3}],
+      [1,2,3],
+      [{:value => "a", :rowspan=>2},"a",{:value => "a\na", :rowspan => 2}],
+      ["a"]
+    ], <<-RESULT, :border => true
++-----------+
+|           |
++---+---+---+
+| 1 | 2 | 3 |
++---+---+---+
+| a | a | a |
+|   +---+ a |
+|   | a |   |
++---+---+---+
+    RESULT
+  end
+
+  def assert_table(array, expected, options={})
+    result = TextLayout::Table.new(array, options).layout
+
+    if expected.rstrip != result
+      puts
+      puts result
+    end
+
+    assert_equal expected.rstrip, result
   end
 end

data/test/test_wrap.rb

@@ -0,0 +1,17 @@
+#!ruby -Ku -I../lib -rubygems
+# -*- coding: UTF-8 -*-;
+require "test/unit"
+require "text_layout"
+
+class TestWrap < Test::Unit::TestCase
+  def test_wrap_private
+    wrap = TextLayout::Wrap.new("")
+    assert_equal %w(linew rap), wrap.send(:split_word, "linewrap", 5)
+    assert_equal %w(あい うえ), wrap.send(:split_word, "あいうえ", 5)
+  end
+
+  def test_wrap
+    assert_equal (["+"*20] * 4).join("\n"), TextLayout::Wrap.new("+"*80).layout(20)
+    assert_equal "line-\nwrap", TextLayout::Wrap.new("linewrap").layout(5)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: text_layout
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-14 00:00:00.000000000Z
+date: 2011-09-16 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: unicode-display_width
-  requirement: &70140059189400 !ruby/object:Gem::Requirement
+  requirement: &70135698111700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70140059189400
+  version_requirements: *70135698111700
 - !ruby/object:Gem::Dependency
   name: hoe
-  requirement: &70140059188880 !ruby/object:Gem::Requirement
+  requirement: &70135698111120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,8 +32,8 @@ dependencies:
         version: '2.10'
   type: :development
   prerelease: false
-  version_requirements: *70140059188880
-description: Text layout engine for CUI apps.
+  version_requirements: *70135698111120
+description: Text layout engine for CUI apps with a pretty table.
 email:
 - nanki@dotswitch.net
 executables: []
@@ -50,6 +50,7 @@ files:
 - Rakefile
 - README.rdoc
 - test/test_text_layout.rb
+- test/test_wrap.rb
 - .gemtest
 homepage: http://github.com/nanki/text_layout
 licenses: []
@@ -76,6 +77,7 @@ rubyforge_project: text_layout
 rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: Text layout engine for CUI apps.
+summary: Text layout engine for CUI apps with a pretty table.
 test_files:
 - test/test_text_layout.rb
+- test/test_wrap.rb