chore: Bumping boilerplate (#4805)

* chore: Bumping Boilerplate to `v0.10.0`

* fix: Adding support for `no-shell` and `no-hooks`

* feat: Adding tests for scaffold

* fix: Fixing initialization of BoilerplateOptions

* chore: Refactoring out shared `scaffold` flags to `shared`

* docs: Updating docs with additional call-out

* chore: Upgrading `boilerplate`

* fix: Addressing lints

* fix: Fixing test for Boilerplate bump

* fix: Addressing lints

* fix: Ignoring boilerplated configurations during tests

Author: yhakbar

cli/commands/catalog/cli.go

@@ -5,6 +5,7 @@ package catalog
 import (
 	"github.com/gruntwork-io/terragrunt/cli/commands/scaffold"
 	"github.com/gruntwork-io/terragrunt/cli/flags"
+	"github.com/gruntwork-io/terragrunt/cli/flags/shared"
 	"github.com/gruntwork-io/terragrunt/internal/cli"
 	"github.com/gruntwork-io/terragrunt/options"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
@@ -15,10 +16,7 @@ const (
 )
 
 func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
-	return scaffold.NewFlags(opts, prefix).Filter(
-		scaffold.RootFileNameFlagName,
-		scaffold.NoIncludeRootFlagName,
-	)
+	return shared.NewScaffoldingFlags(opts, prefix)
 }
 
 func NewCommand(l log.Logger, opts *options.TerragruntOptions) *cli.Command {

cli/commands/scaffold/cli.go

@@ -8,9 +8,9 @@ import (
 
 	runCmd "github.com/gruntwork-io/terragrunt/cli/commands/run"
 	"github.com/gruntwork-io/terragrunt/cli/flags"
+	"github.com/gruntwork-io/terragrunt/cli/flags/shared"
 	"github.com/gruntwork-io/terragrunt/config"
 	"github.com/gruntwork-io/terragrunt/internal/cli"
-	"github.com/gruntwork-io/terragrunt/internal/errors"
 	"github.com/gruntwork-io/terragrunt/internal/strict/controls"
 	"github.com/gruntwork-io/terragrunt/options"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
@@ -19,49 +19,20 @@ import (
 const (
 	CommandName = "scaffold"
 
-	RootFileNameFlagName  = "root-file-name"
-	NoIncludeRootFlagName = "no-include-root"
-	OutputFolderFlagName  = "output-folder"
-	VarFlagName           = "var"
-	VarFileFlagName       = "var-file"
-	NoDependencyPrompt    = "no-dependency-prompt"
+	OutputFolderFlagName = "output-folder"
+	VarFlagName          = "var"
+	VarFileFlagName      = "var-file"
+	NoDependencyPrompt   = "no-dependency-prompt"
 )
 
 func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 	tgPrefix := prefix.Prepend(flags.TgPrefix)
 
-	return cli.Flags{
-		flags.NewFlag(&cli.GenericFlag[string]{
-			Name:        RootFileNameFlagName,
-			EnvVars:     tgPrefix.EnvVars(RootFileNameFlagName),
-			Destination: &opts.ScaffoldRootFileName,
-			Usage:       "Name of the root Terragrunt configuration file, if used.",
-			Action: func(ctx *cli.Context, value string) error {
-				if value == "" {
-					return errors.New("root-file-name flag cannot be empty")
-				}
-
-				if value != opts.TerragruntConfigPath {
-					opts.ScaffoldRootFileName = value
-
-					return nil
-				}
-
-				if err := opts.StrictControls.FilterByNames(controls.RootTerragruntHCL).Evaluate(ctx); err != nil {
-					return cli.NewExitError(err, cli.ExitCodeGeneralError)
-				}
-
-				return nil
-			},
-		}),
-
-		flags.NewFlag(&cli.BoolFlag{
-			Name:        NoIncludeRootFlagName,
-			EnvVars:     tgPrefix.EnvVars(NoIncludeRootFlagName),
-			Destination: &opts.ScaffoldNoIncludeRoot,
-			Usage:       "Do not include root unit in scaffolding done by catalog.",
-		}),
+	// Start with shared scaffolding flags
+	scaffoldFlags := shared.NewScaffoldingFlags(opts, prefix)
 
+	// Add scaffold-specific flags
+	scaffoldFlags = append(scaffoldFlags,
 		flags.NewFlag(&cli.GenericFlag[string]{
 			Name:        OutputFolderFlagName,
 			Destination: &opts.ScaffoldOutputFolder,
@@ -88,7 +59,9 @@ func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 			Destination: &opts.NoDependencyPrompt,
 			Usage:       "Do not prompt for confirmation to include dependencies.",
 		}),
-	}
+	)
+
+	return scaffoldFlags
 }
 
 func NewCommand(l log.Logger, opts *options.TerragruntOptions) *cli.Command {

cli/commands/scaffold/scaffold.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"github.com/gruntwork-io/terragrunt/cli/commands/hcl/format"
+	"github.com/gruntwork-io/terragrunt/cli/flags/shared"
 	"github.com/gruntwork-io/terragrunt/config"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 	"github.com/gruntwork-io/terragrunt/shell"
@@ -106,7 +107,31 @@ const (
 	rootFileName      = "RootFileName"
 )
 
+// NewBoilerplateOptions creates a new BoilerplateOptions struct
+func NewBoilerplateOptions(
+	templateFolder,
+	outputFolder string,
+	vars map[string]any,
+	terragruntOpts *options.TerragruntOptions,
+) *boilerplate_options.BoilerplateOptions {
+	return &boilerplate_options.BoilerplateOptions{
+		TemplateFolder:          templateFolder,
+		OutputFolder:            outputFolder,
+		OnMissingKey:            boilerplate_options.DefaultMissingKeyAction,
+		OnMissingConfig:         boilerplate_options.DefaultMissingConfigAction,
+		Vars:                    vars,
+		ShellCommandAnswers:     map[string]bool{},
+		NoShell:                 terragruntOpts.NoShell,
+		NoHooks:                 terragruntOpts.NoHooks,
+		NonInteractive:          terragruntOpts.NonInteractive,
+		DisableDependencyPrompt: terragruntOpts.NoDependencyPrompt,
+	}
+}
+
 func Run(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, moduleURL, templateURL string) error {
+	// Apply catalog configuration settings, with CLI flags taking precedence
+	applyCatalogConfigToScaffold(ctx, l, opts)
+
 	// download remote repo to local
 	var dirsToClean []string
 	// clean all temp dirs
@@ -186,27 +211,25 @@ func Run(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, mod
 	if _, found := vars[enableRootInclude]; !found {
 		vars[enableRootInclude] = !opts.ScaffoldNoIncludeRoot
 	} else {
-		l.Warnf("The %s variable is already set in the var flag(s). The --%s flag will be ignored.", enableRootInclude, NoIncludeRootFlagName)
+		l.Warnf(
+			"The %s variable is already set in the var flag(s). The --%s flag will be ignored.",
+			enableRootInclude,
+			shared.NoIncludeRootFlagName,
+		)
 	}
 
 	if _, found := vars[rootFileName]; !found {
 		vars[rootFileName] = opts.ScaffoldRootFileName
 	} else {
-		l.Warnf("The %s variable is already set in the var flag(s). The --%s flag will be ignored.", rootFileName, NoIncludeRootFlagName)
+		l.Warnf(
+			"The %s variable is already set in the var flag(s). The --%s flag will be ignored.",
+			rootFileName,
+			shared.NoIncludeRootFlagName,
+		)
 	}
 
 	l.Infof("Running boilerplate generation to %s", outputDir)
-	boilerplateOpts := &boilerplate_options.BoilerplateOptions{
-		OutputFolder:            outputDir,
-		OnMissingKey:            boilerplate_options.DefaultMissingKeyAction,
-		OnMissingConfig:         boilerplate_options.DefaultMissingConfigAction,
-		Vars:                    vars,
-		DisableShell:            true,
-		DisableHooks:            true,
-		NonInteractive:          opts.NonInteractive,
-		DisableDependencyPrompt: opts.NoDependencyPrompt,
-		TemplateFolder:          boilerplateDir,
-	}
+	boilerplateOpts := NewBoilerplateOptions(boilerplateDir, outputDir, vars, opts)
 
 	emptyDep := variables.Dependency{}
 	if err := templates.ProcessTemplate(boilerplateOpts, boilerplateOpts, emptyDep); err != nil {
@@ -224,22 +247,72 @@ func Run(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, mod
 	return nil
 }
 
+// applyCatalogConfigToScaffold applies catalog configuration settings to scaffold options.
+// CLI flags take precedence over config file settings.
+func applyCatalogConfigToScaffold(ctx context.Context, l log.Logger, opts *options.TerragruntOptions) {
+	catalogCfg, err := config.ReadCatalogConfig(ctx, l, opts)
+	if err != nil {
+		// Don't fail if catalog config can't be read - it's optional
+		l.Debugf("Could not read catalog config for scaffold: %v", err)
+		return
+	}
+
+	if catalogCfg == nil {
+		return
+	}
+
+	// Apply config settings only if CLI flags weren't explicitly set
+	// Since both NoShell and NoHooks default to false, we apply the config value
+	// only if it's true (enabling the restriction)
+	if catalogCfg.NoShell != nil && *catalogCfg.NoShell && !opts.NoShell {
+		l.Debugf("Applying catalog config: no_shell = true")
+
+		opts.NoShell = true
+	}
+
+	if catalogCfg.NoHooks != nil && *catalogCfg.NoHooks && !opts.NoHooks {
+		l.Debugf("Applying catalog config: no_hooks = true")
+
+		opts.NoHooks = true
+	}
+}
+
 // generateDefaultTemplate - write default template to provided dir
 func generateDefaultTemplate(boilerplateDir string) (string, error) {
 	const ownerWriteGlobalReadPerms = 0644
-	if err := os.WriteFile(util.JoinPath(boilerplateDir, config.DefaultTerragruntConfigPath), []byte(DefaultTerragruntTemplate), ownerWriteGlobalReadPerms); err != nil {
+	if err := os.WriteFile(
+		util.JoinPath(
+			boilerplateDir,
+			config.DefaultTerragruntConfigPath,
+		),
+		[]byte(DefaultTerragruntTemplate),
+		ownerWriteGlobalReadPerms,
+	); err != nil {
 		return "", errors.New(err)
 	}
 
-	if err := os.WriteFile(util.JoinPath(boilerplateDir, "boilerplate.yml"), []byte(DefaultBoilerplateConfig), ownerWriteGlobalReadPerms); err != nil {
+	if err := os.WriteFile(
+		util.JoinPath(
+			boilerplateDir,
+			"boilerplate.yml",
+		),
+		[]byte(DefaultBoilerplateConfig),
+		ownerWriteGlobalReadPerms,
+	); err != nil {
 		return "", errors.New(err)
 	}
 
 	return boilerplateDir, nil
 }
 
 // downloadTemplate - parse URL, download files, and handle subfolders
-func downloadTemplate(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, templateURL string, tempDir string) (string, error) {
+func downloadTemplate(
+	ctx context.Context,
+	l log.Logger,
+	opts *options.TerragruntOptions,
+	templateURL,
+	tempDir string,
+) (string, error) {
 	parsedTemplateURL, err := tf.ToSourceURL(templateURL, tempDir)
 	if err != nil {
 		return "", errors.New(err)
@@ -278,15 +351,25 @@ func downloadTemplate(ctx context.Context, l log.Logger, opts *options.Terragrun
 		templateDir = filepath.Join(templateDir, subFolder)
 		// Verify that subfolder exists
 		if _, err := os.Stat(templateDir); os.IsNotExist(err) {
-			return "", errors.Errorf("subfolder \"//%s\" not found in downloaded template from %s", subFolder, templateURL)
+			return "", errors.Errorf(
+				"subfolder \"//%s\" not found in downloaded template from %s",
+				subFolder,
+				templateURL,
+			)
 		}
 	}
 
 	return templateDir, nil
 }
 
 // prepareBoilerplateFiles - prepare boilerplate files from provided template, tf module, or (custom) default template
-func prepareBoilerplateFiles(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, templateURL string, tempDir string) (string, error) {
+func prepareBoilerplateFiles(
+	ctx context.Context,
+	l log.Logger,
+	opts *options.TerragruntOptions,
+	templateURL,
+	tempDir string,
+) (string, error) {
 	boilerplateDir := util.JoinPath(tempDir, util.DefaultBoilerplateDir)
 
 	// process template url if it was passed. This overrides the .boilerplate folder in the OpenTofu/Terraform module
@@ -335,7 +418,11 @@ func prepareBoilerplateFiles(ctx context.Context, l log.Logger, opts *options.Te
 }
 
 // parseVariables - parse variables from tf files.
-func parseVariables(l log.Logger, opts *options.TerragruntOptions, moduleDir string) ([]*config.ParsedVariable, []*config.ParsedVariable, error) {
+func parseVariables(
+	l log.Logger,
+	opts *options.TerragruntOptions,
+	moduleDir string,
+) ([]*config.ParsedVariable, []*config.ParsedVariable, error) {
 	inputs, err := config.ParseVariables(l, opts, moduleDir)
 	if err != nil {
 		return nil, nil, errors.New(err)
@@ -359,7 +446,13 @@ func parseVariables(l log.Logger, opts *options.TerragruntOptions, moduleDir str
 }
 
 // parseModuleURL - parse module url and rewrite it if required
-func parseModuleURL(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, vars map[string]any, moduleURL string) (string, error) {
+func parseModuleURL(
+	ctx context.Context,
+	l log.Logger,
+	opts *options.TerragruntOptions,
+	vars map[string]any,
+	moduleURL string,
+) (string, error) {
 	parsedModuleURL, err := tf.ToSourceURL(moduleURL, opts.WorkingDir)
 	if err != nil {
 		return "", errors.New(err)
@@ -385,7 +478,12 @@ func parseModuleURL(ctx context.Context, l log.Logger, opts *options.TerragruntO
 
 // rewriteModuleURL rewrites module url to git ssh if required
 // github.com/gruntwork-io/terragrunt.git//test/fixtures/inputs => git::https://github.com/gruntwork-io/terragrunt.git//test/fixtures/inputs
-func rewriteModuleURL(l log.Logger, opts *options.TerragruntOptions, vars map[string]any, moduleURL string) (*url.URL, error) {
+func rewriteModuleURL(
+	l log.Logger,
+	opts *options.TerragruntOptions,
+	vars map[string]any,
+	moduleURL string,
+) (*url.URL, error) {
 	var updatedModuleURL = moduleURL
 
 	sourceURLType := sourceURLTypeHTTPS
@@ -428,7 +526,12 @@ func rewriteModuleURL(l log.Logger, opts *options.TerragruntOptions, vars map[st
 
 // rewriteTemplateURL rewrites template url with reference to tag
 // github.com/denis256/terragrunt-tests.git//scaffold/base-template => github.com/denis256/terragrunt-tests.git//scaffold/base-template?ref=v0.53.8
-func rewriteTemplateURL(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, parsedTemplateURL *url.URL) (*url.URL, error) {
+func rewriteTemplateURL(
+	ctx context.Context,
+	l log.Logger,
+	opts *options.TerragruntOptions,
+	parsedTemplateURL *url.URL,
+) (*url.URL, error) {
 	var (
 		updatedTemplateURL = parsedTemplateURL
 		templateParams     = updatedTemplateURL.Query()
@@ -459,7 +562,13 @@ func rewriteTemplateURL(ctx context.Context, l log.Logger, opts *options.Terragr
 }
 
 // addRefToModuleURL adds ref to module url if is passed through variables or find it from git tags
-func addRefToModuleURL(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, parsedModuleURL *url.URL, vars map[string]any) (*url.URL, error) {
+func addRefToModuleURL(
+	ctx context.Context,
+	l log.Logger,
+	opts *options.TerragruntOptions,
+	parsedModuleURL *url.URL,
+	vars map[string]any,
+) (*url.URL, error) {
 	var moduleURL = parsedModuleURL
 	// append ref to source url, if is passed through variables or find it from git tags
 	params := moduleURL.Query()