Fix Travis CI

Fixes #112

.editorconfig

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

.github/CONTRIBUTING.md

@@ -1,6 +1,12 @@
 * Bug reports and feature requests are welcome in [the issues][issues]
+* For questions and discussion there's the [Slack room][slack] ([invititation here][slackinvite])
 * Pull Requests are welcome. For more complex changes and features it's
-  recommended to open an issue with the feature request first
+  recommended to open an issue first
+* About 3 or 4 pull requests accepted one gets write access to the repo.
+  Even then, possible backward incompatible changes should be discussed first
+  in an issue or pull request
 * Documentation contributions are as important as code contributions
 
 [issues]: https://github.com/go-task/task/issues
+[slack]: https://gophers.slack.com/messages/task
+[slackinvite]: https://invite.slack.golangbridge.org/

.github/ISSUE_TEMPLATE.md

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

.goreleaser.yml

@@ -11,8 +11,6 @@ build:
   ignore:
     - goos: darwin
       goarch: 386
-  env:
-    - CGO_ENABLED=0
 
 archive:
   name_template: "{{.Binary}}_{{.Os}}_{{.Arch}}"

.travis.yml

@@ -1,8 +1,9 @@
 language: go
 
 go:
-  - 1.9.x
-  - 1.10.x
+  - '1.8'
+  - '1.9'
+  - '1.10'
 
 addons:
   apt:

Gopkg.lock

@@ -2,187 +2,135 @@
 
 
 [[projects]]
-  branch = "master"
-  digest = "1:f3960e064201714a3507bf96183be246b3d941568af01dc5cff2a388ac4c7515"
   name = "github.com/Masterminds/semver"
   packages = ["."]
-  pruneopts = "NUT"
-  revision = "c84ddcca87bf5a941b138dde832a7e20b0159ad8"
+  revision = "15d8430ab86497c5c0da827b748823945e1cf1e1"
+  version = "v1.4.0"
 
 [[projects]]
   branch = "master"
-  digest = "1:58551c80f84fd3ba2954668f5f850a8179dc3c5bb4885fc7eed5a8e2ae815c99"
   name = "github.com/Masterminds/sprig"
   packages = ["."]
-  pruneopts = "NUT"
-  revision = "77bb58b7f5e10889a1195c21b9e7a96ee166f199"
+  revision = "9d9aa1f74c86fd9d36ecfe3f2a44a3093c3d4c15"
 
 [[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"
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
   version = "v1.1.0"
 
 [[projects]]
-  digest = "1:9a52adf44086cead3b384e5d0dbf7a1c1cce65e67552ee3383a8561c42a18cd3"
-  name = "github.com/imdario/mergo"
+  branch = "master"
+  name = "github.com/huandu/xstrings"
   packages = ["."]
-  pruneopts = "NUT"
-  revision = "9f23e2d6bd2a77f959b2bf6acdbefd708a83a4a4"
-  version = "v0.3.6"
+  revision = "2bf18b218c51864a87384c06996e40ff9dcff8e1"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/imdario/mergo"
+  packages = ["."]
+  revision = "0d4b488675fdec1dde48751b05ab530cf0b630e1"
 
 [[projects]]
   branch = "master"
-  digest = "1:729c1199021f057f38487f7e64432f3539f9efac444185e64b4b7e121414ac68"
   name = "github.com/mattn/go-zglob"
   packages = [
     ".",
-    "fastwalk",
+    "fastwalk"
   ]
-  pruneopts = "NUT"
-  revision = "2ea3427bfa539cca900ca2768d8663ecc8a708c1"
+  revision = "4959821b481786922ac53e7ef25c61ae19fb7c36"
 
 [[projects]]
-  digest = "1:a4df73029d2c42fabcb6b41e327d2f87e685284ec03edf76921c267d9cfc9c23"
+  branch = "master"
   name = "github.com/mitchellh/go-homedir"
   packages = ["."]
-  pruneopts = "NUT"
-  revision = "ae18d6b8b3205b561c79e8e5f69bff09736185f4"
-  version = "v1.0.0"
+  revision = "b8bc1bf767474819792c23f32d8286a45736f1c6"
 
 [[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"
+  revision = "6145e1439b9de93806925353403f91d2abbad8a5"
+  version = "v1.0.2"
+
+[[projects]]
+  name = "github.com/satori/go.uuid"
+  packages = ["."]
+  revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3"
+  version = "v1.2.0"
 
 [[projects]]
   branch = "master"
-  digest = "1:9d8420bbf131d1618bde6530af37c3799340d3762cc47210c1d9532a4c3a2779"
   name = "github.com/spf13/pflag"
   packages = ["."]
-  pruneopts = "NUT"
-  revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
+  revision = "ee5fd03fd6acfd43e44aea0b4135958546ed8e73"
 
 [[projects]]
-  digest = "1:bacb8b590716ab7c33f2277240972c9582d389593ee8d66fc10074e0508b8126"
   name = "github.com/stretchr/testify"
   packages = ["assert"]
-  pruneopts = "NUT"
-  revision = "f35b8ab0b5a2cef36673838d662e249dd9c94686"
-  version = "v1.2.2"
+  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
+  version = "v1.2.1"
 
 [[projects]]
   branch = "master"
-  digest = "1:69b3fcb7a41b18436a85471cbdcfc70ad10ba3206f8c87563e1c773610e1bcad"
   name = "golang.org/x/crypto"
   packages = [
     "pbkdf2",
     "scrypt",
-    "ssh/terminal",
+    "ssh/terminal"
   ]
-  pruneopts = "NUT"
-  revision = "182538f80094b6a8efaade63a8fd8e0d9d5843dd"
+  revision = "91a49db82a88618983a78a06c1cbd4e00ab749ab"
 
 [[projects]]
   branch = "master"
-  digest = "1:76ee51c3f468493aff39dbacc401e8831fbb765104cbf613b89bef01cf4bad70"
   name = "golang.org/x/net"
   packages = ["context"]
-  pruneopts = "NUT"
-  revision = "8a410e7b638dca158bf9e766925842f6651ff828"
+  revision = "22ae77b79946ea320088417e4d50825671d82d57"
 
 [[projects]]
   branch = "master"
-  digest = "1:39ebcc2b11457b703ae9ee2e8cca0f68df21969c6102cb3b705f76cca0ea0239"
   name = "golang.org/x/sync"
   packages = ["errgroup"]
-  pruneopts = "NUT"
-  revision = "1d60e4601c6fd243af51cc01ddf169918a5407ca"
+  revision = "fd80eb99c8f653c847d294a001bdf2a3a6f768f5"
 
 [[projects]]
   branch = "master"
-  digest = "1:8270f14d85e8d36e852e018872ac923f7a2067648bfe8428d01be288818aa337"
   name = "golang.org/x/sys"
   packages = [
     "unix",
-    "windows",
+    "windows"
   ]
-  pruneopts = "NUT"
-  revision = "fa5fdf94c78965f1aa8423f0cc50b8b8d728b05a"
+  revision = "dd2ff4accc098aceecb86b36eaa7829b2a17b1c9"
 
 [[projects]]
-  branch = "v2"
-  digest = "1:7c95b35057a0ff2e19f707173cc1a947fa43a6eb5c4d300d196ece0334046082"
   name = "gopkg.in/yaml.v2"
   packages = ["."]
-  pruneopts = "NUT"
-  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+  revision = "7f97868eec74b32b0982dd158a51a446d1da7eb5"
+  version = "v2.1.1"
 
 [[projects]]
   branch = "master"
-  digest = "1:e647f1f4fcc94a6baad3965a347c1ac4ed669f31c87c826516314e415d1a4ad2"
   name = "mvdan.cc/sh"
   packages = [
     "interp",
-    "shell",
-    "syntax",
+    "syntax"
   ]
-  pruneopts = "NUT"
-  revision = "3a244a89e2e520d2777e94693d51bef800761879"
+  revision = "fb0bad77f8fa7a57e6f249f53074ec52b21558d1"
 
 [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",
-  ]
+  inputs-digest = "976972e7291789a9d4904805cc7f49d733476868bf80f120309078b02a095a65"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -7,6 +7,10 @@
   branch = "master"
   name = "github.com/Masterminds/sprig"
 
+[[constraint]]
+  branch = "master"
+  name = "github.com/imdario/mergo"
+
 [[constraint]]
   branch = "master"
   name = "github.com/mattn/go-zglob"
@@ -31,6 +35,10 @@
   branch = "master"
   name = "github.com/radovskyb/watcher"
 
+[[constraint]]
+  branch = "master"
+  name = "github.com/mitchellh/go-homedir"
+
 [[constraint]]
   branch = "master"
   name = "github.com/Masterminds/semver"

README.md

@@ -1,12 +1,665 @@
+[![Join Slack room](https://img.shields.io/badge/%23task-chat%20room-blue.svg)](https://gophers.slack.com/messages/task)
 [![Build Status](https://travis-ci.org/go-task/task.svg?branch=master)](https://travis-ci.org/go-task/task)
 
-# Task
+# Task - A task runner / simpler Make alternative written in Go
 
-Task is a task runner / build tool that aims to be simpler and easier to use
-than, for example, [GNU Make][make].
+> 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 Golang, but can be used to develop any language.
+It aims to be simpler and easier to use then [GNU Make][make].
 
-See [taskfile.org](https://taskfile.org) for documentation.
+- [Installation](#installation)
+  - [Go](#go)
+  - [Homebrew](#homebrew)
+  - [Snap](#snap)
+  - [Binary](#binary)
+- [Usage](#usage)
+  - [Environment](#environment)
+  - [OS specific task](#os-specific-task)
+  - [Task directory](#task-directory)
+  - [Task dependencies](#task-dependencies)
+  - [Calling another task](#calling-another-task)
+  - [Prevent unnecessary work](#prevent-unnecessary-work)
+  - [Variables](#variables)
+    - [Dynamic variables](#dynamic-variables)
+  - [Go's template engine](#gos-template-engine)
+  - [Help](#help)
+  - [Silent mode](#silent-mode)
+  - [Watch tasks](#watch-tasks-experimental)
+- [Examples](#examples)
+- [Alternative task runners](#alternative-task-runners)
+
+## Installation
+
+### 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
+```
+
+### Homebrew
+
+If you're on macOS and have [Homebrew][homebrew] installed, getting Task is
+as simple as running:
+
+```bash
+brew update
+brew tap go-task/tap
+brew install 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
+```
+
+### 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.
+The `cmds` attribute should contains the commands of a task.
+The example below allows compile a Go app and uses [Minify][minify] to concat
+and minify multiple CSS files into a single one.
+
+```yml
+version: '2'
+
+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:
+
+```bash
+task assets build
+```
+
+Task uses [github.com/mvdan/sh](https://github.com/mvdan/sh), a native Go sh
+interpreter. So you can write sh/bash commands and it will work even on
+Windows, where `sh` or `bash` is usually not available. Just remember any
+executable called must be available by the OS or in PATH.
+
+If you ommit a task name, "default" will be assumed.
+
+### Environment
+
+You can specify environment variables that are added when running a command:
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - echo $hallo
+    env:
+      hallo: welt
+```
+
+### OS specific task
+
+If you add a `Taskfile_{{GOOS}}.yml` you can override or amend your taskfile
+based on the operating system.
+
+Example:
+
+Taskfile.yml:
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - echo "default"
+```
+
+Taskfile_linux.yml:
+
+```yml
+tasks:
+  build:
+    cmds:
+      - echo "linux"
+```
+
+Will print out `linux` and not default.
+
+It's also possible to have OS specific `Taskvars.yml` file, like
+`Taskvars_windows.yml`, `Taskfile_linux.yml` or `Taskvars_darwin.yml`. See the
+[variables section](#variables) below.
+
+### Task directory
+
+By default, tasks will be executed in the directory where the Taskfile is
+located. But you can easily make the task run in another folder informing
+`dir`:
+
+```yml
+version: '2'
+
+tasks:
+  serve:
+    dir: public/www
+    cmds:
+      # run http server
+      - caddy
+```
+
+### Task dependencies
+
+You may have tasks that depends on others. Just pointing them on `deps` will
+make them run automatically before running the parent task:
+
+```yml
+version: '2'
+
+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
+`task build`.
+
+A task can have only dependencies and no commands to group tasks together:
+
+```yml
+version: '2'
+
+tasks:
+  assets:
+    deps: [js, css]
+
+  js:
+    cmds:
+      - minify -o public/script.js src/js
+
+  css:
+    cmds:
+      - minify -o public/style.css src/css
+```
+
+If there are 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
+version: '2'
+
+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}}
+```
+
+### Calling another task
+
+When a task has many dependencies, they are executed concurrently. This will
+often result in a faster build pipeline. But in some situations you may need
+to call other tasks serially. In this case, just use the following syntax:
+
+```yml
+version: '2'
+
+tasks:
+  main-task:
+    cmds:
+      - task: task-to-be-called
+      - task: another-task
+      - echo "Both done"
+
+  task-to-be-called:
+    cmds:
+      - echo "Task to be called"
+
+  another-task:
+    cmds:
+      - echo "Another task"
+```
+
+Overriding variables in the called task is as simple as informing `vars`
+attribute:
+
+```yml
+version: '2'
+
+tasks:
+  main-task:
+    cmds:
+      - task: write-file
+        vars: {FILE: "hello.txt", CONTENT: "Hello!"}
+      - task: write-file
+        vars: {FILE: "world.txt", CONTENT: "World!"}
+
+  write-file:
+    cmds:
+      - echo "{{.CONTENT}}" > {{.FILE}}
+```
+
+The above syntax is also supported in `deps`.
+
+### Prevent unnecessary work
+
+If a task generates something, you can inform Task the source and generated
+files, so Task will prevent to run them if not necessary.
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    deps: [js, css]
+    cmds:
+      - go build -v -i main.go
+
+  js:
+    cmds:
+      - minify -o public/script.js src/js
+    sources:
+      - src/js/**/*.js
+    generates:
+      - public/script.js
+
+  css:
+    cmds:
+      - minify -o public/style.css src/css
+    sources:
+      - src/css/**/*.css
+    generates:
+      - public/style.css
+```
+
+`sources` and `generates` can be files or file patterns. When both are given,
+Task will compare the modification date/time of the files to determine if it's
+necessary to run the task. If not, it will just print a message like
+`Task "js" is up to date`.
+
+If you prefer this check to be made by the content of the files, instead of
+its timestamp, just set the `method` property to `checksum`.
+You will probably want to ignore the `.task` folder in your `.gitignore` file
+(It's there that Task stores the last checksum).
+This feature is still experimental and can change until it's stable.
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - go build .
+    sources:
+      - ./*.go
+    generates:
+      - app{{exeExt}}
+    method: checksum
+```
+
+> TIP: method `none` skips any validation and always run the task.
+
+Alternatively, you can inform a sequence of tests as `status`. If no error
+is returned (exit status 0), the task is considered up-to-date:
+
+```yml
+version: '2'
+
+tasks:
+  generate-files:
+    cmds:
+      - mkdir directory
+      - touch directory/file1.txt
+      - touch directory/file2.txt
+    # test existence of files
+    status:
+      - test -d directory
+      - test -f directory/file1.txt
+      - test -f directory/file2.txt
+```
+
+You can use `--force` or `-f` if you want to force a task to run even when
+up-to-date.
+
+Also, `task --status [tasks]...` will exit with non-zero exit code if any of
+the tasks is not up-to-date.
+
+### Variables
+
+When doing interpolation of variables, Task will look for the below.
+They are listed below in order of importance (e.g. most important first):
+
+- Variables declared locally in the task
+- Variables given while calling a task from another.
+  (See [Calling another task](#calling-another-task) above)
+- Variables declared in the `vars:` option in the `Taskfile`
+- Variables available in the `Taskvars.yml` file
+- Environment variables
+
+Example of sending parameters with environment variables:
+
+```bash
+$ TASK_VARIABLE=a-value task do-something
+```
+
+Since some shells don't support above syntax to set environment variables
+(Windows) tasks also accepts a similar style when not in the beginning of
+the command. Variables given in this form are only visible to the task called
+right before.
+
+```bash
+$ task write-file FILE=file.txt "CONTENT=Hello, World!" print "MESSAGE=All done!"
+```
+
+Example of locally declared vars:
+
+```yml
+version: '2'
+
+tasks:
+  print-var:
+    cmds:
+      echo "{{.VAR}}"
+    vars:
+      VAR: Hello!
+```
+
+Example of global vars in a `Taskfile.yml`:
+
+```yml
+version: '2'
+
+vars:
+  GREETING: Hello from Taskfile!
+
+tasks:
+  greet:
+    cmds:
+      - echo "{{.GREETING}}"
+```
+
+Example of `Taskvars.yml` file:
+
+```yml
+PROJECT_NAME: My Project
+DEV_MODE: production
+GIT_COMMIT: {sh: git log -n 1 --format=%h}
+```
+
+#### Variables expansion
+
+Variables are expanded 2 times by default. You can change that by setting the
+`expansions:` option. Change that will be necessary if you compose many
+variables together:
+
+```yml
+version: '2'
+
+expansions: 3
+
+vars:
+  FOO: foo
+  BAR: bar
+  BAZ: baz
+  FOOBAR: "{{.FOO}}{{.BAR}}"
+  FOOBARBAZ: "{{.FOOBAR}}{{.BAZ}}"
+
+tasks:
+  default:
+    cmds:
+      - echo "{{.FOOBARBAZ}}"
+```
+
+#### Dynamic variables
+
+The below syntax (`sh:` prop in a variable) is considered a dynamic variable.
+The value will be treated as a command and the output assigned. If there is one
+or more trailing newlines, the last newline will be trimmed.
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - go build -ldflags="-X main.Version={{.GIT_COMMIT}}" main.go
+    vars:
+      GIT_COMMIT:
+        sh: git log -n 1 --format=%h
+```
+
+This works for all types of variables.
+
+### Go's template engine
+
+Task parse commands as [Go's template engine][gotemplate] before executing
+them. Variables are accessible through dot syntax (`.VARNAME`).
+
+All functions by the Go's [sprig lib](http://masterminds.github.io/sprig/)
+are available. The following example gets the current date in a given format:
+
+```yml
+version: '2'
+
+tasks:
+  print-date:
+    cmds:
+      - echo {{now | date "2006-01-02"}}
+```
+
+Task also adds the following functions:
+
+- `OS`: Returns operating system. Possible values are "windows", "linux",
+  "darwin" (macOS) and "freebsd".
+- `ARCH`: return the architecture Task was compiled to: "386", "amd64", "arm"
+  or "s390x".
+- `splitLines`: Splits Unix (\n) and Windows (\r\n) styled newlines.
+- `catLines`: Replaces Unix (\n) and Windows (\r\n) styled newlines with a space.
+- `toSlash`: Does nothing on Unix, but on Windows converts a string from `\`
+  path format to `/`.
+- `fromSlash`: Oposite of `toSlash`. Does nothing on Unix, but on Windows
+  converts a string from `\` path format to `/`.
+- `exeExt`: Returns the right executable extension for the current OS
+  (`".exe"` for Windows, `""` for others).
+
+Example:
+
+```yml
+version: '2'
+
+tasks:
+  print-os:
+    cmds:
+      - echo '{{OS}} {{ARCH}}'
+      - echo '{{if eq OS "windows"}}windows-command{{else}}unix-command{{end}}'
+      # This will be path/to/file on Unix but path\to\file on Windows
+      - echo '{{fromSlash "path/to/file"}}'
+  enumerated-file:
+    vars:
+      CONTENT: |
+        foo
+        bar
+    cmds:
+      - |
+        cat << EOF > output.txt
+        {{range $i, $line := .CONTENT | splitLines -}}
+        {{printf "%3d" $i}}: {{$line}}
+        {{end}}EOF
+```
+
+### Help
+
+Running `task --list` (or `task -l`) lists all tasks with a description.
+The following taskfile:
+
+```yml
+version: '2'
+
+tasks:
+  build:
+    desc: Build the go binary.
+    cmds:
+      - go build -v -i main.go
+
+  test:
+    desc: Run all the go tests.
+    cmds:
+      - go test -race ./...
+
+  js:
+    cmds:
+      - minify -o public/script.js src/js
+
+  css:
+    cmds:
+      - minify -o public/style.css src/css
+```
+
+would print the following output:
+
+```bash
+* build:   Build the go binary.
+* test:    Run all the go tests.
+```
+
+## Silent mode
+
+Silent mode disables echoing of commands before Task runs it.
+For the following Taskfile:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - echo "Print something"
+```
+
+Normally this will be print:
+
+```sh
+echo "Print something"
+Print something
+```
+
+With silent mode on, the below will be print instead:
+
+```sh
+Print something
+```
+
+There's three ways to enable silent mode:
+
+* At command level:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - cmd: echo "Print something"
+        silent: true
+```
+
+* At task level:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - echo "Print something"
+    silent: true
+```
+
+* Or globally with `--silent` or `-s` flag
+
+If you want to suppress stdout instead, just redirect a command to `/dev/null`:
+
+```yml
+version: '2'
+
+tasks:
+  echo:
+    cmds:
+      - echo "This will print nothing" > /dev/null
+```
+
+## Watch tasks (experimental)
+
+If you give a `--watch` or `-w` argument, task will watch for files changes
+and run the task again. This requires the `sources` attribute to be given,
+so task know which files to watch.
+
+## Examples
+
+The [go-task/examples][examples] intends to be a collection of Taskfiles for
+various use cases.
+(It still lacks many examples, though. Contributions are welcome).
+
+## Alternative task runners
+
+- YAML based:
+  - [goeuro/myke][myke]
+  - [dreadl0ck/zeus][zeus]
+  - [rliebz/tusk][tusk]
+- Go based:
+  - [markbates/grift][grift]
+  - [magefile/mage][mage]
+- Make based:
+  - [tj/mmake][mmake]
 
 [make]: https://www.gnu.org/software/make/
+[releases]: https://github.com/go-task/task/releases
+[golang]: https://golang.org/
+[gotemplate]: https://golang.org/pkg/text/template/
+[myke]: https://github.com/goeuro/myke
+[zeus]: https://github.com/dreadl0ck/zeus
+[tusk]: https://github.com/rliebz/tusk
+[grift]: https://github.com/markbates/grift
+[mage]: https://github.com/magefile/mage
+[mmake]: https://github.com/tj/mmake
+[sh]: https://github.com/mvdan/sh
+[minify]: https://github.com/tdewolff/minify/tree/master/cmd/minify
+[examples]: https://github.com/go-task/examples
+[snapcraft]: https://snapcraft.io/
+[homebrew]: https://brew.sh/

RELEASING_TASK.md

@@ -21,7 +21,7 @@ The exception is the publishing of a new version of the
 the binaries:
 
 * Updating the current version on [snapcraft.yaml][snapcraftyaml];
-* Moving both `i386` and `amd64` new artifacts to the stable channel on
+* Moving either the `i386` and `amd64` new artifacts to the stable channel on
 the [Snapscraft dashboard][snapcraftdashboard]
 
 [goreleaser]: https://goreleaser.com/#continuous_integration

TASKFILE_VERSIONS.md

@@ -1,9 +1,9 @@
-# Taskfile Versions
+# 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
+# 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.
@@ -18,7 +18,7 @@ available, but not `3.0.0+`.
 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:
 
-```yaml
+```yml
 echo:
   cmds:
     - echo "Hello, World!"
@@ -37,7 +37,7 @@ 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:
 
-```yaml
+```yml
 version: '2'
 
 tasks:
@@ -49,7 +49,7 @@ tasks:
 Version 2 allows you to write global variables directly in the Taskfile,
 if you don't want to create a `Taskvars.yml`:
 
-```yaml
+```yml
 version: '2'
 
 vars:
@@ -72,7 +72,7 @@ The variable priority order changed to the following:
 A new global option was added to configure the number of variables expansions
 (which default to 2):
 
-```yaml
+```yml
 version: '2'
 
 expansions: 3
@@ -89,60 +89,3 @@ tasks:
     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):
-
-```yaml
-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 documentation [here][ignore_errors]):
-
-```yaml
-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
-```
-
-## Version 2.2
-
-Version 2.2 comes with a global `includes` options to include other
-Taskfiles:
-
-```yaml
-version: '2'
-
-includes:
-  docs: ./documentation # will look for ./documentation/Taskfile.yml
-  docker: ./DockerTasks.yml
-```
-
-Please check the [documentation][includes]
-
-[output]: usage#output-syntax
-[ignore_errors]: usage#ignore-errors
-[includes]: usage#including-other-taskfiles

Taskfile.yml

@@ -1,29 +1,20 @@
 version: '2'
 
-vars:
-  GIT_COMMIT:
-    sh: git log -n 1 --format=%h
-
-  GO_PACKAGES:
-    sh: go list ./...
-
 tasks:
-  default:
-    cmds:
-      - task: test
-
+  # compiles current source code and make "task" executable available on
+  # $GOPATH/bin/task{.exe}
   install:
     desc: Installs Task
     cmds:
       - go install -v -ldflags="-w -s -X main.version={{.GIT_COMMIT}}" ./cmd/task
-    env:
-      CGO_ENABLED: '0'
 
   dl-deps:
     desc: Downloads cli dependencies
     cmds:
       - task: go-get
-        vars: {REPO: golang.org/x/lint/golint}
+        vars: {REPO: github.com/golang/lint/golint}
+      - task: go-get
+        vars: {REPO: github.com/asticode/go-astitodo/astitodo}
       - task: go-get
         vars: {REPO: github.com/golang/dep/cmd/dep}
       - task: go-get
@@ -45,48 +36,33 @@ tasks:
   lint:
     desc: Runs golint
     cmds:
-      - golint {{catLines .GO_PACKAGES}}
+      - golint {{.GO_PACKAGES}}
     silent: true
 
   test:
     desc: Runs test suite
     deps: [install]
     cmds:
-      - go test {{catLines .GO_PACKAGES}}
+      - go test {{.GO_PACKAGES}}
 
   test-release:
     desc: Tests release process without publishing
     cmds:
       - goreleaser --snapshot --rm-dist
 
-  generate-install-script:
-    desc: Generate install script using https://github.com/goreleaser/godownloader
+  todo:
+    desc: Prints TODO comments present in the code
     cmds:
-      - godownloader --repo go-task/task -o install-task.sh
-      - cp ./install-task.sh ./docs/install.sh
+      - astitodo {{.GO_PACKAGES}}
+    silent: true
 
   ci:
     cmds:
       - task: go-get
-        vars: {REPO: golang.org/x/lint/golint}
+        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
-
-  docs:install:
-    desc: Installs docsify to work the on the documentation site
-    cmds:
-      - npm install docsify-cli -g
-
-  docs:serve:
-    desc: Serves the documentation site locally
-    cmds:
-      - docsify serve docs

Taskvars.yml

@@ -0,0 +1,15 @@
+GIT_COMMIT:
+  sh: git log -n 1 --format=%h
+
+GO_PACKAGES:
+  .
+  ./cmd/task
+  ./internal/args
+  ./internal/compiler
+  ./internal/compiler/v1
+  ./internal/compiler/v2
+  ./internal/execext
+  ./internal/logger
+  ./internal/status
+  ./internal/taskfile
+  ./internal/templater

cmd/task/task.go

@@ -17,7 +17,7 @@ var (
 	version = "master"
 )
 
-const usage = `Usage: task [-ilfwvsd] [--init] [--list] [--force] [--watch] [--verbose] [--silent] [--dir] [--dry] [task...]
+const usage = `Usage: task [-ilfwvsd] [--init] [--list] [--force] [--watch] [--verbose] [--silent] [--dir] [task...]
 
 Runs the specified task(s). Falls back to the "default" task if no task name
 was specified, or lists all tasks if an unknown task name was specified.
@@ -55,7 +55,6 @@ func main() {
 		watch       bool
 		verbose     bool
 		silent      bool
-		dry         bool
 		dir         string
 	)
 
@@ -67,7 +66,6 @@ func main() {
 	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()
 
@@ -87,20 +85,14 @@ func main() {
 		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,
+		Context: getSignalContext(),
 
 		Stdin:  os.Stdin,
 		Stdout: os.Stdout,

completion/zsh/_task

@@ -1,25 +0,0 @@
-#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' \

docs/CNAME

@@ -1 +0,0 @@
-taskfile.org

docs/README.md

@@ -1,46 +0,0 @@
-# Task
-
-Task is a task runner / build tool that aims to be simpler and easier to use
-than, for example, [GNU Make][make].
-
-Since it's written in [Go][go], Task is just a single binary and has no other
-dependencies, which means you don't need to mess with any complicated install
-setups just to use a build tool.
-
-Once [installed](installation), you just need to describe your build tasks
-using a simple [YAML][yaml] schema in a file called `Taskfile.yml`:
-
-```yaml
-version: '2'
-
-tasks:
-  hello:
-    cmds:
-      - echo 'Hello World from Task!'
-    silent: true
-```
-
-And call it by running `task hello` from you terminal.
-
-The above example is just the start, you can take a look at the [usage](usage)
-guide to check the full schema documentation and Task features.
-
-## Features
-
-- [Easy installation](installation): just download a single binary, add to
-  $PATH and you're done! Or you can also install using [Homebrew][homebrew] or
-  [Snapcraft][snapcraft] if you want;
-- Available on CIs: by adding [this simple command](installation#install-script)
-  to install on your CI script and you're done to use Task as part of your CI pipeline;
-- Truly cross-platform: while most build tools only work well on Linux or macOS,
-  Task also supports Windows thanks to [this awesome shell interpreter for Go][sh];
-- Great for code generation: you can easily [prevent a task from running](usage#prevent-unnecessary-work)
-  if a given set of files haven't changed since last run (based either on its
-  timestamp or content).
-
-[make]: https://www.gnu.org/software/make/
-[go]: https://golang.org/
-[yaml]: http://yaml.org/
-[homebrew]: https://brew.sh/
-[snapcraft]: https://snapcraft.io/
-[sh]: https://mvdan.cc/sh

docs/_sidebar.md

@@ -1,8 +0,0 @@
-- [Installation](installation)
-- [Usage](usage)
-- [Taskfile Versions](taskfile_versions)
-- [Examples](examples)
-- [Releasing Task](releasing_task)
-- [Alternative Task Runners](alternative_task_runners)
-- [Sponsors and Backers](sponsors_and_backers)
-- [![Github](https://icongram.jgog.in/simple/github.svg?color=808080&size=16)Github](https://github.com/go-task/task)

docs/alternative_task_runners.md

@@ -1,17 +0,0 @@
-# Alternative task runners
-
-## YAML based
-
-- [rliebz/tusk][tusk]
-
-## Go based
-
-- [magefile/mage][mage]
-
-## Make similar
-
-- [casey/just][just]
-
-[tusk]: https://github.com/rliebz/tusk
-[mage]: https://github.com/magefile/mage
-[just]: https://github.com/casey/just

docs/examples.md

@@ -1,7 +0,0 @@
-# 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).
-
-[examples]: https://github.com/go-task/examples

docs/index.html

@@ -1,49 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8">
-    <title>Task</title>
-    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
-    <meta name="description" content="A task runner / simpler Make alternative written in Go">
-    <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
-    <link rel="stylesheet" href="//unpkg.com/docsify-themeable/dist/css/theme-simple.css">
-    <meta name="google-site-verification" content="VGAYkbdmuaciIDGkBe-eAg9yfZg0C6ostgonbGxxOa0" />
-    <script>
-      var SeedAndDewConfig = {};
-      (function() {
-        SeedAndDewConfig['adClass'] = "snd-ad";
-        /* * * DON'T EDIT BELOW THIS LINE * * */
-        SeedAndDewConfig['projectId'] = '16e0aed0-b265-48c9-9eae-0aad56147553';
-        SeedAndDewConfig['loadStartTime'] = performance.now();
-        SeedAndDewConfig['apiVersion'] = '2018-05-28'
-        SeedAndDewConfig['sessionId'] = Math.random().toString(36).substring(2, 15);
-        var snd = document.createElement('script');
-        snd.type = 'text/javascript';
-        snd.async = true;
-        snd.src = 'https://www.seedanddew.com/static/embed.min.js';
-        (document.getElementsByTagName('head')[0] ||
-        document.getElementsByTagName('body')[0]).appendChild(snd);
-      })();
-    </script>
-  </head>
-  <body>
-    <div id="app"></div>
-    <script>
-      window.$docsify = {
-        name: 'Task',
-        repo: 'go-task/task',
-        ga: 'UA-126286662-1',
-        themeColor: '#83d0f2',
-        loadSidebar: true,
-        auto2top: true,
-        maxLevel: 3,
-        subMaxLevel: 3
-      }
-    </script>
-    <script src="//unpkg.com/docsify/lib/docsify.min.js"></script>
-    <script src="//unpkg.com/docsify/lib/plugins/ga.min.js"></script>
-    <script src="//unpkg.com/docsify-themeable"></script>
-    <script src="//unpkg.com/prismjs/components/prism-bash.min.js"></script>
-    <script src="//unpkg.com/prismjs/components/prism-yaml.min.js"></script>
-  </body>
-</html>

docs/install.sh

@@ -1,390 +0,0 @@
-#!/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

docs/installation.md

@@ -1,53 +0,0 @@
-# Installation
-
-## 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.
-
-## 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
-```
-
-## Go
-
-If you have a [Go][go] environment setup, you can simply run:
-
-```bash
-go get -u -v github.com/go-task/task/cmd/task
-```
-
-## Install script
-
-We also have a [install script][installscript], which is very useful on
-scanarios like CIs. Many thanks to [godownloader][godownloader] for allowing
-easily generating this script.
-
-```bash
-curl -s https://taskfile.org/install.sh | sh
-```
-
-> This method will download the binary on the local `./bin` directory by default.
-
-[go]: https://golang.org/
-[snapcraft]: https://snapcraft.io/
-[homebrew]: https://brew.sh/
-[installscript]: https://github.com/go-task/task/blob/master/install-task.sh
-[releases]: https://github.com/go-task/task/releases
-[godownloader]: https://github.com/goreleaser/godownloader

docs/sponsors_and_backers.md

@@ -1,16 +0,0 @@
-# Sponsors and Backers
-
-## 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]
-
-[opencollective]: https://opencollective.com/task
-[contributors]: https://github.com/go-task/task/graphs/contributors

docs/usage.md

@@ -1,694 +0,0 @@
-# Usage
-
-## Getting started
-
-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.
-
-```yaml
-version: '2'
-
-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:
-
-```bash
-task assets build
-```
-
-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:
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - echo $hallo
-    env:
-      hallo: welt
-```
-
-## Operating System specific tasks
-
-If you add a `Taskfile_{{GOOS}}.yml` you can override or amend your Taskfile
-based on the operating system.
-
-Example:
-
-Taskfile.yml:
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - echo "default"
-```
-
-Taskfile_linux.yml:
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - echo "linux"
-```
-
-Will print out `linux` and not `default`.
-
-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.
-
-## Including other Taskfiles
-
-If you want to share tasks between different projects (Taskfiles), you can use
-the importing mechanism to include other Taskfiles using the `includes` keyword:
-
-```yaml
-version: '2'
-
-includes:
-  docs: ./documentation # will look for ./documentation/Taskfile.yml
-  docker: ./DockerTasks.yml
-```
-
-The tasks described in the given Taskfiles will be available with the informed
-namespace. So, you'd call `task docs:serve` to run the `serve` task from
-`documentation/Taskfile.yml` or `task docker:build` to run the `build` task
-from the `DockerTasks.yml` file.
-
-> The included Taskfiles must be using the same schema version the main
-> Taskfile uses.
-
-> Also, for now included Taskfiles can't include other Taskfiles.
-> This was a deliberate decision to keep use and implementation simple.
-> If you disagree, open an GitHub issue and explain your use case. =)
-
-## 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`:
-
-```yaml
-version: '2'
-
-tasks:
-  serve:
-    dir: public/www
-    cmds:
-      # run http server
-      - caddy
-```
-
-## Task dependencies
-
-You may have tasks that depend on others. Just pointing them on `deps` will
-make them run automatically before running the parent task:
-
-```yaml
-version: '2'
-
-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
-`task build`.
-
-A task can have only dependencies and no commands to group tasks together:
-
-```yaml
-version: '2'
-
-tasks:
-  assets:
-    deps: [js, css]
-
-  js:
-    cmds:
-      - minify -o public/script.js src/js
-
-  css:
-    cmds:
-      - minify -o public/style.css src/css
-```
-
-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):
-
-```yaml
-version: '2'
-
-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}}
-```
-
-## Calling another task
-
-When a task has many dependencies, they are executed concurrently. This will
-often result in a faster build pipeline. But in some situations you may need
-to call other tasks serially. In this case, just use the following syntax:
-
-```yaml
-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:
-
-```yaml
-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.
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    deps: [js, css]
-    cmds:
-      - go build -v -i main.go
-
-  js:
-    cmds:
-      - minify -o public/script.js src/js
-    sources:
-      - src/js/**/*.js
-    generates:
-      - public/script.js
-
-  css:
-    cmds:
-      - minify -o public/style.css src/css
-    sources:
-      - src/css/**/*.css
-    generates:
-      - public/style.css
-```
-
-`sources` and `generates` can be files or file patterns. When both are given,
-Task will compare the modification date/time of the files to determine if it's
-necessary to run the task. If not, it will just print a message like
-`Task "js" is up to date`.
-
-If you prefer this check to be made by the content of the files, instead of
-its timestamp, just set the `method` property to `checksum`.
-You will probably want to ignore the `.task` folder in your `.gitignore` file
-(It's there that Task stores the last checksum).
-
-```yaml
-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:
-
-```yaml
-version: '2'
-
-tasks:
-  generate-files:
-    cmds:
-      - mkdir directory
-      - touch directory/file1.txt
-      - touch directory/file2.txt
-    # test existence of files
-    status:
-      - test -d directory
-      - test -f directory/file1.txt
-      - test -f directory/file2.txt
-```
-
-You can use `--force` or `-f` if you want to force a task to run even when
-up-to-date.
-
-Also, `task --status [tasks]...` will exit with a non-zero exit code if any of
-the tasks are not up-to-date.
-
-## Variables
-
-When doing interpolation of variables, Task will look for the below.
-They are listed below in order of importance (e.g. most important first):
-
-- Variables declared locally in the task
-- Variables given while calling a task from another.
-  (See [Calling another task](#calling-another-task) above)
-- Variables declared in the `vars:` option in the `Taskfile`
-- Variables available in the `Taskvars.yml` file
-- Environment variables
-
-Example of sending parameters with environment variables:
-
-```bash
-$ TASK_VARIABLE=a-value task do-something
-```
-
-Since some shells don't support above syntax to set environment variables
-(Windows) tasks also accepts a similar style when not in the beginning of
-the command. Variables given in this form are only visible to the task called
-right before.
-
-```bash
-$ task write-file FILE=file.txt "CONTENT=Hello, World!" print "MESSAGE=All done!"
-```
-
-Example of locally declared vars:
-
-```yaml
-version: '2'
-
-tasks:
-  print-var:
-    cmds:
-      echo "{{.VAR}}"
-    vars:
-      VAR: Hello!
-```
-
-Example of global vars in a `Taskfile.yml`:
-
-```yaml
-version: '2'
-
-vars:
-  GREETING: Hello from Taskfile!
-
-tasks:
-  greet:
-    cmds:
-      - echo "{{.GREETING}}"
-```
-
-Example of `Taskvars.yml` file:
-
-```yaml
-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:
-
-```yaml
-version: '2'
-
-expansions: 3
-
-vars:
-  FOO: foo
-  BAR: bar
-  BAZ: baz
-  FOOBAR: "{{.FOO}}{{.BAR}}"
-  FOOBARBAZ: "{{.FOOBAR}}{{.BAZ}}"
-
-tasks:
-  default:
-    cmds:
-      - echo "{{.FOOBARBAZ}}"
-```
-
-### Dynamic variables
-
-The below syntax (`sh:` prop in a variable) is considered a dynamic variable.
-The value will be treated as a command and the output assigned. If there is one
-or more trailing newlines, the last newline will be trimmed.
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - go build -ldflags="-X main.Version={{.GIT_COMMIT}}" main.go
-    vars:
-      GIT_COMMIT:
-        sh: git log -n 1 --format=%h
-```
-
-This works for all types of variables.
-
-## Go's template engine
-
-Task parse commands as [Go's template engine][gotemplate] before executing
-them. Variables are accessible through dot syntax (`.VARNAME`).
-
-All functions by the Go's [sprig lib](http://masterminds.github.io/sprig/)
-are available. The following example gets the current date in a given format:
-
-```yaml
-version: '2'
-
-tasks:
-  print-date:
-    cmds:
-      - echo {{now | date "2006-01-02"}}
-```
-
-Task also adds the following functions:
-
-- `OS`: Returns operating system. Possible values are "windows", "linux",
-  "darwin" (macOS) and "freebsd".
-- `ARCH`: return the architecture Task was compiled to: "386", "amd64", "arm"
-  or "s390x".
-- `splitLines`: Splits Unix (\n) and Windows (\r\n) styled newlines.
-- `catLines`: Replaces Unix (\n) and Windows (\r\n) styled newlines with a space.
-- `toSlash`: Does nothing on Unix, but on Windows converts a string from `\`
-  path format to `/`.
-- `fromSlash`: Oposite of `toSlash`. Does nothing on Unix, but on Windows
-  converts a string from `\` path format to `/`.
-- `exeExt`: Returns the right executable extension for the current OS
-  (`".exe"` for Windows, `""` for others).
-
-Example:
-
-```yaml
-version: '2'
-
-tasks:
-  print-os:
-    cmds:
-      - echo '{{OS}} {{ARCH}}'
-      - echo '{{if eq OS "windows"}}windows-command{{else}}unix-command{{end}}'
-      # This will be path/to/file on Unix but path\to\file on Windows
-      - echo '{{fromSlash "path/to/file"}}'
-  enumerated-file:
-    vars:
-      CONTENT: |
-        foo
-        bar
-    cmds:
-      - |
-        cat << EOF > output.txt
-        {{range $i, $line := .CONTENT | splitLines -}}
-        {{printf "%3d" $i}}: {{$line}}
-        {{end}}EOF
-```
-
-## Help
-
-Running `task --list` (or `task -l`) lists all tasks with a description.
-The following taskfile:
-
-```yaml
-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:
-
-```yaml
-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:
-
-```yaml
-version: '2'
-
-tasks:
-  echo:
-    cmds:
-      - cmd: echo "Print something"
-        silent: true
-```
-
-* At task level:
-
-```yaml
-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`:
-
-```yaml
-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:
-
-```yaml
-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`:
-
-```yaml
-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:
-
-```yaml
-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:
-
- ```yaml
-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.
-
-[gotemplate]: https://golang.org/pkg/text/template/
-[minify]: https://github.com/tdewolff/minify/tree/master/cmd/minify

errors.go

@@ -10,6 +10,14 @@ var (
 	ErrTaskfileAlreadyExists = errors.New("task: A Taskfile already exists")
 )
 
+type taskFileNotFound struct {
+	taskFile string
+}
+
+func (err taskFileNotFound) Error() string {
+	return fmt.Sprintf(`task: No task file found (is it named "%s"?). Use "task --init" to create a new one`, err.taskFile)
+}
+
 type taskNotFoundError struct {
 	taskName string
 }
@@ -27,6 +35,22 @@ func (err *taskRunError) Error() string {
 	return fmt.Sprintf(`task: Failed to run task "%s": %v`, err.taskName, err.err)
 }
 
+type cyclicDepError struct {
+	taskName string
+}
+
+func (err *cyclicDepError) Error() string {
+	return fmt.Sprintf(`task: Cyclic dependency of task "%s" detected`, err.taskName)
+}
+
+type cantWatchNoSourcesError struct {
+	taskName string
+}
+
+func (err *cantWatchNoSourcesError) Error() string {
+	return fmt.Sprintf(`task: Can't watch task "%s" because it has no specified sources`, err.taskName)
+}
+
 // MaximumTaskCallExceededError is returned when a task is called too
 // many times. In this case you probably have a cyclic dependendy or
 // infinite loop

install-task.sh

@@ -1,390 +0,0 @@
-#!/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/compiler/v1/compiler_v1.go

@@ -2,7 +2,6 @@ package v1
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"strings"
 	"sync"
@@ -122,7 +121,7 @@ func (c *CompilerV1) HandleDynamicVar(v taskfile.Var) (string, error) {
 		Stdout:  &stdout,
 		Stderr:  c.Logger.Stderr,
 	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
+	if err := execext.RunCommand(opts); err != nil {
 		return "", fmt.Errorf(`task: Command "%s" in taskvars file failed: %s`, opts.Command, err)
 	}
 

internal/compiler/v2/compiler_v2.go

@@ -2,7 +2,6 @@ package v2
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"strings"
 	"sync"
@@ -94,7 +93,7 @@ func (c *CompilerV2) HandleDynamicVar(v taskfile.Var) (string, error) {
 		Stdout:  &stdout,
 		Stderr:  c.Logger.Stderr,
 	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
+	if err := execext.RunCommand(opts); err != nil {
 		return "", fmt.Errorf(`task: Command "%s" in taskvars file failed: %s`, opts.Command, err)
 	}
 

internal/execext/exec.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"io"
-	"os"
 	"strings"
 
 	"mvdan.cc/sh/interp"
@@ -13,6 +12,7 @@ import (
 
 // RunCommandOptions is the options for the RunCommand func
 type RunCommandOptions struct {
+	Context context.Context
 	Command string
 	Dir     string
 	Env     []string
@@ -27,7 +27,7 @@ var (
 )
 
 // RunCommand runs a shell command
-func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
+func RunCommand(opts *RunCommandOptions) error {
 	if opts == nil {
 		return ErrNilOptions
 	}
@@ -37,36 +37,20 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 		return err
 	}
 
-	environ := opts.Env
-	if len(environ) == 0 {
-		environ = os.Environ()
+	r := interp.Runner{
+		Context: opts.Context,
+		Dir:     opts.Dir,
+		Env:     opts.Env,
+
+		Exec: interp.DefaultExec,
+		Open: interp.OpenDevImpls(interp.DefaultOpen),
+
+		Stdin:  opts.Stdin,
+		Stdout: opts.Stdout,
+		Stderr: opts.Stderr,
 	}
-	env, err := interp.EnvFromList(environ)
-	if err != nil {
+	if err = r.Reset(); 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
-	}
+	return r.Run(p)
 }

internal/output/group.go

@@ -1,26 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

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

internal/output/output_test.go

@@ -1,62 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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/glob.go

@@ -5,7 +5,7 @@ import (
 	"sort"
 
 	"github.com/mattn/go-zglob"
-	"mvdan.cc/sh/shell"
+	"github.com/mitchellh/go-homedir"
 )
 
 func glob(dir string, globs []string) (files []string, err error) {
@@ -13,13 +13,13 @@ func glob(dir string, globs []string) (files []string, err error) {
 		if !filepath.IsAbs(g) {
 			g = filepath.Join(dir, g)
 		}
-		g, err = shell.Expand(g, nil)
+		g, err = homedir.Expand(g)
 		if err != nil {
 			return nil, err
 		}
 		f, err := zglob.Glob(g)
 		if err != nil {
-			continue
+			return nil, err
 		}
 		files = append(files, f...)
 	}

internal/taskfile/cmd.go

@@ -7,11 +7,10 @@ import (
 
 // Cmd is a task command
 type Cmd struct {
-	Cmd         string
-	Silent      bool
-	Task        string
-	Vars        Vars
-	IgnoreError bool
+	Cmd    string
+	Silent bool
+	Task   string
+	Vars   Vars
 }
 
 // Dep is a task dependency
@@ -39,14 +38,12 @@ func (c *Cmd) UnmarshalYAML(unmarshal func(interface{}) error) error {
 		return nil
 	}
 	var cmdStruct struct {
-		Cmd         string
-		Silent      bool
-		IgnoreError bool `yaml:"ignore_error"`
+		Cmd    string
+		Silent bool
 	}
 	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 {

internal/taskfile/merge.go

@@ -1,38 +0,0 @@
-package taskfile
-
-import (
-	"fmt"
-	"strings"
-)
-
-// NamespaceSeparator contains the character that separates namescapes
-const NamespaceSeparator = ":"
-
-// Merge merges the second Taskfile into the first
-func Merge(t1, t2 *Taskfile, namespaces ...string) 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.Includes {
-		t1.Includes[k] = v
-	}
-	for k, v := range t2.Vars {
-		t1.Vars[k] = v
-	}
-	for k, v := range t2.Tasks {
-		t1.Tasks[taskNameWithNamespace(k, namespaces...)] = v
-	}
-
-	return nil
-}
-
-func taskNameWithNamespace(taskName string, namespaces ...string) string {
-	return strings.Join(append(namespaces, taskName), NamespaceSeparator)
-}

internal/taskfile/read/taskfile.go

@@ -1,75 +0,0 @@
-package read
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-
-	"github.com/go-task/task/internal/taskfile"
-
-	"gopkg.in/yaml.v2"
-)
-
-// ErrIncludedTaskfilesCantHaveIncludes is returned when a included Taskfile contains includes
-var ErrIncludedTaskfilesCantHaveIncludes = errors.New("task: Included Taskfiles can't have includes. Please, move the include to the main Taskfile")
-
-// Taskfile reads a Taskfile for a given directory
-func Taskfile(dir string) (*taskfile.Taskfile, error) {
-	path := filepath.Join(dir, "Taskfile.yml")
-	if _, err := os.Stat(path); err != nil {
-		return nil, fmt.Errorf(`No Taskfile.yml found. Use "task --init" to create a new one`)
-	}
-	t, err := readTaskfile(path)
-	if err != nil {
-		return nil, err
-	}
-
-	for namespace, path := range t.Includes {
-		path = filepath.Join(dir, path)
-		info, err := os.Stat(path)
-		if err != nil {
-			return nil, err
-		}
-		if info.IsDir() {
-			path = filepath.Join(path, "Taskfile.yml")
-		}
-		includedTaskfile, err := readTaskfile(path)
-		if err != nil {
-			return nil, err
-		}
-		if len(includedTaskfile.Includes) > 0 {
-			return nil, ErrIncludedTaskfilesCantHaveIncludes
-		}
-		if err = taskfile.Merge(t, includedTaskfile, namespace); err != nil {
-			return nil, err
-		}
-	}
-
-	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

@@ -1,52 +0,0 @@
-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

@@ -5,18 +5,16 @@ 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"`
+	Task      string
+	Cmds      []*Cmd
+	Deps      []*Dep
+	Desc      string
+	Sources   []string
+	Generates []string
+	Status    []string
+	Dir       string
+	Vars      Vars
+	Env       Vars
+	Silent    bool
+	Method    string
 }

internal/taskfile/taskfile.go

@@ -4,8 +4,6 @@ package taskfile
 type Taskfile struct {
 	Version    string
 	Expansions int
-	Output     string
-	Includes   map[string]string
 	Vars       Vars
 	Tasks      Tasks
 }
@@ -20,8 +18,6 @@ func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	var taskfile struct {
 		Version    string
 		Expansions int
-		Output     string
-		Includes   map[string]string
 		Vars       Vars
 		Tasks      Tasks
 	}
@@ -30,8 +26,6 @@ func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	}
 	tf.Version = taskfile.Version
 	tf.Expansions = taskfile.Expansions
-	tf.Output = taskfile.Output
-	tf.Includes = taskfile.Includes
 	tf.Vars = taskfile.Vars
 	tf.Tasks = taskfile.Tasks
 	if tf.Expansions <= 0 {

internal/taskfile/version/version.go

@@ -5,36 +5,27 @@ import (
 )
 
 var (
-	v1  = mustVersion("1")
-	v2  = mustVersion("2")
-	v21 = mustVersion("2.1")
-	v22 = mustVersion("2.2")
-	v23 = mustVersion("2.3")
+	v1 = mustVersion("1")
+	v2 = mustVersion("2")
+
+	isV1  = mustConstraint("= 1")
+	isV2  = mustConstraint(">= 2")
+	isV21 = mustConstraint(">= 2.1")
 )
 
 // IsV1 returns if is a given Taskfile version is version 1
-func IsV1(v *semver.Constraints) bool {
-	return v.Check(v1)
+func IsV1(v *semver.Version) bool {
+	return isV1.Check(v)
 }
 
 // IsV2 returns if is a given Taskfile version is at least version 2
-func IsV2(v *semver.Constraints) bool {
-	return v.Check(v2)
+func IsV2(v *semver.Version) bool {
+	return isV2.Check(v)
 }
 
-// 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)
-}
-
-// IsV23 returns if is a given Taskfile version is at least version 2.3
-func IsV23(v *semver.Constraints) bool {
-	return v.Check(v23)
+// IsV21 returns if is a given Taskfile version is at least version 2
+func IsV21(v *semver.Version) bool {
+	return isV21.Check(v)
 }
 
 func mustVersion(s string) *semver.Version {
@@ -44,3 +35,11 @@ func mustVersion(s string) *semver.Version {
 	}
 	return v
 }
+
+func mustConstraint(s string) *semver.Constraints {
+	c, err := semver.NewConstraint(s)
+	if err != nil {
+		panic(err)
+	}
+	return c
+}

status.go

@@ -12,9 +12,9 @@ import (
 // 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, err := e.CompiledTask(call)
-		if err != nil {
-			return err
+		t, ok := e.Taskfile.Tasks[call.Task]
+		if !ok {
+			return &taskNotFoundError{taskName: call.Task}
 		}
 		isUpToDate, err := isTaskUpToDate(e.Context, t)
 		if err != nil {
@@ -71,7 +71,8 @@ func getStatusChecker(t *taskfile.Task) (status.Checker, error) {
 
 func isTaskUpToDateStatus(ctx context.Context, t *taskfile.Task) (bool, error) {
 	for _, s := range t.Status {
-		err := execext.RunCommand(ctx, &execext.RunCommandOptions{
+		err := execext.RunCommand(&execext.RunCommandOptions{
+			Context: ctx,
 			Command: s,
 			Dir:     t.Dir,
 			Env:     getEnviron(t),

task.go

@@ -12,9 +12,7 @@ import (
 	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"
@@ -22,6 +20,8 @@ import (
 )
 
 const (
+	// TaskFilePath is the default Taskfile
+	TaskFilePath = "Taskfile"
 	// MaximumTaskCall is the max number of times a task can be called.
 	// This exists to prevent infinite loops on cyclic dependencies
 	MaximumTaskCall = 100
@@ -35,7 +35,6 @@ type Executor struct {
 	Watch    bool
 	Verbose  bool
 	Silent   bool
-	Dry      bool
 
 	Context context.Context
 
@@ -45,7 +44,6 @@ type Executor struct {
 
 	Logger   *logger.Logger
 	Compiler compiler.Compiler
-	Output   output.Output
 
 	taskvars taskfile.Vars
 
@@ -77,17 +75,11 @@ func (e *Executor) Run(calls ...taskfile.Call) error {
 
 // 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 {
+	if err := e.readTaskfile(); err != nil {
 		return err
 	}
 
-	v, err := semver.NewConstraint(e.Taskfile.Version)
+	v, err := semver.NewVersion(e.Taskfile.Version)
 	if err != nil {
 		return fmt.Errorf(`task: could not parse taskfile version "%s": %v`, e.Taskfile.Version, err)
 	}
@@ -116,7 +108,7 @@ func (e *Executor) Setup() error {
 			Vars:   e.taskvars,
 			Logger: e.Logger,
 		}
-	case version.IsV2(v), version.IsV21(v), version.IsV22(v):
+	case version.IsV2(v):
 		e.Compiler = &compilerv2.CompilerV2{
 			Dir:          e.Dir,
 			Taskvars:     e.taskvars,
@@ -124,40 +116,8 @@ func (e *Executor) Setup() error {
 			Expansions:   e.Taskfile.Expansions,
 			Logger:       e.Logger,
 		}
-	case version.IsV23(v):
-		return fmt.Errorf(`task: Taskfile versions greater than v2.3 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`)
-	}
-	if !version.IsV22(v) && len(e.Taskfile.Includes) > 0 {
-		return fmt.Errorf(`task: Including Taskfiles is only available starting on Taskfile version v2.2`)
-	}
-	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
-				}
-			}
-		}
+	case version.IsV21(v):
+		return fmt.Errorf(`task: Taskfile versions greater than v2 not implemented in the version of Task`)
 	}
 
 	e.taskCallCount = make(map[string]*int32, len(e.Taskfile.Tasks))
@@ -199,12 +159,6 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 			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}
 		}
 	}
@@ -228,39 +182,23 @@ func (e *Executor) runDeps(ctx context.Context, t *taskfile.Task) error {
 func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfile.Call, i int) error {
 	cmd := t.Cmds[i]
 
-	switch {
-	case cmd.Task != "":
+	if cmd.Cmd == "" {
 		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)
-		}
-
-		if e.Dry {
-			return nil
-		}
-
-		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
 	}
+
+	if e.Verbose || (!cmd.Silent && !t.Silent && !e.Silent) {
+		e.Logger.Errf(cmd.Cmd)
+	}
+
+	return execext.RunCommand(&execext.RunCommandOptions{
+		Context: ctx,
+		Command: cmd.Cmd,
+		Dir:     t.Dir,
+		Env:     getEnviron(t),
+		Stdin:   e.Stdin,
+		Stdout:  e.Stdout,
+		Stderr:  e.Stderr,
+	})
 }
 
 func getEnviron(t *taskfile.Task) []string {

task_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/go-task/task"
 	"github.com/go-task/task/internal/taskfile"
 
-	"github.com/mitchellh/go-homedir"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -53,6 +52,7 @@ func (fct fileContentTest) Run(t *testing.T) {
 			assert.Equal(t, expectContent, s, "unexpected file content")
 		})
 	}
+
 }
 
 func TestEnv(t *testing.T) {
@@ -412,75 +412,3 @@ func TestTaskVersion(t *testing.T) {
 		})
 	}
 }
-
-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)
-	}
-}
-
-func TestIncludes(t *testing.T) {
-	tt := fileContentTest{
-		Dir:       "testdata/includes",
-		Target:    "default",
-		TrimSpace: true,
-		Files: map[string]string{
-			"main.txt":               "main",
-			"included_directory.txt": "included_directory",
-			"included_taskfile.txt":  "included_taskfile",
-		},
-	}
-	tt.Run(t)
-}

taskfile.go

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

testdata/checksum/Taskfile.yml

@@ -2,7 +2,6 @@ build:
   cmds:
     - cp ./source.txt ./generated.txt
   sources:
-    - ./**/glob-with-inexistent-file.txt
     - ./source.txt
   generates:
     - ./generated.txt

testdata/dry/Taskfile.yml

@@ -1,6 +0,0 @@
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - touch file.txt

testdata/expand/Taskfile.yml

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

testdata/ignore_errors/Taskfile.yml

@@ -1,20 +0,0 @@
-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/includes/.gitignore

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

testdata/includes/Taskfile.yml

@@ -1,16 +0,0 @@
-version: '2'
-
-includes:
-  included: ./included
-  included_taskfile: ./Taskfile2.yml
-
-tasks:
-  default:
-    cmds:
-      - task: gen
-      - task: included:gen
-      - task: included_taskfile:gen
-
-  gen:
-    cmds:
-      - echo main > main.txt

testdata/includes/Taskfile2.yml

@@ -1,6 +0,0 @@
-version: '2'
-
-tasks:
-  gen:
-    cmds:
-      - echo included_taskfile > included_taskfile.txt

testdata/includes/included/Taskfile.yml

@@ -1,6 +0,0 @@
-version: '2'
-
-tasks:
-  gen:
-    cmds:
-      - echo included_directory > included_directory.txt

variables.go

@@ -6,7 +6,12 @@ import (
 	"github.com/go-task/task/internal/taskfile"
 	"github.com/go-task/task/internal/templater"
 
-	"mvdan.cc/sh/shell"
+	"github.com/mitchellh/go-homedir"
+)
+
+var (
+	// TaskvarsFilePath file containing additional variables.
+	TaskvarsFilePath = "Taskvars"
 )
 
 // CompiledTask returns a copy of a task, but replacing variables in almost all
@@ -24,29 +29,24 @@ func (e *Executor) CompiledTask(call taskfile.Call) (*taskfile.Task, error) {
 	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,
+		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),
 	}
-	new.Dir, err = shell.Expand(new.Dir, nil)
+	new.Dir, err = homedir.Expand(new.Dir)
 	if err != nil {
 		return nil, err
 	}
 	if e.Dir != "" && !filepath.IsAbs(new.Dir) {
 		new.Dir = filepath.Join(e.Dir, new.Dir)
 	}
-	if new.Prefix == "" {
-		new.Prefix = new.Task
-	}
 	for k, v := range new.Env {
 		static, err := e.Compiler.HandleDynamicVar(v)
 		if err != nil {
@@ -59,12 +59,12 @@ func (e *Executor) CompiledTask(call taskfile.Call) (*taskfile.Task, error) {
 		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,
+				Task:   r.Replace(cmd.Task),
+				Silent: cmd.Silent,
+				Cmd:    r.Replace(cmd.Cmd),
+				Vars:   r.ReplaceVars(cmd.Vars),
 			}
+
 		}
 	}
 	if len(origTask.Deps) > 0 {

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

@@ -233,6 +233,12 @@ func constraintNotEqual(v *Version, c *constraint) bool {
 
 func constraintGreaterThan(v *Version, c *constraint) bool {
 
+	// An edge case the constraint is 0.0.0 and the version is 0.0.0-someprerelease
+	// exists. This that case.
+	if !isNonZero(c.con) && isNonZero(v) {
+		return true
+	}
+
 	// If there is a pre-release on the version but the constraint isn't looking
 	// for them assume that pre-releases are not compatible. See issue 21 for
 	// more details.
@@ -265,6 +271,11 @@ func constraintLessThan(v *Version, c *constraint) bool {
 }
 
 func constraintGreaterThanEqual(v *Version, c *constraint) bool {
+	// An edge case the constraint is 0.0.0 and the version is 0.0.0-someprerelease
+	// exists. This that case.
+	if !isNonZero(c.con) && isNonZero(v) {
+		return true
+	}
 
 	// If there is a pre-release on the version but the constraint isn't looking
 	// for them assume that pre-releases are not compatible. See issue 21 for
@@ -404,3 +415,12 @@ func rewriteRange(i string) string {
 
 	return o
 }
+
+// Detect if a version is not zero (0.0.0)
+func isNonZero(v *Version) bool {
+	if v.Major() != 0 || v.Minor() != 0 || v.Patch() != 0 || v.Prerelease() != "" {
+		return true
+	}
+
+	return false
+}

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

@@ -47,7 +47,7 @@ parts of the package.
         // Handle constraint not being parseable.
     }
 
-    v, err := semver.NewVersion("1.3")
+    v, _ := semver.NewVersion("1.3")
     if err != nil {
         // Handle version not being parseable.
     }

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

@@ -106,7 +106,7 @@ func MustParse(v string) *Version {
 // Note, if the original version contained a leading v this version will not.
 // See the Original() method to retrieve the original value. Semantic Versions
 // don't contain a leading v per the spec. Instead it's optional on
-// implementation.
+// impelementation.
 func (v *Version) String() string {
 	var buf bytes.Buffer
 
@@ -379,15 +379,16 @@ func comparePrePart(s, o string) int {
 
 	// When s or o are empty we can use the other in an attempt to determine
 	// the response.
-	if s == "" {
-		if o != "" {
+	if o == "" {
+		_, n := strconv.ParseInt(s, 10, 64)
+		if n != nil {
 			return -1
 		}
 		return 1
 	}
-
-	if o == "" {
-		if s != "" {
+	if s == "" {
+		_, n := strconv.ParseInt(o, 10, 64)
+		if n != nil {
 			return 1
 		}
 		return -1

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

@@ -8,12 +8,10 @@ import (
 	"crypto/hmac"
 	"crypto/rand"
 	"crypto/rsa"
-	"crypto/sha1"
 	"crypto/sha256"
 	"crypto/x509"
 	"crypto/x509/pkix"
 	"encoding/asn1"
-	"encoding/base64"
 	"encoding/binary"
 	"encoding/hex"
 	"encoding/pem"
@@ -23,7 +21,7 @@ import (
 	"net"
 	"time"
 
-	"github.com/google/uuid"
+	uuid "github.com/satori/go.uuid"
 	"golang.org/x/crypto/scrypt"
 )
 
@@ -32,14 +30,9 @@ func sha256sum(input string) string {
 	return hex.EncodeToString(hash[:])
 }
 
-func sha1sum(input string) string {
-	hash := sha1.Sum([]byte(input))
-	return hex.EncodeToString(hash[:])
-}
-
 // uuidv4 provides a safe and secure UUID v4 implementation
 func uuidv4() string {
-	return fmt.Sprintf("%s", uuid.New())
+	return fmt.Sprintf("%s", uuid.NewV4())
 }
 
 var master_password_seed = "com.lyndir.masterpassword"
@@ -163,49 +156,6 @@ type certificate struct {
 	Key  string
 }
 
-func buildCustomCertificate(b64cert string, b64key string) (certificate, error) {
-	crt := certificate{}
-
-	cert, err := base64.StdEncoding.DecodeString(b64cert)
-	if err != nil {
-		return crt, errors.New("unable to decode base64 certificate")
-	}
-
-	key, err := base64.StdEncoding.DecodeString(b64key)
-	if err != nil {
-		return crt, errors.New("unable to decode base64 private key")
-	}
-
-	decodedCert, _ := pem.Decode(cert)
-	if decodedCert == nil {
-		return crt, errors.New("unable to decode certificate")
-	}
-	_, err = x509.ParseCertificate(decodedCert.Bytes)
-	if err != nil {
-		return crt, fmt.Errorf(
-			"error parsing certificate: decodedCert.Bytes: %s",
-			err,
-		)
-	}
-
-	decodedKey, _ := pem.Decode(key)
-	if decodedKey == nil {
-		return crt, errors.New("unable to decode key")
-	}
-	_, err = x509.ParsePKCS1PrivateKey(decodedKey.Bytes)
-	if err != nil {
-		return crt, fmt.Errorf(
-			"error parsing prive key: decodedKey.Bytes: %s",
-			err,
-		)
-	}
-
-	crt.Cert = string(cert)
-	crt.Key = string(key)
-
-	return crt, nil
-}
-
 func generateCertificateAuthority(
 	cn string,
 	daysValid int,
@@ -369,13 +319,8 @@ func getBaseCertTemplate(
 	if err != nil {
 		return nil, err
 	}
-	serialNumberUpperBound := new(big.Int).Lsh(big.NewInt(1), 128)
-	serialNumber, err := rand.Int(rand.Reader, serialNumberUpperBound)
-	if err != nil {
-		return nil, err
-	}
 	return &x509.Certificate{
-		SerialNumber: serialNumber,
+		SerialNumber: big.NewInt(1),
 		Subject: pkix.Name{
 			CommonName: cn,
 		},

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

@@ -66,7 +66,7 @@ func dateAgo(date interface{}) string {
 		t = time.Unix(int64(date), 0)
 	}
 	// Drop resolution to seconds
-	duration := time.Since(t).Round(time.Second)
+	duration := time.Since(t) / time.Second * time.Second
 	return duration.String()
 }
 

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

@@ -49,6 +49,7 @@ func empty(given interface{}) bool {
 	case reflect.Struct:
 		return false
 	}
+	return true
 }
 
 // coalesce returns the first non-empty value.
@@ -72,12 +73,3 @@ func toPrettyJson(v interface{}) string {
 	output, _ := json.MarshalIndent(v, "", "  ")
 	return string(output)
 }
-
-// ternary returns the first value if the last value is true, otherwise returns the second value.
-func ternary(vt interface{}, vf interface{}, v bool) interface{} {
-	if v {
-		return vt
-	}
-
-	return vf
-}

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

@@ -27,12 +27,10 @@ func pluck(key string, d ...map[string]interface{}) []interface{} {
 	return res
 }
 
-func keys(dicts ...map[string]interface{}) []string {
+func keys(dict map[string]interface{}) []string {
 	k := []string{}
-	for _, dict := range dicts {
-		for key := range dict {
-			k = append(k, key)
-		}
+	for key := range dict {
+		k = append(k, key)
 	}
 	return k
 }
@@ -86,12 +84,3 @@ func merge(dst map[string]interface{}, srcs ...map[string]interface{}) interface
 	}
 	return dst
 }
-
-func values(dict map[string]interface{}) []interface{} {
-	values := []interface{}{}
-	for _, value := range dict {
-		values = append(values, value)
-	}
-
-	return values
-}

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

@@ -110,9 +110,6 @@ Defaults:
 	  because it is an empty value.
 	- compact: Return a copy of a list with all of the empty values removed.
 	  'list 0 1 2 "" | compact' will return '[1 2]'
-	- ternary: Given a value,'true | ternary "b" "c"' will return "b".
-	  'false | ternary "b" "c"' will return '"c"'. Similar to the JavaScript ternary
-	  operator.
 
 OS:
 	- env: Resolve an environment variable
@@ -163,7 +160,7 @@ Data Structures:
 	  be assigned the empty string. Non-string keys are converted to strings as
 	  follows: []byte are converted, fmt.Stringers will have String() called.
 	  errors will have Error() called. All others will be passed through
-	  fmt.Sprintf("%v").
+	  fmt.Sprtinf("%v").
 
 Lists Functions:
 
@@ -192,10 +189,9 @@ These are used to manipulate dicts.
 	- hasKey: Takes a dict and a key, and returns boolean true if the key is in
 	  the dict.
 	- pluck: Given a key and one or more maps, get all of the values for that key.
-	- keys: Get an array of all of the keys in one or more dicts.
+	- keys: Get an array of all of the keys in a dict.
 	- pick: Select just the given keys out of the dict, and return a new dict.
 	- omit: Return a dict without the given keys.
-	- values: Returns a list (interface{}) of all dictionary values.
 
 Math Functions:
 

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

@@ -142,7 +142,6 @@ var genericMap = map[string]interface{}{
 	"nindent":   nindent,
 	"replace":   replace,
 	"plural":    plural,
-	"sha1sum":   sha1sum,
 	"sha256sum": sha256sum,
 	"toString":  strval,
 
@@ -160,8 +159,6 @@ var genericMap = map[string]interface{}{
 	// split "/" foo/bar returns map[int]string{0: foo, 1: bar}
 	"split":     split,
 	"splitList": func(sep, orig string) []string { return strings.Split(orig, sep) },
-	// splitn "/" foo/bar/fuu returns map[int]string{0: foo, 1: bar/fuu}
-	"splitn":    splitn,
 	"toStrings": strslice,
 
 	"until":     until,
@@ -205,7 +202,6 @@ var genericMap = map[string]interface{}{
 	"compact":      compact,
 	"toJson":       toJson,
 	"toPrettyJson": toPrettyJson,
-	"ternary":      ternary,
 
 	// Reflection
 	"typeOf":     typeOf,
@@ -243,7 +239,6 @@ var genericMap = map[string]interface{}{
 	"pick":   pick,
 	"omit":   omit,
 	"merge":  merge,
-	"values": values,
 
 	"append": push, "push": push,
 	"prepend": prepend,
@@ -255,12 +250,10 @@ var genericMap = map[string]interface{}{
 	"uniq":    uniq,
 	"without": without,
 	"has":     has,
-	"slice":   slice,
 
 	// Crypto:
 	"genPrivateKey":     generatePrivateKey,
 	"derivePassword":    derivePassword,
-	"buildCustomCert":   buildCustomCertificate,
 	"genCA":             generateCertificateAuthority,
 	"genSelfSignedCert": generateSelfSignedCertificate,
 	"genSignedCert":     generateSignedCertificate,

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

@@ -257,35 +257,3 @@ func has(needle interface{}, haystack interface{}) bool {
 		panic(fmt.Sprintf("Cannot find has on type %s", tp))
 	}
 }
-
-// $list := [1, 2, 3, 4, 5]
-// slice $list     -> list[0:5] = list[:]
-// slice $list 0 3 -> list[0:3] = list[:3]
-// slice $list 3 5 -> list[3:5]
-// slice $list 3   -> list[3:5] = list[3:]
-func slice(list interface{}, indices ...interface{}) interface{} {
-	tp := reflect.TypeOf(list).Kind()
-	switch tp {
-	case reflect.Slice, reflect.Array:
-		l2 := reflect.ValueOf(list)
-
-		l := l2.Len()
-		if l == 0 {
-			return nil
-		}
-
-		var start, end int
-		if len(indices) > 0 {
-			start = toInt(indices[0])
-		}
-		if len(indices) < 2 {
-			end = l
-		} else {
-			end = toInt(indices[1])
-		}
-
-		return l2.Slice(start, end).Interface()
-	default:
-		panic(fmt.Sprintf("list should be type of slice or array but %s", tp))
-	}
-}

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

@@ -156,4 +156,4 @@ func round(a interface{}, p int, r_opt ...float64) float64 {
 		round = math.Floor(digit)
 	}
 	return round / pow
-}
+}

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

@@ -32,4 +32,4 @@ func regexReplaceAllLiteral(regex string, s string, repl string) string {
 func regexSplit(regex string, s string, n int) []string {
 	r := regexp.MustCompile(regex)
 	return r.Split(s, n)
-}
+}

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

@@ -183,15 +183,6 @@ func split(sep, orig string) map[string]string {
 	return res
 }
 
-func splitn(sep string, n int, orig string) map[string]string {
-	parts := strings.SplitN(orig, sep, n)
-	res := make(map[string]string, len(parts))
-	for i, v := range parts {
-		res["_"+strconv.Itoa(i)] = v
-	}
-	return res
-}
-
 // substring creates a substring of the given string.
 //
 // If start is < 0, this calls string[:length].

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

@@ -2,7 +2,7 @@ ISC License
 
 Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
 
-Permission to use, copy, modify, and/or distribute this software for any
+Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
 copyright notice and this permission notice appear in all copies.
 

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

@@ -16,9 +16,7 @@
 // when the code is not running on Google App Engine, compiled by GopherJS, and
 // "-tags safe" is not added to the go build command line.  The "disableunsafe"
 // tag is deprecated and thus should not be used.
-// Go versions prior to 1.4 are disabled because they use a different layout
-// for interfaces which make the implementation of unsafeReflectValue more complex.
-// +build !js,!appengine,!safe,!disableunsafe,go1.4
+// +build !js,!appengine,!safe,!disableunsafe
 
 package spew
 
@@ -36,49 +34,80 @@ const (
 	ptrSize = unsafe.Sizeof((*byte)(nil))
 )
 
-type flag uintptr
-
 var (
-	// flagRO indicates whether the value field of a reflect.Value
-	// is read-only.
-	flagRO flag
+	// offsetPtr, offsetScalar, and offsetFlag are the offsets for the
+	// internal reflect.Value fields.  These values are valid before golang
+	// commit ecccf07e7f9d which changed the format.  The are also valid
+	// after commit 82f48826c6c7 which changed the format again to mirror
+	// the original format.  Code in the init function updates these offsets
+	// as necessary.
+	offsetPtr    = uintptr(ptrSize)
+	offsetScalar = uintptr(0)
+	offsetFlag   = uintptr(ptrSize * 2)
 
-	// flagAddr indicates whether the address of the reflect.Value's
-	// value may be taken.
-	flagAddr flag
+	// flagKindWidth and flagKindShift indicate various bits that the
+	// reflect package uses internally to track kind information.
+	//
+	// flagRO indicates whether or not the value field of a reflect.Value is
+	// read-only.
+	//
+	// flagIndir indicates whether the value field of a reflect.Value is
+	// the actual data or a pointer to the data.
+	//
+	// These values are valid before golang commit 90a7c3c86944 which
+	// changed their positions.  Code in the init function updates these
+	// flags as necessary.
+	flagKindWidth = uintptr(5)
+	flagKindShift = uintptr(flagKindWidth - 1)
+	flagRO        = uintptr(1 << 0)
+	flagIndir     = uintptr(1 << 1)
 )
 
-// flagKindMask holds the bits that make up the kind
-// part of the flags field. In all the supported versions,
-// it is in the lower 5 bits.
-const flagKindMask = flag(0x1f)
-
-// Different versions of Go have used different
-// bit layouts for the flags type. This table
-// records the known combinations.
-var okFlags = []struct {
-	ro, addr flag
-}{{
-	// From Go 1.4 to 1.5
-	ro:   1 << 5,
-	addr: 1 << 7,
-}, {
-	// Up to Go tip.
-	ro:   1<<5 | 1<<6,
-	addr: 1 << 8,
-}}
-
-var flagValOffset = func() uintptr {
-	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
-	if !ok {
-		panic("reflect.Value has no flag field")
+func init() {
+	// Older versions of reflect.Value stored small integers directly in the
+	// ptr field (which is named val in the older versions).  Versions
+	// between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
+	// scalar for this purpose which unfortunately came before the flag
+	// field, so the offset of the flag field is different for those
+	// versions.
+	//
+	// This code constructs a new reflect.Value from a known small integer
+	// and checks if the size of the reflect.Value struct indicates it has
+	// the scalar field. When it does, the offsets are updated accordingly.
+	vv := reflect.ValueOf(0xf00)
+	if unsafe.Sizeof(vv) == (ptrSize * 4) {
+		offsetScalar = ptrSize * 2
+		offsetFlag = ptrSize * 3
 	}
-	return field.Offset
-}()
 
-// flagField returns a pointer to the flag field of a reflect.Value.
-func flagField(v *reflect.Value) *flag {
-	return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset))
+	// Commit 90a7c3c86944 changed the flag positions such that the low
+	// order bits are the kind.  This code extracts the kind from the flags
+	// field and ensures it's the correct type.  When it's not, the flag
+	// order has been changed to the newer format, so the flags are updated
+	// accordingly.
+	upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
+	upfv := *(*uintptr)(upf)
+	flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
+	if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
+		flagKindShift = 0
+		flagRO = 1 << 5
+		flagIndir = 1 << 6
+
+		// Commit adf9b30e5594 modified the flags to separate the
+		// flagRO flag into two bits which specifies whether or not the
+		// field is embedded.  This causes flagIndir to move over a bit
+		// and means that flagRO is the combination of either of the
+		// original flagRO bit and the new bit.
+		//
+		// This code detects the change by extracting what used to be
+		// the indirect bit to ensure it's set.  When it's not, the flag
+		// order has been changed to the newer format, so the flags are
+		// updated accordingly.
+		if upfv&flagIndir == 0 {
+			flagRO = 3 << 5
+			flagIndir = 1 << 7
+		}
+	}
 }
 
 // unsafeReflectValue converts the passed reflect.Value into a one that bypasses
@@ -90,56 +119,34 @@ func flagField(v *reflect.Value) *flag {
 // This allows us to check for implementations of the Stringer and error
 // interfaces to be used for pretty printing ordinarily unaddressable and
 // inaccessible values such as unexported struct fields.
-func unsafeReflectValue(v reflect.Value) reflect.Value {
-	if !v.IsValid() || (v.CanInterface() && v.CanAddr()) {
-		return v
-	}
-	flagFieldPtr := flagField(&v)
-	*flagFieldPtr &^= flagRO
-	*flagFieldPtr |= flagAddr
-	return v
-}
-
-// Sanity checks against future reflect package changes
-// to the type or semantics of the Value.flag field.
-func init() {
-	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
-	if !ok {
-		panic("reflect.Value has no flag field")
-	}
-	if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() {
-		panic("reflect.Value flag field has changed kind")
-	}
-	type t0 int
-	var t struct {
-		A t0
-		// t0 will have flagEmbedRO set.
-		t0
-		// a will have flagStickyRO set
-		a t0
-	}
-	vA := reflect.ValueOf(t).FieldByName("A")
-	va := reflect.ValueOf(t).FieldByName("a")
-	vt0 := reflect.ValueOf(t).FieldByName("t0")
-
-	// Infer flagRO from the difference between the flags
-	// for the (otherwise identical) fields in t.
-	flagPublic := *flagField(&vA)
-	flagWithRO := *flagField(&va) | *flagField(&vt0)
-	flagRO = flagPublic ^ flagWithRO
-
-	// Infer flagAddr from the difference between a value
-	// taken from a pointer and not.
-	vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A")
-	flagNoPtr := *flagField(&vA)
-	flagPtr := *flagField(&vPtrA)
-	flagAddr = flagNoPtr ^ flagPtr
-
-	// Check that the inferred flags tally with one of the known versions.
-	for _, f := range okFlags {
-		if flagRO == f.ro && flagAddr == f.addr {
-			return
+func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
+	indirects := 1
+	vt := v.Type()
+	upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
+	rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
+	if rvf&flagIndir != 0 {
+		vt = reflect.PtrTo(v.Type())
+		indirects++
+	} else if offsetScalar != 0 {
+		// The value is in the scalar field when it's not one of the
+		// reference types.
+		switch vt.Kind() {
+		case reflect.Uintptr:
+		case reflect.Chan:
+		case reflect.Func:
+		case reflect.Map:
+		case reflect.Ptr:
+		case reflect.UnsafePointer:
+		default:
+			upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
+				offsetScalar)
 		}
 	}
-	panic("reflect.Value read-only flag has changed semantics")
+
+	pv := reflect.NewAt(vt, upv)
+	rv = pv
+	for i := 0; i < indirects; i++ {
+		rv = rv.Elem()
+	}
+	return rv
 }

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

@@ -16,7 +16,7 @@
 // when the code is running on Google App Engine, compiled by GopherJS, or
 // "-tags safe" is added to the go build command line.  The "disableunsafe"
 // tag is deprecated and thus should not be used.
-// +build js appengine safe disableunsafe !go1.4
+// +build js appengine safe disableunsafe
 
 package spew
 

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

@@ -180,7 +180,7 @@ func printComplex(w io.Writer, c complex128, floatPrecision int) {
 	w.Write(closeParenBytes)
 }
 
-// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
+// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
 // prefix to Writer w.
 func printHexPtr(w io.Writer, p uintptr) {
 	// Null pointer.

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

@@ -35,16 +35,16 @@ var (
 
 	// cCharRE is a regular expression that matches a cgo char.
 	// It is used to detect character arrays to hexdump them.
-	cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`)
+	cCharRE = regexp.MustCompile("^.*\\._Ctype_char$")
 
 	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
 	// char.  It is used to detect unsigned character arrays to hexdump
 	// them.
-	cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`)
+	cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$")
 
 	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
 	// It is used to detect uint8_t arrays to hexdump them.
-	cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`)
+	cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$")
 )
 
 // dumpState contains information about the state of a dump operation.
@@ -143,10 +143,10 @@ func (d *dumpState) dumpPtr(v reflect.Value) {
 	// Display dereferenced value.
 	d.w.Write(openParenBytes)
 	switch {
-	case nilFound:
+	case nilFound == true:
 		d.w.Write(nilAngleBytes)
 
-	case cycleFound:
+	case cycleFound == true:
 		d.w.Write(circularBytes)
 
 	default:

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

@@ -182,10 +182,10 @@ func (f *formatState) formatPtr(v reflect.Value) {
 
 	// Display dereferenced value.
 	switch {
-	case nilFound:
+	case nilFound == true:
 		f.fs.Write(nilAngleBytes)
 
-	case cycleFound:
+	case cycleFound == true:
 		f.fs.Write(circularShortBytes)
 
 	default:

vendor/github.com/google/uuid/CONTRIBUTORS

@@ -1,9 +0,0 @@
-Paul Borman <borman@google.com>
-bmatsuo
-shawnps
-theory
-jboverfelt
-dsymonds
-cd1
-wallclockbuilder
-dansouza

vendor/github.com/google/uuid/LICENSE

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

vendor/github.com/google/uuid/dce.go

@@ -1,80 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import (
-	"encoding/binary"
-	"fmt"
-	"os"
-)
-
-// A Domain represents a Version 2 domain
-type Domain byte
-
-// Domain constants for DCE Security (Version 2) UUIDs.
-const (
-	Person = Domain(0)
-	Group  = Domain(1)
-	Org    = Domain(2)
-)
-
-// NewDCESecurity returns a DCE Security (Version 2) UUID.
-//
-// The domain should be one of Person, Group or Org.
-// On a POSIX system the id should be the users UID for the Person
-// domain and the users GID for the Group.  The meaning of id for
-// the domain Org or on non-POSIX systems is site defined.
-//
-// For a given domain/id pair the same token may be returned for up to
-// 7 minutes and 10 seconds.
-func NewDCESecurity(domain Domain, id uint32) (UUID, error) {
-	uuid, err := NewUUID()
-	if err == nil {
-		uuid[6] = (uuid[6] & 0x0f) | 0x20 // Version 2
-		uuid[9] = byte(domain)
-		binary.BigEndian.PutUint32(uuid[0:], id)
-	}
-	return uuid, err
-}
-
-// NewDCEPerson returns a DCE Security (Version 2) UUID in the person
-// domain with the id returned by os.Getuid.
-//
-//  NewDCESecurity(Person, uint32(os.Getuid()))
-func NewDCEPerson() (UUID, error) {
-	return NewDCESecurity(Person, uint32(os.Getuid()))
-}
-
-// NewDCEGroup returns a DCE Security (Version 2) UUID in the group
-// domain with the id returned by os.Getgid.
-//
-//  NewDCESecurity(Group, uint32(os.Getgid()))
-func NewDCEGroup() (UUID, error) {
-	return NewDCESecurity(Group, uint32(os.Getgid()))
-}
-
-// Domain returns the domain for a Version 2 UUID.  Domains are only defined
-// for Version 2 UUIDs.
-func (uuid UUID) Domain() Domain {
-	return Domain(uuid[9])
-}
-
-// ID returns the id for a Version 2 UUID. IDs are only defined for Version 2
-// UUIDs.
-func (uuid UUID) ID() uint32 {
-	return binary.BigEndian.Uint32(uuid[0:4])
-}
-
-func (d Domain) String() string {
-	switch d {
-	case Person:
-		return "Person"
-	case Group:
-		return "Group"
-	case Org:
-		return "Org"
-	}
-	return fmt.Sprintf("Domain%d", int(d))
-}

vendor/github.com/google/uuid/doc.go

@@ -1,12 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package uuid generates and inspects UUIDs.
-//
-// UUIDs are based on RFC 4122 and DCE 1.1: Authentication and Security
-// Services.
-//
-// A UUID is a 16 byte (128 bit) array.  UUIDs may be used as keys to
-// maps or compared directly.
-package uuid

vendor/github.com/google/uuid/hash.go

@@ -1,53 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import (
-	"crypto/md5"
-	"crypto/sha1"
-	"hash"
-)
-
-// Well known namespace IDs and UUIDs
-var (
-	NameSpaceDNS  = Must(Parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8"))
-	NameSpaceURL  = Must(Parse("6ba7b811-9dad-11d1-80b4-00c04fd430c8"))
-	NameSpaceOID  = Must(Parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
-	NameSpaceX500 = Must(Parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
-	Nil           UUID // empty UUID, all zeros
-)
-
-// NewHash returns a new UUID derived from the hash of space concatenated with
-// data generated by h.  The hash should be at least 16 byte in length.  The
-// first 16 bytes of the hash are used to form the UUID.  The version of the
-// UUID will be the lower 4 bits of version.  NewHash is used to implement
-// NewMD5 and NewSHA1.
-func NewHash(h hash.Hash, space UUID, data []byte, version int) UUID {
-	h.Reset()
-	h.Write(space[:])
-	h.Write(data)
-	s := h.Sum(nil)
-	var uuid UUID
-	copy(uuid[:], s)
-	uuid[6] = (uuid[6] & 0x0f) | uint8((version&0xf)<<4)
-	uuid[8] = (uuid[8] & 0x3f) | 0x80 // RFC 4122 variant
-	return uuid
-}
-
-// NewMD5 returns a new MD5 (Version 3) UUID based on the
-// supplied name space and data.  It is the same as calling:
-//
-//  NewHash(md5.New(), space, data, 3)
-func NewMD5(space UUID, data []byte) UUID {
-	return NewHash(md5.New(), space, data, 3)
-}
-
-// NewSHA1 returns a new SHA1 (Version 5) UUID based on the
-// supplied name space and data.  It is the same as calling:
-//
-//  NewHash(sha1.New(), space, data, 5)
-func NewSHA1(space UUID, data []byte) UUID {
-	return NewHash(sha1.New(), space, data, 5)
-}

vendor/github.com/google/uuid/marshal.go

@@ -1,37 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import "fmt"
-
-// MarshalText implements encoding.TextMarshaler.
-func (uuid UUID) MarshalText() ([]byte, error) {
-	var js [36]byte
-	encodeHex(js[:], uuid)
-	return js[:], nil
-}
-
-// UnmarshalText implements encoding.TextUnmarshaler.
-func (uuid *UUID) UnmarshalText(data []byte) error {
-	id, err := ParseBytes(data)
-	if err == nil {
-		*uuid = id
-	}
-	return err
-}
-
-// MarshalBinary implements encoding.BinaryMarshaler.
-func (uuid UUID) MarshalBinary() ([]byte, error) {
-	return uuid[:], nil
-}
-
-// UnmarshalBinary implements encoding.BinaryUnmarshaler.
-func (uuid *UUID) UnmarshalBinary(data []byte) error {
-	if len(data) != 16 {
-		return fmt.Errorf("invalid UUID (got %d bytes)", len(data))
-	}
-	copy(uuid[:], data)
-	return nil
-}

vendor/github.com/google/uuid/node.go

@@ -1,89 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import (
-	"sync"
-)
-
-var (
-	nodeMu sync.Mutex
-	ifname string  // name of interface being used
-	nodeID [6]byte // hardware for version 1 UUIDs
-	zeroID [6]byte // nodeID with only 0's
-)
-
-// NodeInterface returns the name of the interface from which the NodeID was
-// derived.  The interface "user" is returned if the NodeID was set by
-// SetNodeID.
-func NodeInterface() string {
-	defer nodeMu.Unlock()
-	nodeMu.Lock()
-	return ifname
-}
-
-// SetNodeInterface selects the hardware address to be used for Version 1 UUIDs.
-// If name is "" then the first usable interface found will be used or a random
-// Node ID will be generated.  If a named interface cannot be found then false
-// is returned.
-//
-// SetNodeInterface never fails when name is "".
-func SetNodeInterface(name string) bool {
-	defer nodeMu.Unlock()
-	nodeMu.Lock()
-	return setNodeInterface(name)
-}
-
-func setNodeInterface(name string) bool {
-	iname, addr := getHardwareInterface(name) // null implementation for js
-	if iname != "" && addr != nil {
-		ifname = iname
-		copy(nodeID[:], addr)
-		return true
-	}
-
-	// We found no interfaces with a valid hardware address.  If name
-	// does not specify a specific interface generate a random Node ID
-	// (section 4.1.6)
-	if name == "" {
-		randomBits(nodeID[:])
-		return true
-	}
-	return false
-}
-
-// NodeID returns a slice of a copy of the current Node ID, setting the Node ID
-// if not already set.
-func NodeID() []byte {
-	defer nodeMu.Unlock()
-	nodeMu.Lock()
-	if nodeID == zeroID {
-		setNodeInterface("")
-	}
-	nid := nodeID
-	return nid[:]
-}
-
-// SetNodeID sets the Node ID to be used for Version 1 UUIDs.  The first 6 bytes
-// of id are used.  If id is less than 6 bytes then false is returned and the
-// Node ID is not set.
-func SetNodeID(id []byte) bool {
-	if len(id) < 6 {
-		return false
-	}
-	defer nodeMu.Unlock()
-	nodeMu.Lock()
-	copy(nodeID[:], id)
-	ifname = "user"
-	return true
-}
-
-// NodeID returns the 6 byte node id encoded in uuid.  It returns nil if uuid is
-// not valid.  The NodeID is only well defined for version 1 and 2 UUIDs.
-func (uuid UUID) NodeID() []byte {
-	var node [6]byte
-	copy(node[:], uuid[10:])
-	return node[:]
-}

vendor/github.com/google/uuid/node_js.go

@@ -1,12 +0,0 @@
-// Copyright 2017 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build js
-
-package uuid
-
-// getHardwareInterface returns nil values for the JS version of the code.
-// This remvoves the "net" dependency, because it is not used in the browser.
-// Using the "net" library inflates the size of the transpiled JS code by 673k bytes.
-func getHardwareInterface(name string) (string, []byte) { return "", nil }

vendor/github.com/google/uuid/node_net.go

@@ -1,33 +0,0 @@
-// Copyright 2017 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !js
-
-package uuid
-
-import "net"
-
-var interfaces []net.Interface // cached list of interfaces
-
-// getHardwareInterface returns the name and hardware address of interface name.
-// If name is "" then the name and hardware address of one of the system's
-// interfaces is returned.  If no interfaces are found (name does not exist or
-// there are no interfaces) then "", nil is returned.
-//
-// Only addresses of at least 6 bytes are returned.
-func getHardwareInterface(name string) (string, []byte) {
-	if interfaces == nil {
-		var err error
-		interfaces, err = net.Interfaces()
-		if err != nil {
-			return "", nil
-		}
-	}
-	for _, ifs := range interfaces {
-		if len(ifs.HardwareAddr) >= 6 && (name == "" || name == ifs.Name) {
-			return ifs.Name, ifs.HardwareAddr
-		}
-	}
-	return "", nil
-}

vendor/github.com/google/uuid/sql.go

@@ -1,59 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import (
-	"database/sql/driver"
-	"fmt"
-)
-
-// Scan implements sql.Scanner so UUIDs can be read from databases transparently
-// Currently, database types that map to string and []byte are supported. Please
-// consult database-specific driver documentation for matching types.
-func (uuid *UUID) Scan(src interface{}) error {
-	switch src := src.(type) {
-	case nil:
-		return nil
-
-	case string:
-		// if an empty UUID comes from a table, we return a null UUID
-		if src == "" {
-			return nil
-		}
-
-		// see Parse for required string format
-		u, err := Parse(src)
-		if err != nil {
-			return fmt.Errorf("Scan: %v", err)
-		}
-
-		*uuid = u
-
-	case []byte:
-		// if an empty UUID comes from a table, we return a null UUID
-		if len(src) == 0 {
-			return nil
-		}
-
-		// assumes a simple slice of bytes if 16 bytes
-		// otherwise attempts to parse
-		if len(src) != 16 {
-			return uuid.Scan(string(src))
-		}
-		copy((*uuid)[:], src)
-
-	default:
-		return fmt.Errorf("Scan: unable to scan type %T into UUID", src)
-	}
-
-	return nil
-}
-
-// Value implements sql.Valuer so that UUIDs can be written to databases
-// transparently. Currently, UUIDs map to strings. Please consult
-// database-specific driver documentation for matching types.
-func (uuid UUID) Value() (driver.Value, error) {
-	return uuid.String(), nil
-}

vendor/github.com/google/uuid/time.go

@@ -1,123 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import (
-	"encoding/binary"
-	"sync"
-	"time"
-)
-
-// A Time represents a time as the number of 100's of nanoseconds since 15 Oct
-// 1582.
-type Time int64
-
-const (
-	lillian    = 2299160          // Julian day of 15 Oct 1582
-	unix       = 2440587          // Julian day of 1 Jan 1970
-	epoch      = unix - lillian   // Days between epochs
-	g1582      = epoch * 86400    // seconds between epochs
-	g1582ns100 = g1582 * 10000000 // 100s of a nanoseconds between epochs
-)
-
-var (
-	timeMu   sync.Mutex
-	lasttime uint64 // last time we returned
-	clockSeq uint16 // clock sequence for this run
-
-	timeNow = time.Now // for testing
-)
-
-// UnixTime converts t the number of seconds and nanoseconds using the Unix
-// epoch of 1 Jan 1970.
-func (t Time) UnixTime() (sec, nsec int64) {
-	sec = int64(t - g1582ns100)
-	nsec = (sec % 10000000) * 100
-	sec /= 10000000
-	return sec, nsec
-}
-
-// GetTime returns the current Time (100s of nanoseconds since 15 Oct 1582) and
-// clock sequence as well as adjusting the clock sequence as needed.  An error
-// is returned if the current time cannot be determined.
-func GetTime() (Time, uint16, error) {
-	defer timeMu.Unlock()
-	timeMu.Lock()
-	return getTime()
-}
-
-func getTime() (Time, uint16, error) {
-	t := timeNow()
-
-	// If we don't have a clock sequence already, set one.
-	if clockSeq == 0 {
-		setClockSequence(-1)
-	}
-	now := uint64(t.UnixNano()/100) + g1582ns100
-
-	// If time has gone backwards with this clock sequence then we
-	// increment the clock sequence
-	if now <= lasttime {
-		clockSeq = ((clockSeq + 1) & 0x3fff) | 0x8000
-	}
-	lasttime = now
-	return Time(now), clockSeq, nil
-}
-
-// ClockSequence returns the current clock sequence, generating one if not
-// already set.  The clock sequence is only used for Version 1 UUIDs.
-//
-// The uuid package does not use global static storage for the clock sequence or
-// the last time a UUID was generated.  Unless SetClockSequence is used, a new
-// random clock sequence is generated the first time a clock sequence is
-// requested by ClockSequence, GetTime, or NewUUID.  (section 4.2.1.1)
-func ClockSequence() int {
-	defer timeMu.Unlock()
-	timeMu.Lock()
-	return clockSequence()
-}
-
-func clockSequence() int {
-	if clockSeq == 0 {
-		setClockSequence(-1)
-	}
-	return int(clockSeq & 0x3fff)
-}
-
-// SetClockSequence sets the clock sequence to the lower 14 bits of seq.  Setting to
-// -1 causes a new sequence to be generated.
-func SetClockSequence(seq int) {
-	defer timeMu.Unlock()
-	timeMu.Lock()
-	setClockSequence(seq)
-}
-
-func setClockSequence(seq int) {
-	if seq == -1 {
-		var b [2]byte
-		randomBits(b[:]) // clock sequence
-		seq = int(b[0])<<8 | int(b[1])
-	}
-	oldSeq := clockSeq
-	clockSeq = uint16(seq&0x3fff) | 0x8000 // Set our variant
-	if oldSeq != clockSeq {
-		lasttime = 0
-	}
-}
-
-// Time returns the time in 100s of nanoseconds since 15 Oct 1582 encoded in
-// uuid.  The time is only defined for version 1 and 2 UUIDs.
-func (uuid UUID) Time() Time {
-	time := int64(binary.BigEndian.Uint32(uuid[0:4]))
-	time |= int64(binary.BigEndian.Uint16(uuid[4:6])) << 32
-	time |= int64(binary.BigEndian.Uint16(uuid[6:8])&0xfff) << 48
-	return Time(time)
-}
-
-// ClockSequence returns the clock sequence encoded in uuid.
-// The clock sequence is only well defined for version 1 and 2 UUIDs.
-func (uuid UUID) ClockSequence() int {
-	return int(binary.BigEndian.Uint16(uuid[8:10])) & 0x3fff
-}

vendor/github.com/google/uuid/util.go

@@ -1,43 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import (
-	"io"
-)
-
-// randomBits completely fills slice b with random data.
-func randomBits(b []byte) {
-	if _, err := io.ReadFull(rander, b); err != nil {
-		panic(err.Error()) // rand should never fail
-	}
-}
-
-// xvalues returns the value of a byte as a hexadecimal digit or 255.
-var xvalues = [256]byte{
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255,
-	255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-}
-
-// xtob converts hex characters x1 and x2 into a byte.
-func xtob(x1, x2 byte) (byte, bool) {
-	b1 := xvalues[x1]
-	b2 := xvalues[x2]
-	return (b1 << 4) | b2, b1 != 255 && b2 != 255
-}

vendor/github.com/google/uuid/uuid.go

@@ -1,198 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import (
-	"bytes"
-	"crypto/rand"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-)
-
-// A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC
-// 4122.
-type UUID [16]byte
-
-// A Version represents a UUID's version.
-type Version byte
-
-// A Variant represents a UUID's variant.
-type Variant byte
-
-// Constants returned by Variant.
-const (
-	Invalid   = Variant(iota) // Invalid UUID
-	RFC4122                   // The variant specified in RFC4122
-	Reserved                  // Reserved, NCS backward compatibility.
-	Microsoft                 // Reserved, Microsoft Corporation backward compatibility.
-	Future                    // Reserved for future definition.
-)
-
-var rander = rand.Reader // random function
-
-// Parse decodes s into a UUID or returns an error.  Both the UUID form of
-// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx and
-// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx are decoded.
-func Parse(s string) (UUID, error) {
-	var uuid UUID
-	if len(s) != 36 {
-		if len(s) != 36+9 {
-			return uuid, fmt.Errorf("invalid UUID length: %d", len(s))
-		}
-		if strings.ToLower(s[:9]) != "urn:uuid:" {
-			return uuid, fmt.Errorf("invalid urn prefix: %q", s[:9])
-		}
-		s = s[9:]
-	}
-	if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
-		return uuid, errors.New("invalid UUID format")
-	}
-	for i, x := range [16]int{
-		0, 2, 4, 6,
-		9, 11,
-		14, 16,
-		19, 21,
-		24, 26, 28, 30, 32, 34} {
-		v, ok := xtob(s[x], s[x+1])
-		if !ok {
-			return uuid, errors.New("invalid UUID format")
-		}
-		uuid[i] = v
-	}
-	return uuid, nil
-}
-
-// ParseBytes is like Parse, except it parses a byte slice instead of a string.
-func ParseBytes(b []byte) (UUID, error) {
-	var uuid UUID
-	if len(b) != 36 {
-		if len(b) != 36+9 {
-			return uuid, fmt.Errorf("invalid UUID length: %d", len(b))
-		}
-		if !bytes.Equal(bytes.ToLower(b[:9]), []byte("urn:uuid:")) {
-			return uuid, fmt.Errorf("invalid urn prefix: %q", b[:9])
-		}
-		b = b[9:]
-	}
-	if b[8] != '-' || b[13] != '-' || b[18] != '-' || b[23] != '-' {
-		return uuid, errors.New("invalid UUID format")
-	}
-	for i, x := range [16]int{
-		0, 2, 4, 6,
-		9, 11,
-		14, 16,
-		19, 21,
-		24, 26, 28, 30, 32, 34} {
-		v, ok := xtob(b[x], b[x+1])
-		if !ok {
-			return uuid, errors.New("invalid UUID format")
-		}
-		uuid[i] = v
-	}
-	return uuid, nil
-}
-
-// FromBytes creates a new UUID from a byte slice. Returns an error if the slice
-// does not have a length of 16. The bytes are copied from the slice.
-func FromBytes(b []byte) (uuid UUID, err error) {
-	err = uuid.UnmarshalBinary(b)
-	return uuid, err
-}
-
-// Must returns uuid if err is nil and panics otherwise.
-func Must(uuid UUID, err error) UUID {
-	if err != nil {
-		panic(err)
-	}
-	return uuid
-}
-
-// String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-// , or "" if uuid is invalid.
-func (uuid UUID) String() string {
-	var buf [36]byte
-	encodeHex(buf[:], uuid)
-	return string(buf[:])
-}
-
-// URN returns the RFC 2141 URN form of uuid,
-// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx,  or "" if uuid is invalid.
-func (uuid UUID) URN() string {
-	var buf [36 + 9]byte
-	copy(buf[:], "urn:uuid:")
-	encodeHex(buf[9:], uuid)
-	return string(buf[:])
-}
-
-func encodeHex(dst []byte, uuid UUID) {
-	hex.Encode(dst[:], uuid[:4])
-	dst[8] = '-'
-	hex.Encode(dst[9:13], uuid[4:6])
-	dst[13] = '-'
-	hex.Encode(dst[14:18], uuid[6:8])
-	dst[18] = '-'
-	hex.Encode(dst[19:23], uuid[8:10])
-	dst[23] = '-'
-	hex.Encode(dst[24:], uuid[10:])
-}
-
-// Variant returns the variant encoded in uuid.
-func (uuid UUID) Variant() Variant {
-	switch {
-	case (uuid[8] & 0xc0) == 0x80:
-		return RFC4122
-	case (uuid[8] & 0xe0) == 0xc0:
-		return Microsoft
-	case (uuid[8] & 0xe0) == 0xe0:
-		return Future
-	default:
-		return Reserved
-	}
-}
-
-// Version returns the version of uuid.
-func (uuid UUID) Version() Version {
-	return Version(uuid[6] >> 4)
-}
-
-func (v Version) String() string {
-	if v > 15 {
-		return fmt.Sprintf("BAD_VERSION_%d", v)
-	}
-	return fmt.Sprintf("VERSION_%d", v)
-}
-
-func (v Variant) String() string {
-	switch v {
-	case RFC4122:
-		return "RFC4122"
-	case Reserved:
-		return "Reserved"
-	case Microsoft:
-		return "Microsoft"
-	case Future:
-		return "Future"
-	case Invalid:
-		return "Invalid"
-	}
-	return fmt.Sprintf("BadVariant%d", int(v))
-}
-
-// SetRand sets the random number generator to r, which implements io.Reader.
-// If r.Read returns an error when the package requests random data then
-// a panic will be issued.
-//
-// Calling SetRand with nil sets the random number generator to the default
-// generator.
-func SetRand(r io.Reader) {
-	if r == nil {
-		rander = rand.Reader
-		return
-	}
-	rander = r
-}

vendor/github.com/google/uuid/version1.go

@@ -1,44 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import (
-	"encoding/binary"
-)
-
-// NewUUID returns a Version 1 UUID based on the current NodeID and clock
-// sequence, and the current time.  If the NodeID has not been set by SetNodeID
-// or SetNodeInterface then it will be set automatically.  If the NodeID cannot
-// be set NewUUID returns nil.  If clock sequence has not been set by
-// SetClockSequence then it will be set automatically.  If GetTime fails to
-// return the current NewUUID returns nil and an error.
-//
-// In most cases, New should be used.
-func NewUUID() (UUID, error) {
-	nodeMu.Lock()
-	if nodeID == zeroID {
-		setNodeInterface("")
-	}
-	nodeMu.Unlock()
-
-	var uuid UUID
-	now, seq, err := GetTime()
-	if err != nil {
-		return uuid, err
-	}
-
-	timeLow := uint32(now & 0xffffffff)
-	timeMid := uint16((now >> 32) & 0xffff)
-	timeHi := uint16((now >> 48) & 0x0fff)
-	timeHi |= 0x1000 // Version 1
-
-	binary.BigEndian.PutUint32(uuid[0:], timeLow)
-	binary.BigEndian.PutUint16(uuid[4:], timeMid)
-	binary.BigEndian.PutUint16(uuid[6:], timeHi)
-	binary.BigEndian.PutUint16(uuid[8:], seq)
-	copy(uuid[10:], nodeID[:])
-
-	return uuid, nil
-}

vendor/github.com/google/uuid/version4.go

@@ -1,38 +0,0 @@
-// Copyright 2016 Google Inc.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package uuid
-
-import "io"
-
-// New creates a new random UUID or panics.  New is equivalent to
-// the expression
-//
-//    uuid.Must(uuid.NewRandom())
-func New() UUID {
-	return Must(NewRandom())
-}
-
-// NewRandom returns a Random (Version 4) UUID.
-//
-// The strength of the UUIDs is based on the strength of the crypto/rand
-// package.
-//
-// A note about uniqueness derived from the UUID Wikipedia entry:
-//
-//  Randomly generated UUIDs have 122 random bits.  One's annual risk of being
-//  hit by a meteorite is estimated to be one chance in 17 billion, that
-//  means the probability is about 0.00000000006 (6 × 10−11),
-//  equivalent to the odds of creating a few tens of trillions of UUIDs in a
-//  year and having one duplicate.
-func NewRandom() (UUID, error) {
-	var uuid UUID
-	_, err := io.ReadFull(rander, uuid[:])
-	if err != nil {
-		return Nil, err
-	}
-	uuid[6] = (uuid[6] & 0x0f) | 0x40 // Version 4
-	uuid[8] = (uuid[8] & 0x3f) | 0x80 // Variant is 10
-	return uuid, nil
-}

vendor/github.com/huandu/xstrings/convert.go

@@ -43,7 +43,7 @@ func ToCamelCase(str string) string {
 	if len(str) == 0 {
 		return buf.String()
 	}
-
+	
 	r0 = unicode.ToUpper(r0)
 
 	for len(str) > 0 {
@@ -81,9 +81,6 @@ func ToCamelCase(str string) string {
 //     "GO_PATH"    => "go_path"
 //     "GO PATH"    => "go_path"      // space is converted to underscore.
 //     "GO-PATH"    => "go_path"      // hyphen is converted to underscore.
-//     "HTTP2XX"    => "http_2xx"     // insert an underscore before a number and after an alphabet.
-//     "http2xx"    => "http_2xx"
-//     "HTTP20xOK"  => "http_20x_ok"
 func ToSnakeCase(str string) string {
 	if len(str) == 0 {
 		return ""
@@ -105,7 +102,7 @@ func ToSnakeCase(str string) string {
 			buf.WriteByte(byte(str[0]))
 
 		case unicode.IsUpper(r0):
-			if prev != '_' && !unicode.IsNumber(prev) {
+			if prev != '_' {
 				buf.WriteRune('_')
 			}
 
@@ -143,12 +140,6 @@ func ToSnakeCase(str string) string {
 						r0 = '_'
 
 						buf.WriteRune(unicode.ToLower(r1))
-					} else if unicode.IsNumber(r0) {
-						// treat a number as an upper case rune
-						// so that both `http2xx` and `HTTP2XX` can be converted to `http_2xx`.
-						buf.WriteRune(unicode.ToLower(r1))
-						buf.WriteRune('_')
-						buf.WriteRune(r0)
 					} else {
 						buf.WriteRune('_')
 						buf.WriteRune(unicode.ToLower(r1))
@@ -163,15 +154,9 @@ func ToSnakeCase(str string) string {
 
 			if len(str) == 0 || r0 == '_' {
 				buf.WriteRune(unicode.ToLower(r0))
+				break
 			}
 
-		case unicode.IsNumber(r0):
-			if prev != '_' && !unicode.IsNumber(prev) {
-				buf.WriteRune('_')
-			}
-
-			buf.WriteRune(r0)
-
 		default:
 			if r0 == ' ' || r0 == '-' {
 				r0 = '_'

vendor/github.com/imdario/mergo/map.go

@@ -31,8 +31,8 @@ func isExported(field reflect.StructField) bool {
 // Traverses recursively both values, assigning src's fields values to dst.
 // The map argument tracks comparisons that have already been seen, which allows
 // short circuiting on recursive types.
-func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) {
-	overwrite := config.Overwrite
+func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *config) (err error) {
+	overwrite := config.overwrite
 	if dst.CanAddr() {
 		addr := dst.UnsafeAddr()
 		h := 17 * addr
@@ -128,23 +128,23 @@ func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, conf
 // doesn't apply if dst is a map.
 // This is separated method from Merge because it is cleaner and it keeps sane
 // semantics: merging equal types, mapping different (restricted) types.
-func Map(dst, src interface{}, opts ...func(*Config)) error {
+func Map(dst, src interface{}, opts ...func(*config)) error {
 	return _map(dst, src, opts...)
 }
 
-// MapWithOverwrite will do the same as Map except that non-empty dst attributes will be overridden by
+// MapWithOverwrite will do the same as Map except that non-empty dst attributes will be overriden by
 // non-empty src attribute values.
 // Deprecated: Use Map(…) with WithOverride
-func MapWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {
+func MapWithOverwrite(dst, src interface{}, opts ...func(*config)) error {
 	return _map(dst, src, append(opts, WithOverride)...)
 }
 
-func _map(dst, src interface{}, opts ...func(*Config)) error {
+func _map(dst, src interface{}, opts ...func(*config)) error {
 	var (
 		vDst, vSrc reflect.Value
 		err        error
 	)
-	config := &Config{}
+	config := &config{}
 
 	for _, opt := range opts {
 		opt(config)

vendor/github.com/imdario/mergo/merge.go

@@ -8,10 +8,7 @@
 
 package mergo
 
-import (
-	"fmt"
-	"reflect"
-)
+import "reflect"
 
 func hasExportedField(dst reflect.Value) (exported bool) {
 	for i, n := 0, dst.NumField(); i < n; i++ {
@@ -25,21 +22,20 @@ func hasExportedField(dst reflect.Value) (exported bool) {
 	return
 }
 
-type Config struct {
-	Overwrite    bool
-	AppendSlice  bool
-	Transformers Transformers
+type config struct {
+	overwrite    bool
+	transformers transformers
 }
 
-type Transformers interface {
+type transformers interface {
 	Transformer(reflect.Type) func(dst, src reflect.Value) error
 }
 
 // Traverses recursively both values, assigning src's fields values to dst.
 // The map argument tracks comparisons that have already been seen, which allows
 // short circuiting on recursive types.
-func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) {
-	overwrite := config.Overwrite
+func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *config) (err error) {
+	overwrite := config.overwrite
 
 	if !src.IsValid() {
 		return
@@ -58,8 +54,8 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 		visited[h] = &visit{addr, typ, seen}
 	}
 
-	if config.Transformers != nil && !isEmptyValue(dst) {
-		if fn := config.Transformers.Transformer(dst.Type()); fn != nil {
+	if config.transformers != nil && !isEmptyValue(dst) {
+		if fn := config.transformers.Transformer(dst.Type()); fn != nil {
 			err = fn(dst, src)
 			return
 		}
@@ -79,8 +75,9 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 			}
 		}
 	case reflect.Map:
-		if dst.IsNil() && !src.IsNil() {
+		if len(src.MapKeys()) == 0 && !src.IsNil() && len(dst.MapKeys()) == 0 {
 			dst.Set(reflect.MakeMap(dst.Type()))
+			return
 		}
 		for _, key := range src.MapKeys() {
 			srcElement := src.MapIndex(key)
@@ -104,15 +101,7 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 				case reflect.Ptr:
 					fallthrough
 				case reflect.Map:
-					srcMapElm := srcElement
-					dstMapElm := dstElement
-					if srcMapElm.CanInterface() {
-						srcMapElm = reflect.ValueOf(srcMapElm.Interface())
-						if dstMapElm.IsValid() {
-							dstMapElm = reflect.ValueOf(dstMapElm.Interface())
-						}
-					}
-					if err = deepMerge(dstMapElm, srcMapElm, visited, depth+1, config); err != nil {
+					if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
 						return
 					}
 				case reflect.Slice:
@@ -125,14 +114,7 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 						dstSlice = reflect.ValueOf(dstElement.Interface())
 					}
 
-					if !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice {
-						dstSlice = srcSlice
-					} else if config.AppendSlice {
-						if srcSlice.Type() != dstSlice.Type() {
-							return fmt.Errorf("cannot append two slice with different type (%s, %s)", srcSlice.Type(), dstSlice.Type())
-						}
-						dstSlice = reflect.AppendSlice(dstSlice, srcSlice)
-					}
+					dstSlice = reflect.AppendSlice(dstSlice, srcSlice)
 					dst.SetMapIndex(key, dstSlice)
 				}
 			}
@@ -140,7 +122,7 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 				continue
 			}
 
-			if srcElement.IsValid() && (overwrite || (!dstElement.IsValid() || isEmptyValue(dstElement))) {
+			if srcElement.IsValid() && (overwrite || (!dstElement.IsValid() || isEmptyValue(dst))) {
 				if dst.IsNil() {
 					dst.Set(reflect.MakeMap(dst.Type()))
 				}
@@ -148,17 +130,7 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 			}
 		}
 	case reflect.Slice:
-		if !dst.CanSet() {
-			break
-		}
-		if !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice {
-			dst.Set(src)
-		} else if config.AppendSlice {
-			if src.Type() != dst.Type() {
-				return fmt.Errorf("cannot append two slice with different type (%s, %s)", src.Type(), dst.Type())
-			}
-			dst.Set(reflect.AppendSlice(dst, src))
-		}
+		dst.Set(reflect.AppendSlice(dst, src))
 	case reflect.Ptr:
 		fallthrough
 	case reflect.Interface:
@@ -202,41 +174,36 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 // src attributes if they themselves are not empty. dst and src must be valid same-type structs
 // and dst must be a pointer to struct.
 // It won't merge unexported (private) fields and will do recursively any exported field.
-func Merge(dst, src interface{}, opts ...func(*Config)) error {
+func Merge(dst, src interface{}, opts ...func(*config)) error {
 	return merge(dst, src, opts...)
 }
 
 // MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overriden by
 // non-empty src attribute values.
 // Deprecated: use Merge(…) with WithOverride
-func MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {
+func MergeWithOverwrite(dst, src interface{}, opts ...func(*config)) error {
 	return merge(dst, src, append(opts, WithOverride)...)
 }
 
 // WithTransformers adds transformers to merge, allowing to customize the merging of some types.
-func WithTransformers(transformers Transformers) func(*Config) {
-	return func(config *Config) {
-		config.Transformers = transformers
+func WithTransformers(transformers transformers) func(*config) {
+	return func(config *config) {
+		config.transformers = transformers
 	}
 }
 
 // WithOverride will make merge override non-empty dst attributes with non-empty src attributes values.
-func WithOverride(config *Config) {
-	config.Overwrite = true
+func WithOverride(config *config) {
+	config.overwrite = true
 }
 
-// WithAppendSlice will make merge append slices instead of overwriting it
-func WithAppendSlice(config *Config) {
-	config.AppendSlice = true
-}
-
-func merge(dst, src interface{}, opts ...func(*Config)) error {
+func merge(dst, src interface{}, opts ...func(*config)) error {
 	var (
 		vDst, vSrc reflect.Value
 		err        error
 	)
 
-	config := &Config{}
+	config := &config{}
 
 	for _, opt := range opts {
 		opt(config)

vendor/github.com/imdario/mergo/mergo.go

@@ -45,12 +45,7 @@ func isEmptyValue(v reflect.Value) bool {
 		return v.Uint() == 0
 	case reflect.Float32, reflect.Float64:
 		return v.Float() == 0
-	case reflect.Interface, reflect.Ptr:
-		if v.IsNil() {
-			return true
-		}
-		return isEmptyValue(v.Elem())
-	case reflect.Func:
+	case reflect.Interface, reflect.Ptr, reflect.Func:
 		return v.IsNil()
 	case reflect.Invalid:
 		return true

vendor/github.com/mattn/go-zglob/fastwalk/fastwalk.go

@@ -19,7 +19,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"sync"
 )
 
 // TraverseLink is a sentinel error for fastWalk, similar to filepath.SkipDir.
@@ -40,16 +39,6 @@ var TraverseLink = errors.New("traverse symlink, assuming target is a directory"
 //     sentinel error. It is the walkFn's responsibility to prevent
 //     fastWalk from going into symlink cycles.
 func FastWalk(root string, walkFn func(path string, typ os.FileMode) error) error {
-	// Check if "root" is actually a file, not a directory.
-	stat, err := os.Stat(root)
-	if err != nil {
-		return err
-	}
-	if !stat.IsDir() {
-		// If it is, just directly pass it to walkFn and return.
-		return walkFn(root, stat.Mode())
-	}
-
 	// TODO(bradfitz): make numWorkers configurable? We used a
 	// minimum of 4 to give the kernel more info about multiple
 	// things we want, in hopes its I/O scheduling can take
@@ -68,14 +57,11 @@ func FastWalk(root string, walkFn func(path string, typ os.FileMode) error) erro
 		// buffered for correctness & not leaking goroutines:
 		resc: make(chan error, numWorkers),
 	}
-
+	defer close(w.donec)
 	// TODO(bradfitz): start the workers as needed? maybe not worth it.
-	var wg sync.WaitGroup
 	for i := 0; i < numWorkers; i++ {
-		wg.Add(1)
-		go w.doWork(&wg)
+		go w.doWork()
 	}
-
 	todo := []walkItem{{dir: root}}
 	out := 0
 	for {
@@ -93,28 +79,10 @@ func FastWalk(root string, walkFn func(path string, typ os.FileMode) error) erro
 		case it := <-w.enqueuec:
 			todo = append(todo, it)
 		case err := <-w.resc:
+			out--
 			if err != nil {
-				// Signal to the workers to close.
-				close(w.donec)
-
-				// Drain the results channel from the other workers which
-				// haven't returned yet.
-				go func() {
-					for {
-						select {
-						case _, ok := <-w.resc:
-							if !ok {
-								return
-							}
-						}
-					}
-				}()
-
-				wg.Wait()
 				return err
 			}
-
-			out--
 			if out == 0 && len(todo) == 0 {
 				// It's safe to quit here, as long as the buffered
 				// enqueue channel isn't also readable, which might
@@ -126,10 +94,6 @@ func FastWalk(root string, walkFn func(path string, typ os.FileMode) error) erro
 				case it := <-w.enqueuec:
 					todo = append(todo, it)
 				default:
-					// Signal to the workers to close, and wait for all of
-					// them to return.
-					close(w.donec)
-					wg.Wait()
 					return nil
 				}
 			}
@@ -139,11 +103,10 @@ func FastWalk(root string, walkFn func(path string, typ os.FileMode) error) erro
 
 // doWork reads directories as instructed (via workc) and runs the
 // user's callback function.
-func (w *walker) doWork(wg *sync.WaitGroup) {
+func (w *walker) doWork() {
 	for {
 		select {
 		case <-w.donec:
-			wg.Done()
 			return
 		case it := <-w.workc:
 			w.resc <- w.walk(it.dir, !it.callbackDone)

vendor/github.com/mattn/go-zglob/zglob.go

@@ -18,13 +18,12 @@ var (
 )
 
 type zenv struct {
-	dre     *regexp.Regexp
-	fre     *regexp.Regexp
-	pattern string
-	root    string
+	dre  *regexp.Regexp
+	fre  *regexp.Regexp
+	root string
 }
 
-func New(pattern string) (*zenv, error) {
+func makePattern(pattern string) (*zenv, error) {
 	globmask := ""
 	root := ""
 	for n, i := range strings.Split(filepath.ToSlash(pattern), "/") {
@@ -57,10 +56,9 @@ func New(pattern string) (*zenv, error) {
 	}
 	if root == "" {
 		return &zenv{
-			dre:     nil,
-			fre:     nil,
-			pattern: pattern,
-			root:    "",
+			dre:  nil,
+			fre:  nil,
+			root: "",
 		}, nil
 	}
 	if globmask == "" {
@@ -108,10 +106,9 @@ func New(pattern string) (*zenv, error) {
 		filemask = "(?i:" + filemask + ")"
 	}
 	return &zenv{
-		dre:     regexp.MustCompile("^" + dirmask),
-		fre:     regexp.MustCompile("^" + filemask + "$"),
-		pattern: pattern,
-		root:    filepath.Clean(root),
+		dre:  regexp.MustCompile("^" + dirmask),
+		fre:  regexp.MustCompile("^" + filemask + "$"),
+		root: filepath.Clean(root),
 	}, nil
 }
 
@@ -124,7 +121,7 @@ func GlobFollowSymlinks(pattern string) ([]string, error) {
 }
 
 func glob(pattern string, followSymlinks bool) ([]string, error) {
-	zenv, err := New(pattern)
+	zenv, err := makePattern(pattern)
 	if err != nil {
 		return nil, err
 	}
@@ -183,26 +180,22 @@ func glob(pattern string, followSymlinks bool) ([]string, error) {
 }
 
 func Match(pattern, name string) (matched bool, err error) {
-	zenv, err := New(pattern)
+	zenv, err := makePattern(pattern)
 	if err != nil {
 		return false, err
 	}
-	return zenv.Match(name), nil
-}
-
-func (z *zenv) Match(name string) bool {
-	if z.root == "" {
-		return z.pattern == name
+	if zenv.root == "" {
+		return pattern == name, nil
 	}
 
 	name = filepath.ToSlash(name)
 
-	if name == "." || len(name) <= len(z.root) {
-		return false
+	if name == "." || len(name) <= len(zenv.root) {
+		return false, nil
 	}
 
-	if z.fre.MatchString(name) {
-		return true
+	if zenv.fre.MatchString(name) {
+		return true, nil
 	}
-	return false
+	return false, nil
 }

vendor/github.com/mitchellh/go-homedir/homedir.go

@@ -77,51 +77,33 @@ func Expand(path string) (string, error) {
 }
 
 func dirUnix() (string, error) {
-	homeEnv := "HOME"
-	if runtime.GOOS == "plan9" {
-		// On plan9, env vars are lowercase.
-		homeEnv = "home"
-	}
-
 	// First prefer the HOME environmental variable
-	if home := os.Getenv(homeEnv); home != "" {
+	if home := os.Getenv("HOME"); home != "" {
 		return home, nil
 	}
 
+	// If that fails, try getent
 	var stdout bytes.Buffer
-
-	// If that fails, try OS specific commands
-	if runtime.GOOS == "darwin" {
-		cmd := exec.Command("sh", "-c", `dscl -q . -read /Users/"$(whoami)" NFSHomeDirectory | sed 's/^[^ ]*: //'`)
-		cmd.Stdout = &stdout
-		if err := cmd.Run(); err == nil {
-			result := strings.TrimSpace(stdout.String())
-			if result != "" {
-				return result, nil
-			}
+	cmd := exec.Command("getent", "passwd", strconv.Itoa(os.Getuid()))
+	cmd.Stdout = &stdout
+	if err := cmd.Run(); err != nil {
+		// If the error is ErrNotFound, we ignore it. Otherwise, return it.
+		if err != exec.ErrNotFound {
+			return "", err
 		}
 	} else {
-		cmd := exec.Command("getent", "passwd", strconv.Itoa(os.Getuid()))
-		cmd.Stdout = &stdout
-		if err := cmd.Run(); err != nil {
-			// If the error is ErrNotFound, we ignore it. Otherwise, return it.
-			if err != exec.ErrNotFound {
-				return "", err
-			}
-		} else {
-			if passwd := strings.TrimSpace(stdout.String()); passwd != "" {
-				// username:password:uid:gid:gecos:home:shell
-				passwdParts := strings.SplitN(passwd, ":", 7)
-				if len(passwdParts) > 5 {
-					return passwdParts[5], nil
-				}
+		if passwd := strings.TrimSpace(stdout.String()); passwd != "" {
+			// username:password:uid:gid:gecos:home:shell
+			passwdParts := strings.SplitN(passwd, ":", 7)
+			if len(passwdParts) > 5 {
+				return passwdParts[5], nil
 			}
 		}
 	}
 
 	// If all else fails, try the shell
 	stdout.Reset()
-	cmd := exec.Command("sh", "-c", "cd && pwd")
+	cmd = exec.Command("sh", "-c", "cd && pwd")
 	cmd.Stdout = &stdout
 	if err := cmd.Run(); err != nil {
 		return "", err
@@ -141,16 +123,14 @@ func dirWindows() (string, error) {
 		return home, nil
 	}
 
-	// Prefer standard environment variable USERPROFILE
-	if home := os.Getenv("USERPROFILE"); home != "" {
-		return home, nil
-	}
-
 	drive := os.Getenv("HOMEDRIVE")
 	path := os.Getenv("HOMEPATH")
 	home := drive + path
 	if drive == "" || path == "" {
-		return "", errors.New("HOMEDRIVE, HOMEPATH, or USERPROFILE are blank")
+		home = os.Getenv("USERPROFILE")
+	}
+	if home == "" {
+		return "", errors.New("HOMEDRIVE, HOMEPATH, and USERPROFILE are blank")
 	}
 
 	return home, nil

vendor/github.com/radovskyb/watcher/samefile.go

@@ -4,6 +4,6 @@ package watcher
 
 import "os"
 
-func sameFile(fi1, fi2 os.FileInfo) bool {
+func SameFile(fi1, fi2 os.FileInfo) bool {
 	return os.SameFile(fi1, fi2)
 }

vendor/github.com/radovskyb/watcher/samefile_windows.go

@@ -4,7 +4,7 @@ package watcher
 
 import "os"
 
-func sameFile(fi1, fi2 os.FileInfo) bool {
+func SameFile(fi1, fi2 os.FileInfo) bool {
 	return fi1.ModTime() == fi2.ModTime() &&
 		fi1.Size() == fi2.Size() &&
 		fi1.Mode() == fi2.Mode() &&