Extra options for ssh/scp don't cause errors.

cmd/cmd.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package cmd
 
 import (
         "bytes"
         "errors"
         "fmt"
         "io"
@@ skipping 16 matching lines @@
 
         // SetFlags adds command specific flags to the flag set.
         SetFlags(f *gnuflag.FlagSet)
 
         // Init initializes the Command before running.
         Init(args []string) error
 
         // Run will execute the Command as directed by the options and positional
         // arguments passed to Init.
         Run(ctx *Context) error
+
+        // AllowInterspersedFlags returns whether the command allows flag
+        // arguments to be interspersed with non-flag arguments.
+        AllowInterspersedFlags() bool
 }
 
 // CommandBase provides the default implementation for SetFlags, Init, and Help.
 type CommandBase struct{}
 
 // SetFlags does nothing in the simplest case.
 func (c *CommandBase) SetFlags(f *gnuflag.FlagSet) {}
 
 // Init in the simplest case makes sure there are no args.
 func (c *CommandBase) Init(args []string) error {
         return CheckEmpty(args)
+}
+
+// AllowInterspersedFlags returns true by default. Some subcommands
+// may want to override this.
+func (c *CommandBase) AllowInterspersedFlags() bool {
+        return true
 }
 
 // Context represents the run context of a Command. Command implementations
 // should interpret file names relative to Dir (see AbsPath below), and print
 // output and errors to Stdout and Stderr respectively.
 type Context struct {
         Dir    string
         Stdin  io.Reader
         Stdout io.Writer
         Stderr io.Writer
@@ skipping 51 matching lines @@
         f.SetOutput(ioutil.Discard)
         if i.Doc != "" {
                 fmt.Fprintf(buf, "\n%s\n", strings.TrimSpace(i.Doc))
         }
         if len(i.Aliases) > 0 {
                 fmt.Fprintf(buf, "\naliases: %s\n", strings.Join(i.Aliases, ", "))
         }
         return buf.Bytes()
 }
 
-// ParseArgs encapsulate the parsing of the args so this function can be
-// called from the testing module too.
-func ParseArgs(c Command, f *gnuflag.FlagSet, args []string) error {
-        // If the command is a SuperCommand, we want to parse the args with
-        // allowIntersperse=false (i.e. the first parameter to Parse.  This will
-        // mean that the args may contain other options that haven't been defined
-        // yet, and that only options that relate to the SuperCommand itself can
-        // come prior to the subcommand name.
-        _, isSuperCommand := c.(*SuperCommand)
-        return f.Parse(!isSuperCommand, args)
-}
-
 // Errors from commands can be either ErrHelp, which means "show the help" or
 // some other error related to needed flags missing, or needed positional args
 // missing, in which case we should print the error and return a non-zero
 // return code.
 func handleCommandError(c Command, ctx *Context, err error, f *gnuflag.FlagSet) (int, bool) {
         if err == gnuflag.ErrHelp {
                 ctx.Stdout.Write(c.Info().Help(f))
                 return 0, true
         }
         if err != nil {
                 fmt.Fprintf(ctx.Stderr, "error: %v\n", err)
                 return 2, true
         }
         return 0, false
 }
 
 // Main runs the given Command in the supplied Context with the given
 // arguments, which should not include the command name. It returns a code
 // suitable for passing to os.Exit.
 func Main(c Command, ctx *Context, args []string) int {
         f := gnuflag.NewFlagSet(c.Info().Name, gnuflag.ContinueOnError)
         f.SetOutput(ioutil.Discard)
         c.SetFlags(f)
-        if rc, done := handleCommandError(c, ctx, ParseArgs(c, f, args), f); done {
+        if rc, done := handleCommandError(c, ctx, f.Parse(c.AllowInterspersedFlags(), args), f); done {
                 return rc
         }
         // Since SuperCommands can also return gnuflag.ErrHelp errors, we need to
         // handle both those types of errors as well as "real" errors.
         if rc, done := handleCommandError(c, ctx, c.Init(f.Args()), f); done {
                 return rc
         }
         if err := c.Run(ctx); err != nil {
                 if err != ErrSilent {
                         fmt.Fprintf(ctx.Stderr, "error: %v\n", err)
@@ skipping 34 matching lines @@
 func ZeroOrOneArgs(args []string) (string, error) {
         var result string
         if len(args) > 0 {
                 result, args = args[0], args[1:]
         }
         if err := CheckEmpty(args); err != nil {
                 return "", err
         }
         return result, nil
 }