ci(docker): fail push when trivy finds CRITICAL/HIGH issues

- Add independent trivy.yml workflow with repo scan and image scan jobs
- Add Trivy image scan step in docker.yml before pushing Docker image
- Add security-events permission for SARIF upload
- Add Trivy Security Scan badge to README

.appveyor.yml

@@ -1,38 +0,0 @@
-version: '{build}'
-image: 'Visual Studio 2017'
-
-clone_folder: 'c:\go\src\github.com\appleboy\drone-telegram'
-
-environment:
-  GOPATH: c:\go
-  docker_username:
-    secure: em/TNLUXxG19O/HvbvfJuQ==
-  docker_password:
-    secure: Yo9FJJqihaNz5q8T4Jz8tQ==
-
-branches:
-  only:
-    - master
-
-install:
-  - echo %PATH%
-  - echo %GOPATH%
-  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
-  - go version
-  - go env
-  - docker version
-
-build_script:
-  - ps: |
-      go build .
-      docker pull microsoft/nanoserver:10.0.14393.1884
-      docker build -f Dockerfile.windows -t appleboy/drone-telegram:windows .
-
-test_script:
-  - ps: |
-      docker run --rm appleboy/drone-telegram:windows --version
-
-deploy_script:
-  - ps: |
-      docker login --username $env:DOCKER_USERNAME --password $env:DOCKER_PASSWORD
-      docker push appleboy/drone-telegram:windows

.drone.yml

@@ -1,147 +0,0 @@
-workspace:
-  base: /go/src
-  path: github.com/appleboy/drone-telegram
-
-clone:
-  git:
-    image: plugins/git
-    depth: 50
-    tags: true
-
-pipeline:
-  test:
-    image: appleboy/golang-testing
-    pull: true
-    secrets: [ telegram_token, telegram_to ]
-    commands:
-      - make vet
-      - make lint
-      - make test-vendor
-      - make misspell-check
-      - make test
-      - make coverage
-
-  build_linux_amd64:
-    image: appleboy/golang-testing
-    pull: true
-    group: build
-    commands:
-      - make build_linux_amd64
-
-  build_linux_i386:
-    image: appleboy/golang-testing
-    pull: true
-    group: build
-    commands:
-      - make build_linux_i386
-
-  build_linux_arm64:
-    image: appleboy/golang-testing
-    pull: true
-    group: build
-    commands:
-      - make build_linux_arm64
-
-  build_linux_arm:
-    image: appleboy/golang-testing
-    pull: true
-    group: build
-    commands:
-      - make build_linux_arm
-
-  codecov:
-    image: robertstettner/drone-codecov
-    secrets: [ codecov_token ]
-    files:
-      - .cover/coverage.txt
-    when:
-      event: [ push, pull_request ]
-
-  release:
-    image: appleboy/golang-testing
-    pull: true
-    commands:
-      - make release
-    when:
-      event: [ tag ]
-
-  publish_alpine:
-    image: plugins/docker
-    group: release
-    pull: true
-    dockerfile: Dockerfile.alpine
-    secrets: [ docker_username, docker_password ]
-    default_tags: true
-    default_suffix: alpine
-    repo: ${DRONE_REPO}
-    when:
-      event: [ push, tag ]
-      local: false
-
-  publish_linux_amd64:
-    image: plugins/docker:17.05
-    pull: true
-    secrets: [ docker_username, docker_password ]
-    group: release
-    repo: ${DRONE_REPO}
-    auto_tag: true
-    dockerfile: Dockerfile
-    when:
-      event: [ push, tag ]
-      local: false
-
-  publish_linux_i386:
-    image: plugins/docker:17.05
-    pull: true
-    secrets: [ docker_username, docker_password ]
-    group: release
-    repo: ${DRONE_REPO}
-    auto_tag: true
-    auto_tag_suffix: i386
-    dockerfile: Dockerfile.i386
-    when:
-      event: [ push, tag ]
-      local: false
-
-  publish_linux_arm64:
-    image: plugins/docker:17.05
-    pull: true
-    secrets: [ docker_username, docker_password ]
-    group: release
-    repo: ${DRONE_REPO}
-    auto_tag: true
-    auto_tag_suffix: arm64
-    dockerfile: Dockerfile.arm64
-    when:
-      event: [ push, tag ]
-      local: false
-
-  publish_linux_arm:
-    image: plugins/docker:17.05
-    pull: true
-    secrets: [ docker_username, docker_password ]
-    group: release
-    repo: ${DRONE_REPO}
-    auto_tag: true
-    auto_tag_suffix: arm
-    dockerfile: Dockerfile.arm
-    when:
-      event: [ push, tag ]
-      local: false
-
-  github:
-    image: plugins/github-release
-    pull: true
-    group: release
-    secrets: [ github_release_api_key ]
-    files:
-      - dist/release/*
-    when:
-      event: [ tag ]
-
-  discord:
-    image: appleboy/drone-discord
-    pull: true
-    secrets: [ discord_webhook_id, discord_webhook_token ]
-    when:
-      status: [ changed, failure ]

.editorconfig

@@ -1,42 +0,0 @@
-# unifying the coding style for different editors and IDEs => editorconfig.org
-
-; indicate this is the root of the project
-root = true
-
-###########################################################
-; common
-###########################################################
-
-[*]
-charset = utf-8
-
-end_of_line = LF
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-indent_style = space
-indent_size = 2
-
-###########################################################
-; make
-###########################################################
-
-[Makefile]
-indent_style = tab
-
-[makefile]
-indent_style = tab
-
-###########################################################
-; markdown
-###########################################################
-
-[*.md]
-trim_trailing_whitespace = false
-
-###########################################################
-; golang
-###########################################################
-
-[*.go]
-indent_style = tab

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: ['https://www.paypal.me/appleboy46']

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+  - package-ecosystem: gomod
+    directory: /
+    schedule:
+      interval: weekly

.github/workflows/codeql.yml

@@ -0,0 +1,54 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [master]
+  schedule:
+    - cron: "41 23 * * 6"
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ["go"]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v4
+        with:
+          languages: ${{ matrix.language }}
+          # If you wish to specify custom queries, you can do so here or in a config file.
+          # By default, queries listed here will override any specified in a config file.
+          # Prefix the list here with "+" to use these queries and those in the config file.
+          # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v4

.github/workflows/docker.yml

@@ -0,0 +1,102 @@
+name: Docker Image
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - "v*"
+  pull_request:
+    branches:
+      - "master"
+
+permissions:
+  contents: read
+  packages: write
+  security-events: write
+
+jobs:
+  build-docker:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version: "^1"
+          check-latest: true
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Build binary
+        run: |
+          make build_linux_amd64
+          make build_linux_arm64
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v4
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Docker meta
+        id: docker-meta
+        uses: docker/metadata-action@v6
+        with:
+          images: |
+            ${{ github.repository }}
+            ghcr.io/${{ github.repository }}
+          tags: |
+            type=raw,value=latest,enable={{is_default_branch}}
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+
+      - name: Build image for scanning
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: linux/amd64
+          push: false
+          load: true
+          tags: drone-telegram:scan
+
+      - name: Run Trivy vulnerability scanner
+        uses: aquasecurity/trivy-action@v0.35.0
+        with:
+          image-ref: "drone-telegram:scan"
+          format: "sarif"
+          output: "trivy-image-results.sarif"
+          severity: "CRITICAL,HIGH"
+          exit-code: '1'
+      - name: Upload Trivy scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@v4
+        if: always()
+        with:
+          sarif_file: "trivy-image-results.sarif"
+          category: "trivy-docker-image"
+
+      - name: Build and push
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          file: docker/Dockerfile
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.docker-meta.outputs.tags }}
+          labels: ${{ steps.docker-meta.outputs.labels }}

.github/workflows/goreleaser.yml

@@ -0,0 +1,33 @@
+name: Goreleaser
+
+on:
+  push:
+    tags:
+      - "*"
+
+permissions:
+  contents: write
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version-file: go.mod
+          check-latest: true
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v7
+        with:
+          # either 'goreleaser' (default) or 'goreleaser-pro'
+          distribution: goreleaser
+          version: latest
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/lint.yml

@@ -0,0 +1,70 @@
+name: Lint and Testing
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version-file: go.mod
+          check-latest: true
+
+      - name: Setup golangci-lint
+        uses: golangci/golangci-lint-action@v9
+        with:
+          version: v2.11
+          args: --verbose
+
+      - uses: hadolint/hadolint-action@v3.3.0
+        name: hadolint for Dockerfile
+        with:
+          dockerfile: docker/Dockerfile
+
+  test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        go: [1.25, 1.26]
+        include:
+          - os: ubuntu-latest
+            go-build: ~/.cache/go-build
+    name: ${{ matrix.os }} @ Go ${{ matrix.go }}
+    runs-on: ${{ matrix.os }}
+    env:
+      GO111MODULE: on
+      GOPROXY: https://proxy.golang.org
+    steps:
+      - name: Set up Go ${{ matrix.go }}
+        uses: actions/setup-go@v6
+        with:
+          go-version: ${{ matrix.go }}
+          check-latest: true
+
+      - name: Checkout Code
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ github.ref }}
+
+      - uses: actions/cache@v5
+        with:
+          path: |
+            ${{ matrix.go-build }}
+            ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+      - name: Run Tests
+        run: |
+          make test
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          flags: ${{ matrix.os }},go-${{ matrix.go }}

.github/workflows/trivy.yml

@@ -0,0 +1,85 @@
+name: Trivy Security Scan
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+  schedule:
+    # Run daily at 00:00 UTC
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  security-events: write
+
+jobs:
+  trivy-repo-scan:
+    name: Trivy Repository Scan
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Run Trivy vulnerability scanner (repo)
+        uses: aquasecurity/trivy-action@v0.35.0
+        with:
+          scan-type: "fs"
+          scan-ref: "."
+          format: "sarif"
+          output: "trivy-repo-results.sarif"
+          severity: "CRITICAL,HIGH"
+
+      - name: Upload Trivy scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@v4
+        if: always()
+        with:
+          sarif_file: "trivy-repo-results.sarif"
+
+  trivy-image-scan:
+    name: Trivy Image Scan
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version-file: go.mod
+          check-latest: true
+
+      - name: Build binary
+        run: |
+          make build_linux_amd64
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Build Docker image for scanning
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: linux/amd64
+          push: false
+          load: true
+          tags: drone-telegram:scan
+
+      - name: Run Trivy vulnerability scanner (image)
+        uses: aquasecurity/trivy-action@v0.35.0
+        with:
+          image-ref: "drone-telegram:scan"
+          format: "sarif"
+          output: "trivy-image-results.sarif"
+          severity: "CRITICAL,HIGH"
+
+      - name: Upload Trivy image scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@v4
+        if: always()
+        with:
+          sarif_file: "trivy-image-results.sarif"
+          category: "trivy-image"

.gitignore

@@ -26,3 +26,4 @@ drone-telegram
 coverage.txt
 .env
 release
+bin

.golangci.yml

@@ -0,0 +1,114 @@
+version: "2"
+output:
+  sort-order:
+    - file
+linters:
+  default: none
+  enable:
+    - bidichk
+    - bodyclose
+    - depguard
+    - errcheck
+    - forbidigo
+    - gocheckcompilerdirectives
+    - gocritic
+    - govet
+    - ineffassign
+    - mirror
+    - modernize
+    - nakedret
+    - nilnil
+    - nolintlint
+    - perfsprint
+    - revive
+    - staticcheck
+    - testifylint
+    - unconvert
+    - unparam
+    - unused
+    - usestdlibvars
+    - usetesting
+    - wastedassign
+  settings:
+    depguard:
+      rules:
+        main:
+          deny:
+            - pkg: io/ioutil
+              desc: use os or io instead
+            - pkg: golang.org/x/exp
+              desc: it's experimental and unreliable
+            - pkg: github.com/pkg/errors
+              desc: use builtin errors package instead
+    nolintlint:
+      allow-unused: false
+      require-explanation: true
+      require-specific: true
+    gocritic:
+      enabled-checks:
+        - equalFold
+      disabled-checks: []
+    revive:
+      severity: error
+      rules:
+        - name: blank-imports
+        - name: constant-logical-expr
+        - name: context-as-argument
+        - name: context-keys-type
+        - name: dot-imports
+        - name: empty-lines
+        - name: error-return
+        - name: error-strings
+        - name: exported
+        - name: identical-branches
+        - name: if-return
+        - name: increment-decrement
+        - name: modifies-value-receiver
+        - name: package-comments
+        - name: redefines-builtin-id
+        - name: superfluous-else
+        - name: time-naming
+        - name: unexported-return
+        - name: var-declaration
+        - name: var-naming
+          disabled: true
+    staticcheck:
+      checks:
+        - all
+    testifylint: {}
+    usetesting:
+      os-temp-dir: true
+    perfsprint:
+      concat-loop: false
+    govet:
+      enable:
+        - nilness
+        - unusedwrite
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    rules:
+      - linters:
+          - errcheck
+          - staticcheck
+          - unparam
+        path: _test\.go
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
+formatters:
+  enable:
+    - gofmt
+    - gofumpt
+    - golines
+  settings:
+    gofumpt:
+      extra-rules: true
+  exclusions:
+    generated: lax
+run:
+  timeout: 10m

.goreleaser.yaml

@@ -0,0 +1,123 @@
+before:
+  hooks:
+    - go mod tidy
+
+builds:
+  - env:
+      - CGO_ENABLED=0
+    goos:
+      - darwin
+      - linux
+      - windows
+      - freebsd
+    goarch:
+      - amd64
+      - arm
+      - arm64
+    goarm:
+      - "5"
+      - "6"
+      - "7"
+    ignore:
+      - goos: darwin
+        goarch: arm
+      - goos: darwin
+        goarch: ppc64le
+      - goos: darwin
+        goarch: s390x
+      - goos: windows
+        goarch: ppc64le
+      - goos: windows
+        goarch: s390x
+      - goos: windows
+        goarch: arm
+        goarm: "5"
+      - goos: windows
+        goarch: arm
+        goarm: "6"
+      - goos: windows
+        goarch: arm
+        goarm: "7"
+      - goos: windows
+        goarch: arm64
+      - goos: freebsd
+        goarch: ppc64le
+      - goos: freebsd
+        goarch: s390x
+      - goos: freebsd
+        goarch: arm
+        goarm: "5"
+      - goos: freebsd
+        goarch: arm
+        goarm: "6"
+      - goos: freebsd
+        goarch: arm
+        goarm: "7"
+      - goos: freebsd
+        goarch: arm64
+    flags:
+      - -trimpath
+    ldflags:
+      - -s -w
+      - -X main.Version={{.Version}}
+    binary: >-
+      {{ .ProjectName }}-
+      {{- if .IsSnapshot }}{{ .Branch }}-
+      {{- else }}{{- .Version }}-{{ end }}
+      {{- .Os }}-
+      {{- if eq .Arch "amd64" }}amd64
+      {{- else if eq .Arch "amd64_v1" }}amd64
+      {{- else if eq .Arch "386" }}386
+      {{- else }}{{ .Arch }}{{ end }}
+      {{- if .Arm }}-{{ .Arm }}{{ end }}
+    no_unique_dist_dir: true
+    hooks:
+      post:
+        - cmd: xz -k -9 {{ .Path }}
+          dir: ./dist/
+
+archives:
+  - format: binary
+    name_template: "{{ .Binary }}"
+    allow_different_binary_count: true
+
+checksum:
+  name_template: "checksums.txt"
+  extra_files:
+    - glob: ./**.xz
+
+snapshot:
+  name_template: "{{ incpatch .Version }}"
+
+release:
+  # You can add extra pre-existing files to the release.
+  # The filename on the release will be the last part of the path (base).
+  # If another file with the same name exists, the last one found will be used.
+  #
+  # Templates: allowed
+  extra_files:
+    - glob: ./**.xz
+
+changelog:
+  use: github
+  groups:
+    - title: Features
+      regexp: "^.*feat[(\\w)]*:+.*$"
+      order: 0
+    - title: "Bug fixes"
+      regexp: "^.*fix[(\\w)]*:+.*$"
+      order: 1
+    - title: "Enhancements"
+      regexp: "^.*chore[(\\w)]*:+.*$"
+      order: 2
+    - title: "Refactor"
+      regexp: "^.*refactor[(\\w)]*:+.*$"
+      order: 3
+    - title: "Build process updates"
+      regexp: ^.*?(build|ci)(\(.+\))??!?:.+$
+      order: 4
+    - title: "Documentation updates"
+      regexp: ^.*?docs?(\(.+\))??!?:.+$
+      order: 4
+    - title: Others
+      order: 999

.hadolint.yaml

@@ -0,0 +1,3 @@
+ignored:
+  - DL3018
+  - DL3008

DOCS.md

@@ -1,19 +1,25 @@
 ---
-date: 2017-01-08T00:00:00+00:00
-title: Telegram
+date: 2019-10-19T00:00:00+00:00
 author: appleboy
-tags: [ notifications, chat ]
-repo: appleboy/drone-telegram
-logo: telegram.svg
+containerImage: docker.io/appleboy/drone-telegram
+containerImageUrl: https://hub.docker.com/r/appleboy/drone-telegram
+description: Plugin for sending Telegram notifications
+icon: https://raw.githubusercontent.com/appleboy/drone-telegram/refs/heads/master/images/logo.svg
 image: appleboy/drone-telegram
+logo: telegram.svg
+name: Telegram
+repo: appleboy/drone-telegram
+tags: [ notifications, chat ]
+title: Telegram
+url: https://github.com/appleboy/drone-telegram
 ---
 
 The Telegram plugin posts build status messages to your account. The below pipeline configuration demonstrates simple usage:
 
 ```yaml
-pipeline:
-  telegram:
-    image: appleboy/drone-telegram
+- name: send telegram notification
+  image: appleboy/drone-telegram
+  settings:
     token: xxxxxxxxxx
     to: telegram_user_id
 ```
@@ -21,147 +27,235 @@ pipeline:
 Example configuration with photo message:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   photo:
-+     - tests/1.png
-+     - tests/2.png
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     photo:
++       - tests/1.png
++       - tests/2.png
 ```
 
 Example configuration with document message:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   document:
-+     - tests/1.pdf
-+     - tests/2.pdf
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     document:
++       - tests/1.pdf
++       - tests/2.pdf
 ```
 
 Example configuration with sticker message:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   sticker:
-+     - tests/3.png
-+     - tests/4.png
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     sticker:
++       - tests/3.png
++       - tests/4.png
 ```
 
 Example configuration with audio message:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   audio:
-+     - tests/audio1.mp3
-+     - tests/audio2.mp3
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     audio:
++       - tests/audio1.mp3
++       - tests/audio2.mp3
 ```
 
 Example configuration with voice message:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   voice:
-+     - tests/voice1.ogg
-+     - tests/voice2.ogg
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     voice:
++       - tests/voice1.ogg
++       - tests/voice2.ogg
 ```
 
 Example configuration with location message:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   location:
-+     - 24.9163213,121.1424972
-+     - 24.9263213,121.1224972
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     location:
++       - 24.9163213,121.1424972
++       - 24.9263213,121.1224972
 ```
 
 Example configuration with venue message:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   venue:
-+     - 24.9163213,121.1424972,title,address
-+     - 24.3163213,121.1824972,title,address
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     venue:
++       - 24.9163213,121.1424972,title,address
++       - 24.3163213,121.1824972,title,address
 ```
 
 Example configuration with video message:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   video:
-+     - tests/video1.mp4
-+     - tests/video2.mp4
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     video:
++       - tests/video1.mp4
++       - tests/video2.mp4
 ```
 
-Example configuration with message format:
+Example configuration with message format (`Markdown` or `HTML`), default as `Markdown`:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   format: markdown
-```
-
-Example configuration for success and failure messages:
-
-```diff
-pipeline:
-  telegram:
-    image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   when:
-+     status: [ success, failure ]
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     format: Markdown
 ```
 
 Example configuration with a custom message template:
 
 ```diff
-pipeline:
-  telegram:
+  - name: send telegram notification
     image: appleboy/drone-telegram
-    token: xxxxxxxxxx
-    to: telegram_user_id
-+   message: >
-+     {{#success build.status}}
-+       build {{build.number}} succeeded. Good job.
-+     {{else}}
-+       build {{build.number}} failed. Fix me please.
-+     {{/success}}
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     message: >
++       {{#success build.status}}
++         build {{build.number}} succeeded. Good job.
++       {{else}}
++         build {{build.number}} failed. Fix me please.
++       {{/success}}
 ```
 
-# Parameter Reference
+Example configuration with a custom message template loaded from file:
+
+```diff
+  - name: send telegram notification
+    image: appleboy/drone-telegram
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     message_file: message_file.tpl
+```
+
+Example configuration with a generic message template loaded from file, with additional extra vars:
+
+```diff
+  - name: send telegram notification
+    image: appleboy/drone-telegram
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     message_file: message_file.tpl
++     template_vars:
++       env: testing
++       app: MyApp
+```
+
+Where `message_file.tpl` is:
+
+```bash
+Build finished for *{{tpl.app}}* - *{{tpl.env}}*
+
+{{#success build.status}}
+  build {{build.number}} succeeded. Good job.
+{{else}}
+  build {{build.number}} failed. Fix me please.
+{{/success}}
+```
+
+Example configuration with a custom message template, with extra vars loaded from file (e.g. from previous build steps):
+
+```diff
+  - name: send telegram notification
+    image: appleboy/drone-telegram
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
++     template_vars_file: build_report.json
++     message: >
++       {{#success build.status}}
++         build {{build.number}} succeeded, artefact version = {{tpl.artefact_version}}.
++       {{else}}
++         build {{build.number}} failed. Fix me please.
++       {{/success}}
+```
+
+Where `build_report.json` is:
+
+```
+{
+  ...
+  "artefact_version": "0.2.3452"
+  ...
+}
+```
+
+Example configuration with a custom socks5 URL:
+
+```diff
+  - name: send telegram notification
+    image: appleboy/drone-telegram
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
+      message: send message using custom socks5 URL
++     socks5: socks5://67.204.21.1:64312
+```
+
+Disables link previews for links in this message
+
+```diff
+  - name: send telegram notification
+    image: appleboy/drone-telegram
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
+      message: send message without a link preview
++     disable_web_page_preview: true
+```
+
+Disables notifications for this message
+
+```diff
+  - name: send telegram notification
+    image: appleboy/drone-telegram
+    settings:
+      token: xxxxxxxxxx
+      to: telegram_user_id
+      message: send message message silently
++     disable_notification: true
+```
+
+## Parameter Reference
 
 token
 : telegram token from [telegram developer center](https://core.telegram.org/bots/api)
@@ -172,6 +266,15 @@ to
 message
 : overwrite the default message template
 
+message_file
+: overwrite the default message template with the contents of the specified file
+
+template_vars
+: define additional template vars. Example: `var1: hello` can be used within the template as `tpl.var1`
+
+template_vars_file
+: load additional template vars from json file. Example: given file content `{"var1":"hello"}`, variable can be used within the template as `tpl.var1`
+
 photo
 : local file path
 
@@ -199,7 +302,7 @@ venue
 format
 : `markdown` or `html` format
 
-# Template Reference
+## Template Reference
 
 repo.owner
 : repository owner
@@ -246,7 +349,7 @@ build.started
 build.finished
 : unix timestamp for build finished
 
-# Template Function Reference
+## Template Function Reference
 
 uppercasefirst
 : converts the first letter of a string to uppercase

Dockerfile

@@ -1,10 +0,0 @@
-FROM plugins/base:multiarch
-
-LABEL maintainer="Bo-Yi Wu <appleboy.tw@gmail.com>" \
-  org.label-schema.name="Drone Telegram" \
-  org.label-schema.vendor="Bo-Yi Wu" \
-  org.label-schema.schema-version="1.0"
-
-ADD release/linux/amd64/drone-telegram /bin/
-
-ENTRYPOINT ["/bin/drone-telegram"]

Dockerfile.alpine

@@ -1,13 +0,0 @@
-FROM alpine:3.6
-
-LABEL maintainer="Bo-Yi Wu <appleboy.tw@gmail.com>" \
-  org.label-schema.name="Drone Telegram" \
-  org.label-schema.vendor="Bo-Yi Wu" \
-  org.label-schema.schema-version="1.0"
-
-RUN apk add -U --no-cache ca-certificates && \
-  rm -rf /var/cache/apk/*
-
-ADD release/linux/amd64/drone-telegram /bin/
-
-ENTRYPOINT ["/bin/drone-telegram"]

Dockerfile.arm

@@ -1,10 +0,0 @@
-FROM plugins/base:multiarch
-
-LABEL maintainer="Bo-Yi Wu <appleboy.tw@gmail.com>" \
-  org.label-schema.name="Drone Telegram" \
-  org.label-schema.vendor="Bo-Yi Wu" \
-  org.label-schema.schema-version="1.0"
-
-ADD release/linux/amd64/drone-telegram /bin/
-
-ENTRYPOINT ["/bin/drone-telegram"]

Dockerfile.arm64

@@ -1,10 +0,0 @@
-FROM plugins/base:multiarch
-
-LABEL maintainer="Bo-Yi Wu <appleboy.tw@gmail.com>" \
-  org.label-schema.name="Drone Telegram" \
-  org.label-schema.vendor="Bo-Yi Wu" \
-  org.label-schema.schema-version="1.0"
-
-ADD release/linux/arm64/drone-telegram /bin/
-
-ENTRYPOINT ["/bin/drone-telegram"]

Dockerfile.i386

@@ -1,10 +0,0 @@
-FROM plugins/base:multiarch
-
-LABEL maintainer="Bo-Yi Wu <appleboy.tw@gmail.com>" \
-  org.label-schema.name="Drone Telegram" \
-  org.label-schema.vendor="Bo-Yi Wu" \
-  org.label-schema.schema-version="1.0"
-
-ADD release/linux/i386/drone-telegram /bin/
-
-ENTRYPOINT ["/bin/drone-telegram"]

Dockerfile.windows

@@ -1,9 +0,0 @@
-FROM microsoft/nanoserver:10.0.14393.1884
-
-LABEL maintainer="Bo-Yi Wu <appleboy.tw@gmail.com>" \
-  org.label-schema.name="Drone Telegram" \
-  org.label-schema.vendor="Bo-Yi Wu" \
-  org.label-schema.schema-version="1.0"
-
-ADD drone-telegram.exe /drone-telegram.exe
-ENTRYPOINT [ "\\drone-telegram.exe" ]

Makefile

@@ -1,18 +1,18 @@
-DIST := dist
 EXECUTABLE := drone-telegram
-GOFMT ?= gofmt "-s"
+GOFMT ?= gofumpt -l
+DIST := dist
+DIST_DIRS := $(DIST)/binaries $(DIST)/release
+GO ?= go
+SHASUM ?= shasum -a 256
+GOFILES := $(shell find . -name "*.go" -type f)
+HAS_GO = $(shell hash $(GO) > /dev/null 2>&1 && echo "GO" || echo "NOGO" )
+XGO_PACKAGE ?= src.techknowlogick.com/xgo@latest
+XGO_VERSION := go-1.19.x
+GXZ_PACKAGE ?= github.com/ulikunitz/xz/cmd/gxz@v0.5.11
 
-# for dockerhub
-DEPLOY_ACCOUNT := appleboy
-DEPLOY_IMAGE := $(EXECUTABLE)
-
-TARGETS ?= linux darwin windows
-PACKAGES ?= $(shell go list ./... | grep -v /vendor/)
-GOFILES := $(shell find . -name "*.go" -type f -not -path "./vendor/*")
-SOURCES ?= $(shell find . -name "*.go" -type f)
-TAGS ?=
-LDFLAGS ?= -X 'main.Version=$(VERSION)'
-TMPDIR := $(shell mktemp -d 2>/dev/null || mktemp -d -t 'tempdir')
+LINUX_ARCHS ?= linux/amd64,linux/arm64
+DARWIN_ARCHS ?= darwin-10.12/amd64,darwin-10.12/arm64
+WINDOWS_ARCHS ?= windows/*
 
 ifneq ($(shell uname), Darwin)
 	EXTLDFLAGS = -extldflags "-static" $(null)
@@ -20,55 +20,50 @@ else
 	EXTLDFLAGS =
 endif
 
+ifeq ($(HAS_GO), GO)
+	GOPATH ?= $(shell $(GO) env GOPATH)
+	export PATH := $(GOPATH)/bin:$(PATH)
+
+	CGO_EXTRA_CFLAGS := -DSQLITE_MAX_VARIABLE_NUMBER=32766
+	CGO_CFLAGS ?= $(shell $(GO) env CGO_CFLAGS) $(CGO_EXTRA_CFLAGS)
+endif
+
+ifeq ($(OS), Windows_NT)
+	GOFLAGS := -v -buildmode=exe
+	EXECUTABLE ?= $(EXECUTABLE).exe
+else ifeq ($(OS), Windows)
+	GOFLAGS := -v -buildmode=exe
+	EXECUTABLE ?= $(EXECUTABLE).exe
+else
+	GOFLAGS := -v
+	EXECUTABLE ?= $(EXECUTABLE)
+endif
+
 ifneq ($(DRONE_TAG),)
 	VERSION ?= $(DRONE_TAG)
 else
 	VERSION ?= $(shell git describe --tags --always || git rev-parse --short HEAD)
 endif
 
+TAGS ?=
+LDFLAGS ?= -X 'main.Version=$(VERSION)'
+
 all: build
 
 fmt:
+	@hash gofumpt > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) install mvdan.cc/gofumpt; \
+	fi
 	$(GOFMT) -w $(GOFILES)
 
 vet:
-	go vet $(PACKAGES)
-
-errcheck:
-	@which errcheck > /dev/null; if [ $$? -ne 0 ]; then \
-		go get -u github.com/kisielk/errcheck; \
-	fi
-	errcheck $(PACKAGES)
-
-lint:
-	@which golint > /dev/null; if [ $$? -ne 0 ]; then \
-		go get -u github.com/golang/lint/golint; \
-	fi
-	for PKG in $(PACKAGES); do golint -set_exit_status $$PKG || exit 1; done;
-
-unconvert:
-	@which unconvert > /dev/null; if [ $$? -ne 0 ]; then \
-		go get -u github.com/mdempsky/unconvert; \
-	fi
-	for PKG in $(PACKAGES); do unconvert -v $$PKG || exit 1; done;
-
-.PHONY: misspell-check
-misspell-check:
-	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go get -u github.com/client9/misspell/cmd/misspell; \
-	fi
-	misspell -error $(GOFILES)
-
-.PHONY: misspell
-misspell:
-	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go get -u github.com/client9/misspell/cmd/misspell; \
-	fi
-	misspell -w $(GOFILES)
+	$(GO) vet ./...
 
 .PHONY: fmt-check
 fmt-check:
-	# get all go files and run go fmt on them
+	@hash gofumpt > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) install mvdan.cc/gofumpt; \
+	fi
 	@diff=$$($(GOFMT) -d $(GOFILES)); \
 	if [ -n "$$diff" ]; then \
 		echo "Please run 'make fmt' and commit the result:"; \
@@ -76,82 +71,95 @@ fmt-check:
 		exit 1; \
 	fi;
 
-.PHONY: test-vendor
-test-vendor:
-	@hash govendor > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go get -u github.com/kardianos/govendor; \
-	fi
-	govendor list +unused | tee "$(TMPDIR)/wc-gitea-unused"
-	[ $$(cat "$(TMPDIR)/wc-gitea-unused" | wc -l) -eq 0 ] || echo "Warning: /!\\ Some vendor are not used /!\\"
+test:
+	@$(GO) test -v -cover -coverprofile coverage.txt ./... && echo "\n==>\033[32m Ok\033[m\n" || exit 1
 
-	govendor list +outside | tee "$(TMPDIR)/wc-gitea-outside"
-	[ $$(cat "$(TMPDIR)/wc-gitea-outside" | wc -l) -eq 0 ] || exit 1
-
-	govendor status || exit 1
-
-test: fmt-check
-	for PKG in $(PACKAGES); do go test -cover -coverprofile $$GOPATH/src/$$PKG/coverage.txt $$PKG || exit 1; done;
-
-html:
-	go tool cover -html=coverage.txt
-
-install: $(SOURCES)
-	go install -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)'
+install: $(GOFILES)
+	$(GO) install -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)'
 
 build: $(EXECUTABLE)
 
-$(EXECUTABLE): $(SOURCES)
-	go build -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o $@
-
-release: release-dirs release-build release-copy release-check
-
-release-dirs:
-	mkdir -p $(DIST)/binaries $(DIST)/release
-
-release-build:
-	@which gox > /dev/null; if [ $$? -ne 0 ]; then \
-		go get -u github.com/mitchellh/gox; \
-	fi
-	gox -os="$(TARGETS)" -arch="amd64 386" -tags="$(TAGS)" -ldflags="-s -w $(LDFLAGS)" -output="$(DIST)/binaries/$(EXECUTABLE)-$(VERSION)-{{.OS}}-{{.Arch}}"
-
-release-copy:
-	$(foreach file,$(wildcard $(DIST)/binaries/$(EXECUTABLE)-*),cp $(file) $(DIST)/release/$(notdir $(file));)
-
-release-check:
-	cd $(DIST)/release; $(foreach file,$(wildcard $(DIST)/release/$(EXECUTABLE)-*),sha256sum $(notdir $(file)) > $(notdir $(file)).sha256;)
+$(EXECUTABLE): $(GOFILES)
+	$(GO) build -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o bin/$@
 
 build_linux_amd64:
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o release/linux/amd64/$(DEPLOY_IMAGE)
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GO) build -a -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o release/linux/amd64/$(DEPLOY_IMAGE)
 
 build_linux_i386:
-	CGO_ENABLED=0 GOOS=linux GOARCH=386 go build -a -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o release/linux/i386/$(DEPLOY_IMAGE)
+	CGO_ENABLED=0 GOOS=linux GOARCH=386 $(GO) build -a -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o release/linux/i386/$(DEPLOY_IMAGE)
 
 build_linux_arm64:
-	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -a -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o release/linux/arm64/$(DEPLOY_IMAGE)
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 $(GO) build -a -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o release/linux/arm64/$(DEPLOY_IMAGE)
 
 build_linux_arm:
-	CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -a -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o release/linux/arm/$(DEPLOY_IMAGE)
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 $(GO) build -a -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o release/linux/arm/$(DEPLOY_IMAGE)
 
-docker_image:
-	docker build -t $(DEPLOY_ACCOUNT)/$(DEPLOY_IMAGE) .
-
-docker: static_build docker_image
-
-docker_deploy:
-ifeq ($(tag),)
-	@echo "Usage: make $@ tag=<tag>"
-	@exit 1
-endif
-	# deploy image
-	docker tag $(DEPLOY_ACCOUNT)/$(DEPLOY_IMAGE):latest $(DEPLOY_ACCOUNT)/$(DEPLOY_IMAGE):$(tag)
-	docker push $(DEPLOY_ACCOUNT)/$(DEPLOY_IMAGE):$(tag)
+ssh-server:
+	adduser -h /home/drone-scp -s /bin/sh -D -S drone-scp
+	echo drone-scp:1234 | chpasswd
+	mkdir -p /home/drone-scp/.ssh
+	chmod 700 /home/drone-scp/.ssh
+	cat tests/.ssh/id_rsa.pub >> /home/drone-scp/.ssh/authorized_keys
+	cat tests/.ssh/test.pub >> /home/drone-scp/.ssh/authorized_keys
+	chmod 600 /home/drone-scp/.ssh/authorized_keys
+	chown -R drone-scp /home/drone-scp/.ssh
+	apk add --update openssh openrc
+	rm -rf /etc/ssh/ssh_host_rsa_key /etc/ssh/ssh_host_dsa_key
+	sed -i 's/^#PubkeyAuthentication yes/PubkeyAuthentication yes/g' /etc/ssh/sshd_config
+	sed -i 's/AllowTcpForwarding no/AllowTcpForwarding yes/g' /etc/ssh/sshd_config
+	./tests/entrypoint.sh /usr/sbin/sshd -D &
 
 coverage:
 	sed -i '/main.go/d' coverage.txt
 
+.PHONY: deps-backend
+deps-backend:
+	$(GO) mod download
+	$(GO) install $(GXZ_PACKAGE)
+	$(GO) install $(XGO_PACKAGE)
+
+.PHONY: release
+release: release-linux release-darwin release-windows release-copy release-compress release-check
+
+$(DIST_DIRS):
+	mkdir -p $(DIST_DIRS)
+
+.PHONY: release-windows
+release-windows: | $(DIST_DIRS)
+	CGO_CFLAGS="$(CGO_CFLAGS)" $(GO) run $(XGO_PACKAGE) -go $(XGO_VERSION) -buildmode exe -dest $(DIST)/binaries -tags 'netgo osusergo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets '$(WINDOWS_ARCHS)' -out $(EXECUTABLE)-$(VERSION) .
+ifeq ($(CI),true)
+	cp -r /build/* $(DIST)/binaries/
+endif
+
+.PHONY: release-linux
+release-linux: | $(DIST_DIRS)
+	CGO_CFLAGS="$(CGO_CFLAGS)" $(GO) run $(XGO_PACKAGE) -go $(XGO_VERSION) -dest $(DIST)/binaries -tags 'netgo osusergo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets '$(LINUX_ARCHS)' -out $(EXECUTABLE)-$(VERSION) .
+ifeq ($(CI),true)
+	cp -r /build/* $(DIST)/binaries/
+endif
+
+.PHONY: release-darwin
+release-darwin: | $(DIST_DIRS)
+	CGO_CFLAGS="$(CGO_CFLAGS)" $(GO) run $(XGO_PACKAGE) -go $(XGO_VERSION) -dest $(DIST)/binaries -tags 'netgo osusergo $(TAGS)' -ldflags '$(LDFLAGS)' -targets '$(DARWIN_ARCHS)' -out $(EXECUTABLE)-$(VERSION) .
+ifeq ($(CI),true)
+	cp -r /build/* $(DIST)/binaries/
+endif
+
+.PHONY: release-copy
+release-copy: | $(DIST_DIRS)
+	cd $(DIST); for file in `find . -type f -name "*"`; do cp $${file} ./release/; done;
+
+.PHONY: release-check
+release-check: | $(DIST_DIRS)
+	cd $(DIST)/release/; for file in `find . -type f -name "*"`; do echo "checksumming $${file}" && $(SHASUM) `echo $${file} | sed 's/^..//'` > $${file}.sha256; done;
+
+.PHONY: release-compress
+release-compress: | $(DIST_DIRS)
+	cd $(DIST)/release/; for file in `find . -type f -name "*"`; do echo "compressing $${file}" && $(GO) run $(GXZ_PACKAGE) -k -9 $${file}; done;
+
 clean:
-	go clean -x -i ./...
-	rm -rf coverage.txt $(EXECUTABLE) $(DIST) vendor
+	$(GO) clean -x -i ./...
+	rm -rf coverage.txt $(EXECUTABLE) $(DIST)
 
 version:
 	@echo $(VERSION)

README.md

@@ -1,14 +1,11 @@
-<img src="images/logo.png" />
-
 # drone-telegram
 
+![logo](./images/logo.png)
+
 [![GoDoc](https://godoc.org/github.com/appleboy/drone-telegram?status.svg)](https://godoc.org/github.com/appleboy/drone-telegram)
-[![Build Status](http://drone.wu-boy.com/api/badges/appleboy/drone-telegram/status.svg)](http://drone.wu-boy.com/appleboy/drone-telegram)
+[![Trivy Security Scan](https://github.com/appleboy/drone-telegram/actions/workflows/trivy.yml/badge.svg?branch=master)](https://github.com/appleboy/drone-telegram/actions/workflows/trivy.yml)
 [![codecov](https://codecov.io/gh/appleboy/drone-telegram/branch/master/graph/badge.svg)](https://codecov.io/gh/appleboy/drone-telegram)
 [![Go Report Card](https://goreportcard.com/badge/github.com/appleboy/drone-telegram)](https://goreportcard.com/report/github.com/appleboy/drone-telegram)
-[![Docker Pulls](https://img.shields.io/docker/pulls/appleboy/drone-telegram.svg)](https://hub.docker.com/r/appleboy/drone-telegram/)
-[![](https://images.microbadger.com/badges/image/appleboy/drone-telegram.svg)](https://microbadger.com/images/appleboy/drone-telegram "Get your own image badge on microbadger.com")
-[![Release](https://github-release-version.herokuapp.com/github/appleboy/drone-telegram/release.svg?style=flat)](https://github.com/appleboy/drone-telegram/releases/latest)
 
 [Drone](https://github.com/drone/drone) plugin for sending telegram notifications. For the usage
 information and a listing of the available options please take a look at [the docs](http://plugins.drone.io/appleboy/drone-telegram/).
@@ -25,54 +22,58 @@ information and a listing of the available options please take a look at [the do
 * [x] Send with New Video.
 * [x] Send with New Sticker.
 
-## Build
+## Build or Download a binary
 
-Build the binary with the following commands:
+The pre-compiled binaries can be downloaded from [release page](https://github.com/appleboy/drone-telegram/releases). Support the following OS type.
 
+* Windows amd64/386
+* Linux arm/amd64/386
+* Darwin amd64/386
+
+With `Go` installed
+
+```sh
+go get -u -v github.com/appleboy/drone-telegram
 ```
-$ make build
+
+or build the binary with the following command:
+
+```sh
+export GOOS=linux
+export GOARCH=amd64
+export CGO_ENABLED=0
+export GO111MODULE=on
+
+go test -cover ./...
+
+go build -v -a -tags netgo -o release/linux/amd64/drone-telegram .
 ```
 
 ## Testing
 
 Test the package with the following command:
 
-```
-$ make test
-```
-
-## Docker
-
-Build the docker image with the following commands:
-
-```
-$ make docker
-```
-
-Please note incorrectly building the image for the correct x64 linux and with
-GCO disabled will result in an error when running the Docker image:
-
-```
-docker: Error response from daemon: Container command
-'/bin/drone-telegram' not found or does not exist..
+```sh
+make test
 ```
 
 ## Usage
 
 Execute from the working directory:
 
-```
+```sh
 docker run --rm \
   -e PLUGIN_TOKEN=xxxxxxx \
   -e PLUGIN_TO=xxxxxxx \
   -e PLUGIN_MESSAGE=test \
+  -e PLUGIN_MESSAGE_FILE=testmessage.md \  
   -e PLUGIN_PHOTO=tests/github.png \
   -e PLUGIN_DOCUMENT=tests/gophercolor.png \
   -e PLUGIN_STICKER=tests/github-logo.png \
   -e PLUGIN_AUDIO=tests/audio.mp3 \
   -e PLUGIN_VOICE=tests/voice.ogg \
-  -e PLUGIN_LOCATION=24.9163213,121.1424972 \
-  -e PLUGIN_VENUE=24.9163213,121.1424972,title,address \
+  -e PLUGIN_LOCATION="24.9163213 121.1424972" \
+  -e PLUGIN_VENUE="24.9163213 121.1424972 title address" \
   -e PLUGIN_VIDEO=tests/video.mp4 \
   -e PLUGIN_DEBUG=true \
   -e PLUGIN_ONLY_MATCH_EMAIL=false \
@@ -99,7 +100,7 @@ Load all environments from file.
 
 ```bash
 docker run --rm \
-  -e ENV_FILE=your_env_file_path \
+  -e PLUGIN_ENV_FILE=your_env_file_path \
   -v $(pwd):$(pwd) \
   -w $(pwd) \
   appleboy/drone-telegram

docker/Dockerfile

@@ -0,0 +1,20 @@
+FROM alpine:3.17
+
+ARG TARGETOS
+ARG TARGETARCH
+
+LABEL maintainer="Bo-Yi Wu <appleboy.tw@gmail.com>" \
+  org.label-schema.name="Telegram Plugin" \
+  org.label-schema.vendor="Bo-Yi Wu" \
+  org.label-schema.schema-version="1.0"
+
+LABEL org.opencontainers.image.source=https://github.com/appleboy/drone-telegram
+LABEL org.opencontainers.image.description="plugin for sending telegram notifications"
+LABEL org.opencontainers.image.licenses=MIT
+
+RUN apk add --no-cache ca-certificates && \
+  rm -rf /var/cache/apk/*
+
+COPY release/${TARGETOS}/${TARGETARCH}/drone-telegram /bin/
+
+ENTRYPOINT ["/bin/drone-telegram"]

go.mod

@@ -0,0 +1,34 @@
+module github.com/appleboy/drone-telegram
+
+go 1.25.9
+
+require (
+	github.com/appleboy/drone-template-lib v1.3.0
+	github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible
+	github.com/joho/godotenv v1.5.1
+	github.com/stretchr/testify v1.9.0
+	github.com/urfave/cli v1.22.15
+)
+
+require (
+	dario.cat/mergo v1.0.1 // indirect
+	github.com/Masterminds/goutils v1.1.1 // indirect
+	github.com/Masterminds/semver/v3 v3.3.0 // indirect
+	github.com/Masterminds/sprig/v3 v3.3.0 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/huandu/xstrings v1.5.0 // indirect
+	github.com/mailgun/raymond/v2 v2.0.48 // indirect
+	github.com/mitchellh/copystructure v1.2.0 // indirect
+	github.com/mitchellh/reflectwalk v1.0.2 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/shopspring/decimal v1.4.0 // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
+	github.com/spf13/cast v1.7.0 // indirect
+	github.com/technoweenie/multipartstreamer v1.0.1 // indirect
+	golang.org/x/crypto v0.45.0 // indirect
+	golang.org/x/sys v0.38.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,79 @@
+dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s=
+dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
+github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI=
+github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU=
+github.com/Masterminds/semver/v3 v3.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0=
+github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/Masterminds/sprig/v3 v3.3.0 h1:mQh0Yrg1XPo6vjYXgtf5OtijNAKJRNcTdOOGZe3tPhs=
+github.com/Masterminds/sprig/v3 v3.3.0/go.mod h1:Zy1iXRYNqNLUolqCpL4uhk6SHUMAOSCzdgBfDb35Lz0=
+github.com/appleboy/drone-template-lib v1.3.0 h1:aX36/1za3v8JsEyBeMY1Bp/VNRtZa8qPYkfkjBszW+A=
+github.com/appleboy/drone-template-lib v1.3.0/go.mod h1:edlmXkFMKYAVypff8r2oN7aFlHfOZE5sLyPEnRHONeA=
+github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible h1:2cauKuaELYAEARXRkq2LrJ0yDDv1rW7+wrTEdVL3uaU=
+github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible/go.mod h1:qf9acutJ8cwBUhm1bqgz6Bei9/C/c93FPDljKWwsOgM=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI=
+github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mailgun/raymond/v2 v2.0.48 h1:5dmlB680ZkFG2RN/0lvTAghrSxIESeu9/2aeDqACtjw=
+github.com/mailgun/raymond/v2 v2.0.48/go.mod h1:lsgvL50kgt1ylcFJYZiULi5fjPBkkhNfj4KA0W54Z18=
+github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
+github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=
+github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
+github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
+github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
+github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/spf13/cast v1.7.0 h1:ntdiHjuueXFgm5nzDRdOS4yfT43P5Fnud6DH50rz/7w=
+github.com/spf13/cast v1.7.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/technoweenie/multipartstreamer v1.0.1 h1:XRztA5MXiR1TIRHxH2uNxXxaIkKQDeX7m2XsSOlQEnM=
+github.com/technoweenie/multipartstreamer v1.0.1/go.mod h1:jNVxdtShOxzAsukZwTSw6MDx5eUJoiEBsSvzDU9uzog=
+github.com/urfave/cli v1.22.15 h1:nuqt+pdC/KqswQKhETJjo7pvn/k4xMUxgW6liI7XpnM=
+github.com/urfave/cli v1.22.15/go.mod h1:wSan1hmo5zeyLGBjRJbzRTNk8gwoYa2B9n4q9dmRIc0=
+golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
+golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -5,14 +5,24 @@ import (
 	"os"
 
 	"github.com/joho/godotenv"
-	_ "github.com/joho/godotenv/autoload"
 	"github.com/urfave/cli"
 )
 
 // Version set at compile-time
-var Version string
+var (
+	Version string
+)
 
 func main() {
+	// Load env-file if it exists first
+	if filename, found := os.LookupEnv("PLUGIN_ENV_FILE"); found {
+		_ = godotenv.Load(filename)
+	}
+
+	if _, err := os.Stat("/run/drone/env"); err == nil {
+		_ = godotenv.Overload("/run/drone/env")
+	}
+
 	app := cli.NewApp()
 	app.Name = "telegram plugin"
 	app.Usage = "telegram plugin"
@@ -22,83 +32,108 @@ func main() {
 		cli.StringFlag{
 			Name:   "token",
 			Usage:  "telegram token",
-			EnvVar: "PLUGIN_TOKEN,TELEGRAM_TOKEN",
+			EnvVar: "PLUGIN_TOKEN,TELEGRAM_TOKEN,INPUT_TOKEN",
 		},
 		cli.StringSliceFlag{
 			Name:   "to",
 			Usage:  "telegram user",
-			EnvVar: "PLUGIN_TO,TELEGRAM_TO",
+			EnvVar: "PLUGIN_TO,TELEGRAM_TO,INPUT_TO",
 		},
-		cli.StringSliceFlag{
+		cli.StringFlag{
 			Name:   "message",
 			Usage:  "send telegram message",
-			EnvVar: "PLUGIN_MESSAGE,TELEGRAM_MESSAGE",
+			EnvVar: "PLUGIN_MESSAGE,TELEGRAM_MESSAGE,INPUT_MESSAGE",
+		},
+		cli.StringFlag{
+			Name:   "message.file",
+			Usage:  "send telegram message from file",
+			EnvVar: "PLUGIN_MESSAGE_FILE,TELEGRAM_MESSAGE_FILE,INPUT_MESSAGE_FILE",
+		},
+		cli.StringFlag{
+			Name:   "template.vars",
+			Usage:  "additional template vars to be used in message, as JSON string",
+			EnvVar: "PLUGIN_TEMPLATE_VARS,TELEGRAM_TEMPLATE_VARS,INPUT_TEMPLATE_VARS",
+		},
+		cli.StringFlag{
+			Name:   "template.vars.file",
+			Usage:  "load additional template vars to be used in message, from json file",
+			EnvVar: "PLUGIN_TEMPLATE_VARS_FILE,TELEGRAM_TEMPLATE_VARS_FILE",
 		},
 		cli.StringSliceFlag{
 			Name:   "photo",
 			Usage:  "send photo message",
-			EnvVar: "PLUGIN_PHOTO",
+			EnvVar: "PLUGIN_PHOTO,PHOTO,INPUT_PHOTO",
 		},
 		cli.StringSliceFlag{
 			Name:   "document",
 			Usage:  "send document message",
-			EnvVar: "PLUGIN_DOCUMENT",
+			EnvVar: "PLUGIN_DOCUMENT,DOCUMENT,INPUT_DOCUMENT",
 		},
 		cli.StringSliceFlag{
 			Name:   "sticker",
 			Usage:  "send sticker message",
-			EnvVar: "PLUGIN_STICKER",
+			EnvVar: "PLUGIN_STICKER,STICKER,INPUT_STICKER",
 		},
 		cli.StringSliceFlag{
 			Name:   "audio",
 			Usage:  "send audio message",
-			EnvVar: "PLUGIN_AUDIO",
+			EnvVar: "PLUGIN_AUDIO,AUDIO,INPUT_AUDIO",
 		},
 		cli.StringSliceFlag{
 			Name:   "voice",
 			Usage:  "send voice message",
-			EnvVar: "PLUGIN_VOICE",
+			EnvVar: "PLUGIN_VOICE,VOICE,INPUT_VOICE",
 		},
 		cli.StringSliceFlag{
 			Name:   "location",
 			Usage:  "send location message",
-			EnvVar: "PLUGIN_LOCATION",
+			EnvVar: "PLUGIN_LOCATION,LOCATION,INPUT_LOCATION",
 		},
 		cli.StringSliceFlag{
 			Name:   "venue",
 			Usage:  "send venue message",
-			EnvVar: "PLUGIN_VENUE",
+			EnvVar: "PLUGIN_VENUE,VENUE,INPUT_VENUE",
 		},
 		cli.StringSliceFlag{
 			Name:   "video",
 			Usage:  "send video message",
-			EnvVar: "PLUGIN_VIDEO",
+			EnvVar: "PLUGIN_VIDEO,VIDEO,INPUT_VIDEO",
 		},
 		cli.BoolFlag{
 			Name:   "debug",
 			Usage:  "enable debug message",
-			EnvVar: "PLUGIN_DEBUG",
+			EnvVar: "PLUGIN_DEBUG,DEBUG,INPUT_DEBUG",
 		},
 		cli.BoolFlag{
 			Name:   "match.email",
 			Usage:  "send message when only match email",
-			EnvVar: "PLUGIN_ONLY_MATCH_EMAIL",
+			EnvVar: "PLUGIN_ONLY_MATCH_EMAIL,INPUT_ONLY_MATCH_EMAIL",
 		},
-		cli.BoolTFlag{
-			Name:   "webpage.preview",
-			Usage:  "toggle web-page preview",
-			EnvVar: "PLUGIN_WEBPAGE_PREVIEW",
+		cli.BoolFlag{
+			Name:   "disable.webpage.preview",
+			Usage:  "disables link previews for links in this message",
+			EnvVar: "PLUGIN_DISABLE_WEB_PAGE_PREVIEW,INPUT_DISABLE_WEB_PAGE_PREVIEW",
+		},
+		cli.BoolFlag{
+			Name:   "disable.notification",
+			Usage:  "sends the message silently. users will receive a notification with no sound.",
+			EnvVar: "PLUGIN_DISABLE_NOTIFICATION,INPUT_DISABLE_NOTIFICATION",
 		},
 		cli.StringFlag{
 			Name:   "format",
-			Value:  "markdown",
-			Usage:  "telegram message format",
-			EnvVar: "PLUGIN_FORMAT",
+			Value:  formatMarkdown,
+			Usage:  "telegram message format (Markdown or HTML)",
+			EnvVar: "PLUGIN_FORMAT,FORMAT,INPUT_FORMAT",
 		},
 		cli.StringFlag{
-			Name:   "repo.owner",
-			Usage:  "repository owner",
-			EnvVar: "DRONE_REPO_OWNER",
+			Name:   "repo",
+			Usage:  "repository owner and repository name",
+			EnvVar: "DRONE_REPO,GITHUB_REPOSITORY",
+		},
+		cli.StringFlag{
+			Name:   "repo.namespace",
+			Usage:  "repository namespace",
+			EnvVar: "DRONE_REPO_OWNER,DRONE_REPO_NAMESPACE,GITHUB_ACTOR",
 		},
 		cli.StringFlag{
 			Name:   "repo.name",
@@ -108,7 +143,12 @@ func main() {
 		cli.StringFlag{
 			Name:   "commit.sha",
 			Usage:  "git commit sha",
-			EnvVar: "DRONE_COMMIT_SHA",
+			EnvVar: "DRONE_COMMIT_SHA,GITHUB_SHA",
+		},
+		cli.StringFlag{
+			Name:   "commit.ref",
+			Usage:  "git commit ref",
+			EnvVar: "DRONE_COMMIT_REF,GITHUB_REF",
 		},
 		cli.StringFlag{
 			Name:   "commit.branch",
@@ -131,6 +171,11 @@ func main() {
 			Usage:  "git author email",
 			EnvVar: "DRONE_COMMIT_AUTHOR_EMAIL",
 		},
+		cli.StringFlag{
+			Name:   "commit.author.avatar",
+			Usage:  "git author avatar",
+			EnvVar: "DRONE_COMMIT_AUTHOR_AVATAR",
+		},
 		cli.StringFlag{
 			Name:   "commit.message",
 			Usage:  "commit message",
@@ -168,44 +213,85 @@ func main() {
 			Usage:  "pull request",
 			EnvVar: "DRONE_PULL_REQUEST",
 		},
-		cli.Float64Flag{
-			Name:   "job.started",
-			Usage:  "job started",
-			EnvVar: "DRONE_JOB_STARTED",
+		cli.Int64Flag{
+			Name:   "build.started",
+			Usage:  "build started",
+			EnvVar: "DRONE_STAGE_STARTED",
 		},
-		cli.Float64Flag{
-			Name:   "job.finished",
-			Usage:  "job finished",
-			EnvVar: "DRONE_JOB_FINISHED",
+		cli.Int64Flag{
+			Name:   "build.finished",
+			Usage:  "build finished",
+			EnvVar: "DRONE_BUILD_FINISHED",
+		},
+		cli.BoolFlag{
+			Name:   "github",
+			Usage:  "Boolean value, indicates the runtime environment is GitHub Action.",
+			EnvVar: "PLUGIN_GITHUB,GITHUB",
 		},
 		cli.StringFlag{
-			Name:   "env-file",
-			Usage:  "source env file",
-			EnvVar: "ENV_FILE",
+			Name:   "github.workflow",
+			Usage:  "The name of the workflow.",
+			EnvVar: "GITHUB_WORKFLOW",
+		},
+		cli.StringFlag{
+			Name:   "github.action",
+			Usage:  "The name of the action.",
+			EnvVar: "GITHUB_ACTION",
+		},
+		cli.StringFlag{
+			Name:   "github.event.name",
+			Usage:  "The webhook name of the event that triggered the workflow.",
+			EnvVar: "GITHUB_EVENT_NAME",
+		},
+		cli.StringFlag{
+			Name:   "github.event.path",
+			Usage:  "The path to a file that contains the payload of the event that triggered the workflow. Value: /github/workflow/event.json.",
+			EnvVar: "GITHUB_EVENT_PATH",
+		},
+		cli.StringFlag{
+			Name:   "github.workspace",
+			Usage:  "The GitHub workspace path. Value: /github/workspace.",
+			EnvVar: "GITHUB_WORKSPACE",
+		},
+		cli.StringFlag{
+			Name:   "deploy.to",
+			Usage:  "Provides the target deployment environment for the running build. This value is only available to promotion and rollback pipelines.",
+			EnvVar: "DRONE_DEPLOY_TO",
+		},
+		cli.StringFlag{
+			Name:   "socks5",
+			Usage:  "Socks5 proxy URL",
+			EnvVar: "PLUGIN_SOCKS5,SOCKS5,INPUT_SOCKS5",
 		},
 	}
 
 	if err := app.Run(os.Args); err != nil {
-		log.Println(err)
+		log.Fatal(err)
 	}
 }
 
 func run(c *cli.Context) error {
-	if c.String("env-file") != "" {
-		_ = godotenv.Load(c.String("env-file"))
-	}
-
 	plugin := Plugin{
+		GitHub: GitHub{
+			Workflow:  c.String("github.workflow"),
+			Workspace: c.String("github.workspace"),
+			Action:    c.String("github.action"),
+			EventName: c.String("github.event.name"),
+			EventPath: c.String("github.event.path"),
+		},
 		Repo: Repo{
-			Owner: c.String("repo.owner"),
-			Name:  c.String("repo.name"),
+			FullName:  c.String("repo"),
+			Namespace: c.String("repo.namespace"),
+			Name:      c.String("repo.name"),
 		},
 		Commit: Commit{
 			Sha:     c.String("commit.sha"),
+			Ref:     c.String("commit.ref"),
 			Branch:  c.String("commit.branch"),
 			Link:    c.String("commit.link"),
 			Author:  c.String("commit.author"),
 			Email:   c.String("commit.author.email"),
+			Avatar:  c.String("commit.author.avatar"),
 			Message: c.String("commit.message"),
 		},
 		Build: Build{
@@ -214,26 +300,34 @@ func run(c *cli.Context) error {
 			Event:    c.String("build.event"),
 			Status:   c.String("build.status"),
 			Link:     c.String("build.link"),
-			Started:  c.Float64("job.started"),
-			Finished: c.Float64("job.finished"),
+			Started:  c.Int64("build.started"),
+			Finished: c.Int64("build.finished"),
 			PR:       c.String("pull.request"),
+			DeployTo: c.String("deploy.to"),
 		},
 		Config: Config{
-			Token:      c.String("token"),
-			Debug:      c.Bool("debug"),
-			MatchEmail: c.Bool("match.email"),
-			WebPreview: c.Bool("webpage.preview"),
-			To:         c.StringSlice("to"),
-			Message:    c.StringSlice("message"),
-			Photo:      c.StringSlice("photo"),
-			Document:   c.StringSlice("document"),
-			Sticker:    c.StringSlice("sticker"),
-			Audio:      c.StringSlice("audio"),
-			Voice:      c.StringSlice("voice"),
-			Location:   c.StringSlice("location"),
-			Video:      c.StringSlice("video"),
-			Venue:      c.StringSlice("venue"),
-			Format:     c.String("format"),
+			Token:            c.String("token"),
+			Debug:            c.Bool("debug"),
+			MatchEmail:       c.Bool("match.email"),
+			To:               c.StringSlice("to"),
+			Message:          c.String("message"),
+			MessageFile:      c.String("message.file"),
+			TemplateVars:     c.String("template.vars"),
+			TemplateVarsFile: c.String("template.vars.file"),
+			Photo:            c.StringSlice("photo"),
+			Document:         c.StringSlice("document"),
+			Sticker:          c.StringSlice("sticker"),
+			Audio:            c.StringSlice("audio"),
+			Voice:            c.StringSlice("voice"),
+			Location:         c.StringSlice("location"),
+			Video:            c.StringSlice("video"),
+			Venue:            c.StringSlice("venue"),
+			Format:           c.String("format"),
+			GitHub:           c.Bool("github"),
+			Socks5:           c.String("socks5"),
+
+			DisableWebPagePreview: c.Bool("disable.webpage.preview"),
+			DisableNotification:   c.Bool("disable.notification"),
 		},
 	}
 

plugin.go

@@ -1,30 +1,53 @@
 package main
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
+	"html"
 	"log"
+	"maps"
+	"net/http"
+	"net/url"
 	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 
-	"github.com/appleboy/drone-facebook/template"
-	"gopkg.in/telegram-bot-api.v4"
+	"github.com/appleboy/drone-template-lib/template"
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
+)
+
+const (
+	formatMarkdown = "Markdown"
+	formatHTML     = "HTML"
 )
 
 type (
+	// GitHub information.
+	GitHub struct {
+		Workflow  string
+		Workspace string
+		Action    string
+		EventName string
+		EventPath string
+	}
+
 	// Repo information.
 	Repo struct {
-		Owner string
-		Name  string
+		FullName  string
+		Namespace string
+		Name      string
 	}
 
 	// Commit information.
 	Commit struct {
 		Sha     string
+		Ref     string
 		Branch  string
 		Link    string
 		Author  string
+		Avatar  string
 		Email   string
 		Message string
 	}
@@ -36,36 +59,46 @@ type (
 		Number   int
 		Status   string
 		Link     string
-		Started  float64
-		Finished float64
+		Started  int64
+		Finished int64
 		PR       string
+		DeployTo string
 	}
 
 	// Config for the plugin.
 	Config struct {
-		Token      string
-		Debug      bool
-		MatchEmail bool
-		WebPreview bool
-		To         []string
-		Message    []string
-		Photo      []string
-		Document   []string
-		Sticker    []string
-		Audio      []string
-		Voice      []string
-		Location   []string
-		Video      []string
-		Venue      []string
-		Format     string
+		Token            string
+		Debug            bool
+		MatchEmail       bool
+		To               []string
+		Message          string
+		MessageFile      string
+		TemplateVarsFile string
+		TemplateVars     string
+		Photo            []string
+		Document         []string
+		Sticker          []string
+		Audio            []string
+		Voice            []string
+		Location         []string
+		Video            []string
+		Venue            []string
+		Format           string
+		GitHub           bool
+		Socks5           string
+
+		DisableWebPagePreview bool
+		DisableNotification   bool
 	}
 
 	// Plugin values.
 	Plugin struct {
+		GitHub GitHub
 		Repo   Repo
 		Commit Commit
 		Build  Build
 		Config Config
+		Tpl    map[string]string
 	}
 
 	// Location format
@@ -77,11 +110,17 @@ type (
 	}
 )
 
+var icons = map[string]string{
+	"failure":   "❌",
+	"cancelled": "❕",
+	"success":   "✅",
+}
+
 func trimElement(keys []string) []string {
-	var newKeys []string
+	newKeys := make([]string, 0, len(keys))
 
 	for _, value := range keys {
-		value = strings.Trim(value, " ")
+		value = strings.TrimSpace(value)
 		if len(value) == 0 {
 			continue
 		}
@@ -92,7 +131,7 @@ func trimElement(keys []string) []string {
 }
 
 func escapeMarkdown(keys []string) []string {
-	var newKeys []string
+	newKeys := make([]string, 0, len(keys))
 
 	for _, value := range keys {
 		value = escapeMarkdownOne(value)
@@ -106,20 +145,29 @@ func escapeMarkdown(keys []string) []string {
 }
 
 func escapeMarkdownOne(str string) string {
-	str = strings.Replace(str, `\_`, `_`, -1)
-	str = strings.Replace(str, `_`, `\_`, -1)
+	str = strings.ReplaceAll(str, `\_`, `_`)
+	str = strings.ReplaceAll(str, `_`, `\_`)
 
 	return str
 }
 
-func fileExist(keys []string) []string {
-	var newKeys []string
+func escapeMarkdownFields(fields ...*string) {
+	for _, f := range fields {
+		*f = escapeMarkdownOne(*f)
+	}
+}
 
-	for _, value := range keys {
-		if _, err := os.Stat(value); os.IsNotExist(err) {
+func globList(keys []string) []string {
+	newKeys := make([]string, 0, len(keys))
+
+	for _, pattern := range keys {
+		pattern = strings.TrimSpace(pattern)
+		matches, err := filepath.Glob(pattern)
+		if err != nil {
+			log.Printf("Glob error for %q: %s", pattern, err)
 			continue
 		}
-		newKeys = append(newKeys, value)
+		newKeys = append(newKeys, matches...)
 	}
 
 	return newKeys
@@ -129,7 +177,7 @@ func convertLocation(value string) (Location, bool) {
 	var latitude, longitude float64
 	var title, address string
 	var err error
-	values := trimElement(strings.Split(value, ","))
+	values := trimElement(strings.Split(value, " "))
 
 	if len(values) < 2 {
 		return Location{}, true
@@ -140,19 +188,16 @@ func convertLocation(value string) (Location, bool) {
 	}
 
 	if len(values) > 3 {
-		title = values[2]
 		address = values[3]
 	}
 
 	latitude, err = strconv.ParseFloat(values[0], 64)
-
 	if err != nil {
 		log.Println(err.Error())
 		return Location{}, true
 	}
 
 	longitude, err = strconv.ParseFloat(values[1], 64)
-
 	if err != nil {
 		log.Println(err.Error())
 		return Location{}, true
@@ -166,6 +211,14 @@ func convertLocation(value string) (Location, bool) {
 	}, false
 }
 
+func loadTextFromFile(filename string) ([]string, error) {
+	content, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	return []string{string(content)}, nil
+}
+
 func parseTo(to []string, authorEmail string, matchEmail bool) []int64 {
 	var emails []int64
 	var ids []int64
@@ -194,36 +247,82 @@ func parseTo(to []string, authorEmail string, matchEmail bool) []int64 {
 		ids = append(ids, id)
 	}
 
-	if matchEmail == true && attachEmail == false {
+	if matchEmail && !attachEmail {
 		return emails
 	}
 
-	for _, value := range emails {
-		ids = append(ids, value)
-	}
+	ids = append(ids, emails...)
 
 	return ids
 }
 
 // Exec executes the plugin.
-func (p Plugin) Exec() error {
-
+func (p *Plugin) Exec() (err error) {
 	if len(p.Config.Token) == 0 || len(p.Config.To) == 0 {
 		return errors.New("missing telegram token or user list")
 	}
 
 	var message []string
-	if len(p.Config.Message) > 0 {
-		message = p.Config.Message
-	} else {
-		message = p.Message(p.Repo, p.Commit, p.Build)
+	switch {
+	case len(p.Config.MessageFile) > 0:
+		message, err = loadTextFromFile(p.Config.MessageFile)
+		if err != nil {
+			return fmt.Errorf("error loading message file '%s': %w", p.Config.MessageFile, err)
+		}
+	case len(p.Config.Message) > 0:
+		message = []string{p.Config.Message}
+	default:
+		p.Config.Format = formatMarkdown
+		message = p.Message()
 	}
 
-	bot, err := tgbotapi.NewBotAPI(p.Config.Token)
+	if p.Config.TemplateVars != "" {
+		p.Tpl = make(map[string]string)
+		if err = json.Unmarshal([]byte(p.Config.TemplateVars), &p.Tpl); err != nil {
+			return fmt.Errorf(
+				"unable to unmarshal template vars from JSON string '%s': %w",
+				p.Config.TemplateVars,
+				err,
+			)
+		}
+	}
 
-	// enable bot debug mode
-	if p.Config.Debug {
-		bot.Debug = true
+	if p.Config.TemplateVarsFile != "" {
+		content, err := os.ReadFile(p.Config.TemplateVarsFile)
+		if err != nil {
+			return fmt.Errorf(
+				"unable to read file with template vars '%s': %w",
+				p.Config.TemplateVarsFile,
+				err,
+			)
+		}
+		vars := make(map[string]string)
+		if err = json.Unmarshal(content, &vars); err != nil {
+			return fmt.Errorf(
+				"unable to unmarshal template vars from JSON file '%s': %w",
+				p.Config.TemplateVarsFile,
+				err,
+			)
+		}
+		// File variables take precedence over inline variables
+		if p.Tpl == nil {
+			p.Tpl = vars
+		} else {
+			maps.Copy(p.Tpl, vars)
+		}
+	}
+
+	var bot *tgbotapi.BotAPI
+	if len(p.Config.Socks5) > 0 {
+		var proxyURL *url.URL
+		proxyURL, err = url.Parse(p.Config.Socks5)
+		if err != nil {
+			return fmt.Errorf("unable to parse socks5 proxy URL '%s': %w", p.Config.Socks5, err)
+		}
+		proxyClient := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}}
+		bot, err = tgbotapi.NewBotAPIWithClient(p.Config.Token, proxyClient)
+	} else {
+		bot, err = tgbotapi.NewBotAPI(p.Config.Token)
 	}
 
 	if err != nil {
@@ -233,45 +332,61 @@ func (p Plugin) Exec() error {
 	bot.Debug = p.Config.Debug
 
 	ids := parseTo(p.Config.To, p.Commit.Email, p.Config.MatchEmail)
-	photos := fileExist(trimElement(p.Config.Photo))
-	documents := fileExist(trimElement(p.Config.Document))
-	stickers := fileExist(trimElement(p.Config.Sticker))
-	audios := fileExist(trimElement(p.Config.Audio))
-	voices := fileExist(trimElement(p.Config.Voice))
-	videos := fileExist(trimElement(p.Config.Video))
+	photos := globList(p.Config.Photo)
+	documents := globList(p.Config.Document)
+	stickers := globList(p.Config.Sticker)
+	audios := globList(p.Config.Audio)
+	voices := globList(p.Config.Voice)
+	videos := globList(p.Config.Video)
 	locations := trimElement(p.Config.Location)
 	venues := trimElement(p.Config.Venue)
 
 	message = trimElement(message)
 
-	if p.Config.Format == "markdown" {
+	if p.Config.Format == formatMarkdown {
 		message = escapeMarkdown(message)
 
-		p.Commit.Message = escapeMarkdownOne(p.Commit.Message)
-		p.Commit.Branch = escapeMarkdownOne(p.Commit.Branch)
-		p.Commit.Link = escapeMarkdownOne(p.Commit.Link)
-		p.Commit.Author = escapeMarkdownOne(p.Commit.Author)
-		p.Commit.Email = escapeMarkdownOne(p.Commit.Email)
-
-		p.Build.Tag = escapeMarkdownOne(p.Build.Tag)
-		p.Build.Link = escapeMarkdownOne(p.Build.Link)
-		p.Build.PR = escapeMarkdownOne(p.Build.PR)
-
-		p.Repo.Owner = escapeMarkdownOne(p.Repo.Owner)
-		p.Repo.Name = escapeMarkdownOne(p.Repo.Name)
+		escapeMarkdownFields(
+			&p.Commit.Message, &p.Commit.Branch, &p.Commit.Link,
+			&p.Commit.Author, &p.Commit.Email,
+			&p.Build.Tag, &p.Build.Link, &p.Build.PR,
+			&p.Repo.Namespace, &p.Repo.Name,
+		)
 	}
 
-	// send message.
-	for _, user := range ids {
-		for _, value := range message {
-			txt, err := template.RenderTrim(value, p)
-			if err != nil {
-				return err
-			}
+	// pre-render message templates (identical for all users)
+	var renderedMessages []string
+	for _, value := range message {
+		txt, err := template.RenderTrim(value, p)
+		if err != nil {
+			return err
+		}
+		renderedMessages = append(renderedMessages, html.UnescapeString(txt))
+	}
 
+	// pre-parse locations and venues (identical for all users)
+	var parsedLocations []Location
+	for _, value := range locations {
+		loc, empty := convertLocation(value)
+		if !empty {
+			parsedLocations = append(parsedLocations, loc)
+		}
+	}
+
+	var parsedVenues []Location
+	for _, value := range venues {
+		loc, empty := convertLocation(value)
+		if !empty {
+			parsedVenues = append(parsedVenues, loc)
+		}
+	}
+
+	for _, user := range ids {
+		for _, txt := range renderedMessages {
 			msg := tgbotapi.NewMessage(user, txt)
 			msg.ParseMode = p.Config.Format
-			msg.DisableWebPagePreview = !p.Config.WebPreview
+			msg.DisableWebPagePreview = p.Config.DisableWebPagePreview
+			msg.DisableNotification = p.Config.DisableNotification
 			if err := p.Send(bot, msg); err != nil {
 				return err
 			}
@@ -300,7 +415,7 @@ func (p Plugin) Exec() error {
 
 		for _, value := range audios {
 			msg := tgbotapi.NewAudioUpload(user, value)
-			msg.Title = "Audio Message."
+			msg.Title = "Audio Message"
 			if err := p.Send(bot, msg); err != nil {
 				return err
 			}
@@ -321,27 +436,21 @@ func (p Plugin) Exec() error {
 			}
 		}
 
-		for _, value := range locations {
-			location, empty := convertLocation(value)
-
-			if empty == true {
-				continue
-			}
-
-			msg := tgbotapi.NewLocation(user, location.Latitude, location.Longitude)
+		for _, loc := range parsedLocations {
+			msg := tgbotapi.NewLocation(user, loc.Latitude, loc.Longitude)
 			if err := p.Send(bot, msg); err != nil {
 				return err
 			}
 		}
 
-		for _, value := range venues {
-			location, empty := convertLocation(value)
-
-			if empty == true {
-				continue
-			}
-
-			msg := tgbotapi.NewVenue(user, location.Title, location.Address, location.Latitude, location.Longitude)
+		for _, loc := range parsedVenues {
+			msg := tgbotapi.NewVenue(
+				user,
+				loc.Title,
+				loc.Address,
+				loc.Latitude,
+				loc.Longitude,
+			)
 			if err := p.Send(bot, msg); err != nil {
 				return err
 			}
@@ -352,25 +461,51 @@ func (p Plugin) Exec() error {
 }
 
 // Send bot message.
-func (p Plugin) Send(bot *tgbotapi.BotAPI, msg tgbotapi.Chattable) error {
+func (p *Plugin) Send(bot *tgbotapi.BotAPI, msg tgbotapi.Chattable) error {
 	message, err := bot.Send(msg)
 
-	if p.Config.Debug == true {
+	if p.Config.Debug {
 		log.Println("=====================")
 		log.Printf("Response Message: %#v\n", message)
 		log.Println("=====================")
 	}
 
-	return err
+	if err == nil {
+		return nil
+	}
+
+	return errors.New(strings.ReplaceAll(err.Error(), p.Config.Token, "<token>"))
 }
 
 // Message is plugin default message.
-func (p Plugin) Message(repo Repo, commit Commit, build Build) []string {
-	return []string{fmt.Sprintf("[%s] <%s> (%s)『%s』by %s",
-		build.Status,
-		build.Link,
-		commit.Branch,
-		commit.Message,
-		commit.Author,
-	)}
+func (p *Plugin) Message() []string {
+	icon := icons[strings.ToLower(p.Build.Status)]
+
+	if p.Config.GitHub {
+		return []string{fmt.Sprintf("%s/%s triggered by %s (%s)",
+			p.Repo.FullName,
+			p.GitHub.Workflow,
+			p.Repo.Namespace,
+			p.GitHub.EventName,
+		)}
+	}
+
+	// ✅  Build #106 of drone-telegram succeeded.
+	//
+	// 📝 Commit by appleboy on master:
+	//  chore: update default template
+	//
+	// 🌐 https://cloud.drone.io/appleboy/drone-telegram/106
+	return []string{
+		fmt.Sprintf("%s Build #%d of `%s` %s.\n\n📝 Commit by %s on `%s`:\n``` %s ```\n\n🌐 %s",
+			icon,
+			p.Build.Number,
+			p.Repo.FullName,
+			p.Build.Status,
+			p.Commit.Author,
+			p.Commit.Branch,
+			p.Commit.Message,
+			p.Build.Link,
+		),
+	}
 }

plugin_test.go

@@ -3,16 +3,26 @@ package main
 import (
 	"os"
 	"testing"
+	"time"
 
+	"github.com/appleboy/drone-template-lib/template"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
+func skipIfNoTelegramSecrets(t *testing.T) {
+	t.Helper()
+	if os.Getenv("TELEGRAM_TOKEN") == "" || os.Getenv("TELEGRAM_TO") == "" {
+		t.Skip("TELEGRAM_TOKEN/TELEGRAM_TO not set; skipping integration test")
+	}
+}
+
 func TestMissingDefaultConfig(t *testing.T) {
 	var plugin Plugin
 
 	err := plugin.Exec()
 
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func TestMissingUserConfig(t *testing.T) {
@@ -24,14 +34,15 @@ func TestMissingUserConfig(t *testing.T) {
 
 	err := plugin.Exec()
 
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func TestDefaultMessageFormat(t *testing.T) {
 	plugin := Plugin{
 		Repo: Repo{
-			Name:  "go-hello",
-			Owner: "appleboy",
+			FullName:  "appleboy/go-hello",
+			Name:      "go-hello",
+			Namespace: "appleboy",
 		},
 		Commit: Commit{
 			Sha:     "e7c4f0a63ceeb42a39ac7806f7b51f3f0d204fd2",
@@ -46,16 +57,48 @@ func TestDefaultMessageFormat(t *testing.T) {
 		},
 	}
 
-	message := plugin.Message(plugin.Repo, plugin.Commit, plugin.Build)
+	message := plugin.Message()
 
-	assert.Equal(t, []string{"[success] <https://github.com/appleboy/go-hello> (master)『update travis』by Bo-Yi Wu"}, message)
+	assert.Equal(
+		t,
+		[]string{
+			"✅ Build #101 of `appleboy/go-hello` success.\n\n📝 Commit by Bo-Yi Wu on `master`:\n``` update travis ```\n\n🌐 https://github.com/appleboy/go-hello",
+		},
+		message,
+	)
+}
+
+func TestDefaultMessageFormatFromGitHub(t *testing.T) {
+	plugin := Plugin{
+		Config: Config{
+			GitHub: true,
+		},
+		Repo: Repo{
+			FullName:  "appleboy/go-hello",
+			Name:      "go-hello",
+			Namespace: "appleboy",
+		},
+		GitHub: GitHub{
+			Workflow:  "test-workflow",
+			Action:    "send notification",
+			EventName: "push",
+		},
+	}
+
+	message := plugin.Message()
+
+	assert.Equal(
+		t,
+		[]string{"appleboy/go-hello/test-workflow triggered by appleboy (push)"},
+		message,
+	)
 }
 
 func TestSendMessage(t *testing.T) {
 	plugin := Plugin{
 		Repo: Repo{
-			Name:  "go-hello",
-			Owner: "appleboy",
+			Name:      "go-hello",
+			Namespace: "appleboy",
 		},
 		Commit: Commit{
 			Sha:     "e7c4f0a63ceeb42a39ac7806f7b51f3f0d204fd2",
@@ -72,40 +115,94 @@ func TestSendMessage(t *testing.T) {
 		},
 
 		Config: Config{
-			Token:    os.Getenv("TELEGRAM_TOKEN"),
-			To:       []string{os.Getenv("TELEGRAM_TO"), os.Getenv("TELEGRAM_TO") + ":appleboy@gmail.com", "中文ID", "1234567890"},
-			Message:  []string{"Test Telegram Chat Bot From Travis or Local", "commit message: 『{{ build.message }}』", " "},
+			Token: os.Getenv("TELEGRAM_TOKEN"),
+			To: []string{
+				os.Getenv("TELEGRAM_TO"),
+				os.Getenv("TELEGRAM_TO") + ":appleboy@gmail.com",
+				"中文ID",
+				"1234567890",
+			},
+			Message:  "Test Telegram Chat Bot From Travis or Local, commit message: 『{{ build.message }}』",
 			Photo:    []string{"tests/github.png", "1234", " "},
 			Document: []string{"tests/gophercolor.png", "1234", " "},
 			Sticker:  []string{"tests/github-logo.png", "tests/github.png", "1234", " "},
 			Audio:    []string{"tests/audio.mp3", "1234", " "},
 			Voice:    []string{"tests/voice.ogg", "1234", " "},
-			Location: []string{"24.9163213,121.1424972", "1", " "},
-			Venue:    []string{"35.661777,139.704051,竹北體育館,新竹縣竹北市", "24.9163213,121.1424972", "1", " "},
-			Video:    []string{"tests/video.mp4", "1234", " "},
-			Debug:    false,
+			Location: []string{"24.9163213 121.1424972", "1", " "},
+			Venue: []string{
+				"35.661777 139.704051 竹北體育館 新竹縣竹北市",
+				"24.9163213 121.1424972",
+				"1",
+				" ",
+			},
+			Video: []string{"tests/video.mp4", "1234", " "},
+			Debug: false,
 		},
 	}
 
 	err := plugin.Exec()
-	assert.NotNil(t, err)
+	require.Error(t, err)
 
-	plugin.Config.Format = "markdown"
-	plugin.Config.Message = []string{"Test escape under_score"}
+	plugin.Config.Format = formatMarkdown
+	plugin.Config.Message = "Test escape under_score"
 	err = plugin.Exec()
-	assert.NotNil(t, err)
+	require.Error(t, err)
 
 	// disable message
-	plugin.Config.Message = []string{}
+	plugin.Config.Message = ""
 	err = plugin.Exec()
-	assert.NotNil(t, err)
+	assert.Error(t, err)
+}
+
+func TestDisableWebPagePreviewMessage(t *testing.T) {
+	skipIfNoTelegramSecrets(t)
+	plugin := Plugin{
+		Config: Config{
+			Token:                 os.Getenv("TELEGRAM_TOKEN"),
+			To:                    []string{os.Getenv("TELEGRAM_TO")},
+			DisableWebPagePreview: true,
+			Debug:                 false,
+		},
+	}
+
+	plugin.Config.Message = "DisableWebPagePreview https://www.google.com.tw"
+	err := plugin.Exec()
+	require.NoError(t, err)
+
+	// disable message
+	plugin.Config.DisableWebPagePreview = false
+	plugin.Config.Message = "EnableWebPagePreview https://www.google.com.tw"
+	err = plugin.Exec()
+	assert.NoError(t, err)
+}
+
+func TestDisableNotificationMessage(t *testing.T) {
+	skipIfNoTelegramSecrets(t)
+	plugin := Plugin{
+		Config: Config{
+			Token:               os.Getenv("TELEGRAM_TOKEN"),
+			To:                  []string{os.Getenv("TELEGRAM_TO")},
+			DisableNotification: true,
+			Debug:               false,
+		},
+	}
+
+	plugin.Config.Message = "DisableNotification https://www.google.com.tw"
+	err := plugin.Exec()
+	require.NoError(t, err)
+
+	// disable message
+	plugin.Config.DisableNotification = false
+	plugin.Config.Message = "EnableNotification https://www.google.com.tw"
+	err = plugin.Exec()
+	assert.NoError(t, err)
 }
 
 func TestBotError(t *testing.T) {
 	plugin := Plugin{
 		Repo: Repo{
-			Name:  "go-hello",
-			Owner: "appleboy",
+			Name:      "go-hello",
+			Namespace: "appleboy",
 		},
 		Commit: Commit{
 			Sha:     "e7c4f0a63ceeb42a39ac7806f7b51f3f0d204fd2",
@@ -122,12 +219,12 @@ func TestBotError(t *testing.T) {
 		Config: Config{
 			Token:   "appleboy",
 			To:      []string{os.Getenv("TELEGRAM_TO"), "中文ID", "1234567890"},
-			Message: []string{"Test Telegram Chat Bot From Travis or Local", " "},
+			Message: "Test Telegram Chat Bot From Travis or Local",
 		},
 	}
 
 	err := plugin.Exec()
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func TestTrimElement(t *testing.T) {
@@ -203,17 +300,20 @@ func TestParseTo(t *testing.T) {
 
 	// test empty ids
 	ids = parseTo([]string{"", " ", "   "}, "a@gmail.com", true)
-	assert.Equal(t, 0, len(ids))
+	assert.Empty(t, ids)
 }
 
-func TestCheckFileExist(t *testing.T) {
+func TestGlobList(t *testing.T) {
 	var input []string
 	var result []string
 
 	input = []string{"tests/gophercolor.png", "測試", "3"}
 	result = []string{"tests/gophercolor.png"}
+	assert.Equal(t, result, globList(input))
 
-	assert.Equal(t, result, fileExist(input))
+	input = []string{"tests/*.mp3"}
+	result = []string{"tests/audio.mp3"}
+	assert.Equal(t, result, globList(input))
 }
 
 func TestConvertLocation(t *testing.T) {
@@ -224,36 +324,36 @@ func TestConvertLocation(t *testing.T) {
 	input = "1"
 	result, empty = convertLocation(input)
 
-	assert.Equal(t, true, empty)
+	assert.True(t, empty)
 	assert.Equal(t, Location{}, result)
 
 	// strconv.ParseInt: parsing "測試": invalid syntax
-	input = "測試,139.704051"
+	input = "測試 139.704051"
 	result, empty = convertLocation(input)
 
-	assert.Equal(t, true, empty)
+	assert.True(t, empty)
 	assert.Equal(t, Location{}, result)
 
 	// strconv.ParseInt: parsing "測試": invalid syntax
-	input = "35.661777,測試"
+	input = "35.661777 測試"
 	result, empty = convertLocation(input)
 
-	assert.Equal(t, true, empty)
+	assert.True(t, empty)
 	assert.Equal(t, Location{}, result)
 
-	input = "35.661777,139.704051"
+	input = "35.661777 139.704051"
 	result, empty = convertLocation(input)
 
-	assert.Equal(t, false, empty)
+	assert.False(t, empty)
 	assert.Equal(t, Location{
 		Latitude:  float64(35.661777),
 		Longitude: float64(139.704051),
 	}, result)
 
-	input = "35.661777,139.704051,title"
+	input = "35.661777 139.704051 title"
 	result, empty = convertLocation(input)
 
-	assert.Equal(t, false, empty)
+	assert.False(t, empty)
 	assert.Equal(t, Location{
 		Title:     "title",
 		Address:   "",
@@ -261,10 +361,10 @@ func TestConvertLocation(t *testing.T) {
 		Longitude: float64(139.704051),
 	}, result)
 
-	input = "35.661777,139.704051,title,address"
+	input = "35.661777 139.704051 title address"
 	result, empty = convertLocation(input)
 
-	assert.Equal(t, false, empty)
+	assert.False(t, empty)
 	assert.Equal(t, Location{
 		Title:     "title",
 		Address:   "address",
@@ -274,16 +374,17 @@ func TestConvertLocation(t *testing.T) {
 }
 
 func TestHTMLMessage(t *testing.T) {
+	skipIfNoTelegramSecrets(t)
 	plugin := Plugin{
 		Repo: Repo{
-			Name:  "go-hello",
-			Owner: "appleboy",
+			Name:      "go-hello",
+			Namespace: "appleboy",
 		},
 		Commit: Commit{
 			Sha:     "e7c4f0a63ceeb42a39ac7806f7b51f3f0d204fd2",
 			Author:  "Bo-Yi Wu",
 			Branch:  "master",
-			Message: "Freakin' macOS isn't fully case-sensitive..",
+			Message: "test",
 		},
 		Build: Build{
 			Number: 101,
@@ -294,9 +395,178 @@ func TestHTMLMessage(t *testing.T) {
 		Config: Config{
 			Token: os.Getenv("TELEGRAM_TOKEN"),
 			To:    []string{os.Getenv("TELEGRAM_TO")},
+			Message: `
+Test HTML Format
+<a href='https://google.com'>Google .com 1</a>
+<a href='https://google.com'>Google .com 2</a>
+<a href='https://google.com'>Google .com 3</a>
+`,
+			Format: formatHTML,
+		},
+	}
+
+	assert.NoError(t, plugin.Exec())
+
+	plugin.Config.MessageFile = "tests/message_html.txt"
+	assert.NoError(t, plugin.Exec())
+}
+
+func TestMessageFile(t *testing.T) {
+	skipIfNoTelegramSecrets(t)
+	plugin := Plugin{
+		Repo: Repo{
+			Name:      "go-hello",
+			Namespace: "appleboy",
+		},
+		Commit: Commit{
+			Sha:     "e7c4f0a63ceeb42a39ac7806f7b51f3f0d204fd2",
+			Author:  "Bo-Yi Wu",
+			Branch:  "master",
+			Message: "Freakin' macOS isn't fully case-sensitive..",
+		},
+		Build: Build{
+			Number:   101,
+			Status:   "success",
+			Link:     "https://github.com/appleboy/go-hello",
+			Started:  time.Now().Unix(),
+			Finished: time.Now().Add(180 * time.Second).Unix(),
+		},
+
+		Config: Config{
+			Token:       os.Getenv("TELEGRAM_TOKEN"),
+			To:          []string{os.Getenv("TELEGRAM_TO")},
+			MessageFile: "tests/message.txt",
 		},
 	}
 
 	err := plugin.Exec()
-	assert.Nil(t, err)
+	assert.NoError(t, err)
+}
+
+func TestTemplateVars(t *testing.T) {
+	skipIfNoTelegramSecrets(t)
+	plugin := Plugin{
+		Repo: Repo{
+			Name:      "go-hello",
+			Namespace: "appleboy",
+		},
+		Commit: Commit{
+			Sha:     "e7c4f0a63ceeb42a39ac7806f7b51f3f0d204fd2",
+			Author:  "Bo-Yi Wu",
+			Branch:  "master",
+			Message: "This is a test commit msg",
+		},
+		Build: Build{
+			Number:   101,
+			Status:   "success",
+			Link:     "https://github.com/appleboy/go-hello",
+			Started:  time.Now().Unix(),
+			Finished: time.Now().Add(180 * time.Second).Unix(),
+		},
+
+		Config: Config{
+			Token:        os.Getenv("TELEGRAM_TOKEN"),
+			To:           []string{os.Getenv("TELEGRAM_TO")},
+			Format:       formatMarkdown,
+			MessageFile:  "tests/message_template.txt",
+			TemplateVars: `{"env":"testing","version":"1.2.0-SNAPSHOT"}`,
+		},
+	}
+
+	err := plugin.Exec()
+	assert.NoError(t, err)
+}
+
+func TestTemplateVarsFile(t *testing.T) {
+	skipIfNoTelegramSecrets(t)
+	plugin := Plugin{
+		Repo: Repo{
+			Name:      "go-hello",
+			Namespace: "appleboy",
+		},
+		Commit: Commit{
+			Sha:     "e7c4f0a63ceeb42a39ac7806f7b51f3f0d204fd2",
+			Author:  "Bo-Yi Wu",
+			Branch:  "master",
+			Message: "This is a test commit msg",
+		},
+		Build: Build{
+			Number: 101,
+			Status: "success",
+			Link:   "https://github.com/appleboy/go-hello",
+		},
+
+		Config: Config{
+			Token:            os.Getenv("TELEGRAM_TOKEN"),
+			To:               []string{os.Getenv("TELEGRAM_TO")},
+			Format:           formatMarkdown,
+			MessageFile:      "tests/message_template.txt",
+			TemplateVarsFile: "tests/vars.json",
+		},
+	}
+
+	err := plugin.Exec()
+	assert.NoError(t, err)
+}
+
+func TestProxySendMessage(t *testing.T) {
+	skipIfNoTelegramSecrets(t)
+	plugin := Plugin{
+		Repo: Repo{
+			Name:      "go-hello",
+			Namespace: "appleboy",
+		},
+		Commit: Commit{
+			Sha:     "e7c4f0a63ceeb42a39ac7806f7b51f3f0d204fd2",
+			Author:  "Bo-Yi Wu",
+			Branch:  "master",
+			Message: "start use proxy",
+			Email:   "test@gmail.com",
+		},
+		Build: Build{
+			Tag:    "1.0.0",
+			Number: 101,
+			Status: "success",
+			Link:   "https://github.com/appleboy/go-hello",
+		},
+
+		Config: Config{
+			Token:   os.Getenv("TELEGRAM_TOKEN"),
+			To:      []string{os.Getenv("TELEGRAM_TO")},
+			Message: "Send message from socks5 proxy URL.",
+			Debug:   false,
+			Socks5:  os.Getenv("SOCKS5"),
+		},
+	}
+
+	err := plugin.Exec()
+	assert.NoError(t, err)
+}
+
+func TestBuildTemplate(t *testing.T) {
+	plugin := Plugin{
+		Commit: Commit{
+			Sha:     "e7c4f0a63ceeb42a39ac7806f7b51f3f0d204fd2",
+			Author:  "Bo-Yi Wu",
+			Branch:  "master",
+			Message: "This is a test commit msg",
+		},
+		Build: Build{
+			Number:   101,
+			Status:   "success",
+			Link:     "https://github.com/appleboy/go-hello",
+			Started:  time.Now().Unix(),
+			Finished: time.Now().Add(180 * time.Second).Unix(),
+		},
+	}
+
+	_, err := template.RenderTrim(
+		`
+Sample message loaded from file.
+
+Commit msg:  {{uppercasefirst commit.message}}
+
+duration: {{duration build.started build.finished}}
+`, plugin)
+	assert.NoError(t, err)
 }

tests/message.txt

@@ -0,0 +1,5 @@
+Sample message loaded from file.
+
+Commit msg:  {{commit.message}}
+
+duration: {{duration build.started build.finished}}

tests/message_html.txt

@@ -0,0 +1,5 @@
+Test HTML Format from file
+<a href='https://google.com'>Google .com 1</a>
+<a href='https://google.com'>Google .com 2</a>
+<a href='https://google.com'>Google .com 3</a>
+<a href='https://google.com'>Google .com 4</a>

tests/message_template.txt

@@ -0,0 +1,8 @@
+Sample message template loaded from file.
+
+*Environ:* {{tpl.env}}
+*Version:* {{tpl.version}}
+
+Commit msg:  {{commit.message}}
+
+duration: {{duration build.started build.finished}}

tests/vars.json

@@ -0,0 +1 @@
+{"env":"testing","version":"1.2.0-SNAPSHOT"}

vendor/github.com/appleboy/drone-facebook/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2016 Bo-Yi Wu
-
-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/appleboy/drone-facebook/template/template.go

@@ -1,134 +0,0 @@
-package template
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"strings"
-	"time"
-	"unicode"
-	"unicode/utf8"
-
-	"github.com/aymerick/raymond"
-)
-
-func init() {
-	raymond.RegisterHelpers(funcs)
-}
-
-// Render parses and executes a template, returning the results in string format.
-func Render(template string, payload interface{}) (s string, err error) {
-	u, err := url.Parse(template)
-	if err == nil {
-		switch u.Scheme {
-		case "http", "https":
-			res, err := http.Get(template)
-			if err != nil {
-				return s, err
-			}
-			defer res.Body.Close()
-			out, err := ioutil.ReadAll(res.Body)
-			if err != nil {
-				return s, err
-			}
-			template = string(out)
-
-		case "file":
-			out, err := ioutil.ReadFile(u.Path)
-			if err != nil {
-				return s, err
-			}
-			template = string(out)
-		}
-	}
-
-	return raymond.Render(template, payload)
-}
-
-// RenderTrim parses and executes a template, returning the results in string
-// format. The result is trimmed to remove left and right padding and newlines
-// that may be added unintentially in the template markup.
-func RenderTrim(template string, playload interface{}) (string, error) {
-	out, err := Render(template, playload)
-	return strings.Trim(out, " \n"), err
-}
-
-var funcs = map[string]interface{}{
-	"uppercasefirst": uppercaseFirst,
-	"uppercase":      strings.ToUpper,
-	"lowercase":      strings.ToLower,
-	"duration":       toDuration,
-	"datetime":       toDatetime,
-	"success":        isSuccess,
-	"failure":        isFailure,
-	"truncate":       truncate,
-	"urlencode":      urlencode,
-	"buildtime":      buildTime,
-}
-
-func truncate(s string, len int) string {
-	if utf8.RuneCountInString(s) <= len {
-		return s
-	}
-	runes := []rune(s)
-	return string(runes[:len])
-
-}
-
-func uppercaseFirst(s string) string {
-	a := []rune(s)
-	a[0] = unicode.ToUpper(a[0])
-	s = string(a)
-	return s
-}
-
-func toDuration(started, finished float64) string {
-	return fmt.Sprint(time.Duration(finished-started) * time.Second)
-}
-
-func buildTime(started float64) string {
-	finished := float64(time.Now().Unix())
-	return fmt.Sprint(time.Duration(finished-started) * time.Second)
-}
-
-func toDatetime(timestamp float64, layout, zone string) string {
-	if len(zone) == 0 {
-		return time.Unix(int64(timestamp), 0).Format(layout)
-	}
-	loc, err := time.LoadLocation(zone)
-	if err != nil {
-		return time.Unix(int64(timestamp), 0).Local().Format(layout)
-	}
-	return time.Unix(int64(timestamp), 0).In(loc).Format(layout)
-}
-
-func isSuccess(conditional bool, options *raymond.Options) string {
-	if !conditional {
-		return options.Inverse()
-	}
-
-	switch options.ParamStr(0) {
-	case "success":
-		return options.Fn()
-	default:
-		return options.Inverse()
-	}
-}
-
-func isFailure(conditional bool, options *raymond.Options) string {
-	if !conditional {
-		return options.Inverse()
-	}
-
-	switch options.ParamStr(0) {
-	case "failure", "error", "killed":
-		return options.Fn()
-	default:
-		return options.Inverse()
-	}
-}
-
-func urlencode(options *raymond.Options) string {
-	return url.QueryEscape(options.Fn())
-}

vendor/github.com/aymerick/raymond/BENCHMARKS.md

@@ -1,46 +0,0 @@
-# Benchmarks
-
-Hardware: MacBookPro11,1 - Intel Core i5 - 2,6 GHz - 8 Go RAM
-
-With:
-
-    - handlebars.js #8cba84df119c317fcebc49fb285518542ca9c2d0
-    - raymond #7bbaaf50ed03c96b56687d7fa6c6e04e02375a98
-
-
-## handlebars.js (ops/ms)
-
-        arguments          198 ±4 (5)
-        array-each         568 ±23 (5)
-        array-mustache     522 ±18 (4)
-        complex             71 ±7 (3)
-        data                67 ±2 (3)
-        depth-1             47 ±2 (3)
-        depth-2             14 ±1 (2)
-        object-mustache   1099 ±47 (5)
-        object             907 ±58 (4)
-        partial-recursion   46 ±3 (4)
-        partial             68 ±3 (3)
-        paths             1650 ±50 (3)
-        string            2552 ±157 (3)
-        subexpression      141 ±2 (4)
-        variables         2671 ±83 (4)
-
-
-## raymond
-
-        BenchmarkArguments          200000     6642 ns/op   151 ops/ms
-        BenchmarkArrayEach          100000    19584 ns/op    51 ops/ms
-        BenchmarkArrayMustache      100000    17305 ns/op    58 ops/ms
-        BenchmarkComplex            30000     50270 ns/op    20 ops/ms
-        BenchmarkData               50000     25551 ns/op    39 ops/ms
-        BenchmarkDepth1             100000    20162 ns/op    50 ops/ms
-        BenchmarkDepth2             30000     47782 ns/op    21 ops/ms
-        BenchmarkObjectMustache     200000     7668 ns/op   130 ops/ms
-        BenchmarkObject             200000     8843 ns/op   113 ops/ms
-        BenchmarkPartialRecursion   50000     23139 ns/op    43 ops/ms
-        BenchmarkPartial            50000     31015 ns/op    32 ops/ms
-        BenchmarkPath               200000     8997 ns/op   111 ops/ms
-        BenchmarkString             1000000    1879 ns/op   532 ops/ms
-        BenchmarkSubExpression      300000     4935 ns/op   203 ops/ms
-        BenchmarkVariables          200000     6478 ns/op   154 ops/ms

vendor/github.com/aymerick/raymond/CHANGELOG.md

@@ -1,33 +0,0 @@
-# Raymond Changelog
-
-### Raymond 2.0.1 _(June 01, 2016)_
-
-- [BUGFIX] Removes data races [#3](https://github.com/aymerick/raymond/issues/3) - Thanks [@markbates](https://github.com/markbates)
-
-### Raymond 2.0.0 _(May 01, 2016)_
-
-- [BUGFIX] Fixes passing of context in helper options [#2](https://github.com/aymerick/raymond/issues/2) - Thanks [@GhostRussia](https://github.com/GhostRussia)
-- [BREAKING] Renames and unexports constants:
-
-  - `handlebars.DUMP_TPL`
-  - `lexer.ESCAPED_ESCAPED_OPEN_MUSTACHE`
-  - `lexer.ESCAPED_OPEN_MUSTACHE`
-  - `lexer.OPEN_MUSTACHE`
-  - `lexer.CLOSE_MUSTACHE`
-  - `lexer.CLOSE_STRIP_MUSTACHE`
-  - `lexer.CLOSE_UNESCAPED_STRIP_MUSTACHE`
-  - `lexer.DUMP_TOKEN_POS`
-  - `lexer.DUMP_ALL_TOKENS_VAL`
-
-
-### Raymond 1.1.0 _(June 15, 2015)_
-
-- Permits templates references with lowercase versions of struct fields.
-- Adds `ParseFile()` function.
-- Adds `RegisterPartialFile()`, `RegisterPartialFiles()` and `Clone()` methods on `Template`.
-- Helpers can now be struct methods.
-- Ensures safe concurrent access to helpers and partials.
-
-### Raymond 1.0.0 _(June 09, 2015)_
-
-- This is the first release. Raymond supports almost all handlebars features. See https://github.com/aymerick/raymond#limitations for a list of differences with the javascript implementation.

vendor/github.com/aymerick/raymond/LICENSE

@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Aymerick JEHANNE
-
-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/aymerick/raymond/VERSION

@@ -1 +0,0 @@
-2.0.1

vendor/github.com/aymerick/raymond/ast/node.go

@@ -1,785 +0,0 @@
-// Package ast provides structures to represent a handlebars Abstract Syntax Tree, and a Visitor interface to visit that tree.
-package ast
-
-import (
-	"fmt"
-	"strconv"
-)
-
-// References:
-//   - https://github.com/wycats/handlebars.js/blob/master/lib/handlebars/compiler/ast.js
-//   - https://github.com/wycats/handlebars.js/blob/master/docs/compiler-api.md
-//   - https://github.com/golang/go/blob/master/src/text/template/parse/node.go
-
-// Node is an element in the AST.
-type Node interface {
-	// node type
-	Type() NodeType
-
-	// location of node in original input string
-	Location() Loc
-
-	// string representation, used for debugging
-	String() string
-
-	// accepts visitor
-	Accept(Visitor) interface{}
-}
-
-// Visitor is the interface to visit an AST.
-type Visitor interface {
-	VisitProgram(*Program) interface{}
-
-	// statements
-	VisitMustache(*MustacheStatement) interface{}
-	VisitBlock(*BlockStatement) interface{}
-	VisitPartial(*PartialStatement) interface{}
-	VisitContent(*ContentStatement) interface{}
-	VisitComment(*CommentStatement) interface{}
-
-	// expressions
-	VisitExpression(*Expression) interface{}
-	VisitSubExpression(*SubExpression) interface{}
-	VisitPath(*PathExpression) interface{}
-
-	// literals
-	VisitString(*StringLiteral) interface{}
-	VisitBoolean(*BooleanLiteral) interface{}
-	VisitNumber(*NumberLiteral) interface{}
-
-	// miscellaneous
-	VisitHash(*Hash) interface{}
-	VisitHashPair(*HashPair) interface{}
-}
-
-// NodeType represents an AST Node type.
-type NodeType int
-
-// Type returns itself, and permits struct includers to satisfy that part of Node interface.
-func (t NodeType) Type() NodeType {
-	return t
-}
-
-const (
-	// NodeProgram is the program node
-	NodeProgram NodeType = iota
-
-	// NodeMustache is the mustache statement node
-	NodeMustache
-
-	// NodeBlock is the block statement node
-	NodeBlock
-
-	// NodePartial is the partial statement node
-	NodePartial
-
-	// NodeContent is the content statement node
-	NodeContent
-
-	// NodeComment is the comment statement node
-	NodeComment
-
-	// NodeExpression is the expression node
-	NodeExpression
-
-	// NodeSubExpression is the subexpression node
-	NodeSubExpression
-
-	// NodePath is the expression path node
-	NodePath
-
-	// NodeBoolean is the literal boolean node
-	NodeBoolean
-
-	// NodeNumber is the literal number node
-	NodeNumber
-
-	// NodeString is the literal string node
-	NodeString
-
-	// NodeHash is the hash node
-	NodeHash
-
-	// NodeHashPair is the hash pair node
-	NodeHashPair
-)
-
-// Loc represents the position of a parsed node in source file.
-type Loc struct {
-	Pos  int // Byte position
-	Line int // Line number
-}
-
-// Location returns itself, and permits struct includers to satisfy that part of Node interface.
-func (l Loc) Location() Loc {
-	return l
-}
-
-// Strip describes node whitespace management.
-type Strip struct {
-	Open  bool
-	Close bool
-
-	OpenStandalone   bool
-	CloseStandalone  bool
-	InlineStandalone bool
-}
-
-// NewStrip instanciates a Strip for given open and close mustaches.
-func NewStrip(openStr, closeStr string) *Strip {
-	return &Strip{
-		Open:  (len(openStr) > 2) && openStr[2] == '~',
-		Close: (len(closeStr) > 2) && closeStr[len(closeStr)-3] == '~',
-	}
-}
-
-// NewStripForStr instanciates a Strip for given tag.
-func NewStripForStr(str string) *Strip {
-	return &Strip{
-		Open:  (len(str) > 2) && str[2] == '~',
-		Close: (len(str) > 2) && str[len(str)-3] == '~',
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (s *Strip) String() string {
-	return fmt.Sprintf("Open: %t, Close: %t, OpenStandalone: %t, CloseStandalone: %t, InlineStandalone: %t", s.Open, s.Close, s.OpenStandalone, s.CloseStandalone, s.InlineStandalone)
-}
-
-//
-// Program
-//
-
-// Program represents a program node.
-type Program struct {
-	NodeType
-	Loc
-
-	Body        []Node // [ Statement ... ]
-	BlockParams []string
-	Chained     bool
-
-	// whitespace management
-	Strip *Strip
-}
-
-// NewProgram instanciates a new program node.
-func NewProgram(pos int, line int) *Program {
-	return &Program{
-		NodeType: NodeProgram,
-		Loc:      Loc{pos, line},
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *Program) String() string {
-	return fmt.Sprintf("Program{Pos: %d}", node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *Program) Accept(visitor Visitor) interface{} {
-	return visitor.VisitProgram(node)
-}
-
-// AddStatement adds given statement to program.
-func (node *Program) AddStatement(statement Node) {
-	node.Body = append(node.Body, statement)
-}
-
-//
-// Mustache Statement
-//
-
-// MustacheStatement represents a mustache node.
-type MustacheStatement struct {
-	NodeType
-	Loc
-
-	Unescaped  bool
-	Expression *Expression
-
-	// whitespace management
-	Strip *Strip
-}
-
-// NewMustacheStatement instanciates a new mustache node.
-func NewMustacheStatement(pos int, line int, unescaped bool) *MustacheStatement {
-	return &MustacheStatement{
-		NodeType:  NodeMustache,
-		Loc:       Loc{pos, line},
-		Unescaped: unescaped,
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *MustacheStatement) String() string {
-	return fmt.Sprintf("Mustache{Pos: %d}", node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *MustacheStatement) Accept(visitor Visitor) interface{} {
-	return visitor.VisitMustache(node)
-}
-
-//
-// Block Statement
-//
-
-// BlockStatement represents a block node.
-type BlockStatement struct {
-	NodeType
-	Loc
-
-	Expression *Expression
-
-	Program *Program
-	Inverse *Program
-
-	// whitespace management
-	OpenStrip    *Strip
-	InverseStrip *Strip
-	CloseStrip   *Strip
-}
-
-// NewBlockStatement instanciates a new block node.
-func NewBlockStatement(pos int, line int) *BlockStatement {
-	return &BlockStatement{
-		NodeType: NodeBlock,
-		Loc:      Loc{pos, line},
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *BlockStatement) String() string {
-	return fmt.Sprintf("Block{Pos: %d}", node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *BlockStatement) Accept(visitor Visitor) interface{} {
-	return visitor.VisitBlock(node)
-}
-
-//
-// Partial Statement
-//
-
-// PartialStatement represents a partial node.
-type PartialStatement struct {
-	NodeType
-	Loc
-
-	Name   Node   // PathExpression | SubExpression
-	Params []Node // [ Expression ... ]
-	Hash   *Hash
-
-	// whitespace management
-	Strip  *Strip
-	Indent string
-}
-
-// NewPartialStatement instanciates a new partial node.
-func NewPartialStatement(pos int, line int) *PartialStatement {
-	return &PartialStatement{
-		NodeType: NodePartial,
-		Loc:      Loc{pos, line},
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *PartialStatement) String() string {
-	return fmt.Sprintf("Partial{Name:%s, Pos:%d}", node.Name, node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *PartialStatement) Accept(visitor Visitor) interface{} {
-	return visitor.VisitPartial(node)
-}
-
-//
-// Content Statement
-//
-
-// ContentStatement represents a content node.
-type ContentStatement struct {
-	NodeType
-	Loc
-
-	Value    string
-	Original string
-
-	// whitespace management
-	RightStripped bool
-	LeftStripped  bool
-}
-
-// NewContentStatement instanciates a new content node.
-func NewContentStatement(pos int, line int, val string) *ContentStatement {
-	return &ContentStatement{
-		NodeType: NodeContent,
-		Loc:      Loc{pos, line},
-
-		Value:    val,
-		Original: val,
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *ContentStatement) String() string {
-	return fmt.Sprintf("Content{Value:'%s', Pos:%d}", node.Value, node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *ContentStatement) Accept(visitor Visitor) interface{} {
-	return visitor.VisitContent(node)
-}
-
-//
-// Comment Statement
-//
-
-// CommentStatement represents a comment node.
-type CommentStatement struct {
-	NodeType
-	Loc
-
-	Value string
-
-	// whitespace management
-	Strip *Strip
-}
-
-// NewCommentStatement instanciates a new comment node.
-func NewCommentStatement(pos int, line int, val string) *CommentStatement {
-	return &CommentStatement{
-		NodeType: NodeComment,
-		Loc:      Loc{pos, line},
-
-		Value: val,
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *CommentStatement) String() string {
-	return fmt.Sprintf("Comment{Value:'%s', Pos:%d}", node.Value, node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *CommentStatement) Accept(visitor Visitor) interface{} {
-	return visitor.VisitComment(node)
-}
-
-//
-// Expression
-//
-
-// Expression represents an expression node.
-type Expression struct {
-	NodeType
-	Loc
-
-	Path   Node   // PathExpression | StringLiteral | BooleanLiteral | NumberLiteral
-	Params []Node // [ Expression ... ]
-	Hash   *Hash
-}
-
-// NewExpression instanciates a new expression node.
-func NewExpression(pos int, line int) *Expression {
-	return &Expression{
-		NodeType: NodeExpression,
-		Loc:      Loc{pos, line},
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *Expression) String() string {
-	return fmt.Sprintf("Expr{Path:%s, Pos:%d}", node.Path, node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *Expression) Accept(visitor Visitor) interface{} {
-	return visitor.VisitExpression(node)
-}
-
-// HelperName returns helper name, or an empty string if this expression can't be a helper.
-func (node *Expression) HelperName() string {
-	path, ok := node.Path.(*PathExpression)
-	if !ok {
-		return ""
-	}
-
-	if path.Data || (len(path.Parts) != 1) || (path.Depth > 0) || path.Scoped {
-		return ""
-	}
-
-	return path.Parts[0]
-}
-
-// FieldPath returns path expression representing a field path, or nil if this is not a field path.
-func (node *Expression) FieldPath() *PathExpression {
-	path, ok := node.Path.(*PathExpression)
-	if !ok {
-		return nil
-	}
-
-	return path
-}
-
-// LiteralStr returns the string representation of literal value, with a boolean set to false if this is not a literal.
-func (node *Expression) LiteralStr() (string, bool) {
-	return LiteralStr(node.Path)
-}
-
-// Canonical returns the canonical form of expression node as a string.
-func (node *Expression) Canonical() string {
-	if str, ok := HelperNameStr(node.Path); ok {
-		return str
-	}
-
-	return ""
-}
-
-// HelperNameStr returns the string representation of a helper name, with a boolean set to false if this is not a valid helper name.
-//
-// helperName : path | dataName | STRING | NUMBER | BOOLEAN | UNDEFINED | NULL
-func HelperNameStr(node Node) (string, bool) {
-	// PathExpression
-	if str, ok := PathExpressionStr(node); ok {
-		return str, ok
-	}
-
-	// Literal
-	if str, ok := LiteralStr(node); ok {
-		return str, ok
-	}
-
-	return "", false
-}
-
-// PathExpressionStr returns the string representation of path expression value, with a boolean set to false if this is not a path expression.
-func PathExpressionStr(node Node) (string, bool) {
-	if path, ok := node.(*PathExpression); ok {
-		result := path.Original
-
-		// "[foo bar]"" => "foo bar"
-		if (len(result) >= 2) && (result[0] == '[') && (result[len(result)-1] == ']') {
-			result = result[1 : len(result)-1]
-		}
-
-		return result, true
-	}
-
-	return "", false
-}
-
-// LiteralStr returns the string representation of literal value, with a boolean set to false if this is not a literal.
-func LiteralStr(node Node) (string, bool) {
-	if lit, ok := node.(*StringLiteral); ok {
-		return lit.Value, true
-	}
-
-	if lit, ok := node.(*BooleanLiteral); ok {
-		return lit.Canonical(), true
-	}
-
-	if lit, ok := node.(*NumberLiteral); ok {
-		return lit.Canonical(), true
-	}
-
-	return "", false
-}
-
-//
-// SubExpression
-//
-
-// SubExpression represents a subexpression node.
-type SubExpression struct {
-	NodeType
-	Loc
-
-	Expression *Expression
-}
-
-// NewSubExpression instanciates a new subexpression node.
-func NewSubExpression(pos int, line int) *SubExpression {
-	return &SubExpression{
-		NodeType: NodeSubExpression,
-		Loc:      Loc{pos, line},
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *SubExpression) String() string {
-	return fmt.Sprintf("Sexp{Path:%s, Pos:%d}", node.Expression.Path, node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *SubExpression) Accept(visitor Visitor) interface{} {
-	return visitor.VisitSubExpression(node)
-}
-
-//
-// Path Expression
-//
-
-// PathExpression represents a path expression node.
-type PathExpression struct {
-	NodeType
-	Loc
-
-	Original string
-	Depth    int
-	Parts    []string
-	Data     bool
-	Scoped   bool
-}
-
-// NewPathExpression instanciates a new path expression node.
-func NewPathExpression(pos int, line int, data bool) *PathExpression {
-	result := &PathExpression{
-		NodeType: NodePath,
-		Loc:      Loc{pos, line},
-
-		Data: data,
-	}
-
-	if data {
-		result.Original = "@"
-	}
-
-	return result
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *PathExpression) String() string {
-	return fmt.Sprintf("Path{Original:'%s', Pos:%d}", node.Original, node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *PathExpression) Accept(visitor Visitor) interface{} {
-	return visitor.VisitPath(node)
-}
-
-// Part adds path part.
-func (node *PathExpression) Part(part string) {
-	node.Original += part
-
-	switch part {
-	case "..":
-		node.Depth++
-		node.Scoped = true
-	case ".", "this":
-		node.Scoped = true
-	default:
-		node.Parts = append(node.Parts, part)
-	}
-}
-
-// Sep adds path separator.
-func (node *PathExpression) Sep(separator string) {
-	node.Original += separator
-}
-
-// IsDataRoot returns true if path expression is @root.
-func (node *PathExpression) IsDataRoot() bool {
-	return node.Data && (node.Parts[0] == "root")
-}
-
-//
-// String Literal
-//
-
-// StringLiteral represents a string node.
-type StringLiteral struct {
-	NodeType
-	Loc
-
-	Value string
-}
-
-// NewStringLiteral instanciates a new string node.
-func NewStringLiteral(pos int, line int, val string) *StringLiteral {
-	return &StringLiteral{
-		NodeType: NodeString,
-		Loc:      Loc{pos, line},
-
-		Value: val,
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *StringLiteral) String() string {
-	return fmt.Sprintf("String{Value:'%s', Pos:%d}", node.Value, node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *StringLiteral) Accept(visitor Visitor) interface{} {
-	return visitor.VisitString(node)
-}
-
-//
-// Boolean Literal
-//
-
-// BooleanLiteral represents a boolean node.
-type BooleanLiteral struct {
-	NodeType
-	Loc
-
-	Value    bool
-	Original string
-}
-
-// NewBooleanLiteral instanciates a new boolean node.
-func NewBooleanLiteral(pos int, line int, val bool, original string) *BooleanLiteral {
-	return &BooleanLiteral{
-		NodeType: NodeBoolean,
-		Loc:      Loc{pos, line},
-
-		Value:    val,
-		Original: original,
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *BooleanLiteral) String() string {
-	return fmt.Sprintf("Boolean{Value:%s, Pos:%d}", node.Canonical(), node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *BooleanLiteral) Accept(visitor Visitor) interface{} {
-	return visitor.VisitBoolean(node)
-}
-
-// Canonical returns the canonical form of boolean node as a string (ie. "true" | "false").
-func (node *BooleanLiteral) Canonical() string {
-	if node.Value {
-		return "true"
-	}
-
-	return "false"
-}
-
-//
-// Number Literal
-//
-
-// NumberLiteral represents a number node.
-type NumberLiteral struct {
-	NodeType
-	Loc
-
-	Value    float64
-	IsInt    bool
-	Original string
-}
-
-// NewNumberLiteral instanciates a new number node.
-func NewNumberLiteral(pos int, line int, val float64, isInt bool, original string) *NumberLiteral {
-	return &NumberLiteral{
-		NodeType: NodeNumber,
-		Loc:      Loc{pos, line},
-
-		Value:    val,
-		IsInt:    isInt,
-		Original: original,
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *NumberLiteral) String() string {
-	return fmt.Sprintf("Number{Value:%s, Pos:%d}", node.Canonical(), node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *NumberLiteral) Accept(visitor Visitor) interface{} {
-	return visitor.VisitNumber(node)
-}
-
-// Canonical returns the canonical form of number node as a string (eg: "12", "-1.51").
-func (node *NumberLiteral) Canonical() string {
-	prec := -1
-	if node.IsInt {
-		prec = 0
-	}
-	return strconv.FormatFloat(node.Value, 'f', prec, 64)
-}
-
-// Number returns an integer or a float.
-func (node *NumberLiteral) Number() interface{} {
-	if node.IsInt {
-		return int(node.Value)
-	}
-
-	return node.Value
-}
-
-//
-// Hash
-//
-
-// Hash represents a hash node.
-type Hash struct {
-	NodeType
-	Loc
-
-	Pairs []*HashPair
-}
-
-// NewHash instanciates a new hash node.
-func NewHash(pos int, line int) *Hash {
-	return &Hash{
-		NodeType: NodeHash,
-		Loc:      Loc{pos, line},
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *Hash) String() string {
-	result := fmt.Sprintf("Hash{[%d", node.Loc.Pos)
-
-	for i, p := range node.Pairs {
-		if i > 0 {
-			result += ", "
-		}
-		result += p.String()
-	}
-
-	return result + fmt.Sprintf("], Pos:%d}", node.Loc.Pos)
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *Hash) Accept(visitor Visitor) interface{} {
-	return visitor.VisitHash(node)
-}
-
-//
-// HashPair
-//
-
-// HashPair represents a hash pair node.
-type HashPair struct {
-	NodeType
-	Loc
-
-	Key string
-	Val Node // Expression
-}
-
-// NewHashPair instanciates a new hash pair node.
-func NewHashPair(pos int, line int) *HashPair {
-	return &HashPair{
-		NodeType: NodeHashPair,
-		Loc:      Loc{pos, line},
-	}
-}
-
-// String returns a string representation of receiver that can be used for debugging.
-func (node *HashPair) String() string {
-	return node.Key + "=" + node.Val.String()
-}
-
-// Accept is the receiver entry point for visitors.
-func (node *HashPair) Accept(visitor Visitor) interface{} {
-	return visitor.VisitHashPair(node)
-}

vendor/github.com/aymerick/raymond/ast/print.go

@@ -1,279 +0,0 @@
-package ast
-
-import (
-	"fmt"
-	"strings"
-)
-
-// printVisitor implements the Visitor interface to print a AST.
-type printVisitor struct {
-	buf   string
-	depth int
-
-	original bool
-	inBlock  bool
-}
-
-func newPrintVisitor() *printVisitor {
-	return &printVisitor{}
-}
-
-// Print returns a string representation of given AST, that can be used for debugging purpose.
-func Print(node Node) string {
-	visitor := newPrintVisitor()
-	node.Accept(visitor)
-	return visitor.output()
-}
-
-func (v *printVisitor) output() string {
-	return v.buf
-}
-
-func (v *printVisitor) indent() {
-	for i := 0; i < v.depth; {
-		v.buf += "  "
-		i++
-	}
-}
-
-func (v *printVisitor) str(val string) {
-	v.buf += val
-}
-
-func (v *printVisitor) nl() {
-	v.str("\n")
-}
-
-func (v *printVisitor) line(val string) {
-	v.indent()
-	v.str(val)
-	v.nl()
-}
-
-//
-// Visitor interface
-//
-
-// Statements
-
-// VisitProgram implements corresponding Visitor interface method
-func (v *printVisitor) VisitProgram(node *Program) interface{} {
-	if len(node.BlockParams) > 0 {
-		v.line("BLOCK PARAMS: [ " + strings.Join(node.BlockParams, " ") + " ]")
-	}
-
-	for _, n := range node.Body {
-		n.Accept(v)
-	}
-
-	return nil
-}
-
-// VisitMustache implements corresponding Visitor interface method
-func (v *printVisitor) VisitMustache(node *MustacheStatement) interface{} {
-	v.indent()
-	v.str("{{ ")
-
-	node.Expression.Accept(v)
-
-	v.str(" }}")
-	v.nl()
-
-	return nil
-}
-
-// VisitBlock implements corresponding Visitor interface method
-func (v *printVisitor) VisitBlock(node *BlockStatement) interface{} {
-	v.inBlock = true
-
-	v.line("BLOCK:")
-	v.depth++
-
-	node.Expression.Accept(v)
-
-	if node.Program != nil {
-		v.line("PROGRAM:")
-		v.depth++
-		node.Program.Accept(v)
-		v.depth--
-	}
-
-	if node.Inverse != nil {
-		// if node.Program != nil {
-		// 	v.depth++
-		// }
-
-		v.line("{{^}}")
-		v.depth++
-		node.Inverse.Accept(v)
-		v.depth--
-
-		// if node.Program != nil {
-		// 	v.depth--
-		// }
-	}
-
-	v.inBlock = false
-
-	return nil
-}
-
-// VisitPartial implements corresponding Visitor interface method
-func (v *printVisitor) VisitPartial(node *PartialStatement) interface{} {
-	v.indent()
-	v.str("{{> PARTIAL:")
-
-	v.original = true
-	node.Name.Accept(v)
-	v.original = false
-
-	if len(node.Params) > 0 {
-		v.str(" ")
-		node.Params[0].Accept(v)
-	}
-
-	// hash
-	if node.Hash != nil {
-		v.str(" ")
-		node.Hash.Accept(v)
-	}
-
-	v.str(" }}")
-	v.nl()
-
-	return nil
-}
-
-// VisitContent implements corresponding Visitor interface method
-func (v *printVisitor) VisitContent(node *ContentStatement) interface{} {
-	v.line("CONTENT[ '" + node.Value + "' ]")
-
-	return nil
-}
-
-// VisitComment implements corresponding Visitor interface method
-func (v *printVisitor) VisitComment(node *CommentStatement) interface{} {
-	v.line("{{! '" + node.Value + "' }}")
-
-	return nil
-}
-
-// Expressions
-
-// VisitExpression implements corresponding Visitor interface method
-func (v *printVisitor) VisitExpression(node *Expression) interface{} {
-	if v.inBlock {
-		v.indent()
-	}
-
-	// path
-	node.Path.Accept(v)
-
-	// params
-	v.str(" [")
-	for i, n := range node.Params {
-		if i > 0 {
-			v.str(", ")
-		}
-		n.Accept(v)
-	}
-	v.str("]")
-
-	// hash
-	if node.Hash != nil {
-		v.str(" ")
-		node.Hash.Accept(v)
-	}
-
-	if v.inBlock {
-		v.nl()
-	}
-
-	return nil
-}
-
-// VisitSubExpression implements corresponding Visitor interface method
-func (v *printVisitor) VisitSubExpression(node *SubExpression) interface{} {
-	node.Expression.Accept(v)
-
-	return nil
-}
-
-// VisitPath implements corresponding Visitor interface method
-func (v *printVisitor) VisitPath(node *PathExpression) interface{} {
-	if v.original {
-		v.str(node.Original)
-	} else {
-		path := strings.Join(node.Parts, "/")
-
-		result := ""
-		if node.Data {
-			result += "@"
-		}
-
-		v.str(result + "PATH:" + path)
-	}
-
-	return nil
-}
-
-// Literals
-
-// VisitString implements corresponding Visitor interface method
-func (v *printVisitor) VisitString(node *StringLiteral) interface{} {
-	if v.original {
-		v.str(node.Value)
-	} else {
-		v.str("\"" + node.Value + "\"")
-	}
-
-	return nil
-}
-
-// VisitBoolean implements corresponding Visitor interface method
-func (v *printVisitor) VisitBoolean(node *BooleanLiteral) interface{} {
-	if v.original {
-		v.str(node.Original)
-	} else {
-		v.str(fmt.Sprintf("BOOLEAN{%s}", node.Canonical()))
-	}
-
-	return nil
-}
-
-// VisitNumber implements corresponding Visitor interface method
-func (v *printVisitor) VisitNumber(node *NumberLiteral) interface{} {
-	if v.original {
-		v.str(node.Original)
-	} else {
-		v.str(fmt.Sprintf("NUMBER{%s}", node.Canonical()))
-	}
-
-	return nil
-}
-
-// Miscellaneous
-
-// VisitHash implements corresponding Visitor interface method
-func (v *printVisitor) VisitHash(node *Hash) interface{} {
-	v.str("HASH{")
-
-	for i, p := range node.Pairs {
-		if i > 0 {
-			v.str(", ")
-		}
-		p.Accept(v)
-	}
-
-	v.str("}")
-
-	return nil
-}
-
-// VisitHashPair implements corresponding Visitor interface method
-func (v *printVisitor) VisitHashPair(node *HashPair) interface{} {
-	v.str(node.Key + "=")
-	node.Val.Accept(v)
-
-	return nil
-}

vendor/github.com/aymerick/raymond/data_frame.go

@@ -1,95 +0,0 @@
-package raymond
-
-import "reflect"
-
-// DataFrame represents a private data frame.
-//
-// Cf. private variables documentation at: http://handlebarsjs.com/block_helpers.html
-type DataFrame struct {
-	parent *DataFrame
-	data   map[string]interface{}
-}
-
-// NewDataFrame instanciates a new private data frame.
-func NewDataFrame() *DataFrame {
-	return &DataFrame{
-		data: make(map[string]interface{}),
-	}
-}
-
-// Copy instanciates a new private data frame with receiver as parent.
-func (p *DataFrame) Copy() *DataFrame {
-	result := NewDataFrame()
-
-	for k, v := range p.data {
-		result.data[k] = v
-	}
-
-	result.parent = p
-
-	return result
-}
-
-// newIterDataFrame instanciates a new private data frame with receiver as parent and with iteration data set (@index, @key, @first, @last)
-func (p *DataFrame) newIterDataFrame(length int, i int, key interface{}) *DataFrame {
-	result := p.Copy()
-
-	result.Set("index", i)
-	result.Set("key", key)
-	result.Set("first", i == 0)
-	result.Set("last", i == length-1)
-
-	return result
-}
-
-// Set sets a data value.
-func (p *DataFrame) Set(key string, val interface{}) {
-	p.data[key] = val
-}
-
-// Get gets a data value.
-func (p *DataFrame) Get(key string) interface{} {
-	return p.find([]string{key})
-}
-
-// find gets a deep data value
-//
-// @todo This is NOT consistent with the way we resolve data in template (cf. `evalDataPathExpression()`) ! FIX THAT !
-func (p *DataFrame) find(parts []string) interface{} {
-	data := p.data
-
-	for i, part := range parts {
-		val := data[part]
-		if val == nil {
-			return nil
-		}
-
-		if i == len(parts)-1 {
-			// found
-			return val
-		}
-
-		valValue := reflect.ValueOf(val)
-		if valValue.Kind() != reflect.Map {
-			// not found
-			return nil
-		}
-
-		// continue
-		data = mapStringInterface(valValue)
-	}
-
-	// not found
-	return nil
-}
-
-// mapStringInterface converts any `map` to `map[string]interface{}`
-func mapStringInterface(value reflect.Value) map[string]interface{} {
-	result := make(map[string]interface{})
-
-	for _, key := range value.MapKeys() {
-		result[strValue(key)] = value.MapIndex(key).Interface()
-	}
-
-	return result
-}

vendor/github.com/aymerick/raymond/escape.go

@@ -1,65 +0,0 @@
-package raymond
-
-import (
-	"bytes"
-	"strings"
-)
-
-//
-// That whole file is borrowed from https://github.com/golang/go/tree/master/src/html/escape.go
-//
-// With changes:
-//    &#39 => '
-//    &#34 => "
-//
-// To stay in sync with JS implementation, and make mustache tests pass.
-//
-
-type writer interface {
-	WriteString(string) (int, error)
-}
-
-const escapedChars = `&'<>"`
-
-func escape(w writer, s string) error {
-	i := strings.IndexAny(s, escapedChars)
-	for i != -1 {
-		if _, err := w.WriteString(s[:i]); err != nil {
-			return err
-		}
-		var esc string
-		switch s[i] {
-		case '&':
-			esc = "&amp;"
-		case '\'':
-			esc = "&apos;"
-		case '<':
-			esc = "&lt;"
-		case '>':
-			esc = "&gt;"
-		case '"':
-			esc = "&quot;"
-		default:
-			panic("unrecognized escape character")
-		}
-		s = s[i+1:]
-		if _, err := w.WriteString(esc); err != nil {
-			return err
-		}
-		i = strings.IndexAny(s, escapedChars)
-	}
-	_, err := w.WriteString(s)
-	return err
-}
-
-// Escape escapes special HTML characters.
-//
-// It can be used by helpers that return a SafeString and that need to escape some content by themselves.
-func Escape(s string) string {
-	if strings.IndexAny(s, escapedChars) == -1 {
-		return s
-	}
-	var buf bytes.Buffer
-	escape(&buf, s)
-	return buf.String()
-}

vendor/github.com/aymerick/raymond/helper.go

@@ -1,382 +0,0 @@
-package raymond
-
-import (
-	"fmt"
-	"log"
-	"reflect"
-	"sync"
-)
-
-// Options represents the options argument provided to helpers and context functions.
-type Options struct {
-	// evaluation visitor
-	eval *evalVisitor
-
-	// params
-	params []interface{}
-	hash   map[string]interface{}
-}
-
-// helpers stores all globally registered helpers
-var helpers = make(map[string]reflect.Value)
-
-// protects global helpers
-var helpersMutex sync.RWMutex
-
-func init() {
-	// register builtin helpers
-	RegisterHelper("if", ifHelper)
-	RegisterHelper("unless", unlessHelper)
-	RegisterHelper("with", withHelper)
-	RegisterHelper("each", eachHelper)
-	RegisterHelper("log", logHelper)
-	RegisterHelper("lookup", lookupHelper)
-	RegisterHelper("equal", equalHelper)
-}
-
-// RegisterHelper registers a global helper. That helper will be available to all templates.
-func RegisterHelper(name string, helper interface{}) {
-	helpersMutex.Lock()
-	defer helpersMutex.Unlock()
-
-	if helpers[name] != zero {
-		panic(fmt.Errorf("Helper already registered: %s", name))
-	}
-
-	val := reflect.ValueOf(helper)
-	ensureValidHelper(name, val)
-
-	helpers[name] = val
-}
-
-// RegisterHelpers registers several global helpers. Those helpers will be available to all templates.
-func RegisterHelpers(helpers map[string]interface{}) {
-	for name, helper := range helpers {
-		RegisterHelper(name, helper)
-	}
-}
-
-// ensureValidHelper panics if given helper is not valid
-func ensureValidHelper(name string, funcValue reflect.Value) {
-	if funcValue.Kind() != reflect.Func {
-		panic(fmt.Errorf("Helper must be a function: %s", name))
-	}
-
-	funcType := funcValue.Type()
-
-	if funcType.NumOut() != 1 {
-		panic(fmt.Errorf("Helper function must return a string or a SafeString: %s", name))
-	}
-
-	// @todo Check if first returned value is a string, SafeString or interface{} ?
-}
-
-// findHelper finds a globally registered helper
-func findHelper(name string) reflect.Value {
-	helpersMutex.RLock()
-	defer helpersMutex.RUnlock()
-
-	return helpers[name]
-}
-
-// newOptions instanciates a new Options
-func newOptions(eval *evalVisitor, params []interface{}, hash map[string]interface{}) *Options {
-	return &Options{
-		eval:   eval,
-		params: params,
-		hash:   hash,
-	}
-}
-
-// newEmptyOptions instanciates a new empty Options
-func newEmptyOptions(eval *evalVisitor) *Options {
-	return &Options{
-		eval: eval,
-		hash: make(map[string]interface{}),
-	}
-}
-
-//
-// Context Values
-//
-
-// Value returns field value from current context.
-func (options *Options) Value(name string) interface{} {
-	value := options.eval.evalField(options.eval.curCtx(), name, false)
-	if !value.IsValid() {
-		return nil
-	}
-
-	return value.Interface()
-}
-
-// ValueStr returns string representation of field value from current context.
-func (options *Options) ValueStr(name string) string {
-	return Str(options.Value(name))
-}
-
-// Ctx returns current evaluation context.
-func (options *Options) Ctx() interface{} {
-	return options.eval.curCtx().Interface()
-}
-
-//
-// Hash Arguments
-//
-
-// HashProp returns hash property.
-func (options *Options) HashProp(name string) interface{} {
-	return options.hash[name]
-}
-
-// HashStr returns string representation of hash property.
-func (options *Options) HashStr(name string) string {
-	return Str(options.hash[name])
-}
-
-// Hash returns entire hash.
-func (options *Options) Hash() map[string]interface{} {
-	return options.hash
-}
-
-//
-// Parameters
-//
-
-// Param returns parameter at given position.
-func (options *Options) Param(pos int) interface{} {
-	if len(options.params) > pos {
-		return options.params[pos]
-	}
-
-	return nil
-}
-
-// ParamStr returns string representation of parameter at given position.
-func (options *Options) ParamStr(pos int) string {
-	return Str(options.Param(pos))
-}
-
-// Params returns all parameters.
-func (options *Options) Params() []interface{} {
-	return options.params
-}
-
-//
-// Private data
-//
-
-// Data returns private data value.
-func (options *Options) Data(name string) interface{} {
-	return options.eval.dataFrame.Get(name)
-}
-
-// DataStr returns string representation of private data value.
-func (options *Options) DataStr(name string) string {
-	return Str(options.eval.dataFrame.Get(name))
-}
-
-// DataFrame returns current private data frame.
-func (options *Options) DataFrame() *DataFrame {
-	return options.eval.dataFrame
-}
-
-// NewDataFrame instanciates a new data frame that is a copy of current evaluation data frame.
-//
-// Parent of returned data frame is set to current evaluation data frame.
-func (options *Options) NewDataFrame() *DataFrame {
-	return options.eval.dataFrame.Copy()
-}
-
-// newIterDataFrame instanciates a new data frame and set iteration specific vars
-func (options *Options) newIterDataFrame(length int, i int, key interface{}) *DataFrame {
-	return options.eval.dataFrame.newIterDataFrame(length, i, key)
-}
-
-//
-// Evaluation
-//
-
-// evalBlock evaluates block with given context, private data and iteration key
-func (options *Options) evalBlock(ctx interface{}, data *DataFrame, key interface{}) string {
-	result := ""
-
-	if block := options.eval.curBlock(); (block != nil) && (block.Program != nil) {
-		result = options.eval.evalProgram(block.Program, ctx, data, key)
-	}
-
-	return result
-}
-
-// Fn evaluates block with current evaluation context.
-func (options *Options) Fn() string {
-	return options.evalBlock(nil, nil, nil)
-}
-
-// FnCtxData evaluates block with given context and private data frame.
-func (options *Options) FnCtxData(ctx interface{}, data *DataFrame) string {
-	return options.evalBlock(ctx, data, nil)
-}
-
-// FnWith evaluates block with given context.
-func (options *Options) FnWith(ctx interface{}) string {
-	return options.evalBlock(ctx, nil, nil)
-}
-
-// FnData evaluates block with given private data frame.
-func (options *Options) FnData(data *DataFrame) string {
-	return options.evalBlock(nil, data, nil)
-}
-
-// Inverse evaluates "else block".
-func (options *Options) Inverse() string {
-	result := ""
-	if block := options.eval.curBlock(); (block != nil) && (block.Inverse != nil) {
-		result, _ = block.Inverse.Accept(options.eval).(string)
-	}
-
-	return result
-}
-
-// Eval evaluates field for given context.
-func (options *Options) Eval(ctx interface{}, field string) interface{} {
-	if ctx == nil {
-		return nil
-	}
-
-	if field == "" {
-		return nil
-	}
-
-	val := options.eval.evalField(reflect.ValueOf(ctx), field, false)
-	if !val.IsValid() {
-		return nil
-	}
-
-	return val.Interface()
-}
-
-//
-// Misc
-//
-
-// isIncludableZero returns true if 'includeZero' option is set and first param is the number 0
-func (options *Options) isIncludableZero() bool {
-	b, ok := options.HashProp("includeZero").(bool)
-	if ok && b {
-		nb, ok := options.Param(0).(int)
-		if ok && nb == 0 {
-			return true
-		}
-	}
-
-	return false
-}
-
-//
-// Builtin helpers
-//
-
-// #if block helper
-func ifHelper(conditional interface{}, options *Options) interface{} {
-	if options.isIncludableZero() || IsTrue(conditional) {
-		return options.Fn()
-	}
-
-	return options.Inverse()
-}
-
-// #unless block helper
-func unlessHelper(conditional interface{}, options *Options) interface{} {
-	if options.isIncludableZero() || IsTrue(conditional) {
-		return options.Inverse()
-	}
-
-	return options.Fn()
-}
-
-// #with block helper
-func withHelper(context interface{}, options *Options) interface{} {
-	if IsTrue(context) {
-		return options.FnWith(context)
-	}
-
-	return options.Inverse()
-}
-
-// #each block helper
-func eachHelper(context interface{}, options *Options) interface{} {
-	if !IsTrue(context) {
-		return options.Inverse()
-	}
-
-	result := ""
-
-	val := reflect.ValueOf(context)
-	switch val.Kind() {
-	case reflect.Array, reflect.Slice:
-		for i := 0; i < val.Len(); i++ {
-			// computes private data
-			data := options.newIterDataFrame(val.Len(), i, nil)
-
-			// evaluates block
-			result += options.evalBlock(val.Index(i).Interface(), data, i)
-		}
-	case reflect.Map:
-		// note: a go hash is not ordered, so result may vary, this behaviour differs from the JS implementation
-		keys := val.MapKeys()
-		for i := 0; i < len(keys); i++ {
-			key := keys[i].Interface()
-			ctx := val.MapIndex(keys[i]).Interface()
-
-			// computes private data
-			data := options.newIterDataFrame(len(keys), i, key)
-
-			// evaluates block
-			result += options.evalBlock(ctx, data, key)
-		}
-	case reflect.Struct:
-		var exportedFields []int
-
-		// collect exported fields only
-		for i := 0; i < val.NumField(); i++ {
-			if tField := val.Type().Field(i); tField.PkgPath == "" {
-				exportedFields = append(exportedFields, i)
-			}
-		}
-
-		for i, fieldIndex := range exportedFields {
-			key := val.Type().Field(fieldIndex).Name
-			ctx := val.Field(fieldIndex).Interface()
-
-			// computes private data
-			data := options.newIterDataFrame(len(exportedFields), i, key)
-
-			// evaluates block
-			result += options.evalBlock(ctx, data, key)
-		}
-	}
-
-	return result
-}
-
-// #log helper
-func logHelper(message string) interface{} {
-	log.Print(message)
-	return ""
-}
-
-// #lookup helper
-func lookupHelper(obj interface{}, field string, options *Options) interface{} {
-	return Str(options.Eval(obj, field))
-}
-
-// #equal helper
-// Ref: https://github.com/aymerick/raymond/issues/7
-func equalHelper(a interface{}, b interface{}, options *Options) interface{} {
-	if Str(a) == Str(b) {
-		return options.Fn()
-	}
-
-	return ""
-}

vendor/github.com/aymerick/raymond/lexer/lexer.go

@@ -1,639 +0,0 @@
-// Package lexer provides a handlebars tokenizer.
-package lexer
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-// References:
-//   - https://github.com/wycats/handlebars.js/blob/master/src/handlebars.l
-//   - https://github.com/golang/go/blob/master/src/text/template/parse/lex.go
-
-const (
-	// Mustaches detection
-	escapedEscapedOpenMustache  = "\\\\{{"
-	escapedOpenMustache         = "\\{{"
-	openMustache                = "{{"
-	closeMustache               = "}}"
-	closeStripMustache          = "~}}"
-	closeUnescapedStripMustache = "}~}}"
-)
-
-const eof = -1
-
-// lexFunc represents a function that returns the next lexer function.
-type lexFunc func(*Lexer) lexFunc
-
-// Lexer is a lexical analyzer.
-type Lexer struct {
-	input    string     // input to scan
-	name     string     // lexer name, used for testing purpose
-	tokens   chan Token // channel of scanned tokens
-	nextFunc lexFunc    // the next function to execute
-
-	pos   int // current byte position in input string
-	line  int // current line position in input string
-	width int // size of last rune scanned from input string
-	start int // start position of the token we are scanning
-
-	// the shameful contextual properties needed because `nextFunc` is not enough
-	closeComment *regexp.Regexp // regexp to scan close of current comment
-	rawBlock     bool           // are we parsing a raw block content ?
-}
-
-var (
-	lookheadChars        = `[\s` + regexp.QuoteMeta("=~}/)|") + `]`
-	literalLookheadChars = `[\s` + regexp.QuoteMeta("~})") + `]`
-
-	// characters not allowed in an identifier
-	unallowedIDChars = " \n\t!\"#%&'()*+,./;<=>@[\\]^`{|}~"
-
-	// regular expressions
-	rID                  = regexp.MustCompile(`^[^` + regexp.QuoteMeta(unallowedIDChars) + `]+`)
-	rDotID               = regexp.MustCompile(`^\.` + lookheadChars)
-	rTrue                = regexp.MustCompile(`^true` + literalLookheadChars)
-	rFalse               = regexp.MustCompile(`^false` + literalLookheadChars)
-	rOpenRaw             = regexp.MustCompile(`^\{\{\{\{`)
-	rCloseRaw            = regexp.MustCompile(`^\}\}\}\}`)
-	rOpenEndRaw          = regexp.MustCompile(`^\{\{\{\{/`)
-	rOpenEndRawLookAhead = regexp.MustCompile(`\{\{\{\{/`)
-	rOpenUnescaped       = regexp.MustCompile(`^\{\{~?\{`)
-	rCloseUnescaped      = regexp.MustCompile(`^\}~?\}\}`)
-	rOpenBlock           = regexp.MustCompile(`^\{\{~?#`)
-	rOpenEndBlock        = regexp.MustCompile(`^\{\{~?/`)
-	rOpenPartial         = regexp.MustCompile(`^\{\{~?>`)
-	// {{^}} or {{else}}
-	rInverse          = regexp.MustCompile(`^(\{\{~?\^\s*~?\}\}|\{\{~?\s*else\s*~?\}\})`)
-	rOpenInverse      = regexp.MustCompile(`^\{\{~?\^`)
-	rOpenInverseChain = regexp.MustCompile(`^\{\{~?\s*else`)
-	// {{ or {{&
-	rOpen            = regexp.MustCompile(`^\{\{~?&?`)
-	rClose           = regexp.MustCompile(`^~?\}\}`)
-	rOpenBlockParams = regexp.MustCompile(`^as\s+\|`)
-	// {{!--  ... --}}
-	rOpenCommentDash  = regexp.MustCompile(`^\{\{~?!--\s*`)
-	rCloseCommentDash = regexp.MustCompile(`^\s*--~?\}\}`)
-	// {{! ... }}
-	rOpenComment  = regexp.MustCompile(`^\{\{~?!\s*`)
-	rCloseComment = regexp.MustCompile(`^\s*~?\}\}`)
-)
-
-// Scan scans given input.
-//
-// Tokens can then be fetched sequentially thanks to NextToken() function on returned lexer.
-func Scan(input string) *Lexer {
-	return scanWithName(input, "")
-}
-
-// scanWithName scans given input, with a name used for testing
-//
-// Tokens can then be fetched sequentially thanks to NextToken() function on returned lexer.
-func scanWithName(input string, name string) *Lexer {
-	result := &Lexer{
-		input:  input,
-		name:   name,
-		tokens: make(chan Token),
-		line:   1,
-	}
-
-	go result.run()
-
-	return result
-}
-
-// Collect scans and collect all tokens.
-//
-// This should be used for debugging purpose only. You should use Scan() and lexer.NextToken() functions instead.
-func Collect(input string) []Token {
-	var result []Token
-
-	l := Scan(input)
-	for {
-		token := l.NextToken()
-		result = append(result, token)
-
-		if token.Kind == TokenEOF || token.Kind == TokenError {
-			break
-		}
-	}
-
-	return result
-}
-
-// NextToken returns the next scanned token.
-func (l *Lexer) NextToken() Token {
-	result := <-l.tokens
-
-	return result
-}
-
-// run starts lexical analysis
-func (l *Lexer) run() {
-	for l.nextFunc = lexContent; l.nextFunc != nil; {
-		l.nextFunc = l.nextFunc(l)
-	}
-}
-
-// next returns next character from input, or eof of there is nothing left to scan
-func (l *Lexer) next() rune {
-	if l.pos >= len(l.input) {
-		l.width = 0
-		return eof
-	}
-
-	r, w := utf8.DecodeRuneInString(l.input[l.pos:])
-	l.width = w
-	l.pos += l.width
-
-	return r
-}
-
-func (l *Lexer) produce(kind TokenKind, val string) {
-	l.tokens <- Token{kind, val, l.start, l.line}
-
-	// scanning a new token
-	l.start = l.pos
-
-	// update line number
-	l.line += strings.Count(val, "\n")
-}
-
-// emit emits a new scanned token
-func (l *Lexer) emit(kind TokenKind) {
-	l.produce(kind, l.input[l.start:l.pos])
-}
-
-// emitContent emits scanned content
-func (l *Lexer) emitContent() {
-	if l.pos > l.start {
-		l.emit(TokenContent)
-	}
-}
-
-// emitString emits a scanned string
-func (l *Lexer) emitString(delimiter rune) {
-	str := l.input[l.start:l.pos]
-
-	// replace escaped delimiters
-	str = strings.Replace(str, "\\"+string(delimiter), string(delimiter), -1)
-
-	l.produce(TokenString, str)
-}
-
-// peek returns but does not consume the next character in the input
-func (l *Lexer) peek() rune {
-	r := l.next()
-	l.backup()
-	return r
-}
-
-// backup steps back one character
-//
-// WARNING: Can only be called once per call of next
-func (l *Lexer) backup() {
-	l.pos -= l.width
-}
-
-// ignoreskips all characters that have been scanned up to current position
-func (l *Lexer) ignore() {
-	l.start = l.pos
-}
-
-// accept scans the next character if it is included in given string
-func (l *Lexer) accept(valid string) bool {
-	if strings.IndexRune(valid, l.next()) >= 0 {
-		return true
-	}
-
-	l.backup()
-
-	return false
-}
-
-// acceptRun scans all following characters that are part of given string
-func (l *Lexer) acceptRun(valid string) {
-	for strings.IndexRune(valid, l.next()) >= 0 {
-	}
-
-	l.backup()
-}
-
-// errorf emits an error token
-func (l *Lexer) errorf(format string, args ...interface{}) lexFunc {
-	l.tokens <- Token{TokenError, fmt.Sprintf(format, args...), l.start, l.line}
-	return nil
-}
-
-// isString returns true if content at current scanning position starts with given string
-func (l *Lexer) isString(str string) bool {
-	return strings.HasPrefix(l.input[l.pos:], str)
-}
-
-// findRegexp returns the first string from current scanning position that matches given regular expression
-func (l *Lexer) findRegexp(r *regexp.Regexp) string {
-	return r.FindString(l.input[l.pos:])
-}
-
-// indexRegexp returns the index of the first string from current scanning position that matches given regular expression
-//
-// It returns -1 if not found
-func (l *Lexer) indexRegexp(r *regexp.Regexp) int {
-	loc := r.FindStringIndex(l.input[l.pos:])
-	if loc == nil {
-		return -1
-	}
-	return loc[0]
-}
-
-// lexContent scans content (ie: not between mustaches)
-func lexContent(l *Lexer) lexFunc {
-	var next lexFunc
-
-	if l.rawBlock {
-		if i := l.indexRegexp(rOpenEndRawLookAhead); i != -1 {
-			// {{{{/
-			l.rawBlock = false
-			l.pos += i
-
-			next = lexOpenMustache
-		} else {
-			return l.errorf("Unclosed raw block")
-		}
-	} else if l.isString(escapedEscapedOpenMustache) {
-		// \\{{
-
-		// emit content with only one escaped escape
-		l.next()
-		l.emitContent()
-
-		// ignore second escaped escape
-		l.next()
-		l.ignore()
-
-		next = lexContent
-	} else if l.isString(escapedOpenMustache) {
-		// \{{
-		next = lexEscapedOpenMustache
-	} else if str := l.findRegexp(rOpenCommentDash); str != "" {
-		// {{!--
-		l.closeComment = rCloseCommentDash
-
-		next = lexComment
-	} else if str := l.findRegexp(rOpenComment); str != "" {
-		// {{!
-		l.closeComment = rCloseComment
-
-		next = lexComment
-	} else if l.isString(openMustache) {
-		// {{
-		next = lexOpenMustache
-	}
-
-	if next != nil {
-		// emit scanned content
-		l.emitContent()
-
-		// scan next token
-		return next
-	}
-
-	// scan next rune
-	if l.next() == eof {
-		// emit scanned content
-		l.emitContent()
-
-		// this is over
-		l.emit(TokenEOF)
-		return nil
-	}
-
-	// continue content scanning
-	return lexContent
-}
-
-// lexEscapedOpenMustache scans \{{
-func lexEscapedOpenMustache(l *Lexer) lexFunc {
-	// ignore escape character
-	l.next()
-	l.ignore()
-
-	// scan mustaches
-	for l.peek() == '{' {
-		l.next()
-	}
-
-	return lexContent
-}
-
-// lexOpenMustache scans {{
-func lexOpenMustache(l *Lexer) lexFunc {
-	var str string
-	var tok TokenKind
-
-	nextFunc := lexExpression
-
-	if str = l.findRegexp(rOpenEndRaw); str != "" {
-		tok = TokenOpenEndRawBlock
-	} else if str = l.findRegexp(rOpenRaw); str != "" {
-		tok = TokenOpenRawBlock
-		l.rawBlock = true
-	} else if str = l.findRegexp(rOpenUnescaped); str != "" {
-		tok = TokenOpenUnescaped
-	} else if str = l.findRegexp(rOpenBlock); str != "" {
-		tok = TokenOpenBlock
-	} else if str = l.findRegexp(rOpenEndBlock); str != "" {
-		tok = TokenOpenEndBlock
-	} else if str = l.findRegexp(rOpenPartial); str != "" {
-		tok = TokenOpenPartial
-	} else if str = l.findRegexp(rInverse); str != "" {
-		tok = TokenInverse
-		nextFunc = lexContent
-	} else if str = l.findRegexp(rOpenInverse); str != "" {
-		tok = TokenOpenInverse
-	} else if str = l.findRegexp(rOpenInverseChain); str != "" {
-		tok = TokenOpenInverseChain
-	} else if str = l.findRegexp(rOpen); str != "" {
-		tok = TokenOpen
-	} else {
-		// this is rotten
-		panic("Current pos MUST be an opening mustache")
-	}
-
-	l.pos += len(str)
-	l.emit(tok)
-
-	return nextFunc
-}
-
-// lexCloseMustache scans }} or ~}}
-func lexCloseMustache(l *Lexer) lexFunc {
-	var str string
-	var tok TokenKind
-
-	if str = l.findRegexp(rCloseRaw); str != "" {
-		// }}}}
-		tok = TokenCloseRawBlock
-	} else if str = l.findRegexp(rCloseUnescaped); str != "" {
-		// }}}
-		tok = TokenCloseUnescaped
-	} else if str = l.findRegexp(rClose); str != "" {
-		// }}
-		tok = TokenClose
-	} else {
-		// this is rotten
-		panic("Current pos MUST be a closing mustache")
-	}
-
-	l.pos += len(str)
-	l.emit(tok)
-
-	return lexContent
-}
-
-// lexExpression scans inside mustaches
-func lexExpression(l *Lexer) lexFunc {
-	// search close mustache delimiter
-	if l.isString(closeMustache) || l.isString(closeStripMustache) || l.isString(closeUnescapedStripMustache) {
-		return lexCloseMustache
-	}
-
-	// search some patterns before advancing scanning position
-
-	// "as |"
-	if str := l.findRegexp(rOpenBlockParams); str != "" {
-		l.pos += len(str)
-		l.emit(TokenOpenBlockParams)
-		return lexExpression
-	}
-
-	// ..
-	if l.isString("..") {
-		l.pos += len("..")
-		l.emit(TokenID)
-		return lexExpression
-	}
-
-	// .
-	if str := l.findRegexp(rDotID); str != "" {
-		l.pos += len(".")
-		l.emit(TokenID)
-		return lexExpression
-	}
-
-	// true
-	if str := l.findRegexp(rTrue); str != "" {
-		l.pos += len("true")
-		l.emit(TokenBoolean)
-		return lexExpression
-	}
-
-	// false
-	if str := l.findRegexp(rFalse); str != "" {
-		l.pos += len("false")
-		l.emit(TokenBoolean)
-		return lexExpression
-	}
-
-	// let's scan next character
-	switch r := l.next(); {
-	case r == eof:
-		return l.errorf("Unclosed expression")
-	case isIgnorable(r):
-		return lexIgnorable
-	case r == '(':
-		l.emit(TokenOpenSexpr)
-	case r == ')':
-		l.emit(TokenCloseSexpr)
-	case r == '=':
-		l.emit(TokenEquals)
-	case r == '@':
-		l.emit(TokenData)
-	case r == '"' || r == '\'':
-		l.backup()
-		return lexString
-	case r == '/' || r == '.':
-		l.emit(TokenSep)
-	case r == '|':
-		l.emit(TokenCloseBlockParams)
-	case r == '+' || r == '-' || (r >= '0' && r <= '9'):
-		l.backup()
-		return lexNumber
-	case r == '[':
-		return lexPathLiteral
-	case strings.IndexRune(unallowedIDChars, r) < 0:
-		l.backup()
-		return lexIdentifier
-	default:
-		return l.errorf("Unexpected character in expression: '%c'", r)
-	}
-
-	return lexExpression
-}
-
-// lexComment scans {{!-- or {{!
-func lexComment(l *Lexer) lexFunc {
-	if str := l.findRegexp(l.closeComment); str != "" {
-		l.pos += len(str)
-		l.emit(TokenComment)
-
-		return lexContent
-	}
-
-	if r := l.next(); r == eof {
-		return l.errorf("Unclosed comment")
-	}
-
-	return lexComment
-}
-
-// lexIgnorable scans all following ignorable characters
-func lexIgnorable(l *Lexer) lexFunc {
-	for isIgnorable(l.peek()) {
-		l.next()
-	}
-	l.ignore()
-
-	return lexExpression
-}
-
-// lexString scans a string
-func lexString(l *Lexer) lexFunc {
-	// get string delimiter
-	delim := l.next()
-	var prev rune
-
-	// ignore delimiter
-	l.ignore()
-
-	for {
-		r := l.next()
-		if r == eof || r == '\n' {
-			return l.errorf("Unterminated string")
-		}
-
-		if (r == delim) && (prev != '\\') {
-			break
-		}
-
-		prev = r
-	}
-
-	// remove end delimiter
-	l.backup()
-
-	// emit string
-	l.emitString(delim)
-
-	// skip end delimiter
-	l.next()
-	l.ignore()
-
-	return lexExpression
-}
-
-// lexNumber scans a number: decimal, octal, hex, float, or imaginary. This
-// isn't a perfect number scanner - for instance it accepts "." and "0x0.2"
-// and "089" - but when it's wrong the input is invalid and the parser (via
-// strconv) will notice.
-//
-// NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/parse/lex.go
-func lexNumber(l *Lexer) lexFunc {
-	if !l.scanNumber() {
-		return l.errorf("bad number syntax: %q", l.input[l.start:l.pos])
-	}
-	if sign := l.peek(); sign == '+' || sign == '-' {
-		// Complex: 1+2i. No spaces, must end in 'i'.
-		if !l.scanNumber() || l.input[l.pos-1] != 'i' {
-			return l.errorf("bad number syntax: %q", l.input[l.start:l.pos])
-		}
-		l.emit(TokenNumber)
-	} else {
-		l.emit(TokenNumber)
-	}
-	return lexExpression
-}
-
-// scanNumber scans a number
-//
-// NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/parse/lex.go
-func (l *Lexer) scanNumber() bool {
-	// Optional leading sign.
-	l.accept("+-")
-
-	// Is it hex?
-	digits := "0123456789"
-
-	if l.accept("0") && l.accept("xX") {
-		digits = "0123456789abcdefABCDEF"
-	}
-
-	l.acceptRun(digits)
-
-	if l.accept(".") {
-		l.acceptRun(digits)
-	}
-
-	if l.accept("eE") {
-		l.accept("+-")
-		l.acceptRun("0123456789")
-	}
-
-	// Is it imaginary?
-	l.accept("i")
-
-	// Next thing mustn't be alphanumeric.
-	if isAlphaNumeric(l.peek()) {
-		l.next()
-		return false
-	}
-
-	return true
-}
-
-// lexIdentifier scans an ID
-func lexIdentifier(l *Lexer) lexFunc {
-	str := l.findRegexp(rID)
-	if len(str) == 0 {
-		// this is rotten
-		panic("Identifier expected")
-	}
-
-	l.pos += len(str)
-	l.emit(TokenID)
-
-	return lexExpression
-}
-
-// lexPathLiteral scans an [ID]
-func lexPathLiteral(l *Lexer) lexFunc {
-	for {
-		r := l.next()
-		if r == eof || r == '\n' {
-			return l.errorf("Unterminated path literal")
-		}
-
-		if r == ']' {
-			break
-		}
-	}
-
-	l.emit(TokenID)
-
-	return lexExpression
-}
-
-// isIgnorable returns true if given character is ignorable (ie. whitespace of line feed)
-func isIgnorable(r rune) bool {
-	return r == ' ' || r == '\t' || r == '\n'
-}
-
-// isAlphaNumeric reports whether r is an alphabetic, digit, or underscore.
-//
-// NOTE borrowed from https://github.com/golang/go/tree/master/src/text/template/parse/lex.go
-func isAlphaNumeric(r rune) bool {
-	return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r)
-}

vendor/github.com/aymerick/raymond/lexer/token.go

@@ -1,183 +0,0 @@
-package lexer
-
-import "fmt"
-
-const (
-	// TokenError represents an error
-	TokenError TokenKind = iota
-
-	// TokenEOF represents an End Of File
-	TokenEOF
-
-	//
-	// Mustache delimiters
-	//
-
-	// TokenOpen is the OPEN token
-	TokenOpen
-
-	// TokenClose is the CLOSE token
-	TokenClose
-
-	// TokenOpenRawBlock is the OPEN_RAW_BLOCK token
-	TokenOpenRawBlock
-
-	// TokenCloseRawBlock is the CLOSE_RAW_BLOCK token
-	TokenCloseRawBlock
-
-	// TokenOpenEndRawBlock is the END_RAW_BLOCK token
-	TokenOpenEndRawBlock
-
-	// TokenOpenUnescaped is the OPEN_UNESCAPED token
-	TokenOpenUnescaped
-
-	// TokenCloseUnescaped is the CLOSE_UNESCAPED token
-	TokenCloseUnescaped
-
-	// TokenOpenBlock is the OPEN_BLOCK token
-	TokenOpenBlock
-
-	// TokenOpenEndBlock is the OPEN_ENDBLOCK token
-	TokenOpenEndBlock
-
-	// TokenInverse is the INVERSE token
-	TokenInverse
-
-	// TokenOpenInverse is the OPEN_INVERSE token
-	TokenOpenInverse
-
-	// TokenOpenInverseChain is the OPEN_INVERSE_CHAIN token
-	TokenOpenInverseChain
-
-	// TokenOpenPartial is the OPEN_PARTIAL token
-	TokenOpenPartial
-
-	// TokenComment is the COMMENT token
-	TokenComment
-
-	//
-	// Inside mustaches
-	//
-
-	// TokenOpenSexpr is the OPEN_SEXPR token
-	TokenOpenSexpr
-
-	// TokenCloseSexpr is the CLOSE_SEXPR token
-	TokenCloseSexpr
-
-	// TokenEquals is the EQUALS token
-	TokenEquals
-
-	// TokenData is the DATA token
-	TokenData
-
-	// TokenSep is the SEP token
-	TokenSep
-
-	// TokenOpenBlockParams is the OPEN_BLOCK_PARAMS token
-	TokenOpenBlockParams
-
-	// TokenCloseBlockParams is the CLOSE_BLOCK_PARAMS token
-	TokenCloseBlockParams
-
-	//
-	// Tokens with content
-	//
-
-	// TokenContent is the CONTENT token
-	TokenContent
-
-	// TokenID is the ID token
-	TokenID
-
-	// TokenString is the STRING token
-	TokenString
-
-	// TokenNumber is the NUMBER token
-	TokenNumber
-
-	// TokenBoolean is the BOOLEAN token
-	TokenBoolean
-)
-
-const (
-	// Option to generate token position in its string representation
-	dumpTokenPos = false
-
-	// Option to generate values for all token kinds for their string representations
-	dumpAllTokensVal = true
-)
-
-// TokenKind represents a Token type.
-type TokenKind int
-
-// Token represents a scanned token.
-type Token struct {
-	Kind TokenKind // Token kind
-	Val  string    // Token value
-
-	Pos  int // Byte position in input string
-	Line int // Line number in input string
-}
-
-// tokenName permits to display token name given token type
-var tokenName = map[TokenKind]string{
-	TokenError:            "Error",
-	TokenEOF:              "EOF",
-	TokenContent:          "Content",
-	TokenComment:          "Comment",
-	TokenOpen:             "Open",
-	TokenClose:            "Close",
-	TokenOpenUnescaped:    "OpenUnescaped",
-	TokenCloseUnescaped:   "CloseUnescaped",
-	TokenOpenBlock:        "OpenBlock",
-	TokenOpenEndBlock:     "OpenEndBlock",
-	TokenOpenRawBlock:     "OpenRawBlock",
-	TokenCloseRawBlock:    "CloseRawBlock",
-	TokenOpenEndRawBlock:  "OpenEndRawBlock",
-	TokenOpenBlockParams:  "OpenBlockParams",
-	TokenCloseBlockParams: "CloseBlockParams",
-	TokenInverse:          "Inverse",
-	TokenOpenInverse:      "OpenInverse",
-	TokenOpenInverseChain: "OpenInverseChain",
-	TokenOpenPartial:      "OpenPartial",
-	TokenOpenSexpr:        "OpenSexpr",
-	TokenCloseSexpr:       "CloseSexpr",
-	TokenID:               "ID",
-	TokenEquals:           "Equals",
-	TokenString:           "String",
-	TokenNumber:           "Number",
-	TokenBoolean:          "Boolean",
-	TokenData:             "Data",
-	TokenSep:              "Sep",
-}
-
-// String returns the token kind string representation for debugging.
-func (k TokenKind) String() string {
-	s := tokenName[k]
-	if s == "" {
-		return fmt.Sprintf("Token-%d", int(k))
-	}
-	return s
-}
-
-// String returns the token string representation for debugging.
-func (t Token) String() string {
-	result := ""
-
-	if dumpTokenPos {
-		result += fmt.Sprintf("%d:", t.Pos)
-	}
-
-	result += fmt.Sprintf("%s", t.Kind)
-
-	if (dumpAllTokensVal || (t.Kind >= TokenContent)) && len(t.Val) > 0 {
-		if len(t.Val) > 100 {
-			result += fmt.Sprintf("{%.20q...}", t.Val)
-		} else {
-			result += fmt.Sprintf("{%q}", t.Val)
-		}
-	}
-
-	return result
-}

vendor/github.com/aymerick/raymond/parser/parser.go

@@ -1,846 +0,0 @@
-// Package parser provides a handlebars syntax analyser. It consumes the tokens provided by the lexer to build an AST.
-package parser
-
-import (
-	"fmt"
-	"regexp"
-	"runtime"
-	"strconv"
-
-	"github.com/aymerick/raymond/ast"
-	"github.com/aymerick/raymond/lexer"
-)
-
-// References:
-//   - https://github.com/wycats/handlebars.js/blob/master/src/handlebars.yy
-//   - https://github.com/golang/go/blob/master/src/text/template/parse/parse.go
-
-// parser is a syntax analyzer.
-type parser struct {
-	// Lexer
-	lex *lexer.Lexer
-
-	// Root node
-	root ast.Node
-
-	// Tokens parsed but not consumed yet
-	tokens []*lexer.Token
-
-	// All tokens have been retreieved from lexer
-	lexOver bool
-}
-
-var (
-	rOpenComment  = regexp.MustCompile(`^\{\{~?!-?-?`)
-	rCloseComment = regexp.MustCompile(`-?-?~?\}\}$`)
-	rOpenAmp      = regexp.MustCompile(`^\{\{~?&`)
-)
-
-// new instanciates a new parser
-func new(input string) *parser {
-	return &parser{
-		lex: lexer.Scan(input),
-	}
-}
-
-// Parse analyzes given input and returns the AST root node.
-func Parse(input string) (result *ast.Program, err error) {
-	// recover error
-	defer errRecover(&err)
-
-	parser := new(input)
-
-	// parse
-	result = parser.parseProgram()
-
-	// check last token
-	token := parser.shift()
-	if token.Kind != lexer.TokenEOF {
-		// Parsing ended before EOF
-		errToken(token, "Syntax error")
-	}
-
-	// fix whitespaces
-	processWhitespaces(result)
-
-	// named returned values
-	return
-}
-
-// errRecover recovers parsing panic
-func errRecover(errp *error) {
-	e := recover()
-	if e != nil {
-		switch err := e.(type) {
-		case runtime.Error:
-			panic(e)
-		case error:
-			*errp = err
-		default:
-			panic(e)
-		}
-	}
-}
-
-// errPanic panics
-func errPanic(err error, line int) {
-	panic(fmt.Errorf("Parse error on line %d:\n%s", line, err))
-}
-
-// errNode panics with given node infos
-func errNode(node ast.Node, msg string) {
-	errPanic(fmt.Errorf("%s\nNode: %s", msg, node), node.Location().Line)
-}
-
-// errNode panics with given Token infos
-func errToken(tok *lexer.Token, msg string) {
-	errPanic(fmt.Errorf("%s\nToken: %s", msg, tok), tok.Line)
-}
-
-// errNode panics because of an unexpected Token kind
-func errExpected(expect lexer.TokenKind, tok *lexer.Token) {
-	errPanic(fmt.Errorf("Expecting %s, got: '%s'", expect, tok), tok.Line)
-}
-
-// program : statement*
-func (p *parser) parseProgram() *ast.Program {
-	result := ast.NewProgram(p.next().Pos, p.next().Line)
-
-	for p.isStatement() {
-		result.AddStatement(p.parseStatement())
-	}
-
-	return result
-}
-
-// statement : mustache | block | rawBlock | partial | content | COMMENT
-func (p *parser) parseStatement() ast.Node {
-	var result ast.Node
-
-	tok := p.next()
-
-	switch tok.Kind {
-	case lexer.TokenOpen, lexer.TokenOpenUnescaped:
-		// mustache
-		result = p.parseMustache()
-	case lexer.TokenOpenBlock:
-		// block
-		result = p.parseBlock()
-	case lexer.TokenOpenInverse:
-		// block
-		result = p.parseInverse()
-	case lexer.TokenOpenRawBlock:
-		// rawBlock
-		result = p.parseRawBlock()
-	case lexer.TokenOpenPartial:
-		// partial
-		result = p.parsePartial()
-	case lexer.TokenContent:
-		// content
-		result = p.parseContent()
-	case lexer.TokenComment:
-		// COMMENT
-		result = p.parseComment()
-	}
-
-	return result
-}
-
-// isStatement returns true if next token starts a statement
-func (p *parser) isStatement() bool {
-	if !p.have(1) {
-		return false
-	}
-
-	switch p.next().Kind {
-	case lexer.TokenOpen, lexer.TokenOpenUnescaped, lexer.TokenOpenBlock,
-		lexer.TokenOpenInverse, lexer.TokenOpenRawBlock, lexer.TokenOpenPartial,
-		lexer.TokenContent, lexer.TokenComment:
-		return true
-	}
-
-	return false
-}
-
-// content : CONTENT
-func (p *parser) parseContent() *ast.ContentStatement {
-	// CONTENT
-	tok := p.shift()
-	if tok.Kind != lexer.TokenContent {
-		// @todo This check can be removed if content is optional in a raw block
-		errExpected(lexer.TokenContent, tok)
-	}
-
-	return ast.NewContentStatement(tok.Pos, tok.Line, tok.Val)
-}
-
-// COMMENT
-func (p *parser) parseComment() *ast.CommentStatement {
-	// COMMENT
-	tok := p.shift()
-
-	value := rOpenComment.ReplaceAllString(tok.Val, "")
-	value = rCloseComment.ReplaceAllString(value, "")
-
-	result := ast.NewCommentStatement(tok.Pos, tok.Line, value)
-	result.Strip = ast.NewStripForStr(tok.Val)
-
-	return result
-}
-
-// param* hash?
-func (p *parser) parseExpressionParamsHash() ([]ast.Node, *ast.Hash) {
-	var params []ast.Node
-	var hash *ast.Hash
-
-	// params*
-	if p.isParam() {
-		params = p.parseParams()
-	}
-
-	// hash?
-	if p.isHashSegment() {
-		hash = p.parseHash()
-	}
-
-	return params, hash
-}
-
-// helperName param* hash?
-func (p *parser) parseExpression(tok *lexer.Token) *ast.Expression {
-	result := ast.NewExpression(tok.Pos, tok.Line)
-
-	// helperName
-	result.Path = p.parseHelperName()
-
-	// param* hash?
-	result.Params, result.Hash = p.parseExpressionParamsHash()
-
-	return result
-}
-
-// rawBlock : openRawBlock content endRawBlock
-// openRawBlock : OPEN_RAW_BLOCK helperName param* hash? CLOSE_RAW_BLOCK
-// endRawBlock : OPEN_END_RAW_BLOCK helperName CLOSE_RAW_BLOCK
-func (p *parser) parseRawBlock() *ast.BlockStatement {
-	// OPEN_RAW_BLOCK
-	tok := p.shift()
-
-	result := ast.NewBlockStatement(tok.Pos, tok.Line)
-
-	// helperName param* hash?
-	result.Expression = p.parseExpression(tok)
-
-	openName := result.Expression.Canonical()
-
-	// CLOSE_RAW_BLOCK
-	tok = p.shift()
-	if tok.Kind != lexer.TokenCloseRawBlock {
-		errExpected(lexer.TokenCloseRawBlock, tok)
-	}
-
-	// content
-	// @todo Is content mandatory in a raw block ?
-	content := p.parseContent()
-
-	program := ast.NewProgram(tok.Pos, tok.Line)
-	program.AddStatement(content)
-
-	result.Program = program
-
-	// OPEN_END_RAW_BLOCK
-	tok = p.shift()
-	if tok.Kind != lexer.TokenOpenEndRawBlock {
-		// should never happen as it is caught by lexer
-		errExpected(lexer.TokenOpenEndRawBlock, tok)
-	}
-
-	// helperName
-	endID := p.parseHelperName()
-
-	closeName, ok := ast.HelperNameStr(endID)
-	if !ok {
-		errNode(endID, "Erroneous closing expression")
-	}
-
-	if openName != closeName {
-		errNode(endID, fmt.Sprintf("%s doesn't match %s", openName, closeName))
-	}
-
-	// CLOSE_RAW_BLOCK
-	tok = p.shift()
-	if tok.Kind != lexer.TokenCloseRawBlock {
-		errExpected(lexer.TokenCloseRawBlock, tok)
-	}
-
-	return result
-}
-
-// block : openBlock program inverseChain? closeBlock
-func (p *parser) parseBlock() *ast.BlockStatement {
-	// openBlock
-	result, blockParams := p.parseOpenBlock()
-
-	// program
-	program := p.parseProgram()
-	program.BlockParams = blockParams
-	result.Program = program
-
-	// inverseChain?
-	if p.isInverseChain() {
-		result.Inverse = p.parseInverseChain()
-	}
-
-	// closeBlock
-	p.parseCloseBlock(result)
-
-	setBlockInverseStrip(result)
-
-	return result
-}
-
-// setBlockInverseStrip is called when parsing `block` (openBlock | openInverse) and `inverseChain`
-//
-// TODO: This was totally cargo culted ! CHECK THAT !
-//
-// cf. prepareBlock() in:
-//   https://github.com/wycats/handlebars.js/blob/master/lib/handlebars/compiler/helper.js
-func setBlockInverseStrip(block *ast.BlockStatement) {
-	if block.Inverse == nil {
-		return
-	}
-
-	if block.Inverse.Chained {
-		b, _ := block.Inverse.Body[0].(*ast.BlockStatement)
-		b.CloseStrip = block.CloseStrip
-	}
-
-	block.InverseStrip = block.Inverse.Strip
-}
-
-// block : openInverse program inverseAndProgram? closeBlock
-func (p *parser) parseInverse() *ast.BlockStatement {
-	// openInverse
-	result, blockParams := p.parseOpenBlock()
-
-	// program
-	program := p.parseProgram()
-
-	program.BlockParams = blockParams
-	result.Inverse = program
-
-	// inverseAndProgram?
-	if p.isInverse() {
-		result.Program = p.parseInverseAndProgram()
-	}
-
-	// closeBlock
-	p.parseCloseBlock(result)
-
-	setBlockInverseStrip(result)
-
-	return result
-}
-
-// helperName param* hash? blockParams?
-func (p *parser) parseOpenBlockExpression(tok *lexer.Token) (*ast.BlockStatement, []string) {
-	var blockParams []string
-
-	result := ast.NewBlockStatement(tok.Pos, tok.Line)
-
-	// helperName param* hash?
-	result.Expression = p.parseExpression(tok)
-
-	// blockParams?
-	if p.isBlockParams() {
-		blockParams = p.parseBlockParams()
-	}
-
-	// named returned values
-	return result, blockParams
-}
-
-// inverseChain : openInverseChain program inverseChain?
-//              | inverseAndProgram
-func (p *parser) parseInverseChain() *ast.Program {
-	if p.isInverse() {
-		// inverseAndProgram
-		return p.parseInverseAndProgram()
-	}
-
-	result := ast.NewProgram(p.next().Pos, p.next().Line)
-
-	// openInverseChain
-	block, blockParams := p.parseOpenBlock()
-
-	// program
-	program := p.parseProgram()
-
-	program.BlockParams = blockParams
-	block.Program = program
-
-	// inverseChain?
-	if p.isInverseChain() {
-		block.Inverse = p.parseInverseChain()
-	}
-
-	setBlockInverseStrip(block)
-
-	result.Chained = true
-	result.AddStatement(block)
-
-	return result
-}
-
-// Returns true if current token starts an inverse chain
-func (p *parser) isInverseChain() bool {
-	return p.isOpenInverseChain() || p.isInverse()
-}
-
-// inverseAndProgram : INVERSE program
-func (p *parser) parseInverseAndProgram() *ast.Program {
-	// INVERSE
-	tok := p.shift()
-
-	// program
-	result := p.parseProgram()
-	result.Strip = ast.NewStripForStr(tok.Val)
-
-	return result
-}
-
-// openBlock : OPEN_BLOCK helperName param* hash? blockParams? CLOSE
-// openInverse : OPEN_INVERSE helperName param* hash? blockParams? CLOSE
-// openInverseChain: OPEN_INVERSE_CHAIN helperName param* hash? blockParams? CLOSE
-func (p *parser) parseOpenBlock() (*ast.BlockStatement, []string) {
-	// OPEN_BLOCK | OPEN_INVERSE | OPEN_INVERSE_CHAIN
-	tok := p.shift()
-
-	// helperName param* hash? blockParams?
-	result, blockParams := p.parseOpenBlockExpression(tok)
-
-	// CLOSE
-	tokClose := p.shift()
-	if tokClose.Kind != lexer.TokenClose {
-		errExpected(lexer.TokenClose, tokClose)
-	}
-
-	result.OpenStrip = ast.NewStrip(tok.Val, tokClose.Val)
-
-	// named returned values
-	return result, blockParams
-}
-
-// closeBlock : OPEN_ENDBLOCK helperName CLOSE
-func (p *parser) parseCloseBlock(block *ast.BlockStatement) {
-	// OPEN_ENDBLOCK
-	tok := p.shift()
-	if tok.Kind != lexer.TokenOpenEndBlock {
-		errExpected(lexer.TokenOpenEndBlock, tok)
-	}
-
-	// helperName
-	endID := p.parseHelperName()
-
-	closeName, ok := ast.HelperNameStr(endID)
-	if !ok {
-		errNode(endID, "Erroneous closing expression")
-	}
-
-	openName := block.Expression.Canonical()
-	if openName != closeName {
-		errNode(endID, fmt.Sprintf("%s doesn't match %s", openName, closeName))
-	}
-
-	// CLOSE
-	tokClose := p.shift()
-	if tokClose.Kind != lexer.TokenClose {
-		errExpected(lexer.TokenClose, tokClose)
-	}
-
-	block.CloseStrip = ast.NewStrip(tok.Val, tokClose.Val)
-}
-
-// mustache : OPEN helperName param* hash? CLOSE
-//          | OPEN_UNESCAPED helperName param* hash? CLOSE_UNESCAPED
-func (p *parser) parseMustache() *ast.MustacheStatement {
-	// OPEN | OPEN_UNESCAPED
-	tok := p.shift()
-
-	closeToken := lexer.TokenClose
-	if tok.Kind == lexer.TokenOpenUnescaped {
-		closeToken = lexer.TokenCloseUnescaped
-	}
-
-	unescaped := false
-	if (tok.Kind == lexer.TokenOpenUnescaped) || (rOpenAmp.MatchString(tok.Val)) {
-		unescaped = true
-	}
-
-	result := ast.NewMustacheStatement(tok.Pos, tok.Line, unescaped)
-
-	// helperName param* hash?
-	result.Expression = p.parseExpression(tok)
-
-	// CLOSE | CLOSE_UNESCAPED
-	tokClose := p.shift()
-	if tokClose.Kind != closeToken {
-		errExpected(closeToken, tokClose)
-	}
-
-	result.Strip = ast.NewStrip(tok.Val, tokClose.Val)
-
-	return result
-}
-
-// partial : OPEN_PARTIAL partialName param* hash? CLOSE
-func (p *parser) parsePartial() *ast.PartialStatement {
-	// OPEN_PARTIAL
-	tok := p.shift()
-
-	result := ast.NewPartialStatement(tok.Pos, tok.Line)
-
-	// partialName
-	result.Name = p.parsePartialName()
-
-	// param* hash?
-	result.Params, result.Hash = p.parseExpressionParamsHash()
-
-	// CLOSE
-	tokClose := p.shift()
-	if tokClose.Kind != lexer.TokenClose {
-		errExpected(lexer.TokenClose, tokClose)
-	}
-
-	result.Strip = ast.NewStrip(tok.Val, tokClose.Val)
-
-	return result
-}
-
-// helperName | sexpr
-func (p *parser) parseHelperNameOrSexpr() ast.Node {
-	if p.isSexpr() {
-		// sexpr
-		return p.parseSexpr()
-	}
-
-	// helperName
-	return p.parseHelperName()
-}
-
-// param : helperName | sexpr
-func (p *parser) parseParam() ast.Node {
-	return p.parseHelperNameOrSexpr()
-}
-
-// Returns true if next tokens represent a `param`
-func (p *parser) isParam() bool {
-	return (p.isSexpr() || p.isHelperName()) && !p.isHashSegment()
-}
-
-// param*
-func (p *parser) parseParams() []ast.Node {
-	var result []ast.Node
-
-	for p.isParam() {
-		result = append(result, p.parseParam())
-	}
-
-	return result
-}
-
-// sexpr : OPEN_SEXPR helperName param* hash? CLOSE_SEXPR
-func (p *parser) parseSexpr() *ast.SubExpression {
-	// OPEN_SEXPR
-	tok := p.shift()
-
-	result := ast.NewSubExpression(tok.Pos, tok.Line)
-
-	// helperName param* hash?
-	result.Expression = p.parseExpression(tok)
-
-	// CLOSE_SEXPR
-	tok = p.shift()
-	if tok.Kind != lexer.TokenCloseSexpr {
-		errExpected(lexer.TokenCloseSexpr, tok)
-	}
-
-	return result
-}
-
-// hash : hashSegment+
-func (p *parser) parseHash() *ast.Hash {
-	var pairs []*ast.HashPair
-
-	for p.isHashSegment() {
-		pairs = append(pairs, p.parseHashSegment())
-	}
-
-	firstLoc := pairs[0].Location()
-
-	result := ast.NewHash(firstLoc.Pos, firstLoc.Line)
-	result.Pairs = pairs
-
-	return result
-}
-
-// returns true if next tokens represents a `hashSegment`
-func (p *parser) isHashSegment() bool {
-	return p.have(2) && (p.next().Kind == lexer.TokenID) && (p.nextAt(1).Kind == lexer.TokenEquals)
-}
-
-// hashSegment : ID EQUALS param
-func (p *parser) parseHashSegment() *ast.HashPair {
-	// ID
-	tok := p.shift()
-
-	// EQUALS
-	p.shift()
-
-	// param
-	param := p.parseParam()
-
-	result := ast.NewHashPair(tok.Pos, tok.Line)
-	result.Key = tok.Val
-	result.Val = param
-
-	return result
-}
-
-// blockParams : OPEN_BLOCK_PARAMS ID+ CLOSE_BLOCK_PARAMS
-func (p *parser) parseBlockParams() []string {
-	var result []string
-
-	// OPEN_BLOCK_PARAMS
-	tok := p.shift()
-
-	// ID+
-	for p.isID() {
-		result = append(result, p.shift().Val)
-	}
-
-	if len(result) == 0 {
-		errExpected(lexer.TokenID, p.next())
-	}
-
-	// CLOSE_BLOCK_PARAMS
-	tok = p.shift()
-	if tok.Kind != lexer.TokenCloseBlockParams {
-		errExpected(lexer.TokenCloseBlockParams, tok)
-	}
-
-	return result
-}
-
-// helperName : path | dataName | STRING | NUMBER | BOOLEAN | UNDEFINED | NULL
-func (p *parser) parseHelperName() ast.Node {
-	var result ast.Node
-
-	tok := p.next()
-
-	switch tok.Kind {
-	case lexer.TokenBoolean:
-		// BOOLEAN
-		p.shift()
-		result = ast.NewBooleanLiteral(tok.Pos, tok.Line, (tok.Val == "true"), tok.Val)
-	case lexer.TokenNumber:
-		// NUMBER
-		p.shift()
-
-		val, isInt := parseNumber(tok)
-		result = ast.NewNumberLiteral(tok.Pos, tok.Line, val, isInt, tok.Val)
-	case lexer.TokenString:
-		// STRING
-		p.shift()
-		result = ast.NewStringLiteral(tok.Pos, tok.Line, tok.Val)
-	case lexer.TokenData:
-		// dataName
-		result = p.parseDataName()
-	default:
-		// path
-		result = p.parsePath(false)
-	}
-
-	return result
-}
-
-// parseNumber parses a number
-func parseNumber(tok *lexer.Token) (result float64, isInt bool) {
-	var valInt int
-	var err error
-
-	valInt, err = strconv.Atoi(tok.Val)
-	if err == nil {
-		isInt = true
-
-		result = float64(valInt)
-	} else {
-		isInt = false
-
-		result, err = strconv.ParseFloat(tok.Val, 64)
-		if err != nil {
-			errToken(tok, fmt.Sprintf("Failed to parse number: %s", tok.Val))
-		}
-	}
-
-	// named returned values
-	return
-}
-
-// Returns true if next tokens represent a `helperName`
-func (p *parser) isHelperName() bool {
-	switch p.next().Kind {
-	case lexer.TokenBoolean, lexer.TokenNumber, lexer.TokenString, lexer.TokenData, lexer.TokenID:
-		return true
-	}
-
-	return false
-}
-
-// partialName : helperName | sexpr
-func (p *parser) parsePartialName() ast.Node {
-	return p.parseHelperNameOrSexpr()
-}
-
-// dataName : DATA pathSegments
-func (p *parser) parseDataName() *ast.PathExpression {
-	// DATA
-	p.shift()
-
-	// pathSegments
-	return p.parsePath(true)
-}
-
-// path : pathSegments
-// pathSegments : pathSegments SEP ID
-//              | ID
-func (p *parser) parsePath(data bool) *ast.PathExpression {
-	var tok *lexer.Token
-
-	// ID
-	tok = p.shift()
-	if tok.Kind != lexer.TokenID {
-		errExpected(lexer.TokenID, tok)
-	}
-
-	result := ast.NewPathExpression(tok.Pos, tok.Line, data)
-	result.Part(tok.Val)
-
-	for p.isPathSep() {
-		// SEP
-		tok = p.shift()
-		result.Sep(tok.Val)
-
-		// ID
-		tok = p.shift()
-		if tok.Kind != lexer.TokenID {
-			errExpected(lexer.TokenID, tok)
-		}
-
-		result.Part(tok.Val)
-
-		if len(result.Parts) > 0 {
-			switch tok.Val {
-			case "..", ".", "this":
-				errToken(tok, "Invalid path: "+result.Original)
-			}
-		}
-	}
-
-	return result
-}
-
-// Ensures there is token to parse at given index
-func (p *parser) ensure(index int) {
-	if p.lexOver {
-		// nothing more to grab
-		return
-	}
-
-	nb := index + 1
-
-	for len(p.tokens) < nb {
-		// fetch next token
-		tok := p.lex.NextToken()
-
-		// queue it
-		p.tokens = append(p.tokens, &tok)
-
-		if (tok.Kind == lexer.TokenEOF) || (tok.Kind == lexer.TokenError) {
-			p.lexOver = true
-			break
-		}
-	}
-}
-
-// have returns true is there are a list given number of tokens to consume left
-func (p *parser) have(nb int) bool {
-	p.ensure(nb - 1)
-
-	return len(p.tokens) >= nb
-}
-
-// nextAt returns next token at given index, without consuming it
-func (p *parser) nextAt(index int) *lexer.Token {
-	p.ensure(index)
-
-	return p.tokens[index]
-}
-
-// next returns next token without consuming it
-func (p *parser) next() *lexer.Token {
-	return p.nextAt(0)
-}
-
-// shift returns next token and remove it from the tokens buffer
-//
-// Panics if next token is `TokenError`
-func (p *parser) shift() *lexer.Token {
-	var result *lexer.Token
-
-	p.ensure(0)
-
-	result, p.tokens = p.tokens[0], p.tokens[1:]
-
-	// check error token
-	if result.Kind == lexer.TokenError {
-		errToken(result, "Lexer error")
-	}
-
-	return result
-}
-
-// isToken returns true if next token is of given type
-func (p *parser) isToken(kind lexer.TokenKind) bool {
-	return p.have(1) && p.next().Kind == kind
-}
-
-// isSexpr returns true if next token starts a sexpr
-func (p *parser) isSexpr() bool {
-	return p.isToken(lexer.TokenOpenSexpr)
-}
-
-// isPathSep returns true if next token is a path separator
-func (p *parser) isPathSep() bool {
-	return p.isToken(lexer.TokenSep)
-}
-
-// isID returns true if next token is an ID
-func (p *parser) isID() bool {
-	return p.isToken(lexer.TokenID)
-}
-
-// isBlockParams returns true if next token starts a block params
-func (p *parser) isBlockParams() bool {
-	return p.isToken(lexer.TokenOpenBlockParams)
-}
-
-// isInverse returns true if next token starts an INVERSE sequence
-func (p *parser) isInverse() bool {
-	return p.isToken(lexer.TokenInverse)
-}
-
-// isOpenInverseChain returns true if next token is OPEN_INVERSE_CHAIN
-func (p *parser) isOpenInverseChain() bool {
-	return p.isToken(lexer.TokenOpenInverseChain)
-}

vendor/github.com/aymerick/raymond/parser/whitespace.go

@@ -1,360 +0,0 @@
-package parser
-
-import (
-	"regexp"
-
-	"github.com/aymerick/raymond/ast"
-)
-
-// whitespaceVisitor walks through the AST to perform whitespace control
-//
-// The logic was shamelessly borrowed from:
-//   https://github.com/wycats/handlebars.js/blob/master/lib/handlebars/compiler/whitespace-control.js
-type whitespaceVisitor struct {
-	isRootSeen bool
-}
-
-var (
-	rTrimLeft         = regexp.MustCompile(`^[ \t]*\r?\n?`)
-	rTrimLeftMultiple = regexp.MustCompile(`^\s+`)
-
-	rTrimRight         = regexp.MustCompile(`[ \t]+$`)
-	rTrimRightMultiple = regexp.MustCompile(`\s+$`)
-
-	rPrevWhitespace      = regexp.MustCompile(`\r?\n\s*?$`)
-	rPrevWhitespaceStart = regexp.MustCompile(`(^|\r?\n)\s*?$`)
-
-	rNextWhitespace    = regexp.MustCompile(`^\s*?\r?\n`)
-	rNextWhitespaceEnd = regexp.MustCompile(`^\s*?(\r?\n|$)`)
-
-	rPartialIndent = regexp.MustCompile(`([ \t]+$)`)
-)
-
-// newWhitespaceVisitor instanciates a new whitespaceVisitor
-func newWhitespaceVisitor() *whitespaceVisitor {
-	return &whitespaceVisitor{}
-}
-
-// processWhitespaces performs whitespace control on given AST
-//
-// WARNING: It must be called only once on AST.
-func processWhitespaces(node ast.Node) {
-	node.Accept(newWhitespaceVisitor())
-}
-
-func omitRightFirst(body []ast.Node, multiple bool) {
-	omitRight(body, -1, multiple)
-}
-
-func omitRight(body []ast.Node, i int, multiple bool) {
-	if i+1 >= len(body) {
-		return
-	}
-
-	current := body[i+1]
-
-	node, ok := current.(*ast.ContentStatement)
-	if !ok {
-		return
-	}
-
-	if !multiple && node.RightStripped {
-		return
-	}
-
-	original := node.Value
-
-	r := rTrimLeft
-	if multiple {
-		r = rTrimLeftMultiple
-	}
-
-	node.Value = r.ReplaceAllString(node.Value, "")
-
-	node.RightStripped = (original != node.Value)
-}
-
-func omitLeftLast(body []ast.Node, multiple bool) {
-	omitLeft(body, len(body), multiple)
-}
-
-func omitLeft(body []ast.Node, i int, multiple bool) bool {
-	if i-1 < 0 {
-		return false
-	}
-
-	current := body[i-1]
-
-	node, ok := current.(*ast.ContentStatement)
-	if !ok {
-		return false
-	}
-
-	if !multiple && node.LeftStripped {
-		return false
-	}
-
-	original := node.Value
-
-	r := rTrimRight
-	if multiple {
-		r = rTrimRightMultiple
-	}
-
-	node.Value = r.ReplaceAllString(node.Value, "")
-
-	node.LeftStripped = (original != node.Value)
-
-	return node.LeftStripped
-}
-
-func isPrevWhitespace(body []ast.Node) bool {
-	return isPrevWhitespaceProgram(body, len(body), false)
-}
-
-func isPrevWhitespaceProgram(body []ast.Node, i int, isRoot bool) bool {
-	if i < 1 {
-		return isRoot
-	}
-
-	prev := body[i-1]
-
-	if node, ok := prev.(*ast.ContentStatement); ok {
-		if (node.Value == "") && node.RightStripped {
-			// already stripped, so it may be an empty string not catched by regexp
-			return true
-		}
-
-		r := rPrevWhitespaceStart
-		if (i > 1) || !isRoot {
-			r = rPrevWhitespace
-		}
-
-		return r.MatchString(node.Value)
-	}
-
-	return false
-}
-
-func isNextWhitespace(body []ast.Node) bool {
-	return isNextWhitespaceProgram(body, -1, false)
-}
-
-func isNextWhitespaceProgram(body []ast.Node, i int, isRoot bool) bool {
-	if i+1 >= len(body) {
-		return isRoot
-	}
-
-	next := body[i+1]
-
-	if node, ok := next.(*ast.ContentStatement); ok {
-		if (node.Value == "") && node.LeftStripped {
-			// already stripped, so it may be an empty string not catched by regexp
-			return true
-		}
-
-		r := rNextWhitespaceEnd
-		if (i+2 > len(body)) || !isRoot {
-			r = rNextWhitespace
-		}
-
-		return r.MatchString(node.Value)
-	}
-
-	return false
-}
-
-//
-// Visitor interface
-//
-
-func (v *whitespaceVisitor) VisitProgram(program *ast.Program) interface{} {
-	isRoot := !v.isRootSeen
-	v.isRootSeen = true
-
-	body := program.Body
-	for i, current := range body {
-		strip, _ := current.Accept(v).(*ast.Strip)
-		if strip == nil {
-			continue
-		}
-
-		_isPrevWhitespace := isPrevWhitespaceProgram(body, i, isRoot)
-		_isNextWhitespace := isNextWhitespaceProgram(body, i, isRoot)
-
-		openStandalone := strip.OpenStandalone && _isPrevWhitespace
-		closeStandalone := strip.CloseStandalone && _isNextWhitespace
-		inlineStandalone := strip.InlineStandalone && _isPrevWhitespace && _isNextWhitespace
-
-		if strip.Close {
-			omitRight(body, i, true)
-		}
-
-		if strip.Open && (i > 0) {
-			omitLeft(body, i, true)
-		}
-
-		if inlineStandalone {
-			omitRight(body, i, false)
-
-			if omitLeft(body, i, false) {
-				// If we are on a standalone node, save the indent info for partials
-				if partial, ok := current.(*ast.PartialStatement); ok {
-					// Pull out the whitespace from the final line
-					if i > 0 {
-						if prevContent, ok := body[i-1].(*ast.ContentStatement); ok {
-							partial.Indent = rPartialIndent.FindString(prevContent.Original)
-						}
-					}
-				}
-			}
-		}
-
-		if b, ok := current.(*ast.BlockStatement); ok {
-			if openStandalone {
-				prog := b.Program
-				if prog == nil {
-					prog = b.Inverse
-				}
-
-				omitRightFirst(prog.Body, false)
-
-				// Strip out the previous content node if it's whitespace only
-				omitLeft(body, i, false)
-			}
-
-			if closeStandalone {
-				prog := b.Inverse
-				if prog == nil {
-					prog = b.Program
-				}
-
-				// Always strip the next node
-				omitRight(body, i, false)
-
-				omitLeftLast(prog.Body, false)
-			}
-
-		}
-	}
-
-	return nil
-}
-
-func (v *whitespaceVisitor) VisitBlock(block *ast.BlockStatement) interface{} {
-	if block.Program != nil {
-		block.Program.Accept(v)
-	}
-
-	if block.Inverse != nil {
-		block.Inverse.Accept(v)
-	}
-
-	program := block.Program
-	inverse := block.Inverse
-
-	if program == nil {
-		program = inverse
-		inverse = nil
-	}
-
-	firstInverse := inverse
-	lastInverse := inverse
-
-	if (inverse != nil) && inverse.Chained {
-		b, _ := inverse.Body[0].(*ast.BlockStatement)
-		firstInverse = b.Program
-
-		for lastInverse.Chained {
-			b, _ := lastInverse.Body[len(lastInverse.Body)-1].(*ast.BlockStatement)
-			lastInverse = b.Program
-		}
-	}
-
-	closeProg := firstInverse
-	if closeProg == nil {
-		closeProg = program
-	}
-
-	strip := &ast.Strip{
-		Open:  (block.OpenStrip != nil) && block.OpenStrip.Open,
-		Close: (block.CloseStrip != nil) && block.CloseStrip.Close,
-
-		OpenStandalone:  isNextWhitespace(program.Body),
-		CloseStandalone: isPrevWhitespace(closeProg.Body),
-	}
-
-	if (block.OpenStrip != nil) && block.OpenStrip.Close {
-		omitRightFirst(program.Body, true)
-	}
-
-	if inverse != nil {
-		if block.InverseStrip != nil {
-			inverseStrip := block.InverseStrip
-
-			if inverseStrip.Open {
-				omitLeftLast(program.Body, true)
-			}
-
-			if inverseStrip.Close {
-				omitRightFirst(firstInverse.Body, true)
-			}
-		}
-
-		if (block.CloseStrip != nil) && block.CloseStrip.Open {
-			omitLeftLast(lastInverse.Body, true)
-		}
-
-		// Find standalone else statements
-		if isPrevWhitespace(program.Body) && isNextWhitespace(firstInverse.Body) {
-			omitLeftLast(program.Body, false)
-
-			omitRightFirst(firstInverse.Body, false)
-		}
-	} else if (block.CloseStrip != nil) && block.CloseStrip.Open {
-		omitLeftLast(program.Body, true)
-	}
-
-	return strip
-}
-
-func (v *whitespaceVisitor) VisitMustache(mustache *ast.MustacheStatement) interface{} {
-	return mustache.Strip
-}
-
-func _inlineStandalone(strip *ast.Strip) interface{} {
-	return &ast.Strip{
-		Open:             strip.Open,
-		Close:            strip.Close,
-		InlineStandalone: true,
-	}
-}
-
-func (v *whitespaceVisitor) VisitPartial(node *ast.PartialStatement) interface{} {
-	strip := node.Strip
-	if strip == nil {
-		strip = &ast.Strip{}
-	}
-
-	return _inlineStandalone(strip)
-}
-
-func (v *whitespaceVisitor) VisitComment(node *ast.CommentStatement) interface{} {
-	strip := node.Strip
-	if strip == nil {
-		strip = &ast.Strip{}
-	}
-
-	return _inlineStandalone(strip)
-}
-
-// NOOP
-func (v *whitespaceVisitor) VisitContent(node *ast.ContentStatement) interface{}    { return nil }
-func (v *whitespaceVisitor) VisitExpression(node *ast.Expression) interface{}       { return nil }
-func (v *whitespaceVisitor) VisitSubExpression(node *ast.SubExpression) interface{} { return nil }
-func (v *whitespaceVisitor) VisitPath(node *ast.PathExpression) interface{}         { return nil }
-func (v *whitespaceVisitor) VisitString(node *ast.StringLiteral) interface{}        { return nil }
-func (v *whitespaceVisitor) VisitBoolean(node *ast.BooleanLiteral) interface{}      { return nil }
-func (v *whitespaceVisitor) VisitNumber(node *ast.NumberLiteral) interface{}        { return nil }
-func (v *whitespaceVisitor) VisitHash(node *ast.Hash) interface{}                   { return nil }
-func (v *whitespaceVisitor) VisitHashPair(node *ast.HashPair) interface{}           { return nil }

vendor/github.com/aymerick/raymond/partial.go

@@ -1,85 +0,0 @@
-package raymond
-
-import (
-	"fmt"
-	"sync"
-)
-
-// partial represents a partial template
-type partial struct {
-	name   string
-	source string
-	tpl    *Template
-}
-
-// partials stores all global partials
-var partials map[string]*partial
-
-// protects global partials
-var partialsMutex sync.RWMutex
-
-func init() {
-	partials = make(map[string]*partial)
-}
-
-// newPartial instanciates a new partial
-func newPartial(name string, source string, tpl *Template) *partial {
-	return &partial{
-		name:   name,
-		source: source,
-		tpl:    tpl,
-	}
-}
-
-// RegisterPartial registers a global partial. That partial will be available to all templates.
-func RegisterPartial(name string, source string) {
-	partialsMutex.Lock()
-	defer partialsMutex.Unlock()
-
-	if partials[name] != nil {
-		panic(fmt.Errorf("Partial already registered: %s", name))
-	}
-
-	partials[name] = newPartial(name, source, nil)
-}
-
-// RegisterPartials registers several global partials. Those partials will be available to all templates.
-func RegisterPartials(partials map[string]string) {
-	for name, p := range partials {
-		RegisterPartial(name, p)
-	}
-}
-
-// RegisterPartialTemplate registers a global partial with given parsed template. That partial will be available to all templates.
-func RegisterPartialTemplate(name string, tpl *Template) {
-	partialsMutex.Lock()
-	defer partialsMutex.Unlock()
-
-	if partials[name] != nil {
-		panic(fmt.Errorf("Partial already registered: %s", name))
-	}
-
-	partials[name] = newPartial(name, "", tpl)
-}
-
-// findPartial finds a registered global partial
-func findPartial(name string) *partial {
-	partialsMutex.RLock()
-	defer partialsMutex.RUnlock()
-
-	return partials[name]
-}
-
-// template returns parsed partial template
-func (p *partial) template() (*Template, error) {
-	if p.tpl == nil {
-		var err error
-
-		p.tpl, err = Parse(p.source)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return p.tpl, nil
-}

vendor/github.com/aymerick/raymond/raymond.go

@@ -1,28 +0,0 @@
-// Package raymond provides handlebars evaluation
-package raymond
-
-// Render parses a template and evaluates it with given context
-//
-// Note that this function call is not optimal as your template is parsed everytime you call it. You should use Parse() function instead.
-func Render(source string, ctx interface{}) (string, error) {
-	// parse template
-	tpl, err := Parse(source)
-	if err != nil {
-		return "", err
-	}
-
-	// renders template
-	str, err := tpl.Exec(ctx)
-	if err != nil {
-		return "", err
-	}
-
-	return str, nil
-}
-
-// MustRender parses a template and evaluates it with given context. It panics on error.
-//
-// Note that this function call is not optimal as your template is parsed everytime you call it. You should use Parse() function instead.
-func MustRender(source string, ctx interface{}) string {
-	return MustParse(source).MustExec(ctx)
-}

vendor/github.com/aymerick/raymond/string.go

@@ -1,84 +0,0 @@
-package raymond
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-)
-
-// SafeString represents a string that must not be escaped.
-//
-// A SafeString can be returned by helpers to disable escaping.
-type SafeString string
-
-// isSafeString returns true if argument is a SafeString
-func isSafeString(value interface{}) bool {
-	if _, ok := value.(SafeString); ok {
-		return true
-	}
-	return false
-}
-
-// Str returns string representation of any basic type value.
-func Str(value interface{}) string {
-	return strValue(reflect.ValueOf(value))
-}
-
-// strValue returns string representation of a reflect.Value
-func strValue(value reflect.Value) string {
-	result := ""
-
-	ival, ok := printableValue(value)
-	if !ok {
-		panic(fmt.Errorf("Can't print value: %q", value))
-	}
-
-	val := reflect.ValueOf(ival)
-
-	switch val.Kind() {
-	case reflect.Array, reflect.Slice:
-		for i := 0; i < val.Len(); i++ {
-			result += strValue(val.Index(i))
-		}
-	case reflect.Bool:
-		result = "false"
-		if val.Bool() {
-			result = "true"
-		}
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		result = fmt.Sprintf("%d", ival)
-	case reflect.Float32, reflect.Float64:
-		result = strconv.FormatFloat(val.Float(), 'f', -1, 64)
-	case reflect.Invalid:
-		result = ""
-	default:
-		result = fmt.Sprintf("%s", ival)
-	}
-
-	return result
-}
-
-// printableValue returns the, possibly indirected, interface value inside v that
-// is best for a call to formatted printer.
-//
-// NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/exec.go
-func printableValue(v reflect.Value) (interface{}, bool) {
-	if v.Kind() == reflect.Ptr {
-		v, _ = indirect(v) // fmt.Fprint handles nil.
-	}
-	if !v.IsValid() {
-		return "", true
-	}
-
-	if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
-		if v.CanAddr() && (reflect.PtrTo(v.Type()).Implements(errorType) || reflect.PtrTo(v.Type()).Implements(fmtStringerType)) {
-			v = v.Addr()
-		} else {
-			switch v.Kind() {
-			case reflect.Chan, reflect.Func:
-				return nil, false
-			}
-		}
-	}
-	return v.Interface(), true
-}

vendor/github.com/aymerick/raymond/template.go

@@ -1,248 +0,0 @@
-package raymond
-
-import (
-	"fmt"
-	"io/ioutil"
-	"reflect"
-	"runtime"
-	"sync"
-
-	"github.com/aymerick/raymond/ast"
-	"github.com/aymerick/raymond/parser"
-)
-
-// Template represents a handlebars template.
-type Template struct {
-	source   string
-	program  *ast.Program
-	helpers  map[string]reflect.Value
-	partials map[string]*partial
-	mutex    sync.RWMutex // protects helpers and partials
-}
-
-// newTemplate instanciate a new template without parsing it
-func newTemplate(source string) *Template {
-	return &Template{
-		source:   source,
-		helpers:  make(map[string]reflect.Value),
-		partials: make(map[string]*partial),
-	}
-}
-
-// Parse instanciates a template by parsing given source.
-func Parse(source string) (*Template, error) {
-	tpl := newTemplate(source)
-
-	// parse template
-	if err := tpl.parse(); err != nil {
-		return nil, err
-	}
-
-	return tpl, nil
-}
-
-// MustParse instanciates a template by parsing given source. It panics on error.
-func MustParse(source string) *Template {
-	result, err := Parse(source)
-	if err != nil {
-		panic(err)
-	}
-	return result
-}
-
-// ParseFile reads given file and returns parsed template.
-func ParseFile(filePath string) (*Template, error) {
-	b, err := ioutil.ReadFile(filePath)
-	if err != nil {
-		return nil, err
-	}
-
-	return Parse(string(b))
-}
-
-// parse parses the template
-//
-// It can be called several times, the parsing will be done only once.
-func (tpl *Template) parse() error {
-	if tpl.program == nil {
-		var err error
-
-		tpl.program, err = parser.Parse(tpl.source)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// Clone returns a copy of that template.
-func (tpl *Template) Clone() *Template {
-	result := newTemplate(tpl.source)
-
-	result.program = tpl.program
-
-	tpl.mutex.RLock()
-	defer tpl.mutex.RUnlock()
-
-	for name, helper := range tpl.helpers {
-		result.RegisterHelper(name, helper.Interface())
-	}
-
-	for name, partial := range tpl.partials {
-		result.addPartial(name, partial.source, partial.tpl)
-	}
-
-	return result
-}
-
-func (tpl *Template) findHelper(name string) reflect.Value {
-	tpl.mutex.RLock()
-	defer tpl.mutex.RUnlock()
-
-	return tpl.helpers[name]
-}
-
-// RegisterHelper registers a helper for that template.
-func (tpl *Template) RegisterHelper(name string, helper interface{}) {
-	tpl.mutex.Lock()
-	defer tpl.mutex.Unlock()
-
-	if tpl.helpers[name] != zero {
-		panic(fmt.Sprintf("Helper %s already registered", name))
-	}
-
-	val := reflect.ValueOf(helper)
-	ensureValidHelper(name, val)
-
-	tpl.helpers[name] = val
-}
-
-// RegisterHelpers registers several helpers for that template.
-func (tpl *Template) RegisterHelpers(helpers map[string]interface{}) {
-	for name, helper := range helpers {
-		tpl.RegisterHelper(name, helper)
-	}
-}
-
-func (tpl *Template) addPartial(name string, source string, template *Template) {
-	tpl.mutex.Lock()
-	defer tpl.mutex.Unlock()
-
-	if tpl.partials[name] != nil {
-		panic(fmt.Sprintf("Partial %s already registered", name))
-	}
-
-	tpl.partials[name] = newPartial(name, source, template)
-}
-
-func (tpl *Template) findPartial(name string) *partial {
-	tpl.mutex.RLock()
-	defer tpl.mutex.RUnlock()
-
-	return tpl.partials[name]
-}
-
-// RegisterPartial registers a partial for that template.
-func (tpl *Template) RegisterPartial(name string, source string) {
-	tpl.addPartial(name, source, nil)
-}
-
-// RegisterPartials registers several partials for that template.
-func (tpl *Template) RegisterPartials(partials map[string]string) {
-	for name, partial := range partials {
-		tpl.RegisterPartial(name, partial)
-	}
-}
-
-// RegisterPartialFile reads given file and registers its content as a partial with given name.
-func (tpl *Template) RegisterPartialFile(filePath string, name string) error {
-	b, err := ioutil.ReadFile(filePath)
-	if err != nil {
-		return err
-	}
-
-	tpl.RegisterPartial(name, string(b))
-
-	return nil
-}
-
-// RegisterPartialFiles reads several files and registers them as partials, the filename base is used as the partial name.
-func (tpl *Template) RegisterPartialFiles(filePaths ...string) error {
-	if len(filePaths) == 0 {
-		return nil
-	}
-
-	for _, filePath := range filePaths {
-		name := fileBase(filePath)
-
-		if err := tpl.RegisterPartialFile(filePath, name); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// RegisterPartialTemplate registers an already parsed partial for that template.
-func (tpl *Template) RegisterPartialTemplate(name string, template *Template) {
-	tpl.addPartial(name, "", template)
-}
-
-// Exec evaluates template with given context.
-func (tpl *Template) Exec(ctx interface{}) (result string, err error) {
-	return tpl.ExecWith(ctx, nil)
-}
-
-// MustExec evaluates template with given context. It panics on error.
-func (tpl *Template) MustExec(ctx interface{}) string {
-	result, err := tpl.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return result
-}
-
-// ExecWith evaluates template with given context and private data frame.
-func (tpl *Template) ExecWith(ctx interface{}, privData *DataFrame) (result string, err error) {
-	defer errRecover(&err)
-
-	// parses template if necessary
-	err = tpl.parse()
-	if err != nil {
-		return
-	}
-
-	// setup visitor
-	v := newEvalVisitor(tpl, ctx, privData)
-
-	// visit AST
-	result, _ = tpl.program.Accept(v).(string)
-
-	// named return values
-	return
-}
-
-// errRecover recovers evaluation panic
-func errRecover(errp *error) {
-	e := recover()
-	if e != nil {
-		switch err := e.(type) {
-		case runtime.Error:
-			panic(e)
-		case error:
-			*errp = err
-		default:
-			panic(e)
-		}
-	}
-}
-
-// PrintAST returns string representation of parsed template.
-func (tpl *Template) PrintAST() string {
-	if err := tpl.parse(); err != nil {
-		return fmt.Sprintf("PARSER ERROR: %s", err)
-	}
-
-	return ast.Print(tpl.program)
-}

vendor/github.com/aymerick/raymond/utils.go

@@ -1,85 +0,0 @@
-package raymond
-
-import (
-	"path"
-	"reflect"
-)
-
-// indirect returns the item at the end of indirection, and a bool to indicate if it's nil.
-// We indirect through pointers and empty interfaces (only) because
-// non-empty interfaces have methods we might need.
-//
-// NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/exec.go
-func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
-	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
-		if v.IsNil() {
-			return v, true
-		}
-		if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
-			break
-		}
-	}
-	return v, false
-}
-
-// IsTrue returns true if obj is a truthy value.
-func IsTrue(obj interface{}) bool {
-	thruth, ok := isTrueValue(reflect.ValueOf(obj))
-	if !ok {
-		return false
-	}
-	return thruth
-}
-
-// isTrueValue reports whether the value is 'true', in the sense of not the zero of its type,
-// and whether the value has a meaningful truth value
-//
-// NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/exec.go
-func isTrueValue(val reflect.Value) (truth, ok bool) {
-	if !val.IsValid() {
-		// Something like var x interface{}, never set. It's a form of nil.
-		return false, true
-	}
-	switch val.Kind() {
-	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
-		truth = val.Len() > 0
-	case reflect.Bool:
-		truth = val.Bool()
-	case reflect.Complex64, reflect.Complex128:
-		truth = val.Complex() != 0
-	case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Interface:
-		truth = !val.IsNil()
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		truth = val.Int() != 0
-	case reflect.Float32, reflect.Float64:
-		truth = val.Float() != 0
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		truth = val.Uint() != 0
-	case reflect.Struct:
-		truth = true // Struct values are always true.
-	default:
-		return
-	}
-	return truth, true
-}
-
-// canBeNil reports whether an untyped nil can be assigned to the type. See reflect.Zero.
-//
-// NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/exec.go
-func canBeNil(typ reflect.Type) bool {
-	switch typ.Kind() {
-	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-		return true
-	}
-	return false
-}
-
-// fileBase returns base file name
-//
-// example: /foo/bar/baz.png => baz
-func fileBase(filePath string) string {
-	fileName := path.Base(filePath)
-	fileExt := path.Ext(filePath)
-
-	return fileName[:len(fileName)-len(fileExt)]
-}

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/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 hexadecimal 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))
-}

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

@@ -1,306 +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"
-	"os"
-)
-
-// ConfigState houses the configuration options used by spew to format and
-// display values.  There is a global instance, Config, that is used to control
-// all top-level Formatter and Dump functionality.  Each ConfigState instance
-// provides methods equivalent to the top-level functions.
-//
-// The zero value for ConfigState provides no indentation.  You would typically
-// want to set it to a space or a tab.
-//
-// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
-// with default settings.  See the documentation of NewDefaultConfig for default
-// values.
-type ConfigState struct {
-	// Indent specifies the string to use for each indentation level.  The
-	// global config instance that all top-level functions use set this to a
-	// single space by default.  If you would like more indentation, you might
-	// set this to a tab with "\t" or perhaps two spaces with "  ".
-	Indent string
-
-	// MaxDepth controls the maximum number of levels to descend into nested
-	// data structures.  The default, 0, means there is no limit.
-	//
-	// NOTE: Circular data structures are properly detected, so it is not
-	// necessary to set this value unless you specifically want to limit deeply
-	// nested data structures.
-	MaxDepth int
-
-	// DisableMethods specifies whether or not error and Stringer interfaces are
-	// invoked for types that implement them.
-	DisableMethods bool
-
-	// DisablePointerMethods specifies whether or not to check for and invoke
-	// error and Stringer interfaces on types which only accept a pointer
-	// receiver when the current type is not a pointer.
-	//
-	// NOTE: This might be an unsafe action since calling one of these methods
-	// with a pointer receiver could technically mutate the value, however,
-	// in practice, types which choose to satisify an error or Stringer
-	// interface with a pointer receiver should not be mutating their state
-	// inside these interface methods.  As a result, 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.
-	DisablePointerMethods bool
-
-	// DisablePointerAddresses specifies whether to disable the printing of
-	// pointer addresses. This is useful when diffing data structures in tests.
-	DisablePointerAddresses bool
-
-	// DisableCapacities specifies whether to disable the printing of capacities
-	// for arrays, slices, maps and channels. This is useful when diffing
-	// data structures in tests.
-	DisableCapacities bool
-
-	// ContinueOnMethod specifies whether or not recursion should continue once
-	// a custom error or Stringer interface is invoked.  The default, false,
-	// means it will print the results of invoking the custom error or Stringer
-	// interface and return immediately instead of continuing to recurse into
-	// the internals of the data type.
-	//
-	// NOTE: This flag does not have any effect if method invocation is disabled
-	// via the DisableMethods or DisablePointerMethods options.
-	ContinueOnMethod bool
-
-	// 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
-	// that support the error or Stringer interfaces (if methods are
-	// enabled) are supported, with other types sorted according to the
-	// reflect.Value.String() output which guarantees display stability.
-	SortKeys bool
-
-	// 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.
-	SpewKeys bool
-}
-
-// Config is the active configuration of the top-level functions.
-// The configuration can be changed by modifying the contents of spew.Config.
-var Config = ConfigState{Indent: " "}
-
-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the formatted string as a value that satisfies error.  See NewFormatter
-// for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
-	return fmt.Errorf(format, c.convertArgs(a)...)
-}
-
-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprint(w, c.convertArgs(a)...)
-}
-
-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	return fmt.Fprintf(w, format, c.convertArgs(a)...)
-}
-
-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
-// passed with a Formatter interface returned by c.NewFormatter.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprintln(w, c.convertArgs(a)...)
-}
-
-// Print is a wrapper for fmt.Print that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
-	return fmt.Print(c.convertArgs(a)...)
-}
-
-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
-	return fmt.Printf(format, c.convertArgs(a)...)
-}
-
-// Println is a wrapper for fmt.Println that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
-	return fmt.Println(c.convertArgs(a)...)
-}
-
-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprint(a ...interface{}) string {
-	return fmt.Sprint(c.convertArgs(a)...)
-}
-
-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
-	return fmt.Sprintf(format, c.convertArgs(a)...)
-}
-
-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
-// were passed with a Formatter interface returned by c.NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintln(a ...interface{}) string {
-	return fmt.Sprintln(c.convertArgs(a)...)
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface.  As a result, it integrates cleanly with standard fmt package
-printing functions.  The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly.  It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-c.Printf, c.Println, or c.Printf.
-*/
-func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
-	return newFormatter(c, v)
-}
-
-// Fdump formats and displays the passed arguments to io.Writer w.  It formats
-// exactly the same as Dump.
-func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
-	fdump(c, w, a...)
-}
-
-/*
-Dump displays the passed parameters to standard out with newlines, customizable
-indentation, and additional debug information such as complete types and all
-pointer addresses used to indirect to the final value.  It provides the
-following features over the built-in printing facilities provided by the fmt
-package:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output
-
-The configuration options are controlled by modifying the public members
-of c.  See ConfigState for options documentation.
-
-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
-get the formatted result as a string.
-*/
-func (c *ConfigState) Dump(a ...interface{}) {
-	fdump(c, os.Stdout, a...)
-}
-
-// Sdump returns a string with the passed arguments formatted exactly the same
-// as Dump.
-func (c *ConfigState) Sdump(a ...interface{}) string {
-	var buf bytes.Buffer
-	fdump(c, &buf, a...)
-	return buf.String()
-}
-
-// convertArgs accepts a slice of arguments and returns a slice of the same
-// length with each argument converted to a spew Formatter interface using
-// the ConfigState associated with s.
-func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
-	formatters = make([]interface{}, len(args))
-	for index, arg := range args {
-		formatters[index] = newFormatter(c, arg)
-	}
-	return formatters
-}
-
-// NewDefaultConfig returns a ConfigState with the following default settings.
-//
-// 	Indent: " "
-// 	MaxDepth: 0
-// 	DisableMethods: false
-// 	DisablePointerMethods: false
-// 	ContinueOnMethod: false
-// 	SortKeys: false
-func NewDefaultConfig() *ConfigState {
-	return &ConfigState{Indent: " "}
-}

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

@@ -1,211 +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 implements a deep pretty printer for Go data structures to aid in
-debugging.
-
-A quick overview of the additional features spew provides over the built-in
-printing facilities for Go data types are as follows:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output (only when using
-	  Dump style)
-
-There are two different approaches spew allows for dumping Go data structures:
-
-	* Dump style which prints with newlines, customizable indentation,
-	  and additional debug information such as types and all pointer addresses
-	  used to indirect to the final value
-	* A custom Formatter interface that integrates cleanly with the standard fmt
-	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
-	  similar to the default %v while providing the additional functionality
-	  outlined above and passing unsupported format verbs such as %x and %q
-	  along to fmt
-
-Quick Start
-
-This section demonstrates how to quickly get started with spew.  See the
-sections below for further details on formatting and configuration options.
-
-To dump a variable with full newlines, indentation, type, and pointer
-information use Dump, Fdump, or Sdump:
-	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):
-	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)
-
-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.
-
-The following configuration options are available:
-	* 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.
-		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
-		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.
-
-Dump Usage
-
-Simply call spew.Dump with a list of variables you want to dump:
-
-	spew.Dump(myVar1, myVar2, ...)
-
-You may also call spew.Fdump if you would prefer to output to an arbitrary
-io.Writer.  For example, to dump to standard error:
-
-	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
-
-A third option is to call spew.Sdump to get the formatted output as a string:
-
-	str := spew.Sdump(myVar1, myVar2, ...)
-
-Sample Dump Output
-
-See the Dump example for details on the setup of the types and variables being
-shown here.
-
-	(main.Foo) {
-	 unexportedField: (*main.Bar)(0xf84002e210)({
-	  flag: (main.Flag) flagTwo,
-	  data: (uintptr) <nil>
-	 }),
-	 ExportedField: (map[interface {}]interface {}) (len=1) {
-	  (string) (len=3) "one": (bool) true
-	 }
-	}
-
-Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
-command as shown.
-	([]uint8) (len=32 cap=32) {
-	 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|
-	}
-
-Custom Formatter
-
-Spew provides a custom formatter that implements the fmt.Formatter interface
-so that it integrates cleanly with standard fmt package printing functions. The
-formatter is useful for inline printing of smaller data types similar to the
-standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Custom Formatter Usage
-
-The simplest way to make use of the spew custom formatter is to call one of the
-convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
-functions have syntax you are most likely already familiar with:
-
-	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-	spew.Println(myVar, myVar2)
-	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-
-See the Index for the full list convenience functions.
-
-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>}
-
-See the Printf example for details on the setup of variables being shown
-here.
-
-Errors
-
-Since it is possible for custom Stringer/error interfaces to panic, spew
-detects them and handles them internally by printing the panic information
-inline with the output.  Since spew is intended to provide deep pretty printing
-capabilities on structures, it intentionally does not return any errors.
-*/
-package spew

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

@@ -1,509 +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"
-	"encoding/hex"
-	"fmt"
-	"io"
-	"os"
-	"reflect"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-var (
-	// uint8Type is a reflect.Type representing a uint8.  It is used to
-	// convert cgo types to uint8 slices for hexdumping.
-	uint8Type = reflect.TypeOf(uint8(0))
-
-	// cCharRE is a regular expression that matches a cgo char.
-	// It is used to detect character arrays to hexdump them.
-	cCharRE = regexp.MustCompile("^.*\\._Ctype_char$")
-
-	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
-	// char.  It is used to detect unsigned character arrays to hexdump
-	// them.
-	cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$")
-
-	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
-	// It is used to detect uint8_t arrays to hexdump them.
-	cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$")
-)
-
-// dumpState contains information about the state of a dump operation.
-type dumpState struct {
-	w                io.Writer
-	depth            int
-	pointers         map[uintptr]int
-	ignoreNextType   bool
-	ignoreNextIndent bool
-	cs               *ConfigState
-}
-
-// indent performs indentation according to the depth level and cs.Indent
-// option.
-func (d *dumpState) indent() {
-	if d.ignoreNextIndent {
-		d.ignoreNextIndent = false
-		return
-	}
-	d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
-}
-
-// unpackValue returns values inside of non-nil interfaces when possible.
-// This is useful for data types like structs, arrays, slices, and maps which
-// can contain varying types packed inside an interface.
-func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Interface && !v.IsNil() {
-		v = v.Elem()
-	}
-	return v
-}
-
-// dumpPtr handles formatting of pointers by indirecting them as necessary.
-func (d *dumpState) dumpPtr(v reflect.Value) {
-	// Remove pointers at or below the current depth from map used to detect
-	// circular refs.
-	for k, depth := range d.pointers {
-		if depth >= d.depth {
-			delete(d.pointers, k)
-		}
-	}
-
-	// Keep list of all dereferenced pointers to show later.
-	pointerChain := make([]uintptr, 0)
-
-	// Figure out how many levels of indirection there are by dereferencing
-	// pointers and unpacking interfaces down the chain while detecting circular
-	// references.
-	nilFound := false
-	cycleFound := false
-	indirects := 0
-	ve := v
-	for ve.Kind() == reflect.Ptr {
-		if ve.IsNil() {
-			nilFound = true
-			break
-		}
-		indirects++
-		addr := ve.Pointer()
-		pointerChain = append(pointerChain, addr)
-		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
-			cycleFound = true
-			indirects--
-			break
-		}
-		d.pointers[addr] = d.depth
-
-		ve = ve.Elem()
-		if ve.Kind() == reflect.Interface {
-			if ve.IsNil() {
-				nilFound = true
-				break
-			}
-			ve = ve.Elem()
-		}
-	}
-
-	// Display type information.
-	d.w.Write(openParenBytes)
-	d.w.Write(bytes.Repeat(asteriskBytes, indirects))
-	d.w.Write([]byte(ve.Type().String()))
-	d.w.Write(closeParenBytes)
-
-	// Display pointer information.
-	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
-		d.w.Write(openParenBytes)
-		for i, addr := range pointerChain {
-			if i > 0 {
-				d.w.Write(pointerChainBytes)
-			}
-			printHexPtr(d.w, addr)
-		}
-		d.w.Write(closeParenBytes)
-	}
-
-	// Display dereferenced value.
-	d.w.Write(openParenBytes)
-	switch {
-	case nilFound == true:
-		d.w.Write(nilAngleBytes)
-
-	case cycleFound == true:
-		d.w.Write(circularBytes)
-
-	default:
-		d.ignoreNextType = true
-		d.dump(ve)
-	}
-	d.w.Write(closeParenBytes)
-}
-
-// dumpSlice handles formatting of arrays and slices.  Byte (uint8 under
-// reflection) arrays and slices are dumped in hexdump -C fashion.
-func (d *dumpState) dumpSlice(v reflect.Value) {
-	// Determine whether this type should be hex dumped or not.  Also,
-	// for types which should be hexdumped, try to use the underlying data
-	// first, then fall back to trying to convert them to a uint8 slice.
-	var buf []uint8
-	doConvert := false
-	doHexDump := false
-	numEntries := v.Len()
-	if numEntries > 0 {
-		vt := v.Index(0).Type()
-		vts := vt.String()
-		switch {
-		// C types that need to be converted.
-		case cCharRE.MatchString(vts):
-			fallthrough
-		case cUnsignedCharRE.MatchString(vts):
-			fallthrough
-		case cUint8tCharRE.MatchString(vts):
-			doConvert = true
-
-		// Try to use existing uint8 slices and fall back to converting
-		// and copying if that fails.
-		case vt.Kind() == reflect.Uint8:
-			// We need an addressable interface to convert the type
-			// to a byte slice.  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 available, to
-			// bypass these restrictions since this package does not
-			// mutate the values.
-			vs := v
-			if !vs.CanInterface() || !vs.CanAddr() {
-				vs = unsafeReflectValue(vs)
-			}
-			if !UnsafeDisabled {
-				vs = vs.Slice(0, numEntries)
-
-				// Use the existing uint8 slice if it can be
-				// type asserted.
-				iface := vs.Interface()
-				if slice, ok := iface.([]uint8); ok {
-					buf = slice
-					doHexDump = true
-					break
-				}
-			}
-
-			// The underlying data needs to be converted if it can't
-			// be type asserted to a uint8 slice.
-			doConvert = true
-		}
-
-		// Copy and convert the underlying type if needed.
-		if doConvert && vt.ConvertibleTo(uint8Type) {
-			// Convert and copy each element into a uint8 byte
-			// slice.
-			buf = make([]uint8, numEntries)
-			for i := 0; i < numEntries; i++ {
-				vv := v.Index(i)
-				buf[i] = uint8(vv.Convert(uint8Type).Uint())
-			}
-			doHexDump = true
-		}
-	}
-
-	// Hexdump the entire slice as needed.
-	if doHexDump {
-		indent := strings.Repeat(d.cs.Indent, d.depth)
-		str := indent + hex.Dump(buf)
-		str = strings.Replace(str, "\n", "\n"+indent, -1)
-		str = strings.TrimRight(str, d.cs.Indent)
-		d.w.Write([]byte(str))
-		return
-	}
-
-	// Recursively call dump for each item.
-	for i := 0; i < numEntries; i++ {
-		d.dump(d.unpackValue(v.Index(i)))
-		if i < (numEntries - 1) {
-			d.w.Write(commaNewlineBytes)
-		} else {
-			d.w.Write(newlineBytes)
-		}
-	}
-}
-
-// dump is the main workhorse for dumping a value.  It uses the passed reflect
-// value to figure out what kind of object we are dealing with and formats it
-// appropriately.  It is a recursive function, however circular data structures
-// are detected and handled properly.
-func (d *dumpState) dump(v reflect.Value) {
-	// Handle invalid reflect values immediately.
-	kind := v.Kind()
-	if kind == reflect.Invalid {
-		d.w.Write(invalidAngleBytes)
-		return
-	}
-
-	// Handle pointers specially.
-	if kind == reflect.Ptr {
-		d.indent()
-		d.dumpPtr(v)
-		return
-	}
-
-	// Print type information unless already handled elsewhere.
-	if !d.ignoreNextType {
-		d.indent()
-		d.w.Write(openParenBytes)
-		d.w.Write([]byte(v.Type().String()))
-		d.w.Write(closeParenBytes)
-		d.w.Write(spaceBytes)
-	}
-	d.ignoreNextType = false
-
-	// Display length and capacity if the built-in len and cap functions
-	// work with the value's kind and the len/cap itself is non-zero.
-	valueLen, valueCap := 0, 0
-	switch v.Kind() {
-	case reflect.Array, reflect.Slice, reflect.Chan:
-		valueLen, valueCap = v.Len(), v.Cap()
-	case reflect.Map, reflect.String:
-		valueLen = v.Len()
-	}
-	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
-		d.w.Write(openParenBytes)
-		if valueLen != 0 {
-			d.w.Write(lenEqualsBytes)
-			printInt(d.w, int64(valueLen), 10)
-		}
-		if !d.cs.DisableCapacities && valueCap != 0 {
-			if valueLen != 0 {
-				d.w.Write(spaceBytes)
-			}
-			d.w.Write(capEqualsBytes)
-			printInt(d.w, int64(valueCap), 10)
-		}
-		d.w.Write(closeParenBytes)
-		d.w.Write(spaceBytes)
-	}
-
-	// Call Stringer/error interfaces if they exist and the handle methods flag
-	// is enabled
-	if !d.cs.DisableMethods {
-		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
-			if handled := handleMethods(d.cs, d.w, v); handled {
-				return
-			}
-		}
-	}
-
-	switch kind {
-	case reflect.Invalid:
-		// Do nothing.  We should never get here since invalid has already
-		// been handled above.
-
-	case reflect.Bool:
-		printBool(d.w, v.Bool())
-
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		printInt(d.w, v.Int(), 10)
-
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		printUint(d.w, v.Uint(), 10)
-
-	case reflect.Float32:
-		printFloat(d.w, v.Float(), 32)
-
-	case reflect.Float64:
-		printFloat(d.w, v.Float(), 64)
-
-	case reflect.Complex64:
-		printComplex(d.w, v.Complex(), 32)
-
-	case reflect.Complex128:
-		printComplex(d.w, v.Complex(), 64)
-
-	case reflect.Slice:
-		if v.IsNil() {
-			d.w.Write(nilAngleBytes)
-			break
-		}
-		fallthrough
-
-	case reflect.Array:
-		d.w.Write(openBraceNewlineBytes)
-		d.depth++
-		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
-			d.indent()
-			d.w.Write(maxNewlineBytes)
-		} else {
-			d.dumpSlice(v)
-		}
-		d.depth--
-		d.indent()
-		d.w.Write(closeBraceBytes)
-
-	case reflect.String:
-		d.w.Write([]byte(strconv.Quote(v.String())))
-
-	case reflect.Interface:
-		// The only time we should get here is for nil interfaces due to
-		// unpackValue calls.
-		if v.IsNil() {
-			d.w.Write(nilAngleBytes)
-		}
-
-	case reflect.Ptr:
-		// Do nothing.  We should never get here since pointers have already
-		// been handled above.
-
-	case reflect.Map:
-		// nil maps should be indicated as different than empty maps
-		if v.IsNil() {
-			d.w.Write(nilAngleBytes)
-			break
-		}
-
-		d.w.Write(openBraceNewlineBytes)
-		d.depth++
-		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
-			d.indent()
-			d.w.Write(maxNewlineBytes)
-		} else {
-			numEntries := v.Len()
-			keys := v.MapKeys()
-			if d.cs.SortKeys {
-				sortValues(keys, d.cs)
-			}
-			for i, key := range keys {
-				d.dump(d.unpackValue(key))
-				d.w.Write(colonSpaceBytes)
-				d.ignoreNextIndent = true
-				d.dump(d.unpackValue(v.MapIndex(key)))
-				if i < (numEntries - 1) {
-					d.w.Write(commaNewlineBytes)
-				} else {
-					d.w.Write(newlineBytes)
-				}
-			}
-		}
-		d.depth--
-		d.indent()
-		d.w.Write(closeBraceBytes)
-
-	case reflect.Struct:
-		d.w.Write(openBraceNewlineBytes)
-		d.depth++
-		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
-			d.indent()
-			d.w.Write(maxNewlineBytes)
-		} else {
-			vt := v.Type()
-			numFields := v.NumField()
-			for i := 0; i < numFields; i++ {
-				d.indent()
-				vtf := vt.Field(i)
-				d.w.Write([]byte(vtf.Name))
-				d.w.Write(colonSpaceBytes)
-				d.ignoreNextIndent = true
-				d.dump(d.unpackValue(v.Field(i)))
-				if i < (numFields - 1) {
-					d.w.Write(commaNewlineBytes)
-				} else {
-					d.w.Write(newlineBytes)
-				}
-			}
-		}
-		d.depth--
-		d.indent()
-		d.w.Write(closeBraceBytes)
-
-	case reflect.Uintptr:
-		printHexPtr(d.w, uintptr(v.Uint()))
-
-	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
-		printHexPtr(d.w, v.Pointer())
-
-	// There were not any other types at the time this code was written, but
-	// fall back to letting the default fmt package handle it in case any new
-	// types are added.
-	default:
-		if v.CanInterface() {
-			fmt.Fprintf(d.w, "%v", v.Interface())
-		} else {
-			fmt.Fprintf(d.w, "%v", v.String())
-		}
-	}
-}
-
-// fdump is a helper function to consolidate the logic from the various public
-// methods which take varying writers and config states.
-func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
-	for _, arg := range a {
-		if arg == nil {
-			w.Write(interfaceBytes)
-			w.Write(spaceBytes)
-			w.Write(nilAngleBytes)
-			w.Write(newlineBytes)
-			continue
-		}
-
-		d := dumpState{w: w, cs: cs}
-		d.pointers = make(map[uintptr]int)
-		d.dump(reflect.ValueOf(arg))
-		d.w.Write(newlineBytes)
-	}
-}
-
-// Fdump formats and displays the passed arguments to io.Writer w.  It formats
-// exactly the same as Dump.
-func Fdump(w io.Writer, a ...interface{}) {
-	fdump(&Config, w, a...)
-}
-
-// Sdump returns a string with the passed arguments formatted exactly the same
-// as Dump.
-func Sdump(a ...interface{}) string {
-	var buf bytes.Buffer
-	fdump(&Config, &buf, a...)
-	return buf.String()
-}
-
-/*
-Dump displays the passed parameters to standard out with newlines, customizable
-indentation, and additional debug information such as complete types and all
-pointer addresses used to indirect to the final value.  It provides the
-following features over the built-in printing facilities provided by the fmt
-package:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output
-
-The configuration options are controlled by an exported package global,
-spew.Config.  See ConfigState for options documentation.
-
-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
-get the formatted result as a string.
-*/
-func Dump(a ...interface{}) {
-	fdump(&Config, os.Stdout, a...)
-}

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

@@ -1,419 +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"
-	"reflect"
-	"strconv"
-	"strings"
-)
-
-// supportedFlags is a list of all the character flags supported by fmt package.
-const supportedFlags = "0-+# "
-
-// formatState implements the fmt.Formatter interface and contains information
-// about the state of a formatting operation.  The NewFormatter function can
-// be used to get a new Formatter which can be used directly as arguments
-// in standard fmt package printing calls.
-type formatState struct {
-	value          interface{}
-	fs             fmt.State
-	depth          int
-	pointers       map[uintptr]int
-	ignoreNextType bool
-	cs             *ConfigState
-}
-
-// buildDefaultFormat recreates the original format string without precision
-// and width information to pass in to fmt.Sprintf in the case of an
-// unrecognized type.  Unless new types are added to the language, this
-// function won't ever be called.
-func (f *formatState) buildDefaultFormat() (format string) {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range supportedFlags {
-		if f.fs.Flag(int(flag)) {
-			buf.WriteRune(flag)
-		}
-	}
-
-	buf.WriteRune('v')
-
-	format = buf.String()
-	return format
-}
-
-// constructOrigFormat recreates the original format string including precision
-// and width information to pass along to the standard fmt package.  This allows
-// automatic deferral of all format strings this package doesn't support.
-func (f *formatState) constructOrigFormat(verb rune) (format string) {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range supportedFlags {
-		if f.fs.Flag(int(flag)) {
-			buf.WriteRune(flag)
-		}
-	}
-
-	if width, ok := f.fs.Width(); ok {
-		buf.WriteString(strconv.Itoa(width))
-	}
-
-	if precision, ok := f.fs.Precision(); ok {
-		buf.Write(precisionBytes)
-		buf.WriteString(strconv.Itoa(precision))
-	}
-
-	buf.WriteRune(verb)
-
-	format = buf.String()
-	return format
-}
-
-// unpackValue returns values inside of non-nil interfaces when possible and
-// ensures that types for values which have been unpacked from an interface
-// are displayed when the show types flag is also set.
-// This is useful for data types like structs, arrays, slices, and maps which
-// can contain varying types packed inside an interface.
-func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Interface {
-		f.ignoreNextType = false
-		if !v.IsNil() {
-			v = v.Elem()
-		}
-	}
-	return v
-}
-
-// formatPtr handles formatting of pointers by indirecting them as necessary.
-func (f *formatState) formatPtr(v reflect.Value) {
-	// Display nil if top level pointer is nil.
-	showTypes := f.fs.Flag('#')
-	if v.IsNil() && (!showTypes || f.ignoreNextType) {
-		f.fs.Write(nilAngleBytes)
-		return
-	}
-
-	// Remove pointers at or below the current depth from map used to detect
-	// circular refs.
-	for k, depth := range f.pointers {
-		if depth >= f.depth {
-			delete(f.pointers, k)
-		}
-	}
-
-	// Keep list of all dereferenced pointers to possibly show later.
-	pointerChain := make([]uintptr, 0)
-
-	// Figure out how many levels of indirection there are by derferencing
-	// pointers and unpacking interfaces down the chain while detecting circular
-	// references.
-	nilFound := false
-	cycleFound := false
-	indirects := 0
-	ve := v
-	for ve.Kind() == reflect.Ptr {
-		if ve.IsNil() {
-			nilFound = true
-			break
-		}
-		indirects++
-		addr := ve.Pointer()
-		pointerChain = append(pointerChain, addr)
-		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
-			cycleFound = true
-			indirects--
-			break
-		}
-		f.pointers[addr] = f.depth
-
-		ve = ve.Elem()
-		if ve.Kind() == reflect.Interface {
-			if ve.IsNil() {
-				nilFound = true
-				break
-			}
-			ve = ve.Elem()
-		}
-	}
-
-	// Display type or indirection level depending on flags.
-	if showTypes && !f.ignoreNextType {
-		f.fs.Write(openParenBytes)
-		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
-		f.fs.Write([]byte(ve.Type().String()))
-		f.fs.Write(closeParenBytes)
-	} else {
-		if nilFound || cycleFound {
-			indirects += strings.Count(ve.Type().String(), "*")
-		}
-		f.fs.Write(openAngleBytes)
-		f.fs.Write([]byte(strings.Repeat("*", indirects)))
-		f.fs.Write(closeAngleBytes)
-	}
-
-	// Display pointer information depending on flags.
-	if f.fs.Flag('+') && (len(pointerChain) > 0) {
-		f.fs.Write(openParenBytes)
-		for i, addr := range pointerChain {
-			if i > 0 {
-				f.fs.Write(pointerChainBytes)
-			}
-			printHexPtr(f.fs, addr)
-		}
-		f.fs.Write(closeParenBytes)
-	}
-
-	// Display dereferenced value.
-	switch {
-	case nilFound == true:
-		f.fs.Write(nilAngleBytes)
-
-	case cycleFound == true:
-		f.fs.Write(circularShortBytes)
-
-	default:
-		f.ignoreNextType = true
-		f.format(ve)
-	}
-}
-
-// format is the main workhorse for providing the Formatter interface.  It
-// uses the passed reflect value to figure out what kind of object we are
-// dealing with and formats it appropriately.  It is a recursive function,
-// however circular data structures are detected and handled properly.
-func (f *formatState) format(v reflect.Value) {
-	// Handle invalid reflect values immediately.
-	kind := v.Kind()
-	if kind == reflect.Invalid {
-		f.fs.Write(invalidAngleBytes)
-		return
-	}
-
-	// Handle pointers specially.
-	if kind == reflect.Ptr {
-		f.formatPtr(v)
-		return
-	}
-
-	// Print type information unless already handled elsewhere.
-	if !f.ignoreNextType && f.fs.Flag('#') {
-		f.fs.Write(openParenBytes)
-		f.fs.Write([]byte(v.Type().String()))
-		f.fs.Write(closeParenBytes)
-	}
-	f.ignoreNextType = false
-
-	// Call Stringer/error interfaces if they exist and the handle methods
-	// flag is enabled.
-	if !f.cs.DisableMethods {
-		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
-			if handled := handleMethods(f.cs, f.fs, v); handled {
-				return
-			}
-		}
-	}
-
-	switch kind {
-	case reflect.Invalid:
-		// Do nothing.  We should never get here since invalid has already
-		// been handled above.
-
-	case reflect.Bool:
-		printBool(f.fs, v.Bool())
-
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		printInt(f.fs, v.Int(), 10)
-
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		printUint(f.fs, v.Uint(), 10)
-
-	case reflect.Float32:
-		printFloat(f.fs, v.Float(), 32)
-
-	case reflect.Float64:
-		printFloat(f.fs, v.Float(), 64)
-
-	case reflect.Complex64:
-		printComplex(f.fs, v.Complex(), 32)
-
-	case reflect.Complex128:
-		printComplex(f.fs, v.Complex(), 64)
-
-	case reflect.Slice:
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-			break
-		}
-		fallthrough
-
-	case reflect.Array:
-		f.fs.Write(openBracketBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			numEntries := v.Len()
-			for i := 0; i < numEntries; i++ {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				f.ignoreNextType = true
-				f.format(f.unpackValue(v.Index(i)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeBracketBytes)
-
-	case reflect.String:
-		f.fs.Write([]byte(v.String()))
-
-	case reflect.Interface:
-		// The only time we should get here is for nil interfaces due to
-		// unpackValue calls.
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-		}
-
-	case reflect.Ptr:
-		// Do nothing.  We should never get here since pointers have already
-		// been handled above.
-
-	case reflect.Map:
-		// nil maps should be indicated as different than empty maps
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-			break
-		}
-
-		f.fs.Write(openMapBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			keys := v.MapKeys()
-			if f.cs.SortKeys {
-				sortValues(keys, f.cs)
-			}
-			for i, key := range keys {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				f.ignoreNextType = true
-				f.format(f.unpackValue(key))
-				f.fs.Write(colonBytes)
-				f.ignoreNextType = true
-				f.format(f.unpackValue(v.MapIndex(key)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeMapBytes)
-
-	case reflect.Struct:
-		numFields := v.NumField()
-		f.fs.Write(openBraceBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			vt := v.Type()
-			for i := 0; i < numFields; i++ {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				vtf := vt.Field(i)
-				if f.fs.Flag('+') || f.fs.Flag('#') {
-					f.fs.Write([]byte(vtf.Name))
-					f.fs.Write(colonBytes)
-				}
-				f.format(f.unpackValue(v.Field(i)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeBraceBytes)
-
-	case reflect.Uintptr:
-		printHexPtr(f.fs, uintptr(v.Uint()))
-
-	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
-		printHexPtr(f.fs, v.Pointer())
-
-	// There were not any other types at the time this code was written, but
-	// fall back to letting the default fmt package handle it if any get added.
-	default:
-		format := f.buildDefaultFormat()
-		if v.CanInterface() {
-			fmt.Fprintf(f.fs, format, v.Interface())
-		} else {
-			fmt.Fprintf(f.fs, format, v.String())
-		}
-	}
-}
-
-// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
-// details.
-func (f *formatState) Format(fs fmt.State, verb rune) {
-	f.fs = fs
-
-	// Use standard formatting for verbs that are not v.
-	if verb != 'v' {
-		format := f.constructOrigFormat(verb)
-		fmt.Fprintf(fs, format, f.value)
-		return
-	}
-
-	if f.value == nil {
-		if fs.Flag('#') {
-			fs.Write(interfaceBytes)
-		}
-		fs.Write(nilAngleBytes)
-		return
-	}
-
-	f.format(reflect.ValueOf(f.value))
-}
-
-// newFormatter is a helper function to consolidate the logic from the various
-// public methods which take varying config states.
-func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
-	fs := &formatState{value: v, cs: cs}
-	fs.pointers = make(map[uintptr]int)
-	return fs
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface.  As a result, it integrates cleanly with standard fmt package
-printing functions.  The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly.  It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-Printf, Println, or Fprintf.
-*/
-func NewFormatter(v interface{}) fmt.Formatter {
-	return newFormatter(&Config, v)
-}

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

@@ -1,148 +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 (
-	"fmt"
-	"io"
-)
-
-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the formatted string as a value that satisfies error.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Errorf(format string, a ...interface{}) (err error) {
-	return fmt.Errorf(format, convertArgs(a)...)
-}
-
-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprint(w, convertArgs(a)...)
-}
-
-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	return fmt.Fprintf(w, format, convertArgs(a)...)
-}
-
-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
-// passed with a default Formatter interface returned by NewFormatter.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprintln(w, convertArgs(a)...)
-}
-
-// Print is a wrapper for fmt.Print that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
-func Print(a ...interface{}) (n int, err error) {
-	return fmt.Print(convertArgs(a)...)
-}
-
-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Printf(format string, a ...interface{}) (n int, err error) {
-	return fmt.Printf(format, convertArgs(a)...)
-}
-
-// Println is a wrapper for fmt.Println that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
-func Println(a ...interface{}) (n int, err error) {
-	return fmt.Println(convertArgs(a)...)
-}
-
-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprint(a ...interface{}) string {
-	return fmt.Sprint(convertArgs(a)...)
-}
-
-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprintf(format string, a ...interface{}) string {
-	return fmt.Sprintf(format, convertArgs(a)...)
-}
-
-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
-// were passed with a default Formatter interface returned by NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprintln(a ...interface{}) string {
-	return fmt.Sprintln(convertArgs(a)...)
-}
-
-// convertArgs accepts a slice of arguments and returns a slice of the same
-// length with each argument converted to a default spew Formatter interface.
-func convertArgs(args []interface{}) (formatters []interface{}) {
-	formatters = make([]interface{}, len(args))
-	for index, arg := range args {
-		formatters[index] = NewFormatter(arg)
-	}
-	return formatters
-}

vendor/github.com/joho/godotenv/LICENCE

@@ -1,23 +0,0 @@
-Copyright (c) 2013 John Barton
-
-MIT License
-
-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/joho/godotenv/README.md

@@ -1,127 +0,0 @@
-# GoDotEnv [![Build Status](https://travis-ci.org/joho/godotenv.svg?branch=master)](https://travis-ci.org/joho/godotenv) [![Build status](https://ci.appveyor.com/api/projects/status/9v40vnfvvgde64u4?svg=true)](https://ci.appveyor.com/project/joho/godotenv)
-
-A Go (golang) port of the Ruby dotenv project (which loads env vars from a .env file)
-
-From the original Library:
-
-> Storing configuration in the environment is one of the tenets of a twelve-factor app. Anything that is likely to change between deployment environments–such as resource handles for databases or credentials for external services–should be extracted from the code into environment variables.
->
-> But it is not always practical to set environment variables on development machines or continuous integration servers where multiple projects are run. Dotenv load variables from a .env file into ENV when the environment is bootstrapped.
-
-It can be used as a library (for loading in env for your own daemons etc) or as a bin command.
-
-There is test coverage and CI for both linuxish and windows environments, but I make no guarantees about the bin version working on windows.
-
-## Installation
-
-As a library
-
-```shell
-go get github.com/joho/godotenv
-```
-
-or if you want to use it as a bin command
-```shell
-go get github.com/joho/godotenv/cmd/godotenv
-```
-
-## Usage
-
-Add your application configuration to your `.env` file in the root of your project:
-
-```shell
-S3_BUCKET=YOURS3BUCKET
-SECRET_KEY=YOURSECRETKEYGOESHERE
-```
-
-Then in your Go app you can do something like
-
-```go
-package main
-
-import (
-    "github.com/joho/godotenv"
-    "log"
-    "os"
-)
-
-func main() {
-  err := godotenv.Load()
-  if err != nil {
-    log.Fatal("Error loading .env file")
-  }
-
-  s3Bucket := os.Getenv("S3_BUCKET")
-  secretKey := os.Getenv("SECRET_KEY")
-
-  // now do something with s3 or whatever
-}
-```
-
-If you're even lazier than that, you can just take advantage of the autoload package which will read in `.env` on import
-
-```go
-import _ "github.com/joho/godotenv/autoload"
-```
-
-While `.env` in the project root is the default, you don't have to be constrained, both examples below are 100% legit
-
-```go
-_ = godotenv.Load("somerandomfile")
-_ = godotenv.Load("filenumberone.env", "filenumbertwo.env")
-```
-
-If you want to be really fancy with your env file you can do comments and exports (below is a valid env file)
-
-```shell
-# I am a comment and that is OK
-SOME_VAR=someval
-FOO=BAR # comments at line end are OK too
-export BAR=BAZ
-```
-
-Or finally you can do YAML(ish) style
-
-```yaml
-FOO: bar
-BAR: baz
-```
-
-as a final aside, if you don't want godotenv munging your env you can just get a map back instead
-
-```go
-var myEnv map[string]string
-myEnv, err := godotenv.Read()
-
-s3Bucket := myEnv["S3_BUCKET"]
-```
-
-### Command Mode
-
-Assuming you've installed the command as above and you've got `$GOPATH/bin` in your `$PATH`
-
-```
-godotenv -f /some/path/to/.env some_command with some args
-```
-
-If you don't specify `-f` it will fall back on the default of loading `.env` in `PWD`
-
-## Contributing
-
-Contributions are most welcome! The parser itself is pretty stupidly naive and I wouldn't be surprised if it breaks with edge cases.
-
-*code changes without tests will not be accepted*
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
-## CI
-
-Linux: [![wercker status](https://app.wercker.com/status/507594c2ec7e60f19403a568dfea0f78/m "wercker status")](https://app.wercker.com/project/bykey/507594c2ec7e60f19403a568dfea0f78) Windows: [![Build status](https://ci.appveyor.com/api/projects/status/9v40vnfvvgde64u4)](https://ci.appveyor.com/project/joho/godotenv)
-
-## Who?
-
-The original library [dotenv](https://github.com/bkeepers/dotenv) was written by [Brandon Keepers](http://opensoul.org/), and this port was done by [John Barton](http://whoisjohnbarton.com) based off the tests/fixtures in the original library.

vendor/github.com/joho/godotenv/autoload/autoload.go

@@ -1,15 +0,0 @@
-package autoload
-
-/*
-	You can just read the .env file on import just by doing
-
-		import _ "github.com/joho/godotenv/autoload"
-
-	And bob's your mother's brother
-*/
-
-import "github.com/joho/godotenv"
-
-func init() {
-	godotenv.Load()
-}

vendor/github.com/joho/godotenv/godotenv.go

@@ -1,247 +0,0 @@
-// Package godotenv is a go port of the ruby dotenv library (https://github.com/bkeepers/dotenv)
-//
-// Examples/readme can be found on the github page at https://github.com/joho/godotenv
-//
-// The TL;DR is that you make a .env file that looks something like
-//
-// 		SOME_ENV_VAR=somevalue
-//
-// and then in your go code you can call
-//
-// 		godotenv.Load()
-//
-// and all the env vars declared in .env will be avaiable through os.Getenv("SOME_ENV_VAR")
-package godotenv
-
-import (
-	"bufio"
-	"errors"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-// Load will read your env file(s) and load them into ENV for this process.
-//
-// Call this function as close as possible to the start of your program (ideally in main)
-//
-// If you call Load without any args it will default to loading .env in the current path
-//
-// You can otherwise tell it which files to load (there can be more than one) like
-//
-//		godotenv.Load("fileone", "filetwo")
-//
-// It's important to note that it WILL NOT OVERRIDE an env variable that already exists - consider the .env file to set dev vars or sensible defaults
-func Load(filenames ...string) (err error) {
-	filenames = filenamesOrDefault(filenames)
-
-	for _, filename := range filenames {
-		err = loadFile(filename, false)
-		if err != nil {
-			return // return early on a spazout
-		}
-	}
-	return
-}
-
-// Overload will read your env file(s) and load them into ENV for this process.
-//
-// Call this function as close as possible to the start of your program (ideally in main)
-//
-// If you call Overload without any args it will default to loading .env in the current path
-//
-// You can otherwise tell it which files to load (there can be more than one) like
-//
-//		godotenv.Overload("fileone", "filetwo")
-//
-// It's important to note this WILL OVERRIDE an env variable that already exists - consider the .env file to forcefilly set all vars.
-func Overload(filenames ...string) (err error) {
-	filenames = filenamesOrDefault(filenames)
-
-	for _, filename := range filenames {
-		err = loadFile(filename, true)
-		if err != nil {
-			return // return early on a spazout
-		}
-	}
-	return
-}
-
-// Read all env (with same file loading semantics as Load) but return values as
-// a map rather than automatically writing values into env
-func Read(filenames ...string) (envMap map[string]string, err error) {
-	filenames = filenamesOrDefault(filenames)
-	envMap = make(map[string]string)
-
-	for _, filename := range filenames {
-		individualEnvMap, individualErr := readFile(filename)
-
-		if individualErr != nil {
-			err = individualErr
-			return // return early on a spazout
-		}
-
-		for key, value := range individualEnvMap {
-			envMap[key] = value
-		}
-	}
-
-	return
-}
-
-// Exec loads env vars from the specified filenames (empty map falls back to default)
-// then executes the cmd specified.
-//
-// Simply hooks up os.Stdin/err/out to the command and calls Run()
-//
-// If you want more fine grained control over your command it's recommended
-// that you use `Load()` or `Read()` and the `os/exec` package yourself.
-func Exec(filenames []string, cmd string, cmdArgs []string) error {
-	Load(filenames...)
-
-	command := exec.Command(cmd, cmdArgs...)
-	command.Stdin = os.Stdin
-	command.Stdout = os.Stdout
-	command.Stderr = os.Stderr
-	return command.Run()
-}
-
-func filenamesOrDefault(filenames []string) []string {
-	if len(filenames) == 0 {
-		return []string{".env"}
-	}
-	return filenames
-}
-
-func loadFile(filename string, overload bool) error {
-	envMap, err := readFile(filename)
-	if err != nil {
-		return err
-	}
-
-	currentEnv := map[string]bool{}
-	rawEnv := os.Environ()
-	for _, rawEnvLine := range rawEnv {
-		key := strings.Split(rawEnvLine, "=")[0]
-		currentEnv[key] = true
-	}
-
-	for key, value := range envMap {
-		if !currentEnv[key] || overload {
-			os.Setenv(key, value)
-		}
-	}
-
-	return nil
-}
-
-func readFile(filename string) (envMap map[string]string, err error) {
-	file, err := os.Open(filename)
-	if err != nil {
-		return
-	}
-	defer file.Close()
-
-	envMap = make(map[string]string)
-
-	var lines []string
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		lines = append(lines, scanner.Text())
-	}
-
-	if err = scanner.Err(); err != nil {
-		return
-	}
-
-	for _, fullLine := range lines {
-		if !isIgnoredLine(fullLine) {
-			var key, value string
-			key, value, err = parseLine(fullLine)
-
-			if err != nil {
-				return
-			}
-			envMap[key] = value
-		}
-	}
-	return
-}
-
-func parseLine(line string) (key string, value string, err error) {
-	if len(line) == 0 {
-		err = errors.New("zero length string")
-		return
-	}
-
-	// ditch the comments (but keep quoted hashes)
-	if strings.Contains(line, "#") {
-		segmentsBetweenHashes := strings.Split(line, "#")
-		quotesAreOpen := false
-		var segmentsToKeep []string
-		for _, segment := range segmentsBetweenHashes {
-			if strings.Count(segment, "\"") == 1 || strings.Count(segment, "'") == 1 {
-				if quotesAreOpen {
-					quotesAreOpen = false
-					segmentsToKeep = append(segmentsToKeep, segment)
-				} else {
-					quotesAreOpen = true
-				}
-			}
-
-			if len(segmentsToKeep) == 0 || quotesAreOpen {
-				segmentsToKeep = append(segmentsToKeep, segment)
-			}
-		}
-
-		line = strings.Join(segmentsToKeep, "#")
-	}
-
-	// now split key from value
-	splitString := strings.SplitN(line, "=", 2)
-
-	if len(splitString) != 2 {
-		// try yaml mode!
-		splitString = strings.SplitN(line, ":", 2)
-	}
-
-	if len(splitString) != 2 {
-		err = errors.New("Can't separate key from value")
-		return
-	}
-
-	// Parse the key
-	key = splitString[0]
-	if strings.HasPrefix(key, "export") {
-		key = strings.TrimPrefix(key, "export")
-	}
-	key = strings.Trim(key, " ")
-
-	// Parse the value
-	value = splitString[1]
-
-	// trim
-	value = strings.Trim(value, " ")
-
-	// check if we've got quoted values
-	if value != "" {
-		first := string(value[0:1])
-		last := string(value[len(value)-1:])
-		if first == last && strings.ContainsAny(first, `"'`) {
-			// pull the quotes off the edges
-			value = strings.Trim(value, `"'`)
-
-			// expand quotes
-			value = strings.Replace(value, `\"`, `"`, -1)
-			// expand newlines
-			value = strings.Replace(value, `\n`, "\n", -1)
-		}
-	}
-
-	return
-}
-
-func isIgnoredLine(line string) bool {
-	trimmedLine := strings.Trim(line, " \n\t")
-	return len(trimmedLine) == 0 || strings.HasPrefix(trimmedLine, "#")
-}

vendor/github.com/pmezard/go-difflib/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2013, Patrick Mezard
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-    The names of its contributors may not be used to endorse or promote
-products derived from this software without specific prior written
-permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/pmezard/go-difflib/difflib/difflib.go

@@ -1,772 +0,0 @@
-// Package difflib is a partial port of Python difflib module.
-//
-// It provides tools to compare sequences of strings and generate textual diffs.
-//
-// The following class and functions have been ported:
-//
-// - SequenceMatcher
-//
-// - unified_diff
-//
-// - context_diff
-//
-// Getting unified diffs was the main goal of the port. Keep in mind this code
-// is mostly suitable to output text differences in a human friendly way, there
-// are no guarantees generated diffs are consumable by patch(1).
-package difflib
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"strings"
-)
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-func max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}
-
-func calculateRatio(matches, length int) float64 {
-	if length > 0 {
-		return 2.0 * float64(matches) / float64(length)
-	}
-	return 1.0
-}
-
-type Match struct {
-	A    int
-	B    int
-	Size int
-}
-
-type OpCode struct {
-	Tag byte
-	I1  int
-	I2  int
-	J1  int
-	J2  int
-}
-
-// SequenceMatcher compares sequence of strings. The basic
-// algorithm predates, and is a little fancier than, an algorithm
-// published in the late 1980's by Ratcliff and Obershelp under the
-// hyperbolic name "gestalt pattern matching".  The basic idea is to find
-// the longest contiguous matching subsequence that contains no "junk"
-// elements (R-O doesn't address junk).  The same idea is then applied
-// recursively to the pieces of the sequences to the left and to the right
-// of the matching subsequence.  This does not yield minimal edit
-// sequences, but does tend to yield matches that "look right" to people.
-//
-// SequenceMatcher tries to compute a "human-friendly diff" between two
-// sequences.  Unlike e.g. UNIX(tm) diff, the fundamental notion is the
-// longest *contiguous* & junk-free matching subsequence.  That's what
-// catches peoples' eyes.  The Windows(tm) windiff has another interesting
-// notion, pairing up elements that appear uniquely in each sequence.
-// That, and the method here, appear to yield more intuitive difference
-// reports than does diff.  This method appears to be the least vulnerable
-// to synching up on blocks of "junk lines", though (like blank lines in
-// ordinary text files, or maybe "<P>" lines in HTML files).  That may be
-// because this is the only method of the 3 that has a *concept* of
-// "junk" <wink>.
-//
-// Timing:  Basic R-O is cubic time worst case and quadratic time expected
-// case.  SequenceMatcher is quadratic time for the worst case and has
-// expected-case behavior dependent in a complicated way on how many
-// elements the sequences have in common; best case time is linear.
-type SequenceMatcher struct {
-	a              []string
-	b              []string
-	b2j            map[string][]int
-	IsJunk         func(string) bool
-	autoJunk       bool
-	bJunk          map[string]struct{}
-	matchingBlocks []Match
-	fullBCount     map[string]int
-	bPopular       map[string]struct{}
-	opCodes        []OpCode
-}
-
-func NewMatcher(a, b []string) *SequenceMatcher {
-	m := SequenceMatcher{autoJunk: true}
-	m.SetSeqs(a, b)
-	return &m
-}
-
-func NewMatcherWithJunk(a, b []string, autoJunk bool,
-	isJunk func(string) bool) *SequenceMatcher {
-
-	m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
-	m.SetSeqs(a, b)
-	return &m
-}
-
-// Set two sequences to be compared.
-func (m *SequenceMatcher) SetSeqs(a, b []string) {
-	m.SetSeq1(a)
-	m.SetSeq2(b)
-}
-
-// Set the first sequence to be compared. The second sequence to be compared is
-// not changed.
-//
-// SequenceMatcher computes and caches detailed information about the second
-// sequence, so if you want to compare one sequence S against many sequences,
-// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
-// sequences.
-//
-// See also SetSeqs() and SetSeq2().
-func (m *SequenceMatcher) SetSeq1(a []string) {
-	if &a == &m.a {
-		return
-	}
-	m.a = a
-	m.matchingBlocks = nil
-	m.opCodes = nil
-}
-
-// Set the second sequence to be compared. The first sequence to be compared is
-// not changed.
-func (m *SequenceMatcher) SetSeq2(b []string) {
-	if &b == &m.b {
-		return
-	}
-	m.b = b
-	m.matchingBlocks = nil
-	m.opCodes = nil
-	m.fullBCount = nil
-	m.chainB()
-}
-
-func (m *SequenceMatcher) chainB() {
-	// Populate line -> index mapping
-	b2j := map[string][]int{}
-	for i, s := range m.b {
-		indices := b2j[s]
-		indices = append(indices, i)
-		b2j[s] = indices
-	}
-
-	// Purge junk elements
-	m.bJunk = map[string]struct{}{}
-	if m.IsJunk != nil {
-		junk := m.bJunk
-		for s, _ := range b2j {
-			if m.IsJunk(s) {
-				junk[s] = struct{}{}
-			}
-		}
-		for s, _ := range junk {
-			delete(b2j, s)
-		}
-	}
-
-	// Purge remaining popular elements
-	popular := map[string]struct{}{}
-	n := len(m.b)
-	if m.autoJunk && n >= 200 {
-		ntest := n/100 + 1
-		for s, indices := range b2j {
-			if len(indices) > ntest {
-				popular[s] = struct{}{}
-			}
-		}
-		for s, _ := range popular {
-			delete(b2j, s)
-		}
-	}
-	m.bPopular = popular
-	m.b2j = b2j
-}
-
-func (m *SequenceMatcher) isBJunk(s string) bool {
-	_, ok := m.bJunk[s]
-	return ok
-}
-
-// Find longest matching block in a[alo:ahi] and b[blo:bhi].
-//
-// If IsJunk is not defined:
-//
-// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
-//     alo <= i <= i+k <= ahi
-//     blo <= j <= j+k <= bhi
-// and for all (i',j',k') meeting those conditions,
-//     k >= k'
-//     i <= i'
-//     and if i == i', j <= j'
-//
-// In other words, of all maximal matching blocks, return one that
-// starts earliest in a, and of all those maximal matching blocks that
-// start earliest in a, return the one that starts earliest in b.
-//
-// If IsJunk is defined, first the longest matching block is
-// determined as above, but with the additional restriction that no
-// junk element appears in the block.  Then that block is extended as
-// far as possible by matching (only) junk elements on both sides.  So
-// the resulting block never matches on junk except as identical junk
-// happens to be adjacent to an "interesting" match.
-//
-// If no blocks match, return (alo, blo, 0).
-func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {
-	// CAUTION:  stripping common prefix or suffix would be incorrect.
-	// E.g.,
-	//    ab
-	//    acab
-	// Longest matching block is "ab", but if common prefix is
-	// stripped, it's "a" (tied with "b").  UNIX(tm) diff does so
-	// strip, so ends up claiming that ab is changed to acab by
-	// inserting "ca" in the middle.  That's minimal but unintuitive:
-	// "it's obvious" that someone inserted "ac" at the front.
-	// Windiff ends up at the same place as diff, but by pairing up
-	// the unique 'b's and then matching the first two 'a's.
-	besti, bestj, bestsize := alo, blo, 0
-
-	// find longest junk-free match
-	// during an iteration of the loop, j2len[j] = length of longest
-	// junk-free match ending with a[i-1] and b[j]
-	j2len := map[int]int{}
-	for i := alo; i != ahi; i++ {
-		// look at all instances of a[i] in b; note that because
-		// b2j has no junk keys, the loop is skipped if a[i] is junk
-		newj2len := map[int]int{}
-		for _, j := range m.b2j[m.a[i]] {
-			// a[i] matches b[j]
-			if j < blo {
-				continue
-			}
-			if j >= bhi {
-				break
-			}
-			k := j2len[j-1] + 1
-			newj2len[j] = k
-			if k > bestsize {
-				besti, bestj, bestsize = i-k+1, j-k+1, k
-			}
-		}
-		j2len = newj2len
-	}
-
-	// Extend the best by non-junk elements on each end.  In particular,
-	// "popular" non-junk elements aren't in b2j, which greatly speeds
-	// the inner loop above, but also means "the best" match so far
-	// doesn't contain any junk *or* popular non-junk elements.
-	for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&
-		m.a[besti-1] == m.b[bestj-1] {
-		besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
-	}
-	for besti+bestsize < ahi && bestj+bestsize < bhi &&
-		!m.isBJunk(m.b[bestj+bestsize]) &&
-		m.a[besti+bestsize] == m.b[bestj+bestsize] {
-		bestsize += 1
-	}
-
-	// Now that we have a wholly interesting match (albeit possibly
-	// empty!), we may as well suck up the matching junk on each
-	// side of it too.  Can't think of a good reason not to, and it
-	// saves post-processing the (possibly considerable) expense of
-	// figuring out what to do with it.  In the case of an empty
-	// interesting match, this is clearly the right thing to do,
-	// because no other kind of match is possible in the regions.
-	for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&
-		m.a[besti-1] == m.b[bestj-1] {
-		besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
-	}
-	for besti+bestsize < ahi && bestj+bestsize < bhi &&
-		m.isBJunk(m.b[bestj+bestsize]) &&
-		m.a[besti+bestsize] == m.b[bestj+bestsize] {
-		bestsize += 1
-	}
-
-	return Match{A: besti, B: bestj, Size: bestsize}
-}
-
-// Return list of triples describing matching subsequences.
-//
-// Each triple is of the form (i, j, n), and means that
-// a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in
-// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
-// adjacent triples in the list, and the second is not the last triple in the
-// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
-// adjacent equal blocks.
-//
-// The last triple is a dummy, (len(a), len(b), 0), and is the only
-// triple with n==0.
-func (m *SequenceMatcher) GetMatchingBlocks() []Match {
-	if m.matchingBlocks != nil {
-		return m.matchingBlocks
-	}
-
-	var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match
-	matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {
-		match := m.findLongestMatch(alo, ahi, blo, bhi)
-		i, j, k := match.A, match.B, match.Size
-		if match.Size > 0 {
-			if alo < i && blo < j {
-				matched = matchBlocks(alo, i, blo, j, matched)
-			}
-			matched = append(matched, match)
-			if i+k < ahi && j+k < bhi {
-				matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
-			}
-		}
-		return matched
-	}
-	matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)
-
-	// It's possible that we have adjacent equal blocks in the
-	// matching_blocks list now.
-	nonAdjacent := []Match{}
-	i1, j1, k1 := 0, 0, 0
-	for _, b := range matched {
-		// Is this block adjacent to i1, j1, k1?
-		i2, j2, k2 := b.A, b.B, b.Size
-		if i1+k1 == i2 && j1+k1 == j2 {
-			// Yes, so collapse them -- this just increases the length of
-			// the first block by the length of the second, and the first
-			// block so lengthened remains the block to compare against.
-			k1 += k2
-		} else {
-			// Not adjacent.  Remember the first block (k1==0 means it's
-			// the dummy we started with), and make the second block the
-			// new block to compare against.
-			if k1 > 0 {
-				nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
-			}
-			i1, j1, k1 = i2, j2, k2
-		}
-	}
-	if k1 > 0 {
-		nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
-	}
-
-	nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})
-	m.matchingBlocks = nonAdjacent
-	return m.matchingBlocks
-}
-
-// Return list of 5-tuples describing how to turn a into b.
-//
-// Each tuple is of the form (tag, i1, i2, j1, j2).  The first tuple
-// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
-// tuple preceding it, and likewise for j1 == the previous j2.
-//
-// The tags are characters, with these meanings:
-//
-// 'r' (replace):  a[i1:i2] should be replaced by b[j1:j2]
-//
-// 'd' (delete):   a[i1:i2] should be deleted, j1==j2 in this case.
-//
-// 'i' (insert):   b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
-//
-// 'e' (equal):    a[i1:i2] == b[j1:j2]
-func (m *SequenceMatcher) GetOpCodes() []OpCode {
-	if m.opCodes != nil {
-		return m.opCodes
-	}
-	i, j := 0, 0
-	matching := m.GetMatchingBlocks()
-	opCodes := make([]OpCode, 0, len(matching))
-	for _, m := range matching {
-		//  invariant:  we've pumped out correct diffs to change
-		//  a[:i] into b[:j], and the next matching block is
-		//  a[ai:ai+size] == b[bj:bj+size]. So we need to pump
-		//  out a diff to change a[i:ai] into b[j:bj], pump out
-		//  the matching block, and move (i,j) beyond the match
-		ai, bj, size := m.A, m.B, m.Size
-		tag := byte(0)
-		if i < ai && j < bj {
-			tag = 'r'
-		} else if i < ai {
-			tag = 'd'
-		} else if j < bj {
-			tag = 'i'
-		}
-		if tag > 0 {
-			opCodes = append(opCodes, OpCode{tag, i, ai, j, bj})
-		}
-		i, j = ai+size, bj+size
-		// the list of matching blocks is terminated by a
-		// sentinel with size 0
-		if size > 0 {
-			opCodes = append(opCodes, OpCode{'e', ai, i, bj, j})
-		}
-	}
-	m.opCodes = opCodes
-	return m.opCodes
-}
-
-// Isolate change clusters by eliminating ranges with no changes.
-//
-// Return a generator of groups with up to n lines of context.
-// Each group is in the same format as returned by GetOpCodes().
-func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
-	if n < 0 {
-		n = 3
-	}
-	codes := m.GetOpCodes()
-	if len(codes) == 0 {
-		codes = []OpCode{OpCode{'e', 0, 1, 0, 1}}
-	}
-	// Fixup leading and trailing groups if they show no changes.
-	if codes[0].Tag == 'e' {
-		c := codes[0]
-		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-		codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}
-	}
-	if codes[len(codes)-1].Tag == 'e' {
-		c := codes[len(codes)-1]
-		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-		codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}
-	}
-	nn := n + n
-	groups := [][]OpCode{}
-	group := []OpCode{}
-	for _, c := range codes {
-		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-		// End the current group and start a new one whenever
-		// there is a large range with no changes.
-		if c.Tag == 'e' && i2-i1 > nn {
-			group = append(group, OpCode{c.Tag, i1, min(i2, i1+n),
-				j1, min(j2, j1+n)})
-			groups = append(groups, group)
-			group = []OpCode{}
-			i1, j1 = max(i1, i2-n), max(j1, j2-n)
-		}
-		group = append(group, OpCode{c.Tag, i1, i2, j1, j2})
-	}
-	if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {
-		groups = append(groups, group)
-	}
-	return groups
-}
-
-// Return a measure of the sequences' similarity (float in [0,1]).
-//
-// Where T is the total number of elements in both sequences, and
-// M is the number of matches, this is 2.0*M / T.
-// Note that this is 1 if the sequences are identical, and 0 if
-// they have nothing in common.
-//
-// .Ratio() is expensive to compute if you haven't already computed
-// .GetMatchingBlocks() or .GetOpCodes(), in which case you may
-// want to try .QuickRatio() or .RealQuickRation() first to get an
-// upper bound.
-func (m *SequenceMatcher) Ratio() float64 {
-	matches := 0
-	for _, m := range m.GetMatchingBlocks() {
-		matches += m.Size
-	}
-	return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() relatively quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute.
-func (m *SequenceMatcher) QuickRatio() float64 {
-	// viewing a and b as multisets, set matches to the cardinality
-	// of their intersection; this counts the number of matches
-	// without regard to order, so is clearly an upper bound
-	if m.fullBCount == nil {
-		m.fullBCount = map[string]int{}
-		for _, s := range m.b {
-			m.fullBCount[s] = m.fullBCount[s] + 1
-		}
-	}
-
-	// avail[x] is the number of times x appears in 'b' less the
-	// number of times we've seen it in 'a' so far ... kinda
-	avail := map[string]int{}
-	matches := 0
-	for _, s := range m.a {
-		n, ok := avail[s]
-		if !ok {
-			n = m.fullBCount[s]
-		}
-		avail[s] = n - 1
-		if n > 0 {
-			matches += 1
-		}
-	}
-	return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() very quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute than either .Ratio() or .QuickRatio().
-func (m *SequenceMatcher) RealQuickRatio() float64 {
-	la, lb := len(m.a), len(m.b)
-	return calculateRatio(min(la, lb), la+lb)
-}
-
-// Convert range to the "ed" format
-func formatRangeUnified(start, stop int) string {
-	// Per the diff spec at http://www.unix.org/single_unix_specification/
-	beginning := start + 1 // lines start numbering with one
-	length := stop - start
-	if length == 1 {
-		return fmt.Sprintf("%d", beginning)
-	}
-	if length == 0 {
-		beginning -= 1 // empty ranges begin at line just before the range
-	}
-	return fmt.Sprintf("%d,%d", beginning, length)
-}
-
-// Unified diff parameters
-type UnifiedDiff struct {
-	A        []string // First sequence lines
-	FromFile string   // First file name
-	FromDate string   // First file time
-	B        []string // Second sequence lines
-	ToFile   string   // Second file name
-	ToDate   string   // Second file time
-	Eol      string   // Headers end of line, defaults to LF
-	Context  int      // Number of context lines
-}
-
-// Compare two sequences of lines; generate the delta as a unified diff.
-//
-// Unified diffs are a compact way of showing line changes and a few
-// lines of context.  The number of context lines is set by 'n' which
-// defaults to three.
-//
-// By default, the diff control lines (those with ---, +++, or @@) are
-// created with a trailing newline.  This is helpful so that inputs
-// created from file.readlines() result in diffs that are suitable for
-// file.writelines() since both the inputs and outputs have trailing
-// newlines.
-//
-// For inputs that do not have trailing newlines, set the lineterm
-// argument to "" so that the output will be uniformly newline free.
-//
-// The unidiff format normally has a header for filenames and modification
-// times.  Any or all of these may be specified using strings for
-// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
-// The modification times are normally expressed in the ISO 8601 format.
-func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {
-	buf := bufio.NewWriter(writer)
-	defer buf.Flush()
-	wf := func(format string, args ...interface{}) error {
-		_, err := buf.WriteString(fmt.Sprintf(format, args...))
-		return err
-	}
-	ws := func(s string) error {
-		_, err := buf.WriteString(s)
-		return err
-	}
-
-	if len(diff.Eol) == 0 {
-		diff.Eol = "\n"
-	}
-
-	started := false
-	m := NewMatcher(diff.A, diff.B)
-	for _, g := range m.GetGroupedOpCodes(diff.Context) {
-		if !started {
-			started = true
-			fromDate := ""
-			if len(diff.FromDate) > 0 {
-				fromDate = "\t" + diff.FromDate
-			}
-			toDate := ""
-			if len(diff.ToDate) > 0 {
-				toDate = "\t" + diff.ToDate
-			}
-			if diff.FromFile != "" || diff.ToFile != "" {
-				err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol)
-				if err != nil {
-					return err
-				}
-				err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol)
-				if err != nil {
-					return err
-				}
-			}
-		}
-		first, last := g[0], g[len(g)-1]
-		range1 := formatRangeUnified(first.I1, last.I2)
-		range2 := formatRangeUnified(first.J1, last.J2)
-		if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil {
-			return err
-		}
-		for _, c := range g {
-			i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-			if c.Tag == 'e' {
-				for _, line := range diff.A[i1:i2] {
-					if err := ws(" " + line); err != nil {
-						return err
-					}
-				}
-				continue
-			}
-			if c.Tag == 'r' || c.Tag == 'd' {
-				for _, line := range diff.A[i1:i2] {
-					if err := ws("-" + line); err != nil {
-						return err
-					}
-				}
-			}
-			if c.Tag == 'r' || c.Tag == 'i' {
-				for _, line := range diff.B[j1:j2] {
-					if err := ws("+" + line); err != nil {
-						return err
-					}
-				}
-			}
-		}
-	}
-	return nil
-}
-
-// Like WriteUnifiedDiff but returns the diff a string.
-func GetUnifiedDiffString(diff UnifiedDiff) (string, error) {
-	w := &bytes.Buffer{}
-	err := WriteUnifiedDiff(w, diff)
-	return string(w.Bytes()), err
-}
-
-// Convert range to the "ed" format.
-func formatRangeContext(start, stop int) string {
-	// Per the diff spec at http://www.unix.org/single_unix_specification/
-	beginning := start + 1 // lines start numbering with one
-	length := stop - start
-	if length == 0 {
-		beginning -= 1 // empty ranges begin at line just before the range
-	}
-	if length <= 1 {
-		return fmt.Sprintf("%d", beginning)
-	}
-	return fmt.Sprintf("%d,%d", beginning, beginning+length-1)
-}
-
-type ContextDiff UnifiedDiff
-
-// Compare two sequences of lines; generate the delta as a context diff.
-//
-// Context diffs are a compact way of showing line changes and a few
-// lines of context. The number of context lines is set by diff.Context
-// which defaults to three.
-//
-// By default, the diff control lines (those with *** or ---) are
-// created with a trailing newline.
-//
-// For inputs that do not have trailing newlines, set the diff.Eol
-// argument to "" so that the output will be uniformly newline free.
-//
-// The context diff format normally has a header for filenames and
-// modification times.  Any or all of these may be specified using
-// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.
-// The modification times are normally expressed in the ISO 8601 format.
-// If not specified, the strings default to blanks.
-func WriteContextDiff(writer io.Writer, diff ContextDiff) error {
-	buf := bufio.NewWriter(writer)
-	defer buf.Flush()
-	var diffErr error
-	wf := func(format string, args ...interface{}) {
-		_, err := buf.WriteString(fmt.Sprintf(format, args...))
-		if diffErr == nil && err != nil {
-			diffErr = err
-		}
-	}
-	ws := func(s string) {
-		_, err := buf.WriteString(s)
-		if diffErr == nil && err != nil {
-			diffErr = err
-		}
-	}
-
-	if len(diff.Eol) == 0 {
-		diff.Eol = "\n"
-	}
-
-	prefix := map[byte]string{
-		'i': "+ ",
-		'd': "- ",
-		'r': "! ",
-		'e': "  ",
-	}
-
-	started := false
-	m := NewMatcher(diff.A, diff.B)
-	for _, g := range m.GetGroupedOpCodes(diff.Context) {
-		if !started {
-			started = true
-			fromDate := ""
-			if len(diff.FromDate) > 0 {
-				fromDate = "\t" + diff.FromDate
-			}
-			toDate := ""
-			if len(diff.ToDate) > 0 {
-				toDate = "\t" + diff.ToDate
-			}
-			if diff.FromFile != "" || diff.ToFile != "" {
-				wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol)
-				wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol)
-			}
-		}
-
-		first, last := g[0], g[len(g)-1]
-		ws("***************" + diff.Eol)
-
-		range1 := formatRangeContext(first.I1, last.I2)
-		wf("*** %s ****%s", range1, diff.Eol)
-		for _, c := range g {
-			if c.Tag == 'r' || c.Tag == 'd' {
-				for _, cc := range g {
-					if cc.Tag == 'i' {
-						continue
-					}
-					for _, line := range diff.A[cc.I1:cc.I2] {
-						ws(prefix[cc.Tag] + line)
-					}
-				}
-				break
-			}
-		}
-
-		range2 := formatRangeContext(first.J1, last.J2)
-		wf("--- %s ----%s", range2, diff.Eol)
-		for _, c := range g {
-			if c.Tag == 'r' || c.Tag == 'i' {
-				for _, cc := range g {
-					if cc.Tag == 'd' {
-						continue
-					}
-					for _, line := range diff.B[cc.J1:cc.J2] {
-						ws(prefix[cc.Tag] + line)
-					}
-				}
-				break
-			}
-		}
-	}
-	return diffErr
-}
-
-// Like WriteContextDiff but returns the diff a string.
-func GetContextDiffString(diff ContextDiff) (string, error) {
-	w := &bytes.Buffer{}
-	err := WriteContextDiff(w, diff)
-	return string(w.Bytes()), err
-}
-
-// Split a string on "\n" while preserving them. The output can be used
-// as input for UnifiedDiff and ContextDiff structures.
-func SplitLines(s string) []string {
-	lines := strings.SplitAfter(s, "\n")
-	lines[len(lines)-1] += "\n"
-	return lines
-}

vendor/github.com/stretchr/testify/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
-
-Please consider promoting this project if you find it useful.
-
-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/stretchr/testify/assert/assertion_format.go

@@ -1,379 +0,0 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
- */
-
-package assert
-
-import (
-	http "net/http"
-	url "net/url"
-	time "time"
-)
-
-// Conditionf uses a Comparison to assert a complex condition.
-func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bool {
-	return Condition(t, comp, append([]interface{}{msg}, args...)...)
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-//    assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
-//    assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
-//    assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
-	return Contains(t, s, contains, append([]interface{}{msg}, args...)...)
-}
-
-// Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-//  assert.Emptyf(t, obj, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
-	return Empty(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// Equalf asserts that two objects are equal.
-//
-//    assert.Equalf(t, 123, 123, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	return Equal(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-//   actualObj, err := SomeFunction()
-//   assert.EqualErrorf(t, err,  expectedErrorString, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool {
-	return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...)
-}
-
-// EqualValuesf asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-//    assert.EqualValuesf(t, uint32(123, "error message %s", "formatted"), int32(123))
-//
-// Returns whether the assertion was successful (true) or not (false).
-func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-//   actualObj, err := SomeFunction()
-//   if assert.Errorf(t, err, "error message %s", "formatted") {
-// 	   assert.Equal(t, expectedErrorf, err)
-//   }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Errorf(t TestingT, err error, msg string, args ...interface{}) bool {
-	return Error(t, err, append([]interface{}{msg}, args...)...)
-}
-
-// Exactlyf asserts that two objects are equal is value and type.
-//
-//    assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123))
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	return Exactly(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Failf reports a failure through
-func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
-	return Fail(t, failureMessage, append([]interface{}{msg}, args...)...)
-}
-
-// FailNowf fails test
-func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
-	return FailNow(t, failureMessage, append([]interface{}{msg}, args...)...)
-}
-
-// Falsef asserts that the specified value is false.
-//
-//    assert.Falsef(t, myBool, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool {
-	return False(t, value, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-//  assert.HTTPBodyContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
-	return HTTPBodyContains(t, handler, method, url, values, str)
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-//  assert.HTTPBodyNotContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
-	return HTTPBodyNotContains(t, handler, method, url, values, str)
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-//  assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
-func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPError(t, handler, method, url, values)
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-//  assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
-func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPRedirect(t, handler, method, url, values)
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-//  assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPSuccess(t, handler, method, url, values)
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-//    assert.Implementsf(t, (*MyInterface, "error message %s", "formatted")(nil), new(MyObject))
-func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
-	return Implements(t, interfaceObject, object, append([]interface{}{msg}, args...)...)
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// 	 assert.InDeltaf(t, math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
-	return InDelta(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
-	return InDeltaSlice(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-//
-// Returns whether the assertion was successful (true) or not (false).
-func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
-	return InEpsilon(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
-	return InEpsilonSlice(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
-	return IsType(t, expectedType, object, append([]interface{}{msg}, args...)...)
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-//  assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
-	return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-//    assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool {
-	return Len(t, object, length, append([]interface{}{msg}, args...)...)
-}
-
-// Nilf asserts that the specified object is nil.
-//
-//    assert.Nilf(t, err, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
-	return Nil(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-//   actualObj, err := SomeFunction()
-//   if assert.NoErrorf(t, err, "error message %s", "formatted") {
-// 	   assert.Equal(t, expectedObj, actualObj)
-//   }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool {
-	return NoError(t, err, append([]interface{}{msg}, args...)...)
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-//    assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
-//    assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
-//    assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
-	return NotContains(t, s, contains, append([]interface{}{msg}, args...)...)
-}
-
-// NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-//  if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
-//    assert.Equal(t, "two", obj[1])
-//  }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
-	return NotEmpty(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-//    assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	return NotEqual(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-//    assert.NotNilf(t, err, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
-	return NotNil(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-//   assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
-	return NotPanics(t, f, append([]interface{}{msg}, args...)...)
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-//  assert.NotRegexpf(t, regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting")
-//  assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
-	return NotRegexp(t, rx, str, append([]interface{}{msg}, args...)...)
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-//    assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
-	return NotSubset(t, list, subset, append([]interface{}{msg}, args...)...)
-}
-
-// NotZerof asserts that i is not the zero value for its type and returns the truth.
-func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
-	return NotZero(t, i, append([]interface{}{msg}, args...)...)
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-//   assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
-	return Panics(t, f, append([]interface{}{msg}, args...)...)
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-//   assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
-	return PanicsWithValue(t, expected, f, append([]interface{}{msg}, args...)...)
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-//  assert.Regexpf(t, regexp.MustCompile("start", "error message %s", "formatted"), "it's starting")
-//  assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
-	return Regexp(t, rx, str, append([]interface{}{msg}, args...)...)
-}
-
-// Subsetf asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-//    assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
-	return Subset(t, list, subset, append([]interface{}{msg}, args...)...)
-}
-
-// Truef asserts that the specified value is true.
-//
-//    assert.Truef(t, myBool, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func Truef(t TestingT, value bool, msg string, args ...interface{}) bool {
-	return True(t, value, append([]interface{}{msg}, args...)...)
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-//   assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
-	return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// Zerof asserts that i is the zero value for its type and returns the truth.
-func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
-	return Zero(t, i, append([]interface{}{msg}, args...)...)
-}

vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl

@@ -1,4 +0,0 @@
-{{.CommentFormat}}
-func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool {
-	return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}})
-}

vendor/github.com/stretchr/testify/assert/assertion_forward.go

@@ -1,746 +0,0 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
- */
-
-package assert
-
-import (
-	http "net/http"
-	url "net/url"
-	time "time"
-)
-
-// Condition uses a Comparison to assert a complex condition.
-func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
-	return Condition(a.t, comp, msgAndArgs...)
-}
-
-// Conditionf uses a Comparison to assert a complex condition.
-func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}) bool {
-	return Conditionf(a.t, comp, msg, args...)
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-//    a.Contains("Hello World", "World")
-//    a.Contains(["Hello", "World"], "World")
-//    a.Contains({"Hello": "World"}, "Hello")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
-	return Contains(a.t, s, contains, msgAndArgs...)
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-//    a.Containsf("Hello World", "World", "error message %s", "formatted")
-//    a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
-//    a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
-	return Containsf(a.t, s, contains, msg, args...)
-}
-
-// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-//  a.Empty(obj)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
-	return Empty(a.t, object, msgAndArgs...)
-}
-
-// Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-//  a.Emptyf(obj, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool {
-	return Emptyf(a.t, object, msg, args...)
-}
-
-// Equal asserts that two objects are equal.
-//
-//    a.Equal(123, 123)
-//
-// Returns whether the assertion was successful (true) or not (false).
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
-	return Equal(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-//   actualObj, err := SomeFunction()
-//   a.EqualError(err,  expectedErrorString)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
-	return EqualError(a.t, theError, errString, msgAndArgs...)
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-//   actualObj, err := SomeFunction()
-//   a.EqualErrorf(err,  expectedErrorString, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool {
-	return EqualErrorf(a.t, theError, errString, msg, args...)
-}
-
-// EqualValues asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-//    a.EqualValues(uint32(123), int32(123))
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
-	return EqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualValuesf asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-//    a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123))
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	return EqualValuesf(a.t, expected, actual, msg, args...)
-}
-
-// Equalf asserts that two objects are equal.
-//
-//    a.Equalf(123, 123, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	return Equalf(a.t, expected, actual, msg, args...)
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-//   actualObj, err := SomeFunction()
-//   if a.Error(err) {
-// 	   assert.Equal(t, expectedError, err)
-//   }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool {
-	return Error(a.t, err, msgAndArgs...)
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-//   actualObj, err := SomeFunction()
-//   if a.Errorf(err, "error message %s", "formatted") {
-// 	   assert.Equal(t, expectedErrorf, err)
-//   }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool {
-	return Errorf(a.t, err, msg, args...)
-}
-
-// Exactly asserts that two objects are equal is value and type.
-//
-//    a.Exactly(int32(123), int64(123))
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
-	return Exactly(a.t, expected, actual, msgAndArgs...)
-}
-
-// Exactlyf asserts that two objects are equal is value and type.
-//
-//    a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123))
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	return Exactlyf(a.t, expected, actual, msg, args...)
-}
-
-// Fail reports a failure through
-func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
-	return Fail(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNow fails test
-func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool {
-	return FailNow(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNowf fails test
-func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) bool {
-	return FailNowf(a.t, failureMessage, msg, args...)
-}
-
-// Failf reports a failure through
-func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) bool {
-	return Failf(a.t, failureMessage, msg, args...)
-}
-
-// False asserts that the specified value is false.
-//
-//    a.False(myBool)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
-	return False(a.t, value, msgAndArgs...)
-}
-
-// Falsef asserts that the specified value is false.
-//
-//    a.Falsef(myBool, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool {
-	return Falsef(a.t, value, msg, args...)
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-//  a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
-	return HTTPBodyContains(a.t, handler, method, url, values, str)
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-//  a.HTTPBodyContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
-	return HTTPBodyContainsf(a.t, handler, method, url, values, str)
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-//  a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
-	return HTTPBodyNotContains(a.t, handler, method, url, values, str)
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-//  a.HTTPBodyNotContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
-	return HTTPBodyNotContainsf(a.t, handler, method, url, values, str)
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-//  a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPError(a.t, handler, method, url, values)
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-//  a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
-func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPErrorf(a.t, handler, method, url, values)
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-//  a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPRedirect(a.t, handler, method, url, values)
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-//  a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
-func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPRedirectf(a.t, handler, method, url, values)
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-//  a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPSuccess(a.t, handler, method, url, values)
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-//  a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values) bool {
-	return HTTPSuccessf(a.t, handler, method, url, values)
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-//    a.Implements((*MyInterface)(nil), new(MyObject))
-func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
-	return Implements(a.t, interfaceObject, object, msgAndArgs...)
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-//    a.Implementsf((*MyInterface, "error message %s", "formatted")(nil), new(MyObject))
-func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
-	return Implementsf(a.t, interfaceObject, object, msg, args...)
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// 	 a.InDelta(math.Pi, (22 / 7.0), 0.01)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
-	return InDelta(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
-	return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
-	return InDeltaSlicef(a.t, expected, actual, delta, msg, args...)
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// 	 a.InDeltaf(math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
-	return InDeltaf(a.t, expected, actual, delta, msg, args...)
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
-	return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
-	return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
-	return InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
-	return InEpsilonf(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// IsType asserts that the specified objects are of the same type.
-func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
-	return IsType(a.t, expectedType, object, msgAndArgs...)
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
-	return IsTypef(a.t, expectedType, object, msg, args...)
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-//  a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool {
-	return JSONEq(a.t, expected, actual, msgAndArgs...)
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-//  a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool {
-	return JSONEqf(a.t, expected, actual, msg, args...)
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-//    a.Len(mySlice, 3)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
-	return Len(a.t, object, length, msgAndArgs...)
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-//    a.Lenf(mySlice, 3, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool {
-	return Lenf(a.t, object, length, msg, args...)
-}
-
-// Nil asserts that the specified object is nil.
-//
-//    a.Nil(err)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
-	return Nil(a.t, object, msgAndArgs...)
-}
-
-// Nilf asserts that the specified object is nil.
-//
-//    a.Nilf(err, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool {
-	return Nilf(a.t, object, msg, args...)
-}
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-//   actualObj, err := SomeFunction()
-//   if a.NoError(err) {
-// 	   assert.Equal(t, expectedObj, actualObj)
-//   }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
-	return NoError(a.t, err, msgAndArgs...)
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-//   actualObj, err := SomeFunction()
-//   if a.NoErrorf(err, "error message %s", "formatted") {
-// 	   assert.Equal(t, expectedObj, actualObj)
-//   }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool {
-	return NoErrorf(a.t, err, msg, args...)
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-//    a.NotContains("Hello World", "Earth")
-//    a.NotContains(["Hello", "World"], "Earth")
-//    a.NotContains({"Hello": "World"}, "Earth")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
-	return NotContains(a.t, s, contains, msgAndArgs...)
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-//    a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
-//    a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
-//    a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
-	return NotContainsf(a.t, s, contains, msg, args...)
-}
-
-// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-//  if a.NotEmpty(obj) {
-//    assert.Equal(t, "two", obj[1])
-//  }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
-	return NotEmpty(a.t, object, msgAndArgs...)
-}
-
-// NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-//  if a.NotEmptyf(obj, "error message %s", "formatted") {
-//    assert.Equal(t, "two", obj[1])
-//  }
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool {
-	return NotEmptyf(a.t, object, msg, args...)
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-//    a.NotEqual(obj1, obj2)
-//
-// Returns whether the assertion was successful (true) or not (false).
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
-	return NotEqual(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-//    a.NotEqualf(obj1, obj2, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	return NotEqualf(a.t, expected, actual, msg, args...)
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-//    a.NotNil(err)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
-	return NotNil(a.t, object, msgAndArgs...)
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-//    a.NotNilf(err, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool {
-	return NotNilf(a.t, object, msg, args...)
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-//   a.NotPanics(func(){ RemainCalm() })
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
-	return NotPanics(a.t, f, msgAndArgs...)
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-//   a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
-	return NotPanicsf(a.t, f, msg, args...)
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-//  a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
-//  a.NotRegexp("^start", "it's not starting")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
-	return NotRegexp(a.t, rx, str, msgAndArgs...)
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-//  a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting")
-//  a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
-	return NotRegexpf(a.t, rx, str, msg, args...)
-}
-
-// NotSubset asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-//    a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
-	return NotSubset(a.t, list, subset, msgAndArgs...)
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-//    a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
-	return NotSubsetf(a.t, list, subset, msg, args...)
-}
-
-// NotZero asserts that i is not the zero value for its type and returns the truth.
-func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool {
-	return NotZero(a.t, i, msgAndArgs...)
-}
-
-// NotZerof asserts that i is not the zero value for its type and returns the truth.
-func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool {
-	return NotZerof(a.t, i, msg, args...)
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-//   a.Panics(func(){ GoCrazy() })
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
-	return Panics(a.t, f, msgAndArgs...)
-}
-
-// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-//   a.PanicsWithValue("crazy error", func(){ GoCrazy() })
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
-	return PanicsWithValue(a.t, expected, f, msgAndArgs...)
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-//   a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
-	return PanicsWithValuef(a.t, expected, f, msg, args...)
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-//   a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
-	return Panicsf(a.t, f, msg, args...)
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-//  a.Regexp(regexp.MustCompile("start"), "it's starting")
-//  a.Regexp("start...$", "it's not starting")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
-	return Regexp(a.t, rx, str, msgAndArgs...)
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-//  a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting")
-//  a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
-	return Regexpf(a.t, rx, str, msg, args...)
-}
-
-// Subset asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-//    a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
-	return Subset(a.t, list, subset, msgAndArgs...)
-}
-
-// Subsetf asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-//    a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
-	return Subsetf(a.t, list, subset, msg, args...)
-}
-
-// True asserts that the specified value is true.
-//
-//    a.True(myBool)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
-	return True(a.t, value, msgAndArgs...)
-}
-
-// Truef asserts that the specified value is true.
-//
-//    a.Truef(myBool, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool {
-	return Truef(a.t, value, msg, args...)
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-//   a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
-	return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-//   a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
-	return WithinDurationf(a.t, expected, actual, delta, msg, args...)
-}
-
-// Zero asserts that i is the zero value for its type and returns the truth.
-func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool {
-	return Zero(a.t, i, msgAndArgs...)
-}
-
-// Zerof asserts that i is the zero value for its type and returns the truth.
-func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool {
-	return Zerof(a.t, i, msg, args...)
-}

vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl

@@ -1,4 +0,0 @@
-{{.CommentWithoutT "a"}}
-func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool {
-	return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
-}

vendor/github.com/stretchr/testify/assert/doc.go

@@ -1,45 +0,0 @@
-// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
-//
-// Example Usage
-//
-// The following is a complete example using assert in a standard test function:
-//    import (
-//      "testing"
-//      "github.com/stretchr/testify/assert"
-//    )
-//
-//    func TestSomething(t *testing.T) {
-//
-//      var a string = "Hello"
-//      var b string = "Hello"
-//
-//      assert.Equal(t, a, b, "The two words should be the same.")
-//
-//    }
-//
-// if you assert many times, use the format below:
-//
-//    import (
-//      "testing"
-//      "github.com/stretchr/testify/assert"
-//    )
-//
-//    func TestSomething(t *testing.T) {
-//      assert := assert.New(t)
-//
-//      var a string = "Hello"
-//      var b string = "Hello"
-//
-//      assert.Equal(a, b, "The two words should be the same.")
-//    }
-//
-// Assertions
-//
-// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
-// All assertion functions take, as the first argument, the `*testing.T` object provided by the
-// testing framework. This allows the assertion funcs to write the failings and other details to
-// the correct place.
-//
-// Every assertion function also takes an optional string message as the final argument,
-// allowing custom error messages to be appended to the message the assertion method outputs.
-package assert

vendor/github.com/stretchr/testify/assert/errors.go

@@ -1,10 +0,0 @@
-package assert
-
-import (
-	"errors"
-)
-
-// AnError is an error instance useful for testing.  If the code does not care
-// about error specifics, and only needs to return the error for example, this
-// error should be used to make the test code more readable.
-var AnError = errors.New("assert.AnError general error for testing")

vendor/github.com/stretchr/testify/assert/forward_assertions.go

@@ -1,16 +0,0 @@
-package assert
-
-// Assertions provides assertion methods around the
-// TestingT interface.
-type Assertions struct {
-	t TestingT
-}
-
-// New makes a new Assertions object for the specified TestingT.
-func New(t TestingT) *Assertions {
-	return &Assertions{
-		t: t,
-	}
-}
-
-//go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs

vendor/github.com/stretchr/testify/assert/http_assertions.go

@@ -1,127 +0,0 @@
-package assert
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-)
-
-// httpCode is a helper that returns HTTP code of the response. It returns -1 and
-// an error if building a new request fails.
-func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) {
-	w := httptest.NewRecorder()
-	req, err := http.NewRequest(method, url+"?"+values.Encode(), nil)
-	if err != nil {
-		return -1, err
-	}
-	handler(w, req)
-	return w.Code, nil
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-//  assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool {
-	code, err := httpCode(handler, method, url, values)
-	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
-		return false
-	}
-
-	isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent
-	if !isSuccessCode {
-		Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code))
-	}
-
-	return isSuccessCode
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-//  assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool {
-	code, err := httpCode(handler, method, url, values)
-	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
-		return false
-	}
-
-	isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
-	if !isRedirectCode {
-		Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code))
-	}
-
-	return isRedirectCode
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-//  assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool {
-	code, err := httpCode(handler, method, url, values)
-	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
-		return false
-	}
-
-	isErrorCode := code >= http.StatusBadRequest
-	if !isErrorCode {
-		Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code))
-	}
-
-	return isErrorCode
-}
-
-// HTTPBody is a helper that returns HTTP body of the response. It returns
-// empty string if building a new request fails.
-func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string {
-	w := httptest.NewRecorder()
-	req, err := http.NewRequest(method, url+"?"+values.Encode(), nil)
-	if err != nil {
-		return ""
-	}
-	handler(w, req)
-	return w.Body.String()
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-//  assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}) bool {
-	body := HTTPBody(handler, method, url, values)
-
-	contains := strings.Contains(body, fmt.Sprint(str))
-	if !contains {
-		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
-	}
-
-	return contains
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-//  assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}) bool {
-	body := HTTPBody(handler, method, url, values)
-
-	contains := strings.Contains(body, fmt.Sprint(str))
-	if contains {
-		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
-	}
-
-	return !contains
-}

vendor/github.com/technoweenie/multipartstreamer/LICENSE

@@ -1,7 +0,0 @@
-Copyright (c) 2013-* rick olson
-
-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/technoweenie/multipartstreamer/README.md

@@ -1,47 +0,0 @@
-# multipartstreamer
-
-Package multipartstreamer helps you encode large files in MIME multipart format
-without reading the entire content into memory.  It uses io.MultiReader to
-combine an inner multipart.Reader with a file handle.
-
-```go
-package main
-
-import (
-  "github.com/technoweenie/multipartstreamer.go"
-  "net/http"
-)
-
-func main() {
-  ms := multipartstreamer.New()
-
-  ms.WriteFields(map[string]string{
-    "key":			"some-key",
-    "AWSAccessKeyId":	"ABCDEF",
-    "acl":			"some-acl",
-  })
-
-  // Add any io.Reader to the multipart.Reader.
-  ms.WriteReader("file", "filename", some_ioReader, size)
-
-  // Shortcut for adding local file.
-  ms.WriteFile("file", "path/to/file")
-
-  req, _ := http.NewRequest("POST", "someurl", nil)
-  ms.SetupRequest(req)
-
-  res, _ := http.DefaultClient.Do(req)
-}
-```
-
-One limitation: You can only write a single file.
-
-## TODO
-
-* Multiple files?
-
-## Credits
-
-Heavily inspired by James
-
-https://groups.google.com/forum/?fromgroups=#!topic/golang-nuts/Zjg5l4nKcQ0

vendor/github.com/technoweenie/multipartstreamer/multipartstreamer.go

@@ -1,101 +0,0 @@
-/*
-Package multipartstreamer helps you encode large files in MIME multipart format
-without reading the entire content into memory.  It uses io.MultiReader to
-combine an inner multipart.Reader with a file handle.
-*/
-package multipartstreamer
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"mime/multipart"
-	"net/http"
-	"os"
-	"path/filepath"
-)
-
-type MultipartStreamer struct {
-	ContentType   string
-	bodyBuffer    *bytes.Buffer
-	bodyWriter    *multipart.Writer
-	closeBuffer   *bytes.Buffer
-	reader        io.Reader
-	contentLength int64
-}
-
-// New initializes a new MultipartStreamer.
-func New() (m *MultipartStreamer) {
-	m = &MultipartStreamer{bodyBuffer: new(bytes.Buffer)}
-
-	m.bodyWriter = multipart.NewWriter(m.bodyBuffer)
-	boundary := m.bodyWriter.Boundary()
-	m.ContentType = "multipart/form-data; boundary=" + boundary
-
-	closeBoundary := fmt.Sprintf("\r\n--%s--\r\n", boundary)
-	m.closeBuffer = bytes.NewBufferString(closeBoundary)
-
-	return
-}
-
-// WriteFields writes multiple form fields to the multipart.Writer.
-func (m *MultipartStreamer) WriteFields(fields map[string]string) error {
-	var err error
-
-	for key, value := range fields {
-		err = m.bodyWriter.WriteField(key, value)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// WriteReader adds an io.Reader to get the content of a file.  The reader is
-// not accessed until the multipart.Reader is copied to some output writer.
-func (m *MultipartStreamer) WriteReader(key, filename string, size int64, reader io.Reader) (err error) {
-	m.reader = reader
-	m.contentLength = size
-
-	_, err = m.bodyWriter.CreateFormFile(key, filename)
-	return
-}
-
-// WriteFile is a shortcut for adding a local file as an io.Reader.
-func (m *MultipartStreamer) WriteFile(key, filename string) error {
-	fh, err := os.Open(filename)
-	if err != nil {
-		return err
-	}
-
-	stat, err := fh.Stat()
-	if err != nil {
-		return err
-	}
-
-	return m.WriteReader(key, filepath.Base(filename), stat.Size(), fh)
-}
-
-// SetupRequest sets up the http.Request body, and some crucial HTTP headers.
-func (m *MultipartStreamer) SetupRequest(req *http.Request) {
-	req.Body = m.GetReader()
-	req.Header.Add("Content-Type", m.ContentType)
-	req.ContentLength = m.Len()
-}
-
-func (m *MultipartStreamer) Boundary() string {
-	return m.bodyWriter.Boundary()
-}
-
-// Len calculates the byte size of the multipart content.
-func (m *MultipartStreamer) Len() int64 {
-	return m.contentLength + int64(m.bodyBuffer.Len()) + int64(m.closeBuffer.Len())
-}
-
-// GetReader gets an io.ReadCloser for passing to an http.Request.
-func (m *MultipartStreamer) GetReader() io.ReadCloser {
-	reader := io.MultiReader(m.bodyBuffer, m.reader, m.closeBuffer)
-	return ioutil.NopCloser(reader)
-}

vendor/github.com/urfave/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/urfave/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/urfave/cli/app.go

@@ -1,497 +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{}
-	// Carries a function which returns app specific info.
-	ExtraInfo func() map[string]string
-	// CustomAppHelpTemplate the text template for app help topic.
-	// cli.go uses text/template to render templates. You can
-	// render custom help text by setting this variable.
-	CustomAppHelpTemplate string
-
-	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 {
-			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/urfave/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/urfave/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/urfave/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/urfave/cli/command.go

@@ -1,304 +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
-
-	// CustomHelpTemplate 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.
-	CustomHelpTemplate 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)
-	context.Command = c
-	if checkCommandCompletions(context, c.Name) {
-		return nil
-	}
-
-	if err != nil {
-		if c.OnUsageError != nil {
-			err := c.OnUsageError(context, err, false)
-			HandleExitCoder(err)
-			return err
-		}
-		fmt.Fprintln(context.App.Writer, "Incorrect Usage:", err.Error())
-		fmt.Fprintln(context.App.Writer)
-		ShowCommandHelp(context, 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 {
-			ShowCommandHelp(context, c.Name)
-			HandleExitCoder(err)
-			return err
-		}
-	}
-
-	if c.Action == nil {
-		c.Action = helpSubcommand.Action
-	}
-
-	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
-	app.CustomAppHelpTemplate = c.CustomHelpTemplate
-
-	// 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
-	}
-	app.OnUsageError = c.OnUsageError
-
-	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/urfave/cli/context.go

@@ -1,278 +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 {
-	c.setFlags = nil
-	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 {
-	globalContext(c).setFlags = nil
-	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/urfave/cli/errors.go

@@ -1,115 +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
-	}
-}
-
-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/urfave/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/urfave/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 Flag = BoolFlag{
-	Name:   "generate-bash-completion",
-	Hidden: true,
-}
-
-// VersionFlag prints the version for the application
-var VersionFlag Flag = 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 Flag = 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 {
-		field := flagValue(flag).FieldByName("Hidden")
-		if !field.IsValid() || !field.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 := ""
-
-	if val := fv.FieldByName("Value"); 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/urfave/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/urfave/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/urfave/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/urfave/cli/help.go

@@ -1,338 +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:
-   {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}}{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{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:
-   {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} command{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{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{})
-
-// Prints help for the App or Command with custom template function.
-type helpPrinterCustom func(w io.Writer, templ string, data interface{}, customFunc map[string]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
-
-// HelpPrinterCustom is same as HelpPrinter but
-// takes a custom function for template function map.
-var HelpPrinterCustom helpPrinterCustom = printHelpCustom
-
-// VersionPrinter prints the version for the App
-var VersionPrinter = printVersion
-
-// ShowAppHelpAndExit - Prints the list of subcommands for the app and exits with exit code.
-func ShowAppHelpAndExit(c *Context, exitCode int) {
-	ShowAppHelp(c)
-	os.Exit(exitCode)
-}
-
-// ShowAppHelp is an action that displays the help.
-func ShowAppHelp(c *Context) (err error) {
-	if c.App.CustomAppHelpTemplate == "" {
-		HelpPrinter(c.App.Writer, AppHelpTemplate, c.App)
-		return
-	}
-	customAppData := func() map[string]interface{} {
-		if c.App.ExtraInfo == nil {
-			return nil
-		}
-		return map[string]interface{}{
-			"ExtraInfo": c.App.ExtraInfo,
-		}
-	}
-	HelpPrinterCustom(c.App.Writer, c.App.CustomAppHelpTemplate, c.App, customAppData())
-	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)
-		}
-	}
-}
-
-// ShowCommandHelpAndExit - exits with code after showing help
-func ShowCommandHelpAndExit(c *Context, command string, code int) {
-	ShowCommandHelp(c, command)
-	os.Exit(code)
-}
-
-// 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) {
-			if c.CustomHelpTemplate != "" {
-				HelpPrinterCustom(ctx.App.Writer, c.CustomHelpTemplate, c, nil)
-			} else {
-				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 printHelpCustom(out io.Writer, templ string, data interface{}, customFunc map[string]interface{}) {
-	funcMap := template.FuncMap{
-		"join": strings.Join,
-	}
-	if customFunc != nil {
-		for key, value := range customFunc {
-			funcMap[key] = value
-		}
-	}
-
-	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 printHelp(out io.Writer, templ string, data interface{}) {
-	printHelpCustom(out, templ, data, nil)
-}
-
-func checkVersion(c *Context) bool {
-	found := false
-	if VersionFlag.GetName() != "" {
-		eachName(VersionFlag.GetName(), func(name string) {
-			if c.GlobalBool(name) || c.Bool(name) {
-				found = true
-			}
-		})
-	}
-	return found
-}
-
-func checkHelp(c *Context) bool {
-	found := false
-	if HelpFlag.GetName() != "" {
-		eachName(HelpFlag.GetName(), 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.GetName() {
-		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
-}