bbcloud 0.8.1 → 0.8.2

data/lib/bbcloud/vendor/gli-1.1.2/bin/gli

@@ -1,64 +0,0 @@
-#!/usr/bin/ruby
-$: << File.expand_path(File.dirname(__FILE__) + '/../lib') 
-
-require 'gli'
-require 'support/scaffold'
-
-include GLI
-
-desc 'Be verbose'
-switch :v
-
-desc 'Show version'
-switch :version
-
-desc 'Dry run; don''t change the disk'
-switch :n
-
-desc 'Root dir of project'
-long_desc 'This is the directory where the project''s directory will be made, so if you specify a project name ''foo'' and the root dir of ''.'', the directory ''./foo'' will be created'
-default_value '.'
-flag [:r,:root]
-
-desc 'Create a new GLI-based project'
-long_desc <<EOS
-This will create a scaffold command line project that uses GLI
-for command line processing.  Specifically, this will create
-an executable ready to go, as well as a lib and test directory, all
-inside the directory named for your project
-EOS
-arg_name 'project_name [command[ command]*]'
-command [:init,:scaffold] do |c|
-
-  c.desc 'Create an ext dir'
-  c.switch [:e,:ext]
-
-  c.desc 'Do not create a test dir'
-  c.switch [:notest]
-
-  c.desc 'Overwrite/ignore existing files and directories'
-  c.switch [:force]
-
-  c.action do |g,o,args|
-    if args.length < 1
-      raise 'You must specify the name of your project'
-    end
-    Scaffold.create_scaffold(g[:r],!o[:notest],o[:e],args[0],args[1..-1],o[:force],g[:n])
-  end
-end
-
-pre do |global,command,options,args|
-  if (!command || command.name == :help) && global[:version]
-    puts "#{$0} v#{GLI::VERSION}"
-    false
-  else
-    puts "Executing #{command.name}" if global[:v]
-    true
-  end
-end
-
-post do |global,command,options,args|
-  puts "Executed #{command.name}" if global[:v]
-end
-
-run(ARGV)

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

@@ -1,45 +0,0 @@
-= <tt>gli</tt>
-
-    gli [global options] command_name [command-specific options] [--] arguments...
-
-* Use the command +help+ to get a summary of commands
-* Use the command <tt>help command_name</tt> to get a help for +command_name+
-* Use <tt>--</tt> to stop command line argument processing; useful if your arguments have dashes in them
-
-== Global Options
-These options are available for any command and are specified before the name of the command
-
-[<tt>-n</tt>] Dry run; dont change the disk
-[<tt>-r, --root=arg</tt>] Root dir of project <i>( default: <tt>.</tt>)</i>
-
-                          This is the directory where the projects directory will be made, so if you specify a project name foo and the root dir of ., the directory ./foo will be created
-
-[<tt>-v</tt>] Be verbose
-[<tt>--version</tt>] Show version
-== Commands
-[<tt>help</tt>] Shows list of commands or help for one command
-[<tt>init</tt>] Create a new GLI-based project
-
-=== <tt>help [command]</tt>
-
-Shows list of commands or help for one command
-
-=== <tt>init project_name [command[ command]*]</tt>
-
-Create a new GLI-based project
-
-*Aliases*
-* <tt><b>scaffold</b></tt>
-
-This will create a scaffold command line project that uses GLI
-for command line processing.  Specifically, this will create
-an executable ready to go, as well as a lib and test directory, all
-inside the directory named for your project
-
-
-==== Options
-These options are specified *after* the command.
-
-[<tt>-e, --ext</tt>] Create an ext dir
-[<tt>--force</tt>] Overwrite/ignore existing files and directories
-[<tt>--notest</tt>] Do not create a test dir

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

@@ -1,323 +0,0 @@
-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/command.rb

@@ -1,74 +0,0 @@
-require 'gli/command_line_token.rb'
-
-module GLI
-  # A command to be run, in context of global flags and switches
-  class Command < CommandLineToken
-
-    # Create a new command
-    #
-    # [names] the name or names of this command (symbol or Array of symbols)
-    # [description] description of this command
-    # [arguments_name] description of the arguments, or nil if this command doesn't take arguments
-    # [long_desc] a longer description of the command, possibly with multiple lines and text formatting
-    #
-    def initialize(names,description,arguments_name=nil,long_desc=nil)
-      super(names,description,long_desc)
-      @arguments_description = arguments_name || ''
-      clear_nexts
-    end
-
-    def arguments_description; @arguments_description; end
-
-    def names
-      all_forms
-    end
-
-    def usage
-      usage = name.to_s
-      usage += ' [options]' if !flags.empty? || !switches.empty?
-      usage += ' ' + @arguments_description if @arguments_description
-      usage
-    end
-
-    def flags; @flags ||= {}; end
-    def switches; @switches ||= {}; end
-
-    # describe the next switch or flag
-    def desc(description); @next_desc = description; 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
-
-    def flag(*names)
-      flag = Flag.new([names].flatten,@next_desc,@next_arg_name,@next_default_value)
-      flags[flag.name] = flag
-      clear_nexts
-    end
-
-    # Create a switch
-    def switch(*names)
-      switch = Switch.new([names].flatten,@next_desc)
-      switches[switch.name] = switch
-      clear_nexts
-    end
-
-    def action(&block)
-      @action = block
-    end
-
-    def self.name_as_string(name)
-      name.to_s
-    end
-
-    def clear_nexts
-      @next_desc = nil
-      @next_arg_name = nil
-      @next_default_value = nil
-    end
-
-    def execute(global_options,options,arguments)
-      @action.call(global_options,options,arguments)
-    end
-  end
-end