bbcloud 0.8 → 0.8.1

data/lib/bbcloud/vendor/gli-1.1.2/lib/gli.rb

@@ -0,0 +1,323 @@
+require 'gli/command_line_token.rb'
+require 'gli/command.rb'
+require 'gli/switch.rb'
+require 'gli/flag.rb'
+require 'gli/options.rb'
+require 'gli_version.rb'
+require 'support/help.rb'
+require 'support/rdoc.rb'
+require 'support/initconfig.rb'
+require 'etc'
+
+# A means to define and parse a command line interface that works as
+# Git's does, in that you specify global options, a command name, command
+# specific options, and then command arguments.
+module GLI
+  extend self
+
+  @@program_name = $0.split(/\//)[-1]
+  @@post_block = nil
+  @@pre_block = nil
+  @@error_block = nil
+  @@config_file = nil
+
+  # Reset the GLI module internal data structures; mostly for testing
+  def reset
+    switches.clear
+    flags.clear
+    commands.clear
+    @@config_file = nil
+    clear_nexts
+  end
+
+  # describe the next switch, flag, or command.  This should be a
+  # short, one-line description
+  def desc(description); @@next_desc = description; end
+
+  # Provide a longer, more detailed description.  This
+  # will be reformatted and wrapped to fit in 80 columns
+  def long_desc(long_desc); @@next_long_desc = long_desc; end
+
+  # describe the argument name of the next flag
+  def arg_name(name); @@next_arg_name = name; end
+
+  # set the default value of the next flag
+  def default_value(val); @@next_default_value = val; end
+
+  # Create a flag, which is a switch that takes an argument
+  def flag(*names)
+    flag = Flag.new([names].flatten,@@next_desc,@@next_arg_name,@@next_default_value,@@next_long_desc)
+    flags[flag.name] = flag
+    clear_nexts
+  end
+
+  # Create a switch
+  def switch(*names)
+    switch = Switch.new([names].flatten,@@next_desc,@@next_long_desc)
+    switches[switch.name] = switch
+    clear_nexts
+  end
+
+  # Sets the config file.  If not an absolute path
+  # sets the path to the user's home directory
+  def config_file(filename)
+    if filename =~ /^\//
+      @@config_file = filename
+    else
+      @@config_file = Etc.getpwuid.dir + '/' + filename
+    end
+    commands[:initconfig] = InitConfig.new(@@config_file)
+    @@config_file
+  end
+
+  # Define a command.
+  def command(*names)
+    command = Command.new([names].flatten,@@next_desc,@@next_arg_name,@@next_long_desc)
+    commands[command.name] = command
+    yield command
+    clear_nexts
+  end
+
+  # Define a block to run after command line arguments are parsed
+  # but before any command is run.  If this block raises an exception
+  # the command specified will not be executed.
+  # The block will receive the global-options,command,options, and arguments
+  # If this block evaluates to true, the program will proceed; otherwise
+  # the program will end immediately
+  def pre(&a_proc)
+    @@pre_block = a_proc
+  end
+
+  # Define a block to run after command hase been executed, only
+  # if there was not an error.
+  # The block will receive the global-options,command,options, and arguments
+  def post(&a_proc)
+    @@post_block = a_proc
+  end
+
+  # Define a block to run if an error occurs.
+  # The block will receive any Exception that was caught.
+  # It should return false to avoid the built-in error handling (which basically just
+  # prints out a message)
+  def on_error(&a_proc)
+    @@error_block = a_proc
+  end
+
+  # Runs whatever command is needed based on the arguments.
+  def run(args)
+    rdoc = RDocCommand.new
+    commands[:rdoc] = rdoc if !commands[:rdoc]
+    commands[:help] = DefaultHelpCommand.new(rdoc) if !commands[:help]
+    begin
+      config = parse_config
+      global_options,command,options,arguments = parse_options(args,config)
+      proceed = true
+      proceed = @@pre_block.call(global_options,command,options,arguments) if @@pre_block 
+      if proceed
+        command = commands[:help] if !command
+        command.execute(global_options,options,arguments)
+        @@post_block.call(global_options,command,options,arguments) if @@post_block 
+      end
+    rescue Exception => ex
+      regular_error_handling = true
+      regular_error_handling = @@error_block.call(ex) if @@error_block
+
+      if regular_error_handling
+        puts "error: #{ex.message}"
+      end
+    end
+  end
+
+  def parse_config
+    return nil if @@config_file.nil?
+    require 'yaml'
+    if File.exist?(@@config_file)
+      File.open(@@config_file) { |f| YAML::load(f) }
+    else
+      {}
+    end
+  end
+
+  def program_name(override=nil)
+    if override
+      @@program_name = override
+    end
+    @@program_name
+  end
+
+  # Returns an array of four values:
+  #  * global options (as a Hash)
+  #  * Command 
+  #  * command options (as a Hash)
+  #  * arguments (as an Array)
+  def parse_options(args,config=nil)
+    command_configs = {}
+    if config.nil?
+      config = {}
+    else
+      command_configs = config.delete(GLI::InitConfig::COMMANDS_KEY) if !config.nil?
+    end
+    global_options,command,options,arguments = parse_options_helper(args.clone,config,nil,Options.new,Array.new,command_configs)
+    flags.each { |name,flag| global_options[name] = flag.default_value if !global_options[name] }
+    command.flags.each { |name,flag| options[name] = flag.default_value if !options[name] }
+    return [global_options,command,options,arguments]
+  end
+
+  # Finds the index of the first non-flag
+  # argument or -1 if there wasn't one.
+  def find_non_flag_index(args)
+    args.each_index do |i|
+      return i if args[i] =~ /^[^\-]/;
+      return i-1 if args[i] =~ /^\-\-$/;
+    end
+    -1;
+  end
+
+  alias :d :desc
+  alias :f :flag
+  alias :s :switch
+  alias :c :command
+
+  def clear_nexts
+    @@next_desc = nil
+    @@next_arg_name = nil
+    @@next_default_value = nil
+    @@next_long_desc = nil
+  end
+
+  clear_nexts
+
+  def flags; @@flags ||= {}; end
+  def switches; @@switches ||= {}; end
+  def commands; @@commands ||= {}; end
+
+  # Recursive helper for parsing command line options
+  # [args] the arguments that have yet to be processed
+  # [global_options] the global options hash
+  # [command] the Command that has been identified (or nil if not identified yet)
+  # [command_options] options for Command
+  # [arguments] the arguments for Command
+  # [command_configs] the configuration file for all commands, used as defaults
+  #
+  # This works by finding the first non-switch/flag argument, and taking that sublist and trying to pick out
+  # flags and switches.  After this is done, one of the following is true:
+  #   * the sublist is empty - in this case, go again, as there might be more flags to parse
+  #   * the sublist has a flag left in it - unknown flag; we bail
+  #   * the sublist has a non-flag left in it - this is the command (or the start of the arguments list)
+  #
+  # This sort of does the same thing in two phases; in the first phase, the command hasn't been identified, so
+  # we are looking for global switches and flags, ending when we get the command.
+  #
+  # Once the command has been found, we start looking for command-specific flags and switches.
+  # When those have been found, we know the rest of the argument list is arguments for the command
+  def parse_options_helper(args,global_options,command,command_options,arguments,command_configs)
+    non_flag_i = find_non_flag_index(args)
+    all_flags = false
+    if non_flag_i == 0
+      # no flags
+      if !command
+        command_name = args.shift
+        command = find_command(command_name)
+        raise "Unknown command '#{command_name}'" if !command
+        return parse_options_helper(args,
+                                    global_options,
+                                    command,
+                                    default_command_options(command,command_configs),
+                                    arguments,
+                                    command_configs)
+      else
+        return global_options,command,command_options,arguments + args
+      end
+    elsif non_flag_i == -1
+      all_flags = true
+    end
+
+    try_me = args[0..non_flag_i]
+    rest = args[(non_flag_i+1)..args.length]
+    if all_flags
+      try_me = args 
+      rest = []
+    end
+
+    # Suck up whatever options we can
+    switch_hash = switches
+    flag_hash = flags
+    options = global_options
+    if command
+      switch_hash = command.switches
+      flag_hash = command.flags
+      options = command_options
+    end
+
+    switch_hash.each do |name,switch|
+      value = switch.get_value!(try_me)
+      options[name] = value if !options[name]
+    end
+
+    flag_hash.each do |name,flag|
+      value = flag.get_value!(try_me)
+      # So, there's a case where the first time we request the value for a flag,
+      # we get the default and not the user-provided value.  The next time we request
+      # it, we want to override it with the real value.
+      # HOWEVER, sometimes this happens in reverse, so we want to err on taking the
+      # user-provided, non-default value where possible.
+      if value 
+        if options[name]
+          options[name] = value if options[name] == flag.default_value
+        else
+          options[name] = value
+        end
+      end
+    end
+
+    if try_me.empty?
+      return [global_options,command,command_options,arguments] if rest.empty?
+      # If we have no more options we've parsed them all
+      # and rest may have more
+      return parse_options_helper(rest,global_options,command,command_options,arguments,command_configs)
+    else
+      if command
+        check = rest
+        check = rest + try_me if all_flags 
+        check.each() do |arg| 
+          if arg =~ /^\-\-$/
+            try_me.delete arg
+            break 
+          end
+          raise "Unknown argument #{arg}" if arg =~ /^\-/ 
+        end
+        return [global_options,command,command_options,try_me + rest]
+      else
+        # Now we have our command name
+        command_name = try_me.shift
+        raise "Unknown argument #{command_name}" if command_name =~ /^\-/
+
+        command = find_command(command_name)
+        raise "Unknown command '#{command_name}'" if !command
+
+        return parse_options_helper(rest,
+                                    global_options,
+                                    command,
+                                    default_command_options(command,command_configs),
+                                    arguments,
+                                    command_configs)
+      end
+    end
+
+  end
+
+  def default_command_options(command,command_configs)
+    options = (command_configs && command_configs[command.name.to_sym]) || {}
+  end
+
+  def find_command(name)
+    sym = name.to_sym
+    return commands[name.to_sym] if commands[sym]
+    commands.keys.each do |command_name|
+      command = commands[command_name]
+      return command if (command.aliases && command.aliases.include?(sym))
+    end
+    nil
+  end
+
+end

data/lib/bbcloud/vendor/gli-1.1.2/lib/gli_version.rb

@@ -0,0 +1,3 @@
+module GLI
+  VERSION = '1.1.2'
+end

data/lib/bbcloud/vendor/gli-1.1.2/lib/support/help.rb

@@ -0,0 +1,118 @@
+require 'gli'
+require 'gli/command'
+
+module GLI
+  class DefaultHelpCommand < Command
+    def initialize(*omit_from_list)
+      @omit_from_list = omit_from_list
+      super(:help,'Shows list of commands or help for one command','[command]')
+    end
+
+    def execute(global_options,options,arguments)
+      if arguments.empty?
+        list_global_flags
+        list_commands
+      else
+        list_one_command_help(arguments[0])
+      end
+    end
+
+    private
+
+    def list_global_flags
+      usage = "usage: #{GLI.program_name} command"
+      all_options = GLI.switches.merge(GLI.flags)
+      if !all_options.empty?
+        usage += ' [options]'
+      end
+      puts usage
+      puts
+      puts 'Options:' if !all_options.empty?
+      output_command_tokens_for_help(all_options)
+      puts if !all_options.empty?
+    end
+
+    def list_commands
+      puts 'Commands:'
+      commands_to_show = GLI.commands.reject{ |name,c| @omit_from_list.include?(c) }
+      output_command_tokens_for_help(commands_to_show,:names)
+    end
+
+    def list_one_command_help(command_name)
+      command = GLI.find_command(command_name)
+      if command
+        puts command.usage
+        description = wrap(command.description,4)
+        puts "    #{description}"
+        if command.long_description
+          puts
+          puts "    #{wrap(command.long_description,4)}"
+        end
+        all_options = command.switches.merge(command.flags)
+        if !all_options.empty?
+          puts
+          puts "Options:"
+          output_command_tokens_for_help(all_options)
+        end
+      else
+        puts "No such command #{command_name}"
+      end
+    end
+
+    def output_command_tokens_for_help(tokens,usage_name=:usage)
+      max = 0
+      tokens.values.each do |token| 
+        len = token.send(usage_name).length
+        if len > max 
+          max = len
+        end
+      end
+      names = tokens.keys.sort { |x,y| x.to_s <=> y.to_s }
+      names.each do |name|
+        token = tokens[name]
+        description = token.description || ''
+        if token.kind_of? Flag 
+          description += " (default: #{token.default_value})" if token.default_value
+        end
+        description = wrap(description,max+7)
+        printf "    %-#{max}s - %s\n",token.send(usage_name),description
+      end
+    end
+  end
+
+  private
+
+  # Wraps the line at the given column length, using the given line padding.
+  # Assumes that the first line doesn't need the padding, as its filled
+  # up with other stuff
+  def wrap(line,pad_length=0,line_length=80)
+    line_padding = sprintf("%#{pad_length}s",'')
+    words = line.split(/\s+/)
+    return line if !words || words.empty?
+    wrapped = ''
+    while wrapped.length + line_padding.length < line_length
+      wrapped += ' ' if wrapped.length > 0
+      word = words.shift
+      if (wrapped.length + line_padding.length + word.length > line_length)
+        words.unshift word
+        break;
+      end
+      wrapped += word
+      return wrapped if words.empty?
+    end
+    wrapped += "\n"
+    this_line = line_padding
+    words.each do |word|
+      if this_line.length + word.length > line_length
+        wrapped += this_line
+        wrapped += "\n"
+        this_line = line_padding + word
+      else
+        this_line += ' ' if this_line.length > line_padding.length
+        this_line += word
+      end
+    end
+    wrapped.chomp!
+    wrapped + "\n" + this_line
+  end
+end

data/lib/bbcloud/vendor/gli-1.1.2/lib/support/initconfig.rb

@@ -0,0 +1,35 @@
+require 'gli'
+require 'gli/command'
+require 'yaml'
+
+module GLI
+  class InitConfig < Command
+    COMMANDS_KEY = 'commands'
+
+    def initialize(config_file_name)
+      @filename = config_file_name
+      super(:initconfig,"Initialize the config file using current global options",nil,'Initializes a configuration file where you can set default options for command line flags, both globally and on a per-command basis.  These defaults override the built-in defaults and allow you to omit commonly-used command line flags when invoking this program')
+
+      self.desc 'force overwrite of existing config file'
+      self.switch :force
+    end
+
+    def execute(global_options,options,arguments)
+      if options[:force] || !File.exist?(@filename)
+        config = global_options
+        config[COMMANDS_KEY] = {}
+        GLI.commands.each do |name,command|
+          if (command != self) && (name != :rdoc) && (name != :help)
+            config[COMMANDS_KEY][name.to_sym] = {} if command != self
+          end
+        end
+        File.open(@filename,'w') do |file|
+          YAML.dump(config,file)
+        end
+      else
+        puts "Not overwriting existing config file #{@filename}"
+        puts 'Use --force to override'
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/gli-1.1.2/lib/support/rdoc.rb

@@ -0,0 +1,78 @@
+require 'gli'
+require 'fileutils'
+
+module GLI
+  class RDocCommand < Command
+
+    def initialize
+      super(:rdoc,'Generates RDoc for your command line interface')
+    end
+
+    def execute(g,o,a)
+      File.open("#{GLI.program_name}.rdoc",'w') do |file|
+        file << "= <tt>#{GLI.program_name}</tt>\n\n"
+        file << "    "
+        file << GLI.program_name
+        file << " "
+        global_options = GLI.switches.merge(GLI.flags)
+        if (global_options && global_options.length > 0)
+          file << "[global options] "
+        end
+        file << "command_name"
+        file << " [command-specific options]"
+        file << " [--] arguments...\n\n"
+        file << "* Use the command +help+ to get a summary of commands\n"
+        file << "* Use the command <tt>help command_name</tt> to get a help for +command_name+\n"
+        file << "* Use <tt>--</tt> to stop command line argument processing; useful if your arguments have dashes in them\n"
+        file << "\n"
+        if (global_options && global_options.length > 0)
+          file << "== Global Options\n"
+          file << "These options are available for any command and are specified before the name of the command\n\n"
+          output_flags(file,global_options)
+        end
+        file << "== Commands\n"
+        GLI.commands.values.sort.each do |command|
+          next if command == self
+          file << "[<tt>#{command.name}</tt>] #{command.description}\n"
+        end
+        file << "\n"
+
+        GLI.commands.values.sort.each do |command|
+          next if command == self
+          file << "=== <tt>#{command.name} #{command.arguments_description}</tt>\n\n"
+          file << "#{command.description}\n\n"
+          if command.aliases
+            file << "*Aliases*\n"
+            command.aliases.each do |al|
+              file << "* <tt><b>#{al}</b></tt>\n"
+            end 
+            file << "\n"
+          end
+          all_options = command.switches.merge(command.flags)
+          if (all_options && all_options.length > 0)
+            file << "#{command.long_description}\n\n"
+            file << "==== Options\n"
+            file << "These options are specified *after* the command.\n\n"
+            output_flags(file,all_options)
+          end
+        end
+      end
+    end
+
+    def output_flags(file,flags)
+      flags.values.sort.each do |flag|
+        file << "[<tt>#{flag.usage}</tt>] #{flag.description}"
+        if flag.kind_of? Flag
+          file << " <i>( default: <tt>#{flag.default_value}</tt>)</i>" if flag.default_value
+        end
+        file << "\n"
+        if flag.long_description
+          file << "\n"
+          # 12 is 4 for tt, 5 for /tt, 2 for the brackets and 1 for spacing
+          (flag.usage.length + 12).times { file << " " }
+          file << "#{flag.long_description}\n\n"
+        end
+      end
+    end
+  end
+end