feat: Add default argument to promptInt template function

docs/REFERENCE.md

@@ -121,7 +121,7 @@ Manage your dotfiles across multiple machines, securely.
   * [`pass` *pass-name*](#pass-pass-name)
   * [`passRaw` *pass-name*](#passraw-pass-name)
   * [`promptBool` *prompt* [*default*]](#promptbool-prompt-default)
-  * [`promptInt` *prompt*](#promptint-prompt)
+  * [`promptInt` *prompt* [*default*]](#promptint-prompt-default)
   * [`promptString` *prompt*](#promptstring-prompt)
   * [`secret` [*arg*...]](#secret-arg)
   * [`secretJSON` [*arg*...]](#secretjson-arg)
@@ -2371,11 +2371,12 @@ config file. The user's response is interpreted as follows (case insensitive):
 
 ---
 
-### `promptInt` *prompt*
+### `promptInt` *prompt* [*default*]
 
-`promptInt` prompts the user with *prompt* and returns the user's response with
-interpreted as an integer. It is only available when generating the initial
-config file.
+`promptInt` prompts the user with *prompt* and returns the user's response
+interpreted as an integer. If *default* is passed and the user's response is
+empty then it returns *default*. It is only available when generating the
+initial config file.
 
 ---
 

internal/cmd/executetemplatecmd.go

@@ -73,8 +73,20 @@ func (c *Config) runExecuteTemplateCmd(cmd *cobra.Command, args []string) error
 					return false
 				}
 			},
-			"promptInt": func(prompt string) int {
-				return c.executeTemplate.promptInt[prompt]
+			"promptInt": func(prompt string, args ...int) int {
+				switch len(args) {
+				case 0:
+					return c.executeTemplate.promptInt[prompt]
+				case 1:
+					if value, ok := c.executeTemplate.promptInt[prompt]; ok {
+						return value
+					}
+					return args[0]
+				default:
+					err := fmt.Errorf("want 1 or 2 arguments, got %d", len(args)+1)
+					returnTemplateError(err)
+					return 0
+				}
 			},
 			"promptString": func(prompt string) string {
 				if value, ok := c.executeTemplate.promptString[prompt]; ok {

internal/cmd/inittemplatefuncs.go

@@ -37,13 +37,32 @@ func (c *Config) promptBool(field string, args ...bool) bool {
 	}
 }
 
-func (c *Config) promptInt(field string) int64 {
-	value, err := strconv.ParseInt(c.promptString(field), 10, 64)
-	if err != nil {
+func (c *Config) promptInt(field string, args ...int64) int64 {
+	switch len(args) {
+	case 0:
+		value, err := strconv.ParseInt(c.promptString(field), 10, 64)
+		if err != nil {
+			returnTemplateError(err)
+			return 0
+		}
+		return value
+	case 1:
+		promptStr := field + " (default " + strconv.FormatInt(args[0], 10) + ")"
+		valueStr := c.promptString(promptStr)
+		if valueStr == "" {
+			return args[0]
+		}
+		value, err := strconv.ParseInt(valueStr, 10, 64)
+		if err != nil {
+			returnTemplateError(err)
+			return 0
+		}
+		return value
+	default:
+		err := fmt.Errorf("want 1 or 2 arguments, got %d", len(args)+1)
 		returnTemplateError(err)
 		return 0
 	}
-	return value
 }
 
 func (c *Config) promptString(field string) string {

internal/cmd/inittemplatefuncs_test.go

@@ -79,3 +79,75 @@ func TestPromptBool(t *testing.T) {
 		})
 	}
 }
+
+func TestPromptInt(t *testing.T) {
+	for _, tc := range []struct {
+		name              string
+		prompt            string
+		args              []int64
+		stdinStr          string
+		expectedStdoutStr string
+		expected          int64
+		expectedErr       bool
+	}{
+		{
+			name:              "response_without_default",
+			prompt:            "int",
+			stdinStr:          "1\n",
+			expectedStdoutStr: "int? ",
+			expected:          1,
+		},
+		{
+			name:              "response_with_default",
+			prompt:            "int",
+			args:              []int64{1},
+			stdinStr:          "2\n",
+			expectedStdoutStr: "int (default 1)? ",
+			expected:          2,
+		},
+		{
+			name:              "no_response_with_default",
+			prompt:            "int",
+			args:              []int64{1},
+			stdinStr:          "\n",
+			expectedStdoutStr: "int (default 1)? ",
+			expected:          1,
+		},
+		{
+			name:        "invalid_response",
+			stdinStr:    "invalid\n",
+			expectedErr: true,
+		},
+		{
+			name:        "invalid_response_with_default",
+			args:        []int64{1},
+			stdinStr:    "invalid\n",
+			expectedErr: true,
+		},
+		{
+			name:        "too_many_args",
+			prompt:      "bool",
+			args:        []int64{0, 0},
+			stdinStr:    "\n",
+			expectedErr: true,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			stdin := strings.NewReader(tc.stdinStr)
+			stdout := &strings.Builder{}
+			config, err := newConfig(
+				withStdin(stdin),
+				withStdout(stdout),
+			)
+			require.NoError(t, err)
+			if tc.expectedErr {
+				assert.Panics(t, func() {
+					config.promptInt(tc.prompt, tc.args...)
+				})
+			} else {
+				assert.Equal(t, tc.expected, config.promptInt(tc.prompt, tc.args...))
+				assert.Equal(t, tc.expectedStdoutStr, stdout.String())
+			}
+		})
+	}
+}

internal/cmd/testdata/scripts/executetemplate.txt

@@ -56,6 +56,10 @@ stdout 1
 ! chezmoi execute-template --promptInt value=error
 stderr 'invalid syntax'
 
+# test --init --promptInt with a default value
+chezmoi execute-template --init '{{ promptInt "value" 1 }}'
+stdout 1
+
 # test --init --promptString
 chezmoi execute-template --init --promptString email=user@example.com '{{ promptString "email" }}'
 stdout 'user@example.com'