Merge pull request #101 from kozmod/bug/100_fix_flags

[#100] fix parsing flags

internal/flag/flags.go

@@ -17,7 +17,7 @@ const (
 	defaultConfigFilePath = "progen.yml"
 
 	flagKeyConfigFile                  = "f"
-	flagKeyVarbose                     = "v"
+	flagKeyVerbose                     = "v"
 	flagKeyErrorStackTrace             = "errtrace"
 	flagKeyPrintConfig                 = "printconf"
 	flagKeyDryRun                      = "dr"
@@ -73,23 +73,21 @@ func Parse() Flags {
 	flagSet := flag.NewFlagSet(args[0], flag.ExitOnError)
 
 	var (
-		flags = Flags{
-			DefaultFlags: NewDefaultFlags(flagSet),
-		}
+		flags = NewFlags(flagSet)
 	)
 
 	err := flags.Parse(flagSet, args[1:])
 	if err != nil {
 		log.Fatalf("parse additioanl flags: %v", err)
 	}
-	return flags
+	return *flags
 }
 
 func NewDefaultFlags(fs *flag.FlagSet) *DefaultFlags {
 	var f DefaultFlags
 	fs.BoolVar(
 		&f.Verbose,
-		flagKeyVarbose,
+		flagKeyVerbose,
 		false,
 		"verbose output")
 	fs.BoolVar(
@@ -101,7 +99,7 @@ func NewDefaultFlags(fs *flag.FlagSet) *DefaultFlags {
 		&f.DryRun,
 		flagKeyDryRun,
 		false,
-		"dry run mode (can be combine with `-v`)")
+		`dry run mode (can be combine with "-v")`)
 	fs.Var(
 		&f.MissingKey,
 		flagKeyMissingKey,
@@ -116,14 +114,6 @@ func NewDefaultFlags(fs *flag.FlagSet) *DefaultFlags {
 	return &f
 }
 
-func (f *DefaultFlags) Parse(fs *flag.FlagSet, args []string) error {
-	err := fs.Parse(args)
-	if err != nil {
-		return xerrors.Errorf("parse args: %w", err)
-	}
-	return nil
-}
-
 func NewFlags(fs *flag.FlagSet) *Flags {
 	var (
 		f = Flags{DefaultFlags: NewDefaultFlags(fs)}

internal/flag/flags_test.go

@@ -291,7 +291,7 @@ func Test_parseFlags(t *testing.T) {
 
 	//goland:noinspection SpellCheckingInspection
 	var (
-		v           = dashPrefixFn(flagKeyVarbose)
+		v           = dashPrefixFn(flagKeyVerbose)
 		errstack    = dashPrefixFn(flagKeyErrorStackTrace)
 		printconfig = dashPrefixFn(flagKeyPrintConfig)
 		dr          = dashPrefixFn(flagKeyDryRun)

pkg/core/engin.go

@@ -1,17 +1,13 @@
 package core
 
 import (
-	"flag"
-	"log"
-	"os"
 	"sync"
 
 	"golang.org/x/xerrors"
 
 	"github.com/kozmod/progen/internal/entity"
 	"github.com/kozmod/progen/internal/exec"
 	"github.com/kozmod/progen/internal/factory"
-	engineFlags "github.com/kozmod/progen/internal/flag"
 )
 
 type Engin struct {
@@ -24,8 +20,6 @@ type Engin struct {
 	rm       []entity.Action[[]string]
 
 	logger entity.Logger
-
-	flags engineFlags.DefaultFlags
 }
 
 // AddActions adds action to the [Engin].
@@ -39,36 +33,33 @@ func (e *Engin) AddActions(actions ...action) *Engin {
 }
 
 // Run all actions.
-func (e *Engin) Run() error {
-	var (
-		args    = os.Args
-		flagSet = flag.NewFlagSet(args[0], flag.ExitOnError)
-	)
-	err := e.flags.Parse(flagSet, args)
-	if err != nil {
-		log.Printf("parse flags failed: %v", err)
-		return err
+func (e *Engin) Run(config *Config) error {
+	if config == nil {
+		config = &Config{}
 	}
 
 	var (
-		logFatalSuffixFn = entity.NewAppendVPlusOrV(e.flags.PrintErrorStackTrace)
+		logFatalSuffixFn = entity.NewAppendVPlusOrV(config.PrintErrorStackTrace)
 		actionFilter     factory.DummyActionFilter
 	)
 
 	e.mx.RLock()
 	defer e.mx.RUnlock()
 
-	var logger entity.Logger
+	var (
+		logger entity.Logger
+		err    error
+	)
 	if e.logger == nil {
-		logger, err = factory.NewLogger(e.flags.Verbose)
+		logger, err = factory.NewLogger(config.Verbose)
 		if err != nil {
 			return xerrors.Errorf("failed to initialize logger: %w", err)
 		}
 	}
 
 	procChain, err := factory.NewExecutorChainFactory(
 		logger,
-		e.flags.DryRun,
+		config.DryRun,
 		func(executors []entity.Executor) entity.Executor {
 			return exec.NewChain(executors)
 		},
@@ -80,16 +71,16 @@ func (e *Engin) Run() error {
 		factory.NewExecutorBuilderFactory(
 			e.fsModify,
 			factory.NewFsModifyExecFactory(
-				e.flags.TemplateVars.Vars,
-				[]string{e.flags.MissingKey.String()},
+				config.TemplateVars.Vars,
+				[]string{config.MissingKey.String()},
 			).Create,
 			actionFilter,
 		),
 		factory.NewExecutorBuilderFactory(
 			e.fsSave,
 			factory.NewFsSaveExecFactory(
-				e.flags.TemplateVars.Vars,
-				[]string{e.flags.MissingKey.String()},
+				config.TemplateVars.Vars,
+				[]string{config.MissingKey.String()},
 			).Create,
 			actionFilter,
 		),
@@ -101,8 +92,8 @@ func (e *Engin) Run() error {
 		factory.NewExecutorBuilderFactory(
 			e.files,
 			factory.NewFileExecutorFactory(
-				e.flags.TemplateVars.Vars,
-				[]string{e.flags.MissingKey.String()},
+				config.TemplateVars.Vars,
+				[]string{config.MissingKey.String()},
 			).Create,
 			actionFilter,
 		),

pkg/core/flags.go

@@ -0,0 +1,32 @@
+package core
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	internalFlags "github.com/kozmod/progen/internal/flag"
+)
+
+// Config for the [Engin].
+type Config internalFlags.DefaultFlags
+
+// AddConfigFlagSet adds flags to [*flag.FlagSet] and creates [Engin] config.
+func AddConfigFlagSet(fs *flag.FlagSet) *Config {
+	f := internalFlags.NewDefaultFlags(fs)
+	return (*Config)(f)
+}
+
+// ParseFlags - parse flags and creates [Engin] config from [*flag.FlagSet].
+func ParseFlags() (*Config, error) {
+	var (
+		args    = os.Args
+		flagSet = flag.NewFlagSet(args[0], flag.ExitOnError)
+		f       = AddConfigFlagSet(flagSet)
+		err     = flagSet.Parse(args[1:])
+	)
+	if err != nil {
+		return f, fmt.Errorf("parse config from flags: %w", err)
+	}
+	return f, nil
+}