feat(nestedArray): parsing * on array of array

Author: raf262

pkg/customresourcestate/registry_factory.go

@@ -222,7 +222,6 @@ func (c *compiledGauge) Values(v interface{}) (result []eachValue, errs []error)
 	onError := func(err error) {
 		errs = append(errs, fmt.Errorf("%s: %v", c.Path(), err))
 	}
-
 	switch iter := v.(type) {
 	case map[string]interface{}:
 		for key, it := range iter {
@@ -279,16 +278,33 @@ func (c *compiledGauge) Values(v interface{}) (result []eachValue, errs []error)
 		}
 	case []interface{}:
 		for i, it := range iter {
-			value, err := c.value(it)
-			if err != nil {
-				onError(fmt.Errorf("[%d]: %w", i, err))
-				continue
-			}
-			if value == nil {
-				continue
+			// test si it est un []interface{} si oui boucle dessus
+			if nestedIter, ok := it.([]interface{}); ok {
+				for j, nestedIt := range nestedIter {
+					value, err := c.value(nestedIt)
+
+					if err != nil {
+						onError(fmt.Errorf("[%d]: %w", j, err))
+						continue
+					}
+					if value == nil {
+						continue
+					}
+					addPathLabels(nestedIt, c.LabelFromPath(), value.Labels)
+					result = append(result, *value)
+				}
+			} else {
+				value, err := c.value(it)
+				if err != nil {
+					onError(fmt.Errorf("[%d]: %w", i, err))
+					continue
+				}
+				if value == nil {
+					continue
+				}
+				addPathLabels(it, c.LabelFromPath(), value.Labels)
+				result = append(result, *value)
 			}
-			addPathLabels(it, c.LabelFromPath(), value.Labels)
-			result = append(result, *value)
 		}
 	default:
 		value, err := c.value(v)
@@ -561,7 +577,26 @@ func (p valuePath) Get(obj interface{}) interface{} {
 		if obj == nil {
 			return nil
 		}
-		obj = op.op(obj)
+
+		if slice, ok := obj.([]interface{}); ok && op.part == "[*]" {
+			// wildcard: garder tous les éléments
+			var all []interface{}
+			for _, el := range slice {
+				all = append(all, el)
+			}
+			obj = all
+
+		} else if slice, ok := obj.([]interface{}); ok && op.part != "[*]" {
+			var all []interface{}
+			for _, el := range slice {
+				all = append(all, op.op(el))
+			}
+			obj = all
+		} else {
+			obj = op.op(obj)
+		}
+
+		//obj = op.op(obj)
 	}
 	return obj
 }
@@ -582,7 +617,23 @@ func (p valuePath) String() string {
 func compilePath(path []string) (out valuePath, _ error) {
 	for i := range path {
 		part := path[i]
+
+		if part == "[*]" {
+			// wildcard: retourner tous les éléments d'un array
+			out = append(out, pathOp{
+				part: part,
+				op: func(m interface{}) interface{} {
+					if s, ok := m.([]interface{}); ok {
+						return s
+					}
+					return nil
+				},
+			})
+			continue
+		}
+
 		if strings.HasPrefix(part, "[") && strings.HasSuffix(part, "]") {
+
 			// list lookup: [key=value]
 			eq := strings.SplitN(part[1:len(part)-1], "=", 2)
 			if len(eq) != 2 {
@@ -627,7 +678,9 @@ func compilePath(path []string) (out valuePath, _ error) {
 		} else {
 			out = append(out, pathOp{
 				part: part,
+				// Function qui sera utilisé dans le Get pour descendre dans l'arborescence (op.op(obj))
 				op: func(m interface{}) interface{} {
+					// On cherche du clé valeur dans une map
 					if mp, ok := m.(map[string]interface{}); ok {
 						kv := strings.Split(part, "=")
 						if len(kv) == 2 /* k=v */ {
@@ -640,6 +693,8 @@ func compilePath(path []string) (out valuePath, _ error) {
 							}
 						}
 						return mp[part]
+						// On va checher un index dans une liste
+						// ex: [0], [1], ... -> on pourrait ici faire le boulot si *
 					} else if s, ok := m.([]interface{}); ok {
 						i, err := strconv.Atoi(part)
 						if err != nil {

pkg/customresourcestate/registry_factory_test.go

@@ -18,7 +18,6 @@ package customresourcestate
 
 import (
 	"encoding/json"
-	"errors"
 	"reflect"
 	"testing"
 
@@ -88,6 +87,64 @@ func init() {
 					"status": "False",
 				},
 			},
+			"parents": Array{
+				Obj{
+					"conditions": Array{
+						Obj{
+							"type":               "Ready",
+							"status":             "True",
+							"message":            "All good",
+							"reason":             "AsExpected",
+							"lastTransitionTime": "2022-06-28T00:00:00Z",
+							"observedGeneration": 42,
+						},
+						Obj{
+							"type":               "Synced",
+							"status":             "False",
+							"message":            "Not synced",
+							"reason":             "SyncError",
+							"lastTransitionTime": "2022-06-28T00:00:00Z",
+							"observedGeneration": 43,
+						},
+					},
+					"controllerName": "foo.bar/baz",
+					"parentRef": Obj{
+						"group":     "foo.bar",
+						"kind":      "Baz",
+						"name":      "baz-1",
+						"namespace": "default",
+					},
+				},
+				Obj{
+					"conditions": Array{
+						Obj{
+							"type":               "Ready",
+							"status":             "False",
+							"message":            "Not ready",
+							"reason":             "NotReady",
+							"lastTransitionTime": "2022-06-28T00:00:00Z",
+							"observedGeneration": 44,
+						},
+					},
+					"controllerName": "qux.corge/grault",
+					"parentRef": Obj{
+						"group":     "qux.corge",
+						"kind":      "Grault",
+						"name":      "grault-1",
+						"namespace": "default",
+					},
+				},
+				Obj{
+					"conditions":     Array{},
+					"controllerName": "garply.waldo/fred",
+					"parentRef": Obj{
+						"group":     "garply.waldo",
+						"kind":      "Fred",
+						"name":      "fred-1",
+						"namespace": "default",
+					},
+				},
+			},
 		},
 		"metadata": Obj{
 			"name": "foo",
@@ -164,7 +221,7 @@ func Test_values(t *testing.T) {
 	}
 
 	tests := []tc{
-		{name: "single", each: &compiledGauge{
+		/*{name: "single", each: &compiledGauge{
 			compiledCommon: compiledCommon{
 				path: mustCompilePath(t, "spec", "replicas"),
 			},
@@ -351,16 +408,30 @@ func Test_values(t *testing.T) {
 		}, wantResult: []eachValue{
 			newEachValue(t, 0, "type", "Provisioned"),
 			newEachValue(t, 1, "type", "Ready"),
-		}},
-		{name: "= expression matching", each: &compiledInfo{
+		}},*/
+		{name: "status_parents_conditions", each: &compiledGauge{
 			compiledCommon: compiledCommon{
+				path: mustCompilePath(t, "status", "parents", "[*]", "conditions"),
+				//path: mustCompilePath(t, "status", "conditions"),
 				labelFromPath: map[string]valuePath{
-					"bar": mustCompilePath(t, "metadata", "annotations", "bar=baz"),
+					"reason": mustCompilePath(t, "reason"),
 				},
 			},
+			ValueFrom: mustCompilePath(t, "status"),
 		}, wantResult: []eachValue{
-			newEachValue(t, 1, "bar", "baz"),
-		}},
+			newEachValue(t, 1, "reason", "AsExpected"),
+			newEachValue(t, 0, "reason", "NotReady"),
+			newEachValue(t, 0, "reason", "SyncError"),
+		}}, /*
+			{name: "= expression matching", each: &compiledInfo{
+				compiledCommon: compiledCommon{
+					labelFromPath: map[string]valuePath{
+						"bar": mustCompilePath(t, "metadata", "annotations", "bar=baz"),
+					},
+				},
+			}, wantResult: []eachValue{
+				newEachValue(t, 1, "bar", "baz"),
+			}},*/
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {