Allow star filters in parse

Author: stilvoid

TODO.md

@@ -1,22 +1,5 @@
 # ToDo
 
-* Allow * in path filtering, e.g.:
-
-    Given the data:
-
-        [
-            {
-                "id": 1
-            },
-            {
-                "id": 2
-            }
-        ]
-
-    `please parse *.id` would result in:
-
-        [1, 2]
-
 * Tidy up help text - separate input/output params
 
     Use [optional] and <value goes here> conventions

parser/filter.go

@@ -8,7 +8,8 @@ import (
 )
 
 // Filter takes structured data and returns just the portion of it that matches the provided path using dot notation.
-// e.g. data.header.1
+// The path may contain asterisks, in which case all entries will match at that level of the path
+// e.g. products.*.id will return all product ids
 func Filter(in interface{}, path string) (interface{}, error) {
 	if path == "" {
 		return in, nil
@@ -27,6 +28,21 @@ func Filter(in interface{}, path string) (interface{}, error) {
 
 	switch val.Kind() {
 	case reflect.Map:
+		if thisPath == "*" {
+			var err error
+			out := make([]interface{}, val.Len())
+
+			for i, key := range val.MapKeys() {
+				out[i], err = Filter(val.MapIndex(key).Interface(), nextPath)
+
+				if err != nil {
+					return nil, err
+				}
+			}
+
+			return out, nil
+		}
+
 		for _, key := range val.MapKeys() {
 			if fmt.Sprint(key.Interface()) == thisPath {
 				value := val.MapIndex(key).Interface()
@@ -36,6 +52,21 @@ func Filter(in interface{}, path string) (interface{}, error) {
 
 		break
 	case reflect.Array, reflect.Slice:
+		if thisPath == "*" {
+			var err error
+			out := make([]interface{}, val.Len())
+
+			for i := 0; i < val.Len(); i++ {
+				out[i], err = Filter(val.Index(i).Interface(), nextPath)
+
+				if err != nil {
+					return nil, err
+				}
+			}
+
+			return out, nil
+		}
+
 		index, err := strconv.Atoi(thisPath)
 
 		if err != nil || index < 0 || index >= val.Len() {

parser/filter_test.go

@@ -1,6 +1,9 @@
 package parser
 
 import (
+	"fmt"
+	"reflect"
+	"sort"
 	"testing"
 )
 
@@ -16,7 +19,7 @@ func TestFilter(t *testing.T) {
 		},
 	}
 
-	cases := map[string]string{
+	cases := map[string]interface{}{
 		"top":         "I am the top",
 		"bottom.16":   "left",
 		"bottom.13.1": "right 2",
@@ -35,6 +38,94 @@ func TestFilter(t *testing.T) {
 	}
 }
 
+func TestStarFilterSlice(t *testing.T) {
+	input := map[string]interface{}{
+		"top": []string{
+			"foo",
+			"bar",
+			"baz",
+		},
+		"bottom": []interface{}{
+			map[string]int{
+				"id": 1,
+			},
+			map[string]int{
+				"id": 2,
+			},
+			map[string]int{
+				"id": 3,
+			},
+		},
+	}
+
+	cases := map[string]interface{}{
+		"top.*":       []interface{}{"foo", "bar", "baz"},
+		"bottom.*.id": []interface{}{1, 2, 3},
+	}
+
+	for path, expected := range cases {
+		actual, err := Filter(input, path)
+
+		if err != nil {
+			t.Fail()
+		}
+
+		if !reflect.DeepEqual(expected, actual) {
+			t.Errorf("case failed: %v vs %v", expected, actual)
+		}
+	}
+}
+
+func TestStarFilterMap(t *testing.T) {
+	input := map[string]interface{}{
+		"top": map[string]int{
+			"one":   1,
+			"two":   2,
+			"three": 3,
+		},
+		"bottom": map[string]interface{}{
+			"a": map[string]int{
+				"id": 4,
+			},
+			"b": map[string]int{
+				"id": 5,
+			},
+			"c": map[string]int{
+				"id": 6,
+			},
+		},
+	}
+
+	cases := map[string]interface{}{
+		"top.*":       []int{1, 2, 3},
+		"bottom.*.id": []int{4, 5, 6},
+	}
+
+	for path, expected := range cases {
+		actual, err := Filter(input, path)
+
+		val := reflect.ValueOf(actual)
+
+		// Some "fun" type conversion here to make sure things work ok
+		intActual := make([]int, val.Len())
+
+		for i := 0; i < val.Len(); i++ {
+			fmt.Println(val.Index(i))
+			intActual[i] = val.Index(i).Interface().(int)
+		}
+
+		sort.Ints(intActual)
+
+		if err != nil {
+			t.Fail()
+		}
+
+		if !reflect.DeepEqual(expected, intActual) {
+			t.Errorf("case failed: %v vs %v", expected, actual)
+		}
+	}
+}
+
 func TestFilterBadKey(t *testing.T) {
 	input := map[string]interface{}{
 		"foo": "bar",
@@ -46,3 +137,23 @@ func TestFilterBadKey(t *testing.T) {
 		t.Errorf("unexpected return values: %v, %v", val, err)
 	}
 }
+
+func TestStarFilterBadKey(t *testing.T) {
+	input := []interface{}{
+		map[string]int{
+			"id": 1,
+		},
+		map[string]int{
+			"id": 2,
+		},
+		map[string]int{
+			"notid": 3,
+		},
+	}
+
+	val, err := Filter(input, "*.id")
+
+	if err == nil || err.Error() != "key does not exist: id" {
+		t.Errorf("unexpected return values: %v, %v", val, err)
+	}
+}