flatmap: Flatten

This commit is contained in:
Mitchell Hashimoto 2014-07-01 13:04:12 -07:00
parent fb843ea5bf
commit eb1aadf9ce
2 changed files with 140 additions and 0 deletions

73
flatmap/map.go Normal file
View File

@ -0,0 +1,73 @@
package flatmap
import (
"fmt"
"reflect"
)
type Map map[string]string
// Flatten takes a structure and turns into a flat map[string]string.
//
// Within the "thing" parameter, only primitive values are allowed. Structs are
// not supported. Therefore, it can only be slices, maps, primitives, and
// any combination of those together.
//
// See the tests for examples of what inputs are turned into.
func Flatten(thing map[string]interface{}) map[string]string {
result := make(map[string]string)
for k, raw := range thing {
flatten(result, k, reflect.ValueOf(raw))
}
return result
}
func flatten(result map[string]string, prefix string, v reflect.Value) {
if v.Kind() == reflect.Interface {
v = v.Elem()
}
switch v.Kind() {
case reflect.Bool:
if v.Bool() {
result[prefix] = "true"
} else {
result[prefix] = "false"
}
case reflect.Int:
result[prefix] = fmt.Sprintf("%d", v.Int())
case reflect.Map:
flattenMap(result, prefix, v)
case reflect.Slice:
flattenSlice(result, prefix, v)
case reflect.String:
result[prefix] = v.String()
default:
panic(fmt.Sprintf("Unknown: %s", v))
}
}
func flattenMap(result map[string]string, prefix string, v reflect.Value) {
for _, k := range v.MapKeys() {
if k.Kind() == reflect.Interface {
k = k.Elem()
}
if k.Kind() != reflect.String {
panic(fmt.Sprintf("%s: map key is not string: %s", prefix, k))
}
flatten(result, fmt.Sprintf("%s.%s", prefix, k.String()), v.MapIndex(k))
}
}
func flattenSlice(result map[string]string, prefix string, v reflect.Value) {
prefix = prefix + "."
result[prefix+"#"] = fmt.Sprintf("%d", v.Len())
for i := 0; i < v.Len(); i++ {
flatten(result, fmt.Sprintf("%s%d", prefix, i), v.Index(i))
}
}

67
flatmap/map_test.go Normal file
View File

@ -0,0 +1,67 @@
package flatmap
import (
"reflect"
"testing"
)
func TestFlatten(t *testing.T) {
cases := []struct {
Input map[string]interface{}
Output map[string]string
}{
{
Input: map[string]interface{}{
"foo": "bar",
"bar": "baz",
},
Output: map[string]string{
"foo": "bar",
"bar": "baz",
},
},
{
Input: map[string]interface{}{
"foo": []string{
"one",
"two",
},
},
Output: map[string]string{
"foo.#": "2",
"foo.0": "one",
"foo.1": "two",
},
},
{
Input: map[string]interface{}{
"foo": []map[interface{}]interface{}{
map[interface{}]interface{}{
"name": "bar",
"port": 3000,
"enabled": true,
},
},
},
Output: map[string]string{
"foo.#": "1",
"foo.0.name": "bar",
"foo.0.port": "3000",
"foo.0.enabled": "true",
},
},
}
for _, tc := range cases {
actual := Flatten(tc.Input)
if !reflect.DeepEqual(actual, tc.Output) {
t.Fatalf(
"Input:\n\n%#v\n\nOutput:\n\n%#v\n\nExpected:\n\n%#v\n",
tc.Input,
actual,
tc.Output)
}
}
}