flags : return HelpError and print at the callsite

flags/flags.go

@@ -155,17 +155,19 @@ func expandOpts(opts any) []Flag {
 }
 
 // internal for type safety testing
-func parseArgsInternal(sub cmd.Subcommand, summary string, args []string, opts any, flags []Flag) {
+func parseArgsInternal(sub cmd.Subcommand, summary string, args []string, opts any, flags []Flag) error {
 argloop:
 	for i := 0; i < len(args); i++ {
 		arg := args[i]
 		for j, f := range flags {
 			if f.Match(arg, i, j) {
 				if f.IsHelp() {
-					Help(sub, summary, opts)
+					// so Help.Val is true to avoid confusion:
+					f.Set(arg)
+					return Help(sub, summary, opts)
 				}
 				if !f.Valid(args, i) {
-					HelpMissingAssignment(sub, arg)
+					return HelpMissingAssignment(sub, arg)
 				}
 				i = f.MaybeIncrement(i)
 				f.Set(args[i])
@@ -173,13 +175,13 @@ argloop:
 			}
 		}
 		// NOTE: if we didn't skip ahead, arg didn't match:
-		HelpInvalidArg(sub, arg)
-		Help(sub, summary, opts)
+		return HelpInvalidArg(sub, arg)
 	}
+	return nil
 }
 
 // assign values of args to opts struct using Flag interface methods
-func ParseArgs(sub cmd.Subcommand, summary string, args []string, opts any) {
+func ParseArgs(sub cmd.Subcommand, summary string, args []string, opts any) error {
 	flags := expandOpts(opts)
-	parseArgsInternal(sub, summary, args, opts, flags)
+	return parseArgsInternal(sub, summary, args, opts, flags)
 }

flags/flags_test.go

@@ -46,11 +46,20 @@ func TestParseArgsInternal(t *testing.T) {
 
 }
 
-// TODO: return errors from Help routines and print at top level, so I can test those cases
+func TestParseArgsHelp(t *testing.T) {
+	args := []string{"--help"}
+	opts := initOpts()
+	err := ParseArgs(CMD, SUMMARY, args, &opts)
+	assert.ErrorContains(t, err, "um TEST [descriptor] [tags] [--source] [--write]\n\nSUMMARY")
+	// we set the Val true although we don't expect to use it:
+	assert.True(t, opts.Help.Val)
+}
+
 func TestParseArgsString(t *testing.T) {
 	args := []string{"--source", "foo"}
 	opts := initOpts()
-	ParseArgs(CMD, SUMMARY, args, &opts)
+	err := ParseArgs(CMD, SUMMARY, args, &opts)
+	assert.NoError(t, err)
 	assert.Equal(t, opts.Source.Val, "foo")
 }
 
@@ -73,7 +82,8 @@ func TestParseArgs(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			ParseArgs(CMD, SUMMARY, tc.args, &opts)
+			err := ParseArgs(CMD, SUMMARY, tc.args, &opts)
+			assert.NoError(t, err)
 			if tc.boolVal != nil {
 				assert.True(t, *tc.boolVal)
 			}

flags/help.go

@@ -1,9 +1,8 @@
 package flags
 
 import (
+	"bytes"
 	"fmt"
-	"log"
-	"os"
 	"reflect"
 	"strings"
 	"text/tabwriter"
@@ -11,30 +10,43 @@ import (
 	"github.com/brtholomy/um/go/cmd"
 )
 
-func HelpRequired(sub cmd.Subcommand, long string) {
-	log.Printf("um %s: %s is required", sub, long)
+type HelpError struct {
+	message string
 }
 
-func HelpInvalidArg(sub cmd.Subcommand, arg string) {
-	log.Printf("um %s: invalid argument: %s", sub, arg)
+func (h HelpError) Error() string {
+	return h.message
 }
 
-func HelpMissingAssignment(sub cmd.Subcommand, arg string) {
-	log.Printf("um %s: %s needs a value assignment\n", sub, arg)
-	log.Fatal("try: um [cmd] --help")
+func HelpRequired(sub cmd.Subcommand, long string) error {
+	return HelpError{
+		fmt.Sprintf("um %s: %s is required", sub, long),
+	}
+}
+
+func HelpInvalidArg(sub cmd.Subcommand, arg string) error {
+	return HelpError{
+		fmt.Sprintf("um %s: invalid argument: %s", sub, arg),
+	}
+}
+
+func HelpMissingAssignment(sub cmd.Subcommand, arg string) error {
+	return HelpError{
+		fmt.Sprintf("um %s: %s needs a value assignment", sub, arg),
+	}
 }
 
 // print out help string by reflecting over fields of provided opts struct
 // and os.Exit(0)
-func Help(sub cmd.Subcommand, summary string, opts any) {
+func Help(sub cmd.Subcommand, summary string, opts any) error {
 	v := reflect.ValueOf(opts)
 	if v.Kind() == reflect.Ptr {
 		v = v.Elem()
 	}
 	t := v.Type()
 
-	// everything should go to either stderr or stdout:
-	w := tabwriter.NewWriter(os.Stderr, 0, 0, 3, ' ', 0)
+	buf := &bytes.Buffer{}
+	w := tabwriter.NewWriter(buf, 0, 0, 3, ' ', 0)
 	positional := ""
 
 	for i := 0; i < v.NumField(); i++ {
@@ -56,8 +68,9 @@ func Help(sub cmd.Subcommand, summary string, opts any) {
 			)
 		}
 	}
-	log.Printf("um %s%s\n\n", sub, positional)
-	log.Printf("%s\n\n", summary)
+	if _, err := buf.WriteString(fmt.Sprintf("um %s%s\n\n%s\n\n", sub, positional, summary)); err != nil {
+		return err
+	}
 	w.Flush()
-	os.Exit(0)
+	return HelpError{buf.String()}
 }