fix: Don't dereference pointers in where, groupBy, sort, etc.

Author: rhansen

internal/template/groupby.go

@@ -2,7 +2,6 @@ package template
 
 import (
 	"fmt"
-	"reflect"
 	"strings"
 
 	"github.com/nginx-proxy/docker-gen/internal/context"
@@ -18,7 +17,7 @@ func generalizedGroupBy(funcName string, entries interface{}, getValue func(inte
 
 	groups := make(map[string][]interface{})
 	for i := 0; i < entriesVal.Len(); i++ {
-		v := reflect.Indirect(entriesVal.Index(i)).Interface()
+		v := entriesVal.Index(i).Interface()
 		value, err := getValue(v)
 		if err != nil {
 			return nil, err
@@ -73,13 +72,13 @@ func groupByKeys(entries interface{}, key string) ([]string, error) {
 // groupByLabel is the same as groupBy but over a given label
 func groupByLabel(entries interface{}, label string) (map[string][]interface{}, error) {
 	getLabel := func(v interface{}) (interface{}, error) {
-		if container, ok := v.(context.RuntimeContainer); ok {
+		if container, ok := v.(*context.RuntimeContainer); ok {
 			if value, ok := container.Labels[label]; ok {
 				return value, nil
 			}
 			return nil, nil
 		}
-		return nil, fmt.Errorf("must pass an array or slice of RuntimeContainer to 'groupByLabel'; received %v", v)
+		return nil, fmt.Errorf("must pass an array or slice of *RuntimeContainer to 'groupByLabel'; received %v", v)
 	}
 	return generalizedGroupBy("groupByLabel", entries, getLabel, func(groups map[string][]interface{}, value interface{}, v interface{}) {
 		groups[value.(string)] = append(groups[value.(string)], v)

internal/template/groupby_test.go

@@ -35,7 +35,7 @@ func TestGroupByExistingKey(t *testing.T) {
 	assert.Len(t, groups, 2)
 	assert.Len(t, groups["demo1.localhost"], 2)
 	assert.Len(t, groups["demo2.localhost"], 1)
-	assert.Equal(t, "3", groups["demo2.localhost"][0].(context.RuntimeContainer).ID)
+	assert.Equal(t, "3", groups["demo2.localhost"][0].(*context.RuntimeContainer).ID)
 }
 
 func TestGroupByAfterWhere(t *testing.T) {
@@ -69,7 +69,7 @@ func TestGroupByAfterWhere(t *testing.T) {
 	assert.Len(t, groups, 2)
 	assert.Len(t, groups["demo1.localhost"], 1)
 	assert.Len(t, groups["demo2.localhost"], 1)
-	assert.Equal(t, "3", groups["demo2.localhost"][0].(context.RuntimeContainer).ID)
+	assert.Equal(t, "3", groups["demo2.localhost"][0].(*context.RuntimeContainer).ID)
 }
 
 func TestGroupByKeys(t *testing.T) {
@@ -149,7 +149,7 @@ func TestGroupByLabel(t *testing.T) {
 	assert.Len(t, groups["one"], 2)
 	assert.Len(t, groups[""], 1)
 	assert.Len(t, groups["two"], 1)
-	assert.Equal(t, "2", groups["two"][0].(context.RuntimeContainer).ID)
+	assert.Equal(t, "2", groups["two"][0].(*context.RuntimeContainer).ID)
 }
 
 func TestGroupByLabelError(t *testing.T) {
@@ -193,13 +193,13 @@ func TestGroupByMulti(t *testing.T) {
 	if len(groups["demo2.localhost"]) != 1 {
 		t.Fatalf("expected 1 got %d", len(groups["demo2.localhost"]))
 	}
-	if groups["demo2.localhost"][0].(context.RuntimeContainer).ID != "3" {
-		t.Fatalf("expected 2 got %s", groups["demo2.localhost"][0].(context.RuntimeContainer).ID)
+	if groups["demo2.localhost"][0].(*context.RuntimeContainer).ID != "3" {
+		t.Fatalf("expected 2 got %s", groups["demo2.localhost"][0].(*context.RuntimeContainer).ID)
 	}
 	if len(groups["demo3.localhost"]) != 1 {
 		t.Fatalf("expect 1 got %d", len(groups["demo3.localhost"]))
 	}
-	if groups["demo3.localhost"][0].(context.RuntimeContainer).ID != "2" {
-		t.Fatalf("expected 2 got %s", groups["demo3.localhost"][0].(context.RuntimeContainer).ID)
+	if groups["demo3.localhost"][0].(*context.RuntimeContainer).ID != "2" {
+		t.Fatalf("expected 2 got %s", groups["demo3.localhost"][0].(*context.RuntimeContainer).ID)
 	}
 }

internal/template/sort.go

@@ -47,7 +47,7 @@ func (s *sortableByKey) set(funcName string, entries interface{}) (err error) {
 	}
 	s.data = make([]interface{}, entriesVal.Len())
 	for i := 0; i < entriesVal.Len(); i++ {
-		s.data[i] = reflect.Indirect(entriesVal.Index(i)).Interface()
+		s.data[i] = entriesVal.Index(i).Interface()
 	}
 	return
 }

internal/template/sort_test.go

@@ -49,15 +49,15 @@ func TestSortObjectsByKeysAsc(t *testing.T) {
 
 	assert.NoError(t, err)
 	assert.Len(t, sorted, 4)
-	assert.Equal(t, "foo.localhost", sorted[0].(context.RuntimeContainer).Env["VIRTUAL_HOST"])
-	assert.Equal(t, "9", sorted[3].(context.RuntimeContainer).ID)
+	assert.Equal(t, "foo.localhost", sorted[0].(*context.RuntimeContainer).Env["VIRTUAL_HOST"])
+	assert.Equal(t, "9", sorted[3].(*context.RuntimeContainer).ID)
 
 	sorted, err = sortObjectsByKeysAsc(sorted, "Env.VIRTUAL_HOST")
 
 	assert.NoError(t, err)
 	assert.Len(t, sorted, 4)
-	assert.Equal(t, "foo.localhost", sorted[3].(context.RuntimeContainer).Env["VIRTUAL_HOST"])
-	assert.Equal(t, "8", sorted[0].(context.RuntimeContainer).ID)
+	assert.Equal(t, "foo.localhost", sorted[3].(*context.RuntimeContainer).Env["VIRTUAL_HOST"])
+	assert.Equal(t, "8", sorted[0].(*context.RuntimeContainer).ID)
 }
 
 func TestSortObjectsByKeysDesc(t *testing.T) {
@@ -90,13 +90,13 @@ func TestSortObjectsByKeysDesc(t *testing.T) {
 
 	assert.NoError(t, err)
 	assert.Len(t, sorted, 4)
-	assert.Equal(t, "bar.localhost", sorted[0].(context.RuntimeContainer).Env["VIRTUAL_HOST"])
-	assert.Equal(t, "1", sorted[3].(context.RuntimeContainer).ID)
+	assert.Equal(t, "bar.localhost", sorted[0].(*context.RuntimeContainer).Env["VIRTUAL_HOST"])
+	assert.Equal(t, "1", sorted[3].(*context.RuntimeContainer).ID)
 
 	sorted, err = sortObjectsByKeysDesc(sorted, "Env.VIRTUAL_HOST")
 
 	assert.NoError(t, err)
 	assert.Len(t, sorted, 4)
-	assert.Equal(t, "", sorted[3].(context.RuntimeContainer).Env["VIRTUAL_HOST"])
-	assert.Equal(t, "1", sorted[0].(context.RuntimeContainer).ID)
+	assert.Equal(t, "", sorted[3].(*context.RuntimeContainer).Env["VIRTUAL_HOST"])
+	assert.Equal(t, "1", sorted[0].(*context.RuntimeContainer).ID)
 }

internal/template/where.go

@@ -18,7 +18,7 @@ func generalizedWhere(funcName string, entries interface{}, key string, test fun
 
 	selection := make([]interface{}, 0)
 	for i := 0; i < entriesVal.Len(); i++ {
-		v := reflect.Indirect(entriesVal.Index(i)).Interface()
+		v := entriesVal.Index(i).Interface()
 
 		value := deepGet(v, key)
 		if test(value) {