Merge pull request #26 from csueiras/more-powerful-type-targeting

Support for regex for targetting.

cmd/reinforcer/cmd/root.go

@@ -1,3 +1,5 @@
+//go:generate mockery --all
+
 // MIT License
 //
 // Copyright (c) 2021 Christian Sueiras
@@ -25,137 +27,154 @@ package cmd
 import (
  "fmt"
  "github.com/csueiras/reinforcer/internal/generator"
+ "github.com/csueiras/reinforcer/internal/generator/executor"
  "github.com/csueiras/reinforcer/internal/loader"
+ "github.com/csueiras/reinforcer/internal/writer"
+ "github.com/mitchellh/go-homedir"
+ "github.com/rs/zerolog"
+ "github.com/rs/zerolog/log"
  "github.com/spf13/cobra"
- "io/ioutil"
+ "github.com/spf13/viper"
  "os"
  "path"
- "regexp"
- "strings"
-
- "github.com/mitchellh/go-homedir"
- "github.com/spf13/viper"
 )
 
 // Version will be set in CI to the current released version
 var Version = "0.0.0"
-
-var matchFirstCap = regexp.MustCompile("(.)([A-Z][a-z]+)")
-var matchAllCap = regexp.MustCompile("([a-z0-9])([A-Z])")
 var cfgFile string
 
-// rootCmd represents the base command when called without any subcommands
-var rootCmd = &cobra.Command{
- Use: "reinforcer",
- Short: "Generates the reinforced middleware code",
- Long: `Reinforcer is a CLI tool that generates code from interfaces that
+// Writer describes the code generator writer
+type Writer interface {
+ Write(outputDirectory string, generated *generator.Generated) error
+}
+
+// Executor describes the code generator executor
+type Executor interface {
+ Execute(settings *executor.Parameters) (*generator.Generated, error)
+}
+
+// DefaultRootCmd creates the default root command with its dependencies wired in
+func DefaultRootCmd() *cobra.Command {
+ return NewRootCmd(executor.New(loader.DefaultLoader()), writer.Default())
+}
+
+// NewRootCmd creates the root command for reinforcer
+func NewRootCmd(exec Executor, writ Writer) *cobra.Command {
+ rootCmd := &cobra.Command{
+ Use: "reinforcer",
+ Short: "Generates the reinforced middleware code",
+ Long: `Reinforcer is a CLI tool that generates code from interfaces that
 will automatically inject middleware. Middlewares provide resiliency constructs
 such as circuit breaker, retries, timeouts, etc.
 `,
- RunE: func(cmd *cobra.Command, args []string) error {
- flags := cmd.Flags()
- if showVersion, _ := flags.GetBool("version"); showVersion {
- fmt.Println(Version)
- return nil
- }
-
- src, _ := flags.GetString("src")
- sourceTypeName, _ := cmd.Flags().GetString("name")
- outPkg, _ := flags.GetString("outpkg")
- outDir, _ := flags.GetString("outputdir")
- ignoreNoRet, _ := flags.GetBool("ignorenoret")
-
- if !path.IsAbs(outDir) {
- cwd, err := os.Getwd()
- if err != nil {
- return err
+ RunE: func(cmd *cobra.Command, args []string) error {
+ flags := cmd.Flags()
+ if showVersion, _ := flags.GetBool("version"); showVersion {
+ fmt.Println(Version)
+ return nil
  }
- outDir = path.Join(cwd, path.Clean(outDir))
- } else {
- outDir = path.Clean(outDir)
- }
 
- if err := os.MkdirAll(outDir, 0755); err != nil {
- return err
- }
+ zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+ log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
 
- l := loader.DefaultLoader()
- _, typ, err := l.Load(src, sourceTypeName)
- if err != nil {
- return err
- }
-
- code, err := generator.Generate(generator.Config{
- OutPkg: outPkg,
- IgnoreNoReturnMethods: ignoreNoRet,
- Files: map[string]*generator.FileConfig{
- src: {
- SrcTypeName: sourceTypeName,
- OutTypeName: sourceTypeName,
- InterfaceType: typ,
- },
- },
- })
- if err != nil {
- return err
- }
+ debug, _ := flags.GetBool("debug")
+ silent, _ := flags.GetBool("silent")
 
- if err := saveTo(path.Join(outDir, "reinforcer_common.go"), code.Common); err != nil {
- return err
- }
-
- if err := saveTo(path.Join(outDir, "reinforcer_constants.go"), code.Constants); err != nil {
- return err
- }
+ // Default level for this example is info, unless debug flag is present (or logging is disabled)
+ zerolog.SetGlobalLevel(zerolog.InfoLevel)
+ if debug {
+ zerolog.SetGlobalLevel(zerolog.DebugLevel)
+ }
+ if silent {
+ zerolog.SetGlobalLevel(zerolog.Disabled)
+ }
 
- for _, codegen := range code.Files {
- if err := saveTo(path.Join(outDir, toSnakeCase(codegen.TypeName)+".go"), codegen.Contents); err != nil {
+  sources, err := flags.GetStringSlice("src")
+ if err != nil {
  return err
  }
- }
+ if len(sources) == 0 {
+ goFile := os.Getenv("GOFILE")
+ if goFile == "" {
+ return fmt.Errorf("no source provided")
+ }
+
+ defSrcFile, err := os.Getwd()
+ if err != nil {
+ return err
+ }
+ sources = append(sources, path.Join(defSrcFile, goFile))
+ }
 
- return nil
- },
-}
+ targetAll, err := flags.GetBool("targetall")
+ if err != nil {
+ return err
+ }
+ targets, err := flags.GetStringSlice("target")
+ if err != nil {
+ return err
+ }
+ if len(targets) == 0 && !targetAll {
+ return fmt.Errorf("no targets provided")
+ }
+ outPkg, err := flags.GetString("outpkg")
+ if err != nil {
+ return err
+ }
+ outDir, err := flags.GetString("outputdir")
+ if err != nil {
+ return err
+ }
+ ignoreNoRet, err := flags.GetBool("ignorenoret")
+ if err != nil {
+ return err
+ }
 
-func saveTo(path string, contents string) error {
- if err := ioutil.WriteFile(path, []byte(contents), 0755); err != nil {
- return fmt.Errorf("failed to write to %s; error=%w", path, err)
+ gen, err := exec.Execute(&executor.Parameters{
+ Sources: sources,
+ Targets: targets,
+ TargetsAll: targetAll,
+ OutPkg: outPkg,
+ IgnoreNoReturnMethods: ignoreNoRet,
+ })
+ if err != nil {
+ return fmt.Errorf("failed to generate code; error=%w", err)
+ }
+ if err := writ.Write(outDir, gen); err != nil {
+ return fmt.Errorf("failed to save generated code; error=%w", err)
+ }
+ return nil
+ },
  }
- return nil
+
+ rootCmd.PersistentFlags().
+ StringVar(&cfgFile, "config", "", "config file (default is $HOME/.reinforcer.yaml)")
+
+ flags := rootCmd.Flags()
+ flags.BoolP("version", "v", false, "show reinforcer's version")
+ flags.BoolP("debug", "d", false, "enables debug logs")
+ flags.BoolP("silent", "q", false, "disables logging. Mutually exclusive with the debug flag.")
+ flags.StringSliceP("src", "s", nil, "source files to scan for the target interface. If unspecified the file pointed by the env variable GOFILE will be used.")
+ flags.StringSliceP("target", "t", []string{}, "name of target type or regex to match interface names with")
+ flags.BoolP("targetall", "a", false, "codegen for all exported interfaces discovered. This option is mutually exclusive with the target option.")
+ flags.StringP("outputdir", "o", "./reinforced", "directory to write the generated code to")
+ flags.StringP("outpkg", "p", "reinforced", "name of generated package")
+ flags.BoolP("ignorenoret", "i", false, "ignores methods that don't return anything (they won't be wrapped in the middleware). By default they'll be wrapped in a middleware and if the middleware emits an error the call will panic.")
+
+ return rootCmd
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
 // This is called by main.main(). It only needs to happen once to the rootCmd.
 func Execute() {
- if err := rootCmd.Execute(); err != nil {
+ if err := DefaultRootCmd().Execute(); err != nil {
  fmt.Println(err)
  os.Exit(1)
  }
 }
 
 func init() {
  cobra.OnInitialize(initConfig)
-
- defSrcFile := ""
- if goFile := os.Getenv("GOFILE"); goFile != "" {
- var err error
- defSrcFile, err = os.Getwd()
- if err != nil {
- panic(err)
- }
- defSrcFile = defSrcFile + "/" + goFile
- }
-
- rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.reinforcer.yaml)")
-
- flags := rootCmd.Flags()
- flags.Bool("version", false, "show reinforcer's version")
- flags.String("name", "", "name of interface to generate reinforcer's proxy for")
- flags.String("src", defSrcFile, "source file to scan for the target interface. If unspecified the file pointed by the env variable GOFILE will be used.")
- flags.String("outputdir", "./reinforced", "directory to write the generated code to")
- flags.String("outpkg", "reinforced", "name of generated package")
- flags.Bool("ignorenoret", false, "ignores methods that don't return anything (they won't be wrapped in the middleware). By default they'll be wrapped in a middleware and if the middleware emits an error the call will panic.")
 }
 
 // initConfig reads in config file and ENV variables if set.
@@ -183,10 +202,3 @@ func initConfig() {
  fmt.Println("Using config file:", viper.ConfigFileUsed())
  }
 }
-
-// Taken from: https://gist.github.com/stoewer/fbe273b711e6a06315d19552dd4d33e6
-func toSnakeCase(str string) string {
- snake := matchFirstCap.ReplaceAllString(str, "${1}_${2}")
- snake = matchAllCap.ReplaceAllString(snake, "${1}_${2}")
- return strings.ToLower(snake)
-}