refactor: VeryFastCompile for Task list

.github/workflows/lint.yml

@@ -13,7 +13,7 @@ jobs:
     name: Lint
     strategy:
       matrix:
-        go-version: [1.23.x, 1.24.x]
+        go-version: [1.22.x, 1.23.x]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/setup-go@v5
@@ -25,7 +25,7 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v6
         with:
-          version: v1.64.2
+          version: v1.60.1
 
   lint-jsonschema:
     runs-on: ubuntu-latest

.github/workflows/release.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.23.x
+          go-version: 1.22.x
 
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v6

.github/workflows/test.yml

@@ -13,7 +13,7 @@ jobs:
     name: Test
     strategy:
       matrix:
-        go-version: [1.23.x, 1.24.x]
+        go-version: [1.22.x, 1.23.x]
         platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{matrix.platform}}
     steps:

.golangci.yml

@@ -12,7 +12,7 @@ linters:
     - misspell
     - noctx
     - paralleltest
-    - usetesting
+    - tenv
     - thelper
     - tparallel
 
@@ -29,8 +29,6 @@ linters-settings:
             desc: "Use github.com/go-task/task/v3/errors instead"
   goimports:
     local-prefixes: github.com/go-task
-  gofumpt:
-    module-path: github.com/go-task/task/v3
   gofmt:
     rewrite-rules:
       - pattern: 'interface{}'

CHANGELOG.md

@@ -4,8 +4,6 @@
 
 - Made `--init` less verbose by default and respect `--silent` and `--verbose`
   flags (#2009, #2011 by @HeCorr).
-- `--init` now accepts a file name or directory as an argument (#2008, #2018 by
-  @HeCorr).
 - Fix a bug where an HTTP node's location was being mutated incorrectly (#2007
   by @jeongukjae).
 - Fixed a bug where allowed values didn't work with dynamic var (#2032, #2033 by
@@ -15,59 +13,6 @@
 - Print warnings when attempting to enable an inactive experiment or an active
   experiment with an invalid value (#1979, #2049 by @pd93).
 - Refactored the experiments package and added tests (#2049 by @pd93).
-- Show allowed values when a variable with an enum is missing (#2027, 2052 by
-  @vmaerten).
-- Refactored how snippets in error work and added tests (#2068 by @pd93).
-- Fixed a bug where errors decoding commands were sometimes unhelpful (#2068 by
-  @pd93).
-- Fixed a bug in the Taskfile schema where `defer` statements in the shorthand
-  `cmds` syntax were not considered valid (#2068 by @pd93).
-- Refactored how task sorting functions work (#1798 by @pd93).
-- Added a new `.taskrc.yml` (or `.taskrc.yaml`) file to let users enable
-  experiments (similar to `.env`) (#1982 by @vmaerten).
-
-#### Package API
-
-Unlike our CLI tool,
-[Task's package API is not currently stable](https://taskfile.dev/reference/package).
-In an effort to ease the pain of breaking changes for our users, we will be
-providing changelogs for our package API going forwards. The hope is that these
-changes will provide a better long-term experience for our users and allow to
-stabilize the API in the future. #121 now tracks this piece of work.
-
-- Bumped the minimum required Go version to 1.23 (#2059 by @pd93).
-- [`task.InitTaskfile`](https://pkg.go.dev/github.com/go-task/task/v3#InitTaskfile)
-  (#2011, ff8c913 by @HeCorr and @pd93)
-  - No longer accepts an `io.Writer` (output is now the caller's
-    responsibility).
-  - The path argument can now be a filename OR a directory.
-  - The function now returns the full path of the generated file.
-- [`TaskfileDecodeError.WithFileInfo`](https://pkg.go.dev/github.com/go-task/task/v3/errors#TaskfileDecodeError.WithFileInfo)
-  now accepts a string instead of the arguments required to generate a snippet
-  (#2068 by @pd93).
-  - The caller is now expected to create the snippet themselves (see below).
-- [`TaskfileSnippet`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Snippet)
-  and related code moved from `v3/errors` to `v3/taskfile` (#2068 by @pd93).
-- Renamed `TaskMissingRequiredVars` to
-  [`TaskMissingRequiredVarsError`](https://pkg.go.dev/github.com/go-task/task/v3/errors#TaskMissingRequiredVarsError)
-  (#2052 by @vmaerten).
-- Renamed `TaskNotAllowedVars` to
-  [`TaskNotAllowedVarsError`](https://pkg.go.dev/github.com/go-task/task/v3/errors#TaskNotAllowedVarsError)
-  (#2052 by @vmaerten).
-- The
-  [`taskfile.Reader`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Reader)
-  is now constructed using the functional options pattern (#2082 by @pd93).
-- Removed our internal `logger.Logger` from the entire `v3/taskfile` package
-  (#2082 by @pd93).
-  - Users are now expected to pass a custom debug/prompt functions into
-    [`taskfile.Reader`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Reader)
-    if they want this functionality by using the new
-    [`WithDebugFunc`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#WithDebugFunc)
-    and
-    [`WithPromptFunc`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#WithPromptFunc)
-    functional options.
-- Remove `Range` functions in `v3/taskfile/ast` in favour of new iterator
-  functions (#1798 by @pd93).
 
 ## v3.41.0 - 2025-01-18
 

Taskfile.yml

@@ -120,22 +120,6 @@ tasks:
     cmds:
       - go install github.com/goreleaser/goreleaser/v2@latest
 
-  gorelease:install:
-    desc: "Installs gorelease: https://pkg.go.dev/golang.org/x/exp/cmd/gorelease"
-    status:
-      - command -v gorelease
-    cmds:
-      - go install golang.org/x/exp/cmd/gorelease@latest
-
-  api:check:
-    desc: Checks what changes have been made to the public API
-    deps: [gorelease:install]
-    vars:
-      LATEST:
-        sh: git describe --tags --abbrev=0
-    cmds:
-      - gorelease -base={{.LATEST}}
-
   release:*:
     desc: Prepare the project for a new release
     summary: |

cmd/task/task.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"path/filepath"
 	"strings"
 
 	"github.com/spf13/pflag"
@@ -14,7 +13,6 @@ import (
 	"github.com/go-task/task/v3/args"
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/experiments"
-	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/internal/flags"
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/sort"
@@ -79,28 +77,18 @@ func run() error {
 		if err != nil {
 			return err
 		}
-		args, _, err := getArgs()
-		if err != nil {
-			return err
-		}
-		path := wd
-		if len(args) > 0 {
-			name := args[0]
-			if filepathext.IsExtOnly(name) {
-				name = filepathext.SmartJoin(filepath.Dir(name), "Taskfile"+filepath.Ext(name))
-			}
-			path = filepathext.SmartJoin(wd, name)
-		}
-		finalPath, err := task.InitTaskfile(path)
-		if err != nil {
+
+		if err := task.InitTaskfile(os.Stdout, wd); err != nil {
 			return err
 		}
+
 		if !flags.Silent {
 			if flags.Verbose {
 				log.Outf(logger.Default, "%s\n", task.DefaultTaskfile)
 			}
-			log.Outf(logger.Green, "Taskfile created: %s\n", filepathext.TryAbsToRel(finalPath))
+			log.Outf(logger.Green, "%s created in the current directory\n", task.DefaultTaskFilename)
 		}
+
 		return nil
 	}
 
@@ -125,12 +113,12 @@ func run() error {
 		log.Warnf("%s\n", err.Error())
 	}
 
-	var taskSorter sort.Sorter
+	var taskSorter sort.TaskSorter
 	switch flags.TaskSort {
 	case "none":
-		taskSorter = nil
+		taskSorter = &sort.Noop{}
 	case "alphanumeric":
-		taskSorter = sort.AlphaNumeric
+		taskSorter = &sort.AlphaNumeric{}
 	}
 
 	e := task.Executor{

errors/error_taskfile_decode.go

@@ -2,18 +2,36 @@ package errors
 
 import (
 	"bytes"
-	"cmp"
+	"embed"
 	"errors"
 	"fmt"
 	"regexp"
 	"strings"
 
+	"github.com/alecthomas/chroma/v2"
+	"github.com/alecthomas/chroma/v2/quick"
+	"github.com/alecthomas/chroma/v2/styles"
 	"github.com/fatih/color"
 	"gopkg.in/yaml.v3"
 )
 
+//go:embed themes/*.xml
+var embedded embed.FS
+
 var typeErrorRegex = regexp.MustCompile(`line \d+: (.*)`)
 
+func init() {
+	r, err := embedded.Open("themes/task.xml")
+	if err != nil {
+		panic(err)
+	}
+	style, err := chroma.NewXMLStyle(r)
+	if err != nil {
+		panic(err)
+	}
+	styles.Register(style)
+}
+
 type (
 	TaskfileDecodeError struct {
 		Message  string
@@ -21,9 +39,15 @@ type (
 		Line     int
 		Column   int
 		Tag      string
-		Snippet  string
+		Snippet  TaskfileSnippet
 		Err      error
 	}
+	TaskfileSnippet struct {
+		Lines     []string
+		StartLine int
+		EndLine   int
+		Padding   int
+	}
 )
 
 func NewTaskfileDecodeError(err error, node *yaml.Node) *TaskfileDecodeError {
@@ -64,44 +88,38 @@ func (err *TaskfileDecodeError) Error() string {
 		}
 	}
 	fmt.Fprintln(buf, color.RedString("file: %s:%d:%d", err.Location, err.Line, err.Column))
-	fmt.Fprint(buf, err.Snippet)
-	return buf.String()
-}
 
-func (err *TaskfileDecodeError) Debug() string {
-	const indentWidth = 2
-	buf := &bytes.Buffer{}
-	fmt.Fprintln(buf, "TaskfileDecodeError:")
+	// Print the snippet
+	maxLineNumberDigits := digits(err.Snippet.EndLine)
+	lineNumberSpacer := strings.Repeat(" ", maxLineNumberDigits)
+	columnSpacer := strings.Repeat(" ", err.Column-1)
+	for i, line := range err.Snippet.Lines {
+		currentLine := err.Snippet.StartLine + i + 1
 
-	// Recursively loop through the error chain and print any details
-	var debug func(error, int)
-	debug = func(err error, indent int) {
-		indentStr := strings.Repeat(" ", indent*indentWidth)
+		lineIndicator := " "
+		if currentLine == err.Line {
+			lineIndicator = ">"
+		}
+		columnIndicator := "^"
 
-		// Nothing left to unwrap
-		if err == nil {
-			fmt.Fprintf(buf, "%sEnd of chain\n", indentStr)
-			return
+		// Print each line
+		lineIndicator = color.RedString(lineIndicator)
+		columnIndicator = color.RedString(columnIndicator)
+		lineNumberFormat := fmt.Sprintf("%%%dd", maxLineNumberDigits)
+		lineNumber := fmt.Sprintf(lineNumberFormat, currentLine)
+		fmt.Fprintf(buf, "%s %s | %s", lineIndicator, lineNumber, line)
+
+		// Print the column indicator
+		if currentLine == err.Line {
+			fmt.Fprintf(buf, "\n  %s | %s%s", lineNumberSpacer, columnSpacer, columnIndicator)
 		}
 
-		// Taskfile decode error
-		decodeErr := &TaskfileDecodeError{}
-		if errors.As(err, &decodeErr) {
-			fmt.Fprintf(buf, "%s%s (%s:%d:%d)\n",
-				indentStr,
-				cmp.Or(decodeErr.Message, "<no_message>"),
-				decodeErr.Location,
-				decodeErr.Line,
-				decodeErr.Column,
-			)
-			debug(errors.Unwrap(err), indent+1)
-			return
+		// If there are more lines to print, add a newline
+		if i < len(err.Snippet.Lines)-1 {
+			fmt.Fprintln(buf)
 		}
-
-		fmt.Fprintf(buf, "%s%s\n", indentStr, err)
-		debug(errors.Unwrap(err), indent+1)
 	}
-	debug(err, 0)
+
 	return buf.String()
 }
 
@@ -123,9 +141,23 @@ func (err *TaskfileDecodeError) WithTypeMessage(t string) *TaskfileDecodeError {
 	return err
 }
 
-func (err *TaskfileDecodeError) WithFileInfo(location string, snippet string) *TaskfileDecodeError {
+func (err *TaskfileDecodeError) WithFileInfo(location string, b []byte, padding int) *TaskfileDecodeError {
+	buf := &bytes.Buffer{}
+	if err := quick.Highlight(buf, string(b), "yaml", "terminal", "task"); err != nil {
+		buf.WriteString(string(b))
+	}
+	lines := strings.Split(buf.String(), "\n")
+	start := max(err.Line-1-padding, 0)
+	end := min(err.Line+padding, len(lines)-1)
+
 	err.Location = location
-	err.Snippet = snippet
+	err.Snippet = TaskfileSnippet{
+		Lines:     lines[start:end],
+		StartLine: start,
+		EndLine:   end,
+		Padding:   padding,
+	}
+
 	return err
 }
 
@@ -136,3 +168,12 @@ func extractTypeErrorMessage(message string) string {
 	}
 	return message
 }
+
+func digits(number int) int {
+	count := 0
+	for number != 0 {
+		number /= 10
+		count += 1
+	}
+	return count
+}

errors/errors_task.go

@@ -141,37 +141,21 @@ func (err *TaskCancelledNoTerminalError) Code() int {
 	return CodeTaskCancelled
 }
 
-// TaskMissingRequiredVarsError is returned when a task is missing required variables.
-
-type MissingVar struct {
-	Name          string
-	AllowedValues []string
-}
-type TaskMissingRequiredVarsError struct {
+// TaskMissingRequiredVars is returned when a task is missing required variables.
+type TaskMissingRequiredVars struct {
 	TaskName    string
-	MissingVars []MissingVar
+	MissingVars []string
 }
 
-func (v MissingVar) String() string {
-	if len(v.AllowedValues) == 0 {
-		return v.Name
-	}
-	return fmt.Sprintf("%s (allowed values: %v)", v.Name, v.AllowedValues)
-}
-
-func (err *TaskMissingRequiredVarsError) Error() string {
-	var vars []string
-	for _, v := range err.MissingVars {
-		vars = append(vars, v.String())
-	}
-
+func (err *TaskMissingRequiredVars) Error() string {
 	return fmt.Sprintf(
 		`task: Task %q cancelled because it is missing required variables: %s`,
 		err.TaskName,
-		strings.Join(vars, ", "))
+		strings.Join(err.MissingVars, ", "),
+	)
 }
 
-func (err *TaskMissingRequiredVarsError) Code() int {
+func (err *TaskMissingRequiredVars) Code() int {
 	return CodeTaskMissingRequiredVars
 }
 
@@ -181,12 +165,12 @@ type NotAllowedVar struct {
 	Name  string
 }
 
-type TaskNotAllowedVarsError struct {
+type TaskNotAllowedVars struct {
 	TaskName       string
 	NotAllowedVars []NotAllowedVar
 }
 
-func (err *TaskNotAllowedVarsError) Error() string {
+func (err *TaskNotAllowedVars) Error() string {
 	var builder strings.Builder
 
 	builder.WriteString(fmt.Sprintf("task: Task %q cancelled because it is missing required variables:\n", err.TaskName))
@@ -197,6 +181,6 @@ func (err *TaskNotAllowedVarsError) Error() string {
 	return builder.String()
 }
 
-func (err *TaskNotAllowedVarsError) Code() int {
+func (err *TaskNotAllowedVars) Code() int {
 	return CodeTaskNotAllowedVars
 }

go.mod

@@ -1,6 +1,6 @@
 module github.com/go-task/task/v3
 
-go 1.23.0
+go 1.22.0
 
 require (
 	github.com/Ladicle/tabwriter v1.0.0
@@ -9,7 +9,7 @@ require (
 	github.com/chainguard-dev/git-urls v1.0.2
 	github.com/davecgh/go-spew v1.1.1
 	github.com/dominikbraun/graph v0.23.0
-	github.com/elliotchance/orderedmap/v3 v3.1.0
+	github.com/elliotchance/orderedmap/v2 v2.7.0
 	github.com/fatih/color v1.18.0
 	github.com/go-git/go-billy/v5 v5.6.2
 	github.com/go-git/go-git/v5 v5.13.2
@@ -21,11 +21,11 @@ require (
 	github.com/otiai10/copy v1.14.1
 	github.com/radovskyb/watcher v1.0.7
 	github.com/sajari/fuzzy v1.0.0
-	github.com/spf13/pflag v1.0.6
+	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.10.0
 	github.com/zeebo/xxh3 v1.0.2
-	golang.org/x/sync v0.11.0
-	golang.org/x/term v0.29.0
+	golang.org/x/sync v0.10.0
+	golang.org/x/term v0.28.0
 	gopkg.in/yaml.v3 v3.0.1
 	mvdan.cc/sh/v3 v3.10.0
 )
@@ -56,7 +56,7 @@ require (
 	golang.org/x/crypto v0.32.0 // indirect
 	golang.org/x/mod v0.18.0 // indirect
 	golang.org/x/net v0.34.0 // indirect
-	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/sys v0.29.0 // indirect
 	golang.org/x/tools v0.22.0 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 )

go.sum

@@ -7,10 +7,14 @@ github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lpr
 github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
 github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
 github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
+github.com/ProtonMail/go-crypto v1.1.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk=
+github.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
 github.com/ProtonMail/go-crypto v1.1.5 h1:eoAQfK2dwL+tFSFpr7TbOaPNUbPiJj4fLYwwGE1FQO4=
 github.com/ProtonMail/go-crypto v1.1.5/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
-github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
-github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
+github.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=
+github.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
+github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
+github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
 github.com/alecthomas/chroma/v2 v2.15.0 h1:LxXTQHFoYrstG2nnV9y2X5O94sOBzf0CIUpSTbpxvMc=
 github.com/alecthomas/chroma/v2 v2.15.0/go.mod h1:gUhVLrPDXPtp/f+L1jo9xepo9gL4eLwRuGAunSZMkio=
 github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
@@ -30,14 +34,16 @@ github.com/cyphar/filepath-securejoin v0.3.6/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGL
 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/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
+github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
 github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dominikbraun/graph v0.23.0 h1:TdZB4pPqCLFxYhdyMFb1TBdFxp8XLcJfTTBQucVPgCo=
 github.com/dominikbraun/graph v0.23.0/go.mod h1:yOjYyogZLY1LSG9E33JWZJiq5k83Qy2C6POAuiViluc=
-github.com/elazarl/goproxy v1.4.0 h1:4GyuSbFa+s26+3rmYNSuUVsx+HgPrV1bk1jXI0l9wjM=
-github.com/elazarl/goproxy v1.4.0/go.mod h1:X/5W/t+gzDyLfHW4DrMdpjqYjpXsURlBt9lpBDxZZZQ=
-github.com/elliotchance/orderedmap/v3 v3.1.0 h1:j4DJ5ObEmMBt/lcwIecKcoRxIQUEnw0L804lXYDt/pg=
-github.com/elliotchance/orderedmap/v3 v3.1.0/go.mod h1:G+Hc2RwaZvJMcS4JpGCOyViCnGeKf0bTYCGTO4uhjSo=
+github.com/elazarl/goproxy v1.2.3 h1:xwIyKHbaP5yfT6O9KIeYJR5549MXRQkoQMRXGztz8YQ=
+github.com/elazarl/goproxy v1.2.3/go.mod h1:YfEbZtqP4AetfO6d40vWchF3znWX7C7Vd6ZMfdL8z64=
+github.com/elliotchance/orderedmap/v2 v2.7.0 h1:WHuf0DRo63uLnldCPp9ojm3gskYwEdIIfAUVG5KhoOc=
+github.com/elliotchance/orderedmap/v2 v2.7.0/go.mod h1:85lZyVbpGaGvHvnKa7Qhx7zncAdBIBq6u56Hb1PRU5Q=
 github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
 github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
@@ -46,10 +52,14 @@ github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
 github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
+github.com/go-git/go-billy/v5 v5.6.1 h1:u+dcrgaguSSkbjzHwelEjc0Yj300NUevrrPphk/SoRA=
+github.com/go-git/go-billy/v5 v5.6.1/go.mod h1:0AsLr1z2+Uksi4NlElmMblP5rPcDZNRCD8ujZCRR2BE=
 github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=
 github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=
 github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
 github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
+github.com/go-git/go-git/v5 v5.13.1 h1:DAQ9APonnlvSWpvolXWIuV6Q6zXy2wHbN4cVlNR5Q+M=
+github.com/go-git/go-git/v5 v5.13.1/go.mod h1:qryJB4cSBoq3FRoBRf5A77joojuBcmPJ0qu3XXXVixc=
 github.com/go-git/go-git/v5 v5.13.2 h1:7O7xvsK7K+rZPKW6AQR1YyNhfywkv7B8/FsP3ki6Zv0=
 github.com/go-git/go-git/v5 v5.13.2/go.mod h1:hWdW5P4YZRjmpGHwRH2v3zkWcNl6HeXaXQEMGb3NJ9A=
 github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
@@ -92,10 +102,16 @@ github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELU
 github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
 github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
 github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
+github.com/otiai10/copy v1.14.0 h1:dCI/t1iTdYGtkvCuBG2BgR6KZa83PTclw4U5n2wAllU=
+github.com/otiai10/copy v1.14.0/go.mod h1:ECfuL02W+/FkTWZWgQqXPWZgW9oeKCSQ5qVfSc4qc4w=
 github.com/otiai10/copy v1.14.1 h1:5/7E6qsUMBaH5AnQ0sSLzzTg1oTECmcCmT6lvF45Na8=
 github.com/otiai10/copy v1.14.1/go.mod h1:oQwrEDDOci3IM8dJF0d8+jnbfPDllW6vUjNc3DoZm9I=
+github.com/otiai10/mint v1.5.1 h1:XaPLeE+9vGbuyEHem1JNk3bYc7KKqyI/na0/mLd/Kks=
+github.com/otiai10/mint v1.5.1/go.mod h1:MJm72SBthJjz8qhefc4z1PYEieWmy8Bku7CjcAqyUSM=
 github.com/otiai10/mint v1.6.3 h1:87qsV/aw1F5as1eH1zS/yqHY85ANKVMgkDrf9rcxbQs=
 github.com/otiai10/mint v1.6.3/go.mod h1:MJm72SBthJjz8qhefc4z1PYEieWmy8Bku7CjcAqyUSM=
+github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4=
+github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI=
 github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
 github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -113,8 +129,8 @@ github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
 github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY=
 github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M=
-github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
-github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
@@ -129,6 +145,8 @@ github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN
 github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
 github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
 golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
@@ -136,10 +154,12 @@ golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbR
 golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
 golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
 golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
 golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
-golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
-golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -149,11 +169,15 @@ golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
-golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
+golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
+golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=

help.go

@@ -128,14 +128,18 @@ func (e *Executor) ListTaskNames(allTasks bool) error {
 		w = e.Stdout
 	}
 
+	// Get the list of tasks and sort them
+	tasks := e.Taskfile.Tasks.Values()
+
 	// Sort the tasks
 	if e.TaskSorter == nil {
-		e.TaskSorter = sort.AlphaNumericWithRootTasksFirst
+		e.TaskSorter = &sort.AlphaNumericWithRootTasksFirst{}
 	}
+	e.TaskSorter.Sort(tasks)
 
 	// Create a list of task names
 	taskNames := make([]string, 0, e.Taskfile.Tasks.Len())
-	for task := range e.Taskfile.Tasks.Values(e.TaskSorter) {
+	for _, task := range tasks {
 		if (allTasks || task.Desc != "") && !task.Internal {
 			taskNames = append(taskNames, strings.TrimRight(task.Task, ":"))
 			for _, alias := range task.Aliases {

init.go

@@ -1,6 +1,7 @@
 package task
 
 import (
+	"io"
 	"os"
 
 	"github.com/go-task/task/v3/errors"
@@ -21,31 +22,19 @@ tasks:
     silent: true
 `
 
-const defaultTaskFilename = "Taskfile.yml"
+const DefaultTaskFilename = "Taskfile.yml"
 
-// InitTaskfile creates a new Taskfile at path.
-//
-// path can be either a file path or a directory path.
-// If path is a directory, path/Taskfile.yml will be created.
-//
-// The final file path is always returned and may be different from the input path.
-func InitTaskfile(path string) (string, error) {
-	fi, err := os.Stat(path)
-	if err == nil && !fi.IsDir() {
-		return path, errors.TaskfileAlreadyExistsError{}
+// InitTaskfile creates a new Taskfile
+func InitTaskfile(w io.Writer, dir string) error {
+	f := filepathext.SmartJoin(dir, DefaultTaskFilename)
+
+	if _, err := os.Stat(f); err == nil {
+		return errors.TaskfileAlreadyExistsError{}
 	}
 
-	if fi != nil && fi.IsDir() {
-		path = filepathext.SmartJoin(path, defaultTaskFilename)
-		// path was a directory, so check if Taskfile.yml exists in it
-		if _, err := os.Stat(path); err == nil {
-			return path, errors.TaskfileAlreadyExistsError{}
-		}
+	if err := os.WriteFile(f, []byte(DefaultTaskfile), 0o644); err != nil {
+		return err
 	}
 
-	if err := os.WriteFile(path, []byte(DefaultTaskfile), 0o644); err != nil {
-		return path, err
-	}
-
-	return path, nil
+	return nil
 }

init_test.go

@@ -1,6 +1,7 @@
 package task_test
 
 import (
+	"io"
 	"os"
 	"testing"
 
@@ -8,7 +9,7 @@ import (
 	"github.com/go-task/task/v3/internal/filepathext"
 )
 
-func TestInitDir(t *testing.T) {
+func TestInit(t *testing.T) {
 	t.Parallel()
 
 	const dir = "testdata/init"
@@ -19,34 +20,12 @@ func TestInitDir(t *testing.T) {
 		t.Errorf("Taskfile.yml should not exist")
 	}
 
-	if _, err := task.InitTaskfile(dir); err != nil {
+	if err := task.InitTaskfile(io.Discard, dir); err != nil {
 		t.Error(err)
 	}
 
 	if _, err := os.Stat(file); err != nil {
 		t.Errorf("Taskfile.yml should exist")
 	}
-
-	_ = os.Remove(file)
-}
-
-func TestInitFile(t *testing.T) {
-	t.Parallel()
-
-	const dir = "testdata/init"
-	file := filepathext.SmartJoin(dir, "Tasks.yml")
-
-	_ = os.Remove(file)
-	if _, err := os.Stat(file); err == nil {
-		t.Errorf("Tasks.yml should not exist")
-	}
-
-	if _, err := task.InitTaskfile(file); err != nil {
-		t.Error(err)
-	}
-
-	if _, err := os.Stat(file); err != nil {
-		t.Errorf("Tasks.yml should exist")
-	}
 	_ = os.Remove(file)
 }

internal/compiler/compiler.go

@@ -103,26 +103,18 @@ func (c *Compiler) getVariables(t *ast.Task, call *ast.Call, evaluateShVars bool
 		taskRangeFunc = getRangeFunc(dir)
 	}
 
-	for k, v := range c.TaskfileEnv.All() {
-		if err := rangeFunc(k, v); err != nil {
-			return nil, err
-		}
+	if err := c.TaskfileEnv.Range(rangeFunc); err != nil {
+		return nil, err
 	}
-	for k, v := range c.TaskfileVars.All() {
-		if err := rangeFunc(k, v); err != nil {
-			return nil, err
-		}
+	if err := c.TaskfileVars.Range(rangeFunc); err != nil {
+		return nil, err
 	}
 	if t != nil {
-		for k, v := range t.IncludeVars.All() {
-			if err := rangeFunc(k, v); err != nil {
-				return nil, err
-			}
+		if err := t.IncludeVars.Range(rangeFunc); err != nil {
+			return nil, err
 		}
-		for k, v := range t.IncludedTaskfileVars.All() {
-			if err := taskRangeFunc(k, v); err != nil {
-				return nil, err
-			}
+		if err := t.IncludedTaskfileVars.Range(taskRangeFunc); err != nil {
+			return nil, err
 		}
 	}
 
@@ -130,15 +122,11 @@ func (c *Compiler) getVariables(t *ast.Task, call *ast.Call, evaluateShVars bool
 		return result, nil
 	}
 
-	for k, v := range call.Vars.All() {
-		if err := rangeFunc(k, v); err != nil {
-			return nil, err
-		}
+	if err := call.Vars.Range(rangeFunc); err != nil {
+		return nil, err
 	}
-	for k, v := range t.Vars.All() {
-		if err := taskRangeFunc(k, v); err != nil {
-			return nil, err
-		}
+	if err := t.Vars.Range(taskRangeFunc); err != nil {
+		return nil, err
 	}
 
 	return result, nil

internal/deepcopy/deepcopy.go

@@ -3,7 +3,7 @@ package deepcopy
 import (
 	"reflect"
 
-	"github.com/elliotchance/orderedmap/v3"
+	"github.com/elliotchance/orderedmap/v2"
 )
 
 type Copier[T any] interface {

internal/experiments/errors.go

@@ -2,16 +2,13 @@ package experiments
 
 import (
 	"fmt"
-	"strconv"
 	"strings"
-
-	"github.com/go-task/task/v3/internal/slicesext"
 )
 
 type InvalidValueError struct {
 	Name          string
-	AllowedValues []int
-	Value         int
+	AllowedValues []string
+	Value         string
 }
 
 func (err InvalidValueError) Error() string {
@@ -19,7 +16,7 @@ func (err InvalidValueError) Error() string {
 		"task: Experiment %q has an invalid value %q (allowed values: %s)",
 		err.Name,
 		err.Value,
-		strings.Join(slicesext.Convert(err.AllowedValues, strconv.Itoa), ", "),
+		strings.Join(err.AllowedValues, ", "),
 	)
 }
 

internal/experiments/experiment.go

@@ -3,24 +3,18 @@ package experiments
 import (
 	"fmt"
 	"slices"
-	"strconv"
 )
 
 type Experiment struct {
-	Name          string // The name of the experiment.
-	AllowedValues []int  // The values that can enable this experiment.
-	Value         int    // The version of the experiment that is enabled.
+	Name          string   // The name of the experiment.
+	AllowedValues []string // The values that can enable this experiment.
+	Value         string   // The version of the experiment that is enabled.
 }
 
 // New creates a new experiment with the given name and sets the values that can
 // enable it.
-func New(xName string, allowedValues ...int) Experiment {
-	value := experimentConfig.Experiments[xName]
-
-	if value == 0 {
-		value, _ = strconv.Atoi(getEnv(xName))
-	}
-
+func New(xName string, allowedValues ...string) Experiment {
+	value := getEnv(xName)
 	x := Experiment{
 		Name:          xName,
 		AllowedValues: allowedValues,
@@ -30,21 +24,21 @@ func New(xName string, allowedValues ...int) Experiment {
 	return x
 }
 
-func (x Experiment) Enabled() bool {
+func (x *Experiment) Enabled() bool {
 	return slices.Contains(x.AllowedValues, x.Value)
 }
 
-func (x Experiment) Active() bool {
+func (x *Experiment) Active() bool {
 	return len(x.AllowedValues) > 0
 }
 
 func (x Experiment) Valid() error {
-	if !x.Active() && x.Value != 0 {
+	if !x.Active() && x.Value != "" {
 		return &InactiveError{
 			Name: x.Name,
 		}
 	}
-	if !x.Enabled() && x.Value != 0 {
+	if !x.Enabled() && x.Value != "" {
 		return &InvalidValueError{
 			Name:          x.Name,
 			AllowedValues: x.AllowedValues,
@@ -56,7 +50,7 @@ func (x Experiment) Valid() error {
 
 func (x Experiment) String() string {
 	if x.Enabled() {
-		return fmt.Sprintf("on (%d)", x.Value)
+		return fmt.Sprintf("on (%s)", x.Value)
 	}
 	return "off"
 }

internal/experiments/experiment_test.go

@@ -1,7 +1,6 @@
 package experiments_test
 
 import (
-	"strconv"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -16,8 +15,8 @@ func TestNew(t *testing.T) {
 	)
 	tests := []struct {
 		name          string
-		allowedValues []int
-		value         int
+		allowedValues []string
+		value         string
 		wantEnabled   bool
 		wantActive    bool
 		wantValid     error
@@ -29,7 +28,7 @@ func TestNew(t *testing.T) {
 		},
 		{
 			name:        `[] allowed, value="1"`,
-			value:       1,
+			value:       "1",
 			wantEnabled: false,
 			wantActive:  false,
 			wantValid: &experiments.InactiveError{
@@ -38,33 +37,33 @@ func TestNew(t *testing.T) {
 		},
 		{
 			name:          `[1] allowed, value=""`,
-			allowedValues: []int{1},
+			allowedValues: []string{"1"},
 			wantEnabled:   false,
 			wantActive:    true,
 		},
 		{
 			name:          `[1] allowed, value="1"`,
-			allowedValues: []int{1},
-			value:         1,
+			allowedValues: []string{"1"},
+			value:         "1",
 			wantEnabled:   true,
 			wantActive:    true,
 		},
 		{
 			name:          `[1] allowed, value="2"`,
-			allowedValues: []int{1},
-			value:         2,
+			allowedValues: []string{"1"},
+			value:         "2",
 			wantEnabled:   false,
 			wantActive:    true,
 			wantValid: &experiments.InvalidValueError{
 				Name:          exampleExperiment,
-				AllowedValues: []int{1},
-				Value:         2,
+				AllowedValues: []string{"1"},
+				Value:         "2",
 			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv(exampleExperimentEnv, strconv.Itoa(tt.value))
+			t.Setenv(exampleExperimentEnv, tt.value)
 			x := experiments.New(exampleExperiment, tt.allowedValues...)
 			assert.Equal(t, exampleExperiment, x.Name)
 			assert.Equal(t, tt.wantEnabled, x.Enabled())

internal/experiments/experiments.go

@@ -6,24 +6,13 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/Masterminds/semver/v3"
 	"github.com/joho/godotenv"
 	"github.com/spf13/pflag"
-	"gopkg.in/yaml.v3"
 )
 
 const envPrefix = "TASK_X_"
 
-var defaultConfigFilenames = []string{
-	".taskrc.yml",
-	".taskrc.yaml",
-}
-
-type experimentConfigFile struct {
-	Experiments map[string]int `yaml:"experiments"`
-	Version     *semver.Version
-}
-
+// A set of experiments that can be enabled or disabled.
 var (
 	GentleForce     Experiment
 	RemoteTaskfiles Experiment
@@ -33,19 +22,15 @@ var (
 )
 
 // An internal list of all the initialized experiments used for iterating.
-var (
-	xList            []Experiment
-	experimentConfig experimentConfigFile
-)
+var xList []Experiment
 
 func init() {
 	readDotEnv()
-	experimentConfig = readConfig()
-	GentleForce = New("GENTLE_FORCE", 1)
-	RemoteTaskfiles = New("REMOTE_TASKFILES", 1)
+	GentleForce = New("GENTLE_FORCE", "1")
+	RemoteTaskfiles = New("REMOTE_TASKFILES", "1")
 	AnyVariables = New("ANY_VARIABLES")
-	MapVariables = New("MAP_VARIABLES", 1, 2)
-	EnvPrecedence = New("ENV_PRECEDENCE", 1)
+	MapVariables = New("MAP_VARIABLES", "1", "2")
+	EnvPrecedence = New("ENV_PRECEDENCE", "1")
 }
 
 // Validate checks if any experiments have been enabled while being inactive.
@@ -68,7 +53,7 @@ func getEnv(xName string) string {
 	return os.Getenv(envName)
 }
 
-func getFilePath(filename string) string {
+func getEnvFilePath() string {
 	// Parse the CLI flags again to get the directory/taskfile being run
 	// We use a flagset here so that we can parse a subset of flags without exiting on error.
 	var dir, taskfile string
@@ -79,18 +64,18 @@ func getFilePath(filename string) string {
 	_ = fs.Parse(os.Args[1:])
 	// If the directory is set, find a .env file in that directory.
 	if dir != "" {
-		return filepath.Join(dir, filename)
+		return filepath.Join(dir, ".env")
 	}
 	// If the taskfile is set, find a .env file in the directory containing the Taskfile.
 	if taskfile != "" {
-		return filepath.Join(filepath.Dir(taskfile), filename)
+		return filepath.Join(filepath.Dir(taskfile), ".env")
 	}
 	// Otherwise just use the current working directory.
-	return filename
+	return ".env"
 }
 
 func readDotEnv() {
-	env, _ := godotenv.Read(getFilePath(".env"))
+	env, _ := godotenv.Read(getEnvFilePath())
 	// If the env var is an experiment, set it.
 	for key, value := range env {
 		if strings.HasPrefix(key, envPrefix) {
@@ -98,27 +83,3 @@ func readDotEnv() {
 		}
 	}
 }
-
-func readConfig() experimentConfigFile {
-	var cfg experimentConfigFile
-
-	var content []byte
-	var err error
-	for _, filename := range defaultConfigFilenames {
-		path := getFilePath(filename)
-		content, err = os.ReadFile(path)
-		if err == nil {
-			break
-		}
-	}
-
-	if err != nil {
-		return experimentConfigFile{}
-	}
-
-	if err := yaml.Unmarshal(content, &cfg); err != nil {
-		return experimentConfigFile{}
-	}
-
-	return cfg
-}

internal/filepathext/filepathext.go

@@ -55,9 +55,3 @@ func TryAbsToRel(abs string) string {
 
 	return rel
 }
-
-// IsExtOnly checks whether path points to a file with no name but with
-// an extension, i.e. ".yaml"
-func IsExtOnly(path string) bool {
-	return filepath.Base(path) == filepath.Ext(path)
-}

internal/slicesext/slicesext.go

@@ -18,15 +18,3 @@ func UniqueJoin[T cmp.Ordered](ss ...[]T) []T {
 	slices.Sort(r)
 	return slices.Compact(r)
 }
-
-func Convert[T, U any](s []T, f func(T) U) []U {
-	// Create a new slice with the same length as the input slice
-	result := make([]U, len(s))
-
-	// Convert each element using the provided function
-	for i, v := range s {
-		result[i] = f(v)
-	}
-
-	return result
-}

internal/slicesext/slicesext_test.go

@@ -1,86 +0,0 @@
-package slicesext
-
-import (
-	"math"
-	"strconv"
-	"testing"
-)
-
-func TestConvertIntToString(t *testing.T) {
-	t.Parallel()
-	input := []int{1, 2, 3, 4, 5}
-	expected := []string{"1", "2", "3", "4", "5"}
-	result := Convert(input, strconv.Itoa)
-
-	if len(result) != len(expected) {
-		t.Errorf("Expected length %d, got %d", len(expected), len(result))
-	}
-
-	for i := range expected {
-		if result[i] != expected[i] {
-			t.Errorf("At index %d: expected %v, got %v", i, expected[i], result[i])
-		}
-	}
-}
-
-func TestConvertStringToInt(t *testing.T) {
-	t.Parallel()
-	input := []string{"1", "2", "3", "4", "5"}
-	expected := []int{1, 2, 3, 4, 5}
-	result := Convert(input, func(s string) int {
-		n, _ := strconv.Atoi(s)
-		return n
-	})
-
-	if len(result) != len(expected) {
-		t.Errorf("Expected length %d, got %d", len(expected), len(result))
-	}
-
-	for i := range expected {
-		if result[i] != expected[i] {
-			t.Errorf("At index %d: expected %v, got %v", i, expected[i], result[i])
-		}
-	}
-}
-
-func TestConvertFloatToInt(t *testing.T) {
-	t.Parallel()
-	input := []float64{1.1, 2.2, 3.7, 4.5, 5.9}
-	expected := []int{1, 2, 4, 5, 6}
-	result := Convert(input, func(f float64) int {
-		return int(math.Round(f))
-	})
-
-	if len(result) != len(expected) {
-		t.Errorf("Expected length %d, got %d", len(expected), len(result))
-	}
-
-	for i := range expected {
-		if result[i] != expected[i] {
-			t.Errorf("At index %d: expected %v, got %v", i, expected[i], result[i])
-		}
-	}
-}
-
-func TestConvertEmptySlice(t *testing.T) {
-	t.Parallel()
-	input := []int{}
-	result := Convert(input, strconv.Itoa)
-
-	if len(result) != 0 {
-		t.Errorf("Expected empty slice, got length %d", len(result))
-	}
-}
-
-func TestConvertNilSlice(t *testing.T) {
-	t.Parallel()
-	var input []int
-	result := Convert(input, strconv.Itoa)
-
-	if result == nil {
-		t.Error("Expected non-nil empty slice, got nil")
-	}
-	if len(result) != 0 {
-		t.Errorf("Expected empty slice, got length %d", len(result))
-	}
-}

internal/sort/sorter.go

@@ -3,38 +3,42 @@ package sort
 import (
 	"sort"
 	"strings"
+
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-// A Sorter is any function that sorts a set of tasks.
-type Sorter func(items []string, namespaces []string) []string
-
-// AlphaNumeric sorts the JSON output so that tasks are in alpha numeric order
-// by task name.
-func AlphaNumeric(items []string, namespaces []string) []string {
-	sort.Slice(items, func(i, j int) bool {
-		return items[i] < items[j]
-	})
-	return items
+type TaskSorter interface {
+	Sort([]*ast.Task)
 }
 
-// AlphaNumericWithRootTasksFirst sorts the JSON output so that tasks are in
-// alpha numeric order by task name. It will also ensure that tasks that are not
-// namespaced will be listed before tasks that are. We detect this by searching
-// for a ':' in the task name.
-func AlphaNumericWithRootTasksFirst(items []string, namespaces []string) []string {
-	if len(namespaces) > 0 {
-		return AlphaNumeric(items, namespaces)
-	}
-	sort.Slice(items, func(i, j int) bool {
-		iContainsColon := strings.Contains(items[i], ":")
-		jContainsColon := strings.Contains(items[j], ":")
+type Noop struct{}
+
+func (s *Noop) Sort(tasks []*ast.Task) {}
+
+type AlphaNumeric struct{}
+
+// Tasks that are not namespaced should be listed before tasks that are.
+// We detect this by searching for a ':' in the task name.
+func (s *AlphaNumeric) Sort(tasks []*ast.Task) {
+	sort.Slice(tasks, func(i, j int) bool {
+		return tasks[i].Task < tasks[j].Task
+	})
+}
+
+type AlphaNumericWithRootTasksFirst struct{}
+
+// Tasks that are not namespaced should be listed before tasks that are.
+// We detect this by searching for a ':' in the task name.
+func (s *AlphaNumericWithRootTasksFirst) Sort(tasks []*ast.Task) {
+	sort.Slice(tasks, func(i, j int) bool {
+		iContainsColon := strings.Contains(tasks[i].Task, ":")
+		jContainsColon := strings.Contains(tasks[j].Task, ":")
 		if iContainsColon == jContainsColon {
-			return items[i] < items[j]
+			return tasks[i].Task < tasks[j].Task
 		}
 		if !iContainsColon && jContainsColon {
 			return true
 		}
 		return false
 	})
-	return items
 }

internal/sort/sorter_test.go

@@ -4,37 +4,39 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
 	t.Parallel()
 
-	item1 := "a-item1"
-	item2 := "m-item2"
-	item3 := "ns1:item3"
-	item4 := "ns2:item4"
-	item5 := "z-item5"
-	item6 := "ns3:item6"
+	task1 := &ast.Task{Task: "task1"}
+	task2 := &ast.Task{Task: "task2"}
+	task3 := &ast.Task{Task: "ns1:task3"}
+	task4 := &ast.Task{Task: "ns2:task4"}
+	task5 := &ast.Task{Task: "task5"}
+	task6 := &ast.Task{Task: "ns3:task6"}
 
 	tests := []struct {
 		name  string
-		items []string
-		want  []string
+		tasks []*ast.Task
+		want  []*ast.Task
 	}{
 		{
-			name:  "no namespace items sorted alphabetically first",
-			items: []string{item3, item2, item1},
-			want:  []string{item1, item2, item3},
+			name:  "no namespace tasks sorted alphabetically first",
+			tasks: []*ast.Task{task3, task2, task1},
+			want:  []*ast.Task{task1, task2, task3},
 		},
 		{
-			name:  "namespace items sorted alphabetically after non-namespaced items",
-			items: []string{item3, item4, item5},
-			want:  []string{item5, item3, item4},
+			name:  "namespace tasks sorted alphabetically after non-namespaced tasks",
+			tasks: []*ast.Task{task3, task4, task5},
+			want:  []*ast.Task{task5, task3, task4},
 		},
 		{
-			name:  "all items sorted alphabetically with root items first",
-			items: []string{item6, item5, item4, item3, item2, item1},
-			want:  []string{item1, item2, item5, item3, item4, item6},
+			name:  "all tasks sorted alphabetically with root tasks first",
+			tasks: []*ast.Task{task6, task5, task4, task3, task2, task1},
+			want:  []*ast.Task{task1, task2, task5, task3, task4, task6},
 		},
 	}
 
@@ -42,8 +44,9 @@ func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			AlphaNumericWithRootTasksFirst(tt.items, nil)
-			assert.Equal(t, tt.want, tt.items)
+			s := &AlphaNumericWithRootTasksFirst{}
+			s.Sort(tt.tasks)
+			assert.Equal(t, tt.want, tt.tasks)
 		})
 	}
 }
@@ -51,22 +54,22 @@ func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
 func TestAlphaNumeric_Sort(t *testing.T) {
 	t.Parallel()
 
-	item1 := "a-item1"
-	item2 := "m-item2"
-	item3 := "ns1:item3"
-	item4 := "ns2:item4"
-	item5 := "z-item5"
-	item6 := "ns3:item6"
+	task1 := &ast.Task{Task: "task1"}
+	task2 := &ast.Task{Task: "task2"}
+	task3 := &ast.Task{Task: "ns1:task3"}
+	task4 := &ast.Task{Task: "ns2:task4"}
+	task5 := &ast.Task{Task: "task5"}
+	task6 := &ast.Task{Task: "ns3:task6"}
 
 	tests := []struct {
 		name  string
-		items []string
-		want  []string
+		tasks []*ast.Task
+		want  []*ast.Task
 	}{
 		{
-			name:  "all items sorted alphabetically",
-			items: []string{item3, item2, item5, item1, item4, item6},
-			want:  []string{item1, item2, item3, item4, item6, item5},
+			name:  "all tasks sorted alphabetically",
+			tasks: []*ast.Task{task3, task2, task5, task1, task4, task6},
+			want:  []*ast.Task{task3, task4, task6, task1, task2, task5},
 		},
 	}
 
@@ -74,8 +77,9 @@ func TestAlphaNumeric_Sort(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			AlphaNumeric(tt.items, nil)
-			assert.Equal(t, tt.want, tt.items)
+			s := &AlphaNumeric{}
+			s.Sort(tt.tasks)
+			assert.Equal(t, tt.tasks, tt.want)
 		})
 	}
 }

internal/templater/templater.go

@@ -141,9 +141,10 @@ func ReplaceVarsWithExtra(vars *ast.Vars, cache *Cache, extra map[string]any) *a
 	}
 
 	newVars := ast.NewVars()
-	for k, v := range vars.All() {
+	_ = vars.Range(func(k string, v ast.Var) error {
 		newVars.Set(k, ReplaceVarWithExtra(v, cache, extra))
-	}
+		return nil
+	})
 
 	return newVars
 }

internal/version/version.go

@@ -12,7 +12,7 @@ var (
 
 func init() {
 	info, ok := debug.ReadBuildInfo()
-	if !ok || info.Main.Version == "(devel)" || info.Main.Version == "" {
+	if !ok || info.Main.Version == "" {
 		version = "unknown"
 	} else {
 		if version == "" {

precondition.go

@@ -2,7 +2,6 @@ package task
 
 import (
 	"context"
-	"slices"
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/env"
@@ -15,7 +14,7 @@ import (
 var ErrPreconditionFailed = errors.New("task: precondition not met")
 
 func (e *Executor) areTaskPreconditionsMet(ctx context.Context, t *ast.Task) (bool, error) {
-	for _, p := range slices.Concat(e.Taskfile.Preconditions.Values, t.Preconditions) {
+	for _, p := range t.Preconditions {
 		err := execext.RunCommand(ctx, &execext.RunCommandOptions{
 			Command: p.Sh,
 			Dir:     t.Dir,

requires.go

@@ -12,19 +12,16 @@ func (e *Executor) areTaskRequiredVarsSet(t *ast.Task) error {
 		return nil
 	}
 
-	var missingVars []errors.MissingVar
+	var missingVars []string
 	for _, requiredVar := range t.Requires.Vars {
 		_, ok := t.Vars.Get(requiredVar.Name)
 		if !ok {
-			missingVars = append(missingVars, errors.MissingVar{
-				Name:          requiredVar.Name,
-				AllowedValues: requiredVar.Enum,
-			})
+			missingVars = append(missingVars, requiredVar.Name)
 		}
 	}
 
 	if len(missingVars) > 0 {
-		return &errors.TaskMissingRequiredVarsError{
+		return &errors.TaskMissingRequiredVars{
 			TaskName:    t.Name(),
 			MissingVars: missingVars,
 		}
@@ -54,7 +51,7 @@ func (e *Executor) areTaskRequiredVarsAllowedValuesSet(t *ast.Task) error {
 	}
 
 	if len(notAllowedValuesVars) > 0 {
-		return &errors.TaskNotAllowedVarsError{
+		return &errors.TaskNotAllowedVars{
 			TaskName:       t.Name(),
 			NotAllowedVars: notAllowedValuesVars,
 		}

setup.go

@@ -56,7 +56,7 @@ func (e *Executor) Setup() error {
 }
 
 func (e *Executor) getRootNode() (taskfile.Node, error) {
-	node, err := taskfile.NewRootNode(e.Entrypoint, e.Dir, e.Insecure, e.Timeout)
+	node, err := taskfile.NewRootNode(e.Logger, e.Entrypoint, e.Dir, e.Insecure, e.Timeout)
 	if err != nil {
 		return nil, err
 	}
@@ -65,21 +65,14 @@ func (e *Executor) getRootNode() (taskfile.Node, error) {
 }
 
 func (e *Executor) readTaskfile(node taskfile.Node) error {
-	debugFunc := func(s string) {
-		e.Logger.VerboseOutf(logger.Magenta, s)
-	}
-	promptFunc := func(s string) error {
-		return e.Logger.Prompt(logger.Yellow, s, "n", "y", "yes")
-	}
 	reader := taskfile.NewReader(
 		node,
-		taskfile.WithInsecure(e.Insecure),
-		taskfile.WithDownload(e.Download),
-		taskfile.WithOffline(e.Offline),
-		taskfile.WithTimeout(e.Timeout),
-		taskfile.WithTempDir(e.TempDir.Remote),
-		taskfile.WithDebugFunc(debugFunc),
-		taskfile.WithPromptFunc(promptFunc),
+		e.Insecure,
+		e.Download,
+		e.Offline,
+		e.Timeout,
+		e.TempDir.Remote,
+		e.Logger,
 	)
 	graph, err := reader.Read()
 	if err != nil {
@@ -100,9 +93,12 @@ func (e *Executor) setupFuzzyModel() {
 	model.SetThreshold(1) // because we want to build grammar based on every task name
 
 	var words []string
-	for name, task := range e.Taskfile.Tasks.All(nil) {
-		words = append(words, name)
-		words = slices.Concat(words, task.Aliases)
+	for _, taskName := range e.Taskfile.Tasks.Keys() {
+		words = append(words, taskName)
+
+		for _, task := range e.Taskfile.Tasks.Values() {
+			words = slices.Concat(words, task.Aliases)
+		}
 	}
 
 	model.Train(words)
@@ -219,11 +215,12 @@ func (e *Executor) readDotEnvFiles() error {
 		return err
 	}
 
-	for k, v := range env.All() {
-		if _, ok := e.Taskfile.Env.Get(k); !ok {
-			e.Taskfile.Env.Set(k, v)
+	err = env.Range(func(key string, value ast.Var) error {
+		if _, ok := e.Taskfile.Env.Get(key); !ok {
+			e.Taskfile.Env.Set(key, value)
 		}
-	}
+		return nil
+	})
 	return err
 }
 
@@ -241,7 +238,7 @@ func (e *Executor) setupConcurrencyState() {
 
 	e.taskCallCount = make(map[string]*int32, e.Taskfile.Tasks.Len())
 	e.mkdirMutexMap = make(map[string]*sync.Mutex, e.Taskfile.Tasks.Len())
-	for k := range e.Taskfile.Tasks.Keys(nil) {
+	for _, k := range e.Taskfile.Tasks.Keys() {
 		e.taskCallCount[k] = new(int32)
 		e.mkdirMutexMap[k] = &sync.Mutex{}
 	}

task.go

@@ -74,7 +74,7 @@ type Executor struct {
 	Compiler           *compiler.Compiler
 	Output             output.Output
 	OutputStyle        ast.Output
-	TaskSorter         sort.Sorter
+	TaskSorter         sort.TaskSorter
 	UserWorkingDir     string
 	EnableVersionCheck bool
 
@@ -475,7 +475,7 @@ func (e *Executor) GetTask(call *ast.Call) (*ast.Task, error) {
 	// If didn't find one, search for a task with a matching alias
 	var matchingTask *ast.Task
 	var aliasedTasks []string
-	for task := range e.Taskfile.Tasks.Values(nil) {
+	for _, task := range e.Taskfile.Tasks.Values() {
 		if slices.Contains(task.Aliases, call.Task) {
 			aliasedTasks = append(aliasedTasks, task.Task)
 			matchingTask = task
@@ -511,13 +511,8 @@ func (e *Executor) GetTaskList(filters ...FilterFunc) ([]*ast.Task, error) {
 	// Create an error group to wait for each task to be compiled
 	var g errgroup.Group
 
-	// Sort the tasks
-	if e.TaskSorter == nil {
-		e.TaskSorter = sort.AlphaNumericWithRootTasksFirst
-	}
-
 	// Filter tasks based on the given filter functions
-	for task := range e.Taskfile.Tasks.Values(e.TaskSorter) {
+	for _, task := range e.Taskfile.Tasks.Values() {
 		var shouldFilter bool
 		for _, filter := range filters {
 			if filter(task) {
@@ -532,7 +527,7 @@ func (e *Executor) GetTaskList(filters ...FilterFunc) ([]*ast.Task, error) {
 	// Compile the list of tasks
 	for i := range tasks {
 		g.Go(func() error {
-			compiledTask, err := e.FastCompiledTask(&ast.Call{Task: tasks[i].Task})
+			compiledTask, err := e.CompiledTaskForTaskList(&ast.Call{Task: tasks[i].Task})
 			if err != nil {
 				return err
 			}
@@ -546,6 +541,12 @@ func (e *Executor) GetTaskList(filters ...FilterFunc) ([]*ast.Task, error) {
 		return nil, err
 	}
 
+	// Sort the tasks
+	if e.TaskSorter == nil {
+		e.TaskSorter = &sort.AlphaNumericWithRootTasksFirst{}
+	}
+	e.TaskSorter.Sort(tasks)
+
 	return tasks, nil
 }
 

task_test.go

@@ -135,7 +135,7 @@ func TestEnv(t *testing.T) {
 		},
 	}
 	tt.Run(t)
-	enableExperimentForTest(t, &experiments.EnvPrecedence, 1)
+	enableExperimentForTest(t, &experiments.EnvPrecedence, "1")
 	ttt := fileContentTest{
 		Dir:       "testdata/env",
 		Target:    "overridden",
@@ -186,32 +186,25 @@ func TestRequires(t *testing.T) {
 
 	vars := ast.NewVars()
 	vars.Set("FOO", ast.Var{Value: "bar"})
-
 	require.NoError(t, e.Run(context.Background(), &ast.Call{
 		Task: "missing-var",
 		Vars: vars,
 	}))
 	buff.Reset()
 
-	vars.Set("ENV", ast.Var{Value: "dev"})
 	require.NoError(t, e.Setup())
 	require.ErrorContains(t, e.Run(context.Background(), &ast.Call{Task: "validation-var", Vars: vars}), "task: Task \"validation-var\" cancelled because it is missing required variables:\n  - FOO has an invalid value : 'bar' (allowed values : [one two])")
 	buff.Reset()
 
+	require.NoError(t, e.Setup())
+	require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "validation-var-dynamic", Vars: vars}))
+	buff.Reset()
+
 	require.NoError(t, e.Setup())
 	vars.Set("FOO", ast.Var{Value: "one"})
 	require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "validation-var", Vars: vars}))
 	buff.Reset()
 
-	vars = ast.NewVars()
-	require.NoError(t, e.Setup())
-	require.ErrorContains(t, e.Run(context.Background(), &ast.Call{Task: "validation-var", Vars: vars}), "task: Task \"validation-var\" cancelled because it is missing required variables: ENV, FOO (allowed values: [one two])")
-	buff.Reset()
-
-	require.NoError(t, e.Setup())
-	require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "validation-var-dynamic", Vars: vars}))
-	buff.Reset()
-
 	require.NoError(t, e.Setup())
 	require.ErrorContains(t, e.Run(context.Background(), &ast.Call{Task: "require-before-compile"}), "task: Task \"require-before-compile\" cancelled because it is missing required variables: MY_VAR")
 	buff.Reset()
@@ -456,10 +449,10 @@ func TestStatus(t *testing.T) {
 	buff.Reset()
 }
 
-func TestPreconditionLocal(t *testing.T) {
+func TestPrecondition(t *testing.T) {
 	t.Parallel()
 
-	const dir = "testdata/precondition/local"
+	const dir = "testdata/precondition"
 
 	var buff bytes.Buffer
 	e := &task.Executor{
@@ -499,62 +492,6 @@ func TestPreconditionLocal(t *testing.T) {
 	buff.Reset()
 }
 
-func TestPreconditionGlobal(t *testing.T) {
-	t.Parallel()
-
-	var buff bytes.Buffer
-	e := &task.Executor{
-		Dir:    "testdata/precondition/global",
-		Stdout: &buff,
-		Stderr: &buff,
-	}
-
-	require.NoError(t, e.Setup())
-
-	// A global precondition that was not met
-	require.Error(t, e.Run(context.Background(), &ast.Call{Task: "impossible"}))
-
-	if buff.String() != "task: 1 != 0 obviously!\n" {
-		t.Errorf("Wrong output message: %s", buff.String())
-	}
-	buff.Reset()
-
-	e = &task.Executor{
-		Dir:    "testdata/precondition/global/with_local",
-		Stdout: &buff,
-		Stderr: &buff,
-	}
-
-	require.NoError(t, e.Setup())
-
-	// A global precondition that was met
-	require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "foo"}))
-	if buff.String() != "" {
-		t.Errorf("Got Output when none was expected: %s", buff.String())
-	}
-
-	// A local precondition that was not met
-	require.Error(t, e.Run(context.Background(), &ast.Call{Task: "impossible"}))
-
-	if buff.String() != "task: 1 != 0 obviously!\n" {
-		t.Errorf("Wrong output message: %s", buff.String())
-	}
-
-	buff.Reset()
-
-	e = &task.Executor{
-		Dir:    "testdata/precondition/global/included",
-		Stdout: &buff,
-		Stderr: &buff,
-	}
-
-	err := e.Setup()
-	require.Error(t, err)
-
-	assert.Equal(t, "task: Included Taskfiles can't have preconditions declarations. Please, move the preconditions declaration to the main Taskfile", err.Error())
-	buff.Reset()
-}
-
 func TestGenerates(t *testing.T) {
 	t.Parallel()
 
@@ -1271,7 +1208,7 @@ func TestIncludesMultiLevel(t *testing.T) {
 }
 
 func TestIncludesRemote(t *testing.T) {
-	enableExperimentForTest(t, &experiments.RemoteTaskfiles, 1)
+	enableExperimentForTest(t, &experiments.RemoteTaskfiles, "1")
 
 	dir := "testdata/includes_remote"
 
@@ -1429,7 +1366,7 @@ func TestIncludesEmptyMain(t *testing.T) {
 }
 
 func TestIncludesHttp(t *testing.T) {
-	enableExperimentForTest(t, &experiments.RemoteTaskfiles, 1)
+	enableExperimentForTest(t, &experiments.RemoteTaskfiles, "1")
 
 	dir, err := filepath.Abs("testdata/includes_http")
 	require.NoError(t, err)
@@ -3280,7 +3217,7 @@ func TestReference(t *testing.T) {
 }
 
 func TestVarInheritance(t *testing.T) {
-	enableExperimentForTest(t, &experiments.EnvPrecedence, 1)
+	enableExperimentForTest(t, &experiments.EnvPrecedence, "1")
 	tests := []struct {
 		name string
 		want string
@@ -3388,12 +3325,12 @@ func TestVarInheritance(t *testing.T) {
 //
 // Typically experiments are controlled via TASK_X_ env vars, but we cannot use those in tests
 // because the experiment settings are parsed during experiments.init(), before any tests run.
-func enableExperimentForTest(t *testing.T, e *experiments.Experiment, val int) {
+func enableExperimentForTest(t *testing.T, e *experiments.Experiment, val string) {
 	t.Helper()
 	prev := *e
 	*e = experiments.Experiment{
 		Name:          prev.Name,
-		AllowedValues: []int{val},
+		AllowedValues: []string{val},
 		Value:         val,
 	}
 	t.Cleanup(func() { *e = prev })

taskfile/ast/cmd.go

@@ -51,53 +51,18 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 		return nil
 
 	case yaml.MappingNode:
+
+		// A command with additional options
 		var cmdStruct struct {
 			Cmd         string
-			Task        string
 			For         *For
 			Silent      bool
 			Set         []string
 			Shopt       []string
-			Vars        *Vars
 			IgnoreError bool `yaml:"ignore_error"`
-			Defer       *Defer
 			Platforms   []*Platform
 		}
-		if err := node.Decode(&cmdStruct); err != nil {
-			return errors.NewTaskfileDecodeError(err, node)
-		}
-		if cmdStruct.Defer != nil {
-
-			// A deferred command
-			if cmdStruct.Defer.Cmd != "" {
-				c.Defer = true
-				c.Cmd = cmdStruct.Defer.Cmd
-				c.Silent = cmdStruct.Silent
-				return nil
-			}
-
-			// A deferred task call
-			if cmdStruct.Defer.Task != "" {
-				c.Defer = true
-				c.Task = cmdStruct.Defer.Task
-				c.Vars = cmdStruct.Defer.Vars
-				c.Silent = cmdStruct.Defer.Silent
-				return nil
-			}
-			return nil
-		}
-
-		// A task call
-		if cmdStruct.Task != "" {
-			c.Task = cmdStruct.Task
-			c.Vars = cmdStruct.Vars
-			c.For = cmdStruct.For
-			c.Silent = cmdStruct.Silent
-			return nil
-		}
-
-		// A command with additional options
-		if cmdStruct.Cmd != "" {
+		if err := node.Decode(&cmdStruct); err == nil && cmdStruct.Cmd != "" {
 			c.Cmd = cmdStruct.Cmd
 			c.For = cmdStruct.For
 			c.Silent = cmdStruct.Silent
@@ -108,6 +73,45 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 			return nil
 		}
 
+		// A deferred command
+		var deferredCmd struct {
+			Defer  string
+			Silent bool
+		}
+		if err := node.Decode(&deferredCmd); err == nil && deferredCmd.Defer != "" {
+			c.Defer = true
+			c.Cmd = deferredCmd.Defer
+			c.Silent = deferredCmd.Silent
+			return nil
+		}
+
+		// A deferred task call
+		var deferredCall struct {
+			Defer Call
+		}
+		if err := node.Decode(&deferredCall); err == nil && deferredCall.Defer.Task != "" {
+			c.Defer = true
+			c.Task = deferredCall.Defer.Task
+			c.Vars = deferredCall.Defer.Vars
+			c.Silent = deferredCall.Defer.Silent
+			return nil
+		}
+
+		// A task call
+		var taskCall struct {
+			Task   string
+			Vars   *Vars
+			For    *For
+			Silent bool
+		}
+		if err := node.Decode(&taskCall); err == nil && taskCall.Task != "" {
+			c.Task = taskCall.Task
+			c.Vars = taskCall.Vars
+			c.For = taskCall.For
+			c.Silent = taskCall.Silent
+			return nil
+		}
+
 		return errors.NewTaskfileDecodeError(nil, node).WithMessage("invalid keys in command")
 	}
 

taskfile/ast/defer.go

@@ -1,45 +0,0 @@
-package ast
-
-import (
-	"gopkg.in/yaml.v3"
-
-	"github.com/go-task/task/v3/errors"
-)
-
-type Defer struct {
-	Cmd    string
-	Task   string
-	Vars   *Vars
-	Silent bool
-}
-
-func (d *Defer) UnmarshalYAML(node *yaml.Node) error {
-	switch node.Kind {
-
-	case yaml.ScalarNode:
-		var cmd string
-		if err := node.Decode(&cmd); err != nil {
-			return errors.NewTaskfileDecodeError(err, node)
-		}
-		d.Cmd = cmd
-		return nil
-
-	case yaml.MappingNode:
-		var deferStruct struct {
-			Defer  string
-			Task   string
-			Vars   *Vars
-			Silent bool
-		}
-		if err := node.Decode(&deferStruct); err != nil {
-			return errors.NewTaskfileDecodeError(err, node)
-		}
-		d.Cmd = deferStruct.Defer
-		d.Task = deferStruct.Task
-		d.Vars = deferStruct.Vars
-		d.Silent = deferStruct.Silent
-		return nil
-	}
-
-	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("defer")
-}

taskfile/ast/graph.go

@@ -116,5 +116,14 @@ func (tfg *TaskfileGraph) Merge() (*Taskfile, error) {
 		return nil, err
 	}
 
+	_ = rootVertex.Taskfile.Tasks.Range(func(name string, task *Task) error {
+		if task == nil {
+			task = &Task{}
+			rootVertex.Taskfile.Tasks.Set(name, task)
+		}
+		task.Task = name
+		return nil
+	})
+
 	return rootVertex.Taskfile, nil
 }

taskfile/ast/include.go

@@ -1,10 +1,9 @@
 package ast
 
 import (
-	"iter"
 	"sync"
 
-	"github.com/elliotchance/orderedmap/v3"
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
@@ -85,31 +84,19 @@ func (includes *Includes) Set(key string, value *Include) bool {
 	return includes.om.Set(key, value)
 }
 
-// All returns an iterator that loops over all task key-value pairs.
 // Range calls the provided function for each include in the map. The function
 // receives the include's key and value as arguments. If the function returns
 // an error, the iteration stops and the error is returned.
-func (includes *Includes) All() iter.Seq2[string, *Include] {
+func (includes *Includes) Range(f func(k string, v *Include) error) error {
 	if includes == nil || includes.om == nil {
-		return func(yield func(string, *Include) bool) {}
+		return nil
 	}
-	return includes.om.AllFromFront()
-}
-
-// Keys returns an iterator that loops over all task keys.
-func (includes *Includes) Keys() iter.Seq[string] {
-	if includes == nil || includes.om == nil {
-		return func(yield func(string) bool) {}
+	for pair := includes.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
 	}
-	return includes.om.Keys()
-}
-
-// Values returns an iterator that loops over all task values.
-func (includes *Includes) Values() iter.Seq[*Include] {
-	if includes == nil || includes.om == nil {
-		return func(yield func(*Include) bool) {}
-	}
-	return includes.om.Values()
+	return nil
 }
 
 // UnmarshalYAML implements the yaml.Unmarshaler interface.

taskfile/ast/matrix.go

@@ -1,9 +1,7 @@
 package ast
 
 import (
-	"iter"
-
-	"github.com/elliotchance/orderedmap/v3"
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
@@ -50,28 +48,16 @@ func (matrix *Matrix) Set(key string, value []any) bool {
 	return matrix.om.Set(key, value)
 }
 
-// All returns an iterator that loops over all task key-value pairs.
-func (matrix *Matrix) All() iter.Seq2[string, []any] {
+func (matrix *Matrix) Range(f func(k string, v []any) error) error {
 	if matrix == nil || matrix.om == nil {
-		return func(yield func(string, []any) bool) {}
+		return nil
 	}
-	return matrix.om.AllFromFront()
-}
-
-// Keys returns an iterator that loops over all task keys.
-func (matrix *Matrix) Keys() iter.Seq[string] {
-	if matrix == nil || matrix.om == nil {
-		return func(yield func(string) bool) {}
+	for pair := matrix.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
 	}
-	return matrix.om.Keys()
-}
-
-// Values returns an iterator that loops over all task values.
-func (matrix *Matrix) Values() iter.Seq[[]any] {
-	if matrix == nil || matrix.om == nil {
-		return func(yield func([]any) bool) {}
-	}
-	return matrix.om.Values()
+	return nil
 }
 
 func (matrix *Matrix) DeepCopy() *Matrix {

taskfile/ast/precondition.go

@@ -9,12 +9,10 @@ import (
 )
 
 // Precondition represents a precondition necessary for a task to run
-type (
-	Precondition struct {
-		Sh  string
-		Msg string
-	}
-)
+type Precondition struct {
+	Sh  string
+	Msg string
+}
 
 func (p *Precondition) DeepCopy() *Precondition {
 	if p == nil {

taskfile/ast/preconditions.go

@@ -1,47 +0,0 @@
-package ast
-
-import (
-	"sync"
-
-	"github.com/go-task/task/v3/errors"
-	"github.com/go-task/task/v3/internal/deepcopy"
-
-	"gopkg.in/yaml.v3"
-)
-
-// Precondition represents a precondition necessary for a task to run
-type (
-	Preconditions struct {
-		Values []*Precondition
-		mutex  sync.RWMutex
-	}
-)
-
-func NewPreconditions() *Preconditions {
-	return &Preconditions{
-		Values: make([]*Precondition, 0),
-	}
-}
-
-func (p *Preconditions) DeepCopy() *Preconditions {
-	if p == nil {
-		return nil
-	}
-	defer p.mutex.RUnlock()
-	p.mutex.RLock()
-	return &Preconditions{
-		Values: deepcopy.Slice(p.Values),
-	}
-}
-
-func (p *Preconditions) UnmarshalYAML(node *yaml.Node) error {
-	if p == nil || p.Values == nil {
-		*p = *NewPreconditions()
-	}
-
-	if err := node.Decode(&p.Values); err != nil {
-		return errors.NewTaskfileDecodeError(err, node).WithTypeMessage("preconditions")
-	}
-
-	return nil
-}

taskfile/ast/taskfile.go

@@ -18,26 +18,22 @@ var V3 = semver.MustParse("3")
 // ErrIncludedTaskfilesCantHaveDotenvs is returned when a included Taskfile contains dotenvs
 var ErrIncludedTaskfilesCantHaveDotenvs = errors.New("task: Included Taskfiles can't have dotenv declarations. Please, move the dotenv declaration to the main Taskfile")
 
-// ErrIncludedTaskfilesCantHavePreconditions is returned when a included Taskfile contains Preconditions
-var ErrIncludedTaskfilesCantHavePreconditions = errors.New("task: Included Taskfiles can't have preconditions declarations. Please, move the preconditions declaration to the main Taskfile")
-
 // Taskfile is the abstract syntax tree for a Taskfile
 type Taskfile struct {
-	Location      string
-	Version       *semver.Version
-	Output        Output
-	Method        string
-	Includes      *Includes
-	Set           []string
-	Shopt         []string
-	Vars          *Vars
-	Env           *Vars
-	Preconditions *Preconditions
-	Tasks         *Tasks
-	Silent        bool
-	Dotenv        []string
-	Run           string
-	Interval      time.Duration
+	Location string
+	Version  *semver.Version
+	Output   Output
+	Method   string
+	Includes *Includes
+	Set      []string
+	Shopt    []string
+	Vars     *Vars
+	Env      *Vars
+	Tasks    *Tasks
+	Silent   bool
+	Dotenv   []string
+	Run      string
+	Interval time.Duration
 }
 
 // Merge merges the second Taskfile into the first
@@ -48,9 +44,6 @@ func (t1 *Taskfile) Merge(t2 *Taskfile, include *Include) error {
 	if len(t2.Dotenv) > 0 {
 		return ErrIncludedTaskfilesCantHaveDotenvs
 	}
-	if len(t2.Preconditions.Values) > 0 {
-		return ErrIncludedTaskfilesCantHavePreconditions
-	}
 	if t2.Output.IsSet() {
 		t1.Output = t2.Output
 	}
@@ -66,9 +59,6 @@ func (t1 *Taskfile) Merge(t2 *Taskfile, include *Include) error {
 	if t1.Tasks == nil {
 		t1.Tasks = NewTasks()
 	}
-	if t1.Preconditions == nil {
-		t1.Preconditions = NewPreconditions()
-	}
 	t1.Vars.Merge(t2.Vars, include)
 	t1.Env.Merge(t2.Env, include)
 	return t1.Tasks.Merge(t2.Tasks, include, t1.Vars)
@@ -78,20 +68,19 @@ func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
 	switch node.Kind {
 	case yaml.MappingNode:
 		var taskfile struct {
-			Version       *semver.Version
-			Output        Output
-			Method        string
-			Includes      *Includes
-			Preconditions *Preconditions
-			Set           []string
-			Shopt         []string
-			Vars          *Vars
-			Env           *Vars
-			Tasks         *Tasks
-			Silent        bool
-			Dotenv        []string
-			Run           string
-			Interval      time.Duration
+			Version  *semver.Version
+			Output   Output
+			Method   string
+			Includes *Includes
+			Set      []string
+			Shopt    []string
+			Vars     *Vars
+			Env      *Vars
+			Tasks    *Tasks
+			Silent   bool
+			Dotenv   []string
+			Run      string
+			Interval time.Duration
 		}
 		if err := node.Decode(&taskfile); err != nil {
 			return errors.NewTaskfileDecodeError(err, node)
@@ -109,7 +98,6 @@ func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
 		tf.Dotenv = taskfile.Dotenv
 		tf.Run = taskfile.Run
 		tf.Interval = taskfile.Interval
-		tf.Preconditions = taskfile.Preconditions
 		if tf.Includes == nil {
 			tf.Includes = NewIncludes()
 		}
@@ -122,9 +110,6 @@ func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
 		if tf.Tasks == nil {
 			tf.Tasks = NewTasks()
 		}
-		if tf.Preconditions == nil {
-			tf.Preconditions = NewPreconditions()
-		}
 		return nil
 	}
 

taskfile/ast/tasks.go

@@ -2,17 +2,15 @@ package ast
 
 import (
 	"fmt"
-	"iter"
 	"slices"
 	"strings"
 	"sync"
 
-	"github.com/elliotchance/orderedmap/v3"
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/internal/sort"
 )
 
 type (
@@ -81,47 +79,47 @@ func (tasks *Tasks) Set(key string, value *Task) bool {
 	return tasks.om.Set(key, value)
 }
 
-// All returns an iterator that loops over all task key-value pairs in the order
-// specified by the sorter.
-func (t *Tasks) All(sorter sort.Sorter) iter.Seq2[string, *Task] {
-	if t == nil || t.om == nil {
-		return func(yield func(string, *Task) bool) {}
+// Range calls the provided function for each task in the map. The function
+// receives the task's key and value as arguments. If the function returns an
+// error, the iteration stops and the error is returned.
+func (tasks *Tasks) Range(f func(k string, v *Task) error) error {
+	if tasks == nil || tasks.om == nil {
+		return nil
 	}
-	if sorter == nil {
-		return t.om.AllFromFront()
-	}
-	return func(yield func(string, *Task) bool) {
-		for _, key := range sorter(slices.Collect(t.om.Keys()), nil) {
-			el := t.om.GetElement(key)
-			if !yield(el.Key, el.Value) {
-				return
-			}
+	for pair := tasks.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
 		}
 	}
+	return nil
 }
 
-// Keys returns an iterator that loops over all task keys in the order specified
-// by the sorter.
-func (t *Tasks) Keys(sorter sort.Sorter) iter.Seq[string] {
-	return func(yield func(string) bool) {
-		for k := range t.All(sorter) {
-			if !yield(k) {
-				return
-			}
-		}
+// Keys returns a slice of all the keys in the Tasks map.
+func (tasks *Tasks) Keys() []string {
+	if tasks == nil {
+		return nil
 	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	var keys []string
+	for pair := tasks.om.Front(); pair != nil; pair = pair.Next() {
+		keys = append(keys, pair.Key)
+	}
+	return keys
 }
 
-// Values returns an iterator that loops over all task values in the order
-// specified by the sorter.
-func (t *Tasks) Values(sorter sort.Sorter) iter.Seq[*Task] {
-	return func(yield func(*Task) bool) {
-		for _, v := range t.All(sorter) {
-			if !yield(v) {
-				return
-			}
-		}
+// Values returns a slice of all the values in the Tasks map.
+func (tasks *Tasks) Values() []*Task {
+	if tasks == nil {
+		return nil
 	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	var values []*Task
+	for pair := tasks.om.Front(); pair != nil; pair = pair.Next() {
+		values = append(values, pair.Value)
+	}
+	return values
 }
 
 // FindMatchingTasks returns a list of tasks that match the given call. A task
@@ -140,21 +138,22 @@ func (t *Tasks) FindMatchingTasks(call *Call) []*MatchingTask {
 	}
 	// Attempt a wildcard match
 	// For now, we can just nil check the task before each loop
-	for _, value := range t.All(nil) {
+	_ = t.Range(func(key string, value *Task) error {
 		if match, wildcards := value.WildcardMatch(call.Task); match {
 			matchingTasks = append(matchingTasks, &MatchingTask{
 				Task:      value,
 				Wildcards: wildcards,
 			})
 		}
-	}
+		return nil
+	})
 	return matchingTasks
 }
 
 func (t1 *Tasks) Merge(t2 *Tasks, include *Include, includedTaskfileVars *Vars) error {
 	defer t2.mutex.RUnlock()
 	t2.mutex.RLock()
-	for name, v := range t2.All(nil) {
+	err := t2.Range(func(name string, v *Task) error {
 		// We do a deep copy of the task struct here to ensure that no data can
 		// be changed elsewhere once the taskfile is merged.
 		task := v.DeepCopy()
@@ -163,9 +162,9 @@ func (t1 *Tasks) Merge(t2 *Tasks, include *Include, includedTaskfileVars *Vars)
 		task.Internal = task.Internal || (include != nil && include.Internal)
 		taskName := name
 
-		// if the task is in the exclude list, don't add it to the merged taskfile
+		// if the task is in the exclude list, don't add it to the merged taskfile and early return
 		if slices.Contains(include.Excludes, name) {
-			continue
+			return nil
 		}
 
 		if !include.Flatten {
@@ -220,7 +219,9 @@ func (t1 *Tasks) Merge(t2 *Tasks, include *Include, includedTaskfileVars *Vars)
 		}
 		// Add the task to the merged taskfile
 		t1.Set(taskName, task)
-	}
+
+		return nil
+	})
 
 	// If the included Taskfile has a default task, is not flattened and the
 	// parent namespace has no task with a matching name, we can add an alias so
@@ -238,7 +239,7 @@ func (t1 *Tasks) Merge(t2 *Tasks, include *Include, includedTaskfileVars *Vars)
 		}
 	}
 
-	return nil
+	return err
 }
 
 func (t *Tasks) UnmarshalYAML(node *yaml.Node) error {

taskfile/ast/var.go

@@ -2,13 +2,169 @@ package ast
 
 import (
 	"strings"
+	"sync"
 
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/deepcopy"
 	"github.com/go-task/task/v3/internal/experiments"
 )
 
+type (
+	// Vars is an ordered map of variable names to values.
+	Vars struct {
+		om    *orderedmap.OrderedMap[string, Var]
+		mutex sync.RWMutex
+	}
+	// A VarElement is a key-value pair that is used for initializing a Vars
+	// structure.
+	VarElement orderedmap.Element[string, Var]
+)
+
+// NewVars creates a new instance of Vars and initializes it with the provided
+// set of elements, if any. The elements are added in the order they are passed.
+func NewVars(els ...*VarElement) *Vars {
+	vars := &Vars{
+		om: orderedmap.NewOrderedMap[string, Var](),
+	}
+	for _, el := range els {
+		vars.Set(el.Key, el.Value)
+	}
+	return vars
+}
+
+// Len returns the number of variables in the Vars map.
+func (vars *Vars) Len() int {
+	if vars == nil || vars.om == nil {
+		return 0
+	}
+	defer vars.mutex.RUnlock()
+	vars.mutex.RLock()
+	return vars.om.Len()
+}
+
+// Get returns the value the the variable with the provided key and a boolean
+// that indicates if the value was found or not. If the value is not found, the
+// returned variable is a zero value and the bool is false.
+func (vars *Vars) Get(key string) (Var, bool) {
+	if vars == nil || vars.om == nil {
+		return Var{}, false
+	}
+	defer vars.mutex.RUnlock()
+	vars.mutex.RLock()
+	return vars.om.Get(key)
+}
+
+// Set sets the value of the variable with the provided key to the provided
+// value. If the variable already exists, its value is updated. If the variable
+// does not exist, it is created.
+func (vars *Vars) Set(key string, value Var) bool {
+	if vars == nil {
+		vars = NewVars()
+	}
+	if vars.om == nil {
+		vars.om = orderedmap.NewOrderedMap[string, Var]()
+	}
+	defer vars.mutex.Unlock()
+	vars.mutex.Lock()
+	return vars.om.Set(key, value)
+}
+
+// Range calls the provided function for each variable in the map. The function
+// receives the variable's key and value as arguments. If the function returns
+// an error, the iteration stops and the error is returned.
+func (vars *Vars) Range(f func(k string, v Var) error) error {
+	if vars == nil || vars.om == nil {
+		return nil
+	}
+	for pair := vars.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ToCacheMap converts Vars to an unordered map containing only the static
+// variables
+func (vars *Vars) ToCacheMap() (m map[string]any) {
+	defer vars.mutex.RUnlock()
+	vars.mutex.RLock()
+	m = make(map[string]any, vars.Len())
+	for pair := vars.om.Front(); pair != nil; pair = pair.Next() {
+		if pair.Value.Sh != nil && *pair.Value.Sh != "" {
+			// Dynamic variable is not yet resolved; trigger
+			// <no value> to be used in templates.
+			return nil
+		}
+		if pair.Value.Live != nil {
+			m[pair.Key] = pair.Value.Live
+		} else {
+			m[pair.Key] = pair.Value.Value
+		}
+	}
+	return
+}
+
+// Merge loops over other and merges it values with the variables in vars. If
+// the include parameter is not nil and its it is an advanced import, the
+// directory is set set to the value of the include parameter.
+func (vars *Vars) Merge(other *Vars, include *Include) {
+	if vars == nil || vars.om == nil || other == nil {
+		return
+	}
+	defer other.mutex.RUnlock()
+	other.mutex.RLock()
+	for pair := other.om.Front(); pair != nil; pair = pair.Next() {
+		if include != nil && include.AdvancedImport {
+			pair.Value.Dir = include.Dir
+		}
+		vars.om.Set(pair.Key, pair.Value)
+	}
+}
+
+func (vs *Vars) DeepCopy() *Vars {
+	if vs == nil {
+		return nil
+	}
+	defer vs.mutex.RUnlock()
+	vs.mutex.RLock()
+	return &Vars{
+		om: deepcopy.OrderedMap(vs.om),
+	}
+}
+
+func (vs *Vars) UnmarshalYAML(node *yaml.Node) error {
+	if vs == nil || vs.om == nil {
+		*vs = *NewVars()
+	}
+	vs.om = orderedmap.NewOrderedMap[string, Var]()
+	switch node.Kind {
+	case yaml.MappingNode:
+		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
+		// the map manually. We increment over 2 values at a time and assign
+		// them as a key-value pair.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
+
+			// Decode the value node into a Task struct
+			var v Var
+			if err := valueNode.Decode(&v); err != nil {
+				return errors.NewTaskfileDecodeError(err, node)
+			}
+
+			// Add the task to the ordered map
+			vs.Set(keyNode.Value, v)
+		}
+		return nil
+	}
+
+	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("vars")
+}
+
 // Var represents either a static or dynamic variable.
 type Var struct {
 	Value any
@@ -22,7 +178,7 @@ func (v *Var) UnmarshalYAML(node *yaml.Node) error {
 	if experiments.MapVariables.Enabled() {
 
 		// This implementation is not backwards-compatible and replaces the 'sh' key with map variables
-		if experiments.MapVariables.Value == 1 {
+		if experiments.MapVariables.Value == "1" {
 			var value any
 			if err := node.Decode(&value); err != nil {
 				return errors.NewTaskfileDecodeError(err, node)
@@ -43,7 +199,7 @@ func (v *Var) UnmarshalYAML(node *yaml.Node) error {
 		}
 
 		// This implementation IS backwards-compatible and keeps the 'sh' key and allows map variables to be added under the `map` key
-		if experiments.MapVariables.Value == 2 {
+		if experiments.MapVariables.Value == "2" {
 			switch node.Kind {
 			case yaml.MappingNode:
 				key := node.Content[0].Value

taskfile/ast/vars.go

@@ -1,174 +0,0 @@
-package ast
-
-import (
-	"iter"
-	"sync"
-
-	"github.com/elliotchance/orderedmap/v3"
-	"gopkg.in/yaml.v3"
-
-	"github.com/go-task/task/v3/errors"
-	"github.com/go-task/task/v3/internal/deepcopy"
-)
-
-type (
-	// Vars is an ordered map of variable names to values.
-	Vars struct {
-		om    *orderedmap.OrderedMap[string, Var]
-		mutex sync.RWMutex
-	}
-	// A VarElement is a key-value pair that is used for initializing a Vars
-	// structure.
-	VarElement orderedmap.Element[string, Var]
-)
-
-// NewVars creates a new instance of Vars and initializes it with the provided
-// set of elements, if any. The elements are added in the order they are passed.
-func NewVars(els ...*VarElement) *Vars {
-	vars := &Vars{
-		om: orderedmap.NewOrderedMap[string, Var](),
-	}
-	for _, el := range els {
-		vars.Set(el.Key, el.Value)
-	}
-	return vars
-}
-
-// Len returns the number of variables in the Vars map.
-func (vars *Vars) Len() int {
-	if vars == nil || vars.om == nil {
-		return 0
-	}
-	defer vars.mutex.RUnlock()
-	vars.mutex.RLock()
-	return vars.om.Len()
-}
-
-// Get returns the value the the variable with the provided key and a boolean
-// that indicates if the value was found or not. If the value is not found, the
-// returned variable is a zero value and the bool is false.
-func (vars *Vars) Get(key string) (Var, bool) {
-	if vars == nil || vars.om == nil {
-		return Var{}, false
-	}
-	defer vars.mutex.RUnlock()
-	vars.mutex.RLock()
-	return vars.om.Get(key)
-}
-
-// Set sets the value of the variable with the provided key to the provided
-// value. If the variable already exists, its value is updated. If the variable
-// does not exist, it is created.
-func (vars *Vars) Set(key string, value Var) bool {
-	if vars == nil {
-		vars = NewVars()
-	}
-	if vars.om == nil {
-		vars.om = orderedmap.NewOrderedMap[string, Var]()
-	}
-	defer vars.mutex.Unlock()
-	vars.mutex.Lock()
-	return vars.om.Set(key, value)
-}
-
-// All returns an iterator that loops over all task key-value pairs.
-func (vars *Vars) All() iter.Seq2[string, Var] {
-	if vars == nil || vars.om == nil {
-		return func(yield func(string, Var) bool) {}
-	}
-	return vars.om.AllFromFront()
-}
-
-// Keys returns an iterator that loops over all task keys.
-func (vars *Vars) Keys() iter.Seq[string] {
-	if vars == nil || vars.om == nil {
-		return func(yield func(string) bool) {}
-	}
-	return vars.om.Keys()
-}
-
-// Values returns an iterator that loops over all task values.
-func (vars *Vars) Values() iter.Seq[Var] {
-	if vars == nil || vars.om == nil {
-		return func(yield func(Var) bool) {}
-	}
-	return vars.om.Values()
-}
-
-// ToCacheMap converts Vars to an unordered map containing only the static
-// variables
-func (vars *Vars) ToCacheMap() (m map[string]any) {
-	defer vars.mutex.RUnlock()
-	vars.mutex.RLock()
-	m = make(map[string]any, vars.Len())
-	for k, v := range vars.All() {
-		if v.Sh != nil && *v.Sh != "" {
-			// Dynamic variable is not yet resolved; trigger
-			// <no value> to be used in templates.
-			return nil
-		}
-		if v.Live != nil {
-			m[k] = v.Live
-		} else {
-			m[k] = v.Value
-		}
-	}
-	return
-}
-
-// Merge loops over other and merges it values with the variables in vars. If
-// the include parameter is not nil and its it is an advanced import, the
-// directory is set set to the value of the include parameter.
-func (vars *Vars) Merge(other *Vars, include *Include) {
-	if vars == nil || vars.om == nil || other == nil {
-		return
-	}
-	defer other.mutex.RUnlock()
-	other.mutex.RLock()
-	for pair := other.om.Front(); pair != nil; pair = pair.Next() {
-		if include != nil && include.AdvancedImport {
-			pair.Value.Dir = include.Dir
-		}
-		vars.om.Set(pair.Key, pair.Value)
-	}
-}
-
-func (vs *Vars) DeepCopy() *Vars {
-	if vs == nil {
-		return nil
-	}
-	defer vs.mutex.RUnlock()
-	vs.mutex.RLock()
-	return &Vars{
-		om: deepcopy.OrderedMap(vs.om),
-	}
-}
-
-func (vs *Vars) UnmarshalYAML(node *yaml.Node) error {
-	if vs == nil || vs.om == nil {
-		*vs = *NewVars()
-	}
-	vs.om = orderedmap.NewOrderedMap[string, Var]()
-	switch node.Kind {
-	case yaml.MappingNode:
-		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
-		// the map manually. We increment over 2 values at a time and assign
-		// them as a key-value pair.
-		for i := 0; i < len(node.Content); i += 2 {
-			keyNode := node.Content[i]
-			valueNode := node.Content[i+1]
-
-			// Decode the value node into a Task struct
-			var v Var
-			if err := valueNode.Decode(&v); err != nil {
-				return errors.NewTaskfileDecodeError(err, node)
-			}
-
-			// Add the task to the ordered map
-			vs.Set(keyNode.Value, v)
-		}
-		return nil
-	}
-
-	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("vars")
-}

taskfile/node.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/experiments"
+	"github.com/go-task/task/v3/internal/logger"
 )
 
 type Node interface {
@@ -25,6 +26,7 @@ type Node interface {
 }
 
 func NewRootNode(
+	l *logger.Logger,
 	entrypoint string,
 	dir string,
 	insecure bool,
@@ -35,10 +37,11 @@ func NewRootNode(
 	if entrypoint == "-" {
 		return NewStdinNode(dir)
 	}
-	return NewNode(entrypoint, dir, insecure, timeout)
+	return NewNode(l, entrypoint, dir, insecure, timeout)
 }
 
 func NewNode(
+	l *logger.Logger,
 	entrypoint string,
 	dir string,
 	insecure bool,
@@ -55,9 +58,9 @@ func NewNode(
 	case "git":
 		node, err = NewGitNode(entrypoint, dir, insecure, opts...)
 	case "http", "https":
-		node, err = NewHTTPNode(entrypoint, dir, insecure, timeout, opts...)
+		node, err = NewHTTPNode(l, entrypoint, dir, insecure, timeout, opts...)
 	default:
-		node, err = NewFileNode(entrypoint, dir, opts...)
+		node, err = NewFileNode(l, entrypoint, dir, opts...)
 
 	}
 

taskfile/node_file.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/internal/logger"
 )
 
 // A FileNode is a node that reads a taskfile from the local filesystem.
@@ -17,10 +18,10 @@ type FileNode struct {
 	Entrypoint string
 }
 
-func NewFileNode(entrypoint, dir string, opts ...NodeOption) (*FileNode, error) {
+func NewFileNode(l *logger.Logger, entrypoint, dir string, opts ...NodeOption) (*FileNode, error) {
 	var err error
 	base := NewBaseNode(dir, opts...)
-	entrypoint, base.dir, err = resolveFileNodeEntrypointAndDir(entrypoint, base.dir)
+	entrypoint, base.dir, err = resolveFileNodeEntrypointAndDir(l, entrypoint, base.dir)
 	if err != nil {
 		return nil, err
 	}
@@ -49,10 +50,10 @@ func (node *FileNode) Read(ctx context.Context) ([]byte, error) {
 
 // resolveFileNodeEntrypointAndDir resolves checks the values of entrypoint and dir and
 // populates them with default values if necessary.
-func resolveFileNodeEntrypointAndDir(entrypoint, dir string) (string, string, error) {
+func resolveFileNodeEntrypointAndDir(l *logger.Logger, entrypoint, dir string) (string, string, error) {
 	var err error
 	if entrypoint != "" {
-		entrypoint, err = Exists(entrypoint)
+		entrypoint, err = Exists(l, entrypoint)
 		if err != nil {
 			return "", "", err
 		}
@@ -67,7 +68,7 @@ func resolveFileNodeEntrypointAndDir(entrypoint, dir string) (string, string, er
 			return "", "", err
 		}
 	}
-	entrypoint, err = ExistsWalk(dir)
+	entrypoint, err = ExistsWalk(l, dir)
 	if err != nil {
 		return "", "", err
 	}

taskfile/node_http.go

@@ -11,6 +11,7 @@ import (
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/internal/logger"
 )
 
 // An HTTPNode is a node that reads a Taskfile from a remote location via HTTP.
@@ -18,10 +19,12 @@ type HTTPNode struct {
 	*BaseNode
 	URL        *url.URL // stores url pointing actual remote file. (e.g. with Taskfile.yml)
 	entrypoint string   // stores entrypoint url. used for building graph vertices.
+	logger     *logger.Logger
 	timeout    time.Duration
 }
 
 func NewHTTPNode(
+	l *logger.Logger,
 	entrypoint string,
 	dir string,
 	insecure bool,
@@ -42,6 +45,7 @@ func NewHTTPNode(
 		URL:        url,
 		entrypoint: entrypoint,
 		timeout:    timeout,
+		logger:     l,
 	}, nil
 }
 
@@ -54,7 +58,7 @@ func (node *HTTPNode) Remote() bool {
 }
 
 func (node *HTTPNode) Read(ctx context.Context) ([]byte, error) {
-	url, err := RemoteExists(ctx, node.URL, node.timeout)
+	url, err := RemoteExists(ctx, node.logger, node.URL, node.timeout)
 	if err != nil {
 		return nil, err
 	}

taskfile/reader.go

@@ -14,6 +14,7 @@ import (
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/compiler"
 	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/templater"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
@@ -27,115 +28,40 @@ Continue?`
 Continue?`
 )
 
-type (
-	// ReaderDebugFunc is a function that is called when the reader wants to
-	// log debug messages
-	ReaderDebugFunc func(string)
-	// ReaderPromptFunc is a function that is called when the reader wants to
-	// prompt the user in some way
-	ReaderPromptFunc func(string) error
-	// ReaderOption is a function that configures a Reader.
-	ReaderOption func(*Reader)
-	// A Reader will recursively read Taskfiles from a given source using a directed
-	// acyclic graph (DAG).
-	Reader struct {
-		graph       *ast.TaskfileGraph
-		node        Node
-		insecure    bool
-		download    bool
-		offline     bool
-		timeout     time.Duration
-		tempDir     string
-		debugFunc   ReaderDebugFunc
-		promptFunc  ReaderPromptFunc
-		promptMutex sync.Mutex
-	}
-)
+// A Reader will recursively read Taskfiles from a given source using a directed
+// acyclic graph (DAG).
+type Reader struct {
+	graph       *ast.TaskfileGraph
+	node        Node
+	insecure    bool
+	download    bool
+	offline     bool
+	timeout     time.Duration
+	tempDir     string
+	logger      *logger.Logger
+	promptMutex sync.Mutex
+}
 
-// NewReader constructs a new Taskfile Reader using the given Node and options.
 func NewReader(
 	node Node,
-	opts ...ReaderOption,
+	insecure bool,
+	download bool,
+	offline bool,
+	timeout time.Duration,
+	tempDir string,
+	logger *logger.Logger,
 ) *Reader {
-	reader := &Reader{
+	return &Reader{
 		graph:       ast.NewTaskfileGraph(),
 		node:        node,
-		insecure:    false,
-		download:    false,
-		offline:     false,
-		timeout:     time.Second * 10,
-		tempDir:     os.TempDir(),
-		debugFunc:   nil,
-		promptFunc:  nil,
+		insecure:    insecure,
+		download:    download,
+		offline:     offline,
+		timeout:     timeout,
+		tempDir:     tempDir,
+		logger:      logger,
 		promptMutex: sync.Mutex{},
 	}
-	for _, opt := range opts {
-		opt(reader)
-	}
-	return reader
-}
-
-// WithInsecure enables insecure connections when reading remote taskfiles. By
-// default, insecure connections are rejected.
-func WithInsecure(insecure bool) ReaderOption {
-	return func(r *Reader) {
-		r.insecure = insecure
-	}
-}
-
-// WithDownload forces the reader to download a fresh copy of the taskfile from
-// the remote source.
-func WithDownload(download bool) ReaderOption {
-	return func(r *Reader) {
-		r.download = download
-	}
-}
-
-// WithOffline stops the reader from being able to make network connections.
-// It will still be able to read local files and cached copies of remote files.
-func WithOffline(offline bool) ReaderOption {
-	return func(r *Reader) {
-		r.offline = offline
-	}
-}
-
-// WithTimeout sets the timeout for reading remote taskfiles. By default, the
-// timeout is set to 10 seconds.
-func WithTimeout(timeout time.Duration) ReaderOption {
-	return func(r *Reader) {
-		r.timeout = timeout
-	}
-}
-
-// WithTempDir sets the temporary directory to be used by the reader. By
-// default, the reader uses `os.TempDir()`.
-func WithTempDir(tempDir string) ReaderOption {
-	return func(r *Reader) {
-		r.tempDir = tempDir
-	}
-}
-
-// WithDebugFunc sets the debug function to be used by the reader. If set, this
-// function will be called with debug messages. This can be useful if the caller
-// wants to log debug messages from the reader. By default, no debug function is
-// set and the logs are not written.
-func WithDebugFunc(debugFunc ReaderDebugFunc) ReaderOption {
-	return func(r *Reader) {
-		r.debugFunc = debugFunc
-	}
-}
-
-// WithPromptFunc sets the prompt function to be used by the reader. If set,
-// this function will be called with prompt messages. The function should
-// optionally log the message to the user and return nil if the prompt is
-// accepted and the execution should continue. Otherwise, it should return an
-// error which describes why the the prompt was rejected. This can then be
-// caught and used later when calling the Read method. By default, no prompt
-// function is set and all prompts are automatically accepted.
-func WithPromptFunc(promptFunc ReaderPromptFunc) ReaderOption {
-	return func(r *Reader) {
-		r.promptFunc = promptFunc
-	}
 }
 
 func (r *Reader) Read() (*ast.TaskfileGraph, error) {
@@ -147,19 +73,6 @@ func (r *Reader) Read() (*ast.TaskfileGraph, error) {
 	return r.graph, nil
 }
 
-func (r *Reader) debugf(format string, a ...any) {
-	if r.debugFunc != nil {
-		r.debugFunc(fmt.Sprintf(format, a...))
-	}
-}
-
-func (r *Reader) promptf(format string, a ...any) error {
-	if r.promptFunc != nil {
-		return r.promptFunc(fmt.Sprintf(format, a...))
-	}
-	return nil
-}
-
 func (r *Reader) include(node Node) error {
 	// Create a new vertex for the Taskfile
 	vertex := &ast.TaskfileVertex{
@@ -187,7 +100,7 @@ func (r *Reader) include(node Node) error {
 	var g errgroup.Group
 
 	// Loop over each included taskfile
-	for _, include := range vertex.Taskfile.Includes.All() {
+	_ = vertex.Taskfile.Includes.Range(func(namespace string, include *ast.Include) error {
 		vars := compiler.GetEnviron()
 		vars.Merge(vertex.Taskfile.Vars, nil)
 		// Start a goroutine to process each included Taskfile
@@ -219,7 +132,7 @@ func (r *Reader) include(node Node) error {
 				return err
 			}
 
-			includeNode, err := NewNode(entrypoint, include.Dir, r.insecure, r.timeout,
+			includeNode, err := NewNode(r.logger, entrypoint, include.Dir, r.insecure, r.timeout,
 				WithParent(node),
 			)
 			if err != nil {
@@ -264,7 +177,8 @@ func (r *Reader) include(node Node) error {
 			}
 			return err
 		})
-	}
+		return nil
+	})
 
 	// Wait for all the go routines to finish
 	return g.Wait()
@@ -279,14 +193,9 @@ func (r *Reader) readNode(node Node) (*ast.Taskfile, error) {
 	var tf ast.Taskfile
 	if err := yaml.Unmarshal(b, &tf); err != nil {
 		// Decode the taskfile and add the file info the any errors
-		taskfileDecodeErr := &errors.TaskfileDecodeError{}
-		if errors.As(err, &taskfileDecodeErr) {
-			snippet := NewSnippet(b,
-				SnippetWithLine(taskfileDecodeErr.Line),
-				SnippetWithColumn(taskfileDecodeErr.Column),
-				SnippetWithPadding(2),
-			)
-			return nil, taskfileDecodeErr.WithFileInfo(node.Location(), snippet.String())
+		taskfileInvalidErr := &errors.TaskfileDecodeError{}
+		if errors.As(err, &taskfileInvalidErr) {
+			return nil, taskfileInvalidErr.WithFileInfo(node.Location(), b, 2)
 		}
 		return nil, &errors.TaskfileInvalidError{URI: filepathext.TryAbsToRel(node.Location()), Err: err}
 	}
@@ -298,7 +207,7 @@ func (r *Reader) readNode(node Node) (*ast.Taskfile, error) {
 
 	// Set the taskfile/task's locations
 	tf.Location = node.Location()
-	for task := range tf.Tasks.Values(nil) {
+	for _, task := range tf.Tasks.Values() {
 		// If the task is not defined, create a new one
 		if task == nil {
 			task = &ast.Task{}
@@ -332,7 +241,7 @@ func (r *Reader) loadNodeContent(node Node) ([]byte, error) {
 		} else if err != nil {
 			return nil, err
 		}
-		r.debugf("task: [%s] Fetched cached copy\n", node.Location())
+		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Fetched cached copy\n", node.Location())
 
 		return cached, nil
 	}
@@ -356,14 +265,14 @@ func (r *Reader) loadNodeContent(node Node) ([]byte, error) {
 		} else if err != nil {
 			return nil, err
 		}
-		r.debugf("task: [%s] Network timeout. Fetched cached copy\n", node.Location())
+		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Network timeout. Fetched cached copy\n", node.Location())
 
 		return cached, nil
 
 	} else if err != nil {
 		return nil, err
 	}
-	r.debugf("task: [%s] Fetched remote copy\n", node.Location())
+	r.logger.VerboseOutf(logger.Magenta, "task: [%s] Fetched remote copy\n", node.Location())
 
 	// Get the checksums
 	checksum := checksum(b)
@@ -372,17 +281,17 @@ func (r *Reader) loadNodeContent(node Node) ([]byte, error) {
 	var prompt string
 	if cachedChecksum == "" {
 		// If the checksum doesn't exist, prompt the user to continue
-		prompt = taskfileUntrustedPrompt
+		prompt = fmt.Sprintf(taskfileUntrustedPrompt, node.Location())
 	} else if checksum != cachedChecksum {
 		// If there is a cached hash, but it doesn't match the expected hash, prompt the user to continue
-		prompt = taskfileChangedPrompt
+		prompt = fmt.Sprintf(taskfileChangedPrompt, node.Location())
 	}
 
 	if prompt != "" {
 		if err := func() error {
 			r.promptMutex.Lock()
 			defer r.promptMutex.Unlock()
-			return r.promptf(prompt, node.Location())
+			return r.logger.Prompt(logger.Yellow, prompt, "n", "y", "yes")
 		}(); err != nil {
 			return nil, &errors.TaskfileNotTrustedError{URI: node.Location()}
 		}
@@ -393,7 +302,7 @@ func (r *Reader) loadNodeContent(node Node) ([]byte, error) {
 		}
 
 		// Cache the file
-		r.debugf("task: [%s] Caching downloaded file\n", node.Location())
+		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Caching downloaded file\n", node.Location())
 		if err = cache.write(node, b); err != nil {
 			return nil, err
 		}

taskfile/snippet.go

@@ -1,148 +0,0 @@
-package taskfile
-
-import (
-	"bytes"
-	"embed"
-	"fmt"
-	"strings"
-
-	"github.com/alecthomas/chroma/v2"
-	"github.com/alecthomas/chroma/v2/quick"
-	"github.com/alecthomas/chroma/v2/styles"
-	"github.com/fatih/color"
-)
-
-//go:embed themes/*.xml
-var embedded embed.FS
-
-const (
-	lineIndicator   = ">"
-	columnIndicator = "^"
-)
-
-func init() {
-	r, err := embedded.Open("themes/task.xml")
-	if err != nil {
-		panic(err)
-	}
-	style, err := chroma.NewXMLStyle(r)
-	if err != nil {
-		panic(err)
-	}
-	styles.Register(style)
-}
-
-type (
-	SnippetOption func(*Snippet)
-	Snippet       struct {
-		linesRaw         []string
-		linesHighlighted []string
-		start            int
-		end              int
-		line             int
-		column           int
-		padding          int
-		noIndicators     bool
-	}
-)
-
-// NewSnippet creates a new snippet from a byte slice and a line and column
-// number. The line and column numbers should be 1-indexed. For example, the
-// first character in the file would be 1:1 (line 1, column 1). The padding
-// determines the number of lines to include before and after the chosen line.
-func NewSnippet(b []byte, opts ...SnippetOption) *Snippet {
-	snippet := &Snippet{}
-	for _, opt := range opts {
-		opt(snippet)
-	}
-
-	// Syntax highlight the input and split it into lines
-	buf := &bytes.Buffer{}
-	if err := quick.Highlight(buf, string(b), "yaml", "terminal", "task"); err != nil {
-		buf.WriteString(string(b))
-	}
-	linesRaw := strings.Split(string(b), "\n")
-	linesHighlighted := strings.Split(buf.String(), "\n")
-
-	// Work out the start and end lines of the snippet
-	snippet.start = max(snippet.line-snippet.padding, 1)
-	snippet.end = min(snippet.line+snippet.padding, len(linesRaw)-1)
-	snippet.linesRaw = linesRaw[snippet.start-1 : snippet.end]
-	snippet.linesHighlighted = linesHighlighted[snippet.start-1 : snippet.end]
-
-	return snippet
-}
-
-func SnippetWithLine(line int) SnippetOption {
-	return func(snippet *Snippet) {
-		snippet.line = line
-	}
-}
-
-func SnippetWithColumn(column int) SnippetOption {
-	return func(snippet *Snippet) {
-		snippet.column = column
-	}
-}
-
-func SnippetWithPadding(padding int) SnippetOption {
-	return func(snippet *Snippet) {
-		snippet.padding = padding
-	}
-}
-
-func SnippetWithNoIndicators() SnippetOption {
-	return func(snippet *Snippet) {
-		snippet.noIndicators = true
-	}
-}
-
-func (snippet *Snippet) String() string {
-	buf := &bytes.Buffer{}
-
-	maxLineNumberDigits := digits(snippet.end)
-	lineNumberFormat := fmt.Sprintf("%%%dd", maxLineNumberDigits)
-	lineNumberSpacer := strings.Repeat(" ", maxLineNumberDigits)
-	lineIndicatorSpacer := strings.Repeat(" ", len(lineIndicator))
-	columnSpacer := strings.Repeat(" ", max(snippet.column-1, 0))
-
-	// Loop over each line in the snippet
-	for i, lineHighlighted := range snippet.linesHighlighted {
-		if i > 0 {
-			fmt.Fprintln(buf)
-		}
-
-		currentLine := snippet.start + i
-		lineNumber := fmt.Sprintf(lineNumberFormat, currentLine)
-
-		// If this is a padding line or indicators are disabled, print it as normal
-		if currentLine != snippet.line || snippet.noIndicators {
-			fmt.Fprintf(buf, "%s %s | %s", lineIndicatorSpacer, lineNumber, lineHighlighted)
-			continue
-		}
-
-		// Otherwise, print the line with indicators
-		fmt.Fprintf(buf, "%s %s | %s", color.RedString(lineIndicator), lineNumber, lineHighlighted)
-
-		// Only print the column indicator if the column is in bounds
-		if snippet.column > 0 && snippet.column <= len(snippet.linesRaw[i]) {
-			fmt.Fprintf(buf, "\n%s %s | %s%s", lineIndicatorSpacer, lineNumberSpacer, columnSpacer, color.RedString(columnIndicator))
-		}
-	}
-
-	// If there are lines, but no line is selected, print the column indicator under all the lines
-	if len(snippet.linesHighlighted) > 0 && snippet.line == 0 && snippet.column > 0 {
-		fmt.Fprintf(buf, "\n%s %s | %s%s", lineIndicatorSpacer, lineNumberSpacer, columnSpacer, color.RedString(columnIndicator))
-	}
-
-	return buf.String()
-}
-
-func digits(number int) int {
-	count := 0
-	for number != 0 {
-		number /= 10
-		count += 1
-	}
-	return count
-}

taskfile/snippet_test.go

@@ -1,289 +0,0 @@
-package taskfile
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-const sample = `version: 3
-
-tasks:
-  default:
-    vars:
-      FOO: foo
-      BAR: bar
-    cmds:
-      - echo "{{.FOO}}"
-      - echo "{{.BAR}}"
-`
-
-func TestNewSnippet(t *testing.T) {
-	t.Parallel()
-	tests := []struct {
-		name string
-		b    []byte
-		opts []SnippetOption
-		want *Snippet
-	}{
-		{
-			name: "first line, first column",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(1),
-				SnippetWithColumn(1),
-			},
-			want: &Snippet{
-				linesRaw: []string{
-					"version: 3",
-				},
-				linesHighlighted: []string{
-					"\x1b[33mversion\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36m3\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-				},
-				start:   1,
-				end:     1,
-				line:    1,
-				column:  1,
-				padding: 0,
-			},
-		},
-		{
-			name: "first line, first column, padding=2",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(1),
-				SnippetWithColumn(1),
-				SnippetWithPadding(2),
-			},
-			want: &Snippet{
-				linesRaw: []string{
-					"version: 3",
-					"",
-					"tasks:",
-				},
-				linesHighlighted: []string{
-					"\x1b[33mversion\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36m3\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-					"\x1b[1m\x1b[30m\x1b[0m",
-					"\x1b[33mtasks\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-				},
-				start:   1,
-				end:     3,
-				line:    1,
-				column:  1,
-				padding: 2,
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			got := NewSnippet(tt.b, tt.opts...)
-			require.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func TestSnippetString(t *testing.T) {
-	t.Parallel()
-	tests := []struct {
-		name string
-		b    []byte
-		opts []SnippetOption
-		want string
-	}{
-		{
-			name: "empty",
-			b:    []byte{},
-			opts: []SnippetOption{
-				SnippetWithLine(1),
-				SnippetWithColumn(1),
-			},
-			want: "",
-		},
-		{
-			name: "0th line, 0th column (no indicators)",
-			b:    []byte(sample),
-			want: "",
-		},
-		{
-			name: "1st line, 0th column (line indicator only)",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(1),
-			},
-			want: "> 1 | \x1b[33mversion\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36m3\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-		},
-		{
-			name: "0th line, 1st column (column indicator only)",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithColumn(1),
-			},
-			want: "",
-		},
-		{
-			name: "0th line, 1st column, padding=2 (column indicator only)",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithColumn(1),
-				SnippetWithPadding(2),
-			},
-			want: "  1 | \x1b[33mversion\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36m3\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n  2 | \x1b[1m\x1b[30m\x1b[0m\n    | ^",
-		},
-		{
-			name: "1st line, 1st column",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(1),
-				SnippetWithColumn(1),
-			},
-			want: "> 1 | \x1b[33mversion\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36m3\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n    | ^",
-		},
-		{
-			name: "1st line, 10th column",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(1),
-				SnippetWithColumn(10),
-			},
-			want: "> 1 | \x1b[33mversion\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36m3\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n    |          ^",
-		},
-		{
-			name: "1st line, 1st column, padding=2",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(1),
-				SnippetWithColumn(1),
-				SnippetWithPadding(2),
-			},
-			want: "> 1 | \x1b[33mversion\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36m3\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n    | ^\n  2 | \x1b[1m\x1b[30m\x1b[0m\n  3 | \x1b[33mtasks\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-		},
-		{
-			name: "1st line, 10th column, padding=2",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(1),
-				SnippetWithColumn(10),
-				SnippetWithPadding(2),
-			},
-			want: "> 1 | \x1b[33mversion\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36m3\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n    |          ^\n  2 | \x1b[1m\x1b[30m\x1b[0m\n  3 | \x1b[33mtasks\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-		},
-		{
-			name: "5th line, 1st column",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(5),
-				SnippetWithColumn(1),
-			},
-			want: "> 5 | \x1b[1m\x1b[30m    \x1b[0m\x1b[33mvars\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n    | ^",
-		},
-		{
-			name: "5th line, 5th column",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(5),
-				SnippetWithColumn(5),
-			},
-			want: "> 5 | \x1b[1m\x1b[30m    \x1b[0m\x1b[33mvars\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n    |     ^",
-		},
-		{
-			name: "5th line, 5th column, padding=2",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(5),
-				SnippetWithColumn(5),
-				SnippetWithPadding(2),
-			},
-			want: "  3 | \x1b[33mtasks\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n  4 | \x1b[1m\x1b[30m  \x1b[0m\x1b[33mdefault\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n> 5 | \x1b[1m\x1b[30m    \x1b[0m\x1b[33mvars\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n    |     ^\n  6 | \x1b[1m\x1b[30m      \x1b[0m\x1b[33mFOO\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36mfoo\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n  7 | \x1b[1m\x1b[30m      \x1b[0m\x1b[33mBAR\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36mbar\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-		},
-		{
-			name: "5th line, 5th column, padding=2, no indicators",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(5),
-				SnippetWithColumn(5),
-				SnippetWithPadding(2),
-				SnippetWithNoIndicators(),
-			},
-			want: "  3 | \x1b[33mtasks\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n  4 | \x1b[1m\x1b[30m  \x1b[0m\x1b[33mdefault\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n  5 | \x1b[1m\x1b[30m    \x1b[0m\x1b[33mvars\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n  6 | \x1b[1m\x1b[30m      \x1b[0m\x1b[33mFOO\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36mfoo\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n  7 | \x1b[1m\x1b[30m      \x1b[0m\x1b[33mBAR\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36mbar\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-		},
-		{
-			name: "10th line, 1st column",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(10),
-				SnippetWithColumn(1),
-			},
-			want: "> 10 | \x1b[1m\x1b[30m      \x1b[0m\x1b[1m\x1b[30m- \x1b[0m\x1b[36mecho \"{{.BAR}}\"\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n     | ^",
-		},
-		{
-			name: "10th line, 23rd column",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(10),
-				SnippetWithColumn(23),
-			},
-			want: "> 10 | \x1b[1m\x1b[30m      \x1b[0m\x1b[1m\x1b[30m- \x1b[0m\x1b[36mecho \"{{.BAR}}\"\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n     |                       ^",
-		},
-		{
-			name: "10th line, 24th column (out of bounds)",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(10),
-				SnippetWithColumn(24),
-			},
-			want: "> 10 | \x1b[1m\x1b[30m      \x1b[0m\x1b[1m\x1b[30m- \x1b[0m\x1b[36mecho \"{{.BAR}}\"\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-		},
-		{
-			name: "10th line, 23rd column, padding=2",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(10),
-				SnippetWithColumn(23),
-				SnippetWithPadding(2),
-			},
-			want: "   8 | \x1b[1m\x1b[30m    \x1b[0m\x1b[33mcmds\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n   9 | \x1b[1m\x1b[30m      \x1b[0m\x1b[1m\x1b[30m- \x1b[0m\x1b[36mecho \"{{.FOO}}\"\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n> 10 | \x1b[1m\x1b[30m      \x1b[0m\x1b[1m\x1b[30m- \x1b[0m\x1b[36mecho \"{{.BAR}}\"\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n     |                       ^",
-		},
-		{
-			name: "5th line, 5th column, padding=100",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(5),
-				SnippetWithColumn(5),
-				SnippetWithPadding(100),
-			},
-			want: "   1 | \x1b[33mversion\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36m3\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n   2 | \x1b[1m\x1b[30m\x1b[0m\n   3 | \x1b[33mtasks\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n   4 | \x1b[1m\x1b[30m  \x1b[0m\x1b[33mdefault\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n>  5 | \x1b[1m\x1b[30m    \x1b[0m\x1b[33mvars\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n     |     ^\n   6 | \x1b[1m\x1b[30m      \x1b[0m\x1b[33mFOO\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36mfoo\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n   7 | \x1b[1m\x1b[30m      \x1b[0m\x1b[33mBAR\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m \x1b[0m\x1b[36mbar\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n   8 | \x1b[1m\x1b[30m    \x1b[0m\x1b[33mcmds\x1b[0m\x1b[1m\x1b[30m:\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n   9 | \x1b[1m\x1b[30m      \x1b[0m\x1b[1m\x1b[30m- \x1b[0m\x1b[36mecho \"{{.FOO}}\"\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n  10 | \x1b[1m\x1b[30m      \x1b[0m\x1b[1m\x1b[30m- \x1b[0m\x1b[36mecho \"{{.BAR}}\"\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-		},
-		{
-			name: "11th line (out of bounds), 1st column",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(11),
-				SnippetWithColumn(1),
-			},
-			want: "",
-		},
-		{
-			name: "11th line (out of bounds), 1st column, padding=2",
-			b:    []byte(sample),
-			opts: []SnippetOption{
-				SnippetWithLine(11),
-				SnippetWithColumn(1),
-				SnippetWithPadding(2),
-			},
-			want: "   9 | \x1b[1m\x1b[30m      \x1b[0m\x1b[1m\x1b[30m- \x1b[0m\x1b[36mecho \"{{.FOO}}\"\x1b[0m\x1b[1m\x1b[30m\x1b[0m\n  10 | \x1b[1m\x1b[30m      \x1b[0m\x1b[1m\x1b[30m- \x1b[0m\x1b[36mecho \"{{.BAR}}\"\x1b[0m\x1b[1m\x1b[30m\x1b[0m",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			snippet := NewSnippet(tt.b, tt.opts...)
-			got := snippet.String()
-			if strings.Contains(got, "\t") {
-				t.Fatalf("tab character found in snippet - check the sample string")
-			}
-			require.Equal(t, tt.want, got)
-		})
-	}
-}

taskfile/taskfile.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/sysinfo"
 )
 
@@ -40,7 +41,7 @@ var (
 // at the given URL with any of the default Taskfile files names. If any of
 // these match a file, the first matching path will be returned. If no files are
 // found, an error will be returned.
-func RemoteExists(ctx context.Context, u *url.URL, timeout time.Duration) (*url.URL, error) {
+func RemoteExists(ctx context.Context, l *logger.Logger, u *url.URL, timeout time.Duration) (*url.URL, error) {
 	// Create a new HEAD request for the given URL to check if the resource exists
 	req, err := http.NewRequestWithContext(ctx, "HEAD", u.String(), nil)
 	if err != nil {
@@ -88,6 +89,7 @@ func RemoteExists(ctx context.Context, u *url.URL, timeout time.Duration) (*url.
 
 		// If the request was successful, return the URL
 		if resp.StatusCode == http.StatusOK {
+			l.VerboseOutf(logger.Magenta, "task: [%s] Not found - Using alternative (%s)\n", alt.String(), taskfile)
 			return alt, nil
 		}
 	}
@@ -100,7 +102,7 @@ func RemoteExists(ctx context.Context, u *url.URL, timeout time.Duration) (*url.
 // given path with any of the default Taskfile files names. If any of these
 // match a file, the first matching path will be returned. If no files are
 // found, an error will be returned.
-func Exists(path string) (string, error) {
+func Exists(l *logger.Logger, path string) (string, error) {
 	fi, err := os.Stat(path)
 	if err != nil {
 		return "", err
@@ -115,6 +117,7 @@ func Exists(path string) (string, error) {
 	for _, taskfile := range defaultTaskfiles {
 		alt := filepathext.SmartJoin(path, taskfile)
 		if _, err := os.Stat(alt); err == nil {
+			l.VerboseOutf(logger.Magenta, "task: [%s] Not found - Using alternative (%s)\n", path, taskfile)
 			return filepath.Abs(alt)
 		}
 	}
@@ -127,14 +130,14 @@ func Exists(path string) (string, error) {
 // calling the exists function until it finds a file or reaches the root
 // directory. On supported operating systems, it will also check if the user ID
 // of the directory changes and abort if it does.
-func ExistsWalk(path string) (string, error) {
+func ExistsWalk(l *logger.Logger, path string) (string, error) {
 	origPath := path
 	owner, err := sysinfo.Owner(path)
 	if err != nil {
 		return "", err
 	}
 	for {
-		fpath, err := Exists(path)
+		fpath, err := Exists(l, path)
 		if err == nil {
 			return fpath, nil
 		}

testdata/precondition/global/Taskfile.yml

@@ -1,9 +0,0 @@
-version: '3'
-
-preconditions:
-  - sh: "[ 1 = 0 ]"
-    msg: "1 != 0 obviously!"
-
-tasks:
-  impossible:
-    cmd: echo "won't run"

testdata/precondition/global/included/Taskfile.yml

@@ -1,8 +0,0 @@
-version: 3
-
-includes:
-  included: included.yml
-
-preconditions:
-  - sh: "[ 1 = 0 ]"
-    msg: "1 != 0 obviously!"

testdata/precondition/global/included/included.yml

@@ -1,5 +0,0 @@
-version: 3
-
-preconditions:
-  - sh: "[ 1 = 0 ]"
-    msg: "1 != 0 obviously!"

testdata/precondition/global/with_local/Taskfile.yml

@@ -1,12 +0,0 @@
-version: '3'
-
-preconditions:
-  - test -f foo.txt
-
-tasks:
-  foo:
-
-  impossible:
-    preconditions:
-      - sh: "[ 1 = 0 ]"
-        msg: "1 != 0 obviously!"

testdata/requires/Taskfile.yml

@@ -33,10 +33,10 @@ tasks:
   validation-var:
     requires:
       vars:
-        - ENV
         - name: FOO
           enum: ['one', 'two']
 
+
   require-before-compile:
     requires:
       vars: [ MY_VAR ]

variables.go

@@ -27,6 +27,51 @@ func (e *Executor) FastCompiledTask(call *ast.Call) (*ast.Task, error) {
 	return e.compiledTask(call, false)
 }
 
+func (e *Executor) CompiledTaskForTaskList(call *ast.Call) (*ast.Task, error) {
+	origTask, err := e.GetTask(call)
+	if err != nil {
+		return nil, err
+	}
+
+	vars, err := e.Compiler.FastGetVariables(origTask, call)
+	if err != nil {
+		return nil, err
+	}
+
+	cache := &templater.Cache{Vars: vars}
+
+	return &ast.Task{
+		Task:                 origTask.Task,
+		Label:                templater.Replace(origTask.Label, cache),
+		Desc:                 templater.Replace(origTask.Desc, cache),
+		Prompt:               templater.Replace(origTask.Prompt, cache),
+		Summary:              templater.Replace(origTask.Summary, cache),
+		Aliases:              origTask.Aliases,
+		Sources:              origTask.Sources,
+		Generates:            origTask.Generates,
+		Dir:                  origTask.Dir,
+		Set:                  origTask.Set,
+		Shopt:                origTask.Shopt,
+		Vars:                 vars,
+		Env:                  nil,
+		Dotenv:               origTask.Dotenv,
+		Silent:               origTask.Silent,
+		Interactive:          origTask.Interactive,
+		Internal:             origTask.Internal,
+		Method:               origTask.Method,
+		Prefix:               origTask.Prefix,
+		IgnoreError:          origTask.IgnoreError,
+		Run:                  origTask.Run,
+		IncludeVars:          origTask.IncludeVars,
+		IncludedTaskfileVars: origTask.IncludedTaskfileVars,
+		Platforms:            origTask.Platforms,
+		Location:             origTask.Location,
+		Requires:             origTask.Requires,
+		Watch:                origTask.Watch,
+		Namespace:            origTask.Namespace,
+	}, nil
+}
+
 func (e *Executor) compiledTask(call *ast.Call, evaluateShVars bool) (*ast.Task, error) {
 	origTask, err := e.GetTask(call)
 	if err != nil {
@@ -110,17 +155,21 @@ func (e *Executor) compiledTask(call *ast.Call, evaluateShVars bool) (*ast.Task,
 	new.Env.Merge(templater.ReplaceVars(dotenvEnvs, cache), nil)
 	new.Env.Merge(templater.ReplaceVars(origTask.Env, cache), nil)
 	if evaluateShVars {
-		for k, v := range new.Env.All() {
+		err = new.Env.Range(func(k string, v ast.Var) error {
 			// If the variable is not dynamic, we can set it and return
 			if v.Value != nil || v.Sh == nil {
 				new.Env.Set(k, ast.Var{Value: v.Value})
-				continue
+				return nil
 			}
 			static, err := e.Compiler.HandleDynamicVar(v, new.Dir, env.GetFromVars(new.Env))
 			if err != nil {
-				return nil, err
+				return err
 			}
 			new.Env.Set(k, ast.Var{Value: static})
+			return nil
+		})
+		if err != nil {
+			return nil, err
 		}
 	}
 
@@ -302,7 +351,7 @@ func itemsFromFor(
 			// If the variable is dynamic, then it hasn't been resolved yet
 			// and we can't use it as a list. This happens when fast compiling a task
 			// for use in --list or --list-all etc.
-			if ok && v.Value != nil && v.Sh == nil {
+			if ok && v.Sh == nil {
 				switch value := v.Value.(type) {
 				case string:
 					if f.Split != "" {
@@ -343,7 +392,7 @@ func product(inputMap *ast.Matrix) []map[string]any {
 	result := []map[string]any{{}}
 
 	// Iterate over each slice in the slices
-	for key, slice := range inputMap.All() {
+	_ = inputMap.Range(func(key string, slice []any) error {
 		var newResult []map[string]any
 
 		// For each combination in the current result
@@ -363,7 +412,8 @@ func product(inputMap *ast.Matrix) []map[string]any {
 
 		// Update result with the new combinations
 		result = newResult
-	}
+		return nil
+	})
 
 	return result
 }

website/docs/experiments/experiments.mdx

@@ -3,9 +3,6 @@ slug: /experiments/
 sidebar_position: 6
 ---
 
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-
 # Experiments
 
 :::caution
@@ -42,7 +39,7 @@ Which method you use depends on how you intend to use the experiment:
 1. Prefixing your task commands with the relevant environment variable(s). For
    example, `TASK_X_{FEATURE}=1 task {my-task}`. This is intended for one-off
    invocations of Task to test out experimental features.
-2. Adding the relevant environment variable(s) in your "dotfiles" (e.g.
+1. Adding the relevant environment variable(s) in your "dotfiles" (e.g.
    `.bashrc`, `.zshrc` etc.). This will permanently enable experimental features
    for your personal environment.
 
@@ -50,33 +47,15 @@ Which method you use depends on how you intend to use the experiment:
    export TASK_X_FEATURE=1
    ```
 
-3. Creating a `.env` or a `.task-experiments.yml` file in the same directory as
-   your root Taskfile.\
-   The `.env` file should contain the relevant environment
-   variable(s), while the `.task-experiments.yml` file should use a YAML format
-   where each experiment is defined as a key with a corresponding value.
+1. Creating a `.env` file in the same directory as your root Taskfile that
+   contains the relevant environment variable(s). This allows you to enable an
+   experimental feature at a project level. If you commit the `.env` file to
+   source control then other users of your project will also have these
+   experiments enabled.
 
-   This allows you to enable an experimental feature at a project level. If you
-   commit this file to source control, then other users of your project will
-   also have these experiments enabled.
-
-   If both files are present, the values in the `.task-experiments.yml` file
-   will take precedence.
-
-    <Tabs values={[ {label: '.task-experiments.yml', value: 'yaml'}, {label: '.env', value: 'env'}]}>
-     <TabItem value="yaml">
-       ```yaml title=".taskrc.yml"
-        experiments:
-          FEATURE: 1
-       ```
-     </TabItem>
-
-        <TabItem value="env">
-       ```shell title=".env"
-       TASK_X_FEATURE=1
-       ```
-     </TabItem>
-    </Tabs>
+   ```shell title=".env"
+   TASK_X_FEATURE=1
+   ```
 
 ## Workflow
 

website/docs/reference/cli.mdx

@@ -16,10 +16,10 @@ task [--flags] [tasks...] [-- CLI_ARGS...]
 If `--` is given, all remaining arguments will be assigned to a special
 `CLI_ARGS` variable
 
-:::
-
 ## Flags
 
+:::
+
 | Short | Flag                        | Type     | Default                                      | Description                                                                                                                                                                                  |
 | ----- | --------------------------- | -------- | -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `-c`  | `--color`                   | `bool`   | `true`                                       | Colored output. Enabled by default. Set flag to `false` or use `NO_COLOR=1` to disable.                                                                                                      |
@@ -45,7 +45,7 @@ If `--` is given, all remaining arguments will be assigned to a special
 | `-y`  | `--yes`                     | `bool`   | `false`                                      | Assume "yes" as answer to all prompts.                                                                                                                                                       |
 |       | `--status`                  | `bool`   | `false`                                      | Exits with non-zero exit code if any of the given tasks is not up-to-date.                                                                                                                   |
 |       | `--summary`                 | `bool`   | `false`                                      | Show summary about a task.                                                                                                                                                                   |
-| `-t`  | `--taskfile`                | `string` |                                              | Taskfile path to run.<br />Check the list of default filenames [here](../usage/#supported-file-names).                                                                                        |
+| `-t`  | `--taskfile`                | `string` | `Taskfile.yml` or `Taskfile.yaml`            |                                                                                                                                                                                              |
 | `-v`  | `--verbose`                 | `bool`   | `false`                                      | Enables verbose mode.                                                                                                                                                                        |
 |       | `--version`                 | `bool`   | `false`                                      | Show Task version.                                                                                                                                                                           |
 | `-w`  | `--watch`                   | `bool`   | `false`                                      | Enables watch of the given task.

website/docs/usage.mdx

@@ -1019,28 +1019,6 @@ tasks:
       - echo "I will not run"
 ```
 
-They can be defined at two levels:
-
-- Global Level: Applies to all tasks.
-- Task Level: Applies only to a specific task.
-
-```yaml
-version: '3'
-
-preconditions:
-  - sh: 'exit 1'
-
-tasks:
-  task-will-fail: echo "I will not run"
-```
-
-:::info
-
-Please note that you are not currently able to use the `preconditions` key inside
-included Taskfiles. It'll produce an error.
-
-:::
-
 ### Limiting when tasks run
 
 If a task executed by multiple `cmds` or multiple `deps` you can control when it

website/static/schema-taskrc.json

@@ -1,15 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema",
-  "title": "Taskrc YAML Schema",
-  "description": "Schema for .taskrc files.",
-  "type": "object",
-  "properties": {
-    "experiments": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "integer"
-      }
-    }
-  },
-  "additionalProperties": false
-}

website/static/schema.json

@@ -29,12 +29,6 @@
                   },
                   {
                     "$ref": "#/definitions/task_call"
-                  },
-                  {
-                    "$ref": "#/definitions/defer_task_call"
-                  },
-                  {
-                    "$ref": "#/definitions/defer_cmd_call"
                   }
                 ]
               }
@@ -222,10 +216,7 @@
           "$ref": "#/definitions/task_call"
         },
         {
-          "$ref": "#/definitions/defer_task_call"
-        },
-        {
-          "$ref": "#/definitions/defer_cmd_call"
+          "$ref": "#/definitions/defer_call"
         },
         {
           "$ref": "#/definitions/for_cmds_call"
@@ -359,12 +350,15 @@
       "additionalProperties": false,
       "required": ["cmd"]
     },
-    "defer_task_call": {
+    "defer_call": {
       "type": "object",
       "properties": {
         "defer": {
           "description": "Run a command when the task completes. This command will run even when the task fails",
           "anyOf": [
+            {
+              "type": "string"
+            },
             {
               "$ref": "#/definitions/task_call"
             }
@@ -374,21 +368,6 @@
       "additionalProperties": false,
       "required": ["defer"]
     },
-    "defer_cmd_call": {
-      "type": "object",
-      "properties": {
-        "defer": {
-          "description": "Name of the command to defer",
-          "type": "string"
-        },
-        "silent": {
-          "description": "Hides task name and command from output. The command's output will still be redirected to `STDOUT` and `STDERR`.",
-          "type": "boolean"
-        }
-      },
-      "additionalProperties": false,
-      "required": ["defer"]
-    },
     "for_cmds_call": {
       "type": "object",
       "properties": {
@@ -699,13 +678,6 @@
           "description": "A set of global environment variables.",
           "$ref": "#/definitions/env"
         },
-        "preconditions": {
-          "description": "A list of commands to check if any task should run. If a condition is not met, the task will return an error.",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/precondition"
-          }
-        },
         "tasks": {
           "description": "A set of task definitions.",
           "$ref": "#/definitions/tasks"