Implement a simple lexagraphic sort. (#755)

pkg/diff/diff.go

@@ -207,9 +207,45 @@ func (d *differ) IncrementalDiff(existing []*models.RecordConfig) (unchanged, cr
 			create = append(create, Correlation{d, nil, rec})
 		}
 	}
+
+	// Sort the lists. This is purely cosmetic.
+	sort.Slice(unchanged, func(i, j int) bool { return ChangesetLess(unchanged, i, j) })
+	sort.Slice(create, func(i, j int) bool { return ChangesetLess(create, i, j) })
+	sort.Slice(toDelete, func(i, j int) bool { return ChangesetLess(toDelete, i, j) })
+
 	return
 }
 
+func ChangesetLess(c Changeset, i, j int) bool {
+	var a, b string
+	// Which fields are we comparing?
+	// Usually only Desired OR Existing content exists (we're either
+	// adding or deleting records).  In those cases, just use whichever
+	// isn't nil.
+	// In the case where both Desired AND Existing exist, it doesn't
+	// matter which we use as long as we are consistent.  I flipped a
+	// coin and picked to use Desired in that case.
+
+	if c[i].Desired != nil {
+		a = c[i].Desired.NameFQDN
+	} else {
+		a = c[i].Existing.NameFQDN
+	}
+
+	if c[j].Desired != nil {
+		b = c[j].Desired.NameFQDN
+	} else {
+		b = c[j].Existing.NameFQDN
+	}
+
+	return a < b
+
+	// TODO(tlim): This won't correctly sort:
+	// []string{"example.com", "foo.example.com", "bar.example.com"}
+	// A simple way to do that correctly is to split on ".", reverse the
+	// elements, and sort on the result.
+}
+
 func (d *differ) ChangedGroups(existing []*models.RecordConfig) map[models.RecordKey][]string {
 	changedKeys := map[models.RecordKey][]string{}
 	_, create, delete, modify := d.IncrementalDiff(existing)