galileo 0.1.0

data/lib/terminal-table/examples/examples.rb

@@ -0,0 +1,83 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'terminal-table/import'
+
+puts
+puts table(['a', 'b'], [1, 2], [3, 4])
+
+puts
+puts table(['name', 'content'], ['ftp.example.com', '1.1.1.1'], ['www.example.com', '|lalalala|lalala|'])
+
+puts
+t = table ['a', 'b']
+t.style = {:padding_left => 2, :width => 80}
+t << [1, 2]
+t << [3, 4]
+t << :separator
+t << [4, 6]
+puts t
+
+puts
+user_table = table do |v|
+  v.title = "Contact Information"
+  v.headings = 'First Name', 'Last Name', 'Email'
+  v << %w( TJ Holowaychuk tj@vision-media.ca )
+  v << %w( Bob Someone bob@vision-media.ca )
+  v << %w( Joe Whatever bob@vision-media.ca )
+end
+puts user_table
+
+puts
+user_table = table do |v|
+  v.style.width = 80
+  v.headings = 'First Name', 'Last Name', 'Email'
+  v << %w( TJ Holowaychuk tj@vision-media.ca )
+  v << %w( Bob Someone bob@vision-media.ca )
+  v << %w( Joe Whatever bob@vision-media.ca )
+end
+puts user_table
+
+puts
+user_table = table do
+  self.headings = 'First Name', 'Last Name', 'Email'
+  add_row ['TJ',  'Holowaychuk', 'tj@vision-media.ca']
+  add_row ['Bob', 'Someone',     'bob@vision-media.ca']
+  add_row ['Joe', 'Whatever',    'joe@vision-media.ca']
+  add_separator
+  add_row ['Total', { :value => '3', :colspan => 2, :alignment => :right }]
+  align_column 1, :center
+end
+puts user_table
+
+puts
+user_table = table do
+  self.headings = ['First Name', 'Last Name', {:value => 'Phones', :colspan => 2, :alignment => :center}]
+  add_row ['Bob', 'Someone',     '123', '456']
+  add_row :separator
+  add_row ['TJ',  'Holowaychuk', {:value => "No phones\navaiable", :colspan => 2, :alignment => :center}]
+  add_row :separator
+  add_row ['Joe', 'Whatever',    '4324', '343242']
+end
+puts user_table
+
+rows = []
+rows << ['Lines',      100]
+rows << ['Comments',   20]
+rows << ['Ruby',       70]
+rows << ['JavaScript', 30]
+puts table([nil, 'Lines'], *rows)
+
+rows = []
+rows << ['Lines',      100]
+rows << ['Comments',   20]
+rows << ['Ruby',       70]
+rows << ['JavaScript', 30]
+puts table(nil, *rows)
+
+rows = []
+rows << ['Lines',      100]
+rows << ['Comments',   20]
+rows << ['Ruby',       70]
+rows << ['JavaScript', 30]
+table = table([{ :value => 'Stats', :colspan => 2, :alignment => :center }], *rows)
+table.align_column 1, :right
+puts table

data/lib/terminal-table/lib/terminal-table/cell.rb

@@ -0,0 +1,98 @@
+
+module Terminal
+  class Table
+    class Cell
+      
+      ##
+      # Cell width.
+      
+      attr_reader :width
+      
+      ##
+      # Cell value.
+      
+      attr_reader :value
+      
+      ##
+      # Column span.
+      
+      attr_reader :colspan
+      
+      ##
+      # Initialize with _options_.
+      
+      def initialize options = nil
+        @value, options = options, {} unless Hash === options
+        @value = options.fetch :value, value
+        @alignment = options.fetch :alignment, nil
+        @colspan = options.fetch :colspan, 1
+        @width = options.fetch :width, @value.to_s.size
+        @index = options.fetch :index
+        @table = options.fetch :table
+      end
+      
+      def alignment?
+        !@alignment.nil?
+      end
+      
+      def alignment
+        @alignment || @table.style.alignment || :left
+      end
+      
+      def alignment=(val)
+        supported = %w(left center right)
+        if supported.include?(val.to_s)
+          @alignment = val
+        else
+          raise "Aligment must be one of: #{supported.join(' ')}"
+        end
+      end
+      
+      def lines
+        @value.to_s.split(/\n/)
+      end
+      
+      ##
+      # Render the cell.
+      
+      def render(line = 0)
+        left = " " * @table.style.padding_left
+        right = " " * @table.style.padding_right
+        render_width = lines[line].to_s.size - escape(lines[line]).size + width
+        "#{left}#{lines[line]}#{right}".align(alignment, render_width + @table.cell_padding)
+      end
+      alias :to_s :render
+      
+      ##
+      # Returns the longest line in the cell and
+      # removes all ANSI escape sequences (e.g. color)
+      
+      def value_for_column_width_recalc
+        lines.map{ |s| escape(s) }.max_by{ |s| s.size }
+      end
+      
+      ##
+      # Returns the width of this cell
+      
+      def width
+        padding = (colspan - 1) * @table.cell_spacing
+        inner_width = (1..@colspan).to_a.inject(0) do |w, counter|
+          w + @table.column_width(@index + counter - 1)
+        end
+        inner_width + padding
+      end
+
+      def wrap(width)
+        @value.gsub!(/(.{1,#{width}})( +|$\n?)|(.{1,#{width}})/, "\\1\\3\n") 
+      end
+
+      ##
+      # removes all ANSI escape sequences (e.g. color)      
+      def escape(line)
+        line.to_s.gsub(/\x1b(\[|\(|\))[;?0-9]*[0-9A-Za-z]/, '').
+          gsub(/\x1b(\[|\(|\))[;?0-9]*[0-9A-Za-z]/, '').
+          gsub(/(\x03|\x1a)/, '')
+      end
+    end
+  end
+end

data/lib/terminal-table/lib/terminal-table/core_ext.rb

@@ -0,0 +1,8 @@
+
+class String
+  def align position, length
+    self.__send__ position, length
+  end
+  alias_method :left, :ljust
+  alias_method :right, :rjust
+end

data/lib/terminal-table/lib/terminal-table/row.rb

@@ -0,0 +1,53 @@
+module Terminal
+  class Table
+    class Row
+      
+      ##
+      # Row cells
+      
+      attr_reader :cells
+      
+      attr_reader :table
+      
+      ##
+      # Initialize with _width_ and _options_.
+      
+      def initialize table, array = []
+        @cell_index = 0
+        @table = table
+        @cells = []
+        array.each { |item| self << item }
+      end
+      
+      def add_cell item
+        options = item.is_a?(Hash) ? item : {:value => item}
+        cell = Cell.new(options.merge(:index => @cell_index, :table => @table))
+        @cell_index += cell.colspan
+        @cells << cell
+      end
+      alias << add_cell
+      
+      def [] index
+        cells[index]
+      end
+      
+      def height
+        cells.map { |c| c.lines.count }.max
+      end
+
+      def wrap_cell(index, width) 
+        return if @cells.nil? or @cells[index].nil?
+        @cells[index].wrap(width)
+      end
+      
+      def render
+        y = @table.style.border_y
+        (0...height).to_a.map do |line|
+          y + cells.map do |cell|
+            cell.render(line)
+          end.join(y) + y
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/terminal-table/lib/terminal-table/separator.rb

@@ -0,0 +1,14 @@
+module Terminal
+  class Table
+    class Separator < Row
+      
+      def render
+        arr_x = (0...@table.number_of_columns).to_a.map do |i|
+          @table.style.border_x * (@table.column_width(i) + @table.cell_padding) 
+        end
+        border_i = @table.style.border_i
+        border_i + arr_x.join(border_i) + border_i
+      end
+    end
+  end
+end

data/lib/terminal-table/lib/terminal-table/style.rb

@@ -0,0 +1,65 @@
+
+module Terminal
+  class Table
+    # A Style object holds all the formatting information for a Table object
+    # 
+    # To create a table with a certain style, use either the constructor 
+    # option <tt>:style</tt>, the Table#style object or the Table#style= method
+    #
+    # All these examples have the same effect:
+    # 
+    #     # by constructor
+    #     @table = Table.new(:style => {:padding_left => 2, :width => 40})
+    #
+    #     # by object
+    #     @table.style.padding_left = 2
+    #     @table.style.width = 40
+    #
+    #     # by method
+    #     @table.style = {:padding_left => 2, :width => 40}
+    # 
+    # To set a default style for all tables created afterwards use Style.defaults=
+    # 
+    #     Terminal::Table::Style.defaults = {:width => 80}
+    #
+    class Style
+      @@defaults = {
+        :border_x => "-", :border_y => "|", :border_i => "+",
+        :padding_left => 1, :padding_right => 1,
+        :width => nil, :alignment => nil,
+        :wrap => true, :wrap_minimum_width => 4
+      }
+      
+      attr_accessor :border_x
+      attr_accessor :border_y
+      attr_accessor :border_i
+      
+      attr_accessor :padding_left
+      attr_accessor :padding_right
+      
+      attr_accessor :width
+      attr_accessor :alignment
+      attr_accessor :wrap
+      attr_accessor :wrap_minimum_width
+      
+      
+      def initialize options = {}
+        apply self.class.defaults.merge(options)
+      end
+      
+      def apply options
+        options.each { |m, v| __send__ "#{m}=", v }
+      end
+      
+      class << self
+        def defaults
+          @@defaults
+        end
+        
+        def defaults= options
+          @@defaults = defaults.merge(options)
+        end
+      end
+    end
+  end
+end

data/lib/terminal-table/lib/terminal-table/table.rb

@@ -0,0 +1,261 @@
+
+module Terminal
+  class Table
+    
+    attr_reader :title
+    attr_reader :headings
+    
+    ##
+    # Generates a ASCII table with the given _options_.
+  
+    def initialize options = {}, &block
+      @column_widths = []
+      self.style = options.fetch :style, {}
+      self.headings = options.fetch :headings, []
+      self.rows = options.fetch :rows, []
+      self.title = options.fetch :title, nil
+      yield_or_eval(&block) if block
+    end
+    
+    ##
+    # Align column _n_ to the given _alignment_ of :center, :left, or :right.
+    
+    def align_column n, alignment
+      r = rows
+      column(n).each_with_index do |col, i|
+        cell = r[i][n]
+        cell.alignment = alignment unless cell.alignment?
+      end
+    end
+    
+    ##
+    # Add a row. 
+    
+    def add_row array
+      row = array == :separator ? Separator.new(self) : Row.new(self, array)
+      @rows << row
+      recalc_column_widths row
+    end
+    alias :<< :add_row
+
+    ##
+    # Add a separator.
+
+    def add_separator
+      self << :separator
+    end
+    
+    def cell_spacing
+      cell_padding + style.border_y.length
+    end
+    
+    def cell_padding
+      style.padding_left + style.padding_right
+    end
+    
+    ##
+    # Return column _n_.
+    
+    def column n, method = :value, array = rows
+      array.map { |row| 
+        cell = row[n]
+        cell && method ? cell.__send__(method) : cell
+      }.compact 
+    end
+    
+    ##
+    # Return _n_ column including headings.
+    
+    def column_with_headings n, method = :value
+      column n, method, headings_with_rows
+    end
+    
+    ##
+    # Return columns.
+    
+    def columns
+      (0...number_of_columns).map { |n| column n } 
+    end
+    
+    ##
+    # Return length of column _n_.
+    
+    def column_width n
+      width = @column_widths[n] || 0
+      width + additional_column_widths[n].to_i
+    end
+    alias length_of_column column_width # for legacy support
+    
+    ##
+    # Return total number of columns available.
+     
+    def number_of_columns
+      headings_with_rows.map { |r| r.cells.size }.max
+    end
+
+    ##
+    # Set the headings
+    
+    def headings= array
+      @headings = Row.new(self, array)
+      recalc_column_widths @headings
+    end
+
+    ##
+    # Render the table.
+  
+    def render
+      adjust_widths
+      separator = Separator.new(self)
+      buffer = [separator]
+      unless @title.nil?
+        buffer << Row.new(self, [title_cell_options])
+        buffer << separator
+      end
+      unless @headings.cells.empty?
+        buffer << @headings
+        buffer << separator
+      end
+      buffer += @rows
+      buffer << separator
+      buffer.map { |r| r.render }.join("\n")
+    end
+    alias :to_s :render
+    
+    ##
+    # Return rows without separator rows.
+
+    def rows
+      @rows.reject { |row| row.is_a? Separator }
+    end
+    
+    def rows= array
+      @rows = []
+      array.each { |arr| self << arr }
+    end
+
+    def style=(options)
+      style.apply options
+    end
+    
+    def style
+      @style ||= Style.new
+    end
+    
+    def title=(title)
+      @title = title
+      recalc_column_widths Row.new(self, [title_cell_options])
+    end
+    
+    ##
+    # Check if _other_ is equal to self. _other_ is considered equal
+    # if it contains the same headings and rows.
+
+    def == other
+      if other.respond_to? :render and other.respond_to? :rows
+        self.headings == other.headings and self.rows == other.rows
+      end
+    end
+
+    private
+    
+    def columns_width
+      @column_widths.inject(0) { |s, i| s + i + cell_spacing } + style.border_y.length
+    end
+
+    def wrap_column(index, new_width)
+      @rows.each do |row|
+        row.wrap_cell(index, new_width)
+      end
+    end
+
+    def adjust_widths
+      return if style.wrap == false or style.width.nil? or style.width > columns_width
+
+      # Make a column index to column size mapping, then sort it
+      current_index = -1
+      total_column_widths = @column_widths.map { |s| current_index +=1; [current_index, s + cell_spacing] }
+      total_column_widths = total_column_widths.sort_by { |a,b| b }
+
+      packed_length = 0
+      current_index = 0
+      # Pack the smallest first, but make sure the remaining space is enough for
+      # the rest of the columns to have at least style.wrap_minimum_width spaces
+      # to wrap into.
+      while (style.width - (packed_length + total_column_widths[current_index][1] + style.border_y.length)) >
+            (style.wrap_minimum_width * (total_column_widths.size - current_index - 1)) do
+        packed_length += total_column_widths[current_index][1]
+        current_index += 1
+      end
+
+      # Calculate the remaining space and figure out how big to wrap the other columns to
+      remaining_space = style.width - packed_length - style.border_y.length
+      trim_to = (remaining_space / (total_column_widths.size - current_index)) - cell_spacing
+      trim_to -= (1 + style.padding_left + style.padding_right)
+      if trim_to < 1
+        raise "Cannot fit a #{total_column_widths.size} column table in width #{style.width}."
+      end
+
+      # The remaining columns are then wrapped
+      (current_index...total_column_widths.size).each do |i|
+        wrap_column(total_column_widths[i][0], trim_to)
+        @column_widths[total_column_widths[i][0]] = trim_to + cell_spacing
+      end
+    end
+
+    def additional_column_widths
+      return [] if style.width.nil?
+      spacing = style.width - columns_width
+      if spacing < 0
+        raise "Table width exceeds wanted width of #{style.width} characters."
+      else
+        per_col = spacing / number_of_columns
+        arr = (1...number_of_columns).to_a.map { |i| per_col }
+        other_cols = arr.inject(0) { |s, i| s + i }
+        arr << spacing - other_cols
+        arr
+      end
+    end
+
+    def recalc_column_widths row
+      return if row.is_a? Separator
+      i = 0
+      row.cells.each do |cell|
+        colspan = cell.colspan
+        cell_value = cell.value_for_column_width_recalc
+        colspan.downto(1) do |j|
+          cell_length = cell_value.to_s.length
+          if colspan > 1
+            spacing_length = cell_spacing * (colspan - 1)
+            length_in_columns = (cell_length - spacing_length)
+            cell_length = (length_in_columns.to_f / colspan).ceil
+          end
+          if @column_widths[i].to_i < cell_length
+            @column_widths[i] = cell_length
+          end
+          i = i + 1
+        end
+      end
+    end
+    
+    ##
+    # Return headings combined with rows.
+    
+    def headings_with_rows
+      [@headings] + rows
+    end
+    
+    def yield_or_eval &block
+      return unless block
+      if block.arity > 0
+        yield self
+      else
+        self.instance_eval(&block)
+      end
+    end
+
+    def title_cell_options
+      {:value => @title, :alignment => :center, :colspan => number_of_columns}
+    end
+  end
+end

data/lib/terminal-table/lib/terminal-table/table_helper.rb

@@ -0,0 +1,9 @@
+module Terminal
+  class Table
+    module TableHelper
+      def table headings = [], *rows, &block
+        Terminal::Table.new :headings => headings.to_a, :rows => rows, &block
+      end
+    end
+  end
+end

data/lib/terminal-table/lib/terminal-table/version.rb

@@ -0,0 +1,5 @@
+module Terminal
+  class Table
+    VERSION = '1.4.3'
+  end
+end

data/lib/terminal-table/lib/terminal-table.rb

@@ -0,0 +1,13 @@
+# require "terminal-table/cell"
+# require "terminal-table/core_ext"
+# require "terminal-table/row"
+# require "terminal-table/separator"
+# require "terminal-table/style"
+# require "terminal-table/table_helper"
+# require "terminal-table/table"
+# require "terminal-table/version"
+
+$:.unshift File.dirname(__FILE__)
+%w(version core_ext table cell row separator style table_helper).each do |file|
+  require "terminal-table/#{file}"
+end

data/lib/terminal-table/spec/cell_spec.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'term/ansicolor'
+
+class String; include Term::ANSIColor; end
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Terminal::Table do
+  Cell = Terminal::Table::Cell
+  
+  it "should default alignment to the left" do
+    cell = Cell.new :value => 'foo', :table => Terminal::Table.new, :index => 0
+    cell.value.should == 'foo'
+    cell.alignment.should == :left
+  end
+
+  it "should allow overriding of alignment" do
+    cell = Cell.new :value => 'foo', :alignment => :center, :table => Terminal::Table.new, :index => 0
+    cell.value.should == 'foo'
+    cell.alignment.should == :center
+  end
+  
+  it "should allow :left, :right and :center for alignment" do
+    @cell = Cell.new :value => 'foo', :table => Terminal::Table.new, :index => 0
+    @cell.alignment = :left
+    @cell.alignment = :right
+    @cell.alignment = :center
+    lambda { @cell.alignment = "foo" }.should raise_error
+  end
+  
+  it "should allow multiline content" do
+    cell = Cell.new :value => "barrissimo\n"+"foo".yellow, :table => Terminal::Table.new, :index => 0
+    cell.value.should == "barrissimo\n"+"foo".yellow
+    cell.lines.should == ['barrissimo','foo'.yellow]
+    cell.value_for_column_width_recalc.should == 'barrissimo'
+    cell.render(0).should == " barrissimo "
+  end
+  
+  it "should allow colorized content" do
+    cell = Cell.new :value => "foo".red, :table => Terminal::Table.new, :index => 0
+    cell.value.should == "\e[31mfoo\e[0m"
+    cell.value_for_column_width_recalc.should == 'foo'
+    cell.render.should == " \e[31mfoo\e[0m "
+  end
+  
+  it "should render padding properly" do
+    @table = Terminal::Table.new(:rows => [['foo', '2'], ['3', '4']], :style => {:padding_right => 3})
+    cell = @table.rows.first.cells.first
+    cell.value.should == 'foo'
+    cell.alignment.should == :left
+    cell.render.should == " foo   "
+  end
+
+  it "should not ignore pipe characters" do
+    cell = Cell.new :value => "f|o|o", :table => Terminal::Table.new, :index => 0
+    cell.value.should == "f|o|o"
+    cell.value_for_column_width_recalc.should == 'f|o|o'
+    cell.render.should == " f|o|o "
+  end
+end

data/lib/terminal-table/spec/core_ext_spec.rb

@@ -0,0 +1,18 @@
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe String do
+  describe "#align" do
+    it "should center" do
+      'foo'.align(:center, 10).should == '   foo    '
+    end
+    
+    it "should align left" do
+      'foo'.align(:left, 10).should == 'foo       '
+    end
+  
+    it "should align right" do
+      'foo'.align(:right, 10).should == '       foo'
+    end
+  end
+end