[ARVADOS] updated: 1.1.2-12-gc9048ae
Git user
git at public.curoverse.com
Tue Jan 2 09:22:48 EST 2018
Summary of changes:
cmd/arvados-client/cmd.go | 63 ++++++++++++++++++----
cmd/arvados-client/cmd_test.go | 6 +--
lib/cli/external.go | 99 +++++++++++++++++++++++++++++++++++
lib/cli/flags.go | 33 ++++++++++++
lib/cli/get.go | 30 +++++------
lib/cli/get_test.go | 2 +-
lib/cmd/cmd.go | 116 +++++++++++++++++++++--------------------
lib/cmd/cmd_test.go | 25 +++++----
8 files changed, 274 insertions(+), 100 deletions(-)
create mode 100644 lib/cli/external.go
create mode 100644 lib/cli/flags.go
via c9048ae0a122f3aad9e89d091bbf414951a42625 (commit)
via f84b235f8b6a962ee63ea8dfbf867c79807b0935 (commit)
from 256e92b825af07947ff09954018da0ca0b767acb (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
commit c9048ae0a122f3aad9e89d091bbf414951a42625
Author: Tom Clegg <tclegg at veritasgenetics.com>
Date: Tue Jan 2 00:47:04 2018 -0500
12868: Pass commands through to ruby/python programs.
Arvados-DCO-1.1-Signed-off-by: Tom Clegg <tclegg at veritasgenetics.com>
diff --git a/cmd/arvados-client/cmd.go b/cmd/arvados-client/cmd.go
index 73d772a..b616b54 100644
--- a/cmd/arvados-client/cmd.go
+++ b/cmd/arvados-client/cmd.go
@@ -5,7 +5,6 @@
package main
import (
- "flag"
"fmt"
"io"
"os"
@@ -14,38 +13,67 @@ import (
"git.curoverse.com/arvados.git/lib/cli"
"git.curoverse.com/arvados.git/lib/cmd"
- "rsc.io/getopt"
)
-var version = "dev"
+var (
+ version = "dev"
+ cmdVersion cmd.Handler = versionCmd{}
+ handler = cmd.Multi(map[string]cmd.Handler{
+ "-e": cmdVersion,
+ "version": cmdVersion,
+ "-version": cmdVersion,
+ "--version": cmdVersion,
-var Run = cmd.Multi(map[string]cmd.RunFunc{
- "get": cli.Get,
- "-e": cmdVersion,
- "version": cmdVersion,
- "-version": cmdVersion,
- "--version": cmdVersion,
-})
+ "copy": cli.Copy,
+ "create": cli.Create,
+ "edit": cli.Edit,
+ "get": cli.Get,
+ "keep": cli.Keep,
+ "pipeline": cli.Pipeline,
+ "run": cli.Run,
+ "tag": cli.Tag,
+ "ws": cli.Ws,
-func cmdVersion(prog string, args []string, _ io.Reader, stdout, _ io.Writer) int {
+ "api_client_authorization": cli.APICall,
+ "api_client": cli.APICall,
+ "authorized_key": cli.APICall,
+ "collection": cli.APICall,
+ "container": cli.APICall,
+ "container_request": cli.APICall,
+ "group": cli.APICall,
+ "human": cli.APICall,
+ "job": cli.APICall,
+ "job_task": cli.APICall,
+ "keep_disk": cli.APICall,
+ "keep_service": cli.APICall,
+ "link": cli.APICall,
+ "log": cli.APICall,
+ "node": cli.APICall,
+ "pipeline_instance": cli.APICall,
+ "pipeline_template": cli.APICall,
+ "repository": cli.APICall,
+ "specimen": cli.APICall,
+ "trait": cli.APICall,
+ "user_agreement": cli.APICall,
+ "user": cli.APICall,
+ "virtual_machine": cli.APICall,
+ "workflow": cli.APICall,
+ })
+)
+
+type versionCmd struct{}
+
+func (versionCmd) RunCommand(prog string, args []string, _ io.Reader, stdout, _ io.Writer) int {
prog = regexp.MustCompile(` -*version$`).ReplaceAllLiteralString(prog, "")
fmt.Fprintf(stdout, "%s %s (%s)\n", prog, version, runtime.Version())
return 0
}
func fixLegacyArgs(args []string) []string {
- flags := getopt.NewFlagSet("", flag.ContinueOnError)
- flags.Bool("dry-run", false, "dry run")
- flags.Alias("n", "dry-run")
- flags.String("format", "json", "output format")
- flags.Alias("f", "format")
- flags.Bool("short", false, "short")
- flags.Alias("s", "short")
- flags.Bool("verbose", false, "verbose")
- flags.Alias("v", "verbose")
+ flags, _ := cli.LegacyFlagSet()
return cmd.SubcommandToFront(args, flags)
}
func main() {
- os.Exit(Run(os.Args[0], fixLegacyArgs(os.Args[1:]), os.Stdin, os.Stdout, os.Stderr))
+ os.Exit(handler.RunCommand(os.Args[0], fixLegacyArgs(os.Args[1:]), os.Stdin, os.Stdout, os.Stderr))
}
diff --git a/cmd/arvados-client/cmd_test.go b/cmd/arvados-client/cmd_test.go
index b1ab5ba..cbbc7b1 100644
--- a/cmd/arvados-client/cmd_test.go
+++ b/cmd/arvados-client/cmd_test.go
@@ -22,19 +22,19 @@ var _ = check.Suite(&ClientSuite{})
type ClientSuite struct{}
func (s *ClientSuite) TestBadCommand(c *check.C) {
- exited := Run("arvados-client", []string{"no such command"}, bytes.NewReader(nil), ioutil.Discard, ioutil.Discard)
+ exited := handler.RunCommand("arvados-client", []string{"no such command"}, bytes.NewReader(nil), ioutil.Discard, ioutil.Discard)
c.Check(exited, check.Equals, 2)
}
func (s *ClientSuite) TestBadSubcommandArgs(c *check.C) {
- exited := Run("arvados-client", []string{"get"}, bytes.NewReader(nil), ioutil.Discard, ioutil.Discard)
+ exited := handler.RunCommand("arvados-client", []string{"get"}, bytes.NewReader(nil), ioutil.Discard, ioutil.Discard)
c.Check(exited, check.Equals, 2)
}
func (s *ClientSuite) TestVersion(c *check.C) {
stdout := bytes.NewBuffer(nil)
stderr := bytes.NewBuffer(nil)
- exited := Run("arvados-client", []string{"version"}, bytes.NewReader(nil), stdout, stderr)
+ exited := handler.RunCommand("arvados-client", []string{"version"}, bytes.NewReader(nil), stdout, stderr)
c.Check(exited, check.Equals, 0)
c.Check(stdout.String(), check.Matches, `arvados-client dev \(go[0-9\.]+\)\n`)
c.Check(stderr.String(), check.Equals, "")
diff --git a/lib/cli/external.go b/lib/cli/external.go
new file mode 100644
index 0000000..ba85aae
--- /dev/null
+++ b/lib/cli/external.go
@@ -0,0 +1,99 @@
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package cli
+
+import (
+ "fmt"
+ "io"
+ "io/ioutil"
+ "os/exec"
+ "strings"
+ "syscall"
+
+ "git.curoverse.com/arvados.git/lib/cmd"
+)
+
+var (
+ Create = rubyArvCmd{"create"}
+ Edit = rubyArvCmd{"edit"}
+
+ Copy = externalCmd{"arv-copy"}
+ Tag = externalCmd{"arv-tag"}
+ Ws = externalCmd{"arv-ws"}
+ Run = externalCmd{"arv-run"}
+
+ Keep = cmd.Multi(map[string]cmd.Handler{
+ "get": externalCmd{"arv-get"},
+ "put": externalCmd{"arv-put"},
+ "ls": externalCmd{"arv-ls"},
+ "normalize": externalCmd{"arv-normalize"},
+ "docker": externalCmd{"arv-keepdocker"},
+ })
+ Pipeline = cmd.Multi(map[string]cmd.Handler{
+ "run": externalCmd{"arv-run-pipeline-instance"},
+ })
+ // user, group, container, specimen, etc.
+ APICall = apiCallCmd{}
+)
+
+// When using the ruby "arv" command, flags must come before the
+// subcommand: "arv --format=yaml get foo" works, but "arv get
+// --format=yaml foo" does not work.
+func legacyFlagsToFront(subcommand string, argsin []string) (argsout []string) {
+ flags, _ := LegacyFlagSet()
+ flags.SetOutput(ioutil.Discard)
+ flags.Parse(argsin)
+ narg := flags.NArg()
+ argsout = append(argsout, argsin[:len(argsin)-narg]...)
+ argsout = append(argsout, subcommand)
+ argsout = append(argsout, argsin[len(argsin)-narg:]...)
+ return
+}
+
+type apiCallCmd struct{}
+
+func (cmd apiCallCmd) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+ split := strings.Split(prog, " ")
+ if len(split) < 2 {
+ fmt.Fprintf(stderr, "internal error: no api model in %q\n", prog)
+ return 2
+ }
+ model := split[len(split)-1]
+ return externalCmd{"arv"}.RunCommand("arv", legacyFlagsToFront(model, args), stdin, stdout, stderr)
+}
+
+type rubyArvCmd struct {
+ subcommand string
+}
+
+func (rc rubyArvCmd) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+ return externalCmd{"arv"}.RunCommand("arv", legacyFlagsToFront(rc.subcommand, args), stdin, stdout, stderr)
+}
+
+type externalCmd struct {
+ prog string
+}
+
+func (ec externalCmd) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+ cmd := exec.Command(ec.prog, args...)
+ cmd.Stdin = stdin
+ cmd.Stdout = stdout
+ cmd.Stderr = stderr
+ err := cmd.Run()
+ switch err := err.(type) {
+ case nil:
+ return 0
+ case *exec.ExitError:
+ status := err.Sys().(syscall.WaitStatus)
+ if status.Exited() {
+ return status.ExitStatus()
+ }
+ fmt.Fprintf(stderr, "%s failed: %s\n", ec.prog, err)
+ return 1
+ default:
+ fmt.Fprintf(stderr, "error running %s: %s\n", ec.prog, err)
+ return 1
+ }
+}
diff --git a/lib/cli/flags.go b/lib/cli/flags.go
new file mode 100644
index 0000000..7147e0c
--- /dev/null
+++ b/lib/cli/flags.go
@@ -0,0 +1,33 @@
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package cli
+
+import (
+ "flag"
+
+ "git.curoverse.com/arvados.git/lib/cmd"
+ "rsc.io/getopt"
+)
+
+type LegacyFlagValues struct {
+ Format string
+ DryRun bool
+ Short bool
+ Verbose bool
+}
+
+func LegacyFlagSet() (cmd.FlagSet, *LegacyFlagValues) {
+ values := &LegacyFlagValues{Format: "json"}
+ flags := getopt.NewFlagSet("", flag.ContinueOnError)
+ flags.BoolVar(&values.DryRun, "dry-run", false, "Don't actually do anything")
+ flags.Alias("n", "dry-run")
+ flags.StringVar(&values.Format, "format", values.Format, "Output format: json, yaml, or uuid")
+ flags.Alias("f", "format")
+ flags.BoolVar(&values.Short, "short", false, "Return only UUIDs (equivalent to --format=uuid)")
+ flags.Alias("s", "short")
+ flags.BoolVar(&values.Verbose, "verbose", false, "Print more debug/progress messages on stderr")
+ flags.Alias("v", "verbose")
+ return flags, values
+}
diff --git a/lib/cli/get.go b/lib/cli/get.go
index baa1df7..2c60f43 100644
--- a/lib/cli/get.go
+++ b/lib/cli/get.go
@@ -6,16 +6,19 @@ package cli
import (
"encoding/json"
- "flag"
"fmt"
"io"
+ "git.curoverse.com/arvados.git/lib/cmd"
"git.curoverse.com/arvados.git/sdk/go/arvados"
"github.com/ghodss/yaml"
- "rsc.io/getopt"
)
-func Get(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+var Get cmd.Handler = getCmd{}
+
+type getCmd struct{}
+
+func (getCmd) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
var err error
defer func() {
if err != nil {
@@ -23,27 +26,19 @@ func Get(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer)
}
}()
- flags := getopt.NewFlagSet(prog, flag.ContinueOnError)
+ flags, opts := LegacyFlagSet()
flags.SetOutput(stderr)
-
- format := flags.String("format", "json", "output format (json, yaml, or uuid)")
- flags.Alias("f", "format")
- short := flags.Bool("short", false, "equivalent to --format=uuid")
- flags.Alias("s", "short")
- flags.Bool("dry-run", false, "dry run (ignored, for compatibility)")
- flags.Alias("n", "dry-run")
- flags.Bool("verbose", false, "verbose (ignored, for compatibility)")
- flags.Alias("v", "verbose")
err = flags.Parse(args)
if err != nil {
return 2
}
if len(flags.Args()) != 1 {
- flags.Usage()
+ fmt.Fprintf(stderr, "usage of %s:\n", prog)
+ flags.PrintDefaults()
return 2
}
- if *short {
- *format = "uuid"
+ if opts.Short {
+ opts.Format = "uuid"
}
id := flags.Args()[0]
@@ -59,13 +54,13 @@ func Get(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer)
err = fmt.Errorf("GET %s: %s", path, err)
return 1
}
- if *format == "yaml" {
+ if opts.Format == "yaml" {
var buf []byte
buf, err = yaml.Marshal(obj)
if err == nil {
_, err = stdout.Write(buf)
}
- } else if *format == "uuid" {
+ } else if opts.Format == "uuid" {
fmt.Fprintln(stdout, obj["uuid"])
} else {
enc := json.NewEncoder(stdout)
diff --git a/lib/cli/get_test.go b/lib/cli/get_test.go
index 9b8f1a0..b2128a4 100644
--- a/lib/cli/get_test.go
+++ b/lib/cli/get_test.go
@@ -25,7 +25,7 @@ type GetSuite struct{}
func (s *GetSuite) TestGetCollectionJSON(c *check.C) {
stdout := bytes.NewBuffer(nil)
stderr := bytes.NewBuffer(nil)
- exited := Get("arvados-client get", []string{arvadostest.FooCollection}, bytes.NewReader(nil), stdout, stderr)
+ exited := Get.RunCommand("arvados-client get", []string{arvadostest.FooCollection}, bytes.NewReader(nil), stdout, stderr)
c.Check(stdout.String(), check.Matches, `(?ms){.*"uuid": "`+arvadostest.FooCollection+`".*}\n`)
c.Check(stdout.String(), check.Matches, `(?ms){.*"portable_data_hash": "`+regexp.QuoteMeta(arvadostest.FooCollectionPDH)+`".*}\n`)
c.Check(stderr.String(), check.Equals, "")
diff --git a/lib/cmd/cmd.go b/lib/cmd/cmd.go
index f33354a..d040065 100644
--- a/lib/cmd/cmd.go
+++ b/lib/cmd/cmd.go
@@ -2,8 +2,8 @@
//
// SPDX-License-Identifier: Apache-2.0
-// package cmd defines a RunFunc type, representing a process that can
-// be invoked from a command line.
+// package cmd helps define reusable functions that can be exposed as
+// [subcommands of] command line programs.
package cmd
import (
@@ -15,41 +15,47 @@ import (
"strings"
)
-// A RunFunc runs a command with the given args, and returns an exit
-// code.
-type RunFunc func(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int
+type Handler interface {
+ RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int
+}
+
+type HandlerFunc func(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int
+
+func (f HandlerFunc) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+ return f(prog, args, stdin, stdout, stderr)
+}
-// Multi returns a RunFunc that looks up its first argument in m, and
-// invokes the resulting RunFunc with the remaining args.
+// Multi is a Handler that looks up its first argument in a map, and
+// invokes the resulting Handler with the remaining args.
//
// Example:
//
-// os.Exit(Multi(map[string]RunFunc{
-// "foobar": func(prog string, args []string) int {
+// os.Exit(Multi(map[string]Handler{
+// "foobar": HandlerFunc(func(prog string, args []string) int {
// fmt.Println(args[0])
// return 2
-// },
+// }),
// })("/usr/bin/multi", []string{"foobar", "baz"}))
//
// ...prints "baz" and exits 2.
-func Multi(m map[string]RunFunc) RunFunc {
- return func(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
- if len(args) < 1 {
- fmt.Fprintf(stderr, "usage: %s command [args]\n", prog)
- multiUsage(stderr, m)
- return 2
- }
- if cmd, ok := m[args[0]]; !ok {
- fmt.Fprintf(stderr, "unrecognized command %q\n", args[0])
- multiUsage(stderr, m)
- return 2
- } else {
- return cmd(prog+" "+args[0], args[1:], stdin, stdout, stderr)
- }
+type Multi map[string]Handler
+
+func (m Multi) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+ if len(args) < 1 {
+ fmt.Fprintf(stderr, "usage: %s command [args]\n", prog)
+ m.Usage(stderr)
+ return 2
+ }
+ if cmd, ok := m[args[0]]; !ok {
+ fmt.Fprintf(stderr, "unrecognized command %q\n", args[0])
+ m.Usage(stderr)
+ return 2
+ } else {
+ return cmd.RunCommand(prog+" "+args[0], args[1:], stdin, stdout, stderr)
}
}
-func multiUsage(stderr io.Writer, m map[string]RunFunc) {
+func (m Multi) Usage(stderr io.Writer) {
var subcommands []string
for sc := range m {
if strings.HasPrefix(sc, "-") {
@@ -69,9 +75,11 @@ func multiUsage(stderr io.Writer, m map[string]RunFunc) {
type FlagSet interface {
Init(string, flag.ErrorHandling)
+ Args() []string
NArg() int
Parse([]string) error
SetOutput(io.Writer)
+ PrintDefaults()
}
// SubcommandToFront silently parses args using flagset, and returns a
diff --git a/lib/cmd/cmd_test.go b/lib/cmd/cmd_test.go
index 04e98d8..d8a4861 100644
--- a/lib/cmd/cmd_test.go
+++ b/lib/cmd/cmd_test.go
@@ -25,18 +25,18 @@ var _ = check.Suite(&CmdSuite{})
type CmdSuite struct{}
-var testCmd = Multi(map[string]RunFunc{
- "echo": func(prog string, args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) int {
+var testCmd = Multi(map[string]Handler{
+ "echo": HandlerFunc(func(prog string, args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) int {
fmt.Fprintln(stdout, strings.Join(args, " "))
return 0
- },
+ }),
})
func (s *CmdSuite) TestHello(c *check.C) {
defer cmdtest.LeakCheck(c)()
stdout := bytes.NewBuffer(nil)
stderr := bytes.NewBuffer(nil)
- exited := testCmd("prog", []string{"echo", "hello", "world"}, bytes.NewReader(nil), stdout, stderr)
+ exited := testCmd.RunCommand("prog", []string{"echo", "hello", "world"}, bytes.NewReader(nil), stdout, stderr)
c.Check(exited, check.Equals, 0)
c.Check(stdout.String(), check.Equals, "hello world\n")
c.Check(stderr.String(), check.Equals, "")
@@ -46,7 +46,7 @@ func (s *CmdSuite) TestUsage(c *check.C) {
defer cmdtest.LeakCheck(c)()
stdout := bytes.NewBuffer(nil)
stderr := bytes.NewBuffer(nil)
- exited := testCmd("prog", []string{"nosuchcommand", "hi"}, bytes.NewReader(nil), stdout, stderr)
+ exited := testCmd.RunCommand("prog", []string{"nosuchcommand", "hi"}, bytes.NewReader(nil), stdout, stderr)
c.Check(exited, check.Equals, 2)
c.Check(stdout.String(), check.Equals, "")
c.Check(stderr.String(), check.Matches, `(?ms)^unrecognized command "nosuchcommand"\n.*echo.*\n`)
commit f84b235f8b6a962ee63ea8dfbf867c79807b0935
Author: Tom Clegg <tclegg at veritasgenetics.com>
Date: Wed Dec 27 02:19:17 2017 -0500
12868: Simplify legacy option parsing.
Arvados-DCO-1.1-Signed-off-by: Tom Clegg <tclegg at veritasgenetics.com>
diff --git a/cmd/arvados-client/cmd.go b/cmd/arvados-client/cmd.go
index b96cce3..73d772a 100644
--- a/cmd/arvados-client/cmd.go
+++ b/cmd/arvados-client/cmd.go
@@ -5,6 +5,7 @@
package main
import (
+ "flag"
"fmt"
"io"
"os"
@@ -13,17 +14,18 @@ import (
"git.curoverse.com/arvados.git/lib/cli"
"git.curoverse.com/arvados.git/lib/cmd"
+ "rsc.io/getopt"
)
var version = "dev"
-var Run = cmd.WithLateSubcommand(cmd.Multi(map[string]cmd.RunFunc{
+var Run = cmd.Multi(map[string]cmd.RunFunc{
"get": cli.Get,
"-e": cmdVersion,
"version": cmdVersion,
"-version": cmdVersion,
"--version": cmdVersion,
-}), []string{"f", "format"}, []string{"n", "dry-run", "v", "verbose", "s", "short"})
+})
func cmdVersion(prog string, args []string, _ io.Reader, stdout, _ io.Writer) int {
prog = regexp.MustCompile(` -*version$`).ReplaceAllLiteralString(prog, "")
@@ -31,6 +33,19 @@ func cmdVersion(prog string, args []string, _ io.Reader, stdout, _ io.Writer) in
return 0
}
+func fixLegacyArgs(args []string) []string {
+ flags := getopt.NewFlagSet("", flag.ContinueOnError)
+ flags.Bool("dry-run", false, "dry run")
+ flags.Alias("n", "dry-run")
+ flags.String("format", "json", "output format")
+ flags.Alias("f", "format")
+ flags.Bool("short", false, "short")
+ flags.Alias("s", "short")
+ flags.Bool("verbose", false, "verbose")
+ flags.Alias("v", "verbose")
+ return cmd.SubcommandToFront(args, flags)
+}
+
func main() {
- os.Exit(Run(os.Args[0], os.Args[1:], os.Stdin, os.Stdout, os.Stderr))
+ os.Exit(Run(os.Args[0], fixLegacyArgs(os.Args[1:]), os.Stdin, os.Stdout, os.Stderr))
}
diff --git a/lib/cli/get.go b/lib/cli/get.go
index d3177f3..baa1df7 100644
--- a/lib/cli/get.go
+++ b/lib/cli/get.go
@@ -12,6 +12,7 @@ import (
"git.curoverse.com/arvados.git/sdk/go/arvados"
"github.com/ghodss/yaml"
+ "rsc.io/getopt"
)
func Get(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
@@ -22,17 +23,17 @@ func Get(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer)
}
}()
- flags := flag.NewFlagSet(prog, flag.ContinueOnError)
+ flags := getopt.NewFlagSet(prog, flag.ContinueOnError)
flags.SetOutput(stderr)
format := flags.String("format", "json", "output format (json, yaml, or uuid)")
- flags.StringVar(format, "f", "json", "output format (json, yaml, or uuid)")
+ flags.Alias("f", "format")
short := flags.Bool("short", false, "equivalent to --format=uuid")
- flags.BoolVar(short, "s", false, "equivalent to --format=uuid")
+ flags.Alias("s", "short")
flags.Bool("dry-run", false, "dry run (ignored, for compatibility)")
- flags.Bool("n", false, "dry run (ignored, for compatibility)")
+ flags.Alias("n", "dry-run")
flags.Bool("verbose", false, "verbose (ignored, for compatibility)")
- flags.Bool("v", false, "verbose (ignored, for compatibility)")
+ flags.Alias("v", "verbose")
err = flags.Parse(args)
if err != nil {
return 2
diff --git a/lib/cmd/cmd.go b/lib/cmd/cmd.go
index 46d9965..f33354a 100644
--- a/lib/cmd/cmd.go
+++ b/lib/cmd/cmd.go
@@ -67,37 +67,33 @@ func multiUsage(stderr io.Writer, m map[string]RunFunc) {
}
}
-// WithLateSubcommand wraps a RunFunc by skipping over some known
-// flags to find a subcommand, and moving that subcommand to the front
-// of the args before calling the wrapped RunFunc. For example:
+type FlagSet interface {
+ Init(string, flag.ErrorHandling)
+ NArg() int
+ Parse([]string) error
+ SetOutput(io.Writer)
+}
+
+// SubcommandToFront silently parses args using flagset, and returns a
+// copy of args with the first non-flag argument moved to the
+// front. If parsing fails or consumes all of args, args is returned
+// unchanged.
//
-// // Translate [ --format foo subcommand bar]
-// // to [subcommand --format foo bar]
-// WithLateSubcommand(fn, []string{"format"}, nil)
-func WithLateSubcommand(run RunFunc, argFlags, boolFlags []string) RunFunc {
- return func(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
- flags := flag.NewFlagSet("prog", flag.ContinueOnError)
- for _, arg := range argFlags {
- flags.String(arg, "", "")
- }
- for _, arg := range boolFlags {
- flags.Bool(arg, false, "")
- }
- // Ignore errors. We can't report a useful error
- // message anyway.
- flags.SetOutput(ioutil.Discard)
- flags.Usage = func() {}
- flags.Parse(args)
- if flags.NArg() > 0 {
- // Move the first arg after the recognized
- // flags up to the front.
- flagargs := len(args) - flags.NArg()
- newargs := make([]string, len(args))
- newargs[0] = args[flagargs]
- copy(newargs[1:flagargs+1], args[:flagargs])
- copy(newargs[flagargs+1:], args[flagargs+1:])
- args = newargs
- }
- return run(prog, args, stdin, stdout, stderr)
+// SubcommandToFront invokes methods on flagset that have side
+// effects, including Parse. In typical usage, flagset will not used
+// for anything else after being passed to SubcommandToFront.
+func SubcommandToFront(args []string, flagset FlagSet) []string {
+ flagset.Init("", flag.ContinueOnError)
+ flagset.SetOutput(ioutil.Discard)
+ if err := flagset.Parse(args); err != nil || flagset.NArg() == 0 {
+ // No subcommand found.
+ return args
}
+ // Move subcommand to the front.
+ flagargs := len(args) - flagset.NArg()
+ newargs := make([]string, len(args))
+ newargs[0] = args[flagargs]
+ copy(newargs[1:flagargs+1], args[:flagargs])
+ copy(newargs[flagargs+1:], args[flagargs+1:])
+ return newargs
}
diff --git a/lib/cmd/cmd_test.go b/lib/cmd/cmd_test.go
index 2d9228a..04e98d8 100644
--- a/lib/cmd/cmd_test.go
+++ b/lib/cmd/cmd_test.go
@@ -6,6 +6,7 @@ package cmd
import (
"bytes"
+ "flag"
"fmt"
"io"
"strings"
@@ -51,13 +52,11 @@ func (s *CmdSuite) TestUsage(c *check.C) {
c.Check(stderr.String(), check.Matches, `(?ms)^unrecognized command "nosuchcommand"\n.*echo.*\n`)
}
-func (s *CmdSuite) TestWithLateSubcommand(c *check.C) {
+func (s *CmdSuite) TestSubcommandToFront(c *check.C) {
defer cmdtest.LeakCheck(c)()
- stdout := bytes.NewBuffer(nil)
- stderr := bytes.NewBuffer(nil)
- run := WithLateSubcommand(testCmd, []string{"format", "f"}, []string{"n"})
- exited := run("prog", []string{"--format=yaml", "-n", "-format", "beep", "echo", "hi"}, bytes.NewReader(nil), stdout, stderr)
- c.Check(exited, check.Equals, 0)
- c.Check(stdout.String(), check.Equals, "--format=yaml -n -format beep hi\n")
- c.Check(stderr.String(), check.Equals, "")
+ flags := flag.NewFlagSet("", flag.ContinueOnError)
+ flags.String("format", "json", "")
+ flags.Bool("n", false, "")
+ args := SubcommandToFront([]string{"--format=yaml", "-n", "-format", "beep", "echo", "hi"}, flags)
+ c.Check(args, check.DeepEquals, []string{"echo", "--format=yaml", "-n", "-format", "beep", "hi"})
}
-----------------------------------------------------------------------
hooks/post-receive
--
More information about the arvados-commits
mailing list