propagate -var

Author: denik

cmd/bundle/deployment/migrate.go

@@ -16,6 +16,7 @@ import (
 	"github.com/databricks/cli/cmd/root"
 	"github.com/databricks/cli/libs/cmdio"
 	"github.com/databricks/cli/libs/logdiag"
+	"github.com/databricks/cli/libs/shellquote"
 	"github.com/databricks/cli/libs/structs/structaccess"
 	"github.com/databricks/cli/libs/structs/structpath"
 	"github.com/spf13/cobra"
@@ -74,25 +75,42 @@ func runPlanCheck(cmd *cobra.Command, extraArgs []string, extraArgsStr string) e
 
 func getCommonArgs(cmd *cobra.Command) ([]string, string) {
 	var args []string
+	var quotedArgs []string
+
 	if flag := cmd.Flag("target"); flag != nil && flag.Changed {
 		target := flag.Value.String()
 		if target != "" {
 			args = append(args, "-t")
 			args = append(args, target)
+			quotedArgs = append(quotedArgs, "-t")
+			quotedArgs = append(quotedArgs, shellquote.BashArg(target))
 		}
 	}
 	if flag := cmd.Flag("profile"); flag != nil && flag.Changed {
 		profile := flag.Value.String()
 		if profile != "" {
 			args = append(args, "-p")
 			args = append(args, profile)
+			quotedArgs = append(quotedArgs, "-p")
+			quotedArgs = append(quotedArgs, shellquote.BashArg(profile))
+		}
+	}
+	if flag := cmd.Flag("var"); flag != nil && flag.Changed {
+		varValues, err := cmd.Flags().GetStringSlice("var")
+		if err == nil {
+			for _, v := range varValues {
+				args = append(args, "--var")
+				args = append(args, v)
+				quotedArgs = append(quotedArgs, "--var")
+				quotedArgs = append(quotedArgs, shellquote.BashArg(v))
+			}
 		}
 	}
 
 	argsStr := ""
 
-	if len(args) > 0 {
-		argsStr = " " + strings.Join(args, " ")
+	if len(quotedArgs) > 0 {
+		argsStr = " " + strings.Join(quotedArgs, " ")
 	}
 
 	return args, argsStr

libs/shellquote/quote.go

@@ -0,0 +1,39 @@
+package shellquote
+
+import (
+	"strings"
+)
+
+// BashArg quotes a string for safe use as a bash command argument.
+// It returns the argument unquoted if it contains only safe characters,
+// otherwise it wraps it in single quotes and escapes any single quotes within.
+func BashArg(s string) string {
+	if s == "" {
+		return "''"
+	}
+
+	// Check if string needs quoting
+	needsQuoting := false
+	for _, c := range s {
+		if !isSafeChar(c) {
+			needsQuoting = true
+			break
+		}
+	}
+
+	if !needsQuoting {
+		return s
+	}
+
+	// Use single quotes and escape any single quotes in the string
+	// by ending the quote, adding an escaped quote, and starting a new quote
+	return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
+}
+
+// isSafeChar returns true if the character is safe to use unquoted in bash.
+func isSafeChar(c rune) bool {
+	return (c >= 'a' && c <= 'z') ||
+		(c >= 'A' && c <= 'Z') ||
+		(c >= '0' && c <= '9') ||
+		c == '-' || c == '_' || c == '/' || c == '.' || c == ':'
+}

libs/shellquote/quote_test.go

@@ -0,0 +1,63 @@
+package shellquote
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBashArg(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		// Simple cases - no quoting needed
+		{"hello", "hello"},
+		{"hello-world", "hello-world"},
+		{"hello_world", "hello_world"},
+		{"path/to/file", "path/to/file"},
+		{"file.txt", "file.txt"},
+		{"host:port", "host:port"},
+		{"123", "123"},
+		{"a1b2c3", "a1b2c3"},
+
+		// Empty string
+		{"", "''"},
+
+		// Cases requiring quoting - spaces
+		{"hello world", "'hello world'"},
+		{"Custom Job Name", "'Custom Job Name'"},
+
+		// Cases requiring quoting - special characters
+		{"job_name=Custom Job Name", "'job_name=Custom Job Name'"},
+		{"foo=bar", "'foo=bar'"},
+		{"a b c", "'a b c'"},
+		{"*", "'*'"},
+		{"$VAR", "'$VAR'"},
+		{"a|b", "'a|b'"},
+		{"a&b", "'a&b'"},
+		{"a;b", "'a;b'"},
+		{"a>b", "'a>b'"},
+		{"a<b", "'a<b'"},
+		{"a(b)", "'a(b)'"},
+		{"a[b]", "'a[b]'"},
+		{"a{b}", "'a{b}'"},
+		{"a`b`", "'a`b`'"},
+		{"a\\b", "'a\\b'"},
+		{"a\"b\"", `'a"b"'`},
+
+		// Single quotes in string
+		{"it's", `'it'\''s'`},
+		{"can't", `'can'\''t'`},
+		{"'", `''\'''`},
+		{"''", `''\'''\'''`},
+		{"a'b'c", `'a'\''b'\''c'`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			result := BashArg(tt.input)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}