rhc 1.6.8 → 1.7.8

data/lib/rhc/commands/account.rb

@@ -12,59 +12,15 @@ module RHC::Commands
     def run
       user = rest_client.user
 
-      say_table nil, get_properties(user, :login, :plan_id, :consumed_gears, :max_gears) + get_properties(user.capabilities, :gear_sizes).unshift(['Server:', openshift_server]) << ['SSL Certificates Supported:', user.capabilities.private_ssl_certificates ? 'yes' : 'no'], :delete => true
-
-      if openshift_online_server?
-      else
-      end
-
-      0
-    end
-
-    summary "End the current session"
-    description <<-DESC
-      Logout ends your current session on the server and then removes
-      all of the local session files.  If you are using multiple 
-      servers and configurations this will remove all of your local
-      session files.
-
-      The --all option will terminate all authorizations on your
-      account. Any previously generated authorizations will be
-      deleted and external tools that integrate with your account
-      will no longer be able to log in.
-      DESC
-    option '--all', "Remove all authorizations on your account."
-    alias_action 'logout', :root_command => true
-    def logout
-      if options.all
-        rest_client.user # force authentication
-        say "Deleting all authorizations associated with your account ... "
-        begin
-          rest_client.delete_authorizations
-          success "done"
-        rescue RHC::Rest::AuthorizationsNotSupported
-          info "not supported"
-        end
-      elsif options.token
-        options.noprompt = true
-        say "Ending session on server ... "
-        begin
-          rest_client.delete_authorization(options.token)
-          success "deleted"
-        rescue RHC::Rest::AuthorizationsNotSupported
-          info "not supported"
-        rescue RHC::Rest::TokenExpiredOrInvalid
-          info "already closed"
-        rescue => e
-          debug_error(e)
-          warn e.message
-        end
-      end
+      say format_table \
+            nil, 
+            get_properties(user, :login, :plan_id, :consumed_gears, :max_gears).
+              concat(get_properties(user.capabilities, :gear_sizes)).
+              unshift(['Server:', openshift_server]).
+              push(['SSL Certificates Supported:', user.capabilities.private_ssl_certificates ? 'yes' : 'no']), 
+            :delete => true
 
       0
-    ensure
-      token_store.clear
-      success "All local sessions removed."
     end
   end
 end

data/lib/rhc/commands/alias.rb

@@ -3,33 +3,42 @@ require 'rhc/config'
 
 module RHC::Commands
   class Alias < Base
-    summary "Add or remove a custom domain name (alias) for the application"
-    syntax "<command> <application> <alias> [--namespace namespace]"
+    summary "Add or remove a custom domain name for an app"
+    syntax "<action>"
+    description <<-DESC
+      Each application may have one or more custom domain names (known as
+      aliases) mapped to it. You may then configure your custom DNS entry
+      CNAME to point to your OpenShift application to serve web requests
+      from that name.
+
+      Each alias may have a single SSL certificate associated with the name
+      to handle SSL traffic.  See the 'add' command for more info.
+      DESC
     default_action :help
 
     summary "Add a custom domain name for the application"
-    syntax "<application> <alias> [--namespace namespace]"
+    syntax "<application> <alias> [--namespace NAME]"
     argument :app, "Application name (required)", ["-a", "--app name"], :context => :app_context, :required => true
     argument :app_alias, "Custom domain name for the application", []
-    option ["-n", "--namespace namespace"], "Namespace of your application", :context => :namespace_context, :required => true
+    option ["-n", "--namespace NAME"], "Namespace of your application", :context => :namespace_context, :required => true
     alias_action :"app add-alias", :root_command => true, :deprecated => true
     def add(app, app_alias)
       rest_app = rest_client.find_application(options.namespace, app)
       rest_app.add_alias(app_alias)
-      results { say "Alias '#{app_alias}' has been added." } 
+      success "Alias '#{app_alias}' has been added."
       0
     end
 
     summary "Remove a custom domain name for the application"
-    syntax "<application> <alias> [--namespace namespace]"
+    syntax "<application> <alias> [--namespace NAME]"
     argument :app, "Application name (required)", ["-a", "--app name"], :context => :app_context, :required => true
     argument :app_alias, "Custom domain name for the application", []
-    option ["-n", "--namespace namespace"], "Namespace of your application", :context => :namespace_context, :required => true
+    option ["-n", "--namespace NAME"], "Namespace of your application", :context => :namespace_context, :required => true
     alias_action :"app remove-alias", :root_command => true, :deprecated => true
     def remove(app, app_alias)
       rest_app = rest_client.find_application(options.namespace, app)
       rest_app.remove_alias(app_alias)
-      results { say "Alias '#{app_alias}' has been removed." } 
+      success "Alias '#{app_alias}' has been removed."
       0
     end
 
@@ -46,13 +55,13 @@ module RHC::Commands
       Pass phrase for the certificate private key is required if the 
       provided private key is encrypted.
     DESC
-    syntax "<application> <alias> --certificate FILE --private-key FILE [--passphrase passphrase]"
+    syntax "<application> <alias> --certificate FILE --private-key FILE [--passphrase PASSPHRASE]"
     argument :app, "Application name (required)", ["-a", "--app name"], :context => :app_context, :required => true
     argument :app_alias, "Custom domain name for the application (required)", []
     option ["--certificate FILE"], "SSL certificate filepath (file in .crt or .pem format)", :required => true
     option ["--private-key FILE"], "Private key filepath for the given SSL certificate", :required => true
-    option ["--passphrase passphrase"], "Private key pass phrase, required if the private key is encripted", :required => false
-    option ["-n", "--namespace namespace"], "Namespace of your application", :context => :namespace_context, :required => true
+    option ["--passphrase PASSPHRASE"], "Private key pass phrase, required if the private key is encrypted", :required => false
+    option ["-n", "--namespace NAME"], "Namespace of your application", :context => :namespace_context, :required => true
     def update_cert(app, app_alias)
       certificate_file_path = options.certificate
       raise ArgumentError, "Certificate file not found: #{certificate_file_path}" if !File.exist?(certificate_file_path) || !File.file?(certificate_file_path)
@@ -70,7 +79,7 @@ module RHC::Commands
       rest_alias = rest_app.find_alias(app_alias)
       if rest_client.api_version_negotiated >= 1.4
         rest_alias.add_certificate(certificate_content, private_key_content, options.passphrase)
-        results { say "SSL certificate successfully added." }
+        success "SSL certificate successfully added."
         0
       else
         raise RHC::Rest::SslCertificatesNotSupported, "The server does not support SSL certificates for custom aliases."
@@ -82,14 +91,14 @@ module RHC::Commands
     argument :app, "Application name (required)", ["-a", "--app name"], :context => :app_context, :required => true
     argument :app_alias, "Custom domain name for the application (required)", []
     option ["--confirm"], "Pass to confirm deleting the application"
-    option ["-n", "--namespace namespace"], "Namespace of your application", :context => :namespace_context, :required => true
+    option ["-n", "--namespace NAME"], "Namespace of your application", :context => :namespace_context, :required => true
     def delete_cert(app, app_alias)
       rest_app = rest_client.find_application(options.namespace, app)
       rest_alias = rest_app.find_alias(app_alias)
       if rest_client.api_version_negotiated >= 1.4
         confirm_action "#{color("This is a non-reversible action! Your SSL certificate will be permanently deleted from application '#{app}'.", :yellow)}\n\nAre you sure you want to delete the SSL certificate?"
         rest_alias.delete_certificate
-        results { say "SSL certificate successfully deleted." }
+        success "SSL certificate successfully deleted."
         0
       else
         raise RHC::Rest::SslCertificatesNotSupported, "The server does not support SSL certificates for custom aliases."
@@ -99,7 +108,7 @@ module RHC::Commands
     summary "List the aliases on an application"
     syntax "<application>"
     argument :app, "Application name (required)", ["-a", "--app name"], :context => :app_context, :required => true
-    option ["-n", "--namespace namespace"], "Namespace of your application", :context => :namespace_context, :required => true
+    option ["-n", "--namespace NAME"], "Namespace of your application", :context => :namespace_context, :required => true
     def list(app)
       rest_app = rest_client.find_application(options.namespace, app)
       items = rest_app.aliases.map do |a|
@@ -108,9 +117,9 @@ module RHC::Commands
           [a.id, a.has_private_ssl_certificate? ? 'yes' : 'no', a.has_private_ssl_certificate? ? Date.parse(a.certificate_added_at) : '-']
       end
       if items.empty?
-        results { say "No aliases associated with the application #{app}." }
+        info "No aliases associated with the application #{app}."
       else
-        table(items, :header => ["Alias", "Has Certificate?", "Certificate Added"]).each { |s| say s }
+        say table(items, :header => ["Alias", "Has Certificate?", "Certificate Added"])
       end
       0
     end

data/lib/rhc/commands/app.rb

@@ -9,6 +9,7 @@ module RHC::Commands
     description "Creates and controls an OpenShift application.  To see the list of all applications use the rhc domain show command.  Note that delete is not reversible and will stop your application and then remove the application and repo from the remote server. No local changes are made."
     syntax "<action>"
     default_action :help
+    suppress_wizard
 
     summary "Create an application"
     description <<-DESC
@@ -38,19 +39,24 @@ module RHC::Commands
 
       DESC
     syntax "<name> <cartridge> [-n namespace]"
-    option ["-n", "--namespace namespace"], "Namespace for the application", :context => :namespace_context
-    option ["-g", "--gear-size size"], "Gear size controls how much memory and CPU your cartridges can use."
+    option ["-n", "--namespace NAME"], "Namespace for the application"
+    option ["-g", "--gear-size SIZE"], "Gear size controls how much memory and CPU your cartridges can use."
     option ["-s", "--scaling"], "Enable scaling for the web cartridge."
-    option ["-r", "--repo dir"], "Path to the Git repository (defaults to ./$app_name)"
+    option ["-r", "--repo DIR"], "Path to the Git repository (defaults to ./$app_name)"
     option ["--from-code URL"], "URL to a Git repository that will become the initial contents of the application"
     option ["--[no-]git"], "Skip creating the local Git repository."
     option ["--nogit"], "DEPRECATED: Skip creating the local Git repository.", :deprecated => {:key => :git, :value => false}
     option ["--[no-]dns"], "Skip waiting for the application DNS name to resolve. Must be used in combination with --no-git"
-    option ["--enable-jenkins [server_name]"], "Enable Jenkins builds for this application (will create a Jenkins application if not already available). The default name will be 'jenkins' if not specified."
-    argument :name, "Name for your application", ["-a", "--app name"]
-    argument :cartridges, "The web framework this application should use", ["-t", "--type cartridge"], :arg_type => :list
+    option ['--no-keys'], "Skip checking SSH keys during app creation", :hide => true
+    option ["--enable-jenkins [NAME]"], "Enable Jenkins builds for this application (will create a Jenkins application if not already available). The default name will be 'jenkins' if not specified."
+    argument :name, "Name for your application", ["-a", "--app NAME"], :optional => true
+    argument :cartridges, "The web framework this application should use", ["-t", "--type CARTRIDGE"], :optional => true, :arg_type => :list
     #argument :additional_cartridges, "A list of other cartridges such as databases you wish to add. Cartridges can also be added later using 'rhc cartridge add'", [], :arg_type => :list
     def create(name, cartridges)
+      check_config!
+
+      check_name!(name)
+
       cartridges = check_cartridges(cartridges, &require_one_web_cart)
 
       options.default \
@@ -59,8 +65,7 @@ module RHC::Commands
 
       raise ArgumentError, "You have named both your main application and your Jenkins application '#{name}'. In order to continue you'll need to specify a different name with --enable-jenkins or choose a different application name." if jenkins_app_name == name && enable_jenkins?
 
-      raise RHC::Rest::DomainNotFoundException.new("No domains found. Please create a domain with 'rhc domain create <namespace>' before creating applications.") if rest_client.domains.empty?
-      rest_domain = rest_client.find_domain(options.namespace)
+      rest_domain = check_domain!
       rest_app = nil
 
       cart_names = cartridges.collect do |c|
@@ -121,6 +126,9 @@ module RHC::Commands
         end if build_app_exists
       end
 
+      debug "Checking SSH keys through the wizard"
+      check_sshkeys! unless options.no_keys
+
       if options.dns
         paragraph do
           say "Waiting for your DNS name to be available ... "
@@ -139,9 +147,6 @@ module RHC::Commands
 
         if options.git
           paragraph do
-            debug "Checking SSH keys through the wizard"
-            check_sshkeys! unless options.noprompt
-
             say "Downloading the application Git repository ..."
             paragraph do
               begin
@@ -174,8 +179,8 @@ module RHC::Commands
     summary "Delete an application from the server"
     description "Deletes your application and all of its data from the server.",
                 "Use with caution as this operation is permanent."
-    syntax "<app> [--namespace namespace]"
-    option ["-n", "--namespace namespace"], "Namespace your application belongs to", :context => :namespace_context, :required => true
+    syntax "<app> [--namespace NAME]"
+    option ["-n", "--namespace NAME"], "Namespace your application belongs to", :context => :namespace_context, :required => true
     option ["-b", "--bypass"], "DEPRECATED Please use '--confirm'", :deprecated => {:key => :confirm, :value => true}
     option ["--confirm"], "Pass to confirm deleting the application"
     argument :app, "The application you wish to delete", ["-a", "--app name"], :context => :app_context
@@ -193,9 +198,9 @@ module RHC::Commands
     end
 
     summary "Start the application"
-    syntax "<app> [--namespace namespace] [--app app]"
-    argument :app, "The name of the application you are starting", ["-a", "--app app"], :context => :app_context
-    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    syntax "<app> [--namespace NAME] [--app NAME]"
+    argument :app, "The name of the application you are starting", ["-a", "--app NAME"], :context => :app_context
+    option ["-n", "--namespace NAME"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
     def start(app)
       app_action app, :start
 
@@ -204,9 +209,9 @@ module RHC::Commands
     end
 
     summary "Stop the application"
-    syntax "<app> [--namespace namespace] [--app app]"
-    argument :app, "The name of the application you are stopping", ["-a", "--app app"], :context => :app_context
-    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    syntax "<app> [--namespace NAME] [--app NAME]"
+    argument :app, "The name of the application you are stopping", ["-a", "--app NAME"], :context => :app_context
+    option ["-n", "--namespace NAME"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
     def stop(app)
       app_action app, :stop
 
@@ -215,9 +220,9 @@ module RHC::Commands
     end
 
     summary "Stops all application processes"
-    syntax "<app> [--namespace namespace] [--app app]"
-    argument :app, "The name of the application you are stopping", ["-a", "--app app"], :context => :app_context
-    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    syntax "<app> [--namespace NAME] [--app NAME]"
+    argument :app, "The name of the application you are stopping", ["-a", "--app NAME"], :context => :app_context
+    option ["-n", "--namespace NAME"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
     def force_stop(app)
       app_action app, :stop, true
 
@@ -226,9 +231,9 @@ module RHC::Commands
     end
 
     summary "Restart the application"
-    syntax "<app> [--namespace namespace] [--app app]"
-    argument :app, "The name of the application you are restarting", ["-a", "--app app"], :context => :app_context
-    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    syntax "<app> [--namespace NAME] [--app NAME]"
+    argument :app, "The name of the application you are restarting", ["-a", "--app NAME"], :context => :app_context
+    option ["-n", "--namespace NAME"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
     def restart(app)
       app_action app, :restart
 
@@ -237,9 +242,9 @@ module RHC::Commands
     end
 
     summary "Reload the application's configuration"
-    syntax "<app> [--namespace namespace] [--app app]"
-    argument :app, "The name of the application you are reloading", ["-a", "--app app"], :context => :app_context
-    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    syntax "<app> [--namespace NAME] [--app NAME]"
+    argument :app, "The name of the application you are reloading", ["-a", "--app NAME"], :context => :app_context
+    option ["-n", "--namespace NAME"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
     def reload(app)
       app_action app, :reload
 
@@ -248,9 +253,9 @@ module RHC::Commands
     end
 
     summary "Clean out the application's logs and tmp directories and tidy up the git repo on the server"
-    syntax "<app> [--namespace namespace] [--app app]"
-    argument :app, "The name of the application you are tidying", ["-a", "--app app"], :context => :app_context
-    option ["-n", "--namespace namespace"], "Namespace of the application belongs to", :context => :namespace_context, :required => true
+    syntax "<app> [--namespace NAME] [--app NAME]"
+    argument :app, "The name of the application you are tidying", ["-a", "--app NAME"], :context => :app_context
+    option ["-n", "--namespace NAME"], "Namespace of the application belongs to", :context => :namespace_context, :required => true
     def tidy(app)
       app_action app, :tidy
 
@@ -259,9 +264,9 @@ module RHC::Commands
     end
 
     summary "Show information about an application"
-    syntax "<app> [--namespace namespace]"
-    argument :app, "The name of the application you are getting information on", ["-a", "--app app"], :context => :app_context
-    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    syntax "<app> [--namespace NAME]"
+    argument :app, "The name of the application you are getting information on", ["-a", "--app NAME"], :context => :app_context
+    option ["-n", "--namespace NAME"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
     option ["--state"], "Get the current state of the cartridges in this application"
     option ["--gears"], "Show the ID, state, and cartridges on each gear in this application"
     def show(app_name)
@@ -282,9 +287,9 @@ module RHC::Commands
 
     summary "SSH into the specified application"
     syntax "<app> [--ssh path_to_ssh_executable]"
-    argument :app, "The name of the application you want to SSH into", ["-a", "--app app"], :context => :app_context
+    argument :app, "The name of the application you want to SSH into", ["-a", "--app NAME"], :context => :app_context
     option ["--ssh PATH"], "Path to your SSH executable"
-    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    option ["-n", "--namespace NAME"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
     alias_action 'ssh', :root_command => true
     def ssh(app_name)
       raise ArgumentError, "No application specified" unless app_name.present?
@@ -303,9 +308,9 @@ module RHC::Commands
     end
 
     summary "DEPRECATED use 'show <app> --state' instead"
-    syntax "<app> [--namespace namespace] [--app app]"
-    argument :app, "The name of the application you are getting information on", ["-a", "--app app"], :context => :app_context
-    option ["-n", "--namespace namespace"], "Namespace of the application belongs to", :context => :namespace_context, :required => true
+    syntax "<app> [--namespace NAME] [--app NAME]"
+    argument :app, "The name of the application you are getting information on", ["-a", "--app NAME"], :context => :app_context
+    option ["-n", "--namespace NAME"], "Namespace of the application belongs to", :context => :namespace_context, :required => true
     deprecated "rhc app show --state"
     def status(app)
       # TODO: add a way to deprecate this and alias to show --apache
@@ -335,9 +340,40 @@ module RHC::Commands
       end
 
       def check_sshkeys!
+        return unless interactive?
         RHC::SSHWizard.new(rest_client, config, options).run
       end
 
+      def check_name!(name)
+        return unless name.blank?
+
+        paragraph{ say "When creating an application, you must provide a name and a cartridge from the list below:" }
+        paragraph{ list_cartridges(standalone_cartridges) }
+
+        raise ArgumentError, "Please specify the name of the application and the web cartridge to install"
+      end
+
+      def check_config!
+        return if not interactive? or (!options.clean && config.has_local_config?) or (options.server && (options.rhlogin || options.token))
+        RHC::EmbeddedWizard.new(config, options).run
+      end
+
+      def check_domain!
+        if options.namespace
+          rest_client.find_domain(options.namespace)
+        else
+          if rest_client.domains.empty?
+            raise RHC::Rest::DomainNotFoundException, "No domains found. Please create a domain with 'rhc domain create <namespace>' before creating applications." unless interactive?
+            RHC::DomainWizard.new(config, options, rest_client).run
+          end
+          domain = rest_client.domains.first
+          raise RHC::Rest::DomainNotFoundException, "No domains found. Please create a domain with 'rhc domain create <namespace>' before creating applications." unless domain
+          options.namespace = domain.id
+          domain
+        end
+      end
+
+
       def gear_groups_for_app(app_name)
         rest_client.find_application_gear_groups(options.namespace, app_name)
       end

data/lib/rhc/commands/authorization.rb

@@ -1,7 +1,7 @@
 module RHC::Commands
   class Authorization < Base
 
-    summary "Display the authorization tokens created under your account"
+    summary "Show the authorization tokens for your account"
     description <<-DESC
       Shows the full list of authorization tokens on your account. You 
       can add, edit, or delete authorizations with subcommands.
@@ -11,8 +11,9 @@ module RHC::Commands
       add an optional note to each authorization token to assist you in
       remembering what is available.
       DESC
+    alias_action 'authorizations', :root_command => true
     def run
-      rest_client.authorizations.each{ |auth| paragraph{ display_authorization(auth, options.token) } } or info "No authorizations"
+      rest_client.authorizations.each{ |auth| paragraph{ display_authorization(auth, token_for_user) } } or info "No authorizations"
 
       0
     end
@@ -21,6 +22,7 @@ module RHC::Commands
     option "--note NOTE", "A description of this authorization (optional)"
     option "--expires-in SECONDS", "The number of seconds before this authorization expires (optional)"
     summary "Add an authorization to your account"
+    syntax "--scopes SCOPES [--note NOTE] [--expires-in SECONDS]"
     description <<-DESC
       Add an authorization to your account. An authorization token grants
       access to the OpenShift REST API with a set of privleges called 'scopes'

data/lib/rhc/commands/base.rb

@@ -26,14 +26,21 @@ class RHC::Commands::Base
     # to the OpenShift API that transforms intent
     # and options, to remote calls, and then handle
     # the output (or failures) into exceptions and
-    # formatted object output.  Most interactions 
+    # formatted object output.  Most interactions
     # should be through this call pattern.
     def rest_client(opts={})
       @rest_client ||= begin
           auth = RHC::Auth::Basic.new(options)
-          auth = RHC::Auth::Token.new(options, auth, token_store)
+          auth = RHC::Auth::Token.new(options, auth, token_store) if (options.use_authorization_tokens || options.token) && !(options.rhlogin && options.password)
+          debug "Authenticating with #{auth.class}"
           client_from_options(:auth => auth)
         end
+
+        if opts[:min_api] && opts[:min_api].to_f > @rest_client.api_version_negotiated.to_f
+          raise RHC::ServerAPINotSupportedException.new(opts[:min_api], @rest_client.api_version_negotiated)
+        end
+
+      @rest_client
     end
 
     def token_store
@@ -60,12 +67,15 @@ class RHC::Commands::Base
       return if private_method_defined? method
       return if protected_method_defined? method
 
+      prefix = self.object_name
       method_name = method.to_s == 'run' ? nil : method.to_s.gsub("_", "-")
-      name = [method_name]
-      name.unshift(self.object_name).compact!
+      name = [prefix, method_name].compact
       raise InvalidCommand, "Either object_name must be set or a non default method defined" if name.empty?
+
+      aliases.each{ |a| a[:action].unshift(prefix) unless a[:root_command] } if prefix
+
       RHC::Commands.add((@options || {}).merge({
-        :name => name.join(' '),
+        :name => name,
         :class => self,
         :method => method
       }));
@@ -84,12 +94,7 @@ class RHC::Commands::Base
 
     def self.description(*args)
       o = args.join(' ')
-      indent = o.scan(/^[ \t]*(?=\S)/).min.size || 0
-      options[:description] =
-        o.gsub(/^[ \t]{#{indent}}/, '').
-          gsub(/(\b|')\s*\n(?!\s*\n)(\S)/m, '\1 \2').
-          gsub(/\n+\Z/, '').
-          gsub(/\n{3,}/, "\n\n")
+      options[:description] = o.strip_heredoc
     end
     def self.summary(value)
       options[:summary] = value
@@ -108,13 +113,17 @@ class RHC::Commands::Base
       @suppress_wizard
     end
 
+    #
+    # Provide an alias to the command.  The alias will not be shown in help, but will
+    # be available in autocompletion and at execution time.
+    #
+    # Supported options:
+    #
+    #   :deprecated - if true, a warning will be displayed when the command is executed
+    #   :root_command - if true, do not prepend the object name to the command
+    #
     def self.alias_action(action, options={})
-      # if it is a root_command we simply alias it to the passed in action
-      # if not we prepend the current resource to the action
-      # default == false
-      options[:root_command] ||= false
-      options[:action] = action
-      options[:deprecated] ||= false
+      options[:action] = action.is_a?(Array) ? action : action.to_s.split(' ')
       aliases << options
     end
 
@@ -127,10 +136,8 @@ class RHC::Commands::Base
                           }
     end
 
-    def self.argument(name, description, switches, options={})
+    def self.argument(name, description, switches=[], options={})
       arg_type = options[:arg_type]
-      raise ArgumentError("Only the last argument descriptor for an action can be a list") if arg_type == :list and list_argument_defined?
-      list_argument_defined true if arg_type == :list
 
       option_symbol = Commander::Runner.switch_to_sym(switches.last)
       args_metadata << {:name => name,
@@ -138,6 +145,7 @@ class RHC::Commands::Base
                         :switches => switches,
                         :context_helper => options[:context],
                         :option_symbol => option_symbol,
+                        :optional => options[:optional],
                         :arg_type => arg_type}
     end
 
@@ -147,22 +155,16 @@ class RHC::Commands::Base
     end
 
     private
-      def self.list_argument_defined(bool)
-        options[:list_argument_defined] = bool
-      end
-      def self.list_argument_defined?
-        options[:list_argument_defined]
-      end
       def self.options_metadata
         options[:options] ||= []
       end
       def self.args_metadata
         options[:args] ||= []
       end
-      def self.options
-        @options ||= {}
-      end
       def self.aliases
         options[:aliases] ||= []
       end
+      def self.options
+        @options ||= {}
+      end
 end