hirb 0.1.2 → 0.2.2

data/lib/hirb/helpers.rb

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

data/lib/hirb/helpers/active_record_table.rb

@@ -8,10 +8,19 @@ class Hirb::Helpers::ActiveRecordTable < Hirb::Helpers::ObjectTable
     rows = [rows] unless rows.is_a?(Array)
     options[:fields] ||= 
       begin
-        fields = rows.first.attribute_names
-        fields.unshift(fields.delete('id')) if fields.include?('id')
+        fields = rows.first.class.column_names
         fields.map {|e| e.to_sym }
       end
+    if query_used_select?(rows)
+      selected_columns = rows.first.attributes.keys
+      sorted_columns = rows.first.class.column_names.dup.delete_if {|e| !selected_columns.include?(e) }
+      sorted_columns += (selected_columns - sorted_columns)
+      options[:fields] = sorted_columns.map {|e| e.to_sym}
+    end
     super(rows, options)
   end
-end
+
+  def self.query_used_select?(rows) #:nodoc:
+    rows.first.attributes.keys.sort != rows.first.class.column_names.sort
+  end
+end

data/lib/hirb/helpers/auto_table.rb

@@ -1,10 +1,11 @@
-# Attempts to autodetect the table class the output represents and delegates rendering to it.
+# 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 options[:fields]
+    elsif (output.is_a?(Array) && !(output[0].is_a?(Hash) || output[0].is_a?(Array)))
       Hirb::Helpers::ObjectTable
     else
       Hirb::Helpers::Table

data/lib/hirb/helpers/object_table.rb

@@ -2,13 +2,13 @@ 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 which are represented as columns in the table. Required option.
-  #     All method values are converted to strings via to_s.
+  #   :fields- Methods of the object to represent as columns. Defaults to [:to_s].
   def self.render(rows, options ={})
-    raise(ArgumentError, "Option 'fields' is required.") unless options[:fields]
+    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).to_s; h}
+      t << options[:fields].inject({}) {|h,f| h[f] = item.send(f); h}
     }
     super(item_hashes, options)
   end

data/lib/hirb/helpers/table.rb

@@ -1,6 +1,6 @@
 # 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 options as well as Hirb:Helpers::Table.max_width.
+# 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:
@@ -25,10 +25,10 @@
 #--
 # derived from http://gist.github.com/72234
 class Hirb::Helpers::Table
-  DEFAULT_MAX_WIDTH = 150
+  BORDER_LENGTH = 3 # " | " and "-+-" are the borders
   class TooManyFieldsForWidthError < StandardError; end
+
   class << self
-    attr_accessor :max_width
     
     # Main method which returns a formatted table.
     # ==== Options:
@@ -40,26 +40,40 @@ class Hirb::Helpers::Table
     #                  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.
+    # [:vertical] When set to true, renders a vertical table using Hirb::Helpers::VerticalTable. Default is false.
     # 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
+      options.delete(:vertical) ? Hirb::Helpers::VerticalTable.render(rows, options) : new(rows, options).render
+    rescue TooManyFieldsForWidthError
+      $stderr.puts "", "** Error: Too many fields for the current width. Configure your width " +
+        "and/or fields to avoid this error. Defaulting to a vertical table. **"
+      Hirb::Helpers::VerticalTable.render(rows, options)
     end
   end
   
   #:stopdoc:
   def initialize(rows, options={})
     @options = options
-    @fields = options[:fields] || ((rows[0].is_a?(Hash)) ? rows[0].keys.sort {|a,b| a.to_s <=> b.to_s} : 
+    @options[:filters] ||= {}
+    @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 : [])
     @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])
+    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
   
@@ -71,6 +85,8 @@ class Hirb::Helpers::Table
         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]
     validate_values(rows)
     rows
   end
@@ -79,15 +95,23 @@ class Hirb::Helpers::Table
     body = []
     unless @rows.length == 0
       setup_field_lengths
-      body += @headers ? render_header : [render_border]
+      body += render_header
       body += render_rows
-      body << render_border
+      body += render_footer
     end
     body << render_table_description
     body.join("\n")
   end
-  
+
   def render_header
+    @headers ? render_table_header : [render_border]
+  end
+
+  def render_footer
+    [render_border]
+  end
+
+  def render_table_header
     title_row = '| ' + @fields.map {|f|
       format_cell(@headers[f], @field_lengths[f])
     }.join(' | ') + ' |'
@@ -124,26 +148,53 @@ class Hirb::Helpers::Table
     if @options[:field_lengths]
       @field_lengths.merge!(@options[:field_lengths])
     else
-      table_max_width = Hirb::Helpers::Table.max_width || DEFAULT_MAX_WIDTH
-      table_max_width = @options[:max_width] if @options.has_key?(:max_width)
-      restrict_field_lengths(@field_lengths, table_max_width)
+      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 restrict_field_lengths(field_lengths, max_width)
+  def adjust_long_fields(field_lengths, max_width)
     total_length = field_lengths.values.inject {|t,n| t += n}
-    if max_width && total_length > max_width
-      min_field_length = 3
-      raise TooManyFieldsForWidthError if @fields.size > max_width.to_f / min_field_length
+    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}
-      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
-      }
+      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
 
@@ -159,6 +210,21 @@ class Hirb::Helpers::Table
     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|

data/lib/hirb/helpers/vertical_table.rb

@@ -0,0 +1,31 @@
+class Hirb::Helpers::VerticalTable < Hirb::Helpers::Table
+
+  # Renders a vertical table using the same options as Hirb::Helpers::Table.render except for :field_lengths,
+  # :vertical and :max_width which aren't used.
+  def self.render(rows, options={})
+    new(rows, options).render
+  end
+
+  #:stopdoc:
+  def setup_field_lengths
+    @field_lengths = default_field_lengths
+  end
+
+  def render_header; []; end
+  def render_footer; []; end
+
+  def render_rows
+    i = 0
+    longest_header = @headers.values.sort_by {|e| e.length}.last.length
+    stars = "*" * [(longest_header + (longest_header / 2)), 3].max
+    @rows.map do |row|
+      row = "#{stars} #{i+1}. row #{stars}\n" +
+      @fields.map {|f|
+        "#{@headers[f].rjust(longest_header)}: #{row[f]}"
+      }.join("\n")
+      i+= 1
+      row
+    end
+  #:startdoc:
+  end
+end

data/lib/hirb/menu.rb

@@ -0,0 +1,47 @@
+module Hirb
+  # This class provides a selection menu using Hirb's table helpers by default to display choices.
+  class Menu
+    # Menu which asks to select from the given array and returns the selected menu items as an array. See Hirb::Util.choose_from_array
+    # for the syntax for specifying selections. All options except for the ones below are passed to render the menu.
+    #
+    # ==== Options:
+    # [:helper_class]  Helper class to render menu. Helper class is expected to implement numbering given a :number option.
+    #                  To use a very basic menu, set this to false. Defaults to Hirb::Helpers::AutoTable.
+    # [:prompt]  String for menu prompt. Defaults to "Choose: ".
+    # [:validate_one] Validates that only one item in array is chosen and returns just that item. Default is false.
+    # [:ask] Always ask for input, even if there is only one choice. Default is true.
+    # Examples:
+    #     extend Hirb::Console
+    #     menu([1,2,3], :fields=>[:field1, :field2], :validate_one=>true)
+    #     menu([1,2,3], :helper_class=>Hirb::Helpers::Table)
+    def self.render(output, options={})
+      default_options = {:helper_class=>Hirb::Helpers::AutoTable, :prompt=>"Choose #{options[:validate_one] ? 'one' : ''}: ", :ask=>true}
+      options = default_options.merge(options)
+      output = [output] unless output.is_a?(Array)
+      chosen = choose_from_menu(output, options)
+      yield(chosen) if block_given? && chosen.is_a?(Array) && chosen.size > 0
+      chosen
+    end
+
+    def self.choose_from_menu(output, options) #:nodoc:
+      return output if output.size == 1 && !options[:ask]
+      if (helper_class = Util.any_const_get(options[:helper_class]))
+        View.render_output(output, :class=>options[:helper_class], :options=>options.merge(:number=>true))
+      else
+        output.each_with_index {|e,i| puts "#{i+1}: #{e}" }
+      end
+      print options[:prompt]
+      input = $stdin.gets.chomp.strip
+      chosen = Util.choose_from_array(output, input)
+      if options[:validate_one]
+        if chosen.size != 1
+          $stderr.puts "Choose one. You chose #{chosen.size} items."
+          return nil
+        else
+          return chosen[0]
+        end
+      end
+      chosen
+    end
+  end
+end

data/lib/hirb/pager.rb

@@ -0,0 +1,94 @@
+module Hirb
+  # This class provides class methods for paging and an object which can conditionally page given a terminal size that is exceeded.
+  class Pager
+    class<<self
+      # Pages using a configured or detected shell command.
+      def command_pager(output, options={})
+        basic_pager(output) if valid_pager_command?(options[:pager_command])
+      end
+
+      def pager_command(*commands) #:nodoc:
+        @pager_command = (!@pager_command.nil? && commands.empty?) ? @pager_command : 
+          begin
+            commands = [ENV['PAGER'], 'less', 'more', 'pager'] if commands.empty?
+            commands.compact.uniq.find {|e| Util.command_exists?(e[/\w+/]) }
+          end
+      end
+
+      # Pages with a ruby-only pager which either pages or quits.
+      def default_pager(output, options={})
+        pager = new(options[:width], options[:height])
+        while pager.activated_by?(output, options[:inspect])
+          puts pager.slice!(output, options[:inspect])
+          return unless continue_paging?
+        end
+        puts output
+        puts "=== Pager finished. ==="
+      end
+
+      #:stopdoc:
+      def valid_pager_command?(cmd)
+        cmd ? pager_command(cmd) : pager_command
+      end
+
+      private
+      def basic_pager(output)
+        pager = IO.popen(pager_command, "w")
+        begin
+          save_stdout = STDOUT.clone
+          STDOUT.reopen(pager)
+          STDOUT.puts output
+        ensure
+         STDOUT.reopen(save_stdout)
+         save_stdout.close
+         pager.close
+        end
+      end
+
+      def continue_paging?
+        puts "=== Press enter/return to continue or q to quit: ==="
+        !$stdin.gets.chomp[/q/i]
+      end
+      #:startdoc:
+    end
+
+    attr_reader :width, :height
+
+    def initialize(width, height, options={})
+      resize(width, height)
+      @pager_command = options[:pager_command] if options[:pager_command]
+    end
+
+    # Pages given string using configured pager.
+    def page(string, inspect_mode)
+      if self.class.valid_pager_command?(@pager_command)
+        self.class.command_pager(string, :pager_command=>@pager_command)
+      else
+        self.class.default_pager(string, :width=>@width, :height=>@height, :inspect=>inspect_mode)
+      end
+    end
+
+    def slice!(output, inspect_mode=false) #:nodoc:
+      effective_height = @height - 2 # takes into account pager prompt
+      if inspect_mode
+        sliced_output = output.slice(0, @width * effective_height)
+        output.replace output.slice(@width * effective_height..-1)
+        sliced_output
+      else
+        # could use output.scan(/[^\n]*\n?/) instead of split
+        sliced_output = output.split("\n").slice(0, effective_height).join("\n")
+        output.replace output.split("\n").slice(effective_height..-1).join("\n")
+        sliced_output
+      end
+    end
+
+    # Determines if string should be paged based on configured width and height.
+    def activated_by?(string_to_page, inspect_mode=false)
+      inspect_mode ? (string_to_page.size > @height * @width) : (string_to_page.count("\n") > @height)
+    end
+
+    def resize(width, height) #:nodoc:
+      @width, @height = Hirb::View.determine_terminal_size(width, height)
+    end
+  end
+end

data/lib/hirb/util.rb

@@ -1,7 +1,8 @@
 module Hirb
+  # Group of handy utility functions used throughout Hirb.
   module Util
     extend self
-    # Returns a constant like const_get() no matter what namespace it's nested in.
+    # Returns a constant like Module#const_get no matter what namespace it's nested in.
     # Returns nil if the constant is not found.
     def any_const_get(name)
       return name if name.is_a?(Module)
@@ -21,9 +22,59 @@ module Hirb
       hash1.merge(hash2) {|k,o,n| (o.is_a?(Hash)) ? recursive_hash_merge(o,n) : n}
     end
 
-    # from Rails ActiveSupport
+    # From Rails ActiveSupport, converting undescored lowercase to camel uppercase.
     def camelize(string)
       string.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
     end
+
+    # Used by Hirb::Menu to select items from an array. Array counting starts at 1. Ranges of numbers are specified with a '-' or '..'.
+    # Multiple ranges can be comma delimited. Anything that isn't a valid number is ignored. All elements can be returned with a '*'.
+    # Examples:
+    #    1-3,5-6 -> [1,2,3,5,6]
+    #    *   -> all elements in array
+    #    ''  -> [] 
+    def choose_from_array(array, input, options={})
+      options = {:splitter=>","}.merge(options)
+      return array if input.strip == '*'
+      result = []
+      input.split(options[:splitter]).each do |e|
+        if e =~ /-|\.\./
+          min,max = e.split(/-|\.\./)
+          slice_min = min.to_i - 1
+          result.push(*array.slice(slice_min, max.to_i - min.to_i + 1))
+        elsif e =~ /\s*(\d+)\s*/
+          index = $1.to_i - 1
+          next if index < 0
+          result.push(array[index]) if array[index]
+        end
+      end
+      return result
+    end
+
+    # Determines if a shell command exists by searching for it in ENV['PATH'].
+    def command_exists?(command)
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? {|d| File.exists? File.join(d, command) }
+    end
+
+    # Returns [width, height] of terminal when detected, nil if not detected.
+    # Think of this as a simpler version of Highline's Highline::SystemExtensions.terminal_size()
+    def detect_terminal_size
+      (ENV['COLUMNS'] =~ /^\d+$/) && (ENV['LINES'] =~ /^\d+$/) ? [ENV['COLUMNS'].to_i, ENV['LINES'].to_i] :
+        ( command_exists?('stty') ? `stty size`.scan(/\d+/).map { |s| s.to_i }.reverse : nil )
+    rescue
+      nil
+    end
+
+    # Captures STDOUT of anything run in its block and returns it as string.
+    def capture_stdout(&block)
+      original_stdout = $stdout
+      $stdout = fake = StringIO.new
+      begin
+        yield
+      ensure
+        $stdout = original_stdout
+      end
+      fake.string
+    end
   end
 end