feat: prevent creating macro file if it would be empty (#473)

Author: tobiasb-ms

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

@@ -102,14 +102,23 @@ func (p *sourcePreparerImpl) PrepareSources(
 
 	if applyOverlays {
 		// Emit computed macros to a macros file in the output directory.
+		// If the build configuration produces no macros, no file is written and
+		// macrosFileName will be empty, signaling postProcessSources to skip
+		// injecting the macro load directive and Source9999 tag.
+		var macrosFileName string
+
 		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)
 		}
 
+		if macrosFilePath != "" {
+			macrosFileName = filepath.Base(macrosFilePath)
+		}
+
 		// Apply any postprocessing to the sources in-place, in the output directory.
-		err = p.postProcessSources(component, outputDir, filepath.Base(macrosFilePath))
+		err = p.postProcessSources(component, outputDir, macrosFileName)
 		if err != nil {
 			return fmt.Errorf("failed to post-process sources for component %q:\n%w", component.GetName(), err)
 		}
@@ -120,10 +129,13 @@ func (p *sourcePreparerImpl) PrepareSources(
 
 // 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). Returns
-// the path to the written macros file, which is guaranteed to be within the given outputDir.
+// If the build configuration produces no macros, no file is written and an empty path is
+// returned. Otherwise, the path to the written macros file is returned.
 func (p *sourcePreparerImpl) writeMacrosFile(component components.Component, outputDir string) (string, error) {
 	contents := GenerateMacrosFileContents(component.GetConfig().Build)
+	if contents == "" {
+		return "", nil
+	}
 
 	macrosFilePath := filepath.Join(outputDir, component.GetName()+MacrosFileExtension)
 
@@ -156,11 +168,10 @@ func (p *sourcePreparerImpl) writeMacrosFile(component components.Component, out
 //
 // Note: RPM macro values can contain spaces without special escaping; everything
 // after the macro name (and separating whitespace) is treated as the macro body.
+//
+// If no macros remain after processing (empty config, or all macros removed via
+// undefines), an empty string is returned to signal that no macros file is needed.
 func GenerateMacrosFileContents(buildConfig projectconfig.ComponentBuildConfig) string {
-	lines := []string{
-		MacrosFileHeader,
-	}
-
 	// Build a unified map of all macros. Later definitions override earlier ones.
 	// Processing order: with flags -> without flags -> explicit defines.
 	macros := make(map[string]string)
@@ -186,6 +197,14 @@ func GenerateMacrosFileContents(buildConfig projectconfig.ComponentBuildConfig)
 		delete(macros, undef)
 	}
 
+	if len(macros) == 0 {
+		return ""
+	}
+
+	lines := []string{
+		MacrosFileHeader,
+	}
+
 	// Sort macro names for deterministic output.
 	macroNames := lo.Keys(macros)
 	slices.Sort(macroNames)
@@ -215,23 +234,25 @@ 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)
+	// Compute any synthetic overlays required to load the macros file, if one was written.
+	if macrosFileName != "" {
+		macroOverlays, macroErr := synthesizeMacroLoadOverlays(macrosFileName)
+		if macroErr != nil {
+			return fmt.Errorf("failed to compute macros load overlays:\n%w", macroErr)
+		}
+
+		// 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)
+			}
+		}
 	}
 
 	// Get the file header overlay.
 	headerOverlay := generateFileHeaderOverlay()
 
-	// 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)

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

@@ -71,15 +71,16 @@ func TestPrepareSources_Success(t *testing.T) {
 	macrosFileName := "test-component" + sources.MacrosFileExtension
 	macrosFilePath := filepath.Join(testOutputDir, macrosFileName)
 
-	// Verify macros file was created.
+	// Verify macros file was NOT created (empty config has no macros).
 	exists, err := fileutils.Exists(ctx.FS(), macrosFilePath)
 	require.NoError(t, err)
-	assert.True(t, exists, "macros file should be created")
+	assert.False(t, exists, "macros file should not be created when there are no macros")
 
-	// Verify spec loads macros.
+	// Verify spec does NOT contain macro load or Source9999.
 	specContents, err := fileutils.ReadFile(ctx.FS(), outputSpecPath)
 	require.NoError(t, err)
-	assert.Contains(t, string(specContents), "%{load:%{_sourcedir}/"+macrosFileName+"}")
+	assert.NotContains(t, string(specContents), "%{load:%{_sourcedir}/"+macrosFileName+"}")
+	assert.NotContains(t, string(specContents), "Source9999")
 }
 
 func TestPrepareSources_SourceManagerError(t *testing.T) {
@@ -138,18 +139,24 @@ func TestPrepareSources_WritesMacrosFile(t *testing.T) {
 	contents, err := fileutils.ReadFile(ctx.FS(), macrosFilePath)
 	require.NoError(t, err)
 	assert.Contains(t, string(contents), "%_with_feature 1")
+
+	// Verify spec has macro load directive and Source9999 tag.
+	specPath := filepath.Join(testOutputDir, "my-package.spec")
+	specContents, err := fileutils.ReadFile(ctx.FS(), specPath)
+	require.NoError(t, err)
+
+	specStr := string(specContents)
+	assert.Contains(t, specStr, "%{load:%{_sourcedir}/my-package"+sources.MacrosFileExtension+"}")
+	assert.Contains(t, specStr, "Source9999")
 }
 
 // Tests for GenerateMacrosFileContents - these test content generation in isolation.
 
 func TestGenerateMacrosFileContents_EmptyConfig(t *testing.T) {
 	contents := sources.GenerateMacrosFileContents(projectconfig.ComponentBuildConfig{})
 
-	// Should always have header comment.
-	assert.Contains(t, contents, sources.MacrosFileHeader)
-
-	// Should end with newline.
-	assert.Equal(t, '\n', rune(contents[len(contents)-1]))
+	// Empty config should produce no macros file content.
+	assert.Empty(t, contents)
 }
 
 func TestGenerateMacrosFileContents_WithFlags(t *testing.T) {
@@ -299,7 +306,7 @@ func TestGenerateMacrosFileContents_UndefinesNonexistentMacroIsNoop(t *testing.T
 }
 
 func TestGenerateMacrosFileContents_UndefinesAllMacros(t *testing.T) {
-	// Undefining all macros should result in only the header.
+	// Undefining all macros should produce no macros file content.
 	contents := sources.GenerateMacrosFileContents(projectconfig.ComponentBuildConfig{
 		With:    []string{"tests"},
 		Without: []string{"debug"},
@@ -309,10 +316,7 @@ func TestGenerateMacrosFileContents_UndefinesAllMacros(t *testing.T) {
 		Undefines: []string{"_with_tests", "_without_debug", "dist"},
 	})
 
-	assert.Contains(t, contents, sources.MacrosFileHeader)
-	assert.NotContains(t, contents, "%_with_tests")
-	assert.NotContains(t, contents, "%_without_debug")
-	assert.NotContains(t, contents, "%dist")
+	assert.Empty(t, contents)
 }
 
 func TestGenerateMacrosFileContents_FullConfig(t *testing.T) {