Merge pull request #39 from md5/keys-function

Add "keys" function

Author: jwilder

README.md

@@ -122,6 +122,7 @@ Within those templates, the object emitted by docker-gen will have [this structu
 * *`hasPrefix $prefix $string`*: Returns whether `$prefix` is a prefix of `$string`.
 * *`hasSuffix $suffix $string`*: Returns whether `$suffix` is a suffix of `$string`.
 * *`json $value`*: Returns the JSON representation of `$value` as a `string`.
+* *`keys $map`*: Returns the keys from `$map`. If `$map` is `nil`, a `nil` is returned. If `$map` is not a `map`, an error will be thrown.
 * *`last $array`*: Returns the last value of an array.
 * *`replace $string $old $new $count`*: Replaces up to `$count` occurences of `$old` with `$new` in `$string`. Alias for [`strings.Replace`](http://golang.org/pkg/strings/#Replace)
 * *`sha1 $string`*: Returns the hexadecimal representation of the SHA1 hash of `$string`.

template.go

@@ -75,6 +75,25 @@ func hasSuffix(suffix, s string) bool {
 	return strings.HasSuffix(s, suffix)
 }
 
+func keys(input interface{}) (interface{}, error) {
+	if input == nil {
+		return nil, nil
+	}
+
+	val := reflect.ValueOf(input)
+	if val.Kind() != reflect.Map {
+		return nil, fmt.Errorf("Cannot call keys on a non-map value: %v", input)
+	}
+
+	vk := val.MapKeys()
+	k := make([]interface{}, val.Len())
+	for i, _ := range k {
+		k[i] = vk[i].Interface()
+	}
+
+	return k, nil
+}
+
 func contains(item map[string]string, key string) bool {
 	if _, ok := item[key]; ok {
 		return true
@@ -195,6 +214,7 @@ func generateFile(config Config, containers Context) bool {
 		"hasPrefix":    hasPrefix,
 		"hasSuffix":    hasSuffix,
 		"json":         marshalJson,
+		"keys":         keys,
 		"last":         arrayLast,
 		"replace":      strings.Replace,
 		"sha1":         hashSha1,

template_test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"encoding/json"
+	"reflect"
 	"testing"
 )
 
@@ -20,7 +21,60 @@ func TestContains(t *testing.T) {
 	}
 }
 
-func TestGroupByExitingKey(t *testing.T) {
+func TestKeys(t *testing.T) {
+	expected := "VIRTUAL_HOST"
+	env := map[string]string{
+		expected: "demo.local",
+	}
+
+	k, err := keys(env)
+	if err != nil {
+		t.Fatalf("Error fetching keys: %v", err)
+	}
+	vk := reflect.ValueOf(k)
+	if vk.Kind() == reflect.Invalid {
+		t.Fatalf("Got invalid kind for keys: %v", vk)
+	}
+
+	if len(env) != vk.Len() {
+		t.Fatalf("Incorrect key count; expected %s, got %s", len(env), vk.Len())
+	}
+
+	got := vk.Index(0).Interface()
+	if expected != got {
+		t.Fatalf("Incorrect key found; expected %s, got %s", expected, got)
+	}
+}
+
+func TestKeysEmpty(t *testing.T) {
+	input := map[string]int{}
+
+	k, err := keys(input)
+	if err != nil {
+		t.Fatalf("Error fetching keys: %v", err)
+	}
+	vk := reflect.ValueOf(k)
+	if vk.Kind() == reflect.Invalid {
+		t.Fatalf("Got invalid kind for keys: %v", vk)
+	}
+
+	if len(input) != vk.Len() {
+		t.Fatalf("Incorrect key count; expected %s, got %s", len(input), vk.Len())
+	}
+}
+
+func TestKeysNil(t *testing.T) {
+	k, err := keys(nil)
+	if err != nil {
+		t.Fatalf("Error fetching keys: %v", err)
+	}
+	vk := reflect.ValueOf(k)
+	if vk.Kind() != reflect.Invalid {
+		t.Fatalf("Got invalid kind for keys: %v", vk)
+	}
+}
+
+func TestGroupByExistingKey(t *testing.T) {
 	containers := []*RuntimeContainer{
 		&RuntimeContainer{
 			Env: map[string]string{