v2.0.3

Fixes #120

.editorconfig

@@ -9,6 +9,6 @@ trim_trailing_whitespace = true
 indent_style = tab
 indent_size = 8
 
-[*.{md,yml}]
+[*.{md,yml,yaml,json,toml}]
 indent_style = space
 indent_size = 2

.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at andrey.nering@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

.github/CONTRIBUTING.md

@@ -0,0 +1,9 @@
+* Bug reports and feature requests are welcome in [the issues][issues]
+* For questions and discussion there's the [Slack room][slack] ([invititation here][slackinvite])
+* Pull Requests are welcome. For more complex changes and features it's
+  recommended to open an issue with the feature request first
+* Documentation contributions are as important as code contributions
+
+[issues]: https://github.com/go-task/task/issues
+[slack]: https://gophers.slack.com/messages/task
+[slackinvite]: https://invite.slack.golangbridge.org/

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,9 @@
+<!--
+For questions and general talk there's the Slack room: https://gophers.slack.com/messages/task
+Invite to the Slack is available in this link: https://invite.slack.golangbridge.org/
+
+If relevant, include the following information:
+- Task version
+- OS
+- Example Taskfile showing the issue
+-->

.gitignore

@@ -14,3 +14,6 @@
 .glide/
 
 ./task
+dist/
+
+.DS_Store

.goreleaser.yml

@@ -0,0 +1,44 @@
+build:
+  binary: task
+  main: cmd/task/task.go
+  goos:
+    - windows
+    - darwin
+    - linux
+  goarch:
+    - 386
+    - amd64
+  ignore:
+    - goos: darwin
+      goarch: 386
+  env:
+    - CGO_ENABLED=0
+
+archive:
+  name_template: "{{.Binary}}_{{.Os}}_{{.Arch}}"
+
+  format_overrides:
+    - goos: windows
+      format: zip
+
+release:
+  draft: true
+
+snapshot:
+  name_template: "{{.Tag}}"
+
+checksum:
+  name_template: "task_checksums.txt"
+
+nfpm:
+  vendor: Task
+  homepage: https://github.com/go-task/task
+  maintainer: Andrey Nering <andrey.nering@gmail.com>
+  description: Simple task runner written in Go
+  license: MIT
+  conflicts:
+    - taskwarrior
+  formats:
+    - deb
+    - rpm
+  name_template: "{{.ProjectName}}_{{.Os}}_{{.Arch}}"

.travis.yml

@@ -0,0 +1,22 @@
+language: go
+
+go:
+  - 1.9.x
+  - 1.10.x
+
+addons:
+  apt:
+    packages:
+      - rpm
+
+script:
+  - go install github.com/go-task/task/cmd/task
+  - task ci
+
+deploy:
+  - provider: script
+    skip_cleanup: true
+    script: curl -sL http://git.io/goreleaser | bash
+    on:
+      tags: true
+      condition: $TRAVIS_OS_NAME = linux

Gopkg.lock

@@ -0,0 +1,131 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  branch = "master"
+  name = "github.com/Masterminds/semver"
+  packages = ["."]
+  revision = "3c560837130448941620d7694991d3ec440aefc0"
+
+[[projects]]
+  name = "github.com/Masterminds/sprig"
+  packages = ["."]
+  revision = "6b2a58267f6a8b1dc8e2eb5519b984008fa85e8c"
+  version = "v2.15.0"
+
+[[projects]]
+  name = "github.com/aokoli/goutils"
+  packages = ["."]
+  revision = "3391d3790d23d03408670993e957e8f408993c34"
+  version = "v1.0.1"
+
+[[projects]]
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
+
+[[projects]]
+  name = "github.com/google/uuid"
+  packages = ["."]
+  revision = "064e2069ce9c359c118179501254f67d7d37ba24"
+  version = "0.2"
+
+[[projects]]
+  name = "github.com/huandu/xstrings"
+  packages = ["."]
+  revision = "2bf18b218c51864a87384c06996e40ff9dcff8e1"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/imdario/mergo"
+  packages = ["."]
+  revision = "9316a62528ac99aaecb4e47eadd6dc8aa6533d58"
+  version = "v0.3.5"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mattn/go-zglob"
+  packages = [
+    ".",
+    "fastwalk"
+  ]
+  revision = "49693fbb3fe3c3a75fc4e4d6fb1d7cedcbdeb385"
+
+[[projects]]
+  name = "github.com/pmezard/go-difflib"
+  packages = ["difflib"]
+  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/radovskyb/watcher"
+  packages = ["."]
+  revision = "0d9d32686dbf6395752c9b209398a59e302a7f1e"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  revision = "3ebe029320b2676d667ae88da602a5f854788a8a"
+
+[[projects]]
+  name = "github.com/stretchr/testify"
+  packages = ["assert"]
+  revision = "f35b8ab0b5a2cef36673838d662e249dd9c94686"
+  version = "v1.2.2"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/crypto"
+  packages = [
+    "pbkdf2",
+    "scrypt",
+    "ssh/terminal"
+  ]
+  revision = "a49355c7e3f8fe157a85be2f77e6e269a0f89602"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/net"
+  packages = ["context"]
+  revision = "afe8f62b1d6bbd81f31868121a50b06d8188e1f9"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sync"
+  packages = ["errgroup"]
+  revision = "1d60e4601c6fd243af51cc01ddf169918a5407ca"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows"
+  ]
+  revision = "63fc586f45fe72d95d5240a5d5eb95e6503907d3"
+
+[[projects]]
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+  version = "v2.2.1"
+
+[[projects]]
+  branch = "master"
+  name = "mvdan.cc/sh"
+  packages = [
+    "interp",
+    "shell",
+    "syntax"
+  ]
+  revision = "ca7561fd34910fd8575a3830d3cded291c0ce8b2"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "600bd482208fdedec60141bfaffe55eb403df077944bfdf5c007a33132c8ab5a"
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,40 @@
+[prune]
+  unused-packages = true
+  non-go = true
+  go-tests = true
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/Masterminds/sprig"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/imdario/mergo"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/mattn/go-zglob"
+
+[[constraint]]
+  branch = "master"
+  name = "mvdan.cc/sh"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/spf13/pflag"
+
+[[constraint]]
+  branch = "master"
+  name = "golang.org/x/sync"
+
+[[constraint]]
+  branch = "v2"
+  name = "gopkg.in/yaml.v2"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/radovskyb/watcher"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/Masterminds/semver"

README.md

@@ -1,32 +1,100 @@
-# Task - Simple "Make" alternative
+[![Join Slack room](https://img.shields.io/badge/%23task-chat%20room-blue.svg)](https://gophers.slack.com/messages/task)
+[![Build Status](https://travis-ci.org/go-task/task.svg?branch=master)](https://travis-ci.org/go-task/task)
+
+# Task - A task runner / simpler Make alternative written in Go
+
+> We recently released version 2.0.0 of Task. The Taskfile changed a bit.
+Please, check the [Taskfile versions](TASKFILE_VERSIONS.md) document to see
+what changed and how to upgrade.
 
 Task is a simple tool that allows you to easily run development and build
-tasks. Task is written in Go, but can be used to develop any language.
+tasks. Task is written in Golang, but can be used to develop any language.
 It aims to be simpler and easier to use then [GNU Make][make].
 
+- [Installation](#installation)
+  - [Go](#go)
+  - [Homebrew](#homebrew)
+  - [Snap](#snap)
+  - [Binary](#binary)
+- [Usage](#usage)
+  - [Environment](#environment)
+  - [OS specific task](#os-specific-task)
+  - [Task directory](#task-directory)
+  - [Task dependencies](#task-dependencies)
+  - [Calling another task](#calling-another-task)
+  - [Prevent unnecessary work](#prevent-unnecessary-work)
+  - [Variables](#variables)
+    - [Dynamic variables](#dynamic-variables)
+  - [Go's template engine](#gos-template-engine)
+  - [Help](#help)
+  - [Silent mode](#silent-mode)
+  - [Watch tasks](#watch-tasks-experimental)
+- [Examples](#examples)
+- [Alternative task runners](#alternative-task-runners)
+
 ## Installation
 
-If you have a Go environment setup, you can simply run:
+### Go
+
+If you have a [Golang][golang] environment setup, you can simply run:
 
 ```bash
 go get -u -v github.com/go-task/task/cmd/task
 ```
 
-Now the `task` executable should be available in your `PATH`.
+### Homebrew
+
+If you're on macOS and have [Homebrew][homebrew] installed, getting Task is
+as simple as running:
+
+```bash
+brew install go-task/tap/go-task
+```
+
+### Snap
+
+Task is available for [Snapcraft][snapcraft], but keep in mind that your
+Linux distribution should allow classic confinement for Snaps to Task work
+right:
+
+```bash
+sudo snap install task
+```
+
+### Install script
+
+We also have a [install script][installscript], which is very useful on
+scanarios like CIs. Many thanks to [godownloader][godownloader] for easily
+generating this script.
+
+```bash
+curl -s https://raw.githubusercontent.com/go-task/task/master/install-task.sh | sh
+```
+
+### Binary
+
+Or you can download the binary from the [releases][releases] page and add to
+your `PATH`. DEB and RPM packages are also available.
+The `task_checksums.txt` file contains the sha256 checksum for each file.
 
 ## Usage
 
-Create a file called `Taskfile.yml`. The `cmds` key should contains the
-commands of a task:
+Create a file called `Taskfile.yml` in the root of your project.
+The `cmds` attribute should contain the commands of a task.
+The example below allows compiling a Go app and uses [Minify][minify] to concat
+and minify multiple CSS files into a single one.
 
 ```yml
-build:
-  cmds:
-    - go build -v -i main.go
+version: '2'
 
-assets:
-  cmds:
-    - gulp
+tasks:
+  build:
+    cmds:
+      - go build -v -i main.go
+
+  assets:
+    cmds:
+      - minify -o public/style.css src/css
 ```
 
 Running the tasks is as simple as running:
@@ -35,23 +103,95 @@ 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 run on `cmd` (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` are 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
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - echo $hallo
+    env:
+      hallo: welt
+```
+
+### OS specific task
+
+If you add a `Taskfile_{{GOOS}}.yml` you can override or amend your taskfile
+based on the operating system.
+
+Example:
+
+Taskfile.yml:
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - echo "default"
+```
+
+Taskfile_linux.yml:
+
+```yml
+tasks:
+  build:
+    cmds:
+      - echo "linux"
+```
+
+Will print out `linux` and not default.
+
+It's also possible to have an OS specific `Taskvars.yml` file, like
+`Taskvars_windows.yml`, `Taskfile_linux.yml`, or `Taskvars_darwin.yml`. See the
+[variables section](#variables) below.
+
+### Task directory
+
+By default, tasks will be executed in the directory where the Taskfile is
+located. But you can easily make the task run in another folder informing
+`dir`:
+
+```yml
+version: '2'
+
+tasks:
+  serve:
+    dir: public/www
+    cmds:
+      # run http server
+      - caddy
+```
 
 ### Task dependencies
 
-You may have tasks that depends on others. Just point them on `deps` will run
-them automatically:
+You may have tasks that depend on others. Just pointing them on `deps` will
+make them run automatically before running the parent task:
 
 ```yml
-build:
-  deps: [assets]
-  cmds:
-    - go build -v -i main.go
+version: '2'
 
-assets:
-  cmds:
-    - gulp
+tasks:
+  build:
+    deps: [assets]
+    cmds:
+      - go build -v -i main.go
+
+  assets:
+    cmds:
+      - minify -o public/style.css src/css
 ```
 
 In the above example, `assets` will always run right before `build` if you run
@@ -60,49 +200,552 @@ In the above example, `assets` will always run right before `build` if you run
 A task can have only dependencies and no commands to group tasks together:
 
 ```yml
-assets:
-  deps: [js, css]
+version: '2'
 
-js:
-  cmds:
-    - npm run buildjs
+tasks:
+  assets:
+    deps: [js, css]
 
-css:
-  cmds:
-    - npm run buildcss
+  js:
+    cmds:
+      - minify -o public/script.js src/js
+
+  css:
+    cmds:
+      - minify -o public/style.css src/css
 ```
 
-### Prevent task from running when not necessary
+If there is more than one dependency, they always run in parallel for better
+performance.
 
-If a task generates something, you can inform Task the source and generated
-files, to Task will prevent to run them if not necessary.
+If you want to pass information to dependencies, you can do that the same
+manner as you would to [call another task](#calling-another-task):
 
 ```yml
-build:
-  deps: [js, css]
-  cmds:
-    - go build -v -i main.go
+version: '2'
 
-js:
-  cmds:
-    - npm run buildjs
-  sources:
-    - js/src/**/*.js
-  generates:
-    - public/bundle.js
+tasks:
+  default:
+    deps:
+      - task: echo_sth
+        vars: {TEXT: "before 1"}
+      - task: echo_sth
+        vars: {TEXT: "before 2"}
+    cmds:
+      - echo "after"
 
-css:
-  cmds:
-    - npm run buildcss
-  sources:
-    - css/src/*.css
-  generates:
-    - public/bundle.css
+  echo_sth:
+    cmds:
+      - echo {{.TEXT}}
 ```
 
-`sources` and `generates` should be file patterns. When both are given, Task
-will compare the modification date/time of the files to determine if it's
-necessary to run the task. If not, it will just print
+### Calling another task
+
+When a task has many dependencies, they are executed concurrently. This will
+often result in a faster build pipeline. But in some situations you may need
+to call other tasks serially. In this case, just use the following syntax:
+
+```yml
+version: '2'
+
+tasks:
+  main-task:
+    cmds:
+      - task: task-to-be-called
+      - task: another-task
+      - echo "Both done"
+
+  task-to-be-called:
+    cmds:
+      - echo "Task to be called"
+
+  another-task:
+    cmds:
+      - echo "Another task"
+```
+
+Overriding variables in the called task is as simple as informing `vars`
+attribute:
+
+```yml
+version: '2'
+
+tasks:
+  main-task:
+    cmds:
+      - task: write-file
+        vars: {FILE: "hello.txt", CONTENT: "Hello!"}
+      - task: write-file
+        vars: {FILE: "world.txt", CONTENT: "World!"}
+
+  write-file:
+    cmds:
+      - echo "{{.CONTENT}}" > {{.FILE}}
+```
+
+The above syntax is also supported in `deps`.
+
+### Prevent unnecessary work
+
+If a task generates something, you can inform Task the source and generated
+files, so Task will prevent to run them if not necessary.
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    deps: [js, css]
+    cmds:
+      - go build -v -i main.go
+
+  js:
+    cmds:
+      - minify -o public/script.js src/js
+    sources:
+      - src/js/**/*.js
+    generates:
+      - public/script.js
+
+  css:
+    cmds:
+      - minify -o public/style.css src/css
+    sources:
+      - src/css/**/*.css
+    generates:
+      - public/style.css
+```
+
+`sources` and `generates` can be files or file patterns. When both are given,
+Task will compare the modification date/time of the files to determine if it's
+necessary to run the task. If not, it will just print a message like
 `Task "js" is up to date`.
 
+If you prefer this check to be made by the content of the files, instead of
+its timestamp, just set the `method` property to `checksum`.
+You will probably want to ignore the `.task` folder in your `.gitignore` file
+(It's there that Task stores the last checksum).
+This feature is still experimental and can change until it's stable.
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - go build .
+    sources:
+      - ./*.go
+    generates:
+      - app{{exeExt}}
+    method: checksum
+```
+
+> TIP: method `none` skips any validation and always run the task.
+
+Alternatively, you can inform a sequence of tests as `status`. If no error
+is returned (exit status 0), the task is considered up-to-date:
+
+```yml
+version: '2'
+
+tasks:
+  generate-files:
+    cmds:
+      - mkdir directory
+      - touch directory/file1.txt
+      - touch directory/file2.txt
+    # test existence of files
+    status:
+      - test -d directory
+      - test -f directory/file1.txt
+      - test -f directory/file2.txt
+```
+
+You can use `--force` or `-f` if you want to force a task to run even when
+up-to-date.
+
+Also, `task --status [tasks]...` will exit with a non-zero exit code if any of
+the tasks are not up-to-date.
+
+### Variables
+
+When doing interpolation of variables, Task will look for the below.
+They are listed below in order of importance (e.g. most important first):
+
+- Variables declared locally in the task
+- Variables given while calling a task from another.
+  (See [Calling another task](#calling-another-task) above)
+- Variables declared in the `vars:` option in the `Taskfile`
+- Variables available in the `Taskvars.yml` file
+- Environment variables
+
+Example of sending parameters with environment variables:
+
+```bash
+$ TASK_VARIABLE=a-value task do-something
+```
+
+Since some shells don't support above syntax to set environment variables
+(Windows) tasks also accepts a similar style when not in the beginning of
+the command. Variables given in this form are only visible to the task called
+right before.
+
+```bash
+$ task write-file FILE=file.txt "CONTENT=Hello, World!" print "MESSAGE=All done!"
+```
+
+Example of locally declared vars:
+
+```yml
+version: '2'
+
+tasks:
+  print-var:
+    cmds:
+      echo "{{.VAR}}"
+    vars:
+      VAR: Hello!
+```
+
+Example of global vars in a `Taskfile.yml`:
+
+```yml
+version: '2'
+
+vars:
+  GREETING: Hello from Taskfile!
+
+tasks:
+  greet:
+    cmds:
+      - echo "{{.GREETING}}"
+```
+
+Example of `Taskvars.yml` file:
+
+```yml
+PROJECT_NAME: My Project
+DEV_MODE: production
+GIT_COMMIT: {sh: git log -n 1 --format=%h}
+```
+
+#### Variables expansion
+
+Variables are expanded 2 times by default. You can change that by setting the
+`expansions:` option. Change that will be necessary if you compose many
+variables together:
+
+```yml
+version: '2'
+
+expansions: 3
+
+vars:
+  FOO: foo
+  BAR: bar
+  BAZ: baz
+  FOOBAR: "{{.FOO}}{{.BAR}}"
+  FOOBARBAZ: "{{.FOOBAR}}{{.BAZ}}"
+
+tasks:
+  default:
+    cmds:
+      - echo "{{.FOOBARBAZ}}"
+```
+
+#### Dynamic variables
+
+The below syntax (`sh:` prop in a variable) is considered a dynamic variable.
+The value will be treated as a command and the output assigned. If there is one
+or more trailing newlines, the last newline will be trimmed.
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - go build -ldflags="-X main.Version={{.GIT_COMMIT}}" main.go
+    vars:
+      GIT_COMMIT:
+        sh: git log -n 1 --format=%h
+```
+
+This works for all types of variables.
+
+### Go's template engine
+
+Task parse commands as [Go's template engine][gotemplate] before executing
+them. Variables are accessible through dot syntax (`.VARNAME`).
+
+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:
+
+```yml
+version: '2'
+
+tasks:
+  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".
+- `splitLines`: Splits Unix (\n) and Windows (\r\n) styled newlines.
+- `catLines`: Replaces Unix (\n) and Windows (\r\n) styled newlines with a space.
+- `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 `/`.
+- `exeExt`: Returns the right executable extension for the current OS
+  (`".exe"` for Windows, `""` for others).
+
+Example:
+
+```yml
+version: '2'
+
+tasks:
+  print-os:
+    cmds:
+      - echo '{{OS}} {{ARCH}}'
+      - echo '{{if eq OS "windows"}}windows-command{{else}}unix-command{{end}}'
+      # This will be path/to/file on Unix but path\to\file on Windows
+      - echo '{{fromSlash "path/to/file"}}'
+  enumerated-file:
+    vars:
+      CONTENT: |
+        foo
+        bar
+    cmds:
+      - |
+        cat << EOF > output.txt
+        {{range $i, $line := .CONTENT | splitLines -}}
+        {{printf "%3d" $i}}: {{$line}}
+        {{end}}EOF
+```
+
+### Help
+
+Running `task --list` (or `task -l`) lists all tasks with a description.
+The following taskfile:
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    desc: Build the go binary.
+    cmds:
+      - go build -v -i main.go
+
+  test:
+    desc: Run all the go tests.
+    cmds:
+      - go test -race ./...
+
+  js:
+    cmds:
+      - minify -o public/script.js src/js
+
+  css:
+    cmds:
+      - minify -o public/style.css src/css
+```
+
+would print the following output:
+
+```bash
+* build:   Build the go binary.
+* test:    Run all the go tests.
+```
+
+## Silent mode
+
+Silent mode disables echoing of commands before Task runs it.
+For the following Taskfile:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - echo "Print something"
+```
+
+Normally this will be print:
+
+```sh
+echo "Print something"
+Print something
+```
+
+With silent mode on, the below will be print instead:
+
+```sh
+Print something
+```
+
+There's three ways to enable silent mode:
+
+* At command level:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - cmd: echo "Print something"
+        silent: true
+```
+
+* At task level:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - echo "Print something"
+    silent: true
+```
+
+* Or globally with `--silent` or `-s` flag
+
+If you want to suppress stdout instead, just redirect a command to `/dev/null`:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - echo "This will print nothing" > /dev/null
+```
+
+## Output syntax
+
+By default, Task just redirect the STDOUT and STDERR of the running commands
+to the shell in real time. This is good for having live feedback for log
+printed by commands, but the output can become messy if you have multiple
+commands running at the same time and printing lots of stuff.
+
+To make this more customizable, there are currently three different output
+options you can choose:
+
+- `interleaved` (default)
+- `group`
+- `prefixed`
+
+ To choose another one, just set it to root in the Taskfile:
+
+ ```yml
+version: '2'
+
+output: 'group'
+
+tasks:
+  # ...
+ ```
+
+ The `group` output will print the entire output of a command once, after it
+ finishes, so you won't have live feedback for commands that take a long time
+ to run.
+
+ The `prefix` output will prefix every line printed by a command with
+ `[task-name] ` as the prefix, but you can customize the prefix for a command
+ with the `prefix:` attribute:
+
+ ```yml
+version: '2'
+
+output: prefixed
+
+tasks:
+  default:
+    deps:
+      - task: print
+        vars: {TEXT: foo}
+      - task: print
+        vars: {TEXT: bar}
+      - task: print
+        vars: {TEXT: baz}
+
+  print:
+    cmds:
+      - echo "{{.TEXT}}"
+    prefix: "print-{{.TEXT}}"
+    silent: true
+```
+
+```bash
+$ task default
+[print-foo] foo
+[print-bar] bar
+[print-baz] baz
+```
+
+## Watch tasks
+
+If you give a `--watch` or `-w` argument, task will watch for file changes
+and run the task again. This requires the `sources` attribute to be given,
+so task know which files to watch.
+
+## Examples
+
+The [go-task/examples][examples] intends to be a collection of Taskfiles for
+various use cases.
+(It still lacks many examples, though. Contributions are welcome).
+
+## Alternative task runners
+
+- YAML based:
+  - [goeuro/myke][myke]
+  - [dreadl0ck/zeus][zeus]
+  - [rliebz/tusk][tusk]
+- Go based:
+  - [markbates/grift][grift]
+  - [magefile/mage][mage]
+- Make based:
+  - [tj/mmake][mmake]
+
+### Sponsors
+
+[![Sponsors](https://opencollective.com/task/sponsors.svg?width=890)][opencollective]
+
+### Backers
+
+[![Backers](https://opencollective.com/task/backers.svg?width=890)][opencollective]
+
+### Contributors
+
+[![Contributors](https://opencollective.com/task/contributors.svg?width=890)][contributors]
+
 [make]: https://www.gnu.org/software/make/
+[releases]: https://github.com/go-task/task/releases
+[golang]: https://golang.org/
+[gotemplate]: https://golang.org/pkg/text/template/
+[myke]: https://github.com/goeuro/myke
+[zeus]: https://github.com/dreadl0ck/zeus
+[tusk]: https://github.com/rliebz/tusk
+[grift]: https://github.com/markbates/grift
+[mage]: https://github.com/magefile/mage
+[mmake]: https://github.com/tj/mmake
+[sh]: https://github.com/mvdan/sh
+[minify]: https://github.com/tdewolff/minify/tree/master/cmd/minify
+[examples]: https://github.com/go-task/examples
+[snapcraft]: https://snapcraft.io/
+[homebrew]: https://brew.sh/
+[installscript]: https://github.com/go-task/task/blob/master/install-task.sh
+[godownloader]: https://github.com/goreleaser/godownloader
+[opencollective]: https://opencollective.com/task
+[contributors]: https://github.com/go-task/task/graphs/contributors

RELEASING_TASK.md

@@ -0,0 +1,32 @@
+# Releasing Task
+
+The release process of Task is done is done with the help of
+[GoReleaser][goreleaser]. You can test the release process locally by calling
+the `test-release` task of the Taskfile.
+
+The Travis CI should release automatically when a new
+Git tag is pushed to master, either for the artifact uploading (raw executables
+and DEB and RPM packages)
+
+# Homebrew
+
+To release a new version on the [Homebrew tap][homebrewtap] edit the
+[Formula/go-task.rb][gotaskrb] file, updating with the new version, download
+URL and sha256.
+
+# Snapcraft
+
+The exception is the publishing of a new version of the
+[snap package][snappackage]. This current require two steps after publishing
+the binaries:
+
+* Updating the current version on [snapcraft.yaml][snapcraftyaml];
+* Moving either the `i386` and `amd64` new artifacts to the stable channel on
+the [Snapscraft dashboard][snapcraftdashboard]
+
+[goreleaser]: https://goreleaser.com/#continuous_integration
+[homebrewtap]: https://github.com/go-task/homebrew-tap
+[gotaskrb]: https://github.com/go-task/homebrew-tap/blob/master/Formula/go-task.rb
+[snappackage]: https://github.com/go-task/snap
+[snapcraftyaml]: https://github.com/go-task/snap/blob/master/snap/snapcraft.yaml#L2
+[snapcraftdashboard]: https://dashboard.snapcraft.io/

TASKFILE_VERSIONS.md

@@ -0,0 +1,91 @@
+# Taskfile version
+
+The Taskfile syntax and features changed with time. This document explains what
+changed on each version and how to upgrade your Taskfile.
+
+# What the Taskfile version mean
+
+The Taskfile version follows the Task version. E.g. the change to Taskfile
+version `2` means that Task `v2.0.0` should be release to support it.
+
+The `version:` key on Taskfile accepts a semver string, so either `2`, `2.0` or
+`2.0.0` is accepted. You you choose to use `2.0` Task will not enable future
+`2.1` features, but if you choose to use `2`, than any `2.x.x` features will be
+available, but not `3.0.0+`.
+
+## Version 1
+
+In the first version of the `Taskfile`, the `version:` key was not available,
+because the tasks was in the root of the YAML document. Like this:
+
+```yml
+echo:
+  cmds:
+    - echo "Hello, World!"
+```
+
+The variable priority order was also different:
+
+1. Call variables
+2. Environment
+3. Task variables
+4. `Taskvars.yml` variables
+
+## Version 2.0
+
+At version 2, we introduced the `version:` key, to allow us to envolve Task
+with new features without breaking existing Taskfiles. The new syntax is as
+follows:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - echo "Hello, World!"
+```
+
+Version 2 allows you to write global variables directly in the Taskfile,
+if you don't want to create a `Taskvars.yml`:
+
+```yml
+version: '2'
+
+vars:
+  GREETING: Hello, World!
+
+tasks:
+  greet:
+    cmds:
+      - echo "{{.GREETING}}"
+```
+
+The variable priority order changed to the following:
+
+1. Task variables
+2. Call variables
+3. Taskfile variables
+4. Taskvars file variables
+5. Environment variables
+
+A new global option was added to configure the number of variables expansions
+(which default to 2):
+
+```yml
+version: '2'
+
+expansions: 3
+
+vars:
+  FOO: foo
+  BAR: bar
+  BAZ: baz
+  FOOBAR: "{{.FOO}}{{.BAR}}"
+  FOOBARBAZ: "{{.FOOBAR}}{{.BAZ}}"
+
+tasks:
+  default:
+    cmds:
+      - echo "{{.FOOBARBAZ}}"
+```

Taskfile.yml

@@ -0,0 +1,95 @@
+version: '2'
+
+vars:
+  GIT_COMMIT:
+    sh: git log -n 1 --format=%h
+
+  GO_PACKAGES:
+    .
+    ./cmd/task
+    ./internal/args
+    ./internal/compiler
+    ./internal/compiler/v1
+    ./internal/compiler/v2
+    ./internal/execext
+    ./internal/logger
+    ./internal/osext
+    ./internal/output
+    ./internal/status
+    ./internal/taskfile
+    ./internal/taskfile/version
+    ./internal/templater
+
+tasks:
+  # compiles current source code and make "task" executable available on
+  # $GOPATH/bin/task{.exe}
+  install:
+    desc: Installs Task
+    cmds:
+      - go install -v -ldflags="-w -s -X main.version={{.GIT_COMMIT}}" ./cmd/task
+    env:
+      CGO_ENABLED: '0'
+
+  dl-deps:
+    desc: Downloads cli dependencies
+    cmds:
+      - task: go-get
+        vars: {REPO: github.com/golang/lint/golint}
+      - task: go-get
+        vars: {REPO: github.com/asticode/go-astitodo/astitodo}
+      - task: go-get
+        vars: {REPO: github.com/golang/dep/cmd/dep}
+      - task: go-get
+        vars: {REPO: github.com/goreleaser/goreleaser}
+      - task: go-get
+        vars: {REPO: github.com/goreleaser/godownloader}
+
+  update-deps:
+    desc: Updates dependencies
+    cmds:
+      - dep ensure
+      - dep ensure -update
+
+  clean:
+    desc: Cleans temp files and folders
+    cmds:
+      - rm -rf dist/
+
+  lint:
+    desc: Runs golint
+    cmds:
+      - golint {{.GO_PACKAGES}}
+    silent: true
+
+  test:
+    desc: Runs test suite
+    deps: [install]
+    cmds:
+      - go test {{.GO_PACKAGES}}
+
+  test-release:
+    desc: Tests release process without publishing
+    cmds:
+      - goreleaser --snapshot --rm-dist
+
+  generate-install-script:
+    desc: Generate install script using https://githbub.com/goreleaser/godownloader
+    cmds:
+      - godownloader --repo go-task/task -o install-task.sh
+
+  todo:
+    desc: Prints TODO comments present in the code
+    cmds:
+      - astitodo {{.GO_PACKAGES}}
+    silent: true
+
+  ci:
+    cmds:
+      - task: go-get
+        vars: {REPO: github.com/golang/lint/golint}
+      - task: lint
+      - task: test
+
+  go-get:
+    cmds:
+      - go get -u {{.REPO}}

cmd/task/task.go

@@ -1,9 +1,143 @@
 package main
 
 import (
+	"context"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+
 	"github.com/go-task/task"
+	"github.com/go-task/task/internal/args"
+
+	"github.com/spf13/pflag"
 )
 
+var (
+	version = "master"
+)
+
+const usage = `Usage: task [-ilfwvsd] [--init] [--list] [--force] [--watch] [--verbose] [--silent] [--dir] [task...]
+
+Runs the specified task(s). Falls back to the "default" task if no task name
+was specified, or lists all tasks if an unknown task name was specified.
+
+Example: 'task hello' with the following 'Taskfile.yml' file will generate an
+'output.txt' file with the content "hello".
+
+'''
+hello:
+  cmds:
+    - echo "I am going to write a file named 'output.txt' now."
+    - echo "hello" > output.txt
+  generates:
+    - output.txt
+'''
+
+Options:
+`
+
 func main() {
-	task.Run()
+	log.SetFlags(0)
+	log.SetOutput(os.Stderr)
+
+	pflag.Usage = func() {
+		log.Print(usage)
+		pflag.PrintDefaults()
+	}
+
+	var (
+		versionFlag bool
+		init        bool
+		list        bool
+		status      bool
+		force       bool
+		watch       bool
+		verbose     bool
+		silent      bool
+		dir         string
+	)
+
+	pflag.BoolVar(&versionFlag, "version", false, "show Task version")
+	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yml in the current folder")
+	pflag.BoolVarP(&list, "list", "l", false, "lists tasks with description of current Taskfile")
+	pflag.BoolVar(&status, "status", false, "exits with non-zero exit code if any of the given tasks is not up-to-date")
+	pflag.BoolVarP(&force, "force", "f", false, "forces execution even when the task is up-to-date")
+	pflag.BoolVarP(&watch, "watch", "w", false, "enables watch of the given task")
+	pflag.BoolVarP(&verbose, "verbose", "v", false, "enables verbose mode")
+	pflag.BoolVarP(&silent, "silent", "s", false, "disables echoing")
+	pflag.StringVarP(&dir, "dir", "d", "", "sets directory of execution")
+	pflag.Parse()
+
+	if versionFlag {
+		log.Printf("Task version: %s\n", version)
+		return
+	}
+
+	if init {
+		wd, err := os.Getwd()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if err := task.InitTaskfile(os.Stdout, wd); err != nil {
+			log.Fatal(err)
+		}
+		return
+	}
+
+	e := task.Executor{
+		Force:   force,
+		Watch:   watch,
+		Verbose: verbose,
+		Silent:  silent,
+		Dir:     dir,
+
+		Context: getSignalContext(),
+
+		Stdin:  os.Stdin,
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
+	}
+	if err := e.Setup(); err != nil {
+		log.Fatal(err)
+	}
+
+	if list {
+		e.PrintTasksHelp()
+		return
+	}
+
+	arguments := pflag.Args()
+	if len(arguments) == 0 {
+		log.Println("task: No argument given, trying default task")
+		arguments = []string{"default"}
+	}
+
+	calls, err := args.Parse(arguments...)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if status {
+		if err = e.Status(calls...); err != nil {
+			log.Fatal(err)
+		}
+		return
+	}
+
+	if err := e.Run(calls...); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func getSignalContext() context.Context {
+	ch := make(chan os.Signal, 1)
+	signal.Notify(ch, os.Interrupt, os.Kill, syscall.SIGTERM)
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		sig := <-ch
+		log.Printf("task: signal received: %s", sig)
+		cancel()
+	}()
+	return ctx
 }

completion/zsh/_task

@@ -0,0 +1,24 @@
+#compdef task
+
+# Listing commands from Taskfile.yml
+function __list() {
+    local -a scripts
+
+    if [ -f Taskfile.yml ]; then
+        scripts=($(task -l | sed '1d' | sed 's/://' | awk '{ print $2 }'))
+        _describe 'script' scripts
+    fi
+}
+
+_arguments \
+    '(-d --dir)'{-d,--dir}': :_files' \
+    '(-f --force)'{-f,--force} \
+    '(-i --init)'{-i,--init} \
+    '(-l --list)'{-l,--list} \
+    '(-s --silent)'{-s,--silent} \
+    '(--status)'--status \
+    '(-v --verbose)'{-v,--verbose} \
+    '(--version)'--version \
+    '(-w --watch)'{-w,--watch} \
+    '(- *)'{-h,--help} \
+    '*: :__list' \

errors.go

@@ -0,0 +1,67 @@
+package task
+
+import (
+	"errors"
+	"fmt"
+)
+
+var (
+	// ErrTaskfileAlreadyExists is returned on creating a Taskfile if one already exists
+	ErrTaskfileAlreadyExists = errors.New("task: A Taskfile already exists")
+)
+
+type taskFileNotFound struct {
+	taskFile string
+}
+
+func (err taskFileNotFound) Error() string {
+	return fmt.Sprintf(`task: No task file found (is it named "%s"?). Use "task --init" to create a new one`, err.taskFile)
+}
+
+type taskNotFoundError struct {
+	taskName string
+}
+
+func (err *taskNotFoundError) Error() string {
+	return fmt.Sprintf(`task: Task "%s" not found`, err.taskName)
+}
+
+type taskRunError struct {
+	taskName string
+	err      error
+}
+
+func (err *taskRunError) Error() string {
+	return fmt.Sprintf(`task: Failed to run task "%s": %v`, err.taskName, err.err)
+}
+
+type cyclicDepError struct {
+	taskName string
+}
+
+func (err *cyclicDepError) Error() string {
+	return fmt.Sprintf(`task: Cyclic dependency of task "%s" detected`, err.taskName)
+}
+
+type cantWatchNoSourcesError struct {
+	taskName string
+}
+
+func (err *cantWatchNoSourcesError) Error() string {
+	return fmt.Sprintf(`task: Can't watch task "%s" because it has no specified sources`, err.taskName)
+}
+
+// MaximumTaskCallExceededError is returned when a task is called too
+// many times. In this case you probably have a cyclic dependendy or
+// infinite loop
+type MaximumTaskCallExceededError struct {
+	task string
+}
+
+func (e *MaximumTaskCallExceededError) Error() string {
+	return fmt.Sprintf(
+		`task: maximum task call exceeded (%d) for task "%s": probably an cyclic dep or infinite loop`,
+		MaximumTaskCall,
+		e.task,
+	)
+}

file.go

@@ -1,87 +0,0 @@
-package task
-
-import (
-	"os"
-	"time"
-
-	"github.com/mattn/go-zglob"
-)
-
-var dirsToSkip = []string{
-	".git",
-	"node_modules",
-}
-
-func minTime(a, b time.Time) time.Time {
-	if !a.IsZero() && a.Before(b) {
-		return a
-	}
-	return b
-}
-func maxTime(a, b time.Time) time.Time {
-	if a.After(b) {
-		return a
-	}
-	return b
-}
-
-func getPatternsMinTime(patterns []string) (m time.Time, err error) {
-	for _, p := range patterns {
-		mp, err := getPatternMinTime(p)
-		if err != nil {
-			return time.Time{}, err
-		}
-		m = minTime(m, mp)
-	}
-	return
-}
-func getPatternsMaxTime(patterns []string) (m time.Time, err error) {
-	for _, p := range patterns {
-		mp, err := getPatternMaxTime(p)
-		if err != nil {
-			return time.Time{}, err
-		}
-		m = maxTime(m, mp)
-	}
-	return
-}
-
-func getPatternMinTime(pattern string) (minTime time.Time, err error) {
-	files, err := zglob.Glob(pattern)
-	if err != nil {
-		return time.Time{}, err
-	}
-
-	for _, f := range files {
-		info, err := os.Stat(f)
-		if err != nil {
-			return time.Time{}, err
-		}
-
-		modTime := info.ModTime()
-		if minTime.IsZero() || modTime.Before(minTime) {
-			minTime = modTime
-		}
-	}
-	return
-}
-
-func getPatternMaxTime(pattern string) (maxTime time.Time, err error) {
-	files, err := zglob.Glob(pattern)
-	if err != nil {
-		return time.Time{}, err
-	}
-
-	for _, f := range files {
-		info, err := os.Stat(f)
-		if err != nil {
-			return time.Time{}, err
-		}
-
-		modTime := info.ModTime()
-		if modTime.After(maxTime) {
-			maxTime = modTime
-		}
-	}
-	return
-}

help.go

@@ -0,0 +1,37 @@
+package task
+
+import (
+	"fmt"
+	"sort"
+	"text/tabwriter"
+
+	"github.com/go-task/task/internal/taskfile"
+)
+
+// PrintTasksHelp prints help os tasks that have a description
+func (e *Executor) PrintTasksHelp() {
+	tasks := e.tasksWithDesc()
+	if len(tasks) == 0 {
+		e.Logger.Outf("task: No tasks with description available")
+		return
+	}
+	e.Logger.Outf("task: Available tasks for this project:")
+
+	// Format in tab-separated columns with a tab stop of 8.
+	w := tabwriter.NewWriter(e.Stdout, 0, 8, 0, '\t', 0)
+	for _, task := range tasks {
+		fmt.Fprintf(w, "* %s: \t%s\n", task.Task, task.Desc)
+	}
+	w.Flush()
+}
+
+func (e *Executor) tasksWithDesc() (tasks []*taskfile.Task) {
+	tasks = make([]*taskfile.Task, 0, len(e.Taskfile.Tasks))
+	for _, task := range e.Taskfile.Tasks {
+		if task.Desc != "" {
+			tasks = append(tasks, task)
+		}
+	}
+	sort.Slice(tasks, func(i, j int) bool { return tasks[i].Task < tasks[j].Task })
+	return
+}

init.go

@@ -0,0 +1,38 @@
+package task
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+)
+
+const defaultTaskfile = `# github.com/go-task/task
+
+version: '2'
+
+vars:
+  GREETING: Hello, World!
+
+tasks:
+  default:
+    cmds:
+      - echo "{{.GREETING}}"
+    silent: true
+`
+
+// InitTaskfile Taskfile creates a new Taskfile
+func InitTaskfile(w io.Writer, dir string) error {
+	f := filepath.Join(dir, "Taskfile.yml")
+
+	if _, err := os.Stat(f); err == nil {
+		return ErrTaskfileAlreadyExists
+	}
+
+	if err := ioutil.WriteFile(f, []byte(defaultTaskfile), 0644); err != nil {
+		return err
+	}
+	fmt.Fprintf(w, "Taskfile.yml created in the current directory\n")
+	return nil
+}

install-task.sh

@@ -0,0 +1,390 @@
+#!/bin/sh
+set -e
+# Code generated by godownloader on 2018-04-07T17:47:38Z. DO NOT EDIT.
+#
+
+usage() {
+  this=$1
+  cat <<EOF
+$this: download go binaries for go-task/task
+
+Usage: $this [-b] bindir [-d] [tag]
+  -b sets bindir or installation directory, Defaults to ./bin
+  -d turns on debug logging
+   [tag] is a tag from
+   https://github.com/go-task/task/releases
+   If tag is missing, then the latest will be used.
+
+ Generated by godownloader
+  https://github.com/goreleaser/godownloader
+
+EOF
+  exit 2
+}
+
+parse_args() {
+  #BINDIR is ./bin unless set be ENV
+  # over-ridden by flag below
+
+  BINDIR=${BINDIR:-./bin}
+  while getopts "b:dh?" arg; do
+    case "$arg" in
+      b) BINDIR="$OPTARG" ;;
+      d) log_set_priority 10 ;;
+      h | \?) usage "$0" ;;
+    esac
+  done
+  shift $((OPTIND - 1))
+  TAG=$1
+}
+# this function wraps all the destructive operations
+# if a curl|bash cuts off the end of the script due to
+# network, either nothing will happen or will syntax error
+# out preventing half-done work
+execute() {
+  tmpdir=$(mktmpdir)
+  log_debug "downloading files into ${tmpdir}"
+  http_download "${tmpdir}/${TARBALL}" "${TARBALL_URL}"
+  http_download "${tmpdir}/${CHECKSUM}" "${CHECKSUM_URL}"
+  hash_sha256_verify "${tmpdir}/${TARBALL}" "${tmpdir}/${CHECKSUM}"
+  srcdir="${tmpdir}"
+  (cd "${tmpdir}" && untar "${TARBALL}")
+  install -d "${BINDIR}"
+  for binexe in "task" ; do
+    if [ "$OS" = "windows" ]; then
+      binexe="${binexe}.exe"
+    fi
+    install "${srcdir}/${binexe}" "${BINDIR}/"
+    log_info "installed ${BINDIR}/${binexe}"
+  done
+}
+is_supported_platform() {
+  platform=$1
+  found=1
+  case "$platform" in
+    windows/386) found=0 ;;
+    windows/amd64) found=0 ;;
+    darwin/386) found=0 ;;
+    darwin/amd64) found=0 ;;
+    linux/386) found=0 ;;
+    linux/amd64) found=0 ;;
+  esac
+  case "$platform" in
+    darwin/386) found=1 ;;
+  esac
+  return $found
+}
+check_platform() {
+  if is_supported_platform "$PLATFORM"; then
+    # optional logging goes here
+    true
+  else
+    log_crit "platform $PLATFORM is not supported.  Make sure this script is up-to-date and file request at https://github.com/${PREFIX}/issues/new"
+    exit 1
+  fi
+}
+tag_to_version() {
+  if [ -z "${TAG}" ]; then
+    log_info "checking GitHub for latest tag"
+  else
+    log_info "checking GitHub for tag '${TAG}'"
+  fi
+  REALTAG=$(github_release "$OWNER/$REPO" "${TAG}") && true
+  if test -z "$REALTAG"; then
+    log_crit "unable to find '${TAG}' - use 'latest' or see https://github.com/${PREFIX}/releases for details"
+    exit 1
+  fi
+  # if version starts with 'v', remove it
+  TAG="$REALTAG"
+  VERSION=${TAG#v}
+}
+adjust_format() {
+  # change format (tar.gz or zip) based on ARCH
+  case ${ARCH} in
+    windows) FORMAT=zip ;;
+  esac
+  true
+}
+adjust_os() {
+  # adjust archive name based on OS
+  true
+}
+adjust_arch() {
+  # adjust archive name based on ARCH
+  true
+}
+
+cat /dev/null <<EOF
+------------------------------------------------------------------------
+https://github.com/client9/shlib - portable posix shell functions
+Public domain - http://unlicense.org
+https://github.com/client9/shlib/blob/master/LICENSE.md
+but credit (and pull requests) appreciated.
+------------------------------------------------------------------------
+EOF
+is_command() {
+  command -v "$1" >/dev/null
+}
+echoerr() {
+  echo "$@" 1>&2
+}
+log_prefix() {
+  echo "$0"
+}
+_logp=6
+log_set_priority() {
+  _logp="$1"
+}
+log_priority() {
+  if test -z "$1"; then
+    echo "$_logp"
+    return
+  fi
+  [ "$1" -le "$_logp" ]
+}
+log_tag() {
+  case $1 in
+    0) echo "emerg" ;;
+    1) echo "alert" ;;
+    2) echo "crit" ;;
+    3) echo "err" ;;
+    4) echo "warning" ;;
+    5) echo "notice" ;;
+    6) echo "info" ;;
+    7) echo "debug" ;;
+    *) echo "$1" ;;
+  esac
+}
+log_debug() {
+  log_priority 7 || return 0
+  echoerr "$(log_prefix)" "$(log_tag 7)" "$@"
+}
+log_info() {
+  log_priority 6 || return 0
+  echoerr "$(log_prefix)" "$(log_tag 6)" "$@"
+}
+log_err() {
+  log_priority 3 || return 0
+  echoerr "$(log_prefix)" "$(log_tag 3)" "$@"
+}
+log_crit() {
+  log_priority 2 || return 0
+  echoerr "$(log_prefix)" "$(log_tag 2)" "$@"
+}
+uname_os() {
+  os=$(uname -s | tr '[:upper:]' '[:lower:]')
+  case "$os" in
+    msys_nt) os="windows" ;;
+  esac
+  echo "$os"
+}
+uname_arch() {
+  arch=$(uname -m)
+  case $arch in
+    x86_64) arch="amd64" ;;
+    x86) arch="386" ;;
+    i686) arch="386" ;;
+    i386) arch="386" ;;
+    aarch64) arch="arm64" ;;
+    armv5*) arch="arm5" ;;
+    armv6*) arch="arm6" ;;
+    armv7*) arch="arm7" ;;
+  esac
+  echo ${arch}
+}
+uname_os_check() {
+  os=$(uname_os)
+  case "$os" in
+    darwin) return 0 ;;
+    dragonfly) return 0 ;;
+    freebsd) return 0 ;;
+    linux) return 0 ;;
+    android) return 0 ;;
+    nacl) return 0 ;;
+    netbsd) return 0 ;;
+    openbsd) return 0 ;;
+    plan9) return 0 ;;
+    solaris) return 0 ;;
+    windows) return 0 ;;
+  esac
+  log_crit "uname_os_check '$(uname -s)' got converted to '$os' which is not a GOOS value. Please file bug at https://github.com/client9/shlib"
+  return 1
+}
+uname_arch_check() {
+  arch=$(uname_arch)
+  case "$arch" in
+    386) return 0 ;;
+    amd64) return 0 ;;
+    arm64) return 0 ;;
+    armv5) return 0 ;;
+    armv6) return 0 ;;
+    armv7) return 0 ;;
+    ppc64) return 0 ;;
+    ppc64le) return 0 ;;
+    mips) return 0 ;;
+    mipsle) return 0 ;;
+    mips64) return 0 ;;
+    mips64le) return 0 ;;
+    s390x) return 0 ;;
+    amd64p32) return 0 ;;
+  esac
+  log_crit "uname_arch_check '$(uname -m)' got converted to '$arch' which is not a GOARCH value.  Please file bug report at https://github.com/client9/shlib"
+  return 1
+}
+untar() {
+  tarball=$1
+  case "${tarball}" in
+    *.tar.gz | *.tgz) tar -xzf "${tarball}" ;;
+    *.tar) tar -xf "${tarball}" ;;
+    *.zip) unzip "${tarball}" ;;
+    *)
+      log_err "untar unknown archive format for ${tarball}"
+      return 1
+      ;;
+  esac
+}
+mktmpdir() {
+  test -z "$TMPDIR" && TMPDIR="$(mktemp -d)"
+  mkdir -p "${TMPDIR}"
+  echo "${TMPDIR}"
+}
+http_download_curl() {
+  local_file=$1
+  source_url=$2
+  header=$3
+  if [ -z "$header" ]; then
+    code=$(curl -w '%{http_code}' -sL -o "$local_file" "$source_url")
+  else
+    code=$(curl -w '%{http_code}' -sL -H "$header" -o "$local_file" "$source_url")
+  fi
+  if [ "$code" != "200" ]; then
+    log_debug "http_download_curl received HTTP status $code"
+    return 1
+  fi
+  return 0
+}
+http_download_wget() {
+  local_file=$1
+  source_url=$2
+  header=$3
+  if [ -z "$header" ]; then
+    wget -q -O "$local_file" "$source_url"
+  else
+    wget -q --header "$header" -O "$local_file" "$source_url"
+  fi
+}
+http_download() {
+  log_debug "http_download $2"
+  if is_command curl; then
+    http_download_curl "$@"
+    return
+  elif is_command wget; then
+    http_download_wget "$@"
+    return
+  fi
+  log_crit "http_download unable to find wget or curl"
+  return 1
+}
+http_copy() {
+  tmp=$(mktemp)
+  http_download "${tmp}" "$1" "$2" || return 1
+  body=$(cat "$tmp")
+  rm -f "${tmp}"
+  echo "$body"
+}
+github_release() {
+  owner_repo=$1
+  version=$2
+  test -z "$version" && version="latest"
+  giturl="https://github.com/${owner_repo}/releases/${version}"
+  json=$(http_copy "$giturl" "Accept:application/json")
+  test -z "$json" && return 1
+  version=$(echo "$json" | tr -s '\n' ' ' | sed 's/.*"tag_name":"//' | sed 's/".*//')
+  test -z "$version" && return 1
+  echo "$version"
+}
+hash_sha256() {
+  TARGET=${1:-/dev/stdin}
+  if is_command gsha256sum; then
+    hash=$(gsha256sum "$TARGET") || return 1
+    echo "$hash" | cut -d ' ' -f 1
+  elif is_command sha256sum; then
+    hash=$(sha256sum "$TARGET") || return 1
+    echo "$hash" | cut -d ' ' -f 1
+  elif is_command shasum; then
+    hash=$(shasum -a 256 "$TARGET" 2>/dev/null) || return 1
+    echo "$hash" | cut -d ' ' -f 1
+  elif is_command openssl; then
+    hash=$(openssl -dst openssl dgst -sha256 "$TARGET") || return 1
+    echo "$hash" | cut -d ' ' -f a
+  else
+    log_crit "hash_sha256 unable to find command to compute sha-256 hash"
+    return 1
+  fi
+}
+hash_sha256_verify() {
+  TARGET=$1
+  checksums=$2
+  if [ -z "$checksums" ]; then
+    log_err "hash_sha256_verify checksum file not specified in arg2"
+    return 1
+  fi
+  BASENAME=${TARGET##*/}
+  want=$(grep "${BASENAME}" "${checksums}" 2>/dev/null | tr '\t' ' ' | cut -d ' ' -f 1)
+  if [ -z "$want" ]; then
+    log_err "hash_sha256_verify unable to find checksum for '${TARGET}' in '${checksums}'"
+    return 1
+  fi
+  got=$(hash_sha256 "$TARGET")
+  if [ "$want" != "$got" ]; then
+    log_err "hash_sha256_verify checksum for '$TARGET' did not verify ${want} vs $got"
+    return 1
+  fi
+}
+cat /dev/null <<EOF
+------------------------------------------------------------------------
+End of functions from https://github.com/client9/shlib
+------------------------------------------------------------------------
+EOF
+
+PROJECT_NAME="task"
+OWNER=go-task
+REPO="task"
+BINARY=task
+FORMAT=tar.gz
+OS=$(uname_os)
+ARCH=$(uname_arch)
+PREFIX="$OWNER/$REPO"
+
+# use in logging routines
+log_prefix() {
+	echo "$PREFIX"
+}
+PLATFORM="${OS}/${ARCH}"
+GITHUB_DOWNLOAD=https://github.com/${OWNER}/${REPO}/releases/download
+
+uname_os_check "$OS"
+uname_arch_check "$ARCH"
+
+parse_args "$@"
+
+check_platform
+
+tag_to_version
+
+adjust_format
+
+adjust_os
+
+adjust_arch
+
+log_info "found version: ${VERSION} for ${TAG}/${OS}/${ARCH}"
+
+NAME=${BINARY}_${OS}_${ARCH}
+TARBALL=${NAME}.${FORMAT}
+TARBALL_URL=${GITHUB_DOWNLOAD}/${TAG}/${TARBALL}
+CHECKSUM=task_checksums.txt
+CHECKSUM_URL=${GITHUB_DOWNLOAD}/${TAG}/${CHECKSUM}
+
+
+execute

internal/args/args.go

@@ -0,0 +1,36 @@
+package args
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/go-task/task/internal/taskfile"
+)
+
+var (
+	// ErrVariableWithoutTask is returned when variables are given before any task
+	ErrVariableWithoutTask = errors.New("task: variable given before any task")
+)
+
+// Parse parses command line argument: tasks and vars of each task
+func Parse(args ...string) ([]taskfile.Call, error) {
+	var calls []taskfile.Call
+
+	for _, arg := range args {
+		if !strings.Contains(arg, "=") {
+			calls = append(calls, taskfile.Call{Task: arg})
+			continue
+		}
+		if len(calls) < 1 {
+			return nil, ErrVariableWithoutTask
+		}
+
+		if calls[len(calls)-1].Vars == nil {
+			calls[len(calls)-1].Vars = make(taskfile.Vars)
+		}
+
+		pair := strings.SplitN(arg, "=", 2)
+		calls[len(calls)-1].Vars[pair[0]] = taskfile.Var{Static: pair[1]}
+	}
+	return calls, nil
+}

internal/args/args_test.go

@@ -0,0 +1,70 @@
+package args_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/go-task/task/internal/args"
+	"github.com/go-task/task/internal/taskfile"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestArgs(t *testing.T) {
+	tests := []struct {
+		Args     []string
+		Expected []taskfile.Call
+		Err      error
+	}{
+		{
+			Args: []string{"task-a", "task-b", "task-c"},
+			Expected: []taskfile.Call{
+				{Task: "task-a"},
+				{Task: "task-b"},
+				{Task: "task-c"},
+			},
+		},
+		{
+			Args: []string{"task-a", "FOO=bar", "task-b", "task-c", "BAR=baz", "BAZ=foo"},
+			Expected: []taskfile.Call{
+				{
+					Task: "task-a",
+					Vars: taskfile.Vars{
+						"FOO": taskfile.Var{Static: "bar"},
+					},
+				},
+				{Task: "task-b"},
+				{
+					Task: "task-c",
+					Vars: taskfile.Vars{
+						"BAR": taskfile.Var{Static: "baz"},
+						"BAZ": taskfile.Var{Static: "foo"},
+					},
+				},
+			},
+		},
+		{
+			Args: []string{"task-a", "CONTENT=with some spaces"},
+			Expected: []taskfile.Call{
+				{
+					Task: "task-a",
+					Vars: taskfile.Vars{
+						"CONTENT": taskfile.Var{Static: "with some spaces"},
+					},
+				},
+			},
+		},
+		{
+			Args: []string{"FOO=bar", "task-a"},
+			Err:  args.ErrVariableWithoutTask,
+		},
+	}
+
+	for i, test := range tests {
+		t.Run(fmt.Sprintf("TestArgs%d", i+1), func(t *testing.T) {
+			calls, err := args.Parse(test.Args...)
+			assert.Equal(t, test.Err, err)
+			assert.Equal(t, test.Expected, calls)
+		})
+	}
+}

internal/compiler/compiler.go

@@ -0,0 +1,12 @@
+package compiler
+
+import (
+	"github.com/go-task/task/internal/taskfile"
+)
+
+// Compiler handles compilation of a task before its execution.
+// E.g. variable merger, template processing, etc.
+type Compiler interface {
+	GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error)
+	HandleDynamicVar(v taskfile.Var) (string, error)
+}

internal/compiler/env.go

@@ -0,0 +1,24 @@
+package compiler
+
+import (
+	"os"
+	"strings"
+
+	"github.com/go-task/task/internal/taskfile"
+)
+
+// GetEnviron the all return all environment variables encapsulated on a
+// taskfile.Vars
+func GetEnviron() taskfile.Vars {
+	var (
+		env = os.Environ()
+		m   = make(taskfile.Vars, len(env))
+	)
+
+	for _, e := range env {
+		keyVal := strings.SplitN(e, "=", 2)
+		key, val := keyVal[0], keyVal[1]
+		m[key] = taskfile.Var{Static: val}
+	}
+	return m
+}

internal/compiler/v1/compiler_v1.go

@@ -0,0 +1,136 @@
+package v1
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/go-task/task/internal/compiler"
+	"github.com/go-task/task/internal/execext"
+	"github.com/go-task/task/internal/logger"
+	"github.com/go-task/task/internal/taskfile"
+	"github.com/go-task/task/internal/templater"
+)
+
+var _ compiler.Compiler = &CompilerV1{}
+
+type CompilerV1 struct {
+	Dir  string
+	Vars taskfile.Vars
+
+	Logger *logger.Logger
+
+	dynamicCache   map[string]string
+	muDynamicCache sync.Mutex
+}
+
+// GetVariables returns fully resolved variables following the priority order:
+// 1. Call variables (should already have been resolved)
+// 2. Environment (should not need to be resolved)
+// 3. Task variables, resolved with access to:
+//    - call, taskvars and environment variables
+// 4. Taskvars variables, resolved with access to:
+//    - environment variables
+func (c *CompilerV1) GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error) {
+	merge := func(dest taskfile.Vars, srcs ...taskfile.Vars) {
+		for _, src := range srcs {
+			for k, v := range src {
+				dest[k] = v
+			}
+		}
+	}
+	varsKeys := func(srcs ...taskfile.Vars) []string {
+		m := make(map[string]struct{})
+		for _, src := range srcs {
+			for k := range src {
+				m[k] = struct{}{}
+			}
+		}
+		lst := make([]string, 0, len(m))
+		for k := range m {
+			lst = append(lst, k)
+		}
+		return lst
+	}
+	replaceVars := func(dest taskfile.Vars, keys []string) error {
+		r := templater.Templater{Vars: dest}
+		for _, k := range keys {
+			v := dest[k]
+			dest[k] = taskfile.Var{
+				Static: r.Replace(v.Static),
+				Sh:     r.Replace(v.Sh),
+			}
+		}
+		return r.Err()
+	}
+	resolveShell := func(dest taskfile.Vars, keys []string) error {
+		for _, k := range keys {
+			v := dest[k]
+			static, err := c.HandleDynamicVar(v)
+			if err != nil {
+				return err
+			}
+			dest[k] = taskfile.Var{Static: static}
+		}
+		return nil
+	}
+	update := func(dest taskfile.Vars, srcs ...taskfile.Vars) error {
+		merge(dest, srcs...)
+		// updatedKeys ensures template evaluation is run only once.
+		updatedKeys := varsKeys(srcs...)
+		if err := replaceVars(dest, updatedKeys); err != nil {
+			return err
+		}
+		return resolveShell(dest, updatedKeys)
+	}
+
+	// Resolve taskvars variables to "result" with environment override variables.
+	override := compiler.GetEnviron()
+	result := make(taskfile.Vars, len(c.Vars)+len(t.Vars)+len(override))
+	if err := update(result, c.Vars, override); err != nil {
+		return nil, err
+	}
+	// Resolve task variables to "result" with environment and call override variables.
+	merge(override, call.Vars)
+	if err := update(result, t.Vars, override); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (c *CompilerV1) HandleDynamicVar(v taskfile.Var) (string, error) {
+	if v.Static != "" || v.Sh == "" {
+		return v.Static, nil
+	}
+
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	if c.dynamicCache == nil {
+		c.dynamicCache = make(map[string]string, 30)
+	}
+	if result, ok := c.dynamicCache[v.Sh]; ok {
+		return result, nil
+	}
+
+	var stdout bytes.Buffer
+	opts := &execext.RunCommandOptions{
+		Command: v.Sh,
+		Dir:     c.Dir,
+		Stdout:  &stdout,
+		Stderr:  c.Logger.Stderr,
+	}
+	if err := execext.RunCommand(opts); err != nil {
+		return "", fmt.Errorf(`task: Command "%s" in taskvars file failed: %s`, opts.Command, err)
+	}
+
+	// Trim a single trailing newline from the result to make most command
+	// output easier to use in shell commands.
+	result := strings.TrimSuffix(stdout.String(), "\n")
+
+	c.dynamicCache[v.Sh] = result
+	c.Logger.VerboseErrf(`task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
+
+	return result, nil
+}

internal/compiler/v2/compiler_v2.go

@@ -0,0 +1,108 @@
+package v2
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/go-task/task/internal/compiler"
+	"github.com/go-task/task/internal/execext"
+	"github.com/go-task/task/internal/logger"
+	"github.com/go-task/task/internal/taskfile"
+	"github.com/go-task/task/internal/templater"
+)
+
+var _ compiler.Compiler = &CompilerV2{}
+
+type CompilerV2 struct {
+	Dir string
+
+	Taskvars     taskfile.Vars
+	TaskfileVars taskfile.Vars
+
+	Expansions int
+
+	Logger *logger.Logger
+
+	dynamicCache   map[string]string
+	muDynamicCache sync.Mutex
+}
+
+// GetVariables returns fully resolved variables following the priority order:
+// 1. Task variables
+// 2. Call variables
+// 3. Taskfile variables
+// 4. Taskvars file variables
+// 5. Environment variables
+func (c *CompilerV2) GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error) {
+	vr := varResolver{c: c, vars: compiler.GetEnviron()}
+	for _, vars := range []taskfile.Vars{c.Taskvars, c.TaskfileVars, call.Vars, t.Vars} {
+		for i := 0; i < c.Expansions; i++ {
+			vr.merge(vars)
+		}
+	}
+	return vr.vars, vr.err
+}
+
+type varResolver struct {
+	c    *CompilerV2
+	vars taskfile.Vars
+	err  error
+}
+
+func (vr *varResolver) merge(vars taskfile.Vars) {
+	if vr.err != nil {
+		return
+	}
+	tr := templater.Templater{Vars: vr.vars}
+	for k, v := range vars {
+		v = taskfile.Var{
+			Static: tr.Replace(v.Static),
+			Sh:     tr.Replace(v.Sh),
+		}
+		static, err := vr.c.HandleDynamicVar(v)
+		if err != nil {
+			vr.err = err
+			return
+		}
+		vr.vars[k] = taskfile.Var{Static: static}
+	}
+	vr.err = tr.Err()
+}
+
+func (c *CompilerV2) HandleDynamicVar(v taskfile.Var) (string, error) {
+	if v.Static != "" || v.Sh == "" {
+		return v.Static, nil
+	}
+
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	if c.dynamicCache == nil {
+		c.dynamicCache = make(map[string]string, 30)
+	}
+	if result, ok := c.dynamicCache[v.Sh]; ok {
+		return result, nil
+	}
+
+	var stdout bytes.Buffer
+	opts := &execext.RunCommandOptions{
+		Command: v.Sh,
+		Dir:     c.Dir,
+		Stdout:  &stdout,
+		Stderr:  c.Logger.Stderr,
+	}
+	if err := execext.RunCommand(opts); err != nil {
+		return "", fmt.Errorf(`task: Command "%s" in taskvars file failed: %s`, opts.Command, err)
+	}
+
+	// Trim a single trailing newline from the result to make most command
+	// output easier to use in shell commands.
+	result := strings.TrimSuffix(stdout.String(), "\n")
+
+	c.dynamicCache[v.Sh] = result
+	c.Logger.VerboseErrf(`task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
+
+	return result, nil
+}

internal/execext/exec.go

@@ -0,0 +1,66 @@
+package execext
+
+import (
+	"context"
+	"errors"
+	"io"
+	"os"
+	"strings"
+
+	"mvdan.cc/sh/interp"
+	"mvdan.cc/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 (
+	// ErrNilOptions is returned when a nil options is given
+	ErrNilOptions = errors.New("execext: nil options given")
+)
+
+// RunCommand runs a shell command
+func RunCommand(opts *RunCommandOptions) error {
+	if opts == nil {
+		return ErrNilOptions
+	}
+
+	p, err := syntax.NewParser().Parse(strings.NewReader(opts.Command), "")
+	if err != nil {
+		return err
+	}
+
+	environ := opts.Env
+	if len(environ) == 0 {
+		environ = os.Environ()
+	}
+	env, err := interp.EnvFromList(environ)
+	if err != nil {
+		return err
+	}
+
+	r := interp.Runner{
+		Context: opts.Context,
+		Dir:     opts.Dir,
+		Env:     env,
+
+		Exec: interp.DefaultExec,
+		Open: interp.OpenDevImpls(interp.DefaultOpen),
+
+		Stdin:  opts.Stdin,
+		Stdout: opts.Stdout,
+		Stderr: opts.Stderr,
+	}
+	if err = r.Reset(); err != nil {
+		return err
+	}
+	return r.Run(p)
+}

internal/logger/logger.go

@@ -0,0 +1,38 @@
+package logger
+
+import (
+	"fmt"
+	"io"
+)
+
+type Logger struct {
+	Stdout  io.Writer
+	Stderr  io.Writer
+	Verbose bool
+}
+
+func (l *Logger) Outf(s string, args ...interface{}) {
+	if len(args) == 0 {
+		s, args = "%s", []interface{}{s}
+	}
+	fmt.Fprintf(l.Stdout, s+"\n", args...)
+}
+
+func (l *Logger) VerboseOutf(s string, args ...interface{}) {
+	if l.Verbose {
+		l.Outf(s, args...)
+	}
+}
+
+func (l *Logger) Errf(s string, args ...interface{}) {
+	if len(args) == 0 {
+		s, args = "%s", []interface{}{s}
+	}
+	fmt.Fprintf(l.Stderr, s+"\n", args...)
+}
+
+func (l *Logger) VerboseErrf(s string, args ...interface{}) {
+	if l.Verbose {
+		l.Errf(s, args...)
+	}
+}

internal/osext/osext.go

@@ -0,0 +1,22 @@
+package osext
+
+import (
+	"os"
+
+	"github.com/mitchellh/go-homedir"
+)
+
+// Expand is an improved version of os.ExpandEnv,
+// that not only expand enrionment variable ($GOPATH/src/github.com/...)
+// but also expands "~" as the home directory.
+func Expand(s string) (string, error) {
+	s = os.ExpandEnv(s)
+
+	var err error
+	s, err = homedir.Expand(s)
+	if err != nil {
+		return "", err
+	}
+
+	return s, nil
+}

internal/output/group.go

@@ -0,0 +1,26 @@
+package output
+
+import (
+	"bytes"
+	"io"
+)
+
+type Group struct{}
+
+func (Group) WrapWriter(w io.Writer, _ string) io.WriteCloser {
+	return &groupWriter{writer: w}
+}
+
+type groupWriter struct {
+	writer io.Writer
+	buff   bytes.Buffer
+}
+
+func (gw *groupWriter) Write(p []byte) (int, error) {
+	return gw.buff.Write(p)
+}
+
+func (gw *groupWriter) Close() error {
+	_, err := io.Copy(gw.writer, &gw.buff)
+	return err
+}

internal/output/interleaved.go

@@ -0,0 +1,23 @@
+package output
+
+import (
+	"io"
+)
+
+type Interleaved struct{}
+
+func (Interleaved) WrapWriter(w io.Writer, _ string) io.WriteCloser {
+	return nopWriterCloser{w: w}
+}
+
+type nopWriterCloser struct {
+	w io.Writer
+}
+
+func (wc nopWriterCloser) Write(p []byte) (int, error) {
+	return wc.w.Write(p)
+}
+
+func (wc nopWriterCloser) Close() error {
+	return nil
+}

internal/output/output.go

@@ -0,0 +1,9 @@
+package output
+
+import (
+	"io"
+)
+
+type Output interface {
+	WrapWriter(w io.Writer, prefix string) io.WriteCloser
+}

internal/output/output_test.go

@@ -0,0 +1,62 @@
+package output_test
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+
+	"github.com/go-task/task/internal/output"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestInterleaved(t *testing.T) {
+	var b bytes.Buffer
+	var o output.Output = output.Interleaved{}
+	var w = o.WrapWriter(&b, "")
+
+	fmt.Fprintln(w, "foo\nbar")
+	assert.Equal(t, "foo\nbar\n", b.String())
+	fmt.Fprintln(w, "baz")
+	assert.Equal(t, "foo\nbar\nbaz\n", b.String())
+}
+
+func TestGroup(t *testing.T) {
+	var b bytes.Buffer
+	var o output.Output = output.Group{}
+	var w = o.WrapWriter(&b, "")
+
+	fmt.Fprintln(w, "foo\nbar")
+	assert.Equal(t, "", b.String())
+	fmt.Fprintln(w, "baz")
+	assert.Equal(t, "", b.String())
+	assert.NoError(t, w.Close())
+	assert.Equal(t, "foo\nbar\nbaz\n", b.String())
+}
+
+func TestPrefixed(t *testing.T) {
+	var b bytes.Buffer
+	var o output.Output = output.Prefixed{}
+	var w = o.WrapWriter(&b, "prefix")
+
+	t.Run("simple use cases", func(t *testing.T) {
+		b.Reset()
+
+		fmt.Fprintln(w, "foo\nbar")
+		assert.Equal(t, "[prefix] foo\n[prefix] bar\n", b.String())
+		fmt.Fprintln(w, "baz")
+		assert.Equal(t, "[prefix] foo\n[prefix] bar\n[prefix] baz\n", b.String())
+	})
+
+	t.Run("multiple writes for a single line", func(t *testing.T) {
+		b.Reset()
+
+		for _, char := range []string{"T", "e", "s", "t", "!"} {
+			fmt.Fprint(w, char)
+			assert.Equal(t, "", b.String())
+		}
+
+		assert.NoError(t, w.Close())
+		assert.Equal(t, "[prefix] Test!\n", b.String())
+	})
+}

internal/output/prefixed.go

@@ -0,0 +1,65 @@
+package output
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+)
+
+type Prefixed struct{}
+
+func (Prefixed) WrapWriter(w io.Writer, prefix string) io.WriteCloser {
+	return &prefixWriter{writer: w, prefix: prefix}
+}
+
+type prefixWriter struct {
+	writer io.Writer
+	prefix string
+	buff   bytes.Buffer
+}
+
+func (pw *prefixWriter) Write(p []byte) (int, error) {
+	n, err := pw.buff.Write(p)
+	if err != nil {
+		return n, err
+	}
+
+	return n, pw.writeOutputLines(false)
+}
+
+func (pw *prefixWriter) Close() error {
+	return pw.writeOutputLines(true)
+}
+
+func (pw *prefixWriter) writeOutputLines(force bool) error {
+	for {
+		line, err := pw.buff.ReadString('\n')
+		if err == nil {
+			if err = pw.writeLine(line); err != nil {
+				return err
+			}
+		} else if err == io.EOF {
+			// if this line was not a complete line, re-add to the buffer
+			if !force && !strings.HasSuffix(line, "\n") {
+				_, err = pw.buff.WriteString(line)
+				return err
+			}
+
+			return pw.writeLine(line)
+		} else {
+			return err
+		}
+	}
+}
+
+func (pw *prefixWriter) writeLine(line string) error {
+	if line == "" {
+		return nil
+	}
+	if !strings.HasSuffix(line, "\n") {
+		line += "\n"
+	}
+	_, err := fmt.Fprintf(pw.writer, "[%s] %s", pw.prefix, line)
+	return err
+}

internal/status/checksum.go

@@ -0,0 +1,87 @@
+package status
+
+import (
+	"crypto/md5"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// Checksum validades if a task is up to date by calculating its source
+// files checksum
+type Checksum struct {
+	Dir     string
+	Task    string
+	Sources []string
+}
+
+// IsUpToDate implements the Checker interface
+func (c *Checksum) IsUpToDate() (bool, error) {
+	checksumFile := c.checksumFilePath()
+
+	data, _ := ioutil.ReadFile(checksumFile)
+	oldMd5 := strings.TrimSpace(string(data))
+
+	sources, err := glob(c.Dir, c.Sources)
+	if err != nil {
+		return false, err
+	}
+
+	newMd5, err := c.checksum(sources...)
+	if err != nil {
+		return false, nil
+	}
+
+	_ = os.MkdirAll(filepath.Join(c.Dir, ".task", "checksum"), 0755)
+	if err = ioutil.WriteFile(checksumFile, []byte(newMd5+"\n"), 0644); err != nil {
+		return false, err
+	}
+	return oldMd5 == newMd5, nil
+}
+
+func (c *Checksum) checksum(files ...string) (string, error) {
+	h := md5.New()
+
+	for _, f := range files {
+		f, err := os.Open(f)
+		if err != nil {
+			return "", err
+		}
+		info, err := f.Stat()
+		if err != nil {
+			return "", err
+		}
+		if info.IsDir() {
+			continue
+		}
+		// also sum the filename, so checksum changes for renaming a file
+		if _, err = io.Copy(h, strings.NewReader(info.Name())); err != nil {
+			return "", err
+		}
+		if _, err = io.Copy(h, f); err != nil {
+			return "", err
+		}
+	}
+
+	return fmt.Sprintf("%x", h.Sum(nil)), nil
+}
+
+// OnError implements the Checker interface
+func (c *Checksum) OnError() error {
+	return os.Remove(c.checksumFilePath())
+}
+
+func (c *Checksum) checksumFilePath() string {
+	return filepath.Join(c.Dir, ".task", "checksum", c.normalizeFilename(c.Task))
+}
+
+var checksumFilenameRegexp = regexp.MustCompile("[^A-z0-9]")
+
+// replaces invalid caracters on filenames with "-"
+func (*Checksum) normalizeFilename(f string) string {
+	return checksumFilenameRegexp.ReplaceAllString(f, "-")
+}

internal/status/checksum_test.go

@@ -0,0 +1,21 @@
+package status
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNormalizeFilename(t *testing.T) {
+	tests := []struct {
+		In, Out string
+	}{
+		{"foobarbaz", "foobarbaz"},
+		{"foo/bar/baz", "foo-bar-baz"},
+		{"foo@bar/baz", "foo-bar-baz"},
+		{"foo1bar2baz3", "foo1bar2baz3"},
+	}
+	for _, test := range tests {
+		assert.Equal(t, test.Out, (&Checksum{}).normalizeFilename(test.In))
+	}
+}

internal/status/glob.go

@@ -0,0 +1,29 @@
+package status
+
+import (
+	"path/filepath"
+	"sort"
+
+	"github.com/go-task/task/internal/osext"
+
+	"github.com/mattn/go-zglob"
+)
+
+func glob(dir string, globs []string) (files []string, err error) {
+	for _, g := range globs {
+		if !filepath.IsAbs(g) {
+			g = filepath.Join(dir, g)
+		}
+		g, err = osext.Expand(g)
+		if err != nil {
+			return nil, err
+		}
+		f, err := zglob.Glob(g)
+		if err != nil {
+			return nil, err
+		}
+		files = append(files, f...)
+	}
+	sort.Strings(files)
+	return
+}

internal/status/none.go

@@ -0,0 +1,14 @@
+package status
+
+// None is a no-op Checker
+type None struct{}
+
+// IsUpToDate implements the Checker interface
+func (None) IsUpToDate() (bool, error) {
+	return false, nil
+}
+
+// OnError implements the Checker interface
+func (None) OnError() error {
+	return nil
+}

internal/status/status.go

@@ -0,0 +1,13 @@
+package status
+
+var (
+	_ Checker = &Timestamp{}
+	_ Checker = &Checksum{}
+	_ Checker = None{}
+)
+
+// Checker is an interface that checks if the status is up-to-date
+type Checker interface {
+	IsUpToDate() (bool, error)
+	OnError() error
+}

internal/status/timestamp.go

@@ -0,0 +1,85 @@
+package status
+
+import (
+	"os"
+	"time"
+)
+
+// Timestamp checks if any source change compared with the generated files,
+// using file modifications timestamps.
+type Timestamp struct {
+	Dir       string
+	Sources   []string
+	Generates []string
+}
+
+// IsUpToDate implements the Checker interface
+func (t *Timestamp) IsUpToDate() (bool, error) {
+	if len(t.Sources) == 0 || len(t.Generates) == 0 {
+		return false, nil
+	}
+
+	sources, err := glob(t.Dir, t.Sources)
+	if err != nil {
+		return false, nil
+	}
+	generates, err := glob(t.Dir, t.Generates)
+	if err != nil {
+		return false, nil
+	}
+
+	sourcesMaxTime, err := getMaxTime(sources...)
+	if err != nil || sourcesMaxTime.IsZero() {
+		return false, nil
+	}
+
+	generatesMinTime, err := getMinTime(generates...)
+	if err != nil || generatesMinTime.IsZero() {
+		return false, nil
+	}
+
+	return !generatesMinTime.Before(sourcesMaxTime), nil
+}
+
+func getMinTime(files ...string) (time.Time, error) {
+	var t time.Time
+	for _, f := range files {
+		info, err := os.Stat(f)
+		if err != nil {
+			return time.Time{}, err
+		}
+		t = minTime(t, info.ModTime())
+	}
+	return t, nil
+}
+
+func getMaxTime(files ...string) (time.Time, error) {
+	var t time.Time
+	for _, f := range files {
+		info, err := os.Stat(f)
+		if err != nil {
+			return time.Time{}, err
+		}
+		t = maxTime(t, info.ModTime())
+	}
+	return t, nil
+}
+
+func minTime(a, b time.Time) time.Time {
+	if !a.IsZero() && a.Before(b) {
+		return a
+	}
+	return b
+}
+
+func maxTime(a, b time.Time) time.Time {
+	if a.After(b) {
+		return a
+	}
+	return b
+}
+
+// OnError implements the Checker interface
+func (*Timestamp) OnError() error {
+	return nil
+}

internal/taskfile/call.go

@@ -0,0 +1,7 @@
+package taskfile
+
+// Call is the parameters to a task call
+type Call struct {
+	Task string
+	Vars Vars
+}

internal/taskfile/cmd.go

@@ -0,0 +1,78 @@
+package taskfile
+
+import (
+	"errors"
+	"strings"
+)
+
+// Cmd is a task command
+type Cmd struct {
+	Cmd    string
+	Silent bool
+	Task   string
+	Vars   Vars
+}
+
+// Dep is a task dependency
+type Dep struct {
+	Task string
+	Vars Vars
+}
+
+var (
+	// ErrCantUnmarshalCmd is returned for invalid command YAML
+	ErrCantUnmarshalCmd = errors.New("task: can't unmarshal cmd value")
+	// ErrCantUnmarshalDep is returned for invalid dependency YAML
+	ErrCantUnmarshalDep = errors.New("task: can't unmarshal dep value")
+)
+
+// UnmarshalYAML implements yaml.Unmarshaler interface
+func (c *Cmd) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var cmd string
+	if err := unmarshal(&cmd); err == nil {
+		if strings.HasPrefix(cmd, "^") {
+			c.Task = strings.TrimPrefix(cmd, "^")
+		} else {
+			c.Cmd = cmd
+		}
+		return nil
+	}
+	var cmdStruct struct {
+		Cmd    string
+		Silent bool
+	}
+	if err := unmarshal(&cmdStruct); err == nil && cmdStruct.Cmd != "" {
+		c.Cmd = cmdStruct.Cmd
+		c.Silent = cmdStruct.Silent
+		return nil
+	}
+	var taskCall struct {
+		Task string
+		Vars Vars
+	}
+	if err := unmarshal(&taskCall); err == nil {
+		c.Task = taskCall.Task
+		c.Vars = taskCall.Vars
+		return nil
+	}
+	return ErrCantUnmarshalCmd
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler interface
+func (d *Dep) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var task string
+	if err := unmarshal(&task); err == nil {
+		d.Task = task
+		return nil
+	}
+	var taskCall struct {
+		Task string
+		Vars Vars
+	}
+	if err := unmarshal(&taskCall); err == nil {
+		d.Task = taskCall.Task
+		d.Vars = taskCall.Vars
+		return nil
+	}
+	return ErrCantUnmarshalDep
+}

internal/taskfile/task.go

@@ -0,0 +1,21 @@
+package taskfile
+
+// Tasks representas a group of tasks
+type Tasks map[string]*Task
+
+// Task represents a task
+type Task struct {
+	Task      string
+	Cmds      []*Cmd
+	Deps      []*Dep
+	Desc      string
+	Sources   []string
+	Generates []string
+	Status    []string
+	Dir       string
+	Vars      Vars
+	Env       Vars
+	Silent    bool
+	Method    string
+	Prefix    string
+}

internal/taskfile/taskfile.go

@@ -0,0 +1,38 @@
+package taskfile
+
+// Taskfile represents a Taskfile.yml
+type Taskfile struct {
+	Version    string
+	Expansions int
+	Output     string
+	Vars       Vars
+	Tasks      Tasks
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler interface
+func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	if err := unmarshal(&tf.Tasks); err == nil {
+		tf.Version = "1"
+		return nil
+	}
+
+	var taskfile struct {
+		Version    string
+		Expansions int
+		Output     string
+		Vars       Vars
+		Tasks      Tasks
+	}
+	if err := unmarshal(&taskfile); err != nil {
+		return err
+	}
+	tf.Version = taskfile.Version
+	tf.Expansions = taskfile.Expansions
+	tf.Output = taskfile.Output
+	tf.Vars = taskfile.Vars
+	tf.Tasks = taskfile.Tasks
+	if tf.Expansions <= 0 {
+		tf.Expansions = 2
+	}
+	return nil
+}

internal/taskfile/taskfile_test.go

@@ -0,0 +1,60 @@
+package taskfile_test
+
+import (
+	"testing"
+
+	"github.com/go-task/task/internal/taskfile"
+
+	"github.com/stretchr/testify/assert"
+	"gopkg.in/yaml.v2"
+)
+
+func TestCmdParse(t *testing.T) {
+	const (
+		yamlCmd      = `echo "a string command"`
+		yamlDep      = `"task-name"`
+		yamlTaskCall = `
+task: another-task
+vars:
+  PARAM1: VALUE1
+  PARAM2: VALUE2
+`
+	)
+	tests := []struct {
+		content  string
+		v        interface{}
+		expected interface{}
+	}{
+		{
+			yamlCmd,
+			&taskfile.Cmd{},
+			&taskfile.Cmd{Cmd: `echo "a string command"`},
+		},
+		{
+			yamlTaskCall,
+			&taskfile.Cmd{},
+			&taskfile.Cmd{Task: "another-task", Vars: taskfile.Vars{
+				"PARAM1": taskfile.Var{Static: "VALUE1"},
+				"PARAM2": taskfile.Var{Static: "VALUE2"},
+			}},
+		},
+		{
+			yamlDep,
+			&taskfile.Dep{},
+			&taskfile.Dep{Task: "task-name"},
+		},
+		{
+			yamlTaskCall,
+			&taskfile.Dep{},
+			&taskfile.Dep{Task: "another-task", Vars: taskfile.Vars{
+				"PARAM1": taskfile.Var{Static: "VALUE1"},
+				"PARAM2": taskfile.Var{Static: "VALUE2"},
+			}},
+		},
+	}
+	for _, test := range tests {
+		err := yaml.Unmarshal([]byte(test.content), test.v)
+		assert.NoError(t, err)
+		assert.Equal(t, test.expected, test.v)
+	}
+}

internal/taskfile/var.go

@@ -0,0 +1,58 @@
+package taskfile
+
+import (
+	"errors"
+	"strings"
+)
+
+var (
+	// ErrCantUnmarshalVar is returned for invalid var YAML.
+	ErrCantUnmarshalVar = errors.New("task: can't unmarshal var value")
+)
+
+// Vars is a string[string] variables map.
+type Vars map[string]Var
+
+// ToStringMap converts Vars to a string map containing only the static
+// variables
+func (vs Vars) ToStringMap() (m map[string]string) {
+	m = make(map[string]string, len(vs))
+	for k, v := range vs {
+		if v.Sh != "" {
+			// Dynamic variable is not yet resolved; trigger
+			// <no value> to be used in templates.
+			continue
+		}
+		m[k] = v.Static
+	}
+	return
+}
+
+// Var represents either a static or dynamic variable.
+type Var struct {
+	Static string
+	Sh     string
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler interface.
+func (v *Var) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var str string
+	if err := unmarshal(&str); err == nil {
+		if strings.HasPrefix(str, "$") {
+			v.Sh = strings.TrimPrefix(str, "$")
+		} else {
+			v.Static = str
+		}
+		return nil
+	}
+
+	var sh struct {
+		Sh string
+	}
+	if err := unmarshal(&sh); err == nil {
+		v.Sh = sh.Sh
+		return nil
+	}
+
+	return ErrCantUnmarshalVar
+}

internal/taskfile/version/version.go

@@ -0,0 +1,40 @@
+package version
+
+import (
+	"github.com/Masterminds/semver"
+)
+
+var (
+	v1  = mustVersion("1")
+	v2  = mustVersion("2")
+	v21 = mustVersion("2.1")
+	v22 = mustVersion("2.2")
+)
+
+// IsV1 returns if is a given Taskfile version is version 1
+func IsV1(v *semver.Constraints) bool {
+	return v.Check(v1)
+}
+
+// IsV2 returns if is a given Taskfile version is at least version 2
+func IsV2(v *semver.Constraints) bool {
+	return v.Check(v2)
+}
+
+// IsV21 returns if is a given Taskfile version is at least version 2.1
+func IsV21(v *semver.Constraints) bool {
+	return v.Check(v21)
+}
+
+// IsV22 returns if is a given Taskfile version is at least version 2.2
+func IsV22(v *semver.Constraints) bool {
+	return v.Check(v22)
+}
+
+func mustVersion(s string) *semver.Version {
+	v, err := semver.NewVersion(s)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}

internal/templater/funcs.go

@@ -0,0 +1,52 @@
+package templater
+
+import (
+	"path/filepath"
+	"runtime"
+	"strings"
+	"text/template"
+
+	"github.com/Masterminds/sprig"
+)
+
+var (
+	templateFuncs template.FuncMap
+)
+
+func init() {
+	taskFuncs := template.FuncMap{
+		"OS":   func() string { return runtime.GOOS },
+		"ARCH": func() string { return runtime.GOARCH },
+		"catLines": func(s string) string {
+			s = strings.Replace(s, "\r\n", " ", -1)
+			return strings.Replace(s, "\n", " ", -1)
+		},
+		"splitLines": func(s string) []string {
+			s = strings.Replace(s, "\r\n", "\n", -1)
+			return strings.Split(s, "\n")
+		},
+		"fromSlash": func(path string) string {
+			return filepath.FromSlash(path)
+		},
+		"toSlash": func(path string) string {
+			return filepath.ToSlash(path)
+		},
+		"exeExt": func() string {
+			if runtime.GOOS == "windows" {
+				return ".exe"
+			}
+			return ""
+		},
+		// IsSH is deprecated.
+		"IsSH": func() bool { return true },
+	}
+	// Deprecated aliases for renamed functions.
+	taskFuncs["FromSlash"] = taskFuncs["fromSlash"]
+	taskFuncs["ToSlash"] = taskFuncs["toSlash"]
+	taskFuncs["ExeExt"] = taskFuncs["exeExt"]
+
+	templateFuncs = sprig.TxtFuncMap()
+	for k, v := range taskFuncs {
+		templateFuncs[k] = v
+	}
+}

internal/templater/templater.go

@@ -0,0 +1,73 @@
+package templater
+
+import (
+	"bytes"
+	"text/template"
+
+	"github.com/go-task/task/internal/taskfile"
+)
+
+// Templater is a help struct that allow us to call "replaceX" funcs multiple
+// times, without having to check for error each time. The first error that
+// happen will be assigned to r.err, and consecutive calls to funcs will just
+// return the zero value.
+type Templater struct {
+	Vars taskfile.Vars
+
+	strMap map[string]string
+	err    error
+}
+
+func (r *Templater) Replace(str string) string {
+	if r.err != nil || str == "" {
+		return ""
+	}
+
+	templ, err := template.New("").Funcs(templateFuncs).Parse(str)
+	if err != nil {
+		r.err = err
+		return ""
+	}
+
+	if r.strMap == nil {
+		r.strMap = r.Vars.ToStringMap()
+	}
+
+	var b bytes.Buffer
+	if err = templ.Execute(&b, r.strMap); err != nil {
+		r.err = err
+		return ""
+	}
+	return b.String()
+}
+
+func (r *Templater) ReplaceSlice(strs []string) []string {
+	if r.err != nil || len(strs) == 0 {
+		return nil
+	}
+
+	new := make([]string, len(strs))
+	for i, str := range strs {
+		new[i] = r.Replace(str)
+	}
+	return new
+}
+
+func (r *Templater) ReplaceVars(vars taskfile.Vars) taskfile.Vars {
+	if r.err != nil || len(vars) == 0 {
+		return nil
+	}
+
+	new := make(taskfile.Vars, len(vars))
+	for k, v := range vars {
+		new[k] = taskfile.Var{
+			Static: r.Replace(v.Static),
+			Sh:     r.Replace(v.Sh),
+		}
+	}
+	return new
+}
+
+func (r *Templater) Err() error {
+	return r.err
+}

status.go

@@ -0,0 +1,85 @@
+package task
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/go-task/task/internal/execext"
+	"github.com/go-task/task/internal/status"
+	"github.com/go-task/task/internal/taskfile"
+)
+
+// Status returns an error if any the of given tasks is not up-to-date
+func (e *Executor) Status(calls ...taskfile.Call) error {
+	for _, call := range calls {
+		t, ok := e.Taskfile.Tasks[call.Task]
+		if !ok {
+			return &taskNotFoundError{taskName: call.Task}
+		}
+		isUpToDate, err := isTaskUpToDate(e.Context, t)
+		if err != nil {
+			return err
+		}
+		if !isUpToDate {
+			return fmt.Errorf(`task: Task "%s" is not up-to-date`, t.Task)
+		}
+	}
+	return nil
+}
+
+func isTaskUpToDate(ctx context.Context, t *taskfile.Task) (bool, error) {
+	if len(t.Status) > 0 {
+		return isTaskUpToDateStatus(ctx, t)
+	}
+
+	checker, err := getStatusChecker(t)
+	if err != nil {
+		return false, err
+	}
+
+	return checker.IsUpToDate()
+}
+
+func statusOnError(t *taskfile.Task) error {
+	checker, err := getStatusChecker(t)
+	if err != nil {
+		return err
+	}
+	return checker.OnError()
+}
+
+func getStatusChecker(t *taskfile.Task) (status.Checker, error) {
+	switch t.Method {
+	case "", "timestamp":
+		return &status.Timestamp{
+			Dir:       t.Dir,
+			Sources:   t.Sources,
+			Generates: t.Generates,
+		}, nil
+	case "checksum":
+		return &status.Checksum{
+			Dir:     t.Dir,
+			Task:    t.Task,
+			Sources: t.Sources,
+		}, nil
+	case "none":
+		return status.None{}, nil
+	default:
+		return nil, fmt.Errorf(`task: invalid method "%s"`, t.Method)
+	}
+}
+
+func isTaskUpToDateStatus(ctx context.Context, t *taskfile.Task) (bool, error) {
+	for _, s := range t.Status {
+		err := execext.RunCommand(&execext.RunCommandOptions{
+			Context: ctx,
+			Command: s,
+			Dir:     t.Dir,
+			Env:     getEnviron(t),
+		})
+		if err != nil {
+			return false, nil
+		}
+	}
+	return true, nil
+}

task.go

@@ -1,137 +1,238 @@
 package task
 
 import (
+	"context"
 	"fmt"
-	"io/ioutil"
-	"log"
+	"io"
 	"os"
-	"os/exec"
+	"sync/atomic"
 
-	"gopkg.in/yaml.v2"
+	"github.com/go-task/task/internal/compiler"
+	compilerv1 "github.com/go-task/task/internal/compiler/v1"
+	compilerv2 "github.com/go-task/task/internal/compiler/v2"
+	"github.com/go-task/task/internal/execext"
+	"github.com/go-task/task/internal/logger"
+	"github.com/go-task/task/internal/output"
+	"github.com/go-task/task/internal/taskfile"
+	"github.com/go-task/task/internal/taskfile/version"
+
+	"github.com/Masterminds/semver"
+	"golang.org/x/sync/errgroup"
 )
 
-var (
-	TaskFilePath = "Taskfile.yml"
-	ShExists     bool
-	ShPath       string
-
-	Tasks = make(map[string]*Task)
+const (
+	// TaskFilePath is the default Taskfile
+	TaskFilePath = "Taskfile"
+	// MaximumTaskCall is the max number of times a task can be called.
+	// This exists to prevent infinite loops on cyclic dependencies
+	MaximumTaskCall = 100
 )
 
-func init() {
-	var err error
-	ShPath, err = exec.LookPath("sh")
-	if err != nil {
-		return
-	}
-	ShExists = true
+// Executor executes a Taskfile
+type Executor struct {
+	Taskfile *taskfile.Taskfile
+	Dir      string
+	Force    bool
+	Watch    bool
+	Verbose  bool
+	Silent   bool
+
+	Context context.Context
+
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+
+	Logger   *logger.Logger
+	Compiler compiler.Compiler
+	Output   output.Output
+
+	taskvars taskfile.Vars
+
+	taskCallCount map[string]*int32
 }
 
-type Task struct {
-	Cmds      []string
-	Deps      []string
-	Sources   []string
-	Generates []string
-}
-
-type TaskNotFoundError struct {
-	taskName string
-}
-
-func (err *TaskNotFoundError) Error() string {
-	return fmt.Sprintf(`Task "%s" not found`, err.taskName)
-}
-
-type TaskRunError struct {
-	taskName string
-	err      error
-}
-
-func (err *TaskRunError) Error() string {
-	return fmt.Sprintf(`Failed to run task "%s": %v`, err.taskName, err.err)
-}
-
-func Run() {
-	log.SetFlags(0)
-
-	args := os.Args[1:]
-	if len(args) == 0 {
-		log.Fatal("No argument given")
-	}
-
-	file, err := ioutil.ReadFile(TaskFilePath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			log.Fatal("Taskfile.yml not found")
-		}
-		log.Fatal(err)
-	}
-
-	if err = yaml.Unmarshal(file, &Tasks); err != nil {
-		log.Fatal(err)
-	}
-
-	for _, a := range args {
-		if err = RunTask(a); err != nil {
-			log.Fatal(err)
+// Run runs Task
+func (e *Executor) Run(calls ...taskfile.Call) error {
+	// check if given tasks exist
+	for _, c := range calls {
+		if _, ok := e.Taskfile.Tasks[c.Task]; !ok {
+			// FIXME: move to the main package
+			e.PrintTasksHelp()
+			return &taskNotFoundError{taskName: c.Task}
 		}
 	}
-}
 
-func RunTask(name string) error {
-	t, ok := Tasks[name]
-	if !ok {
-		return &TaskNotFoundError{name}
+	if e.Watch {
+		return e.watchTasks(calls...)
 	}
 
-	if isTaskUpToDate(t) {
-		log.Printf(`Task "%s" is up to date`, name)
-		return nil
-	}
-
-	for _, d := range t.Deps {
-		if err := RunTask(d); err != nil {
+	for _, c := range calls {
+		if err := e.RunTask(e.Context, c); err != nil {
 			return err
 		}
 	}
+	return nil
+}
 
-	for _, c := range t.Cmds {
-		if err := runCommand(c); err != nil {
-			return &TaskRunError{name, err}
+// Setup setups Executor's internal state
+func (e *Executor) Setup() error {
+	if err := e.readTaskfile(); err != nil {
+		return err
+	}
+
+	v, err := semver.NewConstraint(e.Taskfile.Version)
+	if err != nil {
+		return fmt.Errorf(`task: could not parse taskfile version "%s": %v`, e.Taskfile.Version, err)
+	}
+
+	if e.Context == nil {
+		e.Context = context.Background()
+	}
+	if e.Stdin == nil {
+		e.Stdin = os.Stdin
+	}
+	if e.Stdout == nil {
+		e.Stdout = os.Stdout
+	}
+	if e.Stderr == nil {
+		e.Stderr = os.Stderr
+	}
+	e.Logger = &logger.Logger{
+		Stdout:  e.Stdout,
+		Stderr:  e.Stderr,
+		Verbose: e.Verbose,
+	}
+	switch {
+	case version.IsV1(v):
+		e.Compiler = &compilerv1.CompilerV1{
+			Dir:    e.Dir,
+			Vars:   e.taskvars,
+			Logger: e.Logger,
+		}
+	case version.IsV2(v), version.IsV21(v):
+		e.Compiler = &compilerv2.CompilerV2{
+			Dir:          e.Dir,
+			Taskvars:     e.taskvars,
+			TaskfileVars: e.Taskfile.Vars,
+			Expansions:   e.Taskfile.Expansions,
+			Logger:       e.Logger,
+		}
+	case version.IsV22(v):
+		return fmt.Errorf(`task: Taskfile versions greater than v2.1 not implemented in the version of Task`)
+	}
+
+	if !version.IsV21(v) && e.Taskfile.Output != "" {
+		return fmt.Errorf(`task: Taskfile option "output" is only available starting on Taskfile version v2.1`)
+	}
+	switch e.Taskfile.Output {
+	case "", "interleaved":
+		e.Output = output.Interleaved{}
+	case "group":
+		e.Output = output.Group{}
+	case "prefixed":
+		e.Output = output.Prefixed{}
+	default:
+		return fmt.Errorf(`task: output option "%s" not recognized`, e.Taskfile.Output)
+	}
+
+	e.taskCallCount = make(map[string]*int32, len(e.Taskfile.Tasks))
+	for k := range e.Taskfile.Tasks {
+		e.taskCallCount[k] = new(int32)
+	}
+	return nil
+}
+
+// RunTask runs a task by its name
+func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
+	t, err := e.CompiledTask(call)
+	if err != nil {
+		return err
+	}
+	if !e.Watch && atomic.AddInt32(e.taskCallCount[call.Task], 1) >= MaximumTaskCall {
+		return &MaximumTaskCallExceededError{task: call.Task}
+	}
+
+	if err := e.runDeps(ctx, t); err != nil {
+		return err
+	}
+
+	if !e.Force {
+		upToDate, err := isTaskUpToDate(ctx, t)
+		if err != nil {
+			return err
+		}
+		if upToDate {
+			if !e.Silent {
+				e.Logger.Errf(`task: Task "%s" is up to date`, t.Task)
+			}
+			return nil
+		}
+	}
+
+	for i := range t.Cmds {
+		if err := e.runCommand(ctx, t, call, i); err != nil {
+			if err2 := statusOnError(t); err2 != nil {
+				e.Logger.VerboseErrf("task: error cleaning status on error: %v", err2)
+			}
+			return &taskRunError{t.Task, err}
 		}
 	}
 	return nil
 }
 
-func isTaskUpToDate(t *Task) bool {
-	if len(t.Sources) == 0 || len(t.Generates) == 0 {
-		return false
+func (e *Executor) runDeps(ctx context.Context, t *taskfile.Task) error {
+	g, ctx := errgroup.WithContext(ctx)
+
+	for _, d := range t.Deps {
+		d := d
+
+		g.Go(func() error {
+			return e.RunTask(ctx, taskfile.Call{Task: d.Task, Vars: d.Vars})
+		})
 	}
 
-	sourcesMaxTime, err := getPatternsMaxTime(t.Sources)
-	if err != nil || sourcesMaxTime.IsZero() {
-		return false
-	}
-
-	generatesMinTime, err := getPatternsMinTime(t.Generates)
-	if err != nil || generatesMinTime.IsZero() {
-		return false
-	}
-
-	return generatesMinTime.After(sourcesMaxTime)
+	return g.Wait()
 }
 
-func runCommand(c string) error {
-	var cmd *exec.Cmd
-	if ShExists {
-		cmd = exec.Command(ShPath, "-c", c)
-	} else {
-		cmd = exec.Command("cmd", "/C", c)
+func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfile.Call, i int) error {
+	cmd := t.Cmds[i]
+
+	switch {
+	case cmd.Task != "":
+		return e.RunTask(ctx, taskfile.Call{Task: cmd.Task, Vars: cmd.Vars})
+	case cmd.Cmd != "":
+		if e.Verbose || (!cmd.Silent && !t.Silent && !e.Silent) {
+			e.Logger.Errf(cmd.Cmd)
+		}
+
+		stdOut := e.Output.WrapWriter(e.Stdout, t.Prefix)
+		stdErr := e.Output.WrapWriter(e.Stderr, t.Prefix)
+		defer stdOut.Close()
+		defer stdErr.Close()
+
+		return execext.RunCommand(&execext.RunCommandOptions{
+			Context: ctx,
+			Command: cmd.Cmd,
+			Dir:     t.Dir,
+			Env:     getEnviron(t),
+			Stdin:   e.Stdin,
+			Stdout:  stdOut,
+			Stderr:  stdErr,
+		})
+	default:
+		return nil
 	}
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	if err := cmd.Run(); err != nil {
-		return err
-	}
-	return nil
+}
+
+func getEnviron(t *taskfile.Task) []string {
+	if t.Env == nil {
+		return nil
+	}
+
+	envs := os.Environ()
+	for k, v := range t.Env.ToStringMap() {
+		envs = append(envs, fmt.Sprintf("%s=%s", k, v))
+	}
+	return envs
 }

task_test.go

@@ -0,0 +1,414 @@
+package task_test
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/go-task/task"
+	"github.com/go-task/task/internal/taskfile"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// fileContentTest provides a basic reusable test-case for running a Taskfile
+// and inspect generated files.
+type fileContentTest struct {
+	Dir       string
+	Target    string
+	TrimSpace bool
+	Files     map[string]string
+}
+
+func (fct fileContentTest) name(file string) string {
+	return fmt.Sprintf("target=%q,file=%q", fct.Target, file)
+}
+
+func (fct fileContentTest) Run(t *testing.T) {
+	for f := range fct.Files {
+		_ = os.Remove(filepath.Join(fct.Dir, f))
+	}
+
+	e := &task.Executor{
+		Dir:    fct.Dir,
+		Stdout: ioutil.Discard,
+		Stderr: ioutil.Discard,
+	}
+	assert.NoError(t, e.Setup(), "e.Setup()")
+	assert.NoError(t, e.Run(taskfile.Call{Task: fct.Target}), "e.Run(target)")
+
+	for name, expectContent := range fct.Files {
+		t.Run(fct.name(name), func(t *testing.T) {
+			b, err := ioutil.ReadFile(filepath.Join(fct.Dir, name))
+			assert.NoError(t, err, "Error reading file")
+			s := string(b)
+			if fct.TrimSpace {
+				s = strings.TrimSpace(s)
+			}
+			assert.Equal(t, expectContent, s, "unexpected file content")
+		})
+	}
+
+}
+
+func TestEnv(t *testing.T) {
+	tt := fileContentTest{
+		Dir:       "testdata/env",
+		Target:    "default",
+		TrimSpace: false,
+		Files: map[string]string{
+			"env.txt": "GOOS='linux' GOARCH='amd64' CGO_ENABLED='0'\n",
+		},
+	}
+	tt.Run(t)
+}
+
+func TestVarsV1(t *testing.T) {
+	tt := fileContentTest{
+		Dir:       "testdata/vars/v1",
+		Target:    "default",
+		TrimSpace: true,
+		Files: map[string]string{
+			// hello task:
+			"foo.txt":              "foo",
+			"bar.txt":              "bar",
+			"baz.txt":              "baz",
+			"tmpl_foo.txt":         "foo",
+			"tmpl_bar.txt":         "<no value>",
+			"tmpl_foo2.txt":        "foo2",
+			"tmpl_bar2.txt":        "bar2",
+			"shtmpl_foo.txt":       "foo",
+			"shtmpl_foo2.txt":      "foo2",
+			"nestedtmpl_foo.txt":   "{{.FOO}}",
+			"nestedtmpl_foo2.txt":  "foo2",
+			"foo2.txt":             "foo2",
+			"bar2.txt":             "bar2",
+			"baz2.txt":             "baz2",
+			"tmpl2_foo.txt":        "<no value>",
+			"tmpl2_foo2.txt":       "foo2",
+			"tmpl2_bar.txt":        "<no value>",
+			"tmpl2_bar2.txt":       "<no value>",
+			"shtmpl2_foo.txt":      "<no value>",
+			"shtmpl2_foo2.txt":     "foo2",
+			"nestedtmpl2_foo2.txt": "{{.FOO2}}",
+			"override.txt":         "bar",
+		},
+	}
+	tt.Run(t)
+	// Ensure identical results when running hello task directly.
+	tt.Target = "hello"
+	tt.Run(t)
+}
+
+func TestVarsV2(t *testing.T) {
+	tt := fileContentTest{
+		Dir:       "testdata/vars/v2",
+		Target:    "default",
+		TrimSpace: true,
+		Files: map[string]string{
+			"foo.txt":              "foo",
+			"bar.txt":              "bar",
+			"baz.txt":              "baz",
+			"tmpl_foo.txt":         "foo",
+			"tmpl_bar.txt":         "bar",
+			"tmpl_foo2.txt":        "foo2",
+			"tmpl_bar2.txt":        "bar2",
+			"shtmpl_foo.txt":       "foo",
+			"shtmpl_foo2.txt":      "foo2",
+			"nestedtmpl_foo.txt":   "<no value>",
+			"nestedtmpl_foo2.txt":  "foo2",
+			"foo2.txt":             "foo2",
+			"bar2.txt":             "bar2",
+			"baz2.txt":             "baz2",
+			"tmpl2_foo.txt":        "<no value>",
+			"tmpl2_foo2.txt":       "foo2",
+			"tmpl2_bar.txt":        "<no value>",
+			"tmpl2_bar2.txt":       "bar2",
+			"shtmpl2_foo.txt":      "<no value>",
+			"shtmpl2_foo2.txt":     "foo2",
+			"nestedtmpl2_foo2.txt": "<no value>",
+			"override.txt":         "bar",
+			"nested.txt":           "Taskvars-TaskfileVars-TaskVars",
+		},
+	}
+	tt.Run(t)
+	// Ensure identical results when running hello task directly.
+	tt.Target = "hello"
+	tt.Run(t)
+}
+
+func TestMultilineVars(t *testing.T) {
+	for _, dir := range []string{"testdata/vars/v1/multiline", "testdata/vars/v2/multiline"} {
+		tt := fileContentTest{
+			Dir:       dir,
+			Target:    "default",
+			TrimSpace: false,
+			Files: map[string]string{
+				// Note:
+				// - task does not strip a trailing newline from var entries
+				// - task strips one trailing newline from shell output
+				// - the cat command adds a trailing newline
+				"echo_foobar.txt":      "foo\nbar\n",
+				"echo_n_foobar.txt":    "foo\nbar\n",
+				"echo_n_multiline.txt": "\n\nfoo\n  bar\nfoobar\n\nbaz\n\n",
+				"var_multiline.txt":    "\n\nfoo\n  bar\nfoobar\n\nbaz\n\n\n",
+				"var_catlines.txt":     "  foo   bar foobar  baz  \n",
+				"var_enumfile.txt":     "0:\n1:\n2:foo\n3:  bar\n4:foobar\n5:\n6:baz\n7:\n8:\n",
+			},
+		}
+		tt.Run(t)
+	}
+}
+
+func TestVarsInvalidTmpl(t *testing.T) {
+	const (
+		dir         = "testdata/vars/v1"
+		target      = "invalid-var-tmpl"
+		expectError = "template: :1: unexpected EOF"
+	)
+
+	e := &task.Executor{
+		Dir:    dir,
+		Stdout: ioutil.Discard,
+		Stderr: ioutil.Discard,
+	}
+	assert.NoError(t, e.Setup(), "e.Setup()")
+	assert.EqualError(t, e.Run(taskfile.Call{Task: target}), expectError, "e.Run(target)")
+}
+
+func TestParams(t *testing.T) {
+	tt := fileContentTest{
+		Dir:       "testdata/params",
+		Target:    "default",
+		TrimSpace: false,
+		Files: map[string]string{
+			"hello.txt":       "Hello\n",
+			"world.txt":       "World\n",
+			"exclamation.txt": "!\n",
+			"dep1.txt":        "Dependence1\n",
+			"dep2.txt":        "Dependence2\n",
+			"spanish.txt":     "¡Holla mundo!\n",
+			"spanish-dep.txt": "¡Holla dependencia!\n",
+			"portuguese.txt":  "Olá, mundo!\n",
+			"portuguese2.txt": "Olá, mundo!\n",
+			"german.txt":      "Welt!\n",
+		},
+	}
+	tt.Run(t)
+}
+
+func TestDeps(t *testing.T) {
+	const dir = "testdata/deps"
+
+	files := []string{
+		"d1.txt",
+		"d2.txt",
+		"d3.txt",
+		"d11.txt",
+		"d12.txt",
+		"d13.txt",
+		"d21.txt",
+		"d22.txt",
+		"d23.txt",
+		"d31.txt",
+		"d32.txt",
+		"d33.txt",
+	}
+
+	for _, f := range files {
+		_ = os.Remove(filepath.Join(dir, f))
+	}
+
+	e := &task.Executor{
+		Dir:    dir,
+		Stdout: ioutil.Discard,
+		Stderr: ioutil.Discard,
+	}
+	assert.NoError(t, e.Setup())
+	assert.NoError(t, e.Run(taskfile.Call{Task: "default"}))
+
+	for _, f := range files {
+		f = filepath.Join(dir, f)
+		if _, err := os.Stat(f); err != nil {
+			t.Errorf("File %s should exists", f)
+		}
+	}
+}
+
+func TestStatus(t *testing.T) {
+	const dir = "testdata/status"
+	var file = filepath.Join(dir, "foo.txt")
+
+	_ = os.Remove(file)
+
+	if _, err := os.Stat(file); err == nil {
+		t.Errorf("File should not exists: %v", err)
+	}
+
+	var buff bytes.Buffer
+	e := &task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+		Silent: true,
+	}
+	assert.NoError(t, e.Setup())
+	assert.NoError(t, e.Run(taskfile.Call{Task: "gen-foo"}))
+
+	if _, err := os.Stat(file); err != nil {
+		t.Errorf("File should exists: %v", err)
+	}
+
+	e.Silent = false
+	assert.NoError(t, e.Run(taskfile.Call{Task: "gen-foo"}))
+
+	if buff.String() != `task: Task "gen-foo" is up to date`+"\n" {
+		t.Errorf("Wrong output message: %s", buff.String())
+	}
+}
+
+func TestGenerates(t *testing.T) {
+	var srcTask = "sub/src.txt"
+	var relTask = "rel.txt"
+	var absTask = "abs.txt"
+
+	// This test does not work with a relative dir.
+	dir, err := filepath.Abs("testdata/generates")
+	assert.NoError(t, err)
+	var srcFile = filepath.Join(dir, srcTask)
+
+	for _, task := range []string{srcTask, relTask, absTask} {
+		path := filepath.Join(dir, task)
+		_ = os.Remove(path)
+		if _, err := os.Stat(path); err == nil {
+			t.Errorf("File should not exists: %v", err)
+		}
+	}
+
+	buff := bytes.NewBuffer(nil)
+	e := &task.Executor{
+		Dir:    dir,
+		Stdout: buff,
+		Stderr: buff,
+	}
+	assert.NoError(t, e.Setup())
+
+	for _, theTask := range []string{relTask, absTask} {
+		var destFile = filepath.Join(dir, theTask)
+		var upToDate = fmt.Sprintf("task: Task \"%s\" is up to date\n", srcTask) +
+			fmt.Sprintf("task: Task \"%s\" is up to date\n", theTask)
+
+		// Run task for the first time.
+		assert.NoError(t, e.Run(taskfile.Call{Task: theTask}))
+
+		if _, err := os.Stat(srcFile); err != nil {
+			t.Errorf("File should exists: %v", err)
+		}
+		if _, err := os.Stat(destFile); err != nil {
+			t.Errorf("File should exists: %v", err)
+		}
+		// Ensure task was not incorrectly found to be up-to-date on first run.
+		if buff.String() == upToDate {
+			t.Errorf("Wrong output message: %s", buff.String())
+		}
+		buff.Reset()
+
+		// Re-run task to ensure it's now found to be up-to-date.
+		assert.NoError(t, e.Run(taskfile.Call{Task: theTask}))
+		if buff.String() != upToDate {
+			t.Errorf("Wrong output message: %s", buff.String())
+		}
+		buff.Reset()
+	}
+}
+
+func TestStatusChecksum(t *testing.T) {
+	const dir = "testdata/checksum"
+
+	files := []string{
+		"generated.txt",
+		".task/checksum/build",
+	}
+
+	for _, f := range files {
+		_ = os.Remove(filepath.Join(dir, f))
+
+		_, err := os.Stat(filepath.Join(dir, f))
+		assert.Error(t, err)
+	}
+
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+	}
+	assert.NoError(t, e.Setup())
+
+	assert.NoError(t, e.Run(taskfile.Call{Task: "build"}))
+	for _, f := range files {
+		_, err := os.Stat(filepath.Join(dir, f))
+		assert.NoError(t, err)
+	}
+
+	buff.Reset()
+	assert.NoError(t, e.Run(taskfile.Call{Task: "build"}))
+	assert.Equal(t, `task: Task "build" is up to date`+"\n", buff.String())
+}
+
+func TestInit(t *testing.T) {
+	const dir = "testdata/init"
+	var file = filepath.Join(dir, "Taskfile.yml")
+
+	_ = os.Remove(file)
+	if _, err := os.Stat(file); err == nil {
+		t.Errorf("Taskfile.yml should not exists")
+	}
+
+	if err := task.InitTaskfile(ioutil.Discard, dir); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := os.Stat(file); err != nil {
+		t.Errorf("Taskfile.yml should exists")
+	}
+}
+
+func TestCyclicDep(t *testing.T) {
+	const dir = "testdata/cyclic"
+
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: ioutil.Discard,
+		Stderr: ioutil.Discard,
+	}
+	assert.NoError(t, e.Setup())
+	assert.IsType(t, &task.MaximumTaskCallExceededError{}, e.Run(taskfile.Call{Task: "task-1"}))
+}
+
+func TestTaskVersion(t *testing.T) {
+	tests := []struct {
+		Dir     string
+		Version string
+	}{
+		{"testdata/version/v1", "1"},
+		{"testdata/version/v2", "2"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.Dir, func(t *testing.T) {
+			e := task.Executor{
+				Dir:    test.Dir,
+				Stdout: ioutil.Discard,
+				Stderr: ioutil.Discard,
+			}
+			assert.NoError(t, e.Setup())
+			assert.Equal(t, test.Version, e.Taskfile.Version)
+			assert.Equal(t, 2, len(e.Taskfile.Tasks))
+		})
+	}
+}

taskfile.go

@@ -0,0 +1,74 @@
+package task
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+	"runtime"
+
+	"github.com/go-task/task/internal/taskfile"
+
+	"github.com/imdario/mergo"
+	"gopkg.in/yaml.v2"
+)
+
+// readTaskfile parses Taskfile from the disk
+func (e *Executor) readTaskfile() error {
+	path := filepath.Join(e.Dir, TaskFilePath)
+
+	var err error
+	e.Taskfile, err = e.readTaskfileData(path)
+	if err != nil {
+		return err
+	}
+
+	osTasks, err := e.readTaskfileData(fmt.Sprintf("%s_%s", path, runtime.GOOS))
+	if err != nil {
+		switch err.(type) {
+		case taskFileNotFound:
+		default:
+			return err
+		}
+	} else {
+		if err := mergo.MapWithOverwrite(&e.Taskfile.Tasks, osTasks.Tasks); err != nil {
+			return err
+		}
+	}
+	for name, task := range e.Taskfile.Tasks {
+		task.Task = name
+	}
+
+	return e.readTaskvars()
+}
+
+func (e *Executor) readTaskfileData(path string) (*taskfile.Taskfile, error) {
+	if b, err := ioutil.ReadFile(path + ".yml"); err == nil {
+		var taskfile taskfile.Taskfile
+		return &taskfile, yaml.Unmarshal(b, &taskfile)
+	}
+	return nil, taskFileNotFound{path}
+}
+
+func (e *Executor) readTaskvars() error {
+	var (
+		file           = filepath.Join(e.Dir, TaskvarsFilePath)
+		osSpecificFile = fmt.Sprintf("%s_%s", file, runtime.GOOS)
+	)
+
+	if b, err := ioutil.ReadFile(file + ".yml"); err == nil {
+		if err := yaml.Unmarshal(b, &e.taskvars); err != nil {
+			return err
+		}
+	}
+
+	if b, err := ioutil.ReadFile(osSpecificFile + ".yml"); err == nil {
+		osTaskvars := make(taskfile.Vars, 10)
+		if err := yaml.Unmarshal(b, &osTaskvars); err != nil {
+			return err
+		}
+		for k, v := range osTaskvars {
+			e.taskvars[k] = v
+		}
+	}
+	return nil
+}

testdata/checksum/.gitignore

@@ -0,0 +1,2 @@
+.task/
+generated.txt

testdata/checksum/Taskfile.yml

@@ -0,0 +1,8 @@
+build:
+  cmds:
+    - cp ./source.txt ./generated.txt
+  sources:
+    - ./source.txt
+  generates:
+    - ./generated.txt
+  method: checksum

testdata/checksum/source.txt

@@ -0,0 +1 @@
+Hello, World!

testdata/cyclic/Taskfile.yml

@@ -0,0 +1,7 @@
+task-1:
+  deps:
+    - task: task-2
+
+task-2:
+  deps:
+    - task: task-1

testdata/deps/.gitignore

@@ -0,0 +1 @@
+*.txt

testdata/deps/Taskfile.yml

@@ -0,0 +1,53 @@
+default:
+  deps: [d1, d2, d3]
+
+d1:
+  deps: [d11, d12, d13]
+  cmds:
+    - echo 'Text' > d1.txt
+
+d2:
+  deps: [d21, d22, d23]
+  cmds:
+    - echo 'Text' > d2.txt
+
+d3:
+  deps: [d31, d32, d33]
+  cmds:
+    - echo 'Text' > d3.txt
+
+d11:
+  cmds:
+    - echo 'Text' > d11.txt
+
+d12:
+  cmds:
+    - echo 'Text' > d12.txt
+
+d13:
+  cmds:
+    - echo 'Text' > d13.txt
+
+d21:
+  cmds:
+    - echo 'Text' > d21.txt
+
+d22:
+  cmds:
+    - echo 'Text' > d22.txt
+
+d23:
+  cmds:
+    - echo 'Text' > d23.txt
+
+d31:
+  cmds:
+    - echo 'Text' > d31.txt
+
+d32:
+  cmds:
+    - echo 'Text' > d32.txt
+
+d33:
+  cmds:
+    - echo 'Text' > d33.txt

testdata/env/.gitignore

@@ -0,0 +1 @@
+env.txt

testdata/env/Taskfile.yml

@@ -0,0 +1,10 @@
+default:
+  vars:
+    AMD64: amd64
+  env:
+    GOOS: linux
+    GOARCH: "{{.AMD64}}"
+    CGO_ENABLED:
+      sh: echo '0'
+  cmds:
+    - echo "GOOS='$GOOS' GOARCH='$GOARCH' CGO_ENABLED='$CGO_ENABLED'" > env.txt

testdata/generates/.gitignore

@@ -0,0 +1 @@
+*.txt

testdata/generates/Taskfile.yml

@@ -0,0 +1,31 @@
+abs.txt:
+  desc: generates dest file based on absolute paths
+  deps:
+    - sub/src.txt
+  dir: sub
+  cmds:
+    - cat src.txt > '{{.BUILD_DIR}}/abs.txt'
+  sources:
+    - src.txt
+  generates:
+    - "{{.BUILD_DIR}}/abs.txt"
+
+rel.txt:
+  desc: generates dest file based on relative paths
+  deps:
+    - sub/src.txt
+  dir: sub
+  cmds:
+    - cat src.txt > '../rel.txt'
+  sources:
+    - src.txt
+  generates:
+    - "../rel.txt"
+
+sub/src.txt:
+  desc: generate source file
+  cmds:
+    - mkdir -p sub
+    - echo "hello world" > sub/src.txt
+  status:
+    - test -f sub/src.txt

testdata/generates/Taskvars.yml

@@ -0,0 +1 @@
+BUILD_DIR: $pwd

testdata/init/.gitignore

@@ -0,0 +1 @@
+*.yml

testdata/params/.gitignore

@@ -0,0 +1 @@
+*.txt

testdata/params/Taskfile.yml

@@ -0,0 +1,37 @@
+default:
+  vars:
+    SPANISH: ¡Holla mundo!
+    PORTUGUESE: "{{.PORTUGUESE_HELLO_WORLD}}"
+    GERMAN: "Welt!"
+  deps:
+    - task: write-file
+      vars: {CONTENT: Dependence1, FILE: dep1.txt}
+    - task: write-file
+      vars: {CONTENT: Dependence2, FILE: dep2.txt}
+    - task: write-file
+      vars: {CONTENT: "{{.SPANISH|replace \"mundo\" \"dependencia\"}}", FILE: spanish-dep.txt}
+  cmds:
+    - task: write-file
+      vars: {CONTENT: Hello, FILE: hello.txt}
+    - task: write-file
+      vars: {CONTENT: "$echo 'World'", FILE: world.txt}
+    - task: write-file
+      vars: {CONTENT: "!", FILE: exclamation.txt}
+    - task: write-file
+      vars: {CONTENT: "{{.SPANISH}}", FILE: spanish.txt}
+    - task: write-file
+      vars: {CONTENT: "{{.PORTUGUESE}}", FILE: portuguese.txt}
+    - task: write-file
+      vars: {CONTENT: "{{.GERMAN}}", FILE: german.txt}
+    - task: non-default
+
+write-file:
+  cmds:
+    - echo {{.CONTENT}} > {{.FILE}}
+
+non-default:
+  vars:
+    PORTUGUESE: "{{.PORTUGUESE_HELLO_WORLD}}"
+  cmds:
+    - task: write-file
+      vars: {CONTENT: "{{.PORTUGUESE}}", FILE: portuguese2.txt}

testdata/params/Taskvars.yml

@@ -0,0 +1,2 @@
+PORTUGUESE_HELLO_WORLD: Olá, mundo!
+GERMAN: "Hello"

testdata/status/.gitignore

@@ -0,0 +1 @@
+*.txt

testdata/status/Taskfile.yml

@@ -0,0 +1,5 @@
+gen-foo:
+  cmds:
+    - touch foo.txt
+  status:
+    - test -f foo.txt

testdata/vars/v1/.gitignore

@@ -0,0 +1 @@
+*.txt

testdata/vars/v1/Taskfile.yml

@@ -0,0 +1,48 @@
+default:
+  deps: [hello]
+
+hello:
+  cmds:
+    - echo {{.FOO}} > foo.txt
+    - echo {{.BAR}} > bar.txt
+    - echo {{.BAZ}} > baz.txt
+    - echo '{{.TMPL_FOO}}' > tmpl_foo.txt
+    - echo '{{.TMPL_BAR}}' > tmpl_bar.txt
+    - echo '{{.TMPL_FOO2}}' > tmpl_foo2.txt
+    - echo '{{.TMPL_BAR2}}' > tmpl_bar2.txt
+    - echo '{{.SHTMPL_FOO}}' > shtmpl_foo.txt
+    - echo '{{.SHTMPL_FOO2}}' > shtmpl_foo2.txt
+    - echo '{{.NESTEDTMPL_FOO}}' > nestedtmpl_foo.txt
+    - echo '{{.NESTEDTMPL_FOO2}}' > nestedtmpl_foo2.txt
+    - echo {{.FOO2}} > foo2.txt
+    - echo {{.BAR2}} > bar2.txt
+    - echo {{.BAZ2}} > baz2.txt
+    - echo '{{.TMPL2_FOO}}' > tmpl2_foo.txt
+    - echo '{{.TMPL2_BAR}}' > tmpl2_bar.txt
+    - echo '{{.TMPL2_FOO2}}' > tmpl2_foo2.txt
+    - echo '{{.TMPL2_BAR2}}' > tmpl2_bar2.txt
+    - echo '{{.SHTMPL2_FOO}}' > shtmpl2_foo.txt
+    - echo '{{.SHTMPL2_FOO2}}' > shtmpl2_foo2.txt
+    - echo '{{.NESTEDTMPL2_FOO2}}' > nestedtmpl2_foo2.txt
+    - echo {{.OVERRIDE}} > override.txt
+  vars:
+    FOO: foo
+    BAR: $echo bar
+    BAZ:
+      sh: echo baz
+    TMPL_FOO: "{{.FOO}}"
+    TMPL_BAR: "{{.BAR}}"
+    TMPL_FOO2: "{{.FOO2}}"
+    TMPL_BAR2: "{{.BAR2}}"
+    SHTMPL_FOO:
+      sh: "echo '{{.FOO}}'"
+    SHTMPL_FOO2:
+      sh: "echo '{{.FOO2}}'"
+    NESTEDTMPL_FOO: "{{.TMPL_FOO}}"
+    NESTEDTMPL_FOO2: "{{.TMPL2_FOO2}}"
+    OVERRIDE: "bar"
+
+invalid-var-tmpl:
+  vars:
+    CHARS: "abcd"
+    INVALID: "{{range .CHARS}}no end"

testdata/vars/v1/Taskvars.yml

@@ -0,0 +1,12 @@
+FOO2: foo2
+BAR2: $echo bar2
+BAZ2:
+  sh: echo baz2
+TMPL2_FOO: "{{.FOO}}"
+TMPL2_BAR: "{{.BAR}}"
+TMPL2_FOO2: "{{.FOO2}}"
+TMPL2_BAR2: "{{.BAR2}}"
+SHTMPL2_FOO2:
+  sh: "echo '{{.FOO2}}'"
+NESTEDTMPL2_FOO2: "{{.TMPL2_FOO2}}"
+OVERRIDE: "foo"

testdata/vars/v1/multiline/Taskfile.yml

@@ -0,0 +1,43 @@
+default:
+  vars:
+    MULTILINE: "\n\nfoo\n  bar\nfoobar\n\nbaz\n\n"
+  cmds:
+    - task: file
+      vars:
+        CONTENT:
+          sh: "echo 'foo\nbar'"
+        FILE: "echo_foobar.txt"
+    - task: file
+      vars:
+        CONTENT:
+          sh: "echo -n 'foo\nbar'"
+        FILE: "echo_n_foobar.txt"
+    - task: file
+      vars:
+        CONTENT:
+          sh: echo -n "{{.MULTILINE}}"
+        FILE: "echo_n_multiline.txt"
+    - task: file
+      vars:
+        CONTENT: "{{.MULTILINE}}"
+        FILE: "var_multiline.txt"
+    - task: file
+      vars:
+        CONTENT: "{{.MULTILINE | catLines}}"
+        FILE: "var_catlines.txt"
+    - task: enumfile
+      vars:
+        LINES: "{{.MULTILINE}}"
+        FILE: "var_enumfile.txt"
+file:
+  cmds:
+    - |
+      cat << EOF > '{{.FILE}}'
+      {{.CONTENT}}
+      EOF
+enumfile:
+  cmds:
+    - |
+      cat << EOF > '{{.FILE}}'
+      {{range $i, $line := .LINES| splitLines}}{{$i}}:{{$line}}
+      {{end}}EOF

testdata/vars/v2/.gitignore

@@ -0,0 +1 @@
+*.txt

testdata/vars/v2/Taskfile.yml

@@ -0,0 +1,56 @@
+version: '2'
+
+vars:
+  NESTED2: "{{.NESTED1}}-TaskfileVars"
+
+tasks:
+  default:
+    deps: [hello]
+
+  hello:
+    cmds:
+      - echo {{.FOO}} > foo.txt
+      - echo {{.BAR}} > bar.txt
+      - echo {{.BAZ}} > baz.txt
+      - echo '{{.TMPL_FOO}}' > tmpl_foo.txt
+      - echo '{{.TMPL_BAR}}' > tmpl_bar.txt
+      - echo '{{.TMPL_FOO2}}' > tmpl_foo2.txt
+      - echo '{{.TMPL_BAR2}}' > tmpl_bar2.txt
+      - echo '{{.SHTMPL_FOO}}' > shtmpl_foo.txt
+      - echo '{{.SHTMPL_FOO2}}' > shtmpl_foo2.txt
+      - echo '{{.NESTEDTMPL_FOO}}' > nestedtmpl_foo.txt
+      - echo '{{.NESTEDTMPL_FOO2}}' > nestedtmpl_foo2.txt
+      - echo {{.FOO2}} > foo2.txt
+      - echo {{.BAR2}} > bar2.txt
+      - echo {{.BAZ2}} > baz2.txt
+      - echo '{{.TMPL2_FOO}}' > tmpl2_foo.txt
+      - echo '{{.TMPL2_BAR}}' > tmpl2_bar.txt
+      - echo '{{.TMPL2_FOO2}}' > tmpl2_foo2.txt
+      - echo '{{.TMPL2_BAR2}}' > tmpl2_bar2.txt
+      - echo '{{.SHTMPL2_FOO}}' > shtmpl2_foo.txt
+      - echo '{{.SHTMPL2_FOO2}}' > shtmpl2_foo2.txt
+      - echo '{{.NESTEDTMPL2_FOO2}}' > nestedtmpl2_foo2.txt
+      - echo {{.OVERRIDE}} > override.txt
+      - echo '{{.NESTED3}}' > nested.txt
+    vars:
+      FOO: foo
+      BAR: $echo bar
+      BAZ:
+        sh: echo baz
+      TMPL_FOO: "{{.FOO}}"
+      TMPL_BAR: "{{.BAR}}"
+      TMPL_FOO2: "{{.FOO2}}"
+      TMPL_BAR2: "{{.BAR2}}"
+      SHTMPL_FOO:
+        sh: "echo '{{.FOO}}'"
+      SHTMPL_FOO2:
+        sh: "echo '{{.FOO2}}'"
+      NESTEDTMPL_FOO: "{{.TMPL_FOO}}"
+      NESTEDTMPL_FOO2: "{{.TMPL2_FOO2}}"
+      OVERRIDE: "bar"
+      NESTED3: "{{.NESTED2}}-TaskVars"
+
+  invalid-var-tmpl:
+    vars:
+      CHARS: "abcd"
+      INVALID: "{{range .CHARS}}no end"

testdata/vars/v2/Taskvars.yml

@@ -0,0 +1,13 @@
+FOO2: foo2
+BAR2: $echo bar2
+BAZ2:
+  sh: echo baz2
+TMPL2_FOO: "{{.FOO}}"
+TMPL2_BAR: "{{.BAR}}"
+TMPL2_FOO2: "{{.FOO2}}"
+TMPL2_BAR2: "{{.BAR2}}"
+SHTMPL2_FOO2:
+  sh: "echo '{{.FOO2}}'"
+NESTEDTMPL2_FOO2: "{{.TMPL2_FOO2}}"
+OVERRIDE: "foo"
+NESTED1: "Taskvars"

testdata/vars/v2/multiline/Taskfile.yml

@@ -0,0 +1,45 @@
+version: '2'
+tasks:
+  default:
+    vars:
+      MULTILINE: "\n\nfoo\n  bar\nfoobar\n\nbaz\n\n"
+    cmds:
+      - task: file
+        vars:
+          CONTENT:
+            sh: "echo 'foo\nbar'"
+          FILE: "echo_foobar.txt"
+      - task: file
+        vars:
+          CONTENT:
+            sh: "echo -n 'foo\nbar'"
+          FILE: "echo_n_foobar.txt"
+      - task: file
+        vars:
+          CONTENT:
+            sh: echo -n "{{.MULTILINE}}"
+          FILE: "echo_n_multiline.txt"
+      - task: file
+        vars:
+          CONTENT: "{{.MULTILINE}}"
+          FILE: "var_multiline.txt"
+      - task: file
+        vars:
+          CONTENT: "{{.MULTILINE | catLines}}"
+          FILE: "var_catlines.txt"
+      - task: enumfile
+        vars:
+          LINES: "{{.MULTILINE}}"
+          FILE: "var_enumfile.txt"
+  file:
+    cmds:
+      - |
+        cat << EOF > '{{.FILE}}'
+        {{.CONTENT}}
+        EOF
+  enumfile:
+    cmds:
+      - |
+        cat << EOF > '{{.FILE}}'
+        {{range $i, $line := .LINES| splitLines}}{{$i}}:{{$line}}
+        {{end}}EOF

testdata/version/v1/Taskfile.yml

@@ -0,0 +1,9 @@
+version: 1
+tasks:
+  foo:
+    cmds:
+      - echo "Foo"
+
+  bar:
+    cmds:
+      - echo "Bar"

testdata/version/v2/Taskfile.yml

@@ -0,0 +1,9 @@
+version: 2
+tasks:
+  foo:
+    cmds:
+      - echo "Foo"
+
+  bar:
+    cmds:
+      - echo "Bar"

variables.go

@@ -0,0 +1,84 @@
+package task
+
+import (
+	"path/filepath"
+
+	"github.com/go-task/task/internal/osext"
+	"github.com/go-task/task/internal/taskfile"
+	"github.com/go-task/task/internal/templater"
+)
+
+var (
+	// TaskvarsFilePath file containing additional variables.
+	TaskvarsFilePath = "Taskvars"
+)
+
+// CompiledTask returns a copy of a task, but replacing variables in almost all
+// properties using the Go template package.
+func (e *Executor) CompiledTask(call taskfile.Call) (*taskfile.Task, error) {
+	origTask, ok := e.Taskfile.Tasks[call.Task]
+	if !ok {
+		return nil, &taskNotFoundError{call.Task}
+	}
+
+	vars, err := e.Compiler.GetVariables(origTask, call)
+	if err != nil {
+		return nil, err
+	}
+	r := templater.Templater{Vars: vars}
+
+	new := taskfile.Task{
+		Task:      origTask.Task,
+		Desc:      r.Replace(origTask.Desc),
+		Sources:   r.ReplaceSlice(origTask.Sources),
+		Generates: r.ReplaceSlice(origTask.Generates),
+		Status:    r.ReplaceSlice(origTask.Status),
+		Dir:       r.Replace(origTask.Dir),
+		Vars:      nil,
+		Env:       r.ReplaceVars(origTask.Env),
+		Silent:    origTask.Silent,
+		Method:    r.Replace(origTask.Method),
+		Prefix:    r.Replace(origTask.Prefix),
+	}
+	new.Dir, err = osext.Expand(new.Dir)
+	if err != nil {
+		return nil, err
+	}
+	if e.Dir != "" && !filepath.IsAbs(new.Dir) {
+		new.Dir = filepath.Join(e.Dir, new.Dir)
+	}
+	if new.Prefix == "" {
+		new.Prefix = new.Task
+	}
+	for k, v := range new.Env {
+		static, err := e.Compiler.HandleDynamicVar(v)
+		if err != nil {
+			return nil, err
+		}
+		new.Env[k] = taskfile.Var{Static: static}
+	}
+
+	if len(origTask.Cmds) > 0 {
+		new.Cmds = make([]*taskfile.Cmd, len(origTask.Cmds))
+		for i, cmd := range origTask.Cmds {
+			new.Cmds[i] = &taskfile.Cmd{
+				Task:   r.Replace(cmd.Task),
+				Silent: cmd.Silent,
+				Cmd:    r.Replace(cmd.Cmd),
+				Vars:   r.ReplaceVars(cmd.Vars),
+			}
+
+		}
+	}
+	if len(origTask.Deps) > 0 {
+		new.Deps = make([]*taskfile.Dep, len(origTask.Deps))
+		for i, dep := range origTask.Deps {
+			new.Deps[i] = &taskfile.Dep{
+				Task: r.Replace(dep.Task),
+				Vars: r.ReplaceVars(dep.Vars),
+			}
+		}
+	}
+
+	return &new, r.Err()
+}

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/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,406 @@
+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], ".")) || 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 {
+
+	// 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 {
+
+	// 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
+}

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,421 @@
+package semver
+
+import (
+	"bytes"
+	"encoding/json"
+	"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, 64)
+	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, 64)
+		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, 64)
+		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)
+}
+
+// UnmarshalJSON implements JSON.Unmarshaler interface.
+func (v *Version) UnmarshalJSON(b []byte) error {
+	var s string
+	if err := json.Unmarshal(b, &s); err != nil {
+		return err
+	}
+	temp, err := NewVersion(s)
+	if err != nil {
+		return err
+	}
+	v.major = temp.major
+	v.minor = temp.minor
+	v.patch = temp.patch
+	v.pre = temp.pre
+	v.metadata = temp.metadata
+	v.original = temp.original
+	temp = nil
+	return nil
+}
+
+// MarshalJSON implements JSON.Marshaler interface.
+func (v *Version) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.String())
+}
+
+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 s == "" {
+		if o != "" {
+			return -1
+		}
+		return 1
+	}
+
+	if o == "" {
+		if s != "" {
+			return 1
+		}
+		return -1
+	}
+
+	// When comparing strings "99" is greater than "103". To handle
+	// cases like this we need to detect numbers and compare them.
+
+	oi, n1 := strconv.ParseInt(o, 10, 64)
+	si, n2 := strconv.ParseInt(s, 10, 64)
+
+	// The case where both are strings compare the strings
+	if n1 != nil && n2 != nil {
+		if s > o {
+			return 1
+		}
+		return -1
+	} else if n1 != nil {
+		// o is a string and s is a number
+		return -1
+	} else if n2 != nil {
+		// s is a string and o is a number
+		return 1
+	}
+	// Both are numbers
+	if si > oi {
+		return 1
+	}
+	return -1
+
+}

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/crypto.go

@@ -0,0 +1,430 @@
+package sprig
+
+import (
+	"bytes"
+	"crypto/dsa"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/asn1"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"math/big"
+	"net"
+	"time"
+
+	"github.com/google/uuid"
+	"golang.org/x/crypto/scrypt"
+)
+
+func sha256sum(input string) string {
+	hash := sha256.Sum256([]byte(input))
+	return hex.EncodeToString(hash[:])
+}
+
+func sha1sum(input string) string {
+	hash := sha1.Sum([]byte(input))
+	return hex.EncodeToString(hash[:])
+}
+
+// uuidv4 provides a safe and secure UUID v4 implementation
+func uuidv4() string {
+	return fmt.Sprintf("%s", uuid.New())
+}
+
+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
+	}
+}
+
+type certificate struct {
+	Cert string
+	Key  string
+}
+
+func buildCustomCertificate(b64cert string, b64key string) (certificate, error) {
+	crt := certificate{}
+
+	cert, err := base64.StdEncoding.DecodeString(b64cert)
+	if err != nil {
+		return crt, errors.New("unable to decode base64 certificate")
+	}
+
+	key, err := base64.StdEncoding.DecodeString(b64key)
+	if err != nil {
+		return crt, errors.New("unable to decode base64 private key")
+	}
+
+	decodedCert, _ := pem.Decode(cert)
+	if decodedCert == nil {
+		return crt, errors.New("unable to decode certificate")
+	}
+	_, err = x509.ParseCertificate(decodedCert.Bytes)
+	if err != nil {
+		return crt, fmt.Errorf(
+			"error parsing certificate: decodedCert.Bytes: %s",
+			err,
+		)
+	}
+
+	decodedKey, _ := pem.Decode(key)
+	if decodedKey == nil {
+		return crt, errors.New("unable to decode key")
+	}
+	_, err = x509.ParsePKCS1PrivateKey(decodedKey.Bytes)
+	if err != nil {
+		return crt, fmt.Errorf(
+			"error parsing prive key: decodedKey.Bytes: %s",
+			err,
+		)
+	}
+
+	crt.Cert = string(cert)
+	crt.Key = string(key)
+
+	return crt, nil
+}
+
+func generateCertificateAuthority(
+	cn string,
+	daysValid int,
+) (certificate, error) {
+	ca := certificate{}
+
+	template, err := getBaseCertTemplate(cn, nil, nil, daysValid)
+	if err != nil {
+		return ca, err
+	}
+	// Override KeyUsage and IsCA
+	template.KeyUsage = x509.KeyUsageKeyEncipherment |
+		x509.KeyUsageDigitalSignature |
+		x509.KeyUsageCertSign
+	template.IsCA = true
+
+	priv, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		return ca, fmt.Errorf("error generating rsa key: %s", err)
+	}
+
+	ca.Cert, ca.Key, err = getCertAndKey(template, priv, template, priv)
+	if err != nil {
+		return ca, err
+	}
+
+	return ca, nil
+}
+
+func generateSelfSignedCertificate(
+	cn string,
+	ips []interface{},
+	alternateDNS []interface{},
+	daysValid int,
+) (certificate, error) {
+	cert := certificate{}
+
+	template, err := getBaseCertTemplate(cn, ips, alternateDNS, daysValid)
+	if err != nil {
+		return cert, err
+	}
+
+	priv, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		return cert, fmt.Errorf("error generating rsa key: %s", err)
+	}
+
+	cert.Cert, cert.Key, err = getCertAndKey(template, priv, template, priv)
+	if err != nil {
+		return cert, err
+	}
+
+	return cert, nil
+}
+
+func generateSignedCertificate(
+	cn string,
+	ips []interface{},
+	alternateDNS []interface{},
+	daysValid int,
+	ca certificate,
+) (certificate, error) {
+	cert := certificate{}
+
+	decodedSignerCert, _ := pem.Decode([]byte(ca.Cert))
+	if decodedSignerCert == nil {
+		return cert, errors.New("unable to decode certificate")
+	}
+	signerCert, err := x509.ParseCertificate(decodedSignerCert.Bytes)
+	if err != nil {
+		return cert, fmt.Errorf(
+			"error parsing certificate: decodedSignerCert.Bytes: %s",
+			err,
+		)
+	}
+	decodedSignerKey, _ := pem.Decode([]byte(ca.Key))
+	if decodedSignerKey == nil {
+		return cert, errors.New("unable to decode key")
+	}
+	signerKey, err := x509.ParsePKCS1PrivateKey(decodedSignerKey.Bytes)
+	if err != nil {
+		return cert, fmt.Errorf(
+			"error parsing prive key: decodedSignerKey.Bytes: %s",
+			err,
+		)
+	}
+
+	template, err := getBaseCertTemplate(cn, ips, alternateDNS, daysValid)
+	if err != nil {
+		return cert, err
+	}
+
+	priv, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		return cert, fmt.Errorf("error generating rsa key: %s", err)
+	}
+
+	cert.Cert, cert.Key, err = getCertAndKey(
+		template,
+		priv,
+		signerCert,
+		signerKey,
+	)
+	if err != nil {
+		return cert, err
+	}
+
+	return cert, nil
+}
+
+func getCertAndKey(
+	template *x509.Certificate,
+	signeeKey *rsa.PrivateKey,
+	parent *x509.Certificate,
+	signingKey *rsa.PrivateKey,
+) (string, string, error) {
+	derBytes, err := x509.CreateCertificate(
+		rand.Reader,
+		template,
+		parent,
+		&signeeKey.PublicKey,
+		signingKey,
+	)
+	if err != nil {
+		return "", "", fmt.Errorf("error creating certificate: %s", err)
+	}
+
+	certBuffer := bytes.Buffer{}
+	if err := pem.Encode(
+		&certBuffer,
+		&pem.Block{Type: "CERTIFICATE", Bytes: derBytes},
+	); err != nil {
+		return "", "", fmt.Errorf("error pem-encoding certificate: %s", err)
+	}
+
+	keyBuffer := bytes.Buffer{}
+	if err := pem.Encode(
+		&keyBuffer,
+		&pem.Block{
+			Type:  "RSA PRIVATE KEY",
+			Bytes: x509.MarshalPKCS1PrivateKey(signeeKey),
+		},
+	); err != nil {
+		return "", "", fmt.Errorf("error pem-encoding key: %s", err)
+	}
+
+	return string(certBuffer.Bytes()), string(keyBuffer.Bytes()), nil
+}
+
+func getBaseCertTemplate(
+	cn string,
+	ips []interface{},
+	alternateDNS []interface{},
+	daysValid int,
+) (*x509.Certificate, error) {
+	ipAddresses, err := getNetIPs(ips)
+	if err != nil {
+		return nil, err
+	}
+	dnsNames, err := getAlternateDNSStrs(alternateDNS)
+	if err != nil {
+		return nil, err
+	}
+	return &x509.Certificate{
+		SerialNumber: big.NewInt(1),
+		Subject: pkix.Name{
+			CommonName: cn,
+		},
+		IPAddresses: ipAddresses,
+		DNSNames:    dnsNames,
+		NotBefore:   time.Now(),
+		NotAfter:    time.Now().Add(time.Hour * 24 * time.Duration(daysValid)),
+		KeyUsage:    x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
+		ExtKeyUsage: []x509.ExtKeyUsage{
+			x509.ExtKeyUsageServerAuth,
+			x509.ExtKeyUsageClientAuth,
+		},
+		BasicConstraintsValid: true,
+	}, nil
+}
+
+func getNetIPs(ips []interface{}) ([]net.IP, error) {
+	if ips == nil {
+		return []net.IP{}, nil
+	}
+	var ipStr string
+	var ok bool
+	var netIP net.IP
+	netIPs := make([]net.IP, len(ips))
+	for i, ip := range ips {
+		ipStr, ok = ip.(string)
+		if !ok {
+			return nil, fmt.Errorf("error parsing ip: %v is not a string", ip)
+		}
+		netIP = net.ParseIP(ipStr)
+		if netIP == nil {
+			return nil, fmt.Errorf("error parsing ip: %s", ipStr)
+		}
+		netIPs[i] = netIP
+	}
+	return netIPs, nil
+}
+
+func getAlternateDNSStrs(alternateDNS []interface{}) ([]string, error) {
+	if alternateDNS == nil {
+		return []string{}, nil
+	}
+	var dnsStr string
+	var ok bool
+	alternateDNSStrs := make([]string, len(alternateDNS))
+	for i, dns := range alternateDNS {
+		dnsStr, ok = dns.(string)
+		if !ok {
+			return nil, fmt.Errorf(
+				"error processing alternate dns name: %v is not a string",
+				dns,
+			)
+		}
+		alternateDNSStrs[i] = dnsStr
+	}
+	return alternateDNSStrs, nil
+}

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

@@ -0,0 +1,76 @@
+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)
+}
+
+func dateAgo(date interface{}) 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)
+	}
+	// Drop resolution to seconds
+	duration := time.Since(t).Round(time.Second)
+	return duration.String()
+}
+
+func toDate(fmt, str string) time.Time {
+	t, _ := time.ParseInLocation(fmt, str, time.Local)
+	return t
+}

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

@@ -0,0 +1,84 @@
+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)
+}
+
+// ternary returns the first value if the last value is true, otherwise returns the second value.
+func ternary(vt interface{}, vf interface{}, v bool) interface{} {
+	if v {
+		return vt
+	}
+
+	return vf
+}

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

@@ -0,0 +1,88 @@
+package sprig
+
+import "github.com/imdario/mergo"
+
+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(dicts ...map[string]interface{}) []string {
+	k := []string{}
+	for _, dict := range dicts {
+		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
+}
+
+func merge(dst map[string]interface{}, srcs ...map[string]interface{}) interface{} {
+	for _, src := range srcs {
+		if err := mergo.Merge(&dst, src); err != nil {
+			// Swallow errors inside of a template.
+			return ""
+		}
+	}
+	return dst
+}

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

@@ -0,0 +1,233 @@
+/*
+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.
+	- swapcase: SwapCase swaps the case of a string using a word based algorithm. see https://godoc.org/github.com/Masterminds/goutils#SwapCase
+	- shuffle: Shuffle randomizes runes in a string and returns the result. It uses default random source in `math/rand`
+	- snakecase: convert all upper case characters in a string to underscore format.
+	- camelcase: convert all lower case characters behind underscores to upper case character
+	- 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"
+	- nindent: Indent a string using space characters and prepend a new line. `indent 4 "foo\nbar"` produces "\n    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.
+	- int64: 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]'
+	- ternary: Given a value,'true | ternary "b" "c"' will return "b".
+	  'false | ternary "b" "c"' will return '"c"'. Similar to the JavaScript ternary
+	  operator.
+
+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.Sprintf("%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 one or more dicts.
+	- 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,281 @@
+package sprig
+
+import (
+	"errors"
+	"html/template"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+	ttemplate "text/template"
+	"time"
+
+	util "github.com/aokoli/goutils"
+	"github.com/huandu/xstrings"
+)
+
+// 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,
+	"ago":            dateAgo,
+	"toDate":         toDate,
+
+	// 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,
+	"shuffle":      xstrings.Shuffle,
+	"snakecase":    xstrings.ToSnakeCase,
+	"camelcase":    xstrings.ToCamelCase,
+	"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,
+	"nindent":   nindent,
+	"replace":   replace,
+	"plural":    plural,
+	"sha1sum":   sha1sum,
+	"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,
+	"ceil":    ceil,
+	"floor":   floor,
+	"round":   round,
+
+	// 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,
+	"ternary":      ternary,
+
+	// 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,
+	"merge":  merge,
+
+	"append": push, "push": push,
+	"prepend": prepend,
+	"first":   first,
+	"rest":    rest,
+	"last":    last,
+	"initial": initial,
+	"reverse": reverse,
+	"uniq":    uniq,
+	"without": without,
+	"has":     has,
+
+	// Crypto:
+	"genPrivateKey":     generatePrivateKey,
+	"derivePassword":    derivePassword,
+	"buildCustomCert":   buildCustomCertificate,
+	"genCA":             generateCertificateAuthority,
+	"genSelfSignedCert": generateSelfSignedCertificate,
+	"genSignedCert":     generateSignedCertificate,
+
+	// UUIDs:
+	"uuidv4": uuidv4,
+
+	// SemVer:
+	"semver":        semver,
+	"semverCompare": semverCompare,
+
+	// Flow Control:
+	"fail": func(msg string) (string, error) { return "", errors.New(msg) },
+
+	// Regex
+	"regexMatch":             regexMatch,
+	"regexFindAll":           regexFindAll,
+	"regexFind":              regexFind,
+	"regexReplaceAll":        regexReplaceAll,
+	"regexReplaceAllLiteral": regexReplaceAllLiteral,
+	"regexSplit":             regexSplit,
+}

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

@@ -0,0 +1,259 @@
+package sprig
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+)
+
+// Reflection is used in these functions so that slices and arrays of strings,
+// ints, and other types not implementing []interface{} can be worked with.
+// For example, this is useful if you need to work on the output of regexs.
+
+func list(v ...interface{}) []interface{} {
+	return v
+}
+
+func push(list interface{}, v interface{}) []interface{} {
+	tp := reflect.TypeOf(list).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(list)
+
+		l := l2.Len()
+		nl := make([]interface{}, l)
+		for i := 0; i < l; i++ {
+			nl[i] = l2.Index(i).Interface()
+		}
+
+		return append(nl, v)
+
+	default:
+		panic(fmt.Sprintf("Cannot push on type %s", tp))
+	}
+}
+
+func prepend(list interface{}, v interface{}) []interface{} {
+	//return append([]interface{}{v}, list...)
+
+	tp := reflect.TypeOf(list).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(list)
+
+		l := l2.Len()
+		nl := make([]interface{}, l)
+		for i := 0; i < l; i++ {
+			nl[i] = l2.Index(i).Interface()
+		}
+
+		return append([]interface{}{v}, nl...)
+
+	default:
+		panic(fmt.Sprintf("Cannot prepend on type %s", tp))
+	}
+}
+
+func last(list interface{}) interface{} {
+	tp := reflect.TypeOf(list).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(list)
+
+		l := l2.Len()
+		if l == 0 {
+			return nil
+		}
+
+		return l2.Index(l - 1).Interface()
+	default:
+		panic(fmt.Sprintf("Cannot find last on type %s", tp))
+	}
+}
+
+func first(list interface{}) interface{} {
+	tp := reflect.TypeOf(list).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(list)
+
+		l := l2.Len()
+		if l == 0 {
+			return nil
+		}
+
+		return l2.Index(0).Interface()
+	default:
+		panic(fmt.Sprintf("Cannot find first on type %s", tp))
+	}
+}
+
+func rest(list interface{}) []interface{} {
+	tp := reflect.TypeOf(list).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(list)
+
+		l := l2.Len()
+		if l == 0 {
+			return nil
+		}
+
+		nl := make([]interface{}, l-1)
+		for i := 1; i < l; i++ {
+			nl[i-1] = l2.Index(i).Interface()
+		}
+
+		return nl
+	default:
+		panic(fmt.Sprintf("Cannot find rest on type %s", tp))
+	}
+}
+
+func initial(list interface{}) []interface{} {
+	tp := reflect.TypeOf(list).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(list)
+
+		l := l2.Len()
+		if l == 0 {
+			return nil
+		}
+
+		nl := make([]interface{}, l-1)
+		for i := 0; i < l-1; i++ {
+			nl[i] = l2.Index(i).Interface()
+		}
+
+		return nl
+	default:
+		panic(fmt.Sprintf("Cannot find initial on type %s", tp))
+	}
+}
+
+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{} {
+	tp := reflect.TypeOf(v).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(v)
+
+		l := l2.Len()
+		// We do not sort in place because the incoming array should not be altered.
+		nl := make([]interface{}, l)
+		for i := 0; i < l; i++ {
+			nl[l-i-1] = l2.Index(i).Interface()
+		}
+
+		return nl
+	default:
+		panic(fmt.Sprintf("Cannot find reverse on type %s", tp))
+	}
+}
+
+func compact(list interface{}) []interface{} {
+	tp := reflect.TypeOf(list).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(list)
+
+		l := l2.Len()
+		nl := []interface{}{}
+		var item interface{}
+		for i := 0; i < l; i++ {
+			item = l2.Index(i).Interface()
+			if !empty(item) {
+				nl = append(nl, item)
+			}
+		}
+
+		return nl
+	default:
+		panic(fmt.Sprintf("Cannot compact on type %s", tp))
+	}
+}
+
+func uniq(list interface{}) []interface{} {
+	tp := reflect.TypeOf(list).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(list)
+
+		l := l2.Len()
+		dest := []interface{}{}
+		var item interface{}
+		for i := 0; i < l; i++ {
+			item = l2.Index(i).Interface()
+			if !inList(dest, item) {
+				dest = append(dest, item)
+			}
+		}
+
+		return dest
+	default:
+		panic(fmt.Sprintf("Cannot find uniq on type %s", tp))
+	}
+}
+
+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{} {
+	tp := reflect.TypeOf(list).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(list)
+
+		l := l2.Len()
+		res := []interface{}{}
+		var item interface{}
+		for i := 0; i < l; i++ {
+			item = l2.Index(i).Interface()
+			if !inList(omit, item) {
+				res = append(res, item)
+			}
+		}
+
+		return res
+	default:
+		panic(fmt.Sprintf("Cannot find without on type %s", tp))
+	}
+}
+
+func has(needle interface{}, haystack interface{}) bool {
+	tp := reflect.TypeOf(haystack).Kind()
+	switch tp {
+	case reflect.Slice, reflect.Array:
+		l2 := reflect.ValueOf(haystack)
+		var item interface{}
+		l := l2.Len()
+		for i := 0; i < l; i++ {
+			item = l2.Index(i).Interface()
+			if reflect.DeepEqual(needle, item) {
+				return true
+			}
+		}
+
+		return false
+	default:
+		panic(fmt.Sprintf("Cannot find has on type %s", tp))
+	}
+}

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

@@ -0,0 +1,159 @@
+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
+}
+
+func floor(a interface{}) float64 {
+	aa := toFloat64(a)
+	return math.Floor(aa)
+}
+
+func ceil(a interface{}) float64 {
+	aa := toFloat64(a)
+	return math.Ceil(aa)
+}
+
+func round(a interface{}, p int, r_opt ...float64) float64 {
+	roundOn := .5
+	if len(r_opt) > 0 {
+		roundOn = r_opt[0]
+	}
+	val := toFloat64(a)
+	places := toFloat64(p)
+
+	var round float64
+	pow := math.Pow(10, places)
+	digit := pow * val
+	_, div := math.Modf(digit)
+	if div >= roundOn {
+		round = math.Ceil(digit)
+	} else {
+		round = math.Floor(digit)
+	}
+	return round / pow
+}

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/regex.go

@@ -0,0 +1,35 @@
+package sprig
+
+import (
+	"regexp"
+)
+
+func regexMatch(regex string, s string) bool {
+	match, _ := regexp.MatchString(regex, s)
+	return match
+}
+
+func regexFindAll(regex string, s string, n int) []string {
+	r := regexp.MustCompile(regex)
+	return r.FindAllString(s, n)
+}
+
+func regexFind(regex string, s string) string {
+	r := regexp.MustCompile(regex)
+	return r.FindString(s)
+}
+
+func regexReplaceAll(regex string, s string, repl string) string {
+	r := regexp.MustCompile(regex)
+	return r.ReplaceAllString(s, repl)
+}
+
+func regexReplaceAllLiteral(regex string, s string, repl string) string {
+	r := regexp.MustCompile(regex)
+	return r.ReplaceAllLiteralString(s, repl)
+}
+
+func regexSplit(regex string, s string, n int) []string {
+	r := regexp.MustCompile(regex)
+	return r.Split(s, n)
+}

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,201 @@
+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 nindent(spaces int, v string) string {
+	return "\n" + indent(spaces, v)
+}
+
+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.