Chrononaut-hirb 0.2.1

data/lib/hirb/hash_struct.rb

@@ -0,0 +1,17 @@
+require 'ostruct'
+
+class Hirb::HashStruct < OpenStruct #:nodoc:
+  def self.block_to_hash(block=nil)
+    config = self.new
+    if block
+      block.call(config)
+      config.to_hash
+    else
+      {}
+    end
+  end
+
+  def to_hash
+    @table
+  end
+end

data/lib/hirb/helpers.rb

@@ -0,0 +1,7 @@
+module Hirb
+  module Helpers #:nodoc:
+  end
+end
+%w{table object_table active_record_table auto_table tree parent_child_tree}.each do |e|
+  require "hirb/helpers/#{e}"
+end

data/lib/hirb/helpers/active_record_table.rb

@@ -0,0 +1,16 @@
+class Hirb::Helpers::ActiveRecordTable < Hirb::Helpers::ObjectTable
+  # Rows are Rails' ActiveRecord::Base objects.
+  # Takes same options as Hirb::Helpers::Table.render except as noted below.
+  #
+  # Options:
+  #   :fields- Can be any attribute, column or not. If not given, this defaults to the database table's columns.
+  def self.render(rows, options={})
+    rows = [rows] unless rows.is_a?(Array)
+    options[:fields] ||= 
+      begin
+        fields = rows.first.class.column_names
+        fields.map {|e| e.to_sym }
+      end
+    super(rows, options)
+  end
+end

data/lib/hirb/helpers/auto_table.rb

@@ -0,0 +1,15 @@
+# Detects the table class the output should use and delegates rendering to it.
+class Hirb::Helpers::AutoTable
+  # Same options as Hirb::Helpers::Table.render.
+  def self.render(output, options={})
+    output = output.to_a if !output.is_a?(Array) && output.respond_to?(:to_a)
+    klass = if ((output.is_a?(Array) && output[0].is_a?(ActiveRecord::Base)) or output.is_a?(ActiveRecord::Base) rescue false)
+      Hirb::Helpers::ActiveRecordTable
+    elsif (output.is_a?(Array) && !(output[0].is_a?(Hash) || output[0].is_a?(Array)))
+      Hirb::Helpers::ObjectTable
+    else
+      Hirb::Helpers::Table
+    end
+    klass.render(output, options)
+  end
+end

data/lib/hirb/helpers/object_table.rb

@@ -0,0 +1,15 @@
+class Hirb::Helpers::ObjectTable < Hirb::Helpers::Table
+  # Rows are any ruby objects. Takes same options as Hirb::Helpers::Table.render except as noted below.
+  #
+  # Options:
+  #   :fields- Methods of the object to represent as columns. Defaults to [:to_s].
+  def self.render(rows, options ={})
+    options[:fields] ||= [:to_s]
+    options[:headers] = {:to_s=>'value'} if options[:fields] == [:to_s]
+    rows = [rows] unless rows.is_a?(Array)
+    item_hashes = rows.inject([]) {|t,item|
+      t << options[:fields].inject({}) {|h,f| h[f] = item.send(f); h}
+    }
+    super(item_hashes, options)
+  end
+end

data/lib/hirb/helpers/parent_child_tree.rb

@@ -0,0 +1,22 @@
+class Hirb::Helpers::ParentChildTree < Hirb::Helpers::Tree
+  class <<self
+    # Starting with the given node, this builds a tree by recursively calling a children method.
+    # Takes same options as Hirb::Helper::Table.render with some additional ones below.
+    # ==== Options:
+    # [:value_method] Method to call to display as a node's value. If not given, uses :name if node
+    #                 responds to :name or defaults to :object_id.
+    # [:children_method] Method to call to obtain a node's children. Default is :children.
+    def render(root_node, options={})
+      @value_method = options[:value_method] || (root_node.respond_to?(:name) ? :name : :object_id)
+      @children_method = options[:children_method] || :children
+      @nodes = []
+      build_node(root_node, 0)
+      super(@nodes, options)
+    end
+
+    def build_node(node, level) #:nodoc:
+      @nodes << {:value=>node.send(@value_method), :level=>level}
+      node.send(@children_method).each {|e| build_node(e, level + 1)}
+    end
+  end
+end

data/lib/hirb/helpers/table.rb

@@ -0,0 +1,243 @@
+# Base Table class from which other table classes inherit.
+# By default, a table is constrained to a default width but this can be adjusted
+# via the max_width option or Hirb::View.width.
+# Rows can be an array of arrays or an array of hashes.
+#
+# An array of arrays ie [[1,2], [2,3]], would render:
+#   +---+---+
+#   | 0 | 1 |
+#   +---+---+
+#   | 1 | 2 |
+#   | 2 | 3 |
+#   +---+---+
+#
+# By default, the fields/columns are the numerical indices of the array.
+#
+# An array of hashes ie [{:age=>10, :weight=>100}, {:age=>80, :weight=>500}], would render:
+#   +-----+--------+
+#   | age | weight |
+#   +-----+--------+
+#   | 10  | 100    |
+#   | 80  | 500    |
+#   +-----+--------+
+#
+# By default, the fields/columns are the keys of the first hash.
+#--
+# derived from http://gist.github.com/72234
+class Hirb::Helpers::Table
+  BORDER_LENGTH = 3 # " | " and "-+-" are the borders
+  class TooManyFieldsForWidthError < StandardError; end
+
+  class << self
+
+    # Main method which returns a formatted table.
+    # ==== Options:
+    # [:fields] An array which overrides the default fields and can be used to indicate field order.
+    # [:headers] A hash of fields and their header names. Fields that aren't specified here default to their name.
+    #            This option can also be an array but only for array rows.
+    # [:field_lengths] A hash of fields and their maximum allowed lengths. If a field exceeds it's maximum
+    #                  length than it's truncated and has a ... appended to it. Fields that aren't specified here have no maximum allowed
+    #                  length.
+    # [:max_width] The maximum allowed width of all fields put together. This option is enforced except when the field_lengths option is set.
+    #              This doesn't count field borders as part of the total.
+    # [:number]  When set to true, numbers rows by adding a :hirb_number column as the first column. Default is false.
+    # [:filters] A hash of fields and the filters that each row in the field must run through. The filter converts the cell's value by applying
+    #            a given proc or an array containing a method and optional arguments to it.
+    # Examples:
+    #    Hirb::Helpers::Table.render [[1,2], [2,3]]
+    #    Hirb::Helpers::Table.render [[1,2], [2,3]], :field_lengths=>{0=>10}
+    #    Hirb::Helpers::Table.render [{:age=>10, :weight=>100}, {:age=>80, :weight=>500}]
+    #    Hirb::Helpers::Table.render [{:age=>10, :weight=>100}, {:age=>80, :weight=>500}], :headers=>{:weight=>"Weight(lbs)"}
+    #    Hirb::Helpers::Table.render [{:age=>10, :weight=>100}, {:age=>80, :weight=>500}], :filters=>{:age=>[:to_f]}
+    def render(rows, options={})
+      new(rows,options).render
+    end
+  end
+
+  #:stopdoc:
+  def initialize(rows, options={})
+    @options = options
+    @options[:filters] ||= {}
+    @vertical = options[:vertical] || (Hirb::View.config[:vertical] if Hirb::View.config)
+    @fields = @options[:fields] ? @options[:fields].dup : ((rows[0].is_a?(Hash)) ? rows[0].keys.sort {|a,b| a.to_s <=> b.to_s} :
+                                                           rows[0].is_a?(Array) ? (0..rows[0].length - 1).to_a : [])
+    if @vertical
+      @longest = @fields.map.sort_by { |i| i.to_s.length }.last.to_s.length
+    end
+    @rows = setup_rows(rows)
+    @headers = @fields.inject({}) {|h,e| h[e] = e.to_s; h}
+    if @options.has_key?(:headers)
+      @headers = @options[:headers].is_a?(Hash) ? @headers.merge(@options[:headers]) :
+        (@options[:headers].is_a?(Array) ? array_to_indices_hash(@options[:headers]) : @options[:headers])
+    end
+    if @options[:number]
+      @headers[:hirb_number] = "number"
+      @fields.unshift :hirb_number
+    end
+  end
+
+  def setup_rows(rows)
+    rows ||= []
+    rows = [rows] unless rows.is_a?(Array)
+    if rows[0].is_a?(Array)
+      rows = rows.inject([]) {|new_rows, row|
+        new_rows << array_to_indices_hash(row)
+      }
+    end
+    rows = filter_values(rows)
+    rows.each_with_index {|e,i| e[:hirb_number] = (i + 1).to_s} if @options[:number] or @vertical
+    validate_values(rows)
+    rows
+  end
+
+  def render
+    body = []
+    unless @rows.length == 0
+      setup_field_lengths
+      body += @headers ? render_header : [render_border] unless @vertical
+      body += render_rows
+      body << render_border unless @vertical
+    end
+    body << render_table_description
+    body.join("\n")
+  end
+
+  def render_header
+    title_row = '| ' + @fields.map {|f|
+      format_cell(@headers[f], @field_lengths[f])
+    }.join(' | ') + ' |'
+    [render_border, title_row, render_border]
+  end
+
+  def render_border
+    '+-' + @fields.map {|f| '-' * @field_lengths[f] }.join('-+-') + '-+'
+  end
+
+  def format_cell(value, cell_width)
+    text = value.length > cell_width ?
+      (
+      (cell_width < 5) ? value.slice(0,cell_width) : value.slice(0, cell_width - 3) + '...'
+      ) : value
+    sprintf("%-#{cell_width}s", text)
+  end
+
+  def render_rows
+    i = 0
+    @rows.map do |row|
+      if @vertical
+        stars = "*" * [(@longest + (@longest / 2)), 3].max
+        row = "#{stars} #{@rows[i][:hirb_number]}. row #{stars}\n" +
+        @fields.map {|f|
+          "#{f.to_s.rjust(@longest)}: #{row[f]}"
+        }.join("\n")
+      else
+        row = '| ' + @fields.map {|f|
+          format_cell(row[f], @field_lengths[f])
+        }.join(' | ') + ' |'
+      end
+      i += 1
+      row
+    end
+  end
+
+  def render_table_description
+    (@rows.length == 0) ? "0 rows in set" :
+      "#{@rows.length} #{@rows.length == 1 ? 'row' : 'rows'} in set"
+  end
+
+  def setup_field_lengths
+    @field_lengths = default_field_lengths
+    if @options[:field_lengths]
+      @field_lengths.merge!(@options[:field_lengths])
+    else
+      table_max_width = @options.has_key?(:max_width) ? @options[:max_width] : Hirb::View.width
+      restrict_field_lengths(@field_lengths, table_max_width) if table_max_width
+    end
+  end
+
+  def restrict_field_lengths(field_lengths, max_width)
+    max_width -= @fields.size * BORDER_LENGTH + 1
+    original_field_lengths = field_lengths.dup
+    @min_field_length = BORDER_LENGTH
+    adjust_long_fields(field_lengths, max_width)
+  rescue TooManyFieldsForWidthError
+    raise
+  rescue
+    default_restrict_field_lengths(field_lengths, original_field_lengths, max_width)
+  end
+
+  # Simple algorithm which given a max width, allows smaller fields to be displayed while
+  # restricting longer fields at an average_long_field_length.
+  def adjust_long_fields(field_lengths, max_width)
+    total_length = field_lengths.values.inject {|t,n| t += n}
+    while total_length > max_width
+      raise TooManyFieldsForWidthError if @fields.size > max_width.to_f / @min_field_length
+      average_field_length = total_length / @fields.size.to_f
+      long_lengths = field_lengths.values.select {|e| e > average_field_length}
+      if long_lengths.empty?
+        raise "Algorithm didn't work, resort to default"
+      else
+        total_long_field_length = (long_lengths.inject {|t,n| t += n}) * max_width/total_length
+        average_long_field_length = total_long_field_length / long_lengths.size
+        field_lengths.each {|f,length|
+          field_lengths[f] = average_long_field_length if length > average_long_field_length
+        }
+      end
+      total_length = field_lengths.values.inject {|t,n| t += n}
+    end
+  end
+
+  # Produces a field_lengths which meets the max_width requirement
+  def default_restrict_field_lengths(field_lengths, original_field_lengths, max_width)
+    original_total_length = original_field_lengths.values.inject {|t,n| t += n}
+    relative_lengths = original_field_lengths.values.map {|v| (v / original_total_length.to_f * max_width).to_i  }
+    # set fields by their relative weight to original length
+    if relative_lengths.all? {|e| e > @min_field_length} && (relative_lengths.inject {|a,e| a += e} <= max_width)
+      original_field_lengths.each {|k,v| field_lengths[k] = (v / original_total_length.to_f * max_width).to_i }
+    else
+      # set all fields the same if nothing else works
+      field_lengths.each {|k,v| field_lengths[k] = max_width / @fields.size}
+    end
+  end
+
+  # find max length for each field; start with the headers
+  def default_field_lengths
+    field_lengths = @headers ? @headers.inject({}) {|h,(k,v)| h[k] = v.length; h} : {}
+    @rows.each do |row|
+      @fields.each do |field|
+        len = row[field].length
+        field_lengths[field] = len if len > field_lengths[field].to_i
+      end
+    end
+    field_lengths
+  end
+
+  def filter_values(rows)
+    rows.map {|row|
+      new_row = {}
+      @fields.each {|f|
+        if @options[:filters][f]
+          new_row[f] = @options[:filters][f].is_a?(Proc) ? @options[:filters][f].call(row[f]) :
+            row[f].send(*@options[:filters][f])
+        else
+          new_row[f] = row[f]
+        end
+      }
+      new_row
+    }
+  end
+
+  def validate_values(rows)
+    rows.each {|row|
+      @fields.each {|f|
+        row[f] = row[f].to_s || ''
+      }
+    }
+  end
+
+  # Converts an array to a hash mapping a numerical index to its array value.
+  def array_to_indices_hash(array)
+    array.inject({}) {|hash,e|  hash[hash.size] = e; hash }
+  end
+  #:startdoc:
+end

data/lib/hirb/helpers/tree.rb

@@ -0,0 +1,177 @@
+# Base tree class which given an array of nodes produces different types of trees.
+# The types of trees currently are:
+# * basic:
+#    0
+#      1
+#        2
+#        3
+#      4
+# 
+# * directory:
+#    0
+#    |-- 1
+#    |   |-- 2
+#    |   `-- 3
+#    `-- 4
+# 
+# * number:
+#    1. 0
+#      1. 1
+#        1. 2
+#        2. 3
+#      2. 4 
+# 
+# Tree nodes can be given as an array of arrays or an array of hashes.
+# To render the above basic tree with an array of hashes:
+#   Hirb::Helpers::Tree.render([{:value=>0, :level=>0}, {:value=>1, :level=>1}, {:value=>2, :level=>2}, 
+#     {:value=>3, :level=>2}, {:value=>4, :level=>1}])
+# Note from the hash keys that :level refers to the depth of the tree while :value refers to the text displayed
+# for a node.
+#
+# To render the above basic tree with an array of arrays:
+#   Hirb::Helpers::Tree.render([[0,0], [1,1], [2,2], [2,3], [1,4]])
+# Note that the each array pair consists of the level and the value for the node.
+class Hirb::Helpers::Tree
+  class ParentlessNodeError < StandardError; end
+
+  class <<self
+    # Main method which renders a tree.
+    # ==== Options:
+    # [:type] Type of tree. Either :basic, :directory or :number. Default is :basic.
+    # [:validate] Boolean to validate tree. Checks to see if all nodes have parents. Raises ParentlessNodeError if
+    #             an invalid node is found. Default is false.
+    # [:indent] Number of spaces to indent between levels for basic + number trees. Default is 4.
+    # [:limit] Limits the level or depth of a tree that is displayed. Root node is level 0.
+    # [:description] Displays brief description about tree ie how many nodes it has.
+    #  Examples:
+    #     Hirb::Helpers::Tree.render([[0, 'root'], [1, 'child']], :type=>:directory)
+    def render(nodes, options={})
+      new(nodes, options).render
+    end
+  end
+
+  # :stopdoc:
+  attr_accessor :nodes
+  
+  def initialize(input_nodes, options={})
+    @options = options
+    @type = options[:type] || :basic
+    if input_nodes[0].is_a?(Array)
+      @nodes = input_nodes.map {|e| Node.new(:level=>e[0], :value=>e[1]) }
+    else
+      @nodes = input_nodes.map {|e| Node.new(e)}
+    end
+    @nodes.each_with_index {|e,i| e.merge!(:tree=>self, :index=>i)}
+    @nodes.each {|e| e[:value] = e[:value].to_s }
+    validate_nodes if options[:validate]
+    self
+  end
+
+  def render
+    body = render_tree
+    body += render_description if @options[:description]
+    body
+  end
+  
+  def render_description
+    "\n\n#{@nodes.length} #{@nodes.length == 1 ? 'node' : 'nodes'} in tree"
+  end
+
+  def render_tree
+    @indent = ' ' * (@options[:indent] || 4 )
+    @nodes = @nodes.select {|e| e[:level] <= @options[:limit] } if @options[:limit]
+    case @type.to_s
+    when 'directory'
+      render_directory
+    when 'number'
+      render_number
+    else
+      render_basic
+    end
+  end
+
+  def render_directory
+    mark_last_nodes_per_level
+    new_nodes = []
+    @nodes.each_with_index {|e, i|
+      value = ''
+      unless e.root?
+        value << e.render_parent_characters
+        value << (e[:last_node] ? "`-- " : "|-- ")
+      end
+      value << e[:value]
+      new_nodes << value
+    }
+    new_nodes.join("\n")
+  end
+  
+  def render_number
+    counter = {}
+    @nodes.each {|e|
+      parent_level_key = "#{(e.parent ||{})[:index]}.#{e[:level]}"
+      counter[parent_level_key] ||= 0
+      counter[parent_level_key] += 1
+      e[:pre_value] = "#{counter[parent_level_key]}. "
+    }
+    @nodes.map {|e| @indent * e[:level] + e[:pre_value] + e[:value]}.join("\n")
+  end
+  
+  def render_basic
+    @nodes.map {|e| @indent * e[:level] + e[:value]}.join("\n")
+  end
+  
+  def validate_nodes
+    @nodes.each do |e|
+      raise ParentlessNodeError if (e[:level] > e.previous[:level]) && (e[:level] - e.previous[:level]) > 1
+    end
+  end
+  
+  # walks tree accumulating last nodes per unique parent+level
+  def mark_last_nodes_per_level
+    @nodes.each {|e| e.delete(:last_node)}
+    last_node_hash = @nodes.inject({}) {|h,e|
+      h["#{(e.parent ||{})[:index]}.#{e[:level]}"] = e; h
+    }
+    last_node_hash.values.uniq.each {|e| e[:last_node] = true}
+  end
+  #:startdoc:
+  class Node < ::Hash #:nodoc:
+    class MissingLevelError < StandardError; end
+    class MissingValueError < StandardError; end
+    
+    def initialize(hash)
+      super
+      raise MissingLevelError unless hash.has_key?(:level)
+      raise MissingValueError unless hash.has_key?(:value)
+      replace(hash)
+    end
+
+    def parent
+      self[:tree].nodes.slice(0 .. self[:index]).reverse.detect {|e| e[:level] < self[:level]}
+    end
+
+    def next
+      self[:tree].nodes[self[:index] + 1]
+    end
+
+    def previous
+      self[:tree].nodes[self[:index] - 1]
+    end
+
+    def root?; self[:level] == 0; end
+
+    # refers to characters which connect parent nodes 
+    def render_parent_characters
+      parent_chars = []
+      get_parents_character(parent_chars)
+      parent_chars.reverse.map {|level| level + ' ' * 3 }.to_s
+    end
+
+    def get_parents_character(parent_chars)
+      if self.parent
+        parent_chars << (self.parent[:last_node] ? ' ' : '|') unless self.parent.root?
+        self.parent.get_parents_character(parent_chars)
+      end
+    end
+  end
+end