refactor: remove newlines from formatter print functions (go-task#1137)

pd93 · web-flow · commit 8cfac5a25a7a · 2023-04-26T21:20:06.000-03:00
diff --git a/cmd/task/task.go b/cmd/task/task.go
@@ -255,7 +255,7 @@ func run() error {
 	}
 
 	if err := e.Run(ctx, calls...); err != nil {
-		e.Logger.Errf(logger.Red, "%v", err)
+		e.Logger.Errf(logger.Red, "%v\n", err)
 
 		if exitCode {
 			if err, ok := err.(*errors.TaskRunError); ok {
diff --git a/help.go b/help.go
@@ -88,24 +88,24 @@ func (e *Executor) ListTasks(o ListOptions) (bool, error) {
 	}
 	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")
+			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")
+			e.Logger.Outf(logger.Yellow, "task: No tasks available\n")
 		}
 		return false, nil
 	}
-	e.Logger.Outf(logger.Default, "task: Available tasks for this project:")
+	e.Logger.Outf(logger.Default, "task: Available tasks for this project:\n")
 
 	// Format in tab-separated columns with a tab stop of 8.
 	w := tabwriter.NewWriter(e.Stdout, 0, 8, 6, ' ', 0)
 	for _, task := range tasks {
-		e.Logger.FOutf(w, logger.Yellow, "* ")
-		e.Logger.FOutf(w, logger.Green, task.Task)
-		e.Logger.FOutf(w, logger.Default, ": \t%s", task.Desc)
+		e.Logger.Outf(logger.Yellow, "* ")
+		e.Logger.Outf(logger.Green, task.Task)
+		e.Logger.Outf(logger.Default, ": \t%s", task.Desc)
 		if len(task.Aliases) > 0 {
-			e.Logger.FOutf(w, logger.Cyan, "\t(aliases: %s)", strings.Join(task.Aliases, ", "))
+			e.Logger.Outf(logger.Cyan, "\t(aliases: %s)", strings.Join(task.Aliases, ", "))
 		}
-		_, _ = fmt.Fprint(w, "\n")
+		e.Logger.Outf(logger.Default, "\n")
 	}
 	if err := w.Flush(); err != nil {
 		return false, err
diff --git a/internal/compiler/v2/compiler_v2.go b/internal/compiler/v2/compiler_v2.go
@@ -117,7 +117,7 @@ func (c *CompilerV2) HandleDynamicVar(v taskfile.Var, _ string) (string, error)
 	result := strings.TrimSuffix(stdout.String(), "\n")
 
 	c.dynamicCache[v.Sh] = result
-	c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
+	c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", v.Sh, result)
 
 	return result, nil
 }
diff --git a/internal/compiler/v3/compiler_v3.go b/internal/compiler/v3/compiler_v3.go
@@ -161,7 +161,7 @@ func (c *CompilerV3) HandleDynamicVar(v taskfile.Var, dir string) (string, error
 	result = strings.TrimSuffix(result, "\n")
 
 	c.dynamicCache[v.Sh] = result
-	c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
+	c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", v.Sh, result)
 
 	return result, nil
 }
diff --git a/internal/fingerprint/status.go b/internal/fingerprint/status.go
@@ -27,10 +27,10 @@ func (checker *StatusChecker) IsUpToDate(ctx context.Context, t *taskfile.Task)
 			Env:     env.Get(t),
 		})
 		if err != nil {
-			checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited non-zero: %s", s, err)
+			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", s)
+		checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited zero\n", s)
 	}
 	return true, nil
 }
diff --git a/internal/logger/logger.go b/internal/logger/logger.go
@@ -64,7 +64,7 @@ type Logger struct {
 
 // Outf prints stuff to STDOUT.
 func (l *Logger) Outf(color Color, s string, args ...any) {
-	l.FOutf(l.Stdout, color, s+"\n", args...)
+	l.FOutf(l.Stdout, color, s, args...)
 }
 
 // FOutf prints stuff to the given writer.
@@ -95,7 +95,7 @@ func (l *Logger) Errf(color Color, s string, args ...any) {
 		color = Default
 	}
 	print := color()
-	print(l.Stderr, s+"\n", args...)
+	print(l.Stderr, s, args...)
 }
 
 // VerboseErrf prints stuff to STDERR if verbose mode is enabled.
diff --git a/internal/summary/summary.go b/internal/summary/summary.go
@@ -20,8 +20,8 @@ func PrintSpaceBetweenSummaries(l *logger.Logger, i int) {
 		return
 	}
 
-	l.Outf(logger.Default, "")
-	l.Outf(logger.Default, "")
+	l.Outf(logger.Default, "\n")
+	l.Outf(logger.Default, "\n")
 }
 
 func PrintTask(l *logger.Logger, t *taskfile.Task) {
@@ -51,26 +51,26 @@ func printTaskSummary(l *logger.Logger, t *taskfile.Task) {
 	for i, line := range lines {
 		notLastLine := i+1 < len(lines)
 		if notLastLine || line != "" {
-			l.Outf(logger.Default, line)
+			l.Outf(logger.Default, "%s\n", line)
 		}
 	}
 }
 
 func printTaskName(l *logger.Logger, t *taskfile.Task) {
-	l.FOutf(l.Stdout, logger.Default, "task: ")
-	l.FOutf(l.Stdout, logger.Green, "%s\n", t.Name())
-	l.Outf(logger.Default, "")
+	l.Outf(logger.Default, "task: ")
+	l.Outf(logger.Green, "%s\n", t.Name())
+	l.Outf(logger.Default, "\n")
 }
 
 func printTaskAliases(l *logger.Logger, t *taskfile.Task) {
 	if len(t.Aliases) == 0 {
 		return
 	}
-	l.Outf(logger.Default, "")
-	l.Outf(logger.Default, "aliases:")
+	l.Outf(logger.Default, "\n")
+	l.Outf(logger.Default, "aliases:\n")
 	for _, alias := range t.Aliases {
-		l.FOutf(l.Stdout, logger.Default, " - ")
-		l.Outf(logger.Cyan, alias)
+		l.Outf(logger.Default, " - ")
+		l.Outf(logger.Cyan, "%s\n", alias)
 	}
 }
 
@@ -79,23 +79,23 @@ func hasDescription(t *taskfile.Task) bool {
 }
 
 func printTaskDescription(l *logger.Logger, t *taskfile.Task) {
-	l.Outf(logger.Default, t.Desc)
+	l.Outf(logger.Default, "%s\n", t.Desc)
 }
 
 func printNoDescriptionOrSummary(l *logger.Logger) {
-	l.Outf(logger.Default, "(task does not have description or summary)")
+	l.Outf(logger.Default, "(task does not have description or summary)\n")
 }
 
 func printTaskDependencies(l *logger.Logger, t *taskfile.Task) {
 	if len(t.Deps) == 0 {
 		return
 	}
 
-	l.Outf(logger.Default, "")
-	l.Outf(logger.Default, "dependencies:")
+	l.Outf(logger.Default, "\n")
+	l.Outf(logger.Default, "dependencies:\n")
 
 	for _, d := range t.Deps {
-		l.Outf(logger.Default, " - %s", d.Task)
+		l.Outf(logger.Default, " - %s\n", d.Task)
 	}
 }
 
@@ -104,15 +104,15 @@ func printTaskCommands(l *logger.Logger, t *taskfile.Task) {
 		return
 	}
 
-	l.Outf(logger.Default, "")
-	l.Outf(logger.Default, "commands:")
+	l.Outf(logger.Default, "\n")
+	l.Outf(logger.Default, "commands:\n")
 	for _, c := range t.Cmds {
 		isCommand := c.Cmd != ""
-		l.FOutf(l.Stdout, logger.Default, " - ")
+		l.Outf(logger.Default, " - ")
 		if isCommand {
-			l.FOutf(l.Stdout, logger.Yellow, "%s\n", c.Cmd)
+			l.Outf(logger.Yellow, "%s\n", c.Cmd)
 		} else {
-			l.FOutf(l.Stdout, logger.Green, "Task: %s\n", c.Task)
+			l.Outf(logger.Green, "Task: %s\n", c.Task)
 		}
 	}
 }
diff --git a/precondition.go b/precondition.go
@@ -21,7 +21,7 @@ func (e *Executor) areTaskPreconditionsMet(ctx context.Context, t *taskfile.Task
 			Env:     env.Get(t),
 		})
 		if err != nil {
-			e.Logger.Errf(logger.Magenta, "task: %s", p.Msg)
+			e.Logger.Errf(logger.Magenta, "task: %s\n", p.Msg)
 			return false, ErrPreconditionFailed
 		}
 	}
diff --git a/signals.go b/signals.go
@@ -20,11 +20,11 @@ func (e *Executor) InterceptInterruptSignals() {
 			sig := <-ch
 
 			if i < 3 {
-				e.Logger.Outf(logger.Yellow, `task: Signal received: "%s"`, sig)
+				e.Logger.Outf(logger.Yellow, "task: Signal received: %q\n", sig)
 				continue
 			}
 
-			e.Logger.Errf(logger.Red, `task: Signal received for the third time: "%s". Forcing shutdown`, sig)
+			e.Logger.Errf(logger.Red, "task: Signal received for the third time: %q. Forcing shutdown\n", sig)
 			os.Exit(1)
 		}
 	}()
diff --git a/task.go b/task.go
@@ -141,11 +141,11 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 
 	return e.startExecution(ctx, t, func(ctx context.Context) error {
 		if !shouldRunOnCurrentPlatform(t.Platforms) {
-			e.Logger.VerboseOutf(logger.Yellow, `task: "%s" not for current platform - ignored`, call.Task)
+			e.Logger.VerboseOutf(logger.Yellow, `task: %q not for current platform - ignored\n`, call.Task)
 			return nil
 		}
 
-		e.Logger.VerboseErrf(logger.Magenta, `task: "%s" started`, call.Task)
+		e.Logger.VerboseErrf(logger.Magenta, "task: %q started\n", call.Task)
 		if err := e.runDeps(ctx, t); err != nil {
 			return err
 		}
@@ -178,14 +178,14 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 
 			if upToDate && preCondMet {
 				if e.Verbose || (!t.Silent && !e.Taskfile.Silent && !e.Silent) {
-					e.Logger.Errf(logger.Magenta, `task: Task "%s" is up to date`, t.Name())
+					e.Logger.Errf(logger.Magenta, "task: Task %q is up to date\n", t.Name())
 				}
 				return nil
 			}
 		}
 
 		if err := e.mkdir(t); err != nil {
-			e.Logger.Errf(logger.Red, "task: cannot make directory %q: %v", t.Dir, err)
+			e.Logger.Errf(logger.Red, "task: cannot make directory %q: %v\n", t.Dir, err)
 		}
 
 		for i := range t.Cmds {
@@ -196,18 +196,18 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 
 			if err := e.runCommand(ctx, t, call, i); err != nil {
 				if err2 := e.statusOnError(t); err2 != nil {
-					e.Logger.VerboseErrf(logger.Yellow, "task: error cleaning status on error: %v", err2)
+					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", err)
+					e.Logger.VerboseErrf(logger.Yellow, "task: task error ignored: %v\n", err)
 					continue
 				}
 
 				return &errors.TaskRunError{TaskName: t.Task, Err: err}
 			}
 		}
-		e.Logger.VerboseErrf(logger.Magenta, `task: "%s" finished`, call.Task)
+		e.Logger.VerboseErrf(logger.Magenta, "task: %q finished\n", call.Task)
 		return nil
 	})
 }
@@ -255,7 +255,7 @@ func (e *Executor) runDeferred(t *taskfile.Task, call taskfile.Call, i int) {
 	defer cancel()
 
 	if err := e.runCommand(ctx, t, call, i); err != nil {
-		e.Logger.VerboseErrf(logger.Yellow, `task: ignored error in deferred cmd: %s`, err.Error())
+		e.Logger.VerboseErrf(logger.Yellow, "task: ignored error in deferred cmd: %s\n", err.Error())
 	}
 }
 
@@ -274,12 +274,12 @@ func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfi
 		return nil
 	case cmd.Cmd != "":
 		if !shouldRunOnCurrentPlatform(cmd.Platforms) {
-			e.Logger.VerboseOutf(logger.Yellow, `task: [%s] %s not for current platform - ignored`, t.Name(), cmd.Cmd)
+			e.Logger.VerboseOutf(logger.Yellow, "task: [%s] %s not for current platform - ignored\n", t.Name(), cmd.Cmd)
 			return nil
 		}
 
 		if e.Verbose || (!cmd.Silent && !t.Silent && !e.Taskfile.Silent && !e.Silent) {
-			e.Logger.Errf(logger.Green, "task: [%s] %s", t.Name(), cmd.Cmd)
+			e.Logger.Errf(logger.Green, "task: [%s] %s\n", t.Name(), cmd.Cmd)
 		}
 
 		if e.Dry {
@@ -308,10 +308,10 @@ func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfi
 			Stderr:    stdErr,
 		})
 		if closeErr := close(err); closeErr != nil {
-			e.Logger.Errf(logger.Red, "task: unable to close writer: %v", closeErr)
+			e.Logger.Errf(logger.Red, "task: unable to close writer: %v\n", closeErr)
 		}
 		if execext.IsExitError(err) && cmd.IgnoreError {
-			e.Logger.VerboseErrf(logger.Yellow, "task: [%s] command error ignored: %v", t.Name(), err)
+			e.Logger.VerboseErrf(logger.Yellow, "task: [%s] command error ignored: %v\n", t.Name(), err)
 			return nil
 		}
 		return err
@@ -334,7 +334,7 @@ func (e *Executor) startExecution(ctx context.Context, t *taskfile.Task, execute
 
 	if otherExecutionCtx, ok := e.executionHashes[h]; ok {
 		e.executionHashesMutex.Unlock()
-		e.Logger.VerboseErrf(logger.Magenta, "task: skipping execution of task: %s", h)
+		e.Logger.VerboseErrf(logger.Magenta, "task: skipping execution of task: %s\n", h)
 
 		// Release our execution slot to avoid blocking other tasks while we wait
 		reacquire := e.releaseConcurrencyLimit()
diff --git a/watch.go b/watch.go
@@ -34,7 +34,7 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {
 		c := c
 		go func() {
 			if err := e.RunTask(ctx, c); err != nil && !isContextError(err) {
-				e.Logger.Errf(logger.Red, "%v", err)
+				e.Logger.Errf(logger.Red, "%v\n", err)
 			}
 		}()
 	}
@@ -49,7 +49,7 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {
 		watchInterval = defaultWatchInterval
 	}
 
-	e.Logger.VerboseOutf(logger.Green, "task: Watching for changes every %v", watchInterval)
+	e.Logger.VerboseOutf(logger.Green, "task: Watching for changes every %v\n", watchInterval)
 
 	w := watcher.New()
 	defer w.Close()
@@ -61,7 +61,7 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {
 		for {
 			select {
 			case event := <-w.Event:
-				e.Logger.VerboseErrf(logger.Magenta, "task: received watch event: %v", event)
+				e.Logger.VerboseErrf(logger.Magenta, "task: received watch event: %v\n", event)
 
 				cancel()
 				ctx, cancel = context.WithCancel(context.Background())
@@ -72,15 +72,15 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {
 					c := c
 					go func() {
 						if err := e.RunTask(ctx, c); err != nil && !isContextError(err) {
-							e.Logger.Errf(logger.Red, "%v", err)
+							e.Logger.Errf(logger.Red, "%v\n", err)
 						}
 					}()
 				}
 			case err := <-w.Error:
 				switch err {
 				case watcher.ErrWatchedFileDeleted:
 				default:
-					e.Logger.Errf(logger.Red, "%v", err)
+					e.Logger.Errf(logger.Red, "%v\n", err)
 				}
 			case <-w.Closed:
 				cancel()
@@ -93,7 +93,7 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {
 		// re-register every 5 seconds because we can have new files, but this process is expensive to run
 		for {
 			if err := e.registerWatchedFiles(w, calls...); err != nil {
-				e.Logger.Errf(logger.Red, "%v", err)
+				e.Logger.Errf(logger.Red, "%v\n", err)
 			}
 			time.Sleep(watchInterval)
 		}
@@ -161,7 +161,7 @@ func (e *Executor) registerWatchedFiles(w *watcher.Watcher, calls ...taskfile.Ca
 				if err := w.Add(absFile); err != nil {
 					return err
 				}
-				e.Logger.VerboseOutf(logger.Green, "task: watching new file: %v", absFile)
+				e.Logger.VerboseOutf(logger.Green, "task: watching new file: %v\n", absFile)
 			}
 		}
 		return nil

Original file line number	Diff line number	Diff line change
`@@ -255,7 +255,7 @@ func run() error {`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`if err := e.Run(ctx, calls...); err != nil {`
`258`		`- e.Logger.Errf(logger.Red, "%v", err)`
	`258`	`+ e.Logger.Errf(logger.Red, "%v\n", err)`
`259`	`259`
`260`	`260`	`if exitCode {`
`261`	`261`	`if err, ok := err.(*errors.TaskRunError); ok {`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ func (c *CompilerV2) HandleDynamicVar(v taskfile.Var, _ string) (string, error)`
`117`	`117`	`result := strings.TrimSuffix(stdout.String(), "\n")`
`118`	`118`
`119`	`119`	`c.dynamicCache[v.Sh] = result`
`120`		- c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
	`120`	`+ c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", v.Sh, result)`
`121`	`121`
`122`	`122`	`return result, nil`
`123`	`123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ func (c *CompilerV3) HandleDynamicVar(v taskfile.Var, dir string) (string, error`
`161`	`161`	`result = strings.TrimSuffix(result, "\n")`
`162`	`162`
`163`	`163`	`c.dynamicCache[v.Sh] = result`
`164`		- c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
	`164`	`+ c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", v.Sh, result)`
`165`	`165`
`166`	`166`	`return result, nil`
`167`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,10 @@ func (checker StatusChecker) IsUpToDate(ctx context.Context, t taskfile.Task)`
`27`	`27`	`Env: env.Get(t),`
`28`	`28`	`})`
`29`	`29`	`if err != nil {`
`30`		`- checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited non-zero: %s", s, err)`
	`30`	`+ checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited non-zero: %s\n", s, err)`
`31`	`31`	`return false, nil`
`32`	`32`	`}`
`33`		`- checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited zero", s)`
	`33`	`+ checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited zero\n", s)`
`34`	`34`	`}`
`35`	`35`	`return true, nil`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ type Logger struct {`
`64`	`64`
`65`	`65`	`// Outf prints stuff to STDOUT.`
`66`	`66`	`func (l *Logger) Outf(color Color, s string, args ...any) {`
`67`		`- l.FOutf(l.Stdout, color, s+"\n", args...)`
	`67`	`+ l.FOutf(l.Stdout, color, s, args...)`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`// FOutf prints stuff to the given writer.`
`@@ -95,7 +95,7 @@ func (l *Logger) Errf(color Color, s string, args ...any) {`
`95`	`95`	`color = Default`
`96`	`96`	`}`
`97`	`97`	`print := color()`
`98`		`- print(l.Stderr, s+"\n", args...)`
	`98`	`+ print(l.Stderr, s, args...)`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`// VerboseErrf prints stuff to STDERR if verbose mode is enabled.`
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,8 @@ func PrintSpaceBetweenSummaries(l *logger.Logger, i int) {`
`20`	`20`	`return`
`21`	`21`	`}`
`22`	`22`
`23`		`- l.Outf(logger.Default, "")`
`24`		`- l.Outf(logger.Default, "")`
	`23`	`+ l.Outf(logger.Default, "\n")`
	`24`	`+ l.Outf(logger.Default, "\n")`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`func PrintTask(l logger.Logger, t taskfile.Task) {`
`@@ -51,26 +51,26 @@ func printTaskSummary(l logger.Logger, t taskfile.Task) {`
`51`	`51`	`for i, line := range lines {`
`52`	`52`	`notLastLine := i+1 < len(lines)`
`53`	`53`	`if notLastLine \|\| line != "" {`
`54`		`- l.Outf(logger.Default, line)`
	`54`	`+ l.Outf(logger.Default, "%s\n", line)`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`func printTaskName(l logger.Logger, t taskfile.Task) {`
`60`		`- l.FOutf(l.Stdout, logger.Default, "task: ")`
`61`		`- l.FOutf(l.Stdout, logger.Green, "%s\n", t.Name())`
`62`		`- l.Outf(logger.Default, "")`
	`60`	`+ l.Outf(logger.Default, "task: ")`
	`61`	`+ l.Outf(logger.Green, "%s\n", t.Name())`
	`62`	`+ l.Outf(logger.Default, "\n")`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`func printTaskAliases(l logger.Logger, t taskfile.Task) {`
`66`	`66`	`if len(t.Aliases) == 0 {`
`67`	`67`	`return`
`68`	`68`	`}`
`69`		`- l.Outf(logger.Default, "")`
`70`		`- l.Outf(logger.Default, "aliases:")`
	`69`	`+ l.Outf(logger.Default, "\n")`
	`70`	`+ l.Outf(logger.Default, "aliases:\n")`
`71`	`71`	`for _, alias := range t.Aliases {`
`72`		`- l.FOutf(l.Stdout, logger.Default, " - ")`
`73`		`- l.Outf(logger.Cyan, alias)`
	`72`	`+ l.Outf(logger.Default, " - ")`
	`73`	`+ l.Outf(logger.Cyan, "%s\n", alias)`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`@@ -79,23 +79,23 @@ func hasDescription(t *taskfile.Task) bool {`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`func printTaskDescription(l logger.Logger, t taskfile.Task) {`
`82`		`- l.Outf(logger.Default, t.Desc)`
	`82`	`+ l.Outf(logger.Default, "%s\n", t.Desc)`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`func printNoDescriptionOrSummary(l *logger.Logger) {`
`86`		`- l.Outf(logger.Default, "(task does not have description or summary)")`
	`86`	`+ l.Outf(logger.Default, "(task does not have description or summary)\n")`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`func printTaskDependencies(l logger.Logger, t taskfile.Task) {`
`90`	`90`	`if len(t.Deps) == 0 {`
`91`	`91`	`return`
`92`	`92`	`}`
`93`	`93`
`94`		`- l.Outf(logger.Default, "")`
`95`		`- l.Outf(logger.Default, "dependencies:")`
	`94`	`+ l.Outf(logger.Default, "\n")`
	`95`	`+ l.Outf(logger.Default, "dependencies:\n")`
`96`	`96`
`97`	`97`	`for _, d := range t.Deps {`
`98`		`- l.Outf(logger.Default, " - %s", d.Task)`
	`98`	`+ l.Outf(logger.Default, " - %s\n", d.Task)`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`@@ -104,15 +104,15 @@ func printTaskCommands(l logger.Logger, t taskfile.Task) {`
`104`	`104`	`return`
`105`	`105`	`}`
`106`	`106`
`107`		`- l.Outf(logger.Default, "")`
`108`		`- l.Outf(logger.Default, "commands:")`
	`107`	`+ l.Outf(logger.Default, "\n")`
	`108`	`+ l.Outf(logger.Default, "commands:\n")`
`109`	`109`	`for _, c := range t.Cmds {`
`110`	`110`	`isCommand := c.Cmd != ""`
`111`		`- l.FOutf(l.Stdout, logger.Default, " - ")`
	`111`	`+ l.Outf(logger.Default, " - ")`
`112`	`112`	`if isCommand {`
`113`		`- l.FOutf(l.Stdout, logger.Yellow, "%s\n", c.Cmd)`
	`113`	`+ l.Outf(logger.Yellow, "%s\n", c.Cmd)`
`114`	`114`	`} else {`
`115`		`- l.FOutf(l.Stdout, logger.Green, "Task: %s\n", c.Task)`
	`115`	`+ l.Outf(logger.Green, "Task: %s\n", c.Task)`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ func (e Executor) areTaskPreconditionsMet(ctx context.Context, t taskfile.Task`
`21`	`21`	`Env: env.Get(t),`
`22`	`22`	`})`
`23`	`23`	`if err != nil {`
`24`		`- e.Logger.Errf(logger.Magenta, "task: %s", p.Msg)`
	`24`	`+ e.Logger.Errf(logger.Magenta, "task: %s\n", p.Msg)`
`25`	`25`	`return false, ErrPreconditionFailed`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,11 @@ func (e *Executor) InterceptInterruptSignals() {`
`20`	`20`	`sig := <-ch`
`21`	`21`
`22`	`22`	`if i < 3 {`
`23`		- e.Logger.Outf(logger.Yellow, `task: Signal received: "%s"`, sig)
	`23`	`+ e.Logger.Outf(logger.Yellow, "task: Signal received: %q\n", sig)`
`24`	`24`	`continue`
`25`	`25`	`}`
`26`	`26`
`27`		- e.Logger.Errf(logger.Red, `task: Signal received for the third time: "%s". Forcing shutdown`, sig)
	`27`	`+ e.Logger.Errf(logger.Red, "task: Signal received for the third time: %q. Forcing shutdown\n", sig)`
`28`	`28`	`os.Exit(1)`
`29`	`29`	`}`
`30`	`30`	`}()`
Original file line number	Diff line number	Diff line change
`@@ -141,11 +141,11 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {`
`141`	`141`
`142`	`142`	`return e.startExecution(ctx, t, func(ctx context.Context) error {`
`143`	`143`	`if !shouldRunOnCurrentPlatform(t.Platforms) {`
`144`		- e.Logger.VerboseOutf(logger.Yellow, `task: "%s" not for current platform - ignored`, call.Task)
	`144`	+ e.Logger.VerboseOutf(logger.Yellow, `task: %q not for current platform - ignored\n`, call.Task)
`145`	`145`	`return nil`
`146`	`146`	`}`
`147`	`147`
`148`		- e.Logger.VerboseErrf(logger.Magenta, `task: "%s" started`, call.Task)
	`148`	`+ e.Logger.VerboseErrf(logger.Magenta, "task: %q started\n", call.Task)`
`149`	`149`	`if err := e.runDeps(ctx, t); err != nil {`
`150`	`150`	`return err`
`151`	`151`	`}`
`@@ -178,14 +178,14 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {`
`178`	`178`
`179`	`179`	`if upToDate && preCondMet {`
`180`	`180`	`if e.Verbose \|\| (!t.Silent && !e.Taskfile.Silent && !e.Silent) {`
`181`		- e.Logger.Errf(logger.Magenta, `task: Task "%s" is up to date`, t.Name())
	`181`	`+ e.Logger.Errf(logger.Magenta, "task: Task %q is up to date\n", t.Name())`
`182`	`182`	`}`
`183`	`183`	`return nil`
`184`	`184`	`}`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`if err := e.mkdir(t); err != nil {`
`188`		`- e.Logger.Errf(logger.Red, "task: cannot make directory %q: %v", t.Dir, err)`
	`188`	`+ e.Logger.Errf(logger.Red, "task: cannot make directory %q: %v\n", t.Dir, err)`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`for i := range t.Cmds {`
`@@ -196,18 +196,18 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {`
`196`	`196`
`197`	`197`	`if err := e.runCommand(ctx, t, call, i); err != nil {`
`198`	`198`	`if err2 := e.statusOnError(t); err2 != nil {`
`199`		`- e.Logger.VerboseErrf(logger.Yellow, "task: error cleaning status on error: %v", err2)`
	`199`	`+ e.Logger.VerboseErrf(logger.Yellow, "task: error cleaning status on error: %v\n", err2)`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`if execext.IsExitError(err) && t.IgnoreError {`
`203`		`- e.Logger.VerboseErrf(logger.Yellow, "task: task error ignored: %v", err)`
	`203`	`+ e.Logger.VerboseErrf(logger.Yellow, "task: task error ignored: %v\n", err)`
`204`	`204`	`continue`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`return &errors.TaskRunError{TaskName: t.Task, Err: err}`
`208`	`208`	`}`
`209`	`209`	`}`
`210`		- e.Logger.VerboseErrf(logger.Magenta, `task: "%s" finished`, call.Task)
	`210`	`+ e.Logger.VerboseErrf(logger.Magenta, "task: %q finished\n", call.Task)`
`211`	`211`	`return nil`
`212`	`212`	`})`
`213`	`213`	`}`
`@@ -255,7 +255,7 @@ func (e Executor) runDeferred(t taskfile.Task, call taskfile.Call, i int) {`
`255`	`255`	`defer cancel()`
`256`	`256`
`257`	`257`	`if err := e.runCommand(ctx, t, call, i); err != nil {`
`258`		- e.Logger.VerboseErrf(logger.Yellow, `task: ignored error in deferred cmd: %s`, err.Error())
	`258`	`+ e.Logger.VerboseErrf(logger.Yellow, "task: ignored error in deferred cmd: %s\n", err.Error())`
`259`	`259`	`}`
`260`	`260`	`}`
`261`	`261`
`@@ -274,12 +274,12 @@ func (e Executor) runCommand(ctx context.Context, t taskfile.Task, call taskfi`
`274`	`274`	`return nil`
`275`	`275`	`case cmd.Cmd != "":`
`276`	`276`	`if !shouldRunOnCurrentPlatform(cmd.Platforms) {`
`277`		- e.Logger.VerboseOutf(logger.Yellow, `task: [%s] %s not for current platform - ignored`, t.Name(), cmd.Cmd)
	`277`	`+ e.Logger.VerboseOutf(logger.Yellow, "task: [%s] %s not for current platform - ignored\n", t.Name(), cmd.Cmd)`
`278`	`278`	`return nil`
`279`	`279`	`}`
`280`	`280`
`281`	`281`	`if e.Verbose \|\| (!cmd.Silent && !t.Silent && !e.Taskfile.Silent && !e.Silent) {`
`282`		`- e.Logger.Errf(logger.Green, "task: [%s] %s", t.Name(), cmd.Cmd)`
	`282`	`+ e.Logger.Errf(logger.Green, "task: [%s] %s\n", t.Name(), cmd.Cmd)`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`if e.Dry {`
`@@ -308,10 +308,10 @@ func (e Executor) runCommand(ctx context.Context, t taskfile.Task, call taskfi`
`308`	`308`	`Stderr: stdErr,`
`309`	`309`	`})`
`310`	`310`	`if closeErr := close(err); closeErr != nil {`
`311`		`- e.Logger.Errf(logger.Red, "task: unable to close writer: %v", closeErr)`
	`311`	`+ e.Logger.Errf(logger.Red, "task: unable to close writer: %v\n", closeErr)`
`312`	`312`	`}`
`313`	`313`	`if execext.IsExitError(err) && cmd.IgnoreError {`
`314`		`- e.Logger.VerboseErrf(logger.Yellow, "task: [%s] command error ignored: %v", t.Name(), err)`
	`314`	`+ e.Logger.VerboseErrf(logger.Yellow, "task: [%s] command error ignored: %v\n", t.Name(), err)`
`315`	`315`	`return nil`
`316`	`316`	`}`
`317`	`317`	`return err`
`@@ -334,7 +334,7 @@ func (e Executor) startExecution(ctx context.Context, t taskfile.Task, execute`
`334`	`334`
`335`	`335`	`if otherExecutionCtx, ok := e.executionHashes[h]; ok {`
`336`	`336`	`e.executionHashesMutex.Unlock()`
`337`		`- e.Logger.VerboseErrf(logger.Magenta, "task: skipping execution of task: %s", h)`
	`337`	`+ e.Logger.VerboseErrf(logger.Magenta, "task: skipping execution of task: %s\n", h)`
`338`	`338`
`339`	`339`	`// Release our execution slot to avoid blocking other tasks while we wait`
`340`	`340`	`reacquire := e.releaseConcurrencyLimit()`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {`
`34`	`34`	`c := c`
`35`	`35`	`go func() {`
`36`	`36`	`if err := e.RunTask(ctx, c); err != nil && !isContextError(err) {`
`37`		`- e.Logger.Errf(logger.Red, "%v", err)`
	`37`	`+ e.Logger.Errf(logger.Red, "%v\n", err)`
`38`	`38`	`}`
`39`	`39`	`}()`
`40`	`40`	`}`
`@@ -49,7 +49,7 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {`
`49`	`49`	`watchInterval = defaultWatchInterval`
`50`	`50`	`}`
`51`	`51`
`52`		`- e.Logger.VerboseOutf(logger.Green, "task: Watching for changes every %v", watchInterval)`
	`52`	`+ e.Logger.VerboseOutf(logger.Green, "task: Watching for changes every %v\n", watchInterval)`
`53`	`53`
`54`	`54`	`w := watcher.New()`
`55`	`55`	`defer w.Close()`
`@@ -61,7 +61,7 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {`
`61`	`61`	`for {`
`62`	`62`	`select {`
`63`	`63`	`case event := <-w.Event:`
`64`		`- e.Logger.VerboseErrf(logger.Magenta, "task: received watch event: %v", event)`
	`64`	`+ e.Logger.VerboseErrf(logger.Magenta, "task: received watch event: %v\n", event)`
`65`	`65`
`66`	`66`	`cancel()`
`67`	`67`	`ctx, cancel = context.WithCancel(context.Background())`
`@@ -72,15 +72,15 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {`
`72`	`72`	`c := c`
`73`	`73`	`go func() {`
`74`	`74`	`if err := e.RunTask(ctx, c); err != nil && !isContextError(err) {`
`75`		`- e.Logger.Errf(logger.Red, "%v", err)`
	`75`	`+ e.Logger.Errf(logger.Red, "%v\n", err)`
`76`	`76`	`}`
`77`	`77`	`}()`
`78`	`78`	`}`
`79`	`79`	`case err := <-w.Error:`
`80`	`80`	`switch err {`
`81`	`81`	`case watcher.ErrWatchedFileDeleted:`
`82`	`82`	`default:`
`83`		`- e.Logger.Errf(logger.Red, "%v", err)`
	`83`	`+ e.Logger.Errf(logger.Red, "%v\n", err)`
`84`	`84`	`}`
`85`	`85`	`case <-w.Closed:`
`86`	`86`	`cancel()`
`@@ -93,7 +93,7 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {`
`93`	`93`	`// re-register every 5 seconds because we can have new files, but this process is expensive to run`
`94`	`94`	`for {`
`95`	`95`	`if err := e.registerWatchedFiles(w, calls...); err != nil {`
`96`		`- e.Logger.Errf(logger.Red, "%v", err)`
	`96`	`+ e.Logger.Errf(logger.Red, "%v\n", err)`
`97`	`97`	`}`
`98`	`98`	`time.Sleep(watchInterval)`
`99`	`99`	`}`
`@@ -161,7 +161,7 @@ func (e Executor) registerWatchedFiles(w watcher.Watcher, calls ...taskfile.Ca`
`161`	`161`	`if err := w.Add(absFile); err != nil {`
`162`	`162`	`return err`
`163`	`163`	`}`
`164`		`- e.Logger.VerboseOutf(logger.Green, "task: watching new file: %v", absFile)`
	`164`	`+ e.Logger.VerboseOutf(logger.Green, "task: watching new file: %v\n", absFile)`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`	`return nil`