aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--Godeps/Godeps.json15
-rw-r--r--Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete14
-rw-r--r--Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/zsh_autocomplete5
-rw-r--r--Godeps/_workspace/src/github.com/rs/xhandler/.travis.yml7
-rw-r--r--Godeps/_workspace/src/github.com/rs/xhandler/LICENSE19
-rw-r--r--Godeps/_workspace/src/github.com/rs/xhandler/README.md134
-rw-r--r--Godeps/_workspace/src/github.com/rs/xhandler/chain.go93
-rw-r--r--Godeps/_workspace/src/github.com/rs/xhandler/middleware.go59
-rw-r--r--Godeps/_workspace/src/github.com/rs/xhandler/xhandler.go42
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/.travis.yml (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/.travis.yml)10
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/CHANGELOG.md310
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/LICENSE (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/LICENSE)0
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/README.md (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/README.md)291
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/app.go (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/app.go)225
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/appveyor.yml (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/appveyor.yml)0
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/category.go44
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/cli.go (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/cli.go)23
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/command.go (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/command.go)73
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/context.go (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/context.go)116
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/errors.go92
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/flag.go (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/flag.go)199
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/funcs.go28
-rw-r--r--Godeps/_workspace/src/gopkg.in/urfave/cli.v1/help.go (renamed from Godeps/_workspace/src/github.com/codegangsta/cli/help.go)112
-rw-r--r--cmd/ethtest/main.go2
-rw-r--r--cmd/evm/main.go2
-rw-r--r--cmd/geth/accountcmd.go2
-rw-r--r--cmd/geth/chaincmd.go2
-rw-r--r--cmd/geth/consolecmd.go2
-rw-r--r--cmd/geth/main.go2
-rw-r--r--cmd/geth/monitorcmd.go2
-rw-r--r--cmd/geth/usage.go2
-rw-r--r--cmd/utils/client.go2
-rw-r--r--cmd/utils/customflags.go2
-rw-r--r--cmd/utils/flags.go2
-rw-r--r--internal/debug/flags.go2
35 files changed, 1309 insertions, 626 deletions
diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index f2694a05c..36104b456 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -1,6 +1,7 @@
{
"ImportPath": "github.com/ethereum/go-ethereum",
"GoVersion": "go1.5.2",
+ "GodepVersion": "v74",
"Packages": [
"./..."
],
@@ -14,11 +15,6 @@
"Rev": "165db2f241fd235aec29ba6d9b1ccd5f1c14637c"
},
{
- "ImportPath": "github.com/codegangsta/cli",
- "Comment": "1.2.0-215-g0ab42fd",
- "Rev": "0ab42fd482c27cf2c95e7794ad3bb2082c2ab2d7"
- },
- {
"ImportPath": "github.com/davecgh/go-spew/spew",
"Rev": "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d"
},
@@ -156,6 +152,10 @@
"Rev": "5950cf11d77f8a61b432a25dd4d444b4ced01379"
},
{
+ "ImportPath": "github.com/rs/xhandler",
+ "Rev": "d9d9599b6aaf6a058cb7b1f48291ded2cbd13390"
+ },
+ {
"ImportPath": "github.com/syndtr/goleveldb/leveldb",
"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
},
@@ -319,6 +319,11 @@
{
"ImportPath": "gopkg.in/karalabe/cookiejar.v2/collections/prque",
"Rev": "8dcd6a7f4951f6ff3ee9cbb919a06d8925822e57"
+ },
+ {
+ "ImportPath": "gopkg.in/urfave/cli.v1",
+ "Comment": "v1.17.0",
+ "Rev": "01857ac33766ce0c93856370626f9799281c14f4"
}
]
}
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete b/Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete
deleted file mode 100644
index 21a232f1f..000000000
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete
+++ /dev/null
@@ -1,14 +0,0 @@
-#! /bin/bash
-
-: ${PROG:=$(basename ${BASH_SOURCE})}
-
-_cli_bash_autocomplete() {
- local cur opts base
- COMPREPLY=()
- cur="${COMP_WORDS[COMP_CWORD]}"
- opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
- COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
- return 0
- }
-
- complete -F _cli_bash_autocomplete $PROG
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/zsh_autocomplete b/Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/zsh_autocomplete
deleted file mode 100644
index 5430a18f9..000000000
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/zsh_autocomplete
+++ /dev/null
@@ -1,5 +0,0 @@
-autoload -U compinit && compinit
-autoload -U bashcompinit && bashcompinit
-
-script_dir=$(dirname $0)
-source ${script_dir}/bash_autocomplete
diff --git a/Godeps/_workspace/src/github.com/rs/xhandler/.travis.yml b/Godeps/_workspace/src/github.com/rs/xhandler/.travis.yml
deleted file mode 100644
index b65c7a9f1..000000000
--- a/Godeps/_workspace/src/github.com/rs/xhandler/.travis.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-language: go
-go:
-- 1.5
-- tip
-matrix:
- allow_failures:
- - go: tip
diff --git a/Godeps/_workspace/src/github.com/rs/xhandler/LICENSE b/Godeps/_workspace/src/github.com/rs/xhandler/LICENSE
deleted file mode 100644
index 47c5e9d2d..000000000
--- a/Godeps/_workspace/src/github.com/rs/xhandler/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (c) 2015 Olivier Poitrey <rs@dailymotion.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is furnished
-to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/rs/xhandler/README.md b/Godeps/_workspace/src/github.com/rs/xhandler/README.md
deleted file mode 100644
index 91c594bd2..000000000
--- a/Godeps/_workspace/src/github.com/rs/xhandler/README.md
+++ /dev/null
@@ -1,134 +0,0 @@
-# XHandler
-
-[![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/rs/xhandler) [![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/rs/xhandler/master/LICENSE) [![Build Status](https://travis-ci.org/rs/xhandler.svg?branch=master)](https://travis-ci.org/rs/xhandler) [![Coverage](http://gocover.io/_badge/github.com/rs/xhandler)](http://gocover.io/github.com/rs/xhandler)
-
-XHandler is a bridge between [net/context](https://godoc.org/golang.org/x/net/context) and `http.Handler`.
-
-It lets you enforce `net/context` in your handlers without sacrificing compatibility with existing `http.Handlers` nor imposing a specific router.
-
-Thanks to `net/context` deadline management, `xhandler` is able to enforce a per request deadline and will cancel the context when the client closes the connection unexpectedly.
-
-You may create your own `net/context` aware handler pretty much the same way as you would do with http.Handler.
-
-Read more about xhandler on [Dailymotion engineering blog](http://engineering.dailymotion.com/our-way-to-go/).
-
-## Installing
-
- go get -u github.com/rs/xhandler
-
-## Usage
-
-```go
-package main
-
-import (
- "log"
- "net/http"
- "time"
-
- "github.com/rs/cors"
- "github.com/rs/xhandler"
- "golang.org/x/net/context"
-)
-
-type myMiddleware struct {
- next xhandler.HandlerC
-}
-
-func (h myMiddleware) ServeHTTPC(ctx context.Context, w http.ResponseWriter, r *http.Request) {
- ctx = context.WithValue(ctx, "test", "World")
- h.next.ServeHTTPC(ctx, w, r)
-}
-
-func main() {
- c := xhandler.Chain{}
-
- // Add close notifier handler so context is cancelled when the client closes
- // the connection
- c.UseC(xhandler.CloseHandler)
-
- // Add timeout handler
- c.UseC(xhandler.TimeoutHandler(2 * time.Second))
-
- // Middleware putting something in the context
- c.UseC(func(next xhandler.HandlerC) xhandler.HandlerC {
- return myMiddleware{next: next}
- })
-
- // Mix it with a non-context-aware middleware handler
- c.Use(cors.Default().Handler)
-
- // Final handler (using handlerFuncC), reading from the context
- xh := xhandler.HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
- value := ctx.Value("test").(string)
- w.Write([]byte("Hello " + value))
- })
-
- // Bridge context aware handlers with http.Handler using xhandler.Handle()
- http.Handle("/test", c.Handler(xh))
-
- if err := http.ListenAndServe(":8080", nil); err != nil {
- log.Fatal(err)
- }
-}
-```
-
-### Using xmux
-
-Xhandler comes with an optional context aware [muxer](https://github.com/rs/xmux) forked from [httprouter](https://github.com/julienschmidt/httprouter):
-
-```go
-package main
-
-import (
- "fmt"
- "log"
- "net/http"
- "time"
-
- "github.com/rs/xhandler"
- "github.com/rs/xmux"
- "golang.org/x/net/context"
-)
-
-func main() {
- c := xhandler.Chain{}
-
- // Append a context-aware middleware handler
- c.UseC(xhandler.CloseHandler)
-
- // Another context-aware middleware handler
- c.UseC(xhandler.TimeoutHandler(2 * time.Second))
-
- mux := xmux.New()
-
- // Use c.Handler to terminate the chain with your final handler
- mux.GET("/welcome/:name", xhandler.HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
- fmt.Fprintf(w, "Welcome %s!", xmux.Params(ctx).Get("name"))
- }))
-
- if err := http.ListenAndServe(":8080", c.Handler(mux)); err != nil {
- log.Fatal(err)
- }
-}
-```
-
-See [xmux](https://github.com/rs/xmux) for more examples.
-
-## Context Aware Middleware
-
-Here is a list of `net/context` aware middleware handlers implementing `xhandler.HandlerC` interface.
-
-Feel free to put up a PR linking your middleware if you have built one:
-
-| Middleware | Author | Description |
-| ---------- | ------ | ----------- |
-| [xmux](https://github.com/rs/xmux) | [Olivier Poitrey](https://github.com/rs) | HTTP request muxer |
-| [xlog](https://github.com/rs/xlog) | [Olivier Poitrey](https://github.com/rs) | HTTP handler logger |
-| [xstats](https://github.com/rs/xstats) | [Olivier Poitrey](https://github.com/rs) | A generic client for service instrumentation |
-| [xaccess](https://github.com/rs/xaccess) | [Olivier Poitrey](https://github.com/rs) | HTTP handler access logger with [xlog](https://github.com/rs/xlog) and [xstats](https://github.com/rs/xstats) |
-| [cors](https://github.com/rs/cors) | [Olivier Poitrey](https://github.com/rs) | [Cross Origin Resource Sharing](http://www.w3.org/TR/cors/) (CORS) support |
-
-## Licenses
-
-All source code is licensed under the [MIT License](https://raw.github.com/rs/xhandler/master/LICENSE).
diff --git a/Godeps/_workspace/src/github.com/rs/xhandler/chain.go b/Godeps/_workspace/src/github.com/rs/xhandler/chain.go
deleted file mode 100644
index 042274d17..000000000
--- a/Godeps/_workspace/src/github.com/rs/xhandler/chain.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package xhandler
-
-import (
- "net/http"
-
- "golang.org/x/net/context"
-)
-
-// Chain is an helper to chain middleware handlers together for an easier
-// management.
-type Chain []func(next HandlerC) HandlerC
-
-// UseC appends a context-aware handler to the middleware chain.
-func (c *Chain) UseC(f func(next HandlerC) HandlerC) {
- *c = append(*c, f)
-}
-
-// Use appends a standard http.Handler to the middleware chain without
-// lossing track of the context when inserted between two context aware handlers.
-//
-// Caveat: the f function will be called on each request so you are better to put
-// any initialization sequence outside of this function.
-func (c *Chain) Use(f func(next http.Handler) http.Handler) {
- xf := func(next HandlerC) HandlerC {
- return HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
- n := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- next.ServeHTTPC(ctx, w, r)
- })
- f(n).ServeHTTP(w, r)
- })
- }
- *c = append(*c, xf)
-}
-
-// Handler wraps the provided final handler with all the middleware appended to
-// the chain and return a new standard http.Handler instance.
-// The context.Background() context is injected automatically.
-func (c Chain) Handler(xh HandlerC) http.Handler {
- ctx := context.Background()
- return c.HandlerCtx(ctx, xh)
-}
-
-// HandlerFC is an helper to provide a function (HandlerFuncC) to Handler().
-//
-// HandlerFC is equivalent to:
-// c.Handler(xhandler.HandlerFuncC(xhc))
-func (c Chain) HandlerFC(xhf HandlerFuncC) http.Handler {
- ctx := context.Background()
- return c.HandlerCtx(ctx, HandlerFuncC(xhf))
-}
-
-// HandlerH is an helper to provide a standard http handler (http.HandlerFunc)
-// to Handler(). Your final handler won't have access the context though.
-func (c Chain) HandlerH(h http.Handler) http.Handler {
- ctx := context.Background()
- return c.HandlerCtx(ctx, HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
- h.ServeHTTP(w, r)
- }))
-}
-
-// HandlerF is an helper to provide a standard http handler function
-// (http.HandlerFunc) to Handler(). Your final handler won't have access
-// the context though.
-func (c Chain) HandlerF(hf http.HandlerFunc) http.Handler {
- ctx := context.Background()
- return c.HandlerCtx(ctx, HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
- hf(w, r)
- }))
-}
-
-// HandlerCtx wraps the provided final handler with all the middleware appended to
-// the chain and return a new standard http.Handler instance.
-func (c Chain) HandlerCtx(ctx context.Context, xh HandlerC) http.Handler {
- return New(ctx, c.HandlerC(xh))
-}
-
-// HandlerC wraps the provided final handler with all the middleware appended to
-// the chain and returns a HandlerC instance.
-func (c Chain) HandlerC(xh HandlerC) HandlerC {
- for i := len(c) - 1; i >= 0; i-- {
- xh = c[i](xh)
- }
- return xh
-}
-
-// HandlerCF wraps the provided final handler func with all the middleware appended to
-// the chain and returns a HandlerC instance.
-//
-// HandlerCF is equivalent to:
-// c.HandlerC(xhandler.HandlerFuncC(xhc))
-func (c Chain) HandlerCF(xhc HandlerFuncC) HandlerC {
- return c.HandlerC(HandlerFuncC(xhc))
-}
diff --git a/Godeps/_workspace/src/github.com/rs/xhandler/middleware.go b/Godeps/_workspace/src/github.com/rs/xhandler/middleware.go
deleted file mode 100644
index 5de136419..000000000
--- a/Godeps/_workspace/src/github.com/rs/xhandler/middleware.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package xhandler
-
-import (
- "net/http"
- "time"
-
- "golang.org/x/net/context"
-)
-
-// CloseHandler returns a Handler cancelling the context when the client
-// connection close unexpectedly.
-func CloseHandler(next HandlerC) HandlerC {
- return HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
- // Cancel the context if the client closes the connection
- if wcn, ok := w.(http.CloseNotifier); ok {
- var cancel context.CancelFunc
- ctx, cancel = context.WithCancel(ctx)
- defer cancel()
-
- notify := wcn.CloseNotify()
- go func() {
- select {
- case <-notify:
- cancel()
- case <-ctx.Done():
- }
- }()
- }
-
- next.ServeHTTPC(ctx, w, r)
- })
-}
-
-// TimeoutHandler returns a Handler which adds a timeout to the context.
-//
-// Child handlers have the responsability to obey the context deadline and to return
-// an appropriate error (or not) response in case of timeout.
-func TimeoutHandler(timeout time.Duration) func(next HandlerC) HandlerC {
- return func(next HandlerC) HandlerC {
- return HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
- ctx, _ = context.WithTimeout(ctx, timeout)
- next.ServeHTTPC(ctx, w, r)
- })
- }
-}
-
-// If is a special handler that will skip insert the condNext handler only if a condition
-// applies at runtime.
-func If(cond func(ctx context.Context, w http.ResponseWriter, r *http.Request) bool, condNext func(next HandlerC) HandlerC) func(next HandlerC) HandlerC {
- return func(next HandlerC) HandlerC {
- return HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
- if cond(ctx, w, r) {
- condNext(next).ServeHTTPC(ctx, w, r)
- } else {
- next.ServeHTTPC(ctx, w, r)
- }
- })
- }
-}
diff --git a/Godeps/_workspace/src/github.com/rs/xhandler/xhandler.go b/Godeps/_workspace/src/github.com/rs/xhandler/xhandler.go
deleted file mode 100644
index 718c25322..000000000
--- a/Godeps/_workspace/src/github.com/rs/xhandler/xhandler.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// Package xhandler provides a bridge between http.Handler and net/context.
-//
-// xhandler enforces net/context in your handlers without sacrificing
-// compatibility with existing http.Handlers nor imposing a specific router.
-//
-// Thanks to net/context deadline management, xhandler is able to enforce
-// a per request deadline and will cancel the context in when the client close
-// the connection unexpectedly.
-//
-// You may create net/context aware middlewares pretty much the same way as
-// you would do with http.Handler.
-package xhandler
-
-import (
- "net/http"
-
- "golang.org/x/net/context"
-)
-
-// HandlerC is a net/context aware http.Handler
-type HandlerC interface {
- ServeHTTPC(context.Context, http.ResponseWriter, *http.Request)
-}
-
-// HandlerFuncC type is an adapter to allow the use of ordinary functions
-// as a xhandler.Handler. If f is a function with the appropriate signature,
-// xhandler.HandlerFuncC(f) is a xhandler.Handler object that calls f.
-type HandlerFuncC func(context.Context, http.ResponseWriter, *http.Request)
-
-// ServeHTTPC calls f(ctx, w, r).
-func (f HandlerFuncC) ServeHTTPC(ctx context.Context, w http.ResponseWriter, r *http.Request) {
- f(ctx, w, r)
-}
-
-// New creates a conventional http.Handler injecting the provided root
-// context to sub handlers. This handler is used as a bridge between conventional
-// http.Handler and context aware handlers.
-func New(ctx context.Context, h HandlerC) http.Handler {
- return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- h.ServeHTTPC(ctx, w, r)
- })
-}
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/.travis.yml b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/.travis.yml
index 87ba52f98..76f38a482 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/.travis.yml
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/.travis.yml
@@ -2,18 +2,22 @@ language: go
sudo: false
go:
-- 1.0.3
- 1.1.2
- 1.2.2
- 1.3.3
-- 1.4.2
-- 1.5.1
+- 1.4
+- 1.5.4
+- 1.6.2
- tip
matrix:
allow_failures:
- go: tip
+before_script:
+- go get github.com/meatballhat/gfmxr/...
+
script:
- go vet ./...
- go test -v ./...
+- gfmxr -c $(grep -c 'package main' README.md) -s README.md
diff --git a/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/CHANGELOG.md b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/CHANGELOG.md
new file mode 100644
index 000000000..f623e59b7
--- /dev/null
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/CHANGELOG.md
@@ -0,0 +1,310 @@
+# Change Log
+
+**ATTN**: This project uses [semantic versioning](http://semver.org/).
+
+## [Unreleased]
+
+## [1.17.0] - 2016-05-09
+### Added
+- Pluggable flag-level help text rendering via `cli.DefaultFlagStringFunc`
+- `context.GlobalBoolT` was added as an analogue to `context.GlobalBool`
+- Support for hiding commands by setting `Hidden: true` -- this will hide the
+ commands in help output
+
+### Changed
+- `Float64Flag`, `IntFlag`, and `DurationFlag` default values are no longer
+ quoted in help text output.
+- All flag types now include `(default: {value})` strings following usage when a
+ default value can be (reasonably) detected.
+- `IntSliceFlag` and `StringSliceFlag` usage strings are now more consistent
+ with non-slice flag types
+- Apps now exit with a code of 3 if an unknown subcommand is specified
+ (previously they printed "No help topic for...", but still exited 0. This
+ makes it easier to script around apps built using `cli` since they can trust
+ that a 0 exit code indicated a successful execution.
+- cleanups based on [Go Report Card
+ feedback](https://goreportcard.com/report/github.com/codegangsta/cli)
+
+## [1.16.0] - 2016-05-02
+### Added
+- `Hidden` field on all flag struct types to omit from generated help text
+
+### Changed
+- `BashCompletionFlag` (`--enable-bash-completion`) is now omitted from
+generated help text via the `Hidden` field
+
+### Fixed
+- handling of error values in `HandleAction` and `HandleExitCoder`
+
+## [1.15.0] - 2016-04-30
+### Added
+- This file!
+- Support for placeholders in flag usage strings
+- `App.Metadata` map for arbitrary data/state management
+- `Set` and `GlobalSet` methods on `*cli.Context` for altering values after
+parsing.
+- Support for nested lookup of dot-delimited keys in structures loaded from
+YAML.
+
+### Changed
+- The `App.Action` and `Command.Action` now prefer a return signature of
+`func(*cli.Context) error`, as defined by `cli.ActionFunc`. If a non-nil
+`error` is returned, there may be two outcomes:
+ - If the error fulfills `cli.ExitCoder`, then `os.Exit` will be called
+ automatically
+ - Else the error is bubbled up and returned from `App.Run`
+- Specifying an `Action` with the legacy return signature of
+`func(*cli.Context)` will produce a deprecation message to stderr
+- Specifying an `Action` that is not a `func` type will produce a non-zero exit
+from `App.Run`
+- Specifying an `Action` func that has an invalid (input) signature will
+produce a non-zero exit from `App.Run`
+
+### Deprecated
+- <a name="deprecated-cli-app-runandexitonerror"></a>
+`cli.App.RunAndExitOnError`, which should now be done by returning an error
+that fulfills `cli.ExitCoder` to `cli.App.Run`.
+- <a name="deprecated-cli-app-action-signature"></a> the legacy signature for
+`cli.App.Action` of `func(*cli.Context)`, which should now have a return
+signature of `func(*cli.Context) error`, as defined by `cli.ActionFunc`.
+
+### Fixed
+- Added missing `*cli.Context.GlobalFloat64` method
+
+## [1.14.0] - 2016-04-03 (backfilled 2016-04-25)
+### Added
+- Codebeat badge
+- Support for categorization via `CategorizedHelp` and `Categories` on app.
+
+### Changed
+- Use `filepath.Base` instead of `path.Base` in `Name` and `HelpName`.
+
+### Fixed
+- Ensure version is not shown in help text when `HideVersion` set.
+
+## [1.13.0] - 2016-03-06 (backfilled 2016-04-25)
+### Added
+- YAML file input support.
+- `NArg` method on context.
+
+## [1.12.0] - 2016-02-17 (backfilled 2016-04-25)
+### Added
+- Custom usage error handling.
+- Custom text support in `USAGE` section of help output.
+- Improved help messages for empty strings.
+- AppVeyor CI configuration.
+
+### Changed
+- Removed `panic` from default help printer func.
+- De-duping and optimizations.
+
+### Fixed
+- Correctly handle `Before`/`After` at command level when no subcommands.
+- Case of literal `-` argument causing flag reordering.
+- Environment variable hints on Windows.
+- Docs updates.
+
+## [1.11.1] - 2015-12-21 (backfilled 2016-04-25)
+### Changed
+- Use `path.Base` in `Name` and `HelpName`
+- Export `GetName` on flag types.
+
+### Fixed
+- Flag parsing when skipping is enabled.
+- Test output cleanup.
+- Move completion check to account for empty input case.
+
+## [1.11.0] - 2015-11-15 (backfilled 2016-04-25)
+### Added
+- Destination scan support for flags.
+- Testing against `tip` in Travis CI config.
+
+### Changed
+- Go version in Travis CI config.
+
+### Fixed
+- Removed redundant tests.
+- Use correct example naming in tests.
+
+## [1.10.2] - 2015-10-29 (backfilled 2016-04-25)
+### Fixed
+- Remove unused var in bash completion.
+
+## [1.10.1] - 2015-10-21 (backfilled 2016-04-25)
+### Added
+- Coverage and reference logos in README.
+
+### Fixed
+- Use specified values in help and version parsing.
+- Only display app version and help message once.
+
+## [1.10.0] - 2015-10-06 (backfilled 2016-04-25)
+### Added
+- More tests for existing functionality.
+- `ArgsUsage` at app and command level for help text flexibility.
+
+### Fixed
+- Honor `HideHelp` and `HideVersion` in `App.Run`.
+- Remove juvenile word from README.
+
+## [1.9.0] - 2015-09-08 (backfilled 2016-04-25)
+### Added
+- `FullName` on command with accompanying help output update.
+- Set default `$PROG` in bash completion.
+
+### Changed
+- Docs formatting.
+
+### Fixed
+- Removed self-referential imports in tests.
+
+## [1.8.0] - 2015-06-30 (backfilled 2016-04-25)
+### Added
+- Support for `Copyright` at app level.
+- `Parent` func at context level to walk up context lineage.
+
+### Fixed
+- Global flag processing at top level.
+
+## [1.7.1] - 2015-06-11 (backfilled 2016-04-25)
+### Added
+- Aggregate errors from `Before`/`After` funcs.
+- Doc comments on flag structs.
+- Include non-global flags when checking version and help.
+- Travis CI config updates.
+
+### Fixed
+- Ensure slice type flags have non-nil values.
+- Collect global flags from the full command hierarchy.
+- Docs prose.
+
+## [1.7.0] - 2015-05-03 (backfilled 2016-04-25)
+### Changed
+- `HelpPrinter` signature includes output writer.
+
+### Fixed
+- Specify go 1.1+ in docs.
+- Set `Writer` when running command as app.
+
+## [1.6.0] - 2015-03-23 (backfilled 2016-04-25)
+### Added
+- Multiple author support.
+- `NumFlags` at context level.
+- `Aliases` at command level.
+
+### Deprecated
+- `ShortName` at command level.
+
+### Fixed
+- Subcommand help output.
+- Backward compatible support for deprecated `Author` and `Email` fields.
+- Docs regarding `Names`/`Aliases`.
+
+## [1.5.0] - 2015-02-20 (backfilled 2016-04-25)
+### Added
+- `After` hook func support at app and command level.
+
+### Fixed
+- Use parsed context when running command as subcommand.
+- Docs prose.
+
+## [1.4.1] - 2015-01-09 (backfilled 2016-04-25)
+### Added
+- Support for hiding `-h / --help` flags, but not `help` subcommand.
+- Stop flag parsing after `--`.
+
+### Fixed
+- Help text for generic flags to specify single value.
+- Use double quotes in output for defaults.
+- Use `ParseInt` instead of `ParseUint` for int environment var values.
+- Use `0` as base when parsing int environment var values.
+
+## [1.4.0] - 2014-12-12 (backfilled 2016-04-25)
+### Added
+- Support for environment variable lookup "cascade".
+- Support for `Stdout` on app for output redirection.
+
+### Fixed
+- Print command help instead of app help in `ShowCommandHelp`.
+
+## [1.3.1] - 2014-11-13 (backfilled 2016-04-25)
+### Added
+- Docs and example code updates.
+
+### Changed
+- Default `-v / --version` flag made optional.
+
+## [1.3.0] - 2014-08-10 (backfilled 2016-04-25)
+### Added
+- `FlagNames` at context level.
+- Exposed `VersionPrinter` var for more control over version output.
+- Zsh completion hook.
+- `AUTHOR` section in default app help template.
+- Contribution guidelines.
+- `DurationFlag` type.
+
+## [1.2.0] - 2014-08-02
+### Added
+- Support for environment variable defaults on flags plus tests.
+
+## [1.1.0] - 2014-07-15
+### Added
+- Bash completion.
+- Optional hiding of built-in help command.
+- Optional skipping of flag parsing at command level.
+- `Author`, `Email`, and `Compiled` metadata on app.
+- `Before` hook func support at app and command level.
+- `CommandNotFound` func support at app level.
+- Command reference available on context.
+- `GenericFlag` type.
+- `Float64Flag` type.
+- `BoolTFlag` type.
+- `IsSet` flag helper on context.
+- More flag lookup funcs at context level.
+- More tests &amp; docs.
+
+### Changed
+- Help template updates to account for presence/absence of flags.
+- Separated subcommand help template.
+- Exposed `HelpPrinter` var for more control over help output.
+
+## [1.0.0] - 2013-11-01
+### Added
+- `help` flag in default app flag set and each command flag set.
+- Custom handling of argument parsing errors.
+- Command lookup by name at app level.
+- `StringSliceFlag` type and supporting `StringSlice` type.
+- `IntSliceFlag` type and supporting `IntSlice` type.
+- Slice type flag lookups by name at context level.
+- Export of app and command help functions.
+- More tests &amp; docs.
+
+## 0.1.0 - 2013-07-22
+### Added
+- Initial implementation.
+
+[Unreleased]: https://github.com/codegangsta/cli/compare/v1.17.0...HEAD
+[1.17.0]: https://github.com/codegangsta/cli/compare/v1.16.0...v1.17.0
+[1.16.0]: https://github.com/codegangsta/cli/compare/v1.15.0...v1.16.0
+[1.15.0]: https://github.com/codegangsta/cli/compare/v1.14.0...v1.15.0
+[1.14.0]: https://github.com/codegangsta/cli/compare/v1.13.0...v1.14.0
+[1.13.0]: https://github.com/codegangsta/cli/compare/v1.12.0...v1.13.0
+[1.12.0]: https://github.com/codegangsta/cli/compare/v1.11.1...v1.12.0
+[1.11.1]: https://github.com/codegangsta/cli/compare/v1.11.0...v1.11.1
+[1.11.0]: https://github.com/codegangsta/cli/compare/v1.10.2...v1.11.0
+[1.10.2]: https://github.com/codegangsta/cli/compare/v1.10.1...v1.10.2
+[1.10.1]: https://github.com/codegangsta/cli/compare/v1.10.0...v1.10.1
+[1.10.0]: https://github.com/codegangsta/cli/compare/v1.9.0...v1.10.0
+[1.9.0]: https://github.com/codegangsta/cli/compare/v1.8.0...v1.9.0
+[1.8.0]: https://github.com/codegangsta/cli/compare/v1.7.1...v1.8.0
+[1.7.1]: https://github.com/codegangsta/cli/compare/v1.7.0...v1.7.1
+[1.7.0]: https://github.com/codegangsta/cli/compare/v1.6.0...v1.7.0
+[1.6.0]: https://github.com/codegangsta/cli/compare/v1.5.0...v1.6.0
+[1.5.0]: https://github.com/codegangsta/cli/compare/v1.4.1...v1.5.0
+[1.4.1]: https://github.com/codegangsta/cli/compare/v1.4.0...v1.4.1
+[1.4.0]: https://github.com/codegangsta/cli/compare/v1.3.1...v1.4.0
+[1.3.1]: https://github.com/codegangsta/cli/compare/v1.3.0...v1.3.1
+[1.3.0]: https://github.com/codegangsta/cli/compare/v1.2.0...v1.3.0
+[1.2.0]: https://github.com/codegangsta/cli/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/codegangsta/cli/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/codegangsta/cli/compare/v0.1.0...v1.0.0
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/LICENSE b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/LICENSE
index 5515ccfb7..5515ccfb7 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/LICENSE
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/LICENSE
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/README.md b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/README.md
index ae0a4ca3a..c1709cef8 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/README.md
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/README.md
@@ -1,22 +1,24 @@
[![Coverage](http://gocover.io/_badge/github.com/codegangsta/cli?0)](http://gocover.io/github.com/codegangsta/cli)
[![Build Status](https://travis-ci.org/codegangsta/cli.svg?branch=master)](https://travis-ci.org/codegangsta/cli)
[![GoDoc](https://godoc.org/github.com/codegangsta/cli?status.svg)](https://godoc.org/github.com/codegangsta/cli)
+[![codebeat](https://codebeat.co/badges/0a8f30aa-f975-404b-b878-5fab3ae1cc5f)](https://codebeat.co/projects/github-com-codegangsta-cli)
+[![Go Report Card](https://goreportcard.com/badge/codegangsta/cli)](https://goreportcard.com/report/codegangsta/cli)
-# cli.go
+# cli
-`cli.go` is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
+cli is a simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
## Overview
Command line apps are usually so tiny that there is absolutely no reason why your code should *not* be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.
-**This is where `cli.go` comes into play.** `cli.go` makes command line programming fun, organized, and expressive!
+**This is where cli comes into play.** cli makes command line programming fun, organized, and expressive!
## Installation
Make sure you have a working Go environment (go 1.1+ is *required*). [See the install instructions](http://golang.org/doc/install.html).
-To install `cli.go`, simply run:
+To install cli, simply run:
```
$ go get github.com/codegangsta/cli
```
@@ -28,7 +30,7 @@ export PATH=$PATH:$GOPATH/bin
## Getting Started
-One of the philosophies behind `cli.go` is that an API should be playful and full of discovery. So a `cli.go` app can be as little as one line of code in `main()`.
+One of the philosophies behind cli is that an API should be playful and full of discovery. So a cli app can be as little as one line of code in `main()`.
``` go
package main
@@ -45,11 +47,16 @@ func main() {
This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:
+<!-- {
+ "output": "boom! I say!"
+} -->
``` go
package main
import (
+ "fmt"
"os"
+
"github.com/codegangsta/cli"
)
@@ -57,10 +64,11 @@ func main() {
app := cli.NewApp()
app.Name = "boom"
app.Usage = "make an explosive entrance"
- app.Action = func(c *cli.Context) {
- println("boom! I say!")
+ app.Action = func(c *cli.Context) error {
+ fmt.Println("boom! I say!")
+ return nil
}
-
+
app.Run(os.Args)
}
```
@@ -73,11 +81,16 @@ Being a programmer can be a lonely job. Thankfully by the power of automation th
Start by creating a directory named `greet`, and within it, add a file, `greet.go` with the following code in it:
+<!-- {
+ "output": "Hello friend!"
+} -->
``` go
package main
import (
+ "fmt"
"os"
+
"github.com/codegangsta/cli"
)
@@ -85,8 +98,9 @@ func main() {
app := cli.NewApp()
app.Name = "greet"
app.Usage = "fight the loneliness!"
- app.Action = func(c *cli.Context) {
- println("Hello friend!")
+ app.Action = func(c *cli.Context) error {
+ fmt.Println("Hello friend!")
+ return nil
}
app.Run(os.Args)
@@ -106,7 +120,7 @@ $ greet
Hello friend!
```
-`cli.go` also generates neat help text:
+cli also generates neat help text:
```
$ greet help
@@ -132,8 +146,9 @@ You can lookup arguments by calling the `Args` function on `cli.Context`.
``` go
...
-app.Action = func(c *cli.Context) {
- println("Hello", c.Args()[0])
+app.Action = func(c *cli.Context) error {
+ fmt.Println("Hello", c.Args()[0])
+ return nil
}
...
```
@@ -151,16 +166,17 @@ app.Flags = []cli.Flag {
Usage: "language for the greeting",
},
}
-app.Action = func(c *cli.Context) {
+app.Action = func(c *cli.Context) error {
name := "someone"
- if len(c.Args()) > 0 {
+ if c.NArg() > 0 {
name = c.Args()[0]
}
if c.String("lang") == "spanish" {
- println("Hola", name)
+ fmt.Println("Hola", name)
} else {
- println("Hello", name)
+ fmt.Println("Hello", name)
}
+ return nil
}
...
```
@@ -178,22 +194,45 @@ app.Flags = []cli.Flag {
Destination: &language,
},
}
-app.Action = func(c *cli.Context) {
+app.Action = func(c *cli.Context) error {
name := "someone"
- if len(c.Args()) > 0 {
+ if c.NArg() > 0 {
name = c.Args()[0]
}
if language == "spanish" {
- println("Hola", name)
+ fmt.Println("Hola", name)
} else {
- println("Hello", name)
+ fmt.Println("Hello", name)
}
+ return nil
}
...
```
See full list of flags at http://godoc.org/github.com/codegangsta/cli
+#### Placeholder Values
+
+Sometimes it's useful to specify a flag's value within the usage string itself. Such placeholders are
+indicated with back quotes.
+
+For example this:
+
+```go
+cli.StringFlag{
+ Name: "config, c",
+ Usage: "Load configuration from `FILE`",
+}
+```
+
+Will result in help output like:
+
+```
+--config FILE, -c FILE Load configuration from FILE
+```
+
+Note that only the first placeholder is used. Subsequent back-quoted words will be left as-is.
+
#### Alternate Names
You can set alternate (or short) names for flags by providing a comma-delimited list for the `Name`. e.g.
@@ -238,6 +277,49 @@ app.Flags = []cli.Flag {
}
```
+#### Values from alternate input sources (YAML and others)
+
+There is a separate package altsrc that adds support for getting flag values from other input sources like YAML.
+
+In order to get values for a flag from an alternate input source the following code would be added to wrap an existing cli.Flag like below:
+
+``` go
+ altsrc.NewIntFlag(cli.IntFlag{Name: "test"})
+```
+
+Initialization must also occur for these flags. Below is an example initializing getting data from a yaml file below.
+
+``` go
+ command.Before = altsrc.InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
+```
+
+The code above will use the "load" string as a flag name to get the file name of a yaml file from the cli.Context.
+It will then use that file name to initialize the yaml input source for any flags that are defined on that command.
+As a note the "load" flag used would also have to be defined on the command flags in order for this code snipped to work.
+
+Currently only YAML files are supported but developers can add support for other input sources by implementing the
+altsrc.InputSourceContext for their given sources.
+
+Here is a more complete sample of a command using YAML support:
+
+``` go
+ command := &cli.Command{
+ Name: "test-cmd",
+ Aliases: []string{"tc"},
+ Usage: "this is for testing",
+ Description: "testing",
+ Action: func(c *cli.Context) error {
+ // Action to run
+ return nil
+ },
+ Flags: []cli.Flag{
+ NewIntFlag(cli.IntFlag{Name: "test"}),
+ cli.StringFlag{Name: "load"}},
+ }
+ command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
+ err := command.Run(c)
+```
+
### Subcommands
Subcommands can be defined for a more git-like command line app.
@@ -249,16 +331,18 @@ app.Commands = []cli.Command{
Name: "add",
Aliases: []string{"a"},
Usage: "add a task to the list",
- Action: func(c *cli.Context) {
- println("added task: ", c.Args().First())
+ Action: func(c *cli.Context) error {
+ fmt.Println("added task: ", c.Args().First())
+ return nil
},
},
{
Name: "complete",
Aliases: []string{"c"},
Usage: "complete a task on the list",
- Action: func(c *cli.Context) {
- println("completed task: ", c.Args().First())
+ Action: func(c *cli.Context) error {
+ fmt.Println("completed task: ", c.Args().First())
+ return nil
},
},
{
@@ -269,15 +353,17 @@ app.Commands = []cli.Command{
{
Name: "add",
Usage: "add a new template",
- Action: func(c *cli.Context) {
- println("new task template: ", c.Args().First())
+ Action: func(c *cli.Context) error {
+ fmt.Println("new task template: ", c.Args().First())
+ return nil
},
},
{
Name: "remove",
Usage: "remove an existing template",
- Action: func(c *cli.Context) {
- println("removed task template: ", c.Args().First())
+ Action: func(c *cli.Context) error {
+ fmt.Println("removed task template: ", c.Args().First())
+ return nil
},
},
},
@@ -286,6 +372,80 @@ app.Commands = []cli.Command{
...
```
+### Subcommands categories
+
+For additional organization in apps that have many subcommands, you can
+associate a category for each command to group them together in the help
+output.
+
+E.g.
+
+```go
+...
+ app.Commands = []cli.Command{
+ {
+ Name: "noop",
+ },
+ {
+ Name: "add",
+ Category: "template",
+ },
+ {
+ Name: "remove",
+ Category: "template",
+ },
+ }
+...
+```
+
+Will include:
+
+```
+...
+COMMANDS:
+ noop
+
+ Template actions:
+ add
+ remove
+...
+```
+
+### Exit code
+
+Calling `App.Run` will not automatically call `os.Exit`, which means that by
+default the exit code will "fall through" to being `0`. An explicit exit code
+may be set by returning a non-nil error that fulfills `cli.ExitCoder`, *or* a
+`cli.MultiError` that includes an error that fulfills `cli.ExitCoder`, e.g.:
+
+``` go
+package main
+
+import (
+ "os"
+
+ "github.com/codegangsta/cli"
+)
+
+func main() {
+ app := cli.NewApp()
+ app.Flags = []cli.Flag{
+ cli.BoolTFlag{
+ Name: "ginger-crouton",
+ Usage: "is it in the soup?",
+ },
+ }
+ app.Action = func(ctx *cli.Context) error {
+ if !ctx.Bool("ginger-crouton") {
+ return cli.NewExitError("it is not in the soup", 86)
+ }
+ return nil
+ }
+
+ app.Run(os.Args)
+}
+```
+
### Bash Completion
You can enable completion commands by setting the `EnableBashCompletion`
@@ -303,12 +463,13 @@ app.Commands = []cli.Command{
Name: "complete",
Aliases: []string{"c"},
Usage: "complete a task on the list",
- Action: func(c *cli.Context) {
- println("completed task: ", c.Args().First())
+ Action: func(c *cli.Context) error {
+ fmt.Println("completed task: ", c.Args().First())
+ return nil
},
BashComplete: func(c *cli.Context) {
// This will complete if no args are passed
- if len(c.Args()) > 0 {
+ if c.NArg() > 0 {
return
}
for _, t := range tasks {
@@ -343,6 +504,72 @@ Alternatively, you can just document that users should source the generic
`autocomplete/bash_autocomplete` in their bash configuration with `$PROG` set
to the name of their program (as above).
+### Generated Help Text Customization
+
+All of the help text generation may be customized, and at multiple levels. The
+templates are exposed as variables `AppHelpTemplate`, `CommandHelpTemplate`, and
+`SubcommandHelpTemplate` which may be reassigned or augmented, and full override
+is possible by assigning a compatible func to the `cli.HelpPrinter` variable,
+e.g.:
+
+<!-- {
+ "output": "Ha HA. I pwnd the help!!1"
+} -->
+``` go
+package main
+
+import (
+ "fmt"
+ "io"
+ "os"
+
+ "github.com/codegangsta/cli"
+)
+
+func main() {
+ // EXAMPLE: Append to an existing template
+ cli.AppHelpTemplate = fmt.Sprintf(`%s
+
+WEBSITE: http://awesometown.example.com
+
+SUPPORT: support@awesometown.example.com
+
+`, cli.AppHelpTemplate)
+
+ // EXAMPLE: Override a template
+ cli.AppHelpTemplate = `NAME:
+ {{.Name}} - {{.Usage}}
+USAGE:
+ {{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command
+[command options]{{end}} {{if
+.ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
+ {{if len .Authors}}
+AUTHOR(S):
+ {{range .Authors}}{{ . }}{{end}}
+ {{end}}{{if .Commands}}
+COMMANDS:
+{{range .Commands}}{{if not .HideHelp}} {{join .Names ", "}}{{ "\t"
+}}{{.Usage}}{{ "\n" }}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
+GLOBAL OPTIONS:
+ {{range .VisibleFlags}}{{.}}
+ {{end}}{{end}}{{if .Copyright }}
+COPYRIGHT:
+ {{.Copyright}}
+ {{end}}{{if .Version}}
+VERSION:
+ {{.Version}}
+ {{end}}
+`
+
+ // EXAMPLE: Replace the `HelpPrinter` func
+ cli.HelpPrinter = func(w io.Writer, templ string, data interface{}) {
+ fmt.Println("Ha HA. I pwnd the help!!1")
+ }
+
+ cli.NewApp().Run(os.Args)
+}
+```
+
## Contribution Guidelines
Feel free to put up a pull request to fix a bug or maybe add a feature. I will give it a code review and make sure that it does not break backwards compatibility. If I or any other collaborators agree that it is in line with the vision of the project, we will work with you to get the code into a mergeable state and merge it into the master branch.
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/app.go b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/app.go
index 1ea3fd0b1..7c9b95804 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/app.go
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/app.go
@@ -5,10 +5,27 @@ import (
"io"
"io/ioutil"
"os"
- "path"
+ "path/filepath"
+ "reflect"
+ "sort"
"time"
)
+var (
+ changeLogURL = "https://github.com/codegangsta/cli/blob/master/CHANGELOG.md"
+ appActionDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-action-signature", changeLogURL)
+ runAndExitOnErrorDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-runandexitonerror", changeLogURL)
+
+ contactSysadmin = "This is an error in the application. Please contact the distributor of this application if this is not you."
+
+ errNonFuncAction = NewExitError("ERROR invalid Action type. "+
+ fmt.Sprintf("Must be a func of type `cli.ActionFunc`. %s", contactSysadmin)+
+ fmt.Sprintf("See %s", appActionDeprecationURL), 2)
+ errInvalidActionSignature = NewExitError("ERROR invalid Action signature. "+
+ fmt.Sprintf("Must be `cli.ActionFunc`. %s", contactSysadmin)+
+ fmt.Sprintf("See %s", appActionDeprecationURL), 2)
+)
+
// App is the main structure of a cli application. It is recommended that
// an app be created with the cli.NewApp() function
type App struct {
@@ -32,24 +49,27 @@ type App struct {
EnableBashCompletion bool
// Boolean to hide built-in help command
HideHelp bool
- // Boolean to hide built-in version flag
+ // Boolean to hide built-in version flag and the VERSION section of help
HideVersion bool
+ // Populate on app startup, only gettable through method Categories()
+ categories CommandCategories
// An action to execute when the bash-completion flag is set
- BashComplete func(context *Context)
+ BashComplete BashCompleteFunc
// An action to execute before any subcommands are run, but after the context is ready
// If a non-nil error is returned, no subcommands are run
- Before func(context *Context) error
+ Before BeforeFunc
// An action to execute after any subcommands are run, but after the subcommand has finished
// It is run even if Action() panics
- After func(context *Context) error
+ After AfterFunc
// The action to execute when no subcommands are specified
- Action func(context *Context)
+ Action interface{}
+ // TODO: replace `Action: interface{}` with `Action: ActionFunc` once some kind
+ // of deprecation period has passed, maybe?
+
// Execute this function if the proper command cannot be found
- CommandNotFound func(context *Context, command string)
- // Execute this function, if an usage error occurs. This is useful for displaying customized usage error messages.
- // This function is able to replace the original error messages.
- // If this function is not set, the "Incorrect usage" is displayed and the execution is interrupted.
- OnUsageError func(context *Context, err error, isSubcommand bool) error
+ CommandNotFound CommandNotFoundFunc
+ // Execute this function if an usage error occurs
+ OnUsageError OnUsageErrorFunc
// Compilation date
Compiled time.Time
// List of all authors who contributed
@@ -62,6 +82,12 @@ type App struct {
Email string
// Writer writer to write output to
Writer io.Writer
+ // ErrWriter writes error output
+ ErrWriter io.Writer
+ // Other custom info
+ Metadata map[string]interface{}
+
+ didSetup bool
}
// Tries to find out when this binary was compiled.
@@ -74,11 +100,12 @@ func compileTime() time.Time {
return info.ModTime()
}
-// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
+// NewApp creates a new cli Application with some reasonable defaults for Name,
+// Usage, Version and Action.
func NewApp() *App {
return &App{
- Name: path.Base(os.Args[0]),
- HelpName: path.Base(os.Args[0]),
+ Name: filepath.Base(os.Args[0]),
+ HelpName: filepath.Base(os.Args[0]),
Usage: "A new cli application",
UsageText: "",
Version: "0.0.0",
@@ -89,8 +116,16 @@ func NewApp() *App {
}
}
-// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
-func (a *App) Run(arguments []string) (err error) {
+// Setup runs initialization code to ensure all data structures are ready for
+// `Run` or inspection prior to `Run`. It is internally called by `Run`, but
+// will return early if setup has already happened.
+func (a *App) Setup() {
+ if a.didSetup {
+ return
+ }
+
+ a.didSetup = true
+
if a.Author != "" || a.Email != "" {
a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email})
}
@@ -104,6 +139,12 @@ func (a *App) Run(arguments []string) (err error) {
}
a.Commands = newCmds
+ a.categories = CommandCategories{}
+ for _, command := range a.Commands {
+ a.categories = a.categories.AddCommand(command.Category, command)
+ }
+ sort.Sort(a.categories)
+
// append help to commands
if a.Command(helpCommand.Name) == nil && !a.HideHelp {
a.Commands = append(a.Commands, helpCommand)
@@ -120,6 +161,12 @@ func (a *App) Run(arguments []string) (err error) {
if !a.HideVersion {
a.appendFlag(VersionFlag)
}
+}
+
+// Run is the entry point to the cli app. Parses the arguments slice and routes
+// to the proper flag/args combination
+func (a *App) Run(arguments []string) (err error) {
+ a.Setup()
// parse flags
set := flagSet(a.Name, a.Flags)
@@ -140,12 +187,12 @@ func (a *App) Run(arguments []string) (err error) {
if err != nil {
if a.OnUsageError != nil {
err := a.OnUsageError(context, err, false)
- return err
- } else {
- fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
- ShowAppHelp(context)
+ HandleExitCoder(err)
return err
}
+ fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
+ ShowAppHelp(context)
+ return err
}
if !a.HideHelp && checkHelp(context) {
@@ -171,10 +218,12 @@ func (a *App) Run(arguments []string) (err error) {
}
if a.Before != nil {
- err = a.Before(context)
- if err != nil {
- fmt.Fprintf(a.Writer, "%v\n\n", err)
+ beforeErr := a.Before(context)
+ if beforeErr != nil {
+ fmt.Fprintf(a.Writer, "%v\n\n", beforeErr)
ShowAppHelp(context)
+ HandleExitCoder(beforeErr)
+ err = beforeErr
return err
}
}
@@ -189,19 +238,25 @@ func (a *App) Run(arguments []string) (err error) {
}
// Run default Action
- a.Action(context)
- return nil
+ err = HandleAction(a.Action, context)
+
+ HandleExitCoder(err)
+ return err
}
-// Another entry point to the cli app, takes care of passing arguments and error handling
+// DEPRECATED: Another entry point to the cli app, takes care of passing arguments and error handling
func (a *App) RunAndExitOnError() {
+ fmt.Fprintf(a.errWriter(),
+ "DEPRECATED cli.App.RunAndExitOnError. %s See %s\n",
+ contactSysadmin, runAndExitOnErrorDeprecationURL)
if err := a.Run(os.Args); err != nil {
- fmt.Fprintln(os.Stderr, err)
- os.Exit(1)
+ fmt.Fprintln(a.errWriter(), err)
+ OsExiter(1)
}
}
-// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
+// RunAsSubcommand invokes the subcommand given the context, parses ctx.Args() to
+// generate command-specific flags
func (a *App) RunAsSubcommand(ctx *Context) (err error) {
// append help to commands
if len(a.Commands) > 0 {
@@ -252,12 +307,12 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
if err != nil {
if a.OnUsageError != nil {
err = a.OnUsageError(context, err, true)
- return err
- } else {
- fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
- ShowSubcommandHelp(context)
+ HandleExitCoder(err)
return err
}
+ fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
+ ShowSubcommandHelp(context)
+ return err
}
if len(a.Commands) > 0 {
@@ -274,6 +329,7 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
defer func() {
afterErr := a.After(context)
if afterErr != nil {
+ HandleExitCoder(err)
if err != nil {
err = NewMultiError(err, afterErr)
} else {
@@ -284,8 +340,10 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
}
if a.Before != nil {
- err := a.Before(context)
- if err != nil {
+ beforeErr := a.Before(context)
+ if beforeErr != nil {
+ HandleExitCoder(beforeErr)
+ err = beforeErr
return err
}
}
@@ -300,12 +358,13 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
}
// Run default Action
- a.Action(context)
+ err = HandleAction(a.Action, context)
- return nil
+ HandleExitCoder(err)
+ return err
}
-// Returns the named command on App. Returns nil if the command does not exist
+// Command returns the named command on App. Returns nil if the command does not exist
func (a *App) Command(name string) *Command {
for _, c := range a.Commands {
if c.HasName(name) {
@@ -316,6 +375,46 @@ func (a *App) Command(name string) *Command {
return nil
}
+// Categories returns a slice containing all the categories with the commands they contain
+func (a *App) Categories() CommandCategories {
+ return a.categories
+}
+
+// VisibleCategories returns a slice of categories and commands that are
+// Hidden=false
+func (a *App) VisibleCategories() []*CommandCategory {
+ ret := []*CommandCategory{}
+ for _, category := range a.categories {
+ if visible := func() *CommandCategory {
+ for _, command := range category.Commands {
+ if !command.Hidden {
+ return category
+ }
+ }
+ return nil
+ }(); visible != nil {
+ ret = append(ret, visible)
+ }
+ }
+ return ret
+}
+
+// VisibleCommands returns a slice of the Commands with Hidden=false
+func (a *App) VisibleCommands() []Command {
+ ret := []Command{}
+ for _, command := range a.Commands {
+ if !command.Hidden {
+ ret = append(ret, command)
+ }
+ }
+ return ret
+}
+
+// VisibleFlags returns a slice of the Flags with Hidden=false
+func (a *App) VisibleFlags() []Flag {
+ return visibleFlags(a.Flags)
+}
+
func (a *App) hasFlag(flag Flag) bool {
for _, f := range a.Flags {
if flag == f {
@@ -326,6 +425,16 @@ func (a *App) hasFlag(flag Flag) bool {
return false
}
+func (a *App) errWriter() io.Writer {
+
+ // When the app ErrWriter is nil use the package level one.
+ if a.ErrWriter == nil {
+ return ErrWriter
+ }
+
+ return a.ErrWriter
+}
+
func (a *App) appendFlag(flag Flag) {
if !a.hasFlag(flag) {
a.Flags = append(a.Flags, flag)
@@ -347,3 +456,43 @@ func (a Author) String() string {
return fmt.Sprintf("%v %v", a.Name, e)
}
+
+// HandleAction uses ✧✧✧reflection✧✧✧ to figure out if the given Action is an
+// ActionFunc, a func with the legacy signature for Action, or some other
+// invalid thing. If it's an ActionFunc or a func with the legacy signature for
+// Action, the func is run!
+func HandleAction(action interface{}, context *Context) (err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ switch r.(type) {
+ case error:
+ err = r.(error)
+ default:
+ err = NewExitError(fmt.Sprintf("ERROR unknown Action error: %v. See %s", r, appActionDeprecationURL), 2)
+ }
+ }
+ }()
+
+ if reflect.TypeOf(action).Kind() != reflect.Func {
+ return errNonFuncAction
+ }
+
+ vals := reflect.ValueOf(action).Call([]reflect.Value{reflect.ValueOf(context)})
+
+ if len(vals) == 0 {
+ fmt.Fprintf(ErrWriter,
+ "DEPRECATED Action signature. Must be `cli.ActionFunc`. %s See %s\n",
+ contactSysadmin, appActionDeprecationURL)
+ return nil
+ }
+
+ if len(vals) > 1 {
+ return errInvalidActionSignature
+ }
+
+ if retErr, ok := vals[0].Interface().(error); vals[0].IsValid() && ok {
+ return retErr
+ }
+
+ return err
+}
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/appveyor.yml b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/appveyor.yml
index 3ca7afabd..3ca7afabd 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/appveyor.yml
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/appveyor.yml
diff --git a/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/category.go b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/category.go
new file mode 100644
index 000000000..1a6055023
--- /dev/null
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/category.go
@@ -0,0 +1,44 @@
+package cli
+
+// CommandCategories is a slice of *CommandCategory.
+type CommandCategories []*CommandCategory
+
+// CommandCategory is a category containing commands.
+type CommandCategory struct {
+ Name string
+ Commands Commands
+}
+
+func (c CommandCategories) Less(i, j int) bool {
+ return c[i].Name < c[j].Name
+}
+
+func (c CommandCategories) Len() int {
+ return len(c)
+}
+
+func (c CommandCategories) Swap(i, j int) {
+ c[i], c[j] = c[j], c[i]
+}
+
+// AddCommand adds a command to a category.
+func (c CommandCategories) AddCommand(category string, command Command) CommandCategories {
+ for _, commandCategory := range c {
+ if commandCategory.Name == category {
+ commandCategory.Commands = append(commandCategory.Commands, command)
+ return c
+ }
+ }
+ return append(c, &CommandCategory{Name: category, Commands: []Command{command}})
+}
+
+// VisibleCommands returns a slice of the Commands with Hidden=false
+func (c *CommandCategory) VisibleCommands() []Command {
+ ret := []Command{}
+ for _, command := range c.Commands {
+ if !command.Hidden {
+ ret = append(ret, command)
+ }
+ }
+ return ret
+}
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/cli.go b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/cli.go
index 31dc9124d..f0440c563 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/cli.go
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/cli.go
@@ -10,31 +10,10 @@
// app := cli.NewApp()
// app.Name = "greet"
// app.Usage = "say a greeting"
-// app.Action = func(c *cli.Context) {
+// app.Action = func(c *cli.Context) error {
// println("Greetings")
// }
//
// app.Run(os.Args)
// }
package cli
-
-import (
- "strings"
-)
-
-type MultiError struct {
- Errors []error
-}
-
-func NewMultiError(err ...error) MultiError {
- return MultiError{Errors: err}
-}
-
-func (m MultiError) Error() string {
- errs := make([]string, len(m.Errors))
- for i, err := range m.Errors {
- errs[i] = err.Error()
- }
-
- return strings.Join(errs, "\n")
-}
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/command.go b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/command.go
index bbf42ae40..8950ccae4 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/command.go
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/command.go
@@ -3,6 +3,7 @@ package cli
import (
"fmt"
"io/ioutil"
+ "sort"
"strings"
)
@@ -22,35 +23,40 @@ type Command struct {
Description string
// A short description of the arguments of this command
ArgsUsage string
+ // The category the command is part of
+ Category string
// The function to call when checking for bash command completions
- BashComplete func(context *Context)
+ BashComplete BashCompleteFunc
// An action to execute before any sub-subcommands are run, but after the context is ready
// If a non-nil error is returned, no sub-subcommands are run
- Before func(context *Context) error
+ Before BeforeFunc
// An action to execute after any subcommands are run, but after the subcommand has finished
// It is run even if Action() panics
- After func(context *Context) error
+ After AfterFunc
// The function to call when this command is invoked
- Action func(context *Context)
- // Execute this function, if an usage error occurs. This is useful for displaying customized usage error messages.
- // This function is able to replace the original error messages.
- // If this function is not set, the "Incorrect usage" is displayed and the execution is interrupted.
- OnUsageError func(context *Context, err error) error
+ Action interface{}
+ // TODO: replace `Action: interface{}` with `Action: ActionFunc` once some kind
+ // of deprecation period has passed, maybe?
+
+ // Execute this function if a usage error occurs.
+ OnUsageError OnUsageErrorFunc
// List of child commands
- Subcommands []Command
+ Subcommands Commands
// List of flags to parse
Flags []Flag
// Treat all flags as normal arguments if true
SkipFlagParsing bool
// Boolean to hide built-in help command
HideHelp bool
+ // Boolean to hide this command from help or completion
+ Hidden bool
// Full name of command for help, defaults to full command name, including parent commands.
HelpName string
commandNamePath []string
}
-// Returns the full name of the command.
+// FullName returns the full name of the command.
// For subcommands this ensures that parent commands are part of the command path
func (c Command) FullName() string {
if c.commandNamePath == nil {
@@ -59,7 +65,10 @@ func (c Command) FullName() string {
return strings.Join(c.commandNamePath, " ")
}
-// Invokes the command given the context, parses ctx.Args() to generate command-specific flags
+// Commands is a slice of Command
+type Commands []Command
+
+// Run invokes the command given the context, parses ctx.Args() to generate command-specific flags
func (c Command) Run(ctx *Context) (err error) {
if len(c.Subcommands) > 0 {
return c.startApp(ctx)
@@ -120,14 +129,14 @@ func (c Command) Run(ctx *Context) (err error) {
if err != nil {
if c.OnUsageError != nil {
- err := c.OnUsageError(ctx, err)
- return err
- } else {
- fmt.Fprintln(ctx.App.Writer, "Incorrect Usage.")
- fmt.Fprintln(ctx.App.Writer)
- ShowCommandHelp(ctx, c.Name)
+ err := c.OnUsageError(ctx, err, false)
+ HandleExitCoder(err)
return err
}
+ fmt.Fprintln(ctx.App.Writer, "Incorrect Usage.")
+ fmt.Fprintln(ctx.App.Writer)
+ ShowCommandHelp(ctx, c.Name)
+ return err
}
nerr := normalizeFlags(c.Flags, set)
@@ -137,6 +146,7 @@ func (c Command) Run(ctx *Context) (err error) {
ShowCommandHelp(ctx, c.Name)
return nerr
}
+
context := NewContext(ctx.App, set, ctx)
if checkCommandCompletions(context, c.Name) {
@@ -151,6 +161,7 @@ func (c Command) Run(ctx *Context) (err error) {
defer func() {
afterErr := c.After(context)
if afterErr != nil {
+ HandleExitCoder(err)
if err != nil {
err = NewMultiError(err, afterErr)
} else {
@@ -161,20 +172,26 @@ func (c Command) Run(ctx *Context) (err error) {
}
if c.Before != nil {
- err := c.Before(context)
+ err = c.Before(context)
if err != nil {
fmt.Fprintln(ctx.App.Writer, err)
fmt.Fprintln(ctx.App.Writer)
ShowCommandHelp(ctx, c.Name)
+ HandleExitCoder(err)
return err
}
}
context.Command = c
- c.Action(context)
- return nil
+ err = HandleAction(c.Action, context)
+
+ if err != nil {
+ HandleExitCoder(err)
+ }
+ return err
}
+// Names returns the names including short names and aliases.
func (c Command) Names() []string {
names := []string{c.Name}
@@ -185,7 +202,7 @@ func (c Command) Names() []string {
return append(names, c.Aliases...)
}
-// Returns true if Command.Name or Command.ShortName matches given name
+// HasName returns true if Command.Name or Command.ShortName matches given name
func (c Command) HasName(name string) bool {
for _, n := range c.Names() {
if n == name {
@@ -197,7 +214,7 @@ func (c Command) HasName(name string) bool {
func (c Command) startApp(ctx *Context) error {
app := NewApp()
-
+ app.Metadata = ctx.App.Metadata
// set the name and usage
app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
if c.HelpName == "" {
@@ -227,6 +244,13 @@ func (c Command) startApp(ctx *Context) error {
app.Email = ctx.App.Email
app.Writer = ctx.App.Writer
+ app.categories = CommandCategories{}
+ for _, command := range c.Subcommands {
+ app.categories = app.categories.AddCommand(command.Category, command)
+ }
+
+ sort.Sort(app.categories)
+
// bash completion
app.EnableBashCompletion = ctx.App.EnableBashCompletion
if c.BashComplete != nil {
@@ -248,3 +272,8 @@ func (c Command) startApp(ctx *Context) error {
return app.RunAsSubcommand(ctx)
}
+
+// VisibleFlags returns a slice of the Flags with Hidden=false
+func (c Command) VisibleFlags() []Flag {
+ return visibleFlags(c.Flags)
+}
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/context.go b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/context.go
index 0513d34f6..c34246369 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/context.go
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/context.go
@@ -21,57 +21,62 @@ type Context struct {
parentContext *Context
}
-// Creates a new context. For use in when invoking an App or Command action.
+// NewContext creates a new context. For use in when invoking an App or Command action.
func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
return &Context{App: app, flagSet: set, parentContext: parentCtx}
}
-// Looks up the value of a local int flag, returns 0 if no int flag exists
+// Int looks up the value of a local int flag, returns 0 if no int flag exists
func (c *Context) Int(name string) int {
return lookupInt(name, c.flagSet)
}
-// Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists
+// Duration looks up the value of a local time.Duration flag, returns 0 if no
+// time.Duration flag exists
func (c *Context) Duration(name string) time.Duration {
return lookupDuration(name, c.flagSet)
}
-// Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
+// Float64 looks up the value of a local float64 flag, returns 0 if no float64
+// flag exists
func (c *Context) Float64(name string) float64 {
return lookupFloat64(name, c.flagSet)
}
-// Looks up the value of a local bool flag, returns false if no bool flag exists
+// Bool looks up the value of a local bool flag, returns false if no bool flag exists
func (c *Context) Bool(name string) bool {
return lookupBool(name, c.flagSet)
}
-// Looks up the value of a local boolT flag, returns false if no bool flag exists
+// BoolT looks up the value of a local boolT flag, returns false if no bool flag exists
func (c *Context) BoolT(name string) bool {
return lookupBoolT(name, c.flagSet)
}
-// Looks up the value of a local string flag, returns "" if no string flag exists
+// String looks up the value of a local string flag, returns "" if no string flag exists
func (c *Context) String(name string) string {
return lookupString(name, c.flagSet)
}
-// Looks up the value of a local string slice flag, returns nil if no string slice flag exists
+// StringSlice looks up the value of a local string slice flag, returns nil if no
+// string slice flag exists
func (c *Context) StringSlice(name string) []string {
return lookupStringSlice(name, c.flagSet)
}
-// Looks up the value of a local int slice flag, returns nil if no int slice flag exists
+// IntSlice looks up the value of a local int slice flag, returns nil if no int
+// slice flag exists
func (c *Context) IntSlice(name string) []int {
return lookupIntSlice(name, c.flagSet)
}
-// Looks up the value of a local generic flag, returns nil if no generic flag exists
+// Generic looks up the value of a local generic flag, returns nil if no generic
+// flag exists
func (c *Context) Generic(name string) interface{} {
return lookupGeneric(name, c.flagSet)
}
-// Looks up the value of a global int flag, returns 0 if no int flag exists
+// GlobalInt looks up the value of a global int flag, returns 0 if no int flag exists
func (c *Context) GlobalInt(name string) int {
if fs := lookupGlobalFlagSet(name, c); fs != nil {
return lookupInt(name, fs)
@@ -79,7 +84,17 @@ func (c *Context) GlobalInt(name string) int {
return 0
}
-// Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists
+// GlobalFloat64 looks up the value of a global float64 flag, returns float64(0)
+// if no float64 flag exists
+func (c *Context) GlobalFloat64(name string) float64 {
+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
+ return lookupFloat64(name, fs)
+ }
+ return float64(0)
+}
+
+// GlobalDuration looks up the value of a global time.Duration flag, returns 0
+// if no time.Duration flag exists
func (c *Context) GlobalDuration(name string) time.Duration {
if fs := lookupGlobalFlagSet(name, c); fs != nil {
return lookupDuration(name, fs)
@@ -87,7 +102,8 @@ func (c *Context) GlobalDuration(name string) time.Duration {
return 0
}
-// Looks up the value of a global bool flag, returns false if no bool flag exists
+// GlobalBool looks up the value of a global bool flag, returns false if no bool
+// flag exists
func (c *Context) GlobalBool(name string) bool {
if fs := lookupGlobalFlagSet(name, c); fs != nil {
return lookupBool(name, fs)
@@ -95,7 +111,17 @@ func (c *Context) GlobalBool(name string) bool {
return false
}
-// Looks up the value of a global string flag, returns "" if no string flag exists
+// GlobalBoolT looks up the value of a global bool flag, returns true if no bool
+// flag exists
+func (c *Context) GlobalBoolT(name string) bool {
+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
+ return lookupBoolT(name, fs)
+ }
+ return false
+}
+
+// GlobalString looks up the value of a global string flag, returns "" if no
+// string flag exists
func (c *Context) GlobalString(name string) string {
if fs := lookupGlobalFlagSet(name, c); fs != nil {
return lookupString(name, fs)
@@ -103,7 +129,8 @@ func (c *Context) GlobalString(name string) string {
return ""
}
-// Looks up the value of a global string slice flag, returns nil if no string slice flag exists
+// GlobalStringSlice looks up the value of a global string slice flag, returns
+// nil if no string slice flag exists
func (c *Context) GlobalStringSlice(name string) []string {
if fs := lookupGlobalFlagSet(name, c); fs != nil {
return lookupStringSlice(name, fs)
@@ -111,7 +138,8 @@ func (c *Context) GlobalStringSlice(name string) []string {
return nil
}
-// Looks up the value of a global int slice flag, returns nil if no int slice flag exists
+// GlobalIntSlice looks up the value of a global int slice flag, returns nil if
+// no int slice flag exists
func (c *Context) GlobalIntSlice(name string) []int {
if fs := lookupGlobalFlagSet(name, c); fs != nil {
return lookupIntSlice(name, fs)
@@ -119,7 +147,8 @@ func (c *Context) GlobalIntSlice(name string) []int {
return nil
}
-// Looks up the value of a global generic flag, returns nil if no generic flag exists
+// GlobalGeneric looks up the value of a global generic flag, returns nil if no
+// generic flag exists
func (c *Context) GlobalGeneric(name string) interface{} {
if fs := lookupGlobalFlagSet(name, c); fs != nil {
return lookupGeneric(name, fs)
@@ -127,12 +156,22 @@ func (c *Context) GlobalGeneric(name string) interface{} {
return nil
}
-// Returns the number of flags set
+// NumFlags returns the number of flags set
func (c *Context) NumFlags() int {
return c.flagSet.NFlag()
}
-// Determines if the flag was actually set
+// Set sets a context flag to a value.
+func (c *Context) Set(name, value string) error {
+ return c.flagSet.Set(name, value)
+}
+
+// GlobalSet sets a context flag to a value on the global flagset
+func (c *Context) GlobalSet(name, value string) error {
+ return globalContext(c).flagSet.Set(name, value)
+}
+
+// IsSet determines if the flag was actually set
func (c *Context) IsSet(name string) bool {
if c.setFlags == nil {
c.setFlags = make(map[string]bool)
@@ -143,7 +182,7 @@ func (c *Context) IsSet(name string) bool {
return c.setFlags[name] == true
}
-// Determines if the global flag was actually set
+// GlobalIsSet determines if the global flag was actually set
func (c *Context) GlobalIsSet(name string) bool {
if c.globalSetFlags == nil {
c.globalSetFlags = make(map[string]bool)
@@ -160,7 +199,7 @@ func (c *Context) GlobalIsSet(name string) bool {
return c.globalSetFlags[name]
}
-// Returns a slice of flag names used in this context.
+// FlagNames returns a slice of flag names used in this context.
func (c *Context) FlagNames() (names []string) {
for _, flag := range c.Command.Flags {
name := strings.Split(flag.GetName(), ",")[0]
@@ -172,7 +211,7 @@ func (c *Context) FlagNames() (names []string) {
return
}
-// Returns a slice of global flag names used by the app.
+// GlobalFlagNames returns a slice of global flag names used by the app.
func (c *Context) GlobalFlagNames() (names []string) {
for _, flag := range c.App.Flags {
name := strings.Split(flag.GetName(), ",")[0]
@@ -184,20 +223,26 @@ func (c *Context) GlobalFlagNames() (names []string) {
return
}
-// Returns the parent context, if any
+// Parent returns the parent context, if any
func (c *Context) Parent() *Context {
return c.parentContext
}
+// Args contains apps console arguments
type Args []string
-// Returns the command line arguments associated with the context.
+// Args returns the command line arguments associated with the context.
func (c *Context) Args() Args {
args := Args(c.flagSet.Args())
return args
}
-// Returns the nth argument, or else a blank string
+// NArg returns the number of the command line arguments.
+func (c *Context) NArg() int {
+ return len(c.Args())
+}
+
+// Get returns the nth argument, or else a blank string
func (a Args) Get(n int) string {
if len(a) > n {
return a[n]
@@ -205,12 +250,12 @@ func (a Args) Get(n int) string {
return ""
}
-// Returns the first argument, or else a blank string
+// First returns the first argument, or else a blank string
func (a Args) First() string {
return a.Get(0)
}
-// Return the rest of the arguments (not the first one)
+// Tail returns the rest of the arguments (not the first one)
// or else an empty string slice
func (a Args) Tail() []string {
if len(a) >= 2 {
@@ -219,12 +264,12 @@ func (a Args) Tail() []string {
return []string{}
}
-// Checks if there are any arguments present
+// Present checks if there are any arguments present
func (a Args) Present() bool {
return len(a) != 0
}
-// Swaps arguments at the given indexes
+// Swap swaps arguments at the given indexes
func (a Args) Swap(from, to int) error {
if from >= len(a) || to >= len(a) {
return errors.New("index out of range")
@@ -233,6 +278,19 @@ func (a Args) Swap(from, to int) error {
return nil
}
+func globalContext(ctx *Context) *Context {
+ if ctx == nil {
+ return nil
+ }
+
+ for {
+ if ctx.parentContext == nil {
+ return ctx
+ }
+ ctx = ctx.parentContext
+ }
+}
+
func lookupGlobalFlagSet(name string, ctx *Context) *flag.FlagSet {
if ctx.parentContext != nil {
ctx = ctx.parentContext
diff --git a/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/errors.go b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/errors.go
new file mode 100644
index 000000000..ea551be16
--- /dev/null
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/errors.go
@@ -0,0 +1,92 @@
+package cli
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "strings"
+)
+
+// OsExiter is the function used when the app exits. If not set defaults to os.Exit.
+var OsExiter = os.Exit
+
+// ErrWriter is used to write errors to the user. This can be anything
+// implementing the io.Writer interface and defaults to os.Stderr.
+var ErrWriter io.Writer = os.Stderr
+
+// MultiError is an error that wraps multiple errors.
+type MultiError struct {
+ Errors []error
+}
+
+// NewMultiError creates a new MultiError. Pass in one or more errors.
+func NewMultiError(err ...error) MultiError {
+ return MultiError{Errors: err}
+}
+
+// Error implents the error interface.
+func (m MultiError) Error() string {
+ errs := make([]string, len(m.Errors))
+ for i, err := range m.Errors {
+ errs[i] = err.Error()
+ }
+
+ return strings.Join(errs, "\n")
+}
+
+// ExitCoder is the interface checked by `App` and `Command` for a custom exit
+// code
+type ExitCoder interface {
+ error
+ ExitCode() int
+}
+
+// ExitError fulfills both the builtin `error` interface and `ExitCoder`
+type ExitError struct {
+ exitCode int
+ message string
+}
+
+// NewExitError makes a new *ExitError
+func NewExitError(message string, exitCode int) *ExitError {
+ return &ExitError{
+ exitCode: exitCode,
+ message: message,
+ }
+}
+
+// Error returns the string message, fulfilling the interface required by
+// `error`
+func (ee *ExitError) Error() string {
+ return ee.message
+}
+
+// ExitCode returns the exit code, fulfilling the interface required by
+// `ExitCoder`
+func (ee *ExitError) ExitCode() int {
+ return ee.exitCode
+}
+
+// HandleExitCoder checks if the error fulfills the ExitCoder interface, and if
+// so prints the error to stderr (if it is non-empty) and calls OsExiter with the
+// given exit code. If the given error is a MultiError, then this func is
+// called on all members of the Errors slice.
+func HandleExitCoder(err error) {
+ if err == nil {
+ return
+ }
+
+ if exitErr, ok := err.(ExitCoder); ok {
+ if err.Error() != "" {
+ fmt.Fprintln(ErrWriter, err)
+ }
+ OsExiter(exitErr.ExitCode())
+ return
+ }
+
+ if multiErr, ok := err.(MultiError); ok {
+ for _, merr := range multiErr.Errors {
+ HandleExitCoder(merr)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/flag.go b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/flag.go
index e951c2df7..1e8112e7e 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/flag.go
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/flag.go
@@ -4,24 +4,28 @@ import (
"flag"
"fmt"
"os"
+ "reflect"
"runtime"
"strconv"
"strings"
"time"
)
-// This flag enables bash-completion for all commands and subcommands
+const defaultPlaceholder = "value"
+
+// BashCompletionFlag enables bash-completion for all commands and subcommands
var BashCompletionFlag = BoolFlag{
- Name: "generate-bash-completion",
+ Name: "generate-bash-completion",
+ Hidden: true,
}
-// This flag prints the version for the application
+// VersionFlag prints the version for the application
var VersionFlag = BoolFlag{
Name: "version, v",
Usage: "print the version",
}
-// This flag prints the help for all commands and subcommands
+// HelpFlag prints the help for all commands and subcommands
// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
// unless HideHelp is set to true)
var HelpFlag = BoolFlag{
@@ -29,6 +33,10 @@ var HelpFlag = BoolFlag{
Usage: "show help",
}
+// FlagStringer converts a flag definition to a string. This is used by help
+// to display a flag.
+var FlagStringer FlagStringFunc = stringifyFlag
+
// Flag is a common interface related to parsing flags in cli.
// For more advanced flag parsing techniques, it is recommended that
// this interface be implemented.
@@ -68,24 +76,14 @@ type GenericFlag struct {
Value Generic
Usage string
EnvVar string
+ Hidden bool
}
// String returns the string representation of the generic flag to display the
// help text to the user (uses the String() method of the generic flag to show
// the value)
func (f GenericFlag) String() string {
- return withEnvHint(f.EnvVar, fmt.Sprintf("%s %v\t%v", prefixedNames(f.Name), f.FormatValueHelp(), f.Usage))
-}
-
-func (f GenericFlag) FormatValueHelp() string {
- if f.Value == nil {
- return ""
- }
- s := f.Value.String()
- if len(s) == 0 {
- return ""
- }
- return fmt.Sprintf("\"%s\"", s)
+ return FlagStringer(f)
}
// Apply takes the flagset and calls Set on the generic flag with the value
@@ -107,6 +105,7 @@ func (f GenericFlag) Apply(set *flag.FlagSet) {
})
}
+// GetName returns the name of a flag.
func (f GenericFlag) GetName() string {
return f.Name
}
@@ -130,20 +129,19 @@ func (f *StringSlice) Value() []string {
return *f
}
-// StringSlice is a string flag that can be specified multiple times on the
+// StringSliceFlag is a string flag that can be specified multiple times on the
// command-line
type StringSliceFlag struct {
Name string
Value *StringSlice
Usage string
EnvVar string
+ Hidden bool
}
// String returns the usage
func (f StringSliceFlag) String() string {
- firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
- pref := prefixFor(firstName)
- return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
+ return FlagStringer(f)
}
// Apply populates the flag given the flag set and environment
@@ -171,11 +169,12 @@ func (f StringSliceFlag) Apply(set *flag.FlagSet) {
})
}
+// GetName returns the name of a flag.
func (f StringSliceFlag) GetName() string {
return f.Name
}
-// StringSlice is an opaque type for []int to satisfy flag.Value
+// IntSlice is an opaque type for []int to satisfy flag.Value
type IntSlice []int
// Set parses the value into an integer and appends it to the list of values
@@ -183,9 +182,8 @@ func (f *IntSlice) Set(value string) error {
tmp, err := strconv.Atoi(value)
if err != nil {
return err
- } else {
- *f = append(*f, tmp)
}
+ *f = append(*f, tmp)
return nil
}
@@ -206,13 +204,12 @@ type IntSliceFlag struct {
Value *IntSlice
Usage string
EnvVar string
+ Hidden bool
}
// String returns the usage
func (f IntSliceFlag) String() string {
- firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
- pref := prefixFor(firstName)
- return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
+ return FlagStringer(f)
}
// Apply populates the flag given the flag set and environment
@@ -226,7 +223,7 @@ func (f IntSliceFlag) Apply(set *flag.FlagSet) {
s = strings.TrimSpace(s)
err := newVal.Set(s)
if err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
+ fmt.Fprintf(ErrWriter, err.Error())
}
}
f.Value = newVal
@@ -243,6 +240,7 @@ func (f IntSliceFlag) Apply(set *flag.FlagSet) {
})
}
+// GetName returns the name of the flag.
func (f IntSliceFlag) GetName() string {
return f.Name
}
@@ -253,11 +251,12 @@ type BoolFlag struct {
Usage string
EnvVar string
Destination *bool
+ Hidden bool
}
// String returns a readable representation of this value (for usage defaults)
func (f BoolFlag) String() string {
- return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+ return FlagStringer(f)
}
// Apply populates the flag given the flag set and environment
@@ -285,6 +284,7 @@ func (f BoolFlag) Apply(set *flag.FlagSet) {
})
}
+// GetName returns the name of the flag.
func (f BoolFlag) GetName() string {
return f.Name
}
@@ -296,11 +296,12 @@ type BoolTFlag struct {
Usage string
EnvVar string
Destination *bool
+ Hidden bool
}
// String returns a readable representation of this value (for usage defaults)
func (f BoolTFlag) String() string {
- return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+ return FlagStringer(f)
}
// Apply populates the flag given the flag set and environment
@@ -328,6 +329,7 @@ func (f BoolTFlag) Apply(set *flag.FlagSet) {
})
}
+// GetName returns the name of the flag.
func (f BoolTFlag) GetName() string {
return f.Name
}
@@ -339,19 +341,12 @@ type StringFlag struct {
Usage string
EnvVar string
Destination *string
+ Hidden bool
}
// String returns the usage
func (f StringFlag) String() string {
- return withEnvHint(f.EnvVar, fmt.Sprintf("%s %v\t%v", prefixedNames(f.Name), f.FormatValueHelp(), f.Usage))
-}
-
-func (f StringFlag) FormatValueHelp() string {
- s := f.Value
- if len(s) == 0 {
- return ""
- }
- return fmt.Sprintf("\"%s\"", s)
+ return FlagStringer(f)
}
// Apply populates the flag given the flag set and environment
@@ -375,6 +370,7 @@ func (f StringFlag) Apply(set *flag.FlagSet) {
})
}
+// GetName returns the name of the flag.
func (f StringFlag) GetName() string {
return f.Name
}
@@ -387,11 +383,12 @@ type IntFlag struct {
Usage string
EnvVar string
Destination *int
+ Hidden bool
}
// String returns the usage
func (f IntFlag) String() string {
- return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+ return FlagStringer(f)
}
// Apply populates the flag given the flag set and environment
@@ -418,6 +415,7 @@ func (f IntFlag) Apply(set *flag.FlagSet) {
})
}
+// GetName returns the name of the flag.
func (f IntFlag) GetName() string {
return f.Name
}
@@ -430,11 +428,12 @@ type DurationFlag struct {
Usage string
EnvVar string
Destination *time.Duration
+ Hidden bool
}
// String returns a readable representation of this value (for usage defaults)
func (f DurationFlag) String() string {
- return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+ return FlagStringer(f)
}
// Apply populates the flag given the flag set and environment
@@ -461,6 +460,7 @@ func (f DurationFlag) Apply(set *flag.FlagSet) {
})
}
+// GetName returns the name of the flag.
func (f DurationFlag) GetName() string {
return f.Name
}
@@ -473,11 +473,12 @@ type Float64Flag struct {
Usage string
EnvVar string
Destination *float64
+ Hidden bool
}
// String returns the usage
func (f Float64Flag) String() string {
- return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+ return FlagStringer(f)
}
// Apply populates the flag given the flag set and environment
@@ -503,10 +504,21 @@ func (f Float64Flag) Apply(set *flag.FlagSet) {
})
}
+// GetName returns the name of the flag.
func (f Float64Flag) GetName() string {
return f.Name
}
+func visibleFlags(fl []Flag) []Flag {
+ visible := []Flag{}
+ for _, flag := range fl {
+ if !reflect.ValueOf(flag).FieldByName("Hidden").Bool() {
+ visible = append(visible, flag)
+ }
+ }
+ return visible
+}
+
func prefixFor(name string) (prefix string) {
if len(name) == 1 {
prefix = "-"
@@ -517,16 +529,37 @@ func prefixFor(name string) (prefix string) {
return
}
-func prefixedNames(fullName string) (prefixed string) {
+// Returns the placeholder, if any, and the unquoted usage string.
+func unquoteUsage(usage string) (string, string) {
+ for i := 0; i < len(usage); i++ {
+ if usage[i] == '`' {
+ for j := i + 1; j < len(usage); j++ {
+ if usage[j] == '`' {
+ name := usage[i+1 : j]
+ usage = usage[:i] + name + usage[j+1:]
+ return name, usage
+ }
+ }
+ break
+ }
+ }
+ return "", usage
+}
+
+func prefixedNames(fullName, placeholder string) string {
+ var prefixed string
parts := strings.Split(fullName, ",")
for i, name := range parts {
name = strings.Trim(name, " ")
prefixed += prefixFor(name) + name
+ if placeholder != "" {
+ prefixed += " " + placeholder
+ }
if i < len(parts)-1 {
prefixed += ", "
}
}
- return
+ return prefixed
}
func withEnvHint(envVar, str string) string {
@@ -544,3 +577,83 @@ func withEnvHint(envVar, str string) string {
}
return str + envText
}
+
+func stringifyFlag(f Flag) string {
+ fv := reflect.ValueOf(f)
+
+ switch f.(type) {
+ case IntSliceFlag:
+ return withEnvHint(fv.FieldByName("EnvVar").String(),
+ stringifyIntSliceFlag(f.(IntSliceFlag)))
+ case StringSliceFlag:
+ return withEnvHint(fv.FieldByName("EnvVar").String(),
+ stringifyStringSliceFlag(f.(StringSliceFlag)))
+ }
+
+ placeholder, usage := unquoteUsage(fv.FieldByName("Usage").String())
+
+ needsPlaceholder := false
+ defaultValueString := ""
+ val := fv.FieldByName("Value")
+
+ if val.IsValid() {
+ needsPlaceholder = true
+ defaultValueString = fmt.Sprintf(" (default: %v)", val.Interface())
+
+ if val.Kind() == reflect.String && val.String() != "" {
+ defaultValueString = fmt.Sprintf(" (default: %q)", val.String())
+ }
+ }
+
+ if defaultValueString == " (default: )" {
+ defaultValueString = ""
+ }
+
+ if needsPlaceholder && placeholder == "" {
+ placeholder = defaultPlaceholder
+ }
+
+ usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultValueString))
+
+ return withEnvHint(fv.FieldByName("EnvVar").String(),
+ fmt.Sprintf("%s\t%s", prefixedNames(fv.FieldByName("Name").String(), placeholder), usageWithDefault))
+}
+
+func stringifyIntSliceFlag(f IntSliceFlag) string {
+ defaultVals := []string{}
+ if f.Value != nil && len(f.Value.Value()) > 0 {
+ for _, i := range f.Value.Value() {
+ defaultVals = append(defaultVals, fmt.Sprintf("%d", i))
+ }
+ }
+
+ return stringifySliceFlag(f.Usage, f.Name, defaultVals)
+}
+
+func stringifyStringSliceFlag(f StringSliceFlag) string {
+ defaultVals := []string{}
+ if f.Value != nil && len(f.Value.Value()) > 0 {
+ for _, s := range f.Value.Value() {
+ if len(s) > 0 {
+ defaultVals = append(defaultVals, fmt.Sprintf("%q", s))
+ }
+ }
+ }
+
+ return stringifySliceFlag(f.Usage, f.Name, defaultVals)
+}
+
+func stringifySliceFlag(usage, name string, defaultVals []string) string {
+ placeholder, usage := unquoteUsage(usage)
+ if placeholder == "" {
+ placeholder = defaultPlaceholder
+ }
+
+ defaultVal := ""
+ if len(defaultVals) > 0 {
+ defaultVal = fmt.Sprintf(" (default: %s)", strings.Join(defaultVals, ", "))
+ }
+
+ usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultVal))
+ return fmt.Sprintf("%s\t%s", prefixedNames(name, placeholder), usageWithDefault)
+}
diff --git a/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/funcs.go b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/funcs.go
new file mode 100644
index 000000000..cba5e6cb0
--- /dev/null
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/funcs.go
@@ -0,0 +1,28 @@
+package cli
+
+// BashCompleteFunc is an action to execute when the bash-completion flag is set
+type BashCompleteFunc func(*Context)
+
+// BeforeFunc is an action to execute before any subcommands are run, but after
+// the context is ready if a non-nil error is returned, no subcommands are run
+type BeforeFunc func(*Context) error
+
+// AfterFunc is an action to execute after any subcommands are run, but after the
+// subcommand has finished it is run even if Action() panics
+type AfterFunc func(*Context) error
+
+// ActionFunc is the action to execute when no subcommands are specified
+type ActionFunc func(*Context) error
+
+// CommandNotFoundFunc is executed if the proper command cannot be found
+type CommandNotFoundFunc func(*Context, string)
+
+// OnUsageErrorFunc is executed if an usage error occurs. This is useful for displaying
+// customized usage error messages. This function is able to replace the
+// original error messages. If this function is not set, the "Incorrect usage"
+// is displayed and the execution is interrupted.
+type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error
+
+// FlagStringFunc is used by the help generation to display a flag, which is
+// expected to be a single line.
+type FlagStringFunc func(Flag) string
diff --git a/Godeps/_workspace/src/github.com/codegangsta/cli/help.go b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/help.go
index 15916f86a..801d2b167 100644
--- a/Godeps/_workspace/src/github.com/codegangsta/cli/help.go
+++ b/Godeps/_workspace/src/gopkg.in/urfave/cli.v1/help.go
@@ -3,68 +3,74 @@ package cli
import (
"fmt"
"io"
+ "os"
"strings"
"text/tabwriter"
"text/template"
)
-// The text template for the Default help topic.
+// AppHelpTemplate is the text template for the Default help topic.
// cli.go uses text/template to render templates. You can
// render custom help text by setting this variable.
var AppHelpTemplate = `NAME:
{{.Name}} - {{.Usage}}
USAGE:
- {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .Flags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}
- {{if .Version}}
+ {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}
+ {{if .Version}}{{if not .HideVersion}}
VERSION:
{{.Version}}
- {{end}}{{if len .Authors}}
+ {{end}}{{end}}{{if len .Authors}}
AUTHOR(S):
- {{range .Authors}}{{ . }}{{end}}
- {{end}}{{if .Commands}}
-COMMANDS:
- {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
- {{end}}{{end}}{{if .Flags}}
+ {{range .Authors}}{{.}}{{end}}
+ {{end}}{{if .VisibleCommands}}
+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
+ {{.Name}}:{{end}}{{range .VisibleCommands}}
+ {{.Name}}{{with .ShortName}}, {{.}}{{end}}{{"\t"}}{{.Usage}}{{end}}
+{{end}}{{end}}{{if .VisibleFlags}}
GLOBAL OPTIONS:
- {{range .Flags}}{{.}}
- {{end}}{{end}}{{if .Copyright }}
+ {{range .VisibleFlags}}{{.}}
+ {{end}}{{end}}{{if .Copyright}}
COPYRIGHT:
{{.Copyright}}
{{end}}
`
-// The text template for the command help topic.
+// CommandHelpTemplate is the text template for the command help topic.
// cli.go uses text/template to render templates. You can
// render custom help text by setting this variable.
var CommandHelpTemplate = `NAME:
{{.HelpName}} - {{.Usage}}
USAGE:
- {{.HelpName}}{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Description}}
+ {{.HelpName}}{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Category}}
+
+CATEGORY:
+ {{.Category}}{{end}}{{if .Description}}
DESCRIPTION:
- {{.Description}}{{end}}{{if .Flags}}
+ {{.Description}}{{end}}{{if .VisibleFlags}}
OPTIONS:
- {{range .Flags}}{{.}}
- {{end}}{{ end }}
+ {{range .VisibleFlags}}{{.}}
+ {{end}}{{end}}
`
-// The text template for the subcommand help topic.
+// SubcommandHelpTemplate is the text template for the subcommand help topic.
// cli.go uses text/template to render templates. You can
// render custom help text by setting this variable.
var SubcommandHelpTemplate = `NAME:
{{.HelpName}} - {{.Usage}}
USAGE:
- {{.HelpName}} command{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
+ {{.HelpName}} command{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
-COMMANDS:
- {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
- {{end}}{{if .Flags}}
+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
+ {{.Name}}:{{end}}{{range .VisibleCommands}}
+ {{.Name}}{{with .ShortName}}, {{.}}{{end}}{{"\t"}}{{.Usage}}{{end}}
+{{end}}{{if .VisibleFlags}}
OPTIONS:
- {{range .Flags}}{{.}}
+ {{range .VisibleFlags}}{{.}}
{{end}}{{end}}
`
@@ -73,13 +79,14 @@ var helpCommand = Command{
Aliases: []string{"h"},
Usage: "Shows a list of commands or help for one command",
ArgsUsage: "[command]",
- Action: func(c *Context) {
+ Action: func(c *Context) error {
args := c.Args()
if args.Present() {
- ShowCommandHelp(c, args.First())
- } else {
- ShowAppHelp(c)
+ return ShowCommandHelp(c, args.First())
}
+
+ ShowAppHelp(c)
+ return nil
},
}
@@ -88,65 +95,73 @@ var helpSubcommand = Command{
Aliases: []string{"h"},
Usage: "Shows a list of commands or help for one command",
ArgsUsage: "[command]",
- Action: func(c *Context) {
+ Action: func(c *Context) error {
args := c.Args()
if args.Present() {
- ShowCommandHelp(c, args.First())
- } else {
- ShowSubcommandHelp(c)
+ return ShowCommandHelp(c, args.First())
}
+
+ return ShowSubcommandHelp(c)
},
}
// Prints help for the App or Command
type helpPrinter func(w io.Writer, templ string, data interface{})
+// HelpPrinter is a function that writes the help output. If not set a default
+// is used. The function signature is:
+// func(w io.Writer, templ string, data interface{})
var HelpPrinter helpPrinter = printHelp
-// Prints version for the App
+// VersionPrinter prints the version for the App
var VersionPrinter = printVersion
+// ShowAppHelp is an action that displays the help.
func ShowAppHelp(c *Context) {
HelpPrinter(c.App.Writer, AppHelpTemplate, c.App)
}
-// Prints the list of subcommands as the default app completion method
+// DefaultAppComplete prints the list of subcommands as the default app completion method
func DefaultAppComplete(c *Context) {
for _, command := range c.App.Commands {
+ if command.Hidden {
+ continue
+ }
for _, name := range command.Names() {
fmt.Fprintln(c.App.Writer, name)
}
}
}
-// Prints help for the given command
-func ShowCommandHelp(ctx *Context, command string) {
+// ShowCommandHelp prints help for the given command
+func ShowCommandHelp(ctx *Context, command string) error {
// show the subcommand help for a command with subcommands
if command == "" {
HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App)
- return
+ return nil
}
for _, c := range ctx.App.Commands {
if c.HasName(command) {
HelpPrinter(ctx.App.Writer, CommandHelpTemplate, c)
- return
+ return nil
}
}
- if ctx.App.CommandNotFound != nil {
- ctx.App.CommandNotFound(ctx, command)
- } else {
- fmt.Fprintf(ctx.App.Writer, "No help topic for '%v'\n", command)
+ if ctx.App.CommandNotFound == nil {
+ return NewExitError(fmt.Sprintf("No help topic for '%v'", command), 3)
}
+
+ ctx.App.CommandNotFound(ctx, command)
+ return nil
}
-// Prints help for the given subcommand
-func ShowSubcommandHelp(c *Context) {
- ShowCommandHelp(c, c.Command.Name)
+// ShowSubcommandHelp prints help for the given subcommand
+func ShowSubcommandHelp(c *Context) error {
+ return ShowCommandHelp(c, c.Command.Name)
}
-// Prints the version number of the App
+// ShowVersion prints the version number of the App
func ShowVersion(c *Context) {
VersionPrinter(c)
}
@@ -155,7 +170,7 @@ func printVersion(c *Context) {
fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
}
-// Prints the lists of commands within a given context
+// ShowCompletions prints the lists of commands within a given context
func ShowCompletions(c *Context) {
a := c.App
if a != nil && a.BashComplete != nil {
@@ -163,7 +178,7 @@ func ShowCompletions(c *Context) {
}
}
-// Prints the custom completions for a given command
+// ShowCommandCompletions prints the custom completions for a given command
func ShowCommandCompletions(ctx *Context, command string) {
c := ctx.App.Command(command)
if c != nil && c.BashComplete != nil {
@@ -181,7 +196,10 @@ func printHelp(out io.Writer, templ string, data interface{}) {
err := t.Execute(w, data)
if err != nil {
// If the writer is closed, t.Execute will fail, and there's nothing
- // we can do to recover. We could send this to os.Stderr if we need.
+ // we can do to recover.
+ if os.Getenv("CLI_TEMPLATE_ERROR_DEBUG") != "" {
+ fmt.Fprintf(ErrWriter, "CLI TEMPLATE ERROR: %#v\n", err)
+ }
return
}
w.Flush()
diff --git a/cmd/ethtest/main.go b/cmd/ethtest/main.go
index d8f969636..450dadcbb 100644
--- a/cmd/ethtest/main.go
+++ b/cmd/ethtest/main.go
@@ -25,10 +25,10 @@ import (
"path/filepath"
"strings"
- "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/tests"
+ "gopkg.in/urfave/cli.v1"
)
var (
diff --git a/cmd/evm/main.go b/cmd/evm/main.go
index 7d9b3a6c3..ce8e171bd 100644
--- a/cmd/evm/main.go
+++ b/cmd/evm/main.go
@@ -24,7 +24,6 @@ import (
"runtime"
"time"
- "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
@@ -33,6 +32,7 @@ import (
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/logger/glog"
+ "gopkg.in/urfave/cli.v1"
)
var (
diff --git a/cmd/geth/accountcmd.go b/cmd/geth/accountcmd.go
index 2c2308514..fd5a4bcd4 100644
--- a/cmd/geth/accountcmd.go
+++ b/cmd/geth/accountcmd.go
@@ -20,13 +20,13 @@ import (
"fmt"
"io/ioutil"
- "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/console"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
+ "gopkg.in/urfave/cli.v1"
)
var (
diff --git a/cmd/geth/chaincmd.go b/cmd/geth/chaincmd.go
index 4f47de5d7..3355b7a6a 100644
--- a/cmd/geth/chaincmd.go
+++ b/cmd/geth/chaincmd.go
@@ -23,7 +23,6 @@ import (
"strconv"
"time"
- "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/console"
@@ -32,6 +31,7 @@ import (
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/logger/glog"
+ "gopkg.in/urfave/cli.v1"
)
var (
diff --git a/cmd/geth/consolecmd.go b/cmd/geth/consolecmd.go
index 8bfe27fef..cc7a40fd9 100644
--- a/cmd/geth/consolecmd.go
+++ b/cmd/geth/consolecmd.go
@@ -20,9 +20,9 @@ import (
"os"
"os/signal"
- "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/console"
+ "gopkg.in/urfave/cli.v1"
)
var (
diff --git a/cmd/geth/main.go b/cmd/geth/main.go
index 5ff1a7368..6df16bb2c 100644
--- a/cmd/geth/main.go
+++ b/cmd/geth/main.go
@@ -28,7 +28,6 @@ import (
"strings"
"time"
- "github.com/codegangsta/cli"
"github.com/ethereum/ethash"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/common"
@@ -44,6 +43,7 @@ import (
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/release"
"github.com/ethereum/go-ethereum/rlp"
+ "gopkg.in/urfave/cli.v1"
)
const (
diff --git a/cmd/geth/monitorcmd.go b/cmd/geth/monitorcmd.go
index 5d839b5a3..7058b432f 100644
--- a/cmd/geth/monitorcmd.go
+++ b/cmd/geth/monitorcmd.go
@@ -26,11 +26,11 @@ import (
"sort"
- "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/rpc"
"github.com/gizak/termui"
+ "gopkg.in/urfave/cli.v1"
)
var (
diff --git a/cmd/geth/usage.go b/cmd/geth/usage.go
index 01a71c1f6..e7ef9e2c7 100644
--- a/cmd/geth/usage.go
+++ b/cmd/geth/usage.go
@@ -21,9 +21,9 @@ package main
import (
"io"
- "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/internal/debug"
+ "gopkg.in/urfave/cli.v1"
)
// AppHelpTemplate is the test template for the default, global app help topic.
diff --git a/cmd/utils/client.go b/cmd/utils/client.go
index ec72a1a4b..cc9647580 100644
--- a/cmd/utils/client.go
+++ b/cmd/utils/client.go
@@ -20,9 +20,9 @@ import (
"fmt"
"strings"
- "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/rpc"
+ "gopkg.in/urfave/cli.v1"
)
// NewRemoteRPCClient returns a RPC client which connects to a running geth instance.
diff --git a/cmd/utils/customflags.go b/cmd/utils/customflags.go
index 4450065c1..5cbccfe98 100644
--- a/cmd/utils/customflags.go
+++ b/cmd/utils/customflags.go
@@ -24,7 +24,7 @@ import (
"path"
"strings"
- "github.com/codegangsta/cli"
+ "gopkg.in/urfave/cli.v1"
)
// Custom type which is registered in the flags library which cli uses for
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index c476e1c77..d2ba42801 100644
--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@@ -30,7 +30,6 @@ import (
"strings"
"time"
- "github.com/codegangsta/cli"
"github.com/ethereum/ethash"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
@@ -51,6 +50,7 @@ import (
"github.com/ethereum/go-ethereum/release"
"github.com/ethereum/go-ethereum/rpc"
"github.com/ethereum/go-ethereum/whisper"
+ "gopkg.in/urfave/cli.v1"
)
func init() {
diff --git a/internal/debug/flags.go b/internal/debug/flags.go
index 5b1a9b23c..9fc5fc4fe 100644
--- a/internal/debug/flags.go
+++ b/internal/debug/flags.go
@@ -22,9 +22,9 @@ import (
_ "net/http/pprof"
"runtime"
- "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
+ "gopkg.in/urfave/cli.v1"
)
var (