cli/command/formatter: add Format.templateString, remove Context.preFormat

The `Context.preFormat` method normalizes the Format as given by the user,
and handles (e.g.) stripping the "table" prefix and replacing the "json"
format for the actual format (`{{json .}}`).

The method used a `finalFormat` field on the Context as intermediate,
and was required to be called before executing the format.

This patch adds a `Format.templateString()` method that returns the
parsed format instead of storing it on the Context. It is currently
not exported, but something we could consider in future.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: thaJeztah

cli/command/formatter/disk_usage.go

@@ -46,7 +46,6 @@ func (ctx *DiskUsageContext) startSubsection(format Format) (*template.Template,
 	ctx.buffer = &bytes.Buffer{}
 	ctx.header = ""
 	ctx.Format = format
-	ctx.preFormat()
 
 	return ctx.parseFormat()
 }
@@ -88,7 +87,6 @@ func (ctx *DiskUsageContext) Write() (err error) {
 		return ctx.verboseWrite()
 	}
 	ctx.buffer = &bytes.Buffer{}
-	ctx.preFormat()
 
 	tmpl, err := ctx.parseFormat()
 	if err != nil {
@@ -213,7 +211,6 @@ func (ctx *DiskUsageContext) verboseWrite() error {
 		return ctx.verboseWriteTable(duc)
 	}
 
-	ctx.preFormat()
 	tmpl, err := ctx.parseFormat()
 	if err != nil {
 		return err

cli/command/formatter/formatter.go

@@ -33,7 +33,7 @@ func (f Format) IsTable() bool {
 	return strings.HasPrefix(string(f), TableFormatKey)
 }
 
-// IsJSON returns true if the format is the json format
+// IsJSON returns true if the format is the JSON format
 func (f Format) IsJSON() bool {
 	return string(f) == JSONFormatKey
 }
@@ -43,6 +43,31 @@ func (f Format) Contains(sub string) bool {
 	return strings.Contains(string(f), sub)
 }
 
+// templateString pre-processes the format and returns it as a string
+// for templating.
+func (f Format) templateString() string {
+	out := string(f)
+	switch out {
+	case TableFormatKey:
+		// A bare "--format table" should already be handled before we
+		// hit this; a literal "table" here means a custom "table" format
+		// without template.
+		return ""
+	case JSONFormatKey:
+		// "--format json" only; not JSON formats ("--format '{{json .Field}}'").
+		return JSONFormat
+	}
+
+	// "--format 'table {{.Field}}\t{{.Field}}'" -> "{{.Field}}\t{{.Field}}"
+	if after, isTable := strings.CutPrefix(out, TableFormatKey); isTable {
+		out = after
+	}
+
+	out = strings.Trim(out, " ") // trim spaces, but preserve other whitespace.
+	out = strings.NewReplacer(`\t`, "\t", `\n`, "\n").Replace(out)
+	return out
+}
+
 // Context contains information required by the formatter to print the output as desired.
 type Context struct {
 	// Output is the output stream to which the formatted string is written.
@@ -53,28 +78,12 @@ type Context struct {
 	Trunc bool
 
 	// internal element
-	finalFormat string
-	header      any
-	buffer      *bytes.Buffer
-}
-
-func (c *Context) preFormat() {
-	c.finalFormat = string(c.Format)
-	// TODO: handle this in the Format type
-	switch {
-	case c.Format.IsTable():
-		c.finalFormat = c.finalFormat[len(TableFormatKey):]
-	case c.Format.IsJSON():
-		c.finalFormat = JSONFormat
-	}
-
-	c.finalFormat = strings.Trim(c.finalFormat, " ")
-	r := strings.NewReplacer(`\t`, "\t", `\n`, "\n")
-	c.finalFormat = r.Replace(c.finalFormat)
+	header any
+	buffer *bytes.Buffer
 }
 
 func (c *Context) parseFormat() (*template.Template, error) {
-	tmpl, err := templates.Parse(c.finalFormat)
+	tmpl, err := templates.Parse(c.Format.templateString())
 	if err != nil {
 		return nil, fmt.Errorf("template parsing error: %w", err)
 	}
@@ -116,8 +125,6 @@ type SubFormat func(func(SubContext) error) error
 // Write the template to the buffer using this Context
 func (c *Context) Write(sub SubContext, f SubFormat) error {
 	c.buffer = &bytes.Buffer{}
-	c.preFormat()
-
 	tmpl, err := c.parseFormat()
 	if err != nil {
 		return err

cli/command/formatter/formatter_test.go

@@ -8,20 +8,75 @@ import (
 	"testing"
 
 	"gotest.tools/v3/assert"
+	is "gotest.tools/v3/assert/cmp"
 )
 
 func TestFormat(t *testing.T) {
-	f := Format("json")
-	assert.Assert(t, f.IsJSON())
-	assert.Assert(t, !f.IsTable())
-
-	f = Format("table")
-	assert.Assert(t, !f.IsJSON())
-	assert.Assert(t, f.IsTable())
+	tests := []struct {
+		doc      string
+		f        Format
+		isJSON   bool
+		isTable  bool
+		template string
+	}{
+		{
+			doc:      "json format",
+			f:        "json",
+			isJSON:   true,
+			isTable:  false,
+			template: JSONFormat,
+		},
+		{
+			doc:      "empty table format (no template)",
+			f:        "table",
+			isJSON:   false,
+			isTable:  true,
+			template: "",
+		},
+		{
+			doc:      "table with escaped tabs",
+			f:        "table {{.Field}}\\t{{.Field2}}",
+			isJSON:   false,
+			isTable:  true,
+			template: "{{.Field}}\t{{.Field2}}",
+		},
+		{
+			doc:      "table with raw string",
+			f:        `table {{.Field}}\t{{.Field2}}`,
+			isJSON:   false,
+			isTable:  true,
+			template: "{{.Field}}\t{{.Field2}}",
+		},
+		{
+			doc:      "other format",
+			f:        "other",
+			isJSON:   false,
+			isTable:  false,
+			template: "other",
+		},
+		{
+			doc:      "other with spaces",
+			f:        "   other   ",
+			isJSON:   false,
+			isTable:  false,
+			template: "other",
+		},
+		{
+			doc:      "other with newline preserved",
+			f:        "   other\n   ",
+			isJSON:   false,
+			isTable:  false,
+			template: "other\n",
+		},
+	}
 
-	f = Format("other")
-	assert.Assert(t, !f.IsJSON())
-	assert.Assert(t, !f.IsTable())
+	for _, tc := range tests {
+		t.Run(tc.doc, func(t *testing.T) {
+			assert.Check(t, is.Equal(tc.f.IsJSON(), tc.isJSON))
+			assert.Check(t, is.Equal(tc.f.IsTable(), tc.isTable))
+			assert.Check(t, is.Equal(tc.f.templateString(), tc.template))
+		})
+	}
 }
 
 type fakeSubContext struct {