refactor(command): update visitor pattern

Author: pot-code

cmd/go_flags_parse.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 
 	"github.com/fatih/structtag"
-	"github.com/pot-code/web-cli/internal/validate"
 )
 
 type tagMeta struct {
@@ -38,10 +37,23 @@ func parseTag(tag reflect.StructTag) (*tagMeta, error) {
 		tg.Default = d.Value()
 	}
 
-	tg.Required = validate.IsRequired(tag)
+	tg.Required = isRequired(tag)
 	return tg, nil
 }
 
+func isRequired(tag reflect.StructTag) bool {
+	if tag == "" {
+		return false
+	}
+
+	vt := tag.Get("validate")
+	if vt == "" {
+		return false
+	}
+
+	return strings.Contains(vt, "required")
+}
+
 func parseConfigFile(config *GoFlagsConfig) (*configStructVisitor, error) {
 	fset := token.NewFileSet()
 	f, err := parser.ParseFile(fset, config.ConfigPath, nil, parser.ParseComments)

cmd/go_server.go renamed to cmd/go_web.go

@@ -16,7 +16,7 @@ import (
 type GoWebConfig struct {
 	ProjectName string `arg:"0" alias:"project_name" validate:"required,var"`
 	AuthorName  string `flag:"author" alias:"a" usage:"author name for the app" validate:"required,var"`
-	GoVersion   string `flag:"version" alias:"v" usage:"go compiler version" validate:"required,version"`
+	GoVersion   string `flag:"version" alias:"v" usage:"go compiler version" validate:"version"`
 }
 
 var GoWebCmd = command.NewCliCommand("web", "generate golang web project",
@@ -32,7 +32,7 @@ var GenWebProject = command.InlineHandler(func(c *cli.Context, cfg interface{})
 	projectName := config.ProjectName
 	authorName := config.AuthorName
 
-	if util.FileExists(projectName) {
+	if util.Exists(projectName) {
 		log.Infof("folder '%s' already exists", projectName)
 		return nil
 	}

cmd/react_init.go

@@ -8,7 +8,7 @@ import (
 )
 
 type ReactInitConfig struct {
-	GenType     string `flag:"type" alias:"t" usage:"project type" validate:"required,oneof=vanilla next"`
+	GenType     string `flag:"type" alias:"t" usage:"project type" validate:"oneof=vanilla next"`
 	ProjectName string `arg:"0" alias:"project_name" validate:"required,var"`
 }
 

cmd/root.go

@@ -1,7 +1,6 @@
 package cmd
 
 import (
-	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
@@ -26,9 +25,9 @@ var RootCmd = &cli.App{
 		},
 	},
 	Before: func(c *cli.Context) error {
-		if c.Bool("debug") {
-			log.SetLevel(log.DebugLevel)
-		}
+		// if c.Bool("debug") {
+		// 	log.SetLevel(log.DebugLevel)
+		// }
 		return nil
 	},
 }

internal/command/cli.go

@@ -1,23 +1,16 @@
 package command
 
 import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-
 	"github.com/go-playground/validator/v10"
 	"github.com/pkg/errors"
-	"github.com/pot-code/web-cli/internal/util"
 	"github.com/pot-code/web-cli/internal/validate"
-	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
 type CliCommand struct {
 	cmd      *cli.Command
 	cfg      interface{}
-	services []CommandHandler
+	handlers []CommandHandler
 }
 
 type CommandOption interface {
@@ -53,236 +46,49 @@ func NewCliCommand(name, usage string, defaultConfig interface{}, options ...Com
 		Name:  name,
 		Usage: usage,
 	}
-
-	visitor := NewExtractFlagsVisitor()
-	IterateCliConfig(defaultConfig, visitor, nil)
-	cmd.Flags = append(cmd.Flags, visitor.Flags...)
-
 	for _, option := range options {
 		option.apply(cmd)
 	}
 	return &CliCommand{cmd, defaultConfig, []CommandHandler{}}
 }
 
 func (cc *CliCommand) AddHandlers(h ...CommandHandler) *CliCommand {
-	cc.services = append(cc.services, h...)
+	cc.handlers = append(cc.handlers, h...)
 	return cc
 }
 
 func (cc *CliCommand) BuildCommand() *cli.Command {
-	cc.cmd.Action = func(c *cli.Context) error {
-		cfg := cc.cfg
+	cfg := cc.cfg
 
-		if cfg != nil {
-			IterateCliConfig(cfg, NewSetCliValueVisitor(), c)
-			if err := validate.V.Struct(cfg); err != nil {
-				if v, ok := err.(validator.ValidationErrors); ok {
-					msg := v[0].Translate(validate.T)
-					cli.ShowCommandHelp(c, c.Command.Name)
-					return util.NewCommandError(c.Command.Name, errors.New(msg))
-				}
-				return err
-			}
+	efv := newExtractFlagsVisitor()
+	walkConfig(cfg, efv)
+
+	cc.cmd.Flags = append(cc.cmd.Flags, efv.getFlags()...)
+	cc.cmd.Before = func(c *cli.Context) error {
+		scv := newSetConfigVisitor(c)
+		walkConfig(cfg, scv)
+
+		if errs := scv.getErrors(); errs != nil {
+			return errs[0]
 		}
 
-		for _, s := range cc.services {
+		if err := validate.V.Struct(cfg); err != nil {
+			if v, ok := err.(validator.ValidationErrors); ok {
+				msg := v[0].Translate(validate.T)
+				cli.ShowCommandHelp(c, c.Command.Name)
+				return errors.New(msg)
+			}
+			return err
+		}
+		return nil
+	}
+	cc.cmd.Action = func(c *cli.Context) error {
+		for _, s := range cc.handlers {
 			if err := s.Handle(c, cfg); err != nil {
 				return err
 			}
 		}
-
 		return nil
 	}
 	return cc.cmd
 }
-
-type ConfigStructVisitor interface {
-	VisitStringType(reflect.StructField, reflect.Value, *cli.Context) error
-	VisitBooleanType(reflect.StructField, reflect.Value, *cli.Context) error
-	VisitIntType(reflect.StructField, reflect.Value, *cli.Context) error
-}
-
-func IterateCliConfig(config interface{}, visitor ConfigStructVisitor, ctx *cli.Context) {
-	if config == nil {
-		return
-	}
-
-	directType := reflect.TypeOf(config)
-	if directType.Kind() != reflect.Ptr {
-		panic("config must be of pointer type")
-	}
-	structType := directType.Elem()
-
-	configStruct := reflect.Indirect(reflect.ValueOf(config)) // reflection wrapper for the config struct
-	for i := structType.NumField() - 1; i >= 0; i-- {
-		fieldType := structType.Field(i)
-		fieldValue := configStruct.Field(i)
-
-		if !fieldValue.CanSet() {
-			log.WithFields(log.Fields{
-				"caller": "ParseCliConfig",
-			}).Warnf("config field [ %s ] can't be set, maybe it's not exported", fieldType.Name)
-			continue
-		}
-
-		switch fieldType.Type.Kind() {
-		case reflect.String:
-			visitor.VisitStringType(fieldType, fieldValue, ctx)
-		case reflect.Bool:
-			visitor.VisitBooleanType(fieldType, fieldValue, ctx)
-		case reflect.Int:
-			visitor.VisitIntType(fieldType, fieldValue, ctx)
-		default:
-			panic("not implemented")
-		}
-	}
-}
-
-type ExtractFlagsVisitor struct {
-	Flags []cli.Flag
-}
-
-func NewExtractFlagsVisitor() *ExtractFlagsVisitor {
-	return &ExtractFlagsVisitor{Flags: []cli.Flag{}}
-}
-
-var _ ConfigStructVisitor = &ExtractFlagsVisitor{}
-
-func (efv *ExtractFlagsVisitor) VisitStringType(tf reflect.StructField, vf reflect.Value, c *cli.Context) error {
-	tag := tf.Tag
-
-	if flagName := tag.Get("flag"); flagName != "" {
-		alias := tag.Get("alias")
-		usage := tag.Get("usage")
-
-		required := false
-		if vf.IsZero() && validate.IsRequired(tag) {
-			required = true
-		}
-
-		flag := &cli.StringFlag{
-			Name:     flagName,
-			Required: required,
-		}
-
-		if alias != "" {
-			flag.Aliases = strings.Split(alias, ",")
-		}
-
-		if !vf.IsZero() {
-			flag.Value = vf.String()
-		}
-
-		options := validate.GetOneOfItems(tag)
-		if len(options) > 0 {
-			usage += fmt.Sprintf(" (options: %s)", strings.Join(options, ", "))
-		}
-		flag.Usage = usage
-
-		log.WithFields(log.Fields{
-			"name":     flagName,
-			"type":     tf.Type.String(),
-			"required": required,
-			"alias":    alias,
-			"usage":    usage,
-		}).Debug("register flag")
-
-		efv.Flags = append(efv.Flags, flag)
-	}
-	return nil
-}
-
-func (efv *ExtractFlagsVisitor) VisitBooleanType(tf reflect.StructField, vf reflect.Value, c *cli.Context) error {
-	if flagName := tf.Tag.Get("flag"); flagName != "" {
-		usage := tf.Tag.Get("usage")
-		alias := tf.Tag.Get("alias")
-
-		flag := &cli.BoolFlag{
-			Name:  flagName,
-			Usage: usage,
-		}
-		if alias != "" {
-			flag.Aliases = strings.Split(alias, ",")
-		}
-		if !vf.IsZero() {
-			flag.Value = vf.Bool()
-		}
-
-		log.WithFields(log.Fields{
-			"name":  flagName,
-			"type":  tf.Type.String(),
-			"alias": alias,
-			"usage": usage,
-		}).Debug("register flag")
-		efv.Flags = append(efv.Flags, flag)
-	}
-	return nil
-}
-
-func (efv *ExtractFlagsVisitor) VisitIntType(tf reflect.StructField, vf reflect.Value, c *cli.Context) error {
-	if flagTag := tf.Tag.Get("flag"); flagTag != "" {
-		usage := tf.Tag.Get("usage")
-		alias := tf.Tag.Get("alias")
-
-		flagName := &cli.IntFlag{
-			Name:  flagTag,
-			Usage: usage,
-		}
-		if alias != "" {
-			flagName.Aliases = strings.Split(alias, ",")
-		}
-		if !vf.IsZero() {
-			flagName.Value = int(vf.Int())
-		}
-
-		log.WithFields(log.Fields{
-			"name":  flagName,
-			"type":  tf.Type.String(),
-			"alias": alias,
-			"usage": usage,
-		}).Debug("register flag")
-		efv.Flags = append(efv.Flags, flagName)
-	}
-	return nil
-}
-
-type SetCliValueVisitor struct{}
-
-func NewSetCliValueVisitor() *SetCliValueVisitor {
-	return &SetCliValueVisitor{}
-}
-
-var _ ConfigStructVisitor = &SetCliValueVisitor{}
-
-func (efv *SetCliValueVisitor) VisitStringType(tf reflect.StructField, vf reflect.Value, c *cli.Context) error {
-	if arg := tf.Tag.Get("arg"); arg != "" {
-		index, err := strconv.Atoi(arg)
-		if err != nil {
-			panic(fmt.Sprintf("failed to convert [ %s ] to number", arg))
-		}
-
-		kind := tf.Type.Kind()
-		if kind == reflect.String {
-			vf.SetString(c.Args().Get(index))
-		} else {
-			panic(fmt.Errorf("unsupported arg type: %s", kind.String()))
-		}
-	} else if flag := tf.Tag.Get("flag"); flag != "" {
-		vf.SetString(c.String(flag))
-	}
-	return nil
-}
-
-func (efv *SetCliValueVisitor) VisitBooleanType(tf reflect.StructField, vf reflect.Value, c *cli.Context) error {
-	if flag := tf.Tag.Get("flag"); flag != "" {
-		vf.SetBool(c.Bool(flag))
-	}
-	return nil
-}
-
-func (efv *SetCliValueVisitor) VisitIntType(tf reflect.StructField, vf reflect.Value, c *cli.Context) error {
-	if flag := tf.Tag.Get("flag"); flag != "" {
-		vf.SetInt(int64(c.Int("flag")))
-	}
-	return nil
-}

internal/command/errors.go

@@ -0,0 +1,24 @@
+package command
+
+type CommandError struct {
+	cmd string
+	err error
+}
+
+func NewCommandError(cmd string, err error) *CommandError {
+	return &CommandError{
+		cmd, err,
+	}
+}
+
+func (ce CommandError) Error() string {
+	return ce.err.Error()
+}
+
+func (ce CommandError) Command() string {
+	return ce.cmd
+}
+
+func (ce CommandError) Unwrap() error {
+	return ce.err
+}