bbcloud 0.11.2 → 0.12.0

data/lib/bbcloud/vendor/gli/lib/gli/command.rb

@@ -0,0 +1,124 @@
+require 'gli/command_line_token.rb'
+require 'gli/copy_options_to_aliases.rb'
+
+module GLI
+  # A command to be run, in context of global flags and switches.  You are given an instance of this class
+  # to the block you use for GLI#command.  You then use the methods described here to describe the 
+  # command-specific command-line arguments, much as you use the methods in GLI to describe the global
+  # command-line interface
+  class Command < CommandLineToken
+    include CopyOptionsToAliases
+
+    # Create a new command
+    #
+    # +names+:: A String, Symbol, or Array of String or Symbol that represents the name(s) of this command.
+    # +description+:: short description of this command as a Strign
+    # +arguments_name+:: description of the arguments as a String, or nil if this command doesn't take arguments
+    # +long_desc+:: a longer description of the command, possibly with multiple lines and text formatting
+    # +skips_pre+:: if true, this command advertises that it doesn't want the pre block called first
+    # +skips_post+:: if true, this command advertises that it doesn't want the post block called after it
+    def initialize(names,description,arguments_name=nil,long_desc=nil,skips_pre=false,skips_post=false) # :nodoc:
+      super(names,description,long_desc)
+      @arguments_description = arguments_name || ''
+      @skips_pre = skips_pre
+      @skips_post = skips_post
+      clear_nexts
+    end
+
+    # Return the arguments description
+    def arguments_description #:nodoc:
+      @arguments_description
+    end
+
+    # If true, this command doesn't want the pre block run before it executes
+    def skips_pre #:nodoc:
+      @skips_pre
+    end
+
+    # If true, this command doesn't want the post block run before it executes
+    def skips_post #:nodoc:
+      @skips_post
+    end
+
+    # Return the Array of the command's names
+    def names #:nodoc:
+      all_forms
+    end
+
+    # Get the usage string
+    # CR: This should probably not be here
+    def usage #:nodoc:
+      usage = name.to_s
+      usage += ' [command options]' if !flags.empty? || !switches.empty?
+      usage += ' ' + @arguments_description if @arguments_description
+      usage
+    end
+
+    # Return the flags as a Hash
+    def flags #:nodoc:
+      @flags ||= {}
+    end
+    # Return the switches as a Hash
+    def switches #:nodoc:
+      @switches ||= {}
+    end
+
+    # describe the next switch or flag just as GLI#desc does.
+    def desc(description); @next_desc = description; end
+    # set the long description of this flag/switch, just as GLI#long_desc does.
+    def long_desc(long_desc); @next_long_desc = long_desc; end
+    # describe the argument name of the next flag, just as GLI#arg_name does.
+    def arg_name(name); @next_arg_name = name; end
+    # set the default value of the next flag, just as GLI#default_value does.
+    def default_value(val); @next_default_value = val; end
+
+    # Create a command-specific flag, similar to GLI#flag
+    def flag(*names)
+      names = [names].flatten
+      GLI.verify_unused(names,flags,switches,"in command #{name}")
+      flag = Flag.new(names,@next_desc,@next_arg_name,@next_default_value,@next_long_desc)
+      flags[flag.name] = flag
+      clear_nexts
+    end
+
+    # Create a command-specific switch, similar to GLI#switch
+    def switch(*names)
+      names = [names].flatten
+      GLI.verify_unused(names,flags,switches,"in command #{name}")
+      switch = Switch.new(names,@next_desc,@next_long_desc)
+      switches[switch.name] = switch
+      clear_nexts
+    end
+
+    # Define the action to take when the user executes this command
+    #
+    # +block+:: A block of code to execute.  The block will be given 3 arguments:
+    #           +global_options+:: A Hash (or Options, see GLI#use_openstruct) of the _global_ options specified
+    #                              by the user, with defaults set and config file values used (if using a config file, see
+    #                              GLI#config_file)
+    #           +options+:: A Hash (or Options, see GLI#use_openstruct) of the command-specific options specified by the 
+    #                       user, with defaults set and config file values used (if using a config file, see GLI#config_file)
+    #           +arguments+:: An Array of Strings representing the unparsed command line arguments
+    #           The block's result value is not used; raise an exception or use GLI#exit_now! if you need an early exit based
+    #           on an error condition
+    def action(&block)
+      @action = block
+    end
+
+    def self.name_as_string(name) #:nodoc:
+      name.to_s
+    end
+
+    def clear_nexts #:nodoc:
+      @next_desc = nil
+      @next_arg_name = nil
+      @next_default_value = nil
+      @next_long_desc = nil
+    end
+
+    # Executes the command
+    def execute(global_options,options,arguments) #:nodoc:
+      @action.call(global_options,options,arguments)
+    end
+  end
+end

data/lib/bbcloud/vendor/gli/lib/gli/command_line_token.rb

@@ -0,0 +1,58 @@
+module GLI
+  # Abstract base class for a logical element of a command line, mostly so that subclasses can have similar
+  # initialization and interface
+  class CommandLineToken
+    attr_reader :name #:ndoc:
+    attr_reader :aliases #:ndoc:
+    attr_reader :description #:ndoc:
+    attr_reader :long_description #:ndoc:
+
+    def initialize(names,description,long_description=nil) #:ndoc:
+      @description = description
+      @long_description = long_description
+      @name,@aliases,@names = parse_names(names)
+    end
+
+    def usage #:nodoc:
+      all_forms
+    end
+
+    # Sort based on name
+    def <=>(other)
+      self.name.to_s <=> other.name.to_s
+    end
+
+    private
+    # Returns a string of all possible forms
+    # of this flag.  Mostly intended for printing
+    # to the user.
+    def all_forms(joiner=', ')
+      forms = all_forms_a
+      forms.join(joiner)
+    end
+
+
+    # Handles dealing with the "names" param, parsing
+    # it into the primary name and aliases list
+    def parse_names(names)
+      # Allow strings; convert to symbols
+      names = [names].flatten.map { |name| name.to_sym } 
+      names_hash = Hash.new
+      names.each do |name| 
+        raise ArgumentError.new("#{name} has spaces; they are not allowed") if name.to_s =~ /\s/
+        names_hash[self.class.name_as_string(name)] = true
+      end
+      name = names.shift
+      aliases = names.length > 0 ? names : nil
+      [name,aliases,names_hash]
+    end
+
+    def all_forms_a
+      forms = [self.class.name_as_string(name)]
+      if aliases
+        forms |= aliases.collect { |one_alias| self.class.name_as_string(one_alias) }.sort { |one,two| two.length <=> one.length }
+      end
+      forms
+    end
+  end
+end

data/lib/bbcloud/vendor/gli/lib/gli/copy_options_to_aliases.rb

@@ -0,0 +1,33 @@
+module GLI
+
+  # Mixin that both GLI and Command can use to copy command-line options to the aliased versions
+  # of flags and switches
+  #
+  # includers must provide the methods +flags+ and +switches+ that return an Array of Flag or Switch, 
+  # respectively
+  module CopyOptionsToAliases # :nodoc:
+    # For each option in options, copies its value to keys for the aliases of the flags or
+    # switches in gli_like
+    #
+    # options - Hash of options parsed from command line; this is an I/O param
+    def copy_options_to_aliases(options) # :nodoc:
+      new_options = {}
+      options.each do |key,value|
+        if flags[key] && flags[key].aliases
+          copy_aliases(flags[key].aliases,new_options,value)
+        elsif switches[key] && switches[key].aliases
+          copy_aliases(switches[key].aliases,new_options,value)
+        end
+      end
+      options.merge!(new_options)
+    end
+
+    private 
+
+    def copy_aliases(aliases,new_options,value)
+      aliases.each do |alias_name|
+        new_options[alias_name] = value
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/gli/lib/gli/exceptions.rb

@@ -0,0 +1,45 @@
+module GLI
+  # Indicates that the command line invocation was bad
+  class BadCommandLine < Exception
+    def exit_code; -1; end
+  end
+
+  # Indicates the bad command line was an unknown command
+  class UnknownCommand < BadCommandLine
+  end
+
+  # Indicates the bad command line was an unknown global argument
+  class UnknownGlobalArgument < BadCommandLine
+  end
+
+  # Indicates the bad command line was an unknown command argument
+  class UnknownCommandArgument < BadCommandLine
+    attr_reader :command
+    # +message+:: the error message to show the user
+    # +command+:: the command we were using to parse command-specific options
+    def initialize(message,command)
+      super(message)
+      @command = command
+    end
+  end
+
+  # Raise this if you want to use an exit status that isn't the default
+  # provided by GLI.  Note that GLI#exit_now! might be a bit more to your liking.
+  #
+  # Example:
+  #
+  #     raise CustomExit.new("Not connected to DB",-5) unless connected?
+  #     raise CustomExit.new("Bad SQL",-6) unless valid_sql?(args[0])
+  #
+  class CustomExit < Exception
+    attr_reader :exit_code #:nodoc:
+    # Create a custom exit exception
+    #
+    # +message+:: String containing error message to show the user
+    # +exit_code+:: the exit code to use (as an Int), overridding GLI's default
+    def initialize(message,exit_code)
+      super(message)
+      @exit_code = exit_code
+    end
+  end
+end

data/lib/bbcloud/vendor/gli/lib/gli/flag.rb

@@ -0,0 +1,67 @@
+require 'gli/command_line_token.rb'
+require 'gli/switch.rb'
+
+module GLI
+  # Defines a flag, which is to say a switch that takes an argument
+  class Flag < Switch # :nodoc:
+
+    attr_accessor :default_value
+
+    def initialize(names,description,argument_name=nil,default=nil,long_desc=nil)
+      super(names,description,long_desc)
+      @argument_name = argument_name || "arg"
+      @default_value = default
+    end
+
+    def get_value!(args)
+      args.each_index() do |index|
+        arg = args[index]
+        present,matched,value = find_me(arg)
+        if present
+          args.delete_at index
+          if !value || value == ''
+            if args[index]
+              value = args[index]
+              args.delete_at index
+              return value
+            else
+              raise BadCommandLine.new("#{matched} requires an argument")
+            end
+          else
+            return value
+          end
+        end
+      end
+      return @default_value
+    end
+
+    def find_me(arg)
+      if @names[arg]
+        return [true,arg,nil] if arg.length == 2
+        # This means we matched the long-form, but there's no argument
+        raise BadCommandLine.new("#{arg} requires an argument via #{arg}=argument")
+      end
+      @names.keys.each() do |name|
+        match_string = "^#{name}=(.*)$"
+        match_data = arg.match(match_string)
+        return [true,name,$1] if match_data;
+      end
+      [false,nil,nil]
+    end
+
+    # Returns a string of all possible forms
+    # of this flag.  Mostly intended for printing
+    # to the user.
+    def all_forms(joiner=', ')
+      forms = all_forms_a
+      string = forms.join(joiner)
+      if forms[-1] =~ /^\-\-/
+        string += '='
+      else
+        string += ' '
+      end
+      string += @argument_name
+      return string
+    end
+  end
+end

data/lib/bbcloud/vendor/gli/lib/gli/options.rb

@@ -0,0 +1,19 @@
+require 'ostruct'
+
+module GLI
+  # Subclass of OpenStruct that provides hash-like methods for #[] and #[]=.  Note that is is *not* a Hash.
+  class Options < OpenStruct
+
+    # Return the value of an attribute
+    def[](k)
+      @table[k.to_sym]
+    end
+
+    # Set the value of an attribute
+    def[]=(k, v)
+      @table[k.to_sym] = v
+    end
+
+  end
+end
+

data/lib/bbcloud/vendor/gli/lib/gli/switch.rb

@@ -0,0 +1,63 @@
+require 'gli/command_line_token.rb'
+
+module GLI
+  # Defines a command line switch
+  class Switch < CommandLineToken #:nodoc:
+
+    def initialize(names,description,long_desc=nil)
+      super(names,description,long_desc)
+      @default_value = false
+    end
+
+    # Given the argument list, scans it looking for this switch
+    # returning true if it's in the argumennt list (and removing it from the argument list)
+    def get_value!(args)
+      idx = -1
+      args.each_index do |index|
+        result = find_me(args[index])
+        if result[0]
+          if result[1]
+            args[index] = result[1]
+          else
+            args.delete_at index
+          end
+          return result[0]
+        end
+      end
+      @default_value
+    end
+
+    # Used only to configure what's returned if we do not detect this switch on the command line
+    # This allows the configuration file to set a switch as always on
+    def default_value=(default)
+      @default_value = default
+    end
+
+    # Finds the switch in the given arg, returning the arg to keep.
+    # Returns an array of size 2:
+    # index 0:: true or false if the arg was found
+    # index 1:: the remaining arg to keep in the command line or nil to remove it
+    def find_me(arg)
+      if @names[arg]
+        return [true,nil]
+      end
+      @names.keys.each() do |name|
+        if name =~ /^-(\w)$/
+          match_string = "^\\-(\\w*)#{$1}(\\w*)$"
+          match_data = arg.match(match_string)
+          if match_data
+            # Note that if [1] and [2] were both empty 
+            # we'd have returned above
+            return [true, "-" + match_data[1] + match_data[2]]
+          end
+        end
+      end
+      [false]
+    end
+
+    def self.name_as_string(name)
+      string = name.to_s
+      string.length == 1 ? "-#{string}" : "--#{string}"
+    end
+  end
+end

data/lib/bbcloud/vendor/gli/lib/gli/terminal.rb

@@ -0,0 +1,79 @@
+module GLI
+  # Class to encapsulate stuff about the terminal. This is useful to application developers
+  # as a canonical means to get information about the user's current terminal configuraiton.
+  # GLI uses this to determine the number of columns to use when printing to the screen.
+  #
+  # To access it, use Terminal#instance.  This is a singleton mostly to facilitate testing, but
+  # it seems reasonable enough, since there's only one terminal in effect
+  #
+  # Example:
+  #
+  #     Terminal.instance.size[0] # => columns in the terminal
+  #     Terminal.default_size = [128,24] # => change default when we can't figure it out
+  #     raise "no ls?!?!?" unless Terminal.instance.command_exists?("ls")
+  #
+  class Terminal
+
+    @@default_size = [80,24]
+
+    # Get the default size of the terminal when we can't figure it out
+    # 
+    # Returns an array of int [cols,rows]
+    def self.default_size
+      @@default_size
+    end
+
+    # Set the default size of the terminal to use when we can't figure it out
+    #
+    # +size+:: array of two int [cols,rows]
+    def self.default_size=(size)
+      @@default_size = size
+    end
+
+    # Provide access to the shared instance.  
+    def self.instance; @@instance ||= Terminal.new; end
+
+    # Call this to cause methods to throw exceptions rather than return a sane default.  You
+    # probably don't want to call this unless you are writing tests
+    def make_unsafe!
+      @unsafe = true
+    end
+
+    # Returns true if the given command exists on this system
+    #
+    # +command+:: The command, as a String, to check for, without any path information.
+    def command_exists?(command)
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? {|dir| File.exists? File.join(dir, command) }
+    end
+
+    # Get the size of the current terminal.
+    # Ripped from hirb[https://github.com/cldwalker/hirb/blob/master/lib/hirb/util.rb]
+    #
+    # Returns an Array of size two Ints representing the terminal width and height
+    def size
+      if (ENV['COLUMNS'] =~ /^\d+$/) && (ENV['LINES'] =~ /^\d+$/)
+        [ENV['COLUMNS'].to_i, ENV['LINES'].to_i]
+      elsif (jruby? || (!STDIN.tty? && ENV['TERM'])) && command_exists?('tput')
+        [run_command('tput cols').to_i, run_command('tput lines').to_i]
+      elsif STDIN.tty? && command_exists?('stty')
+        run_command('stty size').scan(/\d+/).map { |size_element| size_element.to_i }.reverse
+      else
+        Terminal.default_size
+      end
+    rescue Exception => ex
+      raise ex if @unsafe
+      Terminal.default_size
+    end
+
+    private
+
+    # Runs a command using backticks.  Extracted to allow for testing
+    def run_command(command)
+      `#{command}`
+    end
+
+    # True if we are JRuby; exposed to allow for testing
+    def jruby?; RUBY_PLATFORM =~ /java/; end
+
+  end
+end