create a type to hold dirname and manifest

vinit-chauhan · vinit-chauhan · commit 8189930a0d88 · 2025-10-27T11:21:39.000-04:00
diff --git a/cmd/filter.go b/cmd/filter.go
@@ -55,7 +55,7 @@ func filterCommandAction(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
-func filterPackage(cmd *cobra.Command) (map[string]packages.PackageManifest, error) {
+func filterPackage(cmd *cobra.Command) ([]packages.PackageDirNameAndManifest, error) {
 	filters := filter.NewFilterRegistry()
 
 	if err := filters.Parse(cmd); err != nil {
@@ -74,7 +74,7 @@ func filterPackage(cmd *cobra.Command) (map[string]packages.PackageManifest, err
 	return filtered, nil
 }
 
-func printPkgList(pkgs map[string]packages.PackageManifest, printPackageName bool, w io.Writer) error {
+func printPkgList(pkgs []packages.PackageDirNameAndManifest, printPackageName bool, w io.Writer) error {
 	enc := json.NewEncoder(w)
 	enc.SetEscapeHTML(false)
 	if len(pkgs) == 0 {
@@ -83,12 +83,12 @@ func printPkgList(pkgs map[string]packages.PackageManifest, printPackageName boo
 
 	names := make([]string, 0, len(pkgs))
 	if printPackageName {
-		for _, pkgManifest := range pkgs {
-			names = append(names, pkgManifest.Name)
+		for _, pkg := range pkgs {
+			names = append(names, pkg.Manifest.Name)
 		}
 	} else {
-		for pkgDirName := range pkgs {
-			names = append(names, pkgDirName)
+		for _, pkg := range pkgs {
+			names = append(names, pkg.DirName)
 		}
 	}
 
diff --git a/cmd/foreach.go b/cmd/foreach.go
@@ -112,8 +112,8 @@ func foreachCommandAction(cmd *cobra.Command, args []string) error {
 		}(packageChan)
 	}
 
-	for pkgName := range filtered {
-		packageChan <- pkgName
+	for _, pkg := range filtered {
+		packageChan <- pkg.DirName
 	}
 	close(packageChan)
 
diff --git a/internal/filter/category_flag.go b/internal/filter/category_flag.go
@@ -30,15 +30,15 @@ func (f *CategoryFlag) Validate() error {
 	return nil
 }
 
-func (f *CategoryFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {
-	return hasAnyMatch(f.values, pkgManifest.Categories)
+func (f *CategoryFlag) Matches(dirName string, manifest *packages.PackageManifest) bool {
+	return hasAnyMatch(f.values, manifest.Categories)
 }
 
-func (f *CategoryFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {
-	filtered := make(map[string]packages.PackageManifest, len(pkgs))
-	for pkgDirName, pkgManifest := range pkgs {
-		if f.Matches(pkgDirName, pkgManifest) {
-			filtered[pkgDirName] = pkgManifest
+func (f *CategoryFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {
+	filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		if f.Matches(pkg.DirName, pkg.Manifest) {
+			filtered = append(filtered, pkg)
 		}
 	}
 	return filtered, nil
diff --git a/internal/filter/codeowner_flag.go b/internal/filter/codeowner_flag.go
@@ -42,15 +42,15 @@ func (f *CodeOwnerFlag) Validate() error {
 	return nil
 }
 
-func (f *CodeOwnerFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {
-	return hasAnyMatch(f.values, []string{pkgManifest.Owner.Github})
+func (f *CodeOwnerFlag) Matches(dirName string, manifest *packages.PackageManifest) bool {
+	return hasAnyMatch(f.values, []string{manifest.Owner.Github})
 }
 
-func (f *CodeOwnerFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {
-	filtered := make(map[string]packages.PackageManifest, len(pkgs))
-	for pkgDirName, pkgManifest := range pkgs {
-		if f.Matches(pkgDirName, pkgManifest) {
-			filtered[pkgDirName] = pkgManifest
+func (f *CodeOwnerFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {
+	filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		if f.Matches(pkg.DirName, pkg.Manifest) {
+			filtered = append(filtered, pkg)
 		}
 	}
 	return filtered, nil
diff --git a/internal/filter/input_flag.go b/internal/filter/input_flag.go
@@ -31,22 +31,22 @@ func (f *InputFlag) Validate() error {
 	return nil
 }
 
-func (f *InputFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {
+func (f *InputFlag) Matches(dirName string, manifest *packages.PackageManifest) bool {
 	if f.values != nil {
-		inputs := extractInputs(pkgManifest)
+		inputs := extractInputs(manifest)
 		if !hasAnyMatch(f.values, inputs) {
 			return false
 		}
 	}
 	return true
 }
 
-func (f *InputFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {
-	filtered := make(map[string]packages.PackageManifest, len(pkgs))
+func (f *InputFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {
+	filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))
 
-	for pkgName, pkgManifest := range pkgs {
-		if f.Matches(pkgName, pkgManifest) {
-			filtered[pkgName] = pkgManifest
+	for _, pkg := range pkgs {
+		if f.Matches(pkg.DirName, pkg.Manifest) {
+			filtered = append(filtered, pkg)
 		}
 	}
 	return filtered, nil
diff --git a/internal/filter/integrationtype_flag.go b/internal/filter/integrationtype_flag.go
@@ -30,21 +30,20 @@ func (f *IntegrationTypeFlag) Validate() error {
 	return nil
 }
 
-func (f *IntegrationTypeFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {
+func (f *IntegrationTypeFlag) Matches(dirName string, manifest *packages.PackageManifest) bool {
 	if f.values != nil {
-		if !hasAnyMatch(f.values, []string{pkgManifest.Type}) {
+		if !hasAnyMatch(f.values, []string{manifest.Type}) {
 			return false
 		}
 	}
 	return true
 }
 
-func (f *IntegrationTypeFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {
-	filtered := make(map[string]packages.PackageManifest, len(pkgs))
-
-	for pkgName, pkgManifest := range pkgs {
-		if f.Matches(pkgName, pkgManifest) {
-			filtered[pkgName] = pkgManifest
+func (f *IntegrationTypeFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {
+	filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		if f.Matches(pkg.DirName, pkg.Manifest) {
+			filtered = append(filtered, pkg)
 		}
 	}
 	return filtered, nil
diff --git a/internal/filter/packagename_flag.go b/internal/filter/packagename_flag.go
@@ -41,20 +41,20 @@ func (f *PackageNameFlag) Validate() error {
 	return nil
 }
 
-func (f *PackageNameFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {
+func (f *PackageNameFlag) Matches(dirName string, manifest *packages.PackageManifest) bool {
 	for _, pattern := range f.patterns {
-		if pattern.Match(pkgDirName) {
+		if pattern.Match(dirName) {
 			return true
 		}
 	}
 	return false
 }
 
-func (f *PackageNameFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {
-	filtered := make(map[string]packages.PackageManifest, len(pkgs))
-	for pkgDirName, pkgManifest := range pkgs {
-		if f.Matches(pkgDirName, pkgManifest) {
-			filtered[pkgDirName] = pkgManifest
+func (f *PackageNameFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {
+	filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		if f.Matches(pkg.DirName, pkg.Manifest) {
+			filtered = append(filtered, pkg)
 		}
 	}
 	return filtered, nil
diff --git a/internal/filter/registry.go b/internal/filter/registry.go
@@ -65,7 +65,7 @@ func (r *FilterRegistry) Validate() error {
 	return nil
 }
 
-func (r *FilterRegistry) Execute() (filtered map[string]packages.PackageManifest, errors multierror.Error) {
+func (r *FilterRegistry) Execute() (filtered []packages.PackageDirNameAndManifest, errors multierror.Error) {
 	root, err := packages.MustFindIntegrationRoot()
 	if err != nil {
 		return nil, multierror.Error{err}
diff --git a/internal/filter/specversion_flag.go b/internal/filter/specversion_flag.go
@@ -40,20 +40,19 @@ func (f *SpecVersionFlag) Validate() error {
 	return nil
 }
 
-func (f *SpecVersionFlag) Matches(pkgName string, pkg packages.PackageManifest) bool {
-	pkgVersion, err := semver.NewVersion(pkg.SpecVersion)
+func (f *SpecVersionFlag) Matches(dirName string, manifest *packages.PackageManifest) bool {
+	pkgVersion, err := semver.NewVersion(manifest.SpecVersion)
 	if err != nil {
 		return false
 	}
 	return f.constraints.Check(pkgVersion)
 }
 
-func (f *SpecVersionFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (filtered map[string]packages.PackageManifest, err error) {
-	filtered = make(map[string]packages.PackageManifest, len(pkgs))
-
-	for pkgName, pkg := range pkgs {
-		if f.Matches(pkgName, pkg) {
-			filtered[pkgName] = pkg
+func (f *SpecVersionFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {
+	filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		if f.Matches(pkg.DirName, pkg.Manifest) {
+			filtered = append(filtered, pkg)
 		}
 	}
 	return filtered, nil
diff --git a/internal/filter/type.go b/internal/filter/type.go
@@ -23,10 +23,10 @@ type Filter interface {
 
 	Parse(cmd *cobra.Command) error
 	Validate() error
-	ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error)
+	ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error)
 	// Matches checks if a package matches the filter criteria.
-	// pkgDirName is the directory name of the package in package root.
-	Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool
+	// dirName is the directory name of the package in package root.
+	Matches(dirName string, manifest *packages.PackageManifest) bool
 }
 
 // FilterFlagBase provides common functionality for filter flags.
diff --git a/internal/filter/utils.go b/internal/filter/utils.go
@@ -38,10 +38,9 @@ func hasAnyMatch(filters map[string]struct{}, items []string) bool {
 }
 
 // extractInputs extracts all input types from package policy templates
-func extractInputs(pkg packages.PackageManifest) []string {
-	var inputs []string
+func extractInputs(manifest *packages.PackageManifest) []string {
 	uniqueInputs := make(map[string]struct{})
-	for _, policyTemplate := range pkg.PolicyTemplates {
+	for _, policyTemplate := range manifest.PolicyTemplates {
 		if policyTemplate.Input != "" {
 			uniqueInputs[policyTemplate.Input] = struct{}{}
 		}
@@ -51,6 +50,7 @@ func extractInputs(pkg packages.PackageManifest) []string {
 		}
 	}
 
+	inputs := make([]string, 0, len(uniqueInputs))
 	for input := range uniqueInputs {
 		inputs = append(inputs, input)
 	}
diff --git a/internal/packages/packages.go b/internal/packages/packages.go
@@ -204,6 +204,11 @@ type PackageManifest struct {
 	Elasticsearch   *Elasticsearch   `config:"elasticsearch" json:"elasticsearch" yaml:"elasticsearch"`
 }
 
+type PackageDirNameAndManifest struct {
+	DirName  string
+	Manifest *PackageManifest
+}
+
 type ManifestIndexTemplate struct {
 	IngestPipeline *ManifestIngestPipeline `config:"ingest_pipeline" json:"ingest_pipeline" yaml:"ingest_pipeline"`
 	Mappings       *ManifestMappings       `config:"mappings" json:"mappings" yaml:"mappings"`
@@ -471,20 +476,24 @@ func ReadPackageManifest(path string) (*PackageManifest, error) {
 }
 
 // ReadAllPackageManifests reads all the package manifests in the given root directory.
-func ReadAllPackageManifests(root string) (map[string]PackageManifest, error) {
+func ReadAllPackageManifests(root string) ([]PackageDirNameAndManifest, error) {
 	files, err := filepath.Glob(filepath.Join(root, "packages", "*", PackageManifestFile))
 	if err != nil {
 		return nil, fmt.Errorf("failed matching files with package manifests: %w", err)
 	}
 
-	packages := make(map[string]PackageManifest, len(files))
+	packages := make([]PackageDirNameAndManifest, 0, len(files))
 	for _, file := range files {
+		dirName := filepath.Base(filepath.Dir(file))
 		manifest, err := ReadPackageManifest(file)
 		if err != nil {
 			return nil, fmt.Errorf("failed to read package manifest: %w", err)
 		}
 
-		packages[filepath.Base(filepath.Dir(file))] = *manifest
+		packages = append(packages, PackageDirNameAndManifest{
+			DirName:  dirName,
+			Manifest: manifest,
+		})
 	}
 
 	return packages, nil

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ func filterCommandAction(cmd *cobra.Command, args []string) error {`
`55`	`55`	`return nil`
`56`	`56`	`}`
`57`	`57`
`58`		`-func filterPackage(cmd *cobra.Command) (map[string]packages.PackageManifest, error) {`
	`58`	`+func filterPackage(cmd *cobra.Command) ([]packages.PackageDirNameAndManifest, error) {`
`59`	`59`	`filters := filter.NewFilterRegistry()`
`60`	`60`
`61`	`61`	`if err := filters.Parse(cmd); err != nil {`
`@@ -74,7 +74,7 @@ func filterPackage(cmd *cobra.Command) (map[string]packages.PackageManifest, err`
`74`	`74`	`return filtered, nil`
`75`	`75`	`}`
`76`	`76`
`77`		`-func printPkgList(pkgs map[string]packages.PackageManifest, printPackageName bool, w io.Writer) error {`
	`77`	`+func printPkgList(pkgs []packages.PackageDirNameAndManifest, printPackageName bool, w io.Writer) error {`
`78`	`78`	`enc := json.NewEncoder(w)`
`79`	`79`	`enc.SetEscapeHTML(false)`
`80`	`80`	`if len(pkgs) == 0 {`
`@@ -83,12 +83,12 @@ func printPkgList(pkgs map[string]packages.PackageManifest, printPackageName boo`
`83`	`83`
`84`	`84`	`names := make([]string, 0, len(pkgs))`
`85`	`85`	`if printPackageName {`
`86`		`- for _, pkgManifest := range pkgs {`
`87`		`- names = append(names, pkgManifest.Name)`
	`86`	`+ for _, pkg := range pkgs {`
	`87`	`+ names = append(names, pkg.Manifest.Name)`
`88`	`88`	`}`
`89`	`89`	`} else {`
`90`		`- for pkgDirName := range pkgs {`
`91`		`- names = append(names, pkgDirName)`
	`90`	`+ for _, pkg := range pkgs {`
	`91`	`+ names = append(names, pkg.DirName)`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
Original file line number	Diff line number	Diff line change
`@@ -112,8 +112,8 @@ func foreachCommandAction(cmd *cobra.Command, args []string) error {`
`112`	`112`	`}(packageChan)`
`113`	`113`	`}`
`114`	`114`
`115`		`- for pkgName := range filtered {`
`116`		`- packageChan <- pkgName`
	`115`	`+ for _, pkg := range filtered {`
	`116`	`+ packageChan <- pkg.DirName`
`117`	`117`	`}`
`118`	`118`	`close(packageChan)`
`119`	`119`
Original file line number	Diff line number	Diff line change
`@@ -30,15 +30,15 @@ func (f *CategoryFlag) Validate() error {`
`30`	`30`	`return nil`
`31`	`31`	`}`
`32`	`32`
`33`		`-func (f *CategoryFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {`
`34`		`- return hasAnyMatch(f.values, pkgManifest.Categories)`
	`33`	`+func (f CategoryFlag) Matches(dirName string, manifest packages.PackageManifest) bool {`
	`34`	`+ return hasAnyMatch(f.values, manifest.Categories)`
`35`	`35`	`}`
`36`	`36`
`37`		`-func (f *CategoryFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {`
`38`		`- filtered := make(map[string]packages.PackageManifest, len(pkgs))`
`39`		`- for pkgDirName, pkgManifest := range pkgs {`
`40`		`- if f.Matches(pkgDirName, pkgManifest) {`
`41`		`- filtered[pkgDirName] = pkgManifest`
	`37`	`+func (f *CategoryFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {`
	`38`	`+ filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))`
	`39`	`+ for _, pkg := range pkgs {`
	`40`	`+ if f.Matches(pkg.DirName, pkg.Manifest) {`
	`41`	`+ filtered = append(filtered, pkg)`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`	`return filtered, nil`
Original file line number	Diff line number	Diff line change
`@@ -42,15 +42,15 @@ func (f *CodeOwnerFlag) Validate() error {`
`42`	`42`	`return nil`
`43`	`43`	`}`
`44`	`44`
`45`		`-func (f *CodeOwnerFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {`
`46`		`- return hasAnyMatch(f.values, []string{pkgManifest.Owner.Github})`
	`45`	`+func (f CodeOwnerFlag) Matches(dirName string, manifest packages.PackageManifest) bool {`
	`46`	`+ return hasAnyMatch(f.values, []string{manifest.Owner.Github})`
`47`	`47`	`}`
`48`	`48`
`49`		`-func (f *CodeOwnerFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {`
`50`		`- filtered := make(map[string]packages.PackageManifest, len(pkgs))`
`51`		`- for pkgDirName, pkgManifest := range pkgs {`
`52`		`- if f.Matches(pkgDirName, pkgManifest) {`
`53`		`- filtered[pkgDirName] = pkgManifest`
	`49`	`+func (f *CodeOwnerFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {`
	`50`	`+ filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))`
	`51`	`+ for _, pkg := range pkgs {`
	`52`	`+ if f.Matches(pkg.DirName, pkg.Manifest) {`
	`53`	`+ filtered = append(filtered, pkg)`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`return filtered, nil`
Original file line number	Diff line number	Diff line change
`@@ -31,22 +31,22 @@ func (f *InputFlag) Validate() error {`
`31`	`31`	`return nil`
`32`	`32`	`}`
`33`	`33`
`34`		`-func (f *InputFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {`
	`34`	`+func (f InputFlag) Matches(dirName string, manifest packages.PackageManifest) bool {`
`35`	`35`	`if f.values != nil {`
`36`		`- inputs := extractInputs(pkgManifest)`
	`36`	`+ inputs := extractInputs(manifest)`
`37`	`37`	`if !hasAnyMatch(f.values, inputs) {`
`38`	`38`	`return false`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`	`return true`
`42`	`42`	`}`
`43`	`43`
`44`		`-func (f *InputFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {`
`45`		`- filtered := make(map[string]packages.PackageManifest, len(pkgs))`
	`44`	`+func (f *InputFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {`
	`45`	`+ filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))`
`46`	`46`
`47`		`- for pkgName, pkgManifest := range pkgs {`
`48`		`- if f.Matches(pkgName, pkgManifest) {`
`49`		`- filtered[pkgName] = pkgManifest`
	`47`	`+ for _, pkg := range pkgs {`
	`48`	`+ if f.Matches(pkg.DirName, pkg.Manifest) {`
	`49`	`+ filtered = append(filtered, pkg)`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`	`return filtered, nil`
Original file line number	Diff line number	Diff line change
`@@ -30,21 +30,20 @@ func (f *IntegrationTypeFlag) Validate() error {`
`30`	`30`	`return nil`
`31`	`31`	`}`
`32`	`32`
`33`		`-func (f *IntegrationTypeFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {`
	`33`	`+func (f IntegrationTypeFlag) Matches(dirName string, manifest packages.PackageManifest) bool {`
`34`	`34`	`if f.values != nil {`
`35`		`- if !hasAnyMatch(f.values, []string{pkgManifest.Type}) {`
	`35`	`+ if !hasAnyMatch(f.values, []string{manifest.Type}) {`
`36`	`36`	`return false`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`return true`
`40`	`40`	`}`
`41`	`41`
`42`		`-func (f *IntegrationTypeFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {`
`43`		`- filtered := make(map[string]packages.PackageManifest, len(pkgs))`
`44`		`-`
`45`		`- for pkgName, pkgManifest := range pkgs {`
`46`		`- if f.Matches(pkgName, pkgManifest) {`
`47`		`- filtered[pkgName] = pkgManifest`
	`42`	`+func (f *IntegrationTypeFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {`
	`43`	`+ filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))`
	`44`	`+ for _, pkg := range pkgs {`
	`45`	`+ if f.Matches(pkg.DirName, pkg.Manifest) {`
	`46`	`+ filtered = append(filtered, pkg)`
`48`	`47`	`}`
`49`	`48`	`}`
`50`	`49`	`return filtered, nil`
Original file line number	Diff line number	Diff line change
`@@ -41,20 +41,20 @@ func (f *PackageNameFlag) Validate() error {`
`41`	`41`	`return nil`
`42`	`42`	`}`
`43`	`43`
`44`		`-func (f *PackageNameFlag) Matches(pkgDirName string, pkgManifest packages.PackageManifest) bool {`
	`44`	`+func (f PackageNameFlag) Matches(dirName string, manifest packages.PackageManifest) bool {`
`45`	`45`	`for _, pattern := range f.patterns {`
`46`		`- if pattern.Match(pkgDirName) {`
	`46`	`+ if pattern.Match(dirName) {`
`47`	`47`	`return true`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`	`return false`
`51`	`51`	`}`
`52`	`52`
`53`		`-func (f *PackageNameFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (map[string]packages.PackageManifest, error) {`
`54`		`- filtered := make(map[string]packages.PackageManifest, len(pkgs))`
`55`		`- for pkgDirName, pkgManifest := range pkgs {`
`56`		`- if f.Matches(pkgDirName, pkgManifest) {`
`57`		`- filtered[pkgDirName] = pkgManifest`
	`53`	`+func (f *PackageNameFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {`
	`54`	`+ filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))`
	`55`	`+ for _, pkg := range pkgs {`
	`56`	`+ if f.Matches(pkg.DirName, pkg.Manifest) {`
	`57`	`+ filtered = append(filtered, pkg)`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`	`return filtered, nil`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ func (r *FilterRegistry) Validate() error {`
`65`	`65`	`return nil`
`66`	`66`	`}`
`67`	`67`
`68`		`-func (r *FilterRegistry) Execute() (filtered map[string]packages.PackageManifest, errors multierror.Error) {`
	`68`	`+func (r *FilterRegistry) Execute() (filtered []packages.PackageDirNameAndManifest, errors multierror.Error) {`
`69`	`69`	`root, err := packages.MustFindIntegrationRoot()`
`70`	`70`	`if err != nil {`
`71`	`71`	`return nil, multierror.Error{err}`
Original file line number	Diff line number	Diff line change
`@@ -40,20 +40,19 @@ func (f *SpecVersionFlag) Validate() error {`
`40`	`40`	`return nil`
`41`	`41`	`}`
`42`	`42`
`43`		`-func (f *SpecVersionFlag) Matches(pkgName string, pkg packages.PackageManifest) bool {`
`44`		`- pkgVersion, err := semver.NewVersion(pkg.SpecVersion)`
	`43`	`+func (f SpecVersionFlag) Matches(dirName string, manifest packages.PackageManifest) bool {`
	`44`	`+ pkgVersion, err := semver.NewVersion(manifest.SpecVersion)`
`45`	`45`	`if err != nil {`
`46`	`46`	`return false`
`47`	`47`	`}`
`48`	`48`	`return f.constraints.Check(pkgVersion)`
`49`	`49`	`}`
`50`	`50`
`51`		`-func (f *SpecVersionFlag) ApplyTo(pkgs map[string]packages.PackageManifest) (filtered map[string]packages.PackageManifest, err error) {`
`52`		`- filtered = make(map[string]packages.PackageManifest, len(pkgs))`
`53`		`-`
`54`		`- for pkgName, pkg := range pkgs {`
`55`		`- if f.Matches(pkgName, pkg) {`
`56`		`- filtered[pkgName] = pkg`
	`51`	`+func (f *SpecVersionFlag) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]packages.PackageDirNameAndManifest, error) {`
	`52`	`+ filtered := make([]packages.PackageDirNameAndManifest, 0, len(pkgs))`
	`53`	`+ for _, pkg := range pkgs {`
	`54`	`+ if f.Matches(pkg.DirName, pkg.Manifest) {`
	`55`	`+ filtered = append(filtered, pkg)`
`57`	`56`	`}`
`58`	`57`	`}`
`59`	`58`	`return filtered, nil`