implement map => map[string]string beautified output (inl. unit tests)

Author: C0DE8

bmfmt.go

@@ -8,7 +8,23 @@ import (
 	"strings"
 )
 
-// Beautify prints a given map (any key and value type) to a better readable format
+var keyTypePadLen = 3
+var valueTypePadLen = 3
+
+var keyDelim = map[string]string{
+	"open":  "[",
+	"close": "]",
+}
+var keyValueSep = ": "
+var valDelim = map[string]string{
+	"open":  "",
+	"close": "",
+}
+
+var rowTmpl = keyDelim["open"] + " %v  %v " + keyDelim["close"] +
+	keyValueSep + valDelim["open"] + "%v  %v" + valDelim["close"] + "\n"
+
+// Beautify prints a given map (any key and value type) to  better readable format
 func Beautify(a interface{}) error {
 
 	// prevent argument a NOT to be a map
@@ -21,6 +37,15 @@ func Beautify(a interface{}) error {
 
 	switch {
 
+	// map structure is => map[string]string
+	case keyType == reflect.String && // is key of type <string>
+		valueType == reflect.String: // is value of type <string>
+
+		var targetType map[string]string
+		var convertedArg = reflect.ValueOf(a).Convert(reflect.TypeOf(targetType)).Interface().(map[string]string)
+
+		printMapKeyStringWithStrings(convertedArg)
+
 	// map structure is => map[string][]string
 	case keyType == reflect.String && // is key of type <string>
 		valueType == reflect.Slice && // is value of type <slice>
@@ -39,29 +64,63 @@ func Beautify(a interface{}) error {
 	return nil
 }
 
-// printMapKeyStringWithSliceOfStrings prints out a map with string keys and slice of strings as value
-func printMapKeyStringWithSliceOfStrings(aMap map[string][]string) {
+// printMapKeyStringWithString prints out a map with string keys and strings as value
+func printMapKeyStringWithStrings(aMap map[string]string) {
+	maxKeyLength, maxValueLength := getMaxLengthOfKeyStringValueString(aMap)
+
+	for key, value := range aMap {
+		maxKeyStringLen := len("string(" + string(maxKeyLength) + ")")
+		keyType := fmt.Sprintf("string(%v)", leftPad(strconv.Itoa(len(key)), " ", keyTypePadLen))
+		maxValueStringLen := len("string(" + string(maxValueLength) + ")")
+		valueType := fmt.Sprintf("string(%v)", leftPad(strconv.Itoa(len(value)), " ", valueTypePadLen))
+		fmt.Printf(
+			rowTmpl,
+			rightPad("\""+key+"\"", " ", maxKeyLength+2),
+			rightPad(keyType, " ", maxKeyStringLen+1),
+			rightPad("\""+value+"\"", " ", maxValueLength+2),
+			leftPad(valueType, " ", maxValueStringLen+1),
+		)
+	}
+}
 
-	var stringPadLen = 3
+// getMaxLengthOfKeyStringValueString detects the max. length of the key, value and value count
+func getMaxLengthOfKeyStringValueString(aMap map[string]string) (int, int) {
+	var maxKeyLength = 0
+	var maxValueLength = 0
 
-	maxKeyLength, maxValueLength, maxValueCount := getMaxLength(aMap)
+	for key, value := range aMap {
+		if len(key) > maxKeyLength {
+			maxKeyLength = len(key)
+		}
+		if len(value) > maxValueLength {
+			maxValueLength = len(value)
+		}
+	}
+
+	return maxKeyLength, maxValueLength
+}
+
+// printMapKeyStringWithSliceOfStrings prints out a map with string keys and slice of strings as value
+func printMapKeyStringWithSliceOfStrings(aMap map[string][]string) {
+	maxKeyLength, maxValueLength, maxValueCount := getMaxLengthOfKeyStringSliceOfStrings(aMap)
 
 	for key, value := range aMap {
 		stringValue := strings.Join(value, "\", \"")
 		maxKeyStringLen := len("string(" + string(maxKeyLength) + ")")
-		keyTypeString := fmt.Sprintf("string(%v)", leftPad(strconv.Itoa(len(key)), " ", stringPadLen))
+		keyTypeString := fmt.Sprintf("string(%v)", leftPad(strconv.Itoa(len(key)), " ", keyTypePadLen))
+		valueType := fmt.Sprintf("string(%v)", leftPad(strconv.Itoa(len(stringValue)), " ", valueTypePadLen))
 		fmt.Printf(
-			"[ %v  %v ]: %v  string(%v)\n",
+			rowTmpl,
 			rightPad("\""+key+"\"", " ", maxKeyLength+2),
 			rightPad(keyTypeString, " ", maxKeyStringLen+1),
 			rightPad("\""+stringValue+"\"", " ", maxValueLength+(maxValueCount*2)),
-			leftPad(strconv.Itoa(len(stringValue)), " ", stringPadLen),
+			leftPad(valueType, " ", valueTypePadLen),
 		)
 	}
 }
 
-// getMaxLength detects the max. length of the key, value and value count
-func getMaxLength(aMap map[string][]string) (int, int, int) {
+// getMaxLengthOfKeyStringSliceOfStrings detects the max. length of the key, value and value count
+func getMaxLengthOfKeyStringSliceOfStrings(aMap map[string][]string) (int, int, int) {
 	var maxKeyLength = 0
 	var maxValueLength = 0
 	var maxValueCount = 0

bmfmt_test.go

@@ -19,15 +19,33 @@ func TestBeautifyCauseAnErrorOnNonMap(t *testing.T) {
 	assert.Equal(t, "given argument is NOT a map", err.Error())
 }
 
-// TestBeautifyOutputASimpleMap test a valid map[string][]string output
-func TestBeautifyOutputASimpleMap(t *testing.T) {
+// TestBeautifyOutputSimpleMapWithStringKeysAndStringValues test a simple map with string keys and string values
+func TestBeautifyOutputSimpleMapWithStringKeysAndStringValues(t *testing.T) {
+
+	var err error
+	candidateSingleValue := map[string]string{
+		"a key": "a short value",
+	}
+
+	expectedOutputSingleValue := `[ "a key"  string(  5) ]: "a short value"  string( 13)
+`
+	output := capturer.CaptureStdout(func() {
+		err = Beautify(candidateSingleValue)
+	})
+
+	assert.NoError(t, err, "nil is expected")
+	assert.Equal(t, expectedOutputSingleValue, output, "beautified map output expected (1)")
+}
+
+// TestBeautifyOutputSimpleMapWithStringKeysAndSliceOfStringValues test a valid map[string][]string output
+func TestBeautifyOutputSimpleMapWithStringKeysAndSliceOfStringValues(t *testing.T) {
 
 	var err error
 	candidateSingleValue := map[string][]string{
 		"a key": {"a single value"},
 	}
 
-	// due to the fact, that maps are NOT sorted, the output order may vary, so we ned to test both orderings
+	// due to the fact, that maps are NOT sorted, the output order may vary, so we can test 1 element in map only
 	expectedOutputSingleValue := `[ "a key"  string(  5) ]: "a single value"  string( 14)
 `
 	output := capturer.CaptureStdout(func() {