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: builder_utils/utils.go

@@ -30,7 +30,6 @@
 package builder_utils
 
 import (
-	"fmt"
 	"io"
 	"os"
 	"os/exec"
@@ -383,10 +382,6 @@ func PrepareCommandForRecipe(ctx *types.Context, buildProperties properties.Map,
 		return nil, i18n.WrapError(err)
 	}
 
-	if ctx.Verbose {
-		fmt.Println(commandLine)
-	}
-
 	return command, nil
 }
 

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

@@ -30,6 +30,7 @@
 package utils
 
 import (
+	"fmt"
 	"bytes"
 	"crypto/md5"
 	"encoding/hex"
@@ -255,6 +256,24 @@ func PrepareCommand(pattern string, logger i18n.Logger) (*exec.Cmd, error) {
 	return PrepareCommandFilteredArgs(pattern, filterEmptyArg, logger)
 }
 
+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
@@ -263,6 +282,10 @@ const (
 )
 
 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