cli-plugins/hooks: add commandInfo type for templating

Define a local type for methods to expose to the template, instead of
passing the cobra.Cmd. This avoids templates depending on features
exposed by Cobra that are not part of the contract, and slightly
decouples the templat from the Cobra implementation.

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

Author: thaJeztah

cli-plugins/hooks/hook_utils.go

@@ -6,8 +6,8 @@ import (
 
 const (
 	hookTemplateCommandName = `{{.Name}}`
-	hookTemplateFlagValue   = `{{flag . %q}}`
-	hookTemplateArg         = `{{arg . %d}}`
+	hookTemplateFlagValue   = `{{.FlagValue %q}}`
+	hookTemplateArg         = `{{.Arg %d}}`
 )
 
 // TemplateReplaceSubcommandName returns a hook template string

cli-plugins/hooks/hooks_utils_test.go

@@ -22,21 +22,21 @@ func TestTemplateHelpers(t *testing.T) {
 			got: func() string {
 				return hooks.TemplateReplaceFlagValue("name")
 			},
-			want: `{{flag . "name"}}`,
+			want: `{{.FlagValue "name"}}`,
 		},
 		{
 			doc: "arg",
 			got: func() string {
 				return hooks.TemplateReplaceArg(0)
 			},
-			want: `{{arg . 0}}`,
+			want: `{{.Arg 0}}`,
 		},
 		{
 			doc: "arg",
 			got: func() string {
 				return hooks.TemplateReplaceArg(3)
 			},
-			want: `{{arg . 3}}`,
+			want: `{{.Arg 3}}`,
 		},
 	}
 

cli-plugins/hooks/template.go

@@ -3,6 +3,7 @@ package hooks
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"strings"
 	"text/template"
 
@@ -13,13 +14,18 @@ func ParseTemplate(hookTemplate string, cmd *cobra.Command) ([]string, error) {
 	out := hookTemplate
 	if strings.Contains(hookTemplate, "{{") {
 		// Message may be a template.
-		tmpl := template.New("").Funcs(commandFunctions)
-		tmpl, err := tmpl.Parse(hookTemplate)
+		msgContext := commandInfo{cmd: cmd}
+
+		tmpl, err := template.New("").Funcs(template.FuncMap{
+			// kept for backward-compatibility with old templates.
+			"flag": func(_ any, flagName string) (string, error) { return msgContext.FlagValue(flagName) },
+			"arg":  func(_ any, i int) (string, error) { return msgContext.Arg(i) },
+		}).Parse(hookTemplate)
 		if err != nil {
 			return nil, err
 		}
 		var b bytes.Buffer
-		err = tmpl.Execute(&b, cmd)
+		err = tmpl.Execute(&b, msgContext)
 		if err != nil {
 			return nil, err
 		}
@@ -30,23 +36,43 @@ func ParseTemplate(hookTemplate string, cmd *cobra.Command) ([]string, error) {
 
 var ErrHookTemplateParse = errors.New("failed to parse hook template")
 
-var commandFunctions = template.FuncMap{
-	"flag": getFlagValue,
-	"arg":  getArgValue,
+// commandInfo provides info about the command for which the hook was invoked.
+// It is used for templated hook-messages.
+type commandInfo struct {
+	cmd *cobra.Command
+}
+
+// Name returns the name of the (sub)command for which the hook was invoked.
+//
+// It's used for backward-compatibility with old templates.
+func (c commandInfo) Name() string {
+	if c.cmd == nil {
+		return ""
+	}
+	return c.cmd.Name()
 }
 
-func getFlagValue(cmd *cobra.Command, flag string) (string, error) {
-	cmdFlag := cmd.Flag(flag)
-	if cmdFlag == nil {
-		return "", ErrHookTemplateParse
+// FlagValue returns the value that was set for the given flag when the hook was invoked.
+func (c commandInfo) FlagValue(flagName string) (string, error) {
+	if c.cmd == nil {
+		return "", fmt.Errorf("%w: flagValue: cmd is nil", ErrHookTemplateParse)
+	}
+	f := c.cmd.Flag(flagName)
+	if f == nil {
+		return "", fmt.Errorf("%w: flagValue: no flags found", ErrHookTemplateParse)
 	}
-	return cmdFlag.Value.String(), nil
+	return f.Value.String(), nil
 }
 
-func getArgValue(cmd *cobra.Command, i int) (string, error) {
-	flags := cmd.Flags()
-	if flags == nil {
-		return "", ErrHookTemplateParse
+// Arg returns the value of the nth argument.
+func (c commandInfo) Arg(n int) (string, error) {
+	if c.cmd == nil {
+		return "", fmt.Errorf("%w: arg: cmd is nil", ErrHookTemplateParse)
+	}
+	flags := c.cmd.Flags()
+	v := flags.Arg(n)
+	if v == "" && n >= flags.NArg() {
+		return "", fmt.Errorf("%w: arg: %dth argument not set", ErrHookTemplateParse, n)
 	}
-	return flags.Arg(i), nil
+	return v, nil
 }