feat: add scaffold configs and scaffold params commands and start remove placeholders

changelog.md

@@ -5,6 +5,7 @@
 ### Features
 
 - [#3977](https://github.com/ignite/cli/pull/3977) Add `chain lint` command to lint the chain's codebase using `golangci-lint`
+- [#3770](https://github.com/ignite/cli/pull/3770) Add `scaffold configs` and `scaffold params` commands
 
 ### Changes
 

ignite/cmd/chain_lint.go

@@ -1,9 +1,10 @@
 package ignitecmd
 
 import (
+	"github.com/spf13/cobra"
+
 	"github.com/ignite/cli/v28/ignite/pkg/cliui"
 	"github.com/ignite/cli/v28/ignite/services/chain"
-	"github.com/spf13/cobra"
 )
 
 // NewChainLint returns a lint command to build a blockchain app.

ignite/cmd/scaffold.go

@@ -123,6 +123,8 @@
 		NewScaffoldMap(),
 		NewScaffoldSingle(),
 		NewScaffoldType(),
+		NewScaffoldParams(),
+		NewScaffoldConfigs(),
 		NewScaffoldMessage(),
 		NewScaffoldQuery(),
 		NewScaffoldPacket(),

ignite/cmd/scaffold_chain.go

@@ -80,6 +80,7 @@
 	c.Flags().StringP(flagPath, "p", "", "create a project in a specific path")
 	c.Flags().Bool(flagNoDefaultModule, false, "create a project without a default module")
 	c.Flags().StringSlice(flagParams, []string{}, "add default module parameters")
+	c.Flags().StringSlice(flagModuleConfigs, []string{}, "add module configs")
 	c.Flags().Bool(flagSkipGit, false, "skip Git repository initialization")
 	c.Flags().Bool(flagMinimal, false, "create a minimal blockchain (with the minimum required Cosmos SDK modules)")
 
@@ -98,10 +99,15 @@
 		skipGit, _         = cmd.Flags().GetBool(flagSkipGit)
 		minimal, _         = cmd.Flags().GetBool(flagMinimal)
 		params, _          = cmd.Flags().GetStringSlice(flagParams)
+		moduleConfigs, _   = cmd.Flags().GetStringSlice(flagModuleConfigs)
 	)
 
-	if noDefaultModule && len(params) > 0 {
-		return errors.New("params flag is only supported if the default module is enabled")
+	if noDefaultModule {
+		if len(params) > 0 {
+			return errors.New("params flag is only supported if the default module is enabled")
+		} else if len(moduleConfigs) > 0 {
+			return errors.New("module configs flag is only supported if the default module is enabled")
+		}
 	}
 
 	cacheStorage, err := newCache(cmd)
@@ -120,6 +126,7 @@
 		skipGit,
 		minimal,
 		params,
+		moduleConfigs,
 	)
 	if err != nil {
 		return err

ignite/cmd/scaffold_configs.go

@@ -0,0 +1,79 @@
+package ignitecmd
+
+import (
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/ignite/cli/v28/ignite/pkg/cliui"
+	"github.com/ignite/cli/v28/ignite/pkg/placeholder"
+	"github.com/ignite/cli/v28/ignite/services/scaffolder"
+)
+
+// NewScaffoldConfigs returns the command to scaffold a Cosmos SDK configs into a module.
+func NewScaffoldConfigs() *cobra.Command {
+	c := &cobra.Command{
+		Use:   "configs [configs]...",
+		Short: "Configs for a custom Cosmos SDK module",
+		Long: `Scaffold a new config for a Cosmos SDK module.
+
+A Cosmos SDK module can have configurations. An example of a config is "address prefix" of the
+"auth" module. A config can be scaffolded into a module using the "--module-configs" into
+the scaffold module command or using the "scaffold configs" command. By default 
+configs are of type "string", but you can specify a type for each config. For example:
+
+	ignite scaffold configs foo baz:uint bar:bool
+
+Refer to Cosmos SDK documentation to learn more about modules, dependencies and
+configs.
+`,
+		Args:    cobra.MinimumNArgs(1),
+		PreRunE: migrationPreRunHandler,
+		RunE:    scaffoldConfigsHandler,
+	}
+
+	flagSetPath(c)
+	flagSetClearCache(c)
+
+	c.Flags().AddFlagSet(flagSetYes())
+
+	c.Flags().String(flagModule, "", "module to add the query into (default: app's main module)")
+
+	return c
+}
+
+func scaffoldConfigsHandler(cmd *cobra.Command, args []string) error {
+	var (
+		configs    = args[0:]
+		appPath    = flagGetPath(cmd)
+		moduleName = flagGetModule(cmd)
+	)
+
+	session := cliui.New(cliui.StartSpinnerWithText(statusScaffolding))
+	defer session.End()
+
+	cacheStorage, err := newCache(cmd)
+	if err != nil {
+		return err
+	}
+
+	sc, err := scaffolder.New(appPath)
+	if err != nil {
+		return err
+	}
+
+	sm, err := sc.CreateConfigs(cmd.Context(), cacheStorage, placeholder.New(), moduleName, configs...)
+	if err != nil {
+		return err
+	}
+
+	modificationsStr, err := sourceModificationToString(sm)
+	if err != nil {
+		return err
+	}
+
+	session.Println(modificationsStr)
+	session.Printf("\n🎉 New configs added to the module:\n\n- %s\n\n", strings.Join(configs, "\n- "))
+
+	return nil
+}

ignite/cmd/scaffold_module.go

@@ -25,6 +25,7 @@
 	flagDep                 = "dep"
 	flagIBC                 = "ibc"
 	flagParams              = "params"
+	flagModuleConfigs       = "module-configs"
 	flagIBCOrdering         = "ordering"
 	flagRequireRegistration = "require-registration"
 
@@ -115,6 +116,7 @@
 	c.Flags().String(flagIBCOrdering, "none", "channel ordering of the IBC module [none|ordered|unordered]")
 	c.Flags().Bool(flagRequireRegistration, false, "fail if module can't be registered")
 	c.Flags().StringSlice(flagParams, []string{}, "add module parameters")
+	c.Flags().StringSlice(flagModuleConfigs, []string{}, "add module configs")
 
 	return c
 }
@@ -133,13 +135,19 @@
 	requireRegistration, _ := cmd.Flags().GetBool(flagRequireRegistration)
 	params, _ := cmd.Flags().GetStringSlice(flagParams)
 
+	moduleConfigs, err := cmd.Flags().GetStringSlice(flagModuleConfigs)
+	if err != nil {
+		return err
+	}
+
 	cacheStorage, err := newCache(cmd)
 	if err != nil {
 		return err
 	}
 
 	options := []scaffolder.ModuleCreationOption{
 		scaffolder.WithParams(params),
+		scaffolder.WithModuleConfigs(moduleConfigs),
 	}
 
 	// Check if the module must be an IBC module

ignite/cmd/scaffold_params.go

@@ -0,0 +1,81 @@
+package ignitecmd
+
+import (
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/ignite/cli/v28/ignite/pkg/cliui"
+	"github.com/ignite/cli/v28/ignite/pkg/placeholder"
+	"github.com/ignite/cli/v28/ignite/services/scaffolder"
+)
+
+// NewScaffoldParams returns the command to scaffold a Cosmos SDK parameters into a module.
+func NewScaffoldParams() *cobra.Command {
+	c := &cobra.Command{
+		Use:   "params [param]...",
+		Short: "Parameters for a custom Cosmos SDK module",
+		Long: `Scaffold a new parameter for a Cosmos SDK module.
+
+A Cosmos SDK module can have parameters (or "params"). Params are values that
+can be set at the genesis of the blockchain and can be modified while the
+blockchain is running. An example of a param is "Inflation rate change" of the
+"mint" module. A params can be scaffolded into a module using the "--params" into
+the scaffold module command or using the "scaffold params" command. By default 
+params are of type "string", but you can specify a type for each param. For example:
+
+	ignite scaffold params foo baz:uint bar:bool
+
+Refer to Cosmos SDK documentation to learn more about modules, dependencies and
+params.
+`,
+		Args:    cobra.MinimumNArgs(1),
+		PreRunE: migrationPreRunHandler,
+		RunE:    scaffoldParamsHandler,
+	}
+
+	flagSetPath(c)
+	flagSetClearCache(c)
+
+	c.Flags().AddFlagSet(flagSetYes())
+
+	c.Flags().String(flagModule, "", "module to add the query into. Default: app's main module")
+
+	return c
+}
+
+func scaffoldParamsHandler(cmd *cobra.Command, args []string) error {
+	var (
+		params     = args[0:]
+		appPath    = flagGetPath(cmd)
+		moduleName = flagGetModule(cmd)
+	)
+
+	session := cliui.New(cliui.StartSpinnerWithText(statusScaffolding))
+	defer session.End()
+
+	cacheStorage, err := newCache(cmd)
+	if err != nil {
+		return err
+	}
+
+	sc, err := scaffolder.New(appPath)
+	if err != nil {
+		return err
+	}
+
+	sm, err := sc.CreateParams(cmd.Context(), cacheStorage, placeholder.New(), moduleName, params...)
+	if err != nil {
+		return err
+	}
+
+	modificationsStr, err := sourceModificationToString(sm)
+	if err != nil {
+		return err
+	}
+
+	session.Println(modificationsStr)
+	session.Printf("\n🎉 New parameters added to the module:\n\n- %s\n\n", strings.Join(params, "\n- "))
+
+	return nil
+}

ignite/pkg/goanalysis/goanalysis.go

@@ -338,3 +338,59 @@
 	}
 	return nil
 }
+
+// HasAnyStructFieldsInPkg finds the struct within a package folder and checks
+// if any of the fields are defined in the struct.
+func HasAnyStructFieldsInPkg(pkgPath, structName string, fields []string) (bool, error) {
+	absPath, err := filepath.Abs(pkgPath)
+	if err != nil {
+		return false, err
+	}
+	fileSet := token.NewFileSet()
+	all, err := parser.ParseDir(fileSet, absPath, nil, parser.ParseComments)
+	if err != nil {
+		return false, err
+	}
+
+	fieldsNames := make(map[string]struct{})
+	for _, field := range fields {
+		fieldsNames[strings.ToLower(field)] = struct{}{}
+	}
+
+	exist := false
+	for _, pkg := range all {
+		for _, f := range pkg.Files {
+			ast.Inspect(f, func(x ast.Node) bool {
+				typeSpec, ok := x.(*ast.TypeSpec)
+				if !ok {
+					return true
+				}
+
+				if _, ok := typeSpec.Type.(*ast.StructType); !ok ||
+					typeSpec.Name.Name != structName ||
+					typeSpec.Type == nil {
+					return true
+				}
+
+				// Check if the struct has fields.
+				structType, ok := typeSpec.Type.(*ast.StructType)
+				if !ok {
+					return true
+				}
+
+				// Iterate through the fields of the struct.
+				for _, field := range structType.Fields.List {
+					for _, fieldName := range field.Names {
+						if _, ok := fieldsNames[strings.ToLower(fieldName.Name)]; !ok {
+							continue
+						}
+						exist = true
+						return false
+					}
+				}
+				return true
+			})
+		}
+	}
+	return exist, nil
+}