help : HelpError holds cmd.Subcommand and summary : NewHelpError constructor

cat/cat.go

@@ -83,7 +83,8 @@ func cat(files []string, opts options) (string, error) {
 
 func Cat(args []string) {
 	opts := initOpts()
-	if err := flags.ParseArgs(CMD, SUMMARY, args, &opts); err != nil {
+	help := flags.NewHelpError(CMD, SUMMARY)
+	if err := flags.ParseArgs(help, args, &opts); err != nil {
 		var herr flags.HelpError
 		if errors.As(err, &herr) {
 			fmt.Println(herr)

flags/flags.go

@@ -4,8 +4,6 @@ import (
 	"log"
 	"reflect"
 	"strings"
-
-	"github.com/brtholomy/um/go/cmd"
 )
 
 const INTERNAL_ERR_PREFIX = "um internal err: ParseArgs"
@@ -155,7 +153,10 @@ func expandOpts(opts any) []Flag {
 }
 
 // internal for type safety testing
-func parseArgsInternal(sub cmd.Subcommand, summary string, args []string, opts any, flags []Flag) error {
+//
+// NOTE: we aren't currently returning any other kind of error, so keeping HelpError as error type
+// may be unnecessary, although it allows another err eventually.
+func parseArgsInternal(help HelpError, args []string, opts any, flags []Flag) error {
 argloop:
 	for i := 0; i < len(args); i++ {
 		arg := args[i]
@@ -164,10 +165,10 @@ argloop:
 				if f.IsHelp() {
 					// so Help.Val is true to avoid confusion:
 					f.Set(arg)
-					return Help(sub, summary, opts)
+					return help.Help(opts)
 				}
 				if !f.Valid(args, i) {
-					return HelpMissingAssignment(sub, arg)
+					return help.HelpMissingAssignment(arg)
 				}
 				i = f.MaybeIncrement(i)
 				f.Set(args[i])
@@ -175,13 +176,13 @@ argloop:
 			}
 		}
 		// NOTE: if we didn't skip ahead, arg didn't match:
-		return HelpInvalidArg(sub, arg)
+		return help.HelpInvalidArg(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) error {
+func ParseArgs(help HelpError, args []string, opts any) error {
 	flags := expandOpts(opts)
-	return parseArgsInternal(sub, summary, args, opts, flags)
+	return parseArgsInternal(help, args, opts, flags)
 }

flags/flags_test.go

@@ -11,6 +11,8 @@ const (
 	SUMMARY = "SUMMARY"
 )
 
+var helpErr = NewHelpError(CMD, SUMMARY)
+
 type options struct {
 	Descriptor Arg
 	Tags       Arg
@@ -38,7 +40,7 @@ func TestParseArgsInternal(t *testing.T) {
 		&Bool{"--help", "-h", false, "show help"},
 	}
 	args := []string{"--source", "foo"}
-	parseArgsInternal(CMD, SUMMARY, args, initOpts(), flags)
+	parseArgsInternal(helpErr, args, initOpts(), flags)
 	assert.False(t, flags[0].IsSet())
 	assert.False(t, flags[0].IsHelp())
 	assert.True(t, flags[2].IsSet())
@@ -49,7 +51,7 @@ func TestParseArgsInternal(t *testing.T) {
 func TestParseArgsHelp(t *testing.T) {
 	args := []string{"--help"}
 	opts := initOpts()
-	err := ParseArgs(CMD, SUMMARY, args, &opts)
+	err := ParseArgs(helpErr, 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)
@@ -58,7 +60,7 @@ func TestParseArgsHelp(t *testing.T) {
 func TestParseArgsString(t *testing.T) {
 	args := []string{"--source", "foo"}
 	opts := initOpts()
-	err := ParseArgs(CMD, SUMMARY, args, &opts)
+	err := ParseArgs(helpErr, args, &opts)
 	assert.NoError(t, err)
 	assert.Equal(t, opts.Source.Val, "foo")
 }
@@ -82,7 +84,7 @@ func TestParseArgs(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			err := ParseArgs(CMD, SUMMARY, tc.args, &opts)
+			err := ParseArgs(helpErr, tc.args, &opts)
 			assert.NoError(t, err)
 			if tc.boolVal != nil {
 				assert.True(t, *tc.boolVal)

flags/help.go

@@ -11,6 +11,8 @@ import (
 )
 
 type HelpError struct {
+	sub     cmd.Subcommand
+	summary string
 	message string
 }
 
@@ -18,27 +20,30 @@ func (h HelpError) Error() string {
 	return h.message
 }
 
-func HelpRequired(sub cmd.Subcommand, long string) error {
+// TODO: is this odd? Constructing an error at the callsite and passing it down and back up?
-	return HelpError{
+// but how else should I fill out its fields to be reused later?
-		fmt.Sprintf("um %s: %s is required", sub, long),
+func NewHelpError(sub cmd.Subcommand, summary string) HelpError {
-	}
+	return HelpError{sub, summary, ""}
 }
 
-func HelpInvalidArg(sub cmd.Subcommand, arg string) error {
+func (h HelpError) HelpRequired(long string) error {
-	return HelpError{
+	h.message = fmt.Sprintf("um %s: %s is required", h.sub, long)
-		fmt.Sprintf("um %s: invalid argument: %s", sub, arg),
+	return h
-	}
 }
 
-func HelpMissingAssignment(sub cmd.Subcommand, arg string) error {
+func (h HelpError) HelpInvalidArg(arg string) error {
-	return HelpError{
+	h.message = fmt.Sprintf("um %s: invalid argument: %s", h.sub, arg)
-		fmt.Sprintf("um %s: %s needs a value assignment", sub, arg),
+	return h
-	}
+
 }
 
-// print out help string by reflecting over fields of provided opts struct
+func (h HelpError) HelpMissingAssignment(arg string) error {
-// and os.Exit(0)
+	h.message = fmt.Sprintf("um %s: %s needs a value assignment", h.sub, arg)
-func Help(sub cmd.Subcommand, summary string, opts any) error {
+	return h
+}
+
+// assemble --help string by reflecting over fields of provided opts struct
+func (h HelpError) Help(opts any) error {
 	v := reflect.ValueOf(opts)
 	if v.Kind() == reflect.Ptr {
 		v = v.Elem()
@@ -68,9 +73,10 @@ func Help(sub cmd.Subcommand, summary string, opts any) error {
 			)
 		}
 	}
-	if _, err := buf.WriteString(fmt.Sprintf("um %s%s\n\n%s\n\n", sub, positional, summary)); err != nil {
+	if _, err := buf.WriteString(fmt.Sprintf("um %s%s\n\n%s\n\n", h.sub, positional, h.summary)); err != nil {
 		return err
 	}
 	w.Flush()
-	return HelpError{buf.String()}
+	h.message = buf.String()
+	return h
 }

last/last.go

@@ -46,7 +46,8 @@ func GlobLast(glob string) (string, error) {
 
 func Last(args []string) {
 	opts := initOpts()
-	if err := flags.ParseArgs(CMD, SUMMARY, args, &opts); err != nil {
+	help := flags.NewHelpError(CMD, SUMMARY)
+	if err := flags.ParseArgs(help, args, &opts); err != nil {
 		var herr flags.HelpError
 		if errors.As(err, &herr) {
 			fmt.Println(herr)

mv/mv.go

@@ -90,7 +90,8 @@ func mv(opts options) error {
 
 func Mv(args []string) {
 	opts := initOpts()
-	if err := flags.ParseArgs(CMD, SUMMARY, args, &opts); err != nil {
+	help := flags.NewHelpError(CMD, SUMMARY)
+	if err := flags.ParseArgs(help, args, &opts); err != nil {
 		var herr flags.HelpError
 		if errors.As(err, &herr) {
 			fmt.Println(herr)

next/next.go

@@ -100,7 +100,8 @@ func emacsNext(f string, tags string) error {
 
 func Next(args []string) {
 	opts := initOpts()
-	if err := flags.ParseArgs(CMD, SUMMARY, args, &opts); err != nil {
+	help := flags.NewHelpError(CMD, SUMMARY)
+	if err := flags.ParseArgs(help, args, &opts); err != nil {
 		var herr flags.HelpError
 		if errors.As(err, &herr) {
 			fmt.Println(herr)

sort/sort.go

@@ -70,7 +70,8 @@ func write(file string, content string) {
 
 func Sort(args []string) {
 	opts := initOpts()
-	if err := flags.ParseArgs(CMD, SUMMARY, args, &opts); err != nil {
+	help := flags.NewHelpError(CMD, SUMMARY)
+	if err := flags.ParseArgs(help, args, &opts); err != nil {
 		var herr flags.HelpError
 		if errors.As(err, &herr) {
 			fmt.Println(herr)
@@ -80,7 +81,7 @@ func Sort(args []string) {
 	}
 	// BORK: by hand for now:
 	if !opts.Key.IsSet() {
-		fmt.Println(flags.HelpRequired(CMD, opts.Key.Long))
+		fmt.Println(help.HelpRequired(opts.Key.Long))
 		return
 	}
 

tag/tag.go

@@ -36,7 +36,8 @@ func initOpts() options {
 
 func Tag(args []string) {
 	opts := initOpts()
-	if err := flags.ParseArgs(CMD, SUMMARY, args, &opts); err != nil {
+	help := flags.NewHelpError(CMD, SUMMARY)
+	if err := flags.ParseArgs(help, args, &opts); err != nil {
 		var herr flags.HelpError
 		if errors.As(err, &herr) {
 			fmt.Println(herr)