feat(defer): expose EXIT_CODE special variable to defer:

Co-authored-by: Dor Sahar <[email protected]>

Author: andreynering

CHANGELOG.md

@@ -8,6 +8,8 @@
 - Added a CI lint job to ensure that the docs are updated correctly (#1719 by
   @vmaerten).
 - Updated minimum required Go version to 1.22 (#1758 by @pd93).
+- Expose a new `EXIT_CODE` special variable on `defer:` when a command finishes
+  with a non-zero exit code (#1484, #1762 by @dorimon-1 and @andreynering).
 
 ## v3.38.0 - 2024-06-30
 

internal/execext/exec.go

@@ -90,14 +90,6 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 	return r.Run(ctx, p)
 }
 
-// IsExitError returns true the given error is an exis status error
-func IsExitError(err error) bool {
-	if _, ok := interp.IsExitStatus(err); ok {
-		return true
-	}
-	return false
-}
-
 // Expand is a helper to mvdan.cc/shell.Fields that returns the first field
 // if available.
 func Expand(s string) (string, error) {

task.go

@@ -11,6 +11,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	"mvdan.cc/sh/v3/interp"
+
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/compiler"
 	"github.com/go-task/task/v3/internal/env"
@@ -247,9 +249,11 @@ func (e *Executor) RunTask(ctx context.Context, call *ast.Call) error {
 			e.Logger.Errf(logger.Red, "task: cannot make directory %q: %v\n", t.Dir, err)
 		}
 
+		var deferredExitCode uint8
+
 		for i := range t.Cmds {
 			if t.Cmds[i].Defer {
-				defer e.runDeferred(t, call, i)
+				defer e.runDeferred(t, call, i, &deferredExitCode)
 				continue
 			}
 
@@ -258,9 +262,13 @@ func (e *Executor) RunTask(ctx context.Context, call *ast.Call) error {
 					e.Logger.VerboseErrf(logger.Yellow, "task: error cleaning status on error: %v\n", err2)
 				}
 
-				if execext.IsExitError(err) && t.IgnoreError {
-					e.Logger.VerboseErrf(logger.Yellow, "task: task error ignored: %v\n", err)
-					continue
+				exitCode, isExitError := interp.IsExitStatus(err)
+				if isExitError {
+					if t.IgnoreError {
+						e.Logger.VerboseErrf(logger.Yellow, "task: task error ignored: %v\n", err)
+						continue
+					}
+					deferredExitCode = exitCode
 				}
 
 				if call.Indirect {
@@ -312,10 +320,21 @@ func (e *Executor) runDeps(ctx context.Context, t *ast.Task) error {
 	return g.Wait()
 }
 
-func (e *Executor) runDeferred(t *ast.Task, call *ast.Call, i int) {
+func (e *Executor) runDeferred(t *ast.Task, call *ast.Call, i int, deferredExitCode *uint8) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
+	cmd := t.Cmds[i]
+	vars, _ := e.Compiler.FastGetVariables(t, call)
+	cache := &templater.Cache{Vars: vars}
+	extra := map[string]any{}
+
+	if deferredExitCode != nil && *deferredExitCode > 0 {
+		extra["EXIT_CODE"] = fmt.Sprintf("%d", *deferredExitCode)
+	}
+
+	cmd.Cmd = templater.ReplaceWithExtra(cmd.Cmd, cache, extra)
+
 	if err := e.runCommand(ctx, t, call, i); err != nil {
 		e.Logger.VerboseErrf(logger.Yellow, "task: ignored error in deferred cmd: %s\n", err.Error())
 	}
@@ -372,7 +391,7 @@ func (e *Executor) runCommand(ctx context.Context, t *ast.Task, call *ast.Call,
 		if closeErr := close(err); closeErr != nil {
 			e.Logger.Errf(logger.Red, "task: unable to close writer: %v\n", closeErr)
 		}
-		if execext.IsExitError(err) && cmd.IgnoreError {
+		if _, isExitError := interp.IsExitStatus(err); isExitError && cmd.IgnoreError {
 			e.Logger.VerboseErrf(logger.Yellow, "task: [%s] command error ignored: %v\n", t.Name(), err)
 			return nil
 		}

task_test.go

@@ -1738,6 +1738,34 @@ task-1 ran successfully
 	assert.Contains(t, buff.String(), expectedOutputOrder)
 }
 
+func TestExitCodeZero(t *testing.T) {
+	const dir = "testdata/exit_code"
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+	}
+	require.NoError(t, e.Setup())
+
+	require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "exit-zero"}))
+	assert.Equal(t, "EXIT_CODE=", strings.TrimSpace(buff.String()))
+}
+
+func TestExitCodeOne(t *testing.T) {
+	const dir = "testdata/exit_code"
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+	}
+	require.NoError(t, e.Setup())
+
+	require.Error(t, e.Run(context.Background(), &ast.Call{Task: "exit-one"}))
+	assert.Equal(t, "EXIT_CODE=1", strings.TrimSpace(buff.String()))
+}
+
 func TestIgnoreNilElements(t *testing.T) {
 	tests := []struct {
 		name string

testdata/exit_code/Taskfile.yml

@@ -0,0 +1,17 @@
+version: '3'
+
+silent: true
+
+vars:
+  PREFIX: EXIT_CODE=
+
+tasks:
+  exit-zero:
+    cmds:
+      - defer: echo {{.PREFIX}}{{.EXIT_CODE}}
+      - exit 0
+
+  exit-one:
+    cmds:
+      - defer: echo {{.PREFIX}}{{.EXIT_CODE}}
+      - exit 1

variables.go

@@ -161,6 +161,12 @@ func (e *Executor) compiledTask(call *ast.Call, evaluateShVars bool) (*ast.Task,
 				}
 				continue
 			}
+			// Defer commands are replaced in a lazy manner because
+			// we need to include EXIT_CODE.
+			if cmd.Defer {
+				new.Cmds = append(new.Cmds, cmd.DeepCopy())
+				continue
+			}
 			newCmd := cmd.DeepCopy()
 			newCmd.Cmd = templater.Replace(cmd.Cmd, cache)
 			newCmd.Task = templater.Replace(cmd.Task, cache)

website/docs/reference/templating.mdx

@@ -117,6 +117,7 @@ special variable will be overridden.
 | `TIMESTAMP`        | The date object of the greatest timestamp of the files listed in `sources`. Only available within the `status` prop and if method is set to `timestamp`. |
 | `TASK_VERSION`     | The current version of task.                                                                                                                             |
 | `ITEM`             | The value of the current iteration when using the `for` property. Can be changed to a different variable name using `as:`.                               |
+| `EXIT_CODE`        | Available exclusively inside the `defer:` command. Contains the failed command exit code. Only set when non-zero.                                        |
 
 ## Functions
 

website/docs/usage.mdx

@@ -1520,6 +1520,20 @@ commands are executed in the reverse order if you schedule multiple of them.
 
 :::
 
+A special variable `.EXIT_CODE` is exposed when a command exited with a non-zero
+exit code. You can check its presence to know if the task completed successfully
+or not:
+
+```yaml
+version: '3'
+
+tasks:
+  default:
+    cmds:
+      - defer: echo '{{if .EXIT_CODE}}Failed with {{.EXIT_CODE}}!{{else}}Success!{{end}}'
+      - exit 1
+```
+
 ## Help
 
 Running `task --list` (or `task -l`) lists all tasks with a description. The