feat: Add optional function to return manifest of generated files

Author: Tim Eijgelshoven

integration-tests/for_production_example_unix_test.go

@@ -4,7 +4,7 @@
 package integration_tests
 
 import (
-	"io/ioutil"
+	"os"
 	"path/filepath"
 	"testing"
 
@@ -19,9 +19,9 @@ func TestForProductionTerragruntArchitectureBoilerplateExample(t *testing.T) {
 
 	forProductionExamplePath := "../examples/for-production/terragrunt-architecture-catalog"
 
-	outputBasePath, err := ioutil.TempDir("", "boilerplate-for-production-output")
+	outputBasePath, err := os.MkdirTemp("", "boilerplate-for-production-output")
 	require.NoError(t, err)
-	//defer os.RemoveAll(outputBasePath)
+	defer os.RemoveAll(outputBasePath)
 
 	templateFolder, err := filepath.Abs(filepath.Join(forProductionExamplePath, "blueprints", "reference-architecture"))
 	require.NoError(t, err)

integration-tests/required_version_test.go

@@ -1,13 +1,12 @@
 package integration_tests
 
 import (
-	"io/ioutil"
 	"os"
 	"testing"
 
 	"github.com/gruntwork-io/boilerplate/cli"
 	"github.com/gruntwork-io/boilerplate/config"
-	"github.com/gruntwork-io/go-commons/errors"
+	"github.com/gruntwork-io/boilerplate/errors"
 	"github.com/gruntwork-io/go-commons/version"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -58,7 +57,7 @@ func TestRequiredVersionUnderTest(t *testing.T) {
 func runRequiredVersionExample(t *testing.T, templateFolder string) error {
 	app := cli.CreateBoilerplateCli()
 
-	outputPath, err := ioutil.TempDir("", "boilerplate-test-output-reqver")
+	outputPath, err := os.MkdirTemp("", "boilerplate-test-output-reqver")
 	require.NoError(t, err)
 	defer os.RemoveAll(outputPath)
 

manifest/manifest.go

@@ -0,0 +1,38 @@
+package manifest
+
+import (
+	"path/filepath"
+)
+
+// GeneratedFile represents a file that was generated by boilerplate
+type GeneratedFile struct {
+	Path string `json:"path"`
+}
+
+// Manifest represents the complete list of files generated by boilerplate
+type Manifest struct {
+	OutputDir string
+	Files     []GeneratedFile
+}
+
+// NewManifest creates a new manifest
+func NewManifest(outputDir string) *Manifest {
+	return &Manifest{
+		OutputDir: outputDir,
+		Files:     []GeneratedFile{},
+	}
+}
+
+// AddFile adds a generated file to the manifest
+func (m *Manifest) AddFile(outputPath string) error {
+	// Convert to relative path from output directory
+	relPath, err := filepath.Rel(m.OutputDir, outputPath)
+	if err != nil {
+		relPath = outputPath
+	}
+
+	m.Files = append(m.Files, GeneratedFile{
+		Path: relPath,
+	})
+	return nil
+}

manifest/manifest_test.go

@@ -0,0 +1,75 @@
+package manifest
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewManifest(t *testing.T) {
+	t.Parallel()
+
+	outputDir := "/test/output"
+
+	manifest := NewManifest(outputDir)
+
+	assert.Equal(t, outputDir, manifest.OutputDir)
+	assert.Empty(t, manifest.Files)
+}
+
+func TestAddFile(t *testing.T) {
+	t.Parallel()
+
+	outputDir := "/test/output"
+	manifest := NewManifest(outputDir)
+
+	// Test adding a file in the output directory
+	outputPath := filepath.Join(outputDir, "subdir", "file.txt")
+
+	err := manifest.AddFile(outputPath)
+
+	assert.NoError(t, err)
+	assert.Len(t, manifest.Files, 1)
+	assert.Equal(t, "subdir/file.txt", manifest.Files[0].Path)
+}
+
+func TestAddFileOutsideOutputDir(t *testing.T) {
+	t.Parallel()
+
+	outputDir := "/test/output"
+	manifest := NewManifest(outputDir)
+
+	// Test adding a file outside the output directory
+	outputPath := "/other/dir/file.txt"
+
+	err := manifest.AddFile(outputPath)
+
+	assert.NoError(t, err)
+	assert.Len(t, manifest.Files, 1)
+	expectedRelPath, _ := filepath.Rel(outputDir, outputPath)
+	assert.Equal(t, expectedRelPath, manifest.Files[0].Path)
+}
+
+func TestAddMultipleFiles(t *testing.T) {
+	t.Parallel()
+
+	outputDir := "/test/output"
+	manifest := NewManifest(outputDir)
+
+	// Add first file
+	err1 := manifest.AddFile(
+		filepath.Join(outputDir, "file1.txt"),
+	)
+
+	// Add second file
+	err2 := manifest.AddFile(
+		filepath.Join(outputDir, "subdir", "file2.txt"),
+	)
+
+	assert.NoError(t, err1)
+	assert.NoError(t, err2)
+	assert.Len(t, manifest.Files, 2)
+	assert.Equal(t, "file1.txt", manifest.Files[0].Path)
+	assert.Equal(t, "subdir/file2.txt", manifest.Files[1].Path)
+}

templates/template_processor.go

@@ -10,6 +10,8 @@ import (
 
 	"github.com/gruntwork-io/go-commons/collections"
 
+	"github.com/gruntwork-io/boilerplate/manifest"
+
 	"github.com/gruntwork-io/boilerplate/config"
 	"github.com/gruntwork-io/boilerplate/errors"
 	getter_helper "github.com/gruntwork-io/boilerplate/getter-helper"
@@ -22,12 +24,23 @@ import (
 // The name of the variable that contains the current value of the loop in each iteration of for_each
 const eachVarName = "__each__"
 
+// Maintaining original function name and signature for backwards compatability
+func ProcessTemplate(options, rootOpts *options.BoilerplateOptions, thisDep variables.Dependency) error {
+	_, err := processTemplateInternal(options, rootOpts, thisDep, false)
+	return err
+}
+
+// ProcessTemplateWithManifest works like ProcessTemplate but also returns the manifest of generated files
+func ProcessTemplateWithManifest(options, rootOpts *options.BoilerplateOptions, thisDep variables.Dependency) (*manifest.Manifest, error) {
+	return processTemplateInternal(options, rootOpts, thisDep, true)
+}
+
 // Process the boilerplate template specified in the given options and use the existing variables. This function will
 // download remote templates to a temporary working directory, which is cleaned up at the end of the function. This
 // function will load any missing variables (either from command line options or by prompting the user), execute all the
 // dependent boilerplate templates, and then execute this template. Note that we pass in rootOptions so that template
 // dependencies can inspect properties of the root template.
-func ProcessTemplate(options, rootOpts *options.BoilerplateOptions, thisDep variables.Dependency) error {
+func processTemplateInternal(options, rootOpts *options.BoilerplateOptions, thisDep variables.Dependency, returnManifest bool) (*manifest.Manifest, error) {
 	// If TemplateFolder is already set, use that directly as it is a local template. Otherwise, download to a temporary
 	// working directory.
 	if options.TemplateFolder == "" {
@@ -37,7 +50,7 @@ func ProcessTemplate(options, rootOpts *options.BoilerplateOptions, thisDep vari
 			os.RemoveAll(workingDir)
 		}()
 		if err != nil {
-			return err
+			return nil, err
 		}
 
 		// Set the TemplateFolder of the options to the download dir
@@ -46,56 +59,64 @@ func ProcessTemplate(options, rootOpts *options.BoilerplateOptions, thisDep vari
 
 	rootBoilerplateConfig, err := config.LoadBoilerplateConfig(rootOpts)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if err := config.EnforceRequiredVersion(rootBoilerplateConfig); err != nil {
-		return err
+		return nil, err
 	}
 
 	boilerplateConfig, err := config.LoadBoilerplateConfig(options)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if err := config.EnforceRequiredVersion(boilerplateConfig); err != nil {
-		return err
+		return nil, err
 	}
 
 	vars, err := config.GetVariables(options, boilerplateConfig, rootBoilerplateConfig, thisDep)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	err = os.MkdirAll(options.OutputFolder, 0777)
 	if err != nil {
-		return errors.WithStackTrace(err)
+		return nil, errors.WithStackTrace(err)
 	}
 
 	err = processHooks(boilerplateConfig.Hooks.BeforeHooks, options, vars)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	err = processDependencies(boilerplateConfig.Dependencies, options, boilerplateConfig.GetVariablesMap(), vars)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	partials, err := processPartials(boilerplateConfig.Partials, options, vars)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	err = processTemplateFolder(boilerplateConfig, options, vars, partials)
+	var fileManifest *manifest.Manifest
+	if returnManifest {
+		fileManifest = manifest.NewManifest(options.OutputFolder)
+	}
+
+	err = processTemplateFolder(boilerplateConfig, options, vars, partials, fileManifest)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	err = processHooks(boilerplateConfig.Hooks.AfterHooks, options, vars)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	return nil
+	if returnManifest {
+		return fileManifest, nil
+	}
+	return nil, nil
 }
 
 func processPartials(partials []string, opts *options.BoilerplateOptions, vars map[string]interface{}) ([]string, error) {
@@ -455,6 +476,7 @@ func processTemplateFolder(
 	opts *options.BoilerplateOptions,
 	variables map[string]interface{},
 	partials []string,
+	fileManifest *manifest.Manifest,
 ) error {
 	util.Logger.Printf("Processing templates in %s and outputting generated files to %s", opts.TemplateFolder, opts.OutputFolder)
 
@@ -477,7 +499,7 @@ func processTemplateFolder(
 			return createOutputDir(path, opts, variables)
 		} else {
 			engine := determineTemplateEngine(processedEngines, path)
-			return processFile(path, opts, variables, partials, engine)
+			return processFile(path, opts, variables, partials, engine, fileManifest)
 		}
 	})
 }
@@ -490,16 +512,17 @@ func processFile(
 	variables map[string]interface{},
 	partials []string,
 	engine variables.TemplateEngineType,
+	fileManifest *manifest.Manifest,
 ) error {
 	isText, err := util.IsTextFile(path)
 	if err != nil {
 		return err
 	}
 
 	if isText {
-		return processTemplate(path, opts, variables, partials, engine)
+		return processTemplate(path, opts, variables, partials, engine, fileManifest)
 	} else {
-		return copyFile(path, opts, variables)
+		return copyFile(path, opts, variables, fileManifest)
 	}
 }
 
@@ -548,14 +571,24 @@ func outPath(file string, opts *options.BoilerplateOptions, variables map[string
 }
 
 // Copy the given file, which is in options.TemplateFolder, to options.OutputFolder
-func copyFile(file string, opts *options.BoilerplateOptions, variables map[string]interface{}) error {
+func copyFile(file string, opts *options.BoilerplateOptions, variables map[string]interface{}, fileManifest *manifest.Manifest) error {
 	destination, err := outPath(file, opts, variables)
 	if err != nil {
 		return err
 	}
 
 	util.Logger.Printf("Copying %s to %s", file, destination)
-	return util.CopyFile(file, destination)
+	if err := util.CopyFile(file, destination); err != nil {
+		return err
+	}
+
+	if fileManifest != nil {
+		if err := fileManifest.AddFile(destination); err != nil {
+			return err
+		}
+	}
+
+	return nil
 }
 
 // Run the template at templatePath, which is in templateFolder, through the Go template engine with the given
@@ -566,6 +599,7 @@ func processTemplate(
 	vars map[string]interface{},
 	partials []string,
 	engine variables.TemplateEngineType,
+	fileManifest *manifest.Manifest,
 ) error {
 	destination, err := outPath(templatePath, opts, vars)
 	if err != nil {
@@ -588,7 +622,17 @@ func processTemplate(
 		destination = strings.TrimSuffix(destination, ".jsonnet")
 	}
 
-	return util.WriteFileWithSamePermissions(templatePath, destination, []byte(out))
+	if err := util.WriteFileWithSamePermissions(templatePath, destination, []byte(out)); err != nil {
+		return err
+	}
+
+	if fileManifest != nil {
+		if err := fileManifest.AddFile(destination); err != nil {
+			return err
+		}
+	}
+
+	return nil
 }
 
 // Return true if this is a path that should not be copied