spec: iterate subpackages by target

Expose target package selection as a package-level iterator so callers consume deterministic package metadata without materializing maps.

Signed-off-by: Brian Goff <cpuguy83@gmail.com>

Author: cpuguy83

subpackage.go

@@ -3,6 +3,7 @@ package dalec
 import (
 	goerrors "errors"
 	"fmt"
+	"iter"
 	"slices"
 	"unicode"
 
@@ -106,6 +107,13 @@ type SubPackage struct {
 	Replaces PackageDependencyList `yaml:"replaces,omitempty" json:"replaces,omitempty"`
 }
 
+// GetSubPackagesForTarget returns the supplemental packages defined for the
+// given target in map-key order. A missing target or a target without
+// supplemental packages yields no values.
+func GetSubPackagesForTarget(spec *Spec, target string) iter.Seq2[string, SubPackage] {
+	return SortedMapIter(spec.Targets[target].Packages)
+}
+
 // ResolvedName returns the package name that this SubPackage will produce.
 // If [SubPackage.Name] is set, it is returned as-is.
 // Otherwise, the name is "<parentName>-<mapKey>".
@@ -255,23 +263,11 @@ func validateSubPackageNames(specName, targetName string, packages map[string]Su
 	return goerrors.Join(errs...)
 }
 
-// GetSubPackages returns the supplemental packages defined for the given target.
-// Returns nil if the target does not exist or has no supplemental packages.
-func (s *Spec) GetSubPackages(targetKey string) map[string]SubPackage {
-	t, ok := s.Targets[targetKey]
-	if !ok {
-		return nil
-	}
-	return t.Packages
-}
-
 // GetAllPackageNames returns the resolved names of all packages (primary +
 // supplemental) for the given target. The primary package name is always first.
 func (s *Spec) GetAllPackageNames(targetKey string) []string {
 	names := []string{s.Name}
-	packages := s.GetSubPackages(targetKey)
-	for _, key := range SortMapKeys(packages) {
-		pkg := packages[key]
+	for key, pkg := range GetSubPackagesForTarget(s, targetKey) {
 		names = append(names, pkg.ResolvedName(s.Name, key))
 	}
 	return names

subpackage_test.go

@@ -487,34 +487,70 @@ targets:
 	assert.Check(t, cmp.Equal(contribPkg.ResolvedName("foo", "contrib"), "foo-contrib-custom"))
 }
 
-func TestGetSubPackages(t *testing.T) {
+func TestGetSubPackagesForTarget(t *testing.T) {
 	t.Parallel()
 
 	spec := &Spec{
 		Name: "foo",
 		Targets: map[string]Target{
 			"azlinux3": {
 				Packages: map[string]SubPackage{
-					"debug": {Description: "debug"},
+					"debug": {
+						Description: "debug",
+					},
+					"contrib": {
+						Name:        "custom-contrib",
+						Description: "contrib",
+					},
 				},
 			},
 			"jammy": {},
+			"other": {
+				Packages: map[string]SubPackage{
+					"other": {
+						Description: "other",
+					},
+				},
+			},
 		},
 	}
 
-	// Target with packages
-	pkgs := spec.GetSubPackages("azlinux3")
-	assert.Check(t, cmp.Equal(len(pkgs), 1))
-	_, ok := pkgs["debug"]
-	assert.Check(t, ok)
+	t.Run("A target with subpackages yields only its packages in map-key order", func(t *testing.T) {
+		t.Parallel()
 
-	// Target without packages
-	pkgs = spec.GetSubPackages("jammy")
-	assert.Check(t, cmp.Equal(len(pkgs), 0))
+		var keys []string
+		var packages []SubPackage
+		for key, pkg := range GetSubPackagesForTarget(spec, "azlinux3") {
+			keys = append(keys, key)
+			packages = append(packages, pkg)
+		}
 
-	// Non-existent target
-	pkgs = spec.GetSubPackages("nonexistent")
-	assert.Check(t, pkgs == nil)
+		assert.DeepEqual(t, keys, []string{"contrib", "debug"})
+		assert.Equal(t, packages[0].Name, "custom-contrib")
+		assert.Equal(t, packages[1].Description, "debug")
+	})
+
+	t.Run("A target without subpackages yields no values", func(t *testing.T) {
+		t.Parallel()
+
+		var count int
+		for range GetSubPackagesForTarget(spec, "jammy") {
+			count++
+		}
+
+		assert.Equal(t, count, 0)
+	})
+
+	t.Run("A missing target yields no values", func(t *testing.T) {
+		t.Parallel()
+
+		var count int
+		for range GetSubPackagesForTarget(spec, "nonexistent") {
+			count++
+		}
+
+		assert.Equal(t, count, 0)
+	})
 }
 
 func TestGetAllPackageNames(t *testing.T) {