Fix Travis CI

Fixes #112

.editorconfig

@@ -7,7 +7,8 @@ insert_final_newline = true
 charset = utf-8
 trim_trailing_whitespace = true
 indent_style = tab
+indent_size = 8
 
-[*.{md,mdx,yml,yaml,json,toml,htm,html,js,ts,css,svg,sh,bash,fish}]
+[*.{md,yml,yaml,json,toml}]
 indent_style = space
 indent_size = 2

.gitattributes

@@ -1,2 +1 @@
 * text=auto
-*.mdx -linguist-detectable

.github/CODE_OF_CONDUCT.md

@@ -34,7 +34,7 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at task@taskfile.dev. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at andrey.nering@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
 
 Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
 

.github/CONTRIBUTING.md

@@ -1,14 +1,12 @@
-## You can find our [contribution guide on our website][contributing]
+* Bug reports and feature requests are welcome in [the issues][issues]
+* For questions and discussion there's the [Slack room][slack] ([invititation here][slackinvite])
+* Pull Requests are welcome. For more complex changes and features it's
+  recommended to open an issue first
+* About 3 or 4 pull requests accepted one gets write access to the repo.
+  Even then, possible backward incompatible changes should be discussed first
+  in an issue or pull request
+* Documentation contributions are as important as code contributions
 
-- Please read it carefully before opening a PR.
-- If you have any questions, you can:
-  - [Open an issue][issues]
-  - [Create a discussion][discussions]
-  - [Chat to us on Discord][discord]
-
-<!-- prettier-ignore-start -->
-[contributing]: https://taskfile.dev/contributing
 [issues]: https://github.com/go-task/task/issues
-[discussions]: https://github.com/go-task/task/discussions
-[discord]: https://discord.gg/6TY36E39UK
-<!-- prettier-ignore-end -->
+[slack]: https://gophers.slack.com/messages/task
+[slackinvite]: https://invite.slack.golangbridge.org/

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-github: [andreynering, pd93, vmaerten]
-open_collective: task
-custom: https://taskfile.dev/donate/

.github/ISSUE_TEMPLATE.md

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

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,69 +0,0 @@
-name: '🐞 Bug Report'
-description: Report a bug in Task.
-labels: ['state: needs-triage']
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for your bug report!
-
-        Before submitting, please check the list of [existing issues](https://github.com/go-task/task/issues) and make sure the same bug was not already reported by someone else.
-
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: Describe the bug you're seeing.
-      placeholder: |
-        - What did you do?
-        - What did you expect to happen?
-        - What happened instead?
-    validations:
-      required: true
-
-  - type: input
-    id: version
-    attributes:
-      label: Version
-      description: What version(s) of Task is the issue occurring on?
-    validations:
-      required: true
-
-  - type: input
-    id: os
-    attributes:
-      label: Operating system
-      description: What operating system(s) is the issue occurring on?
-    validations:
-      required: true
-
-  - type: dropdown
-    id: experiments
-    attributes:
-      label: Experiments Enabled
-      description: Do you have any experiments enabled? You can check by running `task --experiments`.
-      multiple: true
-      options:
-        - Env Precedence
-        - Gentle Force
-        - Map Variables (1)
-        - Map Variables (2)
-        - Remote Taskfiles
-    validations:
-      required: false
-
-  - type: textarea
-    id: logs
-    attributes:
-      label: Example Taskfile
-      description: |
-        If you have a Taskfile that reproduces the issue, please paste it here.
-        This will be automatically formatted into code, so no need for backticks.
-      render: YAML
-      placeholder: |
-        version: '3'
-
-        tasks:
-          default:
-            cmds:
-              - 'echo "This Taskfile is buggy :("'

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: '🔌 Task for Visual Studio Code'
-    url: https://github.com/go-task/vscode-task
-    about: 'Issues related to the Visual Studio Code extension should be opened here.'
-  - name: '💬 Help forum on Discord'
-    url: https://discord.com/channels/974121106208354339/1025054680289660989
-    about: 'The #help channel on our Discord is the best way to get help from the community.'
-  - name: '❓ Questions, Ideas and General Discussions'
-    url: https://github.com/go-task/task/discussions
-    about: 'Ask questions and discuss general ideas with the community.'

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,23 +0,0 @@
-name: '✨ Feature Request'
-description: Suggest a new feature or enhancement for Task.
-labels: ['state: needs-triage']
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for your feature request!
-
-        Before submitting, please check the list of [existing issues](https://github.com/go-task/task/issues) and make sure the same change was not already requested by someone else.
-        If your request is more of an idea than a feature request, consider opening a [discussion](https://github.com/go-task/task/discussions) instead.
-
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: Describe the feature/enhancement you want to see in Task.
-      placeholder: |
-        - Give a general overview of the feature/enhancement.
-        - Explain problem is the change trying to solve.
-        - Give examples of how you would use the feature.
-    validations:
-      required: true

.github/pull_request_template.md

@@ -1,9 +0,0 @@
-<!--
-
-Thanks for your pull request, we really appreciate contributions!
-
-Please understand that it may take some time to be reviewed.
-
-Also, make sure to follow the [Contribution Guide](https://taskfile.dev/contributing/).
-
--->

.github/renovate.json

@@ -1,25 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": [
-    "config:recommended",
-    "group:allNonMajor",
-    "schedule:weekly",
-    ":semanticCommitTypeAll(chore)"
-  ],
-  "mode": "full",
-  "addLabels":["area: dependencies"],
-  "packageRules": [
-    {
-      "matchManagers": ["github-actions"],
-      "addLabels": ["area: github actions"]
-    },
-    {
-      "matchCategories": ["js", "node"],
-      "addLabels": ["lang: javascript"]
-    },
-    {
-      "matchCategories": ["golang"],
-      "addLabels": ["lang: go"]
-    }
-  ]
-}

.github/workflows/issue-awaiting-response.yml

@@ -1,43 +0,0 @@
-name: issue awaiting response
-
-on:
-  issue_comment:
-    types: [created]
-
-jobs:
-  issue-awaiting-response:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            const issue = await github.rest.issues.get({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-            })
-            const comments = await github.paginate(
-              github.rest.issues.listComments, {
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.issue.number,
-              }
-            )
-            const labels = await github.paginate(
-              github.rest.issues.listLabelsOnIssue, {
-                issue_number: context.issue.number,
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-              }
-            )
-            if (labels.find(label => label.name === 'state: awaiting response')) {
-              if (comments[comments.length-1].user?.login === issue.data.user?.login) {
-                github.rest.issues.removeLabel({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  issue_number: context.issue.number,
-                  name: 'state: awaiting response'
-                })
-              }
-            }

.github/workflows/issue-closed.yml

@@ -1,29 +0,0 @@
-name: issue closed
-
-on:
-  issues:
-    types: [closed]
-
-jobs:
-  issue-closed:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            const labels = await github.paginate(
-              github.rest.issues.listLabelsOnIssue, {
-                issue_number: context.issue.number,
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-              }
-            )
-            if (labels.find(label => label.name === 'state: needs triage')) {
-              github.rest.issues.removeLabel({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.issue.number,
-                name: 'state: needs triage'
-              })
-            }

.github/workflows/issue-experiment.yml

@@ -1,123 +0,0 @@
-name: issue experiment
-
-on:
-  issues:
-    types: [labeled]
-
-jobs:
-  issue-experiment-proposed:
-    if: github.event.label.name == format('experiment{0} proposed', ':')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: 'This issue has been marked as an experiment proposal! :test_tube: It will now enter a period of consultation during which we encourage the community to provide feedback on the proposed design. Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
-            })
-  issue-experiment-draft:
-    if: github.event.label.name == format('experiment{0} draft', ':')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: 'This experiment has been marked as a draft! :sparkles: This means that an initial implementation has been added to the latest release of Task! You can find information about this experiment and how to enable it in our [experiments documentation](https://taskfile.dev/experiments). Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
-            })
-  issue-experiment-candidate:
-    if: github.event.label.name == format('experiment{0} candidate', ':')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: 'This experiment has been marked as a candidate! :fire: This means that the  implementation is nearing completion and we are entering a period for final comments and feedback! You can find information about this experiment and how to enable it in our [experiments documentation](https://taskfile.dev/experiments). Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
-            })
-  issue-experiment-stable:
-    if: github.event.label.name == format('experiment{0} stable', ':')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: 'This experiment has been marked as stable! :metal: This means that the  implementation is now final and ready to be released. No more changes will be made and the experiment is safe to use in production! You can find information about this experiment and how to enable it in our [experiments documentation](https://taskfile.dev/experiments). Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
-            })
-  issue-experiment-released:
-    if: github.event.label.name == format('experiment{0} released', ':')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: 'This experiment has been released! :rocket: This means that it is no longer an experiment and is available in the latest major version of Task. Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
-            })
-            github.rest.issues.update({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              state: 'closed'
-            })
-  issue-experiment-abandoned:
-    if: github.event.label.name == format('experiment{0} abandoned', ':')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: 'This experiment has been abandoned. :disappointed: This means that this feature will not be added to Task and any experimental functionality will be removed. Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
-            })
-            github.rest.issues.update({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              state: 'closed'
-            })
-  issue-experiment-superseded:
-    if: github.event.label.name == format('experiment{0} superseded', ':')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: 'This experiment has been superseded. :seedling: This means that another experiment has replaced this one. Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
-            })
-            github.rest.issues.update({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              state: 'closed'
-            })

.github/workflows/issue-needs-triage.yml

@@ -1,29 +0,0 @@
-name: issue needs triage
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  issue-needs-triage:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{secrets.GH_PAT}}
-          script: |
-            const labels = await github.paginate(
-              github.rest.issues.listLabelsOnIssue, {
-                issue_number: context.issue.number,
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-              }
-            )
-            if (labels.length === 0) {
-              github.rest.issues.addLabels({
-                issue_number: context.issue.number,
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                labels: ['state: needs triage']
-              })
-            }

.github/workflows/lint.yml

@@ -1,58 +0,0 @@
-name: Lint
-
-on:
-  pull_request:
-  push:
-    tags:
-      - v*
-    branches:
-      - main
-
-jobs:
-  lint:
-    name: Lint
-    strategy:
-      matrix:
-        go-version: [1.23.x, 1.24.x]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/setup-go@v5
-        with:
-          go-version: ${{matrix.go-version}}
-
-      - uses: actions/checkout@v4
-
-      - name: golangci-lint
-        uses: golangci/golangci-lint-action@v6
-        with:
-          version: v1.64.2
-
-  lint-jsonschema:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/setup-python@v5
-        with:
-          python-version: 3.12
-
-      - uses: actions/checkout@v4
-
-      - name: install check-jsonschema
-        run: python -m pip install 'check-jsonschema==0.27.3'
-
-      - name: check-jsonschema (metaschema)
-        run: check-jsonschema --check-metaschema website/static/schema.json
-  check_doc:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Get changed files in the docs folder
-        id: changed-files-specific
-        uses: tj-actions/changed-files@v45
-        with:
-          files: website/versioned_docs/**
-
-      - uses: actions/github-script@v7
-        if: steps.changed-files-specific.outputs.any_changed == 'true'
-        with:
-          script: |
-            core.setFailed('website/versioned_docs has changed. Instead you need to update the docs in the website/docs folder.')

.github/workflows/release.yml

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

.github/workflows/test.yml

@@ -1,38 +0,0 @@
-name: Test
-
-on:
-  pull_request:
-  push:
-    tags:
-      - v*
-    branches:
-      - main
-
-jobs:
-  test:
-    name: Test
-    strategy:
-      matrix:
-        go-version: [1.23.x, 1.24.x]
-        platform: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{matrix.platform}}
-    steps:
-      - name: Set up Go ${{matrix.go-version}}
-        uses: actions/setup-go@v5
-        with:
-          go-version: ${{matrix.go-version}}
-        id: go
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
-
-      - name: Download Go modules
-        run: go mod download
-        env:
-          GOPROXY: https://proxy.golang.org
-
-      - name: Build
-        run: go build -o ./bin/task -v ./cmd/task
-
-      - name: Test
-        run: ./bin/task test --output=group --output-group-begin='::group::{{.TASK}}' --output-group-end='::endgroup::'

.gitignore

@@ -10,28 +10,10 @@
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
-# Graphvis files
-*.gv
-
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/
 
 ./task
-.task
 dist/
 
 .DS_Store
-
-# editors
-.idea/
-.vscode/settings.json
-.fleet/
-
-# exuberant ctags
-tags
-
-/bin/*
-!/bin/.keep
-/testdata/vars/v1
-/tmp
-node_modules

.golangci.yml

@@ -1,38 +0,0 @@
-# NOTE(@andreynering): The linters listed here are additions on top of
-# those enabled by default:
-#
-# https://golangci-lint.run/usage/linters/#enabled-by-default
-
-linters:
-  enable:
-    - depguard
-    - goimports
-    - gofmt
-    - gofumpt
-    - mirror
-    - misspell
-    - noctx
-    - paralleltest
-    - usetesting
-    - thelper
-    - tparallel
-
-linters-settings:
-  depguard:
-    rules:
-      main:
-        files:
-          - "$all"
-          - "!$test"
-          - "!**/errors/*.go"
-        deny:
-          - pkg: "errors"
-            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{}'
-        replacement: 'any'

.goreleaser.yml

@@ -1,133 +1,42 @@
-# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
-version: 2
+build:
+  binary: task
+  main: cmd/task/task.go
+  goos:
+    - windows
+    - darwin
+    - linux
+  goarch:
+    - 386
+    - amd64
+  ignore:
+    - goos: darwin
+      goarch: 386
 
-builds:
-  - binary: task
-    main: ./cmd/task
-    goos:
-      - windows
-      - darwin
-      - linux
-      - freebsd
-    goarch:
-      - '386'
-      - amd64
-      - arm
-      - arm64
-      - riscv64
-    goarm:
-      - '6'
-    ignore:
-      - goos: darwin
-        goarch: '386'
-      - goos: darwin
-        goarch: riscv64
-      - goos: windows
-        goarch: riscv64
-    env:
-      - CGO_ENABLED=0
-    mod_timestamp: '{{ .CommitTimestamp }}'
-    flags:
-      - -trimpath
-    ldflags:
-      - -s -w # Don't set main.version.
+archive:
+  name_template: "{{.Binary}}_{{.Os}}_{{.Arch}}"
 
-gomod:
-  proxy: true
-
-archives:
-  - name_template: "{{.Binary}}_{{.Os}}_{{.Arch}}"
-    files:
-      - README.md
-      - LICENSE
-      - completion/**/*
-    format_overrides:
-      - goos: windows
-        format: zip
+  format_overrides:
+    - goos: windows
+      format: zip
 
 release:
   draft: true
 
 snapshot:
-  version_template: "{{.Version}}"
+  name_template: "{{.Tag}}"
 
 checksum:
   name_template: "task_checksums.txt"
 
-nfpms:
-  - vendor: Task
-    homepage: https://taskfile.dev
-    maintainer: The Task authors <task@taskfile.dev>
-    description: Simple task runner written in Go
-    license: MIT
-    conflicts:
-      - taskwarrior
-    formats:
-      - deb
-      - rpm
-    file_name_template: "{{.ProjectName}}_{{.Os}}_{{.Arch}}"
-    contents:
-      - src: completion/bash/task.bash
-        dst: /etc/bash_completion.d/task
-      - src: completion/fish/task.fish
-        dst: /usr/share/fish/completions/task.fish
-      - src: completion/zsh/_task
-        dst: /usr/local/share/zsh/site-functions/_task
-
-brews:
-  - name: go-task
-    description: Task runner / simpler Make alternative written in Go
-    license: MIT
-    homepage: https://taskfile.dev
-    directory: Formula
-    repository:
-      owner: go-task
-      name: homebrew-tap
-    test:
-      system "#{bin}/task", "--help"
-    install: |-
-      bin.install "task"
-      bash_completion.install "completion/bash/task.bash" => "task"
-      zsh_completion.install "completion/zsh/_task" => "_task"
-      fish_completion.install "completion/fish/task.fish"
-    commit_author:
-      name: task-bot
-      email: 106601941+task-bot@users.noreply.github.com
-
-winget:
-  - name: Task
-    publisher: Task
-    short_description: A task runner / simpler Make alternative written in Go
-    description: Task is a task runner / build tool that aims to be simpler and easier to use than, for example, GNU Make.
-    license: MIT
-    homepage: https://taskfile.dev/
-    publisher_url: https://taskfile.dev/
-    publisher_support_url: https://github.com/go-task/task/issues
-    package_identifier: Task.Task
-    commit_author:
-      name: task-bot
-      email: 106601941+task-bot@users.noreply.github.com
-    commit_msg_template: "chore: bump {{.PackageIdentifier}} to {{.Tag}}"
-    release_notes_url: https://github.com/go-task/task/releases/tag/{{.Tag}}
-    tags:
-      - build
-      - build-tool
-      - devops
-      - go
-      - make
-      - makefile
-      - runner
-      - task
-      - task-runner
-      - taskfile
-      - tool
-    skip_upload: true
-    repository:
-      owner: microsoft
-      name: winget-pkgs
-      pull_request:
-        enabled: true
-        base:
-          owner: go-task
-          name: winget-pkgs
-          branch: "bump-task-to-{{.Tag}}"
+nfpm:
+  vendor: Task
+  homepage: https://github.com/go-task/task
+  maintainer: Andrey Nering <andrey.nering@gmail.com>
+  description: Simple task runner written in Go
+  license: MIT
+  conflicts:
+    - taskwarrior
+  formats:
+    - deb
+    - rpm
+  name_template: "{{.ProjectName}}_{{.Os}}_{{.Arch}}"

.mockery.yaml

@@ -1,4 +0,0 @@
-with-expecter: true
-keeptree: true
-case: underscore
-output: ./internal/mocks

.nvmrc

@@ -1 +0,0 @@
-22.14.0

.prettierrc.yml

@@ -1,7 +0,0 @@
-trailingComma: none
-singleQuote: true
-overrides:
-  - files: "*.md"
-    options:
-      printWidth: 80
-      proseWrap: always

.travis.yml

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

.vscode/extensions.json

@@ -1,7 +0,0 @@
-{
-  "recommendations": [
-    "editorconfig.editorconfig",
-    "golang.go",
-    "task.vscode-task"
-  ]
-}

.vscode/settings-sample.json

@@ -1,17 +0,0 @@
-{
-  "yaml.schemas": {
-    "./website/static/schema.json": [
-      "Taskfile.yml",
-      "tmp/**/*.yml"
-    ]
-  },
-  "search.exclude": {
-    "**/versioned_docs": true,
-    "**/versioned_sidesbars": true,
-    "**/i18n": true
-  },
-  "gopls": {
-      "formatting.local": "github.com/go-task"
-  },
-  "go.formatTool": "gofumpt"
-}

Gopkg.lock

@@ -0,0 +1,136 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  name = "github.com/Masterminds/semver"
+  packages = ["."]
+  revision = "15d8430ab86497c5c0da827b748823945e1cf1e1"
+  version = "v1.4.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/Masterminds/sprig"
+  packages = ["."]
+  revision = "9d9aa1f74c86fd9d36ecfe3f2a44a3093c3d4c15"
+
+[[projects]]
+  name = "github.com/aokoli/goutils"
+  packages = ["."]
+  revision = "3391d3790d23d03408670993e957e8f408993c34"
+  version = "v1.0.1"
+
+[[projects]]
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/huandu/xstrings"
+  packages = ["."]
+  revision = "2bf18b218c51864a87384c06996e40ff9dcff8e1"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/imdario/mergo"
+  packages = ["."]
+  revision = "0d4b488675fdec1dde48751b05ab530cf0b630e1"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mattn/go-zglob"
+  packages = [
+    ".",
+    "fastwalk"
+  ]
+  revision = "4959821b481786922ac53e7ef25c61ae19fb7c36"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mitchellh/go-homedir"
+  packages = ["."]
+  revision = "b8bc1bf767474819792c23f32d8286a45736f1c6"
+
+[[projects]]
+  name = "github.com/pmezard/go-difflib"
+  packages = ["difflib"]
+  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/radovskyb/watcher"
+  packages = ["."]
+  revision = "6145e1439b9de93806925353403f91d2abbad8a5"
+  version = "v1.0.2"
+
+[[projects]]
+  name = "github.com/satori/go.uuid"
+  packages = ["."]
+  revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3"
+  version = "v1.2.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  revision = "ee5fd03fd6acfd43e44aea0b4135958546ed8e73"
+
+[[projects]]
+  name = "github.com/stretchr/testify"
+  packages = ["assert"]
+  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
+  version = "v1.2.1"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/crypto"
+  packages = [
+    "pbkdf2",
+    "scrypt",
+    "ssh/terminal"
+  ]
+  revision = "91a49db82a88618983a78a06c1cbd4e00ab749ab"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/net"
+  packages = ["context"]
+  revision = "22ae77b79946ea320088417e4d50825671d82d57"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sync"
+  packages = ["errgroup"]
+  revision = "fd80eb99c8f653c847d294a001bdf2a3a6f768f5"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows"
+  ]
+  revision = "dd2ff4accc098aceecb86b36eaa7829b2a17b1c9"
+
+[[projects]]
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  revision = "7f97868eec74b32b0982dd158a51a446d1da7eb5"
+  version = "v2.1.1"
+
+[[projects]]
+  branch = "master"
+  name = "mvdan.cc/sh"
+  packages = [
+    "interp",
+    "syntax"
+  ]
+  revision = "fb0bad77f8fa7a57e6f249f53074ec52b21558d1"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "976972e7291789a9d4904805cc7f49d733476868bf80f120309078b02a095a65"
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

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

README.md

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

RELEASING_TASK.md

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

TASKFILE_VERSIONS.md

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

Taskfile.yml

@@ -1,190 +1,68 @@
-version: '3'
-
-includes:
-  website:
-    aliases: [w, docs, d]
-    taskfile: ./website
-    dir: ./website
-
-vars:
-  BIN: "{{.ROOT_DIR}}/bin"
-
-env:
-  CGO_ENABLED: '0'
+version: '2'
 
 tasks:
-  default:
-    cmds:
-      - task: lint
-      - task: test
-
+  # compiles current source code and make "task" executable available on
+  # $GOPATH/bin/task{.exe}
   install:
     desc: Installs Task
-    aliases: [i]
-    sources:
-      - './**/*.go'
     cmds:
-      - go install -v ./cmd/task
+      - go install -v -ldflags="-w -s -X main.version={{.GIT_COMMIT}}" ./cmd/task
 
-  generate:
-    desc: Runs Mockery to create mocks
-    aliases: [gen, g]
-    deps: [install:mockery]
-    sources:
-      - "internal/fingerprint/checker.go"
-    generates:
-      - "internal/mocks/*.go"
+  dl-deps:
+    desc: Downloads cli dependencies
     cmds:
-      - "{{.BIN}}/mockery --dir ./internal/fingerprint --name SourcesCheckable"
-      - "{{.BIN}}/mockery --dir ./internal/fingerprint --name StatusCheckable"
+      - task: go-get
+        vars: {REPO: github.com/golang/lint/golint}
+      - task: go-get
+        vars: {REPO: github.com/asticode/go-astitodo/astitodo}
+      - task: go-get
+        vars: {REPO: github.com/golang/dep/cmd/dep}
+      - task: go-get
+        vars: {REPO: github.com/goreleaser/goreleaser}
+      - task: go-get
+        vars: {REPO: github.com/goreleaser/godownloader}
 
-  install:mockery:
-    desc: Installs mockgen; a tool to generate mock files
-    vars:
-      MOCKERY_VERSION: v2.24.0
-    env:
-      GOBIN: "{{.BIN}}"
-    status:
-      - go version -m {{.BIN}}/mockery | grep github.com/vektra/mockery | grep {{.MOCKERY_VERSION}}
+  update-deps:
+    desc: Updates dependencies
     cmds:
-      - go install github.com/vektra/mockery/v2@{{.MOCKERY_VERSION}}
-
-  mod:
-    desc: Downloads and tidy Go modules
-    cmds:
-      - go mod download
-      - go mod tidy
+      - dep ensure
+      - dep ensure -update
 
   clean:
     desc: Cleans temp files and folders
-    aliases: [clear]
     cmds:
       - rm -rf dist/
-      - rm -rf tmp/
 
   lint:
-    desc: Runs golangci-lint
-    aliases: [l]
-    sources:
-      - './**/*.go'
-      - .golangci.yml
+    desc: Runs golint
     cmds:
-      - golangci-lint run
-
-  lint:fix:
-    desc: Runs golangci-lint and fixes any issues
-    sources:
-      - './**/*.go'
-      - .golangci.yml
-    cmds:
-      - golangci-lint run --fix
-
-  sleepit:build:
-    desc: Builds the sleepit test helper
-    sources:
-      - ./cmd/sleepit/**/*.go
-    generates:
-      - "{{.BIN}}/sleepit"
-    cmds:
-      - go build -o {{.BIN}}/sleepit{{exeExt}} ./cmd/sleepit
-
-  sleepit:run:
-    desc: Builds the sleepit test helper
-    deps: [sleepit:build]
-    cmds:
-      - "{{.BIN}}/sleepit {{.CLI_ARGS}}"
+      - golint {{.GO_PACKAGES}}
     silent: true
 
   test:
     desc: Runs test suite
-    aliases: [t]
-    sources:
-      - "**/*.go"
-      - "testdata/**/*"
+    deps: [install]
     cmds:
-      - go test ./...
+      - go test {{.GO_PACKAGES}}
 
-  test:all:
-    desc: Runs test suite with signals and watch tests included
-    deps: [sleepit:build]
-    cmds:
-      - go test -tags 'signals watch' ./...
-
-  goreleaser:test:
+  test-release:
     desc: Tests release process without publishing
     cmds:
-      - goreleaser --snapshot --clean
+      - goreleaser --snapshot --rm-dist
 
-  goreleaser:install:
-    desc: Installs goreleaser
+  todo:
+    desc: Prints TODO comments present in the code
     cmds:
-      - go install github.com/goreleaser/goreleaser/v2@latest
+      - astitodo {{.GO_PACKAGES}}
+    silent: true
 
-  gorelease:install:
-    desc: "Installs gorelease: https://pkg.go.dev/golang.org/x/exp/cmd/gorelease"
-    status:
-      - command -v gorelease
+  ci:
     cmds:
-      - go install golang.org/x/exp/cmd/gorelease@latest
+      - task: go-get
+        vars: {REPO: github.com/golang/lint/golint}
+      - task: lint
+      - task: test
 
-  api:check:
-    desc: Checks what changes have been made to the public API
-    deps: [gorelease:install]
-    vars:
-      LATEST:
-        sh: git describe --tags --abbrev=0
+  go-get:
     cmds:
-      - gorelease -base={{.LATEST}}
-
-  release:*:
-    desc: Prepare the project for a new release
-    summary: |
-      This task will do the following:
-
-      - Update the version and date in the CHANGELOG.md file
-      - Update the version in the package.json and package-lock.json files
-      - Copy the latest docs to the "current" version on the website
-      - Commit the changes
-      - Create a new tag
-      - Push the commit/tag to the repository
-      - Create a GitHub release
-
-      To use the task, simply run "task release:<version>" where "<version>" is is one of:
-
-      - "major" - Bumps the major number
-      - "minor" - Bumps the minor number
-      - "patch" - Bumps the patch number
-      - A semver compatible version number (e.g. "1.2.3")
-    vars:
-      VERSION:
-        sh: "go run ./cmd/release --version {{index .MATCH 0}}"
-      COMPLETE_MESSAGE: |
-        Creating release with GoReleaser: https://github.com/go-task/task/actions/workflows/release.yml
-
-        Please wait for the CI to finish and then do the following:
-
-        - Copy the changelog for v{{.VERSION}} to the GitHub release
-        - Publish the package to NPM with `task npm:publish`
-        - Update and push the snapcraft manifest in https://github.com/go-task/snap/blob/main/snap/snapcraft.yaml
-    preconditions:
-      - sh: test $(git rev-parse --abbrev-ref HEAD) = "main"
-        msg: "You must be on the main branch to release"
-      - sh: "[[ -z $(git diff --shortstat main) ]]"
-        msg: "You must have a clean working tree to release"
-    prompt: "Are you sure you want to release version {{.VERSION}}?"
-    cmds:
-      - cmd: echo "Releasing v{{.VERSION}}"
-        silent: true
-      - "go run ./cmd/release {{.VERSION}}"
-      - "git add --all"
-      - "git commit -m v{{.VERSION}}"
-      - "git push"
-      - "git tag v{{.VERSION}}"
-      - "git push origin tag v{{.VERSION}}"
-      - cmd: printf "%s" '{{.COMPLETE_MESSAGE}}'
-        silent: true
-
-  npm:publish:
-    desc: Publish release to npm
-    cmds:
-      - npm publish --access=public
+      - go get -u {{.REPO}}

Taskvars.yml

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

args/args.go

@@ -1,31 +0,0 @@
-package args
-
-import (
-	"strings"
-
-	"github.com/go-task/task/v3"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-// Parse parses command line argument: tasks and global variables
-func Parse(args ...string) ([]*task.Call, *ast.Vars) {
-	calls := []*task.Call{}
-	globals := ast.NewVars()
-
-	for _, arg := range args {
-		if !strings.Contains(arg, "=") {
-			calls = append(calls, &task.Call{Task: arg})
-			continue
-		}
-
-		name, value := splitVar(arg)
-		globals.Set(name, ast.Var{Value: value})
-	}
-
-	return calls, globals
-}
-
-func splitVar(s string) (string, string) {
-	pair := strings.SplitN(s, "=", 2)
-	return pair[0], pair[1]
-}

args/args_test.go

@@ -1,127 +0,0 @@
-package args_test
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/go-task/task/v3"
-	"github.com/go-task/task/v3/args"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-func TestArgs(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		Args            []string
-		ExpectedCalls   []*task.Call
-		ExpectedGlobals *ast.Vars
-	}{
-		{
-			Args: []string{"task-a", "task-b", "task-c"},
-			ExpectedCalls: []*task.Call{
-				{Task: "task-a"},
-				{Task: "task-b"},
-				{Task: "task-c"},
-			},
-		},
-		{
-			Args: []string{"task-a", "FOO=bar", "task-b", "task-c", "BAR=baz", "BAZ=foo"},
-			ExpectedCalls: []*task.Call{
-				{Task: "task-a"},
-				{Task: "task-b"},
-				{Task: "task-c"},
-			},
-			ExpectedGlobals: ast.NewVars(
-				&ast.VarElement{
-					Key: "FOO",
-					Value: ast.Var{
-						Value: "bar",
-					},
-				},
-				&ast.VarElement{
-					Key: "BAR",
-					Value: ast.Var{
-						Value: "baz",
-					},
-				},
-				&ast.VarElement{
-					Key: "BAZ",
-					Value: ast.Var{
-						Value: "foo",
-					},
-				},
-			),
-		},
-		{
-			Args: []string{"task-a", "CONTENT=with some spaces"},
-			ExpectedCalls: []*task.Call{
-				{Task: "task-a"},
-			},
-			ExpectedGlobals: ast.NewVars(
-				&ast.VarElement{
-					Key: "CONTENT",
-					Value: ast.Var{
-						Value: "with some spaces",
-					},
-				},
-			),
-		},
-		{
-			Args: []string{"FOO=bar", "task-a", "task-b"},
-			ExpectedCalls: []*task.Call{
-				{Task: "task-a"},
-				{Task: "task-b"},
-			},
-			ExpectedGlobals: ast.NewVars(
-				&ast.VarElement{
-					Key: "FOO",
-					Value: ast.Var{
-						Value: "bar",
-					},
-				},
-			),
-		},
-		{
-			Args:          nil,
-			ExpectedCalls: []*task.Call{},
-		},
-		{
-			Args:          []string{},
-			ExpectedCalls: []*task.Call{},
-		},
-		{
-			Args:          []string{"FOO=bar", "BAR=baz"},
-			ExpectedCalls: []*task.Call{},
-			ExpectedGlobals: ast.NewVars(
-				&ast.VarElement{
-					Key: "FOO",
-					Value: ast.Var{
-						Value: "bar",
-					},
-				},
-				&ast.VarElement{
-					Key: "BAR",
-					Value: ast.Var{
-						Value: "baz",
-					},
-				},
-			),
-		},
-	}
-
-	for i, test := range tests {
-		t.Run(fmt.Sprintf("TestArgs%d", i+1), func(t *testing.T) {
-			t.Parallel()
-
-			calls, globals := args.Parse(test.Args...)
-			assert.Equal(t, test.ExpectedCalls, calls)
-			if test.ExpectedGlobals.Len() > 0 || globals.Len() > 0 {
-				assert.Equal(t, test.ExpectedGlobals, globals)
-				assert.Equal(t, test.ExpectedGlobals, globals)
-			}
-		})
-	}
-}

call.go

@@ -1,11 +0,0 @@
-package task
-
-import "github.com/go-task/task/v3/taskfile/ast"
-
-// Call is the parameters to a task call
-type Call struct {
-	Task     string
-	Vars     *ast.Vars
-	Silent   bool
-	Indirect bool // True if the task was called by another task
-}

cmd/release/main.go

@@ -1,169 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"regexp"
-	"strings"
-	"time"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/otiai10/copy"
-	"github.com/spf13/pflag"
-
-	"github.com/go-task/task/v3/errors"
-)
-
-const (
-	changelogSource = "CHANGELOG.md"
-	changelogTarget = "website/docs/changelog.mdx"
-	docsSource      = "website/docs"
-	docsTarget      = "website/versioned_docs/version-latest"
-)
-
-var (
-	changelogReleaseRegex = regexp.MustCompile(`## Unreleased`)
-	versionRegex          = regexp.MustCompile(`(?m)^  "version": "\d+\.\d+\.\d+",$`)
-)
-
-// Flags
-var (
-	versionFlag bool
-)
-
-func init() {
-	pflag.BoolVarP(&versionFlag, "version", "v", false, "resolved version number")
-	pflag.Parse()
-}
-
-func main() {
-	if err := release(); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-}
-
-func release() error {
-	if len(pflag.Args()) != 1 {
-		return errors.New("error: expected version number")
-	}
-
-	version, err := getVersion()
-	if err != nil {
-		return err
-	}
-
-	if err := bumpVersion(version, pflag.Arg(0)); err != nil {
-		return err
-	}
-
-	if versionFlag {
-		fmt.Println(version)
-		return nil
-	}
-
-	if err := changelog(version); err != nil {
-		return err
-	}
-
-	if err := setJSONVersion("package.json", version); err != nil {
-		return err
-	}
-
-	if err := setJSONVersion("package-lock.json", version); err != nil {
-		return err
-	}
-
-	if err := docs(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func getVersion() (*semver.Version, error) {
-	cmd := exec.Command("git", "describe", "--tags", "--abbrev=0")
-	b, err := cmd.Output()
-	if err != nil {
-		return nil, err
-	}
-
-	return semver.NewVersion(strings.TrimSpace(string(b)))
-}
-
-func bumpVersion(version *semver.Version, verb string) error {
-	switch verb {
-	case "major":
-		*version = version.IncMajor()
-	case "minor":
-		*version = version.IncMinor()
-	case "patch":
-		*version = version.IncPatch()
-	default:
-		*version = *semver.MustParse(verb)
-	}
-	return nil
-}
-
-func changelog(version *semver.Version) error {
-	// Open changelog target file
-	b, err := os.ReadFile(changelogTarget)
-	if err != nil {
-		return err
-	}
-
-	// Get the current frontmatter
-	currentChangelog := string(b)
-	sections := strings.SplitN(currentChangelog, "---", 3)
-	if len(sections) != 3 {
-		return errors.New("error: invalid frontmatter")
-	}
-	frontmatter := strings.TrimSpace(sections[1])
-
-	// Open changelog source file
-	b, err = os.ReadFile(changelogSource)
-	if err != nil {
-		return err
-	}
-	changelog := string(b)
-	date := time.Now().Format("2006-01-02")
-
-	// Replace "Unreleased" with the new version and date
-	changelog = changelogReleaseRegex.ReplaceAllString(changelog, fmt.Sprintf("## v%s - %s", version, date))
-
-	// Write the changelog to the source file
-	if err := os.WriteFile(changelogSource, []byte(changelog), 0o644); err != nil {
-		return err
-	}
-
-	// Add the frontmatter to the changelog
-	changelog = fmt.Sprintf("---\n%s\n---\n\n%s", frontmatter, changelog)
-
-	// Write the changelog to the target file
-	return os.WriteFile(changelogTarget, []byte(changelog), 0o644)
-}
-
-func setJSONVersion(fileName string, version *semver.Version) error {
-	// Read the JSON file
-	b, err := os.ReadFile(fileName)
-	if err != nil {
-		return err
-	}
-
-	// Replace the version
-	new := versionRegex.ReplaceAllString(string(b), fmt.Sprintf(`  "version": "%s",`, version.String()))
-
-	// Write the JSON file
-	return os.WriteFile(fileName, []byte(new), 0o644)
-}
-
-func docs() error {
-	if err := os.RemoveAll(docsTarget); err != nil {
-		return err
-	}
-	if err := copy.Copy(docsSource, docsTarget); err != nil {
-		return err
-	}
-	return nil
-}

cmd/sleepit/sleepit.go

@@ -1,171 +0,0 @@
-// This code is released under the MIT License
-// Copyright (c) 2020 Marco Molteni and the timeit contributors.
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"os/signal"
-	"time"
-)
-
-const usage = `sleepit: sleep for the specified duration, optionally handling signals
-When the line "sleepit: ready" is printed, it means that it is safe to send signals to it
-Usage: sleepit <command> [<args>]
-Commands
-  default     Use default action: on reception of SIGINT terminate abruptly
-  handle      Handle signals: on reception of SIGINT perform cleanup before exiting
-  version     Show the sleepit version`
-
-// Filled by the linker.
-var fullVersion = "unknown" // example: v0.0.9-8-g941583d027-dirty
-
-func main() {
-	os.Exit(run(os.Args[1:]))
-}
-
-func run(args []string) int {
-	if len(args) < 1 {
-		fmt.Fprintln(os.Stderr, usage)
-		return 2
-	}
-
-	defaultCmd := flag.NewFlagSet("default", flag.ExitOnError)
-	defaultSleep := defaultCmd.Duration("sleep", 5*time.Second, "Sleep duration")
-
-	handleCmd := flag.NewFlagSet("handle", flag.ExitOnError)
-	handleSleep := handleCmd.Duration("sleep", 5*time.Second, "Sleep duration")
-	handleCleanup := handleCmd.Duration("cleanup", 5*time.Second, "Cleanup duration")
-	handleTermAfter := handleCmd.Int("term-after", 0,
-		"Terminate immediately after `N` signals.\n"+
-			"Default is to terminate only when the cleanup phase has completed.")
-
-	versionCmd := flag.NewFlagSet("version", flag.ExitOnError)
-
-	switch args[0] {
-
-	case "default":
-		_ = defaultCmd.Parse(args[1:])
-		if len(defaultCmd.Args()) > 0 {
-			fmt.Fprintf(os.Stderr, "default: unexpected arguments: %v\n", defaultCmd.Args())
-			return 2
-		}
-		return supervisor(*defaultSleep, 0, 0, nil)
-
-	case "handle":
-		_ = handleCmd.Parse(args[1:])
-		if *handleTermAfter == 1 {
-			fmt.Fprintf(os.Stderr, "handle: term-after cannot be 1\n")
-			return 2
-		}
-		if len(handleCmd.Args()) > 0 {
-			fmt.Fprintf(os.Stderr, "handle: unexpected arguments: %v\n", handleCmd.Args())
-			return 2
-		}
-		sigCh := make(chan os.Signal, 1)
-		signal.Notify(sigCh, os.Interrupt) // Ctrl-C -> SIGINT
-		return supervisor(*handleSleep, *handleCleanup, *handleTermAfter, sigCh)
-
-	case "version":
-		_ = versionCmd.Parse(args[1:])
-		if len(versionCmd.Args()) > 0 {
-			fmt.Fprintf(os.Stderr, "version: unexpected arguments: %v\n", versionCmd.Args())
-			return 2
-		}
-		fmt.Printf("sleepit version %s\n", fullVersion)
-		return 0
-
-	default:
-		fmt.Fprintln(os.Stderr, usage)
-		return 2
-	}
-}
-
-func supervisor(
-	sleep time.Duration,
-	cleanup time.Duration,
-	termAfter int,
-	sigCh <-chan os.Signal,
-) int {
-	fmt.Printf("sleepit: ready\n")
-	fmt.Printf("sleepit: PID=%d sleep=%v cleanup=%v\n",
-		os.Getpid(), sleep, cleanup)
-
-	cancelWork := make(chan struct{})
-	workerDone := worker(cancelWork, sleep, "work")
-
-	cancelCleaner := make(chan struct{})
-	var cleanerDone <-chan struct{}
-
-	sigCount := 0
-	for {
-		select {
-		case sig := <-sigCh:
-			sigCount++
-			fmt.Printf("sleepit: got signal=%s count=%d\n", sig, sigCount)
-			if sigCount == 1 {
-				// since `cancelWork` is unbuffered, sending will be synchronous:
-				// we are ensured that the worker has terminated before starting cleanup.
-				// This is important in some real-life situations.
-				cancelWork <- struct{}{}
-				cleanerDone = worker(cancelCleaner, cleanup, "cleanup")
-			}
-			if sigCount == termAfter {
-				cancelCleaner <- struct{}{}
-				return 4
-			}
-		case <-workerDone:
-			return 0
-		case <-cleanerDone:
-			return 3
-		}
-	}
-}
-
-// Start a worker goroutine and return immediately a `workerDone` channel.
-// The goroutine will prepend its prints with the prefix `name`.
-// The goroutine will simulate some work and will terminate when one of the following
-// conditions happens:
-//  1. When `howlong` is elapsed. This case will be signaled on the `workerDone` channel.
-//  2. When something happens on channel `canceled`. Note that this simulates real-life,
-//     so cancellation is not instantaneous: if the caller wants a synchronous cancel,
-//     it should send a message; if instead it wants an asynchronous cancel, it should
-//     close the channel.
-func worker(
-	canceled <-chan struct{},
-	howlong time.Duration,
-	name string,
-) <-chan struct{} {
-	workerDone := make(chan struct{})
-	deadline := time.Now().Add(howlong)
-	go func() {
-		fmt.Printf("sleepit: %s started\n", name)
-		for {
-			select {
-			case <-canceled:
-				fmt.Printf("sleepit: %s canceled\n", name)
-				return
-			default:
-				if doSomeWork(deadline) {
-					fmt.Printf("sleepit: %s done\n", name) // <== NOTE THIS LINE
-					workerDone <- struct{}{}
-					return
-				}
-			}
-		}
-	}()
-	return workerDone
-}
-
-// Do some work and then return, so that the caller can decide whether to continue or not.
-// Return true when all work is done.
-func doSomeWork(deadline time.Time) bool {
-	if time.Now().After(deadline) {
-		return true
-	}
-	timeout := 100 * time.Millisecond
-	time.Sleep(timeout)
-	return false
-}

cmd/task/task.go

@@ -2,258 +2,142 @@ package main
 
 import (
 	"context"
-	"fmt"
+	"log"
 	"os"
-	"path/filepath"
-	"strings"
+	"os/signal"
+	"syscall"
+
+	"github.com/go-task/task"
+	"github.com/go-task/task/internal/args"
 
 	"github.com/spf13/pflag"
-	"mvdan.cc/sh/v3/syntax"
-
-	"github.com/go-task/task/v3"
-	"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"
-	ver "github.com/go-task/task/v3/internal/version"
-	"github.com/go-task/task/v3/taskfile"
-	"github.com/go-task/task/v3/taskfile/ast"
 )
 
+var (
+	version = "master"
+)
+
+const usage = `Usage: task [-ilfwvsd] [--init] [--list] [--force] [--watch] [--verbose] [--silent] [--dir] [task...]
+
+Runs the specified task(s). Falls back to the "default" task if no task name
+was specified, or lists all tasks if an unknown task name was specified.
+
+Example: 'task hello' with the following 'Taskfile.yml' file will generate an
+'output.txt' file with the content "hello".
+
+'''
+hello:
+  cmds:
+    - echo "I am going to write a file named 'output.txt' now."
+    - echo "hello" > output.txt
+  generates:
+    - output.txt
+'''
+
+Options:
+`
+
 func main() {
-	if err := run(); err != nil {
-		l := &logger.Logger{
-			Stdout:  os.Stdout,
-			Stderr:  os.Stderr,
-			Verbose: flags.Verbose,
-			Color:   flags.Color,
-		}
-		if err, ok := err.(*errors.TaskRunError); ok && flags.ExitCode {
-			l.Errf(logger.Red, "%v\n", err)
-			os.Exit(err.TaskExitCode())
-		}
-		if err, ok := err.(errors.TaskError); ok {
-			l.Errf(logger.Red, "%v\n", err)
-			os.Exit(err.Code())
-		}
-		l.Errf(logger.Red, "%v\n", err)
-		os.Exit(errors.CodeUnknown)
-	}
-	os.Exit(errors.CodeOk)
-}
+	log.SetFlags(0)
+	log.SetOutput(os.Stderr)
 
-func run() error {
-	log := &logger.Logger{
-		Stdout:  os.Stdout,
-		Stderr:  os.Stderr,
-		Verbose: flags.Verbose,
-		Color:   flags.Color,
+	pflag.Usage = func() {
+		log.Print(usage)
+		pflag.PrintDefaults()
 	}
 
-	if err := flags.Validate(); err != nil {
-		return err
+	var (
+		versionFlag bool
+		init        bool
+		list        bool
+		status      bool
+		force       bool
+		watch       bool
+		verbose     bool
+		silent      bool
+		dir         string
+	)
+
+	pflag.BoolVar(&versionFlag, "version", false, "show Task version")
+	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yml in the current folder")
+	pflag.BoolVarP(&list, "list", "l", false, "lists tasks with description of current Taskfile")
+	pflag.BoolVar(&status, "status", false, "exits with non-zero exit code if any of the given tasks is not up-to-date")
+	pflag.BoolVarP(&force, "force", "f", false, "forces execution even when the task is up-to-date")
+	pflag.BoolVarP(&watch, "watch", "w", false, "enables watch of the given task")
+	pflag.BoolVarP(&verbose, "verbose", "v", false, "enables verbose mode")
+	pflag.BoolVarP(&silent, "silent", "s", false, "disables echoing")
+	pflag.StringVarP(&dir, "dir", "d", "", "sets directory of execution")
+	pflag.Parse()
+
+	if versionFlag {
+		log.Printf("Task version: %s\n", version)
+		return
 	}
 
-	dir := flags.Dir
-	entrypoint := flags.Entrypoint
-
-	if flags.Version {
-		fmt.Printf("Task version: %s\n", ver.GetVersionWithSum())
-		return nil
-	}
-
-	if flags.Help {
-		pflag.Usage()
-		return nil
-	}
-
-	if flags.Experiments {
-		return log.PrintExperiments()
-	}
-
-	if flags.Init {
+	if init {
 		wd, err := os.Getwd()
 		if err != nil {
-			return err
+			log.Fatal(err)
 		}
-		args, _, err := getArgs()
-		if err != nil {
-			return err
+		if err := task.InitTaskfile(os.Stdout, wd); err != nil {
+			log.Fatal(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 {
-			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))
-		}
-		return nil
-	}
-
-	if flags.Completion != "" {
-		script, err := task.Completion(flags.Completion)
-		if err != nil {
-			return err
-		}
-		fmt.Println(script)
-		return nil
-	}
-
-	if flags.Global {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return fmt.Errorf("task: Failed to get user home directory: %w", err)
-		}
-		dir = home
-	}
-
-	if err := experiments.Validate(); err != nil {
-		log.Warnf("%s\n", err.Error())
-	}
-
-	var taskSorter sort.Sorter
-	switch flags.TaskSort {
-	case "none":
-		taskSorter = nil
-	case "alphanumeric":
-		taskSorter = sort.AlphaNumeric
+		return
 	}
 
 	e := task.Executor{
-		Dir:         dir,
-		Entrypoint:  entrypoint,
-		Force:       flags.Force,
-		ForceAll:    flags.ForceAll,
-		Insecure:    flags.Insecure,
-		Download:    flags.Download,
-		Offline:     flags.Offline,
-		Timeout:     flags.Timeout,
-		Watch:       flags.Watch,
-		Verbose:     flags.Verbose,
-		Silent:      flags.Silent,
-		AssumeYes:   flags.AssumeYes,
-		Dry:         flags.Dry || flags.Status,
-		Summary:     flags.Summary,
-		Parallel:    flags.Parallel,
-		Color:       flags.Color,
-		Concurrency: flags.Concurrency,
-		Interval:    flags.Interval,
+		Force:   force,
+		Watch:   watch,
+		Verbose: verbose,
+		Silent:  silent,
+		Dir:     dir,
+
+		Context: getSignalContext(),
 
 		Stdin:  os.Stdin,
 		Stdout: os.Stdout,
 		Stderr: os.Stderr,
-
-		OutputStyle:        flags.Output,
-		TaskSorter:         taskSorter,
-		EnableVersionCheck: true,
 	}
-	listOptions := task.NewListOptions(flags.List, flags.ListAll, flags.ListJson, flags.NoStatus)
-	if err := listOptions.Validate(); err != nil {
-		return err
+	if err := e.Setup(); err != nil {
+		log.Fatal(err)
 	}
 
-	err := e.Setup()
+	if list {
+		e.PrintTasksHelp()
+		return
+	}
+
+	arguments := pflag.Args()
+	if len(arguments) == 0 {
+		log.Println("task: No argument given, trying default task")
+		arguments = []string{"default"}
+	}
+
+	calls, err := args.Parse(arguments...)
 	if err != nil {
-		return err
+		log.Fatal(err)
 	}
 
-	// If the download flag is specified, we should stop execution as soon as
-	// taskfile is downloaded
-	if flags.Download {
-		return nil
-	}
-
-	if flags.ClearCache {
-		cache, err := taskfile.NewCache(e.TempDir.Remote)
-		if err != nil {
-			return err
+	if status {
+		if err = e.Status(calls...); err != nil {
+			log.Fatal(err)
 		}
-		return cache.Clear()
+		return
 	}
 
-	if (listOptions.ShouldListTasks()) && flags.Silent {
-		return e.ListTaskNames(flags.ListAll)
+	if err := e.Run(calls...); err != nil {
+		log.Fatal(err)
 	}
-
-	if listOptions.ShouldListTasks() {
-		foundTasks, err := e.ListTasks(listOptions)
-		if err != nil {
-			return err
-		}
-		if !foundTasks {
-			os.Exit(errors.CodeUnknown)
-		}
-		return nil
-	}
-
-	var (
-		calls   []*task.Call
-		globals *ast.Vars
-	)
-
-	tasksAndVars, cliArgs, err := getArgs()
-	if err != nil {
-		return err
-	}
-
-	calls, globals = args.Parse(tasksAndVars...)
-
-	// If there are no calls, run the default task instead
-	if len(calls) == 0 {
-		calls = append(calls, &task.Call{Task: "default"})
-	}
-
-	globals.Set("CLI_ARGS", ast.Var{Value: cliArgs})
-	globals.Set("CLI_FORCE", ast.Var{Value: flags.Force || flags.ForceAll})
-	globals.Set("CLI_SILENT", ast.Var{Value: flags.Silent})
-	globals.Set("CLI_VERBOSE", ast.Var{Value: flags.Verbose})
-	globals.Set("CLI_OFFLINE", ast.Var{Value: flags.Offline})
-	e.Taskfile.Vars.Merge(globals, nil)
-
-	if !flags.Watch {
-		e.InterceptInterruptSignals()
-	}
-
-	ctx := context.Background()
-
-	if flags.Status {
-		return e.Status(ctx, calls...)
-	}
-
-	return e.Run(ctx, calls...)
 }
 
-func getArgs() ([]string, string, error) {
-	var (
-		args          = pflag.Args()
-		doubleDashPos = pflag.CommandLine.ArgsLenAtDash()
-	)
-
-	if doubleDashPos == -1 {
-		return args, "", nil
-	}
-
-	var quotedCliArgs []string
-	for _, arg := range args[doubleDashPos:] {
-		quotedCliArg, err := syntax.Quote(arg, syntax.LangBash)
-		if err != nil {
-			return nil, "", err
-		}
-		quotedCliArgs = append(quotedCliArgs, quotedCliArg)
-	}
-	return args[:doubleDashPos], strings.Join(quotedCliArgs, " "), nil
+func getSignalContext() context.Context {
+	ch := make(chan os.Signal, 1)
+	signal.Notify(ch, os.Interrupt, os.Kill, syscall.SIGTERM)
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		sig := <-ch
+		log.Printf("task: signal received: %s", sig)
+		cancel()
+	}()
+	return ctx
 }

compiler.go

@@ -1,218 +0,0 @@
-package task
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	"github.com/go-task/task/v3/internal/env"
-	"github.com/go-task/task/v3/internal/execext"
-	"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/internal/version"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-type Compiler struct {
-	Dir            string
-	Entrypoint     string
-	UserWorkingDir string
-
-	TaskfileEnv  *ast.Vars
-	TaskfileVars *ast.Vars
-
-	Logger *logger.Logger
-
-	dynamicCache   map[string]string
-	muDynamicCache sync.Mutex
-}
-
-func (c *Compiler) GetTaskfileVariables() (*ast.Vars, error) {
-	return c.getVariables(nil, nil, true)
-}
-
-func (c *Compiler) GetVariables(t *ast.Task, call *Call) (*ast.Vars, error) {
-	return c.getVariables(t, call, true)
-}
-
-func (c *Compiler) FastGetVariables(t *ast.Task, call *Call) (*ast.Vars, error) {
-	return c.getVariables(t, call, false)
-}
-
-func (c *Compiler) getVariables(t *ast.Task, call *Call, evaluateShVars bool) (*ast.Vars, error) {
-	result := env.GetEnviron()
-	specialVars, err := c.getSpecialVars(t, call)
-	if err != nil {
-		return nil, err
-	}
-	for k, v := range specialVars {
-		result.Set(k, ast.Var{Value: v})
-	}
-
-	getRangeFunc := func(dir string) func(k string, v ast.Var) error {
-		return func(k string, v ast.Var) error {
-			cache := &templater.Cache{Vars: result}
-			// Replace values
-			newVar := templater.ReplaceVar(v, cache)
-			// If the variable should not be evaluated, but is nil, set it to an empty string
-			// This stops empty interface errors when using the templater to replace values later
-			if !evaluateShVars && newVar.Value == nil {
-				result.Set(k, ast.Var{Value: ""})
-				return nil
-			}
-			// If the variable should not be evaluated and it is set, we can set it and return
-			if !evaluateShVars {
-				result.Set(k, ast.Var{Value: newVar.Value})
-				return nil
-			}
-			// Now we can check for errors since we've handled all the cases when we don't want to evaluate
-			if err := cache.Err(); err != nil {
-				return err
-			}
-			// If the variable is already set, we can set it and return
-			if newVar.Value != nil {
-				result.Set(k, ast.Var{Value: newVar.Value})
-				return nil
-			}
-			// If the variable is dynamic, we need to resolve it first
-			static, err := c.HandleDynamicVar(newVar, dir, env.GetFromVars(result))
-			if err != nil {
-				return err
-			}
-			result.Set(k, ast.Var{Value: static})
-			return nil
-		}
-	}
-	rangeFunc := getRangeFunc(c.Dir)
-
-	var taskRangeFunc func(k string, v ast.Var) error
-	if t != nil {
-		// NOTE(@andreynering): We're manually joining these paths here because
-		// this is the raw task, not the compiled one.
-		cache := &templater.Cache{Vars: result}
-		dir := templater.Replace(t.Dir, cache)
-		if err := cache.Err(); err != nil {
-			return nil, err
-		}
-		dir = filepathext.SmartJoin(c.Dir, dir)
-		taskRangeFunc = getRangeFunc(dir)
-	}
-
-	for k, v := range c.TaskfileEnv.All() {
-		if err := rangeFunc(k, v); err != nil {
-			return nil, err
-		}
-	}
-	for k, v := range c.TaskfileVars.All() {
-		if err := rangeFunc(k, v); 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
-			}
-		}
-		for k, v := range t.IncludedTaskfileVars.All() {
-			if err := taskRangeFunc(k, v); err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	if t == nil || call == nil {
-		return result, nil
-	}
-
-	for k, v := range call.Vars.All() {
-		if err := rangeFunc(k, v); err != nil {
-			return nil, err
-		}
-	}
-	for k, v := range t.Vars.All() {
-		if err := taskRangeFunc(k, v); err != nil {
-			return nil, err
-		}
-	}
-
-	return result, nil
-}
-
-func (c *Compiler) HandleDynamicVar(v ast.Var, dir string, e []string) (string, error) {
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	// If the variable is not dynamic or it is empty, return an empty string
-	if v.Sh == nil || *v.Sh == "" {
-		return "", nil
-	}
-
-	if c.dynamicCache == nil {
-		c.dynamicCache = make(map[string]string, 30)
-	}
-	if result, ok := c.dynamicCache[*v.Sh]; ok {
-		return result, nil
-	}
-
-	// NOTE(@andreynering): If a var have a specific dir, use this instead
-	if v.Dir != "" {
-		dir = v.Dir
-	}
-
-	var stdout bytes.Buffer
-	opts := &execext.RunCommandOptions{
-		Command: *v.Sh,
-		Dir:     dir,
-		Stdout:  &stdout,
-		Stderr:  c.Logger.Stderr,
-		Env:     e,
-	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
-		return "", fmt.Errorf(`task: Command "%s" failed: %s`, opts.Command, err)
-	}
-
-	// Trim a single trailing newline from the result to make most command
-	// output easier to use in shell commands.
-	result := strings.TrimSuffix(stdout.String(), "\r\n")
-	result = strings.TrimSuffix(result, "\n")
-
-	c.dynamicCache[*v.Sh] = result
-	c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", *v.Sh, result)
-
-	return result, nil
-}
-
-// ResetCache clear the dynamic variables cache
-func (c *Compiler) ResetCache() {
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	c.dynamicCache = nil
-}
-
-func (c *Compiler) getSpecialVars(t *ast.Task, call *Call) (map[string]string, error) {
-	allVars := map[string]string{
-		"TASK_EXE":         filepath.ToSlash(os.Args[0]),
-		"ROOT_TASKFILE":    filepathext.SmartJoin(c.Dir, c.Entrypoint),
-		"ROOT_DIR":         c.Dir,
-		"USER_WORKING_DIR": c.UserWorkingDir,
-		"TASK_VERSION":     version.GetVersion(),
-	}
-	if t != nil {
-		allVars["TASK"] = t.Task
-		allVars["TASK_DIR"] = filepathext.SmartJoin(c.Dir, t.Dir)
-		allVars["TASKFILE"] = t.Location.Taskfile
-		allVars["TASKFILE_DIR"] = filepath.Dir(t.Location.Taskfile)
-	}
-	if call != nil {
-		allVars["ALIAS"] = call.Task
-	}
-
-	return allVars, nil
-}

completion.go

@@ -1,34 +0,0 @@
-package task
-
-import (
-	_ "embed"
-	"fmt"
-)
-
-//go:embed completion/bash/task.bash
-var completionBash string
-
-//go:embed completion/fish/task.fish
-var completionFish string
-
-//go:embed completion/ps/task.ps1
-var completionPowershell string
-
-//go:embed completion/zsh/_task
-var completionZsh string
-
-func Completion(completion string) (string, error) {
-	// Get the file extension for the selected shell
-	switch completion {
-	case "bash":
-		return completionBash, nil
-	case "fish":
-		return completionFish, nil
-	case "powershell":
-		return completionPowershell, nil
-	case "zsh":
-		return completionZsh, nil
-	default:
-		return "", fmt.Errorf("unknown shell: %s", completion)
-	}
-}

completion/bash/task.bash

@@ -1,55 +0,0 @@
-# vim: set tabstop=2 shiftwidth=2 expandtab:
-
-_GO_TASK_COMPLETION_LIST_OPTION='--list-all'
-
-function _task()
-{
-  local cur prev words cword
-  _init_completion -n : || return
-
-  # Check for `--` within command-line and quit or strip suffix.
-  local i
-  for i in "${!words[@]}"; do
-    if [ "${words[$i]}" == "--" ]; then
-      # Do not complete words following `--` passed to CLI_ARGS.
-      [ $cword -gt $i ] && return
-      # Remove the words following `--` to not put --list in CLI_ARGS.
-      words=( "${words[@]:0:$i}" )
-      break
-    fi
-  done
-
-  # Handle special arguments of options.
-  case "$prev" in
-    -d|--dir)
-      _filedir -d
-      return $?
-    ;;
-    -t|--taskfile)
-      _filedir yaml || return $?
-      _filedir yml
-      return $?
-    ;;
-    -o|--output)
-      COMPREPLY=( $( compgen -W "interleaved group prefixed" -- $cur ) )
-      return 0
-    ;;
-  esac
-
-  # Handle normal options.
-  case "$cur" in
-    -*)
-      COMPREPLY=( $( compgen -W "$(_parse_help $1)" -- $cur ) )
-      return 0
-    ;;
-  esac
-
-  # Prepare task name completions.
-  local tasks=( $( "${words[@]}" --silent $_GO_TASK_COMPLETION_LIST_OPTION 2> /dev/null ) )
-  COMPREPLY=( $( compgen -W "${tasks[*]}" -- "$cur" ) )
-
-  # Post-process because task names might contain colons.
-  __ltrim_colon_completions "$cur"
-}
-
-complete -F _task task

completion/fish/task.fish

@@ -1,37 +0,0 @@
-set GO_TASK_PROGNAME task
-
-function __task_get_tasks --description "Prints all available tasks with their description"
-  # Read the list of tasks (and potential errors)
-  $GO_TASK_PROGNAME --list-all 2>&1 | read -lz rawOutput
-
-  # Return on non-zero exit code (for cases when there is no Taskfile found or etc.)
-  if test $status -ne 0
-    return
-  end
-
-  # Grab names and descriptions (if any) of the tasks
-  set -l output (echo $rawOutput | sed -e '1d; s/\* \(.*\):\s*\(.*\)\s*(\(aliases.*\))/\1\t\2\t\3/' -e 's/\* \(.*\):\s*\(.*\)/\1\t\2/'| string split0)
-  if test $output
-    echo $output
-  end
-end
-
-complete -c $GO_TASK_PROGNAME -d 'Runs the specified task(s). Falls back to the "default" task if no task name was specified, or lists all tasks if an unknown task name was
-specified.' -xa "(__task_get_tasks)"
-
-complete -c $GO_TASK_PROGNAME -s c -l color     -d 'colored output (default true)'
-complete -c $GO_TASK_PROGNAME -s d -l dir       -d 'sets directory of execution'
-complete -c $GO_TASK_PROGNAME      -l dry       -d 'compiles and prints tasks in the order that they would be run, without executing them'
-complete -c $GO_TASK_PROGNAME -s f -l force     -d 'forces execution even when the task is up-to-date'
-complete -c $GO_TASK_PROGNAME -s h -l help      -d 'shows Task usage'
-complete -c $GO_TASK_PROGNAME -s i -l init      -d 'creates a new Taskfile.yml in the current folder'
-complete -c $GO_TASK_PROGNAME -s l -l list      -d 'lists tasks with description of current Taskfile'
-complete -c $GO_TASK_PROGNAME -s o -l output    -d 'sets output style: [interleaved|group|prefixed]' -xa "interleaved group prefixed"
-complete -c $GO_TASK_PROGNAME -s p -l parallel  -d 'executes tasks provided on command line in parallel'
-complete -c $GO_TASK_PROGNAME -s s -l silent    -d 'disables echoing'
-complete -c $GO_TASK_PROGNAME      -l status    -d 'exits with non-zero exit code if any of the given tasks is not up-to-date'
-complete -c $GO_TASK_PROGNAME      -l summary   -d 'show summary about a task'
-complete -c $GO_TASK_PROGNAME -s t -l taskfile  -d 'choose which Taskfile to run. Defaults to "Taskfile.yml"'
-complete -c $GO_TASK_PROGNAME -s v -l verbose   -d 'enables verbose mode'
-complete -c $GO_TASK_PROGNAME      -l version   -d 'show Task version'
-complete -c $GO_TASK_PROGNAME -s w -l watch     -d 'enables watch of the given task'

completion/ps/task.ps1

@@ -1,28 +0,0 @@
-using namespace System.Management.Automation
-
-Register-ArgumentCompleter -CommandName task -ScriptBlock {
-	param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)
-
-	if ($commandName.StartsWith('-')) {
-		$completions = @(
-			[CompletionResult]::new('--list-all ', '--list-all ', [CompletionResultType]::ParameterName, 'list all tasks'),
-			[CompletionResult]::new('--color ', '--color', [CompletionResultType]::ParameterName, '--color'),
-			[CompletionResult]::new('--concurrency=', '--concurrency=', [CompletionResultType]::ParameterName, 'concurrency'),
-			[CompletionResult]::new('--interval=', '--interval=', [CompletionResultType]::ParameterName, 'interval'),
-			[CompletionResult]::new('--output=interleaved ', '--output=interleaved', [CompletionResultType]::ParameterName, '--output='),
-			[CompletionResult]::new('--output=group ', '--output=group', [CompletionResultType]::ParameterName, '--output='),
-			[CompletionResult]::new('--output=prefixed ', '--output=prefixed', [CompletionResultType]::ParameterName, '--output='),
-			[CompletionResult]::new('--dry ', '--dry', [CompletionResultType]::ParameterName, '--dry'),
-			[CompletionResult]::new('--force ', '--force', [CompletionResultType]::ParameterName, '--force'),
-			[CompletionResult]::new('--parallel ', '--parallel', [CompletionResultType]::ParameterName, '--parallel'),
-			[CompletionResult]::new('--silent ', '--silent', [CompletionResultType]::ParameterName, '--silent'),
-			[CompletionResult]::new('--status ', '--status', [CompletionResultType]::ParameterName, '--status'),
-			[CompletionResult]::new('--verbose ', '--verbose', [CompletionResultType]::ParameterName, '--verbose'),
-			[CompletionResult]::new('--watch ', '--watch', [CompletionResultType]::ParameterName, '--watch')
-		)
-
-		return $completions.Where{ $_.CompletionText.StartsWith($commandName) }
-	}
-
-	return 	$(task --list-all --silent) | Where-Object { $_.StartsWith($commandName) } | ForEach-Object { return $_ + " " }
-}

completion/zsh/_task

@@ -1,70 +0,0 @@
-#compdef task
-compdef _task task
-typeset -A opt_args
-
-_GO_TASK_COMPLETION_LIST_OPTION="${GO_TASK_COMPLETION_LIST_OPTION:---list-all}"
-
-# Listing commands from Taskfile.yml
-function __task_list() {
-    local -a scripts cmd
-    local -i enabled=0
-    local taskfile item task desc
-
-    cmd=(task)
-    taskfile=${(Qv)opt_args[(i)-t|--taskfile]}
-    taskfile=${taskfile//\~/$HOME}
-
-
-    if [[ -n "$taskfile" && -f "$taskfile" ]]; then
-        enabled=1
-        cmd+=(--taskfile "$taskfile")
-    else
-        for taskfile in {T,t}askfile{,.dist}.{yaml,yml}; do
-            if [[ -f "$taskfile" ]]; then
-                enabled=1
-                break
-            fi
-        done
-    fi
-
-    (( enabled )) || return 0
-
-    scripts=()
-    for item in "${(@)${(f)$("${cmd[@]}" $_GO_TASK_COMPLETION_LIST_OPTION)}[2,-1]#\* }"; do
-        task="${item%%:[[:space:]]*}"
-        desc="${item##[^[:space:]]##[[:space:]]##}"
-        scripts+=( "${task//:/\\:}:$desc" )
-    done
-    _describe 'Task to run' scripts
-}
-
-_task() {
-    _arguments \
-        '(-C --concurrency)'{-C,--concurrency}'[limit number of concurrent tasks]: ' \
-        '(-p --parallel)'{-p,--parallel}'[run command-line tasks in parallel]' \
-        '(-f --force)'{-f,--force}'[run even if task is up-to-date]' \
-        '(-c --color)'{-c,--color}'[colored output]' \
-        '(-d --dir)'{-d,--dir}'[dir to run in]:execution dir:_dirs' \
-        '(--dry)--dry[dry-run mode, compile and print tasks only]' \
-        '(-o --output)'{-o,--output}'[set output style]:style:(interleaved group prefixed)' \
-        '(--output-group-begin)--output-group-begin[message template before grouped output]:template text: ' \
-        '(--output-group-end)--output-group-end[message template after grouped output]:template text: ' \
-        '(-s --silent)'{-s,--silent}'[disable echoing]' \
-        '(--status)--status[exit non-zero if supplied tasks not up-to-date]' \
-        '(--summary)--summary[show summary\: field from tasks instead of running them]' \
-        '(-t --taskfile)'{-t,--taskfile}'[specify a different taskfile]:taskfile:_files' \
-        '(-v --verbose)'{-v,--verbose}'[verbose mode]' \
-        '(-w --watch)'{-w,--watch}'[watch-mode for given tasks, re-run when inputs change]' \
-        + '(operation)' \
-            {-l,--list}'[list describable tasks]' \
-            {-a,--list-all}'[list all tasks]' \
-            {-i,--init}'[create new Taskfile.yml]' \
-            '(-*)'{-h,--help}'[show help]' \
-            '(-*)--version[show version and exit]' \
-            '*: :__task_list'
-}
-
-# don't run the completion function when being source-ed or eval-ed
-if [ "$funcstack[1]" = "_task" ]; then
-    _task "$@"
-fi

concurrency.go

@@ -1,25 +0,0 @@
-package task
-
-func (e *Executor) acquireConcurrencyLimit() func() {
-	if e.concurrencySemaphore == nil {
-		return emptyFunc
-	}
-
-	e.concurrencySemaphore <- struct{}{}
-	return func() {
-		<-e.concurrencySemaphore
-	}
-}
-
-func (e *Executor) releaseConcurrencyLimit() func() {
-	if e.concurrencySemaphore == nil {
-		return emptyFunc
-	}
-
-	<-e.concurrencySemaphore
-	return func() {
-		e.concurrencySemaphore <- struct{}{}
-	}
-}
-
-func emptyFunc() {}

errors.go

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

errors/error_taskfile_decode.go

@@ -1,138 +0,0 @@
-package errors
-
-import (
-	"bytes"
-	"cmp"
-	"errors"
-	"fmt"
-	"regexp"
-	"strings"
-
-	"github.com/fatih/color"
-	"gopkg.in/yaml.v3"
-)
-
-var typeErrorRegex = regexp.MustCompile(`line \d+: (.*)`)
-
-type (
-	TaskfileDecodeError struct {
-		Message  string
-		Location string
-		Line     int
-		Column   int
-		Tag      string
-		Snippet  string
-		Err      error
-	}
-)
-
-func NewTaskfileDecodeError(err error, node *yaml.Node) *TaskfileDecodeError {
-	// If the error is already a DecodeError, return it
-	taskfileInvalidErr := &TaskfileDecodeError{}
-	if errors.As(err, &taskfileInvalidErr) {
-		return taskfileInvalidErr
-	}
-	return &TaskfileDecodeError{
-		Line:   node.Line,
-		Column: node.Column,
-		Tag:    node.ShortTag(),
-		Err:    err,
-	}
-}
-
-func (err *TaskfileDecodeError) Error() string {
-	buf := &bytes.Buffer{}
-
-	// Print the error message
-	if err.Message != "" {
-		fmt.Fprintln(buf, color.RedString("err:  %s", err.Message))
-	} else {
-		// Extract the errors from the TypeError
-		te := &yaml.TypeError{}
-		if errors.As(err.Err, &te) {
-			if len(te.Errors) > 1 {
-				fmt.Fprintln(buf, color.RedString("errs:"))
-				for _, message := range te.Errors {
-					fmt.Fprintln(buf, color.RedString("- %s", extractTypeErrorMessage(message)))
-				}
-			} else {
-				fmt.Fprintln(buf, color.RedString("err:  %s", extractTypeErrorMessage(te.Errors[0])))
-			}
-		} else {
-			// Otherwise print the error message normally
-			fmt.Fprintln(buf, color.RedString("err:  %s", err.Err))
-		}
-	}
-	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:")
-
-	// 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)
-
-		// Nothing left to unwrap
-		if err == nil {
-			fmt.Fprintf(buf, "%sEnd of chain\n", indentStr)
-			return
-		}
-
-		// 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
-		}
-
-		fmt.Fprintf(buf, "%s%s\n", indentStr, err)
-		debug(errors.Unwrap(err), indent+1)
-	}
-	debug(err, 0)
-	return buf.String()
-}
-
-func (err *TaskfileDecodeError) Unwrap() error {
-	return err.Err
-}
-
-func (err *TaskfileDecodeError) Code() int {
-	return CodeTaskfileDecode
-}
-
-func (err *TaskfileDecodeError) WithMessage(format string, a ...any) *TaskfileDecodeError {
-	err.Message = fmt.Sprintf(format, a...)
-	return err
-}
-
-func (err *TaskfileDecodeError) WithTypeMessage(t string) *TaskfileDecodeError {
-	err.Message = fmt.Sprintf("cannot unmarshal %s into %s", err.Tag, t)
-	return err
-}
-
-func (err *TaskfileDecodeError) WithFileInfo(location string, snippet string) *TaskfileDecodeError {
-	err.Location = location
-	err.Snippet = snippet
-	return err
-}
-
-func extractTypeErrorMessage(message string) string {
-	matches := typeErrorRegex.FindStringSubmatch(message)
-	if len(matches) == 2 {
-		return matches[1]
-	}
-	return message
-}

errors/errors.go

@@ -1,66 +0,0 @@
-package errors
-
-import "errors"
-
-// General exit codes
-const (
-	CodeOk      int = iota // Used when the program exits without errors
-	CodeUnknown            // Used when no other exit code is appropriate
-)
-
-// Taskfile related exit codes
-const (
-	CodeTaskfileNotFound int = iota + 100
-	CodeTaskfileAlreadyExists
-	CodeTaskfileDecode
-	CodeTaskfileFetchFailed
-	CodeTaskfileNotTrusted
-	CodeTaskfileNotSecure
-	CodeTaskfileCacheNotFound
-	CodeTaskfileVersionCheckError
-	CodeTaskfileNetworkTimeout
-	CodeTaskfileInvalid
-	CodeTaskfileCycle
-)
-
-// Task related exit codes
-const (
-	CodeTaskNotFound int = iota + 200
-	CodeTaskRunError
-	CodeTaskInternal
-	CodeTaskNameConflict
-	CodeTaskCalledTooManyTimes
-	CodeTaskCancelled
-	CodeTaskMissingRequiredVars
-	CodeTaskNotAllowedVars
-)
-
-// TaskError extends the standard error interface with a Code method. This code will
-// be used as the exit code of the program which allows the user to distinguish
-// between different types of errors.
-type TaskError interface {
-	error
-	Code() int
-}
-
-// New returns an error that formats as the given text. Each call to New returns
-// a distinct error value even if the text is identical. This wraps the standard
-// errors.New function so that we don't need to alias that package.
-func New(text string) error {
-	return errors.New(text)
-}
-
-// Is wraps the standard errors.Is function so that we don't need to alias that package.
-func Is(err, target error) bool {
-	return errors.Is(err, target)
-}
-
-// As wraps the standard errors.As function so that we don't need to alias that package.
-func As(err error, target any) bool {
-	return errors.As(err, target)
-}
-
-// Unwrap wraps the standard errors.Unwrap function so that we don't need to alias that package.
-func Unwrap(err error) error {
-	return errors.Unwrap(err)
-}

errors/errors_task.go

@@ -1,202 +0,0 @@
-package errors
-
-import (
-	"fmt"
-	"strings"
-
-	"mvdan.cc/sh/v3/interp"
-)
-
-// TaskNotFoundError is returned when the specified task is not found in the
-// Taskfile.
-type TaskNotFoundError struct {
-	TaskName   string
-	DidYouMean string
-}
-
-func (err *TaskNotFoundError) Error() string {
-	if err.DidYouMean != "" {
-		return fmt.Sprintf(
-			`task: Task %q does not exist. Did you mean %q?`,
-			err.TaskName,
-			err.DidYouMean,
-		)
-	}
-
-	return fmt.Sprintf(`task: Task %q does not exist`, err.TaskName)
-}
-
-func (err *TaskNotFoundError) Code() int {
-	return CodeTaskNotFound
-}
-
-// TaskRunError is returned when a command in a task returns a non-zero exit
-// code.
-type TaskRunError struct {
-	TaskName string
-	Err      error
-}
-
-func (err *TaskRunError) Error() string {
-	return fmt.Sprintf(`task: Failed to run task %q: %v`, err.TaskName, err.Err)
-}
-
-func (err *TaskRunError) Code() int {
-	return CodeTaskRunError
-}
-
-func (err *TaskRunError) TaskExitCode() int {
-	if c, ok := interp.IsExitStatus(err.Err); ok {
-		return int(c)
-	}
-	return err.Code()
-}
-
-// TaskInternalError when the user attempts to invoke a task that is internal.
-type TaskInternalError struct {
-	TaskName string
-}
-
-func (err *TaskInternalError) Error() string {
-	return fmt.Sprintf(`task: Task "%s" is internal`, err.TaskName)
-}
-
-func (err *TaskInternalError) Code() int {
-	return CodeTaskInternal
-}
-
-// TaskNameConflictError is returned when multiple tasks with a matching name or
-// alias are found.
-type TaskNameConflictError struct {
-	Call      string
-	TaskNames []string
-}
-
-func (err *TaskNameConflictError) Error() string {
-	return fmt.Sprintf(`task: Found multiple tasks (%s) that match %q`, strings.Join(err.TaskNames, ", "), err.Call)
-}
-
-func (err *TaskNameConflictError) Code() int {
-	return CodeTaskNameConflict
-}
-
-type TaskNameFlattenConflictError struct {
-	TaskName string
-	Include  string
-}
-
-func (err *TaskNameFlattenConflictError) Error() string {
-	return fmt.Sprintf(`task: Found multiple tasks (%s) included by "%s""`, err.TaskName, err.Include)
-}
-
-func (err *TaskNameFlattenConflictError) Code() int {
-	return CodeTaskNameConflict
-}
-
-// TaskCalledTooManyTimesError is returned when the maximum task call limit is
-// exceeded. This is to prevent infinite loops and cyclic dependencies.
-type TaskCalledTooManyTimesError struct {
-	TaskName        string
-	MaximumTaskCall int
-}
-
-func (err *TaskCalledTooManyTimesError) Error() string {
-	return fmt.Sprintf(
-		`task: Maximum task call exceeded (%d) for task %q: probably an cyclic dep or infinite loop`,
-		err.MaximumTaskCall,
-		err.TaskName,
-	)
-}
-
-func (err *TaskCalledTooManyTimesError) Code() int {
-	return CodeTaskCalledTooManyTimes
-}
-
-// TaskCancelledByUserError is returned when the user does not accept an optional prompt to continue.
-type TaskCancelledByUserError struct {
-	TaskName string
-}
-
-func (err *TaskCancelledByUserError) Error() string {
-	return fmt.Sprintf(`task: Task %q cancelled by user`, err.TaskName)
-}
-
-func (err *TaskCancelledByUserError) Code() int {
-	return CodeTaskCancelled
-}
-
-// TaskCancelledNoTerminalError is returned when trying to run a task with a prompt in a non-terminal environment.
-type TaskCancelledNoTerminalError struct {
-	TaskName string
-}
-
-func (err *TaskCancelledNoTerminalError) Error() string {
-	return fmt.Sprintf(
-		`task: Task %q cancelled because it has a prompt and the environment is not a terminal. Use --yes (-y) to run anyway.`,
-		err.TaskName,
-	)
-}
-
-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 {
-	TaskName    string
-	MissingVars []MissingVar
-}
-
-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())
-	}
-
-	return fmt.Sprintf(
-		`task: Task %q cancelled because it is missing required variables: %s`,
-		err.TaskName,
-		strings.Join(vars, ", "))
-}
-
-func (err *TaskMissingRequiredVarsError) Code() int {
-	return CodeTaskMissingRequiredVars
-}
-
-type NotAllowedVar struct {
-	Value string
-	Enum  []string
-	Name  string
-}
-
-type TaskNotAllowedVarsError struct {
-	TaskName       string
-	NotAllowedVars []NotAllowedVar
-}
-
-func (err *TaskNotAllowedVarsError) Error() string {
-	var builder strings.Builder
-
-	builder.WriteString(fmt.Sprintf("task: Task %q cancelled because it is missing required variables:\n", err.TaskName))
-	for _, s := range err.NotAllowedVars {
-		builder.WriteString(fmt.Sprintf("  - %s has an invalid value : '%s' (allowed values : %v)\n", s.Name, s.Value, s.Enum))
-	}
-
-	return builder.String()
-}
-
-func (err *TaskNotAllowedVarsError) Code() int {
-	return CodeTaskNotAllowedVars
-}

errors/errors_taskfile.go

@@ -1,194 +0,0 @@
-package errors
-
-import (
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/Masterminds/semver/v3"
-)
-
-// TaskfileNotFoundError is returned when no appropriate Taskfile is found when
-// searching the filesystem.
-type TaskfileNotFoundError struct {
-	URI  string
-	Walk bool
-}
-
-func (err TaskfileNotFoundError) Error() string {
-	var walkText string
-	if err.Walk {
-		walkText = " (or any of the parent directories)"
-	}
-	return fmt.Sprintf(`task: No Taskfile found at %q%s`, err.URI, walkText)
-}
-
-func (err TaskfileNotFoundError) Code() int {
-	return CodeTaskfileNotFound
-}
-
-// TaskfileAlreadyExistsError is returned on creating a Taskfile if one already
-// exists.
-type TaskfileAlreadyExistsError struct{}
-
-func (err TaskfileAlreadyExistsError) Error() string {
-	return "task: A Taskfile already exists"
-}
-
-func (err TaskfileAlreadyExistsError) Code() int {
-	return CodeTaskfileAlreadyExists
-}
-
-// TaskfileInvalidError is returned when the Taskfile contains syntax errors or
-// cannot be parsed for some reason.
-type TaskfileInvalidError struct {
-	URI string
-	Err error
-}
-
-func (err TaskfileInvalidError) Error() string {
-	return fmt.Sprintf("task: Failed to parse %s:\n%v", err.URI, err.Err)
-}
-
-func (err TaskfileInvalidError) Code() int {
-	return CodeTaskfileInvalid
-}
-
-// TaskfileFetchFailedError is returned when no appropriate Taskfile is found when
-// searching the filesystem.
-type TaskfileFetchFailedError struct {
-	URI            string
-	HTTPStatusCode int
-}
-
-func (err TaskfileFetchFailedError) Error() string {
-	var statusText string
-	if err.HTTPStatusCode != 0 {
-		statusText = fmt.Sprintf(" with status code %d (%s)", err.HTTPStatusCode, http.StatusText(err.HTTPStatusCode))
-	}
-	return fmt.Sprintf(`task: Download of %q failed%s`, err.URI, statusText)
-}
-
-func (err TaskfileFetchFailedError) Code() int {
-	return CodeTaskfileFetchFailed
-}
-
-// TaskfileNotTrustedError is returned when the user does not accept the trust
-// prompt when downloading a remote Taskfile.
-type TaskfileNotTrustedError struct {
-	URI string
-}
-
-func (err *TaskfileNotTrustedError) Error() string {
-	return fmt.Sprintf(
-		`task: Taskfile %q not trusted by user`,
-		err.URI,
-	)
-}
-
-func (err *TaskfileNotTrustedError) Code() int {
-	return CodeTaskfileNotTrusted
-}
-
-// TaskfileNotSecureError is returned when the user attempts to download a
-// remote Taskfile over an insecure connection.
-type TaskfileNotSecureError struct {
-	URI string
-}
-
-func (err *TaskfileNotSecureError) Error() string {
-	return fmt.Sprintf(
-		`task: Taskfile %q cannot be downloaded over an insecure connection. You can override this by using the --insecure flag`,
-		err.URI,
-	)
-}
-
-func (err *TaskfileNotSecureError) Code() int {
-	return CodeTaskfileNotSecure
-}
-
-// TaskfileCacheNotFoundError is returned when the user attempts to use an offline
-// (cached) Taskfile but the files does not exist in the cache.
-type TaskfileCacheNotFoundError struct {
-	URI string
-}
-
-func (err *TaskfileCacheNotFoundError) Error() string {
-	return fmt.Sprintf(
-		`task: Taskfile %q was not found in the cache. Remove the --offline flag to use a remote copy or download it using the --download flag`,
-		err.URI,
-	)
-}
-
-func (err *TaskfileCacheNotFoundError) Code() int {
-	return CodeTaskfileCacheNotFound
-}
-
-// TaskfileVersionCheckError is returned when the user attempts to run a
-// Taskfile that does not contain a Taskfile schema version key or if they try
-// to use a feature that is not supported by the schema version.
-type TaskfileVersionCheckError struct {
-	URI           string
-	SchemaVersion *semver.Version
-	Message       string
-}
-
-func (err *TaskfileVersionCheckError) Error() string {
-	if err.SchemaVersion == nil {
-		return fmt.Sprintf(
-			`task: Missing schema version in Taskfile %q`,
-			err.URI,
-		)
-	}
-	return fmt.Sprintf(
-		"task: Invalid schema version in Taskfile %q:\nSchema version (%s) %s",
-		err.URI,
-		err.SchemaVersion.String(),
-		err.Message,
-	)
-}
-
-func (err *TaskfileVersionCheckError) Code() int {
-	return CodeTaskfileVersionCheckError
-}
-
-// TaskfileNetworkTimeoutError is returned when the user attempts to use a remote
-// Taskfile but a network connection could not be established within the timeout.
-type TaskfileNetworkTimeoutError struct {
-	URI          string
-	Timeout      time.Duration
-	CheckedCache bool
-}
-
-func (err *TaskfileNetworkTimeoutError) Error() string {
-	var cacheText string
-	if err.CheckedCache {
-		cacheText = " and no offline copy was found in the cache"
-	}
-	return fmt.Sprintf(
-		`task: Network connection timed out after %s while attempting to download Taskfile %q%s`,
-		err.Timeout, err.URI, cacheText,
-	)
-}
-
-func (err *TaskfileNetworkTimeoutError) Code() int {
-	return CodeTaskfileNetworkTimeout
-}
-
-// TaskfileCycleError is returned when we detect that a Taskfile includes a
-// set of Taskfiles that include each other in a cycle.
-type TaskfileCycleError struct {
-	Source      string
-	Destination string
-}
-
-func (err TaskfileCycleError) Error() string {
-	return fmt.Sprintf("task: include cycle detected between %s <--> %s",
-		err.Source,
-		err.Destination,
-	)
-}
-
-func (err TaskfileCycleError) Code() int {
-	return CodeTaskfileCycle
-}

go.mod

@@ -1,62 +0,0 @@
-module github.com/go-task/task/v3
-
-go 1.23.0
-
-require (
-	github.com/Ladicle/tabwriter v1.0.0
-	github.com/Masterminds/semver/v3 v3.3.1
-	github.com/alecthomas/chroma/v2 v2.15.0
-	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/fatih/color v1.18.0
-	github.com/go-git/go-billy/v5 v5.6.2
-	github.com/go-git/go-git/v5 v5.14.0
-	github.com/go-task/slim-sprig/v3 v3.0.0
-	github.com/go-task/template v0.1.0
-	github.com/joho/godotenv v1.5.1
-	github.com/mattn/go-zglob v0.0.6
-	github.com/mitchellh/hashstructure/v2 v2.0.2
-	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/stretchr/testify v1.10.0
-	github.com/zeebo/xxh3 v1.0.2
-	golang.org/x/sync v0.12.0
-	golang.org/x/term v0.30.0
-	gopkg.in/yaml.v3 v3.0.1
-	mvdan.cc/sh/v3 v3.11.0
-)
-
-require (
-	dario.cat/mergo v1.0.0 // indirect
-	github.com/Microsoft/go-winio v0.6.2 // indirect
-	github.com/ProtonMail/go-crypto v1.1.5 // indirect
-	github.com/cloudflare/circl v1.6.0 // indirect
-	github.com/cyphar/filepath-securejoin v0.4.1 // indirect
-	github.com/dlclark/regexp2 v1.11.4 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
-	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
-	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
-	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
-	github.com/kevinburke/ssh_config v1.2.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/otiai10/mint v1.6.3 // indirect
-	github.com/pjbgf/sha1cd v0.3.2 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
-	github.com/skeema/knownhosts v1.3.1 // indirect
-	github.com/stretchr/objx v0.5.2 // indirect
-	github.com/xanzy/ssh-agent v0.3.3 // indirect
-	golang.org/x/crypto v0.35.0 // indirect
-	golang.org/x/mod v0.22.0 // indirect
-	golang.org/x/net v0.35.0 // indirect
-	golang.org/x/sys v0.31.0 // indirect
-	golang.org/x/tools v0.27.0 // indirect
-	gopkg.in/warnings.v0 v0.1.2 // indirect
-)

go.sum

@@ -1,200 +0,0 @@
-dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
-dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
-github.com/Ladicle/tabwriter v1.0.0 h1:DZQqPvMumBDwVNElso13afjYLNp0Z7pHqHnu0r4t9Dg=
-github.com/Ladicle/tabwriter v1.0.0/go.mod h1:c4MdCjxQyTbGuQO/gvqJ+IA/89UEwrsD6hUCW98dyp4=
-github.com/Masterminds/semver/v3 v3.3.1 h1:QtNSWtVZ3nBfk8mAOu/B6v7FMJ+NHTIgUPi7rj+4nv4=
-github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
-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/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
-github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
-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/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=
-github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
-github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
-github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
-github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
-github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
-github.com/chainguard-dev/git-urls v1.0.2 h1:pSpT7ifrpc5X55n4aTTm7FFUE+ZQHKiqpiwNkJrVcKQ=
-github.com/chainguard-dev/git-urls v1.0.2/go.mod h1:rbGgj10OS7UgZlbzdUQIQpT0k/D4+An04HJY7Ol+Y/o=
-github.com/cloudflare/circl v1.3.7 h1:qlCDlTPz2n9fu58M0Nh1J/JzcFpfgkFHHX3O35r5vcU=
-github.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBSc8r4zxgA=
-github.com/cloudflare/circl v1.6.0 h1:cr5JKic4HI+LkINy2lg3W2jF8sHCVTBncJr5gIIq7qk=
-github.com/cloudflare/circl v1.6.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
-github.com/creack/pty v1.1.23 h1:4M6+isWdcStXEf15G/RbrMPOQj1dZ7HPZCGwE4kOeP0=
-github.com/creack/pty v1.1.23/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
-github.com/cyphar/filepath-securejoin v0.3.6 h1:4d9N5ykBnSp5Xn2JkhocYDkOpURL/18CYMpo6xB9uWM=
-github.com/cyphar/filepath-securejoin v0.3.6/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
-github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s=
-github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
-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.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/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=
-github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-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.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.2 h1:7O7xvsK7K+rZPKW6AQR1YyNhfywkv7B8/FsP3ki6Zv0=
-github.com/go-git/go-git/v5 v5.13.2/go.mod h1:hWdW5P4YZRjmpGHwRH2v3zkWcNl6HeXaXQEMGb3NJ9A=
-github.com/go-git/go-git/v5 v5.14.0 h1:/MD3lCrGjCen5WfEAzKg00MJJffKhC8gzS80ycmCi60=
-github.com/go-git/go-git/v5 v5.14.0/go.mod h1:Z5Xhoia5PcWA3NF8vRLURn9E5FRhSl7dGj9ItW3Wk5k=
-github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
-github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
-github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
-github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
-github.com/go-task/template v0.1.0 h1:ym/r2G937RZA1bsgiWedNnY9e5kxDT+3YcoAnuIetTE=
-github.com/go-task/template v0.1.0/go.mod h1:RgwRaZK+kni/hJJ7/AaOE2lPQFPbAdji/DyhC6pxo4k=
-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
-github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
-github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
-github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
-github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
-github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
-github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
-github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
-github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
-github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-zglob v0.0.6 h1:mP8RnmCgho4oaUYDIDn6GNxYk+qJGUs8fJLn+twYj2A=
-github.com/mattn/go-zglob v0.0.6/go.mod h1:MxxjyoXXnMxfIpxTK2GAkw1w8glPsQILx3N5wrKakiY=
-github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=
-github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=
-github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
-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.1 h1:5/7E6qsUMBaH5AnQ0sSLzzTg1oTECmcCmT6lvF45Na8=
-github.com/otiai10/copy v1.14.1/go.mod h1:oQwrEDDOci3IM8dJF0d8+jnbfPDllW6vUjNc3DoZm9I=
-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.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
-github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/radovskyb/watcher v1.0.7 h1:AYePLih6dpmS32vlHfhCeli8127LzkIgwJGcwwe8tUE=
-github.com/radovskyb/watcher v1.0.7/go.mod h1:78okwvY5wPdzcb1UYnip1pvrZNIVEIh/Cm+ZuvsUYIg=
-github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
-github.com/sajari/fuzzy v1.0.0 h1:+FmwVvJErsd0d0hAPlj4CxqxUtQY/fOoY0DwX4ykpRY=
-github.com/sajari/fuzzy v1.0.0/go.mod h1:OjYR6KxoWOe9+dOlXeiCJd4dIbED4Oo8wpS89o0pwOo=
-github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
-github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
-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/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=
-github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=
-github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
-github.com/spf13/pflag v1.0.6/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=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
-github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
-github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
-github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
-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.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
-golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
-golang.org/x/crypto v0.35.0 h1:b15kiHdrGCHrP6LvwaQ3c03kgNhhiMgvlhxHQhmg2Xs=
-golang.org/x/crypto v0.35.0/go.mod h1:dy7dXNW32cAb/6/PRuTNsix8T+vJAqvuIy5Bli/x0YQ=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
-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/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-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/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
-golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
-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.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
-golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-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=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-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.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
-golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-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.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
-golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
-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=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
-golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
-golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
-gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-mvdan.cc/sh/v3 v3.10.0 h1:v9z7N1DLZ7owyLM/SXZQkBSXcwr2IGMm2LY2pmhVXj4=
-mvdan.cc/sh/v3 v3.10.0/go.mod h1:z/mSSVyLFGZzqb3ZIKojjyqIx/xbmz/UHdCSv9HmqXY=
-mvdan.cc/sh/v3 v3.11.0 h1:q5h+XMDRfUGUedCqFFsjoFjrhwf2Mvtt1rkMvVz0blw=
-mvdan.cc/sh/v3 v3.11.0/go.mod h1:LRM+1NjoYCzuq/WZ6y44x14YNAI0NK7FLPeQSaFagGg=

hash.go

@@ -1,25 +0,0 @@
-package task
-
-import (
-	"cmp"
-	"fmt"
-
-	"github.com/go-task/task/v3/internal/hash"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-func (e *Executor) GetHash(t *ast.Task) (string, error) {
-	r := cmp.Or(t.Run, e.Taskfile.Run)
-	var h hash.HashFunc
-	switch r {
-	case "always":
-		h = hash.Empty
-	case "once":
-		h = hash.Name
-	case "when_changed":
-		h = hash.Hash
-	default:
-		return "", fmt.Errorf(`task: invalid run "%s"`, r)
-	}
-	return h(t)
-}

help.go

@@ -1,202 +1,37 @@
 package task
 
 import (
-	"context"
-	"encoding/json"
 	"fmt"
-	"io"
-	"os"
-	"strings"
+	"sort"
+	"text/tabwriter"
 
-	"github.com/Ladicle/tabwriter"
-	"golang.org/x/sync/errgroup"
-
-	"github.com/go-task/task/v3/internal/editors"
-	"github.com/go-task/task/v3/internal/fingerprint"
-	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/sort"
-	"github.com/go-task/task/v3/taskfile/ast"
+	"github.com/go-task/task/internal/taskfile"
 )
 
-// ListOptions collects list-related options
-type ListOptions struct {
-	ListOnlyTasksWithDescriptions bool
-	ListAllTasks                  bool
-	FormatTaskListAsJSON          bool
-	NoStatus                      bool
-}
-
-// NewListOptions creates a new ListOptions instance
-func NewListOptions(list, listAll, listAsJson, noStatus bool) ListOptions {
-	return ListOptions{
-		ListOnlyTasksWithDescriptions: list,
-		ListAllTasks:                  listAll,
-		FormatTaskListAsJSON:          listAsJson,
-		NoStatus:                      noStatus,
-	}
-}
-
-// ShouldListTasks returns true if one of the options to list tasks has been set to true
-func (o ListOptions) ShouldListTasks() bool {
-	return o.ListOnlyTasksWithDescriptions || o.ListAllTasks
-}
-
-// Validate validates that the collection of list-related options are in a valid configuration
-func (o ListOptions) Validate() error {
-	if o.ListOnlyTasksWithDescriptions && o.ListAllTasks {
-		return fmt.Errorf("task: cannot use --list and --list-all at the same time")
-	}
-	if o.FormatTaskListAsJSON && !o.ShouldListTasks() {
-		return fmt.Errorf("task: --json only applies to --list or --list-all")
-	}
-	if o.NoStatus && !o.FormatTaskListAsJSON {
-		return fmt.Errorf("task: --no-status only applies to --json with --list or --list-all")
-	}
-	return nil
-}
-
-// Filters returns the slice of FilterFunc which filters a list
-// of ast.Task according to the given ListOptions
-func (o ListOptions) Filters() []FilterFunc {
-	filters := []FilterFunc{FilterOutInternal}
-
-	if o.ListOnlyTasksWithDescriptions {
-		filters = append(filters, FilterOutNoDesc)
-	}
-
-	return filters
-}
-
-// ListTasks prints a list of tasks.
-// Tasks that match the given filters will be excluded from the list.
-// The function returns a boolean indicating whether tasks were found
-// and an error if one was encountered while preparing the output.
-func (e *Executor) ListTasks(o ListOptions) (bool, error) {
-	tasks, err := e.GetTaskList(o.Filters()...)
-	if err != nil {
-		return false, err
-	}
-	if o.FormatTaskListAsJSON {
-		output, err := e.ToEditorOutput(tasks, o.NoStatus)
-		if err != nil {
-			return false, err
-		}
-
-		encoder := json.NewEncoder(e.Stdout)
-		encoder.SetIndent("", "  ")
-		if err := encoder.Encode(output); err != nil {
-			return false, err
-		}
-
-		return len(tasks) > 0, nil
-	}
+// PrintTasksHelp prints help os tasks that have a description
+func (e *Executor) PrintTasksHelp() {
+	tasks := e.tasksWithDesc()
 	if len(tasks) == 0 {
-		if o.ListOnlyTasksWithDescriptions {
-			e.Logger.Outf(logger.Yellow, "task: No tasks with description available. Try --list-all to list all tasks\n")
-		} else if o.ListAllTasks {
-			e.Logger.Outf(logger.Yellow, "task: No tasks available\n")
-		}
-		return false, nil
+		e.Logger.Outf("task: No tasks with description available")
+		return
 	}
-	e.Logger.Outf(logger.Default, "task: Available tasks for this project:\n")
+	e.Logger.Outf("task: Available tasks for this project:")
 
 	// Format in tab-separated columns with a tab stop of 8.
-	w := tabwriter.NewWriter(e.Stdout, 0, 8, 6, ' ', 0)
+	w := tabwriter.NewWriter(e.Stdout, 0, 8, 0, '\t', 0)
 	for _, task := range tasks {
-		e.Logger.FOutf(w, logger.Yellow, "* ")
-		e.Logger.FOutf(w, logger.Green, task.Task)
-		desc := strings.ReplaceAll(task.Desc, "\n", " ")
-		e.Logger.FOutf(w, logger.Default, ": \t%s", desc)
-		if len(task.Aliases) > 0 {
-			e.Logger.FOutf(w, logger.Cyan, "\t(aliases: %s)", strings.Join(task.Aliases, ", "))
-		}
-		_, _ = fmt.Fprint(w, "\n")
+		fmt.Fprintf(w, "* %s: \t%s\n", task.Task, task.Desc)
 	}
-	if err := w.Flush(); err != nil {
-		return false, err
-	}
-	return true, nil
+	w.Flush()
 }
 
-// ListTaskNames prints only the task names in a Taskfile.
-// Only tasks with a non-empty description are printed if allTasks is false.
-// Otherwise, all task names are printed.
-func (e *Executor) ListTaskNames(allTasks bool) error {
-	// use stdout if no output defined
-	var w io.Writer = os.Stdout
-	if e.Stdout != nil {
-		w = e.Stdout
-	}
-
-	// Sort the tasks
-	if e.TaskSorter == nil {
-		e.TaskSorter = sort.AlphaNumericWithRootTasksFirst
-	}
-
-	// Create a list of task names
-	taskNames := make([]string, 0, e.Taskfile.Tasks.Len())
-	for task := range e.Taskfile.Tasks.Values(e.TaskSorter) {
-		if (allTasks || task.Desc != "") && !task.Internal {
-			taskNames = append(taskNames, strings.TrimRight(task.Task, ":"))
-			for _, alias := range task.Aliases {
-				taskNames = append(taskNames, strings.TrimRight(alias, ":"))
-			}
+func (e *Executor) tasksWithDesc() (tasks []*taskfile.Task) {
+	tasks = make([]*taskfile.Task, 0, len(e.Taskfile.Tasks))
+	for _, task := range e.Taskfile.Tasks {
+		if task.Desc != "" {
+			tasks = append(tasks, task)
 		}
 	}
-	for _, t := range taskNames {
-		fmt.Fprintln(w, t)
-	}
-	return nil
-}
-
-func (e *Executor) ToEditorOutput(tasks []*ast.Task, noStatus bool) (*editors.Taskfile, error) {
-	o := &editors.Taskfile{
-		Tasks:    make([]editors.Task, len(tasks)),
-		Location: e.Taskfile.Location,
-	}
-	var g errgroup.Group
-	for i := range tasks {
-		aliases := []string{}
-		if len(tasks[i].Aliases) > 0 {
-			aliases = tasks[i].Aliases
-		}
-		g.Go(func() error {
-			o.Tasks[i] = editors.Task{
-				Name:     tasks[i].Name(),
-				Desc:     tasks[i].Desc,
-				Summary:  tasks[i].Summary,
-				Aliases:  aliases,
-				UpToDate: false,
-				Location: &editors.Location{
-					Line:     tasks[i].Location.Line,
-					Column:   tasks[i].Location.Column,
-					Taskfile: tasks[i].Location.Taskfile,
-				},
-			}
-
-			if noStatus {
-				return nil
-			}
-
-			// Get the fingerprinting method to use
-			method := e.Taskfile.Method
-			if tasks[i].Method != "" {
-				method = tasks[i].Method
-			}
-			upToDate, err := fingerprint.IsTaskUpToDate(context.Background(), tasks[i],
-				fingerprint.WithMethod(method),
-				fingerprint.WithTempDir(e.TempDir.Fingerprint),
-				fingerprint.WithDry(e.Dry),
-				fingerprint.WithLogger(e.Logger),
-			)
-			if err != nil {
-				return err
-			}
-
-			o.Tasks[i].UpToDate = upToDate
-
-			return nil
-		})
-	}
-	return o, g.Wait()
+	sort.Slice(tasks, func(i, j int) bool { return tasks[i].Task < tasks[j].Task })
+	return
 }

init.go

@@ -1,15 +1,16 @@
 package task
 
 import (
+	"fmt"
+	"io"
+	"io/ioutil"
 	"os"
-
-	"github.com/go-task/task/v3/errors"
-	"github.com/go-task/task/v3/internal/filepathext"
+	"path/filepath"
 )
 
-const DefaultTaskfile = `# https://taskfile.dev
+const defaultTaskfile = `# github.com/go-task/task
 
-version: '3'
+version: '2'
 
 vars:
   GREETING: Hello, World!
@@ -21,31 +22,17 @@ tasks:
     silent: true
 `
 
-const defaultTaskFilename = "Taskfile.yml"
+// InitTaskfile Taskfile creates a new Taskfile
+func InitTaskfile(w io.Writer, dir string) error {
+	f := filepath.Join(dir, "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{}
+	if _, err := os.Stat(f); err == nil {
+		return ErrTaskfileAlreadyExists
 	}
 
-	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 := ioutil.WriteFile(f, []byte(defaultTaskfile), 0644); err != nil {
+		return err
 	}
-
-	if err := os.WriteFile(path, []byte(DefaultTaskfile), 0o644); err != nil {
-		return path, err
-	}
-
-	return path, nil
+	fmt.Fprintf(w, "Taskfile.yml created in the current directory\n")
+	return nil
 }

init_test.go

@@ -1,52 +0,0 @@
-package task_test
-
-import (
-	"os"
-	"testing"
-
-	"github.com/go-task/task/v3"
-	"github.com/go-task/task/v3/internal/filepathext"
-)
-
-func TestInitDir(t *testing.T) {
-	t.Parallel()
-
-	const dir = "testdata/init"
-	file := filepathext.SmartJoin(dir, "Taskfile.yml")
-
-	_ = os.Remove(file)
-	if _, err := os.Stat(file); err == nil {
-		t.Errorf("Taskfile.yml should not exist")
-	}
-
-	if _, err := task.InitTaskfile(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)
-}

install-task.sh

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

internal/args/args.go

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

internal/args/args_test.go

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

internal/compiler/compiler.go

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

internal/compiler/env.go

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

internal/compiler/v1/compiler_v1.go

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

internal/compiler/v2/compiler_v2.go

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

internal/deepcopy/deepcopy.go

@@ -1,158 +0,0 @@
-package deepcopy
-
-import (
-	"reflect"
-
-	"github.com/elliotchance/orderedmap/v3"
-)
-
-type Copier[T any] interface {
-	DeepCopy() T
-}
-
-func Slice[T any](orig []T) []T {
-	if orig == nil {
-		return nil
-	}
-	c := make([]T, len(orig))
-	for i, v := range orig {
-		if copyable, ok := any(v).(Copier[T]); ok {
-			c[i] = copyable.DeepCopy()
-		} else {
-			c[i] = v
-		}
-	}
-	return c
-}
-
-func Map[K comparable, V any](orig map[K]V) map[K]V {
-	if orig == nil {
-		return nil
-	}
-	c := make(map[K]V, len(orig))
-	for k, v := range orig {
-		if copyable, ok := any(v).(Copier[V]); ok {
-			c[k] = copyable.DeepCopy()
-		} else {
-			c[k] = v
-		}
-	}
-	return c
-}
-
-func OrderedMap[K comparable, V any](orig *orderedmap.OrderedMap[K, V]) *orderedmap.OrderedMap[K, V] {
-	if orig.Len() == 0 {
-		return orderedmap.NewOrderedMap[K, V]()
-	}
-	c := orderedmap.NewOrderedMap[K, V]()
-	for pair := orig.Front(); pair != nil; pair = pair.Next() {
-		if copyable, ok := any(pair.Value).(Copier[V]); ok {
-			c.Set(pair.Key, copyable.DeepCopy())
-		} else {
-			c.Set(pair.Key, pair.Value)
-		}
-	}
-	return c
-}
-
-// TraverseStringsFunc runs the given function on every string in the given
-// value by traversing it recursively. If the given value is a string, the
-// function will run on a copy of the string and return it. If the value is a
-// struct, map or a slice, the function will recursively call itself for each
-// field or element of the struct, map or slice until all strings inside the
-// struct or slice are replaced.
-func TraverseStringsFunc[T any](v T, fn func(v string) (string, error)) (T, error) {
-	original := reflect.ValueOf(v)
-	if original.Kind() == reflect.Invalid || !original.IsValid() {
-		return v, nil
-	}
-	copy := reflect.New(original.Type()).Elem()
-
-	var traverseFunc func(copy, v reflect.Value) error
-	traverseFunc = func(copy, v reflect.Value) error {
-		switch v.Kind() {
-
-		case reflect.Ptr:
-			// Unwrap the pointer
-			originalValue := v.Elem()
-			// If the pointer is nil, do nothing
-			if !originalValue.IsValid() {
-				return nil
-			}
-			// Create an empty copy from the original value's type
-			copy.Set(reflect.New(originalValue.Type()))
-			// Unwrap the newly created pointer and call traverseFunc recursively
-			if err := traverseFunc(copy.Elem(), originalValue); err != nil {
-				return err
-			}
-
-		case reflect.Interface:
-			// Unwrap the interface
-			originalValue := v.Elem()
-			if !originalValue.IsValid() {
-				return nil
-			}
-			// Create an empty copy from the original value's type
-			copyValue := reflect.New(originalValue.Type()).Elem()
-			// Unwrap the newly created pointer and call traverseFunc recursively
-			if err := traverseFunc(copyValue, originalValue); err != nil {
-				return err
-			}
-			copy.Set(copyValue)
-
-		case reflect.Struct:
-			// Loop over each field and call traverseFunc recursively
-			for i := range v.NumField() {
-				if err := traverseFunc(copy.Field(i), v.Field(i)); err != nil {
-					return err
-				}
-			}
-
-		case reflect.Slice:
-			// Create an empty copy from the original value's type
-			copy.Set(reflect.MakeSlice(v.Type(), v.Len(), v.Cap()))
-			// Loop over each element and call traverseFunc recursively
-			for i := range v.Len() {
-				if err := traverseFunc(copy.Index(i), v.Index(i)); err != nil {
-					return err
-				}
-			}
-
-		case reflect.Map:
-			// Create an empty copy from the original value's type
-			copy.Set(reflect.MakeMap(v.Type()))
-			// Loop over each key
-			for _, key := range v.MapKeys() {
-				// Create a copy of each map index
-				originalValue := v.MapIndex(key)
-				if originalValue.IsNil() {
-					continue
-				}
-				copyValue := reflect.New(originalValue.Type()).Elem()
-				// Call traverseFunc recursively
-				if err := traverseFunc(copyValue, originalValue); err != nil {
-					return err
-				}
-				copy.SetMapIndex(key, copyValue)
-			}
-
-		case reflect.String:
-			rv, err := fn(v.String())
-			if err != nil {
-				return err
-			}
-			copy.Set(reflect.ValueOf(rv))
-
-		default:
-			copy.Set(v)
-		}
-
-		return nil
-	}
-
-	if err := traverseFunc(copy, original); err != nil {
-		return v, err
-	}
-
-	return copy.Interface().(T), nil
-}

internal/editors/output.go

@@ -1,24 +0,0 @@
-package editors
-
-type (
-	// Taskfile wraps task list output for use in editor integrations (e.g. VSCode, etc)
-	Taskfile struct {
-		Tasks    []Task `json:"tasks"`
-		Location string `json:"location"`
-	}
-	// Task describes a single task
-	Task struct {
-		Name     string    `json:"name"`
-		Desc     string    `json:"desc"`
-		Summary  string    `json:"summary"`
-		Aliases  []string  `json:"aliases"`
-		UpToDate bool      `json:"up_to_date"`
-		Location *Location `json:"location"`
-	}
-	// Location describes a task's location in a taskfile
-	Location struct {
-		Line     int    `json:"line"`
-		Column   int    `json:"column"`
-		Taskfile string `json:"taskfile"`
-	}
-)

internal/env/env.go

@@ -1,63 +0,0 @@
-package env
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/go-task/task/v3/internal/experiments"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-const taskVarPrefix = "TASK_"
-
-// GetEnviron the all return all environment variables encapsulated on a
-// ast.Vars
-func GetEnviron() *ast.Vars {
-	m := ast.NewVars()
-	for _, e := range os.Environ() {
-		keyVal := strings.SplitN(e, "=", 2)
-		key, val := keyVal[0], keyVal[1]
-		m.Set(key, ast.Var{Value: val})
-	}
-	return m
-}
-
-func Get(t *ast.Task) []string {
-	if t.Env == nil {
-		return nil
-	}
-
-	return GetFromVars(t.Env)
-}
-
-func GetFromVars(env *ast.Vars) []string {
-	environ := os.Environ()
-
-	for k, v := range env.ToCacheMap() {
-		if !isTypeAllowed(v) {
-			continue
-		}
-		if !experiments.EnvPrecedence.Enabled() {
-			if _, alreadySet := os.LookupEnv(k); alreadySet {
-				continue
-			}
-		}
-		environ = append(environ, fmt.Sprintf("%s=%v", k, v))
-	}
-
-	return environ
-}
-
-func isTypeAllowed(v any) bool {
-	switch v.(type) {
-	case string, bool, int, float32, float64:
-		return true
-	default:
-		return false
-	}
-}
-
-func GetTaskEnv(key string) string {
-	return os.Getenv(taskVarPrefix + key)
-}

internal/execext/devnull.go

@@ -1,13 +0,0 @@
-package execext
-
-import (
-	"io"
-)
-
-var _ io.ReadWriteCloser = devNull{}
-
-type devNull struct{}
-
-func (devNull) Read(p []byte) (int, error)  { return 0, io.EOF }
-func (devNull) Write(p []byte) (int, error) { return len(p), nil }
-func (devNull) Close() error                { return nil }

internal/execext/exec.go

@@ -2,141 +2,55 @@ package execext
 
 import (
 	"context"
-	"fmt"
+	"errors"
 	"io"
-	"os"
-	"path/filepath"
 	"strings"
-	"time"
 
-	"mvdan.cc/sh/v3/expand"
-	"mvdan.cc/sh/v3/interp"
-	"mvdan.cc/sh/v3/shell"
-	"mvdan.cc/sh/v3/syntax"
-
-	"github.com/go-task/task/v3/errors"
+	"mvdan.cc/sh/interp"
+	"mvdan.cc/sh/syntax"
 )
 
 // RunCommandOptions is the options for the RunCommand func
 type RunCommandOptions struct {
-	Command   string
-	Dir       string
-	Env       []string
-	PosixOpts []string
-	BashOpts  []string
-	Stdin     io.Reader
-	Stdout    io.Writer
-	Stderr    io.Writer
+	Context context.Context
+	Command string
+	Dir     string
+	Env     []string
+	Stdin   io.Reader
+	Stdout  io.Writer
+	Stderr  io.Writer
 }
 
-// ErrNilOptions is returned when a nil options is given
-var ErrNilOptions = errors.New("execext: nil options given")
+var (
+	// ErrNilOptions is returned when a nil options is given
+	ErrNilOptions = errors.New("execext: nil options given")
+)
 
 // RunCommand runs a shell command
-func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
+func RunCommand(opts *RunCommandOptions) error {
 	if opts == nil {
 		return ErrNilOptions
 	}
 
-	// Set "-e" or "errexit" by default
-	opts.PosixOpts = append(opts.PosixOpts, "e")
-
-	// Format POSIX options into a slice that mvdan/sh understands
-	var params []string
-	for _, opt := range opts.PosixOpts {
-		if len(opt) == 1 {
-			params = append(params, fmt.Sprintf("-%s", opt))
-		} else {
-			params = append(params, "-o")
-			params = append(params, opt)
-		}
-	}
-
-	environ := opts.Env
-	if len(environ) == 0 {
-		environ = os.Environ()
-	}
-
-	r, err := interp.New(
-		interp.Params(params...),
-		interp.Env(expand.ListEnviron(environ...)),
-		interp.ExecHandlers(execHandler),
-		interp.OpenHandler(openHandler),
-		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
-		dirOption(opts.Dir),
-	)
+	p, err := syntax.NewParser().Parse(strings.NewReader(opts.Command), "")
 	if err != nil {
 		return err
 	}
 
-	parser := syntax.NewParser()
+	r := interp.Runner{
+		Context: opts.Context,
+		Dir:     opts.Dir,
+		Env:     opts.Env,
 
-	// Run any shopt commands
-	if len(opts.BashOpts) > 0 {
-		shoptCmdStr := fmt.Sprintf("shopt -s %s", strings.Join(opts.BashOpts, " "))
-		shoptCmd, err := parser.Parse(strings.NewReader(shoptCmdStr), "")
-		if err != nil {
-			return err
-		}
-		if err := r.Run(ctx, shoptCmd); err != nil {
-			return err
-		}
+		Exec: interp.DefaultExec,
+		Open: interp.OpenDevImpls(interp.DefaultOpen),
+
+		Stdin:  opts.Stdin,
+		Stdout: opts.Stdout,
+		Stderr: opts.Stderr,
 	}
-
-	// Run the user-defined command
-	p, err := parser.Parse(strings.NewReader(opts.Command), "")
-	if err != nil {
-		return err
-	}
-	return r.Run(ctx, p)
-}
-
-// Expand is a helper to mvdan.cc/shell.Fields that returns the first field
-// if available.
-func Expand(s string) (string, error) {
-	s = filepath.ToSlash(s)
-	s = strings.ReplaceAll(s, " ", `\ `)
-	s = strings.ReplaceAll(s, "&", `\&`)
-	s = strings.ReplaceAll(s, "(", `\(`)
-	s = strings.ReplaceAll(s, ")", `\)`)
-	fields, err := shell.Fields(s, nil)
-	if err != nil {
-		return "", err
-	}
-	if len(fields) > 0 {
-		return fields[0], nil
-	}
-	return "", nil
-}
-
-func execHandler(next interp.ExecHandlerFunc) interp.ExecHandlerFunc {
-	return interp.DefaultExecHandler(15 * time.Second)
-}
-
-func openHandler(ctx context.Context, path string, flag int, perm os.FileMode) (io.ReadWriteCloser, error) {
-	if path == "/dev/null" {
-		return devNull{}, nil
-	}
-	return interp.DefaultOpenHandler()(ctx, path, flag, perm)
-}
-
-func dirOption(path string) interp.RunnerOption {
-	return func(r *interp.Runner) error {
-		err := interp.Dir(path)(r)
-		if err == nil {
-			return nil
-		}
-
-		// If the specified directory doesn't exist, it will be created later.
-		// Therefore, even if `interp.Dir` method returns an error, the
-		// directory path should be set only when the directory cannot be found.
-		if absPath, _ := filepath.Abs(path); absPath != "" {
-			if _, err := os.Stat(absPath); os.IsNotExist(err) {
-				r.Dir = absPath
-				return nil
-			}
-		}
-
+	if err = r.Reset(); err != nil {
 		return err
 	}
+	return r.Run(p)
 }

internal/exp/maps.go

@@ -1,26 +0,0 @@
-// This package is intended as a place to copy functions from the
-// golang.org/x/exp package. Copying these functions allows us to rely on our
-// own code instead of an external package that may change unpredictably in the
-// future.
-//
-// It also prevents problems with transitive dependencies whereby a
-// package that imports Task (and therefore our version of golang.org/x/exp)
-// cannot import a different version of golang.org/x/exp.
-//
-// Finally, it serves as a place to track functions that may be able to be
-// removed in the future if they are added to the standard library. This is also
-// why this package is under the internal directory since these functions are
-// not intended to be used outside of Task.
-package exp
-
-import "cmp"
-
-// Keys is a copy of https://pkg.go.dev/golang.org/x/exp@v0.0.0-20240103183307-be819d1f06fc/maps#Keys.
-// This is not yet included in the standard library. See https://github.com/golang/go/issues/61538.
-func Keys[K cmp.Ordered, V any](m map[K]V) []K {
-	var keys []K
-	for key := range m {
-		keys = append(keys, key)
-	}
-	return keys
-}

internal/experiments/errors.go

@@ -1,35 +0,0 @@
-package experiments
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/go-task/task/v3/internal/slicesext"
-)
-
-type InvalidValueError struct {
-	Name          string
-	AllowedValues []int
-	Value         int
-}
-
-func (err InvalidValueError) Error() string {
-	return fmt.Sprintf(
-		"task: Experiment %q has an invalid value %q (allowed values: %s)",
-		err.Name,
-		err.Value,
-		strings.Join(slicesext.Convert(err.AllowedValues, strconv.Itoa), ", "),
-	)
-}
-
-type InactiveError struct {
-	Name string
-}
-
-func (err InactiveError) Error() string {
-	return fmt.Sprintf(
-		"task: Experiment %q is inactive and cannot be enabled",
-		err.Name,
-	)
-}

internal/experiments/experiment.go

@@ -1,62 +0,0 @@
-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.
-}
-
-// 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))
-	}
-
-	x := Experiment{
-		Name:          xName,
-		AllowedValues: allowedValues,
-		Value:         value,
-	}
-	xList = append(xList, x)
-	return x
-}
-
-func (x Experiment) Enabled() bool {
-	return slices.Contains(x.AllowedValues, x.Value)
-}
-
-func (x Experiment) Active() bool {
-	return len(x.AllowedValues) > 0
-}
-
-func (x Experiment) Valid() error {
-	if !x.Active() && x.Value != 0 {
-		return &InactiveError{
-			Name: x.Name,
-		}
-	}
-	if !x.Enabled() && x.Value != 0 {
-		return &InvalidValueError{
-			Name:          x.Name,
-			AllowedValues: x.AllowedValues,
-			Value:         x.Value,
-		}
-	}
-	return nil
-}
-
-func (x Experiment) String() string {
-	if x.Enabled() {
-		return fmt.Sprintf("on (%d)", x.Value)
-	}
-	return "off"
-}

internal/experiments/experiment_test.go

@@ -1,75 +0,0 @@
-package experiments_test
-
-import (
-	"strconv"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/go-task/task/v3/internal/experiments"
-)
-
-func TestNew(t *testing.T) {
-	const (
-		exampleExperiment    = "EXAMPLE"
-		exampleExperimentEnv = "TASK_X_EXAMPLE"
-	)
-	tests := []struct {
-		name          string
-		allowedValues []int
-		value         int
-		wantEnabled   bool
-		wantActive    bool
-		wantValid     error
-	}{
-		{
-			name:        `[] allowed, value=""`,
-			wantEnabled: false,
-			wantActive:  false,
-		},
-		{
-			name:        `[] allowed, value="1"`,
-			value:       1,
-			wantEnabled: false,
-			wantActive:  false,
-			wantValid: &experiments.InactiveError{
-				Name: exampleExperiment,
-			},
-		},
-		{
-			name:          `[1] allowed, value=""`,
-			allowedValues: []int{1},
-			wantEnabled:   false,
-			wantActive:    true,
-		},
-		{
-			name:          `[1] allowed, value="1"`,
-			allowedValues: []int{1},
-			value:         1,
-			wantEnabled:   true,
-			wantActive:    true,
-		},
-		{
-			name:          `[1] allowed, value="2"`,
-			allowedValues: []int{1},
-			value:         2,
-			wantEnabled:   false,
-			wantActive:    true,
-			wantValid: &experiments.InvalidValueError{
-				Name:          exampleExperiment,
-				AllowedValues: []int{1},
-				Value:         2,
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv(exampleExperimentEnv, strconv.Itoa(tt.value))
-			x := experiments.New(exampleExperiment, tt.allowedValues...)
-			assert.Equal(t, exampleExperiment, x.Name)
-			assert.Equal(t, tt.wantEnabled, x.Enabled())
-			assert.Equal(t, tt.wantActive, x.Active())
-			assert.Equal(t, tt.wantValid, x.Valid())
-		})
-	}
-}

internal/experiments/experiments.go

@@ -1,124 +0,0 @@
-package experiments
-
-import (
-	"fmt"
-	"os"
-	"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
-}
-
-var (
-	GentleForce     Experiment
-	RemoteTaskfiles Experiment
-	AnyVariables    Experiment
-	MapVariables    Experiment
-	EnvPrecedence   Experiment
-)
-
-// An internal list of all the initialized experiments used for iterating.
-var (
-	xList            []Experiment
-	experimentConfig experimentConfigFile
-)
-
-func init() {
-	readDotEnv()
-	experimentConfig = readConfig()
-	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)
-}
-
-// Validate checks if any experiments have been enabled while being inactive.
-// If one is found, the function returns an error.
-func Validate() error {
-	for _, x := range List() {
-		if err := x.Valid(); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func List() []Experiment {
-	return xList
-}
-
-func getEnv(xName string) string {
-	envName := fmt.Sprintf("%s%s", envPrefix, xName)
-	return os.Getenv(envName)
-}
-
-func getFilePath(filename string) 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
-	fs := pflag.NewFlagSet("experiments", pflag.ContinueOnError)
-	fs.StringVarP(&dir, "dir", "d", "", "Sets directory of execution.")
-	fs.StringVarP(&taskfile, "taskfile", "t", "", `Choose which Taskfile to run. Defaults to "Taskfile.yml".`)
-	fs.Usage = func() {}
-	_ = fs.Parse(os.Args[1:])
-	// If the directory is set, find a .env file in that directory.
-	if dir != "" {
-		return filepath.Join(dir, filename)
-	}
-	// If the taskfile is set, find a .env file in the directory containing the Taskfile.
-	if taskfile != "" {
-		return filepath.Join(filepath.Dir(taskfile), filename)
-	}
-	// Otherwise just use the current working directory.
-	return filename
-}
-
-func readDotEnv() {
-	env, _ := godotenv.Read(getFilePath(".env"))
-	// If the env var is an experiment, set it.
-	for key, value := range env {
-		if strings.HasPrefix(key, envPrefix) {
-			os.Setenv(key, value)
-		}
-	}
-}
-
-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

@@ -1,63 +0,0 @@
-package filepathext
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// SmartJoin joins two paths, but only if the second is not already an
-// absolute path.
-func SmartJoin(a, b string) string {
-	if IsAbs(b) {
-		return b
-	}
-	return filepath.Join(a, b)
-}
-
-func IsAbs(path string) bool {
-	// NOTE(@andreynering): If the path contains any if the special
-	// variables that we know are absolute, return true.
-	if isSpecialDir(path) {
-		return true
-	}
-
-	return filepath.IsAbs(path)
-}
-
-var knownAbsDirs = []string{
-	".ROOT_DIR",
-	".TASKFILE_DIR",
-	".USER_WORKING_DIR",
-}
-
-func isSpecialDir(dir string) bool {
-	for _, d := range knownAbsDirs {
-		if strings.Contains(dir, d) {
-			return true
-		}
-	}
-	return false
-}
-
-// TryAbsToRel tries to convert an absolute path to relative based on the
-// process working directory. If it can't, it returns the absolute path.
-func TryAbsToRel(abs string) string {
-	wd, err := os.Getwd()
-	if err != nil {
-		return abs
-	}
-
-	rel, err := filepath.Rel(wd, abs)
-	if err != nil {
-		return abs
-	}
-
-	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/fingerprint/checker.go

@@ -1,20 +0,0 @@
-package fingerprint
-
-import (
-	"context"
-
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-// StatusCheckable defines any type that can check if the status of a task is up-to-date.
-type StatusCheckable interface {
-	IsUpToDate(ctx context.Context, t *ast.Task) (bool, error)
-}
-
-// SourcesCheckable defines any type that can check if the sources of a task are up-to-date.
-type SourcesCheckable interface {
-	IsUpToDate(t *ast.Task) (bool, error)
-	Value(t *ast.Task) (any, error)
-	OnError(t *ast.Task) error
-	Kind() string
-}

internal/fingerprint/glob.go

@@ -1,60 +0,0 @@
-package fingerprint
-
-import (
-	"os"
-	"sort"
-
-	"github.com/mattn/go-zglob"
-
-	"github.com/go-task/task/v3/internal/execext"
-	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-func Globs(dir string, globs []*ast.Glob) ([]string, error) {
-	fileMap := make(map[string]bool)
-	for _, g := range globs {
-		matches, err := Glob(dir, g.Glob)
-		if err != nil {
-			continue
-		}
-		for _, match := range matches {
-			fileMap[match] = !g.Negate
-		}
-	}
-	files := make([]string, 0)
-	for file, includePath := range fileMap {
-		if includePath {
-			files = append(files, file)
-		}
-	}
-	sort.Strings(files)
-	return files, nil
-}
-
-func Glob(dir string, g string) ([]string, error) {
-	files := make([]string, 0)
-	g = filepathext.SmartJoin(dir, g)
-
-	g, err := execext.Expand(g)
-	if err != nil {
-		return nil, err
-	}
-
-	fs, err := zglob.GlobFollowSymlinks(g)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, f := range fs {
-		info, err := os.Stat(f)
-		if err != nil {
-			return nil, err
-		}
-		if info.IsDir() {
-			continue
-		}
-		files = append(files, f)
-	}
-	return files, nil
-}

internal/fingerprint/sources.go

@@ -1,16 +0,0 @@
-package fingerprint
-
-import "fmt"
-
-func NewSourcesChecker(method, tempDir string, dry bool) (SourcesCheckable, error) {
-	switch method {
-	case "timestamp":
-		return NewTimestampChecker(tempDir, dry), nil
-	case "checksum":
-		return NewChecksumChecker(tempDir, dry), nil
-	case "none":
-		return NoneChecker{}, nil
-	default:
-		return nil, fmt.Errorf(`task: invalid method "%s"`, method)
-	}
-}

internal/fingerprint/sources_checksum.go

@@ -1,126 +0,0 @@
-package fingerprint
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/zeebo/xxh3"
-
-	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-// ChecksumChecker validates if a task is up to date by calculating its source
-// files checksum
-type ChecksumChecker struct {
-	tempDir string
-	dry     bool
-}
-
-func NewChecksumChecker(tempDir string, dry bool) *ChecksumChecker {
-	return &ChecksumChecker{
-		tempDir: tempDir,
-		dry:     dry,
-	}
-}
-
-func (checker *ChecksumChecker) IsUpToDate(t *ast.Task) (bool, error) {
-	if len(t.Sources) == 0 {
-		return false, nil
-	}
-
-	checksumFile := checker.checksumFilePath(t)
-
-	data, _ := os.ReadFile(checksumFile)
-	oldHash := strings.TrimSpace(string(data))
-
-	newHash, err := checker.checksum(t)
-	if err != nil {
-		return false, nil
-	}
-
-	if !checker.dry && oldHash != newHash {
-		_ = os.MkdirAll(filepathext.SmartJoin(checker.tempDir, "checksum"), 0o755)
-		if err = os.WriteFile(checksumFile, []byte(newHash+"\n"), 0o644); err != nil {
-			return false, err
-		}
-	}
-
-	if len(t.Generates) > 0 {
-		// For each specified 'generates' field, check whether the files actually exist
-		for _, g := range t.Generates {
-			if g.Negate {
-				continue
-			}
-			generates, err := Glob(t.Dir, g.Glob)
-			if os.IsNotExist(err) {
-				return false, nil
-			}
-			if err != nil {
-				return false, err
-			}
-			if len(generates) == 0 {
-				return false, nil
-			}
-		}
-	}
-
-	return oldHash == newHash, nil
-}
-
-func (checker *ChecksumChecker) Value(t *ast.Task) (any, error) {
-	return checker.checksum(t)
-}
-
-func (checker *ChecksumChecker) OnError(t *ast.Task) error {
-	if len(t.Sources) == 0 {
-		return nil
-	}
-	return os.Remove(checker.checksumFilePath(t))
-}
-
-func (*ChecksumChecker) Kind() string {
-	return "checksum"
-}
-
-func (c *ChecksumChecker) checksum(t *ast.Task) (string, error) {
-	sources, err := Globs(t.Dir, t.Sources)
-	if err != nil {
-		return "", err
-	}
-
-	h := xxh3.New()
-	buf := make([]byte, 128*1024)
-	for _, f := range sources {
-		// also sum the filename, so checksum changes for renaming a file
-		if _, err := io.CopyBuffer(h, strings.NewReader(filepath.Base(f)), buf); err != nil {
-			return "", err
-		}
-		f, err := os.Open(f)
-		if err != nil {
-			return "", err
-		}
-		if _, err = io.CopyBuffer(h, f, buf); err != nil {
-			return "", err
-		}
-		f.Close()
-	}
-
-	hash := h.Sum128()
-	return fmt.Sprintf("%x%x", hash.Hi, hash.Lo), nil
-}
-
-func (checker *ChecksumChecker) checksumFilePath(t *ast.Task) string {
-	return filepath.Join(checker.tempDir, "checksum", normalizeFilename(t.Name()))
-}
-
-var checksumFilenameRegexp = regexp.MustCompile("[^A-z0-9]")
-
-// replaces invalid characters on filenames with "-"
-func normalizeFilename(f string) string {
-	return checksumFilenameRegexp.ReplaceAllString(f, "-")
-}

internal/fingerprint/sources_none.go

@@ -1,23 +0,0 @@
-package fingerprint
-
-import "github.com/go-task/task/v3/taskfile/ast"
-
-// NoneChecker is a no-op Checker.
-// It will always report that the task is not up-to-date.
-type NoneChecker struct{}
-
-func (NoneChecker) IsUpToDate(t *ast.Task) (bool, error) {
-	return false, nil
-}
-
-func (NoneChecker) Value(t *ast.Task) (any, error) {
-	return "", nil
-}
-
-func (NoneChecker) OnError(t *ast.Task) error {
-	return nil
-}
-
-func (NoneChecker) Kind() string {
-	return "none"
-}

internal/fingerprint/sources_timestamp.go

@@ -1,151 +0,0 @@
-package fingerprint
-
-import (
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-// TimestampChecker checks if any source change compared with the generated files,
-// using file modifications timestamps.
-type TimestampChecker struct {
-	tempDir string
-	dry     bool
-}
-
-func NewTimestampChecker(tempDir string, dry bool) *TimestampChecker {
-	return &TimestampChecker{
-		tempDir: tempDir,
-		dry:     dry,
-	}
-}
-
-// IsUpToDate implements the Checker interface
-func (checker *TimestampChecker) IsUpToDate(t *ast.Task) (bool, error) {
-	if len(t.Sources) == 0 {
-		return false, nil
-	}
-
-	sources, err := Globs(t.Dir, t.Sources)
-	if err != nil {
-		return false, nil
-	}
-	generates, err := Globs(t.Dir, t.Generates)
-	if err != nil {
-		return false, nil
-	}
-
-	timestampFile := checker.timestampFilePath(t)
-
-	// If the file exists, add the file path to the generates.
-	// If the generate file is old, the task will be executed.
-	_, err = os.Stat(timestampFile)
-	if err == nil {
-		generates = append(generates, timestampFile)
-	} else {
-		// Create the timestamp file for the next execution when the file does not exist.
-		if !checker.dry {
-			if err := os.MkdirAll(filepath.Dir(timestampFile), 0o755); err != nil {
-				return false, err
-			}
-			f, err := os.Create(timestampFile)
-			if err != nil {
-				return false, err
-			}
-			f.Close()
-		}
-	}
-
-	taskTime := time.Now()
-
-	// Compare the time of the generates and sources. If the generates are old, the task will be executed.
-
-	// Get the max time of the generates.
-	generateMaxTime, err := getMaxTime(generates...)
-	if err != nil || generateMaxTime.IsZero() {
-		return false, nil
-	}
-
-	// Check if any of the source files is newer than the max time of the generates.
-	shouldUpdate, err := anyFileNewerThan(sources, generateMaxTime)
-	if err != nil {
-		return false, nil
-	}
-
-	// Modify the metadata of the file to the the current time.
-	if !checker.dry {
-		if err := os.Chtimes(timestampFile, taskTime, taskTime); err != nil {
-			return false, err
-		}
-	}
-
-	return !shouldUpdate, nil
-}
-
-func (checker *TimestampChecker) Kind() string {
-	return "timestamp"
-}
-
-// Value implements the Checker Interface
-func (checker *TimestampChecker) Value(t *ast.Task) (any, error) {
-	sources, err := Globs(t.Dir, t.Sources)
-	if err != nil {
-		return time.Now(), err
-	}
-
-	sourcesMaxTime, err := getMaxTime(sources...)
-	if err != nil {
-		return time.Now(), err
-	}
-
-	if sourcesMaxTime.IsZero() {
-		return time.Unix(0, 0), nil
-	}
-
-	return sourcesMaxTime, nil
-}
-
-func getMaxTime(files ...string) (time.Time, error) {
-	var t time.Time
-	for _, f := range files {
-		info, err := os.Stat(f)
-		if err != nil {
-			return time.Time{}, err
-		}
-		t = maxTime(t, info.ModTime())
-	}
-	return t, nil
-}
-
-func maxTime(a, b time.Time) time.Time {
-	if a.After(b) {
-		return a
-	}
-	return b
-}
-
-// If the modification time of any of the files is newer than the the given time, returns true.
-// This function is lazy, as it stops when it finds a file newer than the given time.
-func anyFileNewerThan(files []string, givenTime time.Time) (bool, error) {
-	for _, f := range files {
-		info, err := os.Stat(f)
-		if err != nil {
-			return false, err
-		}
-		if info.ModTime().After(givenTime) {
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-// OnError implements the Checker interface
-func (*TimestampChecker) OnError(t *ast.Task) error {
-	return nil
-}
-
-func (checker *TimestampChecker) timestampFilePath(t *ast.Task) string {
-	return filepath.Join(checker.tempDir, "timestamp", normalizeFilename(t.Task))
-}

internal/fingerprint/status.go

@@ -1,36 +0,0 @@
-package fingerprint
-
-import (
-	"context"
-
-	"github.com/go-task/task/v3/internal/env"
-	"github.com/go-task/task/v3/internal/execext"
-	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-type StatusChecker struct {
-	logger *logger.Logger
-}
-
-func NewStatusChecker(logger *logger.Logger) StatusCheckable {
-	return &StatusChecker{
-		logger: logger,
-	}
-}
-
-func (checker *StatusChecker) IsUpToDate(ctx context.Context, t *ast.Task) (bool, error) {
-	for _, s := range t.Status {
-		err := execext.RunCommand(ctx, &execext.RunCommandOptions{
-			Command: s,
-			Dir:     t.Dir,
-			Env:     env.Get(t),
-		})
-		if err != nil {
-			checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited non-zero: %s\n", s, err)
-			return false, nil
-		}
-		checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited zero\n", s)
-	}
-	return true, nil
-}

internal/fingerprint/task.go

@@ -1,132 +0,0 @@
-package fingerprint
-
-import (
-	"context"
-
-	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-type (
-	CheckerOption func(*CheckerConfig)
-	CheckerConfig struct {
-		method         string
-		dry            bool
-		tempDir        string
-		logger         *logger.Logger
-		statusChecker  StatusCheckable
-		sourcesChecker SourcesCheckable
-	}
-)
-
-func WithMethod(method string) CheckerOption {
-	return func(config *CheckerConfig) {
-		config.method = method
-	}
-}
-
-func WithDry(dry bool) CheckerOption {
-	return func(config *CheckerConfig) {
-		config.dry = dry
-	}
-}
-
-func WithTempDir(tempDir string) CheckerOption {
-	return func(config *CheckerConfig) {
-		config.tempDir = tempDir
-	}
-}
-
-func WithLogger(logger *logger.Logger) CheckerOption {
-	return func(config *CheckerConfig) {
-		config.logger = logger
-	}
-}
-
-func WithStatusChecker(checker StatusCheckable) CheckerOption {
-	return func(config *CheckerConfig) {
-		config.statusChecker = checker
-	}
-}
-
-func WithSourcesChecker(checker SourcesCheckable) CheckerOption {
-	return func(config *CheckerConfig) {
-		config.sourcesChecker = checker
-	}
-}
-
-func IsTaskUpToDate(
-	ctx context.Context,
-	t *ast.Task,
-	opts ...CheckerOption,
-) (bool, error) {
-	var statusUpToDate bool
-	var sourcesUpToDate bool
-	var err error
-
-	// Default config
-	config := &CheckerConfig{
-		method:         "none",
-		tempDir:        "",
-		dry:            false,
-		logger:         nil,
-		statusChecker:  nil,
-		sourcesChecker: nil,
-	}
-
-	// Apply functional options
-	for _, opt := range opts {
-		opt(config)
-	}
-
-	// If no status checker was given, set up the default one
-	if config.statusChecker == nil {
-		config.statusChecker = NewStatusChecker(config.logger)
-	}
-
-	// If no sources checker was given, set up the default one
-	if config.sourcesChecker == nil {
-		config.sourcesChecker, err = NewSourcesChecker(config.method, config.tempDir, config.dry)
-		if err != nil {
-			return false, err
-		}
-	}
-
-	statusIsSet := len(t.Status) != 0
-	sourcesIsSet := len(t.Sources) != 0
-
-	// If status is set, check if it is up-to-date
-	if statusIsSet {
-		statusUpToDate, err = config.statusChecker.IsUpToDate(ctx, t)
-		if err != nil {
-			return false, err
-		}
-	}
-
-	// If sources is set, check if they are up-to-date
-	if sourcesIsSet {
-		sourcesUpToDate, err = config.sourcesChecker.IsUpToDate(t)
-		if err != nil {
-			return false, err
-		}
-	}
-
-	// If both status and sources are set, the task is up-to-date if both are up-to-date
-	if statusIsSet && sourcesIsSet {
-		return statusUpToDate && sourcesUpToDate, nil
-	}
-
-	// If only status is set, the task is up-to-date if the status is up-to-date
-	if statusIsSet {
-		return statusUpToDate, nil
-	}
-
-	// If only sources is set, the task is up-to-date if the sources are up-to-date
-	if sourcesIsSet {
-		return sourcesUpToDate, nil
-	}
-
-	// If no status or sources are set, the task should always run
-	// i.e. it is never considered "up-to-date"
-	return false, nil
-}

internal/fingerprint/task_test.go

@@ -1,177 +0,0 @@
-package fingerprint
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-
-	"github.com/go-task/task/v3/internal/mocks"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-// TruthTable
-//
-// | Status up-to-date | Sources up-to-date | Task is up-to-date |
-// | ----------------- | ------------------ | ------------------ |
-// | not set           | not set            | false              |
-// | not set           | true               | true               |
-// | not set           | false              | false              |
-// | true              | not set            | true               |
-// | true              | true               | true               |
-// | true              | false              | false              |
-// | false             | not set            | false              |
-// | false             | true               | false              |
-// | false             | false              | false              |
-func TestIsTaskUpToDate(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name                    string
-		task                    *ast.Task
-		setupMockStatusChecker  func(m *mocks.StatusCheckable)
-		setupMockSourcesChecker func(m *mocks.SourcesCheckable)
-		expected                bool
-	}{
-		{
-			name: "expect FALSE when no status or sources are defined",
-			task: &ast.Task{
-				Status:  nil,
-				Sources: nil,
-			},
-			setupMockStatusChecker:  nil,
-			setupMockSourcesChecker: nil,
-			expected:                false,
-		},
-		{
-			name: "expect TRUE when no status is defined and sources are up-to-date",
-			task: &ast.Task{
-				Status:  nil,
-				Sources: []*ast.Glob{{Glob: "sources"}},
-			},
-			setupMockStatusChecker: nil,
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil)
-			},
-			expected: true,
-		},
-		{
-			name: "expect FALSE when no status is defined and sources are NOT up-to-date",
-			task: &ast.Task{
-				Status:  nil,
-				Sources: []*ast.Glob{{Glob: "sources"}},
-			},
-			setupMockStatusChecker: nil,
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil)
-			},
-			expected: false,
-		},
-		{
-			name: "expect TRUE when status is up-to-date and sources are not defined",
-			task: &ast.Task{
-				Status:  []string{"status"},
-				Sources: nil,
-			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil)
-			},
-			setupMockSourcesChecker: nil,
-			expected:                true,
-		},
-		{
-			name: "expect TRUE when status and sources are up-to-date",
-			task: &ast.Task{
-				Status:  []string{"status"},
-				Sources: []*ast.Glob{{Glob: "sources"}},
-			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil)
-			},
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil)
-			},
-			expected: true,
-		},
-		{
-			name: "expect FALSE when status is up-to-date, but sources are NOT up-to-date",
-			task: &ast.Task{
-				Status:  []string{"status"},
-				Sources: []*ast.Glob{{Glob: "sources"}},
-			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil)
-			},
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil)
-			},
-			expected: false,
-		},
-		{
-			name: "expect FALSE when status is NOT up-to-date and sources are not defined",
-			task: &ast.Task{
-				Status:  []string{"status"},
-				Sources: nil,
-			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil)
-			},
-			setupMockSourcesChecker: nil,
-			expected:                false,
-		},
-		{
-			name: "expect FALSE when status is NOT up-to-date, but sources are up-to-date",
-			task: &ast.Task{
-				Status:  []string{"status"},
-				Sources: []*ast.Glob{{Glob: "sources"}},
-			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil)
-			},
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil)
-			},
-			expected: false,
-		},
-		{
-			name: "expect FALSE when status and sources are NOT up-to-date",
-			task: &ast.Task{
-				Status:  []string{"status"},
-				Sources: []*ast.Glob{{Glob: "sources"}},
-			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil)
-			},
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
-				m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil)
-			},
-			expected: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			mockStatusChecker := mocks.NewStatusCheckable(t)
-			if tt.setupMockStatusChecker != nil {
-				tt.setupMockStatusChecker(mockStatusChecker)
-			}
-
-			mockSourcesChecker := mocks.NewSourcesCheckable(t)
-			if tt.setupMockSourcesChecker != nil {
-				tt.setupMockSourcesChecker(mockSourcesChecker)
-			}
-
-			result, err := IsTaskUpToDate(
-				context.Background(),
-				tt.task,
-				WithStatusChecker(mockStatusChecker),
-				WithSourcesChecker(mockSourcesChecker),
-			)
-			require.NoError(t, err)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}

internal/flags/flags.go

@@ -1,164 +0,0 @@
-package flags
-
-import (
-	"cmp"
-	"log"
-	"os"
-	"strconv"
-	"time"
-
-	"github.com/spf13/pflag"
-
-	"github.com/go-task/task/v3/errors"
-	"github.com/go-task/task/v3/internal/env"
-	"github.com/go-task/task/v3/internal/experiments"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-const usage = `Usage: task [flags...] [task...]
-
-Runs the specified task(s). Falls back to the "default" task if no task name
-was specified, or lists all tasks if an unknown task name was specified.
-
-Example: 'task hello' with the following 'Taskfile.yml' file will generate an
-'output.txt' file with the content "hello".
-
-'''
-version: '3'
-tasks:
-  hello:
-    cmds:
-      - echo "I am going to write a file named 'output.txt' now."
-      - echo "hello" > output.txt
-    generates:
-      - output.txt
-'''
-
-Options:
-`
-
-var (
-	Version     bool
-	Help        bool
-	Init        bool
-	Completion  string
-	List        bool
-	ListAll     bool
-	ListJson    bool
-	TaskSort    string
-	Status      bool
-	NoStatus    bool
-	Insecure    bool
-	Force       bool
-	ForceAll    bool
-	Watch       bool
-	Verbose     bool
-	Silent      bool
-	AssumeYes   bool
-	Dry         bool
-	Summary     bool
-	ExitCode    bool
-	Parallel    bool
-	Concurrency int
-	Dir         string
-	Entrypoint  string
-	Output      ast.Output
-	Color       bool
-	Interval    time.Duration
-	Global      bool
-	Experiments bool
-	Download    bool
-	Offline     bool
-	ClearCache  bool
-	Timeout     time.Duration
-)
-
-func init() {
-	log.SetFlags(0)
-	log.SetOutput(os.Stderr)
-	pflag.Usage = func() {
-		log.Print(usage)
-		pflag.PrintDefaults()
-	}
-	offline, err := strconv.ParseBool(cmp.Or(env.GetTaskEnv("OFFLINE"), "false"))
-	if err != nil {
-		offline = false
-	}
-	pflag.BoolVar(&Version, "version", false, "Show Task version.")
-	pflag.BoolVarP(&Help, "help", "h", false, "Shows Task usage.")
-	pflag.BoolVarP(&Init, "init", "i", false, "Creates a new Taskfile.yml in the current folder.")
-	pflag.StringVar(&Completion, "completion", "", "Generates shell completion script.")
-	pflag.BoolVarP(&List, "list", "l", false, "Lists tasks with description of current Taskfile.")
-	pflag.BoolVarP(&ListAll, "list-all", "a", false, "Lists tasks with or without a description.")
-	pflag.BoolVarP(&ListJson, "json", "j", false, "Formats task list as JSON.")
-	pflag.StringVar(&TaskSort, "sort", "", "Changes the order of the tasks when listed. [default|alphanumeric|none].")
-	pflag.BoolVar(&Status, "status", false, "Exits with non-zero exit code if any of the given tasks is not up-to-date.")
-	pflag.BoolVar(&NoStatus, "no-status", false, "Ignore status when listing tasks as JSON")
-	pflag.BoolVar(&Insecure, "insecure", false, "Forces Task to download Taskfiles over insecure connections.")
-	pflag.BoolVarP(&Watch, "watch", "w", false, "Enables watch of the given task.")
-	pflag.BoolVarP(&Verbose, "verbose", "v", false, "Enables verbose mode.")
-	pflag.BoolVarP(&Silent, "silent", "s", false, "Disables echoing.")
-	pflag.BoolVarP(&AssumeYes, "yes", "y", false, "Assume \"yes\" as answer to all prompts.")
-	pflag.BoolVarP(&Parallel, "parallel", "p", false, "Executes tasks provided on command line in parallel.")
-	pflag.BoolVarP(&Dry, "dry", "n", false, "Compiles and prints tasks in the order that they would be run, without executing them.")
-	pflag.BoolVar(&Summary, "summary", false, "Show summary about a task.")
-	pflag.BoolVarP(&ExitCode, "exit-code", "x", false, "Pass-through the exit code of the task command.")
-	pflag.StringVarP(&Dir, "dir", "d", "", "Sets directory of execution.")
-	pflag.StringVarP(&Entrypoint, "taskfile", "t", "", `Choose which Taskfile to run. Defaults to "Taskfile.yml".`)
-	pflag.StringVarP(&Output.Name, "output", "o", "", "Sets output style: [interleaved|group|prefixed].")
-	pflag.StringVar(&Output.Group.Begin, "output-group-begin", "", "Message template to print before a task's grouped output.")
-	pflag.StringVar(&Output.Group.End, "output-group-end", "", "Message template to print after a task's grouped output.")
-	pflag.BoolVar(&Output.Group.ErrorOnly, "output-group-error-only", false, "Swallow output from successful tasks.")
-	pflag.BoolVarP(&Color, "color", "c", true, "Colored output. Enabled by default. Set flag to false or use NO_COLOR=1 to disable.")
-	pflag.IntVarP(&Concurrency, "concurrency", "C", 0, "Limit number of tasks to run concurrently.")
-	pflag.DurationVarP(&Interval, "interval", "I", 0, "Interval to watch for changes.")
-	pflag.BoolVarP(&Global, "global", "g", false, "Runs global Taskfile, from $HOME/{T,t}askfile.{yml,yaml}.")
-	pflag.BoolVar(&Experiments, "experiments", false, "Lists all the available experiments and whether or not they are enabled.")
-
-	// Gentle force experiment will override the force flag and add a new force-all flag
-	if experiments.GentleForce.Enabled() {
-		pflag.BoolVarP(&Force, "force", "f", false, "Forces execution of the directly called task.")
-		pflag.BoolVar(&ForceAll, "force-all", false, "Forces execution of the called task and all its dependant tasks.")
-	} else {
-		pflag.BoolVarP(&ForceAll, "force", "f", false, "Forces execution even when the task is up-to-date.")
-	}
-
-	// Remote Taskfiles experiment will adds the "download" and "offline" flags
-	if experiments.RemoteTaskfiles.Enabled() {
-		pflag.BoolVar(&Download, "download", false, "Downloads a cached version of a remote Taskfile.")
-		pflag.BoolVar(&Offline, "offline", offline, "Forces Task to only use local or cached Taskfiles.")
-		pflag.DurationVar(&Timeout, "timeout", time.Second*10, "Timeout for downloading remote Taskfiles.")
-		pflag.BoolVar(&ClearCache, "clear-cache", false, "Clear the remote cache.")
-	}
-
-	pflag.Parse()
-}
-
-func Validate() error {
-	if Download && Offline {
-		return errors.New("task: You can't set both --download and --offline flags")
-	}
-
-	if Download && ClearCache {
-		return errors.New("task: You can't set both --download and --clear-cache flags")
-	}
-
-	if Global && Dir != "" {
-		log.Fatal("task: You can't set both --global and --dir")
-		return nil
-	}
-
-	if Output.Name != "group" {
-		if Output.Group.Begin != "" {
-			return errors.New("task: You can't set --output-group-begin without --output=group")
-		}
-		if Output.Group.End != "" {
-			return errors.New("task: You can't set --output-group-end without --output=group")
-		}
-		if Output.Group.ErrorOnly {
-			return errors.New("task: You can't set --output-group-error-only without --output=group")
-		}
-	}
-
-	return nil
-}

internal/goext/meta.go

@@ -1,63 +0,0 @@
-package goext
-
-// NOTE(@andreynering): The lists in this file were copied from:
-//
-// https://github.com/golang/go/blob/master/src/go/build/syslist.go
-
-func IsKnownOS(str string) bool {
-	_, known := knownOS[str]
-	return known
-}
-
-func IsKnownArch(str string) bool {
-	_, known := knownArch[str]
-	return known
-}
-
-var knownOS = map[string]struct{}{
-	"aix":       {},
-	"android":   {},
-	"darwin":    {},
-	"dragonfly": {},
-	"freebsd":   {},
-	"hurd":      {},
-	"illumos":   {},
-	"ios":       {},
-	"js":        {},
-	"linux":     {},
-	"nacl":      {},
-	"netbsd":    {},
-	"openbsd":   {},
-	"plan9":     {},
-	"solaris":   {},
-	"windows":   {},
-	"zos":       {},
-	"__test__":  {},
-}
-
-var knownArch = map[string]struct{}{
-	"386":         {},
-	"amd64":       {},
-	"amd64p32":    {},
-	"arm":         {},
-	"armbe":       {},
-	"arm64":       {},
-	"arm64be":     {},
-	"loong64":     {},
-	"mips":        {},
-	"mipsle":      {},
-	"mips64":      {},
-	"mips64le":    {},
-	"mips64p32":   {},
-	"mips64p32le": {},
-	"ppc":         {},
-	"ppc64":       {},
-	"ppc64le":     {},
-	"riscv":       {},
-	"riscv64":     {},
-	"s390":        {},
-	"s390x":       {},
-	"sparc":       {},
-	"sparc64":     {},
-	"wasm":        {},
-}

internal/hash/hash.go

@@ -1,24 +0,0 @@
-package hash
-
-import (
-	"fmt"
-
-	"github.com/mitchellh/hashstructure/v2"
-
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-type HashFunc func(*ast.Task) (string, error)
-
-func Empty(*ast.Task) (string, error) {
-	return "", nil
-}
-
-func Name(t *ast.Task) (string, error) {
-	return fmt.Sprintf("%s:%s", t.Location.Taskfile, t.LocalName()), nil
-}
-
-func Hash(t *ast.Task) (string, error) {
-	h, err := hashstructure.Hash(t, hashstructure.FormatV2, nil)
-	return fmt.Sprintf("%s:%d", t.Task, h), err
-}

internal/logger/logger.go

@@ -1,229 +1,38 @@
 package logger
 
 import (
-	"bufio"
+	"fmt"
 	"io"
-	"os"
-	"slices"
-	"strconv"
-	"strings"
-
-	"github.com/Ladicle/tabwriter"
-	"github.com/fatih/color"
-
-	"github.com/go-task/task/v3/errors"
-	"github.com/go-task/task/v3/internal/env"
-	"github.com/go-task/task/v3/internal/experiments"
-	"github.com/go-task/task/v3/internal/term"
 )
 
-var (
-	ErrPromptCancelled = errors.New("prompt cancelled")
-	ErrNoTerminal      = errors.New("no terminal")
-)
-
-var (
-	attrsReset       = envColor("COLOR_RESET", color.Reset)
-	attrsFgBlue      = envColor("COLOR_BLUE", color.FgBlue)
-	attrsFgGreen     = envColor("COLOR_GREEN", color.FgGreen)
-	attrsFgCyan      = envColor("COLOR_CYAN", color.FgCyan)
-	attrsFgYellow    = envColor("COLOR_YELLOW", color.FgYellow)
-	attrsFgMagenta   = envColor("COLOR_MAGENTA", color.FgMagenta)
-	attrsFgRed       = envColor("COLOR_RED", color.FgRed)
-	attrsFgHiBlue    = envColor("COLOR_BRIGHT_BLUE", color.FgHiBlue)
-	attrsFgHiGreen   = envColor("COLOR_BRIGHT_GREEN", color.FgHiGreen)
-	attrsFgHiCyan    = envColor("COLOR_BRIGHT_CYAN", color.FgHiCyan)
-	attrsFgHiYellow  = envColor("COLOR_BRIGHT_YELLOW", color.FgHiYellow)
-	attrsFgHiMagenta = envColor("COLOR_BRIGHT_MAGENTA", color.FgHiMagenta)
-	attrsFgHiRed     = envColor("COLOR_BRIGHT_RED", color.FgHiRed)
-)
-
-type (
-	Color     func() PrintFunc
-	PrintFunc func(io.Writer, string, ...any)
-)
-
-func Default() PrintFunc {
-	return color.New(attrsReset...).FprintfFunc()
-}
-
-func Blue() PrintFunc {
-	return color.New(attrsFgBlue...).FprintfFunc()
-}
-
-func Green() PrintFunc {
-	return color.New(attrsFgGreen...).FprintfFunc()
-}
-
-func Cyan() PrintFunc {
-	return color.New(attrsFgCyan...).FprintfFunc()
-}
-
-func Yellow() PrintFunc {
-	return color.New(attrsFgYellow...).FprintfFunc()
-}
-
-func Magenta() PrintFunc {
-	return color.New(attrsFgMagenta...).FprintfFunc()
-}
-
-func Red() PrintFunc {
-	return color.New(attrsFgRed...).FprintfFunc()
-}
-
-func BrightBlue() PrintFunc {
-	return color.New(attrsFgHiBlue...).FprintfFunc()
-}
-
-func BrightGreen() PrintFunc {
-	return color.New(attrsFgHiGreen...).FprintfFunc()
-}
-
-func BrightCyan() PrintFunc {
-	return color.New(attrsFgHiCyan...).FprintfFunc()
-}
-
-func BrightYellow() PrintFunc {
-	return color.New(attrsFgHiYellow...).FprintfFunc()
-}
-
-func BrightMagenta() PrintFunc {
-	return color.New(attrsFgHiMagenta...).FprintfFunc()
-}
-
-func BrightRed() PrintFunc {
-	return color.New(attrsFgHiRed...).FprintfFunc()
-}
-
-func envColor(name string, defaultColor color.Attribute) []color.Attribute {
-	if os.Getenv("FORCE_COLOR") != "" {
-		color.NoColor = false
-	}
-
-	// Fetch the environment variable
-	override := env.GetTaskEnv(name)
-
-	// First, try splitting the string by commas (RGB shortcut syntax) and if it
-	// matches, then prepend the 256-color foreground escape sequence.
-	// Otherwise, split by semicolons (ANSI color codes) and use them as is.
-	attributeStrs := strings.Split(override, ",")
-	if len(attributeStrs) == 3 {
-		attributeStrs = slices.Concat([]string{"38", "2"}, attributeStrs)
-	} else {
-		attributeStrs = strings.Split(override, ";")
-	}
-
-	// Loop over the attributes and convert them to integers
-	attributes := make([]color.Attribute, len(attributeStrs))
-	for i, attributeStr := range attributeStrs {
-		attribute, err := strconv.Atoi(attributeStr)
-		if err != nil {
-			return []color.Attribute{defaultColor}
-		}
-		attributes[i] = color.Attribute(attribute)
-	}
-
-	return attributes
-}
-
-// Logger is just a wrapper that prints stuff to STDOUT or STDERR,
-// with optional color.
 type Logger struct {
-	Stdin      io.Reader
-	Stdout     io.Writer
-	Stderr     io.Writer
-	Verbose    bool
-	Color      bool
-	AssumeYes  bool
-	AssumeTerm bool // Used for testing
+	Stdout  io.Writer
+	Stderr  io.Writer
+	Verbose bool
 }
 
-// Outf prints stuff to STDOUT.
-func (l *Logger) Outf(color Color, s string, args ...any) {
-	l.FOutf(l.Stdout, color, s, args...)
-}
-
-// FOutf prints stuff to the given writer.
-func (l *Logger) FOutf(w io.Writer, color Color, s string, args ...any) {
+func (l *Logger) Outf(s string, args ...interface{}) {
 	if len(args) == 0 {
-		s, args = "%s", []any{s}
+		s, args = "%s", []interface{}{s}
 	}
-	if !l.Color {
-		color = Default
-	}
-	print := color()
-	print(w, s, args...)
+	fmt.Fprintf(l.Stdout, s+"\n", args...)
 }
 
-// VerboseOutf prints stuff to STDOUT if verbose mode is enabled.
-func (l *Logger) VerboseOutf(color Color, s string, args ...any) {
+func (l *Logger) VerboseOutf(s string, args ...interface{}) {
 	if l.Verbose {
-		l.Outf(color, s, args...)
+		l.Outf(s, args...)
 	}
 }
 
-// Errf prints stuff to STDERR.
-func (l *Logger) Errf(color Color, s string, args ...any) {
+func (l *Logger) Errf(s string, args ...interface{}) {
 	if len(args) == 0 {
-		s, args = "%s", []any{s}
+		s, args = "%s", []interface{}{s}
 	}
-	if !l.Color {
-		color = Default
-	}
-	print := color()
-	print(l.Stderr, s, args...)
+	fmt.Fprintf(l.Stderr, s+"\n", args...)
 }
 
-// VerboseErrf prints stuff to STDERR if verbose mode is enabled.
-func (l *Logger) VerboseErrf(color Color, s string, args ...any) {
+func (l *Logger) VerboseErrf(s string, args ...interface{}) {
 	if l.Verbose {
-		l.Errf(color, s, args...)
+		l.Errf(s, args...)
 	}
 }
-
-func (l *Logger) Warnf(message string, args ...any) {
-	l.Errf(Yellow, message, args...)
-}
-
-func (l *Logger) Prompt(color Color, prompt string, defaultValue string, continueValues ...string) error {
-	if l.AssumeYes {
-		l.Outf(color, "%s [assuming yes]\n", prompt)
-		return nil
-	}
-
-	if !l.AssumeTerm && !term.IsTerminal() {
-		return ErrNoTerminal
-	}
-
-	if len(continueValues) == 0 {
-		return errors.New("no continue values provided")
-	}
-
-	l.Outf(color, "%s [%s/%s]: ", prompt, strings.ToLower(continueValues[0]), strings.ToUpper(defaultValue))
-
-	reader := bufio.NewReader(l.Stdin)
-	input, err := reader.ReadString('\n')
-	if err != nil {
-		return err
-	}
-
-	input = strings.TrimSpace(strings.ToLower(input))
-	if !slices.Contains(continueValues, input) {
-		return ErrPromptCancelled
-	}
-
-	return nil
-}
-
-func (l *Logger) PrintExperiments() error {
-	w := tabwriter.NewWriter(l.Stdout, 0, 8, 0, ' ', 0)
-	for _, x := range experiments.List() {
-		if !x.Active() {
-			continue
-		}
-		l.FOutf(w, Yellow, "* ")
-		l.FOutf(w, Green, x.Name)
-		l.FOutf(w, Default, ": \t%s\n", x.String())
-	}
-	return w.Flush()
-}

internal/mocks/sources_checkable.go

@@ -1,226 +0,0 @@
-// Code generated by mockery v2.24.0. DO NOT EDIT.
-
-package mocks
-
-import (
-	ast "github.com/go-task/task/v3/taskfile/ast"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// SourcesCheckable is an autogenerated mock type for the SourcesCheckable type
-type SourcesCheckable struct {
-	mock.Mock
-}
-
-type SourcesCheckable_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SourcesCheckable) EXPECT() *SourcesCheckable_Expecter {
-	return &SourcesCheckable_Expecter{mock: &_m.Mock}
-}
-
-// IsUpToDate provides a mock function with given fields: t
-func (_m *SourcesCheckable) IsUpToDate(t *ast.Task) (bool, error) {
-	ret := _m.Called(t)
-
-	var r0 bool
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*ast.Task) (bool, error)); ok {
-		return rf(t)
-	}
-	if rf, ok := ret.Get(0).(func(*ast.Task) bool); ok {
-		r0 = rf(t)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	if rf, ok := ret.Get(1).(func(*ast.Task) error); ok {
-		r1 = rf(t)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SourcesCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
-type SourcesCheckable_IsUpToDate_Call struct {
-	*mock.Call
-}
-
-// IsUpToDate is a helper method to define mock.On call
-//   - t *ast.Task
-func (_e *SourcesCheckable_Expecter) IsUpToDate(t interface{}) *SourcesCheckable_IsUpToDate_Call {
-	return &SourcesCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", t)}
-}
-
-func (_c *SourcesCheckable_IsUpToDate_Call) Run(run func(t *ast.Task)) *SourcesCheckable_IsUpToDate_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*ast.Task))
-	})
-	return _c
-}
-
-func (_c *SourcesCheckable_IsUpToDate_Call) Return(_a0 bool, _a1 error) *SourcesCheckable_IsUpToDate_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SourcesCheckable_IsUpToDate_Call) RunAndReturn(run func(*ast.Task) (bool, error)) *SourcesCheckable_IsUpToDate_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Kind provides a mock function with given fields:
-func (_m *SourcesCheckable) Kind() string {
-	ret := _m.Called()
-
-	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	return r0
-}
-
-// SourcesCheckable_Kind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Kind'
-type SourcesCheckable_Kind_Call struct {
-	*mock.Call
-}
-
-// Kind is a helper method to define mock.On call
-func (_e *SourcesCheckable_Expecter) Kind() *SourcesCheckable_Kind_Call {
-	return &SourcesCheckable_Kind_Call{Call: _e.mock.On("Kind")}
-}
-
-func (_c *SourcesCheckable_Kind_Call) Run(run func()) *SourcesCheckable_Kind_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SourcesCheckable_Kind_Call) Return(_a0 string) *SourcesCheckable_Kind_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SourcesCheckable_Kind_Call) RunAndReturn(run func() string) *SourcesCheckable_Kind_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// OnError provides a mock function with given fields: t
-func (_m *SourcesCheckable) OnError(t *ast.Task) error {
-	ret := _m.Called(t)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ast.Task) error); ok {
-		r0 = rf(t)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SourcesCheckable_OnError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnError'
-type SourcesCheckable_OnError_Call struct {
-	*mock.Call
-}
-
-// OnError is a helper method to define mock.On call
-//   - t *ast.Task
-func (_e *SourcesCheckable_Expecter) OnError(t interface{}) *SourcesCheckable_OnError_Call {
-	return &SourcesCheckable_OnError_Call{Call: _e.mock.On("OnError", t)}
-}
-
-func (_c *SourcesCheckable_OnError_Call) Run(run func(t *ast.Task)) *SourcesCheckable_OnError_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*ast.Task))
-	})
-	return _c
-}
-
-func (_c *SourcesCheckable_OnError_Call) Return(_a0 error) *SourcesCheckable_OnError_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SourcesCheckable_OnError_Call) RunAndReturn(run func(*ast.Task) error) *SourcesCheckable_OnError_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Value provides a mock function with given fields: t
-func (_m *SourcesCheckable) Value(t *ast.Task) (interface{}, error) {
-	ret := _m.Called(t)
-
-	var r0 interface{}
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*ast.Task) (interface{}, error)); ok {
-		return rf(t)
-	}
-	if rf, ok := ret.Get(0).(func(*ast.Task) interface{}); ok {
-		r0 = rf(t)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(interface{})
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*ast.Task) error); ok {
-		r1 = rf(t)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SourcesCheckable_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Value'
-type SourcesCheckable_Value_Call struct {
-	*mock.Call
-}
-
-// Value is a helper method to define mock.On call
-//   - t *ast.Task
-func (_e *SourcesCheckable_Expecter) Value(t interface{}) *SourcesCheckable_Value_Call {
-	return &SourcesCheckable_Value_Call{Call: _e.mock.On("Value", t)}
-}
-
-func (_c *SourcesCheckable_Value_Call) Run(run func(t *ast.Task)) *SourcesCheckable_Value_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*ast.Task))
-	})
-	return _c
-}
-
-func (_c *SourcesCheckable_Value_Call) Return(_a0 interface{}, _a1 error) *SourcesCheckable_Value_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SourcesCheckable_Value_Call) RunAndReturn(run func(*ast.Task) (interface{}, error)) *SourcesCheckable_Value_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-type mockConstructorTestingTNewSourcesCheckable interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewSourcesCheckable creates a new instance of SourcesCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewSourcesCheckable(t mockConstructorTestingTNewSourcesCheckable) *SourcesCheckable {
-	mock := &SourcesCheckable{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

internal/mocks/status_checkable.go

@@ -1,92 +0,0 @@
-// Code generated by mockery v2.24.0. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	ast "github.com/go-task/task/v3/taskfile/ast"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// StatusCheckable is an autogenerated mock type for the StatusCheckable type
-type StatusCheckable struct {
-	mock.Mock
-}
-
-type StatusCheckable_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *StatusCheckable) EXPECT() *StatusCheckable_Expecter {
-	return &StatusCheckable_Expecter{mock: &_m.Mock}
-}
-
-// IsUpToDate provides a mock function with given fields: ctx, t
-func (_m *StatusCheckable) IsUpToDate(ctx context.Context, t *ast.Task) (bool, error) {
-	ret := _m.Called(ctx, t)
-
-	var r0 bool
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ast.Task) (bool, error)); ok {
-		return rf(ctx, t)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *ast.Task) bool); ok {
-		r0 = rf(ctx, t)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *ast.Task) error); ok {
-		r1 = rf(ctx, t)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StatusCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
-type StatusCheckable_IsUpToDate_Call struct {
-	*mock.Call
-}
-
-// IsUpToDate is a helper method to define mock.On call
-//   - ctx context.Context
-//   - t *ast.Task
-func (_e *StatusCheckable_Expecter) IsUpToDate(ctx interface{}, t interface{}) *StatusCheckable_IsUpToDate_Call {
-	return &StatusCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", ctx, t)}
-}
-
-func (_c *StatusCheckable_IsUpToDate_Call) Run(run func(ctx context.Context, t *ast.Task)) *StatusCheckable_IsUpToDate_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*ast.Task))
-	})
-	return _c
-}
-
-func (_c *StatusCheckable_IsUpToDate_Call) Return(_a0 bool, _a1 error) *StatusCheckable_IsUpToDate_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *StatusCheckable_IsUpToDate_Call) RunAndReturn(run func(context.Context, *ast.Task) (bool, error)) *StatusCheckable_IsUpToDate_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-type mockConstructorTestingTNewStatusCheckable interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewStatusCheckable creates a new instance of StatusCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewStatusCheckable(t mockConstructorTestingTNewStatusCheckable) *StatusCheckable {
-	mock := &StatusCheckable{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

internal/output/group.go

@@ -1,53 +0,0 @@
-package output
-
-import (
-	"bytes"
-	"io"
-
-	"github.com/go-task/task/v3/internal/templater"
-)
-
-type Group struct {
-	Begin, End string
-	ErrorOnly  bool
-}
-
-func (g Group) WrapWriter(stdOut, _ io.Writer, _ string, cache *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
-	gw := &groupWriter{writer: stdOut}
-	if g.Begin != "" {
-		gw.begin = templater.Replace(g.Begin, cache) + "\n"
-	}
-	if g.End != "" {
-		gw.end = templater.Replace(g.End, cache) + "\n"
-	}
-	return gw, gw, func(err error) error {
-		if g.ErrorOnly && err == nil {
-			return nil
-		}
-
-		return gw.close()
-	}
-}
-
-type groupWriter struct {
-	writer     io.Writer
-	buff       bytes.Buffer
-	begin, end string
-}
-
-func (gw *groupWriter) Write(p []byte) (int, error) {
-	return gw.buff.Write(p)
-}
-
-func (gw *groupWriter) close() error {
-	if gw.buff.Len() == 0 {
-		// don't print begin/end messages if there's no buffered entries
-		return nil
-	}
-	if _, err := io.WriteString(gw.writer, gw.begin); err != nil {
-		return err
-	}
-	gw.buff.WriteString(gw.end)
-	_, err := io.Copy(gw.writer, &gw.buff)
-	return err
-}

internal/output/interleaved.go

@@ -1,13 +0,0 @@
-package output
-
-import (
-	"io"
-
-	"github.com/go-task/task/v3/internal/templater"
-)
-
-type Interleaved struct{}
-
-func (Interleaved) WrapWriter(stdOut, stdErr io.Writer, _ string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
-	return stdOut, stdErr, func(error) error { return nil }
-}

internal/output/output.go

@@ -1,47 +0,0 @@
-package output
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/templater"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-type Output interface {
-	WrapWriter(stdOut, stdErr io.Writer, prefix string, cache *templater.Cache) (io.Writer, io.Writer, CloseFunc)
-}
-
-type CloseFunc func(err error) error
-
-// Build the Output for the requested ast.Output.
-func BuildFor(o *ast.Output, logger *logger.Logger) (Output, error) {
-	switch o.Name {
-	case "interleaved", "":
-		if err := checkOutputGroupUnset(o); err != nil {
-			return nil, err
-		}
-		return Interleaved{}, nil
-	case "group":
-		return Group{
-			Begin:     o.Group.Begin,
-			End:       o.Group.End,
-			ErrorOnly: o.Group.ErrorOnly,
-		}, nil
-	case "prefixed":
-		if err := checkOutputGroupUnset(o); err != nil {
-			return nil, err
-		}
-		return NewPrefixed(logger), nil
-	default:
-		return nil, fmt.Errorf(`task: output style %q not recognized`, o.Name)
-	}
-}
-
-func checkOutputGroupUnset(o *ast.Output) error {
-	if o.Group.IsSet() {
-		return fmt.Errorf("task: output style %q does not support the group begin/end parameter", o.Name)
-	}
-	return nil
-}

internal/output/output_test.go

@@ -1,192 +0,0 @@
-package output_test
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"testing"
-
-	"github.com/fatih/color"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/output"
-	"github.com/go-task/task/v3/internal/templater"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-func TestInterleaved(t *testing.T) {
-	t.Parallel()
-
-	var b bytes.Buffer
-	var o output.Output = output.Interleaved{}
-	w, _, _ := o.WrapWriter(&b, io.Discard, "", nil)
-
-	fmt.Fprintln(w, "foo\nbar")
-	assert.Equal(t, "foo\nbar\n", b.String())
-	fmt.Fprintln(w, "baz")
-	assert.Equal(t, "foo\nbar\nbaz\n", b.String())
-}
-
-func TestGroup(t *testing.T) {
-	t.Parallel()
-
-	var b bytes.Buffer
-	var o output.Output = output.Group{}
-	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
-
-	fmt.Fprintln(stdOut, "out\nout")
-	assert.Equal(t, "", b.String())
-	fmt.Fprintln(stdErr, "err\nerr")
-	assert.Equal(t, "", b.String())
-	fmt.Fprintln(stdOut, "out")
-	assert.Equal(t, "", b.String())
-	fmt.Fprintln(stdErr, "err")
-	assert.Equal(t, "", b.String())
-
-	require.NoError(t, cleanup(nil))
-	assert.Equal(t, "out\nout\nerr\nerr\nout\nerr\n", b.String())
-}
-
-func TestGroupWithBeginEnd(t *testing.T) {
-	t.Parallel()
-
-	tmpl := templater.Cache{
-		Vars: ast.NewVars(
-			&ast.VarElement{
-				Key:   "VAR1",
-				Value: ast.Var{Value: "example-value"},
-			},
-		),
-	}
-
-	var o output.Output = output.Group{
-		Begin: "::group::{{ .VAR1 }}",
-		End:   "::endgroup::",
-	}
-	t.Run("simple", func(t *testing.T) {
-		t.Parallel()
-
-		var b bytes.Buffer
-		w, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
-
-		fmt.Fprintln(w, "foo\nbar")
-		assert.Equal(t, "", b.String())
-		fmt.Fprintln(w, "baz")
-		assert.Equal(t, "", b.String())
-		require.NoError(t, cleanup(nil))
-		assert.Equal(t, "::group::example-value\nfoo\nbar\nbaz\n::endgroup::\n", b.String())
-	})
-	t.Run("no output", func(t *testing.T) {
-		t.Parallel()
-
-		var b bytes.Buffer
-		_, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
-		require.NoError(t, cleanup(nil))
-		assert.Equal(t, "", b.String())
-	})
-}
-
-func TestGroupErrorOnlySwallowsOutputOnNoError(t *testing.T) {
-	t.Parallel()
-
-	var b bytes.Buffer
-	var o output.Output = output.Group{
-		ErrorOnly: true,
-	}
-	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
-
-	_, _ = fmt.Fprintln(stdOut, "std-out")
-	_, _ = fmt.Fprintln(stdErr, "std-err")
-
-	require.NoError(t, cleanup(nil))
-	assert.Empty(t, b.String())
-}
-
-func TestGroupErrorOnlyShowsOutputOnError(t *testing.T) {
-	t.Parallel()
-
-	var b bytes.Buffer
-	var o output.Output = output.Group{
-		ErrorOnly: true,
-	}
-	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
-
-	_, _ = fmt.Fprintln(stdOut, "std-out")
-	_, _ = fmt.Fprintln(stdErr, "std-err")
-
-	require.NoError(t, cleanup(errors.New("any-error")))
-	assert.Equal(t, "std-out\nstd-err\n", b.String())
-}
-
-func TestPrefixed(t *testing.T) { //nolint:paralleltest // cannot run in parallel
-	var b bytes.Buffer
-	l := &logger.Logger{
-		Color: false,
-	}
-
-	var o output.Output = output.NewPrefixed(l)
-	w, _, cleanup := o.WrapWriter(&b, io.Discard, "prefix", nil)
-
-	t.Run("simple use cases", func(t *testing.T) { //nolint:paralleltest // cannot run in parallel
-		b.Reset()
-
-		fmt.Fprintln(w, "foo\nbar")
-		assert.Equal(t, "[prefix] foo\n[prefix] bar\n", b.String())
-		fmt.Fprintln(w, "baz")
-		assert.Equal(t, "[prefix] foo\n[prefix] bar\n[prefix] baz\n", b.String())
-		require.NoError(t, cleanup(nil))
-	})
-
-	t.Run("multiple writes for a single line", func(t *testing.T) { //nolint:paralleltest // cannot run in parallel
-		b.Reset()
-
-		for _, char := range []string{"T", "e", "s", "t", "!"} {
-			fmt.Fprint(w, char)
-			assert.Equal(t, "", b.String())
-		}
-
-		require.NoError(t, cleanup(nil))
-		assert.Equal(t, "[prefix] Test!\n", b.String())
-	})
-}
-
-func TestPrefixedWithColor(t *testing.T) {
-	t.Parallel()
-
-	color.NoColor = false
-
-	var b bytes.Buffer
-	l := &logger.Logger{
-		Color: true,
-	}
-
-	var o output.Output = output.NewPrefixed(l)
-
-	writers := make([]io.Writer, 16)
-	for i := range writers {
-		writers[i], _, _ = o.WrapWriter(&b, io.Discard, fmt.Sprintf("prefix-%d", i), nil)
-	}
-
-	t.Run("colors should loop", func(t *testing.T) {
-		t.Parallel()
-
-		for i, w := range writers {
-			b.Reset()
-
-			color := output.PrefixColorSequence[i%len(output.PrefixColorSequence)]
-
-			var prefix bytes.Buffer
-			l.FOutf(&prefix, color, fmt.Sprintf("prefix-%d", i))
-
-			fmt.Fprintln(w, "foo\nbar")
-			assert.Equal(
-				t,
-				fmt.Sprintf("[%s] foo\n[%s] bar\n", prefix.String(), prefix.String()),
-				b.String(),
-			)
-		}
-	})
-}

internal/output/prefixed.go

@@ -1,115 +0,0 @@
-package output
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"strings"
-	"sync"
-
-	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/templater"
-)
-
-type Prefixed struct {
-	logger  *logger.Logger
-	seen    map[string]uint
-	counter *uint
-	mutex   sync.Mutex
-}
-
-func NewPrefixed(logger *logger.Logger) *Prefixed {
-	var counter uint
-
-	return &Prefixed{
-		seen:    make(map[string]uint),
-		counter: &counter,
-		logger:  logger,
-	}
-}
-
-func (p *Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
-	pw := &prefixWriter{writer: stdOut, prefix: prefix, prefixed: p}
-	return pw, pw, func(error) error { return pw.close() }
-}
-
-type prefixWriter struct {
-	writer   io.Writer
-	prefixed *Prefixed
-	prefix   string
-	buff     bytes.Buffer
-}
-
-func (pw *prefixWriter) Write(p []byte) (int, error) {
-	n, err := pw.buff.Write(p)
-	if err != nil {
-		return n, err
-	}
-
-	return n, pw.writeOutputLines(false)
-}
-
-func (pw *prefixWriter) close() error {
-	return pw.writeOutputLines(true)
-}
-
-func (pw *prefixWriter) writeOutputLines(force bool) error {
-	for {
-		switch line, err := pw.buff.ReadString('\n'); err {
-		case nil:
-			if err = pw.writeLine(line); err != nil {
-				return err
-			}
-		case io.EOF:
-			// if this line was not a complete line, re-add to the buffer
-			if !force && !strings.HasSuffix(line, "\n") {
-				_, err = pw.buff.WriteString(line)
-				return err
-			}
-
-			return pw.writeLine(line)
-		default:
-			return err
-		}
-	}
-}
-
-var PrefixColorSequence = []logger.Color{
-	logger.Yellow, logger.Blue, logger.Magenta, logger.Cyan, logger.Green, logger.Red,
-	logger.BrightYellow, logger.BrightBlue, logger.BrightMagenta, logger.BrightCyan, logger.BrightGreen, logger.BrightRed,
-}
-
-func (pw *prefixWriter) writeLine(line string) error {
-	if line == "" {
-		return nil
-	}
-	if !strings.HasSuffix(line, "\n") {
-		line += "\n"
-	}
-
-	defer pw.prefixed.mutex.Unlock()
-	pw.prefixed.mutex.Lock()
-
-	idx, ok := pw.prefixed.seen[pw.prefix]
-
-	if !ok {
-		idx = *pw.prefixed.counter
-		pw.prefixed.seen[pw.prefix] = idx
-
-		*pw.prefixed.counter++
-	}
-
-	if _, err := fmt.Fprint(pw.writer, "["); err != nil {
-		return nil
-	}
-
-	color := PrefixColorSequence[idx%uint(len(PrefixColorSequence))]
-	pw.prefixed.logger.FOutf(pw.writer, color, pw.prefix)
-
-	if _, err := fmt.Fprint(pw.writer, "] "); err != nil {
-		return nil
-	}
-
-	_, err := fmt.Fprint(pw.writer, line)
-	return err
-}

internal/slicesext/slicesext.go

@@ -1,32 +0,0 @@
-package slicesext
-
-import (
-	"cmp"
-	"slices"
-)
-
-func UniqueJoin[T cmp.Ordered](ss ...[]T) []T {
-	var length int
-	for _, s := range ss {
-		length += len(s)
-	}
-	r := make([]T, length)
-	var i int
-	for _, s := range ss {
-		i += copy(r[i:], s)
-	}
-	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))
-	}
-}