bbcloud 0.6.2 → 0.7

data/lib/bbcloud/vendor/hirb/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

data/lib/bbcloud/vendor/hirb/lib/hirb/pager.rb

@@ -1,95 +0,0 @@
-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
-        rescue Errno::EPIPE
-        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 = String.slice(output, 0, @width * effective_height)
-        output.replace String.slice(output, @width * effective_height, String.size(output))
-        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.size(string_to_page) > @height * @width) : (string_to_page.count("\n") > @height)
-    end
-
-    def resize(width, height) #:nodoc:
-      @width, @height = View.determine_terminal_size(width, height)
-    end
-  end
-end

data/lib/bbcloud/vendor/hirb/lib/hirb/string.rb

@@ -1,44 +0,0 @@
-module Hirb
-  # Provides string helpers to deal with UTF-8 and ruby 1.8.x
-  module String
-    extend self
-    # :stopdoc:
-    if RUBY_VERSION < '1.9'
-      def size(string)
-        string.scan(/./).length
-      end
-
-      def ljust(string, desired_length)
-        leftover = desired_length - size(string)
-        leftover > 0 ? string + " " * leftover : string
-      end
-
-      def rjust(string, desired_length)
-        leftover = desired_length - size(string)
-        leftover > 0 ? " " * leftover + string : string
-      end
-
-      def slice(string, start, finish)
-        string.scan(/./).slice(start, finish).join('')
-      end
-    else
-      def size(string)
-        string.length
-      end
-
-      def ljust(string, desired_length)
-        string.ljust(desired_length)
-      end
-
-      def rjust(string, desired_length)
-        string.rjust(desired_length)
-      end
-
-      def slice(*args)
-        string = args.shift
-        string.slice(*args)
-      end
-    end
-    #:startdoc:
-  end
-end

data/lib/bbcloud/vendor/hirb/lib/hirb/util.rb

@@ -1,96 +0,0 @@
-module Hirb
-  # Group of handy utility functions used throughout Hirb.
-  module Util
-    extend self
-    # 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)
-      begin
-        klass = Object
-        name.split('::').each {|e|
-          klass = klass.const_get(e)
-        }
-        klass
-      rescue
-         nil
-      end
-    end
-
-    # Recursively merge hash1 with hash2.
-    def recursive_hash_merge(hash1, hash2)
-      hash1.merge(hash2) {|k,o,n| (o.is_a?(Hash)) ? recursive_hash_merge(o,n) : n}
-    end
-
-    # 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
-      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
-      if (ENV['COLUMNS'] =~ /^\d+$/) && (ENV['LINES'] =~ /^\d+$/)
-        [ENV['COLUMNS'].to_i, ENV['LINES'].to_i]
-      elsif (RUBY_PLATFORM =~ /java/ || (!STDIN.tty? && ENV['TERM'])) && command_exists?('tput')
-        [`tput cols`.to_i, `tput lines`.to_i]
-      elsif STDIN.tty? && command_exists?('stty')
-        `stty size`.scan(/\d+/).map { |s| s.to_i }.reverse
-      else
-        nil
-      end
-    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
-
-    # From Rubygems, determine a user's home.
-    def find_home
-      ['HOME', 'USERPROFILE'].each {|e| return ENV[e] if ENV[e] }
-      return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}" if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
-      File.expand_path("~")
-    rescue
-      File::ALT_SEPARATOR ? "C:/" : "/"
-    end
-  end
-end

data/lib/bbcloud/vendor/hirb/lib/hirb/version.rb

@@ -1,3 +0,0 @@
-module Hirb
-  VERSION = '0.3.4'
-end