From b6f876a64ab6f898c8279f9b20597a0767a71cc0 Mon Sep 17 00:00:00 2001
From: Roberto Santalla <roobre@roobre.es>
Date: Thu, 17 Mar 2022 18:23:13 +0100
Subject: [PATCH] releaseutil/kind_sorter: make lessByKind return a lessFunc
 rather than sorting directly By doing this, we only convert the KindSortOrder
 slice to a map once, rather than on each comparison step.

Co-authored-by: Alvaro Cabanas <acabanas@newrelic.com>
Co-authored-by: Paolo Gallina <paologallina1992@gmail.com>
Signed-off-by: Roberto Santalla <roobre@roobre.es>
---
 pkg/releaseutil/kind_sorter.go | 41 +++++++++++++++++++---------------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/pkg/releaseutil/kind_sorter.go b/pkg/releaseutil/kind_sorter.go
index af21475e3..44011d77b 100644
--- a/pkg/releaseutil/kind_sorter.go
+++ b/pkg/releaseutil/kind_sorter.go
@@ -111,8 +111,9 @@ var UninstallOrder KindSortOrder = []string{
 //
 // Results are sorted by 'ordering', keeping order of items with equal kind/priority
 func sortManifestsByKind(manifests []Manifest, ordering KindSortOrder) []Manifest {
+	lessFunc := lessByKind(ordering)
 	sort.SliceStable(manifests, func(i, j int) bool {
-		return lessByKind(manifests[i], manifests[j], manifests[i].Head.Kind, manifests[j].Head.Kind, ordering)
+		return lessFunc(manifests[i].Head.Kind, manifests[j].Head.Kind)
 	})
 
 	return manifests
@@ -129,8 +130,9 @@ func sortHooks(hooks []*release.Hook, ordering KindSortOrder) []*release.Hook {
 	})
 
 	// Then sort by kind, keeping equal elements in their original order (Stable).
+	lessFunc := lessByKind(ordering)
 	sort.SliceStable(h, func(i, j int) bool {
-		return lessByKind(h[i], h[j], h[i].Kind, h[j].Kind, ordering)
+		return lessFunc(h[i].Kind, h[j].Kind)
 	})
 
 	// Finally, sort by weight, again keeping equal elements in their original order.
@@ -141,29 +143,32 @@ func sortHooks(hooks []*release.Hook, ordering KindSortOrder) []*release.Hook {
 	return h
 }
 
-func lessByKind(a interface{}, b interface{}, kindA string, kindB string, o KindSortOrder) bool {
+// lessByKind takes a KindSortOrder and returns a LessFunc that compares two kinds according to said order.
+func lessByKind(o KindSortOrder) func(kindA string, kindB string) bool {
 	ordering := make(map[string]int, len(o))
 	for v, k := range o {
 		ordering[k] = v
 	}
 
-	first, aok := ordering[kindA]
-	second, bok := ordering[kindB]
+	return func(kindA string, kindB string) bool {
+		first, aok := ordering[kindA]
+		second, bok := ordering[kindB]
 
-	if !aok && !bok {
-		// if both are unknown then sort alphabetically by kind, keep original order if same kind
-		if kindA != kindB {
-			return kindA < kindB
+		if !aok && !bok {
+			// if both are unknown then sort alphabetically by kind, keep original order if same kind
+			if kindA != kindB {
+				return kindA < kindB
+			}
+			return first < second
 		}
+		// unknown kind is last
+		if !aok {
+			return false
+		}
+		if !bok {
+			return true
+		}
+		// sort different kinds, keep original order if same priority
 		return first < second
 	}
-	// unknown kind is last
-	if !aok {
-		return false
-	}
-	if !bok {
-		return true
-	}
-	// sort different kinds, keep original order if same priority
-	return first < second
 }