Added cli for general usage of Vikunja (#66)

2019-03-24 17:15:44 +00:00 · 2019-03-24 17:15:44 +00:00 · 8d78e473f5
commit 8d78e473f5
parent 5525ee0328
28 changed files with 4117 additions and 58 deletions
--- a/2
+++ b/2
@ -19,7 +19,7 @@ GOFMT ?= gofmt -s
 GOFLAGS := -v -mod=vendor
 EXTRA_GOFLAGS ?=
-LDFLAGS := -X "main.Version=$(shell git describe --tags --always --abbrev=10 | sed 's/-/+/' | sed 's/^v//' | sed 's/-g/-/')" -X "main.Tags=$(TAGS)"
+LDFLAGS := -X "code.vikunja.io/api/pkg/cmd.Version=$(shell git describe --tags --always --abbrev=10 | sed 's/-/+/' | sed 's/^v//' | sed 's/-g/-/')" -X "main.Tags=$(TAGS)"
 PACKAGES ?= $(filter-out code.vikunja.io/api/integrations,$(shell go list -mod=vendor ./... | grep -v /vendor/))
 SOURCES ?= $(shell find . -name "*.go" -type f)
--- a/go.mod
+++ b/go.mod
@ -38,6 +38,7 @@ require (
 	github.com/go-xorm/xorm-redis-cache v0.0.0-20180727005610-859b313566b2
 	github.com/gordonklaus/ineffassign v0.0.0-20180909121442-1003c8bd00dc
 	github.com/imdario/mergo v0.3.6
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect
 	github.com/jgautheron/goconst v0.0.0-20170703170152-9740945f5dcb
 	github.com/karalabe/xgo v0.0.0-20181007145344-72da7d1d3970
 	github.com/kisielk/gotool v1.0.0 // indirect
@ -48,12 +49,14 @@ require (
 	github.com/mattn/go-isatty v0.0.7 // indirect
 	github.com/mattn/go-oci8 v0.0.0-20181130072307-052f5d97b9b6 // indirect
 	github.com/mattn/go-sqlite3 v1.10.0
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/mitchellh/mapstructure v1.1.2 // indirect
 	github.com/onsi/ginkgo v1.7.0 // indirect
 	github.com/onsi/gomega v1.4.3 // indirect
 	github.com/op/go-logging v0.0.0-20160315200505-970db520ece7
 	github.com/pkg/errors v0.8.0 // indirect
 	github.com/prometheus/client_golang v0.9.2
 	github.com/spf13/cobra v0.0.3
 	github.com/spf13/viper v1.2.0
 	github.com/stretchr/objx v0.1.1 // indirect
 	github.com/stretchr/testify v1.3.0
--- a/go.sum
+++ b/go.sum
@ -78,6 +78,8 @@ github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/imdario/mergo v0.3.6 h1:xTNEAn+kxVO7dTZGu0CegyqKZmoWFI0rF8UxjlB2d28=
 github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/jgautheron/goconst v0.0.0-20170703170152-9740945f5dcb h1:D5s1HIu80AcMGcqmk7fNIVptmAubVHHaj3v5Upex6Zs=
 github.com/jgautheron/goconst v0.0.0-20170703170152-9740945f5dcb/go.mod h1:82TxjOpWQiPmywlbIaB2ZkqJoSYJdLGPgAJDvM3PbKc=
 github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc=
@ -119,6 +121,8 @@ github.com/mattn/go-sqlite3 v1.10.0 h1:jbhqpg7tQe4SupckyijYiy0mJJ/pRyHvXf7JdWK86
 github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v1.0.0 h1:vVpGvMXJPqSDh2VYHF7gsfQj8Ncx+Xw5Y1KHeTRY+7I=
 github.com/mitchellh/mapstructure v1.0.0/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
@ -148,6 +152,8 @@ github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/cast v1.2.0 h1:HHl1DSRbEQN2i8tJmtS6ViPyHx35+p51amrdsiTCrkg=
 github.com/spf13/cast v1.2.0/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg=
 github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8=
 github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
 github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/pflag v1.0.2 h1:Fy0orTDgHdbnzHcsOgfCN4LtHf0ec3wwtiwJqwvf3Gc=
--- a/main.go
+++ b/main.go
@ -16,62 +16,8 @@
 package main
-import (
+import "code.vikunja.io/api/pkg/cmd"
 	_ "code.vikunja.io/api/pkg/config" // To trigger its init() which initializes the config
 	"code.vikunja.io/api/pkg/log"
 	"code.vikunja.io/api/pkg/mail"
 	"code.vikunja.io/api/pkg/models"
 	"code.vikunja.io/api/pkg/routes"
 	"code.vikunja.io/api/pkg/swagger"
 	"context"
 	"github.com/spf13/viper"
 	"os"
 	"os/signal"
 	"time"
 )
 // Version sets the version to be printed to the user. Gets overwritten by "make release" or "make build" with last git commit or tag.
 var Version = "0.1"
 func main() {
-
+	cmd.Execute()
 	// Set logger
 	log.InitLogger()
 	// Set Engine
 	err := models.SetEngine()
 	if err != nil {
 		log.Log.Fatal(err.Error())
 	}
 	// Start the mail daemon
 	mail.StartMailDaemon()
 	// Version notification
 	log.Log.Infof("Vikunja version %s", Version)
 	// Additional swagger information
 	swagger.SwaggerInfo.Version = Version
 	// Start the webserver
 	e := routes.NewEcho()
 	routes.RegisterRoutes(e)
 	// Start server
 	go func() {
 		if err := e.Start(viper.GetString("service.interface")); err != nil {
 			e.Logger.Info("shutting down...")
 		}
 	}()
 	// Wait for interrupt signal to gracefully shutdown the server with
 	// a timeout of 10 seconds.
 	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, os.Interrupt)
 	<-quit
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 	log.Log.Infof("Shutting down...")
 	if err := e.Shutdown(ctx); err != nil {
 		e.Logger.Fatal(err)
 	}
 }
--- a/pkg/cmd/cmd.go
+++ b/pkg/cmd/cmd.go
@ -0,0 +1,54 @@
 //  Vikunja is a todo-list application to facilitate your life.
 //  Copyright 2019 Vikunja and contributors. All rights reserved.
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
 //  the Free Software Foundation, either version 3 of the License, or
 //  (at your option) any later version.
 //
 //  This program is distributed in the hope that it will be useful,
 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 //  GNU General Public License for more details.
 //
 //  You should have received a copy of the GNU General Public License
 //  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 package cmd
 import (
 	"code.vikunja.io/api/pkg/config"
 	"fmt"
 	"github.com/spf13/cobra"
 	"os"
 )
 // Version sets the version to be printed to the user. Gets overwritten by "make release" or "make build" with last git commit or tag.
 var Version = "0.1"
 func init() {
 	cobra.OnInitialize(config.InitConfig)
 }
 var rootCmd = &cobra.Command{
 	Use:   "vikunja",
 	Short: "Vikunja is the to-do app to organize your life.",
 	Long: `Vikunja (/vɪˈkuːnjə/)
 The to-do app to organize your life.
 Also one of the two wild South American camelids which live in the high
 alpine areas of the Andes and a relative of the llama.
 Vikunja is a self-hosted To-Do list application with a web app and mobile apps for all platforms. It is licensed under the GPLv3.
 Find more info at vikunja.io.`,
 	Run: webCmd.Run,
 }
 // Execute starts the application
 func Execute() {
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 }
--- a/pkg/cmd/version.go
+++ b/pkg/cmd/version.go
@ -0,0 +1,34 @@
 //   Vikunja is a todo-list application to facilitate your life.
 //   Copyright 2019 Vikunja and contributors. All rights reserved.
 //
 //   This program is free software: you can redistribute it and/or modify
 //   it under the terms of the GNU General Public License as published by
 //   the Free Software Foundation, either version 3 of the License, or
 //   (at your option) any later version.
 //
 //   This program is distributed in the hope that it will be useful,
 //   but WITHOUT ANY WARRANTY; without even the implied warranty of
 //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 //   GNU General Public License for more details.
 //
 //   You should have received a copy of the GNU General Public License
 //   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 package cmd
 import (
 	"fmt"
 	"github.com/spf13/cobra"
 )
 func init() {
 	rootCmd.AddCommand(versionCmd)
 }
 var versionCmd = &cobra.Command{
 	Use:   "version",
 	Short: "Print the version number of Vikunja",
 	Run: func(cmd *cobra.Command, args []string) {
 		fmt.Println("Vikunja api version " + Version)
 	},
 }
--- a/pkg/cmd/web.go
+++ b/pkg/cmd/web.go
@ -0,0 +1,83 @@
 //   Vikunja is a todo-list application to facilitate your life.
 //   Copyright 2019 Vikunja and contributors. All rights reserved.
 //
 //   This program is free software: you can redistribute it and/or modify
 //   it under the terms of the GNU General Public License as published by
 //   the Free Software Foundation, either version 3 of the License, or
 //   (at your option) any later version.
 //
 //   This program is distributed in the hope that it will be useful,
 //   but WITHOUT ANY WARRANTY; without even the implied warranty of
 //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 //   GNU General Public License for more details.
 //
 //   You should have received a copy of the GNU General Public License
 //   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 package cmd
 import (
 	"code.vikunja.io/api/pkg/log"
 	"code.vikunja.io/api/pkg/mail"
 	"code.vikunja.io/api/pkg/models"
 	"code.vikunja.io/api/pkg/routes"
 	"code.vikunja.io/api/pkg/swagger"
 	"context"
 	"fmt"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"os"
 	"os/signal"
 	"time"
 )
 func init() {
 	rootCmd.AddCommand(webCmd)
 }
 var webCmd = &cobra.Command{
 	Use:   "web",
 	Short: "Starts the rest api web server",
 	Run: func(cmd *cobra.Command, args []string) {
 		// Set logger
 		log.InitLogger()
 		// Set Engine
 		err := models.SetEngine()
 		if err != nil {
 			log.Log.Fatal(err.Error())
 		}
 		// Start the mail daemon
 		mail.StartMailDaemon()
 		// Version notification
 		fmt.Printf("Vikunja version %s\n", Version)
 		// Additional swagger information
 		swagger.SwaggerInfo.Version = Version
 		// Start the webserver
 		e := routes.NewEcho()
 		routes.RegisterRoutes(e)
 		// Start server
 		go func() {
 			if err := e.Start(viper.GetString("service.interface")); err != nil {
 				e.Logger.Info("shutting down...")
 			}
 		}()
 		// Wait for interrupt signal to gracefully shutdown the server with
 		// a timeout of 10 seconds.
 		quit := make(chan os.Signal, 1)
 		signal.Notify(quit, os.Interrupt)
 		<-quit
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
 		log.Log.Infof("Shutting down...")
 		if err := e.Shutdown(ctx); err != nil {
 			e.Logger.Fatal(err)
 		}
 	},
 }
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@ -27,7 +27,7 @@ import (
 )
 // InitConfig initializes the config, sets defaults etc.
-func init() {
+func InitConfig() {
 	// Set defaults
 	// Service config
--- a/pkg/models/main_test.go
+++ b/pkg/models/main_test.go
@ -17,10 +17,12 @@
 package models
 import (
 	"code.vikunja.io/api/pkg/config"
 	"github.com/spf13/viper"
 	"testing"
 )
 func TestMain(m *testing.M) {
 	config.InitConfig()
 	MainTest(m, viper.GetString("service.rootpath"))
 }
--- a/vendor/github.com/inconshreveable/mousetrap/LICENSE
+++ b/vendor/github.com/inconshreveable/mousetrap/LICENSE
@ -0,0 +1,13 @@
 Copyright 2014 Alan Shreve
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
   http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
--- a/vendor/github.com/inconshreveable/mousetrap/README.md
+++ b/vendor/github.com/inconshreveable/mousetrap/README.md
@ -0,0 +1,23 @@
 # mousetrap
 mousetrap is a tiny library that answers a single question.
 On a Windows machine, was the process invoked by someone double clicking on
 the executable file while browsing in explorer?
 ### Motivation
 Windows developers unfamiliar with command line tools will often "double-click"
 the executable for a tool. Because most CLI tools print the help and then exit
 when invoked without arguments, this is often very frustrating for those users.
 mousetrap provides a way to detect these invocations so that you can provide
 more helpful behavior and instructions on how to run the CLI tool. To see what
 this looks like, both from an organizational and a technical perspective, see
 https://inconshreveable.com/09-09-2014/sweat-the-small-stuff/
 ### The interface
 The library exposes a single interface:
    func StartedByExplorer() (bool)
--- a/vendor/github.com/inconshreveable/mousetrap/trap_others.go
+++ b/vendor/github.com/inconshreveable/mousetrap/trap_others.go
@ -0,0 +1,15 @@
 // +build !windows
 package mousetrap
 // StartedByExplorer returns true if the program was invoked by the user
 // double-clicking on the executable from explorer.exe
 //
 // It is conservative and returns false if any of the internal calls fail.
 // It does not guarantee that the program was run from a terminal. It only can tell you
 // whether it was launched from explorer.exe
 //
 // On non-Windows platforms, it always returns false.
 func StartedByExplorer() bool {
 	return false
 }
--- a/vendor/github.com/inconshreveable/mousetrap/trap_windows.go
+++ b/vendor/github.com/inconshreveable/mousetrap/trap_windows.go
@ -0,0 +1,98 @@
 // +build windows
 // +build !go1.4
 package mousetrap
 import (
 	"fmt"
 	"os"
 	"syscall"
 	"unsafe"
 )
 const (
 	// defined by the Win32 API
 	th32cs_snapprocess uintptr = 0x2
 )
 var (
 	kernel                   = syscall.MustLoadDLL("kernel32.dll")
 	CreateToolhelp32Snapshot = kernel.MustFindProc("CreateToolhelp32Snapshot")
 	Process32First           = kernel.MustFindProc("Process32FirstW")
 	Process32Next            = kernel.MustFindProc("Process32NextW")
 )
 // ProcessEntry32 structure defined by the Win32 API
 type processEntry32 struct {
 	dwSize              uint32
 	cntUsage            uint32
 	th32ProcessID       uint32
 	th32DefaultHeapID   int
 	th32ModuleID        uint32
 	cntThreads          uint32
 	th32ParentProcessID uint32
 	pcPriClassBase      int32
 	dwFlags             uint32
 	szExeFile           [syscall.MAX_PATH]uint16
 }
 func getProcessEntry(pid int) (pe *processEntry32, err error) {
 	snapshot, _, e1 := CreateToolhelp32Snapshot.Call(th32cs_snapprocess, uintptr(0))
 	if snapshot == uintptr(syscall.InvalidHandle) {
 		err = fmt.Errorf("CreateToolhelp32Snapshot: %v", e1)
 		return
 	}
 	defer syscall.CloseHandle(syscall.Handle(snapshot))
 	var processEntry processEntry32
 	processEntry.dwSize = uint32(unsafe.Sizeof(processEntry))
 	ok, _, e1 := Process32First.Call(snapshot, uintptr(unsafe.Pointer(&processEntry)))
 	if ok == 0 {
 		err = fmt.Errorf("Process32First: %v", e1)
 		return
 	}
 	for {
 		if processEntry.th32ProcessID == uint32(pid) {
 			pe = &processEntry
 			return
 		}
 		ok, _, e1 = Process32Next.Call(snapshot, uintptr(unsafe.Pointer(&processEntry)))
 		if ok == 0 {
 			err = fmt.Errorf("Process32Next: %v", e1)
 			return
 		}
 	}
 }
 func getppid() (pid int, err error) {
 	pe, err := getProcessEntry(os.Getpid())
 	if err != nil {
 		return
 	}
 	pid = int(pe.th32ParentProcessID)
 	return
 }
 // StartedByExplorer returns true if the program was invoked by the user double-clicking
 // on the executable from explorer.exe
 //
 // It is conservative and returns false if any of the internal calls fail.
 // It does not guarantee that the program was run from a terminal. It only can tell you
 // whether it was launched from explorer.exe
 func StartedByExplorer() bool {
 	ppid, err := getppid()
 	if err != nil {
 		return false
 	}
 	pe, err := getProcessEntry(ppid)
 	if err != nil {
 		return false
 	}
 	name := syscall.UTF16ToString(pe.szExeFile[:])
 	return name == "explorer.exe"
 }
--- a/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go
+++ b/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go
@ -0,0 +1,46 @@
 // +build windows
 // +build go1.4
 package mousetrap
 import (
 	"os"
 	"syscall"
 	"unsafe"
 )
 func getProcessEntry(pid int) (*syscall.ProcessEntry32, error) {
 	snapshot, err := syscall.CreateToolhelp32Snapshot(syscall.TH32CS_SNAPPROCESS, 0)
 	if err != nil {
 		return nil, err
 	}
 	defer syscall.CloseHandle(snapshot)
 	var procEntry syscall.ProcessEntry32
 	procEntry.Size = uint32(unsafe.Sizeof(procEntry))
 	if err = syscall.Process32First(snapshot, &procEntry); err != nil {
 		return nil, err
 	}
 	for {
 		if procEntry.ProcessID == uint32(pid) {
 			return &procEntry, nil
 		}
 		err = syscall.Process32Next(snapshot, &procEntry)
 		if err != nil {
 			return nil, err
 		}
 	}
 }
 // StartedByExplorer returns true if the program was invoked by the user double-clicking
 // on the executable from explorer.exe
 //
 // It is conservative and returns false if any of the internal calls fail.
 // It does not guarantee that the program was run from a terminal. It only can tell you
 // whether it was launched from explorer.exe
 func StartedByExplorer() bool {
 	pe, err := getProcessEntry(os.Getppid())
 	if err != nil {
 		return false
 	}
 	return "explorer.exe" == syscall.UTF16ToString(pe.ExeFile[:])
 }
--- a/vendor/github.com/spf13/cobra/.gitignore
+++ b/vendor/github.com/spf13/cobra/.gitignore
@ -0,0 +1,36 @@
 # Compiled Object files, Static and Dynamic libs (Shared Objects)
 *.o
 *.a
 *.so
 # Folders
 _obj
 _test
 # Architecture specific extensions/prefixes
 *.[568vq]
 [568vq].out
 *.cgo1.go
 *.cgo2.c
 _cgo_defun.c
 _cgo_gotypes.go
 _cgo_export.*
 _testmain.go
 # Vim files https://github.com/github/gitignore/blob/master/Global/Vim.gitignore
 # swap
 [._]*.s[a-w][a-z]
 [._]s[a-w][a-z]
 # session
 Session.vim
 # temporary
 .netrwhist
 *~
 # auto-generated tag files
 tags
 *.exe
 cobra.test
--- a/vendor/github.com/spf13/cobra/.mailmap
+++ b/vendor/github.com/spf13/cobra/.mailmap
@ -0,0 +1,3 @@
 Steve Francia <steve.francia@gmail.com>
 Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
 Fabiano Franz <ffranz@redhat.com>                   <contact@fabianofranz.com>
--- a/vendor/github.com/spf13/cobra/.travis.yml
+++ b/vendor/github.com/spf13/cobra/.travis.yml
@ -0,0 +1,21 @@
 language: go
 matrix:
  include:
    - go: 1.9.4
    - go: 1.10.0
    - go: tip
  allow_failures:
    - go: tip
 before_install:
  - mkdir -p bin
  - curl -Lso bin/shellcheck https://github.com/caarlos0/shellcheck-docker/releases/download/v0.4.3/shellcheck
  - chmod +x bin/shellcheck
 script:
  - PATH=$PATH:$PWD/bin go test -v ./...
  - go build
  - diff -u <(echo -n) <(gofmt -d -s .)
  - if [ -z $NOVET ]; then
      diff -u <(echo -n) <(go tool vet . 2>&1 | grep -vE 'ExampleCommand|bash_completions.*Fprint');
    fi
--- a/vendor/github.com/spf13/cobra/LICENSE.txt
+++ b/vendor/github.com/spf13/cobra/LICENSE.txt
@ -0,0 +1,174 @@
                                Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
--- a/vendor/github.com/spf13/cobra/README.md
+++ b/vendor/github.com/spf13/cobra/README.md
@ -0,0 +1,736 @@
 ![cobra logo](https://cloud.githubusercontent.com/assets/173412/10886352/ad566232-814f-11e5-9cd0-aa101788c117.png)
 Cobra is both a library for creating powerful modern CLI applications as well as a program to generate applications and command files.
 Many of the most widely used Go projects are built using Cobra including:
 * [Kubernetes](http://kubernetes.io/)
 * [Hugo](http://gohugo.io)
 * [rkt](https://github.com/coreos/rkt)
 * [etcd](https://github.com/coreos/etcd)
 * [Moby (former Docker)](https://github.com/moby/moby)
 * [Docker (distribution)](https://github.com/docker/distribution)
 * [OpenShift](https://www.openshift.com/)
 * [Delve](https://github.com/derekparker/delve)
 * [GopherJS](http://www.gopherjs.org/)
 * [CockroachDB](http://www.cockroachlabs.com/)
 * [Bleve](http://www.blevesearch.com/)
 * [ProjectAtomic (enterprise)](http://www.projectatomic.io/)
 * [GiantSwarm's swarm](https://github.com/giantswarm/cli)
 * [Nanobox](https://github.com/nanobox-io/nanobox)/[Nanopack](https://github.com/nanopack)
 * [rclone](http://rclone.org/)
 * [nehm](https://github.com/bogem/nehm)
 * [Pouch](https://github.com/alibaba/pouch)
 [![Build Status](https://travis-ci.org/spf13/cobra.svg "Travis CI status")](https://travis-ci.org/spf13/cobra)
 [![CircleCI status](https://circleci.com/gh/spf13/cobra.png?circle-token=:circle-token "CircleCI status")](https://circleci.com/gh/spf13/cobra)
 [![GoDoc](https://godoc.org/github.com/spf13/cobra?status.svg)](https://godoc.org/github.com/spf13/cobra)
 # Table of Contents
 - [Overview](#overview)
 - [Concepts](#concepts)
  * [Commands](#commands)
  * [Flags](#flags)
 - [Installing](#installing)
 - [Getting Started](#getting-started)
  * [Using the Cobra Generator](#using-the-cobra-generator)
  * [Using the Cobra Library](#using-the-cobra-library)
  * [Working with Flags](#working-with-flags)
  * [Positional and Custom Arguments](#positional-and-custom-arguments)
  * [Example](#example)
  * [Help Command](#help-command)
  * [Usage Message](#usage-message)
  * [PreRun and PostRun Hooks](#prerun-and-postrun-hooks)
  * [Suggestions when "unknown command" happens](#suggestions-when-unknown-command-happens)
  * [Generating documentation for your command](#generating-documentation-for-your-command)
  * [Generating bash completions](#generating-bash-completions)
 - [Contributing](#contributing)
 - [License](#license)
 # Overview
 Cobra is a library providing a simple interface to create powerful modern CLI
 interfaces similar to git & go tools.
 Cobra is also an application that will generate your application scaffolding to rapidly
 develop a Cobra-based application.
 Cobra provides:
 * Easy subcommand-based CLIs: `app server`, `app fetch`, etc.
 * Fully POSIX-compliant flags (including short & long versions)
 * Nested subcommands
 * Global, local and cascading flags
 * Easy generation of applications & commands with `cobra init appname` & `cobra add cmdname`
 * Intelligent suggestions (`app srver`... did you mean `app server`?)
 * Automatic help generation for commands and flags
 * Automatic help flag recognition of `-h`, `--help`, etc.
 * Automatically generated bash autocomplete for your application
 * Automatically generated man pages for your application
 * Command aliases so you can change things without breaking them
 * The flexibility to define your own help, usage, etc.
 * Optional tight integration with [viper](http://github.com/spf13/viper) for 12-factor apps
 # Concepts
 Cobra is built on a structure of commands, arguments & flags.
 **Commands** represent actions, **Args** are things and **Flags** are modifiers for those actions.
 The best applications will read like sentences when used. Users will know how
 to use the application because they will natively understand how to use it.
 The pattern to follow is
 `APPNAME VERB NOUN --ADJECTIVE.`
    or
 `APPNAME COMMAND ARG --FLAG`
 A few good real world examples may better illustrate this point.
 In the following example, 'server' is a command, and 'port' is a flag:
    hugo server --port=1313
 In this command we are telling Git to clone the url bare.
    git clone URL --bare
 ## Commands
 Command is the central point of the application. Each interaction that
 the application supports will be contained in a Command. A command can
 have children commands and optionally run an action.
 In the example above, 'server' is the command.
 [More about cobra.Command](https://godoc.org/github.com/spf13/cobra#Command)
 ## Flags
 A flag is a way to modify the behavior of a command. Cobra supports
 fully POSIX-compliant flags as well as the Go [flag package](https://golang.org/pkg/flag/).
 A Cobra command can define flags that persist through to children commands
 and flags that are only available to that command.
 In the example above, 'port' is the flag.
 Flag functionality is provided by the [pflag
 library](https://github.com/spf13/pflag), a fork of the flag standard library
 which maintains the same interface while adding POSIX compliance.
 # Installing
 Using Cobra is easy. First, use `go get` to install the latest version
 of the library. This command will install the `cobra` generator executable
 along with the library and its dependencies:
    go get -u github.com/spf13/cobra/cobra
 Next, include Cobra in your application:
 ```go
 import "github.com/spf13/cobra"
 ```
 # Getting Started
 While you are welcome to provide your own organization, typically a Cobra-based
 application will follow the following organizational structure:
 ```
  ▾ appName/
    ▾ cmd/
        add.go
        your.go
        commands.go
        here.go
      main.go
 ```
 In a Cobra app, typically the main.go file is very bare. It serves one purpose: initializing Cobra.
 ```go
 package main
 import (
  "fmt"
  "os"
  "{pathToYourApp}/cmd"
 )
 func main() {
  cmd.Execute()
 }
 ```
 ## Using the Cobra Generator
 Cobra provides its own program that will create your application and add any
 commands you want. It's the easiest way to incorporate Cobra into your application.
 [Here](https://github.com/spf13/cobra/blob/master/cobra/README.md) you can find more information about it.
 ## Using the Cobra Library
 To manually implement Cobra you need to create a bare main.go file and a rootCmd file.
 You will optionally provide additional commands as you see fit.
 ### Create rootCmd
 Cobra doesn't require any special constructors. Simply create your commands.
 Ideally you place this in app/cmd/root.go:
 ```go
 var rootCmd = &cobra.Command{
  Use:   "hugo",
  Short: "Hugo is a very fast static site generator",
  Long: `A Fast and Flexible Static Site Generator built with
                love by spf13 and friends in Go.
                Complete documentation is available at http://hugo.spf13.com`,
  Run: func(cmd *cobra.Command, args []string) {
    // Do Stuff Here
  },
 }
 func Execute() {
  if err := rootCmd.Execute(); err != nil {
    fmt.Println(err)
    os.Exit(1)
  }
 }
 ```
 You will additionally define flags and handle configuration in your init() function.
 For example cmd/root.go:
 ```go
 import (
  "fmt"
  "os"
  homedir "github.com/mitchellh/go-homedir"
  "github.com/spf13/cobra"
  "github.com/spf13/viper"
 )
 func init() {
  cobra.OnInitialize(initConfig)
  rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.cobra.yaml)")
  rootCmd.PersistentFlags().StringVarP(&projectBase, "projectbase", "b", "", "base project directory eg. github.com/spf13/")
  rootCmd.PersistentFlags().StringP("author", "a", "YOUR NAME", "Author name for copyright attribution")
  rootCmd.PersistentFlags().StringVarP(&userLicense, "license", "l", "", "Name of license for the project (can provide `licensetext` in config)")
  rootCmd.PersistentFlags().Bool("viper", true, "Use Viper for configuration")
  viper.BindPFlag("author", rootCmd.PersistentFlags().Lookup("author"))
  viper.BindPFlag("projectbase", rootCmd.PersistentFlags().Lookup("projectbase"))
  viper.BindPFlag("useViper", rootCmd.PersistentFlags().Lookup("viper"))
  viper.SetDefault("author", "NAME HERE <EMAIL ADDRESS>")
  viper.SetDefault("license", "apache")
 }
 func initConfig() {
  // Don't forget to read config either from cfgFile or from home directory!
  if cfgFile != "" {
    // Use config file from the flag.
    viper.SetConfigFile(cfgFile)
  } else {
    // Find home directory.
    home, err := homedir.Dir()
    if err != nil {
      fmt.Println(err)
      os.Exit(1)
    }
    // Search config in home directory with name ".cobra" (without extension).
    viper.AddConfigPath(home)
    viper.SetConfigName(".cobra")
  }
  if err := viper.ReadInConfig(); err != nil {
    fmt.Println("Can't read config:", err)
    os.Exit(1)
  }
 }
 ```
 ### Create your main.go
 With the root command you need to have your main function execute it.
 Execute should be run on the root for clarity, though it can be called on any command.
 In a Cobra app, typically the main.go file is very bare. It serves, one purpose, to initialize Cobra.
 ```go
 package main
 import (
  "fmt"
  "os"
  "{pathToYourApp}/cmd"
 )
 func main() {
  cmd.Execute()
 }
 ```
 ### Create additional commands
 Additional commands can be defined and typically are each given their own file
 inside of the cmd/ directory.
 If you wanted to create a version command you would create cmd/version.go and
 populate it with the following:
 ```go
 package cmd
 import (
  "fmt"
  "github.com/spf13/cobra"
 )
 func init() {
  rootCmd.AddCommand(versionCmd)
 }
 var versionCmd = &cobra.Command{
  Use:   "version",
  Short: "Print the version number of Hugo",
  Long:  `All software has versions. This is Hugo's`,
  Run: func(cmd *cobra.Command, args []string) {
    fmt.Println("Hugo Static Site Generator v0.9 -- HEAD")
  },
 }
 ```
 ## Working with Flags
 Flags provide modifiers to control how the action command operates.
 ### Assign flags to a command
 Since the flags are defined and used in different locations, we need to
 define a variable outside with the correct scope to assign the flag to
 work with.
 ```go
 var Verbose bool
 var Source string
 ```
 There are two different approaches to assign a flag.
 ### Persistent Flags
 A flag can be 'persistent' meaning that this flag will be available to the
 command it's assigned to as well as every command under that command. For
 global flags, assign a flag as a persistent flag on the root.
 ```go
 rootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")
 ```
 ### Local Flags
 A flag can also be assigned locally which will only apply to that specific command.
 ```go
 rootCmd.Flags().StringVarP(&Source, "source", "s", "", "Source directory to read from")
 ```
 ### Local Flag on Parent Commands
 By default Cobra only parses local flags on the target command, any local flags on
 parent commands are ignored. By enabling `Command.TraverseChildren` Cobra will
 parse local flags on each command before executing the target command.
 ```go
 command := cobra.Command{
  Use: "print [OPTIONS] [COMMANDS]",
  TraverseChildren: true,
 }
 ```
 ### Bind Flags with Config
 You can also bind your flags with [viper](https://github.com/spf13/viper):
 ```go
 var author string
 func init() {
  rootCmd.PersistentFlags().StringVar(&author, "author", "YOUR NAME", "Author name for copyright attribution")
  viper.BindPFlag("author", rootCmd.PersistentFlags().Lookup("author"))
 }
 ```
 In this example the persistent flag `author` is bound with `viper`.
 **Note**, that the variable `author` will not be set to the value from config,
 when the `--author` flag is not provided by user.
 More in [viper documentation](https://github.com/spf13/viper#working-with-flags).
 ### Required flags
 Flags are optional by default. If instead you wish your command to report an error
 when a flag has not been set, mark it as required:
 ```go
 rootCmd.Flags().StringVarP(&Region, "region", "r", "", "AWS region (required)")
 rootCmd.MarkFlagRequired("region")
 ```
 ## Positional and Custom Arguments
 Validation of positional arguments can be specified using the `Args` field
 of `Command`.
 The following validators are built in:
 - `NoArgs` - the command will report an error if there are any positional args.
 - `ArbitraryArgs` - the command will accept any args.
 - `OnlyValidArgs` - the command will report an error if there are any positional args that are not in the `ValidArgs` field of `Command`.
 - `MinimumNArgs(int)` - the command will report an error if there are not at least N positional args.
 - `MaximumNArgs(int)` - the command will report an error if there are more than N positional args.
 - `ExactArgs(int)` - the command will report an error if there are not exactly N positional args.
 - `RangeArgs(min, max)` - the command will report an error if the number of args is not between the minimum and maximum number of expected args.
 An example of setting the custom validator:
 ```go
 var cmd = &cobra.Command{
  Short: "hello",
  Args: func(cmd *cobra.Command, args []string) error {
    if len(args) < 1 {
      return errors.New("requires at least one arg")
    }
    if myapp.IsValidColor(args[0]) {
      return nil
    }
    return fmt.Errorf("invalid color specified: %s", args[0])
  },
  Run: func(cmd *cobra.Command, args []string) {
    fmt.Println("Hello, World!")
  },
 }
 ```
 ## Example
 In the example below, we have defined three commands. Two are at the top level
 and one (cmdTimes) is a child of one of the top commands. In this case the root
 is not executable meaning that a subcommand is required. This is accomplished
 by not providing a 'Run' for the 'rootCmd'.
 We have only defined one flag for a single command.
 More documentation about flags is available at https://github.com/spf13/pflag
 ```go
 package main
 import (
  "fmt"
  "strings"
  "github.com/spf13/cobra"
 )
 func main() {
  var echoTimes int
  var cmdPrint = &cobra.Command{
    Use:   "print [string to print]",
    Short: "Print anything to the screen",
    Long: `print is for printing anything back to the screen.
 For many years people have printed back to the screen.`,
    Args: cobra.MinimumNArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
      fmt.Println("Print: " + strings.Join(args, " "))
    },
  }
  var cmdEcho = &cobra.Command{
    Use:   "echo [string to echo]",
    Short: "Echo anything to the screen",
    Long: `echo is for echoing anything back.
 Echo works a lot like print, except it has a child command.`,
    Args: cobra.MinimumNArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
      fmt.Println("Print: " + strings.Join(args, " "))
    },
  }
  var cmdTimes = &cobra.Command{
    Use:   "times [# times] [string to echo]",
    Short: "Echo anything to the screen more times",
    Long: `echo things multiple times back to the user by providing
 a count and a string.`,
    Args: cobra.MinimumNArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
      for i := 0; i < echoTimes; i++ {
        fmt.Println("Echo: " + strings.Join(args, " "))
      }
    },
  }
  cmdTimes.Flags().IntVarP(&echoTimes, "times", "t", 1, "times to echo the input")
  var rootCmd = &cobra.Command{Use: "app"}
  rootCmd.AddCommand(cmdPrint, cmdEcho)
  cmdEcho.AddCommand(cmdTimes)
  rootCmd.Execute()
 }
 ```
 For a more complete example of a larger application, please checkout [Hugo](http://gohugo.io/).
 ## Help Command
 Cobra automatically adds a help command to your application when you have subcommands.
 This will be called when a user runs 'app help'. Additionally, help will also
 support all other commands as input. Say, for instance, you have a command called
 'create' without any additional configuration; Cobra will work when 'app help
 create' is called.  Every command will automatically have the '--help' flag added.
 ### Example
 The following output is automatically generated by Cobra. Nothing beyond the
 command and flag definitions are needed.
    $ cobra help
    Cobra is a CLI library for Go that empowers applications.
    This application is a tool to generate the needed files
    to quickly create a Cobra application.
    Usage:
      cobra [command]
    Available Commands:
      add         Add a command to a Cobra Application
      help        Help about any command
      init        Initialize a Cobra Application
    Flags:
      -a, --author string    author name for copyright attribution (default "YOUR NAME")
          --config string    config file (default is $HOME/.cobra.yaml)
      -h, --help             help for cobra
      -l, --license string   name of license for the project
          --viper            use Viper for configuration (default true)
    Use "cobra [command] --help" for more information about a command.
 Help is just a command like any other. There is no special logic or behavior
 around it. In fact, you can provide your own if you want.
 ### Defining your own help
 You can provide your own Help command or your own template for the default command to use
 with following functions:
 ```go
 cmd.SetHelpCommand(cmd *Command)
 cmd.SetHelpFunc(f func(*Command, []string))
 cmd.SetHelpTemplate(s string)
 ```
 The latter two will also apply to any children commands.
 ## Usage Message
 When the user provides an invalid flag or invalid command, Cobra responds by
 showing the user the 'usage'.
 ### Example
 You may recognize this from the help above. That's because the default help
 embeds the usage as part of its output.
    $ cobra --invalid
    Error: unknown flag: --invalid
    Usage:
      cobra [command]
    Available Commands:
      add         Add a command to a Cobra Application
      help        Help about any command
      init        Initialize a Cobra Application
    Flags:
      -a, --author string    author name for copyright attribution (default "YOUR NAME")
          --config string    config file (default is $HOME/.cobra.yaml)
      -h, --help             help for cobra
      -l, --license string   name of license for the project
          --viper            use Viper for configuration (default true)
    Use "cobra [command] --help" for more information about a command.
 ### Defining your own usage
 You can provide your own usage function or template for Cobra to use.
 Like help, the function and template are overridable through public methods:
 ```go
 cmd.SetUsageFunc(f func(*Command) error)
 cmd.SetUsageTemplate(s string)
 ```
 ## Version Flag
 Cobra adds a top-level '--version' flag if the Version field is set on the root command.
 Running an application with the '--version' flag will print the version to stdout using
 the version template. The template can be customized using the
 `cmd.SetVersionTemplate(s string)` function.
 ## PreRun and PostRun Hooks
 It is possible to run functions before or after the main `Run` function of your command. The `PersistentPreRun` and `PreRun` functions will be executed before `Run`. `PersistentPostRun` and `PostRun` will be executed after `Run`.  The `Persistent*Run` functions will be inherited by children if they do not declare their own.  These functions are run in the following order:
 - `PersistentPreRun`
 - `PreRun`
 - `Run`
 - `PostRun`
 - `PersistentPostRun`
 An example of two commands which use all of these features is below.  When the subcommand is executed, it will run the root command's `PersistentPreRun` but not the root command's `PersistentPostRun`:
 ```go
 package main
 import (
  "fmt"
  "github.com/spf13/cobra"
 )
 func main() {
  var rootCmd = &cobra.Command{
    Use:   "root [sub]",
    Short: "My root command",
    PersistentPreRun: func(cmd *cobra.Command, args []string) {
      fmt.Printf("Inside rootCmd PersistentPreRun with args: %v\n", args)
    },
    PreRun: func(cmd *cobra.Command, args []string) {
      fmt.Printf("Inside rootCmd PreRun with args: %v\n", args)
    },
    Run: func(cmd *cobra.Command, args []string) {
      fmt.Printf("Inside rootCmd Run with args: %v\n", args)
    },
    PostRun: func(cmd *cobra.Command, args []string) {
      fmt.Printf("Inside rootCmd PostRun with args: %v\n", args)
    },
    PersistentPostRun: func(cmd *cobra.Command, args []string) {
      fmt.Printf("Inside rootCmd PersistentPostRun with args: %v\n", args)
    },
  }
  var subCmd = &cobra.Command{
    Use:   "sub [no options!]",
    Short: "My subcommand",
    PreRun: func(cmd *cobra.Command, args []string) {
      fmt.Printf("Inside subCmd PreRun with args: %v\n", args)
    },
    Run: func(cmd *cobra.Command, args []string) {
      fmt.Printf("Inside subCmd Run with args: %v\n", args)
    },
    PostRun: func(cmd *cobra.Command, args []string) {
      fmt.Printf("Inside subCmd PostRun with args: %v\n", args)
    },
    PersistentPostRun: func(cmd *cobra.Command, args []string) {
      fmt.Printf("Inside subCmd PersistentPostRun with args: %v\n", args)
    },
  }
  rootCmd.AddCommand(subCmd)
  rootCmd.SetArgs([]string{""})
  rootCmd.Execute()
  fmt.Println()
  rootCmd.SetArgs([]string{"sub", "arg1", "arg2"})
  rootCmd.Execute()
 }
 ```
 Output:
 ```
 Inside rootCmd PersistentPreRun with args: []
 Inside rootCmd PreRun with args: []
 Inside rootCmd Run with args: []
 Inside rootCmd PostRun with args: []
 Inside rootCmd PersistentPostRun with args: []
 Inside rootCmd PersistentPreRun with args: [arg1 arg2]
 Inside subCmd PreRun with args: [arg1 arg2]
 Inside subCmd Run with args: [arg1 arg2]
 Inside subCmd PostRun with args: [arg1 arg2]
 Inside subCmd PersistentPostRun with args: [arg1 arg2]
 ```
 ## Suggestions when "unknown command" happens
 Cobra will print automatic suggestions when "unknown command" errors happen. This allows Cobra to behave similarly to the `git` command when a typo happens. For example:
 ```
 $ hugo srever
 Error: unknown command "srever" for "hugo"
 Did you mean this?
        server
 Run 'hugo --help' for usage.
 ```
 Suggestions are automatic based on every subcommand registered and use an implementation of [Levenshtein distance](http://en.wikipedia.org/wiki/Levenshtein_distance). Every registered command that matches a minimum distance of 2 (ignoring case) will be displayed as a suggestion.
 If you need to disable suggestions or tweak the string distance in your command, use:
 ```go
 command.DisableSuggestions = true
 ```
 or
 ```go
 command.SuggestionsMinimumDistance = 1
 ```
 You can also explicitly set names for which a given command will be suggested using the `SuggestFor` attribute. This allows suggestions for strings that are not close in terms of string distance, but makes sense in your set of commands and for some which you don't want aliases. Example:
 ```
 $ kubectl remove
 Error: unknown command "remove" for "kubectl"
 Did you mean this?
        delete
 Run 'kubectl help' for usage.
 ```
 ## Generating documentation for your command
 Cobra can generate documentation based on subcommands, flags, etc. in the following formats:
 - [Markdown](doc/md_docs.md)
 - [ReStructured Text](doc/rest_docs.md)
 - [Man Page](doc/man_docs.md)
 ## Generating bash completions
 Cobra can generate a bash-completion file. If you add more information to your command, these completions can be amazingly powerful and flexible.  Read more about it in [Bash Completions](bash_completions.md).
 # Contributing
 1. Fork it
 2. Download your fork to your PC (`git clone https://github.com/your_username/cobra && cd cobra`)
 3. Create your feature branch (`git checkout -b my-new-feature`)
 4. Make changes and add them (`git add .`)
 5. Commit your changes (`git commit -m 'Add some feature'`)
 6. Push to the branch (`git push origin my-new-feature`)
 7. Create new pull request
 # License
 Cobra is released under the Apache 2.0 license. See [LICENSE.txt](https://github.com/spf13/cobra/blob/master/LICENSE.txt)
--- a/vendor/github.com/spf13/cobra/args.go
+++ b/vendor/github.com/spf13/cobra/args.go
@ -0,0 +1,89 @@
 package cobra
 import (
 	"fmt"
 )
 type PositionalArgs func(cmd *Command, args []string) error
 // Legacy arg validation has the following behaviour:
 // - root commands with no subcommands can take arbitrary arguments
 // - root commands with subcommands will do subcommand validity checking
 // - subcommands will always accept arbitrary arguments
 func legacyArgs(cmd *Command, args []string) error {
 	// no subcommand, always take args
 	if !cmd.HasSubCommands() {
 		return nil
 	}
 	// root command with subcommands, do subcommand checking.
 	if !cmd.HasParent() && len(args) > 0 {
 		return fmt.Errorf("unknown command %q for %q%s", args[0], cmd.CommandPath(), cmd.findSuggestions(args[0]))
 	}
 	return nil
 }
 // NoArgs returns an error if any args are included.
 func NoArgs(cmd *Command, args []string) error {
 	if len(args) > 0 {
 		return fmt.Errorf("unknown command %q for %q", args[0], cmd.CommandPath())
 	}
 	return nil
 }
 // OnlyValidArgs returns an error if any args are not in the list of ValidArgs.
 func OnlyValidArgs(cmd *Command, args []string) error {
 	if len(cmd.ValidArgs) > 0 {
 		for _, v := range args {
 			if !stringInSlice(v, cmd.ValidArgs) {
 				return fmt.Errorf("invalid argument %q for %q%s", v, cmd.CommandPath(), cmd.findSuggestions(args[0]))
 			}
 		}
 	}
 	return nil
 }
 // ArbitraryArgs never returns an error.
 func ArbitraryArgs(cmd *Command, args []string) error {
 	return nil
 }
 // MinimumNArgs returns an error if there is not at least N args.
 func MinimumNArgs(n int) PositionalArgs {
 	return func(cmd *Command, args []string) error {
 		if len(args) < n {
 			return fmt.Errorf("requires at least %d arg(s), only received %d", n, len(args))
 		}
 		return nil
 	}
 }
 // MaximumNArgs returns an error if there are more than N args.
 func MaximumNArgs(n int) PositionalArgs {
 	return func(cmd *Command, args []string) error {
 		if len(args) > n {
 			return fmt.Errorf("accepts at most %d arg(s), received %d", n, len(args))
 		}
 		return nil
 	}
 }
 // ExactArgs returns an error if there are not exactly n args.
 func ExactArgs(n int) PositionalArgs {
 	return func(cmd *Command, args []string) error {
 		if len(args) != n {
 			return fmt.Errorf("accepts %d arg(s), received %d", n, len(args))
 		}
 		return nil
 	}
 }
 // RangeArgs returns an error if the number of args is not within the expected range.
 func RangeArgs(min int, max int) PositionalArgs {
 	return func(cmd *Command, args []string) error {
 		if len(args) < min || len(args) > max {
 			return fmt.Errorf("accepts between %d and %d arg(s), received %d", min, max, len(args))
 		}
 		return nil
 	}
 }
--- a/vendor/github.com/spf13/cobra/bash_completions.go
+++ b/vendor/github.com/spf13/cobra/bash_completions.go
@ -0,0 +1,584 @@
 package cobra
 import (
 	"bytes"
 	"fmt"
 	"io"
 	"os"
 	"sort"
 	"strings"
 	"github.com/spf13/pflag"
 )
 // Annotations for Bash completion.
 const (
 	BashCompFilenameExt     = "cobra_annotation_bash_completion_filename_extensions"
 	BashCompCustom          = "cobra_annotation_bash_completion_custom"
 	BashCompOneRequiredFlag = "cobra_annotation_bash_completion_one_required_flag"
 	BashCompSubdirsInDir    = "cobra_annotation_bash_completion_subdirs_in_dir"
 )
 func writePreamble(buf *bytes.Buffer, name string) {
 	buf.WriteString(fmt.Sprintf("# bash completion for %-36s -*- shell-script -*-\n", name))
 	buf.WriteString(fmt.Sprintf(`
 __%[1]s_debug()
 {
    if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then
        echo "$*" >> "${BASH_COMP_DEBUG_FILE}"
    fi
 }
 # Homebrew on Macs have version 1.3 of bash-completion which doesn't include
 # _init_completion. This is a very minimal version of that function.
 __%[1]s_init_completion()
 {
    COMPREPLY=()
    _get_comp_words_by_ref "$@" cur prev words cword
 }
 __%[1]s_index_of_word()
 {
    local w word=$1
    shift
    index=0
    for w in "$@"; do
        [[ $w = "$word" ]] && return
        index=$((index+1))
    done
    index=-1
 }
 __%[1]s_contains_word()
 {
    local w word=$1; shift
    for w in "$@"; do
        [[ $w = "$word" ]] && return
    done
    return 1
 }
 __%[1]s_handle_reply()
 {
    __%[1]s_debug "${FUNCNAME[0]}"
    case $cur in
        -*)
            if [[ $(type -t compopt) = "builtin" ]]; then
                compopt -o nospace
            fi
            local allflags
            if [ ${#must_have_one_flag[@]} -ne 0 ]; then
                allflags=("${must_have_one_flag[@]}")
            else
                allflags=("${flags[*]} ${two_word_flags[*]}")
            fi
            COMPREPLY=( $(compgen -W "${allflags[*]}" -- "$cur") )
            if [[ $(type -t compopt) = "builtin" ]]; then
                [[ "${COMPREPLY[0]}" == *= ]] || compopt +o nospace
            fi
            # complete after --flag=abc
            if [[ $cur == *=* ]]; then
                if [[ $(type -t compopt) = "builtin" ]]; then
                    compopt +o nospace
                fi
                local index flag
                flag="${cur%%=*}"
                __%[1]s_index_of_word "${flag}" "${flags_with_completion[@]}"
                COMPREPLY=()
                if [[ ${index} -ge 0 ]]; then
                    PREFIX=""
                    cur="${cur#*=}"
                    ${flags_completion[${index}]}
                    if [ -n "${ZSH_VERSION}" ]; then
                        # zsh completion needs --flag= prefix
                        eval "COMPREPLY=( \"\${COMPREPLY[@]/#/${flag}=}\" )"
                    fi
                fi
            fi
            return 0;
            ;;
    esac
    # check if we are handling a flag with special work handling
    local index
    __%[1]s_index_of_word "${prev}" "${flags_with_completion[@]}"
    if [[ ${index} -ge 0 ]]; then
        ${flags_completion[${index}]}
        return
    fi
    # we are parsing a flag and don't have a special handler, no completion
    if [[ ${cur} != "${words[cword]}" ]]; then
        return
    fi
    local completions
    completions=("${commands[@]}")
    if [[ ${#must_have_one_noun[@]} -ne 0 ]]; then
        completions=("${must_have_one_noun[@]}")
    fi
    if [[ ${#must_have_one_flag[@]} -ne 0 ]]; then
        completions+=("${must_have_one_flag[@]}")
    fi
    COMPREPLY=( $(compgen -W "${completions[*]}" -- "$cur") )
    if [[ ${#COMPREPLY[@]} -eq 0 && ${#noun_aliases[@]} -gt 0 && ${#must_have_one_noun[@]} -ne 0 ]]; then
        COMPREPLY=( $(compgen -W "${noun_aliases[*]}" -- "$cur") )
    fi
    if [[ ${#COMPREPLY[@]} -eq 0 ]]; then
        declare -F __custom_func >/dev/null && __custom_func
    fi
    # available in bash-completion >= 2, not always present on macOS
    if declare -F __ltrim_colon_completions >/dev/null; then
        __ltrim_colon_completions "$cur"
    fi
    # If there is only 1 completion and it is a flag with an = it will be completed
    # but we don't want a space after the =
    if [[ "${#COMPREPLY[@]}" -eq "1" ]] && [[ $(type -t compopt) = "builtin" ]] && [[ "${COMPREPLY[0]}" == --*= ]]; then
       compopt -o nospace
    fi
 }
 # The arguments should be in the form "ext1|ext2|extn"
 __%[1]s_handle_filename_extension_flag()
 {
    local ext="$1"
    _filedir "@(${ext})"
 }
 __%[1]s_handle_subdirs_in_dir_flag()
 {
    local dir="$1"
    pushd "${dir}" >/dev/null 2>&1 && _filedir -d && popd >/dev/null 2>&1
 }
 __%[1]s_handle_flag()
 {
    __%[1]s_debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"
    # if a command required a flag, and we found it, unset must_have_one_flag()
    local flagname=${words[c]}
    local flagvalue
    # if the word contained an =
    if [[ ${words[c]} == *"="* ]]; then
        flagvalue=${flagname#*=} # take in as flagvalue after the =
        flagname=${flagname%%=*} # strip everything after the =
        flagname="${flagname}=" # but put the = back
    fi
    __%[1]s_debug "${FUNCNAME[0]}: looking for ${flagname}"
    if __%[1]s_contains_word "${flagname}" "${must_have_one_flag[@]}"; then
        must_have_one_flag=()
    fi
    # if you set a flag which only applies to this command, don't show subcommands
    if __%[1]s_contains_word "${flagname}" "${local_nonpersistent_flags[@]}"; then
      commands=()
    fi
    # keep flag value with flagname as flaghash
    # flaghash variable is an associative array which is only supported in bash > 3.
    if [[ -z "${BASH_VERSION}" || "${BASH_VERSINFO[0]}" -gt 3 ]]; then
        if [ -n "${flagvalue}" ] ; then
            flaghash[${flagname}]=${flagvalue}
        elif [ -n "${words[ $((c+1)) ]}" ] ; then
            flaghash[${flagname}]=${words[ $((c+1)) ]}
        else
            flaghash[${flagname}]="true" # pad "true" for bool flag
        fi
    fi
    # skip the argument to a two word flag
    if __%[1]s_contains_word "${words[c]}" "${two_word_flags[@]}"; then
        c=$((c+1))
        # if we are looking for a flags value, don't show commands
        if [[ $c -eq $cword ]]; then
            commands=()
        fi
    fi
    c=$((c+1))
 }
 __%[1]s_handle_noun()
 {
    __%[1]s_debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"
    if __%[1]s_contains_word "${words[c]}" "${must_have_one_noun[@]}"; then
        must_have_one_noun=()
    elif __%[1]s_contains_word "${words[c]}" "${noun_aliases[@]}"; then
        must_have_one_noun=()
    fi
    nouns+=("${words[c]}")
    c=$((c+1))
 }
 __%[1]s_handle_command()
 {
    __%[1]s_debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"
    local next_command
    if [[ -n ${last_command} ]]; then
        next_command="_${last_command}_${words[c]//:/__}"
    else
        if [[ $c -eq 0 ]]; then
            next_command="_%[1]s_root_command"
        else
            next_command="_${words[c]//:/__}"
        fi
    fi
    c=$((c+1))
    __%[1]s_debug "${FUNCNAME[0]}: looking for ${next_command}"
    declare -F "$next_command" >/dev/null && $next_command
 }
 __%[1]s_handle_word()
 {
    if [[ $c -ge $cword ]]; then
        __%[1]s_handle_reply
        return
    fi
    __%[1]s_debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"
    if [[ "${words[c]}" == -* ]]; then
        __%[1]s_handle_flag
    elif __%[1]s_contains_word "${words[c]}" "${commands[@]}"; then
        __%[1]s_handle_command
    elif [[ $c -eq 0 ]]; then
        __%[1]s_handle_command
    elif __%[1]s_contains_word "${words[c]}" "${command_aliases[@]}"; then
        # aliashash variable is an associative array which is only supported in bash > 3.
        if [[ -z "${BASH_VERSION}" || "${BASH_VERSINFO[0]}" -gt 3 ]]; then
            words[c]=${aliashash[${words[c]}]}
            __%[1]s_handle_command
        else
            __%[1]s_handle_noun
        fi
    else
        __%[1]s_handle_noun
    fi
    __%[1]s_handle_word
 }
 `, name))
 }
 func writePostscript(buf *bytes.Buffer, name string) {
 	name = strings.Replace(name, ":", "__", -1)
 	buf.WriteString(fmt.Sprintf("__start_%s()\n", name))
 	buf.WriteString(fmt.Sprintf(`{
    local cur prev words cword
    declare -A flaghash 2>/dev/null || :
    declare -A aliashash 2>/dev/null || :
    if declare -F _init_completion >/dev/null 2>&1; then
        _init_completion -s || return
    else
        __%[1]s_init_completion -n "=" || return
    fi
    local c=0
    local flags=()
    local two_word_flags=()
    local local_nonpersistent_flags=()
    local flags_with_completion=()
    local flags_completion=()
    local commands=("%[1]s")
    local must_have_one_flag=()
    local must_have_one_noun=()
    local last_command
    local nouns=()
    __%[1]s_handle_word
 }
 `, name))
 	buf.WriteString(fmt.Sprintf(`if [[ $(type -t compopt) = "builtin" ]]; then
    complete -o default -F __start_%s %s
 else
    complete -o default -o nospace -F __start_%s %s
 fi
 `, name, name, name, name))
 	buf.WriteString("# ex: ts=4 sw=4 et filetype=sh\n")
 }
 func writeCommands(buf *bytes.Buffer, cmd *Command) {
 	buf.WriteString("    commands=()\n")
 	for _, c := range cmd.Commands() {
 		if !c.IsAvailableCommand() || c == cmd.helpCommand {
 			continue
 		}
 		buf.WriteString(fmt.Sprintf("    commands+=(%q)\n", c.Name()))
 		writeCmdAliases(buf, c)
 	}
 	buf.WriteString("\n")
 }
 func writeFlagHandler(buf *bytes.Buffer, name string, annotations map[string][]string, cmd *Command) {
 	for key, value := range annotations {
 		switch key {
 		case BashCompFilenameExt:
 			buf.WriteString(fmt.Sprintf("    flags_with_completion+=(%q)\n", name))
 			var ext string
 			if len(value) > 0 {
 				ext = fmt.Sprintf("__%s_handle_filename_extension_flag ", cmd.Root().Name()) + strings.Join(value, "|")
 			} else {
 				ext = "_filedir"
 			}
 			buf.WriteString(fmt.Sprintf("    flags_completion+=(%q)\n", ext))
 		case BashCompCustom:
 			buf.WriteString(fmt.Sprintf("    flags_with_completion+=(%q)\n", name))
 			if len(value) > 0 {
 				handlers := strings.Join(value, "; ")
 				buf.WriteString(fmt.Sprintf("    flags_completion+=(%q)\n", handlers))
 			} else {
 				buf.WriteString("    flags_completion+=(:)\n")
 			}
 		case BashCompSubdirsInDir:
 			buf.WriteString(fmt.Sprintf("    flags_with_completion+=(%q)\n", name))
 			var ext string
 			if len(value) == 1 {
 				ext = fmt.Sprintf("__%s_handle_subdirs_in_dir_flag ", cmd.Root().Name()) + value[0]
 			} else {
 				ext = "_filedir -d"
 			}
 			buf.WriteString(fmt.Sprintf("    flags_completion+=(%q)\n", ext))
 		}
 	}
 }
 func writeShortFlag(buf *bytes.Buffer, flag *pflag.Flag, cmd *Command) {
 	name := flag.Shorthand
 	format := "    "
 	if len(flag.NoOptDefVal) == 0 {
 		format += "two_word_"
 	}
 	format += "flags+=(\"-%s\")\n"
 	buf.WriteString(fmt.Sprintf(format, name))
 	writeFlagHandler(buf, "-"+name, flag.Annotations, cmd)
 }
 func writeFlag(buf *bytes.Buffer, flag *pflag.Flag, cmd *Command) {
 	name := flag.Name
 	format := "    flags+=(\"--%s"
 	if len(flag.NoOptDefVal) == 0 {
 		format += "="
 	}
 	format += "\")\n"
 	buf.WriteString(fmt.Sprintf(format, name))
 	writeFlagHandler(buf, "--"+name, flag.Annotations, cmd)
 }
 func writeLocalNonPersistentFlag(buf *bytes.Buffer, flag *pflag.Flag) {
 	name := flag.Name
 	format := "    local_nonpersistent_flags+=(\"--%s"
 	if len(flag.NoOptDefVal) == 0 {
 		format += "="
 	}
 	format += "\")\n"
 	buf.WriteString(fmt.Sprintf(format, name))
 }
 func writeFlags(buf *bytes.Buffer, cmd *Command) {
 	buf.WriteString(`    flags=()
    two_word_flags=()
    local_nonpersistent_flags=()
    flags_with_completion=()
    flags_completion=()
 `)
 	localNonPersistentFlags := cmd.LocalNonPersistentFlags()
 	cmd.NonInheritedFlags().VisitAll(func(flag *pflag.Flag) {
 		if nonCompletableFlag(flag) {
 			return
 		}
 		writeFlag(buf, flag, cmd)
 		if len(flag.Shorthand) > 0 {
 			writeShortFlag(buf, flag, cmd)
 		}
 		if localNonPersistentFlags.Lookup(flag.Name) != nil {
 			writeLocalNonPersistentFlag(buf, flag)
 		}
 	})
 	cmd.InheritedFlags().VisitAll(func(flag *pflag.Flag) {
 		if nonCompletableFlag(flag) {
 			return
 		}
 		writeFlag(buf, flag, cmd)
 		if len(flag.Shorthand) > 0 {
 			writeShortFlag(buf, flag, cmd)
 		}
 	})
 	buf.WriteString("\n")
 }
 func writeRequiredFlag(buf *bytes.Buffer, cmd *Command) {
 	buf.WriteString("    must_have_one_flag=()\n")
 	flags := cmd.NonInheritedFlags()
 	flags.VisitAll(func(flag *pflag.Flag) {
 		if nonCompletableFlag(flag) {
 			return
 		}
 		for key := range flag.Annotations {
 			switch key {
 			case BashCompOneRequiredFlag:
 				format := "    must_have_one_flag+=(\"--%s"
 				if flag.Value.Type() != "bool" {
 					format += "="
 				}
 				format += "\")\n"
 				buf.WriteString(fmt.Sprintf(format, flag.Name))
 				if len(flag.Shorthand) > 0 {
 					buf.WriteString(fmt.Sprintf("    must_have_one_flag+=(\"-%s\")\n", flag.Shorthand))
 				}
 			}
 		}
 	})
 }
 func writeRequiredNouns(buf *bytes.Buffer, cmd *Command) {
 	buf.WriteString("    must_have_one_noun=()\n")
 	sort.Sort(sort.StringSlice(cmd.ValidArgs))
 	for _, value := range cmd.ValidArgs {
 		buf.WriteString(fmt.Sprintf("    must_have_one_noun+=(%q)\n", value))
 	}
 }
 func writeCmdAliases(buf *bytes.Buffer, cmd *Command) {
 	if len(cmd.Aliases) == 0 {
 		return
 	}
 	sort.Sort(sort.StringSlice(cmd.Aliases))
 	buf.WriteString(fmt.Sprint(`    if [[ -z "${BASH_VERSION}" || "${BASH_VERSINFO[0]}" -gt 3 ]]; then`, "\n"))
 	for _, value := range cmd.Aliases {
 		buf.WriteString(fmt.Sprintf("        command_aliases+=(%q)\n", value))
 		buf.WriteString(fmt.Sprintf("        aliashash[%q]=%q\n", value, cmd.Name()))
 	}
 	buf.WriteString(`    fi`)
 	buf.WriteString("\n")
 }
 func writeArgAliases(buf *bytes.Buffer, cmd *Command) {
 	buf.WriteString("    noun_aliases=()\n")
 	sort.Sort(sort.StringSlice(cmd.ArgAliases))
 	for _, value := range cmd.ArgAliases {
 		buf.WriteString(fmt.Sprintf("    noun_aliases+=(%q)\n", value))
 	}
 }
 func gen(buf *bytes.Buffer, cmd *Command) {
 	for _, c := range cmd.Commands() {
 		if !c.IsAvailableCommand() || c == cmd.helpCommand {
 			continue
 		}
 		gen(buf, c)
 	}
 	commandName := cmd.CommandPath()
 	commandName = strings.Replace(commandName, " ", "_", -1)
 	commandName = strings.Replace(commandName, ":", "__", -1)
 	if cmd.Root() == cmd {
 		buf.WriteString(fmt.Sprintf("_%s_root_command()\n{\n", commandName))
 	} else {
 		buf.WriteString(fmt.Sprintf("_%s()\n{\n", commandName))
 	}
 	buf.WriteString(fmt.Sprintf("    last_command=%q\n", commandName))
 	buf.WriteString("\n")
 	buf.WriteString("    command_aliases=()\n")
 	buf.WriteString("\n")
 	writeCommands(buf, cmd)
 	writeFlags(buf, cmd)
 	writeRequiredFlag(buf, cmd)
 	writeRequiredNouns(buf, cmd)
 	writeArgAliases(buf, cmd)
 	buf.WriteString("}\n\n")
 }
 // GenBashCompletion generates bash completion file and writes to the passed writer.
 func (c *Command) GenBashCompletion(w io.Writer) error {
 	buf := new(bytes.Buffer)
 	writePreamble(buf, c.Name())
 	if len(c.BashCompletionFunction) > 0 {
 		buf.WriteString(c.BashCompletionFunction + "\n")
 	}
 	gen(buf, c)
 	writePostscript(buf, c.Name())
 	_, err := buf.WriteTo(w)
 	return err
 }
 func nonCompletableFlag(flag *pflag.Flag) bool {
 	return flag.Hidden || len(flag.Deprecated) > 0
 }
 // GenBashCompletionFile generates bash completion file.
 func (c *Command) GenBashCompletionFile(filename string) error {
 	outFile, err := os.Create(filename)
 	if err != nil {
 		return err
 	}
 	defer outFile.Close()
 	return c.GenBashCompletion(outFile)
 }
 // MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag if it exists,
 // and causes your command to report an error if invoked without the flag.
 func (c *Command) MarkFlagRequired(name string) error {
 	return MarkFlagRequired(c.Flags(), name)
 }
 // MarkPersistentFlagRequired adds the BashCompOneRequiredFlag annotation to the named persistent flag if it exists,
 // and causes your command to report an error if invoked without the flag.
 func (c *Command) MarkPersistentFlagRequired(name string) error {
 	return MarkFlagRequired(c.PersistentFlags(), name)
 }
 // MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag if it exists,
 // and causes your command to report an error if invoked without the flag.
 func MarkFlagRequired(flags *pflag.FlagSet, name string) error {
 	return flags.SetAnnotation(name, BashCompOneRequiredFlag, []string{"true"})
 }
 // MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag, if it exists.
 // Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
 func (c *Command) MarkFlagFilename(name string, extensions ...string) error {
 	return MarkFlagFilename(c.Flags(), name, extensions...)
 }
 // MarkFlagCustom adds the BashCompCustom annotation to the named flag, if it exists.
 // Generated bash autocompletion will call the bash function f for the flag.
 func (c *Command) MarkFlagCustom(name string, f string) error {
 	return MarkFlagCustom(c.Flags(), name, f)
 }
 // MarkPersistentFlagFilename adds the BashCompFilenameExt annotation to the named persistent flag, if it exists.
 // Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
 func (c *Command) MarkPersistentFlagFilename(name string, extensions ...string) error {
 	return MarkFlagFilename(c.PersistentFlags(), name, extensions...)
 }
 // MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag in the flag set, if it exists.
 // Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
 func MarkFlagFilename(flags *pflag.FlagSet, name string, extensions ...string) error {
 	return flags.SetAnnotation(name, BashCompFilenameExt, extensions)
 }
 // MarkFlagCustom adds the BashCompCustom annotation to the named flag in the flag set, if it exists.
 // Generated bash autocompletion will call the bash function f for the flag.
 func MarkFlagCustom(flags *pflag.FlagSet, name string, f string) error {
 	return flags.SetAnnotation(name, BashCompCustom, []string{f})
 }
--- a/vendor/github.com/spf13/cobra/bash_completions.md
+++ b/vendor/github.com/spf13/cobra/bash_completions.md
@ -0,0 +1,221 @@
 # Generating Bash Completions For Your Own cobra.Command
 Generating bash completions from a cobra command is incredibly easy. An actual program which does so for the kubernetes kubectl binary is as follows:
 ```go
 package main
 import (
 	"io/ioutil"
 	"os"
 	"k8s.io/kubernetes/pkg/kubectl/cmd"
 	"k8s.io/kubernetes/pkg/kubectl/cmd/util"
 )
 func main() {
 	kubectl := cmd.NewKubectlCommand(util.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
 	kubectl.GenBashCompletionFile("out.sh")
 }
 ```
 `out.sh` will get you completions of subcommands and flags. Copy it to `/etc/bash_completion.d/` as described [here](https://debian-administration.org/article/316/An_introduction_to_bash_completion_part_1) and reset your terminal to use autocompletion. If you make additional annotations to your code, you can get even more intelligent and flexible behavior.
 ## Creating your own custom functions
 Some more actual code that works in kubernetes:
 ```bash
 const (
        bash_completion_func = `__kubectl_parse_get()
 {
    local kubectl_output out
    if kubectl_output=$(kubectl get --no-headers "$1" 2>/dev/null); then
        out=($(echo "${kubectl_output}" | awk '{print $1}'))
        COMPREPLY=( $( compgen -W "${out[*]}" -- "$cur" ) )
    fi
 }
 __kubectl_get_resource()
 {
    if [[ ${#nouns[@]} -eq 0 ]]; then
        return 1
    fi
    __kubectl_parse_get ${nouns[${#nouns[@]} -1]}
    if [[ $? -eq 0 ]]; then
        return 0
    fi
 }
 __custom_func() {
    case ${last_command} in
        kubectl_get | kubectl_describe | kubectl_delete | kubectl_stop)
            __kubectl_get_resource
            return
            ;;
        *)
            ;;
    esac
 }
 `)
 ```
 And then I set that in my command definition:
 ```go
 cmds := &cobra.Command{
 	Use:   "kubectl",
 	Short: "kubectl controls the Kubernetes cluster manager",
 	Long: `kubectl controls the Kubernetes cluster manager.
 Find more information at https://github.com/GoogleCloudPlatform/kubernetes.`,
 	Run: runHelp,
 	BashCompletionFunction: bash_completion_func,
 }
 ```
 The `BashCompletionFunction` option is really only valid/useful on the root command. Doing the above will cause `__custom_func()` to be called when the built in processor was unable to find a solution. In the case of kubernetes a valid command might look something like `kubectl get pod [mypod]`. If you type `kubectl get pod [tab][tab]` the `__customc_func()` will run because the cobra.Command only understood "kubectl" and "get." `__custom_func()` will see that the cobra.Command is "kubectl_get" and will thus call another helper `__kubectl_get_resource()`.  `__kubectl_get_resource` will look at the 'nouns' collected. In our example the only noun will be `pod`.  So it will call `__kubectl_parse_get pod`.  `__kubectl_parse_get` will actually call out to kubernetes and get any pods.  It will then set `COMPREPLY` to valid pods!
 ## Have the completions code complete your 'nouns'
 In the above example "pod" was assumed to already be typed. But if you want `kubectl get [tab][tab]` to show a list of valid "nouns" you have to set them. Simplified code from `kubectl get` looks like:
 ```go
 validArgs []string = { "pod", "node", "service", "replicationcontroller" }
 cmd := &cobra.Command{
 	Use:     "get [(-o|--output=)json|yaml|template|...] (RESOURCE [NAME] | RESOURCE/NAME ...)",
 	Short:   "Display one or many resources",
 	Long:    get_long,
 	Example: get_example,
 	Run: func(cmd *cobra.Command, args []string) {
 		err := RunGet(f, out, cmd, args)
 		util.CheckErr(err)
 	},
 	ValidArgs: validArgs,
 }
 ```
 Notice we put the "ValidArgs" on the "get" subcommand. Doing so will give results like
 ```bash
 # kubectl get [tab][tab]
 node                 pod                    replicationcontroller  service
 ```
 ## Plural form and shortcuts for nouns
 If your nouns have a number of aliases, you can define them alongside `ValidArgs` using `ArgAliases`:
 ```go
 argAliases []string = { "pods", "nodes", "services", "svc", "replicationcontrollers", "rc" }
 cmd := &cobra.Command{
    ...
 	ValidArgs:  validArgs,
 	ArgAliases: argAliases
 }
 ```
 The aliases are not shown to the user on tab completion, but they are accepted as valid nouns by
 the completion algorithm if entered manually, e.g. in:
 ```bash
 # kubectl get rc [tab][tab]
 backend        frontend       database 
 ```
 Note that without declaring `rc` as an alias, the completion algorithm would show the list of nouns
 in this example again instead of the replication controllers.
 ## Mark flags as required
 Most of the time completions will only show subcommands. But if a flag is required to make a subcommand work, you probably want it to show up when the user types [tab][tab].  Marking a flag as 'Required' is incredibly easy.
 ```go
 cmd.MarkFlagRequired("pod")
 cmd.MarkFlagRequired("container")
 ```
 and you'll get something like
 ```bash
 # kubectl exec [tab][tab][tab]
 -c            --container=  -p            --pod=  
 ```
 # Specify valid filename extensions for flags that take a filename
 In this example we use --filename= and expect to get a json or yaml file as the argument. To make this easier we annotate the --filename flag with valid filename extensions.
 ```go
 	annotations := []string{"json", "yaml", "yml"}
 	annotation := make(map[string][]string)
 	annotation[cobra.BashCompFilenameExt] = annotations
 	flag := &pflag.Flag{
 		Name:        "filename",
 		Shorthand:   "f",
 		Usage:       usage,
 		Value:       value,
 		DefValue:    value.String(),
 		Annotations: annotation,
 	}
 	cmd.Flags().AddFlag(flag)
 ```
 Now when you run a command with this filename flag you'll get something like
 ```bash
 # kubectl create -f 
 test/                         example/                      rpmbuild/
 hello.yml                     test.json
 ```
 So while there are many other files in the CWD it only shows me subdirs and those with valid extensions.
 # Specify custom flag completion
 Similar to the filename completion and filtering using cobra.BashCompFilenameExt, you can specify
 a custom flag completion function with cobra.BashCompCustom:
 ```go
 	annotation := make(map[string][]string)
 	annotation[cobra.BashCompCustom] = []string{"__kubectl_get_namespaces"}
 	flag := &pflag.Flag{
 		Name:        "namespace",
 		Usage:       usage,
 		Annotations: annotation,
 	}
 	cmd.Flags().AddFlag(flag)
 ```
 In addition add the `__handle_namespace_flag` implementation in the `BashCompletionFunction`
 value, e.g.:
 ```bash
 __kubectl_get_namespaces()
 {
    local template
    template="{{ range .items  }}{{ .metadata.name }} {{ end }}"
    local kubectl_out
    if kubectl_out=$(kubectl get -o template --template="${template}" namespace 2>/dev/null); then
        COMPREPLY=( $( compgen -W "${kubectl_out}[*]" -- "$cur" ) )
    fi
 }
 ```
 # Using bash aliases for commands
 You can also configure the `bash aliases` for the commands and they will also support completions.
 ```bash
 alias aliasname=origcommand
 complete -o default -F __start_origcommand aliasname
 # and now when you run `aliasname` completion will make
 # suggestions as it did for `origcommand`.
 $) aliasname <tab><tab>
 completion     firstcommand   secondcommand
 ```
--- a/vendor/github.com/spf13/cobra/cobra.go
+++ b/vendor/github.com/spf13/cobra/cobra.go
@ -0,0 +1,200 @@
 // Copyright © 2013 Steve Francia <spf@spf13.com>.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // Commands similar to git, go tools and other modern CLI tools
 // inspired by go, go-Commander, gh and subcommand
 package cobra
 import (
 	"fmt"
 	"io"
 	"reflect"
 	"strconv"
 	"strings"
 	"text/template"
 	"unicode"
 )
 var templateFuncs = template.FuncMap{
 	"trim":                    strings.TrimSpace,
 	"trimRightSpace":          trimRightSpace,
 	"trimTrailingWhitespaces": trimRightSpace,
 	"appendIfNotPresent":      appendIfNotPresent,
 	"rpad":                    rpad,
 	"gt":                      Gt,
 	"eq":                      Eq,
 }
 var initializers []func()
 // EnablePrefixMatching allows to set automatic prefix matching. Automatic prefix matching can be a dangerous thing
 // to automatically enable in CLI tools.
 // Set this to true to enable it.
 var EnablePrefixMatching = false
 // EnableCommandSorting controls sorting of the slice of commands, which is turned on by default.
 // To disable sorting, set it to false.
 var EnableCommandSorting = true
 // MousetrapHelpText enables an information splash screen on Windows
 // if the CLI is started from explorer.exe.
 // To disable the mousetrap, just set this variable to blank string ("").
 // Works only on Microsoft Windows.
 var MousetrapHelpText string = `This is a command line tool.
 You need to open cmd.exe and run it from there.
 `
 // AddTemplateFunc adds a template function that's available to Usage and Help
 // template generation.
 func AddTemplateFunc(name string, tmplFunc interface{}) {
 	templateFuncs[name] = tmplFunc
 }
 // AddTemplateFuncs adds multiple template functions that are available to Usage and
 // Help template generation.
 func AddTemplateFuncs(tmplFuncs template.FuncMap) {
 	for k, v := range tmplFuncs {
 		templateFuncs[k] = v
 	}
 }
 // OnInitialize sets the passed functions to be run when each command's
 // Execute method is called.
 func OnInitialize(y ...func()) {
 	initializers = append(initializers, y...)
 }
 // FIXME Gt is unused by cobra and should be removed in a version 2. It exists only for compatibility with users of cobra.
 // Gt takes two types and checks whether the first type is greater than the second. In case of types Arrays, Chans,
 // Maps and Slices, Gt will compare their lengths. Ints are compared directly while strings are first parsed as
 // ints and then compared.
 func Gt(a interface{}, b interface{}) bool {
 	var left, right int64
 	av := reflect.ValueOf(a)
 	switch av.Kind() {
 	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
 		left = int64(av.Len())
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		left = av.Int()
 	case reflect.String:
 		left, _ = strconv.ParseInt(av.String(), 10, 64)
 	}
 	bv := reflect.ValueOf(b)
 	switch bv.Kind() {
 	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
 		right = int64(bv.Len())
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		right = bv.Int()
 	case reflect.String:
 		right, _ = strconv.ParseInt(bv.String(), 10, 64)
 	}
 	return left > right
 }
 // FIXME Eq is unused by cobra and should be removed in a version 2. It exists only for compatibility with users of cobra.
 // Eq takes two types and checks whether they are equal. Supported types are int and string. Unsupported types will panic.
 func Eq(a interface{}, b interface{}) bool {
 	av := reflect.ValueOf(a)
 	bv := reflect.ValueOf(b)
 	switch av.Kind() {
 	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
 		panic("Eq called on unsupported type")
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		return av.Int() == bv.Int()
 	case reflect.String:
 		return av.String() == bv.String()
 	}
 	return false
 }
 func trimRightSpace(s string) string {
 	return strings.TrimRightFunc(s, unicode.IsSpace)
 }
 // FIXME appendIfNotPresent is unused by cobra and should be removed in a version 2. It exists only for compatibility with users of cobra.
 // appendIfNotPresent will append stringToAppend to the end of s, but only if it's not yet present in s.
 func appendIfNotPresent(s, stringToAppend string) string {
 	if strings.Contains(s, stringToAppend) {
 		return s
 	}
 	return s + " " + stringToAppend
 }
 // rpad adds padding to the right of a string.
 func rpad(s string, padding int) string {
 	template := fmt.Sprintf("%%-%ds", padding)
 	return fmt.Sprintf(template, s)
 }
 // tmpl executes the given template text on data, writing the result to w.
 func tmpl(w io.Writer, text string, data interface{}) error {
 	t := template.New("top")
 	t.Funcs(templateFuncs)
 	template.Must(t.Parse(text))
 	return t.Execute(w, data)
 }
 // ld compares two strings and returns the levenshtein distance between them.
 func ld(s, t string, ignoreCase bool) int {
 	if ignoreCase {
 		s = strings.ToLower(s)
 		t = strings.ToLower(t)
 	}
 	d := make([][]int, len(s)+1)
 	for i := range d {
 		d[i] = make([]int, len(t)+1)
 	}
 	for i := range d {
 		d[i][0] = i
 	}
 	for j := range d[0] {
 		d[0][j] = j
 	}
 	for j := 1; j <= len(t); j++ {
 		for i := 1; i <= len(s); i++ {
 			if s[i-1] == t[j-1] {
 				d[i][j] = d[i-1][j-1]
 			} else {
 				min := d[i-1][j]
 				if d[i][j-1] < min {
 					min = d[i][j-1]
 				}
 				if d[i-1][j-1] < min {
 					min = d[i-1][j-1]
 				}
 				d[i][j] = min + 1
 			}
 		}
 	}
 	return d[len(s)][len(t)]
 }
 func stringInSlice(a string, list []string) bool {
 	for _, b := range list {
 		if b == a {
 			return true
 		}
 	}
 	return false
 }
--- a/vendor/github.com/spf13/cobra/command.go
+++ b/vendor/github.com/spf13/cobra/command.go
--- a/vendor/github.com/spf13/cobra/command_notwin.go
+++ b/vendor/github.com/spf13/cobra/command_notwin.go
@ -0,0 +1,5 @@
 // +build !windows
 package cobra
 var preExecHookFn func(*Command)
--- a/vendor/github.com/spf13/cobra/command_win.go
+++ b/vendor/github.com/spf13/cobra/command_win.go
@ -0,0 +1,20 @@
 // +build windows
 package cobra
 import (
 	"os"
 	"time"
 	"github.com/inconshreveable/mousetrap"
 )
 var preExecHookFn = preExecHook
 func preExecHook(c *Command) {
 	if MousetrapHelpText != "" && mousetrap.StartedByExplorer() {
 		c.Print(MousetrapHelpText)
 		time.Sleep(5 * time.Second)
 		os.Exit(1)
 	}
 }
--- a/vendor/github.com/spf13/cobra/zsh_completions.go
+++ b/vendor/github.com/spf13/cobra/zsh_completions.go
@ -0,0 +1,126 @@
 package cobra
 import (
 	"bytes"
 	"fmt"
 	"io"
 	"os"
 	"strings"
 )
 // GenZshCompletionFile generates zsh completion file.
 func (c *Command) GenZshCompletionFile(filename string) error {
 	outFile, err := os.Create(filename)
 	if err != nil {
 		return err
 	}
 	defer outFile.Close()
 	return c.GenZshCompletion(outFile)
 }
 // GenZshCompletion generates a zsh completion file and writes to the passed writer.
 func (c *Command) GenZshCompletion(w io.Writer) error {
 	buf := new(bytes.Buffer)
 	writeHeader(buf, c)
 	maxDepth := maxDepth(c)
 	writeLevelMapping(buf, maxDepth)
 	writeLevelCases(buf, maxDepth, c)
 	_, err := buf.WriteTo(w)
 	return err
 }
 func writeHeader(w io.Writer, cmd *Command) {
 	fmt.Fprintf(w, "#compdef %s\n\n", cmd.Name())
 }
 func maxDepth(c *Command) int {
 	if len(c.Commands()) == 0 {
 		return 0
 	}
 	maxDepthSub := 0
 	for _, s := range c.Commands() {
 		subDepth := maxDepth(s)
 		if subDepth > maxDepthSub {
 			maxDepthSub = subDepth
 		}
 	}
 	return 1 + maxDepthSub
 }
 func writeLevelMapping(w io.Writer, numLevels int) {
 	fmt.Fprintln(w, `_arguments \`)
 	for i := 1; i <= numLevels; i++ {
 		fmt.Fprintf(w, `  '%d: :->level%d' \`, i, i)
 		fmt.Fprintln(w)
 	}
 	fmt.Fprintf(w, `  '%d: :%s'`, numLevels+1, "_files")
 	fmt.Fprintln(w)
 }
 func writeLevelCases(w io.Writer, maxDepth int, root *Command) {
 	fmt.Fprintln(w, "case $state in")
 	defer fmt.Fprintln(w, "esac")
 	for i := 1; i <= maxDepth; i++ {
 		fmt.Fprintf(w, "  level%d)\n", i)
 		writeLevel(w, root, i)
 		fmt.Fprintln(w, "  ;;")
 	}
 	fmt.Fprintln(w, "  *)")
 	fmt.Fprintln(w, "    _arguments '*: :_files'")
 	fmt.Fprintln(w, "  ;;")
 }
 func writeLevel(w io.Writer, root *Command, i int) {
 	fmt.Fprintf(w, "    case $words[%d] in\n", i)
 	defer fmt.Fprintln(w, "    esac")
 	commands := filterByLevel(root, i)
 	byParent := groupByParent(commands)
 	for p, c := range byParent {
 		names := names(c)
 		fmt.Fprintf(w, "      %s)\n", p)
 		fmt.Fprintf(w, "        _arguments '%d: :(%s)'\n", i, strings.Join(names, " "))
 		fmt.Fprintln(w, "      ;;")
 	}
 	fmt.Fprintln(w, "      *)")
 	fmt.Fprintln(w, "        _arguments '*: :_files'")
 	fmt.Fprintln(w, "      ;;")
 }
 func filterByLevel(c *Command, l int) []*Command {
 	cs := make([]*Command, 0)
 	if l == 0 {
 		cs = append(cs, c)
 		return cs
 	}
 	for _, s := range c.Commands() {
 		cs = append(cs, filterByLevel(s, l-1)...)
 	}
 	return cs
 }
 func groupByParent(commands []*Command) map[string][]*Command {
 	m := make(map[string][]*Command)
 	for _, c := range commands {
 		parent := c.Parent()
 		if parent == nil {
 			continue
 		}
 		m[parent.Name()] = append(m[parent.Name()], c)
 	}
 	return m
 }
 func names(commands []*Command) []string {
 	ns := make([]string, len(commands))
 	for i, c := range commands {
 		ns[i] = c.Name()
 	}
 	return ns
 }
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@ -74,6 +74,8 @@ github.com/hashicorp/hcl/json/scanner
 github.com/hashicorp/hcl/json/token
 # github.com/imdario/mergo v0.3.6
 github.com/imdario/mergo
 # github.com/inconshreveable/mousetrap v1.0.0
 github.com/inconshreveable/mousetrap
 # github.com/jgautheron/goconst v0.0.0-20170703170152-9740945f5dcb
 github.com/jgautheron/goconst/cmd/goconst
 github.com/jgautheron/goconst
@ -132,6 +134,8 @@ github.com/spf13/afero
 github.com/spf13/afero/mem
 # github.com/spf13/cast v1.2.0
 github.com/spf13/cast
 # github.com/spf13/cobra v0.0.3
 github.com/spf13/cobra
 # github.com/spf13/jwalterweatherman v1.0.0
 github.com/spf13/jwalterweatherman
 # github.com/spf13/pflag v1.0.2