v1.3.0

Migrate from os/exec.Cmd to a native Go sh interpreter

.travis.yml

@@ -4,4 +4,6 @@ go:
   - 1.8
 script:
   - go install github.com/go-task/task/cmd/task
+  - task dl-deps
+  - task lint
   - task test

README.md

@@ -9,7 +9,7 @@ It aims to be simpler and easier to use then [GNU Make][make].
 
 ## Installation
 
-If you have a [Go][golang] environment setup, you can simply run:
+If you have a [Golang][golang] environment setup, you can simply run:
 
 ```bash
 go get -u -v github.com/go-task/task/cmd/task
@@ -40,12 +40,15 @@ Running the tasks is as simple as running:
 task assets build
 ```
 
-If Bash is available (Linux and Windows while on Git Bash), the commands will
-run in Bash, otherwise will fallback to `cmd` (on Windows).
+Task uses [github.com/mvdan/sh](https://github.com/mvdan/sh), a native Go sh
+interpreter. So you can write sh/bash commands and it will work even on
+Windows, where `sh` or `bash` is usually not available. Just remember any
+executable called must be available by the OS or in PATH.
 
 If you ommit a task name, "default" will be assumed.
 
 ### Environment
+
 You can specify environment variables that are added when running a command:
 
 ```yml
@@ -269,17 +272,27 @@ build:
 ### Go's template engine
 
 Task parse commands as [Go's template engine][gotemplate] before executing
-them. Variables are acessible through dot syntax (`.VARNAME`). The following
-functions are available:
+them. Variables are acessible through dot syntax (`.VARNAME`).
 
-- `OS`: return operating system. Possible values are "windows", "linux",
+All functions by the Go's [sprig lib](http://masterminds.github.io/sprig/)
+are available. The following example gets the current date in a given format:
+
+```go
+print-date:
+  cmds:
+    - echo {{now | date "2006-01-02"}}
+```
+
+Task also adds the following functions:
+
+- `OS`: Returns operating system. Possible values are "windows", "linux",
   "darwin" (macOS) and "freebsd".
 - `ARCH`: return the architecture Task was compiled to: "386", "amd64", "arm"
   or "s390x".
-- `IsSH`: on unix systems this should always return `true`. On Windows, will
-  return `true` if `sh` command was found (Git Bash). In this case commands
-  will run on `sh`. Otherwise, this function will return `false` meaning
-  commands will run on `cmd`.
+- `ToSlash`: Does nothing on Unix, but on Windows converts a string from `\`
+  path format to `/`.
+- `FromSlash`: Oposite of `ToSlash`. Does nothing on Unix, but on Windows
+  converts a string from `\` path format to `/`.
 
 Example:
 
@@ -288,7 +301,8 @@ printos:
   cmds:
     - echo '{{OS}} {{ARCH}}'
     - "echo '{{if eq OS \"windows\"}}windows-command{{else}}unix-command{{end}}'"
-    - echo 'Is SH? {{IsSH}}'
+    # This will be path/to/file on Unix but path\to\file on Windows
+    - "{{FromSlash \"path/to/file\"}}"
 ```
 
 ### Help
@@ -341,3 +355,4 @@ Similar software:
 [gotemplate]: https://golang.org/pkg/text/template/
 [robo]: https://github.com/tj/robo
 [dog]: https://github.com/dogtools/dog
+[sh]: https://github.com/mvdan/sh

Taskfile.yml

@@ -5,10 +5,16 @@ install:
   cmds:
     - go install -v ./...
 
+dl-deps:
+  desc: Downloads cli dependencies
+  cmds:
+    - go get -u github.com/golang/lint/golint
+
 lint:
   desc: Runs golint
   cmds:
     - golint .
+    - golint ./execext
     - golint ./cmd/task
 
 test:

cyclic.go

@@ -1,5 +1,6 @@
 package task
 
+// HasCyclicDep checks if a task tree has any cyclic dependency
 func HasCyclicDep(m map[string]*Task) bool {
 	visits := make(map[string]struct{}, len(m))
 

execext/exec.go

@@ -1,22 +1,53 @@
 package execext
 
 import (
-	"os/exec"
+	"context"
+	"errors"
+	"io"
+	"strings"
+
+	"github.com/mvdan/sh/interp"
+	"github.com/mvdan/sh/syntax"
 )
 
+// RunCommandOptions is the options for the RunCommand func
+type RunCommandOptions struct {
+	Context context.Context
+	Command string
+	Dir     string
+	Env     []string
+	Stdin   io.Reader
+	Stdout  io.Writer
+	Stderr  io.Writer
+}
+
 var (
-	// ShPath is path to "sh" command
-	ShPath string
-	// ShExists is true if "sh" command is available on the system
-	ShExists bool
+	// ErrNilOptions is returned when a nil options is given
+	ErrNilOptions = errors.New("execext: nil options given")
 )
 
-func init() {
-	var err error
-	ShPath, err = exec.LookPath("sh")
-	ShExists = err == nil
-}
+// RunCommand runs a shell command
+func RunCommand(opts *RunCommandOptions) error {
+	if opts == nil {
+		return ErrNilOptions
+	}
 
-func newShCommand(c string) *exec.Cmd {
-	return exec.Command(ShPath, "-c", c)
+	p, err := syntax.Parse(strings.NewReader(opts.Command), "", 0)
+	if err != nil {
+		return err
+	}
+
+	r := interp.Runner{
+		Context: opts.Context,
+		File:    p,
+		Dir:     opts.Dir,
+		Env:     opts.Env,
+		Stdin:   opts.Stdin,
+		Stdout:  opts.Stdout,
+		Stderr:  opts.Stderr,
+	}
+	if err = r.Run(); err != nil {
+		return err
+	}
+	return nil
 }

execext/exec_other.go

@@ -1,13 +0,0 @@
-// +build !windows
-
-package execext
-
-import (
-	"os/exec"
-)
-
-// NewCommand returns a new command that runs on "sh" is available or on "cmd"
-// otherwise on Windows
-func NewCommand(c string) *exec.Cmd {
-	return newShCommand(c)
-}

execext/exec_win.go

@@ -1,20 +0,0 @@
-// +build windows
-
-package execext
-
-import (
-	"os/exec"
-)
-
-// NewCommand returns a new command that runs on "sh" is available or on "cmd"
-// otherwise on Windows
-func NewCommand(c string) *exec.Cmd {
-	if ShExists {
-		return newShCommand(c)
-	}
-	return newCmdCommand(c)
-}
-
-func newCmdCommand(c string) *exec.Cmd {
-	return exec.Command("cmd", "/C", c)
-}

goreleaser.yml

@@ -1,5 +1,5 @@
 build:
-  binary_name: task
+  binary: task
   main: cmd/task/task.go
   goos:
     - windows

task.go

@@ -1,15 +1,17 @@
 package task
 
 import (
+	"bytes"
+	"context"
 	"fmt"
 	"log"
 	"os"
 	"strings"
-	"sync"
 
 	"github.com/go-task/task/execext"
 
 	"github.com/spf13/pflag"
+	"golang.org/x/sync/errgroup"
 )
 
 var (
@@ -76,20 +78,20 @@ func Run() {
 	}
 
 	for _, a := range args {
-		if err = RunTask(a); err != nil {
+		if err = RunTask(context.Background(), a); err != nil {
 			log.Fatal(err)
 		}
 	}
 }
 
 // RunTask runs a task by its name
-func RunTask(name string) error {
+func RunTask(ctx context.Context, name string) error {
 	t, ok := Tasks[name]
 	if !ok {
 		return &taskNotFoundError{name}
 	}
 
-	if err := t.runDeps(); err != nil {
+	if err := t.runDeps(ctx); err != nil {
 		return err
 	}
 
@@ -99,54 +101,41 @@ func RunTask(name string) error {
 	}
 
 	for i := range t.Cmds {
-		if err := t.runCommand(i); err != nil {
+		if err := t.runCommand(ctx, i); err != nil {
 			return &taskRunError{name, err}
 		}
 	}
 	return nil
 }
 
-func (t *Task) runDeps() error {
+func (t *Task) runDeps(ctx context.Context) error {
 	vars, err := t.handleVariables()
 	if err != nil {
 		return err
 	}
 
-	var (
-		wg       sync.WaitGroup
-		errChan  = make(chan error)
-		doneChan = make(chan struct{})
-	)
+	g, ctx := errgroup.WithContext(ctx)
 
 	for _, d := range t.Deps {
-		wg.Add(1)
-
-		go func(dep string) {
-			defer wg.Done()
+		dep := d
 
+		g.Go(func() error {
 			dep, err := ReplaceVariables(dep, vars)
 			if err != nil {
-				errChan <- err
-				return
+				return err
 			}
 
-			if err := RunTask(dep); err != nil {
-				errChan <- err
+			if err = RunTask(ctx, dep); err != nil {
+				return err
 			}
-		}(d)
+			return nil
+		})
 	}
 
-	go func() {
-		wg.Wait()
-		doneChan <- struct{}{}
-	}()
-
-	select {
-	case err := <-errChan:
+	if err = g.Wait(); err != nil {
 		return err
-	case <-doneChan:
-		return nil
 	}
+	return nil
 }
 
 func (t *Task) isUpToDate() bool {
@@ -167,7 +156,7 @@ func (t *Task) isUpToDate() bool {
 	return generatesMinTime.After(sourcesMaxTime)
 }
 
-func (t *Task) runCommand(i int) error {
+func (t *Task) runCommand(ctx context.Context, i int) error {
 	vars, err := t.handleVariables()
 	if err != nil {
 		return err
@@ -179,7 +168,7 @@ func (t *Task) runCommand(i int) error {
 
 	if strings.HasPrefix(c, "^") {
 		c = strings.TrimPrefix(c, "^")
-		if err = RunTask(c); err != nil {
+		if err = RunTask(ctx, c); err != nil {
 			return err
 		}
 		return nil
@@ -189,38 +178,54 @@ func (t *Task) runCommand(i int) error {
 	if err != nil {
 		return err
 	}
-	cmd := execext.NewCommand(c)
-	if dir != "" {
-		cmd.Dir = dir
+
+	envs, err := t.getEnviron(vars)
+	if err != nil {
+		return err
 	}
-	if t.Env != nil {
-		cmd.Env = os.Environ()
-		for key, value := range t.Env {
-			replacedValue, err := ReplaceVariables(value, vars)
-			if err != nil {
-				return err
-			}
-			replacedKey, err := ReplaceVariables(key, vars)
-			if err != nil {
-				return err
-			}
-			cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", replacedKey, replacedValue))
-		}
+	opts := &execext.RunCommandOptions{
+		Context: ctx,
+		Command: c,
+		Dir:     dir,
+		Env:     envs,
+		Stdin:   os.Stdin,
+		Stderr:  os.Stderr,
 	}
-	cmd.Stdin = os.Stdin
-	cmd.Stderr = os.Stderr
-	if t.Set != "" {
-		bytes, err := cmd.Output()
-		if err != nil {
+
+	if t.Set == "" {
+		log.Println(c)
+		opts.Stdout = os.Stdout
+		if err = execext.RunCommand(opts); err != nil {
 			return err
 		}
-		os.Setenv(t.Set, strings.TrimSpace(string(bytes)))
-		return nil
-	}
-	cmd.Stdout = os.Stdout
-	log.Println(c)
-	if err = cmd.Run(); err != nil {
-		return err
+	} else {
+		buff := bytes.NewBuffer(nil)
+		opts.Stdout = buff
+		if err = execext.RunCommand(opts); err != nil {
+			return err
+		}
+		os.Setenv(t.Set, strings.TrimSpace(buff.String()))
 	}
 	return nil
 }
+
+func (t *Task) getEnviron(vars map[string]string) ([]string, error) {
+	if t.Env == nil {
+		return nil, nil
+	}
+
+	envs := os.Environ()
+
+	for k, v := range t.Env {
+		replacedValue, err := ReplaceVariables(v, vars)
+		if err != nil {
+			return nil, err
+		}
+		replacedKey, err := ReplaceVariables(k, vars)
+		if err != nil {
+			return nil, err
+		}
+		envs = append(envs, fmt.Sprintf("%s=%s", replacedKey, replacedValue))
+	}
+	return envs, nil
+}

variable_handling.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"io/ioutil"
 	"os"
+	"path/filepath"
 	"runtime"
 	"strings"
 	"text/template"
@@ -13,6 +14,7 @@ import (
 	"github.com/go-task/task/execext"
 
 	"github.com/BurntSushi/toml"
+	"github.com/Masterminds/sprig"
 	"gopkg.in/yaml.v2"
 )
 
@@ -32,20 +34,25 @@ func handleDynamicVariableContent(value string) (string, error) {
 	if result, ok := varCmds[value]; ok {
 		return result, nil
 	}
-	cmd := execext.NewCommand(value[1:])
-	cmd.Stdin = os.Stdin
-	cmd.Stderr = os.Stderr
-	b, err := cmd.Output()
-	if err != nil {
+
+	buff := bytes.NewBuffer(nil)
+
+	opts := &execext.RunCommandOptions{
+		Command: strings.TrimPrefix(value, "$"),
+		Stdout:  buff,
+		Stderr:  os.Stderr,
+	}
+	if err := execext.RunCommand(opts); err != nil {
 		return "", err
 	}
-	if b[len(b)-1] == '\n' {
-		b = b[:len(b)-1]
-	}
-	if bytes.ContainsRune(b, '\n') {
+
+	result := buff.String()
+	result = strings.TrimSuffix(result, "\n")
+	if strings.ContainsRune(result, '\n') {
 		return "", ErrMultilineResultCmd
 	}
-	result := strings.TrimSpace(string(b))
+
+	result = strings.TrimSpace(result)
 	varCmds[value] = result
 	return result, nil
 }
@@ -76,10 +83,26 @@ func (t *Task) handleVariables() (map[string]string, error) {
 	return localVariables, nil
 }
 
-var templateFuncs = template.FuncMap{
-	"OS":   func() string { return runtime.GOOS },
-	"ARCH": func() string { return runtime.GOARCH },
-	"IsSH": func() bool { return execext.ShExists },
+var templateFuncs template.FuncMap
+
+func init() {
+	taskFuncs := template.FuncMap{
+		"OS":   func() string { return runtime.GOOS },
+		"ARCH": func() string { return runtime.GOARCH },
+		// historical reasons
+		"IsSH": func() bool { return true },
+		"FromSlash": func(path string) string {
+			return filepath.FromSlash(path)
+		},
+		"ToSlash": func(path string) string {
+			return filepath.ToSlash(path)
+		},
+	}
+
+	templateFuncs = sprig.TxtFuncMap()
+	for k, v := range taskFuncs {
+		templateFuncs[k] = v
+	}
 }
 
 // ReplaceVariables writes vars into initial string

vendor/github.com/Masterminds/semver/CHANGELOG.md

@@ -0,0 +1,50 @@
+# 1.2.3 (2017-04-03)
+
+## Fixed
+- #46: Fixed 0.x.x and 0.0.x in constraints being treated as *
+
+# Release 1.2.2 (2016-12-13)
+
+## Fixed
+- #34: Fixed issue where hyphen range was not working with pre-release parsing.
+
+# Release 1.2.1 (2016-11-28)
+
+## Fixed
+- #24: Fixed edge case issue where constraint "> 0" does not handle "0.0.1-alpha"
+  properly.
+
+# Release 1.2.0 (2016-11-04)
+
+## Added
+- #20: Added MustParse function for versions (thanks @adamreese)
+- #15: Added increment methods on versions (thanks @mh-cbon)
+
+## Fixed
+- Issue #21: Per the SemVer spec (section 9) a pre-release is unstable and
+  might not satisfy the intended compatibility. The change here ignores pre-releases
+  on constraint checks (e.g., ~ or ^) when a pre-release is not part of the
+  constraint. For example, `^1.2.3` will ignore pre-releases while
+  `^1.2.3-alpha` will include them.
+
+# Release 1.1.1 (2016-06-30)
+
+## Changed
+- Issue #9: Speed up version comparison performance (thanks @sdboyer)
+- Issue #8: Added benchmarks (thanks @sdboyer)
+- Updated Go Report Card URL to new location
+- Updated Readme to add code snippet formatting (thanks @mh-cbon)
+- Updating tagging to v[SemVer] structure for compatibility with other tools.
+
+# Release 1.1.0 (2016-03-11)
+
+- Issue #2: Implemented validation to provide reasons a versions failed a
+  constraint.
+
+# Release 1.0.1 (2015-12-31)
+
+- Fixed #1: * constraint failing on valid versions.
+
+# Release 1.0.0 (2015-10-20)
+
+- Initial release

vendor/github.com/Masterminds/semver/LICENSE.txt

@@ -0,0 +1,20 @@
+The Masterminds
+Copyright (C) 2014-2015, Matt Butcher and Matt Farina
+
+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/Masterminds/semver/Makefile

@@ -0,0 +1,36 @@
+.PHONY: setup
+setup:
+	go get -u gopkg.in/alecthomas/gometalinter.v1
+	gometalinter.v1 --install
+
+.PHONY: test
+test: validate lint
+	@echo "==> Running tests"
+	go test -v
+
+.PHONY: validate
+validate:
+	@echo "==> Running static validations"
+	@gometalinter.v1 \
+	  --disable-all \
+	  --enable deadcode \
+	  --severity deadcode:error \
+	  --enable gofmt \
+	  --enable gosimple \
+	  --enable ineffassign \
+	  --enable misspell \
+	  --enable vet \
+	  --tests \
+	  --vendor \
+	  --deadline 60s \
+	  ./... || exit_code=1
+
+.PHONY: lint
+lint:
+	@echo "==> Running linters"
+	@gometalinter.v1 \
+	  --disable-all \
+	  --enable golint \
+	  --vendor \
+	  --deadline 60s \
+	  ./... || :

vendor/github.com/Masterminds/semver/README.md

@@ -0,0 +1,165 @@
+# SemVer
+
+The `semver` package provides the ability to work with [Semantic Versions](http://semver.org) in Go. Specifically it provides the ability to:
+
+* Parse semantic versions
+* Sort semantic versions
+* Check if a semantic version fits within a set of constraints
+* Optionally work with a `v` prefix
+
+[![Stability:
+Active](https://masterminds.github.io/stability/active.svg)](https://masterminds.github.io/stability/active.html)
+[![Build Status](https://travis-ci.org/Masterminds/semver.svg)](https://travis-ci.org/Masterminds/semver) [![Build status](https://ci.appveyor.com/api/projects/status/jfk66lib7hb985k8/branch/master?svg=true&passingText=windows%20build%20passing&failingText=windows%20build%20failing)](https://ci.appveyor.com/project/mattfarina/semver/branch/master) [![GoDoc](https://godoc.org/github.com/Masterminds/semver?status.png)](https://godoc.org/github.com/Masterminds/semver) [![Go Report Card](https://goreportcard.com/badge/github.com/Masterminds/semver)](https://goreportcard.com/report/github.com/Masterminds/semver)
+
+## Parsing Semantic Versions
+
+To parse a semantic version use the `NewVersion` function. For example,
+
+```go
+    v, err := semver.NewVersion("1.2.3-beta.1+build345")
+```
+
+If there is an error the version wasn't parseable. The version object has methods
+to get the parts of the version, compare it to other versions, convert the
+version back into a string, and get the original string. For more details
+please see the [documentation](https://godoc.org/github.com/Masterminds/semver).
+
+## Sorting Semantic Versions
+
+A set of versions can be sorted using the [`sort`](https://golang.org/pkg/sort/)
+package from the standard library. For example,
+
+```go
+    raw := []string{"1.2.3", "1.0", "1.3", "2", "0.4.2",}
+    vs := make([]*semver.Version, len(raw))
+	for i, r := range raw {
+		v, err := semver.NewVersion(r)
+		if err != nil {
+			t.Errorf("Error parsing version: %s", err)
+		}
+
+		vs[i] = v
+	}
+
+	sort.Sort(semver.Collection(vs))
+```
+
+## Checking Version Constraints
+
+Checking a version against version constraints is one of the most featureful
+parts of the package.
+
+```go
+    c, err := semver.NewConstraint(">= 1.2.3")
+    if err != nil {
+        // Handle constraint not being parseable.
+    }
+
+    v, _ := semver.NewVersion("1.3")
+    if err != nil {
+        // Handle version not being parseable.
+    }
+    // Check if the version meets the constraints. The a variable will be true.
+    a := c.Check(v)
+```
+
+## Basic Comparisons
+
+There are two elements to the comparisons. First, a comparison string is a list
+of comma separated and comparisons. These are then separated by || separated or
+comparisons. For example, `">= 1.2, < 3.0.0 || >= 4.2.3"` is looking for a
+comparison that's greater than or equal to 1.2 and less than 3.0.0 or is
+greater than or equal to 4.2.3.
+
+The basic comparisons are:
+
+* `=`: equal (aliased to no operator)
+* `!=`: not equal
+* `>`: greater than
+* `<`: less than
+* `>=`: greater than or equal to
+* `<=`: less than or equal to
+
+_Note, according to the Semantic Version specification pre-releases may not be
+API compliant with their release counterpart. It says,_
+
+> _A pre-release version indicates that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version._
+
+_SemVer comparisons without a pre-release value will skip pre-release versions.
+For example, `>1.2.3` will skip pre-releases when looking at a list of values
+while `>1.2.3-alpha.1` will evaluate pre-releases._
+
+## Hyphen Range Comparisons
+
+There are multiple methods to handle ranges and the first is hyphens ranges.
+These look like:
+
+* `1.2 - 1.4.5` which is equivalent to `>= 1.2, <= 1.4.5`
+* `2.3.4 - 4.5` which is equivalent to `>= 2.3.4, <= 4.5`
+
+## Wildcards In Comparisons
+
+The `x`, `X`, and `*` characters can be used as a wildcard character. This works
+for all comparison operators. When used on the `=` operator it falls
+back to the pack level comparison (see tilde below). For example,
+
+* `1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
+* `>= 1.2.x` is equivalent to `>= 1.2.0`
+* `<= 2.x` is equivalent to `<= 3`
+* `*` is equivalent to `>= 0.0.0`
+
+## Tilde Range Comparisons (Patch)
+
+The tilde (`~`) comparison operator is for patch level ranges when a minor
+version is specified and major level changes when the minor number is missing.
+For example,
+
+* `~1.2.3` is equivalent to `>= 1.2.3, < 1.3.0`
+* `~1` is equivalent to `>= 1, < 2`
+* `~2.3` is equivalent to `>= 2.3, < 2.4`
+* `~1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
+* `~1.x` is equivalent to `>= 1, < 2`
+
+## Caret Range Comparisons (Major)
+
+The caret (`^`) comparison operator is for major level changes. This is useful
+when comparisons of API versions as a major change is API breaking. For example,
+
+* `^1.2.3` is equivalent to `>= 1.2.3, < 2.0.0`
+* `^1.2.x` is equivalent to `>= 1.2.0, < 2.0.0`
+* `^2.3` is equivalent to `>= 2.3, < 3`
+* `^2.x` is equivalent to `>= 2.0.0, < 3`
+
+# Validation
+
+In addition to testing a version against a constraint, a version can be validated
+against a constraint. When validation fails a slice of errors containing why a
+version didn't meet the constraint is returned. For example,
+
+```go
+    c, err := semver.NewConstraint("<= 1.2.3, >= 1.4")
+    if err != nil {
+        // Handle constraint not being parseable.
+    }
+
+    v, _ := semver.NewVersion("1.3")
+    if err != nil {
+        // Handle version not being parseable.
+    }
+
+    // Validate a version against a constraint.
+    a, msgs := c.Validate(v)
+    // a is false
+    for _, m := range msgs {
+        fmt.Println(m)
+
+        // Loops over the errors which would read
+        // "1.3 is greater than 1.2.3"
+        // "1.3 is less than 1.4"
+    }
+```
+
+# Contribute
+
+If you find an issue or want to contribute please file an [issue](https://github.com/Masterminds/semver/issues)
+or [create a pull request](https://github.com/Masterminds/semver/pulls).

vendor/github.com/Masterminds/semver/appveyor.yml

@@ -0,0 +1,44 @@
+version: build-{build}.{branch}
+
+clone_folder: C:\gopath\src\github.com\Masterminds\semver
+shallow_clone: true
+
+environment:
+  GOPATH: C:\gopath
+
+platform:
+  - x64
+
+install:
+  - go version
+  - go env
+  - go get -u gopkg.in/alecthomas/gometalinter.v1
+  - set PATH=%PATH%;%GOPATH%\bin
+  - gometalinter.v1.exe --install
+
+build_script:
+  - go install -v ./...
+
+test_script:
+  - "gometalinter.v1 \
+    --disable-all \
+    --enable deadcode \
+    --severity deadcode:error \
+    --enable gofmt \
+    --enable gosimple \
+    --enable ineffassign \
+    --enable misspell \
+    --enable vet \
+    --tests \
+    --vendor \
+    --deadline 60s \
+    ./... || exit_code=1"
+  - "gometalinter.v1 \
+    --disable-all \
+    --enable golint \
+    --vendor \
+    --deadline 60s \
+    ./... || :"
+  - go test -v
+
+deploy: off

vendor/github.com/Masterminds/semver/collection.go

@@ -0,0 +1,24 @@
+package semver
+
+// Collection is a collection of Version instances and implements the sort
+// interface. See the sort package for more details.
+// https://golang.org/pkg/sort/
+type Collection []*Version
+
+// Len returns the length of a collection. The number of Version instances
+// on the slice.
+func (c Collection) Len() int {
+	return len(c)
+}
+
+// Less is needed for the sort interface to compare two Version objects on the
+// slice. If checks if one is less than the other.
+func (c Collection) Less(i, j int) bool {
+	return c[i].LessThan(c[j])
+}
+
+// Swap is needed for the sort interface to replace the Version objects
+// at two different positions in the slice.
+func (c Collection) Swap(i, j int) {
+	c[i], c[j] = c[j], c[i]
+}

vendor/github.com/Masterminds/semver/constraints.go

@@ -0,0 +1,426 @@
+package semver
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// Constraints is one or more constraint that a semantic version can be
+// checked against.
+type Constraints struct {
+	constraints [][]*constraint
+}
+
+// NewConstraint returns a Constraints instance that a Version instance can
+// be checked against. If there is a parse error it will be returned.
+func NewConstraint(c string) (*Constraints, error) {
+
+	// Rewrite - ranges into a comparison operation.
+	c = rewriteRange(c)
+
+	ors := strings.Split(c, "||")
+	or := make([][]*constraint, len(ors))
+	for k, v := range ors {
+		cs := strings.Split(v, ",")
+		result := make([]*constraint, len(cs))
+		for i, s := range cs {
+			pc, err := parseConstraint(s)
+			if err != nil {
+				return nil, err
+			}
+
+			result[i] = pc
+		}
+		or[k] = result
+	}
+
+	o := &Constraints{constraints: or}
+	return o, nil
+}
+
+// Check tests if a version satisfies the constraints.
+func (cs Constraints) Check(v *Version) bool {
+	// loop over the ORs and check the inner ANDs
+	for _, o := range cs.constraints {
+		joy := true
+		for _, c := range o {
+			if !c.check(v) {
+				joy = false
+				break
+			}
+		}
+
+		if joy {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Validate checks if a version satisfies a constraint. If not a slice of
+// reasons for the failure are returned in addition to a bool.
+func (cs Constraints) Validate(v *Version) (bool, []error) {
+	// loop over the ORs and check the inner ANDs
+	var e []error
+	for _, o := range cs.constraints {
+		joy := true
+		for _, c := range o {
+			if !c.check(v) {
+				em := fmt.Errorf(c.msg, v, c.orig)
+				e = append(e, em)
+				joy = false
+			}
+		}
+
+		if joy {
+			return true, []error{}
+		}
+	}
+
+	return false, e
+}
+
+var constraintOps map[string]cfunc
+var constraintMsg map[string]string
+var constraintRegex *regexp.Regexp
+
+func init() {
+	constraintOps = map[string]cfunc{
+		"":   constraintTildeOrEqual,
+		"=":  constraintTildeOrEqual,
+		"!=": constraintNotEqual,
+		">":  constraintGreaterThan,
+		"<":  constraintLessThan,
+		">=": constraintGreaterThanEqual,
+		"=>": constraintGreaterThanEqual,
+		"<=": constraintLessThanEqual,
+		"=<": constraintLessThanEqual,
+		"~":  constraintTilde,
+		"~>": constraintTilde,
+		"^":  constraintCaret,
+	}
+
+	constraintMsg = map[string]string{
+		"":   "%s is not equal to %s",
+		"=":  "%s is not equal to %s",
+		"!=": "%s is equal to %s",
+		">":  "%s is less than or equal to %s",
+		"<":  "%s is greater than or equal to %s",
+		">=": "%s is less than %s",
+		"=>": "%s is less than %s",
+		"<=": "%s is greater than %s",
+		"=<": "%s is greater than %s",
+		"~":  "%s does not have same major and minor version as %s",
+		"~>": "%s does not have same major and minor version as %s",
+		"^":  "%s does not have same major version as %s",
+	}
+
+	ops := make([]string, 0, len(constraintOps))
+	for k := range constraintOps {
+		ops = append(ops, regexp.QuoteMeta(k))
+	}
+
+	constraintRegex = regexp.MustCompile(fmt.Sprintf(
+		`^\s*(%s)\s*(%s)\s*$`,
+		strings.Join(ops, "|"),
+		cvRegex))
+
+	constraintRangeRegex = regexp.MustCompile(fmt.Sprintf(
+		`\s*(%s)\s+-\s+(%s)\s*`,
+		cvRegex, cvRegex))
+}
+
+// An individual constraint
+type constraint struct {
+	// The callback function for the restraint. It performs the logic for
+	// the constraint.
+	function cfunc
+
+	msg string
+
+	// The version used in the constraint check. For example, if a constraint
+	// is '<= 2.0.0' the con a version instance representing 2.0.0.
+	con *Version
+
+	// The original parsed version (e.g., 4.x from != 4.x)
+	orig string
+
+	// When an x is used as part of the version (e.g., 1.x)
+	minorDirty bool
+	dirty      bool
+	patchDirty bool
+}
+
+// Check if a version meets the constraint
+func (c *constraint) check(v *Version) bool {
+	return c.function(v, c)
+}
+
+type cfunc func(v *Version, c *constraint) bool
+
+func parseConstraint(c string) (*constraint, error) {
+	m := constraintRegex.FindStringSubmatch(c)
+	if m == nil {
+		return nil, fmt.Errorf("improper constraint: %s", c)
+	}
+
+	ver := m[2]
+	orig := ver
+	minorDirty := false
+	patchDirty := false
+	dirty := false
+	if isX(m[3]) {
+		ver = "0.0.0"
+		dirty = true
+	} else if isX(strings.TrimPrefix(m[4], ".")) {
+		minorDirty = true
+		dirty = true
+		ver = fmt.Sprintf("%s.0.0%s", m[3], m[6])
+	} else if isX(strings.TrimPrefix(m[5], ".")) {
+		dirty = true
+		patchDirty = true
+		ver = fmt.Sprintf("%s%s.0%s", m[3], m[4], m[6])
+	}
+
+	con, err := NewVersion(ver)
+	if err != nil {
+
+		// The constraintRegex should catch any regex parsing errors. So,
+		// we should never get here.
+		return nil, errors.New("constraint Parser Error")
+	}
+
+	cs := &constraint{
+		function:   constraintOps[m[1]],
+		msg:        constraintMsg[m[1]],
+		con:        con,
+		orig:       orig,
+		minorDirty: minorDirty,
+		patchDirty: patchDirty,
+		dirty:      dirty,
+	}
+	return cs, nil
+}
+
+// Constraint functions
+func constraintNotEqual(v *Version, c *constraint) bool {
+	if c.dirty {
+
+		// If there is a pre-release on the version but the constraint isn't looking
+		// for them assume that pre-releases are not compatible. See issue 21 for
+		// more details.
+		if v.Prerelease() != "" && c.con.Prerelease() == "" {
+			return false
+		}
+
+		if c.con.Major() != v.Major() {
+			return true
+		}
+		if c.con.Minor() != v.Minor() && !c.minorDirty {
+			return true
+		} else if c.minorDirty {
+			return false
+		}
+
+		return false
+	}
+
+	return !v.Equal(c.con)
+}
+
+func constraintGreaterThan(v *Version, c *constraint) bool {
+
+	// An edge case the constraint is 0.0.0 and the version is 0.0.0-someprerelease
+	// exists. This that case.
+	if !isNonZero(c.con) && isNonZero(v) {
+		return true
+	}
+
+	// If there is a pre-release on the version but the constraint isn't looking
+	// for them assume that pre-releases are not compatible. See issue 21 for
+	// more details.
+	if v.Prerelease() != "" && c.con.Prerelease() == "" {
+		return false
+	}
+
+	return v.Compare(c.con) == 1
+}
+
+func constraintLessThan(v *Version, c *constraint) bool {
+	// If there is a pre-release on the version but the constraint isn't looking
+	// for them assume that pre-releases are not compatible. See issue 21 for
+	// more details.
+	if v.Prerelease() != "" && c.con.Prerelease() == "" {
+		return false
+	}
+
+	if !c.dirty {
+		return v.Compare(c.con) < 0
+	}
+
+	if v.Major() > c.con.Major() {
+		return false
+	} else if v.Minor() > c.con.Minor() && !c.minorDirty {
+		return false
+	}
+
+	return true
+}
+
+func constraintGreaterThanEqual(v *Version, c *constraint) bool {
+	// An edge case the constraint is 0.0.0 and the version is 0.0.0-someprerelease
+	// exists. This that case.
+	if !isNonZero(c.con) && isNonZero(v) {
+		return true
+	}
+
+	// If there is a pre-release on the version but the constraint isn't looking
+	// for them assume that pre-releases are not compatible. See issue 21 for
+	// more details.
+	if v.Prerelease() != "" && c.con.Prerelease() == "" {
+		return false
+	}
+
+	return v.Compare(c.con) >= 0
+}
+
+func constraintLessThanEqual(v *Version, c *constraint) bool {
+	// If there is a pre-release on the version but the constraint isn't looking
+	// for them assume that pre-releases are not compatible. See issue 21 for
+	// more details.
+	if v.Prerelease() != "" && c.con.Prerelease() == "" {
+		return false
+	}
+
+	if !c.dirty {
+		return v.Compare(c.con) <= 0
+	}
+
+	if v.Major() > c.con.Major() {
+		return false
+	} else if v.Minor() > c.con.Minor() && !c.minorDirty {
+		return false
+	}
+
+	return true
+}
+
+// ~*, ~>* --> >= 0.0.0 (any)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0, <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0, <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0, <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3, <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0, <1.3.0
+func constraintTilde(v *Version, c *constraint) bool {
+	// If there is a pre-release on the version but the constraint isn't looking
+	// for them assume that pre-releases are not compatible. See issue 21 for
+	// more details.
+	if v.Prerelease() != "" && c.con.Prerelease() == "" {
+		return false
+	}
+
+	if v.LessThan(c.con) {
+		return false
+	}
+
+	// ~0.0.0 is a special case where all constraints are accepted. It's
+	// equivalent to >= 0.0.0.
+	if c.con.Major() == 0 && c.con.Minor() == 0 && c.con.Patch() == 0 &&
+		!c.minorDirty && !c.patchDirty {
+		return true
+	}
+
+	if v.Major() != c.con.Major() {
+		return false
+	}
+
+	if v.Minor() != c.con.Minor() && !c.minorDirty {
+		return false
+	}
+
+	return true
+}
+
+// When there is a .x (dirty) status it automatically opts in to ~. Otherwise
+// it's a straight =
+func constraintTildeOrEqual(v *Version, c *constraint) bool {
+	// If there is a pre-release on the version but the constraint isn't looking
+	// for them assume that pre-releases are not compatible. See issue 21 for
+	// more details.
+	if v.Prerelease() != "" && c.con.Prerelease() == "" {
+		return false
+	}
+
+	if c.dirty {
+		c.msg = constraintMsg["~"]
+		return constraintTilde(v, c)
+	}
+
+	return v.Equal(c.con)
+}
+
+// ^* --> (any)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0, <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0, <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0, <2.0.0
+// ^1.2.3 --> >=1.2.3, <2.0.0
+// ^1.2.0 --> >=1.2.0, <2.0.0
+func constraintCaret(v *Version, c *constraint) bool {
+	// If there is a pre-release on the version but the constraint isn't looking
+	// for them assume that pre-releases are not compatible. See issue 21 for
+	// more details.
+	if v.Prerelease() != "" && c.con.Prerelease() == "" {
+		return false
+	}
+
+	if v.LessThan(c.con) {
+		return false
+	}
+
+	if v.Major() != c.con.Major() {
+		return false
+	}
+
+	return true
+}
+
+var constraintRangeRegex *regexp.Regexp
+
+const cvRegex string = `v?([0-9|x|X|\*]+)(\.[0-9|x|X|\*]+)?(\.[0-9|x|X|\*]+)?` +
+	`(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
+	`(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?`
+
+func isX(x string) bool {
+	switch x {
+	case "x", "*", "X":
+		return true
+	default:
+		return false
+	}
+}
+
+func rewriteRange(i string) string {
+	m := constraintRangeRegex.FindAllStringSubmatch(i, -1)
+	if m == nil {
+		return i
+	}
+	o := i
+	for _, v := range m {
+		t := fmt.Sprintf(">= %s, <= %s", v[1], v[11])
+		o = strings.Replace(o, v[0], t, 1)
+	}
+
+	return o
+}
+
+// Detect if a version is not zero (0.0.0)
+func isNonZero(v *Version) bool {
+	if v.Major() != 0 || v.Minor() != 0 || v.Patch() != 0 || v.Prerelease() != "" {
+		return true
+	}
+
+	return false
+}

vendor/github.com/Masterminds/semver/doc.go

@@ -0,0 +1,115 @@
+/*
+Package semver provides the ability to work with Semantic Versions (http://semver.org) in Go.
+
+Specifically it provides the ability to:
+
+    * Parse semantic versions
+    * Sort semantic versions
+    * Check if a semantic version fits within a set of constraints
+    * Optionally work with a `v` prefix
+
+Parsing Semantic Versions
+
+To parse a semantic version use the `NewVersion` function. For example,
+
+    v, err := semver.NewVersion("1.2.3-beta.1+build345")
+
+If there is an error the version wasn't parseable. The version object has methods
+to get the parts of the version, compare it to other versions, convert the
+version back into a string, and get the original string. For more details
+please see the documentation at https://godoc.org/github.com/Masterminds/semver.
+
+Sorting Semantic Versions
+
+A set of versions can be sorted using the `sort` package from the standard library.
+For example,
+
+    raw := []string{"1.2.3", "1.0", "1.3", "2", "0.4.2",}
+    vs := make([]*semver.Version, len(raw))
+	for i, r := range raw {
+		v, err := semver.NewVersion(r)
+		if err != nil {
+			t.Errorf("Error parsing version: %s", err)
+		}
+
+		vs[i] = v
+	}
+
+	sort.Sort(semver.Collection(vs))
+
+Checking Version Constraints
+
+Checking a version against version constraints is one of the most featureful
+parts of the package.
+
+    c, err := semver.NewConstraint(">= 1.2.3")
+    if err != nil {
+        // Handle constraint not being parseable.
+    }
+
+    v, _ := semver.NewVersion("1.3")
+    if err != nil {
+        // Handle version not being parseable.
+    }
+    // Check if the version meets the constraints. The a variable will be true.
+    a := c.Check(v)
+
+Basic Comparisons
+
+There are two elements to the comparisons. First, a comparison string is a list
+of comma separated and comparisons. These are then separated by || separated or
+comparisons. For example, `">= 1.2, < 3.0.0 || >= 4.2.3"` is looking for a
+comparison that's greater than or equal to 1.2 and less than 3.0.0 or is
+greater than or equal to 4.2.3.
+
+The basic comparisons are:
+
+    * `=`: equal (aliased to no operator)
+    * `!=`: not equal
+    * `>`: greater than
+    * `<`: less than
+    * `>=`: greater than or equal to
+    * `<=`: less than or equal to
+
+Hyphen Range Comparisons
+
+There are multiple methods to handle ranges and the first is hyphens ranges.
+These look like:
+
+    * `1.2 - 1.4.5` which is equivalent to `>= 1.2, <= 1.4.5`
+    * `2.3.4 - 4.5` which is equivalent to `>= 2.3.4, <= 4.5`
+
+Wildcards In Comparisons
+
+The `x`, `X`, and `*` characters can be used as a wildcard character. This works
+for all comparison operators. When used on the `=` operator it falls
+back to the pack level comparison (see tilde below). For example,
+
+    * `1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
+    * `>= 1.2.x` is equivalent to `>= 1.2.0`
+    * `<= 2.x` is equivalent to `<= 3`
+    * `*` is equivalent to `>= 0.0.0`
+
+Tilde Range Comparisons (Patch)
+
+The tilde (`~`) comparison operator is for patch level ranges when a minor
+version is specified and major level changes when the minor number is missing.
+For example,
+
+    * `~1.2.3` is equivalent to `>= 1.2.3, < 1.3.0`
+    * `~1` is equivalent to `>= 1, < 2`
+    * `~2.3` is equivalent to `>= 2.3, < 2.4`
+    * `~1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
+    * `~1.x` is equivalent to `>= 1, < 2`
+
+Caret Range Comparisons (Major)
+
+The caret (`^`) comparison operator is for major level changes. This is useful
+when comparisons of API versions as a major change is API breaking. For example,
+
+    * `^1.2.3` is equivalent to `>= 1.2.3, < 2.0.0`
+    * `^1.2.x` is equivalent to `>= 1.2.0, < 2.0.0`
+    * `^2.3` is equivalent to `>= 2.3, < 3`
+    * `^2.x` is equivalent to `>= 2.0.0, < 3`
+*/
+package semver

vendor/github.com/Masterminds/semver/version.go

@@ -0,0 +1,375 @@
+package semver
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// The compiled version of the regex created at init() is cached here so it
+// only needs to be created once.
+var versionRegex *regexp.Regexp
+var validPrereleaseRegex *regexp.Regexp
+
+var (
+	// ErrInvalidSemVer is returned a version is found to be invalid when
+	// being parsed.
+	ErrInvalidSemVer = errors.New("Invalid Semantic Version")
+
+	// ErrInvalidMetadata is returned when the metadata is an invalid format
+	ErrInvalidMetadata = errors.New("Invalid Metadata string")
+
+	// ErrInvalidPrerelease is returned when the pre-release is an invalid format
+	ErrInvalidPrerelease = errors.New("Invalid Prerelease string")
+)
+
+// SemVerRegex is the regular expression used to parse a semantic version.
+const SemVerRegex string = `v?([0-9]+)(\.[0-9]+)?(\.[0-9]+)?` +
+	`(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
+	`(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?`
+
+// ValidPrerelease is the regular expression which validates
+// both prerelease and metadata values.
+const ValidPrerelease string = `^([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*)`
+
+// Version represents a single semantic version.
+type Version struct {
+	major, minor, patch int64
+	pre                 string
+	metadata            string
+	original            string
+}
+
+func init() {
+	versionRegex = regexp.MustCompile("^" + SemVerRegex + "$")
+	validPrereleaseRegex = regexp.MustCompile(ValidPrerelease)
+}
+
+// NewVersion parses a given version and returns an instance of Version or
+// an error if unable to parse the version.
+func NewVersion(v string) (*Version, error) {
+	m := versionRegex.FindStringSubmatch(v)
+	if m == nil {
+		return nil, ErrInvalidSemVer
+	}
+
+	sv := &Version{
+		metadata: m[8],
+		pre:      m[5],
+		original: v,
+	}
+
+	var temp int64
+	temp, err := strconv.ParseInt(m[1], 10, 32)
+	if err != nil {
+		return nil, fmt.Errorf("Error parsing version segment: %s", err)
+	}
+	sv.major = temp
+
+	if m[2] != "" {
+		temp, err = strconv.ParseInt(strings.TrimPrefix(m[2], "."), 10, 32)
+		if err != nil {
+			return nil, fmt.Errorf("Error parsing version segment: %s", err)
+		}
+		sv.minor = temp
+	} else {
+		sv.minor = 0
+	}
+
+	if m[3] != "" {
+		temp, err = strconv.ParseInt(strings.TrimPrefix(m[3], "."), 10, 32)
+		if err != nil {
+			return nil, fmt.Errorf("Error parsing version segment: %s", err)
+		}
+		sv.patch = temp
+	} else {
+		sv.patch = 0
+	}
+
+	return sv, nil
+}
+
+// MustParse parses a given version and panics on error.
+func MustParse(v string) *Version {
+	sv, err := NewVersion(v)
+	if err != nil {
+		panic(err)
+	}
+	return sv
+}
+
+// String converts a Version object to a string.
+// Note, if the original version contained a leading v this version will not.
+// See the Original() method to retrieve the original value. Semantic Versions
+// don't contain a leading v per the spec. Instead it's optional on
+// impelementation.
+func (v *Version) String() string {
+	var buf bytes.Buffer
+
+	fmt.Fprintf(&buf, "%d.%d.%d", v.major, v.minor, v.patch)
+	if v.pre != "" {
+		fmt.Fprintf(&buf, "-%s", v.pre)
+	}
+	if v.metadata != "" {
+		fmt.Fprintf(&buf, "+%s", v.metadata)
+	}
+
+	return buf.String()
+}
+
+// Original returns the original value passed in to be parsed.
+func (v *Version) Original() string {
+	return v.original
+}
+
+// Major returns the major version.
+func (v *Version) Major() int64 {
+	return v.major
+}
+
+// Minor returns the minor version.
+func (v *Version) Minor() int64 {
+	return v.minor
+}
+
+// Patch returns the patch version.
+func (v *Version) Patch() int64 {
+	return v.patch
+}
+
+// Prerelease returns the pre-release version.
+func (v *Version) Prerelease() string {
+	return v.pre
+}
+
+// Metadata returns the metadata on the version.
+func (v *Version) Metadata() string {
+	return v.metadata
+}
+
+// originalVPrefix returns the original 'v' prefix if any.
+func (v *Version) originalVPrefix() string {
+
+	// Note, only lowercase v is supported as a prefix by the parser.
+	if v.original != "" && v.original[:1] == "v" {
+		return v.original[:1]
+	}
+	return ""
+}
+
+// IncPatch produces the next patch version.
+// If the current version does not have prerelease/metadata information,
+// it unsets metadata and prerelease values, increments patch number.
+// If the current version has any of prerelease or metadata information,
+// it unsets both values and keeps curent patch value
+func (v Version) IncPatch() Version {
+	vNext := v
+	// according to http://semver.org/#spec-item-9
+	// Pre-release versions have a lower precedence than the associated normal version.
+	// according to http://semver.org/#spec-item-10
+	// Build metadata SHOULD be ignored when determining version precedence.
+	if v.pre != "" {
+		vNext.metadata = ""
+		vNext.pre = ""
+	} else {
+		vNext.metadata = ""
+		vNext.pre = ""
+		vNext.patch = v.patch + 1
+	}
+	vNext.original = v.originalVPrefix() + "" + vNext.String()
+	return vNext
+}
+
+// IncMinor produces the next minor version.
+// Sets patch to 0.
+// Increments minor number.
+// Unsets metadata.
+// Unsets prerelease status.
+func (v Version) IncMinor() Version {
+	vNext := v
+	vNext.metadata = ""
+	vNext.pre = ""
+	vNext.patch = 0
+	vNext.minor = v.minor + 1
+	vNext.original = v.originalVPrefix() + "" + vNext.String()
+	return vNext
+}
+
+// IncMajor produces the next major version.
+// Sets patch to 0.
+// Sets minor to 0.
+// Increments major number.
+// Unsets metadata.
+// Unsets prerelease status.
+func (v Version) IncMajor() Version {
+	vNext := v
+	vNext.metadata = ""
+	vNext.pre = ""
+	vNext.patch = 0
+	vNext.minor = 0
+	vNext.major = v.major + 1
+	vNext.original = v.originalVPrefix() + "" + vNext.String()
+	return vNext
+}
+
+// SetPrerelease defines the prerelease value.
+// Value must not include the required 'hypen' prefix.
+func (v Version) SetPrerelease(prerelease string) (Version, error) {
+	vNext := v
+	if len(prerelease) > 0 && !validPrereleaseRegex.MatchString(prerelease) {
+		return vNext, ErrInvalidPrerelease
+	}
+	vNext.pre = prerelease
+	vNext.original = v.originalVPrefix() + "" + vNext.String()
+	return vNext, nil
+}
+
+// SetMetadata defines metadata value.
+// Value must not include the required 'plus' prefix.
+func (v Version) SetMetadata(metadata string) (Version, error) {
+	vNext := v
+	if len(metadata) > 0 && !validPrereleaseRegex.MatchString(metadata) {
+		return vNext, ErrInvalidMetadata
+	}
+	vNext.metadata = metadata
+	vNext.original = v.originalVPrefix() + "" + vNext.String()
+	return vNext, nil
+}
+
+// LessThan tests if one version is less than another one.
+func (v *Version) LessThan(o *Version) bool {
+	return v.Compare(o) < 0
+}
+
+// GreaterThan tests if one version is greater than another one.
+func (v *Version) GreaterThan(o *Version) bool {
+	return v.Compare(o) > 0
+}
+
+// Equal tests if two versions are equal to each other.
+// Note, versions can be equal with different metadata since metadata
+// is not considered part of the comparable version.
+func (v *Version) Equal(o *Version) bool {
+	return v.Compare(o) == 0
+}
+
+// Compare compares this version to another one. It returns -1, 0, or 1 if
+// the version smaller, equal, or larger than the other version.
+//
+// Versions are compared by X.Y.Z. Build metadata is ignored. Prerelease is
+// lower than the version without a prerelease.
+func (v *Version) Compare(o *Version) int {
+	// Compare the major, minor, and patch version for differences. If a
+	// difference is found return the comparison.
+	if d := compareSegment(v.Major(), o.Major()); d != 0 {
+		return d
+	}
+	if d := compareSegment(v.Minor(), o.Minor()); d != 0 {
+		return d
+	}
+	if d := compareSegment(v.Patch(), o.Patch()); d != 0 {
+		return d
+	}
+
+	// At this point the major, minor, and patch versions are the same.
+	ps := v.pre
+	po := o.Prerelease()
+
+	if ps == "" && po == "" {
+		return 0
+	}
+	if ps == "" {
+		return 1
+	}
+	if po == "" {
+		return -1
+	}
+
+	return comparePrerelease(ps, po)
+}
+
+func compareSegment(v, o int64) int {
+	if v < o {
+		return -1
+	}
+	if v > o {
+		return 1
+	}
+
+	return 0
+}
+
+func comparePrerelease(v, o string) int {
+
+	// split the prelease versions by their part. The separator, per the spec,
+	// is a .
+	sparts := strings.Split(v, ".")
+	oparts := strings.Split(o, ".")
+
+	// Find the longer length of the parts to know how many loop iterations to
+	// go through.
+	slen := len(sparts)
+	olen := len(oparts)
+
+	l := slen
+	if olen > slen {
+		l = olen
+	}
+
+	// Iterate over each part of the prereleases to compare the differences.
+	for i := 0; i < l; i++ {
+		// Since the lentgh of the parts can be different we need to create
+		// a placeholder. This is to avoid out of bounds issues.
+		stemp := ""
+		if i < slen {
+			stemp = sparts[i]
+		}
+
+		otemp := ""
+		if i < olen {
+			otemp = oparts[i]
+		}
+
+		d := comparePrePart(stemp, otemp)
+		if d != 0 {
+			return d
+		}
+	}
+
+	// Reaching here means two versions are of equal value but have different
+	// metadata (the part following a +). They are not identical in string form
+	// but the version comparison finds them to be equal.
+	return 0
+}
+
+func comparePrePart(s, o string) int {
+	// Fastpath if they are equal
+	if s == o {
+		return 0
+	}
+
+	// When s or o are empty we can use the other in an attempt to determine
+	// the response.
+	if o == "" {
+		_, n := strconv.ParseInt(s, 10, 64)
+		if n != nil {
+			return -1
+		}
+		return 1
+	}
+	if s == "" {
+		_, n := strconv.ParseInt(o, 10, 64)
+		if n != nil {
+			return 1
+		}
+		return -1
+	}
+
+	if s > o {
+		return 1
+	}
+	return -1
+}

vendor/github.com/Masterminds/sprig/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Release 1.2.0 (2016-02-01)
+
+- Added quote and squote
+- Added b32enc and b32dec
+- add now takes varargs
+- biggest now takes varargs
+
+# Release 1.1.0 (2015-12-29)
+
+- Added #4: Added contains function. strings.Contains, but with the arguments
+  switched to simplify common pipelines. (thanks krancour)
+- Added Travis-CI testing support
+
+# Release 1.0.0 (2015-12-23)
+
+- Initial release

vendor/github.com/Masterminds/sprig/LICENSE.txt

@@ -0,0 +1,20 @@
+Sprig
+Copyright (C) 2013 Masterminds
+
+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/Masterminds/sprig/Makefile

@@ -0,0 +1,13 @@
+
+HAS_GLIDE := $(shell command -v glide;)
+
+.PHONY: test
+test:
+	go test -v .
+
+.PHONY: setup
+setup:
+ifndef HAS_GLIDE
+	go get -u github.com/Masterminds/glide
+endif
+	glide install

vendor/github.com/Masterminds/sprig/README.md

@@ -0,0 +1,81 @@
+# Sprig: Template functions for Go templates
+[![Stability: Sustained](https://masterminds.github.io/stability/sustained.svg)](https://masterminds.github.io/stability/sustained.html)
+[![Build Status](https://travis-ci.org/Masterminds/sprig.svg?branch=master)](https://travis-ci.org/Masterminds/sprig)
+
+The Go language comes with a [built-in template
+language](http://golang.org/pkg/text/template/), but not
+very many template functions. This library provides a group of commonly
+used template functions.
+
+It is inspired by the template functions found in
+[Twig](http://twig.sensiolabs.org/documentation) and also in various
+JavaScript libraries, such as [underscore.js](http://underscorejs.org/).
+
+## Usage
+
+Template developers can read the [Sprig function documentation](http://masterminds.github.io/sprig/) to
+learn about the >100 template functions available.
+
+For Go developers wishing to include Sprig as a library in their programs,
+API documentation is available [at GoDoc.org](http://godoc.org/github.com/Masterminds/sprig), but
+read on for standard usage.
+
+### Load the Sprig library
+
+To load the Sprig `FuncMap`:
+
+```go
+
+import (
+  "github.com/Masterminds/sprig"
+  "html/template"
+)
+
+// This example illustrates that the FuncMap *must* be set before the
+// templates themselves are loaded.
+tpl := template.Must(
+  template.New("base").Funcs(sprig.FuncMap()).ParseGlob("*.html")
+)
+
+
+```
+
+### Call the functions inside of templates
+
+By convention, all functions are lowercase. This seems to follow the Go
+idiom for template functions (as opposed to template methods, which are
+TitleCase).
+
+
+Example:
+
+```
+{{ "hello!" | upper | repeat 5 }}
+```
+
+Produces:
+
+```
+HELLO!HELLO!HELLO!HELLO!HELLO!
+```
+
+## Principles:
+
+The following principles were used in deciding on which functions to add, and
+determining how to implement them.
+
+- Template functions should be used to build layout. Therefore, the following
+  types of operations are within the domain of template functions:
+  - Formatting
+  - Layout
+  - Simple type conversions
+  - Utilities that assist in handling common formatting and layout needs (e.g. arithmetic)
+- Template functions should not return errors unless there is no way to print
+  a sensible value. For example, converting a string to an integer should not
+  produce an error if conversion fails. Instead, it should display a default
+  value that can be displayed.
+- Simple math is necessary for grid layouts, pagers, and so on. Complex math
+  (anything other than arithmetic) should be done outside of templates.
+- Template functions only deal with the data passed into them. They never retrieve
+  data from a source.
+- Finally, do not override core Go template functions.

vendor/github.com/Masterminds/sprig/crypto.go

@@ -0,0 +1,148 @@
+package sprig
+
+import (
+	"bytes"
+	"crypto/dsa"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha256"
+	"crypto/x509"
+	"encoding/asn1"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/pem"
+	"fmt"
+	"math/big"
+
+	uuid "github.com/satori/go.uuid"
+	"golang.org/x/crypto/scrypt"
+)
+
+func sha256sum(input string) string {
+	hash := sha256.Sum256([]byte(input))
+	return hex.EncodeToString(hash[:])
+}
+
+// uuidv4 provides a safe and secure UUID v4 implementation
+func uuidv4() string {
+	return fmt.Sprintf("%s", uuid.NewV4())
+}
+
+var master_password_seed = "com.lyndir.masterpassword"
+
+var password_type_templates = map[string][][]byte{
+	"maximum": {[]byte("anoxxxxxxxxxxxxxxxxx"), []byte("axxxxxxxxxxxxxxxxxno")},
+	"long": {[]byte("CvcvnoCvcvCvcv"), []byte("CvcvCvcvnoCvcv"), []byte("CvcvCvcvCvcvno"), []byte("CvccnoCvcvCvcv"), []byte("CvccCvcvnoCvcv"),
+		[]byte("CvccCvcvCvcvno"), []byte("CvcvnoCvccCvcv"), []byte("CvcvCvccnoCvcv"), []byte("CvcvCvccCvcvno"), []byte("CvcvnoCvcvCvcc"),
+		[]byte("CvcvCvcvnoCvcc"), []byte("CvcvCvcvCvccno"), []byte("CvccnoCvccCvcv"), []byte("CvccCvccnoCvcv"), []byte("CvccCvccCvcvno"),
+		[]byte("CvcvnoCvccCvcc"), []byte("CvcvCvccnoCvcc"), []byte("CvcvCvccCvccno"), []byte("CvccnoCvcvCvcc"), []byte("CvccCvcvnoCvcc"),
+		[]byte("CvccCvcvCvccno")},
+	"medium": {[]byte("CvcnoCvc"), []byte("CvcCvcno")},
+	"short":  {[]byte("Cvcn")},
+	"basic":  {[]byte("aaanaaan"), []byte("aannaaan"), []byte("aaannaaa")},
+	"pin":    {[]byte("nnnn")},
+}
+
+var template_characters = map[byte]string{
+	'V': "AEIOU",
+	'C': "BCDFGHJKLMNPQRSTVWXYZ",
+	'v': "aeiou",
+	'c': "bcdfghjklmnpqrstvwxyz",
+	'A': "AEIOUBCDFGHJKLMNPQRSTVWXYZ",
+	'a': "AEIOUaeiouBCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz",
+	'n': "0123456789",
+	'o': "@&%?,=[]_:-+*$#!'^~;()/.",
+	'x': "AEIOUaeiouBCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz0123456789!@#$%^&*()",
+}
+
+func derivePassword(counter uint32, password_type, password, user, site string) string {
+	var templates = password_type_templates[password_type]
+	if templates == nil {
+		return fmt.Sprintf("cannot find password template %s", password_type)
+	}
+
+	var buffer bytes.Buffer
+	buffer.WriteString(master_password_seed)
+	binary.Write(&buffer, binary.BigEndian, uint32(len(user)))
+	buffer.WriteString(user)
+
+	salt := buffer.Bytes()
+	key, err := scrypt.Key([]byte(password), salt, 32768, 8, 2, 64)
+	if err != nil {
+		return fmt.Sprintf("failed to derive password: %s", err)
+	}
+
+	buffer.Truncate(len(master_password_seed))
+	binary.Write(&buffer, binary.BigEndian, uint32(len(site)))
+	buffer.WriteString(site)
+	binary.Write(&buffer, binary.BigEndian, counter)
+
+	var hmacv = hmac.New(sha256.New, key)
+	hmacv.Write(buffer.Bytes())
+	var seed = hmacv.Sum(nil)
+	var temp = templates[int(seed[0])%len(templates)]
+
+	buffer.Truncate(0)
+	for i, element := range temp {
+		pass_chars := template_characters[element]
+		pass_char := pass_chars[int(seed[i+1])%len(pass_chars)]
+		buffer.WriteByte(pass_char)
+	}
+
+	return buffer.String()
+}
+
+func generatePrivateKey(typ string) string {
+	var priv interface{}
+	var err error
+	switch typ {
+	case "", "rsa":
+		// good enough for government work
+		priv, err = rsa.GenerateKey(rand.Reader, 4096)
+	case "dsa":
+		key := new(dsa.PrivateKey)
+		// again, good enough for government work
+		if err = dsa.GenerateParameters(&key.Parameters, rand.Reader, dsa.L2048N256); err != nil {
+			return fmt.Sprintf("failed to generate dsa params: %s", err)
+		}
+		err = dsa.GenerateKey(key, rand.Reader)
+		priv = key
+	case "ecdsa":
+		// again, good enough for government work
+		priv, err = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	default:
+		return "Unknown type " + typ
+	}
+	if err != nil {
+		return fmt.Sprintf("failed to generate private key: %s", err)
+	}
+
+	return string(pem.EncodeToMemory(pemBlockForKey(priv)))
+}
+
+type DSAKeyFormat struct {
+	Version       int
+	P, Q, G, Y, X *big.Int
+}
+
+func pemBlockForKey(priv interface{}) *pem.Block {
+	switch k := priv.(type) {
+	case *rsa.PrivateKey:
+		return &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(k)}
+	case *dsa.PrivateKey:
+		val := DSAKeyFormat{
+			P: k.P, Q: k.Q, G: k.G,
+			Y: k.Y, X: k.X,
+		}
+		bytes, _ := asn1.Marshal(val)
+		return &pem.Block{Type: "DSA PRIVATE KEY", Bytes: bytes}
+	case *ecdsa.PrivateKey:
+		b, _ := x509.MarshalECPrivateKey(k)
+		return &pem.Block{Type: "EC PRIVATE KEY", Bytes: b}
+	default:
+		return nil
+	}
+}

vendor/github.com/Masterminds/sprig/date.go

@@ -0,0 +1,53 @@
+package sprig
+
+import (
+	"time"
+)
+
+// Given a format and a date, format the date string.
+//
+// Date can be a `time.Time` or an `int, int32, int64`.
+// In the later case, it is treated as seconds since UNIX
+// epoch.
+func date(fmt string, date interface{}) string {
+	return dateInZone(fmt, date, "Local")
+}
+
+func htmlDate(date interface{}) string {
+	return dateInZone("2006-01-02", date, "Local")
+}
+
+func htmlDateInZone(date interface{}, zone string) string {
+	return dateInZone("2006-01-02", date, zone)
+}
+
+func dateInZone(fmt string, date interface{}, zone string) string {
+	var t time.Time
+	switch date := date.(type) {
+	default:
+		t = time.Now()
+	case time.Time:
+		t = date
+	case int64:
+		t = time.Unix(date, 0)
+	case int:
+		t = time.Unix(int64(date), 0)
+	case int32:
+		t = time.Unix(int64(date), 0)
+	}
+
+	loc, err := time.LoadLocation(zone)
+	if err != nil {
+		loc, _ = time.LoadLocation("UTC")
+	}
+
+	return t.In(loc).Format(fmt)
+}
+
+func dateModify(fmt string, date time.Time) time.Time {
+	d, err := time.ParseDuration(fmt)
+	if err != nil {
+		return date
+	}
+	return date.Add(d)
+}

vendor/github.com/Masterminds/sprig/defaults.go

@@ -0,0 +1,75 @@
+package sprig
+
+import (
+	"encoding/json"
+	"reflect"
+)
+
+// dfault checks whether `given` is set, and returns default if not set.
+//
+// This returns `d` if `given` appears not to be set, and `given` otherwise.
+//
+// For numeric types 0 is unset.
+// For strings, maps, arrays, and slices, len() = 0 is considered unset.
+// For bool, false is unset.
+// Structs are never considered unset.
+//
+// For everything else, including pointers, a nil value is unset.
+func dfault(d interface{}, given ...interface{}) interface{} {
+
+	if empty(given) || empty(given[0]) {
+		return d
+	}
+	return given[0]
+}
+
+// empty returns true if the given value has the zero value for its type.
+func empty(given interface{}) bool {
+	g := reflect.ValueOf(given)
+	if !g.IsValid() {
+		return true
+	}
+
+	// Basically adapted from text/template.isTrue
+	switch g.Kind() {
+	default:
+		return g.IsNil()
+	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
+		return g.Len() == 0
+	case reflect.Bool:
+		return g.Bool() == false
+	case reflect.Complex64, reflect.Complex128:
+		return g.Complex() == 0
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return g.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return g.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return g.Float() == 0
+	case reflect.Struct:
+		return false
+	}
+	return true
+}
+
+// coalesce returns the first non-empty value.
+func coalesce(v ...interface{}) interface{} {
+	for _, val := range v {
+		if !empty(val) {
+			return val
+		}
+	}
+	return nil
+}
+
+// toJson encodes an item into a JSON string
+func toJson(v interface{}) string {
+	output, _ := json.Marshal(v)
+	return string(output)
+}
+
+// toPrettyJson encodes an item into a pretty (indented) JSON string
+func toPrettyJson(v interface{}) string {
+	output, _ := json.MarshalIndent(v, "", "  ")
+	return string(output)
+}

vendor/github.com/Masterminds/sprig/dict.go

@@ -0,0 +1,74 @@
+package sprig
+
+func set(d map[string]interface{}, key string, value interface{}) map[string]interface{} {
+	d[key] = value
+	return d
+}
+
+func unset(d map[string]interface{}, key string) map[string]interface{} {
+	delete(d, key)
+	return d
+}
+
+func hasKey(d map[string]interface{}, key string) bool {
+	_, ok := d[key]
+	return ok
+}
+
+func pluck(key string, d ...map[string]interface{}) []interface{} {
+	res := []interface{}{}
+	for _, dict := range d {
+		if val, ok := dict[key]; ok {
+			res = append(res, val)
+		}
+	}
+	return res
+}
+
+func keys(dict map[string]interface{}) []string {
+	k := []string{}
+	for key := range dict {
+		k = append(k, key)
+	}
+	return k
+}
+
+func pick(dict map[string]interface{}, keys ...string) map[string]interface{} {
+	res := map[string]interface{}{}
+	for _, k := range keys {
+		if v, ok := dict[k]; ok {
+			res[k] = v
+		}
+	}
+	return res
+}
+
+func omit(dict map[string]interface{}, keys ...string) map[string]interface{} {
+	res := map[string]interface{}{}
+
+	omit := make(map[string]bool, len(keys))
+	for _, k := range keys {
+		omit[k] = true
+	}
+
+	for k, v := range dict {
+		if _, ok := omit[k]; !ok {
+			res[k] = v
+		}
+	}
+	return res
+}
+
+func dict(v ...interface{}) map[string]interface{} {
+	dict := map[string]interface{}{}
+	lenv := len(v)
+	for i := 0; i < lenv; i += 2 {
+		key := strval(v[i])
+		if i+1 >= lenv {
+			dict[key] = ""
+			continue
+		}
+		dict[key] = v[i+1]
+	}
+	return dict
+}

vendor/github.com/Masterminds/sprig/doc.go

@@ -0,0 +1,225 @@
+/*
+Sprig: Template functions for Go.
+
+This package contains a number of utility functions for working with data
+inside of Go `html/template` and `text/template` files.
+
+To add these functions, use the `template.Funcs()` method:
+
+	t := templates.New("foo").Funcs(sprig.FuncMap())
+
+Note that you should add the function map before you parse any template files.
+
+	In several cases, Sprig reverses the order of arguments from the way they
+	appear in the standard library. This is to make it easier to pipe
+	arguments into functions.
+
+Date Functions
+
+	- date FORMAT TIME: Format a date, where a date is an integer type or a time.Time type, and
+	  format is a time.Format formatting string.
+	- dateModify: Given a date, modify it with a duration: `date_modify "-1.5h" now`. If the duration doesn't
+	parse, it returns the time unaltered. See `time.ParseDuration` for info on duration strings.
+	- now: Current time.Time, for feeding into date-related functions.
+	- htmlDate TIME: Format a date for use in the value field of an HTML "date" form element.
+	- dateInZone FORMAT TIME TZ: Like date, but takes three arguments: format, timestamp,
+	  timezone.
+	- htmlDateInZone TIME TZ: Like htmlDate, but takes two arguments: timestamp,
+	  timezone.
+
+String Functions
+
+	- abbrev: Truncate a string with ellipses. `abbrev 5 "hello world"` yields "he..."
+	- abbrevboth: Abbreviate from both sides, yielding "...lo wo..."
+	- trunc: Truncate a string (no suffix). `trunc 5 "Hello World"` yields "hello".
+	- trim: strings.TrimSpace
+	- trimAll: strings.Trim, but with the argument order reversed `trimAll "$" "$5.00"` or `"$5.00 | trimAll "$"`
+	- trimSuffix: strings.TrimSuffix, but with the argument order reversed: `trimSuffix "-" "ends-with-"`
+	- trimPrefix: strings.TrimPrefix, but with the argument order reversed `trimPrefix "$" "$5"`
+	- upper: strings.ToUpper
+	- lower: strings.ToLower
+	- nospace: Remove all space characters from a string. `nospace "h e l l o"` becomes "hello"
+	- title: strings.Title
+	- untitle: Remove title casing
+	- repeat: strings.Repeat, but with the arguments switched: `repeat count str`. (This simplifies common pipelines)
+	- substr: Given string, start, and length, return a substr.
+	- initials: Given a multi-word string, return the initials. `initials "Matt Butcher"` returns "MB"
+	- randAlphaNum: Given a length, generate a random alphanumeric sequence
+	- randAlpha: Given a length, generate an alphabetic string
+	- randAscii: Given a length, generate a random ASCII string (symbols included)
+	- randNumeric: Given a length, generate a string of digits.
+	- wrap: Force a line wrap at the given width. `wrap 80 "imagine a longer string"`
+	- wrapWith: Wrap a line at the given length, but using 'sep' instead of a newline. `wrapWith 50, "<br>", $html`
+	- contains: strings.Contains, but with the arguments switched: `contains substr str`. (This simplifies common pipelines)
+	- hasPrefix: strings.hasPrefix, but with the arguments switched
+	- hasSuffix: strings.hasSuffix, but with the arguments switched
+	- quote: Wrap string(s) in double quotation marks, escape the contents by adding '\' before '"'.
+	- squote: Wrap string(s) in double quotation marks, does not escape content.
+	- cat: Concatenate strings, separating them by spaces. `cat $a $b $c`.
+	- indent: Indent a string using space characters. `indent 4 "foo\nbar"` produces "    foo\n    bar"
+	- replace: Replace an old with a new in a string: `$name | replace " " "-"`
+	- plural: Choose singular or plural based on length: `len $fish | plural "one anchovy" "many anchovies"`
+	- sha256sum: Generate a hex encoded sha256 hash of the input
+	- toString: Convert something to a string
+
+String Slice Functions:
+
+	- join: strings.Join, but as `join SEP SLICE`
+	- split: strings.Split, but as `split SEP STRING`. The results are returned
+	  as a map with the indexes set to _N, where N is an integer starting from 0.
+	  Use it like this: `{{$v := "foo/bar/baz" | split "/"}}{{$v._0}}` (Prints `foo`)
+    - splitList: strings.Split, but as `split SEP STRING`. The results are returned
+	  as an array.
+	- toStrings: convert a list to a list of strings. 'list 1 2 3 | toStrings' produces '["1" "2" "3"]'
+	- sortAlpha: sort a list lexicographically.
+
+Integer Slice Functions:
+
+	- until: Given an integer, returns a slice of counting integers from 0 to one
+	  less than the given integer: `range $i, $e := until 5`
+	- untilStep: Given start, stop, and step, return an integer slice starting at
+	  'start', stopping at `stop`, and incrementing by 'step. This is the same
+	  as Python's long-form of 'range'.
+
+Conversions:
+
+	- atoi: Convert a string to an integer. 0 if the integer could not be parsed.
+	- in64: Convert a string or another numeric type to an int64.
+	- int: Convert a string or another numeric type to an int.
+	- float64: Convert a string or another numeric type to a float64.
+
+Defaults:
+
+	- default: Give a default value. Used like this: trim "   "| default "empty".
+	  Since trim produces an empty string, the default value is returned. For
+	  things with a length (strings, slices, maps), len(0) will trigger the default.
+	  For numbers, the value 0 will trigger the default. For booleans, false will
+	  trigger the default. For structs, the default is never returned (there is
+	  no clear empty condition). For everything else, nil value triggers a default.
+	- empty: Return true if the given value is the zero value for its type.
+	  Caveats: structs are always non-empty. This should match the behavior of
+	  {{if pipeline}}, but can be used inside of a pipeline.
+	- coalesce: Given a list of items, return the first non-empty one.
+	  This follows the same rules as 'empty'. '{{ coalesce .someVal 0 "hello" }}`
+	  will return `.someVal` if set, or else return "hello". The 0 is skipped
+	  because it is an empty value.
+	- compact: Return a copy of a list with all of the empty values removed.
+	  'list 0 1 2 "" | compact' will return '[1 2]'
+
+OS:
+	- env: Resolve an environment variable
+	- expandenv: Expand a string through the environment
+
+File Paths:
+	- base: Return the last element of a path. https://golang.org/pkg/path#Base
+	- dir: Remove the last element of a path. https://golang.org/pkg/path#Dir
+	- clean: Clean a path to the shortest equivalent name.  (e.g. remove "foo/.."
+	from "foo/../bar.html") https://golang.org/pkg/path#Clean
+	- ext: https://golang.org/pkg/path#Ext
+	- isAbs: https://golang.org/pkg/path#IsAbs
+
+Encoding:
+	- b64enc: Base 64 encode a string.
+	- b64dec: Base 64 decode a string.
+
+Reflection:
+
+	- typeOf: Takes an interface and returns a string representation of the type.
+	  For pointers, this will return a type prefixed with an asterisk(`*`). So
+	  a pointer to type `Foo` will be `*Foo`.
+	- typeIs: Compares an interface with a string name, and returns true if they match.
+	  Note that a pointer will not match a reference. For example `*Foo` will not
+	  match `Foo`.
+	- typeIsLike: Compares an interface with a string name and returns true if
+	  the interface is that `name` or that `*name`. In other words, if the given
+	  value matches the given type or is a pointer to the given type, this returns
+	  true.
+	- kindOf: Takes an interface and returns a string representation of its kind.
+	- kindIs: Returns true if the given string matches the kind of the given interface.
+
+	Note: None of these can test whether or not something implements a given
+	interface, since doing so would require compiling the interface in ahead of
+	time.
+
+Data Structures:
+
+	- tuple: Takes an arbitrary list of items and returns a slice of items. Its
+	  tuple-ish properties are mainly gained through the template idiom, and not
+	  through an API provided here. WARNING: The implementation of tuple will
+	  change in the future.
+	- list: An arbitrary ordered list of items. (This is prefered over tuple.)
+	- dict: Takes a list of name/values and returns a map[string]interface{}.
+	  The first parameter is converted to a string and stored as a key, the
+	  second parameter is treated as the value. And so on, with odds as keys and
+	  evens as values. If the function call ends with an odd, the last key will
+	  be assigned the empty string. Non-string keys are converted to strings as
+	  follows: []byte are converted, fmt.Stringers will have String() called.
+	  errors will have Error() called. All others will be passed through
+	  fmt.Sprtinf("%v").
+
+Lists Functions:
+
+These are used to manipulate lists: '{{ list 1 2 3 | reverse | first }}'
+
+	- first: Get the first item in a 'list'. 'list 1 2 3 | first' prints '1'
+	- last: Get the last item in a 'list': 'list 1 2 3 | last ' prints '3'
+	- rest: Get all but the first item in a list: 'list 1 2 3 | rest' returns '[2 3]'
+	- initial: Get all but the last item in a list: 'list 1 2 3 | initial' returns '[1 2]'
+	- append: Add an item to the end of a list: 'append $list 4' adds '4' to the end of '$list'
+	- prepend: Add an item to the beginning of a list: 'prepend $list 4' puts 4 at the beginning of the list.
+	- reverse: Reverse the items in a list.
+	- uniq: Remove duplicates from a list.
+	- without: Return a list with the given values removed: 'without (list 1 2 3) 1' would return '[2 3]'
+	- has: Return 'true' if the item is found in the list: 'has "foo" $list' will return 'true' if the list contains "foo"
+
+Dict Functions:
+
+These are used to manipulate dicts.
+
+	- set: Takes a dict, a key, and a value, and sets that key/value pair in
+	  the dict. `set $dict $key $value`. For convenience, it returns the dict,
+	  even though the dict was modified in place.
+	- unset: Takes a dict and a key, and deletes that key/value pair from the
+	  dict. `unset $dict $key`. This returns the dict for convenience.
+	- hasKey: Takes a dict and a key, and returns boolean true if the key is in
+	  the dict.
+	- pluck: Given a key and one or more maps, get all of the values for that key.
+	- keys: Get an array of all of the keys in a dict.
+	- pick: Select just the given keys out of the dict, and return a new dict.
+	- omit: Return a dict without the given keys.
+
+Math Functions:
+
+Integer functions will convert integers of any width to `int64`. If a
+string is passed in, functions will attempt to convert with
+`strconv.ParseInt(s, 1064)`. If this fails, the value will be treated as 0.
+
+	- add1: Increment an integer by 1
+	- add: Sum an arbitrary number of integers
+	- sub: Subtract the second integer from the first
+	- div: Divide the first integer by the second
+	- mod: Module of first integer divided by second
+	- mul: Multiply integers
+	- max: Return the biggest of a series of one or more integers
+	- min: Return the smallest of a series of one or more integers
+	- biggest: DEPRECATED. Return the biggest of a series of one or more integers
+
+Crypto Functions:
+
+	- genPrivateKey: Generate a private key for the given cryptosystem. If no
+	  argument is supplied, by default it will generate a private key using
+	  the RSA algorithm. Accepted values are `rsa`, `dsa`, and `ecdsa`.
+	- derivePassword: Derive a password from the given parameters according to the ["Master Password" algorithm](http://masterpasswordapp.com/algorithm.html)
+	  Given parameters (in order) are:
+          `counter` (starting with 1), `password_type` (maximum, long, medium, short, basic, or pin), `password`,
+           `user`, and `site`
+
+SemVer Functions:
+
+These functions provide version parsing and comparisons for SemVer 2 version
+strings.
+
+	- semver: Parse a semantic version and return a Version object.
+	- semverCompare: Compare a SemVer range to a particular version.
+*/
+package sprig

vendor/github.com/Masterminds/sprig/functions.go

@@ -0,0 +1,252 @@
+package sprig
+
+import (
+	"html/template"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+	ttemplate "text/template"
+	"time"
+
+	util "github.com/aokoli/goutils"
+)
+
+// Produce the function map.
+//
+// Use this to pass the functions into the template engine:
+//
+// 	tpl := template.New("foo").Funcs(sprig.FuncMap()))
+//
+func FuncMap() template.FuncMap {
+	return HtmlFuncMap()
+}
+
+// HermeticTextFuncMap returns a 'text/template'.FuncMap with only repeatable functions.
+func HermeticTxtFuncMap() ttemplate.FuncMap {
+	r := TxtFuncMap()
+	for _, name := range nonhermeticFunctions {
+		delete(r, name)
+	}
+	return r
+}
+
+// HermeticHtmlFuncMap returns an 'html/template'.Funcmap with only repeatable functions.
+func HermeticHtmlFuncMap() template.FuncMap {
+	r := HtmlFuncMap()
+	for _, name := range nonhermeticFunctions {
+		delete(r, name)
+	}
+	return r
+}
+
+// TextFuncMap returns a 'text/template'.FuncMap
+func TxtFuncMap() ttemplate.FuncMap {
+	return ttemplate.FuncMap(GenericFuncMap())
+}
+
+// HtmlFuncMap returns an 'html/template'.Funcmap
+func HtmlFuncMap() template.FuncMap {
+	return template.FuncMap(GenericFuncMap())
+}
+
+// GenericFuncMap returns a copy of the basic function map as a map[string]interface{}.
+func GenericFuncMap() map[string]interface{} {
+	gfm := make(map[string]interface{}, len(genericMap))
+	for k, v := range genericMap {
+		gfm[k] = v
+	}
+	return gfm
+}
+
+// These functions are not guaranteed to evaluate to the same result for given input, because they
+// refer to the environemnt or global state.
+var nonhermeticFunctions = []string{
+	// Date functions
+	"date",
+	"date_in_zone",
+	"date_modify",
+	"now",
+	"htmlDate",
+	"htmlDateInZone",
+	"dateInZone",
+	"dateModify",
+
+	// Strings
+	"randAlphaNum",
+	"randAlpha",
+	"randAscii",
+	"randNumeric",
+	"uuidv4",
+
+	// OS
+	"env",
+	"expandenv",
+}
+
+var genericMap = map[string]interface{}{
+	"hello": func() string { return "Hello!" },
+
+	// Date functions
+	"date":           date,
+	"date_in_zone":   dateInZone,
+	"date_modify":    dateModify,
+	"now":            func() time.Time { return time.Now() },
+	"htmlDate":       htmlDate,
+	"htmlDateInZone": htmlDateInZone,
+	"dateInZone":     dateInZone,
+	"dateModify":     dateModify,
+
+	// Strings
+	"abbrev":     abbrev,
+	"abbrevboth": abbrevboth,
+	"trunc":      trunc,
+	"trim":       strings.TrimSpace,
+	"upper":      strings.ToUpper,
+	"lower":      strings.ToLower,
+	"title":      strings.Title,
+	"untitle":    untitle,
+	"substr":     substring,
+	// Switch order so that "foo" | repeat 5
+	"repeat": func(count int, str string) string { return strings.Repeat(str, count) },
+	// Deprecated: Use trimAll.
+	"trimall": func(a, b string) string { return strings.Trim(b, a) },
+	// Switch order so that "$foo" | trimall "$"
+	"trimAll":      func(a, b string) string { return strings.Trim(b, a) },
+	"trimSuffix":   func(a, b string) string { return strings.TrimSuffix(b, a) },
+	"trimPrefix":   func(a, b string) string { return strings.TrimPrefix(b, a) },
+	"nospace":      util.DeleteWhiteSpace,
+	"initials":     initials,
+	"randAlphaNum": randAlphaNumeric,
+	"randAlpha":    randAlpha,
+	"randAscii":    randAscii,
+	"randNumeric":  randNumeric,
+	"swapcase":     util.SwapCase,
+	"wrap":         func(l int, s string) string { return util.Wrap(s, l) },
+	"wrapWith":     func(l int, sep, str string) string { return util.WrapCustom(str, l, sep, true) },
+	// Switch order so that "foobar" | contains "foo"
+	"contains":  func(substr string, str string) bool { return strings.Contains(str, substr) },
+	"hasPrefix": func(substr string, str string) bool { return strings.HasPrefix(str, substr) },
+	"hasSuffix": func(substr string, str string) bool { return strings.HasSuffix(str, substr) },
+	"quote":     quote,
+	"squote":    squote,
+	"cat":       cat,
+	"indent":    indent,
+	"replace":   replace,
+	"plural":    plural,
+	"sha256sum": sha256sum,
+	"toString":  strval,
+
+	// Wrap Atoi to stop errors.
+	"atoi":    func(a string) int { i, _ := strconv.Atoi(a); return i },
+	"int64":   toInt64,
+	"int":     toInt,
+	"float64": toFloat64,
+
+	//"gt": func(a, b int) bool {return a > b},
+	//"gte": func(a, b int) bool {return a >= b},
+	//"lt": func(a, b int) bool {return a < b},
+	//"lte": func(a, b int) bool {return a <= b},
+
+	// split "/" foo/bar returns map[int]string{0: foo, 1: bar}
+	"split":     split,
+	"splitList": func(sep, orig string) []string { return strings.Split(orig, sep) },
+	"toStrings": strslice,
+
+	"until":     until,
+	"untilStep": untilStep,
+
+	// VERY basic arithmetic.
+	"add1": func(i interface{}) int64 { return toInt64(i) + 1 },
+	"add": func(i ...interface{}) int64 {
+		var a int64 = 0
+		for _, b := range i {
+			a += toInt64(b)
+		}
+		return a
+	},
+	"sub": func(a, b interface{}) int64 { return toInt64(a) - toInt64(b) },
+	"div": func(a, b interface{}) int64 { return toInt64(a) / toInt64(b) },
+	"mod": func(a, b interface{}) int64 { return toInt64(a) % toInt64(b) },
+	"mul": func(a interface{}, v ...interface{}) int64 {
+		val := toInt64(a)
+		for _, b := range v {
+			val = val * toInt64(b)
+		}
+		return val
+	},
+	"biggest": max,
+	"max":     max,
+	"min":     min,
+
+	// string slices. Note that we reverse the order b/c that's better
+	// for template processing.
+	"join":      join,
+	"sortAlpha": sortAlpha,
+
+	// Defaults
+	"default":      dfault,
+	"empty":        empty,
+	"coalesce":     coalesce,
+	"compact":      compact,
+	"toJson":       toJson,
+	"toPrettyJson": toPrettyJson,
+
+	// Reflection
+	"typeOf":     typeOf,
+	"typeIs":     typeIs,
+	"typeIsLike": typeIsLike,
+	"kindOf":     kindOf,
+	"kindIs":     kindIs,
+
+	// OS:
+	"env":       func(s string) string { return os.Getenv(s) },
+	"expandenv": func(s string) string { return os.ExpandEnv(s) },
+
+	// File Paths:
+	"base":  path.Base,
+	"dir":   path.Dir,
+	"clean": path.Clean,
+	"ext":   path.Ext,
+	"isAbs": path.IsAbs,
+
+	// Encoding:
+	"b64enc": base64encode,
+	"b64dec": base64decode,
+	"b32enc": base32encode,
+	"b32dec": base32decode,
+
+	// Data Structures:
+	"tuple":  list, // FIXME: with the addition of append/prepend these are no longer immutable.
+	"list":   list,
+	"dict":   dict,
+	"set":    set,
+	"unset":  unset,
+	"hasKey": hasKey,
+	"pluck":  pluck,
+	"keys":   keys,
+	"pick":   pick,
+	"omit":   omit,
+
+	"append": push, "push": push,
+	"prepend": prepend,
+	"first":   first,
+	"rest":    rest,
+	"last":    last,
+	"initial": initial,
+	"reverse": reverse,
+	"uniq":    uniq,
+	"without": without,
+	"has":     func(needle interface{}, haystack []interface{}) bool { return inList(haystack, needle) },
+
+	// Crypto:
+	"genPrivateKey":  generatePrivateKey,
+	"derivePassword": derivePassword,
+
+	// UUIDs:
+	"uuidv4": uuidv4,
+
+	// SemVer:
+	"semver":        semver,
+	"semverCompare": semverCompare,
+}

vendor/github.com/Masterminds/sprig/glide.lock

@@ -0,0 +1,19 @@
+hash: d366098dbe0d3a7bc5afdc55b91fb2a75e3443ff976e1a3b87a79e22cfead454
+updated: 2017-04-07T09:31:43.889475111-06:00
+imports:
+- name: github.com/aokoli/goutils
+  version: 9c37978a95bd5c709a15883b6242714ea6709e64
+- name: github.com/Masterminds/goutils
+  version: 45307ec16e3cd47cd841506c081f7afd8237d210
+- name: github.com/Masterminds/semver
+  version: 59c29afe1a994eacb71c833025ca7acf874bb1da
+- name: github.com/satori/go.uuid
+  version: 879c5887cd475cd7864858769793b2ceb0d44feb
+- name: github.com/stretchr/testify
+  version: 4d4bfba8f1d1027c4fdbe371823030df51419987
+- name: golang.org/x/crypto
+  version: 420870623a70591d5e0b187c77c95455a1224ca6
+  subpackages:
+  - scrypt
+  - pbkdf2
+devImports: []

vendor/github.com/Masterminds/sprig/glide.yaml

@@ -0,0 +1,12 @@
+package: github.com/Masterminds/sprig
+import:
+- package: github.com/Masterminds/goutils
+  version: ^1.0.0
+- package: github.com/satori/go.uuid
+  version: ^1.1.0
+- package: golang.org/x/crypto
+  subpackages:
+  - scrypt
+- package: github.com/Masterminds/semver
+  version: v1.2.2
+- package: github.com/stretchr/testify

vendor/github.com/Masterminds/sprig/list.go

@@ -0,0 +1,109 @@
+package sprig
+
+import (
+	"reflect"
+	"sort"
+)
+
+func list(v ...interface{}) []interface{} {
+	return v
+}
+
+func push(list []interface{}, v interface{}) []interface{} {
+	return append(list, v)
+}
+
+func prepend(list []interface{}, v interface{}) []interface{} {
+	return append([]interface{}{v}, list...)
+}
+
+func last(list []interface{}) interface{} {
+	l := len(list)
+	if l == 0 {
+		return nil
+	}
+	return list[l-1]
+}
+
+func first(list []interface{}) interface{} {
+	if len(list) == 0 {
+		return nil
+	}
+	return list[0]
+}
+
+func rest(list []interface{}) []interface{} {
+	if len(list) == 0 {
+		return list
+	}
+	return list[1:]
+}
+
+func initial(list []interface{}) []interface{} {
+	l := len(list)
+	if l == 0 {
+		return list
+	}
+	return list[:l-1]
+}
+
+func sortAlpha(list interface{}) []string {
+	k := reflect.Indirect(reflect.ValueOf(list)).Kind()
+	switch k {
+	case reflect.Slice, reflect.Array:
+		a := strslice(list)
+		s := sort.StringSlice(a)
+		s.Sort()
+		return s
+	}
+	return []string{strval(list)}
+}
+
+func reverse(v []interface{}) []interface{} {
+	// We do not sort in place because the incomming array should not be altered.
+	l := len(v)
+	c := make([]interface{}, l)
+	for i := 0; i < l; i++ {
+		c[l-i-1] = v[i]
+	}
+	return c
+}
+
+func compact(list []interface{}) []interface{} {
+	res := []interface{}{}
+	for _, item := range list {
+		if !empty(item) {
+			res = append(res, item)
+		}
+	}
+	return res
+}
+
+func uniq(list []interface{}) []interface{} {
+	dest := []interface{}{}
+	for _, item := range list {
+		if !inList(dest, item) {
+			dest = append(dest, item)
+		}
+	}
+	return dest
+}
+
+func inList(haystack []interface{}, needle interface{}) bool {
+	for _, h := range haystack {
+		if reflect.DeepEqual(needle, h) {
+			return true
+		}
+	}
+	return false
+}
+
+func without(list []interface{}, omit ...interface{}) []interface{} {
+	res := []interface{}{}
+	for _, i := range list {
+		if !inList(omit, i) {
+			res = append(res, i)
+		}
+	}
+	return res
+}

vendor/github.com/Masterminds/sprig/numeric.go

@@ -0,0 +1,129 @@
+package sprig
+
+import (
+	"math"
+	"reflect"
+	"strconv"
+)
+
+// toFloat64 converts 64-bit floats
+func toFloat64(v interface{}) float64 {
+	if str, ok := v.(string); ok {
+		iv, err := strconv.ParseFloat(str, 64)
+		if err != nil {
+			return 0
+		}
+		return iv
+	}
+
+	val := reflect.Indirect(reflect.ValueOf(v))
+	switch val.Kind() {
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return float64(val.Int())
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32:
+		return float64(val.Uint())
+	case reflect.Uint, reflect.Uint64:
+		return float64(val.Uint())
+	case reflect.Float32, reflect.Float64:
+		return val.Float()
+	case reflect.Bool:
+		if val.Bool() == true {
+			return 1
+		}
+		return 0
+	default:
+		return 0
+	}
+}
+
+func toInt(v interface{}) int {
+	//It's not optimal. Bud I don't want duplicate toInt64 code.
+	return int(toInt64(v))
+}
+
+// toInt64 converts integer types to 64-bit integers
+func toInt64(v interface{}) int64 {
+	if str, ok := v.(string); ok {
+		iv, err := strconv.ParseInt(str, 10, 64)
+		if err != nil {
+			return 0
+		}
+		return iv
+	}
+
+	val := reflect.Indirect(reflect.ValueOf(v))
+	switch val.Kind() {
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return val.Int()
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32:
+		return int64(val.Uint())
+	case reflect.Uint, reflect.Uint64:
+		tv := val.Uint()
+		if tv <= math.MaxInt64 {
+			return int64(tv)
+		}
+		// TODO: What is the sensible thing to do here?
+		return math.MaxInt64
+	case reflect.Float32, reflect.Float64:
+		return int64(val.Float())
+	case reflect.Bool:
+		if val.Bool() == true {
+			return 1
+		}
+		return 0
+	default:
+		return 0
+	}
+}
+
+func max(a interface{}, i ...interface{}) int64 {
+	aa := toInt64(a)
+	for _, b := range i {
+		bb := toInt64(b)
+		if bb > aa {
+			aa = bb
+		}
+	}
+	return aa
+}
+
+func min(a interface{}, i ...interface{}) int64 {
+	aa := toInt64(a)
+	for _, b := range i {
+		bb := toInt64(b)
+		if bb < aa {
+			aa = bb
+		}
+	}
+	return aa
+}
+
+func until(count int) []int {
+	step := 1
+	if count < 0 {
+		step = -1
+	}
+	return untilStep(0, count, step)
+}
+
+func untilStep(start, stop, step int) []int {
+	v := []int{}
+
+	if stop < start {
+		if step >= 0 {
+			return v
+		}
+		for i := start; i > stop; i += step {
+			v = append(v, i)
+		}
+		return v
+	}
+
+	if step <= 0 {
+		return v
+	}
+	for i := start; i < stop; i += step {
+		v = append(v, i)
+	}
+	return v
+}

vendor/github.com/Masterminds/sprig/reflect.go

@@ -0,0 +1,28 @@
+package sprig
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// typeIs returns true if the src is the type named in target.
+func typeIs(target string, src interface{}) bool {
+	return target == typeOf(src)
+}
+
+func typeIsLike(target string, src interface{}) bool {
+	t := typeOf(src)
+	return target == t || "*"+target == t
+}
+
+func typeOf(src interface{}) string {
+	return fmt.Sprintf("%T", src)
+}
+
+func kindIs(target string, src interface{}) bool {
+	return target == kindOf(src)
+}
+
+func kindOf(src interface{}) string {
+	return reflect.ValueOf(src).Kind().String()
+}

vendor/github.com/Masterminds/sprig/semver.go

@@ -0,0 +1,23 @@
+package sprig
+
+import (
+	sv2 "github.com/Masterminds/semver"
+)
+
+func semverCompare(constraint, version string) (bool, error) {
+	c, err := sv2.NewConstraint(constraint)
+	if err != nil {
+		return false, err
+	}
+
+	v, err := sv2.NewVersion(version)
+	if err != nil {
+		return false, err
+	}
+
+	return c.Check(v), nil
+}
+
+func semver(version string) (*sv2.Version, error) {
+	return sv2.NewVersion(version)
+}

vendor/github.com/Masterminds/sprig/strings.go

@@ -0,0 +1,197 @@
+package sprig
+
+import (
+	"encoding/base32"
+	"encoding/base64"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+
+	util "github.com/aokoli/goutils"
+)
+
+func base64encode(v string) string {
+	return base64.StdEncoding.EncodeToString([]byte(v))
+}
+
+func base64decode(v string) string {
+	data, err := base64.StdEncoding.DecodeString(v)
+	if err != nil {
+		return err.Error()
+	}
+	return string(data)
+}
+
+func base32encode(v string) string {
+	return base32.StdEncoding.EncodeToString([]byte(v))
+}
+
+func base32decode(v string) string {
+	data, err := base32.StdEncoding.DecodeString(v)
+	if err != nil {
+		return err.Error()
+	}
+	return string(data)
+}
+
+func abbrev(width int, s string) string {
+	if width < 4 {
+		return s
+	}
+	r, _ := util.Abbreviate(s, width)
+	return r
+}
+
+func abbrevboth(left, right int, s string) string {
+	if right < 4 || left > 0 && right < 7 {
+		return s
+	}
+	r, _ := util.AbbreviateFull(s, left, right)
+	return r
+}
+func initials(s string) string {
+	// Wrap this just to eliminate the var args, which templates don't do well.
+	return util.Initials(s)
+}
+
+func randAlphaNumeric(count int) string {
+	// It is not possible, it appears, to actually generate an error here.
+	r, _ := util.RandomAlphaNumeric(count)
+	return r
+}
+
+func randAlpha(count int) string {
+	r, _ := util.RandomAlphabetic(count)
+	return r
+}
+
+func randAscii(count int) string {
+	r, _ := util.RandomAscii(count)
+	return r
+}
+
+func randNumeric(count int) string {
+	r, _ := util.RandomNumeric(count)
+	return r
+}
+
+func untitle(str string) string {
+	return util.Uncapitalize(str)
+}
+
+func quote(str ...interface{}) string {
+	out := make([]string, len(str))
+	for i, s := range str {
+		out[i] = fmt.Sprintf("%q", strval(s))
+	}
+	return strings.Join(out, " ")
+}
+
+func squote(str ...interface{}) string {
+	out := make([]string, len(str))
+	for i, s := range str {
+		out[i] = fmt.Sprintf("'%v'", s)
+	}
+	return strings.Join(out, " ")
+}
+
+func cat(v ...interface{}) string {
+	r := strings.TrimSpace(strings.Repeat("%v ", len(v)))
+	return fmt.Sprintf(r, v...)
+}
+
+func indent(spaces int, v string) string {
+	pad := strings.Repeat(" ", spaces)
+	return pad + strings.Replace(v, "\n", "\n"+pad, -1)
+}
+
+func replace(old, new, src string) string {
+	return strings.Replace(src, old, new, -1)
+}
+
+func plural(one, many string, count int) string {
+	if count == 1 {
+		return one
+	}
+	return many
+}
+
+func strslice(v interface{}) []string {
+	switch v := v.(type) {
+	case []string:
+		return v
+	case []interface{}:
+		l := len(v)
+		b := make([]string, l)
+		for i := 0; i < l; i++ {
+			b[i] = strval(v[i])
+		}
+		return b
+	default:
+		val := reflect.ValueOf(v)
+		switch val.Kind() {
+		case reflect.Array, reflect.Slice:
+			l := val.Len()
+			b := make([]string, l)
+			for i := 0; i < l; i++ {
+				b[i] = strval(val.Index(i).Interface())
+			}
+			return b
+		default:
+			return []string{strval(v)}
+		}
+	}
+}
+
+func strval(v interface{}) string {
+	switch v := v.(type) {
+	case string:
+		return v
+	case []byte:
+		return string(v)
+	case error:
+		return v.Error()
+	case fmt.Stringer:
+		return v.String()
+	default:
+		return fmt.Sprintf("%v", v)
+	}
+}
+
+func trunc(c int, s string) string {
+	if len(s) <= c {
+		return s
+	}
+	return s[0:c]
+}
+
+func join(sep string, v interface{}) string {
+	return strings.Join(strslice(v), sep)
+}
+
+func split(sep, orig string) map[string]string {
+	parts := strings.Split(orig, sep)
+	res := make(map[string]string, len(parts))
+	for i, v := range parts {
+		res["_"+strconv.Itoa(i)] = v
+	}
+	return res
+}
+
+// substring creates a substring of the given string.
+//
+// If start is < 0, this calls string[:length].
+//
+// If start is >= 0 and length < 0, this calls string[start:]
+//
+// Otherwise, this calls string[start, length].
+func substring(start, length int, s string) string {
+	if start < 0 {
+		return s[:length]
+	}
+	if length < 0 {
+		return s[start:]
+	}
+	return s[start:length]
+}

vendor/github.com/aokoli/goutils/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/aokoli/goutils/README.md

@@ -0,0 +1,74 @@
+GoUtils
+===========
+[![Stability: Maintenance](https://masterminds.github.io/stability/maintenance.svg)](https://masterminds.github.io/stability/maintenance.html)
+[![GoDoc](https://godoc.org/github.com/Masterminds/goutils?status.png)](https://godoc.org/github.com/Masterminds/goutils)
+
+GoUtils provides users with utility functions to manipulate strings in various ways. It is a Go implementation of some 
+string manipulation libraries of Java Apache Commons. GoUtils includes the following Java Apache Commons classes:
+* WordUtils    
+* RandomStringUtils  
+* StringUtils (partial implementation)
+
+## Installation
+If you have Go set up on your system, from the GOPATH directory within the command line/terminal, enter this:
+
+	go get github.com/Masterminds/goutils
+    
+If you do not have Go set up on your system, please follow the [Go installation directions from the documenation](http://golang.org/doc/install), and then follow the instructions above to install GoUtils.
+
+
+## Documentation 
+GoUtils doc is available here: [![GoDoc](https://godoc.org/github.com/Masterminds/goutils?status.png)](https://godoc.org/github.com/Masterminds/goutils)
+
+
+## Usage
+The code snippets below show examples of how to use GoUtils. Some functions return errors while others do not. The first instance below, which does not return an error, is the `Initials` function (located within the `wordutils.go` file).
+
+    package main
+    
+    import (
+        "fmt"
+    	"github.com/Masterminds/goutils"
+    )
+    
+    func main() {
+
+    	// EXAMPLE 1: A goutils function which returns no errors
+        fmt.Println (goutils.Initials("John Doe Foo")) // Prints out "JDF"
+
+    }
+Some functions return errors mainly due to illegal arguements used as parameters. The code example below illustrates how to deal with function that returns an error. In this instance, the function is the `Random` function (located within the `randomstringutils.go` file).
+
+    package main
+    
+    import (
+        "fmt"
+        "github.com/Masterminds/goutils"
+    )
+    
+    func main() {
+
+        // EXAMPLE 2: A goutils function which returns an error
+        rand1, err1 := goutils.Random (-1, 0, 0, true, true)  
+
+        if err1 != nil { 
+			fmt.Println(err1) // Prints out error message because -1 was entered as the first parameter in goutils.Random(...)
+		} else {
+			fmt.Println(rand1) 
+		}
+
+    }
+
+## License
+GoUtils is licensed under the Apache License, Version 2.0. Please check the LICENSE.txt file or visit http://www.apache.org/licenses/LICENSE-2.0 for a copy of the license. 
+
+## Issue Reporting
+Make suggestions or report issues using the Git issue tracker: https://github.com/Masterminds/goutils/issues
+
+## Website
+* [GoUtils webpage](http://Masterminds.github.io/goutils/)
+
+## Mailing List
+Contact [okolialex@gmail.com](mailto:okolialex@mail.com) to be added to the mailing list. You will get updates on the 
+status of the project and the potential direction it will be heading.
+

vendor/github.com/aokoli/goutils/randomstringutils.go

@@ -0,0 +1,250 @@
+/*
+Copyright 2014 Alexander Okoli
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package goutils
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"time"
+	"unicode"
+)
+
+// RANDOM provides the time-based seed used to generate random numbers
+var RANDOM = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+/*
+RandomNonAlphaNumeric creates a random string whose length is the number of characters specified.
+Characters will be chosen from the set of all characters (ASCII/Unicode values between 0 to 2,147,483,647 (math.MaxInt32)).
+
+Parameter:
+	count - the length of random string to create
+
+Returns:
+	string - the random string
+	error - an error stemming from an invalid parameter within underlying function, RandomSeed(...)
+*/
+func RandomNonAlphaNumeric(count int) (string, error) {
+	return RandomAlphaNumericCustom(count, false, false)
+}
+
+/*
+RandomAscii creates a random string whose length is the number of characters specified.
+Characters will be chosen from the set of characters whose ASCII value is between 32 and 126 (inclusive).
+
+Parameter:
+	count - the length of random string to create
+
+Returns:
+	string - the random string
+	error - an error stemming from an invalid parameter within underlying function, RandomSeed(...)
+*/
+func RandomAscii(count int) (string, error) {
+	return Random(count, 32, 127, false, false)
+}
+
+/*
+RandomNumeric creates a random string whose length is the number of characters specified.
+Characters will be chosen from the set of numeric characters.
+
+Parameter:
+	count - the length of random string to create
+
+Returns:
+	string - the random string
+	error - an error stemming from an invalid parameter within underlying function, RandomSeed(...)
+*/
+func RandomNumeric(count int) (string, error) {
+	return Random(count, 0, 0, false, true)
+}
+
+/*
+RandomAlphabetic creates a random string whose length is the number of characters specified.
+Characters will be chosen from the set of alpha-numeric characters as indicated by the arguments.
+
+Parameters:
+	count - the length of random string to create
+	letters - if true, generated string may include alphabetic characters
+	numbers - if true, generated string may include numeric characters
+
+Returns:
+	string - the random string
+	error - an error stemming from an invalid parameter within underlying function, RandomSeed(...)
+*/
+func RandomAlphabetic(count int) (string, error) {
+	return Random(count, 0, 0, true, false)
+}
+
+/*
+RandomAlphaNumeric creates a random string whose length is the number of characters specified.
+Characters will be chosen from the set of alpha-numeric characters.
+
+Parameter:
+	count - the length of random string to create
+
+Returns:
+	string - the random string
+	error - an error stemming from an invalid parameter within underlying function, RandomSeed(...)
+*/
+func RandomAlphaNumeric(count int) (string, error) {
+	return Random(count, 0, 0, true, true)
+}
+
+/*
+RandomAlphaNumericCustom creates a random string whose length is the number of characters specified.
+Characters will be chosen from the set of alpha-numeric characters as indicated by the arguments.
+
+Parameters:
+	count - the length of random string to create
+	letters - if true, generated string may include alphabetic characters
+	numbers - if true, generated string may include numeric characters
+
+Returns:
+	string - the random string
+	error - an error stemming from an invalid parameter within underlying function, RandomSeed(...)
+*/
+func RandomAlphaNumericCustom(count int, letters bool, numbers bool) (string, error) {
+	return Random(count, 0, 0, letters, numbers)
+}
+
+/*
+Random creates a random string based on a variety of options, using default source of randomness.
+This method has exactly the same semantics as RandomSeed(int, int, int, bool, bool, []char, *rand.Rand), but
+instead of using an externally supplied source of randomness, it uses the internal *rand.Rand instance.
+
+Parameters:
+	count - the length of random string to create
+	start - the position in set of chars (ASCII/Unicode int) to start at
+	end - the position in set of chars (ASCII/Unicode int) to end before
+	letters - if true, generated string may include alphabetic characters
+	numbers - if true, generated string may include numeric characters
+	chars - the set of chars to choose randoms from. If nil, then it will use the set of all chars.
+
+Returns:
+	string - the random string
+	error - an error stemming from an invalid parameter within underlying function, RandomSeed(...)
+*/
+func Random(count int, start int, end int, letters bool, numbers bool, chars ...rune) (string, error) {
+	return RandomSeed(count, start, end, letters, numbers, chars, RANDOM)
+}
+
+/*
+RandomSeed creates a random string based on a variety of options, using supplied source of randomness.
+If the parameters start and end are both 0, start and end are set to ' ' and 'z', the ASCII printable characters, will be used,
+unless letters and numbers are both false, in which case, start and end are set to 0 and math.MaxInt32, respectively.
+If chars is not nil, characters stored in chars that are between start and end are chosen.
+This method accepts a user-supplied *rand.Rand instance to use as a source of randomness. By seeding a single *rand.Rand instance
+with a fixed seed and using it for each call, the same random sequence of strings can be generated repeatedly and predictably.
+
+Parameters:
+	count - the length of random string to create
+	start - the position in set of chars (ASCII/Unicode decimals) to start at
+	end - the position in set of chars (ASCII/Unicode decimals) to end before
+	letters - if true, generated string may include alphabetic characters
+	numbers - if true, generated string may include numeric characters
+	chars - the set of chars to choose randoms from. If nil, then it will use the set of all chars.
+	random - a source of randomness.
+
+Returns:
+	string - the random string
+	error - an error stemming from invalid parameters: if count < 0; or the provided chars array is empty; or end <= start; or end > len(chars)
+*/
+func RandomSeed(count int, start int, end int, letters bool, numbers bool, chars []rune, random *rand.Rand) (string, error) {
+
+	if count == 0 {
+		return "", nil
+	} else if count < 0 {
+		err := fmt.Errorf("randomstringutils illegal argument: Requested random string length %v is less than 0.", count) // equiv to err := errors.New("...")
+		return "", err
+	}
+	if chars != nil && len(chars) == 0 {
+		err := fmt.Errorf("randomstringutils illegal argument: The chars array must not be empty")
+		return "", err
+	}
+
+	if start == 0 && end == 0 {
+		if chars != nil {
+			end = len(chars)
+		} else {
+			if !letters && !numbers {
+				end = math.MaxInt32
+			} else {
+				end = 'z' + 1
+				start = ' '
+			}
+		}
+	} else {
+		if end <= start {
+			err := fmt.Errorf("randomstringutils illegal argument: Parameter end (%v) must be greater than start (%v)", end, start)
+			return "", err
+		}
+
+		if chars != nil && end > len(chars) {
+			err := fmt.Errorf("randomstringutils illegal argument: Parameter end (%v) cannot be greater than len(chars) (%v)", end, len(chars))
+			return "", err
+		}
+	}
+
+	buffer := make([]rune, count)
+	gap := end - start
+
+	// high-surrogates range, (\uD800-\uDBFF) = 55296 - 56319
+	//  low-surrogates range, (\uDC00-\uDFFF) = 56320 - 57343
+
+	for count != 0 {
+		count--
+		var ch rune
+		if chars == nil {
+			ch = rune(random.Intn(gap) + start)
+		} else {
+			ch = chars[random.Intn(gap)+start]
+		}
+
+		if letters && unicode.IsLetter(ch) || numbers && unicode.IsDigit(ch) || !letters && !numbers {
+			if ch >= 56320 && ch <= 57343 { // low surrogate range
+				if count == 0 {
+					count++
+				} else {
+					// Insert low surrogate
+					buffer[count] = ch
+					count--
+					// Insert high surrogate
+					buffer[count] = rune(55296 + random.Intn(128))
+				}
+			} else if ch >= 55296 && ch <= 56191 { // High surrogates range (Partial)
+				if count == 0 {
+					count++
+				} else {
+					// Insert low surrogate
+					buffer[count] = rune(56320 + random.Intn(128))
+					count--
+					// Insert high surrogate
+					buffer[count] = ch
+				}
+			} else if ch >= 56192 && ch <= 56319 {
+				// private high surrogate, skip it
+				count++
+			} else {
+				// not one of the surrogates*
+				buffer[count] = ch
+			}
+		} else {
+			count++
+		}
+	}
+	return string(buffer), nil
+}

vendor/github.com/aokoli/goutils/stringutils.go

@@ -0,0 +1,224 @@
+/*
+Copyright 2014 Alexander Okoli
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package goutils
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"unicode"
+)
+
+// Typically returned by functions where a searched item cannot be found
+const INDEX_NOT_FOUND = -1
+
+/*
+Abbreviate abbreviates a string using ellipses. This will turn  the string "Now is the time for all good men" into "Now is the time for..."
+
+Specifically, the algorithm is as follows:
+
+    - If str is less than maxWidth characters long, return it.
+    - Else abbreviate it to (str[0:maxWidth - 3] + "...").
+    - If maxWidth is less than 4, return an illegal argument error.
+    - In no case will it return a string of length greater than maxWidth.
+
+Parameters:
+    str -  the string to check
+    maxWidth - maximum length of result string, must be at least 4
+
+Returns:
+    string - abbreviated string
+    error - if the width is too small
+*/
+func Abbreviate(str string, maxWidth int) (string, error) {
+	return AbbreviateFull(str, 0, maxWidth)
+}
+
+/*
+AbbreviateFull abbreviates a string using ellipses. This will turn the string "Now is the time for all good men" into "...is the time for..."
+This function works like Abbreviate(string, int), but allows you to specify a "left edge" offset. Note that this left edge is not
+necessarily going to be the leftmost character in the result, or the first character following the ellipses, but it will appear
+somewhere in the result.
+In no case will it return a string of length greater than maxWidth.
+
+Parameters:
+    str - the string to check
+    offset - left edge of source string
+    maxWidth - maximum length of result string, must be at least 4
+
+Returns:
+    string - abbreviated string
+    error - if the width is too small
+*/
+func AbbreviateFull(str string, offset int, maxWidth int) (string, error) {
+	if str == "" {
+		return "", nil
+	}
+	if maxWidth < 4 {
+		err := fmt.Errorf("stringutils illegal argument: Minimum abbreviation width is 4")
+		return "", err
+	}
+	if len(str) <= maxWidth {
+		return str, nil
+	}
+	if offset > len(str) {
+		offset = len(str)
+	}
+	if len(str)-offset < (maxWidth - 3) { // 15 - 5 < 10 - 3 =  10 < 7
+		offset = len(str) - (maxWidth - 3)
+	}
+	abrevMarker := "..."
+	if offset <= 4 {
+		return str[0:maxWidth-3] + abrevMarker, nil // str.substring(0, maxWidth - 3) + abrevMarker;
+	}
+	if maxWidth < 7 {
+		err := fmt.Errorf("stringutils illegal argument: Minimum abbreviation width with offset is 7")
+		return "", err
+	}
+	if (offset + maxWidth - 3) < len(str) { // 5 + (10-3) < 15 = 12 < 15
+		abrevStr, _ := Abbreviate(str[offset:len(str)], (maxWidth - 3))
+		return abrevMarker + abrevStr, nil // abrevMarker + abbreviate(str.substring(offset), maxWidth - 3);
+	}
+	return abrevMarker + str[(len(str)-(maxWidth-3)):len(str)], nil // abrevMarker + str.substring(str.length() - (maxWidth - 3));
+}
+
+/*
+DeleteWhiteSpace deletes all whitespaces from a string as defined by unicode.IsSpace(rune).
+It returns the string without whitespaces.
+
+Parameter:
+    str - the string to delete whitespace from, may be nil
+
+Returns:
+    the string without whitespaces
+*/
+func DeleteWhiteSpace(str string) string {
+	if str == "" {
+		return str
+	}
+	sz := len(str)
+	var chs bytes.Buffer
+	count := 0
+	for i := 0; i < sz; i++ {
+		ch := rune(str[i])
+		if !unicode.IsSpace(ch) {
+			chs.WriteRune(ch)
+			count++
+		}
+	}
+	if count == sz {
+		return str
+	}
+	return chs.String()
+}
+
+/*
+IndexOfDifference compares two strings, and returns the index at which the strings begin to differ.
+
+Parameters:
+    str1 - the first string
+    str2 - the second string
+
+Returns:
+    the index where str1 and str2 begin to differ; -1 if they are equal
+*/
+func IndexOfDifference(str1 string, str2 string) int {
+	if str1 == str2 {
+		return INDEX_NOT_FOUND
+	}
+	if IsEmpty(str1) || IsEmpty(str2) {
+		return 0
+	}
+	var i int
+	for i = 0; i < len(str1) && i < len(str2); i++ {
+		if rune(str1[i]) != rune(str2[i]) {
+			break
+		}
+	}
+	if i < len(str2) || i < len(str1) {
+		return i
+	}
+	return INDEX_NOT_FOUND
+}
+
+/*
+IsBlank checks if a string is whitespace or empty (""). Observe the following behavior:
+
+    goutils.IsBlank("")        = true
+    goutils.IsBlank(" ")       = true
+    goutils.IsBlank("bob")     = false
+    goutils.IsBlank("  bob  ") = false
+
+Parameter:
+    str - the string to check
+
+Returns:
+    true - if the string is whitespace or empty ("")
+*/
+func IsBlank(str string) bool {
+	strLen := len(str)
+	if str == "" || strLen == 0 {
+		return true
+	}
+	for i := 0; i < strLen; i++ {
+		if unicode.IsSpace(rune(str[i])) == false {
+			return false
+		}
+	}
+	return true
+}
+
+/*
+IndexOf returns the index of the first instance of sub in str, with the search beginning from the
+index start point specified. -1 is returned if sub is not present in str.
+
+An empty string ("") will return -1 (INDEX_NOT_FOUND). A negative start position is treated as zero.
+A start position greater than the string length returns -1.
+
+Parameters:
+    str - the string to check
+    sub - the substring to find
+    start - the start position; negative treated as zero
+
+Returns:
+    the first index where the sub string was found  (always >= start)
+*/
+func IndexOf(str string, sub string, start int) int {
+
+	if start < 0 {
+		start = 0
+	}
+
+	if len(str) < start {
+		return INDEX_NOT_FOUND
+	}
+
+	if IsEmpty(str) || IsEmpty(sub) {
+		return INDEX_NOT_FOUND
+	}
+
+	partialIndex := strings.Index(str[start:len(str)], sub)
+	if partialIndex == -1 {
+		return INDEX_NOT_FOUND
+	}
+	return partialIndex + start
+}
+
+// IsEmpty checks if a string is empty (""). Returns true if empty, and false otherwise.
+func IsEmpty(str string) bool {
+	return len(str) == 0
+}

vendor/github.com/aokoli/goutils/wordutils.go

@@ -0,0 +1,356 @@
+/*
+Copyright 2014 Alexander Okoli
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Package goutils provides utility functions to manipulate strings in various ways.
+The code snippets below show examples of how to use goutils. Some functions return
+errors while others do not, so usage would vary as a result.
+
+Example:
+
+    package main
+
+    import (
+        "fmt"
+        "github.com/aokoli/goutils"
+    )
+
+    func main() {
+
+        // EXAMPLE 1: A goutils function which returns no errors
+        fmt.Println (goutils.Initials("John Doe Foo")) // Prints out "JDF"
+
+
+
+        // EXAMPLE 2: A goutils function which returns an error
+        rand1, err1 := goutils.Random (-1, 0, 0, true, true)
+
+        if err1 != nil {
+            fmt.Println(err1) // Prints out error message because -1 was entered as the first parameter in goutils.Random(...)
+        } else {
+            fmt.Println(rand1)
+        }
+    }
+*/
+package goutils
+
+import (
+	"bytes"
+	"strings"
+	"unicode"
+)
+
+// VERSION indicates the current version of goutils
+const VERSION = "1.0.0"
+
+/*
+Wrap wraps a single line of text, identifying words by ' '.
+New lines will be separated by '\n'. Very long words, such as URLs will not be wrapped.
+Leading spaces on a new line are stripped. Trailing spaces are not stripped.
+
+Parameters:
+    str - the string to be word wrapped
+    wrapLength - the column (a column can fit only one character) to wrap the words at, less than 1 is treated as 1
+
+Returns:
+    a line with newlines inserted
+*/
+func Wrap(str string, wrapLength int) string {
+	return WrapCustom(str, wrapLength, "", false)
+}
+
+/*
+WrapCustom wraps a single line of text, identifying words by ' '.
+Leading spaces on a new line are stripped. Trailing spaces are not stripped.
+
+Parameters:
+    str - the string to be word wrapped
+    wrapLength - the column number (a column can fit only one character) to wrap the words at, less than 1 is treated as 1
+    newLineStr - the string to insert for a new line, "" uses '\n'
+    wrapLongWords - true if long words (such as URLs) should be wrapped
+
+Returns:
+    a line with newlines inserted
+*/
+func WrapCustom(str string, wrapLength int, newLineStr string, wrapLongWords bool) string {
+
+	if str == "" {
+		return ""
+	}
+	if newLineStr == "" {
+		newLineStr = "\n" // TODO Assumes "\n" is seperator. Explore SystemUtils.LINE_SEPARATOR from Apache Commons
+	}
+	if wrapLength < 1 {
+		wrapLength = 1
+	}
+
+	inputLineLength := len(str)
+	offset := 0
+
+	var wrappedLine bytes.Buffer
+
+	for inputLineLength-offset > wrapLength {
+
+		if rune(str[offset]) == ' ' {
+			offset++
+			continue
+		}
+
+		end := wrapLength + offset + 1
+		spaceToWrapAt := strings.LastIndex(str[offset:end], " ") + offset
+
+		if spaceToWrapAt >= offset {
+			// normal word (not longer than wrapLength)
+			wrappedLine.WriteString(str[offset:spaceToWrapAt])
+			wrappedLine.WriteString(newLineStr)
+			offset = spaceToWrapAt + 1
+
+		} else {
+			// long word or URL
+			if wrapLongWords {
+				end := wrapLength + offset
+				// long words are wrapped one line at a time
+				wrappedLine.WriteString(str[offset:end])
+				wrappedLine.WriteString(newLineStr)
+				offset += wrapLength
+			} else {
+				// long words aren't wrapped, just extended beyond limit
+				end := wrapLength + offset
+				spaceToWrapAt = strings.IndexRune(str[end:len(str)], ' ') + end
+				if spaceToWrapAt >= 0 {
+					wrappedLine.WriteString(str[offset:spaceToWrapAt])
+					wrappedLine.WriteString(newLineStr)
+					offset = spaceToWrapAt + 1
+				} else {
+					wrappedLine.WriteString(str[offset:len(str)])
+					offset = inputLineLength
+				}
+			}
+		}
+	}
+
+	wrappedLine.WriteString(str[offset:len(str)])
+
+	return wrappedLine.String()
+
+}
+
+/*
+Capitalize capitalizes all the delimiter separated words in a string. Only the first letter of each word is changed.
+To convert the rest of each word to lowercase at the same time, use CapitalizeFully(str string, delimiters ...rune).
+The delimiters represent a set of characters understood to separate words. The first string character
+and the first non-delimiter character after a delimiter will be capitalized. A "" input string returns "".
+Capitalization uses the Unicode title case, normally equivalent to upper case.
+
+Parameters:
+    str - the string to capitalize
+    delimiters - set of characters to determine capitalization, exclusion of this parameter means whitespace would be delimeter
+
+Returns:
+    capitalized string
+*/
+func Capitalize(str string, delimiters ...rune) string {
+
+	var delimLen int
+
+	if delimiters == nil {
+		delimLen = -1
+	} else {
+		delimLen = len(delimiters)
+	}
+
+	if str == "" || delimLen == 0 {
+		return str
+	}
+
+	buffer := []rune(str)
+	capitalizeNext := true
+	for i := 0; i < len(buffer); i++ {
+		ch := buffer[i]
+		if isDelimiter(ch, delimiters...) {
+			capitalizeNext = true
+		} else if capitalizeNext {
+			buffer[i] = unicode.ToTitle(ch)
+			capitalizeNext = false
+		}
+	}
+	return string(buffer)
+
+}
+
+/*
+CapitalizeFully converts all the delimiter separated words in a string into capitalized words, that is each word is made up of a
+titlecase character and then a series of lowercase characters. The delimiters represent a set of characters understood
+to separate words. The first string character and the first non-delimiter character after a delimiter will be capitalized.
+Capitalization uses the Unicode title case, normally equivalent to upper case.
+
+Parameters:
+    str - the string to capitalize fully
+    delimiters - set of characters to determine capitalization, exclusion of this parameter means whitespace would be delimeter
+
+Returns:
+    capitalized string
+*/
+func CapitalizeFully(str string, delimiters ...rune) string {
+
+	var delimLen int
+
+	if delimiters == nil {
+		delimLen = -1
+	} else {
+		delimLen = len(delimiters)
+	}
+
+	if str == "" || delimLen == 0 {
+		return str
+	}
+	str = strings.ToLower(str)
+	return Capitalize(str, delimiters...)
+}
+
+/*
+Uncapitalize uncapitalizes all the whitespace separated words in a string. Only the first letter of each word is changed.
+The delimiters represent a set of characters understood to separate words. The first string character and the first non-delimiter
+character after a delimiter will be uncapitalized. Whitespace is defined by unicode.IsSpace(char).
+
+Parameters:
+    str - the string to uncapitalize fully
+    delimiters - set of characters to determine capitalization, exclusion of this parameter means whitespace would be delimeter
+
+Returns:
+    uncapitalized string
+*/
+func Uncapitalize(str string, delimiters ...rune) string {
+
+	var delimLen int
+
+	if delimiters == nil {
+		delimLen = -1
+	} else {
+		delimLen = len(delimiters)
+	}
+
+	if str == "" || delimLen == 0 {
+		return str
+	}
+
+	buffer := []rune(str)
+	uncapitalizeNext := true // TODO Always makes capitalize/un apply to first char.
+	for i := 0; i < len(buffer); i++ {
+		ch := buffer[i]
+		if isDelimiter(ch, delimiters...) {
+			uncapitalizeNext = true
+		} else if uncapitalizeNext {
+			buffer[i] = unicode.ToLower(ch)
+			uncapitalizeNext = false
+		}
+	}
+	return string(buffer)
+}
+
+/*
+SwapCase swaps the case of a string using a word based algorithm.
+
+Conversion algorithm:
+
+    Upper case character converts to Lower case
+    Title case character converts to Lower case
+    Lower case character after Whitespace or at start converts to Title case
+    Other Lower case character converts to Upper case
+    Whitespace is defined by unicode.IsSpace(char).
+
+Parameters:
+    str - the string to swap case
+
+Returns:
+    the changed string
+*/
+func SwapCase(str string) string {
+	if str == "" {
+		return str
+	}
+	buffer := []rune(str)
+
+	whitespace := true
+
+	for i := 0; i < len(buffer); i++ {
+		ch := buffer[i]
+		if unicode.IsUpper(ch) {
+			buffer[i] = unicode.ToLower(ch)
+			whitespace = false
+		} else if unicode.IsTitle(ch) {
+			buffer[i] = unicode.ToLower(ch)
+			whitespace = false
+		} else if unicode.IsLower(ch) {
+			if whitespace {
+				buffer[i] = unicode.ToTitle(ch)
+				whitespace = false
+			} else {
+				buffer[i] = unicode.ToUpper(ch)
+			}
+		} else {
+			whitespace = unicode.IsSpace(ch)
+		}
+	}
+	return string(buffer)
+}
+
+/*
+Initials extracts the initial letters from each word in the string. The first letter of the string and all first
+letters after the defined delimiters are returned as a new string. Their case is not changed. If the delimiters
+parameter is excluded, then Whitespace is used. Whitespace is defined by unicode.IsSpacea(char). An empty delimiter array returns an empty string.
+
+Parameters:
+    str - the string to get initials from
+    delimiters - set of characters to determine words, exclusion of this parameter means whitespace would be delimeter
+Returns:
+    string of initial letters
+*/
+func Initials(str string, delimiters ...rune) string {
+	if str == "" {
+		return str
+	}
+	if delimiters != nil && len(delimiters) == 0 {
+		return ""
+	}
+	strLen := len(str)
+	var buf bytes.Buffer
+	lastWasGap := true
+	for i := 0; i < strLen; i++ {
+		ch := rune(str[i])
+
+		if isDelimiter(ch, delimiters...) {
+			lastWasGap = true
+		} else if lastWasGap {
+			buf.WriteRune(ch)
+			lastWasGap = false
+		}
+	}
+	return buf.String()
+}
+
+// private function (lower case func name)
+func isDelimiter(ch rune, delimiters ...rune) bool {
+	if delimiters == nil {
+		return unicode.IsSpace(ch)
+	}
+	for _, delimiter := range delimiters {
+		if ch == delimiter {
+			return true
+		}
+	}
+	return false
+}

vendor/github.com/mvdan/sh/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2016, Daniel Martí. 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.
+   * Neither the name of the copyright holder nor the names of its
+contributors may 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
+OWNER 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/mvdan/sh/interp/arith.go

@@ -0,0 +1,171 @@
+// Copyright (c) 2017, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+package interp
+
+import (
+	"strconv"
+
+	"github.com/mvdan/sh/syntax"
+)
+
+func (r *Runner) arithm(expr syntax.ArithmExpr) int {
+	switch x := expr.(type) {
+	case *syntax.Word:
+		str := r.loneWord(x)
+		// recursively fetch vars
+		for {
+			val := r.getVar(str)
+			if val == "" {
+				break
+			}
+			str = val
+		}
+		// default to 0
+		return atoi(str)
+	case *syntax.ParenArithm:
+		return r.arithm(x.X)
+	case *syntax.UnaryArithm:
+		switch x.Op {
+		case syntax.Inc, syntax.Dec:
+			name := x.X.(*syntax.Word).Parts[0].(*syntax.Lit).Value
+			old := atoi(r.getVar(name))
+			val := old
+			if x.Op == syntax.Inc {
+				val++
+			} else {
+				val--
+			}
+			r.setVar(name, strconv.Itoa(val))
+			if x.Post {
+				return old
+			}
+			return val
+		}
+		val := r.arithm(x.X)
+		switch x.Op {
+		case syntax.Not:
+			return oneIf(val == 0)
+		case syntax.Plus:
+			return val
+		default: // syntax.Minus
+			return -val
+		}
+	case *syntax.BinaryArithm:
+		switch x.Op {
+		case syntax.Assgn, syntax.AddAssgn, syntax.SubAssgn,
+			syntax.MulAssgn, syntax.QuoAssgn, syntax.RemAssgn,
+			syntax.AndAssgn, syntax.OrAssgn, syntax.XorAssgn,
+			syntax.ShlAssgn, syntax.ShrAssgn:
+			return r.assgnArit(x)
+		case syntax.Quest: // Colon can't happen here
+			cond := r.arithm(x.X)
+			b2 := x.Y.(*syntax.BinaryArithm) // must have Op==Colon
+			if cond == 1 {
+				return r.arithm(b2.X)
+			}
+			return r.arithm(b2.Y)
+		}
+		return binArit(x.Op, r.arithm(x.X), r.arithm(x.Y))
+	default:
+		r.errf("unexpected arithm expr: %T", x)
+		return 0
+	}
+}
+
+// atoi is just a shorthand for strconv.Atoi that ignores the error,
+// just like shells do.
+func atoi(s string) int {
+	n, _ := strconv.Atoi(s)
+	return n
+}
+
+func (r *Runner) assgnArit(b *syntax.BinaryArithm) int {
+	name := b.X.(*syntax.Word).Parts[0].(*syntax.Lit).Value
+	val := atoi(r.getVar(name))
+	arg := r.arithm(b.Y)
+	switch b.Op {
+	case syntax.Assgn:
+		val = arg
+	case syntax.AddAssgn:
+		val += arg
+	case syntax.SubAssgn:
+		val -= arg
+	case syntax.MulAssgn:
+		val *= arg
+	case syntax.QuoAssgn:
+		val /= arg
+	case syntax.RemAssgn:
+		val %= arg
+	case syntax.AndAssgn:
+		val &= arg
+	case syntax.OrAssgn:
+		val |= arg
+	case syntax.XorAssgn:
+		val ^= arg
+	case syntax.ShlAssgn:
+		val <<= uint(arg)
+	default: // syntax.ShrAssgn
+		val >>= uint(arg)
+	}
+	r.setVar(name, strconv.Itoa(val))
+	return val
+}
+
+func intPow(a, b int) int {
+	p := 1
+	for b > 0 {
+		if b&1 != 0 {
+			p *= a
+		}
+		b >>= 1
+		a *= a
+	}
+	return p
+}
+
+func binArit(op syntax.BinAritOperator, x, y int) int {
+	switch op {
+	case syntax.Add:
+		return x + y
+	case syntax.Sub:
+		return x - y
+	case syntax.Mul:
+		return x * y
+	case syntax.Quo:
+		return x / y
+	case syntax.Rem:
+		return x % y
+	case syntax.Pow:
+		return intPow(x, y)
+	case syntax.Eql:
+		return oneIf(x == y)
+	case syntax.Gtr:
+		return oneIf(x > y)
+	case syntax.Lss:
+		return oneIf(x < y)
+	case syntax.Neq:
+		return oneIf(x != y)
+	case syntax.Leq:
+		return oneIf(x <= y)
+	case syntax.Geq:
+		return oneIf(x >= y)
+	case syntax.And:
+		return x & y
+	case syntax.Or:
+		return x | y
+	case syntax.Xor:
+		return x ^ y
+	case syntax.Shr:
+		return x >> uint(y)
+	case syntax.Shl:
+		return x << uint(y)
+	case syntax.AndArit:
+		return oneIf(x != 0 && y != 0)
+	case syntax.OrArit:
+		return oneIf(x != 0 || y != 0)
+	default: // syntax.Comma
+		// x is executed but its result discarded
+		return y
+	}
+}

vendor/github.com/mvdan/sh/interp/builtin.go

@@ -0,0 +1,179 @@
+// Copyright (c) 2017, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+package interp
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"github.com/mvdan/sh/syntax"
+)
+
+func (r *Runner) builtin(pos syntax.Pos, name string, args []string) bool {
+	exit := 0
+	switch name {
+	case "true", ":":
+	case "false":
+		exit = 1
+	case "exit":
+		switch len(args) {
+		case 0:
+			r.lastExit()
+		case 1:
+			if n, err := strconv.Atoi(args[0]); err != nil {
+				r.runErr(pos, "invalid exit code: %q", args[0])
+			} else {
+				exit = n
+				r.err = ExitCode(n)
+			}
+		default:
+			r.runErr(pos, "exit cannot take multiple arguments")
+		}
+	case "set":
+		r.args = args
+	case "shift":
+		n := 1
+		switch len(args) {
+		case 0:
+		case 1:
+			if n2, err := strconv.Atoi(args[0]); err == nil {
+				n = n2
+				break
+			}
+			fallthrough
+		default:
+			r.errf("usage: shift [n]\n")
+			exit = 2
+		}
+		if len(r.args) < n {
+			n = len(r.args)
+		}
+		r.args = r.args[n:]
+	case "unset":
+		for _, arg := range args {
+			r.delVar(arg)
+		}
+	case "echo":
+		newline := true
+	opts:
+		for len(args) > 0 {
+			switch args[0] {
+			case "-n":
+				newline = false
+			case "-e", "-E":
+				// TODO: what should be our default?
+				// exactly what is the difference in
+				// what we write?
+			default:
+				break opts
+			}
+			args = args[1:]
+		}
+		for i, arg := range args {
+			if i > 0 {
+				r.outf(" ")
+			}
+			r.outf("%s", arg)
+		}
+		if newline {
+			r.outf("\n")
+		}
+	case "printf":
+		if len(args) == 0 {
+			r.errf("usage: printf format [arguments]\n")
+			exit = 2
+			break
+		}
+		var a []interface{}
+		for _, arg := range args[1:] {
+			a = append(a, arg)
+		}
+		r.outf(args[0], a...)
+	case "break":
+		if !r.inLoop {
+			r.errf("break is only useful in a loop")
+			break
+		}
+		switch len(args) {
+		case 0:
+			r.breakEnclosing = 1
+		case 1:
+			if n, err := strconv.Atoi(args[0]); err == nil {
+				r.breakEnclosing = n
+				break
+			}
+			fallthrough
+		default:
+			r.errf("usage: break [n]\n")
+			exit = 2
+		}
+	case "continue":
+		if !r.inLoop {
+			r.errf("continue is only useful in a loop")
+			break
+		}
+		switch len(args) {
+		case 0:
+			r.contnEnclosing = 1
+		case 1:
+			if n, err := strconv.Atoi(args[0]); err == nil {
+				r.contnEnclosing = n
+				break
+			}
+			fallthrough
+		default:
+			r.errf("usage: continue [n]\n")
+			exit = 2
+		}
+	case "pwd":
+		r.outf("%s\n", r.getVar("PWD"))
+	case "cd":
+		if len(args) > 1 {
+			r.errf("usage: cd [dir]\n")
+			exit = 2
+			break
+		}
+		var dir string
+		if len(args) == 0 {
+			dir = r.getVar("HOME")
+		} else {
+			dir = args[0]
+		}
+		if !filepath.IsAbs(dir) {
+			dir = filepath.Join(r.Dir, dir)
+		}
+		_, err := os.Stat(dir)
+		if err != nil {
+			exit = 1
+			break
+		}
+		r.Dir = dir
+	case "wait":
+		if len(args) > 0 {
+			r.errf("wait with args not handled yet")
+			break
+		}
+		r.bgShells.Wait()
+	case "builtin":
+		if len(args) < 1 {
+			break
+		}
+		// TODO: pos
+		if !r.builtin(0, args[0], args[1:]) {
+			exit = 1
+		}
+	case "trap", "type", "source", "command", "pushd", "popd",
+		"umask", "alias", "unalias", "fg", "bg", "getopts":
+		r.errf("unhandled builtin: %s", name)
+	// TODO(mvdan): we rely on the binary versions of these, we
+	// should eventually implement them as builtins like Bash for
+	// portability
+	// case "[", "test":
+	default:
+		return false
+	}
+	r.exit = exit
+	return true
+}

vendor/github.com/mvdan/sh/interp/doc.go

@@ -0,0 +1,9 @@
+// Copyright (c) 2017, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+// Package interp implements an interpreter that executes shell
+// programs. It aims to support POSIX.
+//
+// This package is a work in progress and EXPERIMENTAL; its API is not
+// subject to the 1.x backwards compatibility guarantee.
+package interp

vendor/github.com/mvdan/sh/interp/interp.go

@@ -0,0 +1,653 @@
+// Copyright (c) 2017, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+package interp
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"os/user"
+	"path"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+
+	"github.com/mvdan/sh/syntax"
+)
+
+// A Runner interprets shell programs. It cannot be reused once a
+// program has been interpreted.
+//
+// Note that writes to Stdout and Stderr may not be sequential. If
+// you plan on using an io.Writer implementation that isn't safe for
+// concurrent use, consider a workaround like hiding writes behind a
+// mutex.
+type Runner struct {
+	// TODO: syntax.Node instead of *syntax.File?
+	File *syntax.File
+
+	// Env specifies the environment of the interpreter.
+	// If Env is nil, Run uses the current process's environment.
+	Env []string
+
+	// envMap is just Env as a map, to simplify and speed up its use
+	envMap map[string]string
+
+	// Dir specifies the working directory of the command. If Dir is
+	// the empty string, Run runs the command in the calling
+	// process's current directory.
+	Dir string
+
+	// Separate maps, note that bash allows a name to be both a var
+	// and a func simultaneously
+	vars  map[string]varValue
+	funcs map[string]*syntax.Stmt
+
+	// like vars, but local to a cmd i.e. "foo=bar prog args..."
+	cmdVars map[string]varValue
+
+	// Current arguments, if executing a function
+	args []string
+
+	// >0 to break or continue out of N enclosing loops
+	breakEnclosing, contnEnclosing int
+
+	inLoop bool
+
+	err  error // current fatal error
+	exit int   // current (last) exit code
+
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+
+	bgShells sync.WaitGroup
+
+	// Context can be used to cancel the interpreter before it finishes
+	Context context.Context
+}
+
+// varValue can hold a string, an indexed array ([]string) or an
+// associative array (map[string]string)
+// TODO: implement associative arrays
+type varValue interface{}
+
+func varStr(v varValue) string {
+	switch x := v.(type) {
+	case string:
+		return x
+	case []string:
+		if len(x) > 0 {
+			return x[0]
+		}
+	}
+	return ""
+}
+
+func (r *Runner) varInd(v varValue, e syntax.ArithmExpr) string {
+	switch x := v.(type) {
+	case string:
+		i := r.arithm(e)
+		if i == 0 {
+			return x
+		}
+	case []string:
+		// TODO: @ between double quotes
+		if w, ok := e.(*syntax.Word); ok {
+			if lit, ok := w.Parts[0].(*syntax.Lit); ok {
+				switch lit.Value {
+				case "@", "*":
+					return strings.Join(x, " ")
+				}
+			}
+		}
+		i := r.arithm(e)
+		if len(x) > 0 {
+			return x[i]
+		}
+	}
+	return ""
+}
+
+type ExitCode uint8
+
+func (e ExitCode) Error() string { return fmt.Sprintf("exit status %d", e) }
+
+type RunError struct {
+	syntax.Position
+	Text string
+}
+
+func (e RunError) Error() string {
+	return fmt.Sprintf("%s: %s", e.Position.String(), e.Text)
+}
+
+func (r *Runner) runErr(pos syntax.Pos, format string, a ...interface{}) {
+	if r.err == nil {
+		r.err = RunError{
+			Position: r.File.Position(pos),
+			Text:     fmt.Sprintf(format, a...),
+		}
+	}
+}
+
+func (r *Runner) lastExit() {
+	if r.err == nil {
+		r.err = ExitCode(r.exit)
+	}
+}
+
+func (r *Runner) setVar(name string, val varValue) {
+	if r.vars == nil {
+		r.vars = make(map[string]varValue, 4)
+	}
+	r.vars[name] = val
+}
+
+func (r *Runner) lookupVar(name string) (varValue, bool) {
+	switch name {
+	case "PWD":
+		return r.Dir, true
+	case "HOME":
+		u, _ := user.Current()
+		return u.HomeDir, true
+	}
+	if val, e := r.cmdVars[name]; e {
+		return val, true
+	}
+	if val, e := r.vars[name]; e {
+		return val, true
+	}
+	str, e := r.envMap[name]
+	return str, e
+}
+
+func (r *Runner) getVar(name string) string {
+	val, _ := r.lookupVar(name)
+	return varStr(val)
+}
+
+func (r *Runner) delVar(name string) {
+	delete(r.vars, name)
+	delete(r.envMap, name)
+}
+
+func (r *Runner) setFunc(name string, body *syntax.Stmt) {
+	if r.funcs == nil {
+		r.funcs = make(map[string]*syntax.Stmt, 4)
+	}
+	r.funcs[name] = body
+}
+
+// Run starts the interpreter and returns any error.
+func (r *Runner) Run() error {
+	if r.Context == nil {
+		r.Context = context.Background()
+	}
+	if r.Env == nil {
+		r.Env = os.Environ()
+	}
+	r.envMap = make(map[string]string, len(r.Env))
+	for _, kv := range r.Env {
+		i := strings.IndexByte(kv, '=')
+		if i < 0 {
+			return fmt.Errorf("env not in the form key=value: %q", kv)
+		}
+		name, val := kv[:i], kv[i+1:]
+		r.envMap[name] = val
+	}
+	if r.Dir == "" {
+		dir, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("could not get current dir: %v", err)
+		}
+		r.Dir = dir
+	}
+	r.stmts(r.File.Stmts)
+	r.lastExit()
+	if r.err == ExitCode(0) {
+		r.err = nil
+	}
+	return r.err
+}
+
+func (r *Runner) outf(format string, a ...interface{}) {
+	fmt.Fprintf(r.Stdout, format, a...)
+}
+
+func (r *Runner) errf(format string, a ...interface{}) {
+	fmt.Fprintf(r.Stderr, format, a...)
+}
+
+func (r *Runner) fields(words []*syntax.Word) []string {
+	fields := make([]string, 0, len(words))
+	for _, word := range words {
+		fields = append(fields, r.wordParts(word.Parts, false)...)
+	}
+	return fields
+}
+
+func (r *Runner) loneWord(word *syntax.Word) string {
+	return strings.Join(r.wordParts(word.Parts, false), "")
+}
+
+func (r *Runner) stop() bool {
+	if r.err != nil {
+		return true
+	}
+	if err := r.Context.Err(); err != nil {
+		r.err = err
+		return true
+	}
+	return false
+}
+
+func (r *Runner) stmt(st *syntax.Stmt) {
+	if r.stop() {
+		return
+	}
+	if st.Background {
+		r.bgShells.Add(1)
+		r2 := *r
+		r2.bgShells = sync.WaitGroup{}
+		go func() {
+			r2.stmtSync(st)
+			r.bgShells.Done()
+		}()
+	} else {
+		r.stmtSync(st)
+	}
+}
+
+func (r *Runner) assignValue(word *syntax.Word) varValue {
+	if word == nil {
+		return nil
+	}
+	ae, ok := word.Parts[0].(*syntax.ArrayExpr)
+	if !ok {
+		return r.loneWord(word)
+	}
+	strs := make([]string, len(ae.List))
+	for i, w := range ae.List {
+		strs[i] = r.loneWord(w)
+	}
+	return strs
+}
+
+func (r *Runner) stmtSync(st *syntax.Stmt) {
+	oldVars := r.cmdVars
+	for _, as := range st.Assigns {
+		name := as.Name.Value
+		val := r.assignValue(as.Value)
+		if st.Cmd == nil {
+			r.setVar(name, val)
+			continue
+		}
+		if r.cmdVars == nil {
+			r.cmdVars = make(map[string]varValue, len(st.Assigns))
+		}
+		r.cmdVars[name] = val
+	}
+	oldIn, oldOut, oldErr := r.Stdin, r.Stdout, r.Stderr
+	for _, rd := range st.Redirs {
+		cls, err := r.redir(rd)
+		if err != nil {
+			r.exit = 1
+			return
+		}
+		if cls != nil {
+			defer cls.Close()
+		}
+	}
+	if st.Cmd == nil {
+		r.exit = 0
+	} else {
+		r.cmd(st.Cmd)
+	}
+	if st.Negated {
+		r.exit = oneIf(r.exit == 0)
+	}
+	r.cmdVars = oldVars
+	r.Stdin, r.Stdout, r.Stderr = oldIn, oldOut, oldErr
+}
+
+func oneIf(b bool) int {
+	if b {
+		return 1
+	}
+	return 0
+}
+
+func (r *Runner) cmd(cm syntax.Command) {
+	if r.stop() {
+		return
+	}
+	switch x := cm.(type) {
+	case *syntax.Block:
+		r.stmts(x.Stmts)
+	case *syntax.Subshell:
+		r2 := *r
+		r2.stmts(x.Stmts)
+		r.exit = r2.exit
+	case *syntax.CallExpr:
+		fields := r.fields(x.Args)
+		r.call(x.Args[0].Pos(), fields[0], fields[1:])
+	case *syntax.BinaryCmd:
+		switch x.Op {
+		case syntax.AndStmt:
+			r.stmt(x.X)
+			if r.exit == 0 {
+				r.stmt(x.Y)
+			}
+		case syntax.OrStmt:
+			r.stmt(x.X)
+			if r.exit != 0 {
+				r.stmt(x.Y)
+			}
+		case syntax.Pipe, syntax.PipeAll:
+			pr, pw := io.Pipe()
+			r2 := *r
+			r2.Stdin = r.Stdin
+			r2.Stdout = pw
+			if x.Op == syntax.PipeAll {
+				r2.Stderr = pw
+			} else {
+				r2.Stderr = r.Stderr
+			}
+			r.Stdin = pr
+			go func() {
+				r2.stmt(x.X)
+				pw.Close()
+			}()
+			r.stmt(x.Y)
+			pr.Close()
+		}
+	case *syntax.IfClause:
+		r.stmts(x.CondStmts)
+		if r.exit == 0 {
+			r.stmts(x.ThenStmts)
+			return
+		}
+		for _, el := range x.Elifs {
+			r.stmts(el.CondStmts)
+			if r.exit == 0 {
+				r.stmts(el.ThenStmts)
+				return
+			}
+		}
+		r.stmts(x.ElseStmts)
+		if len(x.Elifs)+len(x.ElseStmts) == 0 {
+			r.exit = 0
+		}
+	case *syntax.WhileClause:
+		for r.err == nil {
+			r.stmts(x.CondStmts)
+			if r.exit != 0 {
+				r.exit = 0
+				break
+			}
+			if r.loopStmtsBroken(x.DoStmts) {
+				break
+			}
+		}
+	case *syntax.UntilClause:
+		for r.err == nil {
+			r.stmts(x.CondStmts)
+			if r.exit == 0 {
+				break
+			}
+			r.exit = 0
+			if r.loopStmtsBroken(x.DoStmts) {
+				break
+			}
+		}
+	case *syntax.ForClause:
+		switch y := x.Loop.(type) {
+		case *syntax.WordIter:
+			name := y.Name.Value
+			for _, field := range r.fields(y.List) {
+				r.setVar(name, field)
+				if r.loopStmtsBroken(x.DoStmts) {
+					break
+				}
+			}
+		case *syntax.CStyleLoop:
+			r.arithm(y.Init)
+			for r.arithm(y.Cond) != 0 {
+				if r.loopStmtsBroken(x.DoStmts) {
+					break
+				}
+				r.arithm(y.Post)
+			}
+		}
+	case *syntax.FuncDecl:
+		r.setFunc(x.Name.Value, x.Body)
+	case *syntax.ArithmCmd:
+		if r.arithm(x.X) == 0 {
+			r.exit = 1
+		}
+	case *syntax.LetClause:
+		var val int
+		for _, expr := range x.Exprs {
+			val = r.arithm(expr)
+		}
+		if val == 0 {
+			r.exit = 1
+		}
+	case *syntax.CaseClause:
+		str := r.loneWord(x.Word)
+		for _, pl := range x.List {
+			for _, word := range pl.Patterns {
+				pat := r.loneWord(word)
+				// TODO: error?
+				matched, _ := path.Match(pat, str)
+				if matched {
+					r.stmts(pl.Stmts)
+					return
+				}
+			}
+		}
+	case *syntax.TestClause:
+		if r.bashTest(x.X) == "" && r.exit == 0 {
+			r.exit = 1
+		}
+	default:
+		r.errf("unhandled command node: %T", x)
+	}
+}
+
+func (r *Runner) stmts(stmts []*syntax.Stmt) {
+	for _, stmt := range stmts {
+		r.stmt(stmt)
+	}
+}
+
+func (r *Runner) redir(rd *syntax.Redirect) (io.Closer, error) {
+	if rd.Hdoc != nil {
+		hdoc := r.loneWord(rd.Hdoc)
+		r.Stdin = strings.NewReader(hdoc)
+		return nil, nil
+	}
+	orig := &r.Stdout
+	if rd.N != nil {
+		switch rd.N.Value {
+		case "1":
+		case "2":
+			orig = &r.Stderr
+		}
+	}
+	arg := r.loneWord(rd.Word)
+	switch rd.Op {
+	case syntax.WordHdoc:
+		r.Stdin = strings.NewReader(arg + "\n")
+		return nil, nil
+	case syntax.DplOut:
+		switch arg {
+		case "1":
+			*orig = r.Stdout
+		case "2":
+			*orig = r.Stderr
+		}
+		return nil, nil
+	case syntax.DplIn:
+		r.errf("unhandled redirect op: %v", rd.Op)
+	}
+	mode := os.O_RDONLY
+	switch rd.Op {
+	case syntax.AppOut, syntax.AppAll:
+		mode = os.O_RDWR | os.O_CREATE | os.O_APPEND
+	case syntax.RdrOut, syntax.RdrAll:
+		mode = os.O_RDWR | os.O_CREATE | os.O_TRUNC
+	}
+	f, err := os.OpenFile(arg, mode, 0644)
+	if err != nil {
+		// TODO: print to stderr?
+		return nil, err
+	}
+	switch rd.Op {
+	case syntax.RdrIn:
+		r.Stdin = f
+	case syntax.RdrOut, syntax.AppOut:
+		*orig = f
+	case syntax.RdrAll, syntax.AppAll:
+		r.Stdout = f
+		r.Stderr = f
+	default:
+		r.errf("unhandled redirect op: %v", rd.Op)
+	}
+	return f, nil
+}
+
+func (r *Runner) loopStmtsBroken(stmts []*syntax.Stmt) bool {
+	r.inLoop = true
+	defer func() { r.inLoop = false }()
+	for _, stmt := range stmts {
+		r.stmt(stmt)
+		if r.contnEnclosing > 0 {
+			r.contnEnclosing--
+			return r.contnEnclosing > 0
+		}
+		if r.breakEnclosing > 0 {
+			r.breakEnclosing--
+			return true
+		}
+	}
+	return false
+}
+
+func (r *Runner) wordParts(wps []syntax.WordPart, quoted bool) []string {
+	var parts []string
+	var curBuf bytes.Buffer
+	flush := func() {
+		if curBuf.Len() == 0 {
+			return
+		}
+		parts = append(parts, curBuf.String())
+		curBuf.Reset()
+	}
+	splitAdd := func(val string) {
+		// TODO: use IFS
+		for i, field := range strings.Fields(val) {
+			if i > 0 {
+				flush()
+			}
+			curBuf.WriteString(field)
+		}
+	}
+	for _, wp := range wps {
+		switch x := wp.(type) {
+		case *syntax.Lit:
+			curBuf.WriteString(x.Value)
+		case *syntax.SglQuoted:
+			curBuf.WriteString(x.Value)
+		case *syntax.DblQuoted:
+			// TODO: @ between double quotes but not alone
+			if len(x.Parts) == 1 {
+				pe, ok := x.Parts[0].(*syntax.ParamExp)
+				if ok && pe.Param.Value == "@" {
+					for i, arg := range r.args {
+						if i > 0 {
+							flush()
+						}
+						curBuf.WriteString(arg)
+					}
+					continue
+				}
+			}
+			for _, str := range r.wordParts(x.Parts, true) {
+				curBuf.WriteString(str)
+			}
+		case *syntax.ParamExp:
+			val := r.paramExp(x)
+			if quoted {
+				curBuf.WriteString(val)
+			} else {
+				splitAdd(val)
+			}
+		case *syntax.CmdSubst:
+			r2 := *r
+			var outBuf bytes.Buffer
+			r2.Stdout = &outBuf
+			r2.stmts(x.Stmts)
+			val := strings.TrimRight(outBuf.String(), "\n")
+			if quoted {
+				curBuf.WriteString(val)
+			} else {
+				splitAdd(val)
+			}
+		case *syntax.ArithmExp:
+			curBuf.WriteString(strconv.Itoa(r.arithm(x.X)))
+		default:
+			r.errf("unhandled word part: %T", x)
+		}
+	}
+	flush()
+	return parts
+}
+
+func (r *Runner) call(pos syntax.Pos, name string, args []string) {
+	if body := r.funcs[name]; body != nil {
+		// stack them to support nested func calls
+		oldArgs := r.args
+		r.args = args
+		r.stmt(body)
+		r.args = oldArgs
+		return
+	}
+	if r.builtin(pos, name, args) {
+		return
+	}
+	cmd := exec.CommandContext(r.Context, name, args...)
+	cmd.Env = r.Env
+	for name, val := range r.cmdVars {
+		cmd.Env = append(cmd.Env, name+"="+varStr(val))
+	}
+	cmd.Dir = r.Dir
+	cmd.Stdin = r.Stdin
+	cmd.Stdout = r.Stdout
+	cmd.Stderr = r.Stderr
+	err := cmd.Run()
+	switch x := err.(type) {
+	case *exec.ExitError:
+		// started, but errored - default to 1 if OS
+		// doesn't have exit statuses
+		if status, ok := x.Sys().(syscall.WaitStatus); ok {
+			r.exit = status.ExitStatus()
+		} else {
+			r.exit = 1
+		}
+	case *exec.Error:
+		// did not start
+		// TODO: can this be anything other than
+		// "command not found"?
+		r.exit = 127
+		// TODO: print something?
+	default:
+		r.exit = 0
+	}
+}

vendor/github.com/mvdan/sh/interp/param.go

@@ -0,0 +1,198 @@
+// Copyright (c) 2017, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+package interp
+
+import (
+	"path"
+	"strconv"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/mvdan/sh/syntax"
+)
+
+func (r *Runner) paramExp(pe *syntax.ParamExp) string {
+	name := pe.Param.Value
+	var val varValue
+	set := false
+	switch name {
+	case "#":
+		val = strconv.Itoa(len(r.args))
+	case "*", "@":
+		val = strings.Join(r.args, " ")
+	case "?":
+		val = strconv.Itoa(r.exit)
+	default:
+		if n, err := strconv.Atoi(name); err == nil {
+			if i := n - 1; i < len(r.args) {
+				val, set = r.args[i], true
+			}
+		} else {
+			val, set = r.lookupVar(name)
+		}
+	}
+	str := varStr(val)
+	if pe.Ind != nil {
+		str = r.varInd(val, pe.Ind.Expr)
+	}
+	switch {
+	case pe.Length:
+		str = strconv.Itoa(utf8.RuneCountInString(str))
+	case pe.Excl:
+		val, set = r.lookupVar(str)
+		str = varStr(val)
+	}
+	slicePos := func(expr syntax.ArithmExpr) int {
+		p := r.arithm(expr)
+		if p < 0 {
+			p = len(str) + p
+			if p < 0 {
+				p = len(str)
+			}
+		} else if p > len(str) {
+			p = len(str)
+		}
+		return p
+	}
+	if pe.Slice != nil {
+		if pe.Slice.Offset != nil {
+			offset := slicePos(pe.Slice.Offset)
+			str = str[offset:]
+		}
+		if pe.Slice.Length != nil {
+			length := slicePos(pe.Slice.Length)
+			str = str[:length]
+		}
+	}
+	if pe.Repl != nil {
+		orig := r.loneWord(pe.Repl.Orig)
+		with := r.loneWord(pe.Repl.With)
+		n := 1
+		if pe.Repl.All {
+			n = -1
+		}
+		str = strings.Replace(str, orig, with, n)
+	}
+	if pe.Exp != nil {
+		arg := r.loneWord(pe.Exp.Word)
+		switch pe.Exp.Op {
+		case syntax.SubstColPlus:
+			if str == "" {
+				break
+			}
+			fallthrough
+		case syntax.SubstPlus:
+			if set {
+				str = arg
+			}
+		case syntax.SubstMinus:
+			if set {
+				break
+			}
+			fallthrough
+		case syntax.SubstColMinus:
+			if str == "" {
+				str = arg
+			}
+		case syntax.SubstQuest:
+			if set {
+				break
+			}
+			fallthrough
+		case syntax.SubstColQuest:
+			if str == "" {
+				r.errf("%s", arg)
+				r.exit = 1
+				r.lastExit()
+			}
+		case syntax.SubstAssgn:
+			if set {
+				break
+			}
+			fallthrough
+		case syntax.SubstColAssgn:
+			if str == "" {
+				r.setVar(name, arg)
+				str = arg
+			}
+		case syntax.RemSmallPrefix:
+			str = removePattern(str, arg, false, false)
+		case syntax.RemLargePrefix:
+			str = removePattern(str, arg, false, true)
+		case syntax.RemSmallSuffix:
+			str = removePattern(str, arg, true, false)
+		case syntax.RemLargeSuffix:
+			str = removePattern(str, arg, true, true)
+		case syntax.UpperFirst:
+			rs := []rune(str)
+			if len(rs) > 0 {
+				rs[0] = unicode.ToUpper(rs[0])
+			}
+			str = string(rs)
+		case syntax.UpperAll:
+			str = strings.ToUpper(str)
+		case syntax.LowerFirst:
+			rs := []rune(str)
+			if len(rs) > 0 {
+				rs[0] = unicode.ToLower(rs[0])
+			}
+			str = string(rs)
+		case syntax.LowerAll:
+			str = strings.ToLower(str)
+		default: // syntax.OtherParamOps
+			switch arg {
+			case "Q":
+				str = strconv.Quote(str)
+			case "E":
+				tail := str
+				var rns []rune
+				for tail != "" {
+					var rn rune
+					rn, _, tail, _ = strconv.UnquoteChar(tail, 0)
+					rns = append(rns, rn)
+				}
+				str = string(rns)
+			case "P", "A", "a":
+				r.errf("unhandled @%s param expansion", arg)
+			default:
+				r.errf("unexpected @%s param expansion", arg)
+			}
+		}
+	}
+	return str
+}
+
+func removePattern(str, pattern string, fromEnd, longest bool) string {
+	// TODO: really slow to not re-implement path.Match.
+	last := str
+	s := str
+	i := len(str)
+	if fromEnd {
+		i = 0
+	}
+	for {
+		if m, _ := path.Match(pattern, s); m {
+			last = str[i:]
+			if fromEnd {
+				last = str[:i]
+			}
+			if longest {
+				return last
+			}
+		}
+		if fromEnd {
+			if i++; i >= len(str) {
+				break
+			}
+			s = str[i:]
+		} else {
+			if i--; i < 1 {
+				break
+			}
+			s = str[:i]
+		}
+	}
+	return last
+}

vendor/github.com/mvdan/sh/interp/test.go

@@ -0,0 +1,160 @@
+// Copyright (c) 2017, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+package interp
+
+import (
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"regexp"
+
+	"github.com/mvdan/sh/syntax"
+)
+
+// non-empty string is true, empty string is false
+func (r *Runner) bashTest(expr syntax.TestExpr) string {
+	switch x := expr.(type) {
+	case *syntax.Word:
+		return r.loneWord(x)
+	case *syntax.ParenTest:
+		return r.bashTest(x.X)
+	case *syntax.BinaryTest:
+		if r.binTest(x.Op, r.bashTest(x.X), r.bashTest(x.Y)) {
+			return "1"
+		}
+		return ""
+	case *syntax.UnaryTest:
+		if r.unTest(x.Op, r.bashTest(x.X)) {
+			return "1"
+		}
+		return ""
+	}
+	return ""
+}
+
+func (r *Runner) binTest(op syntax.BinTestOperator, x, y string) bool {
+	switch op {
+	case syntax.TsReMatch:
+		re, err := regexp.Compile(y)
+		if err != nil {
+			r.exit = 2
+			return false
+		}
+		return re.MatchString(x)
+	case syntax.TsNewer:
+		i1, i2 := stat(x), stat(y)
+		if i1 == nil || i2 == nil {
+			return false
+		}
+		return i1.ModTime().After(i2.ModTime())
+	case syntax.TsOlder:
+		i1, i2 := stat(x), stat(y)
+		if i1 == nil || i2 == nil {
+			return false
+		}
+		return i1.ModTime().Before(i2.ModTime())
+	case syntax.TsDevIno:
+		i1, i2 := stat(x), stat(y)
+		return os.SameFile(i1, i2)
+	case syntax.TsEql:
+		return atoi(x) == atoi(y)
+	case syntax.TsNeq:
+		return atoi(x) != atoi(y)
+	case syntax.TsLeq:
+		return atoi(x) <= atoi(y)
+	case syntax.TsGeq:
+		return atoi(x) >= atoi(y)
+	case syntax.TsLss:
+		return atoi(x) < atoi(y)
+	case syntax.TsGtr:
+		return atoi(x) > atoi(y)
+	case syntax.AndTest:
+		return x != "" && y != ""
+	case syntax.OrTest:
+		return x != "" || y != ""
+	case syntax.TsEqual:
+		m, _ := path.Match(y, x)
+		return m
+	case syntax.TsNequal:
+		m, _ := path.Match(y, x)
+		return !m
+	case syntax.TsBefore:
+		return x < y
+	default: // syntax.TsAfter
+		return x > y
+	}
+}
+
+func stat(name string) os.FileInfo {
+	info, _ := os.Stat(name)
+	return info
+}
+
+func statMode(name string, mode os.FileMode) bool {
+	info := stat(name)
+	return info != nil && info.Mode()&mode != 0
+}
+
+func (r *Runner) unTest(op syntax.UnTestOperator, x string) bool {
+	switch op {
+	case syntax.TsExists:
+		return stat(x) != nil
+	case syntax.TsRegFile:
+		info := stat(x)
+		return info != nil && info.Mode().IsRegular()
+	case syntax.TsDirect:
+		return statMode(x, os.ModeDir)
+	//case syntax.TsCharSp:
+	//case syntax.TsBlckSp:
+	case syntax.TsNmPipe:
+		return statMode(x, os.ModeNamedPipe)
+	case syntax.TsSocket:
+		return statMode(x, os.ModeSocket)
+	case syntax.TsSmbLink:
+		info, _ := os.Lstat(x)
+		return info != nil && info.Mode()&os.ModeSymlink != 0
+	case syntax.TsSticky:
+		return statMode(x, os.ModeSticky)
+	case syntax.TsUIDSet:
+		return statMode(x, os.ModeSetuid)
+	case syntax.TsGIDSet:
+		return statMode(x, os.ModeSetgid)
+	//case syntax.TsGrpOwn:
+	//case syntax.TsUsrOwn:
+	//case syntax.TsModif:
+	case syntax.TsRead:
+		f, err := os.OpenFile(x, os.O_RDONLY, 0)
+		if err == nil {
+			f.Close()
+		}
+		return err == nil
+	case syntax.TsWrite:
+		f, err := os.OpenFile(x, os.O_WRONLY, 0)
+		if err == nil {
+			f.Close()
+		}
+		return err == nil
+	case syntax.TsExec:
+		// use an absolute path to not use $PATH
+		_, err := exec.LookPath(filepath.Join(r.Dir, x))
+		return err == nil
+	case syntax.TsNoEmpty:
+		info := stat(x)
+		return info != nil && info.Size() > 0
+	//case syntax.TsFdTerm:
+	case syntax.TsEmpStr:
+		return x == ""
+	case syntax.TsNempStr:
+		return x != ""
+	//case syntax.TsOptSet:
+	//case syntax.TsVarSet:
+	//case syntax.TsRefVar:
+	case syntax.TsNot:
+		return x == ""
+	default:
+		r.errf("unhandled unary test op: %v", op)
+		return false
+	}
+}

vendor/github.com/mvdan/sh/syntax/canonical.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# separate comment
+
+! foo bar >a &
+
+foo() { bar; }
+
+{
+	var1="some long value" # var1 comment
+	var2=short             # var2 comment
+}
+
+if foo; then bar; fi
+
+for foo in a b c; do
+	bar
+done
+
+case $foo in
+	a) A ;;
+	b)
+		B
+		;;
+esac
+
+foo | bar
+foo \
+	&& $(bar) \
+	&& (more)
+
+foo 2>&1
+foo <<EOF
+bar
+EOF
+
+$((3 + 4))

vendor/github.com/mvdan/sh/syntax/doc.go

@@ -0,0 +1,6 @@
+// Copyright (c) 2016, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+// Package syntax implements parsing and formatting of shell programs.
+// It supports both POSIX Shell and Bash.
+package syntax

vendor/github.com/mvdan/sh/syntax/nodes.go

@@ -0,0 +1,731 @@
+// Copyright (c) 2016, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+package syntax
+
+import "fmt"
+
+// Node represents an AST node.
+type Node interface {
+	// Pos returns the first character of the node
+	Pos() Pos
+	// End returns the character immediately after the node
+	End() Pos
+}
+
+// File is a shell program.
+type File struct {
+	Name string
+
+	Stmts    []*Stmt
+	Comments []*Comment
+
+	lines []Pos
+}
+
+// Pos is the internal representation of a position within a source
+// file.
+type Pos uint32
+
+// IsValid reports whether the position is valid. All positions in nodes
+// returned by Parse are valid.
+func (p Pos) IsValid() bool { return p > 0 }
+
+const maxPos = Pos(^uint32(0))
+
+// Position describes a position within a source file including the line
+// and column location. A Position is valid if the line number is > 0.
+type Position struct {
+	Filename string // if any
+	Offset   int    // byte offset, starting at 0
+	Line     int    // line number, starting at 1
+	Column   int    // column number, starting at 1 (in bytes)
+}
+
+// IsValid reports whether the position is valid. All positions in nodes
+// returned by Parse are valid.
+func (p Position) IsValid() bool { return p.Line > 0 }
+
+// String returns the position in the "file:line:column" form, or
+// "line:column" if there is no filename available.
+func (p Position) String() string {
+	prefix := ""
+	if p.Filename != "" {
+		prefix = p.Filename + ":"
+	}
+	return fmt.Sprintf("%s%d:%d", prefix, p.Line, p.Column)
+}
+
+func (f *File) Pos() Pos {
+	if len(f.Stmts) == 0 {
+		return 0
+	}
+	return f.Stmts[0].Pos()
+}
+
+func (f *File) End() Pos {
+	if len(f.Stmts) == 0 {
+		return 0
+	}
+	return f.Stmts[len(f.Stmts)-1].End()
+}
+
+func (f *File) Position(p Pos) (pos Position) {
+	pos.Filename = f.Name
+	pos.Offset = int(p) - 1
+	if i := searchPos(f.lines, p); i >= 0 {
+		pos.Line, pos.Column = i+1, int(p-f.lines[i])
+	}
+	return
+}
+
+func searchPos(a []Pos, x Pos) int {
+	i, j := 0, len(a)
+	for i < j {
+		h := i + (j-i)/2
+		if a[h] <= x {
+			i = h + 1
+		} else {
+			j = h
+		}
+	}
+	return i - 1
+}
+
+func posMax(p1, p2 Pos) Pos {
+	if p2 > p1 {
+		return p2
+	}
+	return p1
+}
+
+// Comment represents a single comment on a single line.
+type Comment struct {
+	Hash Pos
+	Text string
+}
+
+func (c *Comment) Pos() Pos { return c.Hash }
+func (c *Comment) End() Pos { return c.Hash + Pos(len(c.Text)) }
+
+// Stmt represents a statement, otherwise known as a compound command.
+// It is compromised of a command and other components that may come
+// before or after it.
+type Stmt struct {
+	Cmd        Command
+	Position   Pos
+	Semicolon  Pos
+	Negated    bool
+	Background bool
+	Assigns    []*Assign
+	Redirs     []*Redirect
+}
+
+func (s *Stmt) Pos() Pos { return s.Position }
+func (s *Stmt) End() Pos {
+	if s.Semicolon.IsValid() {
+		return s.Semicolon + 1
+	}
+	end := s.Position
+	if s.Negated {
+		end++
+	}
+	if s.Cmd != nil {
+		end = s.Cmd.End()
+	}
+	if len(s.Assigns) > 0 {
+		end = posMax(end, s.Assigns[len(s.Assigns)-1].End())
+	}
+	if len(s.Redirs) > 0 {
+		end = posMax(end, s.Redirs[len(s.Redirs)-1].End())
+	}
+	return end
+}
+
+// Command represents all nodes that are simple commands, which are
+// directly placed in a Stmt.
+type Command interface {
+	Node
+	commandNode()
+}
+
+func (*CallExpr) commandNode()     {}
+func (*IfClause) commandNode()     {}
+func (*WhileClause) commandNode()  {}
+func (*UntilClause) commandNode()  {}
+func (*ForClause) commandNode()    {}
+func (*CaseClause) commandNode()   {}
+func (*Block) commandNode()        {}
+func (*Subshell) commandNode()     {}
+func (*BinaryCmd) commandNode()    {}
+func (*FuncDecl) commandNode()     {}
+func (*ArithmCmd) commandNode()    {}
+func (*TestClause) commandNode()   {}
+func (*DeclClause) commandNode()   {}
+func (*EvalClause) commandNode()   {}
+func (*LetClause) commandNode()    {}
+func (*CoprocClause) commandNode() {}
+
+// Assign represents an assignment to a variable.
+type Assign struct {
+	Append bool
+	Name   *Lit
+	Value  *Word
+}
+
+func (a *Assign) Pos() Pos {
+	if a.Name != nil {
+		return a.Name.Pos()
+	}
+	return a.Value.Pos()
+}
+
+func (a *Assign) End() Pos {
+	if a.Value != nil {
+		return a.Value.End()
+	}
+	return a.Name.End() + 1
+}
+
+// Redirect represents an input/output redirection.
+type Redirect struct {
+	OpPos      Pos
+	Op         RedirOperator
+	N          *Lit
+	Word, Hdoc *Word
+}
+
+func (r *Redirect) Pos() Pos {
+	if r.N != nil {
+		return r.N.Pos()
+	}
+	return r.OpPos
+}
+func (r *Redirect) End() Pos { return r.Word.End() }
+
+// CallExpr represents a command execution or function call.
+type CallExpr struct {
+	Args []*Word
+}
+
+func (c *CallExpr) Pos() Pos { return c.Args[0].Pos() }
+func (c *CallExpr) End() Pos { return c.Args[len(c.Args)-1].End() }
+
+// Subshell represents a series of commands that should be executed in a
+// nested shell environment.
+type Subshell struct {
+	Lparen, Rparen Pos
+	Stmts          []*Stmt
+}
+
+func (s *Subshell) Pos() Pos { return s.Lparen }
+func (s *Subshell) End() Pos { return s.Rparen + 1 }
+
+// Block represents a series of commands that should be executed in a
+// nested scope.
+type Block struct {
+	Lbrace, Rbrace Pos
+	Stmts          []*Stmt
+}
+
+func (b *Block) Pos() Pos { return b.Rbrace }
+func (b *Block) End() Pos { return b.Rbrace + 1 }
+
+// IfClause represents an if statement.
+type IfClause struct {
+	If, Then, Else, Fi Pos
+	CondStmts          []*Stmt
+	ThenStmts          []*Stmt
+	Elifs              []*Elif
+	ElseStmts          []*Stmt
+}
+
+func (c *IfClause) Pos() Pos { return c.If }
+func (c *IfClause) End() Pos { return c.Fi + 2 }
+
+// Elif represents an "else if" case in an if clause.
+type Elif struct {
+	Elif, Then Pos
+	CondStmts  []*Stmt
+	ThenStmts  []*Stmt
+}
+
+// WhileClause represents a while clause.
+type WhileClause struct {
+	While, Do, Done Pos
+	CondStmts       []*Stmt
+	DoStmts         []*Stmt
+}
+
+func (w *WhileClause) Pos() Pos { return w.While }
+func (w *WhileClause) End() Pos { return w.Done + 4 }
+
+// UntilClause represents an until clause.
+type UntilClause struct {
+	Until, Do, Done Pos
+	CondStmts       []*Stmt
+	DoStmts         []*Stmt
+}
+
+func (u *UntilClause) Pos() Pos { return u.Until }
+func (u *UntilClause) End() Pos { return u.Done + 4 }
+
+// ForClause represents a for clause.
+type ForClause struct {
+	For, Do, Done Pos
+	Loop          Loop
+	DoStmts       []*Stmt
+}
+
+func (f *ForClause) Pos() Pos { return f.For }
+func (f *ForClause) End() Pos { return f.Done + 4 }
+
+// Loop represents all nodes that can be loops in a for clause.
+type Loop interface {
+	Node
+	loopNode()
+}
+
+func (*WordIter) loopNode()   {}
+func (*CStyleLoop) loopNode() {}
+
+// WordIter represents the iteration of a variable over a series of
+// words in a for clause.
+type WordIter struct {
+	Name *Lit
+	List []*Word
+}
+
+func (w *WordIter) Pos() Pos { return w.Name.Pos() }
+func (w *WordIter) End() Pos { return posMax(w.Name.End(), wordLastEnd(w.List)) }
+
+// CStyleLoop represents the behaviour of a for clause similar to the C
+// language.
+//
+// This node will never appear when in PosixConformant mode.
+type CStyleLoop struct {
+	Lparen, Rparen   Pos
+	Init, Cond, Post ArithmExpr
+}
+
+func (c *CStyleLoop) Pos() Pos { return c.Lparen }
+func (c *CStyleLoop) End() Pos { return c.Rparen + 2 }
+
+// BinaryCmd represents a binary expression between two statements.
+type BinaryCmd struct {
+	OpPos Pos
+	Op    BinCmdOperator
+	X, Y  *Stmt
+}
+
+func (b *BinaryCmd) Pos() Pos { return b.X.Pos() }
+func (b *BinaryCmd) End() Pos { return b.Y.End() }
+
+// FuncDecl represents the declaration of a function.
+type FuncDecl struct {
+	Position  Pos
+	BashStyle bool
+	Name      *Lit
+	Body      *Stmt
+}
+
+func (f *FuncDecl) Pos() Pos { return f.Position }
+func (f *FuncDecl) End() Pos { return f.Body.End() }
+
+// Word represents a non-empty list of nodes that are contiguous to each
+// other. The word is delimeted by word boundaries.
+type Word struct {
+	Parts []WordPart
+}
+
+func (w *Word) Pos() Pos { return w.Parts[0].Pos() }
+func (w *Word) End() Pos { return w.Parts[len(w.Parts)-1].End() }
+
+// WordPart represents all nodes that can form a word.
+type WordPart interface {
+	Node
+	wordPartNode()
+}
+
+func (*Lit) wordPartNode()       {}
+func (*SglQuoted) wordPartNode() {}
+func (*DblQuoted) wordPartNode() {}
+func (*ParamExp) wordPartNode()  {}
+func (*CmdSubst) wordPartNode()  {}
+func (*ArithmExp) wordPartNode() {}
+func (*ProcSubst) wordPartNode() {}
+func (*ArrayExpr) wordPartNode() {}
+func (*ExtGlob) wordPartNode()   {}
+
+// Lit represents an unquoted string consisting of characters that were
+// not tokenized.
+type Lit struct {
+	ValuePos, ValueEnd Pos
+	Value              string
+}
+
+func (l *Lit) Pos() Pos { return l.ValuePos }
+func (l *Lit) End() Pos { return l.ValueEnd }
+
+// SglQuoted represents a string within single quotes.
+type SglQuoted struct {
+	Position Pos
+	Dollar   bool
+	Value    string
+}
+
+func (q *SglQuoted) Pos() Pos { return q.Position }
+func (q *SglQuoted) End() Pos {
+	end := q.Position + 2 + Pos(len(q.Value))
+	if q.Dollar {
+		end++
+	}
+	return end
+}
+
+// DblQuoted represents a list of nodes within double quotes.
+type DblQuoted struct {
+	Position Pos
+	Dollar   bool
+	Parts    []WordPart
+}
+
+func (q *DblQuoted) Pos() Pos { return q.Position }
+func (q *DblQuoted) End() Pos {
+	if len(q.Parts) == 0 {
+		if q.Dollar {
+			return q.Position + 3
+		}
+		return q.Position + 2
+	}
+	return q.Parts[len(q.Parts)-1].End() + 1
+}
+
+// CmdSubst represents a command substitution.
+type CmdSubst struct {
+	Left, Right Pos
+	Stmts       []*Stmt
+}
+
+func (c *CmdSubst) Pos() Pos { return c.Left }
+func (c *CmdSubst) End() Pos { return c.Right + 1 }
+
+// ParamExp represents a parameter expansion.
+type ParamExp struct {
+	Dollar, Rbrace Pos
+	Short          bool
+	Length, Excl   bool // TODO(mvdan): rename Excl in 2.0 (Indirect, etc)
+	Param          *Lit
+	Ind            *Index
+	Slice          *Slice
+	Repl           *Replace
+	Exp            *Expansion
+}
+
+func (p *ParamExp) Pos() Pos { return p.Dollar }
+func (p *ParamExp) End() Pos {
+	if !p.Short {
+		return p.Rbrace + 1
+	}
+	return p.Param.End()
+}
+
+// Index represents access to an array via an index inside a ParamExp.
+//
+// This node will never appear when in PosixConformant mode.
+type Index struct {
+	Expr ArithmExpr
+}
+
+// Slice represents character slicing inside a ParamExp.
+//
+// This node will never appear when in PosixConformant mode.
+type Slice struct {
+	Offset, Length ArithmExpr
+}
+
+// Replace represents a search and replace inside a ParamExp.
+type Replace struct {
+	All        bool
+	Orig, With *Word
+}
+
+// Expansion represents string manipulation in a ParamExp other than
+// those covered by Replace.
+type Expansion struct {
+	Op   ParExpOperator
+	Word *Word
+}
+
+// ArithmExp represents an arithmetic expansion.
+type ArithmExp struct {
+	Left, Right Pos
+	Bracket     bool
+	X           ArithmExpr
+}
+
+func (a *ArithmExp) Pos() Pos { return a.Left }
+func (a *ArithmExp) End() Pos {
+	if a.Bracket {
+		return a.Right + 1
+	}
+	return a.Right + 2
+}
+
+// ArithmCmd represents an arithmetic command.
+//
+// This node will never appear when in PosixConformant mode.
+type ArithmCmd struct {
+	Left, Right Pos
+	X           ArithmExpr
+}
+
+func (a *ArithmCmd) Pos() Pos { return a.Left }
+func (a *ArithmCmd) End() Pos { return a.Right + 2 }
+
+// ArithmExpr represents all nodes that form arithmetic expressions.
+type ArithmExpr interface {
+	Node
+	arithmExprNode()
+}
+
+func (*BinaryArithm) arithmExprNode() {}
+func (*UnaryArithm) arithmExprNode()  {}
+func (*ParenArithm) arithmExprNode()  {}
+func (*Word) arithmExprNode()         {}
+
+// BinaryArithm represents a binary expression between two arithmetic
+// expression.
+//
+// If Op is any assign operator, X will be a *Word with a single *Lit
+// whose value is a valid name.
+//
+// Ternary operators like "a ? b : c" are fit into this structure. Thus,
+// if Op == Quest, Y will be a *BinaryArithm with Op == Colon. Op can
+// only be Colon in that scenario.
+//
+// TODO(mvdan): we probably want to split up assigns in 2.0 (X would be
+// a *Lit) to simplify the rules here. Perhaps reuse the Assign type?
+type BinaryArithm struct {
+	OpPos Pos
+	Op    BinAritOperator
+	X, Y  ArithmExpr
+}
+
+func (b *BinaryArithm) Pos() Pos { return b.X.Pos() }
+func (b *BinaryArithm) End() Pos { return b.Y.End() }
+
+// UnaryArithm represents an unary expression over a node, either before
+// or after it.
+//
+// If Op is Inc or Dec, X will be a *Word with a single *Lit whose value
+// is a valid name.
+//
+// TODO(mvdan): consider splitting up Inc/Dec like the assigns above in
+// 2.0.
+type UnaryArithm struct {
+	OpPos Pos
+	Op    UnAritOperator
+	Post  bool
+	X     ArithmExpr
+}
+
+func (u *UnaryArithm) Pos() Pos {
+	if u.Post {
+		return u.X.Pos()
+	}
+	return u.OpPos
+}
+
+func (u *UnaryArithm) End() Pos {
+	if u.Post {
+		return u.OpPos + 2
+	}
+	return u.X.End()
+}
+
+// ParenArithm represents an expression within parentheses inside an
+// ArithmExp.
+type ParenArithm struct {
+	Lparen, Rparen Pos
+	X              ArithmExpr
+}
+
+func (p *ParenArithm) Pos() Pos { return p.Lparen }
+func (p *ParenArithm) End() Pos { return p.Rparen + 1 }
+
+// CaseClause represents a case (switch) clause.
+type CaseClause struct {
+	Case, Esac Pos
+	Word       *Word
+	List       []*PatternList
+}
+
+func (c *CaseClause) Pos() Pos { return c.Case }
+func (c *CaseClause) End() Pos { return c.Esac + 4 }
+
+// PatternList represents a pattern list (case) within a CaseClause.
+type PatternList struct {
+	Op       CaseOperator
+	OpPos    Pos
+	Patterns []*Word
+	Stmts    []*Stmt
+}
+
+// TestClause represents a Bash extended test clause.
+//
+// This node will never appear when in PosixConformant mode.
+type TestClause struct {
+	Left, Right Pos
+	X           TestExpr
+}
+
+func (t *TestClause) Pos() Pos { return t.Left }
+func (t *TestClause) End() Pos { return t.Right + 2 }
+
+// TestExpr represents all nodes that form arithmetic expressions.
+type TestExpr interface {
+	Node
+	testExprNode()
+}
+
+func (*BinaryTest) testExprNode() {}
+func (*UnaryTest) testExprNode()  {}
+func (*ParenTest) testExprNode()  {}
+func (*Word) testExprNode()       {}
+
+// BinaryTest represents a binary expression between two arithmetic
+// expression.
+type BinaryTest struct {
+	OpPos Pos
+	Op    BinTestOperator
+	X, Y  TestExpr
+}
+
+func (b *BinaryTest) Pos() Pos { return b.X.Pos() }
+func (b *BinaryTest) End() Pos { return b.Y.End() }
+
+// UnaryTest represents an unary expression over a node, either before
+// or after it.
+type UnaryTest struct {
+	OpPos Pos
+	Op    UnTestOperator
+	X     TestExpr
+}
+
+func (u *UnaryTest) Pos() Pos { return u.OpPos }
+func (u *UnaryTest) End() Pos { return u.X.End() }
+
+// ParenTest represents an expression within parentheses inside an
+// TestExp.
+type ParenTest struct {
+	Lparen, Rparen Pos
+	X              TestExpr
+}
+
+func (p *ParenTest) Pos() Pos { return p.Lparen }
+func (p *ParenTest) End() Pos { return p.Rparen + 1 }
+
+// DeclClause represents a Bash declare clause.
+//
+// This node will never appear when in PosixConformant mode.
+type DeclClause struct {
+	Position Pos
+	Variant  string
+	Opts     []*Word
+	Assigns  []*Assign
+}
+
+func (d *DeclClause) Pos() Pos { return d.Position }
+func (d *DeclClause) End() Pos {
+	if len(d.Assigns) > 0 {
+		return d.Assigns[len(d.Assigns)-1].End()
+	}
+	return wordLastEnd(d.Opts)
+}
+
+// ArrayExpr represents a Bash array expression.
+//
+// This node will never appear when in PosixConformant mode.
+type ArrayExpr struct {
+	Lparen, Rparen Pos
+	List           []*Word
+}
+
+func (a *ArrayExpr) Pos() Pos { return a.Lparen }
+func (a *ArrayExpr) End() Pos { return a.Rparen + 1 }
+
+// ExtGlob represents a Bash extended globbing expression. Note that
+// these are parsed independently of whether shopt has been called or
+// not.
+//
+// This node will never appear when in PosixConformant mode.
+type ExtGlob struct {
+	OpPos   Pos
+	Op      GlobOperator
+	Pattern *Lit
+}
+
+func (e *ExtGlob) Pos() Pos { return e.OpPos }
+func (e *ExtGlob) End() Pos { return e.Pattern.End() + 1 }
+
+// ProcSubst represents a Bash process substitution.
+//
+// This node will never appear when in PosixConformant mode.
+type ProcSubst struct {
+	OpPos, Rparen Pos
+	Op            ProcOperator
+	Stmts         []*Stmt
+}
+
+func (s *ProcSubst) Pos() Pos { return s.OpPos }
+func (s *ProcSubst) End() Pos { return s.Rparen + 1 }
+
+// EvalClause represents a Bash eval clause.
+//
+// This node will never appear when in PosixConformant mode.
+//
+// TODO(mvdan): EvalClause is actually pointless, as any non-trivial use
+// of eval will involve parsing the program at run-time. Remove in 2.0.
+type EvalClause struct {
+	Eval Pos
+	Stmt *Stmt
+}
+
+func (e *EvalClause) Pos() Pos { return e.Eval }
+func (e *EvalClause) End() Pos {
+	if e.Stmt != nil {
+		return e.Stmt.End()
+	}
+	return e.Eval + 4
+}
+
+// CoprocClause represents a Bash coproc clause.
+//
+// This node will never appear when in PosixConformant mode.
+type CoprocClause struct {
+	Coproc Pos
+	Name   *Lit
+	Stmt   *Stmt
+}
+
+func (c *CoprocClause) Pos() Pos { return c.Coproc }
+func (c *CoprocClause) End() Pos { return c.Stmt.End() }
+
+// LetClause represents a Bash let clause.
+//
+// This node will never appear when in PosixConformant mode.
+type LetClause struct {
+	Let   Pos
+	Exprs []ArithmExpr
+}
+
+func (l *LetClause) Pos() Pos { return l.Let }
+func (l *LetClause) End() Pos { return l.Exprs[len(l.Exprs)-1].End() }
+
+func wordLastEnd(ws []*Word) Pos {
+	if len(ws) == 0 {
+		return 0
+	}
+	return ws[len(ws)-1].End()
+}

vendor/github.com/mvdan/sh/syntax/printer.go

@@ -0,0 +1,904 @@
+// Copyright (c) 2016, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+package syntax
+
+import (
+	"bufio"
+	"io"
+	"sync"
+)
+
+// PrintConfig controls how the printing of an AST node will behave.
+type PrintConfig struct {
+	Spaces int // 0 (default) for tabs, >0 for number of spaces
+}
+
+var printerFree = sync.Pool{
+	New: func() interface{} {
+		return &printer{
+			bufWriter:  bufio.NewWriter(nil),
+			lenPrinter: new(printer),
+		}
+	},
+}
+
+// Fprint "pretty-prints" the given AST file to the given writer.
+func (c PrintConfig) Fprint(w io.Writer, f *File) error {
+	p := printerFree.Get().(*printer)
+	p.reset()
+	p.PrintConfig = c
+	p.lines, p.comments = f.lines, f.Comments
+	p.bufWriter.Reset(w)
+	p.stmts(f.Stmts)
+	p.commentsUpTo(0)
+	p.newline(0)
+	var err error
+	if flusher, ok := p.bufWriter.(interface {
+		Flush() error
+	}); ok {
+		err = flusher.Flush()
+	}
+	printerFree.Put(p)
+	return err
+}
+
+// Fprint "pretty-prints" the given AST file to the given writer. It
+// calls PrintConfig.Fprint with its default settings.
+func Fprint(w io.Writer, f *File) error {
+	return PrintConfig{}.Fprint(w, f)
+}
+
+type bufWriter interface {
+	WriteByte(byte) error
+	WriteString(string) (int, error)
+	Reset(io.Writer)
+}
+
+type printer struct {
+	bufWriter
+
+	PrintConfig
+	lines []Pos
+
+	wantSpace   bool
+	wantNewline bool
+	wroteSemi   bool
+
+	commentPadding int
+
+	// nline is the position of the next newline
+	nline      Pos
+	nlineIndex int
+
+	// lastLevel is the last level of indentation that was used.
+	lastLevel int
+	// level is the current level of indentation.
+	level int
+	// levelIncs records which indentation level increments actually
+	// took place, to revert them once their section ends.
+	levelIncs []bool
+
+	nestedBinary bool
+
+	// comments is the list of pending comments to write.
+	comments []*Comment
+
+	// pendingHdocs is the list of pending heredocs to write.
+	pendingHdocs []*Redirect
+
+	// used in stmtLen to align comments
+	lenPrinter *printer
+	lenCounter byteCounter
+}
+
+func (p *printer) reset() {
+	p.wantSpace, p.wantNewline = false, false
+	p.commentPadding = 0
+	p.nline, p.nlineIndex = 0, 0
+	p.lastLevel, p.level = 0, 0
+	p.levelIncs = p.levelIncs[:0]
+	p.nestedBinary = false
+	p.pendingHdocs = p.pendingHdocs[:0]
+}
+
+func (p *printer) incLine() {
+	if p.nlineIndex++; p.nlineIndex >= len(p.lines) {
+		p.nline = maxPos
+	} else {
+		p.nline = p.lines[p.nlineIndex]
+	}
+}
+
+func (p *printer) incLines(pos Pos) {
+	for p.nline < pos {
+		p.incLine()
+	}
+}
+
+func (p *printer) spaces(n int) {
+	for i := 0; i < n; i++ {
+		p.WriteByte(' ')
+	}
+}
+
+func (p *printer) bslashNewl() {
+	if p.wantSpace {
+		p.WriteByte(' ')
+	}
+	p.WriteString("\\\n")
+	p.wantSpace = false
+	p.incLine()
+}
+
+func (p *printer) spacedString(s string) {
+	if p.wantSpace {
+		p.WriteByte(' ')
+	}
+	p.WriteString(s)
+	p.wantSpace = true
+}
+
+func (p *printer) semiOrNewl(s string, pos Pos) {
+	if p.wantNewline {
+		p.newline(pos)
+		p.indent()
+	} else {
+		if !p.wroteSemi {
+			p.WriteByte(';')
+		}
+		p.WriteByte(' ')
+		p.incLines(pos)
+	}
+	p.WriteString(s)
+	p.wantSpace = true
+}
+
+func (p *printer) incLevel() {
+	inc := false
+	if p.level <= p.lastLevel || len(p.levelIncs) == 0 {
+		p.level++
+		inc = true
+	} else if last := &p.levelIncs[len(p.levelIncs)-1]; *last {
+		*last = false
+		inc = true
+	}
+	p.levelIncs = append(p.levelIncs, inc)
+}
+
+func (p *printer) decLevel() {
+	if p.levelIncs[len(p.levelIncs)-1] {
+		p.level--
+	}
+	p.levelIncs = p.levelIncs[:len(p.levelIncs)-1]
+}
+
+func (p *printer) indent() {
+	p.lastLevel = p.level
+	switch {
+	case p.level == 0:
+	case p.Spaces == 0:
+		for i := 0; i < p.level; i++ {
+			p.WriteByte('\t')
+		}
+	case p.Spaces > 0:
+		p.spaces(p.Spaces * p.level)
+	}
+}
+
+func (p *printer) newline(pos Pos) {
+	p.wantNewline, p.wantSpace = false, false
+	p.WriteByte('\n')
+	if pos > p.nline {
+		p.incLine()
+	}
+	hdocs := p.pendingHdocs
+	p.pendingHdocs = p.pendingHdocs[:0]
+	for _, r := range hdocs {
+		p.word(r.Hdoc)
+		p.incLines(r.Hdoc.End())
+		p.unquotedWord(r.Word)
+		p.WriteByte('\n')
+		p.incLine()
+		p.wantSpace = false
+	}
+}
+
+func (p *printer) newlines(pos Pos) {
+	p.newline(pos)
+	if pos > p.nline {
+		// preserve single empty lines
+		p.WriteByte('\n')
+		p.incLine()
+	}
+	p.indent()
+}
+
+func (p *printer) commentsAndSeparate(pos Pos) {
+	p.commentsUpTo(pos)
+	if p.wantNewline || pos > p.nline {
+		p.newlines(pos)
+	}
+}
+
+func (p *printer) sepTok(s string, pos Pos) {
+	p.level++
+	p.commentsUpTo(pos)
+	p.level--
+	if p.wantNewline || pos > p.nline {
+		p.newlines(pos)
+	}
+	p.WriteString(s)
+	p.wantSpace = true
+}
+
+func (p *printer) semiRsrv(s string, pos Pos, fallback bool) {
+	p.level++
+	p.commentsUpTo(pos)
+	p.level--
+	if p.wantNewline || pos > p.nline {
+		p.newlines(pos)
+	} else if fallback {
+		if !p.wroteSemi {
+			p.WriteByte(';')
+		}
+		p.WriteByte(' ')
+	} else if p.wantSpace {
+		p.WriteByte(' ')
+	}
+	p.WriteString(s)
+	p.wantSpace = true
+}
+
+func (p *printer) anyCommentsBefore(pos Pos) bool {
+	if !pos.IsValid() || len(p.comments) < 1 {
+		return false
+	}
+	return p.comments[0].Hash < pos
+}
+
+func (p *printer) commentsUpTo(pos Pos) {
+	if len(p.comments) < 1 {
+		return
+	}
+	c := p.comments[0]
+	if pos.IsValid() && c.Hash >= pos {
+		return
+	}
+	p.comments = p.comments[1:]
+	switch {
+	case p.nlineIndex == 0:
+	case c.Hash > p.nline:
+		p.newlines(c.Hash)
+	case p.wantSpace:
+		p.spaces(p.commentPadding + 1)
+	}
+	p.incLines(c.Hash)
+	p.WriteByte('#')
+	p.WriteString(c.Text)
+	p.commentsUpTo(pos)
+}
+
+func (p *printer) wordPart(wp WordPart) {
+	switch x := wp.(type) {
+	case *Lit:
+		p.WriteString(x.Value)
+	case *SglQuoted:
+		if x.Dollar {
+			p.WriteByte('$')
+		}
+		p.WriteByte('\'')
+		p.WriteString(x.Value)
+		p.WriteByte('\'')
+		p.incLines(x.End())
+	case *DblQuoted:
+		if x.Dollar {
+			p.WriteByte('$')
+		}
+		p.WriteByte('"')
+		for i, n := range x.Parts {
+			p.wordPart(n)
+			if i == len(x.Parts)-1 {
+				p.incLines(n.End())
+			}
+		}
+		p.WriteByte('"')
+	case *CmdSubst:
+		p.incLines(x.Pos())
+		p.WriteString("$(")
+		p.wantSpace = len(x.Stmts) > 0 && startsWithLparen(x.Stmts[0])
+		p.nestedStmts(x.Stmts, x.Right)
+		p.sepTok(")", x.Right)
+	case *ParamExp:
+		if x.Short {
+			p.WriteByte('$')
+			p.WriteString(x.Param.Value)
+			break
+		}
+		p.WriteString("${")
+		switch {
+		case x.Length:
+			p.WriteByte('#')
+		case x.Excl:
+			p.WriteByte('!')
+		}
+		if x.Param != nil {
+			p.WriteString(x.Param.Value)
+		}
+		if x.Ind != nil {
+			p.WriteByte('[')
+			p.arithmExpr(x.Ind.Expr, false)
+			p.WriteByte(']')
+		}
+		if x.Slice != nil {
+			p.WriteByte(':')
+			if un, ok := x.Slice.Offset.(*UnaryArithm); ok {
+				if un.Op == Plus || un.Op == Minus {
+					// to avoid :+ and :-
+					p.WriteByte(' ')
+				}
+			}
+			p.arithmExpr(x.Slice.Offset, true)
+			if x.Slice.Length != nil {
+				p.WriteByte(':')
+				p.arithmExpr(x.Slice.Length, true)
+			}
+		} else if x.Repl != nil {
+			if x.Repl.All {
+				p.WriteByte('/')
+			}
+			p.WriteByte('/')
+			p.word(x.Repl.Orig)
+			p.WriteByte('/')
+			p.word(x.Repl.With)
+		} else if x.Exp != nil {
+			p.WriteString(x.Exp.Op.String())
+			p.word(x.Exp.Word)
+		}
+		p.WriteByte('}')
+	case *ArithmExp:
+		p.WriteString("$((")
+		p.arithmExpr(x.X, false)
+		p.WriteString("))")
+	case *ArrayExpr:
+		p.wantSpace = false
+		p.WriteByte('(')
+		p.wordJoin(x.List, false)
+		p.sepTok(")", x.Rparen)
+	case *ExtGlob:
+		p.WriteString(x.Op.String())
+		p.WriteString(x.Pattern.Value)
+		p.WriteByte(')')
+	case *ProcSubst:
+		// avoid conflict with << and others
+		if p.wantSpace {
+			p.WriteByte(' ')
+			p.wantSpace = false
+		}
+		p.WriteString(x.Op.String())
+		p.nestedStmts(x.Stmts, 0)
+		p.WriteByte(')')
+	}
+}
+
+func (p *printer) loop(loop Loop) {
+	switch x := loop.(type) {
+	case *WordIter:
+		p.WriteString(x.Name.Value)
+		if len(x.List) > 0 {
+			p.spacedString(" in")
+			p.wordJoin(x.List, true)
+		}
+	case *CStyleLoop:
+		p.WriteString("((")
+		if x.Init == nil {
+			p.WriteByte(' ')
+		}
+		p.arithmExpr(x.Init, false)
+		p.WriteString("; ")
+		p.arithmExpr(x.Cond, false)
+		p.WriteString("; ")
+		p.arithmExpr(x.Post, false)
+		p.WriteString("))")
+	}
+}
+
+func (p *printer) arithmExpr(expr ArithmExpr, compact bool) {
+	switch x := expr.(type) {
+	case *Word:
+		p.word(x)
+	case *BinaryArithm:
+		if compact {
+			p.arithmExpr(x.X, compact)
+			p.WriteString(x.Op.String())
+			p.arithmExpr(x.Y, compact)
+		} else {
+			p.arithmExpr(x.X, compact)
+			if x.Op != Comma {
+				p.WriteByte(' ')
+			}
+			p.WriteString(x.Op.String())
+			p.WriteByte(' ')
+			p.arithmExpr(x.Y, compact)
+		}
+	case *UnaryArithm:
+		if x.Post {
+			p.arithmExpr(x.X, compact)
+			p.WriteString(x.Op.String())
+		} else {
+			p.WriteString(x.Op.String())
+			p.arithmExpr(x.X, compact)
+		}
+	case *ParenArithm:
+		p.WriteByte('(')
+		p.arithmExpr(x.X, false)
+		p.WriteByte(')')
+	}
+}
+
+func (p *printer) testExpr(expr TestExpr) {
+	switch x := expr.(type) {
+	case *Word:
+		p.word(x)
+	case *BinaryTest:
+		p.testExpr(x.X)
+		p.WriteByte(' ')
+		p.WriteString(x.Op.String())
+		p.WriteByte(' ')
+		p.testExpr(x.Y)
+	case *UnaryTest:
+		p.WriteString(x.Op.String())
+		p.WriteByte(' ')
+		p.testExpr(x.X)
+	case *ParenTest:
+		p.WriteByte('(')
+		p.testExpr(x.X)
+		p.WriteByte(')')
+	}
+}
+
+func (p *printer) word(w *Word) {
+	for _, n := range w.Parts {
+		p.wordPart(n)
+	}
+	p.wantSpace = true
+}
+
+func (p *printer) unquotedWord(w *Word) {
+	for _, wp := range w.Parts {
+		switch x := wp.(type) {
+		case *SglQuoted:
+			p.WriteString(x.Value)
+		case *DblQuoted:
+			for _, qp := range x.Parts {
+				p.wordPart(qp)
+			}
+		case *Lit:
+			for i := 0; i < len(x.Value); i++ {
+				if b := x.Value[i]; b == '\\' {
+					if i++; i < len(x.Value) {
+						p.WriteByte(x.Value[i])
+					}
+				} else {
+					p.WriteByte(b)
+				}
+			}
+		}
+	}
+}
+
+func (p *printer) wordJoin(ws []*Word, backslash bool) {
+	anyNewline := false
+	for _, w := range ws {
+		if pos := w.Pos(); pos > p.nline {
+			p.commentsUpTo(pos)
+			if backslash {
+				p.bslashNewl()
+			} else {
+				p.WriteByte('\n')
+				p.incLine()
+			}
+			if !anyNewline {
+				p.incLevel()
+				anyNewline = true
+			}
+			p.indent()
+		} else if p.wantSpace {
+			p.WriteByte(' ')
+			p.wantSpace = false
+		}
+		p.word(w)
+	}
+	if anyNewline {
+		p.decLevel()
+	}
+}
+
+func (p *printer) stmt(s *Stmt) {
+	if s.Negated {
+		p.spacedString("!")
+	}
+	p.assigns(s.Assigns)
+	var startRedirs int
+	if s.Cmd != nil {
+		startRedirs = p.command(s.Cmd, s.Redirs)
+	}
+	anyNewline := false
+	for _, r := range s.Redirs[startRedirs:] {
+		if r.OpPos > p.nline {
+			p.bslashNewl()
+			if !anyNewline {
+				p.incLevel()
+				anyNewline = true
+			}
+			p.indent()
+		}
+		p.commentsAndSeparate(r.OpPos)
+		if p.wantSpace {
+			p.WriteByte(' ')
+		}
+		if r.N != nil {
+			p.WriteString(r.N.Value)
+		}
+		p.WriteString(r.Op.String())
+		p.word(r.Word)
+		if r.Op == Hdoc || r.Op == DashHdoc {
+			p.pendingHdocs = append(p.pendingHdocs, r)
+		}
+	}
+	p.wroteSemi = false
+	if s.Semicolon.IsValid() && s.Semicolon > p.nline {
+		p.incLevel()
+		p.bslashNewl()
+		p.indent()
+		p.decLevel()
+		p.WriteByte(';')
+		p.wroteSemi = true
+	} else if s.Background {
+		p.WriteString(" &")
+	}
+	if anyNewline {
+		p.decLevel()
+	}
+}
+
+func (p *printer) command(cmd Command, redirs []*Redirect) (startRedirs int) {
+	if p.wantSpace {
+		p.WriteByte(' ')
+		p.wantSpace = false
+	}
+	switch x := cmd.(type) {
+	case *CallExpr:
+		if len(x.Args) <= 1 {
+			p.wordJoin(x.Args, true)
+			return 0
+		}
+		p.wordJoin(x.Args[:1], true)
+		for _, r := range redirs {
+			if r.Pos() > x.Args[1].Pos() || r.Op == Hdoc || r.Op == DashHdoc {
+				break
+			}
+			if p.wantSpace {
+				p.WriteByte(' ')
+			}
+			if r.N != nil {
+				p.WriteString(r.N.Value)
+			}
+			p.WriteString(r.Op.String())
+			p.word(r.Word)
+			startRedirs++
+		}
+		p.wordJoin(x.Args[1:], true)
+	case *Block:
+		p.WriteByte('{')
+		p.wantSpace = true
+		p.nestedStmts(x.Stmts, x.Rbrace)
+		p.semiRsrv("}", x.Rbrace, true)
+	case *IfClause:
+		p.spacedString("if")
+		p.nestedStmts(x.CondStmts, 0)
+		p.semiOrNewl("then", x.Then)
+		p.nestedStmts(x.ThenStmts, 0)
+		for _, el := range x.Elifs {
+			p.semiRsrv("elif", el.Elif, true)
+			p.nestedStmts(el.CondStmts, 0)
+			p.semiOrNewl("then", el.Then)
+			p.nestedStmts(el.ThenStmts, 0)
+		}
+		if len(x.ElseStmts) > 0 {
+			p.semiRsrv("else", x.Else, true)
+			p.nestedStmts(x.ElseStmts, 0)
+		} else if x.Else.IsValid() {
+			p.incLines(x.Else)
+		}
+		p.semiRsrv("fi", x.Fi, true)
+	case *Subshell:
+		p.WriteByte('(')
+		p.wantSpace = len(x.Stmts) > 0 && startsWithLparen(x.Stmts[0])
+		p.nestedStmts(x.Stmts, x.Rparen)
+		p.sepTok(")", x.Rparen)
+	case *WhileClause:
+		p.spacedString("while")
+		p.nestedStmts(x.CondStmts, 0)
+		p.semiOrNewl("do", x.Do)
+		p.nestedStmts(x.DoStmts, 0)
+		p.semiRsrv("done", x.Done, true)
+	case *ForClause:
+		p.WriteString("for ")
+		p.loop(x.Loop)
+		p.semiOrNewl("do", x.Do)
+		p.nestedStmts(x.DoStmts, 0)
+		p.semiRsrv("done", x.Done, true)
+	case *BinaryCmd:
+		p.stmt(x.X)
+		indent := !p.nestedBinary
+		if indent {
+			p.incLevel()
+		}
+		_, p.nestedBinary = x.Y.Cmd.(*BinaryCmd)
+		if len(p.pendingHdocs) == 0 && x.Y.Pos() > p.nline {
+			p.bslashNewl()
+			p.indent()
+		}
+		p.spacedString(x.Op.String())
+		if p.anyCommentsBefore(x.Y.Pos()) {
+			p.wantSpace = false
+			p.WriteByte('\n')
+			p.indent()
+			p.incLines(p.comments[0].Pos())
+			p.commentsUpTo(x.Y.Pos())
+			p.WriteByte('\n')
+			p.indent()
+		}
+		p.incLines(x.Y.Pos())
+		p.stmt(x.Y)
+		if indent {
+			p.decLevel()
+		}
+		p.nestedBinary = false
+	case *FuncDecl:
+		if x.BashStyle {
+			p.WriteString("function ")
+		}
+		p.WriteString(x.Name.Value)
+		p.WriteString("() ")
+		p.incLines(x.Body.Pos())
+		p.stmt(x.Body)
+	case *CaseClause:
+		p.WriteString("case ")
+		p.word(x.Word)
+		p.WriteString(" in")
+		p.incLevel()
+		for _, pl := range x.List {
+			p.commentsAndSeparate(pl.Patterns[0].Pos())
+			for i, w := range pl.Patterns {
+				if i > 0 {
+					p.spacedString("|")
+				}
+				if p.wantSpace {
+					p.WriteByte(' ')
+				}
+				p.word(w)
+			}
+			p.WriteByte(')')
+			p.wantSpace = true
+			sep := len(pl.Stmts) > 1 || (len(pl.Stmts) > 0 && pl.Stmts[0].Pos() > p.nline)
+			p.nestedStmts(pl.Stmts, 0)
+			p.level++
+			if sep {
+				p.commentsUpTo(pl.OpPos)
+				p.newlines(pl.OpPos)
+			}
+			p.spacedString(pl.Op.String())
+			p.incLines(pl.OpPos)
+			p.level--
+			if sep || pl.OpPos == x.Esac {
+				p.wantNewline = true
+			}
+		}
+		p.decLevel()
+		p.semiRsrv("esac", x.Esac, len(x.List) == 0)
+	case *UntilClause:
+		p.spacedString("until")
+		p.nestedStmts(x.CondStmts, 0)
+		p.semiOrNewl("do", x.Do)
+		p.nestedStmts(x.DoStmts, 0)
+		p.semiRsrv("done", x.Done, true)
+	case *ArithmCmd:
+		p.WriteString("((")
+		p.arithmExpr(x.X, false)
+		p.WriteString("))")
+	case *TestClause:
+		p.WriteString("[[ ")
+		p.testExpr(x.X)
+		p.spacedString("]]")
+	case *DeclClause:
+		name := x.Variant
+		if name == "" {
+			name = "declare"
+		}
+		p.spacedString(name)
+		for _, w := range x.Opts {
+			p.WriteByte(' ')
+			p.word(w)
+		}
+		p.assigns(x.Assigns)
+	case *EvalClause:
+		p.spacedString("eval")
+		if x.Stmt != nil {
+			p.stmt(x.Stmt)
+		}
+	case *CoprocClause:
+		p.spacedString("coproc")
+		if x.Name != nil {
+			p.WriteByte(' ')
+			p.WriteString(x.Name.Value)
+		}
+		p.stmt(x.Stmt)
+	case *LetClause:
+		p.spacedString("let")
+		for _, n := range x.Exprs {
+			p.WriteByte(' ')
+			p.arithmExpr(n, true)
+		}
+	}
+	return startRedirs
+}
+
+func startsWithLparen(s *Stmt) bool {
+	switch x := s.Cmd.(type) {
+	case *Subshell:
+		return true
+	case *BinaryCmd:
+		return startsWithLparen(x.X)
+	}
+	return false
+}
+
+func (p *printer) hasInline(pos, npos, nline Pos) bool {
+	for _, c := range p.comments {
+		if c.Hash > nline {
+			return false
+		}
+		if c.Hash > pos && (npos == 0 || c.Hash < npos) {
+			return true
+		}
+	}
+	return false
+}
+
+func (p *printer) stmts(stmts []*Stmt) {
+	switch len(stmts) {
+	case 0:
+		return
+	case 1:
+		s := stmts[0]
+		pos := s.Pos()
+		p.commentsUpTo(pos)
+		if pos <= p.nline {
+			p.stmt(s)
+		} else {
+			if p.nlineIndex > 0 {
+				p.newlines(pos)
+			}
+			p.incLines(pos)
+			p.stmt(s)
+			p.wantNewline = true
+		}
+		return
+	}
+	inlineIndent := 0
+	for i, s := range stmts {
+		pos := s.Pos()
+		ind := p.nlineIndex
+		p.commentsUpTo(pos)
+		if p.nlineIndex > 0 {
+			p.newlines(pos)
+		}
+		p.incLines(pos)
+		p.stmt(s)
+		var npos Pos
+		if i+1 < len(stmts) {
+			npos = stmts[i+1].Pos()
+		}
+		if !p.hasInline(pos, npos, p.nline) {
+			inlineIndent = 0
+			p.commentPadding = 0
+			continue
+		}
+		if ind < len(p.lines)-1 && s.End() > p.lines[ind+1] {
+			inlineIndent = 0
+		}
+		if inlineIndent == 0 {
+			ind2 := p.nlineIndex
+			nline2 := p.nline
+			follow := stmts[i:]
+			for j, s2 := range follow {
+				pos2 := s2.Pos()
+				var npos2 Pos
+				if j+1 < len(follow) {
+					npos2 = follow[j+1].Pos()
+				}
+				if pos2 > nline2 || !p.hasInline(pos2, npos2, nline2) {
+					break
+				}
+				if l := p.stmtLen(s2); l > inlineIndent {
+					inlineIndent = l
+				}
+				if ind2++; ind2 >= len(p.lines) {
+					nline2 = maxPos
+				} else {
+					nline2 = p.lines[ind2]
+				}
+			}
+			if ind2 == p.nlineIndex+1 {
+				// no inline comments directly after this one
+				continue
+			}
+		}
+		if inlineIndent > 0 {
+			p.commentPadding = inlineIndent - p.stmtLen(s)
+		}
+	}
+	p.wantNewline = true
+}
+
+type byteCounter int
+
+func (c *byteCounter) WriteByte(b byte) error {
+	*c++
+	return nil
+}
+func (c *byteCounter) WriteString(s string) (int, error) {
+	*c += byteCounter(len(s))
+	return 0, nil
+}
+func (c *byteCounter) Reset(io.Writer) { *c = 0 }
+
+func (p *printer) stmtLen(s *Stmt) int {
+	*p.lenPrinter = printer{bufWriter: &p.lenCounter}
+	p.lenPrinter.bufWriter.Reset(nil)
+	p.lenPrinter.incLines(s.Pos())
+	p.lenPrinter.stmt(s)
+	return int(p.lenCounter)
+}
+
+func (p *printer) nestedStmts(stmts []*Stmt, closing Pos) {
+	p.incLevel()
+	if len(stmts) == 1 && closing > p.nline && stmts[0].End() <= p.nline {
+		p.newline(0)
+		p.indent()
+	}
+	p.stmts(stmts)
+	p.decLevel()
+}
+
+func (p *printer) assigns(assigns []*Assign) {
+	anyNewline := false
+	for _, a := range assigns {
+		if a.Pos() > p.nline {
+			p.bslashNewl()
+			if !anyNewline {
+				p.incLevel()
+				anyNewline = true
+			}
+			p.indent()
+		} else if p.wantSpace {
+			p.WriteByte(' ')
+		}
+		if a.Name != nil {
+			p.WriteString(a.Name.Value)
+			if a.Append {
+				p.WriteByte('+')
+			}
+			p.WriteByte('=')
+		}
+		if a.Value != nil {
+			p.word(a.Value)
+		}
+		p.wantSpace = true
+	}
+	if anyNewline {
+		p.decLevel()
+	}
+}

vendor/github.com/mvdan/sh/syntax/token_string.go

@@ -0,0 +1,16 @@
+// Code generated by "stringer -type token"; DO NOT EDIT
+
+package syntax
+
+import "fmt"
+
+const _token_name = "illegalTokEOFLitLitWordLitRedir'\"`&&&||||&$$'$\"${$[$($(([(((}])));;;;&;;&!++--***==!=<=>=+=-=*=/=%=&=|=^=<<=>>=>>><<><&>&>|<<<<-<<<&>&>><(>(+:+-:-?:?=:=%%%###^^^,,,@///:-e-f-d-c-b-p-S-L-k-g-u-G-O-N-r-w-x-s-t-z-n-o-v-R=~-nt-ot-ef-eq-ne-le-ge-lt-gt?(*(+(@(!("
+
+var _token_index = [...]uint16{0, 10, 13, 16, 23, 31, 32, 33, 34, 35, 37, 39, 40, 42, 43, 45, 47, 49, 51, 53, 56, 57, 58, 60, 61, 62, 63, 65, 66, 68, 70, 73, 74, 76, 78, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 108, 111, 112, 114, 115, 117, 119, 121, 123, 125, 128, 131, 133, 136, 138, 140, 141, 143, 144, 146, 147, 149, 150, 152, 153, 155, 156, 158, 159, 161, 162, 164, 165, 166, 168, 169, 171, 173, 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 217, 219, 222, 225, 228, 231, 234, 237, 240, 243, 246, 248, 250, 252, 254, 256}
+
+func (i token) String() string {
+	if i >= token(len(_token_index)-1) {
+		return fmt.Sprintf("token(%d)", i)
+	}
+	return _token_name[_token_index[i]:_token_index[i+1]]
+}

vendor/github.com/mvdan/sh/syntax/tokens.go

@@ -0,0 +1,340 @@
+// Copyright (c) 2016, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+package syntax
+
+type token uint32
+
+// Modified version of golang.org/x/tools/cmd/stringer that gets the
+// string value from the inline comment of each constant, if there is
+// one. Also removes leading '_'.
+//go:generate stringer -type token
+
+// The list of all possible tokens.
+const (
+	illegalTok token = iota
+	_EOF
+	_Lit
+	_LitWord
+	_LitRedir
+
+	sglQuote // '
+	dblQuote // "
+	bckQuote // `
+
+	and     // &
+	andAnd  // &&
+	orOr    // ||
+	or      // |
+	pipeAll // |&
+
+	dollar       // $
+	dollSglQuote // $'
+	dollDblQuote // $"
+	dollBrace    // ${
+	dollBrack    // $[
+	dollParen    // $(
+	dollDblParen // $((
+	leftBrack    // [
+	leftParen    // (
+	dblLeftParen // ((
+
+	rightBrace    // }
+	rightBrack    // ]
+	rightParen    // )
+	dblRightParen // ))
+	semicolon     // ;
+
+	dblSemicolon // ;;
+	semiFall     // ;&
+	dblSemiFall  // ;;&
+
+	exclMark // !
+	addAdd   // ++
+	subSub   // --
+	star     // *
+	power    // **
+	equal    // ==
+	nequal   // !=
+	lequal   // <=
+	gequal   // >=
+
+	addAssgn // +=
+	subAssgn // -=
+	mulAssgn // *=
+	quoAssgn // /=
+	remAssgn // %=
+	andAssgn // &=
+	orAssgn  // |=
+	xorAssgn // ^=
+	shlAssgn // <<=
+	shrAssgn // >>=
+
+	rdrOut   // >
+	appOut   // >>
+	rdrIn    // <
+	rdrInOut // <>
+	dplIn    // <&
+	dplOut   // >&
+	clbOut   // >|
+	hdoc     // <<
+	dashHdoc // <<-
+	wordHdoc // <<<
+	rdrAll   // &>
+	appAll   // &>>
+
+	cmdIn  // <(
+	cmdOut // >(
+
+	plus     // +
+	colPlus  // :+
+	minus    // -
+	colMinus // :-
+	quest    // ?
+	colQuest // :?
+	assgn    // =
+	colAssgn // :=
+	perc     // %
+	dblPerc  // %%
+	hash     // #
+	dblHash  // ##
+	caret    // ^
+	dblCaret // ^^
+	comma    // ,
+	dblComma // ,,
+	at       // @
+	slash    // /
+	dblSlash // //
+	colon    // :
+
+	tsExists  // -e
+	tsRegFile // -f
+	tsDirect  // -d
+	tsCharSp  // -c
+	tsBlckSp  // -b
+	tsNmPipe  // -p
+	tsSocket  // -S
+	tsSmbLink // -L
+	tsSticky  // -k
+	tsGIDSet  // -g
+	tsUIDSet  // -u
+	tsGrpOwn  // -G
+	tsUsrOwn  // -O
+	tsModif   // -N
+	tsRead    // -r
+	tsWrite   // -w
+	tsExec    // -x
+	tsNoEmpty // -s
+	tsFdTerm  // -t
+	tsEmpStr  // -z
+	tsNempStr // -n
+	tsOptSet  // -o
+	tsVarSet  // -v
+	tsRefVar  // -R
+
+	tsReMatch // =~
+	tsNewer   // -nt
+	tsOlder   // -ot
+	tsDevIno  // -ef
+	tsEql     // -eq
+	tsNeq     // -ne
+	tsLeq     // -le
+	tsGeq     // -ge
+	tsLss     // -lt
+	tsGtr     // -gt
+
+	globQuest // ?(
+	globStar  // *(
+	globPlus  // +(
+	globAt    // @(
+	globExcl  // !(
+)
+
+type RedirOperator token
+
+const (
+	RdrOut = RedirOperator(rdrOut) + iota
+	AppOut
+	RdrIn
+	RdrInOut
+	DplIn
+	DplOut
+	ClbOut
+	Hdoc
+	DashHdoc
+	WordHdoc
+	RdrAll
+	AppAll
+)
+
+type ProcOperator token
+
+const (
+	CmdIn = ProcOperator(cmdIn) + iota
+	CmdOut
+)
+
+type GlobOperator token
+
+const (
+	GlobQuest = GlobOperator(globQuest) + iota
+	GlobStar
+	GlobPlus
+	GlobAt
+	GlobExcl
+)
+
+type BinCmdOperator token
+
+const (
+	AndStmt = BinCmdOperator(andAnd) + iota
+	OrStmt
+	Pipe
+	PipeAll
+)
+
+type CaseOperator token
+
+const (
+	DblSemicolon = CaseOperator(dblSemicolon) + iota
+	SemiFall
+	DblSemiFall
+)
+
+type ParExpOperator token
+
+const (
+	SubstPlus = ParExpOperator(plus) + iota
+	SubstColPlus
+	SubstMinus
+	SubstColMinus
+	SubstQuest
+	SubstColQuest
+	SubstAssgn
+	SubstColAssgn
+	RemSmallSuffix
+	RemLargeSuffix
+	RemSmallPrefix
+	RemLargePrefix
+	UpperFirst
+	UpperAll
+	LowerFirst
+	LowerAll
+	OtherParamOps
+)
+
+type UnAritOperator token
+
+const (
+	Not = UnAritOperator(exclMark) + iota
+	Inc
+	Dec
+	Plus  = UnAritOperator(plus)
+	Minus = UnAritOperator(minus)
+)
+
+type BinAritOperator token
+
+const (
+	Add = BinAritOperator(plus)
+	Sub = BinAritOperator(minus)
+	Mul = BinAritOperator(star)
+	Quo = BinAritOperator(slash)
+	Rem = BinAritOperator(perc)
+	Pow = BinAritOperator(power)
+	Eql = BinAritOperator(equal)
+	Gtr = BinAritOperator(rdrOut)
+	Lss = BinAritOperator(rdrIn)
+	Neq = BinAritOperator(nequal)
+	Leq = BinAritOperator(lequal)
+	Geq = BinAritOperator(gequal)
+	And = BinAritOperator(and)
+	Or  = BinAritOperator(or)
+	Xor = BinAritOperator(caret)
+	Shr = BinAritOperator(appOut)
+	Shl = BinAritOperator(hdoc)
+
+	AndArit = BinAritOperator(andAnd)
+	OrArit  = BinAritOperator(orOr)
+	Comma   = BinAritOperator(comma)
+	Quest   = BinAritOperator(quest)
+	Colon   = BinAritOperator(colon)
+
+	Assgn    = BinAritOperator(assgn)
+	AddAssgn = BinAritOperator(addAssgn)
+	SubAssgn = BinAritOperator(subAssgn)
+	MulAssgn = BinAritOperator(mulAssgn)
+	QuoAssgn = BinAritOperator(quoAssgn)
+	RemAssgn = BinAritOperator(remAssgn)
+	AndAssgn = BinAritOperator(andAssgn)
+	OrAssgn  = BinAritOperator(orAssgn)
+	XorAssgn = BinAritOperator(xorAssgn)
+	ShlAssgn = BinAritOperator(shlAssgn)
+	ShrAssgn = BinAritOperator(shrAssgn)
+)
+
+type UnTestOperator token
+
+const (
+	TsExists = UnTestOperator(tsExists) + iota
+	TsRegFile
+	TsDirect
+	TsCharSp
+	TsBlckSp
+	TsNmPipe
+	TsSocket
+	TsSmbLink
+	TsSticky
+	TsGIDSet
+	TsUIDSet
+	TsGrpOwn
+	TsUsrOwn
+	TsModif
+	TsRead
+	TsWrite
+	TsExec
+	TsNoEmpty
+	TsFdTerm
+	TsEmpStr
+	TsNempStr
+	TsOptSet
+	TsVarSet
+	TsRefVar
+	TsNot = UnTestOperator(exclMark)
+)
+
+type BinTestOperator token
+
+const (
+	TsReMatch = BinTestOperator(tsReMatch) + iota
+	TsNewer
+	TsOlder
+	TsDevIno
+	TsEql
+	TsNeq
+	TsLeq
+	TsGeq
+	TsLss
+	TsGtr
+	AndTest = BinTestOperator(andAnd)
+	OrTest  = BinTestOperator(orOr)
+	// TODO(mvdan): == and != are pattern matches; use more
+	// appropriate names like TsMatch and TsNoMatch in 2.0
+	TsEqual  = BinTestOperator(equal)
+	TsNequal = BinTestOperator(nequal)
+	TsBefore = BinTestOperator(rdrIn)
+	TsAfter  = BinTestOperator(rdrOut)
+	// Deprecated: now parses as TsEqual
+	TsAssgn = BinTestOperator(assgn) // TODO(mvdan): remove in 2.0
+)
+
+func (o RedirOperator) String() string   { return token(o).String() }
+func (o ProcOperator) String() string    { return token(o).String() }
+func (o GlobOperator) String() string    { return token(o).String() }
+func (o BinCmdOperator) String() string  { return token(o).String() }
+func (o CaseOperator) String() string    { return token(o).String() }
+func (o ParExpOperator) String() string  { return token(o).String() }
+func (o UnAritOperator) String() string  { return token(o).String() }
+func (o BinAritOperator) String() string { return token(o).String() }
+func (o UnTestOperator) String() string  { return token(o).String() }
+func (o BinTestOperator) String() string { return token(o).String() }

vendor/github.com/mvdan/sh/syntax/walk.go

@@ -0,0 +1,184 @@
+// Copyright (c) 2016, Daniel Martí <mvdan@mvdan.cc>
+// See LICENSE for licensing information
+
+package syntax
+
+import "fmt"
+
+func walkStmts(stmts []*Stmt, f func(Node) bool) {
+	for _, s := range stmts {
+		Walk(s, f)
+	}
+}
+
+func walkWords(words []*Word, f func(Node) bool) {
+	for _, w := range words {
+		Walk(w, f)
+	}
+}
+
+// Walk traverses an AST in depth-first order: It starts by calling
+// f(node); node must not be nil. If f returns true, Walk invokes f
+// recursively for each of the non-nil children of node, followed by
+// f(nil).
+func Walk(node Node, f func(Node) bool) {
+	if !f(node) {
+		return
+	}
+
+	switch x := node.(type) {
+	case *File:
+		walkStmts(x.Stmts, f)
+	case *Stmt:
+		if x.Cmd != nil {
+			Walk(x.Cmd, f)
+		}
+		for _, a := range x.Assigns {
+			Walk(a, f)
+		}
+		for _, r := range x.Redirs {
+			Walk(r, f)
+		}
+	case *Assign:
+		if x.Name != nil {
+			Walk(x.Name, f)
+		}
+		if x.Value != nil {
+			Walk(x.Value, f)
+		}
+	case *Redirect:
+		if x.N != nil {
+			Walk(x.N, f)
+		}
+		Walk(x.Word, f)
+		if x.Hdoc != nil {
+			Walk(x.Hdoc, f)
+		}
+	case *CallExpr:
+		walkWords(x.Args, f)
+	case *Subshell:
+		walkStmts(x.Stmts, f)
+	case *Block:
+		walkStmts(x.Stmts, f)
+	case *IfClause:
+		walkStmts(x.CondStmts, f)
+		walkStmts(x.ThenStmts, f)
+		for _, elif := range x.Elifs {
+			walkStmts(elif.CondStmts, f)
+			walkStmts(elif.ThenStmts, f)
+		}
+		walkStmts(x.ElseStmts, f)
+	case *WhileClause:
+		walkStmts(x.CondStmts, f)
+		walkStmts(x.DoStmts, f)
+	case *UntilClause:
+		walkStmts(x.CondStmts, f)
+		walkStmts(x.DoStmts, f)
+	case *ForClause:
+		Walk(x.Loop, f)
+		walkStmts(x.DoStmts, f)
+	case *WordIter:
+		Walk(x.Name, f)
+		walkWords(x.List, f)
+	case *CStyleLoop:
+		if x.Init != nil {
+			Walk(x.Init, f)
+		}
+		if x.Cond != nil {
+			Walk(x.Cond, f)
+		}
+		if x.Post != nil {
+			Walk(x.Post, f)
+		}
+	case *BinaryCmd:
+		Walk(x.X, f)
+		Walk(x.Y, f)
+	case *FuncDecl:
+		Walk(x.Name, f)
+		Walk(x.Body, f)
+	case *Word:
+		for _, wp := range x.Parts {
+			Walk(wp, f)
+		}
+	case *Lit:
+	case *SglQuoted:
+	case *DblQuoted:
+		for _, wp := range x.Parts {
+			Walk(wp, f)
+		}
+	case *CmdSubst:
+		walkStmts(x.Stmts, f)
+	case *ParamExp:
+		if x.Param != nil {
+			Walk(x.Param, f)
+		}
+		if x.Ind != nil {
+			Walk(x.Ind.Expr, f)
+		}
+		if x.Repl != nil {
+			Walk(x.Repl.Orig, f)
+			Walk(x.Repl.With, f)
+		}
+		if x.Exp != nil {
+			Walk(x.Exp.Word, f)
+		}
+	case *ArithmExp:
+		if x.X != nil {
+			Walk(x.X, f)
+		}
+	case *ArithmCmd:
+		if x.X != nil {
+			Walk(x.X, f)
+		}
+	case *BinaryArithm:
+		Walk(x.X, f)
+		Walk(x.Y, f)
+	case *BinaryTest:
+		Walk(x.X, f)
+		Walk(x.Y, f)
+	case *UnaryArithm:
+		Walk(x.X, f)
+	case *UnaryTest:
+		Walk(x.X, f)
+	case *ParenArithm:
+		Walk(x.X, f)
+	case *ParenTest:
+		Walk(x.X, f)
+	case *CaseClause:
+		Walk(x.Word, f)
+		for _, pl := range x.List {
+			walkWords(pl.Patterns, f)
+			walkStmts(pl.Stmts, f)
+		}
+	case *TestClause:
+		Walk(x.X, f)
+	case *DeclClause:
+		walkWords(x.Opts, f)
+		for _, a := range x.Assigns {
+			Walk(a, f)
+		}
+	case *ArrayExpr:
+		walkWords(x.List, f)
+	case *ExtGlob:
+		Walk(x.Pattern, f)
+	case *ProcSubst:
+		walkStmts(x.Stmts, f)
+	case *EvalClause:
+		if x.Stmt != nil {
+			Walk(x.Stmt, f)
+		}
+	case *CoprocClause:
+		if x.Name != nil {
+			Walk(x.Name, f)
+		}
+		Walk(x.Stmt, f)
+	case *LetClause:
+		for _, expr := range x.Exprs {
+			Walk(expr, f)
+		}
+	default:
+		panic(fmt.Sprintf("syntax.Walk: unexpected node type %T", x))
+	}
+
+	f(nil)
+}

vendor/github.com/satori/go.uuid/LICENSE

@@ -0,0 +1,20 @@
+Copyright (C) 2013-2016 by Maxim Bublis <b@codemonkey.ru>
+
+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/satori/go.uuid/README.md

@@ -0,0 +1,65 @@
+# UUID package for Go language
+
+[![Build Status](https://travis-ci.org/satori/go.uuid.png?branch=master)](https://travis-ci.org/satori/go.uuid)
+[![Coverage Status](https://coveralls.io/repos/github/satori/go.uuid/badge.svg?branch=master)](https://coveralls.io/github/satori/go.uuid)
+[![GoDoc](http://godoc.org/github.com/satori/go.uuid?status.png)](http://godoc.org/github.com/satori/go.uuid)
+
+This package provides pure Go implementation of Universally Unique Identifier (UUID). Supported both creation and parsing of UUIDs.
+
+With 100% test coverage and benchmarks out of box.
+
+Supported versions:
+* Version 1, based on timestamp and MAC address (RFC 4122)
+* Version 2, based on timestamp, MAC address and POSIX UID/GID (DCE 1.1)
+* Version 3, based on MD5 hashing (RFC 4122)
+* Version 4, based on random numbers (RFC 4122)
+* Version 5, based on SHA-1 hashing (RFC 4122)
+
+## Installation
+
+Use the `go` command:
+
+	$ go get github.com/satori/go.uuid
+
+## Requirements
+
+UUID package requires Go >= 1.2.
+
+## Example
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/satori/go.uuid"
+)
+
+func main() {
+	// Creating UUID Version 4
+	u1 := uuid.NewV4()
+	fmt.Printf("UUIDv4: %s\n", u1)
+
+	// Parsing UUID from string input
+	u2, err := uuid.FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+	if err != nil {
+		fmt.Printf("Something gone wrong: %s", err)
+	}
+	fmt.Printf("Successfully parsed: %s", u2)
+}
+```
+
+## Documentation
+
+[Documentation](http://godoc.org/github.com/satori/go.uuid) is hosted at GoDoc project.
+
+## Links
+* [RFC 4122](http://tools.ietf.org/html/rfc4122)
+* [DCE 1.1: Authentication and Security Services](http://pubs.opengroup.org/onlinepubs/9696989899/chap5.htm#tagcjh_08_02_01_01)
+
+## Copyright
+
+Copyright (C) 2013-2016 by Maxim Bublis <b@codemonkey.ru>.
+
+UUID package released under MIT License.
+See [LICENSE](https://github.com/satori/go.uuid/blob/master/LICENSE) for details.

vendor/github.com/satori/go.uuid/uuid.go

@@ -0,0 +1,481 @@
+// Copyright (C) 2013-2015 by Maxim Bublis <b@codemonkey.ru>
+//
+// 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.
+
+// Package uuid provides implementation of Universally Unique Identifier (UUID).
+// Supported versions are 1, 3, 4 and 5 (as specified in RFC 4122) and
+// version 2 (as specified in DCE 1.1).
+package uuid
+
+import (
+	"bytes"
+	"crypto/md5"
+	"crypto/rand"
+	"crypto/sha1"
+	"database/sql/driver"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"hash"
+	"net"
+	"os"
+	"sync"
+	"time"
+)
+
+// UUID layout variants.
+const (
+	VariantNCS = iota
+	VariantRFC4122
+	VariantMicrosoft
+	VariantFuture
+)
+
+// UUID DCE domains.
+const (
+	DomainPerson = iota
+	DomainGroup
+	DomainOrg
+)
+
+// Difference in 100-nanosecond intervals between
+// UUID epoch (October 15, 1582) and Unix epoch (January 1, 1970).
+const epochStart = 122192928000000000
+
+// Used in string method conversion
+const dash byte = '-'
+
+// UUID v1/v2 storage.
+var (
+	storageMutex  sync.Mutex
+	storageOnce   sync.Once
+	epochFunc     = unixTimeFunc
+	clockSequence uint16
+	lastTime      uint64
+	hardwareAddr  [6]byte
+	posixUID      = uint32(os.Getuid())
+	posixGID      = uint32(os.Getgid())
+)
+
+// String parse helpers.
+var (
+	urnPrefix  = []byte("urn:uuid:")
+	byteGroups = []int{8, 4, 4, 4, 12}
+)
+
+func initClockSequence() {
+	buf := make([]byte, 2)
+	safeRandom(buf)
+	clockSequence = binary.BigEndian.Uint16(buf)
+}
+
+func initHardwareAddr() {
+	interfaces, err := net.Interfaces()
+	if err == nil {
+		for _, iface := range interfaces {
+			if len(iface.HardwareAddr) >= 6 {
+				copy(hardwareAddr[:], iface.HardwareAddr)
+				return
+			}
+		}
+	}
+
+	// Initialize hardwareAddr randomly in case
+	// of real network interfaces absence
+	safeRandom(hardwareAddr[:])
+
+	// Set multicast bit as recommended in RFC 4122
+	hardwareAddr[0] |= 0x01
+}
+
+func initStorage() {
+	initClockSequence()
+	initHardwareAddr()
+}
+
+func safeRandom(dest []byte) {
+	if _, err := rand.Read(dest); err != nil {
+		panic(err)
+	}
+}
+
+// Returns difference in 100-nanosecond intervals between
+// UUID epoch (October 15, 1582) and current time.
+// This is default epoch calculation function.
+func unixTimeFunc() uint64 {
+	return epochStart + uint64(time.Now().UnixNano()/100)
+}
+
+// UUID representation compliant with specification
+// described in RFC 4122.
+type UUID [16]byte
+
+// NullUUID can be used with the standard sql package to represent a
+// UUID value that can be NULL in the database
+type NullUUID struct {
+	UUID  UUID
+	Valid bool
+}
+
+// The nil UUID is special form of UUID that is specified to have all
+// 128 bits set to zero.
+var Nil = UUID{}
+
+// Predefined namespace UUIDs.
+var (
+	NamespaceDNS, _  = FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+	NamespaceURL, _  = FromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
+	NamespaceOID, _  = FromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8")
+	NamespaceX500, _ = FromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8")
+)
+
+// And returns result of binary AND of two UUIDs.
+func And(u1 UUID, u2 UUID) UUID {
+	u := UUID{}
+	for i := 0; i < 16; i++ {
+		u[i] = u1[i] & u2[i]
+	}
+	return u
+}
+
+// Or returns result of binary OR of two UUIDs.
+func Or(u1 UUID, u2 UUID) UUID {
+	u := UUID{}
+	for i := 0; i < 16; i++ {
+		u[i] = u1[i] | u2[i]
+	}
+	return u
+}
+
+// Equal returns true if u1 and u2 equals, otherwise returns false.
+func Equal(u1 UUID, u2 UUID) bool {
+	return bytes.Equal(u1[:], u2[:])
+}
+
+// Version returns algorithm version used to generate UUID.
+func (u UUID) Version() uint {
+	return uint(u[6] >> 4)
+}
+
+// Variant returns UUID layout variant.
+func (u UUID) Variant() uint {
+	switch {
+	case (u[8] & 0x80) == 0x00:
+		return VariantNCS
+	case (u[8]&0xc0)|0x80 == 0x80:
+		return VariantRFC4122
+	case (u[8]&0xe0)|0xc0 == 0xc0:
+		return VariantMicrosoft
+	}
+	return VariantFuture
+}
+
+// Bytes returns bytes slice representation of UUID.
+func (u UUID) Bytes() []byte {
+	return u[:]
+}
+
+// Returns canonical string representation of UUID:
+// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+func (u UUID) String() string {
+	buf := make([]byte, 36)
+
+	hex.Encode(buf[0:8], u[0:4])
+	buf[8] = dash
+	hex.Encode(buf[9:13], u[4:6])
+	buf[13] = dash
+	hex.Encode(buf[14:18], u[6:8])
+	buf[18] = dash
+	hex.Encode(buf[19:23], u[8:10])
+	buf[23] = dash
+	hex.Encode(buf[24:], u[10:])
+
+	return string(buf)
+}
+
+// SetVersion sets version bits.
+func (u *UUID) SetVersion(v byte) {
+	u[6] = (u[6] & 0x0f) | (v << 4)
+}
+
+// SetVariant sets variant bits as described in RFC 4122.
+func (u *UUID) SetVariant() {
+	u[8] = (u[8] & 0xbf) | 0x80
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+// The encoding is the same as returned by String.
+func (u UUID) MarshalText() (text []byte, err error) {
+	text = []byte(u.String())
+	return
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// Following formats are supported:
+// "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
+// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+func (u *UUID) UnmarshalText(text []byte) (err error) {
+	if len(text) < 32 {
+		err = fmt.Errorf("uuid: UUID string too short: %s", text)
+		return
+	}
+
+	t := text[:]
+	braced := false
+
+	if bytes.Equal(t[:9], urnPrefix) {
+		t = t[9:]
+	} else if t[0] == '{' {
+		braced = true
+		t = t[1:]
+	}
+
+	b := u[:]
+
+	for i, byteGroup := range byteGroups {
+		if i > 0 {
+			if t[0] != '-' {
+				err = fmt.Errorf("uuid: invalid string format")
+				return
+			}
+			t = t[1:]
+		}
+
+		if len(t) < byteGroup {
+			err = fmt.Errorf("uuid: UUID string too short: %s", text)
+			return
+		}
+
+		if i == 4 && len(t) > byteGroup &&
+			((braced && t[byteGroup] != '}') || len(t[byteGroup:]) > 1 || !braced) {
+			err = fmt.Errorf("uuid: UUID string too long: %s", text)
+			return
+		}
+
+		_, err = hex.Decode(b[:byteGroup/2], t[:byteGroup])
+		if err != nil {
+			return
+		}
+
+		t = t[byteGroup:]
+		b = b[byteGroup/2:]
+	}
+
+	return
+}
+
+// MarshalBinary implements the encoding.BinaryMarshaler interface.
+func (u UUID) MarshalBinary() (data []byte, err error) {
+	data = u.Bytes()
+	return
+}
+
+// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
+// It will return error if the slice isn't 16 bytes long.
+func (u *UUID) UnmarshalBinary(data []byte) (err error) {
+	if len(data) != 16 {
+		err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
+		return
+	}
+	copy(u[:], data)
+
+	return
+}
+
+// Value implements the driver.Valuer interface.
+func (u UUID) Value() (driver.Value, error) {
+	return u.String(), nil
+}
+
+// Scan implements the sql.Scanner interface.
+// A 16-byte slice is handled by UnmarshalBinary, while
+// a longer byte slice or a string is handled by UnmarshalText.
+func (u *UUID) Scan(src interface{}) error {
+	switch src := src.(type) {
+	case []byte:
+		if len(src) == 16 {
+			return u.UnmarshalBinary(src)
+		}
+		return u.UnmarshalText(src)
+
+	case string:
+		return u.UnmarshalText([]byte(src))
+	}
+
+	return fmt.Errorf("uuid: cannot convert %T to UUID", src)
+}
+
+// Value implements the driver.Valuer interface.
+func (u NullUUID) Value() (driver.Value, error) {
+	if !u.Valid {
+		return nil, nil
+	}
+	// Delegate to UUID Value function
+	return u.UUID.Value()
+}
+
+// Scan implements the sql.Scanner interface.
+func (u *NullUUID) Scan(src interface{}) error {
+	if src == nil {
+		u.UUID, u.Valid = Nil, false
+		return nil
+	}
+
+	// Delegate to UUID Scan function
+	u.Valid = true
+	return u.UUID.Scan(src)
+}
+
+// FromBytes returns UUID converted from raw byte slice input.
+// It will return error if the slice isn't 16 bytes long.
+func FromBytes(input []byte) (u UUID, err error) {
+	err = u.UnmarshalBinary(input)
+	return
+}
+
+// FromBytesOrNil returns UUID converted from raw byte slice input.
+// Same behavior as FromBytes, but returns a Nil UUID on error.
+func FromBytesOrNil(input []byte) UUID {
+	uuid, err := FromBytes(input)
+	if err != nil {
+		return Nil
+	}
+	return uuid
+}
+
+// FromString returns UUID parsed from string input.
+// Input is expected in a form accepted by UnmarshalText.
+func FromString(input string) (u UUID, err error) {
+	err = u.UnmarshalText([]byte(input))
+	return
+}
+
+// FromStringOrNil returns UUID parsed from string input.
+// Same behavior as FromString, but returns a Nil UUID on error.
+func FromStringOrNil(input string) UUID {
+	uuid, err := FromString(input)
+	if err != nil {
+		return Nil
+	}
+	return uuid
+}
+
+// Returns UUID v1/v2 storage state.
+// Returns epoch timestamp, clock sequence, and hardware address.
+func getStorage() (uint64, uint16, []byte) {
+	storageOnce.Do(initStorage)
+
+	storageMutex.Lock()
+	defer storageMutex.Unlock()
+
+	timeNow := epochFunc()
+	// Clock changed backwards since last UUID generation.
+	// Should increase clock sequence.
+	if timeNow <= lastTime {
+		clockSequence++
+	}
+	lastTime = timeNow
+
+	return timeNow, clockSequence, hardwareAddr[:]
+}
+
+// NewV1 returns UUID based on current timestamp and MAC address.
+func NewV1() UUID {
+	u := UUID{}
+
+	timeNow, clockSeq, hardwareAddr := getStorage()
+
+	binary.BigEndian.PutUint32(u[0:], uint32(timeNow))
+	binary.BigEndian.PutUint16(u[4:], uint16(timeNow>>32))
+	binary.BigEndian.PutUint16(u[6:], uint16(timeNow>>48))
+	binary.BigEndian.PutUint16(u[8:], clockSeq)
+
+	copy(u[10:], hardwareAddr)
+
+	u.SetVersion(1)
+	u.SetVariant()
+
+	return u
+}
+
+// NewV2 returns DCE Security UUID based on POSIX UID/GID.
+func NewV2(domain byte) UUID {
+	u := UUID{}
+
+	timeNow, clockSeq, hardwareAddr := getStorage()
+
+	switch domain {
+	case DomainPerson:
+		binary.BigEndian.PutUint32(u[0:], posixUID)
+	case DomainGroup:
+		binary.BigEndian.PutUint32(u[0:], posixGID)
+	}
+
+	binary.BigEndian.PutUint16(u[4:], uint16(timeNow>>32))
+	binary.BigEndian.PutUint16(u[6:], uint16(timeNow>>48))
+	binary.BigEndian.PutUint16(u[8:], clockSeq)
+	u[9] = domain
+
+	copy(u[10:], hardwareAddr)
+
+	u.SetVersion(2)
+	u.SetVariant()
+
+	return u
+}
+
+// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
+func NewV3(ns UUID, name string) UUID {
+	u := newFromHash(md5.New(), ns, name)
+	u.SetVersion(3)
+	u.SetVariant()
+
+	return u
+}
+
+// NewV4 returns random generated UUID.
+func NewV4() UUID {
+	u := UUID{}
+	safeRandom(u[:])
+	u.SetVersion(4)
+	u.SetVariant()
+
+	return u
+}
+
+// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
+func NewV5(ns UUID, name string) UUID {
+	u := newFromHash(sha1.New(), ns, name)
+	u.SetVersion(5)
+	u.SetVariant()
+
+	return u
+}
+
+// Returns UUID based on hashing of namespace UUID and name.
+func newFromHash(h hash.Hash, ns UUID, name string) UUID {
+	u := UUID{}
+	h.Write(ns[:])
+	h.Write([]byte(name))
+	copy(u[:], h.Sum(nil))
+
+	return u
+}

vendor/golang.org/x/crypto/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. 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.
+   * Neither the name of Google Inc. nor the names of its
+contributors may 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
+OWNER 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/golang.org/x/crypto/PATENTS

@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.

vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go

@@ -0,0 +1,77 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package pbkdf2 implements the key derivation function PBKDF2 as defined in RFC
+2898 / PKCS #5 v2.0.
+
+A key derivation function is useful when encrypting data based on a password
+or any other not-fully-random data. It uses a pseudorandom function to derive
+a secure encryption key based on the password.
+
+While v2.0 of the standard defines only one pseudorandom function to use,
+HMAC-SHA1, the drafted v2.1 specification allows use of all five FIPS Approved
+Hash Functions SHA-1, SHA-224, SHA-256, SHA-384 and SHA-512 for HMAC. To
+choose, you can pass the `New` functions from the different SHA packages to
+pbkdf2.Key.
+*/
+package pbkdf2 // import "golang.org/x/crypto/pbkdf2"
+
+import (
+	"crypto/hmac"
+	"hash"
+)
+
+// Key derives a key from the password, salt and iteration count, returning a
+// []byte of length keylen that can be used as cryptographic key. The key is
+// derived based on the method described as PBKDF2 with the HMAC variant using
+// the supplied hash function.
+//
+// For example, to use a HMAC-SHA-1 based PBKDF2 key derivation function, you
+// can get a derived key for e.g. AES-256 (which needs a 32-byte key) by
+// doing:
+//
+// 	dk := pbkdf2.Key([]byte("some password"), salt, 4096, 32, sha1.New)
+//
+// Remember to get a good random salt. At least 8 bytes is recommended by the
+// RFC.
+//
+// Using a higher iteration count will increase the cost of an exhaustive
+// search but will also make derivation proportionally slower.
+func Key(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte {
+	prf := hmac.New(h, password)
+	hashLen := prf.Size()
+	numBlocks := (keyLen + hashLen - 1) / hashLen
+
+	var buf [4]byte
+	dk := make([]byte, 0, numBlocks*hashLen)
+	U := make([]byte, hashLen)
+	for block := 1; block <= numBlocks; block++ {
+		// N.B.: || means concatenation, ^ means XOR
+		// for each block T_i = U_1 ^ U_2 ^ ... ^ U_iter
+		// U_1 = PRF(password, salt || uint(i))
+		prf.Reset()
+		prf.Write(salt)
+		buf[0] = byte(block >> 24)
+		buf[1] = byte(block >> 16)
+		buf[2] = byte(block >> 8)
+		buf[3] = byte(block)
+		prf.Write(buf[:4])
+		dk = prf.Sum(dk)
+		T := dk[len(dk)-hashLen:]
+		copy(U, T)
+
+		// U_n = PRF(password, U_(n-1))
+		for n := 2; n <= iter; n++ {
+			prf.Reset()
+			prf.Write(U)
+			U = U[:0]
+			U = prf.Sum(U)
+			for x := range U {
+				T[x] ^= U[x]
+			}
+		}
+	}
+	return dk[:keyLen]
+}

vendor/golang.org/x/crypto/scrypt/scrypt.go

@@ -0,0 +1,243 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package scrypt implements the scrypt key derivation function as defined in
+// Colin Percival's paper "Stronger Key Derivation via Sequential Memory-Hard
+// Functions" (http://www.tarsnap.com/scrypt/scrypt.pdf).
+package scrypt // import "golang.org/x/crypto/scrypt"
+
+import (
+	"crypto/sha256"
+	"errors"
+
+	"golang.org/x/crypto/pbkdf2"
+)
+
+const maxInt = int(^uint(0) >> 1)
+
+// blockCopy copies n numbers from src into dst.
+func blockCopy(dst, src []uint32, n int) {
+	copy(dst, src[:n])
+}
+
+// blockXOR XORs numbers from dst with n numbers from src.
+func blockXOR(dst, src []uint32, n int) {
+	for i, v := range src[:n] {
+		dst[i] ^= v
+	}
+}
+
+// salsaXOR applies Salsa20/8 to the XOR of 16 numbers from tmp and in,
+// and puts the result into both both tmp and out.
+func salsaXOR(tmp *[16]uint32, in, out []uint32) {
+	w0 := tmp[0] ^ in[0]
+	w1 := tmp[1] ^ in[1]
+	w2 := tmp[2] ^ in[2]
+	w3 := tmp[3] ^ in[3]
+	w4 := tmp[4] ^ in[4]
+	w5 := tmp[5] ^ in[5]
+	w6 := tmp[6] ^ in[6]
+	w7 := tmp[7] ^ in[7]
+	w8 := tmp[8] ^ in[8]
+	w9 := tmp[9] ^ in[9]
+	w10 := tmp[10] ^ in[10]
+	w11 := tmp[11] ^ in[11]
+	w12 := tmp[12] ^ in[12]
+	w13 := tmp[13] ^ in[13]
+	w14 := tmp[14] ^ in[14]
+	w15 := tmp[15] ^ in[15]
+
+	x0, x1, x2, x3, x4, x5, x6, x7, x8 := w0, w1, w2, w3, w4, w5, w6, w7, w8
+	x9, x10, x11, x12, x13, x14, x15 := w9, w10, w11, w12, w13, w14, w15
+
+	for i := 0; i < 8; i += 2 {
+		u := x0 + x12
+		x4 ^= u<<7 | u>>(32-7)
+		u = x4 + x0
+		x8 ^= u<<9 | u>>(32-9)
+		u = x8 + x4
+		x12 ^= u<<13 | u>>(32-13)
+		u = x12 + x8
+		x0 ^= u<<18 | u>>(32-18)
+
+		u = x5 + x1
+		x9 ^= u<<7 | u>>(32-7)
+		u = x9 + x5
+		x13 ^= u<<9 | u>>(32-9)
+		u = x13 + x9
+		x1 ^= u<<13 | u>>(32-13)
+		u = x1 + x13
+		x5 ^= u<<18 | u>>(32-18)
+
+		u = x10 + x6
+		x14 ^= u<<7 | u>>(32-7)
+		u = x14 + x10
+		x2 ^= u<<9 | u>>(32-9)
+		u = x2 + x14
+		x6 ^= u<<13 | u>>(32-13)
+		u = x6 + x2
+		x10 ^= u<<18 | u>>(32-18)
+
+		u = x15 + x11
+		x3 ^= u<<7 | u>>(32-7)
+		u = x3 + x15
+		x7 ^= u<<9 | u>>(32-9)
+		u = x7 + x3
+		x11 ^= u<<13 | u>>(32-13)
+		u = x11 + x7
+		x15 ^= u<<18 | u>>(32-18)
+
+		u = x0 + x3
+		x1 ^= u<<7 | u>>(32-7)
+		u = x1 + x0
+		x2 ^= u<<9 | u>>(32-9)
+		u = x2 + x1
+		x3 ^= u<<13 | u>>(32-13)
+		u = x3 + x2
+		x0 ^= u<<18 | u>>(32-18)
+
+		u = x5 + x4
+		x6 ^= u<<7 | u>>(32-7)
+		u = x6 + x5
+		x7 ^= u<<9 | u>>(32-9)
+		u = x7 + x6
+		x4 ^= u<<13 | u>>(32-13)
+		u = x4 + x7
+		x5 ^= u<<18 | u>>(32-18)
+
+		u = x10 + x9
+		x11 ^= u<<7 | u>>(32-7)
+		u = x11 + x10
+		x8 ^= u<<9 | u>>(32-9)
+		u = x8 + x11
+		x9 ^= u<<13 | u>>(32-13)
+		u = x9 + x8
+		x10 ^= u<<18 | u>>(32-18)
+
+		u = x15 + x14
+		x12 ^= u<<7 | u>>(32-7)
+		u = x12 + x15
+		x13 ^= u<<9 | u>>(32-9)
+		u = x13 + x12
+		x14 ^= u<<13 | u>>(32-13)
+		u = x14 + x13
+		x15 ^= u<<18 | u>>(32-18)
+	}
+	x0 += w0
+	x1 += w1
+	x2 += w2
+	x3 += w3
+	x4 += w4
+	x5 += w5
+	x6 += w6
+	x7 += w7
+	x8 += w8
+	x9 += w9
+	x10 += w10
+	x11 += w11
+	x12 += w12
+	x13 += w13
+	x14 += w14
+	x15 += w15
+
+	out[0], tmp[0] = x0, x0
+	out[1], tmp[1] = x1, x1
+	out[2], tmp[2] = x2, x2
+	out[3], tmp[3] = x3, x3
+	out[4], tmp[4] = x4, x4
+	out[5], tmp[5] = x5, x5
+	out[6], tmp[6] = x6, x6
+	out[7], tmp[7] = x7, x7
+	out[8], tmp[8] = x8, x8
+	out[9], tmp[9] = x9, x9
+	out[10], tmp[10] = x10, x10
+	out[11], tmp[11] = x11, x11
+	out[12], tmp[12] = x12, x12
+	out[13], tmp[13] = x13, x13
+	out[14], tmp[14] = x14, x14
+	out[15], tmp[15] = x15, x15
+}
+
+func blockMix(tmp *[16]uint32, in, out []uint32, r int) {
+	blockCopy(tmp[:], in[(2*r-1)*16:], 16)
+	for i := 0; i < 2*r; i += 2 {
+		salsaXOR(tmp, in[i*16:], out[i*8:])
+		salsaXOR(tmp, in[i*16+16:], out[i*8+r*16:])
+	}
+}
+
+func integer(b []uint32, r int) uint64 {
+	j := (2*r - 1) * 16
+	return uint64(b[j]) | uint64(b[j+1])<<32
+}
+
+func smix(b []byte, r, N int, v, xy []uint32) {
+	var tmp [16]uint32
+	x := xy
+	y := xy[32*r:]
+
+	j := 0
+	for i := 0; i < 32*r; i++ {
+		x[i] = uint32(b[j]) | uint32(b[j+1])<<8 | uint32(b[j+2])<<16 | uint32(b[j+3])<<24
+		j += 4
+	}
+	for i := 0; i < N; i += 2 {
+		blockCopy(v[i*(32*r):], x, 32*r)
+		blockMix(&tmp, x, y, r)
+
+		blockCopy(v[(i+1)*(32*r):], y, 32*r)
+		blockMix(&tmp, y, x, r)
+	}
+	for i := 0; i < N; i += 2 {
+		j := int(integer(x, r) & uint64(N-1))
+		blockXOR(x, v[j*(32*r):], 32*r)
+		blockMix(&tmp, x, y, r)
+
+		j = int(integer(y, r) & uint64(N-1))
+		blockXOR(y, v[j*(32*r):], 32*r)
+		blockMix(&tmp, y, x, r)
+	}
+	j = 0
+	for _, v := range x[:32*r] {
+		b[j+0] = byte(v >> 0)
+		b[j+1] = byte(v >> 8)
+		b[j+2] = byte(v >> 16)
+		b[j+3] = byte(v >> 24)
+		j += 4
+	}
+}
+
+// Key derives a key from the password, salt, and cost parameters, returning
+// a byte slice of length keyLen that can be used as cryptographic key.
+//
+// N is a CPU/memory cost parameter, which must be a power of two greater than 1.
+// r and p must satisfy r * p < 2³⁰. If the parameters do not satisfy the
+// limits, the function returns a nil byte slice and an error.
+//
+// For example, you can get a derived key for e.g. AES-256 (which needs a
+// 32-byte key) by doing:
+//
+//      dk, err := scrypt.Key([]byte("some password"), salt, 16384, 8, 1, 32)
+//
+// The recommended parameters for interactive logins as of 2009 are N=16384,
+// r=8, p=1. They should be increased as memory latency and CPU parallelism
+// increases. Remember to get a good random salt.
+func Key(password, salt []byte, N, r, p, keyLen int) ([]byte, error) {
+	if N <= 1 || N&(N-1) != 0 {
+		return nil, errors.New("scrypt: N must be > 1 and a power of 2")
+	}
+	if uint64(r)*uint64(p) >= 1<<30 || r > maxInt/128/p || r > maxInt/256 || N > maxInt/128/r {
+		return nil, errors.New("scrypt: parameters are too large")
+	}
+
+	xy := make([]uint32, 64*r)
+	v := make([]uint32, 32*N*r)
+	b := pbkdf2.Key(password, salt, 1, p*128*r, sha256.New)
+
+	for i := 0; i < p; i++ {
+		smix(b[i*128*r:], r, N, v, xy)
+	}
+
+	return pbkdf2.Key(password, b, 1, keyLen, sha256.New), nil
+}

vendor/golang.org/x/net/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. 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.
+   * Neither the name of Google Inc. nor the names of its
+contributors may 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
+OWNER 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/golang.org/x/net/PATENTS

@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.

vendor/golang.org/x/net/context/context.go

@@ -0,0 +1,156 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package context defines the Context type, which carries deadlines,
+// cancelation signals, and other request-scoped values across API boundaries
+// and between processes.
+//
+// Incoming requests to a server should create a Context, and outgoing calls to
+// servers should accept a Context. The chain of function calls between must
+// propagate the Context, optionally replacing it with a modified copy created
+// using WithDeadline, WithTimeout, WithCancel, or WithValue.
+//
+// Programs that use Contexts should follow these rules to keep interfaces
+// consistent across packages and enable static analysis tools to check context
+// propagation:
+//
+// Do not store Contexts inside a struct type; instead, pass a Context
+// explicitly to each function that needs it. The Context should be the first
+// parameter, typically named ctx:
+//
+// 	func DoSomething(ctx context.Context, arg Arg) error {
+// 		// ... use ctx ...
+// 	}
+//
+// Do not pass a nil Context, even if a function permits it. Pass context.TODO
+// if you are unsure about which Context to use.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+//
+// The same Context may be passed to functions running in different goroutines;
+// Contexts are safe for simultaneous use by multiple goroutines.
+//
+// See http://blog.golang.org/context for example code for a server that uses
+// Contexts.
+package context // import "golang.org/x/net/context"
+
+import "time"
+
+// A Context carries a deadline, a cancelation signal, and other values across
+// API boundaries.
+//
+// Context's methods may be called by multiple goroutines simultaneously.
+type Context interface {
+	// Deadline returns the time when work done on behalf of this context
+	// should be canceled. Deadline returns ok==false when no deadline is
+	// set. Successive calls to Deadline return the same results.
+	Deadline() (deadline time.Time, ok bool)
+
+	// Done returns a channel that's closed when work done on behalf of this
+	// context should be canceled. Done may return nil if this context can
+	// never be canceled. Successive calls to Done return the same value.
+	//
+	// WithCancel arranges for Done to be closed when cancel is called;
+	// WithDeadline arranges for Done to be closed when the deadline
+	// expires; WithTimeout arranges for Done to be closed when the timeout
+	// elapses.
+	//
+	// Done is provided for use in select statements:
+	//
+	//  // Stream generates values with DoSomething and sends them to out
+	//  // until DoSomething returns an error or ctx.Done is closed.
+	//  func Stream(ctx context.Context, out chan<- Value) error {
+	//  	for {
+	//  		v, err := DoSomething(ctx)
+	//  		if err != nil {
+	//  			return err
+	//  		}
+	//  		select {
+	//  		case <-ctx.Done():
+	//  			return ctx.Err()
+	//  		case out <- v:
+	//  		}
+	//  	}
+	//  }
+	//
+	// See http://blog.golang.org/pipelines for more examples of how to use
+	// a Done channel for cancelation.
+	Done() <-chan struct{}
+
+	// Err returns a non-nil error value after Done is closed. Err returns
+	// Canceled if the context was canceled or DeadlineExceeded if the
+	// context's deadline passed. No other values for Err are defined.
+	// After Done is closed, successive calls to Err return the same value.
+	Err() error
+
+	// Value returns the value associated with this context for key, or nil
+	// if no value is associated with key. Successive calls to Value with
+	// the same key returns the same result.
+	//
+	// Use context values only for request-scoped data that transits
+	// processes and API boundaries, not for passing optional parameters to
+	// functions.
+	//
+	// A key identifies a specific value in a Context. Functions that wish
+	// to store values in Context typically allocate a key in a global
+	// variable then use that key as the argument to context.WithValue and
+	// Context.Value. A key can be any type that supports equality;
+	// packages should define keys as an unexported type to avoid
+	// collisions.
+	//
+	// Packages that define a Context key should provide type-safe accessors
+	// for the values stores using that key:
+	//
+	// 	// Package user defines a User type that's stored in Contexts.
+	// 	package user
+	//
+	// 	import "golang.org/x/net/context"
+	//
+	// 	// User is the type of value stored in the Contexts.
+	// 	type User struct {...}
+	//
+	// 	// key is an unexported type for keys defined in this package.
+	// 	// This prevents collisions with keys defined in other packages.
+	// 	type key int
+	//
+	// 	// userKey is the key for user.User values in Contexts. It is
+	// 	// unexported; clients use user.NewContext and user.FromContext
+	// 	// instead of using this key directly.
+	// 	var userKey key = 0
+	//
+	// 	// NewContext returns a new Context that carries value u.
+	// 	func NewContext(ctx context.Context, u *User) context.Context {
+	// 		return context.WithValue(ctx, userKey, u)
+	// 	}
+	//
+	// 	// FromContext returns the User value stored in ctx, if any.
+	// 	func FromContext(ctx context.Context) (*User, bool) {
+	// 		u, ok := ctx.Value(userKey).(*User)
+	// 		return u, ok
+	// 	}
+	Value(key interface{}) interface{}
+}
+
+// Background returns a non-nil, empty Context. It is never canceled, has no
+// values, and has no deadline. It is typically used by the main function,
+// initialization, and tests, and as the top-level Context for incoming
+// requests.
+func Background() Context {
+	return background
+}
+
+// TODO returns a non-nil, empty Context. Code should use context.TODO when
+// it's unclear which Context to use or it is not yet available (because the
+// surrounding function has not yet been extended to accept a Context
+// parameter).  TODO is recognized by static analysis tools that determine
+// whether Contexts are propagated correctly in a program.
+func TODO() Context {
+	return todo
+}
+
+// A CancelFunc tells an operation to abandon its work.
+// A CancelFunc does not wait for the work to stop.
+// After the first call, subsequent calls to a CancelFunc do nothing.
+type CancelFunc func()

vendor/golang.org/x/net/context/go17.go

@@ -0,0 +1,72 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.7
+
+package context
+
+import (
+	"context" // standard library's context, as of Go 1.7
+	"time"
+)
+
+var (
+	todo       = context.TODO()
+	background = context.Background()
+)
+
+// Canceled is the error returned by Context.Err when the context is canceled.
+var Canceled = context.Canceled
+
+// DeadlineExceeded is the error returned by Context.Err when the context's
+// deadline passes.
+var DeadlineExceeded = context.DeadlineExceeded
+
+// WithCancel returns a copy of parent with a new Done channel. The returned
+// context's Done channel is closed when the returned cancel function is called
+// or when the parent context's Done channel is closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
+	ctx, f := context.WithCancel(parent)
+	return ctx, CancelFunc(f)
+}
+
+// WithDeadline returns a copy of the parent context with the deadline adjusted
+// to be no later than d. If the parent's deadline is already earlier than d,
+// WithDeadline(parent, d) is semantically equivalent to parent. The returned
+// context's Done channel is closed when the deadline expires, when the returned
+// cancel function is called, or when the parent context's Done channel is
+// closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
+	ctx, f := context.WithDeadline(parent, deadline)
+	return ctx, CancelFunc(f)
+}
+
+// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete:
+//
+// 	func slowOperationWithTimeout(ctx context.Context) (Result, error) {
+// 		ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
+// 		defer cancel()  // releases resources if slowOperation completes before timeout elapses
+// 		return slowOperation(ctx)
+// 	}
+func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
+	return WithDeadline(parent, time.Now().Add(timeout))
+}
+
+// WithValue returns a copy of parent in which the value associated with key is
+// val.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+func WithValue(parent Context, key interface{}, val interface{}) Context {
+	return context.WithValue(parent, key, val)
+}

vendor/golang.org/x/net/context/pre_go17.go

@@ -0,0 +1,300 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.7
+
+package context
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+)
+
+// An emptyCtx is never canceled, has no values, and has no deadline. It is not
+// struct{}, since vars of this type must have distinct addresses.
+type emptyCtx int
+
+func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
+	return
+}
+
+func (*emptyCtx) Done() <-chan struct{} {
+	return nil
+}
+
+func (*emptyCtx) Err() error {
+	return nil
+}
+
+func (*emptyCtx) Value(key interface{}) interface{} {
+	return nil
+}
+
+func (e *emptyCtx) String() string {
+	switch e {
+	case background:
+		return "context.Background"
+	case todo:
+		return "context.TODO"
+	}
+	return "unknown empty Context"
+}
+
+var (
+	background = new(emptyCtx)
+	todo       = new(emptyCtx)
+)
+
+// Canceled is the error returned by Context.Err when the context is canceled.
+var Canceled = errors.New("context canceled")
+
+// DeadlineExceeded is the error returned by Context.Err when the context's
+// deadline passes.
+var DeadlineExceeded = errors.New("context deadline exceeded")
+
+// WithCancel returns a copy of parent with a new Done channel. The returned
+// context's Done channel is closed when the returned cancel function is called
+// or when the parent context's Done channel is closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
+	c := newCancelCtx(parent)
+	propagateCancel(parent, c)
+	return c, func() { c.cancel(true, Canceled) }
+}
+
+// newCancelCtx returns an initialized cancelCtx.
+func newCancelCtx(parent Context) *cancelCtx {
+	return &cancelCtx{
+		Context: parent,
+		done:    make(chan struct{}),
+	}
+}
+
+// propagateCancel arranges for child to be canceled when parent is.
+func propagateCancel(parent Context, child canceler) {
+	if parent.Done() == nil {
+		return // parent is never canceled
+	}
+	if p, ok := parentCancelCtx(parent); ok {
+		p.mu.Lock()
+		if p.err != nil {
+			// parent has already been canceled
+			child.cancel(false, p.err)
+		} else {
+			if p.children == nil {
+				p.children = make(map[canceler]bool)
+			}
+			p.children[child] = true
+		}
+		p.mu.Unlock()
+	} else {
+		go func() {
+			select {
+			case <-parent.Done():
+				child.cancel(false, parent.Err())
+			case <-child.Done():
+			}
+		}()
+	}
+}
+
+// parentCancelCtx follows a chain of parent references until it finds a
+// *cancelCtx. This function understands how each of the concrete types in this
+// package represents its parent.
+func parentCancelCtx(parent Context) (*cancelCtx, bool) {
+	for {
+		switch c := parent.(type) {
+		case *cancelCtx:
+			return c, true
+		case *timerCtx:
+			return c.cancelCtx, true
+		case *valueCtx:
+			parent = c.Context
+		default:
+			return nil, false
+		}
+	}
+}
+
+// removeChild removes a context from its parent.
+func removeChild(parent Context, child canceler) {
+	p, ok := parentCancelCtx(parent)
+	if !ok {
+		return
+	}
+	p.mu.Lock()
+	if p.children != nil {
+		delete(p.children, child)
+	}
+	p.mu.Unlock()
+}
+
+// A canceler is a context type that can be canceled directly. The
+// implementations are *cancelCtx and *timerCtx.
+type canceler interface {
+	cancel(removeFromParent bool, err error)
+	Done() <-chan struct{}
+}
+
+// A cancelCtx can be canceled. When canceled, it also cancels any children
+// that implement canceler.
+type cancelCtx struct {
+	Context
+
+	done chan struct{} // closed by the first cancel call.
+
+	mu       sync.Mutex
+	children map[canceler]bool // set to nil by the first cancel call
+	err      error             // set to non-nil by the first cancel call
+}
+
+func (c *cancelCtx) Done() <-chan struct{} {
+	return c.done
+}
+
+func (c *cancelCtx) Err() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.err
+}
+
+func (c *cancelCtx) String() string {
+	return fmt.Sprintf("%v.WithCancel", c.Context)
+}
+
+// cancel closes c.done, cancels each of c's children, and, if
+// removeFromParent is true, removes c from its parent's children.
+func (c *cancelCtx) cancel(removeFromParent bool, err error) {
+	if err == nil {
+		panic("context: internal error: missing cancel error")
+	}
+	c.mu.Lock()
+	if c.err != nil {
+		c.mu.Unlock()
+		return // already canceled
+	}
+	c.err = err
+	close(c.done)
+	for child := range c.children {
+		// NOTE: acquiring the child's lock while holding parent's lock.
+		child.cancel(false, err)
+	}
+	c.children = nil
+	c.mu.Unlock()
+
+	if removeFromParent {
+		removeChild(c.Context, c)
+	}
+}
+
+// WithDeadline returns a copy of the parent context with the deadline adjusted
+// to be no later than d. If the parent's deadline is already earlier than d,
+// WithDeadline(parent, d) is semantically equivalent to parent. The returned
+// context's Done channel is closed when the deadline expires, when the returned
+// cancel function is called, or when the parent context's Done channel is
+// closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
+	if cur, ok := parent.Deadline(); ok && cur.Before(deadline) {
+		// The current deadline is already sooner than the new one.
+		return WithCancel(parent)
+	}
+	c := &timerCtx{
+		cancelCtx: newCancelCtx(parent),
+		deadline:  deadline,
+	}
+	propagateCancel(parent, c)
+	d := deadline.Sub(time.Now())
+	if d <= 0 {
+		c.cancel(true, DeadlineExceeded) // deadline has already passed
+		return c, func() { c.cancel(true, Canceled) }
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.err == nil {
+		c.timer = time.AfterFunc(d, func() {
+			c.cancel(true, DeadlineExceeded)
+		})
+	}
+	return c, func() { c.cancel(true, Canceled) }
+}
+
+// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to
+// implement Done and Err. It implements cancel by stopping its timer then
+// delegating to cancelCtx.cancel.
+type timerCtx struct {
+	*cancelCtx
+	timer *time.Timer // Under cancelCtx.mu.
+
+	deadline time.Time
+}
+
+func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
+	return c.deadline, true
+}
+
+func (c *timerCtx) String() string {
+	return fmt.Sprintf("%v.WithDeadline(%s [%s])", c.cancelCtx.Context, c.deadline, c.deadline.Sub(time.Now()))
+}
+
+func (c *timerCtx) cancel(removeFromParent bool, err error) {
+	c.cancelCtx.cancel(false, err)
+	if removeFromParent {
+		// Remove this timerCtx from its parent cancelCtx's children.
+		removeChild(c.cancelCtx.Context, c)
+	}
+	c.mu.Lock()
+	if c.timer != nil {
+		c.timer.Stop()
+		c.timer = nil
+	}
+	c.mu.Unlock()
+}
+
+// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete:
+//
+// 	func slowOperationWithTimeout(ctx context.Context) (Result, error) {
+// 		ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
+// 		defer cancel()  // releases resources if slowOperation completes before timeout elapses
+// 		return slowOperation(ctx)
+// 	}
+func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
+	return WithDeadline(parent, time.Now().Add(timeout))
+}
+
+// WithValue returns a copy of parent in which the value associated with key is
+// val.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+func WithValue(parent Context, key interface{}, val interface{}) Context {
+	return &valueCtx{parent, key, val}
+}
+
+// A valueCtx carries a key-value pair. It implements Value for that key and
+// delegates all other calls to the embedded Context.
+type valueCtx struct {
+	Context
+	key, val interface{}
+}
+
+func (c *valueCtx) String() string {
+	return fmt.Sprintf("%v.WithValue(%#v, %#v)", c.Context, c.key, c.val)
+}
+
+func (c *valueCtx) Value(key interface{}) interface{} {
+	if c.key == key {
+		return c.val
+	}
+	return c.Context.Value(key)
+}

vendor/golang.org/x/sync/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. 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.
+   * Neither the name of Google Inc. nor the names of its
+contributors may 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
+OWNER 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/golang.org/x/sync/PATENTS

@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.

vendor/golang.org/x/sync/errgroup/errgroup.go

@@ -0,0 +1,67 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package errgroup provides synchronization, error propagation, and Context
+// cancelation for groups of goroutines working on subtasks of a common task.
+package errgroup
+
+import (
+	"sync"
+
+	"golang.org/x/net/context"
+)
+
+// A Group is a collection of goroutines working on subtasks that are part of
+// the same overall task.
+//
+// A zero Group is valid and does not cancel on error.
+type Group struct {
+	cancel func()
+
+	wg sync.WaitGroup
+
+	errOnce sync.Once
+	err     error
+}
+
+// WithContext returns a new Group and an associated Context derived from ctx.
+//
+// The derived Context is canceled the first time a function passed to Go
+// returns a non-nil error or the first time Wait returns, whichever occurs
+// first.
+func WithContext(ctx context.Context) (*Group, context.Context) {
+	ctx, cancel := context.WithCancel(ctx)
+	return &Group{cancel: cancel}, ctx
+}
+
+// Wait blocks until all function calls from the Go method have returned, then
+// returns the first non-nil error (if any) from them.
+func (g *Group) Wait() error {
+	g.wg.Wait()
+	if g.cancel != nil {
+		g.cancel()
+	}
+	return g.err
+}
+
+// Go calls the given function in a new goroutine.
+//
+// The first call to return a non-nil error cancels the group; its error will be
+// returned by Wait.
+func (g *Group) Go(f func() error) {
+	g.wg.Add(1)
+
+	go func() {
+		defer g.wg.Done()
+
+		if err := f(); err != nil {
+			g.errOnce.Do(func() {
+				g.err = err
+				if g.cancel != nil {
+					g.cancel()
+				}
+			})
+		}
+	}()
+}

vendor/vendor.json

@@ -8,6 +8,24 @@
 			"revision": "99064174e013895bbd9b025c31100bd1d9b590ca",
 			"revisionTime": "2016-07-17T15:07:09Z"
 		},
+		{
+			"checksumSHA1": "Z8SoRH0ZEPw18R69NtFEJGssQWk=",
+			"path": "github.com/Masterminds/semver",
+			"revision": "923f129261de8c3e45d529e39824061bd5edf9aa",
+			"revisionTime": "2017-04-07T15:36:03Z"
+		},
+		{
+			"checksumSHA1": "HPd13JQQPnYHVCly/iuOekOdc88=",
+			"path": "github.com/Masterminds/sprig",
+			"revision": "4fd5bcb33f764801522c8e35f464a12ceb180873",
+			"revisionTime": "2017-04-07T15:32:54Z"
+		},
+		{
+			"checksumSHA1": "5Vi6/8dcXD/++3YJMwcuv7FgwH8=",
+			"path": "github.com/aokoli/goutils",
+			"revision": "5e8cbdfe987ad788b91aceb88ce79545bc12b1f0",
+			"revisionTime": "2017-04-07T14:28:27Z"
+		},
 		{
 			"checksumSHA1": "x2Km0Qy3WgJJnV19Zv25VwTJcBM=",
 			"path": "github.com/fsnotify/fsnotify",
@@ -32,12 +50,54 @@
 			"revision": "95345c4e1c0ebc9d16a3284177f09360f4d20fab",
 			"revisionTime": "2017-01-24T11:57:57Z"
 		},
+		{
+			"checksumSHA1": "1ZLAvHVYAS3kxaYI8OQiTBllqNU=",
+			"path": "github.com/mvdan/sh/interp",
+			"revision": "17e267b541e30baece16b7ddeae50822cc6a795f",
+			"revisionTime": "2017-04-24T11:31:08Z"
+		},
+		{
+			"checksumSHA1": "4/7joITdf4wl+uoV8zDXgYqy2aw=",
+			"path": "github.com/mvdan/sh/syntax",
+			"revision": "17e267b541e30baece16b7ddeae50822cc6a795f",
+			"revisionTime": "2017-04-24T11:31:08Z"
+		},
+		{
+			"checksumSHA1": "HUXE+Nrcau8FSaVEvPYHMvDjxOE=",
+			"path": "github.com/satori/go.uuid",
+			"revision": "5bf94b69c6b68ee1b541973bb8e1144db23a194b",
+			"revisionTime": "2017-03-21T23:07:31Z"
+		},
 		{
 			"checksumSHA1": "5KvHyB1CImtwZT3fwNkNUlc8R0k=",
 			"path": "github.com/spf13/pflag",
 			"revision": "9ff6c6923cfffbcd502984b8e0c80539a94968b7",
 			"revisionTime": "2017-01-30T21:42:45Z"
 		},
+		{
+			"checksumSHA1": "1MGpGDQqnUoRpv7VEcQrXOBydXE=",
+			"path": "golang.org/x/crypto/pbkdf2",
+			"revision": "cbc3d0884eac986df6e78a039b8792e869bff863",
+			"revisionTime": "2017-04-09T18:29:52Z"
+		},
+		{
+			"checksumSHA1": "E8pDMGySfy5Mw+jzXOkOxo35bww=",
+			"path": "golang.org/x/crypto/scrypt",
+			"revision": "cbc3d0884eac986df6e78a039b8792e869bff863",
+			"revisionTime": "2017-04-09T18:29:52Z"
+		},
+		{
+			"checksumSHA1": "Y+HGqEkYM15ir+J93MEaHdyFy0c=",
+			"path": "golang.org/x/net/context",
+			"revision": "d1e1b351919c6738fdeb9893d5c998b161464f0c",
+			"revisionTime": "2016-12-29T22:47:41Z"
+		},
+		{
+			"checksumSHA1": "Fxh2bhyDOSLGYJAY73976JVMys0=",
+			"path": "golang.org/x/sync/errgroup",
+			"revision": "5a06fca2c336a4b2b2fcb45702e8c47621b2aa2c",
+			"revisionTime": "2017-03-17T17:13:11Z"
+		},
 		{
 			"checksumSHA1": "mIZhS4hXW3qVQxsJ6tqztjJoJ8A=",
 			"path": "golang.org/x/sys/unix",

watch.go

@@ -1,6 +1,7 @@
 package task
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"strings"
@@ -16,7 +17,7 @@ func WatchTasks(args []string) error {
 
 	// run tasks on init
 	for _, a := range args {
-		if err := RunTask(a); err != nil {
+		if err := RunTask(context.Background(), a); err != nil {
 			fmt.Println(err)
 			break
 		}
@@ -42,7 +43,7 @@ loop:
 		select {
 		case <-watcher.Events:
 			for _, a := range args {
-				if err := RunTask(a); err != nil {
+				if err := RunTask(context.Background(), a); err != nil {
 					fmt.Println(err)
 					continue loop
 				}