v3.0.0-preview4

The idea is to allow manual inclusion of a OS-dependant Taskfile, since it's
not automatically included anymore.

.github/workflows/release.yml

@@ -0,0 +1,26 @@
+name: goreleaser
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Set up Go
+        uses: actions/setup-go@v1
+        with:
+          go-version: 1.14.x
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v1
+        with:
+          version: latest
+          args: release --rm-dist
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

.github/workflows/test.yml

@@ -5,7 +5,7 @@ jobs:
     name: Test
     strategy:
       matrix:
-        go-version: [1.12.x, 1.13.x]
+        go-version: [1.13.x, 1.14.x]
         platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{matrix.platform}}
     steps:

.gitignore

@@ -26,3 +26,4 @@ dist/
 tags
 
 /bin
+/testdata/vars/v1

.goreleaser.yml

@@ -40,4 +40,4 @@ nfpms:
     formats:
       - deb
       - rpm
-    name_template: "{{.ProjectName}}_{{.Os}}_{{.Arch}}"
+    file_name_template: "{{.ProjectName}}_{{.Os}}_{{.Arch}}"

.travis.yml

@@ -1,17 +0,0 @@
-language: go
-
-go:
-  - 1.12.x
-  - 1.13.x
-
-env:
-  - GO111MODULE=on
-
-addons:
-  apt:
-    packages:
-      - rpm
-
-script:
-  - go install -v ./cmd/task
-  - task ci

CHANGELOG.md

@@ -1,5 +1,62 @@
 # Changelog
 
+# v3.0.0 - Preview 4
+
+- Refactor how variables work on version 3
+  ([#311](https://github.com/go-task/task/pull/311)).
+- Disallow `expansions` on v3 since it has no effect.
+- `Taskvars.yml` is not automatically included anymore.
+- `Taskfile_{{OS}}.yml` is not automatically included anymore.
+- Allow interpolation on `includes`, so you can manually include a Taskfile
+  based on operation system, for example.
+
+# v3.0.0 - Preview 3
+
+- Expose `.TASK` variable in templates with the task name
+  ([#252](https://github.com/go-task/task/issues/252)).
+- Implement short task syntax
+  ([#194](https://github.com/go-task/task/issues/194), [#240](https://github.com/go-task/task/pull/240)).
+- Added option to make included Taskfile run commands on its own directory
+  ([#260](https://github.com/go-task/task/issues/260), [#144](https://github.com/go-task/task/issues/144))
+
+# v3.0.0 - Preview 2
+
+- Taskfiles in version 1 are not supported anymore
+  ([#237](https://github.com/go-task/task/pull/237)).
+- Added global `method:` option. With this option, you can set a default
+  method to all tasks in a Taskfile
+  ([#246](https://github.com/go-task/task/issues/246)).
+- Changed default method from `timestamp` to `checksum`
+  ([#246](https://github.com/go-task/task/issues/246)).
+- New magic variables are now available when using `status:`:
+  `.TIMESTAMP` which contains the greatest modification date
+  from the files listed in `sources:`, and `.CHECKSUM`, which
+  contains a checksum of all files listed in `status:`.
+  This is useful for manual checking when using external, or even remote,
+  artifacts when using `status:`
+  ([#216](https://github.com/go-task/task/pull/216)).
+
+## v3.0.0 - Preview 1
+
+- We're now using [slim-sprig](https://github.com/go-task/slim-sprig) instead of
+  [sprig](https://github.com/Masterminds/sprig), which allowed a file size
+  reduction of about 22%
+  ([#219](https://github.com/go-task/task/pull/219)).
+- We now use some colors on Task output to better distinguish message types -
+  commands are green, errors are red, etc
+  ([#207](https://github.com/go-task/task/pull/207)).
+
+## v2.8.1 - 2019-05-20
+
+- Fix error code for the `--help` flag
+  ([#300](https://github.com/go-task/task/issues/300), [#330](https://github.com/go-task/task/pull/330)).
+- Print version to stdout instead of stderr
+  ([#299](https://github.com/go-task/task/issues/299), [#329](https://github.com/go-task/task/pull/329)).
+- Supress `context` errors when using the `--watch` flag
+  ([#313](https://github.com/go-task/task/issues/313), [#317](https://github.com/go-task/task/pull/317)).
+- Support templating on description
+  ([#276](https://github.com/go-task/task/issues/276), [#283](https://github.com/go-task/task/pull/283)).
+
 ## v2.8.0 - 2019-12-07
 
 - Add `--parallel` flag (alias `-p`) to run tasks given by the command line in

README.md

@@ -1,4 +1,5 @@
-[![Build Status](https://travis-ci.org/go-task/task.svg?branch=master)](https://travis-ci.org/go-task/task)
+![Test](https://github.com/go-task/task/workflows/Test/badge.svg)
+![GoReleaser](https://github.com/go-task/task/workflows/goreleaser/badge.svg)
 
 # Task
 

Taskfile.yml

@@ -1,9 +1,9 @@
-version: '2'
+version: '3'
-
-# silent: true
 
 includes:
-  docs: ./docs
+  docs:
+    taskfile: ./docs
+    dir: ./docs
 
 vars:
   GIT_COMMIT:
@@ -74,15 +74,12 @@ tasks:
       - cp ./install-task.sh ./docs/install.sh
 
   ci:
-    cmds:
+    - task: go-get
-      - task: go-get
+      vars: {REPO: golang.org/x/lint/golint}
-        vars: {REPO: golang.org/x/lint/golint}
+    - task: lint
-      - task: lint
+    - task: test
-      - task: test
 
-  go-get:
+  go-get: go get -u {{.REPO}}
-    cmds:
-      - go get -u {{.REPO}}
 
   packages:
     cmds:

cmd/redirector/redirector.go

@@ -1,421 +0,0 @@
-// This small web app is used to redirect from the old taskfile.org domain
-// to the new taskfile.dev without breaking CIs that uses cURL to download
-// "/install.sh" without the -L flag (which follow redirects).
-
-package main
-
-import (
-	"net/http"
-)
-
-func main() {
-	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/install.sh" {
-			println("Dumping install.sh")
-
-			w.Write(installShContent)
-			return
-		}
-
-		println("Redirecting to https://taskfile.dev" + r.URL.Path)
-
-		w.Header().Set("Location", "https://taskfile.dev"+r.URL.Path)
-		w.WriteHeader(301)
-	})
-
-	println("Listening :8080")
-
-	panic(http.ListenAndServe(":8080", nil))
-}
-
-var installShContent = []byte(`#!/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
-`)

cmd/task/task.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"fmt"
 	"log"
 	"os"
 	"os/signal"
@@ -10,6 +11,7 @@ import (
 
 	"github.com/go-task/task/v2"
 	"github.com/go-task/task/v2/internal/args"
+	"github.com/go-task/task/v2/internal/logger"
 
 	"github.com/spf13/pflag"
 )
@@ -27,12 +29,14 @@ Example: 'task hello' with the following 'Taskfile.yml' file will generate an
 'output.txt' file with the content "hello".
 
 '''
-hello:
+version: '3'
-  cmds:
+tasks:
-    - echo "I am going to write a file named 'output.txt' now."
+  hello:
-    - echo "hello" > output.txt
+    cmds:
-  generates:
+      - echo "I am going to write a file named 'output.txt' now."
-    - output.txt
+      - echo "hello" > output.txt
+    generates:
+      - output.txt
 '''
 
 Options:
@@ -49,6 +53,7 @@ func main() {
 
 	var (
 		versionFlag bool
+		helpFlag    bool
 		init        bool
 		list        bool
 		status      bool
@@ -62,9 +67,11 @@ func main() {
 		dir         string
 		entrypoint  string
 		output      string
+		color       bool
 	)
 
 	pflag.BoolVar(&versionFlag, "version", false, "show Task version")
+	pflag.BoolVarP(&helpFlag, "help", "h", false, "shows Task usage")
 	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yml in the current folder")
 	pflag.BoolVarP(&list, "list", "l", false, "lists tasks with description of current Taskfile")
 	pflag.BoolVar(&status, "status", false, "exits with non-zero exit code if any of the given tasks is not up-to-date")
@@ -78,10 +85,16 @@ func main() {
 	pflag.StringVarP(&dir, "dir", "d", "", "sets directory of execution")
 	pflag.StringVarP(&entrypoint, "taskfile", "t", "", `choose which Taskfile to run. Defaults to "Taskfile.yml"`)
 	pflag.StringVarP(&output, "output", "o", "", "sets output style: [interleaved|group|prefixed]")
+	pflag.BoolVarP(&color, "color", "c", true, "colored output")
 	pflag.Parse()
 
 	if versionFlag {
-		log.Printf("Task version: %s\n", version)
+		fmt.Printf("Task version: %s\n", version)
+		return
+	}
+
+	if helpFlag {
+		pflag.Usage()
 		return
 	}
 
@@ -117,6 +130,7 @@ func main() {
 		Entrypoint: entrypoint,
 		Summary:    summary,
 		Parallel:   parallel,
+		Color:      color,
 
 		Stdin:  os.Stdin,
 		Stdout: os.Stdout,
@@ -134,9 +148,7 @@ func main() {
 	}
 
 	calls, globals := args.Parse(pflag.Args()...)
-	for name, value := range globals {
+	e.Taskfile.Vars.Merge(globals)
-		e.Taskfile.Vars[name] = value
-	}
 
 	ctx := context.Background()
 	if !watch {
@@ -151,7 +163,8 @@ func main() {
 	}
 
 	if err := e.Run(ctx, calls...); err != nil {
-		log.Fatal(err)
+		e.Logger.Errf(logger.Red, "%v", err)
+		os.Exit(1)
 	}
 }
 

completion/bash/task.bash

@@ -6,7 +6,7 @@ _task_completion()
   # Remove colon from word breaks
   COMP_WORDBREAKS=${COMP_WORDBREAKS//:}
 
-  scripts=$(task -l | sed '1d' | sed 's/^\* //' | awk '{ print $1 }');
+  scripts=$(task -l | sed '1d' | awk '{ print $2 }' | sed 's/:$//');
 
   curr_arg="${COMP_WORDS[COMP_CWORD]:-"."}"
 

completion/ps/task.ps1

@@ -0,0 +1,10 @@
+$scriptBlock = {
+	param($commandName, $wordToComplete, $cursorPosition)
+	$curReg = "task{.exe}? (.*?)$"
+	$startsWith = $wordToComplete | Select-String $curReg -AllMatches | ForEach-Object { $_.Matches.Groups[1].Value }
+	$reg = "\* ($startsWith.+?):"
+	$listOutput = $(task -l)
+	$listOutput | Select-String $reg -AllMatches | ForEach-Object { $_.Matches.Groups[1].Value + " " }
+}
+
+Register-ArgumentCompleter -Native -CommandName task -ScriptBlock $scriptBlock

docs/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   install:
@@ -9,4 +9,4 @@ tasks:
   serve:
     desc: Serves the documentation site locally
     cmds:
-      - docsify serve docs
+      - docsify serve .

docs/_sidebar.md

@@ -5,4 +5,4 @@
 - [Examples](examples.md)
 - [Releasing Task](releasing_task.md)
 - [Alternative Task Runners](alternative_task_runners.md)
-- [![Github](https://icongram.jgog.in/simple/github.svg?color=808080&size=16)Github](https://github.com/go-task/task)
+- [![GitHub](https://icongram.jgog.in/simple/github.svg?color=808080&size=16)GitHub](https://github.com/go-task/task)

docs/installation.md

@@ -40,6 +40,19 @@ scoop install task
 This installation method is community owned. After a new release of Task, it
 may take some time until it's available on Scoop.
 
+## Arch Linux
+
+If you're on Arch Linux you can install Task from
+[AUR](https://aur.archlinux.org/packages/taskfile-git) using your favorite
+package manager such as `yay`, `pacaur` or `yaourt`:
+
+```cmd
+yay -S taskfile-git
+```
+
+This installation method is community owned, but since it's `-git` version of
+the package, it's always latest available version based on the Git repository.
+
 ## Go
 
 Task now uses [Go Modules](https://github.com/golang/go/wiki/Modules), which

docs/releasing_task.md

@@ -4,9 +4,9 @@ The release process of Task is done with the help of
 [GoReleaser][goreleaser]. You can test the release process locally by calling
 the `test-release` task of the Taskfile.
 
-The Travis CI should release automatically when a new
+[GitHub Actions](https://github.com/go-task/task/actions) should release
-Git tag is pushed to master, either for the artifact uploading (raw executables
+artifacts automatically when a new Git tag is pushed to master
-and DEB and RPM packages)
+(raw executables and DEB and RPM packages).
 
 # Homebrew
 

docs/taskfile_versions.md

@@ -15,6 +15,8 @@ available, but not `3.0.0+`.
 
 ## Version 1
 
+> NOTE: Taskfiles in version 1 are not supported on Task >= v3.0.0 anymore.
+
 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:
 

docs/usage.md

@@ -124,6 +124,21 @@ 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.
 
+### Directory of included Taskfile
+
+By default, included Taskfile's tasks are ran in the current directory, even
+if the Taskfile is in another directory, but you can force its tasks to run
+in another directory by using this alternative syntax:
+
+```yaml
+version: '3'
+
+includes:
+  docs:
+    taskfile: ./docs/Taskfile.yml
+    dir: ./docs
+```
+
 > The included Taskfiles must be using the same schema version the main
 > Taskfile uses.
 
@@ -269,6 +284,8 @@ The above syntax is also supported in `deps`.
 
 ## Prevent unnecessary work
 
+### By fingerprinting locally generated files and their sources
+
 If a task generates something, you can inform Task the source and generated
 files, so Task will prevent to run them if not necessary.
 
@@ -324,6 +341,8 @@ tasks:
 
 > TIP: method `none` skips any validation and always run the task.
 
+### Using programmatic checks to indicate a task is up to date.
+
 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:
 
@@ -343,15 +362,34 @@ tasks:
       - test -f directory/file2.txt
 ```
 
+Normally, you would use `sources` in combination with
+`generates` - but for tasks that generate remote artifacts (Docker images,
+deploys, CD releases) the checksum source and timestamps require either
+access to the artifact or for an out-of-band refresh of the `.checksum`
+fingerprint file.
+
+Two special variables `{{.CHECKSUM}}` and `{{.TIMESTAMP}}` are available
+for interpolation within `status` commands, depending on the method assigned
+to fingerprint the sources. Only `source` globs are fingerprinted.
+
+Note that the `{{.TIMESTAMP}}` variable is a "live" Go `time.Time` struct, and
+can be formatted using any of the methods that `time.Time` responds to.
+
+See [the Go Time documentation](https://golang.org/pkg/time/) for more information.
+
 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.
 
-If you need a certain set of conditions to be _true_ you can use the
+### Using programmatic checks to cancel execution of an task and it's dependencies
-`preconditions` stanza.  `preconditions` are very similar to `status`
+
-lines except they support `sh` expansion and they SHOULD all return 0.
+In addition to `status` checks, there are also `preconditions` checks, which are
+the logical inverse of `status` checks.  That is, if you need a certain set of
+conditions to be _true_ you can use the `preconditions` stanza.
+`preconditions` are similar to `status` lines except they support `sh`
+expansion and they SHOULD all return 0.
 
 ```yaml
 version: '2'
@@ -416,6 +454,8 @@ Example of sending parameters with environment variables:
 $ TASK_VARIABLE=a-value task do-something
 ```
 
+> TIP: A special variable `.TASK` is always available containg the task name.
+
 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
@@ -515,7 +555,7 @@ This works for all types of variables.
 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/)
+All functions by the Go's [slim-sprig lib](https://go-task.github.io/slim-sprig/)
 are available. The following example gets the current date in a given format:
 
 ```yaml
@@ -828,6 +868,22 @@ $ task default
 
 > The `output` option can also be specified by the `--output` or `-o` flags.
 
+## Short task syntax
+
+Starting on Task v3, you can now write tasks with a shorter syntax if they
+have the default settings (e.g. no custom `env:`, `vars:`, `silent:` , etc):
+
+```yaml
+version: '3'
+
+tasks:
+  build: go build -v -o ./app{{exeExt}} .
+
+  build:
+    - task: build
+    - ./app{{exeExt}} -h localhost -p 8080
+```
+
 ## Watch tasks
 
 If you give a `--watch` or `-w` argument, task will watch for file changes

go.mod

@@ -1,20 +1,16 @@
 module github.com/go-task/task/v2
 
 require (
-	github.com/Masterminds/semver v1.4.2 // indirect
+	github.com/fatih/color v1.7.0
-	github.com/Masterminds/sprig v2.16.0+incompatible
+	github.com/go-task/slim-sprig v0.0.0-20200516131648-f9bac4e523eb
-	github.com/aokoli/goutils v1.0.1 // indirect
+	github.com/mattn/go-colorable v0.1.2 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/google/uuid v1.0.0 // indirect
-	github.com/huandu/xstrings v1.1.0 // indirect
-	github.com/imdario/mergo v0.3.6 // indirect
 	github.com/mattn/go-zglob v0.0.1
 	github.com/radovskyb/watcher v1.0.5
 	github.com/spf13/pflag v1.0.3
-	github.com/stretchr/testify v1.4.0
+	github.com/stretchr/testify v1.5.1
 	golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e
-	gopkg.in/yaml.v2 v2.2.2
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
-	mvdan.cc/sh/v3 v3.0.0-beta1
+	mvdan.cc/sh/v3 v3.1.1
 )
 
 go 1.13

go.sum

@@ -1,23 +1,29 @@
-github.com/Masterminds/semver v1.4.2 h1:WBLTQ37jOCzSLtXNdoo8bNM8876KhNqOKvrlGITgsTc=
+github.com/creack/pty v1.1.9 h1:uDmaGzcdjhF4i/plgjmEsriH11Y0o7RKapEf/LDaM3w=
-github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/Masterminds/sprig v2.16.0+incompatible h1:QZbMUPxRQ50EKAq3LFMnxddMu88/EUUG3qmxwtDmPsY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/Masterminds/sprig v2.16.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o=
-github.com/aokoli/goutils v1.0.1 h1:7fpzNGoJ3VA8qcrm++XEE1QUe0mIwNeLa02Nwq7RDkg=
-github.com/aokoli/goutils v1.0.1/go.mod h1:SijmP0QR8LtwsmDs8Yii5Z/S4trXFGFC2oO5g9DP+DQ=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/google/uuid v1.0.0 h1:b4Gk+7WdP/d3HZH8EJsZpvV7EtDOgaZLtnaNGIu1adA=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
-github.com/huandu/xstrings v1.1.0 h1:9oZY6Z/H3A1gytJxzuicbmV5QoR8M1TAPcn9WTg7vqg=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/huandu/xstrings v1.1.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63UyNX5k4=
+github.com/go-task/slim-sprig v0.0.0-20200516131648-f9bac4e523eb h1:/qbv1F67s6ehqX9mG23cJOeca3FWpOVKgtPfPUMAi0k=
-github.com/imdario/mergo v0.3.6 h1:xTNEAn+kxVO7dTZGu0CegyqKZmoWFI0rF8UxjlB2d28=
+github.com/go-task/slim-sprig v0.0.0-20200516131648-f9bac4e523eb/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
-github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
+github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-zglob v0.0.1 h1:xsEx/XUoVlI6yXjqBK062zYhRTZltCNmYPx6v+8DNaY=
 github.com/mattn/go-zglob v0.0.1/go.mod h1:9fxibJccNxU2cnpIKLRRFA7zX7qhkJIQWBb449FYHOo=
 github.com/pkg/diff v0.0.0-20190930165518-531926345625/go.mod h1:kFj35MyHn14a6pIgWhm46KVjJr5CHys3eEYxkuKD1EI=
@@ -25,26 +31,25 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/radovskyb/watcher v1.0.5 h1:wqt7gb+HjGacvFoLTKeT44C+XVPxu7bvHvKT1IvZ7rw=
 github.com/radovskyb/watcher v1.0.5/go.mod h1:78okwvY5wPdzcb1UYnip1pvrZNIVEIh/Cm+ZuvsUYIg=
-github.com/rogpeppe/go-internal v1.5.0/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.5.2/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
 github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
-golang.org/x/crypto v0.0.0-20191002192127-34f69633bfdc h1:c0o/qxkaO2LF5t6fQrT4b5hzyggAkLLlCUjqfRxd8Q4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-golang.org/x/crypto v0.0.0-20191002192127-34f69633bfdc/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191008105621-543471e840be h1:QAcqgptGM8IQBC9K/RC4o+O9YmqEm0diQn9QmZw/0mU=
+golang.org/x/sys v0.0.0-20200217220822-9197077df867 h1:JoRuNIf+rpHl+VhScRQQvzbHed86tKkqwPMV34T8myw=
-golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200217220822-9197077df867/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/term v0.0.0-20191110171634-ad39bd3f0407 h1:5zh5atpUEdIc478E/ebrIaHLKcfVvG6dL/fGv7BcMoM=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
+golang.org/x/term v0.0.0-20191110171634-ad39bd3f0407/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
@@ -54,6 +59,8 @@ gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-mvdan.cc/editorconfig v0.1.1-0.20191109213504-890940e3f00e/go.mod h1:Ge4atmRUYqueGppvJ7JNrtqpqokoJEFxYbP0Z+WeKS8=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-mvdan.cc/sh/v3 v3.0.0-beta1 h1:UqiwBEXEPzelaGxuvixaOtzc7WzKtrElePJ8HqvW7K8=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-mvdan.cc/sh/v3 v3.0.0-beta1/go.mod h1:rBIndNJFYPp8xSppiZcGIk6B5d1g3OEARxEaXjPxwVI=
+mvdan.cc/editorconfig v0.1.1-0.20200121172147-e40951bde157/go.mod h1:Ge4atmRUYqueGppvJ7JNrtqpqokoJEFxYbP0Z+WeKS8=
+mvdan.cc/sh/v3 v3.1.1 h1:niuYC5Ug0KzLuN6CNX3ru37v4MkVD5Wm9T4Mk2eJr9A=
+mvdan.cc/sh/v3 v3.1.1/go.mod h1:F+Vm4ZxPJxDKExMLhvjuI50oPnedVXpfjNSrusiTOno=

help.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 	"text/tabwriter"
 
+	"github.com/go-task/task/v2/internal/logger"
 	"github.com/go-task/task/v2/internal/taskfile"
 )
 
@@ -12,10 +13,10 @@ import (
 func (e *Executor) PrintTasksHelp() {
 	tasks := e.tasksWithDesc()
 	if len(tasks) == 0 {
-		e.Logger.Outf("task: No tasks with description available")
+		e.Logger.Outf(logger.Yellow, "task: No tasks with description available")
 		return
 	}
-	e.Logger.Outf("task: Available tasks for this project:")
+	e.Logger.Outf(logger.Default, "task: Available tasks for this project:")
 
 	// Format in tab-separated columns with a tab stop of 8.
 	w := tabwriter.NewWriter(e.Stdout, 0, 8, 0, '\t', 0)
@@ -29,6 +30,10 @@ func (e *Executor) tasksWithDesc() (tasks []*taskfile.Task) {
 	tasks = make([]*taskfile.Task, 0, len(e.Taskfile.Tasks))
 	for _, task := range e.Taskfile.Tasks {
 		if task.Desc != "" {
+			compiledTask, err := e.CompiledTask(taskfile.Call{Task: task.Task})
+			if err == nil {
+				task = compiledTask
+			}
 			tasks = append(tasks, task)
 		}
 	}

init.go

@@ -10,7 +10,7 @@ import (
 
 const defaultTaskfile = `# https://taskfile.dev
 
-version: '2'
+version: '3'
 
 vars:
   GREETING: Hello, World!

internal/args/args.go

@@ -7,9 +7,9 @@ import (
 )
 
 // Parse parses command line argument: tasks and vars of each task
-func Parse(args ...string) ([]taskfile.Call, taskfile.Vars) {
+func Parse(args ...string) ([]taskfile.Call, *taskfile.Vars) {
 	var calls []taskfile.Call
-	var globals taskfile.Vars
+	var globals *taskfile.Vars
 
 	for _, arg := range args {
 		if !strings.Contains(arg, "=") {
@@ -19,18 +19,16 @@ func Parse(args ...string) ([]taskfile.Call, taskfile.Vars) {
 
 		if len(calls) < 1 {
 			if globals == nil {
-				globals = taskfile.Vars{}
+				globals = &taskfile.Vars{}
 			}
-
 			name, value := splitVar(arg)
-			globals[name] = taskfile.Var{Static: value}
+			globals.Set(name, taskfile.Var{Static: value})
 		} else {
 			if calls[len(calls)-1].Vars == nil {
-				calls[len(calls)-1].Vars = make(taskfile.Vars)
+				calls[len(calls)-1].Vars = &taskfile.Vars{}
 			}
-
+			name, value := splitVar(arg)
-			name, value := splitVar((arg))
+			calls[len(calls)-1].Vars.Set(name, taskfile.Var{Static: value})
-			calls[len(calls)-1].Vars[name] = taskfile.Var{Static: value}
 		}
 	}
 

internal/args/args_test.go

@@ -14,7 +14,7 @@ func TestArgs(t *testing.T) {
 	tests := []struct {
 		Args            []string
 		ExpectedCalls   []taskfile.Call
-		ExpectedGlobals taskfile.Vars
+		ExpectedGlobals *taskfile.Vars
 	}{
 		{
 			Args: []string{"task-a", "task-b", "task-c"},
@@ -29,16 +29,22 @@ func TestArgs(t *testing.T) {
 			ExpectedCalls: []taskfile.Call{
 				{
 					Task: "task-a",
-					Vars: taskfile.Vars{
+					Vars: &taskfile.Vars{
-						"FOO": taskfile.Var{Static: "bar"},
+						Keys: []string{"FOO"},
+						Mapping: map[string]taskfile.Var{
+							"FOO": taskfile.Var{Static: "bar"},
+						},
 					},
 				},
 				{Task: "task-b"},
 				{
 					Task: "task-c",
-					Vars: taskfile.Vars{
+					Vars: &taskfile.Vars{
-						"BAR": taskfile.Var{Static: "baz"},
+						Keys: []string{"BAR", "BAZ"},
-						"BAZ": taskfile.Var{Static: "foo"},
+						Mapping: map[string]taskfile.Var{
+							"BAR": taskfile.Var{Static: "baz"},
+							"BAZ": taskfile.Var{Static: "foo"},
+						},
 					},
 				},
 			},
@@ -48,8 +54,11 @@ func TestArgs(t *testing.T) {
 			ExpectedCalls: []taskfile.Call{
 				{
 					Task: "task-a",
-					Vars: taskfile.Vars{
+					Vars: &taskfile.Vars{
-						"CONTENT": taskfile.Var{Static: "with some spaces"},
+						Keys: []string{"CONTENT"},
+						Mapping: map[string]taskfile.Var{
+							"CONTENT": taskfile.Var{Static: "with some spaces"},
+						},
 					},
 				},
 			},
@@ -60,8 +69,11 @@ func TestArgs(t *testing.T) {
 				{Task: "task-a"},
 				{Task: "task-b"},
 			},
-			ExpectedGlobals: taskfile.Vars{
+			ExpectedGlobals: &taskfile.Vars{
-				"FOO": {Static: "bar"},
+				Keys: []string{"FOO"},
+				Mapping: map[string]taskfile.Var{
+					"FOO": {Static: "bar"},
+				},
 			},
 		},
 		{
@@ -81,9 +93,12 @@ func TestArgs(t *testing.T) {
 			ExpectedCalls: []taskfile.Call{
 				{Task: "default"},
 			},
-			ExpectedGlobals: taskfile.Vars{
+			ExpectedGlobals: &taskfile.Vars{
-				"FOO": {Static: "bar"},
+				Keys: []string{"FOO", "BAR"},
-				"BAR": {Static: "baz"},
+				Mapping: map[string]taskfile.Var{
+					"FOO": {Static: "bar"},
+					"BAR": {Static: "baz"},
+				},
 			},
 		},
 	}

internal/compiler/compiler.go

@@ -7,6 +7,6 @@ import (
 // Compiler handles compilation of a task before its execution.
 // E.g. variable merger, template processing, etc.
 type Compiler interface {
-	GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error)
+	GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error)
 	HandleDynamicVar(v taskfile.Var) (string, error)
 }

internal/compiler/env.go

@@ -9,16 +9,12 @@ import (
 
 // GetEnviron the all return all environment variables encapsulated on a
 // taskfile.Vars
-func GetEnviron() taskfile.Vars {
+func GetEnviron() *taskfile.Vars {
-	var (
+	m := &taskfile.Vars{}
-		env = os.Environ()
+	for _, e := range os.Environ() {
-		m   = make(taskfile.Vars, len(env))
-	)
-
-	for _, e := range env {
 		keyVal := strings.SplitN(e, "=", 2)
 		key, val := keyVal[0], keyVal[1]
-		m[key] = taskfile.Var{Static: val}
+		m.Set(key, taskfile.Var{Static: val})
 	}
 	return m
 }

internal/compiler/v1/compiler_v1.go

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

internal/compiler/v2/compiler_v2.go

@@ -19,8 +19,8 @@ var _ compiler.Compiler = &CompilerV2{}
 type CompilerV2 struct {
 	Dir string
 
-	Taskvars     taskfile.Vars
+	Taskvars     *taskfile.Vars
-	TaskfileVars taskfile.Vars
+	TaskfileVars *taskfile.Vars
 
 	Expansions int
 
@@ -36,9 +36,10 @@ type CompilerV2 struct {
 // 3. Taskfile variables
 // 4. Taskvars file variables
 // 5. Environment variables
-func (c *CompilerV2) GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error) {
+func (c *CompilerV2) GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error) {
 	vr := varResolver{c: c, vars: compiler.GetEnviron()}
-	for _, vars := range []taskfile.Vars{c.Taskvars, c.TaskfileVars, call.Vars, t.Vars} {
+	vr.vars.Set("TASK", taskfile.Var{Static: t.Task})
+	for _, vars := range []*taskfile.Vars{c.Taskvars, c.TaskfileVars, call.Vars, t.Vars} {
 		for i := 0; i < c.Expansions; i++ {
 			vr.merge(vars)
 		}
@@ -48,16 +49,16 @@ func (c *CompilerV2) GetVariables(t *taskfile.Task, call taskfile.Call) (taskfil
 
 type varResolver struct {
 	c    *CompilerV2
-	vars taskfile.Vars
+	vars *taskfile.Vars
 	err  error
 }
 
-func (vr *varResolver) merge(vars taskfile.Vars) {
+func (vr *varResolver) merge(vars *taskfile.Vars) {
 	if vr.err != nil {
 		return
 	}
 	tr := templater.Templater{Vars: vr.vars}
-	for k, v := range vars {
+	vars.Range(func(k string, v taskfile.Var) error {
 		v = taskfile.Var{
 			Static: tr.Replace(v.Static),
 			Sh:     tr.Replace(v.Sh),
@@ -65,10 +66,11 @@ func (vr *varResolver) merge(vars taskfile.Vars) {
 		static, err := vr.c.HandleDynamicVar(v)
 		if err != nil {
 			vr.err = err
-			return
+			return err
 		}
-		vr.vars[k] = taskfile.Var{Static: static}
+		vr.vars.Set(k, taskfile.Var{Static: static})
-	}
+		return nil
+	})
 	vr.err = tr.Err()
 }
 
@@ -103,7 +105,7 @@ func (c *CompilerV2) HandleDynamicVar(v taskfile.Var) (string, error) {
 	result := strings.TrimSuffix(stdout.String(), "\n")
 
 	c.dynamicCache[v.Sh] = result
-	c.Logger.VerboseErrf(`task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
+	c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
 
 	return result, nil
 }

internal/compiler/v3/compiler_v3.go

@@ -0,0 +1,98 @@
+package v3
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/go-task/task/v2/internal/compiler"
+	"github.com/go-task/task/v2/internal/execext"
+	"github.com/go-task/task/v2/internal/logger"
+	"github.com/go-task/task/v2/internal/taskfile"
+	"github.com/go-task/task/v2/internal/templater"
+)
+
+var _ compiler.Compiler = &CompilerV3{}
+
+type CompilerV3 struct {
+	Dir string
+
+	TaskfileVars *taskfile.Vars
+
+	Logger *logger.Logger
+
+	dynamicCache   map[string]string
+	muDynamicCache sync.Mutex
+}
+
+func (c *CompilerV3) GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error) {
+	result := compiler.GetEnviron()
+	result.Set("TASK", taskfile.Var{Static: t.Task})
+
+	rangeFunc := func(k string, v taskfile.Var) error {
+		tr := templater.Templater{Vars: result, RemoveNoValue: true}
+		v = taskfile.Var{
+			Static: tr.Replace(v.Static),
+			Sh:     tr.Replace(v.Sh),
+		}
+		if err := tr.Err(); err != nil {
+			return err
+		}
+		static, err := c.HandleDynamicVar(v)
+		if err != nil {
+			return err
+		}
+		result.Set(k, taskfile.Var{Static: static})
+		return nil
+	}
+
+	if err := c.TaskfileVars.Range(rangeFunc); err != nil {
+		return nil, err
+	}
+	if err := call.Vars.Range(rangeFunc); err != nil {
+		return nil, err
+	}
+	if err := t.Vars.Range(rangeFunc); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (c *CompilerV3) HandleDynamicVar(v taskfile.Var) (string, error) {
+	if v.Static != "" || v.Sh == "" {
+		return v.Static, nil
+	}
+
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	if c.dynamicCache == nil {
+		c.dynamicCache = make(map[string]string, 30)
+	}
+	if result, ok := c.dynamicCache[v.Sh]; ok {
+		return result, nil
+	}
+
+	var stdout bytes.Buffer
+	opts := &execext.RunCommandOptions{
+		Command: v.Sh,
+		Dir:     c.Dir,
+		Stdout:  &stdout,
+		Stderr:  c.Logger.Stderr,
+	}
+	if err := execext.RunCommand(context.Background(), opts); err != nil {
+		return "", fmt.Errorf(`task: Command "%s" in taskvars file failed: %s`, opts.Command, err)
+	}
+
+	// Trim a single trailing newline from the result to make most command
+	// output easier to use in shell commands.
+	result := strings.TrimSuffix(stdout.String(), "\n")
+
+	c.dynamicCache[v.Sh] = result
+	c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
+
+	return result, nil
+}

internal/logger/logger.go

@@ -1,38 +1,64 @@
 package logger
 
 import (
-	"fmt"
 	"io"
+
+	"github.com/fatih/color"
 )
 
+type PrintFunc func(io.Writer, string, ...interface{})
+
+var (
+	Default PrintFunc = color.New(color.Reset).FprintfFunc()
+	Blue    PrintFunc = color.New(color.FgBlue).FprintfFunc()
+	Green   PrintFunc = color.New(color.FgGreen).FprintfFunc()
+	Cyan    PrintFunc = color.New(color.FgCyan).FprintfFunc()
+	Yellow  PrintFunc = color.New(color.FgYellow).FprintfFunc()
+	Magenta PrintFunc = color.New(color.FgMagenta).FprintfFunc()
+	Red     PrintFunc = color.New(color.FgRed).FprintfFunc()
+)
+
+// Logger is just a wrapper that prints stuff to STDOUT or STDERR,
+// with optional color.
 type Logger struct {
 	Stdout  io.Writer
 	Stderr  io.Writer
 	Verbose bool
+	Color   bool
 }
 
-func (l *Logger) Outf(s string, args ...interface{}) {
+// Outf prints stuff to STDOUT.
+func (l *Logger) Outf(print PrintFunc, s string, args ...interface{}) {
 	if len(args) == 0 {
 		s, args = "%s", []interface{}{s}
 	}
-	fmt.Fprintf(l.Stdout, s+"\n", args...)
+	if !l.Color {
+		print = Default
+	}
+	print(l.Stdout, s+"\n", args...)
 }
 
-func (l *Logger) VerboseOutf(s string, args ...interface{}) {
+// VerboseOutf prints stuff to STDOUT if verbose mode is enabled.
+func (l *Logger) VerboseOutf(print PrintFunc, s string, args ...interface{}) {
 	if l.Verbose {
-		l.Outf(s, args...)
+		l.Outf(print, s, args...)
 	}
 }
 
-func (l *Logger) Errf(s string, args ...interface{}) {
+// Errf prints stuff to STDERR.
+func (l *Logger) Errf(print PrintFunc, s string, args ...interface{}) {
 	if len(args) == 0 {
 		s, args = "%s", []interface{}{s}
 	}
-	fmt.Fprintf(l.Stderr, s+"\n", args...)
+	if !l.Color {
+		print = Default
+	}
+	print(l.Stderr, s+"\n", args...)
 }
 
-func (l *Logger) VerboseErrf(s string, args ...interface{}) {
+// VerboseErrf prints stuff to STDERR if verbose mode is enabled.
+func (l *Logger) VerboseErrf(print PrintFunc, s string, args ...interface{}) {
 	if l.Verbose {
-		l.Errf(s, args...)
+		l.Errf(print, s, args...)
 	}
 }

internal/status/checksum.go

@@ -23,6 +23,10 @@ type Checksum struct {
 
 // IsUpToDate implements the Checker interface
 func (c *Checksum) IsUpToDate() (bool, error) {
+	if len(c.Sources) == 0 {
+		return false, nil
+	}
+
 	checksumFile := c.checksumFilePath()
 
 	data, _ := ioutil.ReadFile(checksumFile)
@@ -84,11 +88,21 @@ func (c *Checksum) checksum(files ...string) (string, error) {
 	return fmt.Sprintf("%x", h.Sum(nil)), nil
 }
 
+// Value implements the Checker Interface
+func (c *Checksum) Value() (interface{}, error) {
+	return c.checksum()
+}
+
 // OnError implements the Checker interface
 func (c *Checksum) OnError() error {
 	return os.Remove(c.checksumFilePath())
 }
 
+// Kind implements the Checker Interface
+func (*Checksum) Kind() string {
+	return "checksum"
+}
+
 func (c *Checksum) checksumFilePath() string {
 	return filepath.Join(c.Dir, ".task", "checksum", c.normalizeFilename(c.Task))
 }

internal/status/none.go

@@ -8,6 +8,15 @@ func (None) IsUpToDate() (bool, error) {
 	return false, nil
 }
 
+// Value implements the Checker interface
+func (None) Value() (interface{}, error) {
+	return "", nil
+}
+
+func (None) Kind() string {
+	return "none"
+}
+
 // OnError implements the Checker interface
 func (None) OnError() error {
 	return nil

internal/status/status.go

@@ -9,5 +9,7 @@ var (
 // Checker is an interface that checks if the status is up-to-date
 type Checker interface {
 	IsUpToDate() (bool, error)
+	Value() (interface{}, error)
 	OnError() error
+	Kind() string
 }

internal/status/timestamp.go

@@ -41,6 +41,29 @@ func (t *Timestamp) IsUpToDate() (bool, error) {
 	return !generatesMinTime.Before(sourcesMaxTime), nil
 }
 
+func (t *Timestamp) Kind() string {
+	return "timestamp"
+}
+
+// Value implements the Checker Interface
+func (t *Timestamp) Value() (interface{}, error) {
+	sources, err := globs(t.Dir, t.Sources)
+	if err != nil {
+		return time.Now(), err
+	}
+
+	sourcesMaxTime, err := getMaxTime(sources...)
+	if err != nil {
+		return time.Now(), err
+	}
+
+	if sourcesMaxTime.IsZero() {
+		return time.Unix(0, 0), nil
+	}
+
+	return sourcesMaxTime, nil
+}
+
 func getMinTime(files ...string) (time.Time, error) {
 	var t time.Time
 	for _, f := range files {

internal/summary/summary.go

@@ -9,19 +9,19 @@ import (
 
 func PrintTasks(l *logger.Logger, t *taskfile.Taskfile, c []taskfile.Call) {
 	for i, call := range c {
-		printSpaceBetweenSummaries(l, i)
+		PrintSpaceBetweenSummaries(l, i)
 		PrintTask(l, t.Tasks[call.Task])
 	}
 }
 
-func printSpaceBetweenSummaries(l *logger.Logger, i int) {
+func PrintSpaceBetweenSummaries(l *logger.Logger, i int) {
 	spaceRequired := i > 0
 	if !spaceRequired {
 		return
 	}
 
-	l.Outf("")
+	l.Outf(logger.Default, "")
-	l.Outf("")
+	l.Outf(logger.Default, "")
 }
 
 func PrintTask(l *logger.Logger, t *taskfile.Task) {
@@ -50,14 +50,14 @@ func printTaskSummary(l *logger.Logger, t *taskfile.Task) {
 	for i, line := range lines {
 		notLastLine := i+1 < len(lines)
 		if notLastLine || line != "" {
-			l.Outf(line)
+			l.Outf(logger.Default, line)
 		}
 	}
 }
 
 func printTaskName(l *logger.Logger, t *taskfile.Task) {
-	l.Outf("task: %s", t.Task)
+	l.Outf(logger.Default, "task: %s", t.Task)
-	l.Outf("")
+	l.Outf(logger.Default, "")
 }
 
 func hasDescription(t *taskfile.Task) bool {
@@ -65,11 +65,11 @@ func hasDescription(t *taskfile.Task) bool {
 }
 
 func printTaskDescription(l *logger.Logger, t *taskfile.Task) {
-	l.Outf(t.Desc)
+	l.Outf(logger.Default, t.Desc)
 }
 
 func printNoDescriptionOrSummary(l *logger.Logger) {
-	l.Outf("(task does not have description or summary)")
+	l.Outf(logger.Default, "(task does not have description or summary)")
 }
 
 func printTaskDependencies(l *logger.Logger, t *taskfile.Task) {
@@ -77,11 +77,11 @@ func printTaskDependencies(l *logger.Logger, t *taskfile.Task) {
 		return
 	}
 
-	l.Outf("")
+	l.Outf(logger.Default, "")
-	l.Outf("dependencies:")
+	l.Outf(logger.Default, "dependencies:")
 
 	for _, d := range t.Deps {
-		l.Outf(" - %s", d.Task)
+		l.Outf(logger.Default, " - %s", d.Task)
 	}
 }
 
@@ -90,14 +90,14 @@ func printTaskCommands(l *logger.Logger, t *taskfile.Task) {
 		return
 	}
 
-	l.Outf("")
+	l.Outf(logger.Default, "")
-	l.Outf("commands:")
+	l.Outf(logger.Default, "commands:")
 	for _, c := range t.Cmds {
 		isCommand := c.Cmd != ""
 		if isCommand {
-			l.Outf(" - %s", c.Cmd)
+			l.Outf(logger.Default, " - %s", c.Cmd)
 		} else {
-			l.Outf(" - Task: %s", c.Task)
+			l.Outf(logger.Default, " - Task: %s", c.Task)
 		}
 	}
 }

internal/taskfile/call.go

@@ -3,5 +3,5 @@ package taskfile
 // Call is the parameters to a task call
 type Call struct {
 	Task string
-	Vars Vars
+	Vars *Vars
 }

internal/taskfile/cmd.go

@@ -10,14 +10,14 @@ type Cmd struct {
 	Cmd         string
 	Silent      bool
 	Task        string
-	Vars        Vars
+	Vars        *Vars
 	IgnoreError bool
 }
 
 // Dep is a task dependency
 type Dep struct {
 	Task string
-	Vars Vars
+	Vars *Vars
 }
 
 var (
@@ -51,7 +51,7 @@ func (c *Cmd) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	}
 	var taskCall struct {
 		Task string
-		Vars Vars
+		Vars *Vars
 	}
 	if err := unmarshal(&taskCall); err == nil {
 		c.Task = taskCall.Task
@@ -70,7 +70,7 @@ func (d *Dep) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	}
 	var taskCall struct {
 		Task string
-		Vars Vars
+		Vars *Vars
 	}
 	if err := unmarshal(&taskCall); err == nil {
 		d.Task = taskCall.Task

internal/taskfile/included_taskfile.go

@@ -0,0 +1,40 @@
+package taskfile
+
+import "errors"
+
+var (
+	// ErrCantUnmarshalIncludedTaskfile is returned for invalid var YAML.
+	ErrCantUnmarshalIncludedTaskfile = errors.New("task: can't unmarshal included value")
+)
+
+// IncludedTaskfile represents information about included tasksfile
+type IncludedTaskfile struct {
+	Taskfile       string
+	Dir            string
+	AdvancedImport bool
+}
+
+// IncludedTaskfiles represents information about included tasksfiles
+type IncludedTaskfiles = map[string]IncludedTaskfile
+
+// UnmarshalYAML implements yaml.Unmarshaler interface
+func (it *IncludedTaskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var str string
+	if err := unmarshal(&str); err == nil {
+		it.Taskfile = str
+		return nil
+	}
+
+	var includedTaskfile struct {
+		Taskfile string
+		Dir      string
+	}
+	if err := unmarshal(&includedTaskfile); err == nil {
+		it.Dir = includedTaskfile.Dir
+		it.Taskfile = includedTaskfile.Taskfile
+		it.AdvancedImport = true
+		return nil
+	}
+
+	return ErrCantUnmarshalIncludedTaskfile
+}

internal/taskfile/merge.go

@@ -22,25 +22,20 @@ func Merge(t1, t2 *Taskfile, namespaces ...string) error {
 	}
 
 	if t1.Includes == nil {
-		t1.Includes = make(map[string]string)
+		t1.Includes = make(IncludedTaskfiles)
 	}
 	for k, v := range t2.Includes {
 		t1.Includes[k] = v
 	}
 
 	if t1.Vars == nil {
-		t1.Vars = make(Vars)
+		t1.Vars = &Vars{}
 	}
-	for k, v := range t2.Vars {
-		t1.Vars[k] = v
-	}
-
 	if t1.Env == nil {
-		t1.Env = make(Vars)
+		t1.Env = &Vars{}
-	}
-	for k, v := range t2.Env {
-		t1.Env[k] = v
 	}
+	t1.Vars.Merge(t2.Vars)
+	t1.Env.Merge(t2.Env)
 
 	if t1.Tasks == nil {
 		t1.Tasks = make(Tasks)

internal/taskfile/precondition_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/go-task/task/v2/internal/taskfile"
 
 	"github.com/stretchr/testify/assert"
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 func TestPreconditionParse(t *testing.T) {

internal/taskfile/read/taskfile.go

@@ -8,8 +8,9 @@ import (
 	"runtime"
 
 	"github.com/go-task/task/v2/internal/taskfile"
+	"github.com/go-task/task/v2/internal/templater"
 
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 var (
@@ -28,8 +29,30 @@ func Taskfile(dir string, entrypoint string) (*taskfile.Taskfile, error) {
 		return nil, err
 	}
 
-	for namespace, path := range t.Includes {
+	v, err := t.ParsedVersion()
-		path = filepath.Join(dir, path)
+	if err != nil {
+		return nil, err
+	}
+
+	for namespace, includedTask := range t.Includes {
+		if v >= 3.0 {
+			tr := templater.Templater{Vars: &taskfile.Vars{}, RemoveNoValue: true}
+			includedTask = taskfile.IncludedTaskfile{
+				Taskfile:       tr.Replace(includedTask.Taskfile),
+				Dir:            tr.Replace(includedTask.Dir),
+				AdvancedImport: includedTask.AdvancedImport,
+			}
+			if err := tr.Err(); err != nil {
+				return nil, err
+			}
+		}
+
+		if filepath.IsAbs(includedTask.Taskfile) {
+			path = includedTask.Taskfile
+		} else {
+			path = filepath.Join(dir, includedTask.Taskfile)
+		}
+
 		info, err := os.Stat(path)
 		if err != nil {
 			return nil, err
@@ -44,19 +67,30 @@ func Taskfile(dir string, entrypoint string) (*taskfile.Taskfile, error) {
 		if len(includedTaskfile.Includes) > 0 {
 			return nil, ErrIncludedTaskfilesCantHaveIncludes
 		}
+
+		if includedTask.AdvancedImport {
+			for _, task := range includedTaskfile.Tasks {
+				if !filepath.IsAbs(task.Dir) {
+					task.Dir = filepath.Join(includedTask.Dir, task.Dir)
+				}
+			}
+		}
+
 		if err = taskfile.Merge(t, includedTaskfile, namespace); err != nil {
 			return nil, err
 		}
 	}
 
-	path = filepath.Join(dir, fmt.Sprintf("Taskfile_%s.yml", runtime.GOOS))
+	if v < 3.0 {
-	if _, err = os.Stat(path); err == nil {
+		path = filepath.Join(dir, fmt.Sprintf("Taskfile_%s.yml", runtime.GOOS))
-		osTaskfile, err := readTaskfile(path)
+		if _, err = os.Stat(path); err == nil {
-		if err != nil {
+			osTaskfile, err := readTaskfile(path)
-			return nil, err
+			if err != nil {
-		}
+				return nil, err
-		if err = taskfile.Merge(t, osTaskfile); err != nil {
+			}
-			return nil, err
+			if err = taskfile.Merge(t, osTaskfile); err != nil {
+				return nil, err
+			}
 		}
 	}
 

internal/taskfile/read/taskvars.go

@@ -8,12 +8,12 @@ import (
 
 	"github.com/go-task/task/v2/internal/taskfile"
 
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 // Taskvars reads a Taskvars for a given directory
-func Taskvars(dir string) (taskfile.Vars, error) {
+func Taskvars(dir string) (*taskfile.Vars, error) {
-	vars := make(taskfile.Vars)
+	vars := &taskfile.Vars{}
 
 	path := filepath.Join(dir, "Taskvars.yml")
 	if _, err := os.Stat(path); err == nil {
@@ -29,24 +29,17 @@ func Taskvars(dir string) (taskfile.Vars, error) {
 		if err != nil {
 			return nil, err
 		}
-
+		vars.Merge(osVars)
-		if vars == nil {
-			vars = osVars
-		} else {
-			for k, v := range osVars {
-				vars[k] = v
-			}
-		}
 	}
 
 	return vars, nil
 }
 
-func readTaskvars(file string) (taskfile.Vars, error) {
+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)
+	return &vars, yaml.NewDecoder(f).Decode(&vars)
 }

internal/taskfile/task.go

@@ -1,24 +1,86 @@
 package taskfile
 
+import (
+	"errors"
+)
+
 // Tasks represents a group of tasks
 type Tasks map[string]*Task
 
 // Task represents a task
 type Task struct {
-	Task         string
+	Task          string
-	Cmds         []*Cmd
+	Cmds          []*Cmd
-	Deps         []*Dep
+	Deps          []*Dep
-	Desc         string
+	Desc          string
-	Summary      string
+	Summary       string
-	Sources      []string
+	Sources       []string
-	Generates    []string
+	Generates     []string
-	Status       []string
+	Status        []string
 	Preconditions []*Precondition
-	Dir          string
+	Dir           string
-	Vars         Vars
+	Vars          *Vars
-	Env          Vars
+	Env           *Vars
-	Silent       bool
+	Silent        bool
-	Method       string
+	Method        string
-	Prefix       string
+	Prefix        string
-	IgnoreError  bool `yaml:"ignore_error"`
+	IgnoreError   bool
+}
+
+var (
+	// ErrCantUnmarshalTask is returned for invalid task YAML
+	ErrCantUnmarshalTask = errors.New("task: can't unmarshal task value")
+)
+
+func (t *Task) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var cmd Cmd
+	if err := unmarshal(&cmd); err == nil && cmd.Cmd != "" {
+		t.Cmds = append(t.Cmds, &cmd)
+		return nil
+	}
+
+	var cmds []*Cmd
+	if err := unmarshal(&cmds); err == nil && len(cmds) > 0 {
+		t.Cmds = cmds
+		return nil
+	}
+
+	var task struct {
+		Cmds          []*Cmd
+		Deps          []*Dep
+		Desc          string
+		Summary       string
+		Sources       []string
+		Generates     []string
+		Status        []string
+		Preconditions []*Precondition
+		Dir           string
+		Vars          *Vars
+		Env           *Vars
+		Silent        bool
+		Method        string
+		Prefix        string
+		IgnoreError   bool `yaml:"ignore_error"`
+	}
+	if err := unmarshal(&task); err == nil {
+		t.Cmds = task.Cmds
+		t.Deps = task.Deps
+		t.Desc = task.Desc
+		t.Summary = task.Summary
+		t.Sources = task.Sources
+		t.Generates = task.Generates
+		t.Status = task.Status
+		t.Preconditions = task.Preconditions
+		t.Dir = task.Dir
+		t.Vars = task.Vars
+		t.Env = task.Env
+		t.Silent = task.Silent
+		t.Method = task.Method
+		t.Prefix = task.Prefix
+		t.IgnoreError = task.IgnoreError
+
+		return nil
+	}
+
+	return ErrCantUnmarshalTask
 }

internal/taskfile/taskfile.go

@@ -1,31 +1,33 @@
 package taskfile
 
+import (
+	"fmt"
+	"strconv"
+)
+
 // Taskfile represents a Taskfile.yml
 type Taskfile struct {
 	Version    string
 	Expansions int
 	Output     string
-	Includes   map[string]string
+	Method     string
-	Vars       Vars
+	Includes   IncludedTaskfiles
-	Env        Vars
+	Vars       *Vars
+	Env        *Vars
 	Tasks      Tasks
 	Silent     bool
 }
 
 // UnmarshalYAML implements yaml.Unmarshaler interface
 func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	if err := unmarshal(&tf.Tasks); err == nil {
-		tf.Version = "1"
-		return nil
-	}
-
 	var taskfile struct {
 		Version    string
 		Expansions int
 		Output     string
-		Includes   map[string]string
+		Method     string
-		Vars       Vars
+		Includes   IncludedTaskfiles
-		Env        Vars
+		Vars       *Vars
+		Env        *Vars
 		Tasks      Tasks
 		Silent     bool
 	}
@@ -35,6 +37,7 @@ func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	tf.Version = taskfile.Version
 	tf.Expansions = taskfile.Expansions
 	tf.Output = taskfile.Output
+	tf.Method = taskfile.Method
 	tf.Includes = taskfile.Includes
 	tf.Vars = taskfile.Vars
 	tf.Env = taskfile.Env
@@ -44,7 +47,19 @@ func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
 		tf.Expansions = 2
 	}
 	if tf.Vars == nil {
-		tf.Vars = make(Vars)
+		tf.Vars = &Vars{}
+	}
+	if tf.Env == nil {
+		tf.Env = &Vars{}
 	}
 	return nil
 }
+
+// ParsedVersion returns the version as a float64
+func (tf *Taskfile) ParsedVersion() (float64, error) {
+	v, err := strconv.ParseFloat(tf.Version, 64)
+	if err != nil {
+		return 0, fmt.Errorf(`task: Could not parse taskfile version "%s": %v`, tf.Version, err)
+	}
+	return v, nil
+}

internal/taskfile/taskfile_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/go-task/task/v2/internal/taskfile"
 
 	"github.com/stretchr/testify/assert"
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 func TestCmdParse(t *testing.T) {
@@ -33,9 +33,12 @@ vars:
 		{
 			yamlTaskCall,
 			&taskfile.Cmd{},
-			&taskfile.Cmd{Task: "another-task", Vars: taskfile.Vars{
+			&taskfile.Cmd{Task: "another-task", Vars: &taskfile.Vars{
-				"PARAM1": taskfile.Var{Static: "VALUE1"},
+				Keys: []string{"PARAM1", "PARAM2"},
-				"PARAM2": taskfile.Var{Static: "VALUE2"},
+				Mapping: map[string]taskfile.Var{
+					"PARAM1": taskfile.Var{Static: "VALUE1"},
+					"PARAM2": taskfile.Var{Static: "VALUE2"},
+				},
 			}},
 		},
 		{
@@ -46,9 +49,12 @@ vars:
 		{
 			yamlTaskCall,
 			&taskfile.Dep{},
-			&taskfile.Dep{Task: "another-task", Vars: taskfile.Vars{
+			&taskfile.Dep{Task: "another-task", Vars: &taskfile.Vars{
-				"PARAM1": taskfile.Var{Static: "VALUE1"},
+				Keys: []string{"PARAM1", "PARAM2"},
-				"PARAM2": taskfile.Var{Static: "VALUE2"},
+				Mapping: map[string]taskfile.Var{
+					"PARAM1": taskfile.Var{Static: "VALUE1"},
+					"PARAM2": taskfile.Var{Static: "VALUE2"},
+				},
 			}},
 		},
 	}

internal/taskfile/var.go

@@ -3,6 +3,8 @@ package taskfile
 import (
 	"errors"
 	"strings"
+
+	"gopkg.in/yaml.v3"
 )
 
 var (
@@ -11,26 +13,99 @@ var (
 )
 
 // Vars is a string[string] variables map.
-type Vars map[string]Var
+type Vars struct {
+	Keys    []string
+	Mapping map[string]Var
+}
 
-// ToStringMap converts Vars to a string map containing only the static
+// UnmarshalYAML implements the yaml.Unmarshaler interface.
+func (vs *Vars) UnmarshalYAML(node *yaml.Node) error {
+	if node.Kind != yaml.MappingNode {
+		return errors.New("task: vars is not a map")
+	}
+
+	// NOTE(@andreynering): on this style of custom unmarsheling,
+	// even number contains the keys, while odd numbers contains
+	// the values.
+	for i := 0; i < len(node.Content); i += 2 {
+		keyNode := node.Content[i]
+		valueNode := node.Content[i+1]
+
+		var v Var
+		if err := valueNode.Decode(&v); err != nil {
+			return err
+		}
+		vs.Set(keyNode.Value, v)
+	}
+	return nil
+}
+
+// Merge merges the given Vars into the caller one
+func (vs *Vars) Merge(other *Vars) {
+	other.Range(func(key string, value Var) error {
+		vs.Set(key, value)
+		return nil
+	})
+}
+
+// Set sets a value to a given key
+func (vs *Vars) Set(key string, value Var) {
+	if vs.Mapping == nil {
+		vs.Mapping = make(map[string]Var, 1)
+	}
+	if !strSliceContains(vs.Keys, key) {
+		vs.Keys = append(vs.Keys, key)
+	}
+	vs.Mapping[key] = value
+}
+
+func strSliceContains(s []string, str string) bool {
+	for _, v := range s {
+		if v == str {
+			return true
+		}
+	}
+	return false
+}
+
+// Range allows you to loop into the vars in its right order
+func (vs *Vars) Range(yield func(key string, value Var) error) error {
+	if vs == nil {
+		return nil
+	}
+	for _, k := range vs.Keys {
+		if err := yield(k, vs.Mapping[k]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ToCacheMap converts Vars to a map containing only the static
 // variables
-func (vs Vars) ToStringMap() (m map[string]string) {
+func (vs *Vars) ToCacheMap() (m map[string]interface{}) {
-	m = make(map[string]string, len(vs))
+	m = make(map[string]interface{}, len(vs.Keys))
-	for k, v := range vs {
+	vs.Range(func(k string, v Var) error {
 		if v.Sh != "" {
 			// Dynamic variable is not yet resolved; trigger
 			// <no value> to be used in templates.
-			continue
+			return nil
 		}
-		m[k] = v.Static
+
-	}
+		if v.Live != nil {
+			m[k] = v.Live
+		} else {
+			m[k] = v.Static
+		}
+		return nil
+	})
 	return
 }
 
 // Var represents either a static or dynamic variable.
 type Var struct {
 	Static string
+	Live   interface{}
 	Sh     string
 }
 

internal/templater/funcs.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/Masterminds/sprig"
+	"github.com/go-task/slim-sprig"
 )
 
 var (

internal/templater/templater.go

@@ -2,6 +2,7 @@ package templater
 
 import (
 	"bytes"
+	"strings"
 	"text/template"
 
 	"github.com/go-task/task/v2/internal/taskfile"
@@ -12,10 +13,15 @@ import (
 // happen will be assigned to r.err, and consecutive calls to funcs will just
 // return the zero value.
 type Templater struct {
-	Vars taskfile.Vars
+	Vars          *taskfile.Vars
+	RemoveNoValue bool
 
-	strMap map[string]string
+	cacheMap map[string]interface{}
-	err    error
+	err      error
+}
+
+func (r *Templater) ResetCache() {
+	r.cacheMap = r.Vars.ToCacheMap()
 }
 
 func (r *Templater) Replace(str string) string {
@@ -29,15 +35,18 @@ func (r *Templater) Replace(str string) string {
 		return ""
 	}
 
-	if r.strMap == nil {
+	if r.cacheMap == nil {
-		r.strMap = r.Vars.ToStringMap()
+		r.cacheMap = r.Vars.ToCacheMap()
 	}
 
 	var b bytes.Buffer
-	if err = templ.Execute(&b, r.strMap); err != nil {
+	if err = templ.Execute(&b, r.cacheMap); err != nil {
 		r.err = err
 		return ""
 	}
+	if r.RemoveNoValue {
+		return strings.ReplaceAll(b.String(), "<no value>", "")
+	}
 	return b.String()
 }
 
@@ -53,19 +62,22 @@ func (r *Templater) ReplaceSlice(strs []string) []string {
 	return new
 }
 
-func (r *Templater) ReplaceVars(vars taskfile.Vars) taskfile.Vars {
+func (r *Templater) ReplaceVars(vars *taskfile.Vars) *taskfile.Vars {
-	if r.err != nil || len(vars) == 0 {
+	if r.err != nil || vars == nil || len(vars.Keys) == 0 {
 		return nil
 	}
 
-	new := make(taskfile.Vars, len(vars))
+	var new taskfile.Vars
-	for k, v := range vars {
+	vars.Range(func(k string, v taskfile.Var) error {
-		new[k] = taskfile.Var{
+		new.Set(k, taskfile.Var{
 			Static: r.Replace(v.Static),
+			Live:   v.Live,
 			Sh:     r.Replace(v.Sh),
-		}
+		})
-	}
+		return nil
-	return new
+	})
+
+	return &new
 }
 
 func (r *Templater) Err() error {

precondition.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 
 	"github.com/go-task/task/v2/internal/execext"
+	"github.com/go-task/task/v2/internal/logger"
 	"github.com/go-task/task/v2/internal/taskfile"
 )
 
@@ -22,7 +23,7 @@ func (e *Executor) areTaskPreconditionsMet(ctx context.Context, t *taskfile.Task
 		})
 
 		if err != nil {
-			e.Logger.Errf("task: %s", p.Msg)
+			e.Logger.Errf(logger.Magenta, "task: %s", p.Msg)
 			return false, ErrPreconditionFailed
 		}
 	}

status.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/go-task/task/v2/internal/execext"
+	"github.com/go-task/task/v2/internal/logger"
 	"github.com/go-task/task/v2/internal/status"
 	"github.com/go-task/task/v2/internal/taskfile"
 )
@@ -49,25 +50,37 @@ func (e *Executor) statusOnError(t *taskfile.Task) error {
 }
 
 func (e *Executor) getStatusChecker(t *taskfile.Task) (status.Checker, error) {
-	switch t.Method {
+	method := t.Method
-	case "", "timestamp":
+	if method == "" {
-		return &status.Timestamp{
+		method = e.Taskfile.Method
-			Dir:       t.Dir,
+	}
-			Sources:   t.Sources,
+	switch method {
-			Generates: t.Generates,
+	case "timestamp":
-		}, nil
+		return e.timestampChecker(t), nil
 	case "checksum":
-		return &status.Checksum{
+		return e.checksumChecker(t), nil
-			Dir:       t.Dir,
-			Task:      t.Task,
-			Sources:   t.Sources,
-			Generates: t.Generates,
-			Dry:       e.Dry,
-		}, nil
 	case "none":
 		return status.None{}, nil
 	default:
-		return nil, fmt.Errorf(`task: invalid method "%s"`, t.Method)
+		return nil, fmt.Errorf(`task: invalid method "%s"`, method)
+	}
+}
+
+func (e *Executor) timestampChecker(t *taskfile.Task) status.Checker {
+	return &status.Timestamp{
+		Dir:       t.Dir,
+		Sources:   t.Sources,
+		Generates: t.Generates,
+	}
+}
+
+func (e *Executor) checksumChecker(t *taskfile.Task) status.Checker {
+	return &status.Checksum{
+		Dir:       t.Dir,
+		Task:      t.Task,
+		Sources:   t.Sources,
+		Generates: t.Generates,
+		Dry:       e.Dry,
 	}
 }
 
@@ -79,10 +92,10 @@ func (e *Executor) isTaskUpToDateStatus(ctx context.Context, t *taskfile.Task) (
 			Env:     getEnviron(t),
 		})
 		if err != nil {
-			e.Logger.VerboseOutf("task: status command %s exited non-zero: %s", s, err)
+			e.Logger.VerboseOutf(logger.Yellow, "task: status command %s exited non-zero: %s", s, err)
 			return false, nil
 		}
-		e.Logger.VerboseOutf("task: status command %s exited zero", s)
+		e.Logger.VerboseOutf(logger.Yellow, "task: status command %s exited zero", s)
 	}
 	return true, nil
 }

task.go

@@ -6,13 +6,12 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"strconv"
 	"sync"
 	"sync/atomic"
 
 	"github.com/go-task/task/v2/internal/compiler"
-	compilerv1 "github.com/go-task/task/v2/internal/compiler/v1"
 	compilerv2 "github.com/go-task/task/v2/internal/compiler/v2"
+	compilerv3 "github.com/go-task/task/v2/internal/compiler/v3"
 	"github.com/go-task/task/v2/internal/execext"
 	"github.com/go-task/task/v2/internal/logger"
 	"github.com/go-task/task/v2/internal/output"
@@ -42,6 +41,7 @@ type Executor struct {
 	Dry        bool
 	Summary    bool
 	Parallel   bool
+	Color      bool
 
 	Stdin  io.Reader
 	Stdout io.Writer
@@ -52,7 +52,7 @@ type Executor struct {
 	Output      output.Output
 	OutputStyle string
 
-	taskvars taskfile.Vars
+	taskvars *taskfile.Vars
 
 	taskCallCount map[string]*int32
 	mkdirMutexMap map[string]*sync.Mutex
@@ -70,7 +70,14 @@ func (e *Executor) Run(ctx context.Context, calls ...taskfile.Call) error {
 	}
 
 	if e.Summary {
-		summary.PrintTasks(e.Logger, e.Taskfile, calls)
+		for i, c := range calls {
+			compiledTask, err := e.CompiledTask(c)
+			if err != nil {
+				return nil
+			}
+			summary.PrintSpaceBetweenSummaries(e.Logger, i)
+			summary.PrintTask(e.Logger, compiledTask)
+		}
 		return nil
 	}
 
@@ -103,11 +110,19 @@ func (e *Executor) Setup() error {
 	if err != nil {
 		return err
 	}
-	e.taskvars, err = read.Taskvars(e.Dir)
+
+	v, err := e.Taskfile.ParsedVersion()
 	if err != nil {
 		return err
 	}
 
+	if v < 3.0 {
+		e.taskvars, err = read.Taskvars(e.Dir)
+		if err != nil {
+			return err
+		}
+	}
+
 	if e.Stdin == nil {
 		e.Stdin = os.Stdin
 	}
@@ -121,31 +136,28 @@ func (e *Executor) Setup() error {
 		Stdout:  e.Stdout,
 		Stderr:  e.Stderr,
 		Verbose: e.Verbose,
+		Color:   e.Color,
 	}
 
-	v, err := strconv.ParseFloat(e.Taskfile.Version, 64)
+	if v < 2 {
-	if err != nil {
+		return fmt.Errorf(`task: Taskfile versions prior to v2 are not supported anymore`)
-		return fmt.Errorf(`task: Could not parse taskfile version "%s": %v`, e.Taskfile.Version, err)
 	}
+
 	// consider as equal to the greater version if round
 	if v == 2.0 {
 		v = 2.6
 	}
 
-	if v < 1 {
+	if v > 3.0 {
-		return fmt.Errorf(`task: Taskfile version should be greater or equal to v1`)
+		return fmt.Errorf(`task: Taskfile versions greater than v3.0 not implemented in the version of Task`)
-	}
-	if v > 2.6 {
-		return fmt.Errorf(`task: Taskfile versions greater than v2.6 not implemented in the version of Task`)
 	}
 
-	if v < 2 {
+	// Color available only on v3
-		e.Compiler = &compilerv1.CompilerV1{
+	if v < 3 {
-			Dir:    e.Dir,
+		e.Logger.Color = false
-			Vars:   e.taskvars,
+	}
-			Logger: e.Logger,
+
-		}
+	if v < 3 {
-	} else { // v >= 2
 		e.Compiler = &compilerv2.CompilerV2{
 			Dir:          e.Dir,
 			Taskvars:     e.taskvars,
@@ -153,6 +165,12 @@ func (e *Executor) Setup() error {
 			Expansions:   e.Taskfile.Expansions,
 			Logger:       e.Logger,
 		}
+	} else {
+		e.Compiler = &compilerv3.CompilerV3{
+			Dir:          e.Dir,
+			TaskfileVars: e.Taskfile.Vars,
+			Logger:       e.Logger,
+		}
 	}
 
 	if v < 2.1 && e.Taskfile.Output != "" {
@@ -161,6 +179,9 @@ func (e *Executor) Setup() error {
 	if v < 2.2 && len(e.Taskfile.Includes) > 0 {
 		return fmt.Errorf(`task: Including Taskfiles is only available starting on Taskfile version v2.2`)
 	}
+	if v >= 3.0 && e.Taskfile.Expansions > 2 {
+		return fmt.Errorf(`task: The "expansions" setting is not available anymore on v3.0`)
+	}
 
 	if e.OutputStyle != "" {
 		e.Taskfile.Output = e.OutputStyle
@@ -176,6 +197,14 @@ func (e *Executor) Setup() error {
 		return fmt.Errorf(`task: output option "%s" not recognized`, e.Taskfile.Output)
 	}
 
+	if e.Taskfile.Method == "" {
+		if v >= 3 {
+			e.Taskfile.Method = "checksum"
+		} else {
+			e.Taskfile.Method = "timestamp"
+		}
+	}
+
 	if v <= 2.1 {
 		err := errors.New(`task: Taskfile option "ignore_error" is only available starting on Taskfile version v2.1`)
 
@@ -199,6 +228,14 @@ func (e *Executor) Setup() error {
 		}
 	}
 
+	if v < 3 {
+		for _, taskfile := range e.Taskfile.Includes {
+			if taskfile.AdvancedImport {
+				return errors.New(`task: Import with additional parameters is only available starting on Taskfile version v3`)
+			}
+		}
+	}
+
 	e.taskCallCount = make(map[string]*int32, len(e.Taskfile.Tasks))
 	e.mkdirMutexMap = make(map[string]*sync.Mutex, len(e.Taskfile.Tasks))
 	for k := range e.Taskfile.Tasks {
@@ -235,24 +272,24 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 
 		if upToDate && preCondMet {
 			if !e.Silent {
-				e.Logger.Errf(`task: Task "%s" is up to date`, t.Task)
+				e.Logger.Errf(logger.Magenta, `task: Task "%s" is up to date`, t.Task)
 			}
 			return nil
 		}
 	}
 
 	if err := e.mkdir(t); err != nil {
-		e.Logger.Errf("task: cannot make directory %q: %v", t.Dir, err)
+		e.Logger.Errf(logger.Red, "task: cannot make directory %q: %v", t.Dir, err)
 	}
 
 	for i := range t.Cmds {
 		if err := e.runCommand(ctx, t, call, i); err != nil {
 			if err2 := e.statusOnError(t); err2 != nil {
-				e.Logger.VerboseErrf("task: error cleaning status on error: %v", err2)
+				e.Logger.VerboseErrf(logger.Yellow, "task: error cleaning status on error: %v", err2)
 			}
 
 			if execext.IsExitError(err) && t.IgnoreError {
-				e.Logger.VerboseErrf("task: task error ignored: %v", err)
+				e.Logger.VerboseErrf(logger.Yellow, "task: task error ignored: %v", err)
 				continue
 			}
 
@@ -309,7 +346,7 @@ func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfi
 		return nil
 	case cmd.Cmd != "":
 		if e.Verbose || (!cmd.Silent && !t.Silent && !e.Taskfile.Silent && !e.Silent) {
-			e.Logger.Errf(cmd.Cmd)
+			e.Logger.Errf(logger.Green, "task: %s", cmd.Cmd)
 		}
 
 		if e.Dry {
@@ -340,7 +377,7 @@ func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfi
 			Stderr:  stdErr,
 		})
 		if execext.IsExitError(err) && cmd.IgnoreError {
-			e.Logger.VerboseErrf("task: command error ignored: %v", err)
+			e.Logger.VerboseErrf(logger.Yellow, "task: command error ignored: %v", err)
 			return nil
 		}
 		return err
@@ -355,8 +392,10 @@ func getEnviron(t *taskfile.Task) []string {
 	}
 
 	environ := os.Environ()
-	for k, v := range t.Env.ToStringMap() {
+	for k, v := range t.Env.ToCacheMap() {
-		environ = append(environ, fmt.Sprintf("%s=%s", k, v))
+		if s, ok := v.(string); ok {
+			environ = append(environ, fmt.Sprintf("%s=%s", k, s))
+		}
 	}
 	return environ
 }

task_test.go

@@ -69,43 +69,6 @@ func TestEnv(t *testing.T) {
 	tt.Run(t)
 }
 
-func TestVarsV1(t *testing.T) {
-	tt := fileContentTest{
-		Dir:       "testdata/vars/v1",
-		Target:    "default",
-		TrimSpace: true,
-		Files: map[string]string{
-			// hello task:
-			"foo.txt":              "foo",
-			"bar.txt":              "bar",
-			"baz.txt":              "baz",
-			"tmpl_foo.txt":         "foo",
-			"tmpl_bar.txt":         "<no value>",
-			"tmpl_foo2.txt":        "foo2",
-			"tmpl_bar2.txt":        "bar2",
-			"shtmpl_foo.txt":       "foo",
-			"shtmpl_foo2.txt":      "foo2",
-			"nestedtmpl_foo.txt":   "{{.FOO}}",
-			"nestedtmpl_foo2.txt":  "foo2",
-			"foo2.txt":             "foo2",
-			"bar2.txt":             "bar2",
-			"baz2.txt":             "baz2",
-			"tmpl2_foo.txt":        "<no value>",
-			"tmpl2_foo2.txt":       "foo2",
-			"tmpl2_bar.txt":        "<no value>",
-			"tmpl2_bar2.txt":       "<no value>",
-			"shtmpl2_foo.txt":      "<no value>",
-			"shtmpl2_foo2.txt":     "foo2",
-			"nestedtmpl2_foo2.txt": "{{.FOO2}}",
-			"override.txt":         "bar",
-		},
-	}
-	tt.Run(t)
-	// Ensure identical results when running hello task directly.
-	tt.Target = "hello"
-	tt.Run(t)
-}
-
 func TestVarsV2(t *testing.T) {
 	tt := fileContentTest{
 		Dir:       "testdata/vars/v2",
@@ -135,6 +98,7 @@ func TestVarsV2(t *testing.T) {
 			"nestedtmpl2_foo2.txt": "<no value>",
 			"override.txt":         "bar",
 			"nested.txt":           "Taskvars-TaskfileVars-TaskVars",
+			"task_name.txt":        "hello",
 		},
 	}
 	tt.Run(t)
@@ -143,8 +107,22 @@ func TestVarsV2(t *testing.T) {
 	tt.Run(t)
 }
 
+func TestVarsV3(t *testing.T) {
+	tt := fileContentTest{
+		Dir:    "testdata/vars/v3",
+		Target: "default",
+		Files: map[string]string{
+			"missing-var.txt":  "\n",
+			"var-order.txt":    "ABCDEF\n",
+			"dependent-sh.txt": "123456\n",
+			"with-call.txt":    "Hi, ABC123!\n",
+		},
+	}
+	tt.Run(t)
+}
+
 func TestMultilineVars(t *testing.T) {
-	for _, dir := range []string{"testdata/vars/v1/multiline", "testdata/vars/v2/multiline"} {
+	for _, dir := range []string{"testdata/vars/v2/multiline"} {
 		tt := fileContentTest{
 			Dir:       dir,
 			Target:    "default",
@@ -168,7 +146,7 @@ func TestMultilineVars(t *testing.T) {
 
 func TestVarsInvalidTmpl(t *testing.T) {
 	const (
-		dir         = "testdata/vars/v1"
+		dir         = "testdata/vars/v2"
 		target      = "invalid-var-tmpl"
 		expectError = "template: :1: unexpected EOF"
 	)
@@ -406,6 +384,34 @@ func TestStatusChecksum(t *testing.T) {
 	assert.Equal(t, `task: Task "build" is up to date`+"\n", buff.String())
 }
 
+func TestStatusVariables(t *testing.T) {
+	const dir = "testdata/status_vars"
+
+	_ = os.RemoveAll(filepath.Join(dir, ".task"))
+	_ = os.Remove(filepath.Join(dir, "generated.txt"))
+
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:     dir,
+		Stdout:  &buff,
+		Stderr:  &buff,
+		Silent:  false,
+		Verbose: true,
+	}
+	assert.NoError(t, e.Setup())
+	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "build"}))
+
+	assert.Contains(t, buff.String(), "d41d8cd98f00b204e9800998ecf8427e")
+
+	inf, err := os.Stat(filepath.Join(dir, "source.txt"))
+	assert.NoError(t, err)
+	ts := fmt.Sprintf("%d", inf.ModTime().Unix())
+	tf := fmt.Sprintf("%s", inf.ModTime())
+
+	assert.Contains(t, buff.String(), ts)
+	assert.Contains(t, buff.String(), tf)
+}
+
 func TestInit(t *testing.T) {
 	const dir = "testdata/init"
 	var file = filepath.Join(dir, "Taskfile.yml")
@@ -441,7 +447,6 @@ func TestTaskVersion(t *testing.T) {
 		Dir     string
 		Version string
 	}{
-		{"testdata/version/v1", "1"},
 		{"testdata/version/v2", "2"},
 	}
 
@@ -511,7 +516,7 @@ func TestDry(t *testing.T) {
 	assert.NoError(t, e.Setup())
 	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "build"}))
 
-	assert.Equal(t, "touch file.txt", strings.TrimSpace(buff.String()))
+	assert.Equal(t, "task: touch file.txt", strings.TrimSpace(buff.String()))
 	if _, err := os.Stat(file); err == nil {
 		t.Errorf("File should not exist %s", file)
 	}
@@ -549,14 +554,33 @@ func TestIncludes(t *testing.T) {
 		Target:    "default",
 		TrimSpace: true,
 		Files: map[string]string{
-			"main.txt":               "main",
+			"main.txt":                                  "main",
-			"included_directory.txt": "included_directory",
+			"included_directory.txt":                    "included_directory",
-			"included_taskfile.txt":  "included_taskfile",
+			"included_directory_without_dir.txt":        "included_directory_without_dir",
+			"included_taskfile_without_dir.txt":         "included_taskfile_without_dir",
+			"./module2/included_directory_with_dir.txt": "included_directory_with_dir",
+			"./module2/included_taskfile_with_dir.txt":  "included_taskfile_with_dir",
+			"os_include.txt":                            "os",
 		},
 	}
 	tt.Run(t)
 }
 
+func TestIncorrectVersionIncludes(t *testing.T) {
+	const dir = "testdata/incorrect_includes"
+	expectedError := "task: Import with additional parameters is only available starting on Taskfile version v3"
+
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+		Silent: true,
+	}
+
+	assert.EqualError(t, e.Setup(), expectedError)
+}
+
 func TestIncludesEmptyMain(t *testing.T) {
 	tt := fileContentTest{
 		Dir:       "testdata/includes_empty",
@@ -668,7 +692,7 @@ func TestWhenDirAttributeItCreatesMissingAndRunsInThatDir(t *testing.T) {
 	}
 
 	// Ensure that the directory to be created doesn't actually exist.
-	_ = os.Remove(toBeCreated)
+	_ = os.RemoveAll(toBeCreated)
 	if _, err := os.Stat(toBeCreated); err == nil {
 		t.Errorf("Directory should not exist: %v", err)
 	}
@@ -679,5 +703,32 @@ func TestWhenDirAttributeItCreatesMissingAndRunsInThatDir(t *testing.T) {
 	assert.Equal(t, expected, got, "Mismatch in the working directory")
 
 	// Clean-up after ourselves only if no error.
-	_ = os.Remove(toBeCreated)
+	_ = os.RemoveAll(toBeCreated)
+}
+
+func TestDisplaysErrorOnUnsupportedVersion(t *testing.T) {
+	e := task.Executor{
+		Dir:    "testdata/version/v1",
+		Stdout: ioutil.Discard,
+		Stderr: ioutil.Discard,
+	}
+	err := e.Setup()
+	assert.Error(t, err)
+	assert.Equal(t, "task: Taskfile versions prior to v2 are not supported anymore", err.Error())
+
+}
+
+func TestShortTaskNotation(t *testing.T) {
+	const dir = "testdata/short_task_notation"
+
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+		Silent: true,
+	}
+	assert.NoError(t, e.Setup())
+	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "default"}))
+	assert.Equal(t, "string-slice-1\nstring-slice-2\nstring\n", buff.String())
 }

testdata/checksum/Taskfile.yml

@@ -1,9 +1,12 @@
-build:
+version: '3'
-  cmds:
+
-    - cp ./source.txt ./generated.txt
+tasks:
-  sources:
+  build:
-    - ./**/glob-with-inexistent-file.txt
+    cmds:
-    - ./source.txt
+      - cp ./source.txt ./generated.txt
-  generates:
+    sources:
-    - ./generated.txt
+      - ./**/glob-with-inexistent-file.txt
-  method: checksum
+      - ./source.txt
+    generates:
+      - ./generated.txt
+    method: checksum

testdata/cyclic/Taskfile.yml

@@ -1,7 +1,10 @@
-task-1:
+version: '3'
-  deps:
-    - task: task-2
 
-task-2:
+tasks:
-  deps:
+  task-1:
-    - task: task-1
+    deps:
+      - task: task-2
+
+  task-2:
+    deps:
+      - task: task-1

testdata/deps/Taskfile.yml

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

testdata/dir/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   whereami:

testdata/dir/explicit_doesnt_exist/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   whereami:

testdata/dir/explicit_exists/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   whereami:

testdata/dry/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   build:

testdata/dry_checksum/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   default:

testdata/env/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 vars:
   BAZ:

testdata/expand/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   pwd:

testdata/generates/Taskfile.yml

@@ -1,41 +1,51 @@
-abs.txt:
+version: '3'
-  desc: generates dest file based on absolute paths
-  deps:
-    - sub/src.txt
-  dir: sub
-  cmds:
-    - cat src.txt > '{{.BUILD_DIR}}/abs.txt'
-  sources:
-    - src.txt
-  generates:
-    - "{{.BUILD_DIR}}/abs.txt"
 
-rel.txt:
+vars:
-  desc: generates dest file based on relative paths
+  BUILD_DIR: $pwd
-  deps:
-    - sub/src.txt
-  dir: sub
-  cmds:
-    - cat src.txt > '../rel.txt'
-  sources:
-    - src.txt
-  generates:
-    - "../rel.txt"
 
-sub/src.txt:
+tasks:
-  desc: generate source file
+  abs.txt:
-  cmds:
+    desc: generates dest file based on absolute paths
-    - mkdir -p sub
+    deps:
-    - echo "hello world" > sub/src.txt
+      - sub/src.txt
-  status:
+    dir: sub
-    - test -f sub/src.txt
+    cmds:
+      - cat src.txt > '{{.BUILD_DIR}}/abs.txt'
+    method: timestamp
+    sources:
+      - src.txt
+    generates:
+      - "{{.BUILD_DIR}}/abs.txt"
 
-'my text file.txt':
+  rel.txt:
-  desc: generate file with spaces in the name
+    desc: generates dest file based on relative paths
-  deps: [sub/src.txt]
+    deps:
-  cmds:
+      - sub/src.txt
-    - cat sub/src.txt > 'my text file.txt'
+    dir: sub
-  sources:
+    cmds:
-    - sub/src.txt
+      - cat src.txt > '../rel.txt'
-  generates:
+    method: timestamp
-    - 'my text file.txt'
+    sources:
+      - src.txt
+    generates:
+      - "../rel.txt"
+
+  sub/src.txt:
+    desc: generate source file
+    cmds:
+      - mkdir -p sub
+      - echo "hello world" > sub/src.txt
+    method: timestamp
+    status:
+      - test -f sub/src.txt
+
+  'my text file.txt':
+    desc: generate file with spaces in the name
+    deps: [sub/src.txt]
+    cmds:
+      - cat sub/src.txt > 'my text file.txt'
+    method: timestamp
+    sources:
+      - sub/src.txt
+    generates:
+      - 'my text file.txt'

testdata/generates/Taskvars.yml

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

testdata/ignore_errors/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   task-should-pass:

testdata/includes/Taskfile.yml

@@ -1,8 +1,19 @@
-version: '2'
+version: '3'
 
 includes:
   included: ./included
   included_taskfile: ./Taskfile2.yml
+  included_without_dir:
+    taskfile:  ./module1
+  included_taskfile_without_dir:
+    taskfile:  ./module1/Taskfile.yml
+  included_with_dir:
+    taskfile:  ./module2
+    dir:  ./module2
+  included_taskfile_with_dir:
+    taskfile:  ./module2/Taskfile.yml
+    dir:  ./module2
+  included_os: ./Taskfile_{{OS}}.yml
 
 tasks:
   default:
@@ -10,6 +21,11 @@ tasks:
       - task: gen
       - task: included:gen
       - task: included_taskfile:gen
+      - task: included_without_dir:gen_file
+      - task: included_taskfile_without_dir:gen_dir
+      - task: included_with_dir:gen_file
+      - task: included_taskfile_with_dir:gen_dir
+      - task: included_os:gen
 
   gen:
     cmds:

testdata/includes/Taskfile2.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   gen:

testdata/includes/Taskfile_darwin.yml

@@ -0,0 +1,4 @@
+version: '3'
+
+tasks:
+  gen: echo 'os' > os_include.txt

testdata/includes/Taskfile_linux.yml

@@ -0,0 +1,4 @@
+version: '3'
+
+tasks:
+  gen: echo 'os' > os_include.txt

testdata/includes/Taskfile_windows.yml

@@ -0,0 +1,4 @@
+version: '3'
+
+tasks:
+  gen: echo 'os' > os_include.txt

testdata/includes/included/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   gen:

testdata/includes/module1/Taskfile.yml

@@ -0,0 +1,10 @@
+version: '3'
+
+tasks:
+  gen_dir:
+    cmds:
+      - echo included_directory_without_dir > included_directory_without_dir.txt
+
+  gen_file:
+    cmds:
+      - echo included_taskfile_without_dir > included_taskfile_without_dir.txt

testdata/includes/module2/Taskfile.yml

@@ -0,0 +1,10 @@
+version: '3'
+
+tasks:
+  gen_dir:
+    cmds:
+      - echo included_directory_with_dir > included_directory_with_dir.txt
+
+  gen_file:
+    cmds:
+      - echo included_taskfile_with_dir > included_taskfile_with_dir.txt

testdata/includes_call_root_task/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 includes:
   included: Taskfile2.yml

testdata/includes_call_root_task/Taskfile2.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   call-root:

testdata/includes_deps/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 includes:
   included: Taskfile2.yml

testdata/includes_deps/Taskfile2.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   default:

testdata/includes_empty/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 includes:
   included: Taskfile2.yml

testdata/includes_empty/Taskfile2.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 vars:
   FILE: file.txt

testdata/incorrect_includes/Taskfile.yml

@@ -0,0 +1,10 @@
+version: '2.6'
+
+includes:
+  included:
+    taskfile:  ./included
+
+tasks:
+  default:
+    cmds:
+      - task: gen

testdata/incorrect_includes/included/Taskfile.yml

@@ -0,0 +1,6 @@
+version: '2.6'
+
+tasks:
+  gen:
+    cmds:
+      - echo incorrect includes test

testdata/params/Taskfile.yml

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

testdata/params/Taskvars.yml

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

testdata/precondition/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   foo:

testdata/short_task_notation/Taskfile.yml

@@ -0,0 +1,12 @@
+version: '3'
+
+tasks:
+  default:
+    - task: string-slice
+    - task: string
+
+  string-slice:
+    - echo "string-slice-1"
+    - echo "string-slice-2"
+
+  string: echo "string"

testdata/status/Taskfile.yml

@@ -1,5 +1,8 @@
-gen-foo:
+version: '3'
-  cmds:
+
-    - touch foo.txt
+tasks:
-  status:
+  gen-foo:
-    - test -f foo.txt
+    cmds:
+      - touch foo.txt
+    status:
+      - test -f foo.txt

testdata/status_vars/.gitignore

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

testdata/status_vars/Taskfile.yml

@@ -0,0 +1,10 @@
+version: '3'
+
+tasks:
+  build:
+    sources:
+      - ./source.txt
+    status:
+      - echo "{{.CHECKSUM}}"
+      - echo '{{.TIMESTAMP.Unix}}'
+      - echo '{{.TIMESTAMP}}'

testdata/status_vars/source.txt

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

testdata/summary/Taskfile.yml

@@ -1,4 +1,4 @@
-version: 2
+version: '3'
 
 tasks:
   task-with-summary:

testdata/vars/v1/Taskfile.yml

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

testdata/vars/v1/Taskvars.yml

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

testdata/vars/v1/multiline/Taskfile.yml

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

testdata/vars/v2/Taskfile.yml

@@ -32,6 +32,7 @@ tasks:
       - echo '{{.NESTEDTMPL2_FOO2}}' > nestedtmpl2_foo2.txt
       - echo {{.OVERRIDE}} > override.txt
       - echo '{{.NESTED3}}' > nested.txt
+      - echo '{{.TASK}}' > task_name.txt
     vars:
       FOO: foo
       BAR: $echo bar

testdata/vars/v3/Taskfile.yml

@@ -0,0 +1,46 @@
+version: '3'
+
+vars:
+  VAR_A: A
+  VAR_B: '{{.VAR_A}}B'
+  VAR_C: '{{.VAR_B}}C'
+
+  VAR_1: {sh: echo 1}
+  VAR_2: {sh: 'echo "{{.VAR_1}}2"'}
+  VAR_3: {sh: 'echo "{{.VAR_2}}3"'}
+
+tasks:
+  default:
+    - task: missing-var
+    - task: var-order
+    - task: dependent-sh
+    - task: with-call
+
+  missing-var: echo '{{.NON_EXISTING_VAR}}' > missing-var.txt
+
+  var-order:
+    vars:
+      VAR_D: '{{.VAR_C}}D'
+      VAR_E: '{{.VAR_D}}E'
+      VAR_F: '{{.VAR_E}}F'
+    cmds:
+      - echo '{{.VAR_F}}' > var-order.txt
+
+  dependent-sh:
+    vars:
+      VAR_4: {sh: 'echo "{{.VAR_3}}4"'}
+      VAR_5: {sh: 'echo "{{.VAR_4}}5"'}
+      VAR_6: {sh: 'echo "{{.VAR_5}}6"'}
+    cmds:
+      - echo '{{.VAR_6}}' > dependent-sh.txt
+
+  with-call:
+    - task: called-task
+      vars:
+        ABC123: '{{.VAR_C}}{{.VAR_3}}'
+
+  called-task:
+    vars:
+      MESSAGE: Hi, {{.ABC123}}!
+    cmds:
+      - echo "{{.MESSAGE}}" > with-call.txt

testdata/version/v2/Taskfile.yml

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

variables.go

@@ -2,8 +2,10 @@ package task
 
 import (
 	"path/filepath"
+	"strings"
 
 	"github.com/go-task/task/v2/internal/execext"
+	"github.com/go-task/task/v2/internal/status"
 	"github.com/go-task/task/v2/internal/taskfile"
 	"github.com/go-task/task/v2/internal/templater"
 )
@@ -20,14 +22,20 @@ func (e *Executor) CompiledTask(call taskfile.Call) (*taskfile.Task, error) {
 	if err != nil {
 		return nil, err
 	}
-	r := templater.Templater{Vars: vars}
+
+	v, err := e.Taskfile.ParsedVersion()
+	if err != nil {
+		return nil, err
+	}
+
+	r := templater.Templater{Vars: vars, RemoveNoValue: v >= 3.0}
 
 	new := taskfile.Task{
 		Task:        origTask.Task,
 		Desc:        r.Replace(origTask.Desc),
+		Summary:     r.Replace(origTask.Summary),
 		Sources:     r.ReplaceSlice(origTask.Sources),
 		Generates:   r.ReplaceSlice(origTask.Generates),
-		Status:      r.ReplaceSlice(origTask.Status),
 		Dir:         r.Replace(origTask.Dir),
 		Vars:        nil,
 		Env:         nil,
@@ -47,19 +55,19 @@ func (e *Executor) CompiledTask(call taskfile.Call) (*taskfile.Task, error) {
 		new.Prefix = new.Task
 	}
 
-	new.Env = make(taskfile.Vars, len(e.Taskfile.Env)+len(origTask.Env))
+	new.Env = &taskfile.Vars{}
-	for k, v := range r.ReplaceVars(e.Taskfile.Env) {
+	new.Env.Merge(r.ReplaceVars(e.Taskfile.Env))
-		new.Env[k] = v
+	new.Env.Merge(r.ReplaceVars(origTask.Env))
-	}
+	err = new.Env.Range(func(k string, v taskfile.Var) error {
-	for k, v := range r.ReplaceVars(origTask.Env) {
-		new.Env[k] = v
-	}
-	for k, v := range new.Env {
 		static, err := e.Compiler.HandleDynamicVar(v)
 		if err != nil {
-			return nil, err
+			return err
 		}
-		new.Env[k] = taskfile.Var{Static: static}
+		new.Env.Set(k, taskfile.Var{Static: static})
+		return nil
+	})
+	if err != nil {
+		return nil, err
 	}
 
 	if len(origTask.Cmds) > 0 {
@@ -94,5 +102,21 @@ func (e *Executor) CompiledTask(call taskfile.Call) (*taskfile.Task, error) {
 		}
 	}
 
+	if len(origTask.Status) > 0 {
+		for _, checker := range []status.Checker{e.timestampChecker(&new), e.checksumChecker(&new)} {
+			value, err := checker.Value()
+			if err != nil {
+				return nil, err
+			}
+			vars.Set(strings.ToUpper(checker.Kind()), taskfile.Var{Live: value})
+		}
+
+		// Adding new variables, requires us to refresh the templaters
+		// cache of the the values manually
+		r.ResetCache()
+
+		new.Status = r.ReplaceSlice(origTask.Status)
+	}
+
 	return &new, r.Err()
 }

vendor/golang.org/x/crypto/ssh/terminal/terminal.go

@@ -1,966 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package terminal
-
-import (
-	"bytes"
-	"io"
-	"strconv"
-	"sync"
-	"unicode/utf8"
-)
-
-// EscapeCodes contains escape sequences that can be written to the terminal in
-// order to achieve different styles of text.
-type EscapeCodes struct {
-	// Foreground colors
-	Black, Red, Green, Yellow, Blue, Magenta, Cyan, White []byte
-
-	// Reset all attributes
-	Reset []byte
-}
-
-var vt100EscapeCodes = EscapeCodes{
-	Black:   []byte{keyEscape, '[', '3', '0', 'm'},
-	Red:     []byte{keyEscape, '[', '3', '1', 'm'},
-	Green:   []byte{keyEscape, '[', '3', '2', 'm'},
-	Yellow:  []byte{keyEscape, '[', '3', '3', 'm'},
-	Blue:    []byte{keyEscape, '[', '3', '4', 'm'},
-	Magenta: []byte{keyEscape, '[', '3', '5', 'm'},
-	Cyan:    []byte{keyEscape, '[', '3', '6', 'm'},
-	White:   []byte{keyEscape, '[', '3', '7', 'm'},
-
-	Reset: []byte{keyEscape, '[', '0', 'm'},
-}
-
-// Terminal contains the state for running a VT100 terminal that is capable of
-// reading lines of input.
-type Terminal struct {
-	// AutoCompleteCallback, if non-null, is called for each keypress with
-	// the full input line and the current position of the cursor (in
-	// bytes, as an index into |line|). If it returns ok=false, the key
-	// press is processed normally. Otherwise it returns a replacement line
-	// and the new cursor position.
-	AutoCompleteCallback func(line string, pos int, key rune) (newLine string, newPos int, ok bool)
-
-	// Escape contains a pointer to the escape codes for this terminal.
-	// It's always a valid pointer, although the escape codes themselves
-	// may be empty if the terminal doesn't support them.
-	Escape *EscapeCodes
-
-	// lock protects the terminal and the state in this object from
-	// concurrent processing of a key press and a Write() call.
-	lock sync.Mutex
-
-	c      io.ReadWriter
-	prompt []rune
-
-	// line is the current line being entered.
-	line []rune
-	// pos is the logical position of the cursor in line
-	pos int
-	// echo is true if local echo is enabled
-	echo bool
-	// pasteActive is true iff there is a bracketed paste operation in
-	// progress.
-	pasteActive bool
-
-	// cursorX contains the current X value of the cursor where the left
-	// edge is 0. cursorY contains the row number where the first row of
-	// the current line is 0.
-	cursorX, cursorY int
-	// maxLine is the greatest value of cursorY so far.
-	maxLine int
-
-	termWidth, termHeight int
-
-	// outBuf contains the terminal data to be sent.
-	outBuf []byte
-	// remainder contains the remainder of any partial key sequences after
-	// a read. It aliases into inBuf.
-	remainder []byte
-	inBuf     [256]byte
-
-	// history contains previously entered commands so that they can be
-	// accessed with the up and down keys.
-	history stRingBuffer
-	// historyIndex stores the currently accessed history entry, where zero
-	// means the immediately previous entry.
-	historyIndex int
-	// When navigating up and down the history it's possible to return to
-	// the incomplete, initial line. That value is stored in
-	// historyPending.
-	historyPending string
-}
-
-// NewTerminal runs a VT100 terminal on the given ReadWriter. If the ReadWriter is
-// a local terminal, that terminal must first have been put into raw mode.
-// prompt is a string that is written at the start of each input line (i.e.
-// "> ").
-func NewTerminal(c io.ReadWriter, prompt string) *Terminal {
-	return &Terminal{
-		Escape:       &vt100EscapeCodes,
-		c:            c,
-		prompt:       []rune(prompt),
-		termWidth:    80,
-		termHeight:   24,
-		echo:         true,
-		historyIndex: -1,
-	}
-}
-
-const (
-	keyCtrlD     = 4
-	keyCtrlU     = 21
-	keyEnter     = '\r'
-	keyEscape    = 27
-	keyBackspace = 127
-	keyUnknown   = 0xd800 /* UTF-16 surrogate area */ + iota
-	keyUp
-	keyDown
-	keyLeft
-	keyRight
-	keyAltLeft
-	keyAltRight
-	keyHome
-	keyEnd
-	keyDeleteWord
-	keyDeleteLine
-	keyClearScreen
-	keyPasteStart
-	keyPasteEnd
-)
-
-var (
-	crlf       = []byte{'\r', '\n'}
-	pasteStart = []byte{keyEscape, '[', '2', '0', '0', '~'}
-	pasteEnd   = []byte{keyEscape, '[', '2', '0', '1', '~'}
-)
-
-// bytesToKey tries to parse a key sequence from b. If successful, it returns
-// the key and the remainder of the input. Otherwise it returns utf8.RuneError.
-func bytesToKey(b []byte, pasteActive bool) (rune, []byte) {
-	if len(b) == 0 {
-		return utf8.RuneError, nil
-	}
-
-	if !pasteActive {
-		switch b[0] {
-		case 1: // ^A
-			return keyHome, b[1:]
-		case 5: // ^E
-			return keyEnd, b[1:]
-		case 8: // ^H
-			return keyBackspace, b[1:]
-		case 11: // ^K
-			return keyDeleteLine, b[1:]
-		case 12: // ^L
-			return keyClearScreen, b[1:]
-		case 23: // ^W
-			return keyDeleteWord, b[1:]
-		case 14: // ^N
-			return keyDown, b[1:]
-		case 16: // ^P
-			return keyUp, b[1:]
-		}
-	}
-
-	if b[0] != keyEscape {
-		if !utf8.FullRune(b) {
-			return utf8.RuneError, b
-		}
-		r, l := utf8.DecodeRune(b)
-		return r, b[l:]
-	}
-
-	if !pasteActive && len(b) >= 3 && b[0] == keyEscape && b[1] == '[' {
-		switch b[2] {
-		case 'A':
-			return keyUp, b[3:]
-		case 'B':
-			return keyDown, b[3:]
-		case 'C':
-			return keyRight, b[3:]
-		case 'D':
-			return keyLeft, b[3:]
-		case 'H':
-			return keyHome, b[3:]
-		case 'F':
-			return keyEnd, b[3:]
-		}
-	}
-
-	if !pasteActive && len(b) >= 6 && b[0] == keyEscape && b[1] == '[' && b[2] == '1' && b[3] == ';' && b[4] == '3' {
-		switch b[5] {
-		case 'C':
-			return keyAltRight, b[6:]
-		case 'D':
-			return keyAltLeft, b[6:]
-		}
-	}
-
-	if !pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteStart) {
-		return keyPasteStart, b[6:]
-	}
-
-	if pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteEnd) {
-		return keyPasteEnd, b[6:]
-	}
-
-	// If we get here then we have a key that we don't recognise, or a
-	// partial sequence. It's not clear how one should find the end of a
-	// sequence without knowing them all, but it seems that [a-zA-Z~] only
-	// appears at the end of a sequence.
-	for i, c := range b[0:] {
-		if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c == '~' {
-			return keyUnknown, b[i+1:]
-		}
-	}
-
-	return utf8.RuneError, b
-}
-
-// queue appends data to the end of t.outBuf
-func (t *Terminal) queue(data []rune) {
-	t.outBuf = append(t.outBuf, []byte(string(data))...)
-}
-
-var eraseUnderCursor = []rune{' ', keyEscape, '[', 'D'}
-var space = []rune{' '}
-
-func isPrintable(key rune) bool {
-	isInSurrogateArea := key >= 0xd800 && key <= 0xdbff
-	return key >= 32 && !isInSurrogateArea
-}
-
-// moveCursorToPos appends data to t.outBuf which will move the cursor to the
-// given, logical position in the text.
-func (t *Terminal) moveCursorToPos(pos int) {
-	if !t.echo {
-		return
-	}
-
-	x := visualLength(t.prompt) + pos
-	y := x / t.termWidth
-	x = x % t.termWidth
-
-	up := 0
-	if y < t.cursorY {
-		up = t.cursorY - y
-	}
-
-	down := 0
-	if y > t.cursorY {
-		down = y - t.cursorY
-	}
-
-	left := 0
-	if x < t.cursorX {
-		left = t.cursorX - x
-	}
-
-	right := 0
-	if x > t.cursorX {
-		right = x - t.cursorX
-	}
-
-	t.cursorX = x
-	t.cursorY = y
-	t.move(up, down, left, right)
-}
-
-func (t *Terminal) move(up, down, left, right int) {
-	m := []rune{}
-
-	// 1 unit up can be expressed as ^[[A or ^[A
-	// 5 units up can be expressed as ^[[5A
-
-	if up == 1 {
-		m = append(m, keyEscape, '[', 'A')
-	} else if up > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(up))...)
-		m = append(m, 'A')
-	}
-
-	if down == 1 {
-		m = append(m, keyEscape, '[', 'B')
-	} else if down > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(down))...)
-		m = append(m, 'B')
-	}
-
-	if right == 1 {
-		m = append(m, keyEscape, '[', 'C')
-	} else if right > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(right))...)
-		m = append(m, 'C')
-	}
-
-	if left == 1 {
-		m = append(m, keyEscape, '[', 'D')
-	} else if left > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(left))...)
-		m = append(m, 'D')
-	}
-
-	t.queue(m)
-}
-
-func (t *Terminal) clearLineToRight() {
-	op := []rune{keyEscape, '[', 'K'}
-	t.queue(op)
-}
-
-const maxLineLength = 4096
-
-func (t *Terminal) setLine(newLine []rune, newPos int) {
-	if t.echo {
-		t.moveCursorToPos(0)
-		t.writeLine(newLine)
-		for i := len(newLine); i < len(t.line); i++ {
-			t.writeLine(space)
-		}
-		t.moveCursorToPos(newPos)
-	}
-	t.line = newLine
-	t.pos = newPos
-}
-
-func (t *Terminal) advanceCursor(places int) {
-	t.cursorX += places
-	t.cursorY += t.cursorX / t.termWidth
-	if t.cursorY > t.maxLine {
-		t.maxLine = t.cursorY
-	}
-	t.cursorX = t.cursorX % t.termWidth
-
-	if places > 0 && t.cursorX == 0 {
-		// Normally terminals will advance the current position
-		// when writing a character. But that doesn't happen
-		// for the last character in a line. However, when
-		// writing a character (except a new line) that causes
-		// a line wrap, the position will be advanced two
-		// places.
-		//
-		// So, if we are stopping at the end of a line, we
-		// need to write a newline so that our cursor can be
-		// advanced to the next line.
-		t.outBuf = append(t.outBuf, '\r', '\n')
-	}
-}
-
-func (t *Terminal) eraseNPreviousChars(n int) {
-	if n == 0 {
-		return
-	}
-
-	if t.pos < n {
-		n = t.pos
-	}
-	t.pos -= n
-	t.moveCursorToPos(t.pos)
-
-	copy(t.line[t.pos:], t.line[n+t.pos:])
-	t.line = t.line[:len(t.line)-n]
-	if t.echo {
-		t.writeLine(t.line[t.pos:])
-		for i := 0; i < n; i++ {
-			t.queue(space)
-		}
-		t.advanceCursor(n)
-		t.moveCursorToPos(t.pos)
-	}
-}
-
-// countToLeftWord returns then number of characters from the cursor to the
-// start of the previous word.
-func (t *Terminal) countToLeftWord() int {
-	if t.pos == 0 {
-		return 0
-	}
-
-	pos := t.pos - 1
-	for pos > 0 {
-		if t.line[pos] != ' ' {
-			break
-		}
-		pos--
-	}
-	for pos > 0 {
-		if t.line[pos] == ' ' {
-			pos++
-			break
-		}
-		pos--
-	}
-
-	return t.pos - pos
-}
-
-// countToRightWord returns then number of characters from the cursor to the
-// start of the next word.
-func (t *Terminal) countToRightWord() int {
-	pos := t.pos
-	for pos < len(t.line) {
-		if t.line[pos] == ' ' {
-			break
-		}
-		pos++
-	}
-	for pos < len(t.line) {
-		if t.line[pos] != ' ' {
-			break
-		}
-		pos++
-	}
-	return pos - t.pos
-}
-
-// visualLength returns the number of visible glyphs in s.
-func visualLength(runes []rune) int {
-	inEscapeSeq := false
-	length := 0
-
-	for _, r := range runes {
-		switch {
-		case inEscapeSeq:
-			if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {
-				inEscapeSeq = false
-			}
-		case r == '\x1b':
-			inEscapeSeq = true
-		default:
-			length++
-		}
-	}
-
-	return length
-}
-
-// handleKey processes the given key and, optionally, returns a line of text
-// that the user has entered.
-func (t *Terminal) handleKey(key rune) (line string, ok bool) {
-	if t.pasteActive && key != keyEnter {
-		t.addKeyToLine(key)
-		return
-	}
-
-	switch key {
-	case keyBackspace:
-		if t.pos == 0 {
-			return
-		}
-		t.eraseNPreviousChars(1)
-	case keyAltLeft:
-		// move left by a word.
-		t.pos -= t.countToLeftWord()
-		t.moveCursorToPos(t.pos)
-	case keyAltRight:
-		// move right by a word.
-		t.pos += t.countToRightWord()
-		t.moveCursorToPos(t.pos)
-	case keyLeft:
-		if t.pos == 0 {
-			return
-		}
-		t.pos--
-		t.moveCursorToPos(t.pos)
-	case keyRight:
-		if t.pos == len(t.line) {
-			return
-		}
-		t.pos++
-		t.moveCursorToPos(t.pos)
-	case keyHome:
-		if t.pos == 0 {
-			return
-		}
-		t.pos = 0
-		t.moveCursorToPos(t.pos)
-	case keyEnd:
-		if t.pos == len(t.line) {
-			return
-		}
-		t.pos = len(t.line)
-		t.moveCursorToPos(t.pos)
-	case keyUp:
-		entry, ok := t.history.NthPreviousEntry(t.historyIndex + 1)
-		if !ok {
-			return "", false
-		}
-		if t.historyIndex == -1 {
-			t.historyPending = string(t.line)
-		}
-		t.historyIndex++
-		runes := []rune(entry)
-		t.setLine(runes, len(runes))
-	case keyDown:
-		switch t.historyIndex {
-		case -1:
-			return
-		case 0:
-			runes := []rune(t.historyPending)
-			t.setLine(runes, len(runes))
-			t.historyIndex--
-		default:
-			entry, ok := t.history.NthPreviousEntry(t.historyIndex - 1)
-			if ok {
-				t.historyIndex--
-				runes := []rune(entry)
-				t.setLine(runes, len(runes))
-			}
-		}
-	case keyEnter:
-		t.moveCursorToPos(len(t.line))
-		t.queue([]rune("\r\n"))
-		line = string(t.line)
-		ok = true
-		t.line = t.line[:0]
-		t.pos = 0
-		t.cursorX = 0
-		t.cursorY = 0
-		t.maxLine = 0
-	case keyDeleteWord:
-		// Delete zero or more spaces and then one or more characters.
-		t.eraseNPreviousChars(t.countToLeftWord())
-	case keyDeleteLine:
-		// Delete everything from the current cursor position to the
-		// end of line.
-		for i := t.pos; i < len(t.line); i++ {
-			t.queue(space)
-			t.advanceCursor(1)
-		}
-		t.line = t.line[:t.pos]
-		t.moveCursorToPos(t.pos)
-	case keyCtrlD:
-		// Erase the character under the current position.
-		// The EOF case when the line is empty is handled in
-		// readLine().
-		if t.pos < len(t.line) {
-			t.pos++
-			t.eraseNPreviousChars(1)
-		}
-	case keyCtrlU:
-		t.eraseNPreviousChars(t.pos)
-	case keyClearScreen:
-		// Erases the screen and moves the cursor to the home position.
-		t.queue([]rune("\x1b[2J\x1b[H"))
-		t.queue(t.prompt)
-		t.cursorX, t.cursorY = 0, 0
-		t.advanceCursor(visualLength(t.prompt))
-		t.setLine(t.line, t.pos)
-	default:
-		if t.AutoCompleteCallback != nil {
-			prefix := string(t.line[:t.pos])
-			suffix := string(t.line[t.pos:])
-
-			t.lock.Unlock()
-			newLine, newPos, completeOk := t.AutoCompleteCallback(prefix+suffix, len(prefix), key)
-			t.lock.Lock()
-
-			if completeOk {
-				t.setLine([]rune(newLine), utf8.RuneCount([]byte(newLine)[:newPos]))
-				return
-			}
-		}
-		if !isPrintable(key) {
-			return
-		}
-		if len(t.line) == maxLineLength {
-			return
-		}
-		t.addKeyToLine(key)
-	}
-	return
-}
-
-// addKeyToLine inserts the given key at the current position in the current
-// line.
-func (t *Terminal) addKeyToLine(key rune) {
-	if len(t.line) == cap(t.line) {
-		newLine := make([]rune, len(t.line), 2*(1+len(t.line)))
-		copy(newLine, t.line)
-		t.line = newLine
-	}
-	t.line = t.line[:len(t.line)+1]
-	copy(t.line[t.pos+1:], t.line[t.pos:])
-	t.line[t.pos] = key
-	if t.echo {
-		t.writeLine(t.line[t.pos:])
-	}
-	t.pos++
-	t.moveCursorToPos(t.pos)
-}
-
-func (t *Terminal) writeLine(line []rune) {
-	for len(line) != 0 {
-		remainingOnLine := t.termWidth - t.cursorX
-		todo := len(line)
-		if todo > remainingOnLine {
-			todo = remainingOnLine
-		}
-		t.queue(line[:todo])
-		t.advanceCursor(visualLength(line[:todo]))
-		line = line[todo:]
-	}
-}
-
-// writeWithCRLF writes buf to w but replaces all occurrences of \n with \r\n.
-func writeWithCRLF(w io.Writer, buf []byte) (n int, err error) {
-	for len(buf) > 0 {
-		i := bytes.IndexByte(buf, '\n')
-		todo := len(buf)
-		if i >= 0 {
-			todo = i
-		}
-
-		var nn int
-		nn, err = w.Write(buf[:todo])
-		n += nn
-		if err != nil {
-			return n, err
-		}
-		buf = buf[todo:]
-
-		if i >= 0 {
-			if _, err = w.Write(crlf); err != nil {
-				return n, err
-			}
-			n++
-			buf = buf[1:]
-		}
-	}
-
-	return n, nil
-}
-
-func (t *Terminal) Write(buf []byte) (n int, err error) {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	if t.cursorX == 0 && t.cursorY == 0 {
-		// This is the easy case: there's nothing on the screen that we
-		// have to move out of the way.
-		return writeWithCRLF(t.c, buf)
-	}
-
-	// We have a prompt and possibly user input on the screen. We
-	// have to clear it first.
-	t.move(0 /* up */, 0 /* down */, t.cursorX /* left */, 0 /* right */)
-	t.cursorX = 0
-	t.clearLineToRight()
-
-	for t.cursorY > 0 {
-		t.move(1 /* up */, 0, 0, 0)
-		t.cursorY--
-		t.clearLineToRight()
-	}
-
-	if _, err = t.c.Write(t.outBuf); err != nil {
-		return
-	}
-	t.outBuf = t.outBuf[:0]
-
-	if n, err = writeWithCRLF(t.c, buf); err != nil {
-		return
-	}
-
-	t.writeLine(t.prompt)
-	if t.echo {
-		t.writeLine(t.line)
-	}
-
-	t.moveCursorToPos(t.pos)
-
-	if _, err = t.c.Write(t.outBuf); err != nil {
-		return
-	}
-	t.outBuf = t.outBuf[:0]
-	return
-}
-
-// ReadPassword temporarily changes the prompt and reads a password, without
-// echo, from the terminal.
-func (t *Terminal) ReadPassword(prompt string) (line string, err error) {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	oldPrompt := t.prompt
-	t.prompt = []rune(prompt)
-	t.echo = false
-
-	line, err = t.readLine()
-
-	t.prompt = oldPrompt
-	t.echo = true
-
-	return
-}
-
-// ReadLine returns a line of input from the terminal.
-func (t *Terminal) ReadLine() (line string, err error) {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	return t.readLine()
-}
-
-func (t *Terminal) readLine() (line string, err error) {
-	// t.lock must be held at this point
-
-	if t.cursorX == 0 && t.cursorY == 0 {
-		t.writeLine(t.prompt)
-		t.c.Write(t.outBuf)
-		t.outBuf = t.outBuf[:0]
-	}
-
-	lineIsPasted := t.pasteActive
-
-	for {
-		rest := t.remainder
-		lineOk := false
-		for !lineOk {
-			var key rune
-			key, rest = bytesToKey(rest, t.pasteActive)
-			if key == utf8.RuneError {
-				break
-			}
-			if !t.pasteActive {
-				if key == keyCtrlD {
-					if len(t.line) == 0 {
-						return "", io.EOF
-					}
-				}
-				if key == keyPasteStart {
-					t.pasteActive = true
-					if len(t.line) == 0 {
-						lineIsPasted = true
-					}
-					continue
-				}
-			} else if key == keyPasteEnd {
-				t.pasteActive = false
-				continue
-			}
-			if !t.pasteActive {
-				lineIsPasted = false
-			}
-			line, lineOk = t.handleKey(key)
-		}
-		if len(rest) > 0 {
-			n := copy(t.inBuf[:], rest)
-			t.remainder = t.inBuf[:n]
-		} else {
-			t.remainder = nil
-		}
-		t.c.Write(t.outBuf)
-		t.outBuf = t.outBuf[:0]
-		if lineOk {
-			if t.echo {
-				t.historyIndex = -1
-				t.history.Add(line)
-			}
-			if lineIsPasted {
-				err = ErrPasteIndicator
-			}
-			return
-		}
-
-		// t.remainder is a slice at the beginning of t.inBuf
-		// containing a partial key sequence
-		readBuf := t.inBuf[len(t.remainder):]
-		var n int
-
-		t.lock.Unlock()
-		n, err = t.c.Read(readBuf)
-		t.lock.Lock()
-
-		if err != nil {
-			return
-		}
-
-		t.remainder = t.inBuf[:n+len(t.remainder)]
-	}
-}
-
-// SetPrompt sets the prompt to be used when reading subsequent lines.
-func (t *Terminal) SetPrompt(prompt string) {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	t.prompt = []rune(prompt)
-}
-
-func (t *Terminal) clearAndRepaintLinePlusNPrevious(numPrevLines int) {
-	// Move cursor to column zero at the start of the line.
-	t.move(t.cursorY, 0, t.cursorX, 0)
-	t.cursorX, t.cursorY = 0, 0
-	t.clearLineToRight()
-	for t.cursorY < numPrevLines {
-		// Move down a line
-		t.move(0, 1, 0, 0)
-		t.cursorY++
-		t.clearLineToRight()
-	}
-	// Move back to beginning.
-	t.move(t.cursorY, 0, 0, 0)
-	t.cursorX, t.cursorY = 0, 0
-
-	t.queue(t.prompt)
-	t.advanceCursor(visualLength(t.prompt))
-	t.writeLine(t.line)
-	t.moveCursorToPos(t.pos)
-}
-
-func (t *Terminal) SetSize(width, height int) error {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	if width == 0 {
-		width = 1
-	}
-
-	oldWidth := t.termWidth
-	t.termWidth, t.termHeight = width, height
-
-	switch {
-	case width == oldWidth:
-		// If the width didn't change then nothing else needs to be
-		// done.
-		return nil
-	case len(t.line) == 0 && t.cursorX == 0 && t.cursorY == 0:
-		// If there is nothing on current line and no prompt printed,
-		// just do nothing
-		return nil
-	case width < oldWidth:
-		// Some terminals (e.g. xterm) will truncate lines that were
-		// too long when shinking. Others, (e.g. gnome-terminal) will
-		// attempt to wrap them. For the former, repainting t.maxLine
-		// works great, but that behaviour goes badly wrong in the case
-		// of the latter because they have doubled every full line.
-
-		// We assume that we are working on a terminal that wraps lines
-		// and adjust the cursor position based on every previous line
-		// wrapping and turning into two. This causes the prompt on
-		// xterms to move upwards, which isn't great, but it avoids a
-		// huge mess with gnome-terminal.
-		if t.cursorX >= t.termWidth {
-			t.cursorX = t.termWidth - 1
-		}
-		t.cursorY *= 2
-		t.clearAndRepaintLinePlusNPrevious(t.maxLine * 2)
-	case width > oldWidth:
-		// If the terminal expands then our position calculations will
-		// be wrong in the future because we think the cursor is
-		// |t.pos| chars into the string, but there will be a gap at
-		// the end of any wrapped line.
-		//
-		// But the position will actually be correct until we move, so
-		// we can move back to the beginning and repaint everything.
-		t.clearAndRepaintLinePlusNPrevious(t.maxLine)
-	}
-
-	_, err := t.c.Write(t.outBuf)
-	t.outBuf = t.outBuf[:0]
-	return err
-}
-
-type pasteIndicatorError struct{}
-
-func (pasteIndicatorError) Error() string {
-	return "terminal: ErrPasteIndicator not correctly handled"
-}
-
-// ErrPasteIndicator may be returned from ReadLine as the error, in addition
-// to valid line data. It indicates that bracketed paste mode is enabled and
-// that the returned line consists only of pasted data. Programs may wish to
-// interpret pasted data more literally than typed data.
-var ErrPasteIndicator = pasteIndicatorError{}
-
-// SetBracketedPasteMode requests that the terminal bracket paste operations
-// with markers. Not all terminals support this but, if it is supported, then
-// enabling this mode will stop any autocomplete callback from running due to
-// pastes. Additionally, any lines that are completely pasted will be returned
-// from ReadLine with the error set to ErrPasteIndicator.
-func (t *Terminal) SetBracketedPasteMode(on bool) {
-	if on {
-		io.WriteString(t.c, "\x1b[?2004h")
-	} else {
-		io.WriteString(t.c, "\x1b[?2004l")
-	}
-}
-
-// stRingBuffer is a ring buffer of strings.
-type stRingBuffer struct {
-	// entries contains max elements.
-	entries []string
-	max     int
-	// head contains the index of the element most recently added to the ring.
-	head int
-	// size contains the number of elements in the ring.
-	size int
-}
-
-func (s *stRingBuffer) Add(a string) {
-	if s.entries == nil {
-		const defaultNumEntries = 100
-		s.entries = make([]string, defaultNumEntries)
-		s.max = defaultNumEntries
-	}
-
-	s.head = (s.head + 1) % s.max
-	s.entries[s.head] = a
-	if s.size < s.max {
-		s.size++
-	}
-}
-
-// NthPreviousEntry returns the value passed to the nth previous call to Add.
-// If n is zero then the immediately prior value is returned, if one, then the
-// next most recent, and so on. If such an element doesn't exist then ok is
-// false.
-func (s *stRingBuffer) NthPreviousEntry(n int) (value string, ok bool) {
-	if n >= s.size {
-		return "", false
-	}
-	index := s.head - n
-	if index < 0 {
-		index += s.max
-	}
-	return s.entries[index], true
-}
-
-// readPasswordLine reads from reader until it finds \n or io.EOF.
-// The slice returned does not include the \n.
-// readPasswordLine also ignores any \r it finds.
-func readPasswordLine(reader io.Reader) ([]byte, error) {
-	var buf [1]byte
-	var ret []byte
-
-	for {
-		n, err := reader.Read(buf[:])
-		if n > 0 {
-			switch buf[0] {
-			case '\n':
-				return ret, nil
-			case '\r':
-				// remove \r from passwords on Windows
-			default:
-				ret = append(ret, buf[0])
-			}
-			continue
-		}
-		if err != nil {
-			if err == io.EOF && len(ret) > 0 {
-				return ret, nil
-			}
-			return ret, err
-		}
-	}
-}

vendor/golang.org/x/crypto/ssh/terminal/util.go

@@ -1,114 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build aix darwin dragonfly freebsd linux,!appengine netbsd openbsd
-
-// Package terminal provides support functions for dealing with terminals, as
-// commonly found on UNIX systems.
-//
-// Putting a terminal into raw mode is the most common requirement:
-//
-// 	oldState, err := terminal.MakeRaw(0)
-// 	if err != nil {
-// 	        panic(err)
-// 	}
-// 	defer terminal.Restore(0, oldState)
-package terminal // import "golang.org/x/crypto/ssh/terminal"
-
-import (
-	"golang.org/x/sys/unix"
-)
-
-// State contains the state of a terminal.
-type State struct {
-	termios unix.Termios
-}
-
-// IsTerminal returns whether the given file descriptor is a terminal.
-func IsTerminal(fd int) bool {
-	_, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
-	return err == nil
-}
-
-// MakeRaw put the terminal connected to the given file descriptor into raw
-// mode and returns the previous state of the terminal so that it can be
-// restored.
-func MakeRaw(fd int) (*State, error) {
-	termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
-	if err != nil {
-		return nil, err
-	}
-
-	oldState := State{termios: *termios}
-
-	// This attempts to replicate the behaviour documented for cfmakeraw in
-	// the termios(3) manpage.
-	termios.Iflag &^= unix.IGNBRK | unix.BRKINT | unix.PARMRK | unix.ISTRIP | unix.INLCR | unix.IGNCR | unix.ICRNL | unix.IXON
-	termios.Oflag &^= unix.OPOST
-	termios.Lflag &^= unix.ECHO | unix.ECHONL | unix.ICANON | unix.ISIG | unix.IEXTEN
-	termios.Cflag &^= unix.CSIZE | unix.PARENB
-	termios.Cflag |= unix.CS8
-	termios.Cc[unix.VMIN] = 1
-	termios.Cc[unix.VTIME] = 0
-	if err := unix.IoctlSetTermios(fd, ioctlWriteTermios, termios); err != nil {
-		return nil, err
-	}
-
-	return &oldState, nil
-}
-
-// GetState returns the current state of a terminal which may be useful to
-// restore the terminal after a signal.
-func GetState(fd int) (*State, error) {
-	termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
-	if err != nil {
-		return nil, err
-	}
-
-	return &State{termios: *termios}, nil
-}
-
-// Restore restores the terminal connected to the given file descriptor to a
-// previous state.
-func Restore(fd int, state *State) error {
-	return unix.IoctlSetTermios(fd, ioctlWriteTermios, &state.termios)
-}
-
-// GetSize returns the dimensions of the given terminal.
-func GetSize(fd int) (width, height int, err error) {
-	ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)
-	if err != nil {
-		return -1, -1, err
-	}
-	return int(ws.Col), int(ws.Row), nil
-}
-
-// passwordReader is an io.Reader that reads from a specific file descriptor.
-type passwordReader int
-
-func (r passwordReader) Read(buf []byte) (int, error) {
-	return unix.Read(int(r), buf)
-}
-
-// ReadPassword reads a line of input from a terminal without local echo.  This
-// is commonly used for inputting passwords and other sensitive data. The slice
-// returned does not include the \n.
-func ReadPassword(fd int) ([]byte, error) {
-	termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
-	if err != nil {
-		return nil, err
-	}
-
-	newState := *termios
-	newState.Lflag &^= unix.ECHO
-	newState.Lflag |= unix.ICANON | unix.ISIG
-	newState.Iflag |= unix.ICRNL
-	if err := unix.IoctlSetTermios(fd, ioctlWriteTermios, &newState); err != nil {
-		return nil, err
-	}
-
-	defer unix.IoctlSetTermios(fd, ioctlWriteTermios, termios)
-
-	return readPasswordLine(passwordReader(fd))
-}