Generalize "where" using reflection

Author: md5

README.md

@@ -134,7 +134,7 @@ Within those templates, the object emitted by docker-gen will have [this structu
 * *`split $string $sep`*: Splits `$string` into a slice of substrings delimited by `$sep`. Alias for [`strings.Split`](http://golang.org/pkg/strings/#Split)
 * *`trimPrefix $prefix $string`*: If `$prefix` is a prefix of `$string`, return `$string` with `$prefix` trimmed from the beginning. Otherwise, return `$string` unchanged.
 * *`trimSuffix $suffix $string`*: If `$suffix` is a suffix of `$string`, return `$string` with `$suffix` trimmed from the end. Otherwise, return `$string` unchanged.
-* *`where $containers $fieldPath $value`*: Filters an array of `RuntimeContainer` instances based on the values of a field path expression `$fieldPath`. A field path expression is a dot-delimited list of map keys or struct member names specifying the path from container to a nested value, which must be a string. Returns an array of containers having that value.
+* *`where $entries $fieldPath $value`*: Filters an array or slice based on the values of a field path expression `$fieldPath`. A field path expression is a dot-delimited list of map keys or struct member names specifying the path from container to a nested value. Returns an array of items having that value.
 * *`whereExist $containers $fieldPath`*: Like `where`, but returns only containers where `$fieldPath` exists (is not nil).
 * *`whereNotExist $containers $fieldPath`*: Like `where`, but returns only containers where `$fieldPath` does not exist (is nil).
 * *`whereAny $containers $fieldPath $sep $values`*: Like `where`, but the string value specified by `$fieldPath` is first split by `$sep` into a list of strings. The comparison value is a string slice with possible matches. Returns containers which OR intersect these values.

reflect.go

@@ -40,7 +40,7 @@ func deepGet(item interface{}, path string) interface{} {
 				return deepGet(mapValue.Interface(), strings.Join(parts[1:], "."))
 			}
 		default:
-			log.Printf("can't group by %s\n", path)
+			log.Printf("can't group by %s (value %v, kind %s)\n", path, itemValue, itemValue.Kind())
 		}
 		return nil
 	}

template.go

@@ -67,15 +67,27 @@ func groupByKeys(entries []*RuntimeContainer, key string) []string {
 }
 
 // selects entries based on key
-func where(entries []*RuntimeContainer, key string, cmp string) []*RuntimeContainer {
-	selection := []*RuntimeContainer{}
-	for _, v := range entries {
-		value := deepGet(*v, key)
-		if value == cmp {
+func where(entries interface{}, key string, cmp interface{}) (interface{}, error) {
+	entriesVal := reflect.ValueOf(entries)
+
+	switch entriesVal.Kind() {
+	case reflect.Array, reflect.Slice:
+		break
+	default:
+		return nil, fmt.Errorf("Must pass an array or slice to 'where'; received %v", entries)
+	}
+
+	selection := make([]interface{}, 0)
+	for i := 0; i < entriesVal.Len(); i++ {
+		v := reflect.Indirect(entriesVal.Index(i)).Interface()
+
+		value := deepGet(v, key)
+		if reflect.DeepEqual(value, cmp) {
 			selection = append(selection, v)
 		}
 	}
-	return selection
+
+	return selection, nil
 }
 
 // selects entries where a key exists

template_test.go

@@ -181,12 +181,26 @@ func TestWhere(t *testing.T) {
 				"VIRTUAL_HOST": "demo1.localhost",
 			},
 			ID: "1",
+			Addresses: []Address{
+				Address{
+					IP:    "172.16.42.1",
+					Port:  "80",
+					Proto: "tcp",
+				},
+			},
 		},
 		&RuntimeContainer{
 			Env: map[string]string{
 				"VIRTUAL_HOST": "demo2.localhost",
 			},
 			ID: "2",
+			Addresses: []Address{
+				Address{
+					IP:    "172.16.42.1",
+					Port:  "9999",
+					Proto: "tcp",
+				},
+			},
 		},
 		&RuntimeContainer{
 			Env: map[string]string{
@@ -211,6 +225,19 @@ func TestWhere(t *testing.T) {
 		{`{{where . "Env.VIRTUAL_HOST" "demo2.localhost" | len}}`, containers, `2`},
 		{`{{where . "Env.VIRTUAL_HOST" "demo3.localhost" | len}}`, containers, `1`},
 		{`{{where . "Env.NOEXIST" "demo3.localhost" | len}}`, containers, `0`},
+		{`{{where .Addresses "Port" "80" | len}}`, containers[0], `1`},
+		{`{{where .Addresses "Port" "80" | len}}`, containers[1], `0`},
+		{
+			`{{where . "Value" 5 | len}}`,
+			[]struct {
+				Value int
+			}{
+				{Value: 5},
+				{Value: 3},
+				{Value: 5},
+			},
+			`2`,
+		},
 	}
 
 	for n, test := range tests {