Conditional inclusions #2880

Activity

1. github-actions

   added

   state: needs triageWaiting to be triaged by a maintainer.Waiting to be triaged by a maintainer.

   on Jun 12, 2026
2. trulede commented on Jun 12, 2026

   

   trulede

   on Jun 12, 2026

   Contributor

   More actions

   Combine "conditional inclusions" with "optional inclusions" and see if you can find a way that works.

   version: '3'
   var:
     DOCKER:
       sh: "docker" # somehow like this  -  if .dockerenv then echo "docker"
   includes:
     build: ./Taskfile_{{DOCKER}}.yml
     optional: true
   
3. trulede

   added the

   support

   issue type on Jun 12, 2026
4. trulede

   added

   state: awaiting responseWaiting for issue author to respond.Waiting for issue author to respond.

   on Jun 12, 2026
5. cschanhniem commented on Jun 18, 2026

   

   cschanhniem

   on Jun 18, 2026

   More actions

   The design tension here is that includes are resolved during taskfile loading (in taskfile/reader.go::include()), while preconditions are evaluated during task execution. So naively porting preconditions: to the includes: block means evaluating shell commands at parse time — which changes the loading model and introduces ordering issues (e.g., if the precondition depends on a task you haven't run yet).

   @trulede's template-variable + optional: true approach works for cases where the decision can be reduced to a variable. The current vars: system supports sh: for dynamic variables, so you could express the devcontainer check as:

   vars:
     IN_DOCKER:
       sh: '[ -f /.dockerenv ] && echo "docker" || true'
   includes:
     devcontainer:
       taskfile: ./Taskfile_{{.IN_DOCKER}}.yml
       optional: true

   But this is fragile — when IN_DOCKER is empty, the include resolves to ./Taskfile_.yml which likely doesn't exist but could accidentally match a real file.

   A cleaner design would be adding a when field to the Include struct that takes a Go template expression evaluated against the existing vars/globals, evaluated during include resolution (not task execution). This keeps the evaluation at load time but uses the template engine rather than shell, avoiding the need to spawn subprocesses during loading:

   includes:
     devcontainer:
       taskfile: ./Taskfile_devcontainer.yml
       optional: true
       when: '{{.IN_DOCKER}} != ""'

   The when field would be a string template expression, evaluated in reader.go::include() before the goroutine spawns. If the expression evaluates to "false" or an empty string, the include is skipped (same as optional: true with missing file). This is consistent with how Taskfile already uses Go templates for interpolation and avoids the architectural complexity of deferred include resolution.

   The type change would be minimal: add When string to ast.Include, add when to the YAML decoding in ast.Include.UnmarshalYAML, and add a conditional skip in reader.go just before the goroutine spawns.

   Happy to sketch a PR if this direction makes sense.
6. vmaerten

   removed

   state: needs triageWaiting to be triaged by a maintainer.Waiting to be triaged by a maintainer.

   on Jul 19, 2026
7. vmaerten commented on Jul 19, 2026

   

   vmaerten

   on Jul 19, 2026

   Member

   More actions

   Hello !
   Re-open it if the solution from @trulede does not work for you
8. vmaerten

   closed this as completedon Jul 19, 2026