Fail early when custom templates are used with urfave_cli_no_template

With urfave_cli_no_template tag, custom templates are not supported,
but using them results in a working binary which just prints an error
instead of help. Make such misuse fail as early as possible:

 - with the tag, make RootCommandHelpTemplate, CommandHelpTemplate,
   SubcommandHelpTemplate and FishCompletionTemplate constants, so an
   attempt to modify them results in a compile error;

 - with the tag, return an error from Run if CustomRootCommandHelpTemplate
   or CustomHelpTemplate is set for any command.

The only remaining case is calling DefaultPrintHelpCustom with a custom
template, which still prints an error instead of help.

To keep the template text in one place, the default values are now
defined as unexported constants, which the exported variables (or, with
the tag, constants) are initialized from.

Signed-off-by: Kir Kolyshkin <kolyshkin@gmail.com>

Author: kolyshkin

command_run.go

@@ -111,6 +111,9 @@ func (cmd *Command) run(ctx context.Context, osArgs []string) (_ context.Context
 	}
 
 	if cmd.parent == nil {
+		if err := checkNoCustomTemplates(cmd); err != nil {
+			return ctx, err
+		}
 		if cmd.ReadArgsFromStdin {
 			if args, err := cmd.parseArgsFromStdin(); err != nil {
 				return ctx, err

docs/v3/binary-size.md

@@ -164,11 +164,17 @@ For larger programs, this can noticeably increase the binary size.
 
 With the `urfave_cli_no_template` build tag, the default help and fish
 completion are rendered without `text/template`, producing the same output.
-Custom templates (`CustomRootCommandHelpTemplate`, `CustomHelpTemplate`,
-modified `RootCommandHelpTemplate` etc.) are not supported in this mode:
-instead of help, an error is printed to `ErrWriter`, and `ToFishCompletion`
-returns an error. Custom template functions other than `wrap` and `wrapAt`
-are ignored.
+Custom templates are not supported in this mode:
+
+- `RootCommandHelpTemplate`, `CommandHelpTemplate`, `SubcommandHelpTemplate`
+  and `FishCompletionTemplate` are constants, so modifying them results in
+  a compile error;
+- if `CustomRootCommandHelpTemplate` or `CustomHelpTemplate` is set for any
+  command, `Run` returns an error;
+- if `DefaultPrintHelpCustom` is called with a custom template, an error is
+  printed to `ErrWriter` instead of help.
+
+Custom template functions other than `wrap` and `wrapAt` are ignored.
 
 ```sh-session
 go build -tags urfave_cli_no_template -o myapp ./cmd/myapp

examples_template_test.go

@@ -37,3 +37,44 @@ func ExampleCommand_Suggest() {
 	//
 	// (this space intentionally left blank)
 }
+
+func ExampleCommand_Suggest_command() {
+	cmd := &cli.Command{
+		ErrWriter: os.Stdout,
+		Name:      "greet",
+		Flags: []cli.Flag{
+			&cli.StringFlag{Name: "name", Value: "squirrel", Usage: "a name to say"},
+		},
+		Action: func(_ context.Context, cmd *cli.Command) error {
+			fmt.Printf("Hello %v\n", cmd.String("name"))
+			return nil
+		},
+		Commands: []*cli.Command{
+			{
+				Name:               "neighbors",
+				HideHelp:           true,
+				HideHelpCommand:    true,
+				Suggest:            true,
+				CustomHelpTemplate: "(this space intentionally left blank)\n",
+				Flags: []cli.Flag{
+					&cli.BoolFlag{Name: "smiling"},
+				},
+				Action: func(_ context.Context, cmd *cli.Command) error {
+					if cmd.Bool("smiling") {
+						fmt.Println("😀")
+					}
+					fmt.Println("Hello, neighbors")
+					return nil
+				},
+			},
+		},
+	}
+
+	if cmd.Run(context.Background(), []string{"greet", "neighbors", "--sliming"}) == nil {
+		fmt.Println("Expected error")
+	}
+	// Output:
+	// Incorrect Usage: flag provided but not defined: -sliming
+	//
+	// Did you mean "--smiling"?
+}

examples_test.go

@@ -539,44 +539,3 @@ func ExampleBoolWithInverseFlag() {
 	// no-env is set
 	// flags: 2
 }
-
-func ExampleCommand_Suggest_command() {
-	cmd := &cli.Command{
-		ErrWriter: os.Stdout,
-		Name:      "greet",
-		Flags: []cli.Flag{
-			&cli.StringFlag{Name: "name", Value: "squirrel", Usage: "a name to say"},
-		},
-		Action: func(_ context.Context, cmd *cli.Command) error {
-			fmt.Printf("Hello %v\n", cmd.String("name"))
-			return nil
-		},
-		Commands: []*cli.Command{
-			{
-				Name:               "neighbors",
-				HideHelp:           true,
-				HideHelpCommand:    true,
-				Suggest:            true,
-				CustomHelpTemplate: "(this space intentionally left blank)\n",
-				Flags: []cli.Flag{
-					&cli.BoolFlag{Name: "smiling"},
-				},
-				Action: func(_ context.Context, cmd *cli.Command) error {
-					if cmd.Bool("smiling") {
-						fmt.Println("😀")
-					}
-					fmt.Println("Hello, neighbors")
-					return nil
-				},
-			},
-		},
-	}
-
-	if cmd.Run(context.Background(), []string{"greet", "neighbors", "--sliming"}) == nil {
-		fmt.Println("Expected error")
-	}
-	// Output:
-	// Incorrect Usage: flag provided but not defined: -sliming
-	//
-	// Did you mean "--smiling"?
-}

fish_template_test.go

@@ -0,0 +1,17 @@
+//go:build !urfave_cli_no_template
+
+package cli
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFishCompletionTemplateError(t *testing.T) {
+	defer func(old string) { FishCompletionTemplate = old }(FishCompletionTemplate)
+	FishCompletionTemplate = "{{something"
+
+	_, err := buildExtendedTestCommand().ToFishCompletion()
+	assert.Error(t, err)
+}

fish_test.go

@@ -23,16 +23,6 @@ func TestFishCompletion(t *testing.T) {
 		})
 	cmd.setupCommandGraph()
 
-	oldTemplate := FishCompletionTemplate
-	defer func() { FishCompletionTemplate = oldTemplate }()
-	FishCompletionTemplate = "{{something"
-
-	// test error case
-	_, err1 := cmd.ToFishCompletion()
-	assert.Error(t, err1)
-
-	// reset the template
-	FishCompletionTemplate = oldTemplate
 	// When
 	res, err := cmd.ToFishCompletion()
 

godoc-current.txt

@@ -61,24 +61,7 @@ var ArgsUsageCommandHelp = "[command]"
     ArgsUsageCommandHelp is a short description of the arguments of the help
     command
 
-var CommandHelpTemplate = `NAME:
-   {{template "helpNameTemplate" .}}
-
-USAGE:
-   {{template "usageTemplate" .}}{{if .Category}}
-
-CATEGORY:
-   {{.Category}}{{end}}{{if .Description}}
-
-DESCRIPTION:
-   {{template "descriptionTemplate" .}}{{end}}{{if .VisibleFlagCategories}}
-
-OPTIONS:{{template "visibleFlagCategoryTemplate" .}}{{else if .VisibleFlags}}
-
-OPTIONS:{{template "visibleFlagTemplate" .}}{{end}}{{if .VisiblePersistentFlags}}
-
-GLOBAL OPTIONS:{{template "visiblePersistentFlagTemplate" .}}{{end}}
-`
+var CommandHelpTemplate = commandHelpTemplate
     CommandHelpTemplate is the text template for the command help topic. cli.go
     uses text/template to render templates. You can render custom help text by
     setting this variable.
@@ -92,49 +75,16 @@ var ErrWriter io.Writer = os.Stderr
     ErrWriter is used to write errors to the user. This can be anything
     implementing the io.Writer interface and defaults to os.Stderr.
 
-var FishCompletionTemplate = `# {{ .Command.Name }} fish shell completion
+var FishCompletionTemplate = fishCompletionTemplate
+    FishCompletionTemplate is the text template for fish shell completion.
 
-function __fish_{{ .Command.Name }}_no_subcommand --description 'Test if there has been any subcommand yet'
-    for i in (commandline -opc)
-        if contains -- $i{{ range $v := .AllCommands }} {{ $v }}{{ end }}
-            return 1
-        end
-    end
-    return 0
-end
-
-{{ range $v := .Completions }}{{ $v }}
-{{ end }}`
 var NewStringMap = NewMapBase[string, StringConfig, stringValue]
 var NewStringSlice = NewSliceBase[string, StringConfig, stringValue]
 var OsExiter = os.Exit
     OsExiter is the function used when the app exits. If not set defaults to
     os.Exit.
 
-var RootCommandHelpTemplate = `NAME:
-   {{template "helpNameTemplate" .}}
-
-USAGE:
-   {{if .UsageText}}{{wrap .UsageText 3}}{{else}}{{.FullName}} {{if .VisibleFlags}}[global options]{{end}}{{if .VisibleCommands}} [command [command options]]{{end}}{{if .ArgsUsage}} {{.ArgsUsage}}{{else}}{{if .Arguments}} [arguments...]{{end}}{{end}}{{end}}{{if .Version}}{{if not .HideVersion}}
-
-VERSION:
-   {{.Version}}{{end}}{{end}}{{if .Description}}
-
-DESCRIPTION:
-   {{template "descriptionTemplate" .}}{{end}}
-{{- if len .Authors}}
-
-AUTHOR{{template "authorsTemplate" .}}{{end}}{{if .VisibleCommands}}
-
-COMMANDS:{{template "visibleCommandCategoryTemplate" .}}{{end}}{{if .VisibleFlagCategories}}
-
-GLOBAL OPTIONS:{{template "visibleFlagCategoryTemplate" .}}{{else if .VisibleFlags}}
-
-GLOBAL OPTIONS:{{template "visibleFlagTemplate" .}}{{end}}{{if .Copyright}}
-
-COPYRIGHT:
-   {{template "copyrightTemplate" .}}{{end}}
-`
+var RootCommandHelpTemplate = rootCommandHelpTemplate
     RootCommandHelpTemplate is the text template for the Default help topic.
     cli.go uses text/template to render templates. You can render custom help
     text by setting this variable.
@@ -154,26 +104,7 @@ var ShowRootCommandHelp = DefaultShowRootCommandHelp
 var ShowSubcommandHelp = DefaultShowSubcommandHelp
     ShowSubcommandHelp prints help for the given subcommand
 
-var SubcommandHelpTemplate = `NAME:
-   {{template "helpNameTemplate" .}}
-
-USAGE:
-   {{if .UsageText}}{{wrap .UsageText 3}}{{else}}{{.FullName}}{{if .VisibleCommands}} [command [command options]]{{end}}{{if .ArgsUsage}} {{.ArgsUsage}}{{else}}{{if .Arguments}} [arguments...]{{end}}{{end}}{{end}}{{if .Category}}
-
-CATEGORY:
-   {{.Category}}{{end}}{{if .Description}}
-
-DESCRIPTION:
-   {{template "descriptionTemplate" .}}{{end}}{{if .VisibleCommands}}
-
-COMMANDS:{{template "visibleCommandTemplate" .}}{{end}}{{if .VisibleFlagCategories}}
-
-OPTIONS:{{template "visibleFlagCategoryTemplate" .}}{{else if .VisibleFlags}}
-
-OPTIONS:{{template "visibleFlagTemplate" .}}{{end}}{{if .VisiblePersistentFlags}}
-
-GLOBAL OPTIONS:{{template "visiblePersistentFlagTemplate" .}}{{end}}
-`
+var SubcommandHelpTemplate = subcommandHelpTemplate
     SubcommandHelpTemplate is the text template for the subcommand help topic.
     cli.go uses text/template to render templates. You can render custom help
     text by setting this variable.

help_notemplate.go

@@ -14,14 +14,17 @@ import (
 // templatesSupported is true unless built with the urfave_cli_no_template tag.
 const templatesSupported = false
 
-// Default template values, used to recognize which help is being requested.
-// Package-level variable initialization happens before any init function,
-// so these are the values before any modifications by the user.
-var (
-	defaultRootCommandHelpTemplate = RootCommandHelpTemplate
-	defaultCommandHelpTemplate     = CommandHelpTemplate
-	defaultSubcommandHelpTemplate  = SubcommandHelpTemplate
-	defaultFishCompletionTemplate  = FishCompletionTemplate
+// With urfave_cli_no_template tag, the default templates are constants,
+// so an attempt to modify them results in a compile error.
+const (
+	// RootCommandHelpTemplate is the text template for the Default help topic.
+	RootCommandHelpTemplate = rootCommandHelpTemplate
+	// CommandHelpTemplate is the text template for the command help topic.
+	CommandHelpTemplate = commandHelpTemplate
+	// SubcommandHelpTemplate is the text template for the subcommand help topic.
+	SubcommandHelpTemplate = subcommandHelpTemplate
+	// FishCompletionTemplate is the text template for fish shell completion.
+	FishCompletionTemplate = fishCompletionTemplate
 )
 
 var errNoTemplate = errors.New("custom templates are not supported when built with urfave_cli_no_template tag")
@@ -62,11 +65,11 @@ func DefaultPrintHelpCustom(out io.Writer, templ string, data any, customFuncs m
 	}
 
 	switch templ {
-	case defaultRootCommandHelpTemplate:
+	case RootCommandHelpTemplate:
 		h.root()
-	case defaultCommandHelpTemplate:
+	case CommandHelpTemplate:
 		h.command()
-	case defaultSubcommandHelpTemplate:
+	case SubcommandHelpTemplate:
 		h.subcommand()
 	default:
 		reportNoTemplate(cmd)
@@ -79,6 +82,20 @@ func DefaultPrintHelpCustom(out io.Writer, templ string, data any, customFuncs m
 	_ = w.Flush()
 }
 
+// checkNoCustomTemplates returns an error if cmd or any of its subcommands
+// has a custom help template set, as these are not supported.
+func checkNoCustomTemplates(cmd *Command) error {
+	if cmd.CustomRootCommandHelpTemplate != "" || cmd.CustomHelpTemplate != "" {
+		return fmt.Errorf("command %q: %w", cmd.Name, errNoTemplate)
+	}
+	for _, sub := range cmd.Commands {
+		if err := checkNoCustomTemplates(sub); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // reportNoTemplate reports that a custom template can't be used,
 // so it's not silently ignored.
 func reportNoTemplate(cmd *Command) {
@@ -324,10 +341,6 @@ func printableValue(v any) string {
 }
 
 func renderFishCompletion(w io.Writer, data *fishCommandCompletionTemplate) error {
-	if FishCompletionTemplate != defaultFishCompletionTemplate {
-		return errNoTemplate
-	}
-
 	name := data.Command.Name
 	var b strings.Builder
 	b.WriteString("# " + name + " fish shell completion\n\n" +