feat: auto-load generated macros file in spec (#392)

Author: reubeno

internal/app/azldev/core/componentbuilder/componentbuilder_test.go

@@ -47,7 +47,19 @@ func setupBuilder(t *testing.T) *componentBuilderTestParams {
 	workDirFactory, err := workdir.NewFactory(testEnv.Env.FS(), testEnv.Env.WorkDir(), testEnv.Env.ConstructionTime())
 	require.NoError(t, err)
 
-	sourceManager := sourceproviders_test.NewNoOpMockSourceManager(ctrl)
+	sourceManager := sourceproviders_test.NewMockSourceManager(ctrl)
+
+	// Configure the source manager to create a spec file when FetchComponent is called.
+	sourceManager.EXPECT().FetchComponent(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(
+		func(ctx context.Context, component components.Component, outputDir string) error {
+			// Create the expected spec file.
+			specPath := filepath.Join(outputDir, component.GetName()+".spec")
+
+			return fileutils.WriteFile(testEnv.Env.FS(), specPath, []byte("# test spec"), fileperms.PublicFile)
+		},
+	)
+
+	sourceManager.EXPECT().FetchFile(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 
 	preparer, err := sources.NewPreparer(sourceManager, testEnv.Env.FS(), testEnv.Env, testEnv.Env)
 

internal/app/azldev/core/sources/sourceprep.go

@@ -10,6 +10,7 @@ import (
 	"path/filepath"
 	"slices"
 	"strings"
+	"unicode"
 
 	"github.com/gim-home/azldev-preview/internal/app/azldev/core/components"
 	"github.com/gim-home/azldev-preview/internal/global/opctx"
@@ -91,36 +92,37 @@ func (p *sourcePreparerImpl) PrepareSources(
 			component.GetName(), err)
 	}
 
-	// Apply any postprocessing to the sources in-place, in the output directory.
-	err = p.postProcessSources(component, outputDir)
-	if err != nil {
-		return fmt.Errorf("failed to post-process sources for component %q:\n%w", component.GetName(), err)
-	}
-
 	// Emit computed macros to a macros file in the output directory.
-	err = p.writeMacrosFile(component, outputDir)
+	macrosFilePath, err := p.writeMacrosFile(component, outputDir)
 	if err != nil {
 		return fmt.Errorf("failed to write macros file for component %#q:\n%w",
 			component.GetName(), err)
 	}
 
+	// Apply any postprocessing to the sources in-place, in the output directory.
+	err = p.postProcessSources(component, outputDir, filepath.Base(macrosFilePath))
+	if err != nil {
+		return fmt.Errorf("failed to post-process sources for component %q:\n%w", component.GetName(), err)
+	}
+
 	return nil
 }
 
 // writeMacrosFile writes a macros file containing the resolved macros for a component.
 // This includes with/without flags converted to macro format, and any explicit defines.
-// The file is always created, even if empty (aside from the header comment).
-func (p *sourcePreparerImpl) writeMacrosFile(component components.Component, outputDir string) error {
+// The file is always created, even if empty (aside from the header comment). Returns
+// the path to the written macros file, which is guaranteed to be within the given outputDir.
+func (p *sourcePreparerImpl) writeMacrosFile(component components.Component, outputDir string) (string, error) {
 	contents := GenerateMacrosFileContents(component.GetConfig().Build)
 
 	macrosFilePath := filepath.Join(outputDir, component.GetName()+MacrosFileExtension)
 
 	err := fileutils.WriteFile(p.fs, macrosFilePath, []byte(contents), fileperms.PublicFile)
 	if err != nil {
-		return fmt.Errorf("failed to write macros file %#q:\n%w", macrosFilePath, err)
+		return "", fmt.Errorf("failed to write macros file %#q:\n%w", macrosFilePath, err)
 	}
 
-	return nil
+	return macrosFilePath, nil
 }
 
 // GenerateMacrosFileContents generates the contents of an RPM macros file from the given
@@ -174,16 +176,12 @@ func GenerateMacrosFileContents(buildConfig projectconfig.ComponentBuildConfig)
 }
 
 func (p *sourcePreparerImpl) postProcessSources(
-	component components.Component, sourcesDirPath string,
+	component components.Component, sourcesDirPath, macrosFileName string,
 ) error {
-	// Short-circuit early if no overlays to apply.
-	if len(component.GetConfig().Overlays) == 0 {
-		return nil
-	}
-
 	event := p.eventListener.StartEvent("Applying overlays to sources", "component", component.GetName())
 	defer event.End()
 
+	// Find the spec.
 	specPath, err := findSpecInDir(p.fs, component, sourcesDirPath)
 	if err != nil {
 		return fmt.Errorf("failed to find spec in acquired sources dir %#q:\n%w", sourcesDirPath, err)
@@ -195,6 +193,21 @@ func (p *sourcePreparerImpl) postProcessSources(
 		return fmt.Errorf("failed to get absolute path for %#q:\n%w", specPath, err)
 	}
 
+	// Compute any synthetic overlays required to load the macros file.
+	macroOverlays, err := synthesizeMacroLoadOverlays(macrosFileName)
+	if err != nil {
+		return fmt.Errorf("failed to compute macros load overlays:\n%w", err)
+	}
+
+	// Apply those overlays *first*, in sequence.
+	for _, overlay := range macroOverlays {
+		err = ApplyOverlayToSources(p.dryRunnable, p.fs, overlay, sourcesDirPath, absSpecPath)
+		if err != nil {
+			return fmt.Errorf("failed to apply system overlay to sources for component %#q:\n%w", component.GetName(), err)
+		}
+	}
+
+	// Apply all overlays in sequence.
 	for _, overlay := range component.GetConfig().Overlays {
 		err = ApplyOverlayToSources(p.dryRunnable, p.fs, overlay, sourcesDirPath, absSpecPath)
 		if err != nil {
@@ -205,6 +218,39 @@ func (p *sourcePreparerImpl) postProcessSources(
 	return nil
 }
 
+func synthesizeMacroLoadOverlays(macrosFileName string) ([]projectconfig.ComponentOverlay, error) {
+	// Basic check that the macros file name is valid and doesn't require escaping.
+	if strings.ContainsFunc(macrosFileName, func(r rune) bool {
+		return !unicode.IsLetter(r) && !unicode.IsDigit(r) && r != '.' && r != '-' && r != '_'
+	}) {
+		return nil, fmt.Errorf(
+			"macros file name %#q contains invalid characters; does the component name contain invalid characters?",
+			macrosFileName,
+		)
+	}
+
+	// We inject an overlay to prepend a line to the spec to load the macros file.
+	return []projectconfig.ComponentOverlay{
+		{
+			// Prepend the %{load:...} directive to the spec.
+			Type: projectconfig.ComponentOverlayPrependSpecLines,
+			Lines: []string{
+				fmt.Sprintf("%%{load:%%{_sourcedir}/%s}", macrosFileName),
+			},
+		},
+		{
+			// Ensure that the macros file is manifested as a source in the spec so that
+			// mock and other tools know it needs to be present in the build root.
+			// Ideally we'd dynamically compute a unique source tag here, but for now
+			// we just use a high number to stay simple. If a conflict is found, this
+			// overlay application will fail.
+			Type:  projectconfig.ComponentOverlayAddSpecTag,
+			Tag:   "Source9999", // Use a high number to avoid conflicts with existing sources.
+			Value: macrosFileName,
+		},
+	}, nil
+}
+
 func findSpecInDir(
 	fs opctx.FS, component components.Component, dirPath string,
 ) (string, error) {

internal/app/azldev/core/sources/sourceprep_test.go

@@ -14,7 +14,7 @@ import (
 	"github.com/gim-home/azldev-preview/internal/global/testctx"
 	"github.com/gim-home/azldev-preview/internal/projectconfig"
 	"github.com/gim-home/azldev-preview/internal/providers/sourceproviders/sourceproviders_test"
-	"github.com/spf13/afero"
+	"github.com/gim-home/azldev-preview/internal/utils/fileutils"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
@@ -43,25 +43,42 @@ func TestNewPreparer_NilArgs(t *testing.T) {
 }
 
 func TestPrepareSources_Success(t *testing.T) {
+	const (
+		testSpecName   = "test-component.spec"
+		outputSpecPath = testOutputDir + "/" + testSpecName
+	)
+
 	ctrl := gomock.NewController(t)
 	component := components_testutils.NewMockComponent(ctrl)
 	sourceManager := sourceproviders_test.NewMockSourceManager(ctrl)
 	ctx := testctx.NewCtx()
 
 	component.EXPECT().GetName().AnyTimes().Return("test-component")
 	component.EXPECT().GetConfig().AnyTimes().Return(&projectconfig.ComponentConfig{})
-	sourceManager.EXPECT().FetchComponent(gomock.Any(), component, testOutputDir).Return(nil)
+	sourceManager.EXPECT().FetchComponent(gomock.Any(), component, testOutputDir).DoAndReturn(
+		func(_ interface{}, _ interface{}, outputDir string) error {
+			// Create the expected spec file.
+			return fileutils.WriteFile(ctx.FS(), outputSpecPath, []byte("# test spec"), 0o644)
+		},
+	)
 
 	preparer, err := sources.NewPreparer(sourceManager, ctx.FS(), ctx, ctx)
 	require.NoError(t, err)
 	err = preparer.PrepareSources(ctx, component, testOutputDir)
 	require.NoError(t, err)
 
+	macrosFileName := "test-component" + sources.MacrosFileExtension
+	macrosFilePath := filepath.Join(testOutputDir, macrosFileName)
+
 	// Verify macros file was created.
-	macrosFilePath := filepath.Join(testOutputDir, "test-component"+sources.MacrosFileExtension)
-	exists, err := afero.Exists(ctx.FS(), macrosFilePath)
+	exists, err := fileutils.Exists(ctx.FS(), macrosFilePath)
 	require.NoError(t, err)
 	assert.True(t, exists, "macros file should be created")
+
+	// Verify spec loads macros.
+	specContents, err := fileutils.ReadFile(ctx.FS(), outputSpecPath)
+	require.NoError(t, err)
+	assert.Contains(t, string(specContents), "%{load:%{_sourcedir}/"+macrosFileName+"}")
 }
 
 func TestPrepareSources_SourceManagerError(t *testing.T) {
@@ -95,7 +112,14 @@ func TestPrepareSources_WritesMacrosFile(t *testing.T) {
 			With: []string{"feature"},
 		},
 	})
-	sourceManager.EXPECT().FetchComponent(gomock.Any(), component, testOutputDir).Return(nil)
+	sourceManager.EXPECT().FetchComponent(gomock.Any(), component, testOutputDir).DoAndReturn(
+		func(_ interface{}, _ interface{}, outputDir string) error {
+			// Create the expected spec file.
+			specPath := filepath.Join(outputDir, "my-package.spec")
+
+			return fileutils.WriteFile(ctx.FS(), specPath, []byte("# test spec"), 0o644)
+		},
+	)
 
 	preparer, err := sources.NewPreparer(sourceManager, ctx.FS(), ctx, ctx)
 	require.NoError(t, err)
@@ -104,12 +128,12 @@ func TestPrepareSources_WritesMacrosFile(t *testing.T) {
 
 	// Verify file exists with expected name.
 	macrosFilePath := filepath.Join(testOutputDir, "my-package"+sources.MacrosFileExtension)
-	exists, err := afero.Exists(ctx.FS(), macrosFilePath)
+	exists, err := fileutils.Exists(ctx.FS(), macrosFilePath)
 	require.NoError(t, err)
 	assert.True(t, exists)
 
 	// Verify content is non-empty and has expected macro.
-	contents, err := afero.ReadFile(ctx.FS(), macrosFilePath)
+	contents, err := fileutils.ReadFile(ctx.FS(), macrosFilePath)
 	require.NoError(t, err)
 	assert.Contains(t, string(contents), "%_with_feature 1")
 }