From 5396df2e282c61ffb1fc8fa65240c36a0216055f Mon Sep 17 00:00:00 2001 From: zwwhdls Date: Sun, 8 Dec 2019 00:30:16 +0800 Subject: [PATCH 1/5] fix #6116 Signed-off-by: zwwhdls --- pkg/strvals/parser.go | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/pkg/strvals/parser.go b/pkg/strvals/parser.go index c735412e9..3c585cbea 100644 --- a/pkg/strvals/parser.go +++ b/pkg/strvals/parser.go @@ -305,8 +305,15 @@ func (t *parser) listItem(list []interface{}, i int) ([]interface{}, error) { if err != nil { return list, errors.Wrap(err, "error parsing index") } + var crtList []interface{} + if len(list) > i { + // If nested list already exists, take the value of list to next cycle. + crtList = list[i].([]interface{}) + } else { + crtList = list + } // Now we need to get the value after the ]. - list2, err := t.listItem(list, i) + list2, err := t.listItem(crtList, i) if err != nil { return list, err } From c41c72cee980b8763a3701450b4b5da8ebf343a2 Mon Sep 17 00:00:00 2001 From: zwwhdls Date: Sun, 8 Dec 2019 00:41:35 +0800 Subject: [PATCH 2/5] add test case Signed-off-by: zwwhdls --- pkg/strvals/parser_test.go | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/pkg/strvals/parser_test.go b/pkg/strvals/parser_test.go index 742256153..7c6e6f73b 100644 --- a/pkg/strvals/parser_test.go +++ b/pkg/strvals/parser_test.go @@ -427,7 +427,7 @@ func TestParseInto(t *testing.T) { "inner2": "value2", }, } - input := "outer.inner1=value1,outer.inner3=value3,outer.inner4=4" + input := "outer.inner1=value1,outer.inner3=value3,outer.inner4=4,listOuter[0][0].type=listValue" expect := map[string]interface{}{ "outer": map[string]interface{}{ "inner1": "value1", @@ -435,12 +435,22 @@ func TestParseInto(t *testing.T) { "inner3": "value3", "inner4": 4, }, + "listOuter": [][]interface{}{{map[string]string{ + "type": "listValue", + "status": "alive", + }}, + }, } if err := ParseInto(input, got); err != nil { t.Fatal(err) } + input2 := "listOuter[0][0].status=alive" + if err := ParseInto(input2, got); err != nil { + t.Fatal(err) + } + y1, err := yaml.Marshal(expect) if err != nil { t.Fatal(err) From 4532485fd03a8cb56186c93ffeba285431073429 Mon Sep 17 00:00:00 2001 From: zwwhdls Date: Sun, 8 Dec 2019 10:37:46 +0800 Subject: [PATCH 3/5] fix another extreme case Signed-off-by: zwwhdls --- pkg/strvals/parser.go | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/pkg/strvals/parser.go b/pkg/strvals/parser.go index 3c585cbea..cc5c509da 100644 --- a/pkg/strvals/parser.go +++ b/pkg/strvals/parser.go @@ -301,7 +301,7 @@ func (t *parser) listItem(list []interface{}, i int) ([]interface{}, error) { } case last == '[': // now we have a nested list. Read the index and handle. - i, err := t.keyIndex() + nextI, err := t.keyIndex() if err != nil { return list, errors.Wrap(err, "error parsing index") } @@ -309,15 +309,18 @@ func (t *parser) listItem(list []interface{}, i int) ([]interface{}, error) { if len(list) > i { // If nested list already exists, take the value of list to next cycle. crtList = list[i].([]interface{}) - } else { - crtList = list } // Now we need to get the value after the ]. +<<<<<<< HEAD list2, err := t.listItem(crtList, i) if err != nil { return list, err } return setIndex(list, i, list2) +======= + list2, err := t.listItem(crtList, nextI) + return setIndex(list, i, list2), err +>>>>>>> fix another extreme case case last == '.': // We have a nested object. Send to t.key inner := map[string]interface{}{} From 1b39857ac32165db1ad64f66a03d74f1fa09a3f7 Mon Sep 17 00:00:00 2001 From: zwwhdls Date: Sun, 8 Dec 2019 11:30:11 +0800 Subject: [PATCH 4/5] add test case Signed-off-by: zwwhdls --- pkg/strvals/parser.go | 5 +- pkg/strvals/parser_test.go | 137 ++++++++++++++++++++++++++++--------- 2 files changed, 107 insertions(+), 35 deletions(-) diff --git a/pkg/strvals/parser.go b/pkg/strvals/parser.go index cc5c509da..45aa65eac 100644 --- a/pkg/strvals/parser.go +++ b/pkg/strvals/parser.go @@ -308,7 +308,10 @@ func (t *parser) listItem(list []interface{}, i int) ([]interface{}, error) { var crtList []interface{} if len(list) > i { // If nested list already exists, take the value of list to next cycle. - crtList = list[i].([]interface{}) + existed := list[i] + if existed != nil { + crtList = list[i].([]interface{}) + } } // Now we need to get the value after the ]. <<<<<<< HEAD diff --git a/pkg/strvals/parser_test.go b/pkg/strvals/parser_test.go index 7c6e6f73b..cef98ba0a 100644 --- a/pkg/strvals/parser_test.go +++ b/pkg/strvals/parser_test.go @@ -421,49 +421,118 @@ func TestParseSet(t *testing.T) { } func TestParseInto(t *testing.T) { - got := map[string]interface{}{ - "outer": map[string]interface{}{ - "inner1": "overwrite", - "inner2": "value2", + tests := []struct { + input string + input2 string + got map[string]interface{} + expect map[string]interface{} + err bool + }{ + { + input: "outer.inner1=value1,outer.inner3=value3,outer.inner4=4", + got: map[string]interface{}{ + "outer": map[string]interface{}{ + "inner1": "overwrite", + "inner2": "value2", + }, + }, + expect: map[string]interface{}{ + "outer": map[string]interface{}{ + "inner1": "value1", + "inner2": "value2", + "inner3": "value3", + "inner4": 4, + }}, + err: false, }, - } - input := "outer.inner1=value1,outer.inner3=value3,outer.inner4=4,listOuter[0][0].type=listValue" - expect := map[string]interface{}{ - "outer": map[string]interface{}{ - "inner1": "value1", - "inner2": "value2", - "inner3": "value3", - "inner4": 4, + { + input: "listOuter[0][0].type=listValue", + input2: "listOuter[0][0].status=alive", + got: map[string]interface{}{}, + expect: map[string]interface{}{ + "listOuter": [][]interface{}{{map[string]string{ + "type": "listValue", + "status": "alive", + }}}, + }, + err: false, }, - "listOuter": [][]interface{}{{map[string]string{ - "type": "listValue", - "status": "alive", - }}, + { + input: "listOuter[0][0].type=listValue", + input2: "listOuter[1][0].status=alive", + got: map[string]interface{}{}, + expect: map[string]interface{}{ + "listOuter": [][]interface{}{ + { + map[string]string{"type": "listValue"}, + }, + { + map[string]string{"status": "alive"}, + }, + }, + }, + err: false, + }, + { + input: "listOuter[0][1][0].type=listValue", + input2: "listOuter[0][0][1].status=alive", + got: map[string]interface{}{ + "listOuter": []interface{}{ + []interface{}{ + []interface{}{ + map[string]string{"exited": "old"}, + }, + }, + }, + }, + expect: map[string]interface{}{ + "listOuter": [][][]interface{}{ + { + { + map[string]string{"exited": "old"}, + map[string]string{"status": "alive"}, + }, + { + map[string]string{"type": "listValue"}, + }, + }, + }, + }, + err: false, }, } + for _, tt := range tests { + if err := ParseInto(tt.input, tt.got); err != nil { + t.Fatal(err) + } + if tt.err { + t.Errorf("%s: Expected error. Got nil", tt.input) + } - if err := ParseInto(input, got); err != nil { - t.Fatal(err) - } - - input2 := "listOuter[0][0].status=alive" - if err := ParseInto(input2, got); err != nil { - t.Fatal(err) - } + if tt.input2 != "" { + if err := ParseInto(tt.input2, tt.got); err != nil { + t.Fatal(err) + } + if tt.err { + t.Errorf("%s: Expected error. Got nil", tt.input2) + } + } - y1, err := yaml.Marshal(expect) - if err != nil { - t.Fatal(err) - } - y2, err := yaml.Marshal(got) - if err != nil { - t.Fatalf("Error serializing parsed value: %s", err) - } + y1, err := yaml.Marshal(tt.expect) + if err != nil { + t.Fatal(err) + } + y2, err := yaml.Marshal(tt.got) + if err != nil { + t.Fatalf("Error serializing parsed value: %s", err) + } - if string(y1) != string(y2) { - t.Errorf("%s: Expected:\n%s\nGot:\n%s", input, y1, y2) + if string(y1) != string(y2) { + t.Errorf("%s: Expected:\n%s\nGot:\n%s", tt.input, y1, y2) + } } } + func TestParseIntoString(t *testing.T) { got := map[string]interface{}{ "outer": map[string]interface{}{ From d58a984878ea290e04a135ef037b75e13b7b8df5 Mon Sep 17 00:00:00 2001 From: zwwhdls Date: Wed, 1 Jul 2020 21:29:20 +0800 Subject: [PATCH 5/5] fix conflict Signed-off-by: zwwhdls --- pkg/strvals/parser.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/pkg/strvals/parser.go b/pkg/strvals/parser.go index 45aa65eac..457b99f94 100644 --- a/pkg/strvals/parser.go +++ b/pkg/strvals/parser.go @@ -314,16 +314,11 @@ func (t *parser) listItem(list []interface{}, i int) ([]interface{}, error) { } } // Now we need to get the value after the ]. -<<<<<<< HEAD - list2, err := t.listItem(crtList, i) + list2, err := t.listItem(crtList, nextI) if err != nil { return list, err } return setIndex(list, i, list2) -======= - list2, err := t.listItem(crtList, nextI) - return setIndex(list, i, list2), err ->>>>>>> fix another extreme case case last == '.': // We have a nested object. Send to t.key inner := map[string]interface{}{}