rhc 0.97.17 → 0.98.16

data/lib/rhc/commands.rb

@@ -3,100 +3,6 @@ require 'rhc/helpers'
 
 module RHC
   module Commands
-    class CommandHelpBindings
-      def initialize(command, instance_commands, global_options)
-        @command = command
-        @actions = instance_commands.collect do |ic|
-          m = /^#{command.name} ([^ ]+)/.match(ic[0])
-          # if we have a match and it is not an alias then we can use it
-          m and ic[0] == ic[1].name ? {:name => m[1], :summary => ic[1].summary || ""} : nil
-        end
-        @actions.compact!
-        @global_options = global_options
-      end
-    end
-    class Runner < Commander::Runner
-      # regex fix from git - match on word boundries
-      def valid_command_names_from *args
-        arg_string = args.delete_if { |value| value =~ /^-/ }.join ' '
-        commands.keys.find_all { |name| name if /^#{name}\b/.match arg_string }
-      end
-
-      # override so we can do our own error handling
-      def run!
-        trace = false
-        require_program :version, :description
-        trap('INT') { abort program(:int_message) } if program(:int_message)
-        trap('INT') { program(:int_block).call } if program(:int_block)
-        global_option('-h', '--help', 'Display help documentation') do
-          args = @args - %w[-h --help]
-          command(:help).run(*args)
-          return
-        end
-        global_option('-v', '--version', 'Display version information') { say version; return }
-        global_option('-t', '--trace', 'Display backtrace when an error occurs') { trace = true }
-        parse_global_options
-        remove_global_options options, @args
-
-        # if help is last arg run as if --help was passed in
-        if @args[-1] == "help"
-          args = @args - ["help"]
-          command(:help).run(*args)
-          return
-        end
-
-        unless trace
-          begin
-            run_active_command
-          rescue InvalidCommandError => e
-            usage = RHC::UsageHelpFormatter.new(self).render
-            i = @args.find_index { |a| a.start_with?('-') } || @args.length
-            abort "The command 'rhc #{@args[0,i].join(' ')}' is not recognized.\n#{usage}"
-          rescue \
-            ArgumentError,
-            OptionParser::InvalidOption,
-            OptionParser::InvalidArgument,
-            OptionParser::MissingArgument => e
-
-            help_bindings = CommandHelpBindings.new(active_command, commands, Commander::Runner.instance.options)
-            usage = RHC::UsageHelpFormatter.new(self).render_command(help_bindings)
-            say "#{e}\n#{usage}"
-            1
-          rescue Rhc::Rest::BaseException => e
-            RHC::Helpers.results { say "#{e}" }
-            e.code.nil? ? 128 : e.code
-          rescue Exception => e
-            RHC::Helpers.results { say "error: #{e} Use --trace to view backtrace." }
-            128
-          end
-        else
-          run_active_command
-        end
-      end
-
-      def create_default_commands
-        command :help do |c|
-          c.syntax = 'rhc help <command>'
-          c.description = 'Display global or <command> help documentation.'
-          c.when_called do |args, options|
-            if args.empty?
-              say help_formatter.render
-            else
-              command = command args.join(' ')
-              begin
-                require_valid_command command
-              rescue InvalidCommandError => e
-                abort "#{e}"
-              end
-
-              help_bindings = CommandHelpBindings.new command, commands, Commander::Runner.instance.options
-              say help_formatter.render_command help_bindings
-            end
-          end
-        end
-      end
-    end
-
     def self.load
       Dir[File.join(File.dirname(__FILE__), "commands", "*.rb")].each do |file|
         require file
@@ -106,71 +12,96 @@ module RHC
     def self.add(opts)
       commands[opts[:name]] = opts
     end
-    def self.global_option(switches, description)
-      global_options << [switches, description].flatten(1)
-    end
-    def self.validate_command(c, args, options, args_metadata)
-      # check to see if an arg's option was set
-      raise ArgumentError.new("Invalid arguments") if args.length > args_metadata.length
-      args_metadata.each_with_index do |arg_meta, i|
-        switch = arg_meta[:switches]
-        value = options.__hash__[arg_meta[:name]]
-        unless value.nil?
-          raise ArgumentError.new("#{arg_meta[:name]} specified twice on the command line and as a #{switch[0]} switch") unless args.length == i
-          # add the option as an argument
-          args << value
-        end
-      end
+    def self.global_option(*args, &block)
+      global_options << [args, block]
     end
 
     def self.global_config_setup(options)
       RHC::Config.set_opts_config(options.config) if options.config
       RHC::Config.password = options.password if options.password
       RHC::Config.opts_login = options.rhlogin if options.rhlogin
-      RHC::Config.noprompt(options.noprompt) if options.noprompt
       RHC::Config
     end
 
-    def self.needs_configuration!(cmd, config)
-      # check to see if we need to run wizard
-      if not cmd.class.suppress_wizard?
-        w = RHC::Wizard.new config
-        return w.run if w.needs_configuration?
+    def self.deprecated?
+      command_name = Commander::Runner.instance.command_name_from_args
+      command = Commander::Runner.instance.active_command
+
+      if deprecated[command_name]
+        msg = "The command 'rhc #{command_name}' is deprecated.  Please use 'rhc #{command.name}' instead."
+
+        raise DeprecatedError.new("#{msg} For porting and testing purposes you may switch this error to a warning by setting the DISABLE_DEPRECATED environment variable to 0.  It is not recommended to do so in a production environment as this command may be removed in future releases.") if RHC::Helpers.disable_deprecated?
+
+        warn "Warning: #{msg} For porting and testing purposes you may switch this warning to an error by setting the DISABLE_DEPRECATED environment variable to 1.  This command may be removed in future releases."
+      end
+    end
+
+    def self.needs_configuration!(cmd, options, config)
+      if not (cmd.class.suppress_wizard? or
+              options.noprompt or
+              options.help or
+              config.has_local_config? or
+              config.has_opts_config?)
+        RHC::Wizard.new(config).run
       end
-      false
     end
 
     def self.to_commander(instance=Commander::Runner.instance)
-      global_options.each{ |args| instance.global_option *args }
+      global_options.each do |args, block|
+        opts = (args.pop if Hash === args.last) || {}
+        option = instance.global_option(*args, &block).last
+        option.merge!(opts)
+      end
       commands.each_pair do |name, opts|
         instance.command name do |c|
           c.description = opts[:description]
           c.summary = opts[:summary]
           c.syntax = opts[:syntax]
 
-          (opts[:options]||[]).each { |o| c.option *o }
-          args_metadata = opts[:args] || []
-          (args_metadata).each do |arg_meta|
-            arg_switches = arg_meta[:switches]
-            arg_switches << arg_meta[:description]
-            c.option *arg_switches unless arg_switches.nil?
+          (options_metadata = opts[:options] || []).each do |o|
+            option_data = [o[:switches], o[:description]].flatten(1)
+            c.option *option_data
+            o[:arg] = Commander::Runner.switch_to_sym(o[:switches].last)
           end
 
-          c.when_called do |args, options|
-            validate_command c, args, options, args_metadata
-            config = global_config_setup options
-            cmd = opts[:class].new c, args, options, config
-            needs_configuration! cmd, config
-            cmd.send opts[:method], *args
+          args_metadata = opts[:args] || []
+          args_metadata.each do |arg_meta|
+            arg_switches = arg_meta[:switches]
+            unless arg_switches.nil? or arg_switches.empty?
+              arg_switches << arg_meta[:description]
+              c.option *arg_switches
+            end
           end
 
           unless opts[:aliases].nil?
             opts[:aliases].each do |a|
-              alias_components = name.split(" ")
-              alias_components[-1] = a
-              instance.alias_command  "#{alias_components.join(' ')}", :"#{name}"
+              alias_cmd = a[:action]
+
+              unless a[:root_command]
+                # prepend the current resource
+                alias_components = name.split(" ")
+                alias_components[-1] = a[:action]
+                alias_cmd = alias_components.join(' ')
+              end
+
+              deprecated[alias_cmd] = true if a[:deprecated]
+              instance.alias_command "#{alias_cmd}", :"#{name}"
             end
           end
+
+          c.when_called do |args, options|
+            config = global_config_setup(options)
+            deprecated?
+
+            cmd = opts[:class].new
+            cmd.options = options
+            cmd.config = config
+
+            filled_args = cmd.validate_args_and_options(args_metadata, options_metadata, args)
+
+            needs_configuration!(cmd, options, config)
+            cmd.send(opts[:method], *filled_args)
+          end
         end
       end
       self
@@ -183,5 +114,8 @@ module RHC
       def self.global_options
         @options ||= []
       end
+      def self.deprecated
+        @deprecated ||= {}
+      end
   end
 end

data/lib/rhc/commands/base.rb

@@ -5,23 +5,66 @@ require 'rhc/wizard'
 require 'rhc/config'
 require 'rhc/commands'
 require 'rhc/exceptions'
+require 'rhc/context_helper'
 
 class RHC::Commands::Base
 
-  def initialize(command=nil,
-                 args=[],
-                 options=Commander::Command::Options.new,
-                 config=RHC::Config)
-    @command, @args, @options, @config = command, args, options, config
+  attr_writer :options, :config
+
+  def initialize(options=Commander::Command::Options.new,
+                 config=nil)
+    @options, @config = options, config
 
     # apply timeout here even though it isn't quite a global
     $rest_timeout = @options.timeout ? @options.timeout.to_i : nil
   end
 
+  def validate_args_and_options(args_metadata, options_metadata, args)
+    # process options
+    options_metadata.each do |option_meta|
+      arg = option_meta[:arg]
+
+      context_helper = option_meta[:context_helper]
+      @options.__hash__[arg] = self.send(context_helper) if @options.__hash__[arg].nil? and context_helper
+      raise ArgumentError.new("Missing required option '#{arg}'.") if option_meta[:required] and @options.__hash__[arg].nil?
+    end
+
+    # process args
+    arg_slots = [].fill(nil, 0, args_metadata.length)
+    fill_args = args.reverse
+    args_metadata.each_with_index do |arg_meta, i|
+      # check options
+      value = @options.__hash__[arg_meta[:name]]
+      if value
+        arg_slots[i] = value
+      elsif arg_meta[:arg_type] == :list
+        arg_slots[i] = fill_args.reverse
+        fill_args = []
+      else
+        raise ArgumentError.new("Missing required argument '#{arg_meta[:name]}'.") if fill_args.empty?
+        arg_slots[i] = fill_args.pop
+      end
+    end
+
+    raise ArgumentError.new("Too many arguments passed in.") unless fill_args.empty?
+
+    arg_slots
+  end
+
   protected
     include RHC::Helpers
+    include RHC::ContextHelpers
 
-    attr_reader :command, :args, :options, :config
+    attr_reader :options, :config
+
+    #
+    # The implicit config object provides no defaults.
+    #
+    def config
+      @config ||= begin
+        RHC::Config.new
+      end
+    end
 
     def application
       #@application ||= ... identify current application or throw,
@@ -31,18 +74,26 @@ class RHC::Commands::Base
       #                     current git repo for remote, fail.
     end
 
-    def client
-      #@client ||= ... Return a client object capable of making calls
-      #                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 
-      #                should be through this call pattern.
-      #
-      #                Initialize with auth (a separate responsibility
-      #                object).
+    # Return a client object capable of making calls
+    # 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 
+    # should be through this call pattern.
+    def rest_client
+      @rest_client ||= begin
+        username = config.username
+        unless username
+          username = ask "To connect to #{openshift_server} enter your OpenShift login (email or Red Hat login id): "
+          config.config_user(username)
+        end
+        password = RHC::Config.password || RHC::get_password
+
+        RHC::Rest::Client.new(openshift_rest_node, username, password, @options.debug)
+      end
     end
 
+
     class InvalidCommand < StandardError ; end
 
     def self.inherited(klass)
@@ -62,7 +113,7 @@ class RHC::Commands::Base
       RHC::Commands.add((@options || {}).merge({
         :name => name.join(' '),
         :class => self,
-        :method => method,
+        :method => method
       }));
       @options = nil
     end
@@ -72,7 +123,7 @@ class RHC::Commands::Base
           value ||= if self.name && !self.name.empty?
             self.name.split('::').last
           end
-          value.to_s.downcase if value
+          value.to_s.split(/(?=[A-Z])/).join('-').downcase if value
         end
     end
 
@@ -94,16 +145,30 @@ class RHC::Commands::Base
       @suppress_wizard
     end
 
-    def self.alias_action(action)
-      aliases << action
+    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
+      aliases << options
     end
 
-    def self.option(switches, description)
-      options_metadata << [switches, description].flatten(1)
+    def self.option(switches, description, options={})
+      options_metadata << {:switches => switches,
+                           :description => description,
+                           :context_helper => options[:context],
+                           :required => options[:required]
+                          }
     end
 
-    def self.argument(name, description, switches)
-      args_metadata << {:name => name, :description => description, :switches => switches}
+    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
+
+      args_metadata << {:name => name, :description => description, :switches => switches, :arg_type => arg_type}
     end
 
     def self.default_action(action)
@@ -111,6 +176,12 @@ 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

data/lib/rhc/commands/domain.rb

@@ -2,11 +2,11 @@ require 'rhc/commands/base'
 
 module RHC::Commands
   class Domain < Base
-    summary "Manage your domain"
+    summary "Manage the domain and namespace for your applications."
     syntax "<action>"
     default_action :show
 
-    summary "Bind a registered user to a domain"
+    summary "Define a namespace for your applications to share."
     syntax "<namespace> [--timeout timeout]"
     argument :namespace, "Namespace for your application(s) (alphanumeric)", ["-n", "--namespace namespace"]
     option ["--timeout timeout"], "Timeout, in seconds, for the session"
@@ -22,9 +22,9 @@ module RHC::Commands
       0
     end
 
-    summary "Update namespace (will change urls)."
+    summary "Change current namespace (will change application urls)"
     syntax "<namespace> [--timeout timeout]"
-    argument :namespace, "Namespace for your application(s) (alphanumeric)", ["-n", "--namespace namespace"]
+    argument :namespace, "Namespace to change", ["-n", "--namespace namespace"]
     option ["--timeout timeout"], "Timeout, in seconds, for the session"
     alias_action :alter
     def update(namespace)
@@ -33,9 +33,9 @@ module RHC::Commands
       #       but in the future this will be manditory if you have more than one
       #       domain.  Figure out how to support overloading of commands
       domain = rest_client.domains
-      raise RHC::DomainNotFoundException.new("No domains are registered to the user #{config.username}. Please use 'rhc domain create' to create one.") if domain.empty?
+      raise RHC::DomainNotFoundException, "No domains are registered to the user #{config.username}. Please use 'rhc domain create' to create one." if domain.empty?
 
-      paragraph { say "Updating domain '#{domain[0].id}' to namespace '#{namespace}'" }
+      say "Changing namespace '#{domain[0].id}' to '#{namespace}'..."
 
       domain[0].update(namespace)
 
@@ -47,57 +47,41 @@ module RHC::Commands
       0
     end
 
-    summary "Show your configured domains"
+    summary "Display the applications in your domain"
     def show
-      domains = rest_client.domains
-      paragraph do
-        say "User Info"
-        say "========="
-        if domains.length == 0
-          say "Namespace: No namespaces found. You can use 'rhc domain create <namespace>' to create a namespace for your applications."
-        elsif domains.length == 1
-          say "Namespace: #{domains[0].id}"
-        else
-          domains.each_with_index { |d, i| say "Namespace(#{i}): #{d.id}" }
-        end
-      end
+      domain = rest_client.domains.first
 
-      paragraph { say "Login: #{config.username}" }
-      domains.each do |d|
+      if domain
         paragraph do
-          header = "Namespace #{d.id}'s Applications"
-          say header
-          say "=" * header.length
-          apps = d.applications
+          say "Applications in #{domain.id}:"
+          apps = domain.applications
           if apps.length == 0
-            say "No applications found.  You can use 'rhc app create' to create new applications."
+            say "No applications.  You can use 'rhc app create' to create new applications."
           else
-            apps.each do |a|
+            apps.each_with_index do |a,i|
               carts = a.cartridges
-              paragraph do
-                say a.name
-                say "    Framework: #{carts[0].name}"
-                say "     Creation: #{a.creation_time}"
-                say "         UUID: #{a.uuid}"
-                say "      Git URL: #{a.git_url}" if a.git_url
-                say "   Public URL: #{a.app_url}" if a.app_url
-                say "      Aliases: #{a.aliases.join(', ')}" if a.aliases and not a.aliases.empty?
-                say "   Cartridges:"
-                if carts.length > 1
+              section(:top => (i == 0 ? 1 : 2)) do
+                header "%s @ %s" % [a.name, a.app_url]
+                say "Created: #{date(a.creation_time)}"
+                #say "         UUID: #{a.uuid}"
+                say "Git URL: #{a.git_url}" if a.git_url
+                say "Aliases: #{a.aliases.join(', ')}" if a.aliases and not a.aliases.empty?
+                if carts.present?
+                  say "\nCartridges:"
                   carts.each do |c|
-                    if c.type == 'embedded'
-                      connection_url = c.property(:cart_data, :connection_url) || c.property(:cart_data, :job_url) || c.property(:cart_data, :monitoring_url)
-                      value = connection_url ? " - #{connection_url['value']}" : ""
-                      say "       #{c.name}#{value}"
-                    end
+                    connection_url = c.property(:cart_data, :connection_url) || c.property(:cart_data, :job_url) || c.property(:cart_data, :monitoring_url)
+                    value = connection_url ? " - #{connection_url['value']}" : ""
+                    say "  #{c.name}#{value}"
                   end
                 else
-                  say "       None"
+                  say "Cartridges: none"
                 end
               end
             end
           end
         end
+      else
+        say "No domain exists.  You can use 'rhc domain create' to create a namespace for applications." unless domain
       end
       0
     end
@@ -123,15 +107,14 @@ module RHC::Commands
     option ["--timeout timeout"], "Timeout, in seconds, for the session"
     alias_action :destroy
     def delete(namespace)
-      paragraph { say "Deleting domain '#{namespace}'" }
       domain = rest_client.find_domain namespace
 
-      paragraph do
-        begin
-          domain.destroy
-        rescue Rhc::Rest::ClientErrorException
-          raise Rhc::Rest::ClientErrorException.new("Domain contains applications. Delete applications first.", 128)
-        end
+      say "Deleting domain '#{namespace}'"
+
+      begin
+        domain.destroy
+      rescue RHC::Rest::ClientErrorException #FIXME: I am insufficiently specific
+        raise RHC::Exception.new("Domain contains applications. Delete applications first.", 128)
       end
 
       results { say "Success!" }