Add nested commands

Author: cristaloleg

acmd.go

@@ -76,6 +76,9 @@ func RunnerOf(cmds []Command, cfg Config) *Runner {
 }
 
 func (r *Runner) init() error {
+	if len(r.cmds) == 0 {
+		return errors.New("no cmds provided")
+	}
 	if r.cfg.AppName == "" {
 		r.cfg.AppName = os.Args[0]
 	}
@@ -105,7 +108,6 @@ func (r *Runner) init() error {
 	cmds := r.cmds
 	r.rootCmd = Command{
 		Name:        "root",
-		Do:          func(context.Context, []string) error { return nil },
 		subcommands: cmds,
 	}
 	if err := validateCommand(r.rootCmd); err != nil {
@@ -136,6 +138,7 @@ func (r *Runner) init() error {
 	})
 
 	r.rootCmd.subcommands = cmds
+	r.rootCmd.Do = rootDo(r.cfg, cmds)
 
 	return nil
 }
@@ -145,7 +148,10 @@ func validateCommand(cmd Command) error {
 
 	switch {
 	case cmd.Do == nil && len(cmds) == 0:
-		return fmt.Errorf("command %q function cannot be nil", cmd.Name)
+		return fmt.Errorf("command %q function cannot be nil or must have subcommands", cmd.Name)
+
+	case cmd.Do != nil && len(cmds) != 0:
+		return fmt.Errorf("command %q function cannot be set and have subcommands", cmd.Name)
 
 	case cmd.Name == "help" || cmd.Name == "version":
 		return fmt.Errorf("command %q is reserved", cmd.Name)
@@ -178,28 +184,48 @@ func (r *Runner) Run() error {
 	if r.errInit != nil {
 		return fmt.Errorf("acmd: cannot init runner: %w", r.errInit)
 	}
-	if err := run(r.ctx, r.cfg, r.rootCmd.subcommands, r.args); err != nil {
+	if err := r.rootCmd.Do(r.ctx, r.args); err != nil {
 		return fmt.Errorf("acmd: cannot run command: %w", err)
 	}
 	return nil
 }
 
-func run(ctx context.Context, cfg Config, cmds []Command, args []string) error {
-	if len(args) == 0 {
-		return errors.New("no args provided")
-	}
-	selected, params := args[0], args[1:]
-
-	for _, c := range cmds {
-		if c.Name == selected {
-			return c.Do(ctx, params)
+func rootDo(cfg Config, cmds []Command) func(ctx context.Context, args []string) error {
+	return func(ctx context.Context, args []string) error {
+		if len(args) == 0 {
+			return errors.New("no args provided")
 		}
-	}
 
-	if suggestion := suggestCommand(selected, cmds); suggestion != "" {
-		fmt.Fprintf(cfg.Output, "%q is not a subcommand, did you mean %q?\n", selected, suggestion)
+		cmds, args := cmds, args
+		for {
+			selected, params := args[0], args[1:]
+
+			var found bool
+			for _, c := range cmds {
+				if c.Name != selected {
+					continue
+				}
+
+				// go deeper into subcommands
+				if c.Do == nil {
+					if len(params) == 0 {
+						return errors.New("no args for subcmd provided")
+					}
+					cmds, args = c.subcommands, params
+					found = true
+					break
+				}
+				return c.Do(ctx, params)
+			}
+
+			if !found {
+				if suggestion := suggestCommand(selected, cmds); suggestion != "" {
+					fmt.Fprintf(cfg.Output, "%q is not a subcommand, did you mean %q?\n", selected, suggestion)
+				}
+				return fmt.Errorf("no such command %q", selected)
+			}
+		}
 	}
-	return fmt.Errorf("no such command %q", selected)
 }
 
 // suggestCommand for not found earlier command.

acmd_test.go

@@ -3,7 +3,11 @@ package acmd
 import (
 	"bytes"
 	"context"
+	"fmt"
+	"os"
+	"strings"
 	"testing"
+	"time"
 )
 
 var nopFunc = func(context.Context, []string) error { return nil }
@@ -19,8 +23,16 @@ func TestRunner_init(t *testing.T) {
 			wantErrStr: `command "foo%" must contains only letters, digits, - and _`,
 		},
 		{
-			cmds:       []Command{{Name: "foo%", Do: nil}},
-			wantErrStr: `command "foo%" function cannot be nil`,
+			cmds:       []Command{{Name: "foo", Do: nil}},
+			wantErrStr: `command "foo" function cannot be nil or must have subcommands`,
+		},
+		{
+			cmds: []Command{{
+				Name:        "foobar",
+				Do:          nopFunc,
+				subcommands: []Command{{Name: "nested"}},
+			}},
+			wantErrStr: `command "foobar" function cannot be set and have subcommands`,
 		},
 		{
 			cmds: []Command{{Name: "foo", Do: nopFunc}},
@@ -68,17 +80,17 @@ func TestRunner_suggestCommand(t *testing.T) {
 			want: `"fooo" is not a subcommand, did you mean "foo"?` + "\n",
 		},
 		{
-			cmds: []Command{},
+			cmds: []Command{{Name: "for", Do: nopFunc}},
 			args: []string{"hell"},
 			want: `"hell" is not a subcommand, did you mean "help"?` + "\n",
 		},
 		{
-			cmds: []Command{},
+			cmds: []Command{{Name: "for", Do: nopFunc}},
 			args: []string{"verZION"},
 			want: "",
 		},
 		{
-			cmds: []Command{},
+			cmds: []Command{{Name: "for", Do: nopFunc}},
 			args: []string{"verZion"},
 			want: `"verZion" is not a subcommand, did you mean "version"?` + "\n",
 		},
@@ -90,12 +102,61 @@ func TestRunner_suggestCommand(t *testing.T) {
 			Args:   tc.args,
 			Output: buf,
 		})
-		if err := r.Run(); err == nil {
-			t.Fatal()
+		if err := r.Run(); err != nil && !strings.Contains(err.Error(), "no such command") {
+			t.Fatal(err)
 		}
 
 		if got := buf.String(); got != tc.want {
-			t.Logf("want %q got %q", tc.want, got)
+			t.Fatalf("want %q got %q", tc.want, got)
 		}
 	}
 }
+
+func TestRunner(t *testing.T) {
+	r := RunnerOf([]Command{
+		{
+			Name:        "test",
+			Description: "some test command",
+			// Do: func(ctx context.Context, args []string) error {
+			// 	return nil
+			// },
+			subcommands: []Command{
+				{
+					Name: "foo",
+					// Do: func(ctx context.Context, args []string) error {
+					// 	fmt.Fprint(os.Stderr, "foo")
+					// 	return nil
+					// },
+					subcommands: []Command{
+						{
+							Name: "for", Do: func(ctx context.Context, args []string) error {
+								fmt.Fprint(os.Stderr, "for")
+								return nil
+							},
+						},
+					},
+				},
+				{Name: "bar", Do: func(ctx context.Context, args []string) error {
+					fmt.Fprint(os.Stderr, "bar")
+					return nil
+				}},
+			},
+		},
+		{
+			Name:        "status",
+			Description: "status command gives status of the state",
+			Do: func(ctx context.Context, args []string) error {
+				return nil
+			},
+		},
+	}, Config{
+		Args:           []string{"test", "foo", "for"},
+		AppName:        "acmd_test_app",
+		AppDescription: "acmd_test_app is a test application.",
+		Version:        time.Now().String(),
+	})
+
+	if err := r.Run(); err != nil {
+		t.Fatal(err)
+	}
+}