terminal-table 1.4.3 → 1.4.4

data/lib/terminal-table/core_ext.rb

@@ -1,28 +1,8 @@
 
 class String
   def align position, length
-    send position, length
+    self.__send__ position, length
   end
   alias_method :left, :ljust
   alias_method :right, :rjust
-end
-
-module Enumerable
-  def map_with_index &block
-    vals = []
-    each_with_index { |v, i| vals << yield(v, i) } 
-    vals
-  end
-  alias :collect_with_index :map_with_index
-end
-
-class Object
-  def yield_or_eval &block
-    return unless block
-    if block.arity > 0
-      yield self
-    else
-      self.instance_eval &block
-    end
-  end
 end

data/lib/terminal-table/row.rb

@@ -0,0 +1,48 @@
+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 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/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/style.rb

@@ -0,0 +1,61 @@
+
+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
+      }
+      
+      attr_accessor :border_x
+      attr_accessor :border_y
+      attr_accessor :border_i
+      
+      attr_accessor :padding_left
+      attr_accessor :padding_right
+      
+      attr_accessor :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/table.rb

@@ -2,143 +2,39 @@
 module Terminal
   class Table
     
-    #--
-    # Exceptions
-    #++
-    
-    Error = Class.new StandardError
-    
-    ##
-    # Table characters, x axis, y axis, and intersection.
-    
-    X, Y, I = '-', '|', '+'
-    
-    ##
-    # Rows array.
-    
-    attr_accessor :rows
+    attr_reader :title
+    attr_reader :headings
     
     ##
     # Generates a ASCII table with the given _options_.
   
     def initialize options = {}, &block
-      @column_lengths = []
+      @column_widths = []
+      self.style = options.fetch :style, {}
+      self.title = options.fetch :title, nil
       self.headings = options.fetch :headings, []
-      @rows = []
-      options.fetch(:rows, []).each { |row| add_row row }
-      yield_or_eval &block if block
-    end
-
-    def headings= h
-      @headings = h
-      recalc_column_lengths @headings
-    end
-
-    ##
-    # Render the table.
-  
-    def render
-      buffer = [separator, "\n"]
-      if has_headings?
-        buffer << render_headings
-        buffer << "\n" << separator << "\n"
-      end
-      buffer << @rows.map do |row| 
-        render_row(row)
-      end.join("\n")
-      buffer << "\n" << separator << "\n"
-      buffer.join
-    end
-    alias :to_s :render
-    
-    ##
-    # Render headings.
-
-    def render_headings
-      Y + @headings.map_with_index do |heading, i|
-        width = 0
-        if heading.is_a?(Hash) and !heading[:colspan].nil?
-          i.upto(i + heading[:colspan] - 1) do |col|
-            width += length_of_column(col)
-          end
-          width += (heading[:colspan] - 1) * (Y.length + 2)
-        else
-          width = length_of_column(i)
-        end
-        Heading.new( width, heading).render
-      end.join(Y) + Y
+      self.rows = options.fetch :rows, []
+      yield_or_eval(&block) if block
     end
     
     ##
-    # Render the given _row_.
-
-    def render_row row
-      if row == :separator
-        separator
-      else
-        Y + row.map_with_index do |cell, i|
-          render_cell(cell, row_to_index(row, i))
-        end.join(Y) + Y
-      end
-    end
+    # Align column _n_ to the given _alignment_ of :center, :left, or :right.
     
-    ##
-    # Render the given _cell_ at index _i_.
-
-    def render_cell cell, i
-      width = 0
-      if cell.is_a?(Hash) and !cell[:colspan].nil?
-        i.upto(i + cell[:colspan] - 1) do |col|
-          width += length_of_column(col)
-        end
-        width += (cell[:colspan] - 1) * (Y.length + 2)
-      else
-        width = length_of_column(i)
+    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
-      Cell.new(width, cell).render
-    end
-    
-    ##
-    # Create a separator based on colum lengths.
-    
-    def separator
-      I + columns.collect_with_index do |col, i| 
-        X * (length_of_column(i) + 2) 
-      end.join(I) + I 
     end
     
     ##
     # Add a row. 
     
-    def add_row row
+    def add_row array
+      row = array == :separator ? Separator.new(self) : Row.new(self, array)
       @rows << row
-      recalc_column_lengths row
-    end
-
-    def recalc_column_lengths row
-      if row.is_a?(Symbol) then return end
-      i = 0
-      row.each do |cell|
-        if cell.is_a?(Hash)
-          colspan = cell[:colspan] || 1
-          cell_value = cell[:value]
-        else
-          colspan = 1
-          cell_value = cell
-        end
-        colspan.downto(1) do |j|
-          cell_length = cell_value.to_s.length
-          if colspan > 1
-            spacing_length = (3 * (colspan - 1))
-            length_in_columns = (cell_length - spacing_length)
-            cell_length = (length_in_columns.to_f / colspan).ceil
-          end
-          if (@column_lengths[i] || 0) < cell_length
-            @column_lengths[i] = cell_length
-          end
-          i = i + 1
-        end
-      end
+      recalc_column_widths row
     end
     alias :<< :add_row
 
@@ -146,121 +42,175 @@ module Terminal
     # Add a separator.
 
     def add_separator
-      @rows << :separator
+      self << :separator
+    end
+    
+    def cell_spacing
+      cell_padding + style.border_y.length
     end
-
-    ##
-    # Weither or not any headings are present, since they are optional.
     
-    def has_headings?
-      not @headings.empty?
+    def cell_padding
+      style.padding_left + style.padding_right
     end
     
     ##
     # Return column _n_.
     
-    def column n
-      rows.map { |row| row[n] }.compact 
+    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
-      headings_with_rows.map { |row| row_with_hash(row)[n] }.compact
-    end
-
-    def row_with_hash row
-      # this method duplicates the multi-column columns in each column they are in
-      index = 0
-      row.inject [] do |columns, column|
-        if column.is_a?(Hash) && column[:colspan] && column[:colspan] > 1
-          column[:start_index] = index
-          column[:colspan].times do
-            columns << column
-            index += 1
-          end
-        else
-          columns << column
-          index += 1
-        end
-        columns
-      end
-    end
-
-    def row_to_index row, index
-      new_index = -1
-      0.upto(index) do |i|
-        column = row[i]
-        if column.is_a?(Hash) && column[:colspan] && column[:colspan] > 1 && index != i
-          new_index = new_index + column[:colspan]
-        else
-          new_index += 1
-        end
-      end
-      return new_index
+    def column_with_headings n, method = :value
+      column n, method, headings_with_rows
     end
     
     ##
     # Return columns.
     
-    def columns 
+    def columns
       (0...number_of_columns).map { |n| column n } 
     end
     
     ##
     # Return length of column _n_.
     
-    def length_of_column n
-      @column_lengths[n] || 0
+    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
-      return rows.first.length unless rows.empty?
-      raise Error, 'your table needs some rows'
+      headings_with_rows.map { |r| r.cells.size }.max
     end
-    
+
     ##
-    # Align column _n_ to the given _alignment_ of :center, :left, or :right.
+    # Set the headings
     
-    def align_column n, alignment
-      r = rows
-      column(n).each_with_index do |col, i|
-        r[i][n] = { :value => col, :alignment => alignment } unless Hash === col
-      end
+    def headings= array
+      @headings = Row.new(self, array)
+      recalc_column_widths @headings
     end
-    
+
     ##
-    # Return headings combined with rows.
-    
-    def headings_with_rows
-      [@headings] + rows
+    # Render the table.
+  
+    def render
+      separator = Separator.new(self)
+      buffer = [separator]
+      unless @title.nil?
+        opts = {:value => @title, :alignment => :center, :colspan => number_of_columns}
+        buffer << Row.new(self, [opts])
+        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 == :separator }
+      @rows.reject { |row| row.is_a? Separator }
     end
-
-    ##
-    # Return rows including separator rows.
-
-    def all_rows
-      @rows
+    
+    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])
+    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? :headings and other.respond_to? :rows
-        @headings == other.headings and rows == other.rows
+      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 additional_column_widths
+      return [] if style.width.nil?
+      spacing = style.width - columns_width
+      if spacing < 0
+        raise "Table width exceeds wanted width of #{wanted} 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
   end