bbcloud 0.8.1 → 0.8.2

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/helpers/table/filters.rb

@@ -1,10 +0,0 @@
-class Hirb::Helpers::Table
-  # Contains filter methods used by :filters option. To define a custom filter, simply open this module and create a method
-  # that take one argument, the value you will be filtering.
-  module Filters
-    extend self
-    def comma_join(arr) #:nodoc:
-      arr.join(', ')
-    end
-  end
-end

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/helpers/table/resizer.rb

@@ -1,82 +0,0 @@
-class Hirb::Helpers::Table
-  # Resizes a table's fields to the table's max width.
-  class Resizer
-    # Modifies field_lengths to fit within width. Also enforces a table's max_fields.
-    def self.resize!(table)
-      obj = new(table)
-      obj.resize
-      obj.field_lengths
-    end
-
-    #:stopdoc:
-    attr_reader :field_lengths
-    def initialize(table)
-      @table, @width, @field_size = table, table.actual_width, table.fields.size
-      @field_lengths = table.field_lengths
-      @original_field_lengths = @field_lengths.dup
-    end
-
-    def resize
-      adjust_long_fields || default_restrict_field_lengths
-      @table.enforce_field_constraints
-      add_extra_width
-    end
-
-    # Simple algorithm which allows smaller fields to be displayed while
-    # restricting longer fields to an average_long_field
-    def adjust_long_fields
-      while (total_length = sum(@field_lengths.values)) > @width
-        average_field = total_length / @field_size.to_f
-        long_lengths = @field_lengths.values.select {|e| e > average_field }
-        return false if long_lengths.empty?
-
-        # adjusts average long field by ratio with @width
-        average_long_field = sum(long_lengths)/long_lengths.size * @width/total_length
-        @field_lengths.each {|f,length|
-          @field_lengths[f] = average_long_field if length > average_long_field
-        }
-      end
-      true
-    end
-
-    # Produces a field_lengths which meets the @width requirement
-    def default_restrict_field_lengths
-      original_total_length = sum @original_field_lengths.values
-      # set fields by their relative weight to original length
-      new_lengths = @original_field_lengths.inject({}) {|t,(k,v)|
-        t[k] = (v / original_total_length.to_f * @width).to_i; t  }
-
-      # set all fields the same if relative doesn't work
-      unless new_lengths.values.all? {|e| e > MIN_FIELD_LENGTH} && (sum(new_lengths.values) <= @width)
-        new_lengths = @field_lengths.inject({}) {|t,(k,v)| t[k] = @width / @field_size; t }
-      end
-      @field_lengths.each {|k,v| @field_lengths[k] = new_lengths[k] }
-    end
-
-    def add_extra_width
-      added_width = 0
-      extra_width = @width - sum(@field_lengths.values)
-      unmaxed_fields = @field_lengths.keys.select {|f| !remaining_width(f).zero? }
-      # order can affect which one gets the remainder so let's keep it consistent
-      unmaxed_fields = unmaxed_fields.sort_by {|e| e.to_s}
-
-      unmaxed_fields.each_with_index do |f, i|
-        extra_per_field = (extra_width - added_width) / (unmaxed_fields.size - i)
-        add_to_field = remaining_width(f) < extra_per_field ? remaining_width(f) : extra_per_field
-        added_width += add_to_field
-        @field_lengths[f] += add_to_field
-      end
-    end
-
-    def remaining_width(field)
-      (@remaining_width ||= {})[field] ||= begin
-        (@table.max_fields[field] || @original_field_lengths[field]) - @field_lengths[field]
-      end
-    end
-
-    def sum(arr)
-      arr.inject {|t,e| t += e }
-    end
-    #:startdoc:
-  end
-end

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/helpers/tree.rb

@@ -1,181 +0,0 @@
-# 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.
-    # [:multi_line_nodes] Handles multi-lined nodes by indenting their newlines. Default is false.
-    #  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' then render_directory
-    when 'number'    then render_number
-    else render_basic
-    end
-  end
-
-  def render_nodes
-    value_indent = @options[:multi_line_nodes] ? @indent : nil
-    @nodes.map {|e| yield(e) + e.value(value_indent) }.join("\n")
-  end
-
-  def render_directory
-    mark_last_nodes_per_level
-    render_nodes {|e|
-      value = ''
-      unless e.root?
-        value << e.render_parent_characters
-        value << (e[:last_node] ? "`-- " : "|-- ")
-      end
-      value
-    }
-  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]}. "
-    }
-    render_nodes {|e| @indent * e[:level] + e[:pre_value] }
-  end
-
-  def render_basic
-    render_nodes {|e| @indent * e[:level] }
-  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 value(indent=nil)
-      indent ? self[:value].gsub("\n", "\n#{indent * self[:level]}") : self[:value]
-    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 }.join('')
-    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

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/helpers/vertical_table.rb

@@ -1,37 +0,0 @@
-class Hirb::Helpers::VerticalTable < Hirb::Helpers::Table
-
-  # Renders a vertical table using the same options as Hirb::Helpers::Table.render except for the ones below
-  # and :max_fields, :vertical and :max_width which aren't used.
-  # ==== Options:
-  # [:hide_empty] Boolean which hides empty values (nil or '') from being displayed. Default is false.
-  def self.render(rows, options={})
-    new(rows, {:escape_special_chars=>false, :resize=>false}.merge(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 = Hirb::String.size @headers.values.sort_by {|e| Hirb::String.size(e) }.last
-    stars = "*" * [(longest_header + (longest_header / 2)), 3].max
-    @rows.map do |row|
-      row = "#{stars} #{i+1}. row #{stars}\n" +
-      @fields.map {|f|
-        if !@options[:hide_empty] || (@options[:hide_empty] && !row[f].empty?)
-          "#{Hirb::String.rjust(@headers[f], longest_header)}: #{row[f]}"
-        else
-          nil
-        end
-      }.compact.join("\n")
-      i+= 1
-      row
-    end
-  end
-  #:startdoc:
-end

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/import_object.rb

@@ -1,10 +0,0 @@
-module Hirb
-  module ObjectMethods
-    # Takes same options as Hirb::View.render_output.
-    def view(*args)
-      Hirb::Console.render_output(*(args.unshift(self)))
-    end
-  end
-end
-
-Object.send :include, Hirb::ObjectMethods

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/menu.rb

@@ -1,221 +0,0 @@
-module Hirb
-  # This class provides a menu using Hirb's table helpers by default to display choices.
-  # Menu choices (syntax at Hirb::Util.choose_from_array) refer to rows. However, when in
-  # two_d mode, choices refer to specific cells by appending a ':field' to a choice.
-  # A field name can be an abbreviated. Menus can also have an action mode, which turns the
-  # menu prompt into a commandline that executes the choices as arguments and uses methods as
-  # actions/commands.
-  class Menu
-    class Error < StandardError; end
-
-    # Detects valid choices and optional field/column
-    CHOSEN_REGEXP = /^(\d([^:]+)?)(?::)?(\S+)?/
-    CHOSEN_ARG = '%s'
-    DIRECTIONS = "Specify individual choices (4,7), range of choices (1-3) or all choices (*)."
-
-
-    # This method will return an array unless it's exited by simply pressing return, which returns nil.
-    # If given a block, the block will yield if and with any menu items are chosen.
-    # 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: ".
-    # [*:ask*] Always ask for input, even if there is only one choice. Default is true.
-    # [*:directions*] Display directions before prompt. Default is true.
-    # [*:readline*] Use readline to get user input if available. Input strings are added to readline history. Default is false.
-    # [*:two_d*] Turn menu into a 2 dimensional (2D) menu by allowing user to pick values from table cells. Default is false.
-    # [*:default_field*] Default field for a 2D menu. Defaults to first field in a table.
-    # [*:action*] Turn menu into an action menu by letting user pass menu choices as an argument to a method/command.
-    #             A menu choice's place amongst other arguments is preserved. Default is false.
-    # [*:multi_action*] Execute action menu multiple times iterating over the menu choices. Default is false.
-    # [*:action_object*] Object that takes method/command calls. Default is main.
-    # [*:command*] Default method/command to call when no command given.
-    # [*:reopen*] Reopens $stdin with given file or with /dev/tty when set to true. Use when
-    #             $stdin is already reading in piped data.
-    # Examples:
-    #     >> extend Hirb::Console
-    #     => self
-    #     >> menu [1,2,3], :prompt=> "So many choices, so little time: "
-    #     >> menu [{:a=>1, :b=>2}, {:a=>3, :b=>4}], :fields=>[:a,b], :two_d=>true)
-    def self.render(output, options={}, &block)
-      new(options).render(output, &block)
-    rescue Error=>e
-      $stderr.puts "Error: #{e.message}"
-    end
-
-    #:stopdoc:
-    def initialize(options={})
-      @options = {:helper_class=>Hirb::Helpers::AutoTable, :prompt=>"Choose: ", :ask=>true,
-        :directions=>true}.merge options
-      @options[:reopen] = '/dev/tty' if @options[:reopen] == true
-    end
-
-    def render(output, &block)
-      @output = Array(output)
-      return [] if @output.size.zero?
-      chosen = choose_from_menu
-      block.call(chosen) if block && chosen.size > 0
-      @options[:action] ? execute_action(chosen) : chosen
-    end
-
-    def get_input
-      prompt = pre_prompt + @options[:prompt]
-      prompt = DIRECTIONS+"\n"+prompt if @options[:directions]
-      $stdin.reopen @options[:reopen] if @options[:reopen]
-
-      if @options[:readline] && readline_loads?
-        get_readline_input(prompt)
-      else
-        print prompt
-        $stdin.gets.chomp.strip
-      end
-    end
-
-    def get_readline_input(prompt)
-      input = Readline.readline prompt
-      Readline::HISTORY << input
-      input
-    end
-
-    def pre_prompt
-      prompt = ''
-      prompt << "Default field: #{default_field}\n" if @options[:two_d] && default_field
-      prompt << "Default command: #{@options[:command]}\n" if @options[:action] && @options[:command]
-      prompt
-    end
-
-    def choose_from_menu
-      return unasked_choice 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
-
-      parse_input get_input
-    end
-
-    def unasked_choice
-      return @output unless @options[:action]
-      raise(Error, "Default command and field required for unasked action menu") unless default_field && @options[:command]
-      @new_args = [@options[:command], CHOSEN_ARG]
-      map_tokens([[@output, default_field]])
-    end
-
-    def execute_action(chosen)
-      return nil if chosen.size.zero?
-      if @options[:multi_action]
-        chosen.each {|e| invoke command, add_chosen_to_args(e) }
-      else
-        invoke command, add_chosen_to_args(chosen)
-      end
-    end
-
-    def invoke(cmd, args)
-      action_object.send(cmd, *args)
-    end
-
-    def parse_input(input)
-      if (@options[:two_d] || @options[:action])
-        tokens = input_to_tokens(input)
-        map_tokens(tokens)
-      else
-        Util.choose_from_array(@output, input)
-      end
-    end
-
-    def map_tokens(tokens)
-      if return_cell_values?
-        @output[0].is_a?(Hash) ? tokens.map {|arr,f| arr.map {|e| e[f]} }.flatten :
-          tokens.map {|arr,f|
-            arr.map {|e| e.is_a?(Array) && f.is_a?(Integer) ? e[f] : e.send(f) }
-          }.flatten
-      else
-        tokens.map {|e| e[0] }.flatten
-      end
-    end
-
-    def return_cell_values?
-      @options[:two_d]
-    end
-
-    def input_to_tokens(input)
-      @new_args = []
-      tokens = (@args = split_input_args(input)).map {|word| parse_word(word) }.compact
-      cleanup_new_args
-      tokens
-    end
-
-    def parse_word(word)
-      if word[CHOSEN_REGEXP]
-        @new_args << CHOSEN_ARG
-        field = $3 ? unalias_field($3) : default_field ||
-          raise(Error, "No default field/column found. Fields must be explicitly picked.")
-        [Util.choose_from_array(@output, word), field ]
-      else
-        @new_args << word
-        nil
-      end
-    end
-
-    def cleanup_new_args
-      if @new_args.all? {|e| e == CHOSEN_ARG }
-        @new_args = [CHOSEN_ARG]
-      else
-        i = @new_args.index(CHOSEN_ARG) || raise(Error, "No rows chosen")
-        @new_args.delete(CHOSEN_ARG)
-        @new_args.insert(i, CHOSEN_ARG)
-      end
-    end
-
-    def add_chosen_to_args(items)
-      args = @new_args.dup
-      args[args.index(CHOSEN_ARG)] = items
-      args
-    end
-
-    def command
-      @command ||= begin
-        cmd = (@new_args == [CHOSEN_ARG]) ? nil : @new_args.shift
-        cmd ||= @options[:command] || raise(Error, "No command given for action menu")
-      end
-    end
-
-    def action_object
-      @options[:action_object] || eval("self", TOPLEVEL_BINDING)
-    end
-
-    def split_input_args(input)
-      input.split(/\s+/)
-    end
-
-    def default_field
-      @default_field ||= @options[:default_field] || fields[0]
-    end
-
-    # Has to be called after displaying menu
-    def fields
-      @fields ||= @options[:fields] || (@options[:ask] && table_helper_class? && Helpers::Table.last_table ?
-        Helpers::Table.last_table.fields[1..-1] : [])
-    end
-
-    def table_helper_class?
-      @options[:helper_class].is_a?(Class) && @options[:helper_class] < Helpers::Table
-    end
-
-    def unalias_field(field)
-      fields.sort_by {|e| e.to_s }.find {|e| e.to_s[/^#{field}/] } || raise(Error, "Invalid field '#{field}'")
-    end
-
-    def readline_loads?
-      require 'readline'
-      true
-    rescue LoadError
-      false
-    end
-    #:startdoc:
-  end
-end