feat: Add chezmoi:template:format-indent template directive

assets/chezmoi.io/docs/reference/templates/directives.md

@@ -37,6 +37,33 @@ inherited by templates called from the file.
     # [[ "true" ]]
     ```
 
+## Format indent
+
+By default, chezmoi's `toJson`, `toToml`, and `toYaml` template functions use
+the default indent of two spaces. The indent can be overidden with:
+
+    chezmoi:template:format-indent=$STRING
+
+to set the indent to be the literal `$STRING`, or
+
+    chezmoi:template:format-indent-width=$WIDTH
+
+to set the indent to be `$WIDTH` spaces.
+
+!!! example
+
+    ```
+    {{/* chezmoi:template:format-indent="\t" */}}
+    {{ dict "key" "value" | toJson }}
+    ```
+
+!!! example
+
+    ```
+    {{/* chezmoi:template:format-indent-width=4 */}}
+    {{ dict "key" "value" | toYaml }}
+    ```
+
 ## Line endings
 
 Many of the template functions available in chezmoi primarily use UNIX-style

go.mod

@@ -26,6 +26,7 @@ require (
 	github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79
 	github.com/itchyny/gojq v0.12.17
 	github.com/klauspost/compress v1.17.11
+	github.com/mattn/go-runewidth v0.0.16
 	github.com/mitchellh/copystructure v1.2.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/muesli/combinator v0.3.0
@@ -131,7 +132,6 @@ require (
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-localereader v0.0.1 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/microcosm-cc/bluemonday v1.0.27 // indirect
 	github.com/mitchellh/reflectwalk v1.0.2 // indirect
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect

internal/chezmoi/sourcestate.go

@@ -798,9 +798,10 @@ type ExecuteTemplateDataOptions struct {
 // ExecuteTemplateData returns the result of executing template data.
 func (s *SourceState) ExecuteTemplateData(options ExecuteTemplateDataOptions) ([]byte, error) {
 	templateOptions := options.TemplateOptions
+	templateOptions.Funcs = s.templateFuncs
 	templateOptions.Options = slices.Clone(s.templateOptions)
 
-	tmpl, err := ParseTemplate(options.Name, options.Data, s.templateFuncs, templateOptions)
+	tmpl, err := ParseTemplate(options.Name, options.Data, templateOptions)
 	if err != nil {
 		return nil, err
 	}
@@ -1529,7 +1530,8 @@ func (s *SourceState) addTemplatesDir(ctx context.Context, templatesDirAbsPath A
 			templateRelPath := templateAbsPath.MustTrimDirPrefix(templatesDirAbsPath)
 			name := templateRelPath.String()
 
-			tmpl, err := ParseTemplate(name, contents, s.templateFuncs, TemplateOptions{
+			tmpl, err := ParseTemplate(name, contents, TemplateOptions{
+				Funcs:   s.templateFuncs,
 				Options: slices.Clone(s.templateOptions),
 			})
 			if err != nil {
@@ -1955,14 +1957,10 @@ func (s *SourceState) newModifyTargetStateEntryFunc(
 				sourceFile := sourceRelPath.String()
 				templateContents := removeMatches(modifierContents, matches)
 				var tmpl *Template
-				tmpl, err = ParseTemplate(
-					sourceFile,
-					templateContents,
-					s.templateFuncs,
-					TemplateOptions{
-						Options: slices.Clone(s.templateOptions),
-					},
-				)
+				tmpl, err = ParseTemplate(sourceFile, templateContents, TemplateOptions{
+					Funcs:   s.templateFuncs,
+					Options: slices.Clone(s.templateOptions),
+				})
 				if err != nil {
 					return
 				}

internal/chezmoi/sourcestate_test.go

@@ -1798,6 +1798,7 @@ func TestTemplateOptionsParseDirectives(t *testing.T) {
 		name            string
 		dataStr         string
 		expected        TemplateOptions
+		expectedErr     string
 		expectedDataStr string
 	}{
 		{
@@ -1957,12 +1958,36 @@ func TestTemplateOptionsParseDirectives(t *testing.T) {
 				LineEnding: "\n",
 			},
 		},
+		{
+			name:    "format_indent_string",
+			dataStr: `chezmoi:template:format-indent="\t"`,
+			expected: TemplateOptions{
+				FormatIndent: "\t",
+			},
+		},
+		{
+			name:    "format_indent_width_number",
+			dataStr: `chezmoi:template:format-indent-width=2`,
+			expected: TemplateOptions{
+				FormatIndent: "  ",
+			},
+		},
+		{
+			name:        "format_indent_width_number_error",
+			dataStr:     `chezmoi:template:format-indent-width=x`,
+			expectedErr: `strconv.Atoi: parsing "x": invalid syntax`,
+		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			var actual TemplateOptions
-			actualData := actual.parseAndRemoveDirectives([]byte(tc.dataStr))
-			assert.Equal(t, tc.expected, actual)
-			assert.Equal(t, tc.expectedDataStr, string(actualData))
+			actualData, err := actual.parseAndRemoveDirectives([]byte(tc.dataStr))
+			if tc.expectedErr != "" {
+				assert.EqualError(t, err, tc.expectedErr)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tc.expected, actual)
+				assert.Equal(t, tc.expectedDataStr, string(actualData))
+			}
 		})
 	}
 }

internal/chezmoi/template.go

@@ -2,10 +2,16 @@ package chezmoi
 
 import (
 	"bytes"
+	"encoding/json"
+	"maps"
+	"strconv"
 	"strings"
 	"text/template"
 
+	"github.com/mattn/go-runewidth"
 	"github.com/mitchellh/copystructure"
+	"github.com/pelletier/go-toml/v2"
+	"gopkg.in/yaml.v3"
 )
 
 // A Template extends text/template.Template with support for directives.
@@ -17,6 +23,8 @@ type Template struct {
 
 // TemplateOptions are template options that can be set with directives.
 type TemplateOptions struct {
+	Funcs          template.FuncMap
+	FormatIndent   string
 	LeftDelimiter  string
 	LineEnding     string
 	RightDelimiter string
@@ -25,8 +33,42 @@ type TemplateOptions struct {
 
 // ParseTemplate parses a template named name from data with the given funcs and
 // templateOptions.
-func ParseTemplate(name string, data []byte, funcs template.FuncMap, options TemplateOptions) (*Template, error) {
-	contents := options.parseAndRemoveDirectives(data)
+func ParseTemplate(name string, data []byte, options TemplateOptions) (*Template, error) {
+	contents, err := options.parseAndRemoveDirectives(data)
+	if err != nil {
+		return nil, err
+	}
+	funcs := options.Funcs
+	if options.FormatIndent != "" {
+		funcs = maps.Clone(funcs)
+		funcs["toJson"] = func(data any) string {
+			var builder strings.Builder
+			encoder := json.NewEncoder(&builder)
+			encoder.SetIndent("", options.FormatIndent)
+			if err := encoder.Encode(data); err != nil {
+				panic(err)
+			}
+			return builder.String()
+		}
+		funcs["toToml"] = func(data any) string {
+			var builder strings.Builder
+			encoder := toml.NewEncoder(&builder)
+			encoder.SetIndentSymbol(options.FormatIndent)
+			if err := encoder.Encode(data); err != nil {
+				panic(err)
+			}
+			return builder.String()
+		}
+		funcs["toYaml"] = func(data any) string {
+			var builder strings.Builder
+			encoder := yaml.NewEncoder(&builder)
+			encoder.SetIndent(runewidth.StringWidth(options.FormatIndent))
+			if err := encoder.Encode(data); err != nil {
+				panic(err)
+			}
+			return builder.String()
+		}
+	}
 	tmpl, err := template.New(name).
 		Option(options.Options...).
 		Delims(options.LeftDelimiter, options.RightDelimiter).
@@ -70,10 +112,10 @@ func (t *Template) Execute(data any) ([]byte, error) {
 // parseAndRemoveDirectives updates o by parsing all template directives in data
 // and returns data with the lines containing directives removed. The lines are
 // removed so that any delimiters do not break template parsing.
-func (o *TemplateOptions) parseAndRemoveDirectives(data []byte) []byte {
+func (o *TemplateOptions) parseAndRemoveDirectives(data []byte) ([]byte, error) {
 	directiveMatches := templateDirectiveRx.FindAllSubmatchIndex(data, -1)
 	if directiveMatches == nil {
-		return data
+		return data, nil
 	}
 
 	// Parse options from directives.
@@ -83,6 +125,14 @@ func (o *TemplateOptions) parseAndRemoveDirectives(data []byte) []byte {
 			key := string(keyValuePairMatch[1])
 			value := maybeUnquote(string(keyValuePairMatch[2]))
 			switch key {
+			case "format-indent":
+				o.FormatIndent = value
+			case "format-indent-width":
+				width, err := strconv.Atoi(value)
+				if err != nil {
+					return nil, err
+				}
+				o.FormatIndent = strings.Repeat(" ", width)
 			case "left-delimiter":
 				o.LeftDelimiter = value
 			case "line-ending", "line-endings":
@@ -104,7 +154,7 @@ func (o *TemplateOptions) parseAndRemoveDirectives(data []byte) []byte {
 		}
 	}
 
-	return removeMatches(data, directiveMatches)
+	return removeMatches(data, directiveMatches), nil
 }
 
 // removeMatches returns data with matchesIndexes removed.

internal/chezmoi/template_test.go

@@ -65,7 +65,7 @@ func TestTemplateParseAndExecute(t *testing.T) {
 		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
-			tmpl, err := ParseTemplate(tc.name, []byte(tc.dataStr), nil, TemplateOptions{})
+			tmpl, err := ParseTemplate(tc.name, []byte(tc.dataStr), TemplateOptions{})
 			assert.NoError(t, err)
 			actual, err := tmpl.Execute(nil)
 			assert.NoError(t, err)

internal/cmd/catcmd_test.go

@@ -36,6 +36,43 @@ func TestCatCmd(t *testing.T) {
 				"ok",
 			),
 		},
+		{
+			name: "json_indent",
+			root: map[string]any{
+				"/home/user/.local/share/chezmoi/dot_template.tmpl": chezmoitest.JoinLines(
+					`# chezmoi:template:format-indent-width=3`,
+					`{{ dict "a" (dict "b" "c") | toJson }}`,
+				),
+			},
+			args: []string{
+				"/home/user/.template",
+			},
+			expectedStr: chezmoitest.JoinLines(
+				`{`,
+				`   "a": {`,
+				`      "b": "c"`,
+				`   }`,
+				`}`,
+				``,
+			),
+		},
+		{
+			name: "yaml_indent",
+			root: map[string]any{
+				"/home/user/.local/share/chezmoi/dot_template.tmpl": chezmoitest.JoinLines(
+					`# chezmoi:template:format-indent-width=3`,
+					`{{ dict "a" (dict "b" "c") | toYaml }}`,
+				),
+			},
+			args: []string{
+				"/home/user/.template",
+			},
+			expectedStr: chezmoitest.JoinLines(
+				`a:`,
+				`   b: c`,
+				``,
+			),
+		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			chezmoitest.WithTestFS(t, tc.root, func(fileSystem vfs.FS) {

internal/cmd/config.go

@@ -873,7 +873,8 @@ func (c *Config) createConfigFile(filename chezmoi.RelPath, data []byte, cmd *co
 	}
 	chezmoi.RecursiveMerge(c.templateFuncs, initTemplateFuncs)
 
-	tmpl, err := chezmoi.ParseTemplate(filename.String(), data, c.templateFuncs, chezmoi.TemplateOptions{
+	tmpl, err := chezmoi.ParseTemplate(filename.String(), data, chezmoi.TemplateOptions{
+		Funcs:   c.templateFuncs,
 		Options: slices.Clone(c.Template.Options),
 	})
 	if err != nil {
@@ -1594,8 +1595,8 @@ func (c *Config) gitAutoPush(status *chezmoigit.Status) error {
 
 // gitCommitMessage returns the git commit message for the given status.
 func (c *Config) gitCommitMessage(cmd *cobra.Command, status *chezmoigit.Status) ([]byte, error) {
-	funcMap := maps.Clone(c.templateFuncs)
-	maps.Copy(funcMap, map[string]any{
+	templateFuncs := maps.Clone(c.templateFuncs)
+	maps.Copy(templateFuncs, map[string]any{
 		"promptBool":   c.promptBoolInteractiveTemplateFunc,
 		"promptChoice": c.promptChoiceInteractiveTemplateFunc,
 		"promptInt":    c.promptIntInteractiveTemplateFunc,
@@ -1625,7 +1626,8 @@ func (c *Config) gitCommitMessage(cmd *cobra.Command, status *chezmoigit.Status)
 		name = "COMMIT_MESSAGE"
 		commitMessageTemplateData = []byte(templates.CommitMessageTmpl)
 	}
-	commitMessageTmpl, err := chezmoi.ParseTemplate(name, commitMessageTemplateData, funcMap, chezmoi.TemplateOptions{
+	commitMessageTmpl, err := chezmoi.ParseTemplate(name, commitMessageTemplateData, chezmoi.TemplateOptions{
+		Funcs:   templateFuncs,
 		Options: slices.Clone(c.Template.Options),
 	})
 	if err != nil {

internal/cmd/templatefuncs.go

@@ -237,10 +237,10 @@ func (c *Config) includeTemplateTemplateFunc(filename string, args ...any) strin
 	}
 	contents := mustValue(c.readFile(filename, searchDirAbsPaths))
 
-	templateOptions := chezmoi.TemplateOptions{
+	tmpl := mustValue(chezmoi.ParseTemplate(filename, contents, chezmoi.TemplateOptions{
+		Funcs:   c.templateFuncs,
 		Options: slices.Clone(c.Template.Options),
-	}
-	tmpl := mustValue(chezmoi.ParseTemplate(filename, contents, c.templateFuncs, templateOptions))
+	}))
 
 	return string(mustValue(tmpl.Execute(data)))
 }