v2.1.1

Closes #132

.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,6 @@
+* Bug reports and feature requests are welcome in [the issues][issues]
+* 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

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,6 @@
+<!--
+If relevant, include the following information:
+- Task version
+- OS
+- Example Taskfile showing the issue
+-->

.gitignore

@@ -15,3 +15,5 @@
 
 ./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,188 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  branch = "master"
+  digest = "1:f3960e064201714a3507bf96183be246b3d941568af01dc5cff2a388ac4c7515"
+  name = "github.com/Masterminds/semver"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "c84ddcca87bf5a941b138dde832a7e20b0159ad8"
+
+[[projects]]
+  branch = "master"
+  digest = "1:58551c80f84fd3ba2954668f5f850a8179dc3c5bb4885fc7eed5a8e2ae815c99"
+  name = "github.com/Masterminds/sprig"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "77bb58b7f5e10889a1195c21b9e7a96ee166f199"
+
+[[projects]]
+  digest = "1:975108e8d4f5dab096fc991326e96a5716ee8d02e5e7386bb4796171afc4ab9a"
+  name = "github.com/aokoli/goutils"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "3391d3790d23d03408670993e957e8f408993c34"
+  version = "v1.0.1"
+
+[[projects]]
+  digest = "1:ffe9824d294da03b391f44e1ae8281281b4afc1bdaa9588c9097785e3af10cec"
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  pruneopts = "NUT"
+  revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73"
+  version = "v1.1.1"
+
+[[projects]]
+  digest = "1:a1578f7323eca2b88021fdc9a79a99833d40b12c32a5ea4f284e2fad19ea2657"
+  name = "github.com/google/uuid"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "d460ce9f8df2e77fb1ba55ca87fafed96c607494"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:ed24122ea28f4f65f82f5b4703389fdbb5f246efc971e4d74f01f7c47c0b81b2"
+  name = "github.com/huandu/xstrings"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "55ae428c2ac4f74d7430952ef528631e656ac92c"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:9a52adf44086cead3b384e5d0dbf7a1c1cce65e67552ee3383a8561c42a18cd3"
+  name = "github.com/imdario/mergo"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "9f23e2d6bd2a77f959b2bf6acdbefd708a83a4a4"
+  version = "v0.3.6"
+
+[[projects]]
+  branch = "master"
+  digest = "1:729c1199021f057f38487f7e64432f3539f9efac444185e64b4b7e121414ac68"
+  name = "github.com/mattn/go-zglob"
+  packages = [
+    ".",
+    "fastwalk",
+  ]
+  pruneopts = "NUT"
+  revision = "2ea3427bfa539cca900ca2768d8663ecc8a708c1"
+
+[[projects]]
+  digest = "1:a4df73029d2c42fabcb6b41e327d2f87e685284ec03edf76921c267d9cfc9c23"
+  name = "github.com/mitchellh/go-homedir"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "ae18d6b8b3205b561c79e8e5f69bff09736185f4"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:0028cb19b2e4c3112225cd871870f2d9cf49b9b4276531f03438a88e94be86fe"
+  name = "github.com/pmezard/go-difflib"
+  packages = ["difflib"]
+  pruneopts = "NUT"
+  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:5089085e1b27a57be4fb7acf32bfa71fb6236dc0e8371165651c9e15285a9ce0"
+  name = "github.com/radovskyb/watcher"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "0d9d32686dbf6395752c9b209398a59e302a7f1e"
+
+[[projects]]
+  branch = "master"
+  digest = "1:9d8420bbf131d1618bde6530af37c3799340d3762cc47210c1d9532a4c3a2779"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
+
+[[projects]]
+  digest = "1:bacb8b590716ab7c33f2277240972c9582d389593ee8d66fc10074e0508b8126"
+  name = "github.com/stretchr/testify"
+  packages = ["assert"]
+  pruneopts = "NUT"
+  revision = "f35b8ab0b5a2cef36673838d662e249dd9c94686"
+  version = "v1.2.2"
+
+[[projects]]
+  branch = "master"
+  digest = "1:69b3fcb7a41b18436a85471cbdcfc70ad10ba3206f8c87563e1c773610e1bcad"
+  name = "golang.org/x/crypto"
+  packages = [
+    "pbkdf2",
+    "scrypt",
+    "ssh/terminal",
+  ]
+  pruneopts = "NUT"
+  revision = "182538f80094b6a8efaade63a8fd8e0d9d5843dd"
+
+[[projects]]
+  branch = "master"
+  digest = "1:76ee51c3f468493aff39dbacc401e8831fbb765104cbf613b89bef01cf4bad70"
+  name = "golang.org/x/net"
+  packages = ["context"]
+  pruneopts = "NUT"
+  revision = "8a410e7b638dca158bf9e766925842f6651ff828"
+
+[[projects]]
+  branch = "master"
+  digest = "1:39ebcc2b11457b703ae9ee2e8cca0f68df21969c6102cb3b705f76cca0ea0239"
+  name = "golang.org/x/sync"
+  packages = ["errgroup"]
+  pruneopts = "NUT"
+  revision = "1d60e4601c6fd243af51cc01ddf169918a5407ca"
+
+[[projects]]
+  branch = "master"
+  digest = "1:8270f14d85e8d36e852e018872ac923f7a2067648bfe8428d01be288818aa337"
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows",
+  ]
+  pruneopts = "NUT"
+  revision = "fa5fdf94c78965f1aa8423f0cc50b8b8d728b05a"
+
+[[projects]]
+  branch = "v2"
+  digest = "1:7c95b35057a0ff2e19f707173cc1a947fa43a6eb5c4d300d196ece0334046082"
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+
+[[projects]]
+  branch = "master"
+  digest = "1:e647f1f4fcc94a6baad3965a347c1ac4ed669f31c87c826516314e415d1a4ad2"
+  name = "mvdan.cc/sh"
+  packages = [
+    "interp",
+    "shell",
+    "syntax",
+  ]
+  pruneopts = "NUT"
+  revision = "3a244a89e2e520d2777e94693d51bef800761879"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "github.com/Masterminds/semver",
+    "github.com/Masterminds/sprig",
+    "github.com/mattn/go-zglob",
+    "github.com/mitchellh/go-homedir",
+    "github.com/radovskyb/watcher",
+    "github.com/spf13/pflag",
+    "github.com/stretchr/testify/assert",
+    "golang.org/x/sync/errgroup",
+    "gopkg.in/yaml.v2",
+    "mvdan.cc/sh/interp",
+    "mvdan.cc/sh/shell",
+    "mvdan.cc/sh/syntax",
+  ]
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,36 @@
+[prune]
+  unused-packages = true
+  non-go = true
+  go-tests = true
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/Masterminds/sprig"
+
+[[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,36 +1,102 @@
-[![Join the chat at https://gitter.im/go-task/task](https://badges.gitter.im/go-task/task.svg)](https://gitter.im/go-task/task?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Build Status](https://travis-ci.org/go-task/task.svg?branch=master)](https://travis-ci.org/go-task/task)
 
-# Task - Simple "Make" alternative
+# 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)
+  - [Dry run mode](#dry-run-mode)
+  - [Ignore errors](#ignore-errors)
+  - [Output syntax](#output-syntax)
+  - [Watch tasks](#watch-tasks-experimental)
+- [Examples](#examples)
+- [Alternative task runners](#alternative-task-runners)
+
 ## Installation
 
-If you have a [Go][golang] 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
 ```
 
-Or you can download from the [releases][releases] page and add to 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` in the root of the project.
-(`Taskfile.toml` and `Taskfile.json` are also supported, but YAML is used in
-the documentation). The `cmds` attribute 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:
@@ -39,72 +105,100 @@ Running the tasks is as simple as running:
 task assets build
 ```
 
-If Bash is available (Linux and Windows while on Git Bash), the commands will
-run in Bash, otherwise will fallback to `cmd` (on Windows).
+Task uses [github.com/mvdan/sh](https://github.com/mvdan/sh), a native Go sh
+interpreter. So you can write sh/bash commands and it will work even on
+Windows, where `sh` or `bash` 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
-build:
-  cmds:
-  - echo $hallo
-  env:
-    hallo: welt
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - echo $hallo
+    env:
+      hallo: welt
 ```
 
-### OS specific task support
+### OS specific task
 
-If you add a `Taskfile_{{GOOS}}` you can override or amend your taskfile based on the op;erating system.
+If you add a `Taskfile_{{GOOS}}.yml` you can override or amend your Taskfile
+based on the operating system.
 
 Example:
 
 Taskfile.yml:
 
 ```yml
-build:
-  cmds:
-  - echo  "default"
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - echo "default"
 ```
 
 Taskfile_linux.yml:
 
 ```yml
-build:
-  cmds:
-  - echo  "linux"
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - echo "linux"
 ```
 
-Will print out `linux` and not default
+Will print out `linux` and not `default`.
 
-### Running task in another dir
+Keep in mind that the version of the files should match. Also, when redefining
+a task the whole task is replaced, properties of the task are not merged.
+
+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
-js:
-  dir: www/public/js
-  cmds:
-    - gulp
+version: '2'
+
+tasks:
+  serve:
+    dir: public/www
+    cmds:
+      # run http server
+      - caddy
 ```
 
 ### Task dependencies
 
-You may have tasks that depends on others. Just pointing them on `deps` will
+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
@@ -113,169 +207,583 @@ 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
 ```
 
-Each task can only be run once. If it is included from another dependend task causing
-a cyclomatic dependency, execution will be stopped.
+If there is more than one dependency, they always run in parallel for better
+performance.
+
+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
-task1:
-  deps: [task2]
+version: '2'
 
-task2:
-  deps: [task1]
+tasks:
+  default:
+    deps:
+      - task: echo_sth
+        vars: {TEXT: "before 1"}
+      - task: echo_sth
+        vars: {TEXT: "before 2"}
+    cmds:
+      - echo "after"
+
+  echo_sth:
+    cmds:
+      - echo {{.TEXT}}
 ```
 
-Will stop at the moment the dependencies of `task2` are executed.
+### Calling another task
 
-### Prevent task from running when not necessary
+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
-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:
+  build:
+    deps: [js, css]
+    cmds:
+      - go build -v -i main.go
 
-css:
-  cmds:
-    - npm run buildcss
-  sources:
-    - css/src/*.css
-  generates:
-    - public/bundle.css
+  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` 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
+`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).
+
+```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
 
-```yml
-build:
-  deps: [setvar]
-  cmds:
-  - echo "{{.PREFIX}} {{.THEVAR}}"
-  vars:
-    PREFIX: "Path:"
+When doing interpolation of variables, Task will look for the below.
+They are listed below in order of importance (e.g. most important first):
 
-setvar:
-  cmds:
-  - echo "{{.PATH}}"
-  set: THEVAR
+- 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
 ```
 
-The above sample saves the path into a new variable which is then again echoed.
+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.
 
-You can use environment variables, task level variables and a file called
-`Taskvars.yml` (or `Taskvars.toml` or `Taskvars.json`) as source of variables.
+```bash
+$ task write-file FILE=file.txt "CONTENT=Hello, World!" print "MESSAGE=All done!"
+```
 
-They are evaluated in the following order:
-
-Task local variables are overwritten by variables found in `Taskvars` file.
-Variables found in `Taskvars` file are overwritten with variables from the
-environment. The output of the last command is stored in the environment. So
-you can do something like this:
+Example of locally declared vars:
 
 ```yml
-build:
-  deps: [setvar]
-  cmds:
-  - echo "{{.PREFIX}} '{{.THEVAR}}'"
-  vars:
-    PREFIX: "Result: "
+version: '2'
 
-setvar:
-  cmds:
-  - echo -n "a"
-  - echo -n "{{.THEVAR}}b"
-  - echo -n "{{.THEVAR}}c"
-  set: THEVAR
+tasks:
+  print-var:
+    cmds:
+      echo "{{.VAR}}"
+    vars:
+      VAR: Hello!
 ```
 
-The result of a run of build would be:
+Example of global vars in a `Taskfile.yml`:
 
+```yml
+version: '2'
+
+vars:
+  GREETING: Hello from Taskfile!
+
+tasks:
+  greet:
+    cmds:
+      - echo "{{.GREETING}}"
 ```
-a
-ab
-abc
-Result:  'abc'
+
+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
 
-If you prefix a variable with `$`, then the variable is considered a dynamic
-variable. The value after the $-symbol will be treated as a command and the
-output assigned.
+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
-build:
-  cmds:
-    - go build -ldflags="-X main.Version={{.LAST_GIT_COMMIT}}" main.go
-  vars:
-    LAST_GIT_COMMIT: $git log -n 1 --format=%h
+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 acessible through dot syntax (`.VARNAME`). The following
-functions are available:
+them. Variables are accessible through dot syntax (`.VARNAME`).
 
-- `OS`: return operating system. Possible values are "windows", "linux",
+All functions by the Go's [sprig lib](http://masterminds.github.io/sprig/)
+are available. The following example gets the current date in a given format:
+
+```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".
-- `IsSH`: on unix systems this should always return `true`. On Windows, will
-  return `true` if `sh` command was found (Git Bash). In this case commands
-  will run on `sh`. Otherwise, this function will return `false` meaning
-  commands will run on `cmd`.
+- `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
-printos:
-  cmds:
-    - echo '{{OS}} {{ARCH}}'
-    - "echo '{{if eq OS \"windows\"}}windows-command{{else}}unix-command{{end}}'"
-    - echo 'Is SH? {{IsSH}}'
+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
 ```
 
-## Alternatives
+### Help
 
-Similar software:
+Running `task --list` (or `task -l`) lists all tasks with a description.
+The following taskfile:
 
-- [tj/robo][robo]
-- [dogtools/dog][dog]
+```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
+```
+
+## Dry run mode
+
+Dry run mode (`--dry`) compiles and steps through each task, printing the commands
+that would be run without executing them. This is useful for debugging your Taskfiles.
+
+## Ignore errors
+
+You have the option to ignore errors during command execution.
+Given the following Taskfile:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - exit 1
+      - echo "Hello World"
+```
+
+Task will abort the execution after running `exit 1` because the status code `1` stands for `EXIT_FAILURE`.
+However it is possible to continue with execution using `ignore_error`:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - cmd: exit 1
+        ignore_error: true
+      - echo "Hello World"
+```
+
+`ignore_error` can also be set for a task, which mean errors will be supressed
+for all commands. But keep in mind this option won't propagate to other tasks
+called either by `deps` or `cmds`!
+
+## 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:
+  - [rliebz/tusk][tusk]
+- Go based:
+  - [magefile/mage][mage]
+- Make based or similar:
+  - [casey/just][just]
+
+### 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/
-[robo]: https://github.com/tj/robo
-[dog]: https://github.com/dogtools/dog
+[tusk]: https://github.com/rliebz/tusk
+[mage]: https://github.com/magefile/mage
+[just]: https://github.com/casey/just
+[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 both `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,132 @@
+# 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}}"
+```
+
+## Version 2.1
+
+Version 2.1 includes a global `output` option, to allow having more control
+over how commands output are printed to the console
+(see [documentation][output] for more info):
+
+```yml
+version: '2'
+
+output: prefixed
+
+tasks:
+  server:
+    cmds:
+      - go run main.go
+  prefix: server
+```
+
+From this version it's not also possible to ignore errors of a command or task
+(check documentatio [here][ignore_errors]):
+
+```yml
+version: '2'
+
+tasks:
+  example-1:
+    cmds:
+      - cmd: exit 1
+        ignore_error: true
+      - echo "This will be print"
+
+  example-2:
+    cmds:
+      - exit 1
+      - echo "This will be print"
+    ignore_error: true
+```
+
+[output]: https://github.com/go-task/task#output-syntax
+[ignore_errors]: https://github.com/go-task/task#ignore-errors

Taskfile.yml

@@ -1,20 +1,81 @@
-# compiles current source code and make "task" executable available on
-# $GOPATH/bin/task{.exe}
-install:
-  cmds:
-    - go install -v ./...
+version: '2'
 
-lint:
-  cmds:
-    - golint .
-    - golint ./cmd/task
+vars:
+  GIT_COMMIT:
+    sh: git log -n 1 --format=%h
 
-# TODO: have tests
-test:
-  cmds:
-    - go test -v
+  GO_PACKAGES:
+    sh: go list ./...
 
-# https://github.com/goreleaser/goreleaser
-release:
-  cmds:
-    - goreleaser
+tasks:
+  default:
+    cmds:
+      - task: test
+
+  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/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 {{catLines .GO_PACKAGES}}
+    silent: true
+
+  test:
+    desc: Runs test suite
+    deps: [install]
+    cmds:
+      - go test {{catLines .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
+
+  ci:
+    cmds:
+      - task: go-get
+        vars: {REPO: github.com/golang/lint/golint}
+      - task: lint
+      - task: test
+
+  go-get:
+    cmds:
+      - go get -u {{.REPO}}
+
+  packages:
+    cmds:
+      - echo '{{.GO_PACKAGES}}'
+    silent: true

cmd/task/task.go

@@ -1,19 +1,30 @@
 package main
 
 import (
-	"fmt"
+	"context"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
 
 	"github.com/go-task/task"
+	"github.com/go-task/task/internal/args"
 
 	"github.com/spf13/pflag"
 )
 
-func main() {
-	pflag.Usage = func() {
-		fmt.Println(`task [target1 target2 ...]: Runs commands under targets like make.
+var (
+	version = "master"
+)
+
+const usage = `Usage: task [-ilfwvsd] [--init] [--list] [--force] [--watch] [--verbose] [--silent] [--dir] [--dry] [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".
 
-Example: 'task hello' with the following 'Taskfile.yml' file will generate
-an 'output.txt' file.
 '''
 hello:
   cmds:
@@ -22,10 +33,119 @@ hello:
   generates:
     - output.txt
 '''
-`)
+
+Options:
+`
+
+func main() {
+	log.SetFlags(0)
+	log.SetOutput(os.Stderr)
+
+	pflag.Usage = func() {
+		log.Print(usage)
 		pflag.PrintDefaults()
 	}
-	pflag.BoolVarP(&task.Force, "force", "f", false, "forces execution even when the task is up-to-date")
+
+	var (
+		versionFlag bool
+		init        bool
+		list        bool
+		status      bool
+		force       bool
+		watch       bool
+		verbose     bool
+		silent      bool
+		dry         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.BoolVar(&dry, "dry", false, "compiles and prints tasks in the order that they would be run, without executing them")
+	pflag.StringVarP(&dir, "dir", "d", "", "sets directory of execution")
 	pflag.Parse()
-	task.Run()
+
+	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
+	}
+
+	ctx := context.Background()
+	if !watch {
+		ctx = getSignalContext()
+	}
+
+	e := task.Executor{
+		Force:   force,
+		Watch:   watch,
+		Verbose: verbose,
+		Silent:  silent,
+		Dir:     dir,
+		Dry:     dry,
+
+		Context: ctx,
+
+		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,25 @@
+#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' \
+    '(--dry)'--dry \
+    '(-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

@@ -1,16 +1,14 @@
 package task
 
 import (
+	"errors"
 	"fmt"
 )
 
-type taskFileNotFound struct {
-	taskFile string
-}
-
-func (err taskFileNotFound) Error() string {
-	return fmt.Sprintf(`task: No task file found (is it named "%s"?)`, err.taskFile)
-}
+var (
+	// ErrTaskfileAlreadyExists is returned on creating a Taskfile if one already exists
+	ErrTaskfileAlreadyExists = errors.New("task: A Taskfile already exists")
+)
 
 type taskNotFoundError struct {
 	taskName string
@@ -29,10 +27,17 @@ func (err *taskRunError) Error() string {
 	return fmt.Sprintf(`task: Failed to run task "%s": %v`, err.taskName, err.err)
 }
 
-type cyclicDepError struct {
-	taskName string
+// 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 (err *cyclicDepError) Error() string {
-	return fmt.Sprintf(`task: Cyclic dependency of task "%s" detected`, err.taskName)
+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,
+	)
 }

example/Taskfile.json

@@ -1,11 +0,0 @@
-{
-  "hello": {
-    "cmds": [
-      "echo \"I am going to write a file named 'output.txt' now.\"",
-      "echo \"hello\" > output.txt"
-    ],
-    "generates": [
-      "output.txt"
-    ]
-  }
-}

example/Taskfile.toml

@@ -1,6 +0,0 @@
-[hello]
-cmds = [
-  "echo \"I am going to write a file named 'output.txt' now.\"",
-  "echo \"hello\" > output.txt"
-]
-generates = ["output.txt"]

example/Taskfile.yml

@@ -1,6 +0,0 @@
-hello:
-  cmds:
-    - echo "I am going to write a file named 'output.txt' now."
-    - echo "hello" > output.txt
-  generates:
-    - output.txt

file.go

@@ -1,82 +0,0 @@
-package task
-
-import (
-	"os"
-	"time"
-
-	"github.com/mattn/go-zglob"
-)
-
-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
-}

goreleaser.yml

@@ -1,10 +0,0 @@
-build:
-  binary_name: task
-  main: cmd/task/task.go
-  goos:
-    - windows
-    - darwin
-    - linux
-  goarch:
-    - 386
-    - amd64

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,137 @@
+package v1
+
+import (
+	"bytes"
+	"context"
+	"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(context.Background(), 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,109 @@
+package v2
+
+import (
+	"bytes"
+	"context"
+	"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(context.Background(), 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,72 @@
+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 {
+	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(ctx context.Context, 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, err := interp.New(
+		interp.Dir(opts.Dir),
+		interp.Env(env),
+
+		interp.Module(interp.DefaultExec),
+		interp.Module(interp.OpenDevImpls(interp.DefaultOpen)),
+
+		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
+	)
+	if err != nil {
+		return err
+	}
+	return r.Run(ctx, p)
+}
+
+// IsExitError returns true the given error is an exis status error
+func IsExitError(err error) bool {
+	switch err.(type) {
+	case interp.ExitStatus, interp.ShellExitStatus:
+		return true
+	default:
+		return false
+	}
+}

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/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,28 @@
+package status
+
+import (
+	"path/filepath"
+	"sort"
+
+	"github.com/mattn/go-zglob"
+	"mvdan.cc/sh/shell"
+)
+
+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 = shell.Expand(g, nil)
+		if err != nil {
+			return nil, err
+		}
+		f, err := zglob.Glob(g)
+		if err != nil {
+			continue
+		}
+		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,81 @@
+package taskfile
+
+import (
+	"errors"
+	"strings"
+)
+
+// Cmd is a task command
+type Cmd struct {
+	Cmd         string
+	Silent      bool
+	Task        string
+	Vars        Vars
+	IgnoreError bool
+}
+
+// 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
+		IgnoreError bool `yaml:"ignore_error"`
+	}
+	if err := unmarshal(&cmdStruct); err == nil && cmdStruct.Cmd != "" {
+		c.Cmd = cmdStruct.Cmd
+		c.Silent = cmdStruct.Silent
+		c.IgnoreError = cmdStruct.IgnoreError
+		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/merge.go

@@ -0,0 +1,27 @@
+package taskfile
+
+import (
+	"fmt"
+)
+
+// Merge merges the second Taskfile into the first
+func Merge(t1, t2 *Taskfile) error {
+	if t1.Version != t2.Version {
+		return fmt.Errorf(`Taskfiles versions should match. First is "%s" but second is "%s"`, t1.Version, t2.Version)
+	}
+
+	if t2.Expansions != 0 && t2.Expansions != 2 {
+		t1.Expansions = t2.Expansions
+	}
+	if t2.Output != "" {
+		t1.Output = t2.Output
+	}
+	for k, v := range t2.Vars {
+		t1.Vars[k] = v
+	}
+	for k, v := range t2.Tasks {
+		t1.Tasks[k] = v
+	}
+
+	return nil
+}

internal/taskfile/read/taskfile.go

@@ -0,0 +1,47 @@
+package read
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/go-task/task/internal/taskfile"
+
+	"gopkg.in/yaml.v2"
+)
+
+// Taskfile reads a Taskfile for a given directory
+func Taskfile(dir string) (*taskfile.Taskfile, error) {
+	path := filepath.Join(dir, "Taskfile.yml")
+	t, err := readTaskfile(path)
+	if err != nil {
+		return nil, fmt.Errorf(`No Taskfile.yml found. Use "task --init" to create a new one`)
+	}
+
+	path = filepath.Join(dir, fmt.Sprintf("Taskfile_%s.yml", runtime.GOOS))
+	if _, err = os.Stat(path); err == nil {
+		osTaskfile, err := readTaskfile(path)
+		if err != nil {
+			return nil, err
+		}
+		if err = taskfile.Merge(t, osTaskfile); err != nil {
+			return nil, err
+		}
+	}
+
+	for name, task := range t.Tasks {
+		task.Task = name
+	}
+
+	return t, nil
+}
+
+func readTaskfile(file string) (*taskfile.Taskfile, error) {
+	f, err := os.Open(file)
+	if err != nil {
+		return nil, err
+	}
+	var t taskfile.Taskfile
+	return &t, yaml.NewDecoder(f).Decode(&t)
+}

internal/taskfile/read/taskvars.go

@@ -0,0 +1,52 @@
+package read
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/go-task/task/internal/taskfile"
+
+	"gopkg.in/yaml.v2"
+)
+
+// Taskvars reads a Taskvars for a given directory
+func Taskvars(dir string) (taskfile.Vars, error) {
+	vars := make(taskfile.Vars)
+
+	path := filepath.Join(dir, "Taskvars.yml")
+	if _, err := os.Stat(path); err == nil {
+		vars, err = readTaskvars(path)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	path = filepath.Join(dir, fmt.Sprintf("Taskvars_%s.yml", runtime.GOOS))
+	if _, err := os.Stat(path); err == nil {
+		osVars, err := readTaskvars(path)
+		if err != nil {
+			return nil, err
+		}
+
+		if vars == nil {
+			vars = osVars
+		} else {
+			for k, v := range osVars {
+				vars[k] = v
+			}
+		}
+	}
+
+	return vars, nil
+}
+
+func readTaskvars(file string) (taskfile.Vars, error) {
+	f, err := os.Open(file)
+	if err != nil {
+		return nil, err
+	}
+	var vars taskfile.Vars
+	return vars, yaml.NewDecoder(f).Decode(&vars)
+}

internal/taskfile/task.go

@@ -0,0 +1,22 @@
+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
+	IgnoreError bool `yaml:"ignore_error"`
+}

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
+}

read_taskfile.go

@@ -1,58 +0,0 @@
-package task
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"os"
-
-	"runtime"
-
-	"github.com/BurntSushi/toml"
-	"github.com/imdario/mergo"
-	"gopkg.in/yaml.v2"
-)
-
-func readTaskfile() (map[string]*Task, error) {
-	initialTasks, err := readTaskfileData(TaskFilePath)
-	if err != nil {
-		return nil, err
-	}
-	mergeTasks, err := readTaskfileData(fmt.Sprintf("%s_%s", TaskFilePath, runtime.GOOS))
-	if err != nil {
-		switch err.(type) {
-		default:
-			return nil, err
-		case taskFileNotFound:
-			return initialTasks, nil
-		}
-	}
-	if err := mergo.MapWithOverwrite(&initialTasks, mergeTasks); err != nil {
-		return nil, err
-	}
-	return initialTasks, nil
-}
-
-func readTaskfileData(path string) (tasks map[string]*Task, err error) {
-	if b, err := ioutil.ReadFile(path + ".yml"); err == nil {
-		return tasks, yaml.Unmarshal(b, &tasks)
-	}
-	if b, err := ioutil.ReadFile(path + ".json"); err == nil {
-		return tasks, json.Unmarshal(b, &tasks)
-	}
-	if b, err := ioutil.ReadFile(path + ".toml"); err == nil {
-		return tasks, toml.Unmarshal(b, &tasks)
-	}
-	return nil, taskFileNotFound{path}
-}
-
-func exists(path string) (bool, error) {
-	_, err := os.Stat(path)
-	if err == nil {
-		return true, nil
-	}
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-	return true, err
-}

status.go

@@ -0,0 +1,84 @@
+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(ctx, &execext.RunCommandOptions{
+			Command: s,
+			Dir:     t.Dir,
+			Env:     getEnviron(t),
+		})
+		if err != nil {
+			return false, nil
+		}
+	}
+	return true, nil
+}

task.go

@@ -1,182 +1,273 @@
 package task
 
 import (
+	"context"
 	"fmt"
-	"log"
+	"io"
 	"os"
-	"os/exec"
-	"strings"
+	"sync/atomic"
 
-	"github.com/spf13/pflag"
+	"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/read"
+	"github.com/go-task/task/internal/taskfile/version"
+
+	"github.com/Masterminds/semver"
+	"golang.org/x/sync/errgroup"
 )
 
-var (
-	// TaskFilePath is the default Taskfile
-	TaskFilePath = "Taskfile"
-	// ShExists is true if Bash was found
-	ShExists bool
-	// ShPath constains the Bash path if found
-	ShPath string
-
-	// Force (--force or -f flag) forces a task to run even when it's up-to-date
-	Force bool
-
-	// Tasks constains the tasks parsed from Taskfile
-	Tasks = make(map[string]*Task)
-
-	runnedTasks = make(map[string]struct{})
+const (
+	// 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
+	Dry      bool
 
-// Task represents a task
-type Task struct {
-	Cmds      []string
-	Deps      []string
-	Sources   []string
-	Generates []string
-	Dir       string
-	Vars      map[string]string
-	Set       string
-	Env       map[string]string
+	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
 }
 
 // Run runs Task
-func Run() {
-	log.SetFlags(0)
-
-	args := pflag.Args()
-	if len(args) == 0 {
-		log.Fatal("task: No argument given")
-	}
-
-	var err error
-	Tasks, err = readTaskfile()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	for _, a := range args {
-		if err = RunTask(a); err != nil {
-			log.Fatal(err)
+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}
 		}
 	}
+
+	if e.Watch {
+		return e.watchTasks(calls...)
+	}
+
+	for _, c := range calls {
+		if err := e.RunTask(e.Context, c); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Setup setups Executor's internal state
+func (e *Executor) Setup() error {
+	var err error
+	e.Taskfile, err = read.Taskfile(e.Dir)
+	if err != nil {
+		return err
+	}
+	e.taskvars, err = read.Taskvars(e.Dir)
+	if 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)
+	}
+
+	if !version.IsV21(v) {
+		err := fmt.Errorf(`task: Taskfile option "ignore_error" is only available starting on Taskfile version v2.1`)
+
+		for _, task := range e.Taskfile.Tasks {
+			if task.IgnoreError {
+				return err
+			}
+			for _, cmd := range task.Cmds {
+				if cmd.IgnoreError {
+					return err
+				}
+			}
+		}
+	}
+
+	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 RunTask(name string) error {
-	if _, found := runnedTasks[name]; found {
-		return &cyclicDepError{name}
-	}
-	runnedTasks[name] = struct{}{}
-
-	t, ok := Tasks[name]
-	if !ok {
-		return &taskNotFoundError{name}
-	}
-
-	vars, err := t.handleVariables()
+func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
+	t, err := e.CompiledTask(call)
 	if err != nil {
-		return &taskRunError{name, err}
+		return err
+	}
+	if !e.Watch && atomic.AddInt32(e.taskCallCount[call.Task], 1) >= MaximumTaskCall {
+		return &MaximumTaskCallExceededError{task: call.Task}
 	}
 
-	for _, d := range t.Deps {
-		d, err = ReplaceVariables(d, vars)
+	if err := e.runDeps(ctx, t); err != nil {
+		return err
+	}
+
+	if !e.Force {
+		upToDate, err := isTaskUpToDate(ctx, t)
 		if err != nil {
 			return err
 		}
-		if err = RunTask(d); err != nil {
-			return err
+		if upToDate {
+			if !e.Silent {
+				e.Logger.Errf(`task: Task "%s" is up to date`, t.Task)
+			}
+			return nil
 		}
 	}
 
-	if !Force && t.isUpToDate() {
-		log.Printf(`task: Task "%s" is up to date`, name)
-		return nil
-	}
-
 	for i := range t.Cmds {
-		if err = t.runCommand(i); err != nil {
-			return &taskRunError{name, err}
+		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)
+			}
+
+			if execext.IsExitError(err) && t.IgnoreError {
+				e.Logger.VerboseErrf("task: task error ignored: %v", err)
+				continue
+			}
+
+			return &taskRunError{t.Task, err}
 		}
 	}
 	return nil
 }
 
-func (t *Task) isUpToDate() 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 (t *Task) runCommand(i int) error {
-	vars, err := t.handleVariables()
-	if err != nil {
-		return err
-	}
-	c, err := ReplaceVariables(t.Cmds[i], vars)
-	if err != nil {
-		return err
-	}
-	dir, err := ReplaceVariables(t.Dir, vars)
-	if err != nil {
-		return err
-	}
-	var cmd *exec.Cmd
-	if ShExists {
-		cmd = exec.Command(ShPath, "-c", c)
-	} else {
-		cmd = exec.Command("cmd", "/C", c)
-	}
-	if dir != "" {
-		cmd.Dir = dir
-	}
-	if t.Env != nil {
-		cmd.Env = os.Environ()
-		for key, value := range t.Env {
-			replacedValue, err := ReplaceVariables(value, vars)
-			if err != nil {
-				return err
-			}
-			replacedKey, err := ReplaceVariables(key, vars)
-			if err != nil {
-				return err
-			}
-			cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", replacedKey, replacedValue))
+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)
 		}
-	}
-	cmd.Stdin = os.Stdin
-	cmd.Stderr = os.Stderr
-	if t.Set != "" {
-		bytes, err := cmd.Output()
-		if err != nil {
-			return err
+
+		if e.Dry {
+			return nil
 		}
-		os.Setenv(t.Set, strings.TrimSpace(string(bytes)))
+
+		stdOut := e.Output.WrapWriter(e.Stdout, t.Prefix)
+		stdErr := e.Output.WrapWriter(e.Stderr, t.Prefix)
+		defer stdOut.Close()
+		defer stdErr.Close()
+
+		err := execext.RunCommand(ctx, &execext.RunCommandOptions{
+			Command: cmd.Cmd,
+			Dir:     t.Dir,
+			Env:     getEnviron(t),
+			Stdin:   e.Stdin,
+			Stdout:  stdOut,
+			Stderr:  stdErr,
+		})
+		if execext.IsExitError(err) && cmd.IgnoreError {
+			e.Logger.VerboseErrf("task: command error ignored: %v", err)
+			return nil
+		}
+		return err
+	default:
 		return nil
 	}
-	cmd.Stdout = os.Stdout
-	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,472 @@
+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/mitchellh/go-homedir"
+	"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))
+		})
+	}
+}
+
+func TestTaskIgnoreErrors(t *testing.T) {
+	const dir = "testdata/ignore_errors"
+
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: ioutil.Discard,
+		Stderr: ioutil.Discard,
+	}
+	assert.NoError(t, e.Setup())
+
+	assert.NoError(t, e.Run(taskfile.Call{Task: "task-should-pass"}))
+	assert.Error(t, e.Run(taskfile.Call{Task: "task-should-fail"}))
+	assert.NoError(t, e.Run(taskfile.Call{Task: "cmd-should-pass"}))
+	assert.Error(t, e.Run(taskfile.Call{Task: "cmd-should-fail"}))
+}
+
+func TestExpand(t *testing.T) {
+	const dir = "testdata/expand"
+
+	home, err := homedir.Dir()
+	if err != nil {
+		t.Errorf("Couldn't get $HOME: %v", 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: "pwd"}))
+	assert.Equal(t, home, strings.TrimSpace(buff.String()))
+}
+
+func TestDry(t *testing.T) {
+	const dir = "testdata/dry"
+
+	file := filepath.Join(dir, "file.txt")
+	_ = os.Remove(file)
+
+	var buff bytes.Buffer
+
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+		Dry:    true,
+	}
+	assert.NoError(t, e.Setup())
+	assert.NoError(t, e.Run(taskfile.Call{Task: "build"}))
+
+	assert.Equal(t, "touch file.txt", strings.TrimSpace(buff.String()))
+	if _, err := os.Stat(file); err == nil {
+		t.Errorf("File should not exist %s", file)
+	}
+}

testdata/checksum/.gitignore

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

testdata/checksum/Taskfile.yml

@@ -0,0 +1,9 @@
+build:
+  cmds:
+    - cp ./source.txt ./generated.txt
+  sources:
+    - ./**/glob-with-inexistent-file.txt
+    - ./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/dry/Taskfile.yml

@@ -0,0 +1,6 @@
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - touch file.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/expand/Taskfile.yml

@@ -0,0 +1,8 @@
+version: '2'
+
+tasks:
+  pwd:
+    cmds:
+      - pwd
+    dir: '~'
+    silent: true

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/ignore_errors/Taskfile.yml

@@ -0,0 +1,20 @@
+version: '2'
+
+tasks:
+  task-should-pass:
+    cmds:
+      - exit 1
+    ignore_error: true
+
+  task-should-fail:
+    cmds:
+      - exit 1
+
+  cmd-should-pass:
+    cmds:
+      - cmd: exit 1
+        ignore_error: true
+
+  cmd-should-fail:
+    cmds:
+      - cmd: exit 1

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"

variable_handling.go

@@ -1,142 +0,0 @@
-package task
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"runtime"
-	"strings"
-	"text/template"
-
-	"github.com/BurntSushi/toml"
-	"gopkg.in/yaml.v2"
-)
-
-var (
-	// TaskvarsFilePath file containing additional variables
-	TaskvarsFilePath = "Taskvars"
-	// ErrMultilineResultCmd is returned when a command returns multiline result
-	ErrMultilineResultCmd = errors.New("Got multiline result from command")
-)
-
-var varCmds = make(map[string]string)
-
-func handleDynamicVariableContent(value string) (string, error) {
-	if value == "" || value[0] != '$' {
-		return value, nil
-	}
-	if result, ok := varCmds[value]; ok {
-		return result, nil
-	}
-	var cmd *exec.Cmd
-	if ShExists {
-		cmd = exec.Command(ShPath, "-c", value[1:])
-	} else {
-		cmd = exec.Command("cmd", "/C", value[1:])
-	}
-	cmd.Stdin = os.Stdin
-	cmd.Stderr = os.Stderr
-	b, err := cmd.Output()
-	if err != nil {
-		return "", err
-	}
-	if b[len(b)-1] == '\n' {
-		b = b[:len(b)-1]
-	}
-	if bytes.ContainsRune(b, '\n') {
-		return "", ErrMultilineResultCmd
-	}
-	result := strings.TrimSpace(string(b))
-	varCmds[value] = result
-	return result, nil
-}
-
-func (t *Task) handleVariables() (map[string]string, error) {
-	localVariables := make(map[string]string)
-	for key, value := range t.Vars {
-		val, err := handleDynamicVariableContent(value)
-		if err != nil {
-			return nil, err
-		}
-		localVariables[key] = val
-	}
-	if fileVariables, err := readTaskvarsFile(); err == nil {
-		for key, value := range fileVariables {
-			val, err := handleDynamicVariableContent(value)
-			if err != nil {
-				return nil, err
-			}
-			localVariables[key] = val
-		}
-	} else {
-		return nil, err
-	}
-	for key, value := range getEnvironmentVariables() {
-		localVariables[key] = value
-	}
-	return localVariables, nil
-}
-
-var templateFuncs = template.FuncMap{
-	"OS":   func() string { return runtime.GOOS },
-	"ARCH": func() string { return runtime.GOARCH },
-	"IsSH": func() bool { return ShExists },
-}
-
-// ReplaceVariables writes vars into initial string
-func ReplaceVariables(initial string, vars map[string]string) (string, error) {
-	t, err := template.New("").Funcs(templateFuncs).Parse(initial)
-	if err != nil {
-		return "", err
-	}
-	b := bytes.NewBuffer(nil)
-	if err = t.Execute(b, vars); err != nil {
-		return "", err
-	}
-	return b.String(), nil
-}
-
-// GetEnvironmentVariables returns environment variables as map
-func getEnvironmentVariables() map[string]string {
-	type getKeyValFunc func(item string) (key, val string)
-	getEnvironment := func(data []string, getKeyVal getKeyValFunc) map[string]string {
-		items := make(map[string]string)
-		for _, item := range data {
-			key, val := getKeyVal(item)
-			items[key] = val
-		}
-		return items
-	}
-	return getEnvironment(os.Environ(), func(item string) (key, val string) {
-		splits := strings.Split(item, "=")
-		key = splits[0]
-		val = splits[1]
-		return
-	})
-}
-
-func readTaskvarsFile() (map[string]string, error) {
-	var variables map[string]string
-	if b, err := ioutil.ReadFile(TaskvarsFilePath + ".yml"); err == nil {
-		if err := yaml.Unmarshal(b, &variables); err != nil {
-			return nil, err
-		}
-		return variables, nil
-	}
-	if b, err := ioutil.ReadFile(TaskvarsFilePath + ".json"); err == nil {
-		if err := json.Unmarshal(b, &variables); err != nil {
-			return nil, err
-		}
-		return variables, nil
-	}
-	if b, err := ioutil.ReadFile(TaskvarsFilePath + ".toml"); err == nil {
-		if err := toml.Unmarshal(b, &variables); err != nil {
-			return nil, err
-		}
-		return variables, nil
-	}
-	return variables, nil
-}

variables.go

@@ -0,0 +1,81 @@
+package task
+
+import (
+	"path/filepath"
+
+	"github.com/go-task/task/internal/taskfile"
+	"github.com/go-task/task/internal/templater"
+
+	"mvdan.cc/sh/shell"
+)
+
+// 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),
+		IgnoreError: origTask.IgnoreError,
+	}
+	new.Dir, err = shell.Expand(new.Dir, nil)
+	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),
+				IgnoreError: cmd.IgnoreError,
+			}
+		}
+	}
+	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/BurntSushi/toml/COMPATIBLE

@@ -1,3 +0,0 @@
-Compatible with TOML version
-[v0.2.0](https://github.com/mojombo/toml/blob/master/versions/toml-v0.2.0.md)
-

vendor/github.com/BurntSushi/toml/COPYING

@@ -1,14 +0,0 @@
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-                    Version 2, December 2004
-
- Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
-
- Everyone is permitted to copy and distribute verbatim or modified
- copies of this license document, and changing it is allowed as long
- as the name is changed.
-
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. You just DO WHAT THE FUCK YOU WANT TO.
-

vendor/github.com/BurntSushi/toml/Makefile

@@ -1,19 +0,0 @@
-install:
-	go install ./...
-
-test: install
-	go test -v
-	toml-test toml-test-decoder
-	toml-test -encoder toml-test-encoder
-
-fmt:
-	gofmt -w *.go */*.go
-	colcheck *.go */*.go
-
-tags:
-	find ./ -name '*.go' -print0 | xargs -0 gotags > TAGS
-
-push:
-	git push origin master
-	git push github master
-

vendor/github.com/BurntSushi/toml/README.md

@@ -1,220 +0,0 @@
-## TOML parser and encoder for Go with reflection
-
-TOML stands for Tom's Obvious, Minimal Language. This Go package provides a
-reflection interface similar to Go's standard library `json` and `xml` 
-packages. This package also supports the `encoding.TextUnmarshaler` and
-`encoding.TextMarshaler` interfaces so that you can define custom data 
-representations. (There is an example of this below.)
-
-Spec: https://github.com/mojombo/toml
-
-Compatible with TOML version
-[v0.2.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.2.0.md)
-
-Documentation: http://godoc.org/github.com/BurntSushi/toml
-
-Installation:
-
-```bash
-go get github.com/BurntSushi/toml
-```
-
-Try the toml validator:
-
-```bash
-go get github.com/BurntSushi/toml/cmd/tomlv
-tomlv some-toml-file.toml
-```
-
-[![Build status](https://api.travis-ci.org/BurntSushi/toml.png)](https://travis-ci.org/BurntSushi/toml)
-
-
-### Testing
-
-This package passes all tests in
-[toml-test](https://github.com/BurntSushi/toml-test) for both the decoder
-and the encoder.
-
-### Examples
-
-This package works similarly to how the Go standard library handles `XML`
-and `JSON`. Namely, data is loaded into Go values via reflection.
-
-For the simplest example, consider some TOML file as just a list of keys
-and values:
-
-```toml
-Age = 25
-Cats = [ "Cauchy", "Plato" ]
-Pi = 3.14
-Perfection = [ 6, 28, 496, 8128 ]
-DOB = 1987-07-05T05:45:00Z
-```
-
-Which could be defined in Go as:
-
-```go
-type Config struct {
-  Age int
-  Cats []string
-  Pi float64
-  Perfection []int
-  DOB time.Time // requires `import time`
-}
-```
-
-And then decoded with:
-
-```go
-var conf Config
-if _, err := toml.Decode(tomlData, &conf); err != nil {
-  // handle error
-}
-```
-
-You can also use struct tags if your struct field name doesn't map to a TOML
-key value directly:
-
-```toml
-some_key_NAME = "wat"
-```
-
-```go
-type TOML struct {
-  ObscureKey string `toml:"some_key_NAME"`
-}
-```
-
-### Using the `encoding.TextUnmarshaler` interface
-
-Here's an example that automatically parses duration strings into 
-`time.Duration` values:
-
-```toml
-[[song]]
-name = "Thunder Road"
-duration = "4m49s"
-
-[[song]]
-name = "Stairway to Heaven"
-duration = "8m03s"
-```
-
-Which can be decoded with:
-
-```go
-type song struct {
-  Name     string
-  Duration duration
-}
-type songs struct {
-  Song []song
-}
-var favorites songs
-if _, err := toml.Decode(blob, &favorites); err != nil {
-  log.Fatal(err)
-}
-
-for _, s := range favorites.Song {
-  fmt.Printf("%s (%s)\n", s.Name, s.Duration)
-}
-```
-
-And you'll also need a `duration` type that satisfies the 
-`encoding.TextUnmarshaler` interface:
-
-```go
-type duration struct {
-	time.Duration
-}
-
-func (d *duration) UnmarshalText(text []byte) error {
-	var err error
-	d.Duration, err = time.ParseDuration(string(text))
-	return err
-}
-```
-
-### More complex usage
-
-Here's an example of how to load the example from the official spec page:
-
-```toml
-# This is a TOML document. Boom.
-
-title = "TOML Example"
-
-[owner]
-name = "Tom Preston-Werner"
-organization = "GitHub"
-bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
-dob = 1979-05-27T07:32:00Z # First class dates? Why not?
-
-[database]
-server = "192.168.1.1"
-ports = [ 8001, 8001, 8002 ]
-connection_max = 5000
-enabled = true
-
-[servers]
-
-  # You can indent as you please. Tabs or spaces. TOML don't care.
-  [servers.alpha]
-  ip = "10.0.0.1"
-  dc = "eqdc10"
-
-  [servers.beta]
-  ip = "10.0.0.2"
-  dc = "eqdc10"
-
-[clients]
-data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it
-
-# Line breaks are OK when inside arrays
-hosts = [
-  "alpha",
-  "omega"
-]
-```
-
-And the corresponding Go types are:
-
-```go
-type tomlConfig struct {
-	Title string
-	Owner ownerInfo
-	DB database `toml:"database"`
-	Servers map[string]server
-	Clients clients
-}
-
-type ownerInfo struct {
-	Name string
-	Org string `toml:"organization"`
-	Bio string
-	DOB time.Time
-}
-
-type database struct {
-	Server string
-	Ports []int
-	ConnMax int `toml:"connection_max"`
-	Enabled bool
-}
-
-type server struct {
-	IP string
-	DC string
-}
-
-type clients struct {
-	Data [][]interface{}
-	Hosts []string
-}
-```
-
-Note that a case insensitive match will be tried if an exact match can't be
-found.
-
-A working example of the above can be found in `_examples/example.{go,toml}`.
-

vendor/github.com/BurntSushi/toml/decode.go

@@ -1,509 +0,0 @@
-package toml
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math"
-	"reflect"
-	"strings"
-	"time"
-)
-
-func e(format string, args ...interface{}) error {
-	return fmt.Errorf("toml: "+format, args...)
-}
-
-// Unmarshaler is the interface implemented by objects that can unmarshal a
-// TOML description of themselves.
-type Unmarshaler interface {
-	UnmarshalTOML(interface{}) error
-}
-
-// Unmarshal decodes the contents of `p` in TOML format into a pointer `v`.
-func Unmarshal(p []byte, v interface{}) error {
-	_, err := Decode(string(p), v)
-	return err
-}
-
-// Primitive is a TOML value that hasn't been decoded into a Go value.
-// When using the various `Decode*` functions, the type `Primitive` may
-// be given to any value, and its decoding will be delayed.
-//
-// A `Primitive` value can be decoded using the `PrimitiveDecode` function.
-//
-// The underlying representation of a `Primitive` value is subject to change.
-// Do not rely on it.
-//
-// N.B. Primitive values are still parsed, so using them will only avoid
-// the overhead of reflection. They can be useful when you don't know the
-// exact type of TOML data until run time.
-type Primitive struct {
-	undecoded interface{}
-	context   Key
-}
-
-// DEPRECATED!
-//
-// Use MetaData.PrimitiveDecode instead.
-func PrimitiveDecode(primValue Primitive, v interface{}) error {
-	md := MetaData{decoded: make(map[string]bool)}
-	return md.unify(primValue.undecoded, rvalue(v))
-}
-
-// PrimitiveDecode is just like the other `Decode*` functions, except it
-// decodes a TOML value that has already been parsed. Valid primitive values
-// can *only* be obtained from values filled by the decoder functions,
-// including this method. (i.e., `v` may contain more `Primitive`
-// values.)
-//
-// Meta data for primitive values is included in the meta data returned by
-// the `Decode*` functions with one exception: keys returned by the Undecoded
-// method will only reflect keys that were decoded. Namely, any keys hidden
-// behind a Primitive will be considered undecoded. Executing this method will
-// update the undecoded keys in the meta data. (See the example.)
-func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error {
-	md.context = primValue.context
-	defer func() { md.context = nil }()
-	return md.unify(primValue.undecoded, rvalue(v))
-}
-
-// Decode will decode the contents of `data` in TOML format into a pointer
-// `v`.
-//
-// TOML hashes correspond to Go structs or maps. (Dealer's choice. They can be
-// used interchangeably.)
-//
-// TOML arrays of tables correspond to either a slice of structs or a slice
-// of maps.
-//
-// TOML datetimes correspond to Go `time.Time` values.
-//
-// All other TOML types (float, string, int, bool and array) correspond
-// to the obvious Go types.
-//
-// An exception to the above rules is if a type implements the
-// encoding.TextUnmarshaler interface. In this case, any primitive TOML value
-// (floats, strings, integers, booleans and datetimes) will be converted to
-// a byte string and given to the value's UnmarshalText method. See the
-// Unmarshaler example for a demonstration with time duration strings.
-//
-// Key mapping
-//
-// TOML keys can map to either keys in a Go map or field names in a Go
-// struct. The special `toml` struct tag may be used to map TOML keys to
-// struct fields that don't match the key name exactly. (See the example.)
-// A case insensitive match to struct names will be tried if an exact match
-// can't be found.
-//
-// The mapping between TOML values and Go values is loose. That is, there
-// may exist TOML values that cannot be placed into your representation, and
-// there may be parts of your representation that do not correspond to
-// TOML values. This loose mapping can be made stricter by using the IsDefined
-// and/or Undecoded methods on the MetaData returned.
-//
-// This decoder will not handle cyclic types. If a cyclic type is passed,
-// `Decode` will not terminate.
-func Decode(data string, v interface{}) (MetaData, error) {
-	rv := reflect.ValueOf(v)
-	if rv.Kind() != reflect.Ptr {
-		return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v))
-	}
-	if rv.IsNil() {
-		return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v))
-	}
-	p, err := parse(data)
-	if err != nil {
-		return MetaData{}, err
-	}
-	md := MetaData{
-		p.mapping, p.types, p.ordered,
-		make(map[string]bool, len(p.ordered)), nil,
-	}
-	return md, md.unify(p.mapping, indirect(rv))
-}
-
-// DecodeFile is just like Decode, except it will automatically read the
-// contents of the file at `fpath` and decode it for you.
-func DecodeFile(fpath string, v interface{}) (MetaData, error) {
-	bs, err := ioutil.ReadFile(fpath)
-	if err != nil {
-		return MetaData{}, err
-	}
-	return Decode(string(bs), v)
-}
-
-// DecodeReader is just like Decode, except it will consume all bytes
-// from the reader and decode it for you.
-func DecodeReader(r io.Reader, v interface{}) (MetaData, error) {
-	bs, err := ioutil.ReadAll(r)
-	if err != nil {
-		return MetaData{}, err
-	}
-	return Decode(string(bs), v)
-}
-
-// unify performs a sort of type unification based on the structure of `rv`,
-// which is the client representation.
-//
-// Any type mismatch produces an error. Finding a type that we don't know
-// how to handle produces an unsupported type error.
-func (md *MetaData) unify(data interface{}, rv reflect.Value) error {
-
-	// Special case. Look for a `Primitive` value.
-	if rv.Type() == reflect.TypeOf((*Primitive)(nil)).Elem() {
-		// Save the undecoded data and the key context into the primitive
-		// value.
-		context := make(Key, len(md.context))
-		copy(context, md.context)
-		rv.Set(reflect.ValueOf(Primitive{
-			undecoded: data,
-			context:   context,
-		}))
-		return nil
-	}
-
-	// Special case. Unmarshaler Interface support.
-	if rv.CanAddr() {
-		if v, ok := rv.Addr().Interface().(Unmarshaler); ok {
-			return v.UnmarshalTOML(data)
-		}
-	}
-
-	// Special case. Handle time.Time values specifically.
-	// TODO: Remove this code when we decide to drop support for Go 1.1.
-	// This isn't necessary in Go 1.2 because time.Time satisfies the encoding
-	// interfaces.
-	if rv.Type().AssignableTo(rvalue(time.Time{}).Type()) {
-		return md.unifyDatetime(data, rv)
-	}
-
-	// Special case. Look for a value satisfying the TextUnmarshaler interface.
-	if v, ok := rv.Interface().(TextUnmarshaler); ok {
-		return md.unifyText(data, v)
-	}
-	// BUG(burntsushi)
-	// The behavior here is incorrect whenever a Go type satisfies the
-	// encoding.TextUnmarshaler interface but also corresponds to a TOML
-	// hash or array. In particular, the unmarshaler should only be applied
-	// to primitive TOML values. But at this point, it will be applied to
-	// all kinds of values and produce an incorrect error whenever those values
-	// are hashes or arrays (including arrays of tables).
-
-	k := rv.Kind()
-
-	// laziness
-	if k >= reflect.Int && k <= reflect.Uint64 {
-		return md.unifyInt(data, rv)
-	}
-	switch k {
-	case reflect.Ptr:
-		elem := reflect.New(rv.Type().Elem())
-		err := md.unify(data, reflect.Indirect(elem))
-		if err != nil {
-			return err
-		}
-		rv.Set(elem)
-		return nil
-	case reflect.Struct:
-		return md.unifyStruct(data, rv)
-	case reflect.Map:
-		return md.unifyMap(data, rv)
-	case reflect.Array:
-		return md.unifyArray(data, rv)
-	case reflect.Slice:
-		return md.unifySlice(data, rv)
-	case reflect.String:
-		return md.unifyString(data, rv)
-	case reflect.Bool:
-		return md.unifyBool(data, rv)
-	case reflect.Interface:
-		// we only support empty interfaces.
-		if rv.NumMethod() > 0 {
-			return e("unsupported type %s", rv.Type())
-		}
-		return md.unifyAnything(data, rv)
-	case reflect.Float32:
-		fallthrough
-	case reflect.Float64:
-		return md.unifyFloat64(data, rv)
-	}
-	return e("unsupported type %s", rv.Kind())
-}
-
-func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {
-	tmap, ok := mapping.(map[string]interface{})
-	if !ok {
-		if mapping == nil {
-			return nil
-		}
-		return e("type mismatch for %s: expected table but found %T",
-			rv.Type().String(), mapping)
-	}
-
-	for key, datum := range tmap {
-		var f *field
-		fields := cachedTypeFields(rv.Type())
-		for i := range fields {
-			ff := &fields[i]
-			if ff.name == key {
-				f = ff
-				break
-			}
-			if f == nil && strings.EqualFold(ff.name, key) {
-				f = ff
-			}
-		}
-		if f != nil {
-			subv := rv
-			for _, i := range f.index {
-				subv = indirect(subv.Field(i))
-			}
-			if isUnifiable(subv) {
-				md.decoded[md.context.add(key).String()] = true
-				md.context = append(md.context, key)
-				if err := md.unify(datum, subv); err != nil {
-					return err
-				}
-				md.context = md.context[0 : len(md.context)-1]
-			} else if f.name != "" {
-				// Bad user! No soup for you!
-				return e("cannot write unexported field %s.%s",
-					rv.Type().String(), f.name)
-			}
-		}
-	}
-	return nil
-}
-
-func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {
-	tmap, ok := mapping.(map[string]interface{})
-	if !ok {
-		if tmap == nil {
-			return nil
-		}
-		return badtype("map", mapping)
-	}
-	if rv.IsNil() {
-		rv.Set(reflect.MakeMap(rv.Type()))
-	}
-	for k, v := range tmap {
-		md.decoded[md.context.add(k).String()] = true
-		md.context = append(md.context, k)
-
-		rvkey := indirect(reflect.New(rv.Type().Key()))
-		rvval := reflect.Indirect(reflect.New(rv.Type().Elem()))
-		if err := md.unify(v, rvval); err != nil {
-			return err
-		}
-		md.context = md.context[0 : len(md.context)-1]
-
-		rvkey.SetString(k)
-		rv.SetMapIndex(rvkey, rvval)
-	}
-	return nil
-}
-
-func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {
-	datav := reflect.ValueOf(data)
-	if datav.Kind() != reflect.Slice {
-		if !datav.IsValid() {
-			return nil
-		}
-		return badtype("slice", data)
-	}
-	sliceLen := datav.Len()
-	if sliceLen != rv.Len() {
-		return e("expected array length %d; got TOML array of length %d",
-			rv.Len(), sliceLen)
-	}
-	return md.unifySliceArray(datav, rv)
-}
-
-func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error {
-	datav := reflect.ValueOf(data)
-	if datav.Kind() != reflect.Slice {
-		if !datav.IsValid() {
-			return nil
-		}
-		return badtype("slice", data)
-	}
-	n := datav.Len()
-	if rv.IsNil() || rv.Cap() < n {
-		rv.Set(reflect.MakeSlice(rv.Type(), n, n))
-	}
-	rv.SetLen(n)
-	return md.unifySliceArray(datav, rv)
-}
-
-func (md *MetaData) unifySliceArray(data, rv reflect.Value) error {
-	sliceLen := data.Len()
-	for i := 0; i < sliceLen; i++ {
-		v := data.Index(i).Interface()
-		sliceval := indirect(rv.Index(i))
-		if err := md.unify(v, sliceval); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (md *MetaData) unifyDatetime(data interface{}, rv reflect.Value) error {
-	if _, ok := data.(time.Time); ok {
-		rv.Set(reflect.ValueOf(data))
-		return nil
-	}
-	return badtype("time.Time", data)
-}
-
-func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error {
-	if s, ok := data.(string); ok {
-		rv.SetString(s)
-		return nil
-	}
-	return badtype("string", data)
-}
-
-func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) error {
-	if num, ok := data.(float64); ok {
-		switch rv.Kind() {
-		case reflect.Float32:
-			fallthrough
-		case reflect.Float64:
-			rv.SetFloat(num)
-		default:
-			panic("bug")
-		}
-		return nil
-	}
-	return badtype("float", data)
-}
-
-func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error {
-	if num, ok := data.(int64); ok {
-		if rv.Kind() >= reflect.Int && rv.Kind() <= reflect.Int64 {
-			switch rv.Kind() {
-			case reflect.Int, reflect.Int64:
-				// No bounds checking necessary.
-			case reflect.Int8:
-				if num < math.MinInt8 || num > math.MaxInt8 {
-					return e("value %d is out of range for int8", num)
-				}
-			case reflect.Int16:
-				if num < math.MinInt16 || num > math.MaxInt16 {
-					return e("value %d is out of range for int16", num)
-				}
-			case reflect.Int32:
-				if num < math.MinInt32 || num > math.MaxInt32 {
-					return e("value %d is out of range for int32", num)
-				}
-			}
-			rv.SetInt(num)
-		} else if rv.Kind() >= reflect.Uint && rv.Kind() <= reflect.Uint64 {
-			unum := uint64(num)
-			switch rv.Kind() {
-			case reflect.Uint, reflect.Uint64:
-				// No bounds checking necessary.
-			case reflect.Uint8:
-				if num < 0 || unum > math.MaxUint8 {
-					return e("value %d is out of range for uint8", num)
-				}
-			case reflect.Uint16:
-				if num < 0 || unum > math.MaxUint16 {
-					return e("value %d is out of range for uint16", num)
-				}
-			case reflect.Uint32:
-				if num < 0 || unum > math.MaxUint32 {
-					return e("value %d is out of range for uint32", num)
-				}
-			}
-			rv.SetUint(unum)
-		} else {
-			panic("unreachable")
-		}
-		return nil
-	}
-	return badtype("integer", data)
-}
-
-func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error {
-	if b, ok := data.(bool); ok {
-		rv.SetBool(b)
-		return nil
-	}
-	return badtype("boolean", data)
-}
-
-func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error {
-	rv.Set(reflect.ValueOf(data))
-	return nil
-}
-
-func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error {
-	var s string
-	switch sdata := data.(type) {
-	case TextMarshaler:
-		text, err := sdata.MarshalText()
-		if err != nil {
-			return err
-		}
-		s = string(text)
-	case fmt.Stringer:
-		s = sdata.String()
-	case string:
-		s = sdata
-	case bool:
-		s = fmt.Sprintf("%v", sdata)
-	case int64:
-		s = fmt.Sprintf("%d", sdata)
-	case float64:
-		s = fmt.Sprintf("%f", sdata)
-	default:
-		return badtype("primitive (string-like)", data)
-	}
-	if err := v.UnmarshalText([]byte(s)); err != nil {
-		return err
-	}
-	return nil
-}
-
-// rvalue returns a reflect.Value of `v`. All pointers are resolved.
-func rvalue(v interface{}) reflect.Value {
-	return indirect(reflect.ValueOf(v))
-}
-
-// indirect returns the value pointed to by a pointer.
-// Pointers are followed until the value is not a pointer.
-// New values are allocated for each nil pointer.
-//
-// An exception to this rule is if the value satisfies an interface of
-// interest to us (like encoding.TextUnmarshaler).
-func indirect(v reflect.Value) reflect.Value {
-	if v.Kind() != reflect.Ptr {
-		if v.CanSet() {
-			pv := v.Addr()
-			if _, ok := pv.Interface().(TextUnmarshaler); ok {
-				return pv
-			}
-		}
-		return v
-	}
-	if v.IsNil() {
-		v.Set(reflect.New(v.Type().Elem()))
-	}
-	return indirect(reflect.Indirect(v))
-}
-
-func isUnifiable(rv reflect.Value) bool {
-	if rv.CanSet() {
-		return true
-	}
-	if _, ok := rv.Interface().(TextUnmarshaler); ok {
-		return true
-	}
-	return false
-}
-
-func badtype(expected string, data interface{}) error {
-	return e("cannot load TOML value of type %T into a Go %s", data, expected)
-}

vendor/github.com/BurntSushi/toml/decode_meta.go

@@ -1,121 +0,0 @@
-package toml
-
-import "strings"
-
-// MetaData allows access to meta information about TOML data that may not
-// be inferrable via reflection. In particular, whether a key has been defined
-// and the TOML type of a key.
-type MetaData struct {
-	mapping map[string]interface{}
-	types   map[string]tomlType
-	keys    []Key
-	decoded map[string]bool
-	context Key // Used only during decoding.
-}
-
-// IsDefined returns true if the key given exists in the TOML data. The key
-// should be specified hierarchially. e.g.,
-//
-//	// access the TOML key 'a.b.c'
-//	IsDefined("a", "b", "c")
-//
-// IsDefined will return false if an empty key given. Keys are case sensitive.
-func (md *MetaData) IsDefined(key ...string) bool {
-	if len(key) == 0 {
-		return false
-	}
-
-	var hash map[string]interface{}
-	var ok bool
-	var hashOrVal interface{} = md.mapping
-	for _, k := range key {
-		if hash, ok = hashOrVal.(map[string]interface{}); !ok {
-			return false
-		}
-		if hashOrVal, ok = hash[k]; !ok {
-			return false
-		}
-	}
-	return true
-}
-
-// Type returns a string representation of the type of the key specified.
-//
-// Type will return the empty string if given an empty key or a key that
-// does not exist. Keys are case sensitive.
-func (md *MetaData) Type(key ...string) string {
-	fullkey := strings.Join(key, ".")
-	if typ, ok := md.types[fullkey]; ok {
-		return typ.typeString()
-	}
-	return ""
-}
-
-// Key is the type of any TOML key, including key groups. Use (MetaData).Keys
-// to get values of this type.
-type Key []string
-
-func (k Key) String() string {
-	return strings.Join(k, ".")
-}
-
-func (k Key) maybeQuotedAll() string {
-	var ss []string
-	for i := range k {
-		ss = append(ss, k.maybeQuoted(i))
-	}
-	return strings.Join(ss, ".")
-}
-
-func (k Key) maybeQuoted(i int) string {
-	quote := false
-	for _, c := range k[i] {
-		if !isBareKeyChar(c) {
-			quote = true
-			break
-		}
-	}
-	if quote {
-		return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\""
-	}
-	return k[i]
-}
-
-func (k Key) add(piece string) Key {
-	newKey := make(Key, len(k)+1)
-	copy(newKey, k)
-	newKey[len(k)] = piece
-	return newKey
-}
-
-// Keys returns a slice of every key in the TOML data, including key groups.
-// Each key is itself a slice, where the first element is the top of the
-// hierarchy and the last is the most specific.
-//
-// The list will have the same order as the keys appeared in the TOML data.
-//
-// All keys returned are non-empty.
-func (md *MetaData) Keys() []Key {
-	return md.keys
-}
-
-// Undecoded returns all keys that have not been decoded in the order in which
-// they appear in the original TOML document.
-//
-// This includes keys that haven't been decoded because of a Primitive value.
-// Once the Primitive value is decoded, the keys will be considered decoded.
-//
-// Also note that decoding into an empty interface will result in no decoding,
-// and so no keys will be considered decoded.
-//
-// In this sense, the Undecoded keys correspond to keys in the TOML document
-// that do not have a concrete type in your representation.
-func (md *MetaData) Undecoded() []Key {
-	undecoded := make([]Key, 0, len(md.keys))
-	for _, key := range md.keys {
-		if !md.decoded[key.String()] {
-			undecoded = append(undecoded, key)
-		}
-	}
-	return undecoded
-}

vendor/github.com/BurntSushi/toml/doc.go

@@ -1,27 +0,0 @@
-/*
-Package toml provides facilities for decoding and encoding TOML configuration
-files via reflection. There is also support for delaying decoding with
-the Primitive type, and querying the set of keys in a TOML document with the
-MetaData type.
-
-The specification implemented: https://github.com/mojombo/toml
-
-The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify
-whether a file is a valid TOML document. It can also be used to print the
-type of each key in a TOML document.
-
-Testing
-
-There are two important types of tests used for this package. The first is
-contained inside '*_test.go' files and uses the standard Go unit testing
-framework. These tests are primarily devoted to holistically testing the
-decoder and encoder.
-
-The second type of testing is used to verify the implementation's adherence
-to the TOML specification. These tests have been factored into their own
-project: https://github.com/BurntSushi/toml-test
-
-The reason the tests are in a separate project is so that they can be used by
-any implementation of TOML. Namely, it is language agnostic.
-*/
-package toml

vendor/github.com/BurntSushi/toml/encode.go

@@ -1,568 +0,0 @@
-package toml
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"io"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type tomlEncodeError struct{ error }
-
-var (
-	errArrayMixedElementTypes = errors.New(
-		"toml: cannot encode array with mixed element types")
-	errArrayNilElement = errors.New(
-		"toml: cannot encode array with nil element")
-	errNonString = errors.New(
-		"toml: cannot encode a map with non-string key type")
-	errAnonNonStruct = errors.New(
-		"toml: cannot encode an anonymous field that is not a struct")
-	errArrayNoTable = errors.New(
-		"toml: TOML array element cannot contain a table")
-	errNoKey = errors.New(
-		"toml: top-level values must be Go maps or structs")
-	errAnything = errors.New("") // used in testing
-)
-
-var quotedReplacer = strings.NewReplacer(
-	"\t", "\\t",
-	"\n", "\\n",
-	"\r", "\\r",
-	"\"", "\\\"",
-	"\\", "\\\\",
-)
-
-// Encoder controls the encoding of Go values to a TOML document to some
-// io.Writer.
-//
-// The indentation level can be controlled with the Indent field.
-type Encoder struct {
-	// A single indentation level. By default it is two spaces.
-	Indent string
-
-	// hasWritten is whether we have written any output to w yet.
-	hasWritten bool
-	w          *bufio.Writer
-}
-
-// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer
-// given. By default, a single indentation level is 2 spaces.
-func NewEncoder(w io.Writer) *Encoder {
-	return &Encoder{
-		w:      bufio.NewWriter(w),
-		Indent: "  ",
-	}
-}
-
-// Encode writes a TOML representation of the Go value to the underlying
-// io.Writer. If the value given cannot be encoded to a valid TOML document,
-// then an error is returned.
-//
-// The mapping between Go values and TOML values should be precisely the same
-// as for the Decode* functions. Similarly, the TextMarshaler interface is
-// supported by encoding the resulting bytes as strings. (If you want to write
-// arbitrary binary data then you will need to use something like base64 since
-// TOML does not have any binary types.)
-//
-// When encoding TOML hashes (i.e., Go maps or structs), keys without any
-// sub-hashes are encoded first.
-//
-// If a Go map is encoded, then its keys are sorted alphabetically for
-// deterministic output. More control over this behavior may be provided if
-// there is demand for it.
-//
-// Encoding Go values without a corresponding TOML representation---like map
-// types with non-string keys---will cause an error to be returned. Similarly
-// for mixed arrays/slices, arrays/slices with nil elements, embedded
-// non-struct types and nested slices containing maps or structs.
-// (e.g., [][]map[string]string is not allowed but []map[string]string is OK
-// and so is []map[string][]string.)
-func (enc *Encoder) Encode(v interface{}) error {
-	rv := eindirect(reflect.ValueOf(v))
-	if err := enc.safeEncode(Key([]string{}), rv); err != nil {
-		return err
-	}
-	return enc.w.Flush()
-}
-
-func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			if terr, ok := r.(tomlEncodeError); ok {
-				err = terr.error
-				return
-			}
-			panic(r)
-		}
-	}()
-	enc.encode(key, rv)
-	return nil
-}
-
-func (enc *Encoder) encode(key Key, rv reflect.Value) {
-	// Special case. Time needs to be in ISO8601 format.
-	// Special case. If we can marshal the type to text, then we used that.
-	// Basically, this prevents the encoder for handling these types as
-	// generic structs (or whatever the underlying type of a TextMarshaler is).
-	switch rv.Interface().(type) {
-	case time.Time, TextMarshaler:
-		enc.keyEqElement(key, rv)
-		return
-	}
-
-	k := rv.Kind()
-	switch k {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
-		reflect.Int64,
-		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
-		reflect.Uint64,
-		reflect.Float32, reflect.Float64, reflect.String, reflect.Bool:
-		enc.keyEqElement(key, rv)
-	case reflect.Array, reflect.Slice:
-		if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) {
-			enc.eArrayOfTables(key, rv)
-		} else {
-			enc.keyEqElement(key, rv)
-		}
-	case reflect.Interface:
-		if rv.IsNil() {
-			return
-		}
-		enc.encode(key, rv.Elem())
-	case reflect.Map:
-		if rv.IsNil() {
-			return
-		}
-		enc.eTable(key, rv)
-	case reflect.Ptr:
-		if rv.IsNil() {
-			return
-		}
-		enc.encode(key, rv.Elem())
-	case reflect.Struct:
-		enc.eTable(key, rv)
-	default:
-		panic(e("unsupported type for key '%s': %s", key, k))
-	}
-}
-
-// eElement encodes any value that can be an array element (primitives and
-// arrays).
-func (enc *Encoder) eElement(rv reflect.Value) {
-	switch v := rv.Interface().(type) {
-	case time.Time:
-		// Special case time.Time as a primitive. Has to come before
-		// TextMarshaler below because time.Time implements
-		// encoding.TextMarshaler, but we need to always use UTC.
-		enc.wf(v.UTC().Format("2006-01-02T15:04:05Z"))
-		return
-	case TextMarshaler:
-		// Special case. Use text marshaler if it's available for this value.
-		if s, err := v.MarshalText(); err != nil {
-			encPanic(err)
-		} else {
-			enc.writeQuoted(string(s))
-		}
-		return
-	}
-	switch rv.Kind() {
-	case reflect.Bool:
-		enc.wf(strconv.FormatBool(rv.Bool()))
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
-		reflect.Int64:
-		enc.wf(strconv.FormatInt(rv.Int(), 10))
-	case reflect.Uint, reflect.Uint8, reflect.Uint16,
-		reflect.Uint32, reflect.Uint64:
-		enc.wf(strconv.FormatUint(rv.Uint(), 10))
-	case reflect.Float32:
-		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 32)))
-	case reflect.Float64:
-		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 64)))
-	case reflect.Array, reflect.Slice:
-		enc.eArrayOrSliceElement(rv)
-	case reflect.Interface:
-		enc.eElement(rv.Elem())
-	case reflect.String:
-		enc.writeQuoted(rv.String())
-	default:
-		panic(e("unexpected primitive type: %s", rv.Kind()))
-	}
-}
-
-// By the TOML spec, all floats must have a decimal with at least one
-// number on either side.
-func floatAddDecimal(fstr string) string {
-	if !strings.Contains(fstr, ".") {
-		return fstr + ".0"
-	}
-	return fstr
-}
-
-func (enc *Encoder) writeQuoted(s string) {
-	enc.wf("\"%s\"", quotedReplacer.Replace(s))
-}
-
-func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) {
-	length := rv.Len()
-	enc.wf("[")
-	for i := 0; i < length; i++ {
-		elem := rv.Index(i)
-		enc.eElement(elem)
-		if i != length-1 {
-			enc.wf(", ")
-		}
-	}
-	enc.wf("]")
-}
-
-func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {
-	if len(key) == 0 {
-		encPanic(errNoKey)
-	}
-	for i := 0; i < rv.Len(); i++ {
-		trv := rv.Index(i)
-		if isNil(trv) {
-			continue
-		}
-		panicIfInvalidKey(key)
-		enc.newline()
-		enc.wf("%s[[%s]]", enc.indentStr(key), key.maybeQuotedAll())
-		enc.newline()
-		enc.eMapOrStruct(key, trv)
-	}
-}
-
-func (enc *Encoder) eTable(key Key, rv reflect.Value) {
-	panicIfInvalidKey(key)
-	if len(key) == 1 {
-		// Output an extra new line between top-level tables.
-		// (The newline isn't written if nothing else has been written though.)
-		enc.newline()
-	}
-	if len(key) > 0 {
-		enc.wf("%s[%s]", enc.indentStr(key), key.maybeQuotedAll())
-		enc.newline()
-	}
-	enc.eMapOrStruct(key, rv)
-}
-
-func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) {
-	switch rv := eindirect(rv); rv.Kind() {
-	case reflect.Map:
-		enc.eMap(key, rv)
-	case reflect.Struct:
-		enc.eStruct(key, rv)
-	default:
-		panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String())
-	}
-}
-
-func (enc *Encoder) eMap(key Key, rv reflect.Value) {
-	rt := rv.Type()
-	if rt.Key().Kind() != reflect.String {
-		encPanic(errNonString)
-	}
-
-	// Sort keys so that we have deterministic output. And write keys directly
-	// underneath this key first, before writing sub-structs or sub-maps.
-	var mapKeysDirect, mapKeysSub []string
-	for _, mapKey := range rv.MapKeys() {
-		k := mapKey.String()
-		if typeIsHash(tomlTypeOfGo(rv.MapIndex(mapKey))) {
-			mapKeysSub = append(mapKeysSub, k)
-		} else {
-			mapKeysDirect = append(mapKeysDirect, k)
-		}
-	}
-
-	var writeMapKeys = func(mapKeys []string) {
-		sort.Strings(mapKeys)
-		for _, mapKey := range mapKeys {
-			mrv := rv.MapIndex(reflect.ValueOf(mapKey))
-			if isNil(mrv) {
-				// Don't write anything for nil fields.
-				continue
-			}
-			enc.encode(key.add(mapKey), mrv)
-		}
-	}
-	writeMapKeys(mapKeysDirect)
-	writeMapKeys(mapKeysSub)
-}
-
-func (enc *Encoder) eStruct(key Key, rv reflect.Value) {
-	// Write keys for fields directly under this key first, because if we write
-	// a field that creates a new table, then all keys under it will be in that
-	// table (not the one we're writing here).
-	rt := rv.Type()
-	var fieldsDirect, fieldsSub [][]int
-	var addFields func(rt reflect.Type, rv reflect.Value, start []int)
-	addFields = func(rt reflect.Type, rv reflect.Value, start []int) {
-		for i := 0; i < rt.NumField(); i++ {
-			f := rt.Field(i)
-			// skip unexported fields
-			if f.PkgPath != "" && !f.Anonymous {
-				continue
-			}
-			frv := rv.Field(i)
-			if f.Anonymous {
-				t := f.Type
-				switch t.Kind() {
-				case reflect.Struct:
-					// Treat anonymous struct fields with
-					// tag names as though they are not
-					// anonymous, like encoding/json does.
-					if getOptions(f.Tag).name == "" {
-						addFields(t, frv, f.Index)
-						continue
-					}
-				case reflect.Ptr:
-					if t.Elem().Kind() == reflect.Struct &&
-						getOptions(f.Tag).name == "" {
-						if !frv.IsNil() {
-							addFields(t.Elem(), frv.Elem(), f.Index)
-						}
-						continue
-					}
-					// Fall through to the normal field encoding logic below
-					// for non-struct anonymous fields.
-				}
-			}
-
-			if typeIsHash(tomlTypeOfGo(frv)) {
-				fieldsSub = append(fieldsSub, append(start, f.Index...))
-			} else {
-				fieldsDirect = append(fieldsDirect, append(start, f.Index...))
-			}
-		}
-	}
-	addFields(rt, rv, nil)
-
-	var writeFields = func(fields [][]int) {
-		for _, fieldIndex := range fields {
-			sft := rt.FieldByIndex(fieldIndex)
-			sf := rv.FieldByIndex(fieldIndex)
-			if isNil(sf) {
-				// Don't write anything for nil fields.
-				continue
-			}
-
-			opts := getOptions(sft.Tag)
-			if opts.skip {
-				continue
-			}
-			keyName := sft.Name
-			if opts.name != "" {
-				keyName = opts.name
-			}
-			if opts.omitempty && isEmpty(sf) {
-				continue
-			}
-			if opts.omitzero && isZero(sf) {
-				continue
-			}
-
-			enc.encode(key.add(keyName), sf)
-		}
-	}
-	writeFields(fieldsDirect)
-	writeFields(fieldsSub)
-}
-
-// tomlTypeName returns the TOML type name of the Go value's type. It is
-// used to determine whether the types of array elements are mixed (which is
-// forbidden). If the Go value is nil, then it is illegal for it to be an array
-// element, and valueIsNil is returned as true.
-
-// Returns the TOML type of a Go value. The type may be `nil`, which means
-// no concrete TOML type could be found.
-func tomlTypeOfGo(rv reflect.Value) tomlType {
-	if isNil(rv) || !rv.IsValid() {
-		return nil
-	}
-	switch rv.Kind() {
-	case reflect.Bool:
-		return tomlBool
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
-		reflect.Int64,
-		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
-		reflect.Uint64:
-		return tomlInteger
-	case reflect.Float32, reflect.Float64:
-		return tomlFloat
-	case reflect.Array, reflect.Slice:
-		if typeEqual(tomlHash, tomlArrayType(rv)) {
-			return tomlArrayHash
-		}
-		return tomlArray
-	case reflect.Ptr, reflect.Interface:
-		return tomlTypeOfGo(rv.Elem())
-	case reflect.String:
-		return tomlString
-	case reflect.Map:
-		return tomlHash
-	case reflect.Struct:
-		switch rv.Interface().(type) {
-		case time.Time:
-			return tomlDatetime
-		case TextMarshaler:
-			return tomlString
-		default:
-			return tomlHash
-		}
-	default:
-		panic("unexpected reflect.Kind: " + rv.Kind().String())
-	}
-}
-
-// tomlArrayType returns the element type of a TOML array. The type returned
-// may be nil if it cannot be determined (e.g., a nil slice or a zero length
-// slize). This function may also panic if it finds a type that cannot be
-// expressed in TOML (such as nil elements, heterogeneous arrays or directly
-// nested arrays of tables).
-func tomlArrayType(rv reflect.Value) tomlType {
-	if isNil(rv) || !rv.IsValid() || rv.Len() == 0 {
-		return nil
-	}
-	firstType := tomlTypeOfGo(rv.Index(0))
-	if firstType == nil {
-		encPanic(errArrayNilElement)
-	}
-
-	rvlen := rv.Len()
-	for i := 1; i < rvlen; i++ {
-		elem := rv.Index(i)
-		switch elemType := tomlTypeOfGo(elem); {
-		case elemType == nil:
-			encPanic(errArrayNilElement)
-		case !typeEqual(firstType, elemType):
-			encPanic(errArrayMixedElementTypes)
-		}
-	}
-	// If we have a nested array, then we must make sure that the nested
-	// array contains ONLY primitives.
-	// This checks arbitrarily nested arrays.
-	if typeEqual(firstType, tomlArray) || typeEqual(firstType, tomlArrayHash) {
-		nest := tomlArrayType(eindirect(rv.Index(0)))
-		if typeEqual(nest, tomlHash) || typeEqual(nest, tomlArrayHash) {
-			encPanic(errArrayNoTable)
-		}
-	}
-	return firstType
-}
-
-type tagOptions struct {
-	skip      bool // "-"
-	name      string
-	omitempty bool
-	omitzero  bool
-}
-
-func getOptions(tag reflect.StructTag) tagOptions {
-	t := tag.Get("toml")
-	if t == "-" {
-		return tagOptions{skip: true}
-	}
-	var opts tagOptions
-	parts := strings.Split(t, ",")
-	opts.name = parts[0]
-	for _, s := range parts[1:] {
-		switch s {
-		case "omitempty":
-			opts.omitempty = true
-		case "omitzero":
-			opts.omitzero = true
-		}
-	}
-	return opts
-}
-
-func isZero(rv reflect.Value) bool {
-	switch rv.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return rv.Int() == 0
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return rv.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return rv.Float() == 0.0
-	}
-	return false
-}
-
-func isEmpty(rv reflect.Value) bool {
-	switch rv.Kind() {
-	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
-		return rv.Len() == 0
-	case reflect.Bool:
-		return !rv.Bool()
-	}
-	return false
-}
-
-func (enc *Encoder) newline() {
-	if enc.hasWritten {
-		enc.wf("\n")
-	}
-}
-
-func (enc *Encoder) keyEqElement(key Key, val reflect.Value) {
-	if len(key) == 0 {
-		encPanic(errNoKey)
-	}
-	panicIfInvalidKey(key)
-	enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1))
-	enc.eElement(val)
-	enc.newline()
-}
-
-func (enc *Encoder) wf(format string, v ...interface{}) {
-	if _, err := fmt.Fprintf(enc.w, format, v...); err != nil {
-		encPanic(err)
-	}
-	enc.hasWritten = true
-}
-
-func (enc *Encoder) indentStr(key Key) string {
-	return strings.Repeat(enc.Indent, len(key)-1)
-}
-
-func encPanic(err error) {
-	panic(tomlEncodeError{err})
-}
-
-func eindirect(v reflect.Value) reflect.Value {
-	switch v.Kind() {
-	case reflect.Ptr, reflect.Interface:
-		return eindirect(v.Elem())
-	default:
-		return v
-	}
-}
-
-func isNil(rv reflect.Value) bool {
-	switch rv.Kind() {
-	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-		return rv.IsNil()
-	default:
-		return false
-	}
-}
-
-func panicIfInvalidKey(key Key) {
-	for _, k := range key {
-		if len(k) == 0 {
-			encPanic(e("Key '%s' is not a valid table name. Key names "+
-				"cannot be empty.", key.maybeQuotedAll()))
-		}
-	}
-}
-
-func isValidKeyName(s string) bool {
-	return len(s) != 0
-}

vendor/github.com/BurntSushi/toml/encoding_types.go

@@ -1,19 +0,0 @@
-// +build go1.2
-
-package toml
-
-// In order to support Go 1.1, we define our own TextMarshaler and
-// TextUnmarshaler types. For Go 1.2+, we just alias them with the
-// standard library interfaces.
-
-import (
-	"encoding"
-)
-
-// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
-// so that Go 1.1 can be supported.
-type TextMarshaler encoding.TextMarshaler
-
-// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
-// here so that Go 1.1 can be supported.
-type TextUnmarshaler encoding.TextUnmarshaler

vendor/github.com/BurntSushi/toml/encoding_types_1.1.go

@@ -1,18 +0,0 @@
-// +build !go1.2
-
-package toml
-
-// These interfaces were introduced in Go 1.2, so we add them manually when
-// compiling for Go 1.1.
-
-// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
-// so that Go 1.1 can be supported.
-type TextMarshaler interface {
-	MarshalText() (text []byte, err error)
-}
-
-// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
-// here so that Go 1.1 can be supported.
-type TextUnmarshaler interface {
-	UnmarshalText(text []byte) error
-}