Improve ordering of diff and apply results

pkg/cluster/apply/format.go

@@ -15,9 +15,9 @@ func ResultsTextTable(results []Result) string {
 	table := tablewriter.NewWriter(buf)
 	table.SetHeader(
 		[]string{
+			"Namespace",
 			"Kind",
 			"Name",
-			"Namespace",
 			"Created",
 			"Old Version",
 			"New Version",
@@ -60,9 +60,9 @@ func ResultsTextTable(results []Result) string {
 
 		table.Append(
 			[]string{
+				printer("%s", result.Namespace),
 				printer("%s", result.Kind),
 				printer("%s", result.Name),
-				printer("%s", result.Namespace),
 				printer("%s", result.CreatedTimestamp()),
 				printer("%s", result.OldVersion),
 				printer("%s", result.NewVersion),

pkg/cluster/diff/format.go

@@ -14,9 +14,9 @@ func ResultsTable(results []Result) string {
 	table := tablewriter.NewWriter(buf)
 	table.SetHeader(
 		[]string{
+			"Namespace",
 			"Kind",
 			"Name",
-			"Namespace",
 			"Changed Lines",
 		},
 	)
@@ -53,9 +53,9 @@ func ResultsTable(results []Result) string {
 
 		table.Append(
 			[]string{
+				namespace,
 				kind,
 				name,
-				namespace,
 				fmt.Sprintf("%d", result.NumChangedLines()),
 			},
 		)

pkg/cluster/kube_client.go

@@ -195,7 +195,11 @@ func (cc *KubeClusterClient) ApplyStructured(
 		return nil, err
 	}
 
-	return apply.ObjsToResults(oldObjs, newObjs)
+	results, err := apply.ObjsToResults(oldObjs, newObjs)
+	if err != nil {
+		return nil, err
+	}
+	return sortedApplyResults(results), nil
 }
 
 // Diff runs a kubectl diff between the configs at the argument path and the associated
@@ -238,7 +242,7 @@ func (cc *KubeClusterClient) DiffStructured(
 	if err := json.Unmarshal(rawResults, &results); err != nil {
 		return nil, err
 	}
-	return results.Results, nil
+	return sortedDiffResults(results.Results), nil
 }
 
 // Summary returns a summary of the current cluster state.

pkg/cluster/sort.go

@@ -0,0 +1,112 @@
+package cluster
+
+import (
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/segmentio/kubeapply/pkg/cluster/apply"
+	"github.com/segmentio/kubeapply/pkg/cluster/diff"
+)
+
+type wrappedResult struct {
+	nameBase       string
+	nameIndex      int
+	namespaceBase  string
+	namespaceIndex int
+	kind           string
+	resultIndex    int
+}
+
+// sortedDiffResults sorts diff results by namespace, then resource type,
+// then resource name. If a resource name or namespace is structured as
+// [base string]-[number], then the number is used to break ties among all
+// entities with the same base.
+func sortedDiffResults(results []diff.Result) []diff.Result {
+	wrappedResults := make([]wrappedResult, len(results))
+	for r, result := range results {
+		if result.Object != nil {
+			wrappedResults[r].nameBase, wrappedResults[r].nameIndex =
+				parseName(result.Object.Name)
+			wrappedResults[r].namespaceBase, wrappedResults[r].namespaceIndex =
+				parseName(result.Object.Namespace)
+			wrappedResults[r].kind = result.Object.Kind
+		} else {
+			wrappedResults[r].namespaceBase = result.Name
+		}
+		wrappedResults[r].resultIndex = r
+	}
+
+	sortWrappedResults(wrappedResults)
+
+	sortedResults := make([]diff.Result, len(results))
+	for r, wrappedResult := range wrappedResults {
+		sortedResults[r] = results[wrappedResult.resultIndex]
+	}
+
+	return sortedResults
+}
+
+// sortedApplyResults sorts apply results by namespace, then resource type,
+// then resource name.  If a resource name or namespace is structured as
+// [base string]-[number], then the number is used to break ties among all
+// entities with the same base.
+func sortedApplyResults(results []apply.Result) []apply.Result {
+	wrappedResults := make([]wrappedResult, len(results))
+	for r, result := range results {
+		wrappedResults[r].nameBase, wrappedResults[r].nameIndex =
+			parseName(result.Name)
+		wrappedResults[r].namespaceBase, wrappedResults[r].namespaceIndex =
+			parseName(result.Namespace)
+		wrappedResults[r].kind = result.Kind
+		wrappedResults[r].resultIndex = r
+	}
+
+	sortWrappedResults(wrappedResults)
+
+	sortedResults := make([]apply.Result, len(results))
+	for r, wrappedResult := range wrappedResults {
+		sortedResults[r] = results[wrappedResult.resultIndex]
+	}
+
+	return sortedResults
+}
+
+func sortWrappedResults(wrappedResults []wrappedResult) {
+	sort.Slice(wrappedResults, func(a, b int) bool {
+		result1 := wrappedResults[a]
+		result2 := wrappedResults[b]
+		if result1.namespaceBase < result2.namespaceBase {
+			return true
+		} else if result1.namespaceBase > result2.namespaceBase {
+			return false
+		} else if result1.namespaceIndex < result2.namespaceIndex {
+			return true
+		} else if result1.namespaceIndex > result2.namespaceIndex {
+			return false
+		} else if result1.kind < result2.kind {
+			return true
+		} else if result1.kind > result2.kind {
+			return false
+		} else if result1.nameBase < result2.nameBase {
+			return true
+		} else if result1.nameBase > result2.nameBase {
+			return false
+		} else if result1.nameIndex < result2.nameIndex {
+			return true
+		}
+		return false
+	})
+}
+
+func parseName(name string) (string, int) {
+	components := strings.Split(name, "-")
+	if len(components) < 2 {
+		return name, 0
+	}
+	index, err := strconv.Atoi(components[len(components)-1])
+	if err != nil {
+		return name, 0
+	}
+	return strings.Join(components[0:len(components)-1], "-"), index
+}