bbcloud 0.11.2 → 0.12.0

data/lib/bbcloud/vendor/gli/features/step_definitions/gli_init_steps.rb

@@ -0,0 +1,4 @@
+Given /^GLI's libs are in my path$/ do
+  ENV['RUBYLIB'] = GLI_LIB_PATH
+end
+

data/lib/bbcloud/vendor/gli/features/support/env.rb

@@ -0,0 +1,21 @@
+require 'aruba/cucumber'
+require 'fileutils'
+
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+GLI_LIB_PATH = File.expand_path(File.join(File.dirname(__FILE__),'..','..','lib'))
+
+GLI_GEMSET = 'gli-testing'
+TMP_PATH = 'tmp/aruba'
+
+Before do
+  # Not sure how else to get this dynamically
+  @dirs = [TMP_PATH]
+end
+
+After do |scenario|
+  ENV['RUBYLIB'] = ''
+  todo_app_dir = File.join(TMP_PATH,'todo')
+  if File.exists? todo_app_dir
+    FileUtils.rm_rf(todo_app_dir)
+  end
+end

data/lib/bbcloud/vendor/gli/gli.cheat

@@ -0,0 +1,80 @@
+gli - create command-suite apps, a la git, using this awesome Ruby DSL
+======================================================================
+
+Setup and Usage
+---------------
+
+Installation:
+$ gem install gli
+
+Show list of commands
+$ gli help [command]
+
+Show help for one command
+$ gli help init
+
+Create a new GLI-based project with the commands foo and bar
+$ gli init project_name foo bar
+
+Create a new GLI-based project with an ext directory
+$ gli init -e project_name foo bar
+
+Create a new GLI-based project without a test directory (bad!)
+$ gli init --notest project_name foo bar
+
+Create a new GLI-based project somewhere else than .
+$ gli -r /tmp init project_name foo bar
+
+Just see what GLI would create
+$ gli -n init -e project_name foo bar
+
+
+Using GLI's DSL
+---------------
+
+Create a switch (option that takes no args)
+
+  desc 'Dry-run; don't change the disk
+  switch [:n,'dry-run']
+  # Both -n and --dry-run will work
+  # Access in code via global_options[:n]
+
+Create a flag (option that takes an argument)
+
+  desc 'Location of the config file'
+  arg_name 'path_to_file'
+  default_value '~/.glirc'
+  flag [:c,:conf]
+  # Both -c and --conf work, if this flag is omitted
+  # then the default of ~/.glirc is avaialble to the code
+  # Access in code via global_options[:c] (or :conf)
+
+Create a command
+
+  desc 'Get the list of open tickets'
+  command [:tickets] do |c|
+    c.desc 'Only assigned to me'
+    c.switch [:m,:me]
+
+    c.desc 'Show only tickets for one project'
+    c.flag [:p,:project,'only-project']
+
+    c.action do |global_options,options,args|
+      # global_options has the global options as a hash
+      # options are the command specific ones (e.g. options[:p])
+      # args are the command line arguments that weren't parsed
+      # raise an exception or exit_now! if things go wrong
+    end
+  end
+
+Set up stuff ahead of time
+
+  pre do |global_options,command,options,args|
+    return true if things_are_ok
+    return false if we_should_abort_the_command
+  end
+
+Use GLI
+
+  exit run(ARGV)
+  # run returns a suitable exit status

data/lib/bbcloud/vendor/gli/gli.gemspec

@@ -0,0 +1,46 @@
+# Make sure we get the gli that's local
+require File.join([File.dirname(__FILE__),'lib','gli_version.rb'])
+
+spec = Gem::Specification.new do |s| 
+  s.name = 'gli'
+  s.version = GLI::VERSION
+  s.author = 'David Copeland'
+  s.email = 'davidcopeland@naildrivin5.com'
+  s.homepage = 'http://davetron5000.github.com/gli'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'A Git Like Interface for building command line apps'
+  s.description = 'An application and API for describing command line interfaces that can be used to quickly create a shell for executing command-line tasks.  The command line user interface is similar to Git''s, in that it takes global options, a command, command-specific options, and arguments'
+  s.files = %w(
+lib/gli/command.rb
+lib/gli/command_line_token.rb
+lib/gli/copy_options_to_aliases.rb
+lib/gli/flag.rb
+lib/gli/switch.rb
+lib/gli/options.rb
+lib/gli/exceptions.rb
+lib/gli/terminal.rb
+lib/gli.rb
+lib/gli_version.rb
+lib/support/help.rb
+lib/support/rdoc.rb
+lib/support/scaffold.rb
+lib/support/initconfig.rb
+bin/gli
+  )
+  s.require_paths << 'lib'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.rdoc', 'gli.rdoc']
+  s.rdoc_options << '--title' << 'Git Like Interface' << '--main' << 'README.rdoc' << '-R'
+  s.bindir = 'bin'
+  s.executables << 'gli'
+  s.rubyforge_project = 'gli'
+  s.add_development_dependency('rake', '~> 0.8.0')
+  s.add_development_dependency('rdoc', '~> 2.4.0')
+  s.add_development_dependency('sdoc', '~> 0.2.0')
+  s.add_development_dependency('reek', '~> 1.2.0')
+  s.add_development_dependency('roodi', '~> 2.1.0')
+  s.add_development_dependency('grancher', '~> 0.1.5')
+  s.add_development_dependency('rainbow', '~> 1.1.1')
+  s.add_development_dependency('aruba', '~> 0.3.6')
+end
+

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

@@ -0,0 +1,51 @@
+= <tt>gli</tt>
+
+gli allows you to create the scaffolding for a GLI-powered application
+    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
+== 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
+
+Gets help for the application or its commands.  Can also list the commands in a way helpful to creating a bash-style completion function
+
+==== Options
+These options are specified *after* the command.
+
+[<tt>-c, --completion</tt>] List all commands one line at a time, for use with shell completion ([command] argument is partial command to match)
+=== <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/lib/gli.rb

@@ -0,0 +1,560 @@
+require 'gli/command.rb'
+require 'gli/command_line_token.rb'
+require 'gli/copy_options_to_aliases.rb'
+require 'gli/exceptions.rb'
+require 'gli/flag.rb'
+require 'gli/options.rb'
+require 'gli/switch.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
+  include CopyOptionsToAliases
+
+  @@program_name = $0.split(/\//)[-1]
+  @@post_block = nil
+  @@pre_block = nil
+  @@error_block = nil
+  @@config_file = nil
+  @@use_openstruct = false
+  @@version = nil
+  @@stderr = $stderr
+  @@program_desc = nil
+  @@skips_pre = false
+  @@skips_post = false
+
+  # Override the device of stderr; exposed only for testing
+  def error_device=(e) #:nodoc:
+    @@stderr = e
+  end
+
+  # Reset the GLI module internal data structures; mostly useful for testing
+  def reset # :nodoc:
+    switches.clear
+    flags.clear
+    commands.clear
+    @@version = nil
+    @@config_file = nil
+    @@use_openstruct = false
+    @@prog_desc = nil
+    clear_nexts
+  end
+
+  # Describe the next switch, flag, or command.  This should be a
+  # short, one-line description
+  #
+  # +description+:: A String of the short descripiton of the switch, flag, or command following
+  def desc(description); @@next_desc = description; end
+
+  # Describe the overall application/programm.  This should be a one-sentence summary
+  # of what your program does that will appear in the help output.
+  #
+  # +description+:: A String of the short description of your program's purpose
+  def program_desc(description=nil) 
+    if description
+      @@program_desc = description
+    end
+    @@program_desc
+  end
+
+  # Use this if the following command should not have the pre block executed.
+  # By default, the pre block is executed before each command and can result in
+  # aborting the call.  Using this will avoid that behavior for the following command
+  def skips_pre
+    @@skips_pre = true
+  end
+
+  # Use this if the following command should not have the post block executed.
+  # By default, the post block is executed after each command.
+  # Using this will avoid that behavior for the following command
+  def skips_post
+    @@skips_post = true
+  end
+
+  # Provide a longer, more detailed description.  This
+  # will be reformatted and wrapped to fit in the terminal's columns
+  #
+  # +long_desc+:: A String that is s longer description of the switch, flag, or command following.
+  def long_desc(long_desc); @@next_long_desc = long_desc; end
+
+  # Describe the argument name of the next flag.  It's important to keep
+  # this VERY short and, ideally, without any spaces (see Example).
+  #
+  # +name+:: A String that *briefly* describes the argument given to the following command or flag.
+  #
+  # Example:
+  #     desc 'Set the filename'
+  #     arg_name 'file_name'
+  #     flag [:f,:filename]
+  #
+  # Produces:
+  #     -f, --filename=file_name      Set the filename
+  def arg_name(name); @@next_arg_name = name; end
+
+  # set the default value of the next flag
+  #
+  # +val+:: A String reprensenting the default value to be used for the following flag if the user doesn't specify one
+  #         and, when using a config file, the config also doesn't specify one
+  def default_value(val); @@next_default_value = val; end
+
+  # Create a flag, which is a switch that takes an argument
+  #
+  # +names+:: a String or Symbol, or an Array of String or Symbol that represent all the different names
+  #           and aliases for this flag.
+  #
+  # Example:
+  #
+  #     desc 'Set the filename'
+  #     flag [:f,:filename,'file-name']
+  #
+  # Produces:
+  #
+  #     -f, --filename, --file-name=arg     Set the filename
+  def flag(*names)
+    names = [names].flatten
+    verify_unused(names,flags,switches,"in global options")
+    flag = Flag.new(names,@@next_desc,@@next_arg_name,@@next_default_value,@@next_long_desc)
+    flags[flag.name] = flag
+    clear_nexts
+  end
+
+  # Create a switch, which is a command line flag that takes no arguments (thus, it _switches_ something on)
+  #
+  # +names+:: a String or Symbol, or an Array of String or Symbol that represent all the different names
+  #           and aliases for this switch.
+  def switch(*names)
+    names = [names].flatten
+    verify_unused(names,flags,switches,"in global options")
+    switch = Switch.new(names,@@next_desc,@@next_long_desc)
+    switches[switch.name] = switch
+    clear_nexts
+  end
+
+  # Sets that this app uses a config file as well as the name of the config file.  
+  #
+  # +filename+:: A String representing the path to the file to use for the config file.  If it's an absolute
+  #              path, this is treated as the path to the file.  If it's *not*, it's treated as relative to the user's home
+  #              directory as produced by <code>Etc.getpwuid.dir</code>.
+  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 new command.  This takes a block that will be given an instance of the Command that was created.
+  # You then may call methods on this object to define aspects of that Command.
+  #
+  # +names+:: a String or Symbol, or an Array of String or Symbol that represent all the different names and aliases for this command.
+  #
+  def command(*names)
+    command = Command.new([names].flatten,@@next_desc,@@next_arg_name,@@next_long_desc,@@skips_pre,@@skips_post)
+    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 the command was executed, <b>only
+  # if there was not an error</b>.
+  # 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 evaluate to false to avoid the built-in error handling (which basically just
+  # prints out a message). GLI uses a variety of exceptions that you can use to find out what 
+  # errors might've occurred during command-line parsing:
+  # * GLI::CustomExit
+  # * GLI::UnknownCommandArgument
+  # * GLI::UnknownGlobalArgument
+  # * GLI::UnknownCommand
+  # * GLI::BadCommandLine
+  def on_error(&a_proc)
+    @@error_block = a_proc
+  end
+
+  # Indicate the version of your application
+  #
+  # +version+:: String containing the version of your application.  
+  def version(version)
+    @@version = version
+  end
+
+  # Call this with +true+ will cause the +global_options+ and
+  # +options+ passed to your code to be wrapped in
+  # Options, which is a subclass of +OpenStruct+ that adds
+  # <tt>[]</tt> and <tt>[]=</tt> methods.
+  #
+  # +use_openstruct+:: a Boolean indicating if we should use OpenStruct instead of Hashes
+  def use_openstruct(use_openstruct)
+    @@use_openstruct = use_openstruct
+  end
+
+  # Runs whatever command is needed based on the arguments. 
+  #
+  # +args+:: the command line ARGV array
+  #
+  # Returns a number that would be a reasonable exit code
+  def run(args) #:nodoc:
+    rdoc = RDocCommand.new
+    commands[:rdoc] = rdoc if !commands[:rdoc]
+    commands[:help] = DefaultHelpCommand.new(@@version,rdoc) if !commands[:help]
+    exit_code = 0
+    begin
+      config = parse_config
+      override_defaults_based_on_config(config)
+      global_options,command,options,arguments = parse_options(args)
+      copy_options_to_aliased_versions(global_options,command,options)
+      global_options = convert_to_openstruct?(global_options)
+      options = convert_to_openstruct?(options)
+      if proceed?(global_options,command,options,arguments)
+        command = commands[:help] if !command
+        command.execute(global_options,options,arguments)
+        if !command.skips_post && @@post_block
+          @@post_block.call(global_options,command,options,arguments)
+        end
+      end
+    rescue Exception => ex
+
+      @@stderr.puts error_message(ex) if regular_error_handling?(ex)
+
+      exit_code = if ex.respond_to? :exit_code
+        ex.exit_code
+      else
+        -2
+      end
+      raise ex if ENV['GLI_DEBUG'] == 'true'
+    end
+    exit_code
+  end
+
+  # True if we should proceed with executing the command; this calls
+  # the pre block if it's defined
+  def proceed?(global_options,command,options,arguments) #:nodoc:
+    if command && command.skips_pre
+      true
+    elsif @@pre_block 
+      @@pre_block.call(global_options,command,options,arguments) 
+    else
+      true
+    end
+  end
+
+  # Returns true if we should proceed with GLI's basic error handling.
+  # This calls the error block if the user provided one
+  def regular_error_handling?(ex) #:nodoc:
+    if @@error_block
+      @@error_block.call(ex)
+    else
+      true
+    end
+  end
+
+  # Returns a String of the error message to show the user
+  # +ex+:: The exception we caught that launched the error handling routines
+  def error_message(ex) #:nodoc:
+    msg = "error: #{ex.message}"
+    case ex
+    when UnknownCommand
+      msg += ". Use '#{program_name} help' for a list of commands"
+    when UnknownCommandArgument
+      msg += ". Use '#{program_name} help #{ex.command.name}' for a list of command options"
+    when UnknownGlobalArgument
+      msg += ". Use '#{program_name} help' for a list of global options"
+    end
+  end
+
+  # Simpler means of exiting with a custom exit code.  This will 
+  # raise a CustomExit with the given message and exit code, which will ultimatley
+  # cause your application to exit with the given exit_code as its exit status
+  def exit_now!(message,exit_code)
+    raise CustomExit.new(message,exit_code)
+  end
+
+  # Set or get the name of the program, if you don't want the default (which is
+  # the name of the command line program).  This
+  # is only used currently in the help and rdoc commands.
+  #
+  # +override+:: A String that represents the name of the program to use, other than the default.
+  #
+  # Returns the current program name, as a String
+  def program_name(override=nil)
+    if override
+      @@program_name = override
+    end
+    @@program_name
+  end
+
+  alias :d :desc
+  alias :f :flag
+  alias :s :switch
+  alias :c :command
+
+  # Possibly returns a copy of the passed-in Hash as an instance of GLI::Option.
+  # By default, it will *not*. However by putting <tt>use_openstruct true</tt>
+  # in your CLI definition, it will
+  def convert_to_openstruct?(options) # :nodoc:
+    @@use_openstruct ? Options.new(options) : options
+  end
+
+  # Copies all options in both global_options and options to keys for the aliases of those flags.
+  # For example, if a flag works with either -f or --flag, this will copy the value from [:f] to [:flag]
+  # to allow the user to access the options by any alias
+  def copy_options_to_aliased_versions(global_options,command,options) # :nodoc:
+    copy_options_to_aliases(global_options)
+    command.copy_options_to_aliases(options)
+  end
+
+  def parse_config # :nodoc:
+    return nil if @@config_file.nil?
+    require 'yaml'
+    if File.exist?(@@config_file)
+      File.open(@@config_file) { |file| YAML::load(file) }
+    else
+      {}
+    end
+  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) # :nodoc:
+    global_options,command,options,arguments = parse_options_helper(args.clone,Hash.new,nil,Hash.new,Array.new)
+    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) # :nodoc:
+    args.each_with_index do |item,index|
+      return index if item =~ /^[^\-]/
+      return index-1 if item =~ /^\-\-$/
+    end
+    -1
+  end
+
+  def flag_switch_index(args)
+    args.each_with_index do |item,index|
+      return index if item =~ /^[\-]/
+    end
+    -1
+  end
+
+  def clear_nexts # :nodoc:
+    @@next_desc = nil
+    @@next_arg_name = nil
+    @@next_default_value = nil
+    @@next_long_desc = nil
+    @@skips_pre = false
+    @@skips_post = false
+  end
+
+  clear_nexts
+
+  def flags # :nodoc:
+    @@flags ||= {}
+  end
+  def switches # :nodoc:
+    @@switches ||= {}
+  end
+  def commands # :nodoc:
+    @@commands ||= {}
+  end
+
+  # Recursive helper for parsing command line options
+  # <code>args</code>:: the arguments that have yet to be processed
+  # <code>global_options</code>:: the global options hash
+  # <code>command</code>:: the Command that has been identified (or nil if not identified yet)
+  # <code>command_options</code>:: options for Command
+  # <code>arguments</code>:: the arguments for Command
+  #
+  # 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) # :nodoc:
+    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 UnknownCommand.new("Unknown command '#{command_name}'") if !command
+        return parse_options_helper(args,
+                                    global_options,
+                                    command,
+                                    Hash.new,
+                                    arguments)
+      elsif((index = flag_switch_index(args)) >= 0)
+        try_me = args[0..index-1]
+        rest = args[index..args.length]
+        new_args = rest + try_me
+        return parse_options_helper(new_args,
+                                    global_options,
+                                    command,
+                                    Hash.new,
+                                    arguments)
+      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)
+    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 UnknownCommandArgument.new("Unknown option #{arg}",command) 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 UnknownGlobalArgument.new("Unknown option #{command_name}") if command_name =~ /^\-/
+
+        command = find_command(command_name)
+        raise UnknownCommand.new("Unknown command '#{command_name}'") if !command
+
+        return parse_options_helper(rest,
+                                    global_options,
+                                    command,
+                                    Hash.new,
+                                    arguments)
+      end
+    end
+  end
+
+  def find_command(name) # :nodoc:
+    sym = name.to_sym
+    return commands[name.to_sym] if commands[sym]
+    commands.each do |command_name,command|
+      return command if (command.aliases && command.aliases.include?(sym))
+    end
+    nil
+  end
+
+  # Checks that the names passed in have not been used in another flag or option
+  def verify_unused(names,flags,switches,context) # :nodoc:
+    names.each do |name|
+      verify_unused_in_option(name,flags,"flag",context)
+      verify_unused_in_option(name,switches,"switch",context)
+    end
+  end
+
+  private
+
+  def verify_unused_in_option(name,option_like,type,context) # :nodoc:
+    raise ArgumentError.new("#{name} has already been specified as a #{type} #{context}") if option_like[name]
+    option_like.each do |one_option_name,one_option|
+      if one_option.aliases
+        raise ArgumentError.new("#{name} has already been specified as an alias of #{type} #{one_option_name} #{context}") if one_option.aliases.include? name
+      end
+    end
+  end
+
+  # Sets the default values for flags based on the configuration
+  def override_defaults_based_on_config(config)
+    config ||= {}
+    config['commands'] ||= {}
+
+    override_default(flags,config)
+    override_default(switches,config)
+
+    commands.each do |command_name,command|
+      command_config = config['commands'][command_name] || {}
+
+      override_default(command.flags,command_config)
+      override_default(command.switches,command_config)
+    end
+  end
+
+  def override_default(tokens,config)
+    tokens.each do |name,token|
+      token.default_value=config[name] if config[name]
+    end
+  end
+
+end