Let utils.ExecCommand print the command in verbose mode

Previously, the command was printed by PrepareCommandForRecipe. Letting
ExecCommand print seems more accurate, since it is only printed when it
is actually run (though this already happened in practice).
Additionally, the command can now be modified between
PrepareCommandForRecipe and ExecCommand while preserving correct output.

Since ExecCommand deals with a slice of arguments instead of a single
command string, this requires merging them together into a proper
commandline. Some care is taken to quote arguments containing
spaces, quotes or backslashes, though this is mostly intended for
display purposes. Arguments are only quoted when needed, regardless of
whether they were quoted in the original pattern.

Signed-off-by: Matthijs Kooijman <[email protected]>

Author: matthijskooijman

Diff for: test/utils_test.go

@@ -70,6 +70,25 @@ func TestCommandLineParser(t *testing.T) {
 	require.Equal(t, "/tmp/sketch321469072.cpp", parts[22])
 }
 
+func TestPrintableCommand(t *testing.T) {
+	parts := []string{
+		"/path/to/dir with spaces/cmd",
+		"arg1",
+		"arg-\"with\"-quotes",
+		"specialchar-`~!@#$%^&*()-_=+[{]}\\|;:'\",<.>/?-argument",
+		"arg   with spaces",
+		"arg\twith\t\ttabs",
+		"lastarg",
+	}
+	correct := "\"/path/to/dir with spaces/cmd\"" +
+		" arg1 \"arg-\\\"with\\\"-quotes\"" +
+		" \"specialchar-`~!@#$%^&*()-_=+[{]}\\\\|;:'\\\",<.>/?-argument\"" +
+		" \"arg   with spaces\" \"arg\twith\t\ttabs\"" +
+		" lastarg"
+	result := utils.PrintableCommand(parts)
+	require.Equal(t, correct, result)
+}
+
 func TestCommandLineParserError(t *testing.T) {
 	command := "\"command missing quote"
 

Diff for: utils/utils.go

@@ -277,14 +277,36 @@ func PrepareCommand(pattern string, logger i18n.Logger, relativePath string) (*e
 	return PrepareCommandFilteredArgs(pattern, filterEmptyArg, logger, relativePath)
 }
 
+func printableArgument(arg string) string {
+	if strings.ContainsAny(arg, "\"\\ \t") {
+		arg = strings.Replace(arg, "\\", "\\\\", -1)
+		arg = strings.Replace(arg, "\"", "\\\"", -1)
+		return "\"" + arg + "\""
+	} else {
+		return arg
+	}
+}
+
+// Convert a command and argument slice back to a printable string.
+// This adds basic escaping which is sufficient for debug output, but
+// probably not for shell interpretation. This essentially reverses
+// ParseCommandLine.
+func PrintableCommand(parts []string) string {
+	return strings.Join(Map(parts, printableArgument), " ")
+}
+
 const (
-	Ignore = 0 // Redirect to null
-	Show = 1 // Show on stdout/stderr as normal
+	Ignore        = 0 // Redirect to null
+	Show          = 1 // Show on stdout/stderr as normal
 	ShowIfVerbose = 2 // Show if verbose is set, Ignore otherwise
-	Capture = 3 // Capture into buffer
+	Capture       = 3 // Capture into buffer
 )
 
 func ExecCommand(ctx *types.Context, command *exec.Cmd, stdout int, stderr int) ([]byte, []byte, error) {
+	if ctx.Verbose {
+		fmt.Println(PrintableCommand(command.Args))
+	}
+
 	if stdout == Capture {
 		buffer := &bytes.Buffer{}
 		command.Stdout = buffer
@@ -308,10 +330,10 @@ func ExecCommand(ctx *types.Context, command *exec.Cmd, stdout int, stderr int)
 
 	var outbytes, errbytes []byte
 	if buf, ok := command.Stdout.(*bytes.Buffer); ok {
-		outbytes =  buf.Bytes()
+		outbytes = buf.Bytes()
 	}
 	if buf, ok := command.Stderr.(*bytes.Buffer); ok {
-		errbytes =  buf.Bytes()
+		errbytes = buf.Bytes()
 	}
 
 	return outbytes, errbytes, i18n.WrapError(err)