Merge pull request #39 from Ashtonian/patch-1

add `for rancher 1.x only` in initial summary so its clear.

.drone.yml

@@ -1,46 +1,114 @@
+kind: pipeline
+name: default
+
 workspace:
   base: /go
+  path: src/github.com/josmo/drone-rancher
+steps:
+- name: deps
+  image: golang:1.10
+  pull: true
+  commands:
+  - go get -u github.com/golang/dep/cmd/dep
+  - dep ensure
 
-pipeline:
-  build:
-    image: golang:1.6
-    environment:
-      - CGO_ENABLED=0
-    commands:
-      - go vet
-      - go test -cover -coverprofile=coverage.out
-      - go build -ldflags "-s -w -X main.build=$DRONE_BUILD_NUMBER" -a -tags netgo
+- name: test
+  image: golang:1.10
+  depends_on:
+  - deps
+  commands:
+  - go vet
+  - go test -cover -coverprofile=coverage.out
 
-  publish:
-    image: plugins/docker
-    username: josmo
-    password: ${DOCKER_PASSWORD}
-    repo: peloton/drone-rancher
-    tag:
-      - ${DRONE_BUILD_NUMBER}
-      - latest
-    when:
-      branch: master
-      event: push
+- name: build_linux_amd64
+  image: golang:1.10
+  depends_on: [ test]
+  environment:
+    GOOS: linux
+    GOARCH: amd64
+    CGO_ENABLED: 0
+  commands:
+  - |
+    if test "${DRONE_TAG}" = ""; then
+      go build -v -ldflags "-X main.build=${DRONE_BUILD_NUMBER}" -a -o release/linux/amd64/${DRONE_REPO_NAME}
+    else
+      go build -v -ldflags "-X main.version=${DRONE_TAG##v} -X main.build=${DRONE_BUILD_NUMBER}" -a -o release/linux/amd64/${DRONE_REPO_NAME}
+    fi
 
-  publish:
-    image: plugins/docker
-    username: josmo
-    password: ${DOCKER_PASSWORD}
-    repo: peloton/drone-rancher
-    tag:
-      - ${DRONE_BUILD_NUMBER}
-      - develop-latest
-    when:
-      branch: develop
-      event: push
+- name: build_linux_arm64
+  image: golang:1.10
+  depends_on: [ test ]
+  environment:
+    GOOS: linux
+    GOARCH: arm64
+    CGO_ENABLED: 0
+  commands:
+  - |
+    if test "${DRONE_TAG}" = ""; then
+      go build -v -ldflags "-X main.build=${DRONE_BUILD_NUMBER}" -a -o release/linux/arm64/${DRONE_REPO_NAME}
+    else
+      go build -v -ldflags "-X main.version=${DRONE_TAG##v} -X main.build=${DRONE_BUILD_NUMBER}" -a -o release/linux/arm64/${DRONE_REPO_NAME}
+    fi
 
+- name: build_linux_arm
+  image: golang:1.10
+  depends_on: [ test ]
+  environment:
+    GOOS: linux
+    GOARCH: arm
+    CGO_ENABLED: 0
+    GOARM: 7
+  commands:
+  - |
+    if test "${DRONE_TAG}" = ""; then
+      go build -v -ldflags "-X main.build=${DRONE_BUILD_NUMBER}" -a -o release/linux/arm/${DRONE_REPO_NAME}
+    else
+      go build -v -ldflags "-X main.version=${DRONE_TAG##v} -X main.build=${DRONE_BUILD_NUMBER}" -a -o release/linux/arm/${DRONE_REPO_NAME}
+    fi
 
-plugin:
-  name: Rancher
-  desc: Deploy or update a project on Rancher
-  type: deploy
-  image: peloton/rancher
-  labels:
-    - rancher
-    - docker
+- name: publish_linux_amd64
+  image: plugins/docker
+  depends_on: [ build_linux_amd64 ]
+  settings:
+    auto_tag: true
+    username:
+      from_secret: docker_username
+    password:
+      from_secret: docker_password
+    repo:
+      from_secret: plugin_repo
+    dockerfile: Dockerfile
+  when:
+    event: [ tag, push ]
+
+- name: publish_linux_arm64
+  image: plugins/docker
+  depends_on: [ build_linux_arm64 ]
+  settings:
+    auto_tag: true
+    auto_tag_suffix: linux-arm64
+    username:
+      from_secret: docker_username
+    password:
+      from_secret: docker_password
+    repo:
+      from_secret: plugin_repo
+    dockerfile: Dockerfile.arm64
+  when:
+    event: [ tag, push ]
+
+- name: publish_linux_arm
+  image: plugins/docker
+  depends_on: [ build_linux_arm ]
+  settings:
+    auto_tag: true
+    auto_tag_suffix: linux-arm
+    username:
+      from_secret: docker_username
+    password:
+      from_secret: docker_password
+    repo:
+      from_secret: plugin_repo
+    dockerfile: Dockerfile.arm
+  when:
+    event: [ tag, push ]

.drone.yml.sig

@@ -1 +0,0 @@
-eyJhbGciOiJIUzI1NiJ9.d29ya3NwYWNlOgogIGJhc2U6IC9nbwoKcGlwZWxpbmU6CiAgYnVpbGQ6CiAgICBpbWFnZTogZ29sYW5nOjEuNgogICAgZW52aXJvbm1lbnQ6CiAgICAgIC0gQ0dPX0VOQUJMRUQ9MAogICAgY29tbWFuZHM6CiAgICAgIC0gZ28gdmV0CiAgICAgIC0gZ28gdGVzdCAtY292ZXIgLWNvdmVycHJvZmlsZT1jb3ZlcmFnZS5vdXQKICAgICAgLSBnbyBidWlsZCAtbGRmbGFncyAiLXMgLXcgLVggbWFpbi5idWlsZD0kRFJPTkVfQlVJTERfTlVNQkVSIiAtYSAtdGFncyBuZXRnbwoKICBwdWJsaXNoOgogICAgaW1hZ2U6IHBsdWdpbnMvZG9ja2VyCiAgICB1c2VybmFtZTogam9zbW8KICAgIHBhc3N3b3JkOiAke0RPQ0tFUl9QQVNTV09SRH0KICAgIHJlcG86IHBlbG90b24vZHJvbmUtcmFuY2hlcgogICAgdGFnOgogICAgICAtICR7RFJPTkVfQlVJTERfTlVNQkVSfQogICAgICAtIGxhdGVzdAogICAgd2hlbjoKICAgICAgYnJhbmNoOiBtYXN0ZXIKICAgICAgZXZlbnQ6IHB1c2gKCiAgcHVibGlzaDoKICAgIGltYWdlOiBwbHVnaW5zL2RvY2tlcgogICAgdXNlcm5hbWU6IGpvc21vCiAgICBwYXNzd29yZDogJHtET0NLRVJfUEFTU1dPUkR9CiAgICByZXBvOiBwZWxvdG9uL2Ryb25lLXJhbmNoZXIKICAgIHRhZzoKICAgICAgLSAke0RST05FX0JVSUxEX05VTUJFUn0KICAgICAgLSBkZXZlbG9wLWxhdGVzdAogICAgd2hlbjoKICAgICAgYnJhbmNoOiBkZXZlbG9wCiAgICAgIGV2ZW50OiBwdXNoCgoKcGx1Z2luOgogIG5hbWU6IFJhbmNoZXIKICBkZXNjOiBEZXBsb3kgb3IgdXBkYXRlIGEgcHJvamVjdCBvbiBSYW5jaGVyCiAgdHlwZTogZGVwbG95CiAgaW1hZ2U6IHBlbG90b24vcmFuY2hlcgogIGxhYmVsczoKICAgIC0gcmFuY2hlcgogICAgLSBkb2NrZXIK.k_LdvCu8dp7TqB9bupLAvdYG57XVpmrv05vG5tAYq6Q

.github/issue_template.md

@@ -0,0 +1,5 @@
+<!-- PLEASE READ BEFORE DELETING
+
+Bugs or Issues?
+
+-->

.github/pull_request_template.md

@@ -0,0 +1,6 @@
+<!-- PLEASE READ BEFORE DELETING
+
+Please discuss changes before creating pull requests.
+
+
+-->

.gitignore

@@ -27,3 +27,5 @@ coverage.out
 drone-rancher
 
 *.idea
+vendor
+release

DOCS.md

@@ -3,10 +3,11 @@ Use the rancher plugin to upgrade a service in [rancher](http://rancher.com).
 The following parameters are used to configure this plugin:
 
 - `url` - url to your rancher server, including protocol and port
-- `rancher_access_key` - rancher api access key
-- `rancher_secret_key` - rancher api secret key
+- `access_key` - rancher api access key
+- `secret_key` - rancher api secret key
 - `service` - name of rancher service to act on
 - `docker_image` - new image to assign to service, including tag (`drone/drone:latest`)
+- `sidekick` - sidekick name and docker image separated by space, multiple declaration supported
 - `start_first` - start the new container before stopping the old one, defaults to `true`
 - `confirm` - auto confirm the service upgrade if successful, defaults to `false`
 - `timeout` - the maximum wait time in seconds for the service to upgrade, default to `30`
@@ -18,15 +19,17 @@ The following is a sample Rancher configuration in your `.drone.yml` file:
 ```yaml
 deploy:
   rancher:
-    image: peloton/drone-rancher
+    image: pelotech/drone-rancher
     url: https://example.rancher.com
     access_key: 1234567abcdefg
     secret_key: abcdefg1234567
     service: drone/drone
+    sidekick: nginx nginx:latest
+    sidekick: node node:latest
     docker_image: drone/drone:latest
 ```
 
-if you want to add secrets for the access_key and secret it's RANCHER_ACCESS_KEY and RANCHER_SECRET_KEY
+if you want to add secrets for the access_key and secret_key it's RANCHER_ACCESS_KEY and RANCHER_SECRET_KEY
 
 
 Note that if your `service` is part of a stack, you should use the notation `stackname/servicename` as this will make sure that the found service is part of the correct stack. If no stack is specified, this plugin will update the first service with a matching name which may not be what you want.

Dockerfile

@@ -1,11 +1,16 @@
-# Docker image for the Drone build runner
-#
-#     CGO_ENABLED=0 go build -a -tags netgo
-#     docker build --rm=true -t plugins/drone-rancher .
+FROM alpine:3.6 as alpine
+RUN apk add -U --no-cache ca-certificates
 
-FROM gliderlabs/alpine:3.2
-RUN apk add --update \
-  ca-certificates
-ADD drone-rancher /bin/
+FROM scratch
+
+ENV GODEBUG=netdns=go
+
+COPY --from=alpine /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
+
+LABEL org.label-schema.version=latest
+LABEL org.label-schema.vcs-url="https://github.com/josmo/drone-rancher.git"
+LABEL org.label-schema.name="Drone Rancher"
+LABEL org.label-schema.vendor="Josmo"
+
+ADD release/linux/amd64/drone-rancher /bin/
 ENTRYPOINT ["/bin/drone-rancher"]
-

Dockerfile.arm

@@ -0,0 +1,17 @@
+FROM alpine:3.6 as alpine
+RUN apk add -U --no-cache ca-certificates
+
+FROM scratch
+
+ENV GODEBUG=netdns=go
+
+COPY --from=alpine /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
+
+LABEL org.label-schema.version=latest
+LABEL org.label-schema.vcs-url="https://github.com/josmo/drone-rancher.git"
+LABEL org.label-schema.name="Drone Rancher"
+LABEL org.label-schema.vendor="Josmo"
+LABEL org.label-schema.schema-version="1.0"
+
+ADD release/linux/arm/drone-rancher /bin/
+ENTRYPOINT ["/bin/drone-rancher"]

Dockerfile.arm64

@@ -0,0 +1,17 @@
+FROM alpine:3.6 as alpine
+RUN apk add -U --no-cache ca-certificates
+
+FROM scratch
+
+ENV GODEBUG=netdns=go
+
+COPY --from=alpine /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
+
+LABEL org.label-schema.version=latest
+LABEL org.label-schema.vcs-url="https://github.com/josmo/drone-rancher.git"
+LABEL org.label-schema.name="Drone Rancher"
+LABEL org.label-schema.vendor="Josmo"
+LABEL org.label-schema.schema-version="1.0"
+
+ADD release/linux/arm64/drone-rancher /bin/
+ENTRYPOINT ["/bin/drone-rancher"]

Dockerfile.windows

@@ -0,0 +1,12 @@
+FROM microsoft/nanoserver:latest
+
+ENV GODEBUG=netdns=go
+
+LABEL org.label-schema.version=latest
+LABEL org.label-schema.vcs-url="https://github.com/josmo/drone-rancher.git"
+LABEL org.label-schema.name="Drone Rancher"
+LABEL org.label-schema.vendor="Josmo"
+LABEL org.label-schema.schema-version="1.0"
+
+ADD release/windows/amd64/drone-rancher /bin/
+ENTRYPOINT [ "/bin/drone-rancher" ]

Gopkg.lock

@@ -0,0 +1,72 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  digest = "1:d867dfa6751c8d7a435821ad3b736310c2ed68945d05b50fb9d23aee0540c8cc"
+  name = "github.com/Sirupsen/logrus"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "3e01752db0189b9157070a0e1668a620f9a85da2"
+  version = "v1.0.6"
+
+[[projects]]
+  digest = "1:43dd08a10854b2056e615d1b1d22ac94559d822e1f8b6fcc92c1a1057e85188e"
+  name = "github.com/gorilla/websocket"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b"
+  version = "v1.2.0"
+
+[[projects]]
+  digest = "1:40e195917a951a8bf867cd05de2a46aaf1806c50cf92eebf4c16f78cd196f747"
+  name = "github.com/pkg/errors"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
+  version = "v0.8.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:0451d67c615c56d31c3689dd1c9aefa9d18c03f241199a0e3c470451666a1ab8"
+  name = "github.com/rancher/go-rancher"
+  packages = ["v2"]
+  pruneopts = "UT"
+  revision = "5d4e55e3f5de872bd5136d538139fffad238ad3a"
+
+[[projects]]
+  digest = "1:b24d38b282bacf9791408a080f606370efa3d364e4b5fd9ba0f7b87786d3b679"
+  name = "github.com/urfave/cli"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "cfb38830724cc34fedffe9a2a29fb54fa9169cd1"
+  version = "v1.20.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:3f3a05ae0b95893d90b9b3b5afdb79a9b3d96e4e36e099d841ae602e4aca0da8"
+  name = "golang.org/x/crypto"
+  packages = ["ssh/terminal"]
+  pruneopts = "UT"
+  revision = "c126467f60eb25f8f27e5a981f32a87e3965053f"
+
+[[projects]]
+  branch = "master"
+  digest = "1:4a7c38ff146e5002dda78fdf599ac143fd0c98ffba9fb9d1721c3ba7fcd356c0"
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows",
+  ]
+  pruneopts = "UT"
+  revision = "3dc4335d56c789b04b0ba99b7a37249d9b614314"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "github.com/Sirupsen/logrus",
+    "github.com/rancher/go-rancher/v2",
+    "github.com/urfave/cli",
+  ]
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,42 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  name = "github.com/Sirupsen/logrus"
+  version = "1.0.6"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/rancher/go-rancher"
+
+[[constraint]]
+  name = "github.com/urfave/cli"
+  version = "1.20.0"
+
+[prune]
+  go-tests = true
+  unused-packages = true

MAINTAINERS

@@ -1,46 +0,0 @@
-[people]
-  [people.bradrydzewski]
-    name = "Brad Rydzewski"
-    email = "brad@drone.io"
-    login = "bradrydzewski"
-  [people.Bugagazavr]
-    name = "Kirill"
-    email = ""
-    login = "Bugagazavr"
-  [people.donny-dont]
-    name = "Don Olmstead"
-    email = "donny-dont@gmail.com"
-    login = "donny-dont"
-  [people.jackspirou]
-    name = "Jack Spirou"
-    email = ""
-    login = "jackspirou"
-  [people.msteinert]
-    name = "Mike Steinert"
-    email = ""
-    login = "msteinert"
-  [people.nlf]
-    name = "Nathan LaFreniere"
-    email = ""
-    login = "nlf"
-  [people.tboerger]
-    name = "Thomas Boerger"
-    email = "thomas@webhippie.de"
-    login = "tboerger"
-  [people.athieriot]
-    name = "Aurélien Thieriot"
-    email = "a.thieriot@gmail.com"
-    login = "athieriot"
-
-[org]
-  [org.core]
-    people = [
-      "bradrydzewski",
-      "Bugagazavr",
-      "donny-dont",
-      "jackspirou",
-      "msteinert",
-      "nlf",
-      "tboerger",
-      "athieriot"
-    ]

README.md

@@ -1,24 +1,18 @@
 # drone-rancher
 
-[![Build Status](http://drone.ci.prod.seattleslow.com/api/badges/josmo/drone-rancher/status.svg)](http://drone.ci.prod.seattleslow.com/josmo/drone-rancher)
+[![Build Status](https://cloud.drone.io/api/badges/josmo/drone-rancher/status.svg)](https://cloud.drone.io/josmo/drone-rancher)
+[![Go Doc](https://godoc.org/github.com/josmo/drone-rancher?status.svg)](http://godoc.org/github.com/josmo/drone-rancher)
+[![Go Report](https://goreportcard.com/badge/github.com/josmo/drone-rancher)](https://goreportcard.com/report/github.com/josmo/drone-rancher)
+[![](https://images.microbadger.com/badges/image/pelotech/drone-rancher.svg)](https://microbadger.com/images/pelotech/drone-rancher "Get your own image badge on microbadger.com")
 
-Drone plugin to deploy or update a project on Rancher. For the usage information and a listing of the available options please take a look at [the docs](DOCS.md).
+Drone plugin to deploy or update a project on Rancher 1.x only. For the usage information and a listing of the available options please take a look at [the docs](DOCS.md).
 
 ## Binary
 
-Build the binary using `make`:
+Build the binary using `drone cli`:
 
 ```
-make deps build
-```
-
-
-## Docker
-
-Build the container using `make`:
-
-```
-make deps docker
+drone exec
 ```
 
 ### Example
@@ -36,5 +30,13 @@ docker run --rm                          \
   -e PLUGIN_DOCKER_IMAGE=<image>         \
   -v $(pwd):$(pwd)                       \
   -w $(pwd)                              \
-  peloton/drone-rancher 
+  pelotech/drone-rancher 
 ```
+
+### Contribution
+
+This repo is setup in a way that if you enable a personal drone server to build your fork it will
+ build and publish your image (makes it easier to test PRs and use the image till the contributions get merged)
+ 
+* Build local ```DRONE_REPO_OWNER=josmo DRONE_REPO_NAME=drone-rancher drone exec```
+* on your server just make sure you have DOCKER_USERNAME, DOCKER_PASSWORD, and PLUGIN_REPO set as secrets

main.go

@@ -1,38 +1,31 @@
 package main
 
 import (
-	"github.com/codegangsta/cli"
-	"log"
+	"fmt"
 	"os"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/urfave/cli"
 )
 
-type Rancher struct {
-	Url            string `json:"url"`
-	AccessKey      string `json:"access_key"`
-	SecretKey      string `json:"secret_key"`
-	Service        string `json:"service"`
-	Image          string `json:"docker_image"`
-	StartFirst     bool   `json:"start_first"`
-	Confirm        bool   `json:"confirm"`
-	Timeout        int    `json:"timeout"`
-	IntervalMillis int64  `json:"interval_millis"`
-	BatchSize      int64  `json:"batch_size"`
-}
-
-var version string // build number set at compile-time
+var (
+	version = "0.0.0"
+	build   = "0"
+)
 
 func main() {
 	app := cli.NewApp()
 	app.Name = "rancher publish"
 	app.Usage = "rancher publish"
 	app.Action = run
-	app.Version = version
+	app.Version = fmt.Sprintf("%s+%s", version, build)
+
 	app.Flags = []cli.Flag{
 
 		cli.StringFlag{
 			Name:   "url",
 			Usage:  "url to the rancher api",
-			EnvVar: "PLUGIN_URL",
+			EnvVar: "PLUGIN_URL, RANCHER_URL",
 		},
 		cli.StringFlag{
 			Name:   "access-key",
@@ -49,6 +42,11 @@ func main() {
 			Usage:  "Service to act on",
 			EnvVar: "PLUGIN_SERVICE",
 		},
+		cli.StringSliceFlag{
+			Name:   "sidekick",
+			Usage:  "Service's sidekick name and image separated by the space, supports multiple flags",
+			EnvVar: "PLUGIN_SIDEKICK",
+		},
 		cli.StringFlag{
 			Name:   "docker-image",
 			Usage:  "image to use",
@@ -87,6 +85,11 @@ func main() {
 			Usage:  "Ensure the yaml was signed",
 			EnvVar: "DRONE_YAML_VERIFIED",
 		},
+		cli.StringFlag{
+			Name:   "environment",
+			Usage:  "rancher environment to act on",
+			EnvVar: "PLUGIN_ENVIRONMENT",
+		},
 	}
 
 	if err := app.Run(os.Args); err != nil {
@@ -96,17 +99,19 @@ func main() {
 
 func run(c *cli.Context) error {
 	plugin := Plugin{
-		URL:            c.String("url"),
-		Key:            c.String("access-key"),
-		Secret:         c.String("secret-key"),
-		Service:        c.String("service"),
-		DockerImage:    c.String("docker-image"),
-		StartFirst:     c.BoolT("start-first"),
-		Confirm:        c.Bool("confirm"),
-		Timeout:        c.Int("timeout"),
-		IntervalMillis: c.Int64("interval-millis"),
-		BatchSize:      c.Int64("batch-size"),
-		YamlVerified:   c.BoolT("yaml-verified"),
+		URL:                 c.String("url"),
+		Key:                 c.String("access-key"),
+		Secret:              c.String("secret-key"),
+		Service:             c.String("service"),
+		SidekickDockerImage: c.StringSlice("sidekick"),
+		DockerImage:         c.String("docker-image"),
+		StartFirst:          c.BoolT("start-first"),
+		Confirm:             c.Bool("confirm"),
+		Timeout:             c.Int("timeout"),
+		IntervalMillis:      c.Int64("interval-millis"),
+		BatchSize:           c.Int64("batch-size"),
+		YamlVerified:        c.BoolT("yaml-verified"),
+		Environment:         c.String("environment"),
 	}
 	return plugin.Exec()
 }

plugin.go

@@ -3,36 +3,36 @@ package main
 import (
 	"errors"
 	"fmt"
-	log "github.com/Sirupsen/logrus"
-	"github.com/rancher/go-rancher/client"
 	"strings"
 	"time"
+
+	log "github.com/Sirupsen/logrus"
+	client "github.com/rancher/go-rancher/v2"
 )
 
 type Plugin struct {
-	URL            string
-	Key            string
-	Secret         string
-	Service        string
-	DockerImage    string
-	StartFirst     bool
-	Confirm        bool
-	Timeout        int
-	IntervalMillis int64
-	BatchSize      int64
-	YamlVerified   bool
+	URL                 string
+	Key                 string
+	Secret              string
+	Service             string
+	SidekickDockerImage []string
+	DockerImage         string
+	StartFirst          bool
+	Confirm             bool
+	Timeout             int
+	IntervalMillis      int64
+	BatchSize           int64
+	YamlVerified        bool
+	Environment         string
 }
 
 func (p *Plugin) Exec() error {
 	log.Info("Drone Rancher Plugin built")
 
-	if p.URL == "" || p.Key == "" || p.Secret == "" {
+	if p.URL == "" || p.Key == "" || p.Secret == "" || p.Service == "" {
 		return errors.New("Eek: Must have url, key, secret, and service definied")
 	}
 
-	if !strings.HasPrefix(p.DockerImage, "docker:") {
-		p.DockerImage = fmt.Sprintf("docker:%s", p.DockerImage)
-	}
 	var wantedService, wantedStack string
 	if strings.Contains(p.Service, "/") {
 		parts := strings.SplitN(p.Service, "/", 2)
@@ -48,41 +48,80 @@ func (p *Plugin) Exec() error {
 		SecretKey: p.Secret,
 	})
 	if err != nil {
-		return errors.New(fmt.Sprintf("Failed to create rancher client: %s\n :(", err))
+		return fmt.Errorf("Failed to create rancher client: %s", err)
 	}
 
-	var stackId string
-	if wantedStack != "" {
-		environments, err := rancher.Environment.List(&client.ListOpts{})
+	// Prepare service filters for service listing
+	serviceFilters := map[string]interface{}{"name": wantedService}
+
+	if len(p.Environment) >= 1 {
+		environments, err := rancher.Account.List(&client.ListOpts{Filters: map[string]interface{}{"name": p.Environment}})
+
 		if err != nil {
-			return errors.New(fmt.Sprintf("Failed to list rancher environments: %s\n", err))
+			return fmt.Errorf("Failed to find given rancher environment: %s", err)
 		}
-		for _, env := range environments.Data {
-			if env.Name == wantedStack {
-				stackId = env.Id
+		if len(environments.Data) <= 0 {
+			return fmt.Errorf("Unable to find environment %s", p.Environment)
+		}
+
+		// If found add environmentID to serviceFilters
+		serviceFilters["accountId"] = environments.Data[0].Id
+	}
+
+	// Query stacks with filter name=wantedStack
+	if wantedStack != "" {
+		stacks, err := rancher.Stack.List(&client.ListOpts{Filters: map[string]interface{}{"name": wantedStack}})
+
+		// If environment is defined re-query the API with the accountId
+		if len(p.Environment) >= 1 {
+			stacks, err = rancher.Stack.List(&client.ListOpts{Filters: map[string]interface{}{"accountId": serviceFilters["accountId"], "name": wantedStack}})
+		}
+
+		if err != nil {
+			return fmt.Errorf("Failed to list rancher environments: %s", err)
+		}
+		if len(stacks.Data) <= 0 {
+			return fmt.Errorf("Unable to find stack %s", wantedStack)
+		}
+		// If found add stackID to serviceFilters
+		serviceFilters["stackId"] = stacks.Data[0].Id
+
+	}
+
+	// Query services with prepared filters
+	services, err := rancher.Service.List(&client.ListOpts{Filters: serviceFilters})
+	if err != nil {
+		return fmt.Errorf("Failed to list rancher services: %s", err)
+	}
+	if len(services.Data) <= 0 {
+		return fmt.Errorf("Unable to find service %s", p.Service)
+	}
+	service := services.Data[0]
+	// Service is found, proceed with upgrade
+
+	// We want to exit if there is no docker image updates
+	if p.DockerImage == "" && len(p.SidekickDockerImage) <= 0 {
+		return fmt.Errorf("Nothing to upgrade")
+	}
+
+	// Only change value if it's not null.
+	if p.DockerImage != "" {
+		// Add prefix when missing to meet Rancher API requirement
+		service.LaunchConfig.ImageUuid = prepareDockerPrefix(p.DockerImage)
+	}
+
+	// Iterate over provided sidekick flags
+	for _, sidekick := range p.SidekickDockerImage {
+		// Split flag in two from "--sidekick nginx nginx:latest"
+		parts := strings.SplitN(sidekick, " ", 2)
+		wantedSidekick := parts[0]
+		wantedImage := parts[1]
+		for i, s := range service.SecondaryLaunchConfigs {
+			if wantedSidekick == s.Name {
+				service.SecondaryLaunchConfigs[i].ImageUuid = prepareDockerPrefix(wantedImage)
 			}
 		}
-		if stackId == "" {
-			return errors.New(fmt.Sprintf("Unable to find stack %s\n", wantedStack))
-		}
 	}
-	services, err := rancher.Service.List(&client.ListOpts{})
-	if err != nil {
-		return errors.New(fmt.Sprintf("Failed to list rancher services: %s\n", err))
-	}
-	found := false
-	var service client.Service
-	for _, svc := range services.Data {
-		if svc.Name == wantedService && ((wantedStack != "" && svc.EnvironmentId == stackId) || wantedStack == "") {
-			service = svc
-			found = true
-		}
-	}
-	if !found {
-		return errors.New(fmt.Sprintf("Unable to find service %s\n", p.Service))
-	}
-
-	service.LaunchConfig.ImageUuid = p.DockerImage
 	upgrade := &client.ServiceUpgrade{}
 	upgrade.InServiceStrategy = &client.InServiceUpgradeStrategy{
 		LaunchConfig:           service.LaunchConfig,
@@ -94,10 +133,9 @@ func (p *Plugin) Exec() error {
 	upgrade.ToServiceStrategy = &client.ToServiceUpgradeStrategy{}
 	_, err = rancher.Service.ActionUpgrade(&service, upgrade)
 	if err != nil {
-		return errors.New(fmt.Sprintf("Unable to upgrade service %s: %s\n", p.Service, err))
+		return fmt.Errorf("Unable to upgrade service %s: %s", p.Service, err)
 	}
 
-	log.Info(fmt.Sprintf("Upgraded %s to %s\n", p.Service, p.DockerImage))
 	if p.Confirm {
 		srv, err := retry(func() (interface{}, error) {
 			s, e := rancher.Service.ById(service.Id)
@@ -105,26 +143,36 @@ func (p *Plugin) Exec() error {
 				return nil, e
 			}
 			if s.State != "upgraded" {
-				return nil, errors.New(fmt.Sprintf("Service not upgraded: %s", s.State))
+				return nil, fmt.Errorf("Service not upgraded: %s", s.State)
 			}
 			return s, nil
 		}, time.Duration(p.Timeout)*time.Second, 3*time.Second)
 
 		if err != nil {
-			return errors.New(fmt.Sprintf("Error waiting for service upgrade to complete: %s", err))
+			return fmt.Errorf("Error waiting for service upgrade to complete: %s", err)
 		}
 
 		_, err = rancher.Service.ActionFinishupgrade(srv.(*client.Service))
 		if err != nil {
-			return errors.New(fmt.Sprintf("Unable to finish upgrade %s: %s\n", p.Service, err))
+			return fmt.Errorf("Unable to finish upgrade %s: %s", p.Service, err)
 		}
-		log.Info(fmt.Printf("Finished upgrade %s\n", p.Service))
+		log.Infof("Finished upgrade %s", p.Service)
 	}
+
+	log.Infof("Upgraded %s to %s", p.Service, p.DockerImage)
+
 	return nil
 }
 
 type retryFunc func() (interface{}, error)
 
+func prepareDockerPrefix(image string) string {
+	if !strings.HasPrefix(image, "docker:") {
+		image = fmt.Sprintf("docker:%s", image)
+	}
+	return image
+}
+
 func retry(f retryFunc, timeout time.Duration, interval time.Duration) (interface{}, error) {
 	finish := time.After(timeout)
 	for {

vendor.yml

@@ -1,19 +0,0 @@
-vendors:
-- path: github.com/Sirupsen/logrus
-  rev: 3f603f494d61c73457fb234161d8982b9f0f0b71
-- path: github.com/codegangsta/cli
-  rev: 347a9884a87374d000eec7e6445a34487c1f4a2b
-- path: github.com/davecgh/go-spew
-  rev: 346938d642f2ec3594ed81d874461961cd0faa76
-- path: github.com/gorilla/websocket
-  rev: 804cb600d06b10672f2fbc0a336a7bee507a428e
-- path: github.com/pkg/errors
-  rev: 248dadf4e9068a0b3e79f02ed0a610d935de5302
-- path: github.com/pmezard/go-difflib
-  rev: 792786c7400a136282c1664665ae0a8db921c6c2
-- path: github.com/rancher/go-rancher
-  rev: 2c43ff300f3eafcbd7d0b89b10427fc630efdc1e
-- path: github.com/stretchr/testify
-  rev: 4d4bfba8f1d1027c4fdbe371823030df51419987
-- path: golang.org/x/sys
-  rev: e24f485414aeafb646f6fca458b0bf869c0880a1

vendor/github.com/Sirupsen/logrus/.travis.yml

@@ -1,8 +0,0 @@
-language: go
-go:
-  - 1.6
-  - 1.7
-  - tip
-install:
-  - go get -t ./...
-script: GOMAXPROCS=4 GORACE="halt_on_error=1" go test -race -v ./...

vendor/github.com/Sirupsen/logrus/CHANGELOG.md

@@ -1,80 +0,0 @@
-# 0.11.2
-
-* bug: fix windows terminal detection (#476)
-
-# 0.11.1
-
-* bug: fix tty detection with custom out (#471)
-
-# 0.11.0
-
-* performance: Use bufferpool to allocate (#370)
-* terminal: terminal detection for app-engine (#343)
-* feature: exit handler (#375)
-
-# 0.10.0
-
-* feature: Add a test hook (#180)
-* feature: `ParseLevel` is now case-insensitive (#326)
-* feature: `FieldLogger` interface that generalizes `Logger` and `Entry` (#308)
-* performance: avoid re-allocations on `WithFields` (#335)
-
-# 0.9.0
-
-* logrus/text_formatter: don't emit empty msg
-* logrus/hooks/airbrake: move out of main repository
-* logrus/hooks/sentry: move out of main repository
-* logrus/hooks/papertrail: move out of main repository
-* logrus/hooks/bugsnag: move out of main repository
-* logrus/core: run tests with `-race`
-* logrus/core: detect TTY based on `stderr`
-* logrus/core: support `WithError` on logger
-* logrus/core: Solaris support
-
-# 0.8.7
-
-* logrus/core: fix possible race (#216)
-* logrus/doc: small typo fixes and doc improvements
-
-
-# 0.8.6
-
-* hooks/raven: allow passing an initialized client
-
-# 0.8.5
-
-* logrus/core: revert #208
-
-# 0.8.4
-
-* formatter/text: fix data race (#218)
-
-# 0.8.3
-
-* logrus/core: fix entry log level (#208)
-* logrus/core: improve performance of text formatter by 40%
-* logrus/core: expose `LevelHooks` type
-* logrus/core: add support for DragonflyBSD and NetBSD
-* formatter/text: print structs more verbosely
-
-# 0.8.2
-
-* logrus: fix more Fatal family functions
-
-# 0.8.1
-
-* logrus: fix not exiting on `Fatalf` and `Fatalln`
-
-# 0.8.0
-
-* logrus: defaults to stderr instead of stdout
-* hooks/sentry: add special field for `*http.Request`
-* formatter/text: ignore Windows for colors
-
-# 0.7.3
-
-* formatter/\*: allow configuration of timestamp layout
-
-# 0.7.2
-
-* formatter/text: Add configuration option for time format (#158)

vendor/github.com/Sirupsen/logrus/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Simon Eskildsen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

vendor/github.com/Sirupsen/logrus/README.md

@@ -1,476 +0,0 @@
-# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>&nbsp;[![Build Status](https://travis-ci.org/Sirupsen/logrus.svg?branch=master)](https://travis-ci.org/Sirupsen/logrus)&nbsp;[![GoDoc](https://godoc.org/github.com/Sirupsen/logrus?status.svg)](https://godoc.org/github.com/Sirupsen/logrus)
-
-**Seeing weird case-sensitive problems?** See [this
-issue](https://github.com/sirupsen/logrus/issues/451#issuecomment-264332021).
-This change has been reverted. I apologize for causing this. I greatly
-underestimated the impact this would have. Logrus strives for stability and
-backwards compatibility and failed to provide that.
-
-Logrus is a structured logger for Go (golang), completely API compatible with
-the standard library logger. [Godoc][godoc]. **Please note the Logrus API is not
-yet stable (pre 1.0). Logrus itself is completely stable and has been used in
-many large deployments. The core API is unlikely to change much but please
-version control your Logrus to make sure you aren't fetching latest `master` on
-every build.**
-
-Nicely color-coded in development (when a TTY is attached, otherwise just
-plain text):
-
-![Colored](http://i.imgur.com/PY7qMwd.png)
-
-With `log.SetFormatter(&log.JSONFormatter{})`, for easy parsing by logstash
-or Splunk:
-
-```json
-{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
-ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
-
-{"level":"warning","msg":"The group's number increased tremendously!",
-"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"A giant walrus appears!",
-"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.",
-"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"}
-
-{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true,
-"time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
-```
-
-With the default `log.SetFormatter(&log.TextFormatter{})` when a TTY is not
-attached, the output is compatible with the
-[logfmt](http://godoc.org/github.com/kr/logfmt) format:
-
-```text
-time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8
-time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10
-time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true
-time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4
-time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009
-time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true
-exit status 1
-```
-
-#### Example
-
-The simplest way to use Logrus is simply the package-level exported logger:
-
-```go
-package main
-
-import (
-  log "github.com/Sirupsen/logrus"
-)
-
-func main() {
-  log.WithFields(log.Fields{
-    "animal": "walrus",
-  }).Info("A walrus appears")
-}
-```
-
-Note that it's completely api-compatible with the stdlib logger, so you can
-replace your `log` imports everywhere with `log "github.com/Sirupsen/logrus"`
-and you'll now have the flexibility of Logrus. You can customize it all you
-want:
-
-```go
-package main
-
-import (
-  "os"
-  log "github.com/Sirupsen/logrus"
-)
-
-func init() {
-  // Log as JSON instead of the default ASCII formatter.
-  log.SetFormatter(&log.JSONFormatter{})
-
-  // Output to stdout instead of the default stderr
-  // Can be any io.Writer, see below for File example
-  log.SetOutput(os.Stdout)
-
-  // Only log the warning severity or above.
-  log.SetLevel(log.WarnLevel)
-}
-
-func main() {
-  log.WithFields(log.Fields{
-    "animal": "walrus",
-    "size":   10,
-  }).Info("A group of walrus emerges from the ocean")
-
-  log.WithFields(log.Fields{
-    "omg":    true,
-    "number": 122,
-  }).Warn("The group's number increased tremendously!")
-
-  log.WithFields(log.Fields{
-    "omg":    true,
-    "number": 100,
-  }).Fatal("The ice breaks!")
-
-  // A common pattern is to re-use fields between logging statements by re-using
-  // the logrus.Entry returned from WithFields()
-  contextLogger := log.WithFields(log.Fields{
-    "common": "this is a common field",
-    "other": "I also should be logged always",
-  })
-
-  contextLogger.Info("I'll be logged with common and other field")
-  contextLogger.Info("Me too")
-}
-```
-
-For more advanced usage such as logging to multiple locations from the same
-application, you can also create an instance of the `logrus` Logger:
-
-```go
-package main
-
-import (
-  "github.com/Sirupsen/logrus"
-)
-
-// Create a new instance of the logger. You can have any number of instances.
-var log = logrus.New()
-
-func main() {
-  // The API for setting attributes is a little different than the package level
-  // exported logger. See Godoc.
-  log.Out = os.Stdout
-
-  // You could set this to any `io.Writer` such as a file
-  // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY, 0666)
-  // if err == nil {
-  //  log.Out = file
-  // } else {
-  //  log.Info("Failed to log to file, using default stderr")
-  // }
-
-  log.WithFields(logrus.Fields{
-    "animal": "walrus",
-    "size":   10,
-  }).Info("A group of walrus emerges from the ocean")
-}
-```
-
-#### Fields
-
-Logrus encourages careful, structured logging though logging fields instead of
-long, unparseable error messages. For example, instead of: `log.Fatalf("Failed
-to send event %s to topic %s with key %d")`, you should log the much more
-discoverable:
-
-```go
-log.WithFields(log.Fields{
-  "event": event,
-  "topic": topic,
-  "key": key,
-}).Fatal("Failed to send event")
-```
-
-We've found this API forces you to think about logging in a way that produces
-much more useful logging messages. We've been in countless situations where just
-a single added field to a log statement that was already there would've saved us
-hours. The `WithFields` call is optional.
-
-In general, with Logrus using any of the `printf`-family functions should be
-seen as a hint you should add a field, however, you can still use the
-`printf`-family functions with Logrus.
-
-#### Default Fields
-
-Often it's helpful to have fields _always_ attached to log statements in an
-application or parts of one. For example, you may want to always log the
-`request_id` and `user_ip` in the context of a request. Instead of writing
-`log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})` on
-every line, you can create a `logrus.Entry` to pass around instead:
-
-```go
-requestLogger := log.WithFields(log.Fields{"request_id": request_id, user_ip: user_ip})
-requestLogger.Info("something happened on that request") # will log request_id and user_ip
-requestLogger.Warn("something not great happened")
-```
-
-#### Hooks
-
-You can add hooks for logging levels. For example to send errors to an exception
-tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to
-multiple places simultaneously, e.g. syslog.
-
-Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in
-`init`:
-
-```go
-import (
-  log "github.com/Sirupsen/logrus"
-  "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "aibrake"
-  logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
-  "log/syslog"
-)
-
-func init() {
-
-  // Use the Airbrake hook to report errors that have Error severity or above to
-  // an exception tracker. You can create custom hooks, see the Hooks section.
-  log.AddHook(airbrake.NewHook(123, "xyz", "production"))
-
-  hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
-  if err != nil {
-    log.Error("Unable to connect to local syslog daemon")
-  } else {
-    log.AddHook(hook)
-  }
-}
-```
-Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md).
-
-| Hook  | Description |
-| ----- | ----------- |
-| [Airbrake "legacy"](https://github.com/gemnasium/logrus-airbrake-legacy-hook) | Send errors to an exception tracking service compatible with the Airbrake API V2. Uses [`airbrake-go`](https://github.com/tobi/airbrake-go) behind the scenes. |
-| [Airbrake](https://github.com/gemnasium/logrus-airbrake-hook) | Send errors to the Airbrake API V3. Uses the official [`gobrake`](https://github.com/airbrake/gobrake) behind the scenes. |
-| [Amazon Kinesis](https://github.com/evalphobia/logrus_kinesis) | Hook for logging to [Amazon Kinesis](https://aws.amazon.com/kinesis/) |
-| [Amqp-Hook](https://github.com/vladoatanasov/logrus_amqp) | Hook for logging to Amqp broker (Like RabbitMQ) |
-| [Bugsnag](https://github.com/Shopify/logrus-bugsnag/blob/master/bugsnag.go) | Send errors to the Bugsnag exception tracking service. |
-| [DeferPanic](https://github.com/deferpanic/dp-logrus) | Hook for logging to DeferPanic |
-| [ElasticSearch](https://github.com/sohlich/elogrus) | Hook for logging to ElasticSearch|
-| [Fluentd](https://github.com/evalphobia/logrus_fluent) | Hook for logging to fluentd |
-| [Go-Slack](https://github.com/multiplay/go-slack) | Hook for logging to [Slack](https://slack.com) |
-| [Graylog](https://github.com/gemnasium/logrus-graylog-hook) | Hook for logging to [Graylog](http://graylog2.org/) |
-| [Hiprus](https://github.com/nubo/hiprus) | Send errors to a channel in hipchat. |
-| [Honeybadger](https://github.com/agonzalezro/logrus_honeybadger) | Hook for sending exceptions to Honeybadger |
-| [InfluxDB](https://github.com/Abramovic/logrus_influxdb) | Hook for logging to influxdb |
-| [Influxus] (http://github.com/vlad-doru/influxus) | Hook for concurrently logging to [InfluxDB] (http://influxdata.com/) |
-| [Journalhook](https://github.com/wercker/journalhook) | Hook for logging to `systemd-journald` |
-| [KafkaLogrus](https://github.com/goibibo/KafkaLogrus) | Hook for logging to kafka |
-| [LFShook](https://github.com/rifflock/lfshook) | Hook for logging to the local filesystem |
-| [Logentries](https://github.com/jcftang/logentriesrus) | Hook for logging to [Logentries](https://logentries.com/) |
-| [Logentrus](https://github.com/puddingfactory/logentrus) | Hook for logging to [Logentries](https://logentries.com/) |
-| [Logmatic.io](https://github.com/logmatic/logmatic-go) | Hook for logging to [Logmatic.io](http://logmatic.io/) |
-| [Logrusly](https://github.com/sebest/logrusly) | Send logs to [Loggly](https://www.loggly.com/) |
-| [Logstash](https://github.com/bshuster-repo/logrus-logstash-hook) | Hook for logging to [Logstash](https://www.elastic.co/products/logstash) |
-| [Mail](https://github.com/zbindenren/logrus_mail) | Hook for sending exceptions via mail |
-| [Mongodb](https://github.com/weekface/mgorus) | Hook for logging to mongodb |
-| [NATS-Hook](https://github.com/rybit/nats_logrus_hook) | Hook for logging to [NATS](https://nats.io) |
-| [Octokit](https://github.com/dorajistyle/logrus-octokit-hook) | Hook for logging to github via octokit |
-| [Papertrail](https://github.com/polds/logrus-papertrail-hook) | Send errors to the [Papertrail](https://papertrailapp.com) hosted logging service via UDP. |
-| [PostgreSQL](https://github.com/gemnasium/logrus-postgresql-hook) | Send logs to [PostgreSQL](http://postgresql.org) |
-| [Pushover](https://github.com/toorop/logrus_pushover) | Send error via [Pushover](https://pushover.net) |
-| [Raygun](https://github.com/squirkle/logrus-raygun-hook) | Hook for logging to [Raygun.io](http://raygun.io/) |
-| [Redis-Hook](https://github.com/rogierlommers/logrus-redis-hook) | Hook for logging to a ELK stack (through Redis) |
-| [Rollrus](https://github.com/heroku/rollrus) | Hook for sending errors to rollbar |
-| [Scribe](https://github.com/sagar8192/logrus-scribe-hook) | Hook for logging to [Scribe](https://github.com/facebookarchive/scribe)|
-| [Sentry](https://github.com/evalphobia/logrus_sentry) | Send errors to the Sentry error logging and aggregation service. |
-| [Slackrus](https://github.com/johntdyer/slackrus) | Hook for Slack chat. |
-| [Stackdriver](https://github.com/knq/sdhook) | Hook for logging to [Google Stackdriver](https://cloud.google.com/logging/) |
-| [Sumorus](https://github.com/doublefree/sumorus) | Hook for logging to [SumoLogic](https://www.sumologic.com/)|
-| [Syslog](https://github.com/Sirupsen/logrus/blob/master/hooks/syslog/syslog.go) | Send errors to remote syslog server. Uses standard library `log/syslog` behind the scenes. |
-| [TraceView](https://github.com/evalphobia/logrus_appneta) | Hook for logging to [AppNeta TraceView](https://www.appneta.com/products/traceview/) |
-| [Typetalk](https://github.com/dragon3/logrus-typetalk-hook) | Hook for logging to [Typetalk](https://www.typetalk.in/) |
-| [logz.io](https://github.com/ripcurld00d/logrus-logzio-hook) | Hook for logging to [logz.io](https://logz.io), a Log as a Service using Logstash |
-
-#### Level logging
-
-Logrus has six logging levels: Debug, Info, Warning, Error, Fatal and Panic.
-
-```go
-log.Debug("Useful debugging information.")
-log.Info("Something noteworthy happened!")
-log.Warn("You should probably take a look at this.")
-log.Error("Something failed but I'm not quitting.")
-// Calls os.Exit(1) after logging
-log.Fatal("Bye.")
-// Calls panic() after logging
-log.Panic("I'm bailing.")
-```
-
-You can set the logging level on a `Logger`, then it will only log entries with
-that severity or anything above it:
-
-```go
-// Will log anything that is info or above (warn, error, fatal, panic). Default.
-log.SetLevel(log.InfoLevel)
-```
-
-It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
-environment if your application has that.
-
-#### Entries
-
-Besides the fields added with `WithField` or `WithFields` some fields are
-automatically added to all logging events:
-
-1. `time`. The timestamp when the entry was created.
-2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after
-   the `AddFields` call. E.g. `Failed to send event.`
-3. `level`. The logging level. E.g. `info`.
-
-#### Environments
-
-Logrus has no notion of environment.
-
-If you wish for hooks and formatters to only be used in specific environments,
-you should handle that yourself. For example, if your application has a global
-variable `Environment`, which is a string representation of the environment you
-could do:
-
-```go
-import (
-  log "github.com/Sirupsen/logrus"
-)
-
-init() {
-  // do something here to set environment depending on an environment variable
-  // or command-line flag
-  if Environment == "production" {
-    log.SetFormatter(&log.JSONFormatter{})
-  } else {
-    // The TextFormatter is default, you don't actually have to do this.
-    log.SetFormatter(&log.TextFormatter{})
-  }
-}
-```
-
-This configuration is how `logrus` was intended to be used, but JSON in
-production is mostly only useful if you do log aggregation with tools like
-Splunk or Logstash.
-
-#### Formatters
-
-The built-in logging formatters are:
-
-* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise
-  without colors.
-  * *Note:* to force colored output when there is no TTY, set the `ForceColors`
-    field to `true`.  To force no colored output even if there is a TTY  set the
-    `DisableColors` field to `true`. For Windows, see
-    [github.com/mattn/go-colorable](https://github.com/mattn/go-colorable).
-  * All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#TextFormatter).
-* `logrus.JSONFormatter`. Logs fields as JSON.
-  * All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#JSONFormatter).
-
-Third party logging formatters:
-
-* [`logstash`](https://github.com/bshuster-repo/logrus-logstash-hook). Logs fields as [Logstash](http://logstash.net) Events.
-* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout.
-* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
-
-You can define your formatter by implementing the `Formatter` interface,
-requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
-`Fields` type (`map[string]interface{}`) with all your fields as well as the
-default ones (see Entries section above):
-
-```go
-type MyJSONFormatter struct {
-}
-
-log.SetFormatter(new(MyJSONFormatter))
-
-func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) {
-  // Note this doesn't include Time, Level and Message which are available on
-  // the Entry. Consult `godoc` on information about those fields or read the
-  // source of the official loggers.
-  serialized, err := json.Marshal(entry.Data)
-    if err != nil {
-      return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
-    }
-  return append(serialized, '\n'), nil
-}
-```
-
-#### Logger as an `io.Writer`
-
-Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.
-
-```go
-w := logger.Writer()
-defer w.Close()
-
-srv := http.Server{
-    // create a stdlib log.Logger that writes to
-    // logrus.Logger.
-    ErrorLog: log.New(w, "", 0),
-}
-```
-
-Each line written to that writer will be printed the usual way, using formatters
-and hooks. The level for those entries is `info`.
-
-This means that we can override the standard library logger easily:
-
-```go
-logger := logrus.New()
-logger.Formatter = &logrus.JSONFormatter{}
-
-// Use logrus for standard log output
-// Note that `log` here references stdlib's log
-// Not logrus imported under the name `log`.
-log.SetOutput(logger.Writer())
-```
-
-#### Rotation
-
-Log rotation is not provided with Logrus. Log rotation should be done by an
-external program (like `logrotate(8)`) that can compress and delete old log
-entries. It should not be a feature of the application-level logger.
-
-#### Tools
-
-| Tool | Description |
-| ---- | ----------- |
-|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will generated with different config at different environment.|
-|[Logrus Viper Helper](https://github.com/heirko/go-contrib/tree/master/logrusHelper)|An Helper arround Logrus to wrap with spf13/Viper to load configuration with fangs! And to simplify Logrus configuration use some behavior of [Logrus Mate](https://github.com/gogap/logrus_mate). [sample](https://github.com/heirko/iris-contrib/blob/master/middleware/logrus-logger/example) |
-
-#### Testing
-
-Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides:
-
-* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just add the `test` hook
-* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any):
-
-```go
-logger, hook := NewNullLogger()
-logger.Error("Hello error")
-
-assert.Equal(1, len(hook.Entries))
-assert.Equal(logrus.ErrorLevel, hook.LastEntry().Level)
-assert.Equal("Hello error", hook.LastEntry().Message)
-
-hook.Reset()
-assert.Nil(hook.LastEntry())
-```
-
-#### Fatal handlers
-
-Logrus can register one or more functions that will be called when any `fatal`
-level message is logged. The registered handlers will be executed before
-logrus performs a `os.Exit(1)`. This behavior may be helpful if callers need
-to gracefully shutdown. Unlike a `panic("Something went wrong...")` call which can be intercepted with a deferred `recover` a call to `os.Exit(1)` can not be intercepted.
-
-```
-...
-handler := func() {
-  // gracefully shutdown something...
-}
-logrus.RegisterExitHandler(handler)
-...
-```
-
-#### Thread safety
-
-By default Logger is protected by mutex for concurrent writes, this mutex is invoked when calling hooks and writing logs.
-If you are sure such locking is not needed, you can call logger.SetNoLock() to disable the locking.
-
-Situation when locking is not needed includes:
-
-* You have no hooks registered, or hooks calling is already thread-safe.
-
-* Writing to logger.Out is already thread-safe, for example:
-
-  1) logger.Out is protected by locks.
-
-  2) logger.Out is a os.File handler opened with `O_APPEND` flag, and every write is smaller than 4k. (This allow multi-thread/multi-process writing)
-
-     (Refer to http://www.notthewizard.com/2014/06/17/are-files-appends-really-atomic/)

vendor/github.com/Sirupsen/logrus/alt_exit.go

@@ -1,64 +0,0 @@
-package logrus
-
-// The following code was sourced and modified from the
-// https://bitbucket.org/tebeka/atexit package governed by the following license:
-//
-// Copyright (c) 2012 Miki Tebeka <miki.tebeka@gmail.com>.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-// the Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-import (
-	"fmt"
-	"os"
-)
-
-var handlers = []func(){}
-
-func runHandler(handler func()) {
-	defer func() {
-		if err := recover(); err != nil {
-			fmt.Fprintln(os.Stderr, "Error: Logrus exit handler error:", err)
-		}
-	}()
-
-	handler()
-}
-
-func runHandlers() {
-	for _, handler := range handlers {
-		runHandler(handler)
-	}
-}
-
-// Exit runs all the Logrus atexit handlers and then terminates the program using os.Exit(code)
-func Exit(code int) {
-	runHandlers()
-	os.Exit(code)
-}
-
-// RegisterExitHandler adds a Logrus Exit handler, call logrus.Exit to invoke
-// all handlers. The handlers will also be invoked when any Fatal log entry is
-// made.
-//
-// This method is useful when a caller wishes to use logrus to log a fatal
-// message but also needs to gracefully shutdown. An example usecase could be
-// closing database connections, or sending a alert that the application is
-// closing.
-func RegisterExitHandler(handler func()) {
-	handlers = append(handlers, handler)
-}

vendor/github.com/Sirupsen/logrus/alt_exit_test.go

@@ -1,74 +0,0 @@
-package logrus
-
-import (
-	"io/ioutil"
-	"os/exec"
-	"testing"
-	"time"
-)
-
-func TestRegister(t *testing.T) {
-	current := len(handlers)
-	RegisterExitHandler(func() {})
-	if len(handlers) != current+1 {
-		t.Fatalf("can't add handler")
-	}
-}
-
-func TestHandler(t *testing.T) {
-	gofile := "/tmp/testprog.go"
-	if err := ioutil.WriteFile(gofile, testprog, 0666); err != nil {
-		t.Fatalf("can't create go file")
-	}
-
-	outfile := "/tmp/testprog.out"
-	arg := time.Now().UTC().String()
-	err := exec.Command("go", "run", gofile, outfile, arg).Run()
-	if err == nil {
-		t.Fatalf("completed normally, should have failed")
-	}
-
-	data, err := ioutil.ReadFile(outfile)
-	if err != nil {
-		t.Fatalf("can't read output file %s", outfile)
-	}
-
-	if string(data) != arg {
-		t.Fatalf("bad data")
-	}
-}
-
-var testprog = []byte(`
-// Test program for atexit, gets output file and data as arguments and writes
-// data to output file in atexit handler.
-package main
-
-import (
-	"github.com/Sirupsen/logrus"
-	"flag"
-	"fmt"
-	"io/ioutil"
-)
-
-var outfile = ""
-var data = ""
-
-func handler() {
-	ioutil.WriteFile(outfile, []byte(data), 0666)
-}
-
-func badHandler() {
-	n := 0
-	fmt.Println(1/n)
-}
-
-func main() {
-	flag.Parse()
-	outfile = flag.Arg(0)
-	data = flag.Arg(1)
-
-	logrus.RegisterExitHandler(handler)
-	logrus.RegisterExitHandler(badHandler)
-	logrus.Fatal("Bye bye")
-}
-`)

vendor/github.com/Sirupsen/logrus/doc.go

@@ -1,26 +0,0 @@
-/*
-Package logrus is a structured logger for Go, completely API compatible with the standard library logger.
-
-
-The simplest way to use Logrus is simply the package-level exported logger:
-
-  package main
-
-  import (
-    log "github.com/Sirupsen/logrus"
-  )
-
-  func main() {
-    log.WithFields(log.Fields{
-      "animal": "walrus",
-      "number": 1,
-      "size":   10,
-    }).Info("A walrus appears")
-  }
-
-Output:
-  time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10
-
-For a full guide visit https://github.com/Sirupsen/logrus
-*/
-package logrus

vendor/github.com/Sirupsen/logrus/entry.go

@@ -1,275 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"sync"
-	"time"
-)
-
-var bufferPool *sync.Pool
-
-func init() {
-	bufferPool = &sync.Pool{
-		New: func() interface{} {
-			return new(bytes.Buffer)
-		},
-	}
-}
-
-// Defines the key when adding errors using WithError.
-var ErrorKey = "error"
-
-// An entry is the final or intermediate Logrus logging entry. It contains all
-// the fields passed with WithField{,s}. It's finally logged when Debug, Info,
-// Warn, Error, Fatal or Panic is called on it. These objects can be reused and
-// passed around as much as you wish to avoid field duplication.
-type Entry struct {
-	Logger *Logger
-
-	// Contains all the fields set by the user.
-	Data Fields
-
-	// Time at which the log entry was created
-	Time time.Time
-
-	// Level the log entry was logged at: Debug, Info, Warn, Error, Fatal or Panic
-	Level Level
-
-	// Message passed to Debug, Info, Warn, Error, Fatal or Panic
-	Message string
-
-	// When formatter is called in entry.log(), an Buffer may be set to entry
-	Buffer *bytes.Buffer
-}
-
-func NewEntry(logger *Logger) *Entry {
-	return &Entry{
-		Logger: logger,
-		// Default is three fields, give a little extra room
-		Data: make(Fields, 5),
-	}
-}
-
-// Returns the string representation from the reader and ultimately the
-// formatter.
-func (entry *Entry) String() (string, error) {
-	serialized, err := entry.Logger.Formatter.Format(entry)
-	if err != nil {
-		return "", err
-	}
-	str := string(serialized)
-	return str, nil
-}
-
-// Add an error as single field (using the key defined in ErrorKey) to the Entry.
-func (entry *Entry) WithError(err error) *Entry {
-	return entry.WithField(ErrorKey, err)
-}
-
-// Add a single field to the Entry.
-func (entry *Entry) WithField(key string, value interface{}) *Entry {
-	return entry.WithFields(Fields{key: value})
-}
-
-// Add a map of fields to the Entry.
-func (entry *Entry) WithFields(fields Fields) *Entry {
-	data := make(Fields, len(entry.Data)+len(fields))
-	for k, v := range entry.Data {
-		data[k] = v
-	}
-	for k, v := range fields {
-		data[k] = v
-	}
-	return &Entry{Logger: entry.Logger, Data: data}
-}
-
-// This function is not declared with a pointer value because otherwise
-// race conditions will occur when using multiple goroutines
-func (entry Entry) log(level Level, msg string) {
-	var buffer *bytes.Buffer
-	entry.Time = time.Now()
-	entry.Level = level
-	entry.Message = msg
-
-	if err := entry.Logger.Hooks.Fire(level, &entry); err != nil {
-		entry.Logger.mu.Lock()
-		fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)
-		entry.Logger.mu.Unlock()
-	}
-	buffer = bufferPool.Get().(*bytes.Buffer)
-	buffer.Reset()
-	defer bufferPool.Put(buffer)
-	entry.Buffer = buffer
-	serialized, err := entry.Logger.Formatter.Format(&entry)
-	entry.Buffer = nil
-	if err != nil {
-		entry.Logger.mu.Lock()
-		fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
-		entry.Logger.mu.Unlock()
-	} else {
-		entry.Logger.mu.Lock()
-		_, err = entry.Logger.Out.Write(serialized)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
-		}
-		entry.Logger.mu.Unlock()
-	}
-
-	// To avoid Entry#log() returning a value that only would make sense for
-	// panic() to use in Entry#Panic(), we avoid the allocation by checking
-	// directly here.
-	if level <= PanicLevel {
-		panic(&entry)
-	}
-}
-
-func (entry *Entry) Debug(args ...interface{}) {
-	if entry.Logger.Level >= DebugLevel {
-		entry.log(DebugLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Print(args ...interface{}) {
-	entry.Info(args...)
-}
-
-func (entry *Entry) Info(args ...interface{}) {
-	if entry.Logger.Level >= InfoLevel {
-		entry.log(InfoLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Warn(args ...interface{}) {
-	if entry.Logger.Level >= WarnLevel {
-		entry.log(WarnLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Warning(args ...interface{}) {
-	entry.Warn(args...)
-}
-
-func (entry *Entry) Error(args ...interface{}) {
-	if entry.Logger.Level >= ErrorLevel {
-		entry.log(ErrorLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Fatal(args ...interface{}) {
-	if entry.Logger.Level >= FatalLevel {
-		entry.log(FatalLevel, fmt.Sprint(args...))
-	}
-	Exit(1)
-}
-
-func (entry *Entry) Panic(args ...interface{}) {
-	if entry.Logger.Level >= PanicLevel {
-		entry.log(PanicLevel, fmt.Sprint(args...))
-	}
-	panic(fmt.Sprint(args...))
-}
-
-// Entry Printf family functions
-
-func (entry *Entry) Debugf(format string, args ...interface{}) {
-	if entry.Logger.Level >= DebugLevel {
-		entry.Debug(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Infof(format string, args ...interface{}) {
-	if entry.Logger.Level >= InfoLevel {
-		entry.Info(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Printf(format string, args ...interface{}) {
-	entry.Infof(format, args...)
-}
-
-func (entry *Entry) Warnf(format string, args ...interface{}) {
-	if entry.Logger.Level >= WarnLevel {
-		entry.Warn(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Warningf(format string, args ...interface{}) {
-	entry.Warnf(format, args...)
-}
-
-func (entry *Entry) Errorf(format string, args ...interface{}) {
-	if entry.Logger.Level >= ErrorLevel {
-		entry.Error(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Fatalf(format string, args ...interface{}) {
-	if entry.Logger.Level >= FatalLevel {
-		entry.Fatal(fmt.Sprintf(format, args...))
-	}
-	Exit(1)
-}
-
-func (entry *Entry) Panicf(format string, args ...interface{}) {
-	if entry.Logger.Level >= PanicLevel {
-		entry.Panic(fmt.Sprintf(format, args...))
-	}
-}
-
-// Entry Println family functions
-
-func (entry *Entry) Debugln(args ...interface{}) {
-	if entry.Logger.Level >= DebugLevel {
-		entry.Debug(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Infoln(args ...interface{}) {
-	if entry.Logger.Level >= InfoLevel {
-		entry.Info(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Println(args ...interface{}) {
-	entry.Infoln(args...)
-}
-
-func (entry *Entry) Warnln(args ...interface{}) {
-	if entry.Logger.Level >= WarnLevel {
-		entry.Warn(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Warningln(args ...interface{}) {
-	entry.Warnln(args...)
-}
-
-func (entry *Entry) Errorln(args ...interface{}) {
-	if entry.Logger.Level >= ErrorLevel {
-		entry.Error(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Fatalln(args ...interface{}) {
-	if entry.Logger.Level >= FatalLevel {
-		entry.Fatal(entry.sprintlnn(args...))
-	}
-	Exit(1)
-}
-
-func (entry *Entry) Panicln(args ...interface{}) {
-	if entry.Logger.Level >= PanicLevel {
-		entry.Panic(entry.sprintlnn(args...))
-	}
-}
-
-// Sprintlnn => Sprint no newline. This is to get the behavior of how
-// fmt.Sprintln where spaces are always added between operands, regardless of
-// their type. Instead of vendoring the Sprintln implementation to spare a
-// string allocation, we do the simplest thing.
-func (entry *Entry) sprintlnn(args ...interface{}) string {
-	msg := fmt.Sprintln(args...)
-	return msg[:len(msg)-1]
-}

vendor/github.com/Sirupsen/logrus/entry_test.go

@@ -1,77 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestEntryWithError(t *testing.T) {
-
-	assert := assert.New(t)
-
-	defer func() {
-		ErrorKey = "error"
-	}()
-
-	err := fmt.Errorf("kaboom at layer %d", 4711)
-
-	assert.Equal(err, WithError(err).Data["error"])
-
-	logger := New()
-	logger.Out = &bytes.Buffer{}
-	entry := NewEntry(logger)
-
-	assert.Equal(err, entry.WithError(err).Data["error"])
-
-	ErrorKey = "err"
-
-	assert.Equal(err, entry.WithError(err).Data["err"])
-
-}
-
-func TestEntryPanicln(t *testing.T) {
-	errBoom := fmt.Errorf("boom time")
-
-	defer func() {
-		p := recover()
-		assert.NotNil(t, p)
-
-		switch pVal := p.(type) {
-		case *Entry:
-			assert.Equal(t, "kaboom", pVal.Message)
-			assert.Equal(t, errBoom, pVal.Data["err"])
-		default:
-			t.Fatalf("want type *Entry, got %T: %#v", pVal, pVal)
-		}
-	}()
-
-	logger := New()
-	logger.Out = &bytes.Buffer{}
-	entry := NewEntry(logger)
-	entry.WithField("err", errBoom).Panicln("kaboom")
-}
-
-func TestEntryPanicf(t *testing.T) {
-	errBoom := fmt.Errorf("boom again")
-
-	defer func() {
-		p := recover()
-		assert.NotNil(t, p)
-
-		switch pVal := p.(type) {
-		case *Entry:
-			assert.Equal(t, "kaboom true", pVal.Message)
-			assert.Equal(t, errBoom, pVal.Data["err"])
-		default:
-			t.Fatalf("want type *Entry, got %T: %#v", pVal, pVal)
-		}
-	}()
-
-	logger := New()
-	logger.Out = &bytes.Buffer{}
-	entry := NewEntry(logger)
-	entry.WithField("err", errBoom).Panicf("kaboom %v", true)
-}

vendor/github.com/Sirupsen/logrus/examples/basic/basic.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"github.com/Sirupsen/logrus"
-	// "os"
-)
-
-var log = logrus.New()
-
-func init() {
-	log.Formatter = new(logrus.JSONFormatter)
-	log.Formatter = new(logrus.TextFormatter) // default
-
-	// file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY, 0666)
-	// if err == nil {
-	// 	log.Out = file
-	// } else {
-	// 	log.Info("Failed to log to file, using default stderr")
-	// }
-
-	log.Level = logrus.DebugLevel
-}
-
-func main() {
-	defer func() {
-		err := recover()
-		if err != nil {
-			log.WithFields(logrus.Fields{
-				"omg":    true,
-				"err":    err,
-				"number": 100,
-			}).Fatal("The ice breaks!")
-		}
-	}()
-
-	log.WithFields(logrus.Fields{
-		"animal": "walrus",
-		"number": 8,
-	}).Debug("Started observing beach")
-
-	log.WithFields(logrus.Fields{
-		"animal": "walrus",
-		"size":   10,
-	}).Info("A group of walrus emerges from the ocean")
-
-	log.WithFields(logrus.Fields{
-		"omg":    true,
-		"number": 122,
-	}).Warn("The group's number increased tremendously!")
-
-	log.WithFields(logrus.Fields{
-		"temperature": -4,
-	}).Debug("Temperature changes")
-
-	log.WithFields(logrus.Fields{
-		"animal": "orca",
-		"size":   9009,
-	}).Panic("It's over 9000!")
-}

vendor/github.com/Sirupsen/logrus/examples/hook/hook.go

@@ -1,30 +0,0 @@
-package main
-
-import (
-	"github.com/Sirupsen/logrus"
-	"gopkg.in/gemnasium/logrus-airbrake-hook.v2"
-)
-
-var log = logrus.New()
-
-func init() {
-	log.Formatter = new(logrus.TextFormatter) // default
-	log.Hooks.Add(airbrake.NewHook(123, "xyz", "development"))
-}
-
-func main() {
-	log.WithFields(logrus.Fields{
-		"animal": "walrus",
-		"size":   10,
-	}).Info("A group of walrus emerges from the ocean")
-
-	log.WithFields(logrus.Fields{
-		"omg":    true,
-		"number": 122,
-	}).Warn("The group's number increased tremendously!")
-
-	log.WithFields(logrus.Fields{
-		"omg":    true,
-		"number": 100,
-	}).Fatal("The ice breaks!")
-}

vendor/github.com/Sirupsen/logrus/exported.go

@@ -1,193 +0,0 @@
-package logrus
-
-import (
-	"io"
-)
-
-var (
-	// std is the name of the standard logger in stdlib `log`
-	std = New()
-)
-
-func StandardLogger() *Logger {
-	return std
-}
-
-// SetOutput sets the standard logger output.
-func SetOutput(out io.Writer) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Out = out
-}
-
-// SetFormatter sets the standard logger formatter.
-func SetFormatter(formatter Formatter) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Formatter = formatter
-}
-
-// SetLevel sets the standard logger level.
-func SetLevel(level Level) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Level = level
-}
-
-// GetLevel returns the standard logger level.
-func GetLevel() Level {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	return std.Level
-}
-
-// AddHook adds a hook to the standard logger hooks.
-func AddHook(hook Hook) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Hooks.Add(hook)
-}
-
-// WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key.
-func WithError(err error) *Entry {
-	return std.WithField(ErrorKey, err)
-}
-
-// WithField creates an entry from the standard logger and adds a field to
-// it. If you want multiple fields, use `WithFields`.
-//
-// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
-// or Panic on the Entry it returns.
-func WithField(key string, value interface{}) *Entry {
-	return std.WithField(key, value)
-}
-
-// WithFields creates an entry from the standard logger and adds multiple
-// fields to it. This is simply a helper for `WithField`, invoking it
-// once for each field.
-//
-// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
-// or Panic on the Entry it returns.
-func WithFields(fields Fields) *Entry {
-	return std.WithFields(fields)
-}
-
-// Debug logs a message at level Debug on the standard logger.
-func Debug(args ...interface{}) {
-	std.Debug(args...)
-}
-
-// Print logs a message at level Info on the standard logger.
-func Print(args ...interface{}) {
-	std.Print(args...)
-}
-
-// Info logs a message at level Info on the standard logger.
-func Info(args ...interface{}) {
-	std.Info(args...)
-}
-
-// Warn logs a message at level Warn on the standard logger.
-func Warn(args ...interface{}) {
-	std.Warn(args...)
-}
-
-// Warning logs a message at level Warn on the standard logger.
-func Warning(args ...interface{}) {
-	std.Warning(args...)
-}
-
-// Error logs a message at level Error on the standard logger.
-func Error(args ...interface{}) {
-	std.Error(args...)
-}
-
-// Panic logs a message at level Panic on the standard logger.
-func Panic(args ...interface{}) {
-	std.Panic(args...)
-}
-
-// Fatal logs a message at level Fatal on the standard logger.
-func Fatal(args ...interface{}) {
-	std.Fatal(args...)
-}
-
-// Debugf logs a message at level Debug on the standard logger.
-func Debugf(format string, args ...interface{}) {
-	std.Debugf(format, args...)
-}
-
-// Printf logs a message at level Info on the standard logger.
-func Printf(format string, args ...interface{}) {
-	std.Printf(format, args...)
-}
-
-// Infof logs a message at level Info on the standard logger.
-func Infof(format string, args ...interface{}) {
-	std.Infof(format, args...)
-}
-
-// Warnf logs a message at level Warn on the standard logger.
-func Warnf(format string, args ...interface{}) {
-	std.Warnf(format, args...)
-}
-
-// Warningf logs a message at level Warn on the standard logger.
-func Warningf(format string, args ...interface{}) {
-	std.Warningf(format, args...)
-}
-
-// Errorf logs a message at level Error on the standard logger.
-func Errorf(format string, args ...interface{}) {
-	std.Errorf(format, args...)
-}
-
-// Panicf logs a message at level Panic on the standard logger.
-func Panicf(format string, args ...interface{}) {
-	std.Panicf(format, args...)
-}
-
-// Fatalf logs a message at level Fatal on the standard logger.
-func Fatalf(format string, args ...interface{}) {
-	std.Fatalf(format, args...)
-}
-
-// Debugln logs a message at level Debug on the standard logger.
-func Debugln(args ...interface{}) {
-	std.Debugln(args...)
-}
-
-// Println logs a message at level Info on the standard logger.
-func Println(args ...interface{}) {
-	std.Println(args...)
-}
-
-// Infoln logs a message at level Info on the standard logger.
-func Infoln(args ...interface{}) {
-	std.Infoln(args...)
-}
-
-// Warnln logs a message at level Warn on the standard logger.
-func Warnln(args ...interface{}) {
-	std.Warnln(args...)
-}
-
-// Warningln logs a message at level Warn on the standard logger.
-func Warningln(args ...interface{}) {
-	std.Warningln(args...)
-}
-
-// Errorln logs a message at level Error on the standard logger.
-func Errorln(args ...interface{}) {
-	std.Errorln(args...)
-}
-
-// Panicln logs a message at level Panic on the standard logger.
-func Panicln(args ...interface{}) {
-	std.Panicln(args...)
-}
-
-// Fatalln logs a message at level Fatal on the standard logger.
-func Fatalln(args ...interface{}) {
-	std.Fatalln(args...)
-}

vendor/github.com/Sirupsen/logrus/formatter.go

@@ -1,45 +0,0 @@
-package logrus
-
-import "time"
-
-const DefaultTimestampFormat = time.RFC3339
-
-// The Formatter interface is used to implement a custom Formatter. It takes an
-// `Entry`. It exposes all the fields, including the default ones:
-//
-// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
-// * `entry.Data["time"]`. The timestamp.
-// * `entry.Data["level"]. The level the entry was logged at.
-//
-// Any additional fields added with `WithField` or `WithFields` are also in
-// `entry.Data`. Format is expected to return an array of bytes which are then
-// logged to `logger.Out`.
-type Formatter interface {
-	Format(*Entry) ([]byte, error)
-}
-
-// This is to not silently overwrite `time`, `msg` and `level` fields when
-// dumping it. If this code wasn't there doing:
-//
-//  logrus.WithField("level", 1).Info("hello")
-//
-// Would just silently drop the user provided level. Instead with this code
-// it'll logged as:
-//
-//  {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
-//
-// It's not exported because it's still using Data in an opinionated way. It's to
-// avoid code duplication between the two default formatters.
-func prefixFieldClashes(data Fields) {
-	if t, ok := data["time"]; ok {
-		data["fields.time"] = t
-	}
-
-	if m, ok := data["msg"]; ok {
-		data["fields.msg"] = m
-	}
-
-	if l, ok := data["level"]; ok {
-		data["fields.level"] = l
-	}
-}

vendor/github.com/Sirupsen/logrus/formatter_bench_test.go

@@ -1,101 +0,0 @@
-package logrus
-
-import (
-	"fmt"
-	"testing"
-	"time"
-)
-
-// smallFields is a small size data set for benchmarking
-var smallFields = Fields{
-	"foo":   "bar",
-	"baz":   "qux",
-	"one":   "two",
-	"three": "four",
-}
-
-// largeFields is a large size data set for benchmarking
-var largeFields = Fields{
-	"foo":       "bar",
-	"baz":       "qux",
-	"one":       "two",
-	"three":     "four",
-	"five":      "six",
-	"seven":     "eight",
-	"nine":      "ten",
-	"eleven":    "twelve",
-	"thirteen":  "fourteen",
-	"fifteen":   "sixteen",
-	"seventeen": "eighteen",
-	"nineteen":  "twenty",
-	"a":         "b",
-	"c":         "d",
-	"e":         "f",
-	"g":         "h",
-	"i":         "j",
-	"k":         "l",
-	"m":         "n",
-	"o":         "p",
-	"q":         "r",
-	"s":         "t",
-	"u":         "v",
-	"w":         "x",
-	"y":         "z",
-	"this":      "will",
-	"make":      "thirty",
-	"entries":   "yeah",
-}
-
-var errorFields = Fields{
-	"foo": fmt.Errorf("bar"),
-	"baz": fmt.Errorf("qux"),
-}
-
-func BenchmarkErrorTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{DisableColors: true}, errorFields)
-}
-
-func BenchmarkSmallTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{DisableColors: true}, smallFields)
-}
-
-func BenchmarkLargeTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{DisableColors: true}, largeFields)
-}
-
-func BenchmarkSmallColoredTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{ForceColors: true}, smallFields)
-}
-
-func BenchmarkLargeColoredTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{ForceColors: true}, largeFields)
-}
-
-func BenchmarkSmallJSONFormatter(b *testing.B) {
-	doBenchmark(b, &JSONFormatter{}, smallFields)
-}
-
-func BenchmarkLargeJSONFormatter(b *testing.B) {
-	doBenchmark(b, &JSONFormatter{}, largeFields)
-}
-
-func doBenchmark(b *testing.B, formatter Formatter, fields Fields) {
-	logger := New()
-
-	entry := &Entry{
-		Time:    time.Time{},
-		Level:   InfoLevel,
-		Message: "message",
-		Data:    fields,
-		Logger:  logger,
-	}
-	var d []byte
-	var err error
-	for i := 0; i < b.N; i++ {
-		d, err = formatter.Format(entry)
-		if err != nil {
-			b.Fatal(err)
-		}
-		b.SetBytes(int64(len(d)))
-	}
-}

vendor/github.com/Sirupsen/logrus/hook_test.go

@@ -1,122 +0,0 @@
-package logrus
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-type TestHook struct {
-	Fired bool
-}
-
-func (hook *TestHook) Fire(entry *Entry) error {
-	hook.Fired = true
-	return nil
-}
-
-func (hook *TestHook) Levels() []Level {
-	return []Level{
-		DebugLevel,
-		InfoLevel,
-		WarnLevel,
-		ErrorLevel,
-		FatalLevel,
-		PanicLevel,
-	}
-}
-
-func TestHookFires(t *testing.T) {
-	hook := new(TestHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook)
-		assert.Equal(t, hook.Fired, false)
-
-		log.Print("test")
-	}, func(fields Fields) {
-		assert.Equal(t, hook.Fired, true)
-	})
-}
-
-type ModifyHook struct {
-}
-
-func (hook *ModifyHook) Fire(entry *Entry) error {
-	entry.Data["wow"] = "whale"
-	return nil
-}
-
-func (hook *ModifyHook) Levels() []Level {
-	return []Level{
-		DebugLevel,
-		InfoLevel,
-		WarnLevel,
-		ErrorLevel,
-		FatalLevel,
-		PanicLevel,
-	}
-}
-
-func TestHookCanModifyEntry(t *testing.T) {
-	hook := new(ModifyHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook)
-		log.WithField("wow", "elephant").Print("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["wow"], "whale")
-	})
-}
-
-func TestCanFireMultipleHooks(t *testing.T) {
-	hook1 := new(ModifyHook)
-	hook2 := new(TestHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook1)
-		log.Hooks.Add(hook2)
-
-		log.WithField("wow", "elephant").Print("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["wow"], "whale")
-		assert.Equal(t, hook2.Fired, true)
-	})
-}
-
-type ErrorHook struct {
-	Fired bool
-}
-
-func (hook *ErrorHook) Fire(entry *Entry) error {
-	hook.Fired = true
-	return nil
-}
-
-func (hook *ErrorHook) Levels() []Level {
-	return []Level{
-		ErrorLevel,
-	}
-}
-
-func TestErrorHookShouldntFireOnInfo(t *testing.T) {
-	hook := new(ErrorHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook)
-		log.Info("test")
-	}, func(fields Fields) {
-		assert.Equal(t, hook.Fired, false)
-	})
-}
-
-func TestErrorHookShouldFireOnError(t *testing.T) {
-	hook := new(ErrorHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook)
-		log.Error("test")
-	}, func(fields Fields) {
-		assert.Equal(t, hook.Fired, true)
-	})
-}

vendor/github.com/Sirupsen/logrus/hooks.go

@@ -1,34 +0,0 @@
-package logrus
-
-// A hook to be fired when logging on the logging levels returned from
-// `Levels()` on your implementation of the interface. Note that this is not
-// fired in a goroutine or a channel with workers, you should handle such
-// functionality yourself if your call is non-blocking and you don't wish for
-// the logging calls for levels returned from `Levels()` to block.
-type Hook interface {
-	Levels() []Level
-	Fire(*Entry) error
-}
-
-// Internal type for storing the hooks on a logger instance.
-type LevelHooks map[Level][]Hook
-
-// Add a hook to an instance of logger. This is called with
-// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.
-func (hooks LevelHooks) Add(hook Hook) {
-	for _, level := range hook.Levels() {
-		hooks[level] = append(hooks[level], hook)
-	}
-}
-
-// Fire all the hooks for the passed level. Used by `entry.log` to fire
-// appropriate hooks for a log entry.
-func (hooks LevelHooks) Fire(level Level, entry *Entry) error {
-	for _, hook := range hooks[level] {
-		if err := hook.Fire(entry); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

vendor/github.com/Sirupsen/logrus/hooks/syslog/README.md

@@ -1,39 +0,0 @@
-# Syslog Hooks for Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>
-
-## Usage
-
-```go
-import (
-  "log/syslog"
-  "github.com/Sirupsen/logrus"
-  logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
-)
-
-func main() {
-  log       := logrus.New()
-  hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
-
-  if err == nil {
-    log.Hooks.Add(hook)
-  }
-}
-```
-
-If you want to connect to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). Just assign empty string to the first two parameters of `NewSyslogHook`. It should look like the following.
-
-```go
-import (
-  "log/syslog"
-  "github.com/Sirupsen/logrus"
-  logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
-)
-
-func main() {
-  log       := logrus.New()
-  hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_INFO, "")
-
-  if err == nil {
-    log.Hooks.Add(hook)
-  }
-}
-```

vendor/github.com/Sirupsen/logrus/hooks/syslog/syslog.go

@@ -1,54 +0,0 @@
-// +build !windows,!nacl,!plan9
-
-package logrus_syslog
-
-import (
-	"fmt"
-	"github.com/Sirupsen/logrus"
-	"log/syslog"
-	"os"
-)
-
-// SyslogHook to send logs via syslog.
-type SyslogHook struct {
-	Writer        *syslog.Writer
-	SyslogNetwork string
-	SyslogRaddr   string
-}
-
-// Creates a hook to be added to an instance of logger. This is called with
-// `hook, err := NewSyslogHook("udp", "localhost:514", syslog.LOG_DEBUG, "")`
-// `if err == nil { log.Hooks.Add(hook) }`
-func NewSyslogHook(network, raddr string, priority syslog.Priority, tag string) (*SyslogHook, error) {
-	w, err := syslog.Dial(network, raddr, priority, tag)
-	return &SyslogHook{w, network, raddr}, err
-}
-
-func (hook *SyslogHook) Fire(entry *logrus.Entry) error {
-	line, err := entry.String()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Unable to read entry, %v", err)
-		return err
-	}
-
-	switch entry.Level {
-	case logrus.PanicLevel:
-		return hook.Writer.Crit(line)
-	case logrus.FatalLevel:
-		return hook.Writer.Crit(line)
-	case logrus.ErrorLevel:
-		return hook.Writer.Err(line)
-	case logrus.WarnLevel:
-		return hook.Writer.Warning(line)
-	case logrus.InfoLevel:
-		return hook.Writer.Info(line)
-	case logrus.DebugLevel:
-		return hook.Writer.Debug(line)
-	default:
-		return nil
-	}
-}
-
-func (hook *SyslogHook) Levels() []logrus.Level {
-	return logrus.AllLevels
-}

vendor/github.com/Sirupsen/logrus/hooks/syslog/syslog_test.go

@@ -1,26 +0,0 @@
-package logrus_syslog
-
-import (
-	"github.com/Sirupsen/logrus"
-	"log/syslog"
-	"testing"
-)
-
-func TestLocalhostAddAndPrint(t *testing.T) {
-	log := logrus.New()
-	hook, err := NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
-
-	if err != nil {
-		t.Errorf("Unable to connect to local syslog.")
-	}
-
-	log.Hooks.Add(hook)
-
-	for _, level := range hook.Levels() {
-		if len(log.Hooks[level]) != 1 {
-			t.Errorf("SyslogHook was not added. The length of log.Hooks[%v]: %v", level, len(log.Hooks[level]))
-		}
-	}
-
-	log.Info("Congratulations!")
-}

vendor/github.com/Sirupsen/logrus/hooks/test/test.go

@@ -1,67 +0,0 @@
-package test
-
-import (
-	"io/ioutil"
-
-	"github.com/Sirupsen/logrus"
-)
-
-// test.Hook is a hook designed for dealing with logs in test scenarios.
-type Hook struct {
-	Entries []*logrus.Entry
-}
-
-// Installs a test hook for the global logger.
-func NewGlobal() *Hook {
-
-	hook := new(Hook)
-	logrus.AddHook(hook)
-
-	return hook
-
-}
-
-// Installs a test hook for a given local logger.
-func NewLocal(logger *logrus.Logger) *Hook {
-
-	hook := new(Hook)
-	logger.Hooks.Add(hook)
-
-	return hook
-
-}
-
-// Creates a discarding logger and installs the test hook.
-func NewNullLogger() (*logrus.Logger, *Hook) {
-
-	logger := logrus.New()
-	logger.Out = ioutil.Discard
-
-	return logger, NewLocal(logger)
-
-}
-
-func (t *Hook) Fire(e *logrus.Entry) error {
-	t.Entries = append(t.Entries, e)
-	return nil
-}
-
-func (t *Hook) Levels() []logrus.Level {
-	return logrus.AllLevels
-}
-
-// LastEntry returns the last entry that was logged or nil.
-func (t *Hook) LastEntry() (l *logrus.Entry) {
-
-	if i := len(t.Entries) - 1; i < 0 {
-		return nil
-	} else {
-		return t.Entries[i]
-	}
-
-}
-
-// Reset removes all Entries from this test hook.
-func (t *Hook) Reset() {
-	t.Entries = make([]*logrus.Entry, 0)
-}

vendor/github.com/Sirupsen/logrus/hooks/test/test_test.go

@@ -1,39 +0,0 @@
-package test
-
-import (
-	"testing"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAllHooks(t *testing.T) {
-
-	assert := assert.New(t)
-
-	logger, hook := NewNullLogger()
-	assert.Nil(hook.LastEntry())
-	assert.Equal(0, len(hook.Entries))
-
-	logger.Error("Hello error")
-	assert.Equal(logrus.ErrorLevel, hook.LastEntry().Level)
-	assert.Equal("Hello error", hook.LastEntry().Message)
-	assert.Equal(1, len(hook.Entries))
-
-	logger.Warn("Hello warning")
-	assert.Equal(logrus.WarnLevel, hook.LastEntry().Level)
-	assert.Equal("Hello warning", hook.LastEntry().Message)
-	assert.Equal(2, len(hook.Entries))
-
-	hook.Reset()
-	assert.Nil(hook.LastEntry())
-	assert.Equal(0, len(hook.Entries))
-
-	hook = NewGlobal()
-
-	logrus.Error("Hello error")
-	assert.Equal(logrus.ErrorLevel, hook.LastEntry().Level)
-	assert.Equal("Hello error", hook.LastEntry().Message)
-	assert.Equal(1, len(hook.Entries))
-
-}

vendor/github.com/Sirupsen/logrus/json_formatter.go

@@ -1,74 +0,0 @@
-package logrus
-
-import (
-	"encoding/json"
-	"fmt"
-)
-
-type fieldKey string
-type FieldMap map[fieldKey]string
-
-const (
-	FieldKeyMsg   = "msg"
-	FieldKeyLevel = "level"
-	FieldKeyTime  = "time"
-)
-
-func (f FieldMap) resolve(key fieldKey) string {
-	if k, ok := f[key]; ok {
-		return k
-	}
-
-	return string(key)
-}
-
-type JSONFormatter struct {
-	// TimestampFormat sets the format used for marshaling timestamps.
-	TimestampFormat string
-
-	// DisableTimestamp allows disabling automatic timestamps in output
-	DisableTimestamp bool
-
-	// FieldMap allows users to customize the names of keys for various fields.
-	// As an example:
-	// formatter := &JSONFormatter{
-	//   	FieldMap: FieldMap{
-	// 		 FieldKeyTime: "@timestamp",
-	// 		 FieldKeyLevel: "@level",
-	// 		 FieldKeyLevel: "@message",
-	//    },
-	// }
-	FieldMap FieldMap
-}
-
-func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
-	data := make(Fields, len(entry.Data)+3)
-	for k, v := range entry.Data {
-		switch v := v.(type) {
-		case error:
-			// Otherwise errors are ignored by `encoding/json`
-			// https://github.com/Sirupsen/logrus/issues/137
-			data[k] = v.Error()
-		default:
-			data[k] = v
-		}
-	}
-	prefixFieldClashes(data)
-
-	timestampFormat := f.TimestampFormat
-	if timestampFormat == "" {
-		timestampFormat = DefaultTimestampFormat
-	}
-
-	if !f.DisableTimestamp {
-		data[f.FieldMap.resolve(FieldKeyTime)] = entry.Time.Format(timestampFormat)
-	}
-	data[f.FieldMap.resolve(FieldKeyMsg)] = entry.Message
-	data[f.FieldMap.resolve(FieldKeyLevel)] = entry.Level.String()
-
-	serialized, err := json.Marshal(data)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
-	}
-	return append(serialized, '\n'), nil
-}

vendor/github.com/Sirupsen/logrus/json_formatter_test.go

@@ -1,199 +0,0 @@
-package logrus
-
-import (
-	"encoding/json"
-	"errors"
-	"strings"
-	"testing"
-)
-
-func TestErrorNotLost(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("error", errors.New("wild walrus")))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["error"] != "wild walrus" {
-		t.Fatal("Error field not set")
-	}
-}
-
-func TestErrorNotLostOnFieldNotNamedError(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("omg", errors.New("wild walrus")))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["omg"] != "wild walrus" {
-		t.Fatal("Error field not set")
-	}
-}
-
-func TestFieldClashWithTime(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("time", "right now!"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["fields.time"] != "right now!" {
-		t.Fatal("fields.time not set to original time field")
-	}
-
-	if entry["time"] != "0001-01-01T00:00:00Z" {
-		t.Fatal("time field not set to current time, was: ", entry["time"])
-	}
-}
-
-func TestFieldClashWithMsg(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("msg", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["fields.msg"] != "something" {
-		t.Fatal("fields.msg not set to original msg field")
-	}
-}
-
-func TestFieldClashWithLevel(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["fields.level"] != "something" {
-		t.Fatal("fields.level not set to original level field")
-	}
-}
-
-func TestJSONEntryEndsWithNewline(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	if b[len(b)-1] != '\n' {
-		t.Fatal("Expected JSON log entry to end with a newline")
-	}
-}
-
-func TestJSONMessageKey(t *testing.T) {
-	formatter := &JSONFormatter{
-		FieldMap: FieldMap{
-			FieldKeyMsg: "message",
-		},
-	}
-
-	b, err := formatter.Format(&Entry{Message: "oh hai"})
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if !(strings.Contains(s, "message") && strings.Contains(s, "oh hai")) {
-		t.Fatal("Expected JSON to format message key")
-	}
-}
-
-func TestJSONLevelKey(t *testing.T) {
-	formatter := &JSONFormatter{
-		FieldMap: FieldMap{
-			FieldKeyLevel: "somelevel",
-		},
-	}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if !strings.Contains(s, "somelevel") {
-		t.Fatal("Expected JSON to format level key")
-	}
-}
-
-func TestJSONTimeKey(t *testing.T) {
-	formatter := &JSONFormatter{
-		FieldMap: FieldMap{
-			FieldKeyTime: "timeywimey",
-		},
-	}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if !strings.Contains(s, "timeywimey") {
-		t.Fatal("Expected JSON to format time key")
-	}
-}
-
-func TestJSONDisableTimestamp(t *testing.T) {
-	formatter := &JSONFormatter{
-		DisableTimestamp: true,
-	}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if strings.Contains(s, FieldKeyTime) {
-		t.Error("Did not prevent timestamp", s)
-	}
-}
-
-func TestJSONEnableTimestamp(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if !strings.Contains(s, FieldKeyTime) {
-		t.Error("Timestamp not present", s)
-	}
-}

vendor/github.com/Sirupsen/logrus/logger.go

@@ -1,308 +0,0 @@
-package logrus
-
-import (
-	"io"
-	"os"
-	"sync"
-)
-
-type Logger struct {
-	// The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
-	// file, or leave it default which is `os.Stderr`. You can also set this to
-	// something more adventorous, such as logging to Kafka.
-	Out io.Writer
-	// Hooks for the logger instance. These allow firing events based on logging
-	// levels and log entries. For example, to send errors to an error tracking
-	// service, log to StatsD or dump the core on fatal errors.
-	Hooks LevelHooks
-	// All log entries pass through the formatter before logged to Out. The
-	// included formatters are `TextFormatter` and `JSONFormatter` for which
-	// TextFormatter is the default. In development (when a TTY is attached) it
-	// logs with colors, but to a file it wouldn't. You can easily implement your
-	// own that implements the `Formatter` interface, see the `README` or included
-	// formatters for examples.
-	Formatter Formatter
-	// The logging level the logger should log at. This is typically (and defaults
-	// to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
-	// logged. `logrus.Debug` is useful in
-	Level Level
-	// Used to sync writing to the log. Locking is enabled by Default
-	mu MutexWrap
-	// Reusable empty entry
-	entryPool sync.Pool
-}
-
-type MutexWrap struct {
-	lock     sync.Mutex
-	disabled bool
-}
-
-func (mw *MutexWrap) Lock() {
-	if !mw.disabled {
-		mw.lock.Lock()
-	}
-}
-
-func (mw *MutexWrap) Unlock() {
-	if !mw.disabled {
-		mw.lock.Unlock()
-	}
-}
-
-func (mw *MutexWrap) Disable() {
-	mw.disabled = true
-}
-
-// Creates a new logger. Configuration should be set by changing `Formatter`,
-// `Out` and `Hooks` directly on the default logger instance. You can also just
-// instantiate your own:
-//
-//    var log = &Logger{
-//      Out: os.Stderr,
-//      Formatter: new(JSONFormatter),
-//      Hooks: make(LevelHooks),
-//      Level: logrus.DebugLevel,
-//    }
-//
-// It's recommended to make this a global instance called `log`.
-func New() *Logger {
-	return &Logger{
-		Out:       os.Stderr,
-		Formatter: new(TextFormatter),
-		Hooks:     make(LevelHooks),
-		Level:     InfoLevel,
-	}
-}
-
-func (logger *Logger) newEntry() *Entry {
-	entry, ok := logger.entryPool.Get().(*Entry)
-	if ok {
-		return entry
-	}
-	return NewEntry(logger)
-}
-
-func (logger *Logger) releaseEntry(entry *Entry) {
-	logger.entryPool.Put(entry)
-}
-
-// Adds a field to the log entry, note that it doesn't log until you call
-// Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry.
-// If you want multiple fields, use `WithFields`.
-func (logger *Logger) WithField(key string, value interface{}) *Entry {
-	entry := logger.newEntry()
-	defer logger.releaseEntry(entry)
-	return entry.WithField(key, value)
-}
-
-// Adds a struct of fields to the log entry. All it does is call `WithField` for
-// each `Field`.
-func (logger *Logger) WithFields(fields Fields) *Entry {
-	entry := logger.newEntry()
-	defer logger.releaseEntry(entry)
-	return entry.WithFields(fields)
-}
-
-// Add an error as single field to the log entry.  All it does is call
-// `WithError` for the given `error`.
-func (logger *Logger) WithError(err error) *Entry {
-	entry := logger.newEntry()
-	defer logger.releaseEntry(entry)
-	return entry.WithError(err)
-}
-
-func (logger *Logger) Debugf(format string, args ...interface{}) {
-	if logger.Level >= DebugLevel {
-		entry := logger.newEntry()
-		entry.Debugf(format, args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Infof(format string, args ...interface{}) {
-	if logger.Level >= InfoLevel {
-		entry := logger.newEntry()
-		entry.Infof(format, args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Printf(format string, args ...interface{}) {
-	entry := logger.newEntry()
-	entry.Printf(format, args...)
-	logger.releaseEntry(entry)
-}
-
-func (logger *Logger) Warnf(format string, args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		entry := logger.newEntry()
-		entry.Warnf(format, args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Warningf(format string, args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		entry := logger.newEntry()
-		entry.Warnf(format, args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Errorf(format string, args ...interface{}) {
-	if logger.Level >= ErrorLevel {
-		entry := logger.newEntry()
-		entry.Errorf(format, args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Fatalf(format string, args ...interface{}) {
-	if logger.Level >= FatalLevel {
-		entry := logger.newEntry()
-		entry.Fatalf(format, args...)
-		logger.releaseEntry(entry)
-	}
-	Exit(1)
-}
-
-func (logger *Logger) Panicf(format string, args ...interface{}) {
-	if logger.Level >= PanicLevel {
-		entry := logger.newEntry()
-		entry.Panicf(format, args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Debug(args ...interface{}) {
-	if logger.Level >= DebugLevel {
-		entry := logger.newEntry()
-		entry.Debug(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Info(args ...interface{}) {
-	if logger.Level >= InfoLevel {
-		entry := logger.newEntry()
-		entry.Info(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Print(args ...interface{}) {
-	entry := logger.newEntry()
-	entry.Info(args...)
-	logger.releaseEntry(entry)
-}
-
-func (logger *Logger) Warn(args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		entry := logger.newEntry()
-		entry.Warn(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Warning(args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		entry := logger.newEntry()
-		entry.Warn(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Error(args ...interface{}) {
-	if logger.Level >= ErrorLevel {
-		entry := logger.newEntry()
-		entry.Error(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Fatal(args ...interface{}) {
-	if logger.Level >= FatalLevel {
-		entry := logger.newEntry()
-		entry.Fatal(args...)
-		logger.releaseEntry(entry)
-	}
-	Exit(1)
-}
-
-func (logger *Logger) Panic(args ...interface{}) {
-	if logger.Level >= PanicLevel {
-		entry := logger.newEntry()
-		entry.Panic(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Debugln(args ...interface{}) {
-	if logger.Level >= DebugLevel {
-		entry := logger.newEntry()
-		entry.Debugln(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Infoln(args ...interface{}) {
-	if logger.Level >= InfoLevel {
-		entry := logger.newEntry()
-		entry.Infoln(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Println(args ...interface{}) {
-	entry := logger.newEntry()
-	entry.Println(args...)
-	logger.releaseEntry(entry)
-}
-
-func (logger *Logger) Warnln(args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		entry := logger.newEntry()
-		entry.Warnln(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Warningln(args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		entry := logger.newEntry()
-		entry.Warnln(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Errorln(args ...interface{}) {
-	if logger.Level >= ErrorLevel {
-		entry := logger.newEntry()
-		entry.Errorln(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-func (logger *Logger) Fatalln(args ...interface{}) {
-	if logger.Level >= FatalLevel {
-		entry := logger.newEntry()
-		entry.Fatalln(args...)
-		logger.releaseEntry(entry)
-	}
-	Exit(1)
-}
-
-func (logger *Logger) Panicln(args ...interface{}) {
-	if logger.Level >= PanicLevel {
-		entry := logger.newEntry()
-		entry.Panicln(args...)
-		logger.releaseEntry(entry)
-	}
-}
-
-//When file is opened with appending mode, it's safe to
-//write concurrently to a file (within 4k message on Linux).
-//In these cases user can choose to disable the lock.
-func (logger *Logger) SetNoLock() {
-	logger.mu.Disable()
-}

vendor/github.com/Sirupsen/logrus/logger_bench_test.go

@@ -1,61 +0,0 @@
-package logrus
-
-import (
-	"os"
-	"testing"
-)
-
-// smallFields is a small size data set for benchmarking
-var loggerFields = Fields{
-	"foo":   "bar",
-	"baz":   "qux",
-	"one":   "two",
-	"three": "four",
-}
-
-func BenchmarkDummyLogger(b *testing.B) {
-	nullf, err := os.OpenFile("/dev/null", os.O_WRONLY, 0666)
-	if err != nil {
-		b.Fatalf("%v", err)
-	}
-	defer nullf.Close()
-	doLoggerBenchmark(b, nullf, &TextFormatter{DisableColors: true}, smallFields)
-}
-
-func BenchmarkDummyLoggerNoLock(b *testing.B) {
-	nullf, err := os.OpenFile("/dev/null", os.O_WRONLY|os.O_APPEND, 0666)
-	if err != nil {
-		b.Fatalf("%v", err)
-	}
-	defer nullf.Close()
-	doLoggerBenchmarkNoLock(b, nullf, &TextFormatter{DisableColors: true}, smallFields)
-}
-
-func doLoggerBenchmark(b *testing.B, out *os.File, formatter Formatter, fields Fields) {
-	logger := Logger{
-		Out:       out,
-		Level:     InfoLevel,
-		Formatter: formatter,
-	}
-	entry := logger.WithFields(fields)
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			entry.Info("aaa")
-		}
-	})
-}
-
-func doLoggerBenchmarkNoLock(b *testing.B, out *os.File, formatter Formatter, fields Fields) {
-	logger := Logger{
-		Out:       out,
-		Level:     InfoLevel,
-		Formatter: formatter,
-	}
-	logger.SetNoLock()
-	entry := logger.WithFields(fields)
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			entry.Info("aaa")
-		}
-	})
-}

vendor/github.com/Sirupsen/logrus/logrus.go

@@ -1,143 +0,0 @@
-package logrus
-
-import (
-	"fmt"
-	"log"
-	"strings"
-)
-
-// Fields type, used to pass to `WithFields`.
-type Fields map[string]interface{}
-
-// Level type
-type Level uint8
-
-// Convert the Level to a string. E.g. PanicLevel becomes "panic".
-func (level Level) String() string {
-	switch level {
-	case DebugLevel:
-		return "debug"
-	case InfoLevel:
-		return "info"
-	case WarnLevel:
-		return "warning"
-	case ErrorLevel:
-		return "error"
-	case FatalLevel:
-		return "fatal"
-	case PanicLevel:
-		return "panic"
-	}
-
-	return "unknown"
-}
-
-// ParseLevel takes a string level and returns the Logrus log level constant.
-func ParseLevel(lvl string) (Level, error) {
-	switch strings.ToLower(lvl) {
-	case "panic":
-		return PanicLevel, nil
-	case "fatal":
-		return FatalLevel, nil
-	case "error":
-		return ErrorLevel, nil
-	case "warn", "warning":
-		return WarnLevel, nil
-	case "info":
-		return InfoLevel, nil
-	case "debug":
-		return DebugLevel, nil
-	}
-
-	var l Level
-	return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
-}
-
-// A constant exposing all logging levels
-var AllLevels = []Level{
-	PanicLevel,
-	FatalLevel,
-	ErrorLevel,
-	WarnLevel,
-	InfoLevel,
-	DebugLevel,
-}
-
-// These are the different logging levels. You can set the logging level to log
-// on your instance of logger, obtained with `logrus.New()`.
-const (
-	// PanicLevel level, highest level of severity. Logs and then calls panic with the
-	// message passed to Debug, Info, ...
-	PanicLevel Level = iota
-	// FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the
-	// logging level is set to Panic.
-	FatalLevel
-	// ErrorLevel level. Logs. Used for errors that should definitely be noted.
-	// Commonly used for hooks to send errors to an error tracking service.
-	ErrorLevel
-	// WarnLevel level. Non-critical entries that deserve eyes.
-	WarnLevel
-	// InfoLevel level. General operational entries about what's going on inside the
-	// application.
-	InfoLevel
-	// DebugLevel level. Usually only enabled when debugging. Very verbose logging.
-	DebugLevel
-)
-
-// Won't compile if StdLogger can't be realized by a log.Logger
-var (
-	_ StdLogger = &log.Logger{}
-	_ StdLogger = &Entry{}
-	_ StdLogger = &Logger{}
-)
-
-// StdLogger is what your logrus-enabled library should take, that way
-// it'll accept a stdlib logger and a logrus logger. There's no standard
-// interface, this is the closest we get, unfortunately.
-type StdLogger interface {
-	Print(...interface{})
-	Printf(string, ...interface{})
-	Println(...interface{})
-
-	Fatal(...interface{})
-	Fatalf(string, ...interface{})
-	Fatalln(...interface{})
-
-	Panic(...interface{})
-	Panicf(string, ...interface{})
-	Panicln(...interface{})
-}
-
-// The FieldLogger interface generalizes the Entry and Logger types
-type FieldLogger interface {
-	WithField(key string, value interface{}) *Entry
-	WithFields(fields Fields) *Entry
-	WithError(err error) *Entry
-
-	Debugf(format string, args ...interface{})
-	Infof(format string, args ...interface{})
-	Printf(format string, args ...interface{})
-	Warnf(format string, args ...interface{})
-	Warningf(format string, args ...interface{})
-	Errorf(format string, args ...interface{})
-	Fatalf(format string, args ...interface{})
-	Panicf(format string, args ...interface{})
-
-	Debug(args ...interface{})
-	Info(args ...interface{})
-	Print(args ...interface{})
-	Warn(args ...interface{})
-	Warning(args ...interface{})
-	Error(args ...interface{})
-	Fatal(args ...interface{})
-	Panic(args ...interface{})
-
-	Debugln(args ...interface{})
-	Infoln(args ...interface{})
-	Println(args ...interface{})
-	Warnln(args ...interface{})
-	Warningln(args ...interface{})
-	Errorln(args ...interface{})
-	Fatalln(args ...interface{})
-	Panicln(args ...interface{})
-}

vendor/github.com/Sirupsen/logrus/logrus_test.go

@@ -1,361 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"encoding/json"
-	"strconv"
-	"strings"
-	"sync"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func LogAndAssertJSON(t *testing.T, log func(*Logger), assertions func(fields Fields)) {
-	var buffer bytes.Buffer
-	var fields Fields
-
-	logger := New()
-	logger.Out = &buffer
-	logger.Formatter = new(JSONFormatter)
-
-	log(logger)
-
-	err := json.Unmarshal(buffer.Bytes(), &fields)
-	assert.Nil(t, err)
-
-	assertions(fields)
-}
-
-func LogAndAssertText(t *testing.T, log func(*Logger), assertions func(fields map[string]string)) {
-	var buffer bytes.Buffer
-
-	logger := New()
-	logger.Out = &buffer
-	logger.Formatter = &TextFormatter{
-		DisableColors: true,
-	}
-
-	log(logger)
-
-	fields := make(map[string]string)
-	for _, kv := range strings.Split(buffer.String(), " ") {
-		if !strings.Contains(kv, "=") {
-			continue
-		}
-		kvArr := strings.Split(kv, "=")
-		key := strings.TrimSpace(kvArr[0])
-		val := kvArr[1]
-		if kvArr[1][0] == '"' {
-			var err error
-			val, err = strconv.Unquote(val)
-			assert.NoError(t, err)
-		}
-		fields[key] = val
-	}
-	assertions(fields)
-}
-
-func TestPrint(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Print("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "test")
-		assert.Equal(t, fields["level"], "info")
-	})
-}
-
-func TestInfo(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Info("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "test")
-		assert.Equal(t, fields["level"], "info")
-	})
-}
-
-func TestWarn(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Warn("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "test")
-		assert.Equal(t, fields["level"], "warning")
-	})
-}
-
-func TestInfolnShouldAddSpacesBetweenStrings(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Infoln("test", "test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "test test")
-	})
-}
-
-func TestInfolnShouldAddSpacesBetweenStringAndNonstring(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Infoln("test", 10)
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "test 10")
-	})
-}
-
-func TestInfolnShouldAddSpacesBetweenTwoNonStrings(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Infoln(10, 10)
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "10 10")
-	})
-}
-
-func TestInfoShouldAddSpacesBetweenTwoNonStrings(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Infoln(10, 10)
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "10 10")
-	})
-}
-
-func TestInfoShouldNotAddSpacesBetweenStringAndNonstring(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Info("test", 10)
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "test10")
-	})
-}
-
-func TestInfoShouldNotAddSpacesBetweenStrings(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Info("test", "test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "testtest")
-	})
-}
-
-func TestWithFieldsShouldAllowAssignments(t *testing.T) {
-	var buffer bytes.Buffer
-	var fields Fields
-
-	logger := New()
-	logger.Out = &buffer
-	logger.Formatter = new(JSONFormatter)
-
-	localLog := logger.WithFields(Fields{
-		"key1": "value1",
-	})
-
-	localLog.WithField("key2", "value2").Info("test")
-	err := json.Unmarshal(buffer.Bytes(), &fields)
-	assert.Nil(t, err)
-
-	assert.Equal(t, "value2", fields["key2"])
-	assert.Equal(t, "value1", fields["key1"])
-
-	buffer = bytes.Buffer{}
-	fields = Fields{}
-	localLog.Info("test")
-	err = json.Unmarshal(buffer.Bytes(), &fields)
-	assert.Nil(t, err)
-
-	_, ok := fields["key2"]
-	assert.Equal(t, false, ok)
-	assert.Equal(t, "value1", fields["key1"])
-}
-
-func TestUserSuppliedFieldDoesNotOverwriteDefaults(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.WithField("msg", "hello").Info("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "test")
-	})
-}
-
-func TestUserSuppliedMsgFieldHasPrefix(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.WithField("msg", "hello").Info("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["msg"], "test")
-		assert.Equal(t, fields["fields.msg"], "hello")
-	})
-}
-
-func TestUserSuppliedTimeFieldHasPrefix(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.WithField("time", "hello").Info("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["fields.time"], "hello")
-	})
-}
-
-func TestUserSuppliedLevelFieldHasPrefix(t *testing.T) {
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.WithField("level", 1).Info("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["level"], "info")
-		assert.Equal(t, fields["fields.level"], 1.0) // JSON has floats only
-	})
-}
-
-func TestDefaultFieldsAreNotPrefixed(t *testing.T) {
-	LogAndAssertText(t, func(log *Logger) {
-		ll := log.WithField("herp", "derp")
-		ll.Info("hello")
-		ll.Info("bye")
-	}, func(fields map[string]string) {
-		for _, fieldName := range []string{"fields.level", "fields.time", "fields.msg"} {
-			if _, ok := fields[fieldName]; ok {
-				t.Fatalf("should not have prefixed %q: %v", fieldName, fields)
-			}
-		}
-	})
-}
-
-func TestDoubleLoggingDoesntPrefixPreviousFields(t *testing.T) {
-
-	var buffer bytes.Buffer
-	var fields Fields
-
-	logger := New()
-	logger.Out = &buffer
-	logger.Formatter = new(JSONFormatter)
-
-	llog := logger.WithField("context", "eating raw fish")
-
-	llog.Info("looks delicious")
-
-	err := json.Unmarshal(buffer.Bytes(), &fields)
-	assert.NoError(t, err, "should have decoded first message")
-	assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields")
-	assert.Equal(t, fields["msg"], "looks delicious")
-	assert.Equal(t, fields["context"], "eating raw fish")
-
-	buffer.Reset()
-
-	llog.Warn("omg it is!")
-
-	err = json.Unmarshal(buffer.Bytes(), &fields)
-	assert.NoError(t, err, "should have decoded second message")
-	assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields")
-	assert.Equal(t, fields["msg"], "omg it is!")
-	assert.Equal(t, fields["context"], "eating raw fish")
-	assert.Nil(t, fields["fields.msg"], "should not have prefixed previous `msg` entry")
-
-}
-
-func TestConvertLevelToString(t *testing.T) {
-	assert.Equal(t, "debug", DebugLevel.String())
-	assert.Equal(t, "info", InfoLevel.String())
-	assert.Equal(t, "warning", WarnLevel.String())
-	assert.Equal(t, "error", ErrorLevel.String())
-	assert.Equal(t, "fatal", FatalLevel.String())
-	assert.Equal(t, "panic", PanicLevel.String())
-}
-
-func TestParseLevel(t *testing.T) {
-	l, err := ParseLevel("panic")
-	assert.Nil(t, err)
-	assert.Equal(t, PanicLevel, l)
-
-	l, err = ParseLevel("PANIC")
-	assert.Nil(t, err)
-	assert.Equal(t, PanicLevel, l)
-
-	l, err = ParseLevel("fatal")
-	assert.Nil(t, err)
-	assert.Equal(t, FatalLevel, l)
-
-	l, err = ParseLevel("FATAL")
-	assert.Nil(t, err)
-	assert.Equal(t, FatalLevel, l)
-
-	l, err = ParseLevel("error")
-	assert.Nil(t, err)
-	assert.Equal(t, ErrorLevel, l)
-
-	l, err = ParseLevel("ERROR")
-	assert.Nil(t, err)
-	assert.Equal(t, ErrorLevel, l)
-
-	l, err = ParseLevel("warn")
-	assert.Nil(t, err)
-	assert.Equal(t, WarnLevel, l)
-
-	l, err = ParseLevel("WARN")
-	assert.Nil(t, err)
-	assert.Equal(t, WarnLevel, l)
-
-	l, err = ParseLevel("warning")
-	assert.Nil(t, err)
-	assert.Equal(t, WarnLevel, l)
-
-	l, err = ParseLevel("WARNING")
-	assert.Nil(t, err)
-	assert.Equal(t, WarnLevel, l)
-
-	l, err = ParseLevel("info")
-	assert.Nil(t, err)
-	assert.Equal(t, InfoLevel, l)
-
-	l, err = ParseLevel("INFO")
-	assert.Nil(t, err)
-	assert.Equal(t, InfoLevel, l)
-
-	l, err = ParseLevel("debug")
-	assert.Nil(t, err)
-	assert.Equal(t, DebugLevel, l)
-
-	l, err = ParseLevel("DEBUG")
-	assert.Nil(t, err)
-	assert.Equal(t, DebugLevel, l)
-
-	l, err = ParseLevel("invalid")
-	assert.Equal(t, "not a valid logrus Level: \"invalid\"", err.Error())
-}
-
-func TestGetSetLevelRace(t *testing.T) {
-	wg := sync.WaitGroup{}
-	for i := 0; i < 100; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			if i%2 == 0 {
-				SetLevel(InfoLevel)
-			} else {
-				GetLevel()
-			}
-		}(i)
-
-	}
-	wg.Wait()
-}
-
-func TestLoggingRace(t *testing.T) {
-	logger := New()
-
-	var wg sync.WaitGroup
-	wg.Add(100)
-
-	for i := 0; i < 100; i++ {
-		go func() {
-			logger.Info("info")
-			wg.Done()
-		}()
-	}
-	wg.Wait()
-}
-
-// Compile test
-func TestLogrusInterface(t *testing.T) {
-	var buffer bytes.Buffer
-	fn := func(l FieldLogger) {
-		b := l.WithField("key", "value")
-		b.Debug("Test")
-	}
-	// test logger
-	logger := New()
-	logger.Out = &buffer
-	fn(logger)
-
-	// test Entry
-	e := logger.WithField("another", "value")
-	fn(e)
-}

vendor/github.com/Sirupsen/logrus/terminal_appengine.go

@@ -1,8 +0,0 @@
-// +build appengine
-
-package logrus
-
-// IsTerminal returns true if stderr's file descriptor is a terminal.
-func IsTerminal(f io.Writer) bool {
-	return true
-}

vendor/github.com/Sirupsen/logrus/terminal_bsd.go

@@ -1,10 +0,0 @@
-// +build darwin freebsd openbsd netbsd dragonfly
-// +build !appengine
-
-package logrus
-
-import "syscall"
-
-const ioctlReadTermios = syscall.TIOCGETA
-
-type Termios syscall.Termios

vendor/github.com/Sirupsen/logrus/terminal_linux.go

@@ -1,14 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !appengine
-
-package logrus
-
-import "syscall"
-
-const ioctlReadTermios = syscall.TCGETS
-
-type Termios syscall.Termios

vendor/github.com/Sirupsen/logrus/terminal_notwindows.go

@@ -1,28 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build linux darwin freebsd openbsd netbsd dragonfly
-// +build !appengine
-
-package logrus
-
-import (
-	"io"
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-// IsTerminal returns true if stderr's file descriptor is a terminal.
-func IsTerminal(f io.Writer) bool {
-	var termios Termios
-	switch v := f.(type) {
-	case *os.File:
-		_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(v.Fd()), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-		return err == 0
-	default:
-		return false
-	}
-}

vendor/github.com/Sirupsen/logrus/terminal_solaris.go

@@ -1,21 +0,0 @@
-// +build solaris,!appengine
-
-package logrus
-
-import (
-	"os"
-
-	"golang.org/x/sys/unix"
-)
-
-// IsTerminal returns true if the given file descriptor is a terminal.
-func IsTerminal(f io.Writer) bool {
-	var termios Termios
-	switch v := f.(type) {
-	case *os.File:
-		_, err := unix.IoctlGetTermios(int(v.Fd()), unix.TCGETA)
-		return err == nil
-	default:
-		return false
-	}
-}

vendor/github.com/Sirupsen/logrus/terminal_windows.go

@@ -1,33 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build windows,!appengine
-
-package logrus
-
-import (
-	"io"	
-	"os"	
-	"syscall"
-	"unsafe"
-)
-
-var kernel32 = syscall.NewLazyDLL("kernel32.dll")
-
-var (
-	procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
-)
-
-// IsTerminal returns true if stderr's file descriptor is a terminal.
-func IsTerminal(f io.Writer) bool {
-	switch v := f.(type) {
-	case *os.File:
-		var st uint32
-		r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(v.Fd()), uintptr(unsafe.Pointer(&st)), 0)
-		return r != 0 && e == 0
-	default:
-		return false
-	}
-}

vendor/github.com/Sirupsen/logrus/text_formatter.go

@@ -1,173 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"fmt"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-)
-
-const (
-	nocolor = 0
-	red     = 31
-	green   = 32
-	yellow  = 33
-	blue    = 34
-	gray    = 37
-)
-
-var (
-	baseTimestamp time.Time
-)
-
-func init() {
-	baseTimestamp = time.Now()
-}
-
-type TextFormatter struct {
-	// Set to true to bypass checking for a TTY before outputting colors.
-	ForceColors bool
-
-	// Force disabling colors.
-	DisableColors bool
-
-	// Disable timestamp logging. useful when output is redirected to logging
-	// system that already adds timestamps.
-	DisableTimestamp bool
-
-	// Enable logging the full timestamp when a TTY is attached instead of just
-	// the time passed since beginning of execution.
-	FullTimestamp bool
-
-	// TimestampFormat to use for display when a full timestamp is printed
-	TimestampFormat string
-
-	// The fields are sorted by default for a consistent output. For applications
-	// that log extremely frequently and don't use the JSON formatter this may not
-	// be desired.
-	DisableSorting bool
-
-	// Whether the logger's out is to a terminal
-	isTerminal   bool
-	terminalOnce sync.Once
-}
-
-func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
-	var b *bytes.Buffer
-	keys := make([]string, 0, len(entry.Data))
-	for k := range entry.Data {
-		keys = append(keys, k)
-	}
-
-	if !f.DisableSorting {
-		sort.Strings(keys)
-	}
-	if entry.Buffer != nil {
-		b = entry.Buffer
-	} else {
-		b = &bytes.Buffer{}
-	}
-
-	prefixFieldClashes(entry.Data)
-
-	f.terminalOnce.Do(func() {
-		if entry.Logger != nil {
-			f.isTerminal = IsTerminal(entry.Logger.Out)
-		}
-	})
-
-	isColored := (f.ForceColors || f.isTerminal) && !f.DisableColors
-
-	timestampFormat := f.TimestampFormat
-	if timestampFormat == "" {
-		timestampFormat = DefaultTimestampFormat
-	}
-	if isColored {
-		f.printColored(b, entry, keys, timestampFormat)
-	} else {
-		if !f.DisableTimestamp {
-			f.appendKeyValue(b, "time", entry.Time.Format(timestampFormat))
-		}
-		f.appendKeyValue(b, "level", entry.Level.String())
-		if entry.Message != "" {
-			f.appendKeyValue(b, "msg", entry.Message)
-		}
-		for _, key := range keys {
-			f.appendKeyValue(b, key, entry.Data[key])
-		}
-	}
-
-	b.WriteByte('\n')
-	return b.Bytes(), nil
-}
-
-func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, timestampFormat string) {
-	var levelColor int
-	switch entry.Level {
-	case DebugLevel:
-		levelColor = gray
-	case WarnLevel:
-		levelColor = yellow
-	case ErrorLevel, FatalLevel, PanicLevel:
-		levelColor = red
-	default:
-		levelColor = blue
-	}
-
-	levelText := strings.ToUpper(entry.Level.String())[0:4]
-
-	if f.DisableTimestamp {
-		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m %-44s ", levelColor, levelText, entry.Message)
-	} else if !f.FullTimestamp {
-		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d] %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), entry.Message)
-	} else {
-		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), entry.Message)
-	}
-	for _, k := range keys {
-		v := entry.Data[k]
-		fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k)
-		f.appendValue(b, v)
-	}
-}
-
-func needsQuoting(text string) bool {
-	for _, ch := range text {
-		if !((ch >= 'a' && ch <= 'z') ||
-			(ch >= 'A' && ch <= 'Z') ||
-			(ch >= '0' && ch <= '9') ||
-			ch == '-' || ch == '.') {
-			return true
-		}
-	}
-	return false
-}
-
-func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
-
-	b.WriteString(key)
-	b.WriteByte('=')
-	f.appendValue(b, value)
-	b.WriteByte(' ')
-}
-
-func (f *TextFormatter) appendValue(b *bytes.Buffer, value interface{}) {
-	switch value := value.(type) {
-	case string:
-		if !needsQuoting(value) {
-			b.WriteString(value)
-		} else {
-			fmt.Fprintf(b, "%q", value)
-		}
-	case error:
-		errmsg := value.Error()
-		if !needsQuoting(errmsg) {
-			b.WriteString(errmsg)
-		} else {
-			fmt.Fprintf(b, "%q", errmsg)
-		}
-	default:
-		fmt.Fprint(b, value)
-	}
-}

vendor/github.com/Sirupsen/logrus/text_formatter_test.go

@@ -1,71 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"errors"
-	"testing"
-	"time"
-	"strings"
-)
-
-func TestQuoting(t *testing.T) {
-	tf := &TextFormatter{DisableColors: true}
-
-	checkQuoting := func(q bool, value interface{}) {
-		b, _ := tf.Format(WithField("test", value))
-		idx := bytes.Index(b, ([]byte)("test="))
-		cont := bytes.Contains(b[idx+5:], []byte{'"'})
-		if cont != q {
-			if q {
-				t.Errorf("quoting expected for: %#v", value)
-			} else {
-				t.Errorf("quoting not expected for: %#v", value)
-			}
-		}
-	}
-
-	checkQuoting(false, "abcd")
-	checkQuoting(false, "v1.0")
-	checkQuoting(false, "1234567890")
-	checkQuoting(true, "/foobar")
-	checkQuoting(true, "x y")
-	checkQuoting(true, "x,y")
-	checkQuoting(false, errors.New("invalid"))
-	checkQuoting(true, errors.New("invalid argument"))
-}
-
-func TestTimestampFormat(t *testing.T) {
-	checkTimeStr := func(format string) {
-		customFormatter := &TextFormatter{DisableColors: true, TimestampFormat: format}
-		customStr, _ := customFormatter.Format(WithField("test", "test"))
-		timeStart := bytes.Index(customStr, ([]byte)("time="))
-		timeEnd := bytes.Index(customStr, ([]byte)("level="))
-		timeStr := customStr[timeStart+5 : timeEnd-1]
-		if timeStr[0] == '"' && timeStr[len(timeStr)-1] == '"' {
-			timeStr = timeStr[1 : len(timeStr)-1]
-		}
-		if format == "" {
-			format = time.RFC3339
-		}
-		_, e := time.Parse(format, (string)(timeStr))
-		if e != nil {
-			t.Errorf("time string \"%s\" did not match provided time format \"%s\": %s", timeStr, format, e)
-		}
-	}
-
-	checkTimeStr("2006-01-02T15:04:05.000000000Z07:00")
-	checkTimeStr("Mon Jan _2 15:04:05 2006")
-	checkTimeStr("")
-}
-
-func TestDisableTimestampWithColoredOutput(t *testing.T) {
-	tf := &TextFormatter{DisableTimestamp: true, ForceColors: true}
-
-	b, _ := tf.Format(WithField("test", "test"))
-	if strings.Contains(string(b), "[0000]") {
-		t.Error("timestamp not expected when DisableTimestamp is true")
-	}
-}
-
-// TODO add tests for sorting etc., this requires a parser for the text
-// formatter output.

vendor/github.com/Sirupsen/logrus/writer.go

@@ -1,53 +0,0 @@
-package logrus
-
-import (
-	"bufio"
-	"io"
-	"runtime"
-)
-
-func (logger *Logger) Writer() *io.PipeWriter {
-	return logger.WriterLevel(InfoLevel)
-}
-
-func (logger *Logger) WriterLevel(level Level) *io.PipeWriter {
-	reader, writer := io.Pipe()
-
-	var printFunc func(args ...interface{})
-	switch level {
-	case DebugLevel:
-		printFunc = logger.Debug
-	case InfoLevel:
-		printFunc = logger.Info
-	case WarnLevel:
-		printFunc = logger.Warn
-	case ErrorLevel:
-		printFunc = logger.Error
-	case FatalLevel:
-		printFunc = logger.Fatal
-	case PanicLevel:
-		printFunc = logger.Panic
-	default:
-		printFunc = logger.Print
-	}
-
-	go logger.writerScanner(reader, printFunc)
-	runtime.SetFinalizer(writer, writerFinalizer)
-
-	return writer
-}
-
-func (logger *Logger) writerScanner(reader *io.PipeReader, printFunc func(args ...interface{})) {
-	scanner := bufio.NewScanner(reader)
-	for scanner.Scan() {
-		printFunc(scanner.Text())
-	}
-	if err := scanner.Err(); err != nil {
-		logger.Errorf("Error while reading from Writer: %s", err)
-	}
-	reader.Close()
-}
-
-func writerFinalizer(writer *io.PipeWriter) {
-	writer.Close()
-}

vendor/github.com/codegangsta/cli/.travis.yml

@@ -1,39 +0,0 @@
-language: go
-
-sudo: false
-
-cache:
-  directories:
-  - node_modules
-
-go:
-- 1.2.x
-- 1.3.x
-- 1.4.2
-- 1.5.x
-- 1.6.x
-- 1.7.x
-- master
-
-matrix:
-  allow_failures:
-  - go: master
-  include:
-  - go: 1.6.x
-    os: osx
-  - go: 1.7.x
-    os: osx
-
-before_script:
-- go get github.com/urfave/gfmrun/... || true
-- go get golang.org/x/tools/... || true
-- if [ ! -f node_modules/.bin/markdown-toc ] ; then
-    npm install markdown-toc ;
-  fi
-
-script:
-- ./runtests gen
-- ./runtests vet
-- ./runtests test
-- ./runtests gfmrun
-- ./runtests toc

vendor/github.com/codegangsta/cli/CHANGELOG.md

@@ -1,392 +0,0 @@
-# Change Log
-
-**ATTN**: This project uses [semantic versioning](http://semver.org/).
-
-## [Unreleased]
-
-## [1.19.1] - 2016-11-21
-
-### Fixed
-
-- Fixes regression introduced in 1.19.0 where using an `ActionFunc` as
-  the `Action` for a command would cause it to error rather than calling the
-  function. Should not have a affected declarative cases using `func(c
-  *cli.Context) err)`.
-- Shell completion now handles the case where the user specifies
-  `--generate-bash-completion` immediately after a flag that takes an argument.
-  Previously it call the application with `--generate-bash-completion` as the
-  flag value.
-
-## [1.19.0] - 2016-11-19
-### Added
-- `FlagsByName` was added to make it easy to sort flags (e.g. `sort.Sort(cli.FlagsByName(app.Flags))`)
-- A `Description` field was added to `App` for a more detailed description of
-  the application (similar to the existing `Description` field on `Command`)
-- Flag type code generation via `go generate`
-- Write to stderr and exit 1 if action returns non-nil error
-- Added support for TOML to the `altsrc` loader
-- `SkipArgReorder` was added to allow users to skip the argument reordering.
-  This is useful if you want to consider all "flags" after an argument as
-  arguments rather than flags (the default behavior of the stdlib `flag`
-  library). This is backported functionality from the [removal of the flag
-  reordering](https://github.com/urfave/cli/pull/398) in the unreleased version
-  2
-- For formatted errors (those implementing `ErrorFormatter`), the errors will
-  be formatted during output. Compatible with `pkg/errors`.
-
-### Changed
-- Raise minimum tested/supported Go version to 1.2+
-
-### Fixed
-- Consider empty environment variables as set (previously environment variables
-  with the equivalent of `""` would be skipped rather than their value used).
-- Return an error if the value in a given environment variable cannot be parsed
-  as the flag type. Previously these errors were silently swallowed.
-- Print full error when an invalid flag is specified (which includes the invalid flag)
-- `App.Writer` defaults to `stdout` when `nil`
-- If no action is specified on a command or app, the help is now printed instead of `panic`ing
-- `App.Metadata` is initialized automatically now (previously was `nil` unless initialized)
-- Correctly show help message if `-h` is provided to a subcommand
-- `context.(Global)IsSet` now respects environment variables. Previously it
-  would return `false` if a flag was specified in the environment rather than
-  as an argument
-- Removed deprecation warnings to STDERR to avoid them leaking to the end-user
-- `altsrc`s import paths were updated to use `gopkg.in/urfave/cli.v1`. This
-  fixes issues that occurred when `gopkg.in/urfave/cli.v1` was imported as well
-  as `altsrc` where Go would complain that the types didn't match
-
-## [1.18.1] - 2016-08-28
-### Fixed
-- Removed deprecation warnings to STDERR to avoid them leaking to the end-user (backported)
-
-## [1.18.0] - 2016-06-27
-### Added
-- `./runtests` test runner with coverage tracking by default
-- testing on OS X
-- testing on Windows
-- `UintFlag`, `Uint64Flag`, and `Int64Flag` types and supporting code
-
-### Changed
-- Use spaces for alignment in help/usage output instead of tabs, making the
-  output alignment consistent regardless of tab width
-
-### Fixed
-- Printing of command aliases in help text
-- Printing of visible flags for both struct and struct pointer flags
-- Display the `help` subcommand when using `CommandCategories`
-- No longer swallows `panic`s that occur within the `Action`s themselves when
-  detecting the signature of the `Action` field
-
-## [1.17.1] - 2016-08-28
-### Fixed
-- Removed deprecation warnings to STDERR to avoid them leaking to the end-user
-
-## [1.17.0] - 2016-05-09
-### Added
-- Pluggable flag-level help text rendering via `cli.DefaultFlagStringFunc`
-- `context.GlobalBoolT` was added as an analogue to `context.GlobalBool`
-- Support for hiding commands by setting `Hidden: true` -- this will hide the
-  commands in help output
-
-### Changed
-- `Float64Flag`, `IntFlag`, and `DurationFlag` default values are no longer
-  quoted in help text output.
-- All flag types now include `(default: {value})` strings following usage when a
-  default value can be (reasonably) detected.
-- `IntSliceFlag` and `StringSliceFlag` usage strings are now more consistent
-  with non-slice flag types
-- Apps now exit with a code of 3 if an unknown subcommand is specified
-  (previously they printed "No help topic for...", but still exited 0. This
-  makes it easier to script around apps built using `cli` since they can trust
-  that a 0 exit code indicated a successful execution.
-- cleanups based on [Go Report Card
-  feedback](https://goreportcard.com/report/github.com/urfave/cli)
-
-## [1.16.1] - 2016-08-28
-### Fixed
-- Removed deprecation warnings to STDERR to avoid them leaking to the end-user
-
-## [1.16.0] - 2016-05-02
-### Added
-- `Hidden` field on all flag struct types to omit from generated help text
-
-### Changed
-- `BashCompletionFlag` (`--enable-bash-completion`) is now omitted from
-generated help text via the `Hidden` field
-
-### Fixed
-- handling of error values in `HandleAction` and `HandleExitCoder`
-
-## [1.15.0] - 2016-04-30
-### Added
-- This file!
-- Support for placeholders in flag usage strings
-- `App.Metadata` map for arbitrary data/state management
-- `Set` and `GlobalSet` methods on `*cli.Context` for altering values after
-parsing.
-- Support for nested lookup of dot-delimited keys in structures loaded from
-YAML.
-
-### Changed
-- The `App.Action` and `Command.Action` now prefer a return signature of
-`func(*cli.Context) error`, as defined by `cli.ActionFunc`.  If a non-nil
-`error` is returned, there may be two outcomes:
-    - If the error fulfills `cli.ExitCoder`, then `os.Exit` will be called
-    automatically
-    - Else the error is bubbled up and returned from `App.Run`
-- Specifying an `Action` with the legacy return signature of
-`func(*cli.Context)` will produce a deprecation message to stderr
-- Specifying an `Action` that is not a `func` type will produce a non-zero exit
-from `App.Run`
-- Specifying an `Action` func that has an invalid (input) signature will
-produce a non-zero exit from `App.Run`
-
-### Deprecated
-- <a name="deprecated-cli-app-runandexitonerror"></a>
-`cli.App.RunAndExitOnError`, which should now be done by returning an error
-that fulfills `cli.ExitCoder` to `cli.App.Run`.
-- <a name="deprecated-cli-app-action-signature"></a> the legacy signature for
-`cli.App.Action` of `func(*cli.Context)`, which should now have a return
-signature of `func(*cli.Context) error`, as defined by `cli.ActionFunc`.
-
-### Fixed
-- Added missing `*cli.Context.GlobalFloat64` method
-
-## [1.14.0] - 2016-04-03 (backfilled 2016-04-25)
-### Added
-- Codebeat badge
-- Support for categorization via `CategorizedHelp` and `Categories` on app.
-
-### Changed
-- Use `filepath.Base` instead of `path.Base` in `Name` and `HelpName`.
-
-### Fixed
-- Ensure version is not shown in help text when `HideVersion` set.
-
-## [1.13.0] - 2016-03-06 (backfilled 2016-04-25)
-### Added
-- YAML file input support.
-- `NArg` method on context.
-
-## [1.12.0] - 2016-02-17 (backfilled 2016-04-25)
-### Added
-- Custom usage error handling.
-- Custom text support in `USAGE` section of help output.
-- Improved help messages for empty strings.
-- AppVeyor CI configuration.
-
-### Changed
-- Removed `panic` from default help printer func.
-- De-duping and optimizations.
-
-### Fixed
-- Correctly handle `Before`/`After` at command level when no subcommands.
-- Case of literal `-` argument causing flag reordering.
-- Environment variable hints on Windows.
-- Docs updates.
-
-## [1.11.1] - 2015-12-21 (backfilled 2016-04-25)
-### Changed
-- Use `path.Base` in `Name` and `HelpName`
-- Export `GetName` on flag types.
-
-### Fixed
-- Flag parsing when skipping is enabled.
-- Test output cleanup.
-- Move completion check to account for empty input case.
-
-## [1.11.0] - 2015-11-15 (backfilled 2016-04-25)
-### Added
-- Destination scan support for flags.
-- Testing against `tip` in Travis CI config.
-
-### Changed
-- Go version in Travis CI config.
-
-### Fixed
-- Removed redundant tests.
-- Use correct example naming in tests.
-
-## [1.10.2] - 2015-10-29 (backfilled 2016-04-25)
-### Fixed
-- Remove unused var in bash completion.
-
-## [1.10.1] - 2015-10-21 (backfilled 2016-04-25)
-### Added
-- Coverage and reference logos in README.
-
-### Fixed
-- Use specified values in help and version parsing.
-- Only display app version and help message once.
-
-## [1.10.0] - 2015-10-06 (backfilled 2016-04-25)
-### Added
-- More tests for existing functionality.
-- `ArgsUsage` at app and command level for help text flexibility.
-
-### Fixed
-- Honor `HideHelp` and `HideVersion` in `App.Run`.
-- Remove juvenile word from README.
-
-## [1.9.0] - 2015-09-08 (backfilled 2016-04-25)
-### Added
-- `FullName` on command with accompanying help output update.
-- Set default `$PROG` in bash completion.
-
-### Changed
-- Docs formatting.
-
-### Fixed
-- Removed self-referential imports in tests.
-
-## [1.8.0] - 2015-06-30 (backfilled 2016-04-25)
-### Added
-- Support for `Copyright` at app level.
-- `Parent` func at context level to walk up context lineage.
-
-### Fixed
-- Global flag processing at top level.
-
-## [1.7.1] - 2015-06-11 (backfilled 2016-04-25)
-### Added
-- Aggregate errors from `Before`/`After` funcs.
-- Doc comments on flag structs.
-- Include non-global flags when checking version and help.
-- Travis CI config updates.
-
-### Fixed
-- Ensure slice type flags have non-nil values.
-- Collect global flags from the full command hierarchy.
-- Docs prose.
-
-## [1.7.0] - 2015-05-03 (backfilled 2016-04-25)
-### Changed
-- `HelpPrinter` signature includes output writer.
-
-### Fixed
-- Specify go 1.1+ in docs.
-- Set `Writer` when running command as app.
-
-## [1.6.0] - 2015-03-23 (backfilled 2016-04-25)
-### Added
-- Multiple author support.
-- `NumFlags` at context level.
-- `Aliases` at command level.
-
-### Deprecated
-- `ShortName` at command level.
-
-### Fixed
-- Subcommand help output.
-- Backward compatible support for deprecated `Author` and `Email` fields.
-- Docs regarding `Names`/`Aliases`.
-
-## [1.5.0] - 2015-02-20 (backfilled 2016-04-25)
-### Added
-- `After` hook func support at app and command level.
-
-### Fixed
-- Use parsed context when running command as subcommand.
-- Docs prose.
-
-## [1.4.1] - 2015-01-09 (backfilled 2016-04-25)
-### Added
-- Support for hiding `-h / --help` flags, but not `help` subcommand.
-- Stop flag parsing after `--`.
-
-### Fixed
-- Help text for generic flags to specify single value.
-- Use double quotes in output for defaults.
-- Use `ParseInt` instead of `ParseUint` for int environment var values.
-- Use `0` as base when parsing int environment var values.
-
-## [1.4.0] - 2014-12-12 (backfilled 2016-04-25)
-### Added
-- Support for environment variable lookup "cascade".
-- Support for `Stdout` on app for output redirection.
-
-### Fixed
-- Print command help instead of app help in `ShowCommandHelp`.
-
-## [1.3.1] - 2014-11-13 (backfilled 2016-04-25)
-### Added
-- Docs and example code updates.
-
-### Changed
-- Default `-v / --version` flag made optional.
-
-## [1.3.0] - 2014-08-10 (backfilled 2016-04-25)
-### Added
-- `FlagNames` at context level.
-- Exposed `VersionPrinter` var for more control over version output.
-- Zsh completion hook.
-- `AUTHOR` section in default app help template.
-- Contribution guidelines.
-- `DurationFlag` type.
-
-## [1.2.0] - 2014-08-02
-### Added
-- Support for environment variable defaults on flags plus tests.
-
-## [1.1.0] - 2014-07-15
-### Added
-- Bash completion.
-- Optional hiding of built-in help command.
-- Optional skipping of flag parsing at command level.
-- `Author`, `Email`, and `Compiled` metadata on app.
-- `Before` hook func support at app and command level.
-- `CommandNotFound` func support at app level.
-- Command reference available on context.
-- `GenericFlag` type.
-- `Float64Flag` type.
-- `BoolTFlag` type.
-- `IsSet` flag helper on context.
-- More flag lookup funcs at context level.
-- More tests &amp; docs.
-
-### Changed
-- Help template updates to account for presence/absence of flags.
-- Separated subcommand help template.
-- Exposed `HelpPrinter` var for more control over help output.
-
-## [1.0.0] - 2013-11-01
-### Added
-- `help` flag in default app flag set and each command flag set.
-- Custom handling of argument parsing errors.
-- Command lookup by name at app level.
-- `StringSliceFlag` type and supporting `StringSlice` type.
-- `IntSliceFlag` type and supporting `IntSlice` type.
-- Slice type flag lookups by name at context level.
-- Export of app and command help functions.
-- More tests &amp; docs.
-
-## 0.1.0 - 2013-07-22
-### Added
-- Initial implementation.
-
-[Unreleased]: https://github.com/urfave/cli/compare/v1.18.0...HEAD
-[1.18.0]: https://github.com/urfave/cli/compare/v1.17.0...v1.18.0
-[1.17.0]: https://github.com/urfave/cli/compare/v1.16.0...v1.17.0
-[1.16.0]: https://github.com/urfave/cli/compare/v1.15.0...v1.16.0
-[1.15.0]: https://github.com/urfave/cli/compare/v1.14.0...v1.15.0
-[1.14.0]: https://github.com/urfave/cli/compare/v1.13.0...v1.14.0
-[1.13.0]: https://github.com/urfave/cli/compare/v1.12.0...v1.13.0
-[1.12.0]: https://github.com/urfave/cli/compare/v1.11.1...v1.12.0
-[1.11.1]: https://github.com/urfave/cli/compare/v1.11.0...v1.11.1
-[1.11.0]: https://github.com/urfave/cli/compare/v1.10.2...v1.11.0
-[1.10.2]: https://github.com/urfave/cli/compare/v1.10.1...v1.10.2
-[1.10.1]: https://github.com/urfave/cli/compare/v1.10.0...v1.10.1
-[1.10.0]: https://github.com/urfave/cli/compare/v1.9.0...v1.10.0
-[1.9.0]: https://github.com/urfave/cli/compare/v1.8.0...v1.9.0
-[1.8.0]: https://github.com/urfave/cli/compare/v1.7.1...v1.8.0
-[1.7.1]: https://github.com/urfave/cli/compare/v1.7.0...v1.7.1
-[1.7.0]: https://github.com/urfave/cli/compare/v1.6.0...v1.7.0
-[1.6.0]: https://github.com/urfave/cli/compare/v1.5.0...v1.6.0
-[1.5.0]: https://github.com/urfave/cli/compare/v1.4.1...v1.5.0
-[1.4.1]: https://github.com/urfave/cli/compare/v1.4.0...v1.4.1
-[1.4.0]: https://github.com/urfave/cli/compare/v1.3.1...v1.4.0
-[1.3.1]: https://github.com/urfave/cli/compare/v1.3.0...v1.3.1
-[1.3.0]: https://github.com/urfave/cli/compare/v1.2.0...v1.3.0
-[1.2.0]: https://github.com/urfave/cli/compare/v1.1.0...v1.2.0
-[1.1.0]: https://github.com/urfave/cli/compare/v1.0.0...v1.1.0
-[1.0.0]: https://github.com/urfave/cli/compare/v0.1.0...v1.0.0

vendor/github.com/codegangsta/cli/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2016 Jeremy Saenz & Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

vendor/github.com/codegangsta/cli/altsrc/altsrc.go

@@ -1,3 +0,0 @@
-package altsrc
-
-//go:generate python ../generate-flag-types altsrc -i ../flag-types.json -o flag_generated.go

vendor/github.com/codegangsta/cli/altsrc/flag.go

@@ -1,261 +0,0 @@
-package altsrc
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"syscall"
-
-	"gopkg.in/urfave/cli.v1"
-)
-
-// FlagInputSourceExtension is an extension interface of cli.Flag that
-// allows a value to be set on the existing parsed flags.
-type FlagInputSourceExtension interface {
-	cli.Flag
-	ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error
-}
-
-// ApplyInputSourceValues iterates over all provided flags and
-// executes ApplyInputSourceValue on flags implementing the
-// FlagInputSourceExtension interface to initialize these flags
-// to an alternate input source.
-func ApplyInputSourceValues(context *cli.Context, inputSourceContext InputSourceContext, flags []cli.Flag) error {
-	for _, f := range flags {
-		inputSourceExtendedFlag, isType := f.(FlagInputSourceExtension)
-		if isType {
-			err := inputSourceExtendedFlag.ApplyInputSourceValue(context, inputSourceContext)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-// InitInputSource is used to to setup an InputSourceContext on a cli.Command Before method. It will create a new
-// input source based on the func provided. If there is no error it will then apply the new input source to any flags
-// that are supported by the input source
-func InitInputSource(flags []cli.Flag, createInputSource func() (InputSourceContext, error)) cli.BeforeFunc {
-	return func(context *cli.Context) error {
-		inputSource, err := createInputSource()
-		if err != nil {
-			return fmt.Errorf("Unable to create input source: inner error: \n'%v'", err.Error())
-		}
-
-		return ApplyInputSourceValues(context, inputSource, flags)
-	}
-}
-
-// InitInputSourceWithContext is used to to setup an InputSourceContext on a cli.Command Before method. It will create a new
-// input source based on the func provided with potentially using existing cli.Context values to initialize itself. If there is
-// no error it will then apply the new input source to any flags that are supported by the input source
-func InitInputSourceWithContext(flags []cli.Flag, createInputSource func(context *cli.Context) (InputSourceContext, error)) cli.BeforeFunc {
-	return func(context *cli.Context) error {
-		inputSource, err := createInputSource(context)
-		if err != nil {
-			return fmt.Errorf("Unable to create input source with context: inner error: \n'%v'", err.Error())
-		}
-
-		return ApplyInputSourceValues(context, inputSource, flags)
-	}
-}
-
-// ApplyInputSourceValue applies a generic value to the flagSet if required
-func (f *GenericFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
-			value, err := isc.Generic(f.GenericFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value != nil {
-				eachName(f.Name, func(name string) {
-					f.set.Set(f.Name, value.String())
-				})
-			}
-		}
-	}
-
-	return nil
-}
-
-// ApplyInputSourceValue applies a StringSlice value to the flagSet if required
-func (f *StringSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
-			value, err := isc.StringSlice(f.StringSliceFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value != nil {
-				var sliceValue cli.StringSlice = value
-				eachName(f.Name, func(name string) {
-					underlyingFlag := f.set.Lookup(f.Name)
-					if underlyingFlag != nil {
-						underlyingFlag.Value = &sliceValue
-					}
-				})
-			}
-		}
-	}
-	return nil
-}
-
-// ApplyInputSourceValue applies a IntSlice value if required
-func (f *IntSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
-			value, err := isc.IntSlice(f.IntSliceFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value != nil {
-				var sliceValue cli.IntSlice = value
-				eachName(f.Name, func(name string) {
-					underlyingFlag := f.set.Lookup(f.Name)
-					if underlyingFlag != nil {
-						underlyingFlag.Value = &sliceValue
-					}
-				})
-			}
-		}
-	}
-	return nil
-}
-
-// ApplyInputSourceValue applies a Bool value to the flagSet if required
-func (f *BoolFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
-			value, err := isc.Bool(f.BoolFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value {
-				eachName(f.Name, func(name string) {
-					f.set.Set(f.Name, strconv.FormatBool(value))
-				})
-			}
-		}
-	}
-	return nil
-}
-
-// ApplyInputSourceValue applies a BoolT value to the flagSet if required
-func (f *BoolTFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVar) {
-			value, err := isc.BoolT(f.BoolTFlag.Name)
-			if err != nil {
-				return err
-			}
-			if !value {
-				eachName(f.Name, func(name string) {
-					f.set.Set(f.Name, strconv.FormatBool(value))
-				})
-			}
-		}
-	}
-	return nil
-}
-
-// ApplyInputSourceValue applies a String value to the flagSet if required
-func (f *StringFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVar)) {
-			value, err := isc.String(f.StringFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value != "" {
-				eachName(f.Name, func(name string) {
-					f.set.Set(f.Name, value)
-				})
-			}
-		}
-	}
-	return nil
-}
-
-// ApplyInputSourceValue applies a int value to the flagSet if required
-func (f *IntFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVar)) {
-			value, err := isc.Int(f.IntFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value > 0 {
-				eachName(f.Name, func(name string) {
-					f.set.Set(f.Name, strconv.FormatInt(int64(value), 10))
-				})
-			}
-		}
-	}
-	return nil
-}
-
-// ApplyInputSourceValue applies a Duration value to the flagSet if required
-func (f *DurationFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVar)) {
-			value, err := isc.Duration(f.DurationFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value > 0 {
-				eachName(f.Name, func(name string) {
-					f.set.Set(f.Name, value.String())
-				})
-			}
-		}
-	}
-	return nil
-}
-
-// ApplyInputSourceValue applies a Float64 value to the flagSet if required
-func (f *Float64Flag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVar)) {
-			value, err := isc.Float64(f.Float64Flag.Name)
-			if err != nil {
-				return err
-			}
-			if value > 0 {
-				floatStr := float64ToString(value)
-				eachName(f.Name, func(name string) {
-					f.set.Set(f.Name, floatStr)
-				})
-			}
-		}
-	}
-	return nil
-}
-
-func isEnvVarSet(envVars string) bool {
-	for _, envVar := range strings.Split(envVars, ",") {
-		envVar = strings.TrimSpace(envVar)
-		if _, ok := syscall.Getenv(envVar); ok {
-			// TODO: Can't use this for bools as
-			// set means that it was true or false based on
-			// Bool flag type, should work for other types
-			return true
-		}
-	}
-
-	return false
-}
-
-func float64ToString(f float64) string {
-	return fmt.Sprintf("%v", f)
-}
-
-func eachName(longName string, fn func(string)) {
-	parts := strings.Split(longName, ",")
-	for _, name := range parts {
-		name = strings.Trim(name, " ")
-		fn(name)
-	}
-}

vendor/github.com/codegangsta/cli/altsrc/flag_generated.go

@@ -1,347 +0,0 @@
-package altsrc
-
-import (
-	"flag"
-
-	"gopkg.in/urfave/cli.v1"
-)
-
-// WARNING: This file is generated!
-
-// BoolFlag is the flag type that wraps cli.BoolFlag to allow
-// for other values to be specified
-type BoolFlag struct {
-	cli.BoolFlag
-	set *flag.FlagSet
-}
-
-// NewBoolFlag creates a new BoolFlag
-func NewBoolFlag(fl cli.BoolFlag) *BoolFlag {
-	return &BoolFlag{BoolFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped BoolFlag.Apply
-func (f *BoolFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.BoolFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped BoolFlag.ApplyWithError
-func (f *BoolFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.BoolFlag.ApplyWithError(set)
-}
-
-// BoolTFlag is the flag type that wraps cli.BoolTFlag to allow
-// for other values to be specified
-type BoolTFlag struct {
-	cli.BoolTFlag
-	set *flag.FlagSet
-}
-
-// NewBoolTFlag creates a new BoolTFlag
-func NewBoolTFlag(fl cli.BoolTFlag) *BoolTFlag {
-	return &BoolTFlag{BoolTFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped BoolTFlag.Apply
-func (f *BoolTFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.BoolTFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped BoolTFlag.ApplyWithError
-func (f *BoolTFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.BoolTFlag.ApplyWithError(set)
-}
-
-// DurationFlag is the flag type that wraps cli.DurationFlag to allow
-// for other values to be specified
-type DurationFlag struct {
-	cli.DurationFlag
-	set *flag.FlagSet
-}
-
-// NewDurationFlag creates a new DurationFlag
-func NewDurationFlag(fl cli.DurationFlag) *DurationFlag {
-	return &DurationFlag{DurationFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped DurationFlag.Apply
-func (f *DurationFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.DurationFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped DurationFlag.ApplyWithError
-func (f *DurationFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.DurationFlag.ApplyWithError(set)
-}
-
-// Float64Flag is the flag type that wraps cli.Float64Flag to allow
-// for other values to be specified
-type Float64Flag struct {
-	cli.Float64Flag
-	set *flag.FlagSet
-}
-
-// NewFloat64Flag creates a new Float64Flag
-func NewFloat64Flag(fl cli.Float64Flag) *Float64Flag {
-	return &Float64Flag{Float64Flag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped Float64Flag.Apply
-func (f *Float64Flag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.Float64Flag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped Float64Flag.ApplyWithError
-func (f *Float64Flag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.Float64Flag.ApplyWithError(set)
-}
-
-// GenericFlag is the flag type that wraps cli.GenericFlag to allow
-// for other values to be specified
-type GenericFlag struct {
-	cli.GenericFlag
-	set *flag.FlagSet
-}
-
-// NewGenericFlag creates a new GenericFlag
-func NewGenericFlag(fl cli.GenericFlag) *GenericFlag {
-	return &GenericFlag{GenericFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped GenericFlag.Apply
-func (f *GenericFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.GenericFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped GenericFlag.ApplyWithError
-func (f *GenericFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.GenericFlag.ApplyWithError(set)
-}
-
-// Int64Flag is the flag type that wraps cli.Int64Flag to allow
-// for other values to be specified
-type Int64Flag struct {
-	cli.Int64Flag
-	set *flag.FlagSet
-}
-
-// NewInt64Flag creates a new Int64Flag
-func NewInt64Flag(fl cli.Int64Flag) *Int64Flag {
-	return &Int64Flag{Int64Flag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped Int64Flag.Apply
-func (f *Int64Flag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.Int64Flag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped Int64Flag.ApplyWithError
-func (f *Int64Flag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.Int64Flag.ApplyWithError(set)
-}
-
-// IntFlag is the flag type that wraps cli.IntFlag to allow
-// for other values to be specified
-type IntFlag struct {
-	cli.IntFlag
-	set *flag.FlagSet
-}
-
-// NewIntFlag creates a new IntFlag
-func NewIntFlag(fl cli.IntFlag) *IntFlag {
-	return &IntFlag{IntFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped IntFlag.Apply
-func (f *IntFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.IntFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped IntFlag.ApplyWithError
-func (f *IntFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.IntFlag.ApplyWithError(set)
-}
-
-// IntSliceFlag is the flag type that wraps cli.IntSliceFlag to allow
-// for other values to be specified
-type IntSliceFlag struct {
-	cli.IntSliceFlag
-	set *flag.FlagSet
-}
-
-// NewIntSliceFlag creates a new IntSliceFlag
-func NewIntSliceFlag(fl cli.IntSliceFlag) *IntSliceFlag {
-	return &IntSliceFlag{IntSliceFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped IntSliceFlag.Apply
-func (f *IntSliceFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.IntSliceFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped IntSliceFlag.ApplyWithError
-func (f *IntSliceFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.IntSliceFlag.ApplyWithError(set)
-}
-
-// Int64SliceFlag is the flag type that wraps cli.Int64SliceFlag to allow
-// for other values to be specified
-type Int64SliceFlag struct {
-	cli.Int64SliceFlag
-	set *flag.FlagSet
-}
-
-// NewInt64SliceFlag creates a new Int64SliceFlag
-func NewInt64SliceFlag(fl cli.Int64SliceFlag) *Int64SliceFlag {
-	return &Int64SliceFlag{Int64SliceFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped Int64SliceFlag.Apply
-func (f *Int64SliceFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.Int64SliceFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped Int64SliceFlag.ApplyWithError
-func (f *Int64SliceFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.Int64SliceFlag.ApplyWithError(set)
-}
-
-// StringFlag is the flag type that wraps cli.StringFlag to allow
-// for other values to be specified
-type StringFlag struct {
-	cli.StringFlag
-	set *flag.FlagSet
-}
-
-// NewStringFlag creates a new StringFlag
-func NewStringFlag(fl cli.StringFlag) *StringFlag {
-	return &StringFlag{StringFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped StringFlag.Apply
-func (f *StringFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.StringFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped StringFlag.ApplyWithError
-func (f *StringFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.StringFlag.ApplyWithError(set)
-}
-
-// StringSliceFlag is the flag type that wraps cli.StringSliceFlag to allow
-// for other values to be specified
-type StringSliceFlag struct {
-	cli.StringSliceFlag
-	set *flag.FlagSet
-}
-
-// NewStringSliceFlag creates a new StringSliceFlag
-func NewStringSliceFlag(fl cli.StringSliceFlag) *StringSliceFlag {
-	return &StringSliceFlag{StringSliceFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped StringSliceFlag.Apply
-func (f *StringSliceFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.StringSliceFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped StringSliceFlag.ApplyWithError
-func (f *StringSliceFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.StringSliceFlag.ApplyWithError(set)
-}
-
-// Uint64Flag is the flag type that wraps cli.Uint64Flag to allow
-// for other values to be specified
-type Uint64Flag struct {
-	cli.Uint64Flag
-	set *flag.FlagSet
-}
-
-// NewUint64Flag creates a new Uint64Flag
-func NewUint64Flag(fl cli.Uint64Flag) *Uint64Flag {
-	return &Uint64Flag{Uint64Flag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped Uint64Flag.Apply
-func (f *Uint64Flag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.Uint64Flag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped Uint64Flag.ApplyWithError
-func (f *Uint64Flag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.Uint64Flag.ApplyWithError(set)
-}
-
-// UintFlag is the flag type that wraps cli.UintFlag to allow
-// for other values to be specified
-type UintFlag struct {
-	cli.UintFlag
-	set *flag.FlagSet
-}
-
-// NewUintFlag creates a new UintFlag
-func NewUintFlag(fl cli.UintFlag) *UintFlag {
-	return &UintFlag{UintFlag: fl, set: nil}
-}
-
-// Apply saves the flagSet for later usage calls, then calls the
-// wrapped UintFlag.Apply
-func (f *UintFlag) Apply(set *flag.FlagSet) {
-	f.set = set
-	f.UintFlag.Apply(set)
-}
-
-// ApplyWithError saves the flagSet for later usage calls, then calls the
-// wrapped UintFlag.ApplyWithError
-func (f *UintFlag) ApplyWithError(set *flag.FlagSet) error {
-	f.set = set
-	return f.UintFlag.ApplyWithError(set)
-}

vendor/github.com/codegangsta/cli/altsrc/flag_test.go

@@ -1,336 +0,0 @@
-package altsrc
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-	"time"
-
-	"gopkg.in/urfave/cli.v1"
-)
-
-type testApplyInputSource struct {
-	Flag               FlagInputSourceExtension
-	FlagName           string
-	FlagSetName        string
-	Expected           string
-	ContextValueString string
-	ContextValue       flag.Value
-	EnvVarValue        string
-	EnvVarName         string
-	MapValue           interface{}
-}
-
-func TestGenericApplyInputSourceValue(t *testing.T) {
-	v := &Parser{"abc", "def"}
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewGenericFlag(cli.GenericFlag{Name: "test", Value: &Parser{}}),
-		FlagName: "test",
-		MapValue: v,
-	})
-	expect(t, v, c.Generic("test"))
-}
-
-func TestGenericApplyInputSourceMethodContextSet(t *testing.T) {
-	p := &Parser{"abc", "def"}
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewGenericFlag(cli.GenericFlag{Name: "test", Value: &Parser{}}),
-		FlagName:           "test",
-		MapValue:           &Parser{"efg", "hig"},
-		ContextValueString: p.String(),
-	})
-	expect(t, p, c.Generic("test"))
-}
-
-func TestGenericApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewGenericFlag(cli.GenericFlag{Name: "test", Value: &Parser{}, EnvVar: "TEST"}),
-		FlagName:    "test",
-		MapValue:    &Parser{"efg", "hij"},
-		EnvVarName:  "TEST",
-		EnvVarValue: "abc,def",
-	})
-	expect(t, &Parser{"abc", "def"}, c.Generic("test"))
-}
-
-func TestStringSliceApplyInputSourceValue(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewStringSliceFlag(cli.StringSliceFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: []string{"hello", "world"},
-	})
-	expect(t, c.StringSlice("test"), []string{"hello", "world"})
-}
-
-func TestStringSliceApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewStringSliceFlag(cli.StringSliceFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           []string{"hello", "world"},
-		ContextValueString: "ohno",
-	})
-	expect(t, c.StringSlice("test"), []string{"ohno"})
-}
-
-func TestStringSliceApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewStringSliceFlag(cli.StringSliceFlag{Name: "test", EnvVar: "TEST"}),
-		FlagName:    "test",
-		MapValue:    []string{"hello", "world"},
-		EnvVarName:  "TEST",
-		EnvVarValue: "oh,no",
-	})
-	expect(t, c.StringSlice("test"), []string{"oh", "no"})
-}
-
-func TestIntSliceApplyInputSourceValue(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewIntSliceFlag(cli.IntSliceFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: []int{1, 2},
-	})
-	expect(t, c.IntSlice("test"), []int{1, 2})
-}
-
-func TestIntSliceApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewIntSliceFlag(cli.IntSliceFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           []int{1, 2},
-		ContextValueString: "3",
-	})
-	expect(t, c.IntSlice("test"), []int{3})
-}
-
-func TestIntSliceApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewIntSliceFlag(cli.IntSliceFlag{Name: "test", EnvVar: "TEST"}),
-		FlagName:    "test",
-		MapValue:    []int{1, 2},
-		EnvVarName:  "TEST",
-		EnvVarValue: "3,4",
-	})
-	expect(t, c.IntSlice("test"), []int{3, 4})
-}
-
-func TestBoolApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewBoolFlag(cli.BoolFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: true,
-	})
-	expect(t, true, c.Bool("test"))
-}
-
-func TestBoolApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewBoolFlag(cli.BoolFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           false,
-		ContextValueString: "true",
-	})
-	expect(t, true, c.Bool("test"))
-}
-
-func TestBoolApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewBoolFlag(cli.BoolFlag{Name: "test", EnvVar: "TEST"}),
-		FlagName:    "test",
-		MapValue:    false,
-		EnvVarName:  "TEST",
-		EnvVarValue: "true",
-	})
-	expect(t, true, c.Bool("test"))
-}
-
-func TestBoolTApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewBoolTFlag(cli.BoolTFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: false,
-	})
-	expect(t, false, c.BoolT("test"))
-}
-
-func TestBoolTApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewBoolTFlag(cli.BoolTFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           true,
-		ContextValueString: "false",
-	})
-	expect(t, false, c.BoolT("test"))
-}
-
-func TestBoolTApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewBoolTFlag(cli.BoolTFlag{Name: "test", EnvVar: "TEST"}),
-		FlagName:    "test",
-		MapValue:    true,
-		EnvVarName:  "TEST",
-		EnvVarValue: "false",
-	})
-	expect(t, false, c.BoolT("test"))
-}
-
-func TestStringApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewStringFlag(cli.StringFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: "hello",
-	})
-	expect(t, "hello", c.String("test"))
-}
-
-func TestStringApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewStringFlag(cli.StringFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           "hello",
-		ContextValueString: "goodbye",
-	})
-	expect(t, "goodbye", c.String("test"))
-}
-
-func TestStringApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewStringFlag(cli.StringFlag{Name: "test", EnvVar: "TEST"}),
-		FlagName:    "test",
-		MapValue:    "hello",
-		EnvVarName:  "TEST",
-		EnvVarValue: "goodbye",
-	})
-	expect(t, "goodbye", c.String("test"))
-}
-
-func TestIntApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewIntFlag(cli.IntFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: 15,
-	})
-	expect(t, 15, c.Int("test"))
-}
-
-func TestIntApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewIntFlag(cli.IntFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           15,
-		ContextValueString: "7",
-	})
-	expect(t, 7, c.Int("test"))
-}
-
-func TestIntApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewIntFlag(cli.IntFlag{Name: "test", EnvVar: "TEST"}),
-		FlagName:    "test",
-		MapValue:    15,
-		EnvVarName:  "TEST",
-		EnvVarValue: "12",
-	})
-	expect(t, 12, c.Int("test"))
-}
-
-func TestDurationApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewDurationFlag(cli.DurationFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: time.Duration(30 * time.Second),
-	})
-	expect(t, time.Duration(30*time.Second), c.Duration("test"))
-}
-
-func TestDurationApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewDurationFlag(cli.DurationFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           time.Duration(30 * time.Second),
-		ContextValueString: time.Duration(15 * time.Second).String(),
-	})
-	expect(t, time.Duration(15*time.Second), c.Duration("test"))
-}
-
-func TestDurationApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewDurationFlag(cli.DurationFlag{Name: "test", EnvVar: "TEST"}),
-		FlagName:    "test",
-		MapValue:    time.Duration(30 * time.Second),
-		EnvVarName:  "TEST",
-		EnvVarValue: time.Duration(15 * time.Second).String(),
-	})
-	expect(t, time.Duration(15*time.Second), c.Duration("test"))
-}
-
-func TestFloat64ApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewFloat64Flag(cli.Float64Flag{Name: "test"}),
-		FlagName: "test",
-		MapValue: 1.3,
-	})
-	expect(t, 1.3, c.Float64("test"))
-}
-
-func TestFloat64ApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewFloat64Flag(cli.Float64Flag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           1.3,
-		ContextValueString: fmt.Sprintf("%v", 1.4),
-	})
-	expect(t, 1.4, c.Float64("test"))
-}
-
-func TestFloat64ApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewFloat64Flag(cli.Float64Flag{Name: "test", EnvVar: "TEST"}),
-		FlagName:    "test",
-		MapValue:    1.3,
-		EnvVarName:  "TEST",
-		EnvVarValue: fmt.Sprintf("%v", 1.4),
-	})
-	expect(t, 1.4, c.Float64("test"))
-}
-
-func runTest(t *testing.T, test testApplyInputSource) *cli.Context {
-	inputSource := &MapInputSource{valueMap: map[interface{}]interface{}{test.FlagName: test.MapValue}}
-	set := flag.NewFlagSet(test.FlagSetName, flag.ContinueOnError)
-	c := cli.NewContext(nil, set, nil)
-	if test.EnvVarName != "" && test.EnvVarValue != "" {
-		os.Setenv(test.EnvVarName, test.EnvVarValue)
-		defer os.Setenv(test.EnvVarName, "")
-	}
-
-	test.Flag.Apply(set)
-	if test.ContextValue != nil {
-		flag := set.Lookup(test.FlagName)
-		flag.Value = test.ContextValue
-	}
-	if test.ContextValueString != "" {
-		set.Set(test.FlagName, test.ContextValueString)
-	}
-	test.Flag.ApplyInputSourceValue(c, inputSource)
-
-	return c
-}
-
-type Parser [2]string
-
-func (p *Parser) Set(value string) error {
-	parts := strings.Split(value, ",")
-	if len(parts) != 2 {
-		return fmt.Errorf("invalid format")
-	}
-
-	(*p)[0] = parts[0]
-	(*p)[1] = parts[1]
-
-	return nil
-}
-
-func (p *Parser) String() string {
-	return fmt.Sprintf("%s,%s", p[0], p[1])
-}

vendor/github.com/codegangsta/cli/altsrc/helpers_test.go

@@ -1,18 +0,0 @@
-package altsrc
-
-import (
-	"reflect"
-	"testing"
-)
-
-func expect(t *testing.T, a interface{}, b interface{}) {
-	if !reflect.DeepEqual(b, a) {
-		t.Errorf("Expected %#v (type %v) - Got %#v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}
-
-func refute(t *testing.T, a interface{}, b interface{}) {
-	if a == b {
-		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}

vendor/github.com/codegangsta/cli/altsrc/input_source_context.go

@@ -1,21 +0,0 @@
-package altsrc
-
-import (
-	"time"
-
-	"gopkg.in/urfave/cli.v1"
-)
-
-// InputSourceContext is an interface used to allow
-// other input sources to be implemented as needed.
-type InputSourceContext interface {
-	Int(name string) (int, error)
-	Duration(name string) (time.Duration, error)
-	Float64(name string) (float64, error)
-	String(name string) (string, error)
-	StringSlice(name string) ([]string, error)
-	IntSlice(name string) ([]int, error)
-	Generic(name string) (cli.Generic, error)
-	Bool(name string) (bool, error)
-	BoolT(name string) (bool, error)
-}

vendor/github.com/codegangsta/cli/altsrc/map_input_source.go

@@ -1,248 +0,0 @@
-package altsrc
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"time"
-
-	"gopkg.in/urfave/cli.v1"
-)
-
-// MapInputSource implements InputSourceContext to return
-// data from the map that is loaded.
-type MapInputSource struct {
-	valueMap map[interface{}]interface{}
-}
-
-// nestedVal checks if the name has '.' delimiters.
-// If so, it tries to traverse the tree by the '.' delimited sections to find
-// a nested value for the key.
-func nestedVal(name string, tree map[interface{}]interface{}) (interface{}, bool) {
-	if sections := strings.Split(name, "."); len(sections) > 1 {
-		node := tree
-		for _, section := range sections[:len(sections)-1] {
-			if child, ok := node[section]; !ok {
-				return nil, false
-			} else {
-				if ctype, ok := child.(map[interface{}]interface{}); !ok {
-					return nil, false
-				} else {
-					node = ctype
-				}
-			}
-		}
-		if val, ok := node[sections[len(sections)-1]]; ok {
-			return val, true
-		}
-	}
-	return nil, false
-}
-
-// Int returns an int from the map if it exists otherwise returns 0
-func (fsm *MapInputSource) Int(name string) (int, error) {
-	otherGenericValue, exists := fsm.valueMap[name]
-	if exists {
-		otherValue, isType := otherGenericValue.(int)
-		if !isType {
-			return 0, incorrectTypeForFlagError(name, "int", otherGenericValue)
-		}
-		return otherValue, nil
-	}
-	nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
-	if exists {
-		otherValue, isType := nestedGenericValue.(int)
-		if !isType {
-			return 0, incorrectTypeForFlagError(name, "int", nestedGenericValue)
-		}
-		return otherValue, nil
-	}
-
-	return 0, nil
-}
-
-// Duration returns a duration from the map if it exists otherwise returns 0
-func (fsm *MapInputSource) Duration(name string) (time.Duration, error) {
-	otherGenericValue, exists := fsm.valueMap[name]
-	if exists {
-		otherValue, isType := otherGenericValue.(time.Duration)
-		if !isType {
-			return 0, incorrectTypeForFlagError(name, "duration", otherGenericValue)
-		}
-		return otherValue, nil
-	}
-	nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
-	if exists {
-		otherValue, isType := nestedGenericValue.(time.Duration)
-		if !isType {
-			return 0, incorrectTypeForFlagError(name, "duration", nestedGenericValue)
-		}
-		return otherValue, nil
-	}
-
-	return 0, nil
-}
-
-// Float64 returns an float64 from the map if it exists otherwise returns 0
-func (fsm *MapInputSource) Float64(name string) (float64, error) {
-	otherGenericValue, exists := fsm.valueMap[name]
-	if exists {
-		otherValue, isType := otherGenericValue.(float64)
-		if !isType {
-			return 0, incorrectTypeForFlagError(name, "float64", otherGenericValue)
-		}
-		return otherValue, nil
-	}
-	nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
-	if exists {
-		otherValue, isType := nestedGenericValue.(float64)
-		if !isType {
-			return 0, incorrectTypeForFlagError(name, "float64", nestedGenericValue)
-		}
-		return otherValue, nil
-	}
-
-	return 0, nil
-}
-
-// String returns a string from the map if it exists otherwise returns an empty string
-func (fsm *MapInputSource) String(name string) (string, error) {
-	otherGenericValue, exists := fsm.valueMap[name]
-	if exists {
-		otherValue, isType := otherGenericValue.(string)
-		if !isType {
-			return "", incorrectTypeForFlagError(name, "string", otherGenericValue)
-		}
-		return otherValue, nil
-	}
-	nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
-	if exists {
-		otherValue, isType := nestedGenericValue.(string)
-		if !isType {
-			return "", incorrectTypeForFlagError(name, "string", nestedGenericValue)
-		}
-		return otherValue, nil
-	}
-
-	return "", nil
-}
-
-// StringSlice returns an []string from the map if it exists otherwise returns nil
-func (fsm *MapInputSource) StringSlice(name string) ([]string, error) {
-	otherGenericValue, exists := fsm.valueMap[name]
-	if exists {
-		otherValue, isType := otherGenericValue.([]string)
-		if !isType {
-			return nil, incorrectTypeForFlagError(name, "[]string", otherGenericValue)
-		}
-		return otherValue, nil
-	}
-	nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
-	if exists {
-		otherValue, isType := nestedGenericValue.([]string)
-		if !isType {
-			return nil, incorrectTypeForFlagError(name, "[]string", nestedGenericValue)
-		}
-		return otherValue, nil
-	}
-
-	return nil, nil
-}
-
-// IntSlice returns an []int from the map if it exists otherwise returns nil
-func (fsm *MapInputSource) IntSlice(name string) ([]int, error) {
-	otherGenericValue, exists := fsm.valueMap[name]
-	if exists {
-		otherValue, isType := otherGenericValue.([]int)
-		if !isType {
-			return nil, incorrectTypeForFlagError(name, "[]int", otherGenericValue)
-		}
-		return otherValue, nil
-	}
-	nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
-	if exists {
-		otherValue, isType := nestedGenericValue.([]int)
-		if !isType {
-			return nil, incorrectTypeForFlagError(name, "[]int", nestedGenericValue)
-		}
-		return otherValue, nil
-	}
-
-	return nil, nil
-}
-
-// Generic returns an cli.Generic from the map if it exists otherwise returns nil
-func (fsm *MapInputSource) Generic(name string) (cli.Generic, error) {
-	otherGenericValue, exists := fsm.valueMap[name]
-	if exists {
-		otherValue, isType := otherGenericValue.(cli.Generic)
-		if !isType {
-			return nil, incorrectTypeForFlagError(name, "cli.Generic", otherGenericValue)
-		}
-		return otherValue, nil
-	}
-	nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
-	if exists {
-		otherValue, isType := nestedGenericValue.(cli.Generic)
-		if !isType {
-			return nil, incorrectTypeForFlagError(name, "cli.Generic", nestedGenericValue)
-		}
-		return otherValue, nil
-	}
-
-	return nil, nil
-}
-
-// Bool returns an bool from the map otherwise returns false
-func (fsm *MapInputSource) Bool(name string) (bool, error) {
-	otherGenericValue, exists := fsm.valueMap[name]
-	if exists {
-		otherValue, isType := otherGenericValue.(bool)
-		if !isType {
-			return false, incorrectTypeForFlagError(name, "bool", otherGenericValue)
-		}
-		return otherValue, nil
-	}
-	nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
-	if exists {
-		otherValue, isType := nestedGenericValue.(bool)
-		if !isType {
-			return false, incorrectTypeForFlagError(name, "bool", nestedGenericValue)
-		}
-		return otherValue, nil
-	}
-
-	return false, nil
-}
-
-// BoolT returns an bool from the map otherwise returns true
-func (fsm *MapInputSource) BoolT(name string) (bool, error) {
-	otherGenericValue, exists := fsm.valueMap[name]
-	if exists {
-		otherValue, isType := otherGenericValue.(bool)
-		if !isType {
-			return true, incorrectTypeForFlagError(name, "bool", otherGenericValue)
-		}
-		return otherValue, nil
-	}
-	nestedGenericValue, exists := nestedVal(name, fsm.valueMap)
-	if exists {
-		otherValue, isType := nestedGenericValue.(bool)
-		if !isType {
-			return true, incorrectTypeForFlagError(name, "bool", nestedGenericValue)
-		}
-		return otherValue, nil
-	}
-
-	return true, nil
-}
-
-func incorrectTypeForFlagError(name, expectedTypeName string, value interface{}) error {
-	valueType := reflect.TypeOf(value)
-	valueTypeName := ""
-	if valueType != nil {
-		valueTypeName = valueType.Name()
-	}
-
-	return fmt.Errorf("Mismatched type for flag '%s'. Expected '%s' but actual is '%s'", name, expectedTypeName, valueTypeName)
-}

vendor/github.com/codegangsta/cli/altsrc/toml_command_test.go

@@ -1,310 +0,0 @@
-// Disabling building of toml support in cases where golang is 1.0 or 1.1
-// as the encoding library is not implemented or supported.
-
-// +build go1.2
-
-package altsrc
-
-import (
-	"flag"
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"gopkg.in/urfave/cli.v1"
-)
-
-func TestCommandTomFileTest(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestGlobalEnvVarWins(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test", EnvVar: "THE_TEST"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestGlobalEnvVarWinsNested(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "top.test", EnvVar: "THE_TEST"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestSpecifiedFlagWins(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	test := []string{"test-cmd", "--load", "current.toml", "--test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestSpecifiedFlagWinsNested(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte(`[top]
-  test = 15`), 0666)
-	defer os.Remove("current.toml")
-
-	test := []string{"test-cmd", "--load", "current.toml", "--top.test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "top.test"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestDefaultValueFileWins(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test", Value: 7}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestDefaultValueFileWinsNested(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "top.test", Value: 7}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileFlagHasDefaultGlobalEnvTomlSetGlobalEnvWins(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test", Value: 7, EnvVar: "THE_TEST"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileFlagHasDefaultGlobalEnvTomlSetGlobalEnvWinsNested(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "top.test", Value: 7, EnvVar: "THE_TEST"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}

vendor/github.com/codegangsta/cli/altsrc/toml_file_loader.go

@@ -1,113 +0,0 @@
-// Disabling building of toml support in cases where golang is 1.0 or 1.1
-// as the encoding library is not implemented or supported.
-
-// +build go1.2
-
-package altsrc
-
-import (
-	"fmt"
-	"reflect"
-
-	"github.com/BurntSushi/toml"
-	"gopkg.in/urfave/cli.v1"
-)
-
-type tomlMap struct {
-	Map map[interface{}]interface{}
-}
-
-func unmarshalMap(i interface{}) (ret map[interface{}]interface{}, err error) {
-	ret = make(map[interface{}]interface{})
-	m := i.(map[string]interface{})
-	for key, val := range m {
-		v := reflect.ValueOf(val)
-		switch v.Kind() {
-		case reflect.Bool:
-			ret[key] = val.(bool)
-		case reflect.String:
-			ret[key] = val.(string)
-		case reflect.Int:
-			ret[key] = int(val.(int))
-		case reflect.Int8:
-			ret[key] = int(val.(int8))
-		case reflect.Int16:
-			ret[key] = int(val.(int16))
-		case reflect.Int32:
-			ret[key] = int(val.(int32))
-		case reflect.Int64:
-			ret[key] = int(val.(int64))
-		case reflect.Uint:
-			ret[key] = int(val.(uint))
-		case reflect.Uint8:
-			ret[key] = int(val.(uint8))
-		case reflect.Uint16:
-			ret[key] = int(val.(uint16))
-		case reflect.Uint32:
-			ret[key] = int(val.(uint32))
-		case reflect.Uint64:
-			ret[key] = int(val.(uint64))
-		case reflect.Float32:
-			ret[key] = float64(val.(float32))
-		case reflect.Float64:
-			ret[key] = float64(val.(float64))
-		case reflect.Map:
-			if tmp, err := unmarshalMap(val); err == nil {
-				ret[key] = tmp
-			} else {
-				return nil, err
-			}
-		case reflect.Array:
-			fallthrough // [todo] - Support array type
-		default:
-			return nil, fmt.Errorf("Unsupported: type = %#v", v.Kind())
-		}
-	}
-	return ret, nil
-}
-
-func (self *tomlMap) UnmarshalTOML(i interface{}) error {
-	if tmp, err := unmarshalMap(i); err == nil {
-		self.Map = tmp
-	} else {
-		return err
-	}
-	return nil
-}
-
-type tomlSourceContext struct {
-	FilePath string
-}
-
-// NewTomlSourceFromFile creates a new TOML InputSourceContext from a filepath.
-func NewTomlSourceFromFile(file string) (InputSourceContext, error) {
-	tsc := &tomlSourceContext{FilePath: file}
-	var results tomlMap = tomlMap{}
-	if err := readCommandToml(tsc.FilePath, &results); err != nil {
-		return nil, fmt.Errorf("Unable to load TOML file '%s': inner error: \n'%v'", tsc.FilePath, err.Error())
-	}
-	return &MapInputSource{valueMap: results.Map}, nil
-}
-
-// NewTomlSourceFromFlagFunc creates a new TOML InputSourceContext from a provided flag name and source context.
-func NewTomlSourceFromFlagFunc(flagFileName string) func(context *cli.Context) (InputSourceContext, error) {
-	return func(context *cli.Context) (InputSourceContext, error) {
-		filePath := context.String(flagFileName)
-		return NewTomlSourceFromFile(filePath)
-	}
-}
-
-func readCommandToml(filePath string, container interface{}) (err error) {
-	b, err := loadDataFrom(filePath)
-	if err != nil {
-		return err
-	}
-
-	err = toml.Unmarshal(b, container)
-	if err != nil {
-		return err
-	}
-
-	err = nil
-	return
-}

vendor/github.com/codegangsta/cli/altsrc/yaml_command_test.go

@@ -1,313 +0,0 @@
-// Disabling building of yaml support in cases where golang is 1.0 or 1.1
-// as the encoding library is not implemented or supported.
-
-// +build go1.2
-
-package altsrc
-
-import (
-	"flag"
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"gopkg.in/urfave/cli.v1"
-)
-
-func TestCommandYamlFileTest(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestGlobalEnvVarWins(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test", EnvVar: "THE_TEST"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestGlobalEnvVarWinsNested(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte(`top:
-  test: 15`), 0666)
-	defer os.Remove("current.yaml")
-
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "top.test", EnvVar: "THE_TEST"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestSpecifiedFlagWins(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-
-	test := []string{"test-cmd", "--load", "current.yaml", "--test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestSpecifiedFlagWinsNested(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte(`top:
-  test: 15`), 0666)
-	defer os.Remove("current.yaml")
-
-	test := []string{"test-cmd", "--load", "current.yaml", "--top.test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "top.test"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestDefaultValueFileWins(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test", Value: 7}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestDefaultValueFileWinsNested(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte(`top:
-  test: 15`), 0666)
-	defer os.Remove("current.yaml")
-
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "top.test", Value: 7}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileFlagHasDefaultGlobalEnvYamlSetGlobalEnvWins(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test", Value: 7, EnvVar: "THE_TEST"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileFlagHasDefaultGlobalEnvYamlSetGlobalEnvWinsNested(t *testing.T) {
-	app := cli.NewApp()
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte(`top:
-  test: 15`), 0666)
-	defer os.Remove("current.yaml")
-
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "top.test", Value: 7, EnvVar: "THE_TEST"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}

vendor/github.com/codegangsta/cli/altsrc/yaml_file_loader.go

@@ -1,92 +0,0 @@
-// Disabling building of yaml support in cases where golang is 1.0 or 1.1
-// as the encoding library is not implemented or supported.
-
-// +build go1.2
-
-package altsrc
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"os"
-	"runtime"
-	"strings"
-
-	"gopkg.in/urfave/cli.v1"
-
-	"gopkg.in/yaml.v2"
-)
-
-type yamlSourceContext struct {
-	FilePath string
-}
-
-// NewYamlSourceFromFile creates a new Yaml InputSourceContext from a filepath.
-func NewYamlSourceFromFile(file string) (InputSourceContext, error) {
-	ysc := &yamlSourceContext{FilePath: file}
-	var results map[interface{}]interface{}
-	err := readCommandYaml(ysc.FilePath, &results)
-	if err != nil {
-		return nil, fmt.Errorf("Unable to load Yaml file '%s': inner error: \n'%v'", ysc.FilePath, err.Error())
-	}
-
-	return &MapInputSource{valueMap: results}, nil
-}
-
-// NewYamlSourceFromFlagFunc creates a new Yaml InputSourceContext from a provided flag name and source context.
-func NewYamlSourceFromFlagFunc(flagFileName string) func(context *cli.Context) (InputSourceContext, error) {
-	return func(context *cli.Context) (InputSourceContext, error) {
-		filePath := context.String(flagFileName)
-		return NewYamlSourceFromFile(filePath)
-	}
-}
-
-func readCommandYaml(filePath string, container interface{}) (err error) {
-	b, err := loadDataFrom(filePath)
-	if err != nil {
-		return err
-	}
-
-	err = yaml.Unmarshal(b, container)
-	if err != nil {
-		return err
-	}
-
-	err = nil
-	return
-}
-
-func loadDataFrom(filePath string) ([]byte, error) {
-	u, err := url.Parse(filePath)
-	if err != nil {
-		return nil, err
-	}
-
-	if u.Host != "" { // i have a host, now do i support the scheme?
-		switch u.Scheme {
-		case "http", "https":
-			res, err := http.Get(filePath)
-			if err != nil {
-				return nil, err
-			}
-			return ioutil.ReadAll(res.Body)
-		default:
-			return nil, fmt.Errorf("scheme of %s is unsupported", filePath)
-		}
-	} else if u.Path != "" { // i dont have a host, but I have a path. I am a local file.
-		if _, notFoundFileErr := os.Stat(filePath); notFoundFileErr != nil {
-			return nil, fmt.Errorf("Cannot read from file: '%s' because it does not exist.", filePath)
-		}
-		return ioutil.ReadFile(filePath)
-	} else if runtime.GOOS == "windows" && strings.Contains(u.String(), "\\") {
-		// on Windows systems u.Path is always empty, so we need to check the string directly.
-		if _, notFoundFileErr := os.Stat(filePath); notFoundFileErr != nil {
-			return nil, fmt.Errorf("Cannot read from file: '%s' because it does not exist.", filePath)
-		}
-		return ioutil.ReadFile(filePath)
-	} else {
-		return nil, fmt.Errorf("unable to determine how to load from path %s", filePath)
-	}
-}

vendor/github.com/codegangsta/cli/app.go

@@ -1,492 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"sort"
-	"time"
-)
-
-var (
-	changeLogURL                    = "https://github.com/urfave/cli/blob/master/CHANGELOG.md"
-	appActionDeprecationURL         = fmt.Sprintf("%s#deprecated-cli-app-action-signature", changeLogURL)
-	runAndExitOnErrorDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-runandexitonerror", changeLogURL)
-
-	contactSysadmin = "This is an error in the application.  Please contact the distributor of this application if this is not you."
-
-	errInvalidActionType = NewExitError("ERROR invalid Action type. "+
-		fmt.Sprintf("Must be `func(*Context`)` or `func(*Context) error).  %s", contactSysadmin)+
-		fmt.Sprintf("See %s", appActionDeprecationURL), 2)
-)
-
-// App is the main structure of a cli application. It is recommended that
-// an app be created with the cli.NewApp() function
-type App struct {
-	// The name of the program. Defaults to path.Base(os.Args[0])
-	Name string
-	// Full name of command for help, defaults to Name
-	HelpName string
-	// Description of the program.
-	Usage string
-	// Text to override the USAGE section of help
-	UsageText string
-	// Description of the program argument format.
-	ArgsUsage string
-	// Version of the program
-	Version string
-	// Description of the program
-	Description string
-	// List of commands to execute
-	Commands []Command
-	// List of flags to parse
-	Flags []Flag
-	// Boolean to enable bash completion commands
-	EnableBashCompletion bool
-	// Boolean to hide built-in help command
-	HideHelp bool
-	// Boolean to hide built-in version flag and the VERSION section of help
-	HideVersion bool
-	// Populate on app startup, only gettable through method Categories()
-	categories CommandCategories
-	// An action to execute when the bash-completion flag is set
-	BashComplete BashCompleteFunc
-	// An action to execute before any subcommands are run, but after the context is ready
-	// If a non-nil error is returned, no subcommands are run
-	Before BeforeFunc
-	// An action to execute after any subcommands are run, but after the subcommand has finished
-	// It is run even if Action() panics
-	After AfterFunc
-
-	// The action to execute when no subcommands are specified
-	// Expects a `cli.ActionFunc` but will accept the *deprecated* signature of `func(*cli.Context) {}`
-	// *Note*: support for the deprecated `Action` signature will be removed in a future version
-	Action interface{}
-
-	// Execute this function if the proper command cannot be found
-	CommandNotFound CommandNotFoundFunc
-	// Execute this function if an usage error occurs
-	OnUsageError OnUsageErrorFunc
-	// Compilation date
-	Compiled time.Time
-	// List of all authors who contributed
-	Authors []Author
-	// Copyright of the binary if any
-	Copyright string
-	// Name of Author (Note: Use App.Authors, this is deprecated)
-	Author string
-	// Email of Author (Note: Use App.Authors, this is deprecated)
-	Email string
-	// Writer writer to write output to
-	Writer io.Writer
-	// ErrWriter writes error output
-	ErrWriter io.Writer
-	// Other custom info
-	Metadata map[string]interface{}
-
-	didSetup bool
-}
-
-// Tries to find out when this binary was compiled.
-// Returns the current time if it fails to find it.
-func compileTime() time.Time {
-	info, err := os.Stat(os.Args[0])
-	if err != nil {
-		return time.Now()
-	}
-	return info.ModTime()
-}
-
-// NewApp creates a new cli Application with some reasonable defaults for Name,
-// Usage, Version and Action.
-func NewApp() *App {
-	return &App{
-		Name:         filepath.Base(os.Args[0]),
-		HelpName:     filepath.Base(os.Args[0]),
-		Usage:        "A new cli application",
-		UsageText:    "",
-		Version:      "0.0.0",
-		BashComplete: DefaultAppComplete,
-		Action:       helpCommand.Action,
-		Compiled:     compileTime(),
-		Writer:       os.Stdout,
-	}
-}
-
-// Setup runs initialization code to ensure all data structures are ready for
-// `Run` or inspection prior to `Run`.  It is internally called by `Run`, but
-// will return early if setup has already happened.
-func (a *App) Setup() {
-	if a.didSetup {
-		return
-	}
-
-	a.didSetup = true
-
-	if a.Author != "" || a.Email != "" {
-		a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email})
-	}
-
-	newCmds := []Command{}
-	for _, c := range a.Commands {
-		if c.HelpName == "" {
-			c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
-		}
-		newCmds = append(newCmds, c)
-	}
-	a.Commands = newCmds
-
-	if a.Command(helpCommand.Name) == nil && !a.HideHelp {
-		a.Commands = append(a.Commands, helpCommand)
-		if (HelpFlag != BoolFlag{}) {
-			a.appendFlag(HelpFlag)
-		}
-	}
-
-	if !a.HideVersion {
-		a.appendFlag(VersionFlag)
-	}
-
-	a.categories = CommandCategories{}
-	for _, command := range a.Commands {
-		a.categories = a.categories.AddCommand(command.Category, command)
-	}
-	sort.Sort(a.categories)
-
-	if a.Metadata == nil {
-		a.Metadata = make(map[string]interface{})
-	}
-
-	if a.Writer == nil {
-		a.Writer = os.Stdout
-	}
-}
-
-// Run is the entry point to the cli app. Parses the arguments slice and routes
-// to the proper flag/args combination
-func (a *App) Run(arguments []string) (err error) {
-	a.Setup()
-
-	// handle the completion flag separately from the flagset since
-	// completion could be attempted after a flag, but before its value was put
-	// on the command line. this causes the flagset to interpret the completion
-	// flag name as the value of the flag before it which is undesirable
-	// note that we can only do this because the shell autocomplete function
-	// always appends the completion flag at the end of the command
-	shellComplete, arguments := checkShellCompleteFlag(a, arguments)
-
-	// parse flags
-	set, err := flagSet(a.Name, a.Flags)
-	if err != nil {
-		return err
-	}
-
-	set.SetOutput(ioutil.Discard)
-	err = set.Parse(arguments[1:])
-	nerr := normalizeFlags(a.Flags, set)
-	context := NewContext(a, set, nil)
-	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
-		ShowAppHelp(context)
-		return nerr
-	}
-	context.shellComplete = shellComplete
-
-	if checkCompletions(context) {
-		return nil
-	}
-
-	if err != nil {
-		if a.OnUsageError != nil {
-			err := a.OnUsageError(context, err, false)
-			HandleExitCoder(err)
-			return err
-		}
-		fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
-		ShowAppHelp(context)
-		return err
-	}
-
-	if !a.HideHelp && checkHelp(context) {
-		ShowAppHelp(context)
-		return nil
-	}
-
-	if !a.HideVersion && checkVersion(context) {
-		ShowVersion(context)
-		return nil
-	}
-
-	if a.After != nil {
-		defer func() {
-			if afterErr := a.After(context); afterErr != nil {
-				if err != nil {
-					err = NewMultiError(err, afterErr)
-				} else {
-					err = afterErr
-				}
-			}
-		}()
-	}
-
-	if a.Before != nil {
-		beforeErr := a.Before(context)
-		if beforeErr != nil {
-			fmt.Fprintf(a.Writer, "%v\n\n", beforeErr)
-			ShowAppHelp(context)
-			HandleExitCoder(beforeErr)
-			err = beforeErr
-			return err
-		}
-	}
-
-	args := context.Args()
-	if args.Present() {
-		name := args.First()
-		c := a.Command(name)
-		if c != nil {
-			return c.Run(context)
-		}
-	}
-
-	if a.Action == nil {
-		a.Action = helpCommand.Action
-	}
-
-	// Run default Action
-	err = HandleAction(a.Action, context)
-
-	HandleExitCoder(err)
-	return err
-}
-
-// RunAndExitOnError calls .Run() and exits non-zero if an error was returned
-//
-// Deprecated: instead you should return an error that fulfills cli.ExitCoder
-// to cli.App.Run. This will cause the application to exit with the given eror
-// code in the cli.ExitCoder
-func (a *App) RunAndExitOnError() {
-	if err := a.Run(os.Args); err != nil {
-		fmt.Fprintln(a.errWriter(), err)
-		OsExiter(1)
-	}
-}
-
-// RunAsSubcommand invokes the subcommand given the context, parses ctx.Args() to
-// generate command-specific flags
-func (a *App) RunAsSubcommand(ctx *Context) (err error) {
-	// append help to commands
-	if len(a.Commands) > 0 {
-		if a.Command(helpCommand.Name) == nil && !a.HideHelp {
-			a.Commands = append(a.Commands, helpCommand)
-			if (HelpFlag != BoolFlag{}) {
-				a.appendFlag(HelpFlag)
-			}
-		}
-	}
-
-	newCmds := []Command{}
-	for _, c := range a.Commands {
-		if c.HelpName == "" {
-			c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
-		}
-		newCmds = append(newCmds, c)
-	}
-	a.Commands = newCmds
-
-	// parse flags
-	set, err := flagSet(a.Name, a.Flags)
-	if err != nil {
-		return err
-	}
-
-	set.SetOutput(ioutil.Discard)
-	err = set.Parse(ctx.Args().Tail())
-	nerr := normalizeFlags(a.Flags, set)
-	context := NewContext(a, set, ctx)
-
-	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
-		fmt.Fprintln(a.Writer)
-		if len(a.Commands) > 0 {
-			ShowSubcommandHelp(context)
-		} else {
-			ShowCommandHelp(ctx, context.Args().First())
-		}
-		return nerr
-	}
-
-	if checkCompletions(context) {
-		return nil
-	}
-
-	if err != nil {
-		if a.OnUsageError != nil {
-			err = a.OnUsageError(context, err, true)
-			HandleExitCoder(err)
-			return err
-		}
-		fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
-		ShowSubcommandHelp(context)
-		return err
-	}
-
-	if len(a.Commands) > 0 {
-		if checkSubcommandHelp(context) {
-			return nil
-		}
-	} else {
-		if checkCommandHelp(ctx, context.Args().First()) {
-			return nil
-		}
-	}
-
-	if a.After != nil {
-		defer func() {
-			afterErr := a.After(context)
-			if afterErr != nil {
-				HandleExitCoder(err)
-				if err != nil {
-					err = NewMultiError(err, afterErr)
-				} else {
-					err = afterErr
-				}
-			}
-		}()
-	}
-
-	if a.Before != nil {
-		beforeErr := a.Before(context)
-		if beforeErr != nil {
-			HandleExitCoder(beforeErr)
-			err = beforeErr
-			return err
-		}
-	}
-
-	args := context.Args()
-	if args.Present() {
-		name := args.First()
-		c := a.Command(name)
-		if c != nil {
-			return c.Run(context)
-		}
-	}
-
-	// Run default Action
-	err = HandleAction(a.Action, context)
-
-	HandleExitCoder(err)
-	return err
-}
-
-// Command returns the named command on App. Returns nil if the command does not exist
-func (a *App) Command(name string) *Command {
-	for _, c := range a.Commands {
-		if c.HasName(name) {
-			return &c
-		}
-	}
-
-	return nil
-}
-
-// Categories returns a slice containing all the categories with the commands they contain
-func (a *App) Categories() CommandCategories {
-	return a.categories
-}
-
-// VisibleCategories returns a slice of categories and commands that are
-// Hidden=false
-func (a *App) VisibleCategories() []*CommandCategory {
-	ret := []*CommandCategory{}
-	for _, category := range a.categories {
-		if visible := func() *CommandCategory {
-			for _, command := range category.Commands {
-				if !command.Hidden {
-					return category
-				}
-			}
-			return nil
-		}(); visible != nil {
-			ret = append(ret, visible)
-		}
-	}
-	return ret
-}
-
-// VisibleCommands returns a slice of the Commands with Hidden=false
-func (a *App) VisibleCommands() []Command {
-	ret := []Command{}
-	for _, command := range a.Commands {
-		if !command.Hidden {
-			ret = append(ret, command)
-		}
-	}
-	return ret
-}
-
-// VisibleFlags returns a slice of the Flags with Hidden=false
-func (a *App) VisibleFlags() []Flag {
-	return visibleFlags(a.Flags)
-}
-
-func (a *App) hasFlag(flag Flag) bool {
-	for _, f := range a.Flags {
-		if flag == f {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (a *App) errWriter() io.Writer {
-
-	// When the app ErrWriter is nil use the package level one.
-	if a.ErrWriter == nil {
-		return ErrWriter
-	}
-
-	return a.ErrWriter
-}
-
-func (a *App) appendFlag(flag Flag) {
-	if !a.hasFlag(flag) {
-		a.Flags = append(a.Flags, flag)
-	}
-}
-
-// Author represents someone who has contributed to a cli project.
-type Author struct {
-	Name  string // The Authors name
-	Email string // The Authors email
-}
-
-// String makes Author comply to the Stringer interface, to allow an easy print in the templating process
-func (a Author) String() string {
-	e := ""
-	if a.Email != "" {
-		e = " <" + a.Email + ">"
-	}
-
-	return fmt.Sprintf("%v%v", a.Name, e)
-}
-
-// HandleAction attempts to figure out which Action signature was used.  If
-// it's an ActionFunc or a func with the legacy signature for Action, the func
-// is run!
-func HandleAction(action interface{}, context *Context) (err error) {
-	if a, ok := action.(ActionFunc); ok {
-		return a(context)
-	} else if a, ok := action.(func(*Context) error); ok {
-		return a(context)
-	} else if a, ok := action.(func(*Context)); ok { // deprecated function signature
-		a(context)
-		return nil
-	} else {
-		return errInvalidActionType
-	}
-}

vendor/github.com/codegangsta/cli/appveyor.yml

@@ -1,24 +0,0 @@
-version: "{build}"
-
-os: Windows Server 2012 R2
-
-clone_folder: c:\gopath\src\github.com\urfave\cli
-
-environment:
-  GOPATH: C:\gopath
-  GOVERSION: 1.6
-  PYTHON: C:\Python27-x64
-  PYTHON_VERSION: 2.7.x
-  PYTHON_ARCH: 64
-
-install:
-- set PATH=%GOPATH%\bin;C:\go\bin;%PATH%
-- go version
-- go env
-- go get github.com/urfave/gfmrun/...
-- go get -v -t ./...
-
-build_script:
-- python runtests vet
-- python runtests test
-- python runtests gfmrun

vendor/github.com/codegangsta/cli/autocomplete/bash_autocomplete

@@ -1,14 +0,0 @@
-#! /bin/bash
-
-: ${PROG:=$(basename ${BASH_SOURCE})}
-
-_cli_bash_autocomplete() {
-     local cur opts base
-     COMPREPLY=()
-     cur="${COMP_WORDS[COMP_CWORD]}"
-     opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
-     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
-     return 0
- }
-  
- complete -F _cli_bash_autocomplete $PROG

vendor/github.com/codegangsta/cli/autocomplete/zsh_autocomplete

@@ -1,5 +0,0 @@
-autoload -U compinit && compinit
-autoload -U bashcompinit && bashcompinit
-
-script_dir=$(dirname $0)
-source ${script_dir}/bash_autocomplete

vendor/github.com/codegangsta/cli/category.go

@@ -1,44 +0,0 @@
-package cli
-
-// CommandCategories is a slice of *CommandCategory.
-type CommandCategories []*CommandCategory
-
-// CommandCategory is a category containing commands.
-type CommandCategory struct {
-	Name     string
-	Commands Commands
-}
-
-func (c CommandCategories) Less(i, j int) bool {
-	return c[i].Name < c[j].Name
-}
-
-func (c CommandCategories) Len() int {
-	return len(c)
-}
-
-func (c CommandCategories) Swap(i, j int) {
-	c[i], c[j] = c[j], c[i]
-}
-
-// AddCommand adds a command to a category.
-func (c CommandCategories) AddCommand(category string, command Command) CommandCategories {
-	for _, commandCategory := range c {
-		if commandCategory.Name == category {
-			commandCategory.Commands = append(commandCategory.Commands, command)
-			return c
-		}
-	}
-	return append(c, &CommandCategory{Name: category, Commands: []Command{command}})
-}
-
-// VisibleCommands returns a slice of the Commands with Hidden=false
-func (c *CommandCategory) VisibleCommands() []Command {
-	ret := []Command{}
-	for _, command := range c.Commands {
-		if !command.Hidden {
-			ret = append(ret, command)
-		}
-	}
-	return ret
-}

vendor/github.com/codegangsta/cli/cli.go

@@ -1,21 +0,0 @@
-// Package cli provides a minimal framework for creating and organizing command line
-// Go applications. cli is designed to be easy to understand and write, the most simple
-// cli application can be written as follows:
-//   func main() {
-//     cli.NewApp().Run(os.Args)
-//   }
-//
-// Of course this application does not do much, so let's make this an actual application:
-//   func main() {
-//     app := cli.NewApp()
-//     app.Name = "greet"
-//     app.Usage = "say a greeting"
-//     app.Action = func(c *cli.Context) error {
-//       println("Greetings")
-//     }
-//
-//     app.Run(os.Args)
-//   }
-package cli
-
-//go:generate python ./generate-flag-types cli -i flag-types.json -o flag_generated.go

vendor/github.com/codegangsta/cli/command.go

@@ -1,299 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io/ioutil"
-	"sort"
-	"strings"
-)
-
-// Command is a subcommand for a cli.App.
-type Command struct {
-	// The name of the command
-	Name string
-	// short name of the command. Typically one character (deprecated, use `Aliases`)
-	ShortName string
-	// A list of aliases for the command
-	Aliases []string
-	// A short description of the usage of this command
-	Usage string
-	// Custom text to show on USAGE section of help
-	UsageText string
-	// A longer explanation of how the command works
-	Description string
-	// A short description of the arguments of this command
-	ArgsUsage string
-	// The category the command is part of
-	Category string
-	// The function to call when checking for bash command completions
-	BashComplete BashCompleteFunc
-	// An action to execute before any sub-subcommands are run, but after the context is ready
-	// If a non-nil error is returned, no sub-subcommands are run
-	Before BeforeFunc
-	// An action to execute after any subcommands are run, but after the subcommand has finished
-	// It is run even if Action() panics
-	After AfterFunc
-	// The function to call when this command is invoked
-	Action interface{}
-	// TODO: replace `Action: interface{}` with `Action: ActionFunc` once some kind
-	// of deprecation period has passed, maybe?
-
-	// Execute this function if a usage error occurs.
-	OnUsageError OnUsageErrorFunc
-	// List of child commands
-	Subcommands Commands
-	// List of flags to parse
-	Flags []Flag
-	// Treat all flags as normal arguments if true
-	SkipFlagParsing bool
-	// Skip argument reordering which attempts to move flags before arguments,
-	// but only works if all flags appear after all arguments. This behavior was
-	// removed n version 2 since it only works under specific conditions so we
-	// backport here by exposing it as an option for compatibility.
-	SkipArgReorder bool
-	// Boolean to hide built-in help command
-	HideHelp bool
-	// Boolean to hide this command from help or completion
-	Hidden bool
-
-	// Full name of command for help, defaults to full command name, including parent commands.
-	HelpName        string
-	commandNamePath []string
-}
-
-type CommandsByName []Command
-
-func (c CommandsByName) Len() int {
-	return len(c)
-}
-
-func (c CommandsByName) Less(i, j int) bool {
-	return c[i].Name < c[j].Name
-}
-
-func (c CommandsByName) Swap(i, j int) {
-	c[i], c[j] = c[j], c[i]
-}
-
-// FullName returns the full name of the command.
-// For subcommands this ensures that parent commands are part of the command path
-func (c Command) FullName() string {
-	if c.commandNamePath == nil {
-		return c.Name
-	}
-	return strings.Join(c.commandNamePath, " ")
-}
-
-// Commands is a slice of Command
-type Commands []Command
-
-// Run invokes the command given the context, parses ctx.Args() to generate command-specific flags
-func (c Command) Run(ctx *Context) (err error) {
-	if len(c.Subcommands) > 0 {
-		return c.startApp(ctx)
-	}
-
-	if !c.HideHelp && (HelpFlag != BoolFlag{}) {
-		// append help to flags
-		c.Flags = append(
-			c.Flags,
-			HelpFlag,
-		)
-	}
-
-	set, err := flagSet(c.Name, c.Flags)
-	if err != nil {
-		return err
-	}
-	set.SetOutput(ioutil.Discard)
-
-	if c.SkipFlagParsing {
-		err = set.Parse(append([]string{"--"}, ctx.Args().Tail()...))
-	} else if !c.SkipArgReorder {
-		firstFlagIndex := -1
-		terminatorIndex := -1
-		for index, arg := range ctx.Args() {
-			if arg == "--" {
-				terminatorIndex = index
-				break
-			} else if arg == "-" {
-				// Do nothing. A dash alone is not really a flag.
-				continue
-			} else if strings.HasPrefix(arg, "-") && firstFlagIndex == -1 {
-				firstFlagIndex = index
-			}
-		}
-
-		if firstFlagIndex > -1 {
-			args := ctx.Args()
-			regularArgs := make([]string, len(args[1:firstFlagIndex]))
-			copy(regularArgs, args[1:firstFlagIndex])
-
-			var flagArgs []string
-			if terminatorIndex > -1 {
-				flagArgs = args[firstFlagIndex:terminatorIndex]
-				regularArgs = append(regularArgs, args[terminatorIndex:]...)
-			} else {
-				flagArgs = args[firstFlagIndex:]
-			}
-
-			err = set.Parse(append(flagArgs, regularArgs...))
-		} else {
-			err = set.Parse(ctx.Args().Tail())
-		}
-	} else {
-		err = set.Parse(ctx.Args().Tail())
-	}
-
-	nerr := normalizeFlags(c.Flags, set)
-	if nerr != nil {
-		fmt.Fprintln(ctx.App.Writer, nerr)
-		fmt.Fprintln(ctx.App.Writer)
-		ShowCommandHelp(ctx, c.Name)
-		return nerr
-	}
-
-	context := NewContext(ctx.App, set, ctx)
-	if checkCommandCompletions(context, c.Name) {
-		return nil
-	}
-
-	if err != nil {
-		if c.OnUsageError != nil {
-			err := c.OnUsageError(ctx, err, false)
-			HandleExitCoder(err)
-			return err
-		}
-		fmt.Fprintln(ctx.App.Writer, "Incorrect Usage:", err.Error())
-		fmt.Fprintln(ctx.App.Writer)
-		ShowCommandHelp(ctx, c.Name)
-		return err
-	}
-
-	if checkCommandHelp(context, c.Name) {
-		return nil
-	}
-
-	if c.After != nil {
-		defer func() {
-			afterErr := c.After(context)
-			if afterErr != nil {
-				HandleExitCoder(err)
-				if err != nil {
-					err = NewMultiError(err, afterErr)
-				} else {
-					err = afterErr
-				}
-			}
-		}()
-	}
-
-	if c.Before != nil {
-		err = c.Before(context)
-		if err != nil {
-			fmt.Fprintln(ctx.App.Writer, err)
-			fmt.Fprintln(ctx.App.Writer)
-			ShowCommandHelp(ctx, c.Name)
-			HandleExitCoder(err)
-			return err
-		}
-	}
-
-	if c.Action == nil {
-		c.Action = helpSubcommand.Action
-	}
-
-	context.Command = c
-	err = HandleAction(c.Action, context)
-
-	if err != nil {
-		HandleExitCoder(err)
-	}
-	return err
-}
-
-// Names returns the names including short names and aliases.
-func (c Command) Names() []string {
-	names := []string{c.Name}
-
-	if c.ShortName != "" {
-		names = append(names, c.ShortName)
-	}
-
-	return append(names, c.Aliases...)
-}
-
-// HasName returns true if Command.Name or Command.ShortName matches given name
-func (c Command) HasName(name string) bool {
-	for _, n := range c.Names() {
-		if n == name {
-			return true
-		}
-	}
-	return false
-}
-
-func (c Command) startApp(ctx *Context) error {
-	app := NewApp()
-	app.Metadata = ctx.App.Metadata
-	// set the name and usage
-	app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
-	if c.HelpName == "" {
-		app.HelpName = c.HelpName
-	} else {
-		app.HelpName = app.Name
-	}
-
-	app.Usage = c.Usage
-	app.Description = c.Description
-	app.ArgsUsage = c.ArgsUsage
-
-	// set CommandNotFound
-	app.CommandNotFound = ctx.App.CommandNotFound
-
-	// set the flags and commands
-	app.Commands = c.Subcommands
-	app.Flags = c.Flags
-	app.HideHelp = c.HideHelp
-
-	app.Version = ctx.App.Version
-	app.HideVersion = ctx.App.HideVersion
-	app.Compiled = ctx.App.Compiled
-	app.Author = ctx.App.Author
-	app.Email = ctx.App.Email
-	app.Writer = ctx.App.Writer
-	app.ErrWriter = ctx.App.ErrWriter
-
-	app.categories = CommandCategories{}
-	for _, command := range c.Subcommands {
-		app.categories = app.categories.AddCommand(command.Category, command)
-	}
-
-	sort.Sort(app.categories)
-
-	// bash completion
-	app.EnableBashCompletion = ctx.App.EnableBashCompletion
-	if c.BashComplete != nil {
-		app.BashComplete = c.BashComplete
-	}
-
-	// set the actions
-	app.Before = c.Before
-	app.After = c.After
-	if c.Action != nil {
-		app.Action = c.Action
-	} else {
-		app.Action = helpSubcommand.Action
-	}
-
-	for index, cc := range app.Commands {
-		app.Commands[index].commandNamePath = []string{c.Name, cc.Name}
-	}
-
-	return app.RunAsSubcommand(ctx)
-}
-
-// VisibleFlags returns a slice of the Flags with Hidden=false
-func (c Command) VisibleFlags() []Flag {
-	return visibleFlags(c.Flags)
-}

vendor/github.com/codegangsta/cli/command_test.go

@@ -1,184 +0,0 @@
-package cli
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"strings"
-	"testing"
-)
-
-func TestCommandFlagParsing(t *testing.T) {
-	cases := []struct {
-		testArgs        []string
-		skipFlagParsing bool
-		skipArgReorder  bool
-		expectedErr     error
-	}{
-		// Test normal "not ignoring flags" flow
-		{[]string{"test-cmd", "blah", "blah", "-break"}, false, false, errors.New("flag provided but not defined: -break")},
-
-		// Test no arg reorder
-		{[]string{"test-cmd", "blah", "blah", "-break"}, false, true, nil},
-
-		{[]string{"test-cmd", "blah", "blah"}, true, false, nil},   // Test SkipFlagParsing without any args that look like flags
-		{[]string{"test-cmd", "blah", "-break"}, true, false, nil}, // Test SkipFlagParsing with random flag arg
-		{[]string{"test-cmd", "blah", "-help"}, true, false, nil},  // Test SkipFlagParsing with "special" help flag arg
-	}
-
-	for _, c := range cases {
-		app := NewApp()
-		app.Writer = ioutil.Discard
-		set := flag.NewFlagSet("test", 0)
-		set.Parse(c.testArgs)
-
-		context := NewContext(app, set, nil)
-
-		command := Command{
-			Name:            "test-cmd",
-			Aliases:         []string{"tc"},
-			Usage:           "this is for testing",
-			Description:     "testing",
-			Action:          func(_ *Context) error { return nil },
-			SkipFlagParsing: c.skipFlagParsing,
-			SkipArgReorder:  c.skipArgReorder,
-		}
-
-		err := command.Run(context)
-
-		expect(t, err, c.expectedErr)
-		expect(t, []string(context.Args()), c.testArgs)
-	}
-}
-
-func TestCommand_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
-	app := NewApp()
-	app.Commands = []Command{
-		{
-			Name: "bar",
-			Before: func(c *Context) error {
-				return fmt.Errorf("before error")
-			},
-			After: func(c *Context) error {
-				return fmt.Errorf("after error")
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar"})
-	if err == nil {
-		t.Fatalf("expected to receive error from Run, got none")
-	}
-
-	if !strings.Contains(err.Error(), "before error") {
-		t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
-	}
-	if !strings.Contains(err.Error(), "after error") {
-		t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
-	}
-}
-
-func TestCommand_Run_BeforeSavesMetadata(t *testing.T) {
-	var receivedMsgFromAction string
-	var receivedMsgFromAfter string
-
-	app := NewApp()
-	app.Commands = []Command{
-		{
-			Name: "bar",
-			Before: func(c *Context) error {
-				c.App.Metadata["msg"] = "hello world"
-				return nil
-			},
-			Action: func(c *Context) error {
-				msg, ok := c.App.Metadata["msg"]
-				if !ok {
-					return errors.New("msg not found")
-				}
-				receivedMsgFromAction = msg.(string)
-				return nil
-			},
-			After: func(c *Context) error {
-				msg, ok := c.App.Metadata["msg"]
-				if !ok {
-					return errors.New("msg not found")
-				}
-				receivedMsgFromAfter = msg.(string)
-				return nil
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar"})
-	if err != nil {
-		t.Fatalf("expected no error from Run, got %s", err)
-	}
-
-	expectedMsg := "hello world"
-
-	if receivedMsgFromAction != expectedMsg {
-		t.Fatalf("expected msg from Action to match. Given: %q\nExpected: %q",
-			receivedMsgFromAction, expectedMsg)
-	}
-	if receivedMsgFromAfter != expectedMsg {
-		t.Fatalf("expected msg from After to match. Given: %q\nExpected: %q",
-			receivedMsgFromAction, expectedMsg)
-	}
-}
-
-func TestCommand_OnUsageError_WithWrongFlagValue(t *testing.T) {
-	app := NewApp()
-	app.Commands = []Command{
-		{
-			Name: "bar",
-			Flags: []Flag{
-				IntFlag{Name: "flag"},
-			},
-			OnUsageError: func(c *Context, err error, _ bool) error {
-				if !strings.HasPrefix(err.Error(), "invalid value \"wrong\"") {
-					t.Errorf("Expect an invalid value error, but got \"%v\"", err)
-				}
-				return errors.New("intercepted: " + err.Error())
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar", "--flag=wrong"})
-	if err == nil {
-		t.Fatalf("expected to receive error from Run, got none")
-	}
-
-	if !strings.HasPrefix(err.Error(), "intercepted: invalid value") {
-		t.Errorf("Expect an intercepted error, but got \"%v\"", err)
-	}
-}
-
-func TestCommand_Run_SubcommandsCanUseErrWriter(t *testing.T) {
-	app := NewApp()
-	app.ErrWriter = ioutil.Discard
-	app.Commands = []Command{
-		{
-			Name:  "bar",
-			Usage: "this is for testing",
-			Subcommands: []Command{
-				{
-					Name:  "baz",
-					Usage: "this is for testing",
-					Action: func(c *Context) error {
-						if c.App.ErrWriter != ioutil.Discard {
-							return fmt.Errorf("ErrWriter not passed")
-						}
-
-						return nil
-					},
-				},
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar", "baz"})
-	if err != nil {
-		t.Fatal(err)
-	}
-}

vendor/github.com/codegangsta/cli/context.go

@@ -1,276 +0,0 @@
-package cli
-
-import (
-	"errors"
-	"flag"
-	"reflect"
-	"strings"
-	"syscall"
-)
-
-// Context is a type that is passed through to
-// each Handler action in a cli application. Context
-// can be used to retrieve context-specific Args and
-// parsed command-line options.
-type Context struct {
-	App           *App
-	Command       Command
-	shellComplete bool
-	flagSet       *flag.FlagSet
-	setFlags      map[string]bool
-	parentContext *Context
-}
-
-// NewContext creates a new context. For use in when invoking an App or Command action.
-func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
-	c := &Context{App: app, flagSet: set, parentContext: parentCtx}
-
-	if parentCtx != nil {
-		c.shellComplete = parentCtx.shellComplete
-	}
-
-	return c
-}
-
-// NumFlags returns the number of flags set
-func (c *Context) NumFlags() int {
-	return c.flagSet.NFlag()
-}
-
-// Set sets a context flag to a value.
-func (c *Context) Set(name, value string) error {
-	return c.flagSet.Set(name, value)
-}
-
-// GlobalSet sets a context flag to a value on the global flagset
-func (c *Context) GlobalSet(name, value string) error {
-	return globalContext(c).flagSet.Set(name, value)
-}
-
-// IsSet determines if the flag was actually set
-func (c *Context) IsSet(name string) bool {
-	if c.setFlags == nil {
-		c.setFlags = make(map[string]bool)
-
-		c.flagSet.Visit(func(f *flag.Flag) {
-			c.setFlags[f.Name] = true
-		})
-
-		c.flagSet.VisitAll(func(f *flag.Flag) {
-			if _, ok := c.setFlags[f.Name]; ok {
-				return
-			}
-			c.setFlags[f.Name] = false
-		})
-
-		// XXX hack to support IsSet for flags with EnvVar
-		//
-		// There isn't an easy way to do this with the current implementation since
-		// whether a flag was set via an environment variable is very difficult to
-		// determine here. Instead, we intend to introduce a backwards incompatible
-		// change in version 2 to add `IsSet` to the Flag interface to push the
-		// responsibility closer to where the information required to determine
-		// whether a flag is set by non-standard means such as environment
-		// variables is avaliable.
-		//
-		// See https://github.com/urfave/cli/issues/294 for additional discussion
-		flags := c.Command.Flags
-		if c.Command.Name == "" { // cannot == Command{} since it contains slice types
-			if c.App != nil {
-				flags = c.App.Flags
-			}
-		}
-		for _, f := range flags {
-			eachName(f.GetName(), func(name string) {
-				if isSet, ok := c.setFlags[name]; isSet || !ok {
-					return
-				}
-
-				val := reflect.ValueOf(f)
-				if val.Kind() == reflect.Ptr {
-					val = val.Elem()
-				}
-
-				envVarValue := val.FieldByName("EnvVar")
-				if !envVarValue.IsValid() {
-					return
-				}
-
-				eachName(envVarValue.String(), func(envVar string) {
-					envVar = strings.TrimSpace(envVar)
-					if _, ok := syscall.Getenv(envVar); ok {
-						c.setFlags[name] = true
-						return
-					}
-				})
-			})
-		}
-	}
-
-	return c.setFlags[name]
-}
-
-// GlobalIsSet determines if the global flag was actually set
-func (c *Context) GlobalIsSet(name string) bool {
-	ctx := c
-	if ctx.parentContext != nil {
-		ctx = ctx.parentContext
-	}
-
-	for ; ctx != nil; ctx = ctx.parentContext {
-		if ctx.IsSet(name) {
-			return true
-		}
-	}
-	return false
-}
-
-// FlagNames returns a slice of flag names used in this context.
-func (c *Context) FlagNames() (names []string) {
-	for _, flag := range c.Command.Flags {
-		name := strings.Split(flag.GetName(), ",")[0]
-		if name == "help" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-// GlobalFlagNames returns a slice of global flag names used by the app.
-func (c *Context) GlobalFlagNames() (names []string) {
-	for _, flag := range c.App.Flags {
-		name := strings.Split(flag.GetName(), ",")[0]
-		if name == "help" || name == "version" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-// Parent returns the parent context, if any
-func (c *Context) Parent() *Context {
-	return c.parentContext
-}
-
-// value returns the value of the flag coressponding to `name`
-func (c *Context) value(name string) interface{} {
-	return c.flagSet.Lookup(name).Value.(flag.Getter).Get()
-}
-
-// Args contains apps console arguments
-type Args []string
-
-// Args returns the command line arguments associated with the context.
-func (c *Context) Args() Args {
-	args := Args(c.flagSet.Args())
-	return args
-}
-
-// NArg returns the number of the command line arguments.
-func (c *Context) NArg() int {
-	return len(c.Args())
-}
-
-// Get returns the nth argument, or else a blank string
-func (a Args) Get(n int) string {
-	if len(a) > n {
-		return a[n]
-	}
-	return ""
-}
-
-// First returns the first argument, or else a blank string
-func (a Args) First() string {
-	return a.Get(0)
-}
-
-// Tail returns the rest of the arguments (not the first one)
-// or else an empty string slice
-func (a Args) Tail() []string {
-	if len(a) >= 2 {
-		return []string(a)[1:]
-	}
-	return []string{}
-}
-
-// Present checks if there are any arguments present
-func (a Args) Present() bool {
-	return len(a) != 0
-}
-
-// Swap swaps arguments at the given indexes
-func (a Args) Swap(from, to int) error {
-	if from >= len(a) || to >= len(a) {
-		return errors.New("index out of range")
-	}
-	a[from], a[to] = a[to], a[from]
-	return nil
-}
-
-func globalContext(ctx *Context) *Context {
-	if ctx == nil {
-		return nil
-	}
-
-	for {
-		if ctx.parentContext == nil {
-			return ctx
-		}
-		ctx = ctx.parentContext
-	}
-}
-
-func lookupGlobalFlagSet(name string, ctx *Context) *flag.FlagSet {
-	if ctx.parentContext != nil {
-		ctx = ctx.parentContext
-	}
-	for ; ctx != nil; ctx = ctx.parentContext {
-		if f := ctx.flagSet.Lookup(name); f != nil {
-			return ctx.flagSet
-		}
-	}
-	return nil
-}
-
-func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) {
-	switch ff.Value.(type) {
-	case *StringSlice:
-	default:
-		set.Set(name, ff.Value.String())
-	}
-}
-
-func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
-	visited := make(map[string]bool)
-	set.Visit(func(f *flag.Flag) {
-		visited[f.Name] = true
-	})
-	for _, f := range flags {
-		parts := strings.Split(f.GetName(), ",")
-		if len(parts) == 1 {
-			continue
-		}
-		var ff *flag.Flag
-		for _, name := range parts {
-			name = strings.Trim(name, " ")
-			if visited[name] {
-				if ff != nil {
-					return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
-				}
-				ff = set.Lookup(name)
-			}
-		}
-		if ff == nil {
-			continue
-		}
-		for _, name := range parts {
-			name = strings.Trim(name, " ")
-			if !visited[name] {
-				copyFlag(name, ff, set)
-			}
-		}
-	}
-	return nil
-}

vendor/github.com/codegangsta/cli/context_test.go

@@ -1,399 +0,0 @@
-package cli
-
-import (
-	"flag"
-	"os"
-	"testing"
-	"time"
-)
-
-func TestNewContext(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int("myflag", 12, "doc")
-	set.Int64("myflagInt64", int64(12), "doc")
-	set.Uint("myflagUint", uint(93), "doc")
-	set.Uint64("myflagUint64", uint64(93), "doc")
-	set.Float64("myflag64", float64(17), "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Int("myflag", 42, "doc")
-	globalSet.Int64("myflagInt64", int64(42), "doc")
-	globalSet.Uint("myflagUint", uint(33), "doc")
-	globalSet.Uint64("myflagUint64", uint64(33), "doc")
-	globalSet.Float64("myflag64", float64(47), "doc")
-	globalCtx := NewContext(nil, globalSet, nil)
-	command := Command{Name: "mycommand"}
-	c := NewContext(nil, set, globalCtx)
-	c.Command = command
-	expect(t, c.Int("myflag"), 12)
-	expect(t, c.Int64("myflagInt64"), int64(12))
-	expect(t, c.Uint("myflagUint"), uint(93))
-	expect(t, c.Uint64("myflagUint64"), uint64(93))
-	expect(t, c.Float64("myflag64"), float64(17))
-	expect(t, c.GlobalInt("myflag"), 42)
-	expect(t, c.GlobalInt64("myflagInt64"), int64(42))
-	expect(t, c.GlobalUint("myflagUint"), uint(33))
-	expect(t, c.GlobalUint64("myflagUint64"), uint64(33))
-	expect(t, c.GlobalFloat64("myflag64"), float64(47))
-	expect(t, c.Command.Name, "mycommand")
-}
-
-func TestContext_Int(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int("myflag", 12, "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.Int("myflag"), 12)
-}
-
-func TestContext_Int64(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int64("myflagInt64", 12, "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.Int64("myflagInt64"), int64(12))
-}
-
-func TestContext_Uint(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Uint("myflagUint", uint(13), "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.Uint("myflagUint"), uint(13))
-}
-
-func TestContext_Uint64(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Uint64("myflagUint64", uint64(9), "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.Uint64("myflagUint64"), uint64(9))
-}
-
-func TestContext_GlobalInt(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int("myflag", 12, "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.GlobalInt("myflag"), 12)
-	expect(t, c.GlobalInt("nope"), 0)
-}
-
-func TestContext_GlobalInt64(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int64("myflagInt64", 12, "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.GlobalInt64("myflagInt64"), int64(12))
-	expect(t, c.GlobalInt64("nope"), int64(0))
-}
-
-func TestContext_Float64(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Float64("myflag", float64(17), "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.Float64("myflag"), float64(17))
-}
-
-func TestContext_GlobalFloat64(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Float64("myflag", float64(17), "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.GlobalFloat64("myflag"), float64(17))
-	expect(t, c.GlobalFloat64("nope"), float64(0))
-}
-
-func TestContext_Duration(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Duration("myflag", time.Duration(12*time.Second), "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.Duration("myflag"), time.Duration(12*time.Second))
-}
-
-func TestContext_String(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.String("myflag", "hello world", "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.String("myflag"), "hello world")
-}
-
-func TestContext_Bool(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.Bool("myflag"), false)
-}
-
-func TestContext_BoolT(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", true, "doc")
-	c := NewContext(nil, set, nil)
-	expect(t, c.BoolT("myflag"), true)
-}
-
-func TestContext_GlobalBool(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-
-	globalSet := flag.NewFlagSet("test-global", 0)
-	globalSet.Bool("myflag", false, "doc")
-	globalCtx := NewContext(nil, globalSet, nil)
-
-	c := NewContext(nil, set, globalCtx)
-	expect(t, c.GlobalBool("myflag"), false)
-	expect(t, c.GlobalBool("nope"), false)
-}
-
-func TestContext_GlobalBoolT(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-
-	globalSet := flag.NewFlagSet("test-global", 0)
-	globalSet.Bool("myflag", true, "doc")
-	globalCtx := NewContext(nil, globalSet, nil)
-
-	c := NewContext(nil, set, globalCtx)
-	expect(t, c.GlobalBoolT("myflag"), true)
-	expect(t, c.GlobalBoolT("nope"), false)
-}
-
-func TestContext_Args(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	c := NewContext(nil, set, nil)
-	set.Parse([]string{"--myflag", "bat", "baz"})
-	expect(t, len(c.Args()), 2)
-	expect(t, c.Bool("myflag"), true)
-}
-
-func TestContext_NArg(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	c := NewContext(nil, set, nil)
-	set.Parse([]string{"--myflag", "bat", "baz"})
-	expect(t, c.NArg(), 2)
-}
-
-func TestContext_IsSet(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	set.String("otherflag", "hello world", "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Bool("myflagGlobal", true, "doc")
-	globalCtx := NewContext(nil, globalSet, nil)
-	c := NewContext(nil, set, globalCtx)
-	set.Parse([]string{"--myflag", "bat", "baz"})
-	globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
-	expect(t, c.IsSet("myflag"), true)
-	expect(t, c.IsSet("otherflag"), false)
-	expect(t, c.IsSet("bogusflag"), false)
-	expect(t, c.IsSet("myflagGlobal"), false)
-}
-
-// XXX Corresponds to hack in context.IsSet for flags with EnvVar field
-// Should be moved to `flag_test` in v2
-func TestContext_IsSet_fromEnv(t *testing.T) {
-	var (
-		timeoutIsSet, tIsSet    bool
-		noEnvVarIsSet, nIsSet   bool
-		passwordIsSet, pIsSet   bool
-		unparsableIsSet, uIsSet bool
-	)
-
-	clearenv()
-	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
-	os.Setenv("APP_PASSWORD", "")
-	a := App{
-		Flags: []Flag{
-			Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
-			StringFlag{Name: "password, p", EnvVar: "APP_PASSWORD"},
-			Float64Flag{Name: "unparsable, u", EnvVar: "APP_UNPARSABLE"},
-			Float64Flag{Name: "no-env-var, n"},
-		},
-		Action: func(ctx *Context) error {
-			timeoutIsSet = ctx.IsSet("timeout")
-			tIsSet = ctx.IsSet("t")
-			passwordIsSet = ctx.IsSet("password")
-			pIsSet = ctx.IsSet("p")
-			unparsableIsSet = ctx.IsSet("unparsable")
-			uIsSet = ctx.IsSet("u")
-			noEnvVarIsSet = ctx.IsSet("no-env-var")
-			nIsSet = ctx.IsSet("n")
-			return nil
-		},
-	}
-	a.Run([]string{"run"})
-	expect(t, timeoutIsSet, true)
-	expect(t, tIsSet, true)
-	expect(t, passwordIsSet, true)
-	expect(t, pIsSet, true)
-	expect(t, noEnvVarIsSet, false)
-	expect(t, nIsSet, false)
-
-	os.Setenv("APP_UNPARSABLE", "foobar")
-	a.Run([]string{"run"})
-	expect(t, unparsableIsSet, false)
-	expect(t, uIsSet, false)
-}
-
-func TestContext_GlobalIsSet(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	set.String("otherflag", "hello world", "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Bool("myflagGlobal", true, "doc")
-	globalSet.Bool("myflagGlobalUnset", true, "doc")
-	globalCtx := NewContext(nil, globalSet, nil)
-	c := NewContext(nil, set, globalCtx)
-	set.Parse([]string{"--myflag", "bat", "baz"})
-	globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
-	expect(t, c.GlobalIsSet("myflag"), false)
-	expect(t, c.GlobalIsSet("otherflag"), false)
-	expect(t, c.GlobalIsSet("bogusflag"), false)
-	expect(t, c.GlobalIsSet("myflagGlobal"), true)
-	expect(t, c.GlobalIsSet("myflagGlobalUnset"), false)
-	expect(t, c.GlobalIsSet("bogusGlobal"), false)
-}
-
-// XXX Corresponds to hack in context.IsSet for flags with EnvVar field
-// Should be moved to `flag_test` in v2
-func TestContext_GlobalIsSet_fromEnv(t *testing.T) {
-	var (
-		timeoutIsSet, tIsSet    bool
-		noEnvVarIsSet, nIsSet   bool
-		passwordIsSet, pIsSet   bool
-		unparsableIsSet, uIsSet bool
-	)
-
-	clearenv()
-	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
-	os.Setenv("APP_PASSWORD", "")
-	a := App{
-		Flags: []Flag{
-			Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
-			StringFlag{Name: "password, p", EnvVar: "APP_PASSWORD"},
-			Float64Flag{Name: "no-env-var, n"},
-			Float64Flag{Name: "unparsable, u", EnvVar: "APP_UNPARSABLE"},
-		},
-		Commands: []Command{
-			{
-				Name: "hello",
-				Action: func(ctx *Context) error {
-					timeoutIsSet = ctx.GlobalIsSet("timeout")
-					tIsSet = ctx.GlobalIsSet("t")
-					passwordIsSet = ctx.GlobalIsSet("password")
-					pIsSet = ctx.GlobalIsSet("p")
-					unparsableIsSet = ctx.GlobalIsSet("unparsable")
-					uIsSet = ctx.GlobalIsSet("u")
-					noEnvVarIsSet = ctx.GlobalIsSet("no-env-var")
-					nIsSet = ctx.GlobalIsSet("n")
-					return nil
-				},
-			},
-		},
-	}
-	if err := a.Run([]string{"run", "hello"}); err != nil {
-		t.Logf("error running Run(): %+v", err)
-	}
-	expect(t, timeoutIsSet, true)
-	expect(t, tIsSet, true)
-	expect(t, passwordIsSet, true)
-	expect(t, pIsSet, true)
-	expect(t, noEnvVarIsSet, false)
-	expect(t, nIsSet, false)
-
-	os.Setenv("APP_UNPARSABLE", "foobar")
-	if err := a.Run([]string{"run"}); err != nil {
-		t.Logf("error running Run(): %+v", err)
-	}
-	expect(t, unparsableIsSet, false)
-	expect(t, uIsSet, false)
-}
-
-func TestContext_NumFlags(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	set.String("otherflag", "hello world", "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Bool("myflagGlobal", true, "doc")
-	globalCtx := NewContext(nil, globalSet, nil)
-	c := NewContext(nil, set, globalCtx)
-	set.Parse([]string{"--myflag", "--otherflag=foo"})
-	globalSet.Parse([]string{"--myflagGlobal"})
-	expect(t, c.NumFlags(), 2)
-}
-
-func TestContext_GlobalFlag(t *testing.T) {
-	var globalFlag string
-	var globalFlagSet bool
-	app := NewApp()
-	app.Flags = []Flag{
-		StringFlag{Name: "global, g", Usage: "global"},
-	}
-	app.Action = func(c *Context) error {
-		globalFlag = c.GlobalString("global")
-		globalFlagSet = c.GlobalIsSet("global")
-		return nil
-	}
-	app.Run([]string{"command", "-g", "foo"})
-	expect(t, globalFlag, "foo")
-	expect(t, globalFlagSet, true)
-
-}
-
-func TestContext_GlobalFlagsInSubcommands(t *testing.T) {
-	subcommandRun := false
-	parentFlag := false
-	app := NewApp()
-
-	app.Flags = []Flag{
-		BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
-	}
-
-	app.Commands = []Command{
-		{
-			Name: "foo",
-			Flags: []Flag{
-				BoolFlag{Name: "parent, p", Usage: "Parent flag"},
-			},
-			Subcommands: []Command{
-				{
-					Name: "bar",
-					Action: func(c *Context) error {
-						if c.GlobalBool("debug") {
-							subcommandRun = true
-						}
-						if c.GlobalBool("parent") {
-							parentFlag = true
-						}
-						return nil
-					},
-				},
-			},
-		},
-	}
-
-	app.Run([]string{"command", "-d", "foo", "-p", "bar"})
-
-	expect(t, subcommandRun, true)
-	expect(t, parentFlag, true)
-}
-
-func TestContext_Set(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int("int", 5, "an int")
-	c := NewContext(nil, set, nil)
-
-	c.Set("int", "1")
-	expect(t, c.Int("int"), 1)
-}
-
-func TestContext_GlobalSet(t *testing.T) {
-	gSet := flag.NewFlagSet("test", 0)
-	gSet.Int("int", 5, "an int")
-
-	set := flag.NewFlagSet("sub", 0)
-	set.Int("int", 3, "an int")
-
-	pc := NewContext(nil, gSet, nil)
-	c := NewContext(nil, set, pc)
-
-	c.Set("int", "1")
-	expect(t, c.Int("int"), 1)
-	expect(t, c.GlobalInt("int"), 5)
-
-	c.GlobalSet("int", "1")
-	expect(t, c.Int("int"), 1)
-	expect(t, c.GlobalInt("int"), 1)
-}

vendor/github.com/codegangsta/cli/errors.go

@@ -1,124 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strings"
-)
-
-// OsExiter is the function used when the app exits. If not set defaults to os.Exit.
-var OsExiter = os.Exit
-
-// ErrWriter is used to write errors to the user. This can be anything
-// implementing the io.Writer interface and defaults to os.Stderr.
-var ErrWriter io.Writer = os.Stderr
-
-// MultiError is an error that wraps multiple errors.
-type MultiError struct {
-	Errors []error
-}
-
-// NewMultiError creates a new MultiError. Pass in one or more errors.
-func NewMultiError(err ...error) MultiError {
-	return MultiError{Errors: err}
-}
-
-// Error implements the error interface.
-func (m MultiError) Error() string {
-	errs := make([]string, len(m.Errors))
-	for i, err := range m.Errors {
-		errs[i] = err.Error()
-	}
-
-	return strings.Join(errs, "\n")
-}
-
-type ErrorFormatter interface {
-	Format(s fmt.State, verb rune)
-}
-
-// ExitCoder is the interface checked by `App` and `Command` for a custom exit
-// code
-type ExitCoder interface {
-	error
-	ExitCode() int
-}
-
-// ExitError fulfills both the builtin `error` interface and `ExitCoder`
-type ExitError struct {
-	exitCode int
-	message  interface{}
-}
-
-// NewExitError makes a new *ExitError
-func NewExitError(message interface{}, exitCode int) *ExitError {
-	return &ExitError{
-		exitCode: exitCode,
-		message:  message,
-	}
-}
-
-// Error returns the string message, fulfilling the interface required by
-// `error`
-func (ee *ExitError) Error() string {
-	return fmt.Sprintf("%v", ee.message)
-}
-
-// ExitCode returns the exit code, fulfilling the interface required by
-// `ExitCoder`
-func (ee *ExitError) ExitCode() int {
-	return ee.exitCode
-}
-
-// HandleExitCoder checks if the error fulfills the ExitCoder interface, and if
-// so prints the error to stderr (if it is non-empty) and calls OsExiter with the
-// given exit code.  If the given error is a MultiError, then this func is
-// called on all members of the Errors slice and calls OsExiter with the last exit code.
-func HandleExitCoder(err error) {
-	if err == nil {
-		return
-	}
-
-	if exitErr, ok := err.(ExitCoder); ok {
-		if err.Error() != "" {
-			if _, ok := exitErr.(ErrorFormatter); ok {
-				fmt.Fprintf(ErrWriter, "%+v\n", err)
-			} else {
-				fmt.Fprintln(ErrWriter, err)
-			}
-		}
-		OsExiter(exitErr.ExitCode())
-		return
-	}
-
-	if multiErr, ok := err.(MultiError); ok {
-		code := handleMultiError(multiErr)
-		OsExiter(code)
-		return
-	}
-
-	if err.Error() != "" {
-		if _, ok := err.(ErrorFormatter); ok {
-			fmt.Fprintf(ErrWriter, "%+v\n", err)
-		} else {
-			fmt.Fprintln(ErrWriter, err)
-		}
-	}
-	OsExiter(1)
-}
-
-func handleMultiError(multiErr MultiError) int {
-	code := 1
-	for _, merr := range multiErr.Errors {
-		if multiErr2, ok := merr.(MultiError); ok {
-			code = handleMultiError(multiErr2)
-		} else {
-			fmt.Fprintln(ErrWriter, merr)
-			if exitErr, ok := merr.(ExitCoder); ok {
-				code = exitErr.ExitCode()
-			}
-		}
-	}
-	return code
-}

vendor/github.com/codegangsta/cli/errors_test.go

@@ -1,172 +0,0 @@
-package cli
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"testing"
-)
-
-func TestHandleExitCoder_nil(t *testing.T) {
-	exitCode := 0
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			exitCode = rc
-			called = true
-		}
-	}
-
-	defer func() { OsExiter = fakeOsExiter }()
-
-	HandleExitCoder(nil)
-
-	expect(t, exitCode, 0)
-	expect(t, called, false)
-}
-
-func TestHandleExitCoder_ExitCoder(t *testing.T) {
-	exitCode := 0
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			exitCode = rc
-			called = true
-		}
-	}
-
-	defer func() { OsExiter = fakeOsExiter }()
-
-	HandleExitCoder(NewExitError("galactic perimeter breach", 9))
-
-	expect(t, exitCode, 9)
-	expect(t, called, true)
-}
-
-func TestHandleExitCoder_MultiErrorWithExitCoder(t *testing.T) {
-	exitCode := 0
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			exitCode = rc
-			called = true
-		}
-	}
-
-	defer func() { OsExiter = fakeOsExiter }()
-
-	exitErr := NewExitError("galactic perimeter breach", 9)
-	exitErr2 := NewExitError("last ExitCoder", 11)
-	err := NewMultiError(errors.New("wowsa"), errors.New("egad"), exitErr, exitErr2)
-	HandleExitCoder(err)
-
-	expect(t, exitCode, 11)
-	expect(t, called, true)
-}
-
-func TestHandleExitCoder_ErrorWithMessage(t *testing.T) {
-	exitCode := 0
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			exitCode = rc
-			called = true
-		}
-	}
-	ErrWriter = &bytes.Buffer{}
-
-	defer func() {
-		OsExiter = fakeOsExiter
-		ErrWriter = fakeErrWriter
-	}()
-
-	err := errors.New("gourd havens")
-	HandleExitCoder(err)
-
-	expect(t, exitCode, 1)
-	expect(t, called, true)
-	expect(t, ErrWriter.(*bytes.Buffer).String(), "gourd havens\n")
-}
-
-func TestHandleExitCoder_ErrorWithoutMessage(t *testing.T) {
-	exitCode := 0
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			exitCode = rc
-			called = true
-		}
-	}
-	ErrWriter = &bytes.Buffer{}
-
-	defer func() {
-		OsExiter = fakeOsExiter
-		ErrWriter = fakeErrWriter
-	}()
-
-	err := errors.New("")
-	HandleExitCoder(err)
-
-	expect(t, exitCode, 1)
-	expect(t, called, true)
-	expect(t, ErrWriter.(*bytes.Buffer).String(), "")
-}
-
-// make a stub to not import pkg/errors
-type ErrorWithFormat struct {
-	error
-}
-
-func NewErrorWithFormat(m string) *ErrorWithFormat {
-	return &ErrorWithFormat{error: errors.New(m)}
-}
-
-func (f *ErrorWithFormat) Format(s fmt.State, verb rune) {
-	fmt.Fprintf(s, "This the format: %v", f.error)
-}
-
-func TestHandleExitCoder_ErrorWithFormat(t *testing.T) {
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			called = true
-		}
-	}
-	ErrWriter = &bytes.Buffer{}
-
-	defer func() {
-		OsExiter = fakeOsExiter
-		ErrWriter = fakeErrWriter
-	}()
-
-	err := NewErrorWithFormat("I am formatted")
-	HandleExitCoder(err)
-
-	expect(t, called, true)
-	expect(t, ErrWriter.(*bytes.Buffer).String(), "This the format: I am formatted\n")
-}
-
-func TestHandleExitCoder_MultiErrorWithFormat(t *testing.T) {
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			called = true
-		}
-	}
-	ErrWriter = &bytes.Buffer{}
-
-	defer func() { OsExiter = fakeOsExiter }()
-
-	err := NewMultiError(NewErrorWithFormat("err1"), NewErrorWithFormat("err2"))
-	HandleExitCoder(err)
-
-	expect(t, called, true)
-	expect(t, ErrWriter.(*bytes.Buffer).String(), "This the format: err1\nThis the format: err2\n")
-}

vendor/github.com/codegangsta/cli/flag-types.json

@@ -1,93 +0,0 @@
-[
-  {
-    "name": "Bool",
-    "type": "bool",
-    "value": false,
-    "context_default": "false",
-    "parser": "strconv.ParseBool(f.Value.String())"
-  },
-  {
-    "name": "BoolT",
-    "type": "bool",
-    "value": false,
-    "doctail": " that is true by default",
-    "context_default": "false",
-    "parser": "strconv.ParseBool(f.Value.String())"
-  },
-  {
-    "name": "Duration",
-    "type": "time.Duration",
-    "doctail": " (see https://golang.org/pkg/time/#ParseDuration)",
-    "context_default": "0",
-    "parser": "time.ParseDuration(f.Value.String())"
-  },
-  {
-    "name": "Float64",
-    "type": "float64",
-    "context_default": "0",
-    "parser": "strconv.ParseFloat(f.Value.String(), 64)"
-  },
-  {
-    "name": "Generic",
-    "type": "Generic",
-    "dest": false,
-    "context_default": "nil",
-    "context_type": "interface{}"
-  },
-  {
-    "name": "Int64",
-    "type": "int64",
-    "context_default": "0",
-    "parser": "strconv.ParseInt(f.Value.String(), 0, 64)"
-  },
-  {
-    "name": "Int",
-    "type": "int",
-    "context_default": "0",
-    "parser": "strconv.ParseInt(f.Value.String(), 0, 64)",
-    "parser_cast": "int(parsed)"
-  },
-  {
-    "name": "IntSlice",
-    "type": "*IntSlice",
-    "dest": false,
-    "context_default": "nil",
-    "context_type": "[]int",
-    "parser": "(f.Value.(*IntSlice)).Value(), error(nil)"
-  },
-  {
-    "name": "Int64Slice",
-    "type": "*Int64Slice",
-    "dest": false,
-    "context_default": "nil",
-    "context_type": "[]int64",
-    "parser": "(f.Value.(*Int64Slice)).Value(), error(nil)"
-  },
-  {
-    "name": "String",
-    "type": "string",
-    "context_default": "\"\"",
-    "parser": "f.Value.String(), error(nil)"
-  },
-  {
-    "name": "StringSlice",
-    "type": "*StringSlice",
-    "dest": false,
-    "context_default": "nil",
-    "context_type": "[]string",
-    "parser": "(f.Value.(*StringSlice)).Value(), error(nil)"
-  },
-  {
-    "name": "Uint64",
-    "type": "uint64",
-    "context_default": "0",
-    "parser": "strconv.ParseUint(f.Value.String(), 0, 64)"
-  },
-  {
-    "name": "Uint",
-    "type": "uint",
-    "context_default": "0",
-    "parser": "strconv.ParseUint(f.Value.String(), 0, 64)",
-    "parser_cast": "uint(parsed)"
-  }
-]

vendor/github.com/codegangsta/cli/flag.go

@@ -1,799 +0,0 @@
-package cli
-
-import (
-	"flag"
-	"fmt"
-	"reflect"
-	"runtime"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-)
-
-const defaultPlaceholder = "value"
-
-// BashCompletionFlag enables bash-completion for all commands and subcommands
-var BashCompletionFlag = BoolFlag{
-	Name:   "generate-bash-completion",
-	Hidden: true,
-}
-
-// VersionFlag prints the version for the application
-var VersionFlag = BoolFlag{
-	Name:  "version, v",
-	Usage: "print the version",
-}
-
-// HelpFlag prints the help for all commands and subcommands
-// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
-// unless HideHelp is set to true)
-var HelpFlag = BoolFlag{
-	Name:  "help, h",
-	Usage: "show help",
-}
-
-// FlagStringer converts a flag definition to a string. This is used by help
-// to display a flag.
-var FlagStringer FlagStringFunc = stringifyFlag
-
-// FlagsByName is a slice of Flag.
-type FlagsByName []Flag
-
-func (f FlagsByName) Len() int {
-	return len(f)
-}
-
-func (f FlagsByName) Less(i, j int) bool {
-	return f[i].GetName() < f[j].GetName()
-}
-
-func (f FlagsByName) Swap(i, j int) {
-	f[i], f[j] = f[j], f[i]
-}
-
-// Flag is a common interface related to parsing flags in cli.
-// For more advanced flag parsing techniques, it is recommended that
-// this interface be implemented.
-type Flag interface {
-	fmt.Stringer
-	// Apply Flag settings to the given flag set
-	Apply(*flag.FlagSet)
-	GetName() string
-}
-
-// errorableFlag is an interface that allows us to return errors during apply
-// it allows flags defined in this library to return errors in a fashion backwards compatible
-// TODO remove in v2 and modify the existing Flag interface to return errors
-type errorableFlag interface {
-	Flag
-
-	ApplyWithError(*flag.FlagSet) error
-}
-
-func flagSet(name string, flags []Flag) (*flag.FlagSet, error) {
-	set := flag.NewFlagSet(name, flag.ContinueOnError)
-
-	for _, f := range flags {
-		//TODO remove in v2 when errorableFlag is removed
-		if ef, ok := f.(errorableFlag); ok {
-			if err := ef.ApplyWithError(set); err != nil {
-				return nil, err
-			}
-		} else {
-			f.Apply(set)
-		}
-	}
-	return set, nil
-}
-
-func eachName(longName string, fn func(string)) {
-	parts := strings.Split(longName, ",")
-	for _, name := range parts {
-		name = strings.Trim(name, " ")
-		fn(name)
-	}
-}
-
-// Generic is a generic parseable type identified by a specific flag
-type Generic interface {
-	Set(value string) error
-	String() string
-}
-
-// Apply takes the flagset and calls Set on the generic flag with the value
-// provided by the user for parsing by the flag
-// Ignores parsing errors
-func (f GenericFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError takes the flagset and calls Set on the generic flag with the value
-// provided by the user for parsing by the flag
-func (f GenericFlag) ApplyWithError(set *flag.FlagSet) error {
-	val := f.Value
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				if err := val.Set(envVal); err != nil {
-					return fmt.Errorf("could not parse %s as value for flag %s: %s", envVal, f.Name, err)
-				}
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Var(f.Value, name, f.Usage)
-	})
-
-	return nil
-}
-
-// StringSlice is an opaque type for []string to satisfy flag.Value and flag.Getter
-type StringSlice []string
-
-// Set appends the string value to the list of values
-func (f *StringSlice) Set(value string) error {
-	*f = append(*f, value)
-	return nil
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f *StringSlice) String() string {
-	return fmt.Sprintf("%s", *f)
-}
-
-// Value returns the slice of strings set by this flag
-func (f *StringSlice) Value() []string {
-	return *f
-}
-
-// Get returns the slice of strings set by this flag
-func (f *StringSlice) Get() interface{} {
-	return *f
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f StringSliceFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f StringSliceFlag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				newVal := &StringSlice{}
-				for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
-					if err := newVal.Set(s); err != nil {
-						return fmt.Errorf("could not parse %s as string value for flag %s: %s", envVal, f.Name, err)
-					}
-				}
-				f.Value = newVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Value == nil {
-			f.Value = &StringSlice{}
-		}
-		set.Var(f.Value, name, f.Usage)
-	})
-
-	return nil
-}
-
-// IntSlice is an opaque type for []int to satisfy flag.Value and flag.Getter
-type IntSlice []int
-
-// Set parses the value into an integer and appends it to the list of values
-func (f *IntSlice) Set(value string) error {
-	tmp, err := strconv.Atoi(value)
-	if err != nil {
-		return err
-	}
-	*f = append(*f, tmp)
-	return nil
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f *IntSlice) String() string {
-	return fmt.Sprintf("%#v", *f)
-}
-
-// Value returns the slice of ints set by this flag
-func (f *IntSlice) Value() []int {
-	return *f
-}
-
-// Get returns the slice of ints set by this flag
-func (f *IntSlice) Get() interface{} {
-	return *f
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f IntSliceFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f IntSliceFlag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				newVal := &IntSlice{}
-				for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
-					if err := newVal.Set(s); err != nil {
-						return fmt.Errorf("could not parse %s as int slice value for flag %s: %s", envVal, f.Name, err)
-					}
-				}
-				f.Value = newVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Value == nil {
-			f.Value = &IntSlice{}
-		}
-		set.Var(f.Value, name, f.Usage)
-	})
-
-	return nil
-}
-
-// Int64Slice is an opaque type for []int to satisfy flag.Value and flag.Getter
-type Int64Slice []int64
-
-// Set parses the value into an integer and appends it to the list of values
-func (f *Int64Slice) Set(value string) error {
-	tmp, err := strconv.ParseInt(value, 10, 64)
-	if err != nil {
-		return err
-	}
-	*f = append(*f, tmp)
-	return nil
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f *Int64Slice) String() string {
-	return fmt.Sprintf("%#v", *f)
-}
-
-// Value returns the slice of ints set by this flag
-func (f *Int64Slice) Value() []int64 {
-	return *f
-}
-
-// Get returns the slice of ints set by this flag
-func (f *Int64Slice) Get() interface{} {
-	return *f
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f Int64SliceFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f Int64SliceFlag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				newVal := &Int64Slice{}
-				for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
-					if err := newVal.Set(s); err != nil {
-						return fmt.Errorf("could not parse %s as int64 slice value for flag %s: %s", envVal, f.Name, err)
-					}
-				}
-				f.Value = newVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Value == nil {
-			f.Value = &Int64Slice{}
-		}
-		set.Var(f.Value, name, f.Usage)
-	})
-	return nil
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f BoolFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f BoolFlag) ApplyWithError(set *flag.FlagSet) error {
-	val := false
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				if envVal == "" {
-					val = false
-					break
-				}
-
-				envValBool, err := strconv.ParseBool(envVal)
-				if err != nil {
-					return fmt.Errorf("could not parse %s as bool value for flag %s: %s", envVal, f.Name, err)
-				}
-
-				val = envValBool
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.BoolVar(f.Destination, name, val, f.Usage)
-			return
-		}
-		set.Bool(name, val, f.Usage)
-	})
-
-	return nil
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f BoolTFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f BoolTFlag) ApplyWithError(set *flag.FlagSet) error {
-	val := true
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				if envVal == "" {
-					val = false
-					break
-				}
-
-				envValBool, err := strconv.ParseBool(envVal)
-				if err != nil {
-					return fmt.Errorf("could not parse %s as bool value for flag %s: %s", envVal, f.Name, err)
-				}
-
-				val = envValBool
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.BoolVar(f.Destination, name, val, f.Usage)
-			return
-		}
-		set.Bool(name, val, f.Usage)
-	})
-
-	return nil
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f StringFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f StringFlag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				f.Value = envVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.StringVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.String(name, f.Value, f.Usage)
-	})
-
-	return nil
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f IntFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f IntFlag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				envValInt, err := strconv.ParseInt(envVal, 0, 64)
-				if err != nil {
-					return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err)
-				}
-				f.Value = int(envValInt)
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.IntVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Int(name, f.Value, f.Usage)
-	})
-
-	return nil
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f Int64Flag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f Int64Flag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				envValInt, err := strconv.ParseInt(envVal, 0, 64)
-				if err != nil {
-					return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err)
-				}
-
-				f.Value = envValInt
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.Int64Var(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Int64(name, f.Value, f.Usage)
-	})
-
-	return nil
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f UintFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f UintFlag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				envValInt, err := strconv.ParseUint(envVal, 0, 64)
-				if err != nil {
-					return fmt.Errorf("could not parse %s as uint value for flag %s: %s", envVal, f.Name, err)
-				}
-
-				f.Value = uint(envValInt)
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.UintVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Uint(name, f.Value, f.Usage)
-	})
-
-	return nil
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f Uint64Flag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f Uint64Flag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				envValInt, err := strconv.ParseUint(envVal, 0, 64)
-				if err != nil {
-					return fmt.Errorf("could not parse %s as uint64 value for flag %s: %s", envVal, f.Name, err)
-				}
-
-				f.Value = uint64(envValInt)
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.Uint64Var(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Uint64(name, f.Value, f.Usage)
-	})
-
-	return nil
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f DurationFlag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f DurationFlag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				envValDuration, err := time.ParseDuration(envVal)
-				if err != nil {
-					return fmt.Errorf("could not parse %s as duration for flag %s: %s", envVal, f.Name, err)
-				}
-
-				f.Value = envValDuration
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.DurationVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Duration(name, f.Value, f.Usage)
-	})
-
-	return nil
-}
-
-// Apply populates the flag given the flag set and environment
-// Ignores errors
-func (f Float64Flag) Apply(set *flag.FlagSet) {
-	f.ApplyWithError(set)
-}
-
-// ApplyWithError populates the flag given the flag set and environment
-func (f Float64Flag) ApplyWithError(set *flag.FlagSet) error {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal, ok := syscall.Getenv(envVar); ok {
-				envValFloat, err := strconv.ParseFloat(envVal, 10)
-				if err != nil {
-					return fmt.Errorf("could not parse %s as float64 value for flag %s: %s", envVal, f.Name, err)
-				}
-
-				f.Value = float64(envValFloat)
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.Float64Var(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Float64(name, f.Value, f.Usage)
-	})
-
-	return nil
-}
-
-func visibleFlags(fl []Flag) []Flag {
-	visible := []Flag{}
-	for _, flag := range fl {
-		if !flagValue(flag).FieldByName("Hidden").Bool() {
-			visible = append(visible, flag)
-		}
-	}
-	return visible
-}
-
-func prefixFor(name string) (prefix string) {
-	if len(name) == 1 {
-		prefix = "-"
-	} else {
-		prefix = "--"
-	}
-
-	return
-}
-
-// Returns the placeholder, if any, and the unquoted usage string.
-func unquoteUsage(usage string) (string, string) {
-	for i := 0; i < len(usage); i++ {
-		if usage[i] == '`' {
-			for j := i + 1; j < len(usage); j++ {
-				if usage[j] == '`' {
-					name := usage[i+1 : j]
-					usage = usage[:i] + name + usage[j+1:]
-					return name, usage
-				}
-			}
-			break
-		}
-	}
-	return "", usage
-}
-
-func prefixedNames(fullName, placeholder string) string {
-	var prefixed string
-	parts := strings.Split(fullName, ",")
-	for i, name := range parts {
-		name = strings.Trim(name, " ")
-		prefixed += prefixFor(name) + name
-		if placeholder != "" {
-			prefixed += " " + placeholder
-		}
-		if i < len(parts)-1 {
-			prefixed += ", "
-		}
-	}
-	return prefixed
-}
-
-func withEnvHint(envVar, str string) string {
-	envText := ""
-	if envVar != "" {
-		prefix := "$"
-		suffix := ""
-		sep := ", $"
-		if runtime.GOOS == "windows" {
-			prefix = "%"
-			suffix = "%"
-			sep = "%, %"
-		}
-		envText = fmt.Sprintf(" [%s%s%s]", prefix, strings.Join(strings.Split(envVar, ","), sep), suffix)
-	}
-	return str + envText
-}
-
-func flagValue(f Flag) reflect.Value {
-	fv := reflect.ValueOf(f)
-	for fv.Kind() == reflect.Ptr {
-		fv = reflect.Indirect(fv)
-	}
-	return fv
-}
-
-func stringifyFlag(f Flag) string {
-	fv := flagValue(f)
-
-	switch f.(type) {
-	case IntSliceFlag:
-		return withEnvHint(fv.FieldByName("EnvVar").String(),
-			stringifyIntSliceFlag(f.(IntSliceFlag)))
-	case Int64SliceFlag:
-		return withEnvHint(fv.FieldByName("EnvVar").String(),
-			stringifyInt64SliceFlag(f.(Int64SliceFlag)))
-	case StringSliceFlag:
-		return withEnvHint(fv.FieldByName("EnvVar").String(),
-			stringifyStringSliceFlag(f.(StringSliceFlag)))
-	}
-
-	placeholder, usage := unquoteUsage(fv.FieldByName("Usage").String())
-
-	needsPlaceholder := false
-	defaultValueString := ""
-	val := fv.FieldByName("Value")
-
-	if val.IsValid() {
-		needsPlaceholder = true
-		defaultValueString = fmt.Sprintf(" (default: %v)", val.Interface())
-
-		if val.Kind() == reflect.String && val.String() != "" {
-			defaultValueString = fmt.Sprintf(" (default: %q)", val.String())
-		}
-	}
-
-	if defaultValueString == " (default: )" {
-		defaultValueString = ""
-	}
-
-	if needsPlaceholder && placeholder == "" {
-		placeholder = defaultPlaceholder
-	}
-
-	usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultValueString))
-
-	return withEnvHint(fv.FieldByName("EnvVar").String(),
-		fmt.Sprintf("%s\t%s", prefixedNames(fv.FieldByName("Name").String(), placeholder), usageWithDefault))
-}
-
-func stringifyIntSliceFlag(f IntSliceFlag) string {
-	defaultVals := []string{}
-	if f.Value != nil && len(f.Value.Value()) > 0 {
-		for _, i := range f.Value.Value() {
-			defaultVals = append(defaultVals, fmt.Sprintf("%d", i))
-		}
-	}
-
-	return stringifySliceFlag(f.Usage, f.Name, defaultVals)
-}
-
-func stringifyInt64SliceFlag(f Int64SliceFlag) string {
-	defaultVals := []string{}
-	if f.Value != nil && len(f.Value.Value()) > 0 {
-		for _, i := range f.Value.Value() {
-			defaultVals = append(defaultVals, fmt.Sprintf("%d", i))
-		}
-	}
-
-	return stringifySliceFlag(f.Usage, f.Name, defaultVals)
-}
-
-func stringifyStringSliceFlag(f StringSliceFlag) string {
-	defaultVals := []string{}
-	if f.Value != nil && len(f.Value.Value()) > 0 {
-		for _, s := range f.Value.Value() {
-			if len(s) > 0 {
-				defaultVals = append(defaultVals, fmt.Sprintf("%q", s))
-			}
-		}
-	}
-
-	return stringifySliceFlag(f.Usage, f.Name, defaultVals)
-}
-
-func stringifySliceFlag(usage, name string, defaultVals []string) string {
-	placeholder, usage := unquoteUsage(usage)
-	if placeholder == "" {
-		placeholder = defaultPlaceholder
-	}
-
-	defaultVal := ""
-	if len(defaultVals) > 0 {
-		defaultVal = fmt.Sprintf(" (default: %s)", strings.Join(defaultVals, ", "))
-	}
-
-	usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultVal))
-	return fmt.Sprintf("%s\t%s", prefixedNames(name, placeholder), usageWithDefault)
-}

vendor/github.com/codegangsta/cli/flag_generated.go

@@ -1,627 +0,0 @@
-package cli
-
-import (
-	"flag"
-	"strconv"
-	"time"
-)
-
-// WARNING: This file is generated!
-
-// BoolFlag is a flag with type bool
-type BoolFlag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Hidden      bool
-	Destination *bool
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f BoolFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f BoolFlag) GetName() string {
-	return f.Name
-}
-
-// Bool looks up the value of a local BoolFlag, returns
-// false if not found
-func (c *Context) Bool(name string) bool {
-	return lookupBool(name, c.flagSet)
-}
-
-// GlobalBool looks up the value of a global BoolFlag, returns
-// false if not found
-func (c *Context) GlobalBool(name string) bool {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupBool(name, fs)
-	}
-	return false
-}
-
-func lookupBool(name string, set *flag.FlagSet) bool {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := strconv.ParseBool(f.Value.String())
-		if err != nil {
-			return false
-		}
-		return parsed
-	}
-	return false
-}
-
-// BoolTFlag is a flag with type bool that is true by default
-type BoolTFlag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Hidden      bool
-	Destination *bool
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f BoolTFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f BoolTFlag) GetName() string {
-	return f.Name
-}
-
-// BoolT looks up the value of a local BoolTFlag, returns
-// false if not found
-func (c *Context) BoolT(name string) bool {
-	return lookupBoolT(name, c.flagSet)
-}
-
-// GlobalBoolT looks up the value of a global BoolTFlag, returns
-// false if not found
-func (c *Context) GlobalBoolT(name string) bool {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupBoolT(name, fs)
-	}
-	return false
-}
-
-func lookupBoolT(name string, set *flag.FlagSet) bool {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := strconv.ParseBool(f.Value.String())
-		if err != nil {
-			return false
-		}
-		return parsed
-	}
-	return false
-}
-
-// DurationFlag is a flag with type time.Duration (see https://golang.org/pkg/time/#ParseDuration)
-type DurationFlag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Hidden      bool
-	Value       time.Duration
-	Destination *time.Duration
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f DurationFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f DurationFlag) GetName() string {
-	return f.Name
-}
-
-// Duration looks up the value of a local DurationFlag, returns
-// 0 if not found
-func (c *Context) Duration(name string) time.Duration {
-	return lookupDuration(name, c.flagSet)
-}
-
-// GlobalDuration looks up the value of a global DurationFlag, returns
-// 0 if not found
-func (c *Context) GlobalDuration(name string) time.Duration {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupDuration(name, fs)
-	}
-	return 0
-}
-
-func lookupDuration(name string, set *flag.FlagSet) time.Duration {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := time.ParseDuration(f.Value.String())
-		if err != nil {
-			return 0
-		}
-		return parsed
-	}
-	return 0
-}
-
-// Float64Flag is a flag with type float64
-type Float64Flag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Hidden      bool
-	Value       float64
-	Destination *float64
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f Float64Flag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f Float64Flag) GetName() string {
-	return f.Name
-}
-
-// Float64 looks up the value of a local Float64Flag, returns
-// 0 if not found
-func (c *Context) Float64(name string) float64 {
-	return lookupFloat64(name, c.flagSet)
-}
-
-// GlobalFloat64 looks up the value of a global Float64Flag, returns
-// 0 if not found
-func (c *Context) GlobalFloat64(name string) float64 {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupFloat64(name, fs)
-	}
-	return 0
-}
-
-func lookupFloat64(name string, set *flag.FlagSet) float64 {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := strconv.ParseFloat(f.Value.String(), 64)
-		if err != nil {
-			return 0
-		}
-		return parsed
-	}
-	return 0
-}
-
-// GenericFlag is a flag with type Generic
-type GenericFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
-	Hidden bool
-	Value  Generic
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f GenericFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f GenericFlag) GetName() string {
-	return f.Name
-}
-
-// Generic looks up the value of a local GenericFlag, returns
-// nil if not found
-func (c *Context) Generic(name string) interface{} {
-	return lookupGeneric(name, c.flagSet)
-}
-
-// GlobalGeneric looks up the value of a global GenericFlag, returns
-// nil if not found
-func (c *Context) GlobalGeneric(name string) interface{} {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupGeneric(name, fs)
-	}
-	return nil
-}
-
-func lookupGeneric(name string, set *flag.FlagSet) interface{} {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := f.Value, error(nil)
-		if err != nil {
-			return nil
-		}
-		return parsed
-	}
-	return nil
-}
-
-// Int64Flag is a flag with type int64
-type Int64Flag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Hidden      bool
-	Value       int64
-	Destination *int64
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f Int64Flag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f Int64Flag) GetName() string {
-	return f.Name
-}
-
-// Int64 looks up the value of a local Int64Flag, returns
-// 0 if not found
-func (c *Context) Int64(name string) int64 {
-	return lookupInt64(name, c.flagSet)
-}
-
-// GlobalInt64 looks up the value of a global Int64Flag, returns
-// 0 if not found
-func (c *Context) GlobalInt64(name string) int64 {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupInt64(name, fs)
-	}
-	return 0
-}
-
-func lookupInt64(name string, set *flag.FlagSet) int64 {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
-		if err != nil {
-			return 0
-		}
-		return parsed
-	}
-	return 0
-}
-
-// IntFlag is a flag with type int
-type IntFlag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Hidden      bool
-	Value       int
-	Destination *int
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f IntFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f IntFlag) GetName() string {
-	return f.Name
-}
-
-// Int looks up the value of a local IntFlag, returns
-// 0 if not found
-func (c *Context) Int(name string) int {
-	return lookupInt(name, c.flagSet)
-}
-
-// GlobalInt looks up the value of a global IntFlag, returns
-// 0 if not found
-func (c *Context) GlobalInt(name string) int {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupInt(name, fs)
-	}
-	return 0
-}
-
-func lookupInt(name string, set *flag.FlagSet) int {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
-		if err != nil {
-			return 0
-		}
-		return int(parsed)
-	}
-	return 0
-}
-
-// IntSliceFlag is a flag with type *IntSlice
-type IntSliceFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
-	Hidden bool
-	Value  *IntSlice
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f IntSliceFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f IntSliceFlag) GetName() string {
-	return f.Name
-}
-
-// IntSlice looks up the value of a local IntSliceFlag, returns
-// nil if not found
-func (c *Context) IntSlice(name string) []int {
-	return lookupIntSlice(name, c.flagSet)
-}
-
-// GlobalIntSlice looks up the value of a global IntSliceFlag, returns
-// nil if not found
-func (c *Context) GlobalIntSlice(name string) []int {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupIntSlice(name, fs)
-	}
-	return nil
-}
-
-func lookupIntSlice(name string, set *flag.FlagSet) []int {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := (f.Value.(*IntSlice)).Value(), error(nil)
-		if err != nil {
-			return nil
-		}
-		return parsed
-	}
-	return nil
-}
-
-// Int64SliceFlag is a flag with type *Int64Slice
-type Int64SliceFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
-	Hidden bool
-	Value  *Int64Slice
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f Int64SliceFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f Int64SliceFlag) GetName() string {
-	return f.Name
-}
-
-// Int64Slice looks up the value of a local Int64SliceFlag, returns
-// nil if not found
-func (c *Context) Int64Slice(name string) []int64 {
-	return lookupInt64Slice(name, c.flagSet)
-}
-
-// GlobalInt64Slice looks up the value of a global Int64SliceFlag, returns
-// nil if not found
-func (c *Context) GlobalInt64Slice(name string) []int64 {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupInt64Slice(name, fs)
-	}
-	return nil
-}
-
-func lookupInt64Slice(name string, set *flag.FlagSet) []int64 {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := (f.Value.(*Int64Slice)).Value(), error(nil)
-		if err != nil {
-			return nil
-		}
-		return parsed
-	}
-	return nil
-}
-
-// StringFlag is a flag with type string
-type StringFlag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Hidden      bool
-	Value       string
-	Destination *string
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f StringFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f StringFlag) GetName() string {
-	return f.Name
-}
-
-// String looks up the value of a local StringFlag, returns
-// "" if not found
-func (c *Context) String(name string) string {
-	return lookupString(name, c.flagSet)
-}
-
-// GlobalString looks up the value of a global StringFlag, returns
-// "" if not found
-func (c *Context) GlobalString(name string) string {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupString(name, fs)
-	}
-	return ""
-}
-
-func lookupString(name string, set *flag.FlagSet) string {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := f.Value.String(), error(nil)
-		if err != nil {
-			return ""
-		}
-		return parsed
-	}
-	return ""
-}
-
-// StringSliceFlag is a flag with type *StringSlice
-type StringSliceFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
-	Hidden bool
-	Value  *StringSlice
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f StringSliceFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f StringSliceFlag) GetName() string {
-	return f.Name
-}
-
-// StringSlice looks up the value of a local StringSliceFlag, returns
-// nil if not found
-func (c *Context) StringSlice(name string) []string {
-	return lookupStringSlice(name, c.flagSet)
-}
-
-// GlobalStringSlice looks up the value of a global StringSliceFlag, returns
-// nil if not found
-func (c *Context) GlobalStringSlice(name string) []string {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupStringSlice(name, fs)
-	}
-	return nil
-}
-
-func lookupStringSlice(name string, set *flag.FlagSet) []string {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := (f.Value.(*StringSlice)).Value(), error(nil)
-		if err != nil {
-			return nil
-		}
-		return parsed
-	}
-	return nil
-}
-
-// Uint64Flag is a flag with type uint64
-type Uint64Flag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Hidden      bool
-	Value       uint64
-	Destination *uint64
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f Uint64Flag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f Uint64Flag) GetName() string {
-	return f.Name
-}
-
-// Uint64 looks up the value of a local Uint64Flag, returns
-// 0 if not found
-func (c *Context) Uint64(name string) uint64 {
-	return lookupUint64(name, c.flagSet)
-}
-
-// GlobalUint64 looks up the value of a global Uint64Flag, returns
-// 0 if not found
-func (c *Context) GlobalUint64(name string) uint64 {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupUint64(name, fs)
-	}
-	return 0
-}
-
-func lookupUint64(name string, set *flag.FlagSet) uint64 {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
-		if err != nil {
-			return 0
-		}
-		return parsed
-	}
-	return 0
-}
-
-// UintFlag is a flag with type uint
-type UintFlag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Hidden      bool
-	Value       uint
-	Destination *uint
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f UintFlag) String() string {
-	return FlagStringer(f)
-}
-
-// GetName returns the name of the flag
-func (f UintFlag) GetName() string {
-	return f.Name
-}
-
-// Uint looks up the value of a local UintFlag, returns
-// 0 if not found
-func (c *Context) Uint(name string) uint {
-	return lookupUint(name, c.flagSet)
-}
-
-// GlobalUint looks up the value of a global UintFlag, returns
-// 0 if not found
-func (c *Context) GlobalUint(name string) uint {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupUint(name, fs)
-	}
-	return 0
-}
-
-func lookupUint(name string, set *flag.FlagSet) uint {
-	f := set.Lookup(name)
-	if f != nil {
-		parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
-		if err != nil {
-			return 0
-		}
-		return uint(parsed)
-	}
-	return 0
-}

vendor/github.com/codegangsta/cli/funcs.go

@@ -1,28 +0,0 @@
-package cli
-
-// BashCompleteFunc is an action to execute when the bash-completion flag is set
-type BashCompleteFunc func(*Context)
-
-// BeforeFunc is an action to execute before any subcommands are run, but after
-// the context is ready if a non-nil error is returned, no subcommands are run
-type BeforeFunc func(*Context) error
-
-// AfterFunc is an action to execute after any subcommands are run, but after the
-// subcommand has finished it is run even if Action() panics
-type AfterFunc func(*Context) error
-
-// ActionFunc is the action to execute when no subcommands are specified
-type ActionFunc func(*Context) error
-
-// CommandNotFoundFunc is executed if the proper command cannot be found
-type CommandNotFoundFunc func(*Context, string)
-
-// OnUsageErrorFunc is executed if an usage error occurs. This is useful for displaying
-// customized usage error messages.  This function is able to replace the
-// original error messages.  If this function is not set, the "Incorrect usage"
-// is displayed and the execution is interrupted.
-type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error
-
-// FlagStringFunc is used by the help generation to display a flag, which is
-// expected to be a single line.
-type FlagStringFunc func(Flag) string

vendor/github.com/codegangsta/cli/generate-flag-types

@@ -1,255 +0,0 @@
-#!/usr/bin/env python
-"""
-The flag types that ship with the cli library have many things in common, and
-so we can take advantage of the `go generate` command to create much of the
-source code from a list of definitions.  These definitions attempt to cover
-the parts that vary between flag types, and should evolve as needed.
-
-An example of the minimum definition needed is:
-
-    {
-      "name": "SomeType",
-      "type": "sometype",
-      "context_default": "nil"
-    }
-
-In this example, the code generated for the `cli` package will include a type
-named `SomeTypeFlag` that is expected to wrap a value of type `sometype`.
-Fetching values by name via `*cli.Context` will default to a value of `nil`.
-
-A more complete, albeit somewhat redundant, example showing all available
-definition keys is:
-
-    {
-      "name": "VeryMuchType",
-      "type": "*VeryMuchType",
-      "value": true,
-      "dest": false,
-      "doctail": " which really only wraps a []float64, oh well!",
-      "context_type": "[]float64",
-      "context_default": "nil",
-      "parser": "parseVeryMuchType(f.Value.String())",
-      "parser_cast": "[]float64(parsed)"
-    }
-
-The meaning of each field is as follows:
-
-               name (string) - The type "name", which will be suffixed with
-                               `Flag` when generating the type definition
-                               for `cli` and the wrapper type for `altsrc`
-               type (string) - The type that the generated `Flag` type for `cli`
-                               is expected to "contain" as its `.Value` member
-                value (bool) - Should the generated `cli` type have a `Value`
-                               member?
-                 dest (bool) - Should the generated `cli` type support a
-                               destination pointer?
-            doctail (string) - Additional docs for the `cli` flag type comment
-       context_type (string) - The literal type used in the `*cli.Context`
-                               reader func signature
-    context_default (string) - The literal value used as the default by the
-                               `*cli.Context` reader funcs when no value is
-                               present
-             parser (string) - Literal code used to parse the flag `f`,
-                               expected to have a return signature of
-                               (value, error)
-        parser_cast (string) - Literal code used to cast the `parsed` value
-                               returned from the `parser` code
-"""
-
-from __future__ import print_function, unicode_literals
-
-import argparse
-import json
-import os
-import subprocess
-import sys
-import tempfile
-import textwrap
-
-
-class _FancyFormatter(argparse.ArgumentDefaultsHelpFormatter,
-                      argparse.RawDescriptionHelpFormatter):
-    pass
-
-
-def main(sysargs=sys.argv[:]):
-    parser = argparse.ArgumentParser(
-        description='Generate flag type code!',
-        formatter_class=_FancyFormatter)
-    parser.add_argument(
-        'package',
-        type=str, default='cli', choices=_WRITEFUNCS.keys(),
-        help='Package for which flag types will be generated'
-    )
-    parser.add_argument(
-        '-i', '--in-json',
-        type=argparse.FileType('r'),
-        default=sys.stdin,
-        help='Input JSON file which defines each type to be generated'
-    )
-    parser.add_argument(
-        '-o', '--out-go',
-        type=argparse.FileType('w'),
-        default=sys.stdout,
-        help='Output file/stream to which generated source will be written'
-    )
-    parser.epilog = __doc__
-
-    args = parser.parse_args(sysargs[1:])
-    _generate_flag_types(_WRITEFUNCS[args.package], args.out_go, args.in_json)
-    return 0
-
-
-def _generate_flag_types(writefunc, output_go, input_json):
-    types = json.load(input_json)
-
-    tmp = tempfile.NamedTemporaryFile(suffix='.go', delete=False)
-    writefunc(tmp, types)
-    tmp.close()
-
-    new_content = subprocess.check_output(
-        ['goimports', tmp.name]
-    ).decode('utf-8')
-
-    print(new_content, file=output_go, end='')
-    output_go.flush()
-    os.remove(tmp.name)
-
-
-def _set_typedef_defaults(typedef):
-    typedef.setdefault('doctail', '')
-    typedef.setdefault('context_type', typedef['type'])
-    typedef.setdefault('dest', True)
-    typedef.setdefault('value', True)
-    typedef.setdefault('parser', 'f.Value, error(nil)')
-    typedef.setdefault('parser_cast', 'parsed')
-
-
-def _write_cli_flag_types(outfile, types):
-    _fwrite(outfile, """\
-        package cli
-
-        // WARNING: This file is generated!
-
-        """)
-
-    for typedef in types:
-        _set_typedef_defaults(typedef)
-
-        _fwrite(outfile, """\
-        // {name}Flag is a flag with type {type}{doctail}
-        type {name}Flag struct {{
-            Name string
-            Usage string
-            EnvVar string
-            Hidden bool
-        """.format(**typedef))
-
-        if typedef['value']:
-            _fwrite(outfile, """\
-            Value {type}
-            """.format(**typedef))
-
-        if typedef['dest']:
-            _fwrite(outfile, """\
-            Destination *{type}
-            """.format(**typedef))
-
-        _fwrite(outfile, "\n}\n\n")
-
-        _fwrite(outfile, """\
-            // String returns a readable representation of this value
-            // (for usage defaults)
-            func (f {name}Flag) String() string {{
-                return FlagStringer(f)
-            }}
-
-            // GetName returns the name of the flag
-            func (f {name}Flag) GetName() string {{
-                return f.Name
-            }}
-
-            // {name} looks up the value of a local {name}Flag, returns
-            // {context_default} if not found
-            func (c *Context) {name}(name string) {context_type} {{
-                return lookup{name}(name, c.flagSet)
-            }}
-
-            // Global{name} looks up the value of a global {name}Flag, returns
-            // {context_default} if not found
-            func (c *Context) Global{name}(name string) {context_type} {{
-                if fs := lookupGlobalFlagSet(name, c); fs != nil {{
-                    return lookup{name}(name, fs)
-                }}
-                return {context_default}
-            }}
-
-            func lookup{name}(name string, set *flag.FlagSet) {context_type} {{
-                f := set.Lookup(name)
-                if f != nil {{
-                    parsed, err := {parser}
-                    if err != nil {{
-                        return {context_default}
-                    }}
-                    return {parser_cast}
-                }}
-                return {context_default}
-            }}
-            """.format(**typedef))
-
-
-def _write_altsrc_flag_types(outfile, types):
-    _fwrite(outfile, """\
-        package altsrc
-
-        import (
-            "gopkg.in/urfave/cli.v1"
-        )
-
-        // WARNING: This file is generated!
-
-        """)
-
-    for typedef in types:
-        _set_typedef_defaults(typedef)
-
-        _fwrite(outfile, """\
-        // {name}Flag is the flag type that wraps cli.{name}Flag to allow
-        // for other values to be specified
-        type {name}Flag struct {{
-            cli.{name}Flag
-            set *flag.FlagSet
-        }}
-
-        // New{name}Flag creates a new {name}Flag
-        func New{name}Flag(fl cli.{name}Flag) *{name}Flag {{
-            return &{name}Flag{{{name}Flag: fl, set: nil}}
-        }}
-
-        // Apply saves the flagSet for later usage calls, then calls the
-        // wrapped {name}Flag.Apply
-        func (f *{name}Flag) Apply(set *flag.FlagSet) {{
-            f.set = set
-            f.{name}Flag.Apply(set)
-        }}
-
-        // ApplyWithError saves the flagSet for later usage calls, then calls the
-        // wrapped {name}Flag.ApplyWithError
-        func (f *{name}Flag) ApplyWithError(set *flag.FlagSet) error {{
-            f.set = set
-            return f.{name}Flag.ApplyWithError(set)
-        }}
-        """.format(**typedef))
-
-
-def _fwrite(outfile, text):
-    print(textwrap.dedent(text), end='', file=outfile)
-
-
-_WRITEFUNCS = {
-    'cli': _write_cli_flag_types,
-    'altsrc': _write_altsrc_flag_types
-}
-
-if __name__ == '__main__':
-    sys.exit(main())

vendor/github.com/codegangsta/cli/help.go

@@ -1,294 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strings"
-	"text/tabwriter"
-	"text/template"
-)
-
-// AppHelpTemplate is the text template for the Default help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var AppHelpTemplate = `NAME:
-   {{.Name}}{{if .Usage}} - {{.Usage}}{{end}}
-
-USAGE:
-   {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}{{if .Version}}{{if not .HideVersion}}
-
-VERSION:
-   {{.Version}}{{end}}{{end}}{{if .Description}}
-
-DESCRIPTION:
-   {{.Description}}{{end}}{{if len .Authors}}
-
-AUTHOR{{with $length := len .Authors}}{{if ne 1 $length}}S{{end}}{{end}}:
-   {{range $index, $author := .Authors}}{{if $index}}
-   {{end}}{{$author}}{{end}}{{end}}{{if .VisibleCommands}}
-
-COMMANDS:{{range .VisibleCategories}}{{if .Name}}
-   {{.Name}}:{{end}}{{range .VisibleCommands}}
-     {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
-
-GLOBAL OPTIONS:
-   {{range $index, $option := .VisibleFlags}}{{if $index}}
-   {{end}}{{$option}}{{end}}{{end}}{{if .Copyright}}
-
-COPYRIGHT:
-   {{.Copyright}}{{end}}
-`
-
-// CommandHelpTemplate is the text template for the command help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var CommandHelpTemplate = `NAME:
-   {{.HelpName}} - {{.Usage}}
-
-USAGE:
-   {{.HelpName}}{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Category}}
-
-CATEGORY:
-   {{.Category}}{{end}}{{if .Description}}
-
-DESCRIPTION:
-   {{.Description}}{{end}}{{if .VisibleFlags}}
-
-OPTIONS:
-   {{range .VisibleFlags}}{{.}}
-   {{end}}{{end}}
-`
-
-// SubcommandHelpTemplate is the text template for the subcommand help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var SubcommandHelpTemplate = `NAME:
-   {{.HelpName}} - {{if .Description}}{{.Description}}{{else}}{{.Usage}}{{end}}
-
-USAGE:
-   {{.HelpName}} command{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
-
-COMMANDS:{{range .VisibleCategories}}{{if .Name}}
-   {{.Name}}:{{end}}{{range .VisibleCommands}}
-     {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}
-{{end}}{{if .VisibleFlags}}
-OPTIONS:
-   {{range .VisibleFlags}}{{.}}
-   {{end}}{{end}}
-`
-
-var helpCommand = Command{
-	Name:      "help",
-	Aliases:   []string{"h"},
-	Usage:     "Shows a list of commands or help for one command",
-	ArgsUsage: "[command]",
-	Action: func(c *Context) error {
-		args := c.Args()
-		if args.Present() {
-			return ShowCommandHelp(c, args.First())
-		}
-
-		ShowAppHelp(c)
-		return nil
-	},
-}
-
-var helpSubcommand = Command{
-	Name:      "help",
-	Aliases:   []string{"h"},
-	Usage:     "Shows a list of commands or help for one command",
-	ArgsUsage: "[command]",
-	Action: func(c *Context) error {
-		args := c.Args()
-		if args.Present() {
-			return ShowCommandHelp(c, args.First())
-		}
-
-		return ShowSubcommandHelp(c)
-	},
-}
-
-// Prints help for the App or Command
-type helpPrinter func(w io.Writer, templ string, data interface{})
-
-// HelpPrinter is a function that writes the help output. If not set a default
-// is used. The function signature is:
-// func(w io.Writer, templ string, data interface{})
-var HelpPrinter helpPrinter = printHelp
-
-// VersionPrinter prints the version for the App
-var VersionPrinter = printVersion
-
-// ShowAppHelp is an action that displays the help.
-func ShowAppHelp(c *Context) error {
-	HelpPrinter(c.App.Writer, AppHelpTemplate, c.App)
-	return nil
-}
-
-// DefaultAppComplete prints the list of subcommands as the default app completion method
-func DefaultAppComplete(c *Context) {
-	for _, command := range c.App.Commands {
-		if command.Hidden {
-			continue
-		}
-		for _, name := range command.Names() {
-			fmt.Fprintln(c.App.Writer, name)
-		}
-	}
-}
-
-// ShowCommandHelp prints help for the given command
-func ShowCommandHelp(ctx *Context, command string) error {
-	// show the subcommand help for a command with subcommands
-	if command == "" {
-		HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App)
-		return nil
-	}
-
-	for _, c := range ctx.App.Commands {
-		if c.HasName(command) {
-			HelpPrinter(ctx.App.Writer, CommandHelpTemplate, c)
-			return nil
-		}
-	}
-
-	if ctx.App.CommandNotFound == nil {
-		return NewExitError(fmt.Sprintf("No help topic for '%v'", command), 3)
-	}
-
-	ctx.App.CommandNotFound(ctx, command)
-	return nil
-}
-
-// ShowSubcommandHelp prints help for the given subcommand
-func ShowSubcommandHelp(c *Context) error {
-	return ShowCommandHelp(c, c.Command.Name)
-}
-
-// ShowVersion prints the version number of the App
-func ShowVersion(c *Context) {
-	VersionPrinter(c)
-}
-
-func printVersion(c *Context) {
-	fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
-}
-
-// ShowCompletions prints the lists of commands within a given context
-func ShowCompletions(c *Context) {
-	a := c.App
-	if a != nil && a.BashComplete != nil {
-		a.BashComplete(c)
-	}
-}
-
-// ShowCommandCompletions prints the custom completions for a given command
-func ShowCommandCompletions(ctx *Context, command string) {
-	c := ctx.App.Command(command)
-	if c != nil && c.BashComplete != nil {
-		c.BashComplete(ctx)
-	}
-}
-
-func printHelp(out io.Writer, templ string, data interface{}) {
-	funcMap := template.FuncMap{
-		"join": strings.Join,
-	}
-
-	w := tabwriter.NewWriter(out, 1, 8, 2, ' ', 0)
-	t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
-	err := t.Execute(w, data)
-	if err != nil {
-		// If the writer is closed, t.Execute will fail, and there's nothing
-		// we can do to recover.
-		if os.Getenv("CLI_TEMPLATE_ERROR_DEBUG") != "" {
-			fmt.Fprintf(ErrWriter, "CLI TEMPLATE ERROR: %#v\n", err)
-		}
-		return
-	}
-	w.Flush()
-}
-
-func checkVersion(c *Context) bool {
-	found := false
-	if VersionFlag.Name != "" {
-		eachName(VersionFlag.Name, func(name string) {
-			if c.GlobalBool(name) || c.Bool(name) {
-				found = true
-			}
-		})
-	}
-	return found
-}
-
-func checkHelp(c *Context) bool {
-	found := false
-	if HelpFlag.Name != "" {
-		eachName(HelpFlag.Name, func(name string) {
-			if c.GlobalBool(name) || c.Bool(name) {
-				found = true
-			}
-		})
-	}
-	return found
-}
-
-func checkCommandHelp(c *Context, name string) bool {
-	if c.Bool("h") || c.Bool("help") {
-		ShowCommandHelp(c, name)
-		return true
-	}
-
-	return false
-}
-
-func checkSubcommandHelp(c *Context) bool {
-	if c.Bool("h") || c.Bool("help") {
-		ShowSubcommandHelp(c)
-		return true
-	}
-
-	return false
-}
-
-func checkShellCompleteFlag(a *App, arguments []string) (bool, []string) {
-	if !a.EnableBashCompletion {
-		return false, arguments
-	}
-
-	pos := len(arguments) - 1
-	lastArg := arguments[pos]
-
-	if lastArg != "--"+BashCompletionFlag.Name {
-		return false, arguments
-	}
-
-	return true, arguments[:pos]
-}
-
-func checkCompletions(c *Context) bool {
-	if !c.shellComplete {
-		return false
-	}
-
-	if args := c.Args(); args.Present() {
-		name := args.First()
-		if cmd := c.App.Command(name); cmd != nil {
-			// let the command handle the completion
-			return false
-		}
-	}
-
-	ShowCompletions(c)
-	return true
-}
-
-func checkCommandCompletions(c *Context, name string) bool {
-	if !c.shellComplete {
-		return false
-	}
-
-	ShowCommandCompletions(c, name)
-	return true
-}

vendor/github.com/codegangsta/cli/help_test.go

@@ -1,289 +0,0 @@
-package cli
-
-import (
-	"bytes"
-	"flag"
-	"strings"
-	"testing"
-)
-
-func Test_ShowAppHelp_NoAuthor(t *testing.T) {
-	output := new(bytes.Buffer)
-	app := NewApp()
-	app.Writer = output
-
-	c := NewContext(app, nil, nil)
-
-	ShowAppHelp(c)
-
-	if bytes.Index(output.Bytes(), []byte("AUTHOR(S):")) != -1 {
-		t.Errorf("expected\n%snot to include %s", output.String(), "AUTHOR(S):")
-	}
-}
-
-func Test_ShowAppHelp_NoVersion(t *testing.T) {
-	output := new(bytes.Buffer)
-	app := NewApp()
-	app.Writer = output
-
-	app.Version = ""
-
-	c := NewContext(app, nil, nil)
-
-	ShowAppHelp(c)
-
-	if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 {
-		t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:")
-	}
-}
-
-func Test_ShowAppHelp_HideVersion(t *testing.T) {
-	output := new(bytes.Buffer)
-	app := NewApp()
-	app.Writer = output
-
-	app.HideVersion = true
-
-	c := NewContext(app, nil, nil)
-
-	ShowAppHelp(c)
-
-	if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 {
-		t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:")
-	}
-}
-
-func Test_Help_Custom_Flags(t *testing.T) {
-	oldFlag := HelpFlag
-	defer func() {
-		HelpFlag = oldFlag
-	}()
-
-	HelpFlag = BoolFlag{
-		Name:  "help, x",
-		Usage: "show help",
-	}
-
-	app := App{
-		Flags: []Flag{
-			BoolFlag{Name: "foo, h"},
-		},
-		Action: func(ctx *Context) error {
-			if ctx.Bool("h") != true {
-				t.Errorf("custom help flag not set")
-			}
-			return nil
-		},
-	}
-	output := new(bytes.Buffer)
-	app.Writer = output
-	app.Run([]string{"test", "-h"})
-	if output.Len() > 0 {
-		t.Errorf("unexpected output: %s", output.String())
-	}
-}
-
-func Test_Version_Custom_Flags(t *testing.T) {
-	oldFlag := VersionFlag
-	defer func() {
-		VersionFlag = oldFlag
-	}()
-
-	VersionFlag = BoolFlag{
-		Name:  "version, V",
-		Usage: "show version",
-	}
-
-	app := App{
-		Flags: []Flag{
-			BoolFlag{Name: "foo, v"},
-		},
-		Action: func(ctx *Context) error {
-			if ctx.Bool("v") != true {
-				t.Errorf("custom version flag not set")
-			}
-			return nil
-		},
-	}
-	output := new(bytes.Buffer)
-	app.Writer = output
-	app.Run([]string{"test", "-v"})
-	if output.Len() > 0 {
-		t.Errorf("unexpected output: %s", output.String())
-	}
-}
-
-func Test_helpCommand_Action_ErrorIfNoTopic(t *testing.T) {
-	app := NewApp()
-
-	set := flag.NewFlagSet("test", 0)
-	set.Parse([]string{"foo"})
-
-	c := NewContext(app, set, nil)
-
-	err := helpCommand.Action.(func(*Context) error)(c)
-
-	if err == nil {
-		t.Fatalf("expected error from helpCommand.Action(), but got nil")
-	}
-
-	exitErr, ok := err.(*ExitError)
-	if !ok {
-		t.Fatalf("expected ExitError from helpCommand.Action(), but instead got: %v", err.Error())
-	}
-
-	if !strings.HasPrefix(exitErr.Error(), "No help topic for") {
-		t.Fatalf("expected an unknown help topic error, but got: %v", exitErr.Error())
-	}
-
-	if exitErr.exitCode != 3 {
-		t.Fatalf("expected exit value = 3, got %d instead", exitErr.exitCode)
-	}
-}
-
-func Test_helpCommand_InHelpOutput(t *testing.T) {
-	app := NewApp()
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"test", "--help"})
-
-	s := output.String()
-
-	if strings.Contains(s, "\nCOMMANDS:\nGLOBAL OPTIONS:\n") {
-		t.Fatalf("empty COMMANDS section detected: %q", s)
-	}
-
-	if !strings.Contains(s, "help, h") {
-		t.Fatalf("missing \"help, h\": %q", s)
-	}
-}
-
-func Test_helpSubcommand_Action_ErrorIfNoTopic(t *testing.T) {
-	app := NewApp()
-
-	set := flag.NewFlagSet("test", 0)
-	set.Parse([]string{"foo"})
-
-	c := NewContext(app, set, nil)
-
-	err := helpSubcommand.Action.(func(*Context) error)(c)
-
-	if err == nil {
-		t.Fatalf("expected error from helpCommand.Action(), but got nil")
-	}
-
-	exitErr, ok := err.(*ExitError)
-	if !ok {
-		t.Fatalf("expected ExitError from helpCommand.Action(), but instead got: %v", err.Error())
-	}
-
-	if !strings.HasPrefix(exitErr.Error(), "No help topic for") {
-		t.Fatalf("expected an unknown help topic error, but got: %v", exitErr.Error())
-	}
-
-	if exitErr.exitCode != 3 {
-		t.Fatalf("expected exit value = 3, got %d instead", exitErr.exitCode)
-	}
-}
-
-func TestShowAppHelp_CommandAliases(t *testing.T) {
-	app := &App{
-		Commands: []Command{
-			{
-				Name:    "frobbly",
-				Aliases: []string{"fr", "frob"},
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"foo", "--help"})
-
-	if !strings.Contains(output.String(), "frobbly, fr, frob") {
-		t.Errorf("expected output to include all command aliases; got: %q", output.String())
-	}
-}
-
-func TestShowCommandHelp_CommandAliases(t *testing.T) {
-	app := &App{
-		Commands: []Command{
-			{
-				Name:    "frobbly",
-				Aliases: []string{"fr", "frob", "bork"},
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"foo", "help", "fr"})
-
-	if !strings.Contains(output.String(), "frobbly") {
-		t.Errorf("expected output to include command name; got: %q", output.String())
-	}
-
-	if strings.Contains(output.String(), "bork") {
-		t.Errorf("expected output to exclude command aliases; got: %q", output.String())
-	}
-}
-
-func TestShowSubcommandHelp_CommandAliases(t *testing.T) {
-	app := &App{
-		Commands: []Command{
-			{
-				Name:    "frobbly",
-				Aliases: []string{"fr", "frob", "bork"},
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"foo", "help"})
-
-	if !strings.Contains(output.String(), "frobbly, fr, frob, bork") {
-		t.Errorf("expected output to include all command aliases; got: %q", output.String())
-	}
-}
-
-func TestShowAppHelp_HiddenCommand(t *testing.T) {
-	app := &App{
-		Commands: []Command{
-			{
-				Name: "frobbly",
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-			{
-				Name:   "secretfrob",
-				Hidden: true,
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"app", "--help"})
-
-	if strings.Contains(output.String(), "secretfrob") {
-		t.Errorf("expected output to exclude \"secretfrob\"; got: %q", output.String())
-	}
-
-	if !strings.Contains(output.String(), "frobbly") {
-		t.Errorf("expected output to include \"frobbly\"; got: %q", output.String())
-	}
-}

vendor/github.com/codegangsta/cli/helpers_test.go

@@ -1,28 +0,0 @@
-package cli
-
-import (
-	"os"
-	"reflect"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-var (
-	wd, _ = os.Getwd()
-)
-
-func expect(t *testing.T, a interface{}, b interface{}) {
-	_, fn, line, _ := runtime.Caller(1)
-	fn = strings.Replace(fn, wd+"/", "", -1)
-
-	if !reflect.DeepEqual(a, b) {
-		t.Errorf("(%s:%d) Expected %v (type %v) - Got %v (type %v)", fn, line, b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}
-
-func refute(t *testing.T, a interface{}, b interface{}) {
-	if reflect.DeepEqual(a, b) {
-		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}

vendor/github.com/codegangsta/cli/helpers_unix_test.go

@@ -1,9 +0,0 @@
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package cli
-
-import "os"
-
-func clearenv() {
-	os.Clearenv()
-}

vendor/github.com/codegangsta/cli/helpers_windows_test.go

@@ -1,20 +0,0 @@
-package cli
-
-import (
-	"os"
-	"syscall"
-)
-
-// os.Clearenv() doesn't actually unset variables on Windows
-// See: https://github.com/golang/go/issues/17902
-func clearenv() {
-	for _, s := range os.Environ() {
-		for j := 1; j < len(s); j++ {
-			if s[j] == '=' {
-				keyp, _ := syscall.UTF16PtrFromString(s[0:j])
-				syscall.SetEnvironmentVariable(keyp, nil)
-				break
-			}
-		}
-	}
-}

vendor/github.com/codegangsta/cli/runtests

@@ -1,122 +0,0 @@
-#!/usr/bin/env python
-from __future__ import print_function
-
-import argparse
-import os
-import sys
-import tempfile
-
-from subprocess import check_call, check_output
-
-
-PACKAGE_NAME = os.environ.get(
-    'CLI_PACKAGE_NAME', 'github.com/urfave/cli'
-)
-
-
-def main(sysargs=sys.argv[:]):
-    targets = {
-        'vet': _vet,
-        'test': _test,
-        'gfmrun': _gfmrun,
-        'toc': _toc,
-        'gen': _gen,
-    }
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        'target', nargs='?', choices=tuple(targets.keys()), default='test'
-    )
-    args = parser.parse_args(sysargs[1:])
-
-    targets[args.target]()
-    return 0
-
-
-def _test():
-    if check_output('go version'.split()).split()[2] < 'go1.2':
-        _run('go test -v .')
-        return
-
-    coverprofiles = []
-    for subpackage in ['', 'altsrc']:
-        coverprofile = 'cli.coverprofile'
-        if subpackage != '':
-            coverprofile = '{}.coverprofile'.format(subpackage)
-
-        coverprofiles.append(coverprofile)
-
-        _run('go test -v'.split() + [
-            '-coverprofile={}'.format(coverprofile),
-            ('{}/{}'.format(PACKAGE_NAME, subpackage)).rstrip('/')
-        ])
-
-    combined_name = _combine_coverprofiles(coverprofiles)
-    _run('go tool cover -func={}'.format(combined_name))
-    os.remove(combined_name)
-
-
-def _gfmrun():
-    go_version = check_output('go version'.split()).split()[2]
-    if go_version < 'go1.3':
-        print('runtests: skip on {}'.format(go_version), file=sys.stderr)
-        return
-    _run(['gfmrun', '-c', str(_gfmrun_count()), '-s', 'README.md'])
-
-
-def _vet():
-    _run('go vet ./...')
-
-
-def _toc():
-    _run('node_modules/.bin/markdown-toc -i README.md')
-    _run('git diff --exit-code')
-
-
-def _gen():
-    go_version = check_output('go version'.split()).split()[2]
-    if go_version < 'go1.5':
-        print('runtests: skip on {}'.format(go_version), file=sys.stderr)
-        return
-
-    _run('go generate ./...')
-    _run('git diff --exit-code')
-
-
-def _run(command):
-    if hasattr(command, 'split'):
-        command = command.split()
-    print('runtests: {}'.format(' '.join(command)), file=sys.stderr)
-    check_call(command)
-
-
-def _gfmrun_count():
-    with open('README.md') as infile:
-        lines = infile.read().splitlines()
-        return len(filter(_is_go_runnable, lines))
-
-
-def _is_go_runnable(line):
-    return line.startswith('package main')
-
-
-def _combine_coverprofiles(coverprofiles):
-    combined = tempfile.NamedTemporaryFile(
-        suffix='.coverprofile', delete=False
-    )
-    combined.write('mode: set\n')
-
-    for coverprofile in coverprofiles:
-        with open(coverprofile, 'r') as infile:
-            for line in infile.readlines():
-                if not line.startswith('mode: '):
-                    combined.write(line)
-
-    combined.flush()
-    name = combined.name
-    combined.close()
-    return name
-
-
-if __name__ == '__main__':
-    sys.exit(main())

vendor/github.com/davecgh/go-spew/.travis.yml

@@ -1,14 +0,0 @@
-language: go
-go:
-    - 1.5.4
-    - 1.6.3
-    - 1.7
-install:
-    - go get -v golang.org/x/tools/cmd/cover
-script:
-    - go test -v -tags=safe ./spew
-    - go test -v -tags=testcgo ./spew -covermode=count -coverprofile=profile.cov
-after_success:
-    - go get -v github.com/mattn/goveralls
-    - export PATH=$PATH:$HOME/gopath/bin
-    - goveralls -coverprofile=profile.cov -service=travis-ci

vendor/github.com/davecgh/go-spew/LICENSE

@@ -1,15 +0,0 @@
-ISC License
-
-Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
-
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

vendor/github.com/davecgh/go-spew/README.md

@@ -1,205 +0,0 @@
-go-spew
-=======
-
-[![Build Status](https://img.shields.io/travis/davecgh/go-spew.svg)]
-(https://travis-ci.org/davecgh/go-spew) [![ISC License]
-(http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org) [![Coverage Status]
-(https://img.shields.io/coveralls/davecgh/go-spew.svg)]
-(https://coveralls.io/r/davecgh/go-spew?branch=master)
-
-
-Go-spew implements a deep pretty printer for Go data structures to aid in
-debugging.  A comprehensive suite of tests with 100% test coverage is provided
-to ensure proper functionality.  See `test_coverage.txt` for the gocov coverage
-report.  Go-spew is licensed under the liberal ISC license, so it may be used in
-open source or commercial projects.
-
-If you're interested in reading about how this package came to life and some
-of the challenges involved in providing a deep pretty printer, there is a blog
-post about it
-[here](https://web.archive.org/web/20160304013555/https://blog.cyphertite.com/go-spew-a-journey-into-dumping-go-data-structures/).
-
-## Documentation
-
-[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)]
-(http://godoc.org/github.com/davecgh/go-spew/spew)
-
-Full `go doc` style documentation for the project can be viewed online without
-installing this package by using the excellent GoDoc site here:
-http://godoc.org/github.com/davecgh/go-spew/spew
-
-You can also view the documentation locally once the package is installed with
-the `godoc` tool by running `godoc -http=":6060"` and pointing your browser to
-http://localhost:6060/pkg/github.com/davecgh/go-spew/spew
-
-## Installation
-
-```bash
-$ go get -u github.com/davecgh/go-spew/spew
-```
-
-## Quick Start
-
-Add this import line to the file you're working in:
-
-```Go
-import "github.com/davecgh/go-spew/spew"
-```
-
-To dump a variable with full newlines, indentation, type, and pointer
-information use Dump, Fdump, or Sdump:
-
-```Go
-spew.Dump(myVar1, myVar2, ...)
-spew.Fdump(someWriter, myVar1, myVar2, ...)
-str := spew.Sdump(myVar1, myVar2, ...)
-```
-
-Alternatively, if you would prefer to use format strings with a compacted inline
-printing style, use the convenience wrappers Printf, Fprintf, etc with %v (most
-compact), %+v (adds pointer addresses), %#v (adds types), or %#+v (adds types
-and pointer addresses): 
-
-```Go
-spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-```
-
-## Debugging a Web Application Example
-
-Here is an example of how you can use `spew.Sdump()` to help debug a web application. Please be sure to wrap your output using the `html.EscapeString()` function for safety reasons. You should also only use this debugging technique in a development environment, never in production.
-
-```Go
-package main
-
-import (
-    "fmt"
-    "html"
-    "net/http"
-
-    "github.com/davecgh/go-spew/spew"
-)
-
-func handler(w http.ResponseWriter, r *http.Request) {
-    w.Header().Set("Content-Type", "text/html")
-    fmt.Fprintf(w, "Hi there, %s!", r.URL.Path[1:])
-    fmt.Fprintf(w, "<!--\n" + html.EscapeString(spew.Sdump(w)) + "\n-->")
-}
-
-func main() {
-    http.HandleFunc("/", handler)
-    http.ListenAndServe(":8080", nil)
-}
-```
-
-## Sample Dump Output
-
-```
-(main.Foo) {
- unexportedField: (*main.Bar)(0xf84002e210)({
-  flag: (main.Flag) flagTwo,
-  data: (uintptr) <nil>
- }),
- ExportedField: (map[interface {}]interface {}) {
-  (string) "one": (bool) true
- }
-}
-([]uint8) {
- 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
- 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
- 00000020  31 32                                             |12|
-}
-```
-
-## Sample Formatter Output
-
-Double pointer to a uint8:
-```
-	  %v: <**>5
-	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
-	 %#v: (**uint8)5
-	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
-```
-
-Pointer to circular struct with a uint8 field and a pointer to itself:
-```
-	  %v: <*>{1 <*><shown>}
-	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
-	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
-	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
-```
-
-## Configuration Options
-
-Configuration of spew is handled by fields in the ConfigState type. For
-convenience, all of the top-level functions use a global state available via the
-spew.Config global.
-
-It is also possible to create a ConfigState instance that provides methods
-equivalent to the top-level functions. This allows concurrent configuration
-options. See the ConfigState documentation for more details.
-
-```
-* Indent
-	String to use for each indentation level for Dump functions.
-	It is a single space by default.  A popular alternative is "\t".
-
-* MaxDepth
-	Maximum number of levels to descend into nested data structures.
-	There is no limit by default.
-
-* DisableMethods
-	Disables invocation of error and Stringer interface methods.
-	Method invocation is enabled by default.
-
-* DisablePointerMethods
-	Disables invocation of error and Stringer interface methods on types
-	which only accept pointer receivers from non-pointer variables.  This option
-	relies on access to the unsafe package, so it will not have any effect when
-	running in environments without access to the unsafe package such as Google
-	App Engine or with the "safe" build tag specified.
-	Pointer method invocation is enabled by default.
-
-* DisablePointerAddresses
-	DisablePointerAddresses specifies whether to disable the printing of
-	pointer addresses. This is useful when diffing data structures in tests.
-
-* DisableCapacities
-	DisableCapacities specifies whether to disable the printing of capacities
-	for arrays, slices, maps and channels. This is useful when diffing data
-	structures in tests.
-
-* ContinueOnMethod
-	Enables recursion into types after invoking error and Stringer interface
-	methods. Recursion after method invocation is disabled by default.
-
-* SortKeys
-	Specifies map keys should be sorted before being printed. Use
-	this to have a more deterministic, diffable output.  Note that
-	only native types (bool, int, uint, floats, uintptr and string)
-	and types which implement error or Stringer interfaces are supported,
-	with other types sorted according to the reflect.Value.String() output
-	which guarantees display stability.  Natural map order is used by
-	default.
-
-* SpewKeys
-	SpewKeys specifies that, as a last resort attempt, map keys should be
-	spewed to strings and sorted by those strings.  This is only considered
-	if SortKeys is true.
-
-```
-
-## Unsafe Package Dependency
-
-This package relies on the unsafe package to perform some of the more advanced
-features, however it also supports a "limited" mode which allows it to work in
-environments where the unsafe package is not available.  By default, it will
-operate in this mode on Google App Engine and when compiled with GopherJS.  The
-"safe" build tag may also be specified to force the package to build without
-using the unsafe package.
-
-## License
-
-Go-spew is licensed under the [copyfree](http://copyfree.org) ISC License.

vendor/github.com/davecgh/go-spew/cov_report.sh

@@ -1,22 +0,0 @@
-#!/bin/sh
-
-# This script uses gocov to generate a test coverage report.
-# The gocov tool my be obtained with the following command:
-#   go get github.com/axw/gocov/gocov
-#
-# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH.
-
-# Check for gocov.
-if ! type gocov >/dev/null 2>&1; then
-	echo >&2 "This script requires the gocov tool."
-	echo >&2 "You may obtain it with the following command:"
-	echo >&2 "go get github.com/axw/gocov/gocov"
-	exit 1
-fi
-
-# Only run the cgo tests if gcc is installed.
-if type gcc >/dev/null 2>&1; then
-	(cd spew && gocov test -tags testcgo | gocov report)
-else
-	(cd spew && gocov test | gocov report)
-fi

vendor/github.com/davecgh/go-spew/spew/bypass.go

@@ -1,152 +0,0 @@
-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when the code is not running on Google App Engine, compiled by GopherJS, and
-// "-tags safe" is not added to the go build command line.  The "disableunsafe"
-// tag is deprecated and thus should not be used.
-// +build !js,!appengine,!safe,!disableunsafe
-
-package spew
-
-import (
-	"reflect"
-	"unsafe"
-)
-
-const (
-	// UnsafeDisabled is a build-time constant which specifies whether or
-	// not access to the unsafe package is available.
-	UnsafeDisabled = false
-
-	// ptrSize is the size of a pointer on the current arch.
-	ptrSize = unsafe.Sizeof((*byte)(nil))
-)
-
-var (
-	// offsetPtr, offsetScalar, and offsetFlag are the offsets for the
-	// internal reflect.Value fields.  These values are valid before golang
-	// commit ecccf07e7f9d which changed the format.  The are also valid
-	// after commit 82f48826c6c7 which changed the format again to mirror
-	// the original format.  Code in the init function updates these offsets
-	// as necessary.
-	offsetPtr    = uintptr(ptrSize)
-	offsetScalar = uintptr(0)
-	offsetFlag   = uintptr(ptrSize * 2)
-
-	// flagKindWidth and flagKindShift indicate various bits that the
-	// reflect package uses internally to track kind information.
-	//
-	// flagRO indicates whether or not the value field of a reflect.Value is
-	// read-only.
-	//
-	// flagIndir indicates whether the value field of a reflect.Value is
-	// the actual data or a pointer to the data.
-	//
-	// These values are valid before golang commit 90a7c3c86944 which
-	// changed their positions.  Code in the init function updates these
-	// flags as necessary.
-	flagKindWidth = uintptr(5)
-	flagKindShift = uintptr(flagKindWidth - 1)
-	flagRO        = uintptr(1 << 0)
-	flagIndir     = uintptr(1 << 1)
-)
-
-func init() {
-	// Older versions of reflect.Value stored small integers directly in the
-	// ptr field (which is named val in the older versions).  Versions
-	// between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
-	// scalar for this purpose which unfortunately came before the flag
-	// field, so the offset of the flag field is different for those
-	// versions.
-	//
-	// This code constructs a new reflect.Value from a known small integer
-	// and checks if the size of the reflect.Value struct indicates it has
-	// the scalar field. When it does, the offsets are updated accordingly.
-	vv := reflect.ValueOf(0xf00)
-	if unsafe.Sizeof(vv) == (ptrSize * 4) {
-		offsetScalar = ptrSize * 2
-		offsetFlag = ptrSize * 3
-	}
-
-	// Commit 90a7c3c86944 changed the flag positions such that the low
-	// order bits are the kind.  This code extracts the kind from the flags
-	// field and ensures it's the correct type.  When it's not, the flag
-	// order has been changed to the newer format, so the flags are updated
-	// accordingly.
-	upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
-	upfv := *(*uintptr)(upf)
-	flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
-	if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
-		flagKindShift = 0
-		flagRO = 1 << 5
-		flagIndir = 1 << 6
-
-		// Commit adf9b30e5594 modified the flags to separate the
-		// flagRO flag into two bits which specifies whether or not the
-		// field is embedded.  This causes flagIndir to move over a bit
-		// and means that flagRO is the combination of either of the
-		// original flagRO bit and the new bit.
-		//
-		// This code detects the change by extracting what used to be
-		// the indirect bit to ensure it's set.  When it's not, the flag
-		// order has been changed to the newer format, so the flags are
-		// updated accordingly.
-		if upfv&flagIndir == 0 {
-			flagRO = 3 << 5
-			flagIndir = 1 << 7
-		}
-	}
-}
-
-// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
-// the typical safety restrictions preventing access to unaddressable and
-// unexported data.  It works by digging the raw pointer to the underlying
-// value out of the protected value and generating a new unprotected (unsafe)
-// reflect.Value to it.
-//
-// This allows us to check for implementations of the Stringer and error
-// interfaces to be used for pretty printing ordinarily unaddressable and
-// inaccessible values such as unexported struct fields.
-func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
-	indirects := 1
-	vt := v.Type()
-	upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
-	rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
-	if rvf&flagIndir != 0 {
-		vt = reflect.PtrTo(v.Type())
-		indirects++
-	} else if offsetScalar != 0 {
-		// The value is in the scalar field when it's not one of the
-		// reference types.
-		switch vt.Kind() {
-		case reflect.Uintptr:
-		case reflect.Chan:
-		case reflect.Func:
-		case reflect.Map:
-		case reflect.Ptr:
-		case reflect.UnsafePointer:
-		default:
-			upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
-				offsetScalar)
-		}
-	}
-
-	pv := reflect.NewAt(vt, upv)
-	rv = pv
-	for i := 0; i < indirects; i++ {
-		rv = rv.Elem()
-	}
-	return rv
-}

vendor/github.com/davecgh/go-spew/spew/bypasssafe.go

@@ -1,38 +0,0 @@
-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when the code is running on Google App Engine, compiled by GopherJS, or
-// "-tags safe" is added to the go build command line.  The "disableunsafe"
-// tag is deprecated and thus should not be used.
-// +build js appengine safe disableunsafe
-
-package spew
-
-import "reflect"
-
-const (
-	// UnsafeDisabled is a build-time constant which specifies whether or
-	// not access to the unsafe package is available.
-	UnsafeDisabled = true
-)
-
-// unsafeReflectValue typically converts the passed reflect.Value into a one
-// that bypasses the typical safety restrictions preventing access to
-// unaddressable and unexported data.  However, doing this relies on access to
-// the unsafe package.  This is a stub version which simply returns the passed
-// reflect.Value when the unsafe package is not available.
-func unsafeReflectValue(v reflect.Value) reflect.Value {
-	return v
-}

vendor/github.com/davecgh/go-spew/spew/common.go

@@ -1,341 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"reflect"
-	"sort"
-	"strconv"
-)
-
-// Some constants in the form of bytes to avoid string overhead.  This mirrors
-// the technique used in the fmt package.
-var (
-	panicBytes            = []byte("(PANIC=")
-	plusBytes             = []byte("+")
-	iBytes                = []byte("i")
-	trueBytes             = []byte("true")
-	falseBytes            = []byte("false")
-	interfaceBytes        = []byte("(interface {})")
-	commaNewlineBytes     = []byte(",\n")
-	newlineBytes          = []byte("\n")
-	openBraceBytes        = []byte("{")
-	openBraceNewlineBytes = []byte("{\n")
-	closeBraceBytes       = []byte("}")
-	asteriskBytes         = []byte("*")
-	colonBytes            = []byte(":")
-	colonSpaceBytes       = []byte(": ")
-	openParenBytes        = []byte("(")
-	closeParenBytes       = []byte(")")
-	spaceBytes            = []byte(" ")
-	pointerChainBytes     = []byte("->")
-	nilAngleBytes         = []byte("<nil>")
-	maxNewlineBytes       = []byte("<max depth reached>\n")
-	maxShortBytes         = []byte("<max>")
-	circularBytes         = []byte("<already shown>")
-	circularShortBytes    = []byte("<shown>")
-	invalidAngleBytes     = []byte("<invalid>")
-	openBracketBytes      = []byte("[")
-	closeBracketBytes     = []byte("]")
-	percentBytes          = []byte("%")
-	precisionBytes        = []byte(".")
-	openAngleBytes        = []byte("<")
-	closeAngleBytes       = []byte(">")
-	openMapBytes          = []byte("map[")
-	closeMapBytes         = []byte("]")
-	lenEqualsBytes        = []byte("len=")
-	capEqualsBytes        = []byte("cap=")
-)
-
-// hexDigits is used to map a decimal value to a hex digit.
-var hexDigits = "0123456789abcdef"
-
-// catchPanic handles any panics that might occur during the handleMethods
-// calls.
-func catchPanic(w io.Writer, v reflect.Value) {
-	if err := recover(); err != nil {
-		w.Write(panicBytes)
-		fmt.Fprintf(w, "%v", err)
-		w.Write(closeParenBytes)
-	}
-}
-
-// handleMethods attempts to call the Error and String methods on the underlying
-// type the passed reflect.Value represents and outputes the result to Writer w.
-//
-// It handles panics in any called methods by catching and displaying the error
-// as the formatted value.
-func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
-	// We need an interface to check if the type implements the error or
-	// Stringer interface.  However, the reflect package won't give us an
-	// interface on certain things like unexported struct fields in order
-	// to enforce visibility rules.  We use unsafe, when it's available,
-	// to bypass these restrictions since this package does not mutate the
-	// values.
-	if !v.CanInterface() {
-		if UnsafeDisabled {
-			return false
-		}
-
-		v = unsafeReflectValue(v)
-	}
-
-	// Choose whether or not to do error and Stringer interface lookups against
-	// the base type or a pointer to the base type depending on settings.
-	// Technically calling one of these methods with a pointer receiver can
-	// mutate the value, however, types which choose to satisify an error or
-	// Stringer interface with a pointer receiver should not be mutating their
-	// state inside these interface methods.
-	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
-		v = unsafeReflectValue(v)
-	}
-	if v.CanAddr() {
-		v = v.Addr()
-	}
-
-	// Is it an error or Stringer?
-	switch iface := v.Interface().(type) {
-	case error:
-		defer catchPanic(w, v)
-		if cs.ContinueOnMethod {
-			w.Write(openParenBytes)
-			w.Write([]byte(iface.Error()))
-			w.Write(closeParenBytes)
-			w.Write(spaceBytes)
-			return false
-		}
-
-		w.Write([]byte(iface.Error()))
-		return true
-
-	case fmt.Stringer:
-		defer catchPanic(w, v)
-		if cs.ContinueOnMethod {
-			w.Write(openParenBytes)
-			w.Write([]byte(iface.String()))
-			w.Write(closeParenBytes)
-			w.Write(spaceBytes)
-			return false
-		}
-		w.Write([]byte(iface.String()))
-		return true
-	}
-	return false
-}
-
-// printBool outputs a boolean value as true or false to Writer w.
-func printBool(w io.Writer, val bool) {
-	if val {
-		w.Write(trueBytes)
-	} else {
-		w.Write(falseBytes)
-	}
-}
-
-// printInt outputs a signed integer value to Writer w.
-func printInt(w io.Writer, val int64, base int) {
-	w.Write([]byte(strconv.FormatInt(val, base)))
-}
-
-// printUint outputs an unsigned integer value to Writer w.
-func printUint(w io.Writer, val uint64, base int) {
-	w.Write([]byte(strconv.FormatUint(val, base)))
-}
-
-// printFloat outputs a floating point value using the specified precision,
-// which is expected to be 32 or 64bit, to Writer w.
-func printFloat(w io.Writer, val float64, precision int) {
-	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
-}
-
-// printComplex outputs a complex value using the specified float precision
-// for the real and imaginary parts to Writer w.
-func printComplex(w io.Writer, c complex128, floatPrecision int) {
-	r := real(c)
-	w.Write(openParenBytes)
-	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
-	i := imag(c)
-	if i >= 0 {
-		w.Write(plusBytes)
-	}
-	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
-	w.Write(iBytes)
-	w.Write(closeParenBytes)
-}
-
-// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
-// prefix to Writer w.
-func printHexPtr(w io.Writer, p uintptr) {
-	// Null pointer.
-	num := uint64(p)
-	if num == 0 {
-		w.Write(nilAngleBytes)
-		return
-	}
-
-	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
-	buf := make([]byte, 18)
-
-	// It's simpler to construct the hex string right to left.
-	base := uint64(16)
-	i := len(buf) - 1
-	for num >= base {
-		buf[i] = hexDigits[num%base]
-		num /= base
-		i--
-	}
-	buf[i] = hexDigits[num]
-
-	// Add '0x' prefix.
-	i--
-	buf[i] = 'x'
-	i--
-	buf[i] = '0'
-
-	// Strip unused leading bytes.
-	buf = buf[i:]
-	w.Write(buf)
-}
-
-// valuesSorter implements sort.Interface to allow a slice of reflect.Value
-// elements to be sorted.
-type valuesSorter struct {
-	values  []reflect.Value
-	strings []string // either nil or same len and values
-	cs      *ConfigState
-}
-
-// newValuesSorter initializes a valuesSorter instance, which holds a set of
-// surrogate keys on which the data should be sorted.  It uses flags in
-// ConfigState to decide if and how to populate those surrogate keys.
-func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
-	vs := &valuesSorter{values: values, cs: cs}
-	if canSortSimply(vs.values[0].Kind()) {
-		return vs
-	}
-	if !cs.DisableMethods {
-		vs.strings = make([]string, len(values))
-		for i := range vs.values {
-			b := bytes.Buffer{}
-			if !handleMethods(cs, &b, vs.values[i]) {
-				vs.strings = nil
-				break
-			}
-			vs.strings[i] = b.String()
-		}
-	}
-	if vs.strings == nil && cs.SpewKeys {
-		vs.strings = make([]string, len(values))
-		for i := range vs.values {
-			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
-		}
-	}
-	return vs
-}
-
-// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
-// directly, or whether it should be considered for sorting by surrogate keys
-// (if the ConfigState allows it).
-func canSortSimply(kind reflect.Kind) bool {
-	// This switch parallels valueSortLess, except for the default case.
-	switch kind {
-	case reflect.Bool:
-		return true
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		return true
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		return true
-	case reflect.Float32, reflect.Float64:
-		return true
-	case reflect.String:
-		return true
-	case reflect.Uintptr:
-		return true
-	case reflect.Array:
-		return true
-	}
-	return false
-}
-
-// Len returns the number of values in the slice.  It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Len() int {
-	return len(s.values)
-}
-
-// Swap swaps the values at the passed indices.  It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Swap(i, j int) {
-	s.values[i], s.values[j] = s.values[j], s.values[i]
-	if s.strings != nil {
-		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
-	}
-}
-
-// valueSortLess returns whether the first value should sort before the second
-// value.  It is used by valueSorter.Less as part of the sort.Interface
-// implementation.
-func valueSortLess(a, b reflect.Value) bool {
-	switch a.Kind() {
-	case reflect.Bool:
-		return !a.Bool() && b.Bool()
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		return a.Int() < b.Int()
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		return a.Uint() < b.Uint()
-	case reflect.Float32, reflect.Float64:
-		return a.Float() < b.Float()
-	case reflect.String:
-		return a.String() < b.String()
-	case reflect.Uintptr:
-		return a.Uint() < b.Uint()
-	case reflect.Array:
-		// Compare the contents of both arrays.
-		l := a.Len()
-		for i := 0; i < l; i++ {
-			av := a.Index(i)
-			bv := b.Index(i)
-			if av.Interface() == bv.Interface() {
-				continue
-			}
-			return valueSortLess(av, bv)
-		}
-	}
-	return a.String() < b.String()
-}
-
-// Less returns whether the value at index i should sort before the
-// value at index j.  It is part of the sort.Interface implementation.
-func (s *valuesSorter) Less(i, j int) bool {
-	if s.strings == nil {
-		return valueSortLess(s.values[i], s.values[j])
-	}
-	return s.strings[i] < s.strings[j]
-}
-
-// sortValues is a sort function that handles both native types and any type that
-// can be converted to error or Stringer.  Other inputs are sorted according to
-// their Value.String() value to ensure display stability.
-func sortValues(values []reflect.Value, cs *ConfigState) {
-	if len(values) == 0 {
-		return
-	}
-	sort.Sort(newValuesSorter(values, cs))
-}