feat: generate macros file during source prep (#382)

When preparing sources for a component COMP, `azldev` will now also write out `COMP.azl.macros` with any macros computed from the component's TOML-derived (and resolved) build configuration.

Author: reubeno

internal/app/azldev/cmds/component/build.go

@@ -171,7 +171,7 @@ func BuildComponent(
 		return nil
 	}, &err)
 
-	sourcePreparer, err := sources.NewPreparer(sourceManager)
+	sourcePreparer, err := sources.NewPreparer(sourceManager, env.FS())
 	if err != nil {
 		return ComponentBuildResults{},
 			fmt.Errorf("failed to create source preparer for component %q:\n%w", component.GetName(), err)

internal/app/azldev/cmds/component/preparesources.go

@@ -84,7 +84,7 @@ func PrepareComponentSources(env *azldev.Env, options *PrepareSourcesOptions) er
 		return fmt.Errorf("failed to create source manager:\n%w", err)
 	}
 
-	preparer, err := sources.NewPreparer(sourceManager)
+	preparer, err := sources.NewPreparer(sourceManager, env.FS())
 	if err != nil {
 		return fmt.Errorf("failed to create source preparer:\n%w", err)
 	}

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

@@ -49,7 +49,7 @@ func setupBuilder(t *testing.T) *componentBuilderTestParams {
 
 	sourceManager := sourceproviders_test.NewNoOpMockSourceManager(ctrl)
 
-	preparer, err := sources.NewPreparer(sourceManager)
+	preparer, err := sources.NewPreparer(sourceManager, testEnv.Env.FS())
 
 	require.NoError(t, err)
 

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

@@ -7,11 +7,26 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"path/filepath"
+	"slices"
+	"strings"
 
 	"github.com/microsoft/azldev/internal/app/azldev/core/components"
+	"github.com/microsoft/azldev/internal/global/opctx"
+	"github.com/microsoft/azldev/internal/projectconfig"
 	"github.com/microsoft/azldev/internal/providers/sourceproviders"
+	"github.com/microsoft/azldev/internal/utils/fileperms"
+	"github.com/microsoft/azldev/internal/utils/fileutils"
+	"github.com/samber/lo"
 )
 
+// MacrosFileExtension is the file extension used for azldev-generated macros files.
+const MacrosFileExtension = ".azl.macros"
+
+// MacrosFileHeader is the comment header included at the top of generated macros files.
+const MacrosFileHeader = `# Macros file automatically generated by azldev.
+# Do not edit manually; changes will be overwritten.`
+
 // SourcePreparer is a utility for acquiring and preparing all input files required to build a component.
 // This may include the component's spec file, any loose files that must accompany it, any payload source
 // archives and patches required by the spec, etc. Preparation may also include any post-processing of these
@@ -29,18 +44,25 @@ type SourcePreparer interface {
 // Standard implementation of the [SourcePreparer] interface.
 type sourcePreparerImpl struct {
 	sourceManager sourceproviders.SourceManager
+	fs            opctx.FS
 }
 
 // NewPreparer creates a new [SourcePreparer] instance. All arguments are required.
 func NewPreparer(
 	sourceManager sourceproviders.SourceManager,
+	fs opctx.FS,
 ) (SourcePreparer, error) {
 	if sourceManager == nil {
 		return nil, errors.New("source manager cannot be nil")
 	}
 
+	if fs == nil {
+		return nil, errors.New("filesystem interface cannot be nil")
+	}
+
 	return &sourcePreparerImpl{
 		sourceManager: sourceManager,
+		fs:            fs,
 	}, nil
 }
 
@@ -55,5 +77,78 @@ func (p *sourcePreparerImpl) PrepareSources(
 			component.GetName(), err)
 	}
 
+	// Emit computed macros to a macros file.
+	err = p.writeMacrosFile(component, outputDir)
+	if err != nil {
+		return fmt.Errorf("failed to write macros file 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 {
+	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 nil
 }
+
+// GenerateMacrosFileContents generates the contents of an RPM macros file from the given
+// build configuration. The output uses standard RPM macro file format (%name value) and
+// includes a header comment identifying the file as auto-generated.
+//
+// With flags are converted to %_with_FLAG 1 macros.
+// Without flags are converted to %_without_FLAG 1 macros.
+// Defines are emitted as %name value macros.
+//
+// All macros are collected into a single map and sorted alphabetically by name for
+// deterministic output. If the same macro is defined multiple times (e.g., via both
+// a with flag and an explicit define), the later definition wins. The order of processing
+// is: with flags, then without flags, then explicit defines.
+//
+// Note: RPM macro values can contain spaces without special escaping; everything
+// after the macro name (and separating whitespace) is treated as the macro body.
+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)
+
+	// Convert 'with' flags to macros: FLAG -> _with_FLAG = 1
+	for _, with := range buildConfig.With {
+		macros["_with_"+with] = "1"
+	}
+
+	// Convert 'without' flags to macros: FLAG -> _without_FLAG = 1
+	for _, without := range buildConfig.Without {
+		macros["_without_"+without] = "1"
+	}
+
+	// Add explicit macro definitions (these override any conflicting with/without flags).
+	for name, value := range buildConfig.Defines {
+		macros[name] = value
+	}
+
+	// Sort macro names for deterministic output.
+	macroNames := lo.Keys(macros)
+	slices.Sort(macroNames)
+
+	for _, name := range macroNames {
+		lines = append(lines, fmt.Sprintf("%%%s %s", name, macros[name]))
+	}
+
+	return strings.Join(lines, "\n") + "\n"
+}