add NeedArgs feature for package gcmd

Author: gqcn

os/gcmd/gcmd_command.go

@@ -26,6 +26,7 @@ type Command struct {
 	HelpFunc      Function      // Custom help function
 	Examples      string        // Usage examples.
 	Additional    string        // Additional info about this command, which will be appended to the end of help info.
+	NeedArgs      bool          // NeedArgs specifies this command needs arguments.
 	Strict        bool          // Strict parsing options, which means it returns error if invalid option given.
 	parent        *Command      // Parent command for internal usage.
 	commands      []Command     // Sub commands of this command.

os/gcmd/gcmd_command_object.go

@@ -26,6 +26,7 @@ import (
 const (
 	tagNameDc   = `dc`
 	tagNameAd   = `ad`
+	tagNameArgs = `args`
 	tagNameRoot = `root`
 )
 
@@ -113,6 +114,9 @@ func newCommandFromObjectMeta(object interface{}) (command Command, err error) {
 		)
 		return
 	}
+	if !command.NeedArgs {
+		command.NeedArgs = gconv.Bool(metaData[tagNameArgs])
+	}
 	if command.Description == "" {
 		command.Description = metaData[tagNameDc]
 	}
@@ -199,7 +203,7 @@ func newCommandFromMethod(object interface{}, method reflect.Value) (command Com
 
 	// Create function that has value return.
 	command.FuncWithValue = func(ctx context.Context, parser *Parser) (out interface{}, err error) {
-		ctx = context.WithValue(ctx, CtxKeyParser, command)
+		ctx = context.WithValue(ctx, CtxKeyParser, parser)
 
 		defer func() {
 			if exception := recover(); exception != nil {

os/gcmd/gcmd_command_run.go

@@ -106,6 +106,12 @@ func (c *Command) searchCommand(args []string) *Command {
 		return nil
 	}
 	for _, cmd := range c.commands {
+		// If this command needs argument,
+		// it then gives all its left arguments to it.
+		if cmd.NeedArgs {
+			return &cmd
+		}
+		// Recursively searching the command.
 		if cmd.Name == args[0] {
 			leftArgs := args[1:]
 			if len(leftArgs) == 0 {

os/gcmd/gcmd_z_unit_feature_object_test.go

@@ -139,3 +139,47 @@ func Test_Command_RootTag(t *testing.T) {
 		t.Assert(value, `{"Content":"john"}`)
 	})
 }
+
+type TestObjectForNeedArgs struct {
+	g.Meta `name:"root" root:"root"`
+}
+
+type TestObjectForNeedArgsEnvInput struct {
+	g.Meta `name:"env" usage:"root env" brief:"root env command" dc:"root env command description" ad:"root env command ad"`
+}
+type TestObjectForNeedArgsEnvOutput struct{}
+
+type TestObjectForNeedArgsTestInput struct {
+	g.Meta `name:"test" args:"true"`
+	Name   string `v:"required" short:"n" orphan:"false" brief:"name for test command"`
+}
+type TestObjectForNeedArgsTestOutput struct {
+	Args []string
+}
+
+func (TestObjectForNeedArgs) Env(ctx context.Context, in TestObjectForNeedArgsEnvInput) (out *TestObjectForNeedArgsEnvOutput, err error) {
+	return
+}
+
+func (TestObjectForNeedArgs) Test(ctx context.Context, in TestObjectForNeedArgsTestInput) (out *TestObjectForNeedArgsTestOutput, err error) {
+	parser := gcmd.ParserFromCtx(ctx)
+	out = &TestObjectForNeedArgsTestOutput{
+		Args: parser.GetArgAll(),
+	}
+	return
+}
+
+func Test_Command_NeedArgs(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			ctx = gctx.New()
+		)
+		cmd, err := gcmd.NewFromObject(TestObjectForNeedArgs{})
+		t.AssertNil(err)
+
+		os.Args = []string{"root", "test", "a", "b", "c", "-n=john"}
+		value, err := cmd.RunWithValue(ctx)
+		t.AssertNil(err)
+		t.Assert(value, `{"Args":["root","test","a","b","c"]}`)
+	})
+}