better formatting

pkg/utils/color.go

@@ -2,12 +2,27 @@ package utils
 
 import (
 	"regexp"
+	"sync"
 )
 
+var decoloriseCache = make(map[string]string)
+var decoloriseMutex sync.Mutex
+
 // Decolorise strips a string of color
 func Decolorise(str string) string {
+	decoloriseMutex.Lock()
+	defer decoloriseMutex.Unlock()
+
+	if decoloriseCache[str] != "" {
+		return decoloriseCache[str]
+	}
+
 	re := regexp.MustCompile(`\x1B\[([0-9]{1,3}(;[0-9]{1,3})*)?[mGK]`)
-	return re.ReplaceAllString(str, "")
+	ret := re.ReplaceAllString(str, "")
+
+	decoloriseCache[str] = ret
+
+	return ret
 }
 
 func IsValidHexValue(v string) bool {

pkg/utils/formatting.go

@@ -17,14 +17,48 @@ func WithPadding(str string, padding int) string {
 }
 
 func RenderDisplayStrings(displayStringsArr [][]string) string {
+	displayStringsArr = excludeBlankColumns(displayStringsArr)
 	padWidths := getPadWidths(displayStringsArr)
-	paddedDisplayStrings := getPaddedDisplayStrings(displayStringsArr, padWidths)
+	output := getPaddedDisplayStrings(displayStringsArr, padWidths)
 
-	return strings.Join(paddedDisplayStrings, "\n")
+	return output
 }
 
-func getPaddedDisplayStrings(stringArrays [][]string, padWidths []int) []string {
+// NOTE: this mutates the input slice for the sake of performance
-	paddedDisplayStrings := make([]string, len(stringArrays))
+func excludeBlankColumns(displayStringsArr [][]string) [][]string {
+	if len(displayStringsArr) == 0 {
+		return displayStringsArr
+	}
+
+	// if all rows share a blank column, we want to remove that column
+	toRemove := []int{}
+outer:
+	for i := range displayStringsArr[0] {
+		for _, strings := range displayStringsArr {
+			if strings[i] != "" {
+				continue outer
+			}
+		}
+		toRemove = append(toRemove, i)
+	}
+
+	if len(toRemove) == 0 {
+		return displayStringsArr
+	}
+
+	// remove the columns
+	for i, strings := range displayStringsArr {
+		for j := len(toRemove) - 1; j >= 0; j-- {
+			strings = append(strings[:toRemove[j]], strings[toRemove[j]+1:]...)
+		}
+		displayStringsArr[i] = strings
+	}
+
+	return displayStringsArr
+}
+
+func getPaddedDisplayStrings(stringArrays [][]string, padWidths []int) string {
+	builder := strings.Builder{}
 	for i, stringArray := range stringArrays {
 		if len(stringArray) == 0 {
 			continue
@@ -33,14 +67,19 @@ func getPaddedDisplayStrings(stringArrays [][]string, padWidths []int) []string
 			if len(stringArray)-1 < j {
 				continue
 			}
-			paddedDisplayStrings[i] += WithPadding(stringArray[j], padWidth) + " "
+			builder.WriteString(WithPadding(stringArray[j], padWidth))
+			builder.WriteString(" ")
 		}
 		if len(stringArray)-1 < len(padWidths) {
 			continue
 		}
-		paddedDisplayStrings[i] += stringArray[len(padWidths)]
+		builder.WriteString(stringArray[len(padWidths)])
+
+		if i < len(stringArrays)-1 {
+			builder.WriteString("\n")
+		}
 	}
-	return paddedDisplayStrings
+	return builder.String()
 }
 
 func getPadWidths(stringArrays [][]string) []int {

pkg/utils/formatting_test.go

@@ -37,27 +37,6 @@ func TestWithPadding(t *testing.T) {
 	}
 }
 
-// TestGetPaddedDisplayStrings is a function.
-func TestGetPaddedDisplayStrings(t *testing.T) {
-	type scenario struct {
-		stringArrays [][]string
-		padWidths    []int
-		expected     []string
-	}
-
-	scenarios := []scenario{
-		{
-			[][]string{{"a", "b"}, {"c", "d"}},
-			[]int{1},
-			[]string{"a b", "c d"},
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, getPaddedDisplayStrings(s.stringArrays, s.padWidths))
-	}
-}
-
 func TestGetPadWidths(t *testing.T) {
 	type scenario struct {
 		input    [][]string
@@ -162,3 +141,44 @@ func TestTruncateWithEllipsis(t *testing.T) {
 		assert.EqualValues(t, s.expected, TruncateWithEllipsis(s.str, s.limit))
 	}
 }
+
+func TestRenderDisplayStrings(t *testing.T) {
+	type scenario struct {
+		input    [][]string
+		expected string
+	}
+
+	tests := []scenario{
+		{
+			[][]string{{""}, {""}},
+			"",
+		},
+		{
+			[][]string{{"a"}, {""}},
+			"a\n",
+		},
+		{
+			[][]string{{"a"}, {"b"}},
+			"a\nb",
+		},
+		{
+			[][]string{{"a", "b"}, {"c", "d"}},
+			"a b\nc d",
+		},
+		{
+			[][]string{{"a", "", "c"}, {"d", "", "f"}},
+			"a c\nd f",
+		},
+		{
+			[][]string{{"a", "", "c", ""}, {"d", "", "f", ""}},
+			"a c\nd f",
+		},
+	}
+
+	for _, test := range tests {
+		output := RenderDisplayStrings(test.input)
+		if !assert.EqualValues(t, output, test.expected) {
+			t.Errorf("RenderDisplayStrings(%v) = %v, want %v", test.input, output, test.expected)
+		}
+	}
+}

pkg/utils/utils.go

@@ -52,6 +52,13 @@ func Min(x, y int) int {
 	return y
 }
 
+func Max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
 func AsJson(i interface{}) string {
 	bytes, _ := json.MarshalIndent(i, "", "    ")
 	return string(bytes)