def command(*names)
      command_options = {
        :description => @next_desc,
        :arguments_name => @next_arg_name,
        :arguments_options => @next_arg_options,
        :arguments => @next_arguments,
        :long_desc => @next_long_desc,
        :skips_pre => @skips_pre,
        :skips_post => @skips_post,
        :skips_around => @skips_around,
        :hide_commands_without_desc => @hide_commands_without_desc,
      }
      @commands_declaration_order ||= []
      if names.first.kind_of? Hash
        command = GLI::Commands::CompoundCommand.new(self,
                                                     names.first,
                                                     command_options)
        command.parent = self
        commands[command.name] = command
        @commands_declaration_order << command
      else
        new_command = Command.new(command_options.merge(:names => [names].flatten))
        command = commands[new_command.name]
        if command.nil?
          command = new_command
          command.parent = self
          commands[command.name] = command
          @commands_declaration_order << command
        end
        yield command
      end
      clear_nexts
      @next_arguments = []
    end
def command(*names)
      command_options = {
        :description => @next_desc,
        :arguments_name => @next_arg_name,
        :arguments_options => @next_arg_options,
        :arguments => @next_arguments,
        :long_desc => @next_long_desc,
        :skips_pre => @skips_pre,
        :skips_post => @skips_post,
        :skips_around => @skips_around,
        :hide_commands_without_desc => @hide_commands_without_desc,
      }
      @commands_declaration_order ||= []
      if names.first.kind_of? Hash
        command = GLI::Commands::CompoundCommand.new(self,
                                                     names.first,
                                                     command_options)
        command.parent = self
        commands[command.name] = command
        @commands_declaration_order << command
      else
        new_command = Command.new(command_options.merge(:names => [names].flatten))
        command = commands[new_command.name]
        if command.nil?
          command = new_command
          command.parent = self
          commands[command.name] = command
          @commands_declaration_order << command
        end
        yield command
      end
      clear_nexts
      @next_arguments = []
    end
Define a new command.  This can be done in a few ways, but the most common method is
 to pass a symbol (or Array of symbols) representing the command name (or names) and a block.
 The block 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.

 Alternatively, you can call this with a one element Hash, where the key is the symbol representing the name
 of the command, and the value being an Array of symbols representing the commands to call in order, as a
 chained or compound command.  Note that these commands must exist already, and that only those command-specific
 options defined in *this* command will be parsed and passed to the chained commands.  This might not be what you expect

 +names+:: a String or Symbol, or an Array of String or Symbol that represent all the different names and aliases
           for this command *or* a Hash, as described above.

 ==Examples

     # Make a command named list
     command :list do |c|
       c.action do |global_options,options,args|
         # your command code
       end
     end

     # Make a command named list, callable by ls as well
     command [:list,:ls] do |c|
       c.action do |global_options,options,args|
         # your command code
       end
     end

     # Make a command named all, that calls list and list_contexts
     command :all => [ :list, :list_contexts ]

     # Make a command named all, aliased as :a:, that calls list and list_contexts
     command [:all,:a] => [ :list, :list_contexts ]