bbcloud 0.8.1 → 0.8.2

data/lib/bbcloud/vendor/hirb-0.3.4/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-0.3.4/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-0.3.4/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-0.3.4/lib/hirb/version.rb

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

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

@@ -1,284 +0,0 @@
-module Hirb
-  # This class is responsible for managing all view-related functionality.
-  #
-  # == Create a View
-  # Let's create a simple view for Hash objects:
-  #   $ irb -rubygems
-  #   >> require 'hirb'
-  #   =>true
-  #   >> Hirb.enable
-  #   =>nil
-  #   >> require 'yaml'
-  #   =>true
-  #
-  #   # A view method is the smallest view
-  #   >> def yaml(output); output.to_yaml; end
-  #   => nil
-  #   # Add the view
-  #   >> Hirb.add_view Hash, :method=>:yaml
-  #   => true
-  #
-  #   # Hashes now appear as yaml
-  #   >> {:a=>1, :b=>{:c=>3}}
-  #   ---
-  #   :a : 1
-  #   :b : 
-  #     :c : 3
-  #   => true
-  #
-  # Another way of creating a view is a Helper class:
-  #
-  #   # Create yaml view class
-  #   >> class Hirb::Helpers::Yaml; def self.render(output, options={}); output.to_yaml; end ;end
-  #   =>nil
-  #   # Add the view
-  #   >> Hirb.add_view Hash, :class=>Hirb::Helpers::Yaml
-  #   =>true
-  #
-  #   # Hashes appear as yaml like above ...
-  #
-  # == Configure a View
-  # To configure the above Helper class as a view, either pass Hirb.enable a hash:
-  #   # In .irbrc
-  #   require 'hirb'
-  #   # View class needs to come before enable()
-  #   class Hirb::Helpers::Yaml; def self.render(output, options={}); output.to_yaml; end ;end
-  #   Hirb.enable :output=>{"Hash"=>{:class=>"Hirb::Helpers::Yaml"}}
-  #
-  # Or create a config file at config/hirb.yml or ~/.hirb.yml:
-  #   # The config file for the yaml example would look like:
-  #   # ---
-  #   # :output :
-  #   #   Hash :
-  #   #    :class : Hirb::Helpers::Yaml
-  #
-  #   # In .irbrc
-  #   require 'hirb'
-  #   # View class needs to come before enable()
-  #   class Hirb::Helpers::Yaml; def self.render(output, options={}); output.to_yaml; end ;end
-  #   Hirb.enable
-  #
-  # For more about configuring Hirb, see the Config Files section in Hirb.
-  module View
-    DEFAULT_WIDTH = 120
-    DEFAULT_HEIGHT = 40
-    class<<self
-      attr_accessor :render_method
-      attr_reader :config
-
-      # This activates view functionality i.e. the formatter, pager and size detection. If irb exists, it overrides irb's output
-      # method with Hirb::View.view_output. When called multiple times, new configs are merged into the existing config.
-      # If using Wirble, you should call this after it. The view configuration can be specified in a hash via a config file,
-      # or as options to this method. In addition to the config keys mentioned in Hirb, options also take the following keys:
-      # ==== Options:
-      # * config_file: Name of config file(s) that are merged into existing config
-      # * output_method: Specify an object's class and instance method (separated by a period) to be realiased with
-      #   hirb's view system. The instance method should take a string to be output. Default is IRB::Irb.output_value
-      #   if using irb.
-      # Examples:
-      #   Hirb.enable
-      #   Hirb.enable :formatter=>false, :output_method=>"Mini.output"
-      def enable(options={}, &block)
-        Array(options.delete(:config_file)).each {|e|
-          @new_config_file = true
-          Hirb.config_files << e
-        }
-        enable_output_method(options.delete(:output_method))
-        merge_or_load_config options
-        resize(config[:width], config[:height])
-        @enabled = true
-      end
-
-      # Indicates if Hirb::View is enabled.
-      def enabled?
-        @enabled || false
-      end
-
-      # Disable's Hirb's output and revert's irb's output method if irb exists.
-      def disable
-        @enabled = false
-        unalias_output_method(@output_method) if @output_method
-        false
-      end
-
-      # Toggles pager on or off. The pager only works while Hirb::View is enabled.
-      def toggle_pager
-        config[:pager] = !config[:pager]
-      end
-
-      # Toggles formatter on or off.
-      def toggle_formatter
-        config[:formatter] = !config[:formatter]
-      end
-
-      # Resizes the console width and height for use with the table and pager i.e. after having resized the console window. *nix users
-      # should only have to call this method. Non-*nix users should call this method with explicit width and height. If you don't know
-      # your width and height, in irb play with "a"* width to find width and puts "a\n" * height to find height.
-      def resize(width=nil, height=nil)
-        config[:width], config[:height] = determine_terminal_size(width, height)
-        pager.resize(config[:width], config[:height])
-      end
-      
-      # This is the main method of this class. When view is enabled, this method searches for a formatter it can use for the output and if
-      # successful renders it using render_method(). The options this method takes are helper config hashes as described in 
-      # Hirb::Formatter.format_output(). Returns true if successful and false if no formatting is done or if not enabled.
-      def view_output(output, options={})
-        enabled? && config[:formatter] && render_output(output, options)
-      rescue Exception=>e
-        if config[:ignore_errors]
-          $stderr.puts "Hirb Error: #{e.message}"
-          false
-        else
-          index = (obj = e.backtrace.find {|f| f =~ /^\(eval\)/}) ? e.backtrace.index(obj) : e.backtrace.length
-          $stderr.puts "Hirb Error: #{e.message}", e.backtrace.slice(0,index).map {|e| "    " + e }
-          true
-        end
-      end
-
-      # Captures STDOUT and renders it using render_method(). The main use case is to conditionally page captured stdout.
-      def capture_and_render(&block)
-        render_method.call Util.capture_stdout(&block)
-      end
-
-      # A lambda or proc which handles the final formatted object.
-      # Although this pages/puts the object by default, it could be set to do other things
-      # i.e. write the formatted object to a file.
-      def render_method
-        @render_method ||= default_render_method
-      end
-
-      # Resets render_method back to its default.
-      def reset_render_method
-        @render_method = default_render_method
-      end
-      
-      # Current console width
-      def width
-        config && config[:width] ? config[:width] : DEFAULT_WIDTH
-      end
-
-      # Current console height
-      def height
-        config && config[:height] ? config[:height] : DEFAULT_HEIGHT
-      end
-
-      # Current formatter config, storing a hash of all static views
-      def formatter_config
-        formatter.config
-      end
-
-      # Adds a view when View is enabled. See Formatter.add_view for more details.
-      def add(klass, view_config)
-        if enabled?
-          formatter.add_view(klass, view_config)
-        else
-          puts "View must be enabled to add a view"
-        end
-      end
-
-      #:stopdoc:
-      def enable_output_method(meth)
-        if (meth ||= Object.const_defined?(:IRB) ? "IRB::Irb.output_value" : false) && !@output_method
-          @output_method = meth
-          alias_output_method(@output_method)
-        end
-      end
-
-      def unalias_output_method(output_method)
-        klass, klass_method = output_method.split(".")
-        eval %[
-          ::#{klass}.class_eval do
-            alias_method :#{klass_method}, :non_hirb_view_output
-          end
-        ]
-        @output_method = nil
-      end
-
-      def alias_output_method(output_method)
-        klass, klass_method = output_method.split(".")
-        eval %[
-          ::#{klass}.class_eval do
-            alias_method :non_hirb_view_output, :#{klass_method}
-            if '#{klass}' == "IRB::Irb"
-              def #{klass_method} #:nodoc:
-                Hirb::View.view_output(@context.last_value) || Hirb::View.page_output(@context.last_value.inspect, true) ||
-                  non_hirb_view_output
-              end
-            else
-              def #{klass_method}(output_string) #:nodoc:
-                Hirb::View.view_output(output_string) || Hirb::View.page_output(output_string.inspect, true) ||
-                  non_hirb_view_output(output_string)
-              end
-            end
-          end
-        ]
-      end
-
-      def render_output(output, options={})
-        if (formatted_output = formatter.format_output(output, options))
-          render_method.call(formatted_output)
-          true
-        else
-          false
-        end
-      end
-
-      def determine_terminal_size(width, height)
-        detected  = (width.nil? || height.nil?) ? Util.detect_terminal_size || [] : []
-        [width || detected[0] || DEFAULT_WIDTH , height || detected[1] || DEFAULT_HEIGHT]
-      end
-
-      def page_output(output, inspect_mode=false)
-        if enabled? && config[:pager] && pager.activated_by?(output, inspect_mode)
-          pager.page(output, inspect_mode)
-          true
-        else
-          false
-        end
-      end
-
-      def pager
-        @pager ||= Pager.new(config[:width], config[:height], :pager_command=>config[:pager_command])
-      end
-
-      def pager=(value); @pager = value; end
-
-      def formatter(reload=false)
-        @formatter = reload || @formatter.nil? ? Formatter.new(config[:output]) : @formatter
-      end
-
-      def formatter=(value); @formatter = value; end
-
-      def merge_or_load_config(additional_config={})
-        if @config && (@new_config_file || !additional_config.empty?)
-          Hirb.config = nil
-          load_config Util.recursive_hash_merge(@config, additional_config)
-          @new_config_file = false
-        elsif !@enabled
-          load_config(additional_config)
-        end
-      end
-
-      def load_config(additional_config={})
-        @config = Util.recursive_hash_merge default_config, additional_config
-        formatter(true)
-        true
-      end
-
-      def config_loaded?; !!@config; end
-
-      def config
-        @config
-      end
-      
-      def default_render_method
-        lambda {|output| page_output(output) || puts(output) }
-      end
-
-      def default_config
-        Util.recursive_hash_merge({:pager=>true, :formatter=>true}, Hirb.config || {})
-      end
-      #:startdoc:
-    end
-  end
-end