taigrr/yq
1
0
Fork 0
mirror of https://github.com/taigrr/yq synced 2025-01-18 04:53:17 -08:00
Code Issues Projects Releases Wiki Activity

splatting

Browse Source
This commit is contained in:
Mike Farah
2019-12-09 13:44:53 +11:00
parent 8da9a81702
commit 9771e7001c
13 changed files with 527 additions and 515 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
pkg/yqlib/data_navigator.go
View File

@@ -9,6 +9,7 @@ import (
)
type DataNavigator interface {
DebugNode(node *yaml.Node)
Get(rootNode *yaml.Node, remainingPath []string) (*yaml.Node, error)
Update(rootNode *yaml.Node, remainingPath []string, changesToApply yaml.Node) error
}
@@ -36,9 +37,9 @@ func (n *navigator) Get(value *yaml.Node, path []string) (*yaml.Node, error) {
func (n *navigator) Update(value *yaml.Node, path []string, changesToApply yaml.Node) error {
_, errorVisiting := n.Visit(value, path, func(nodeToUpdate *yaml.Node) (*yaml.Node, error) {
n.log.Debug("going to update")
n.debugNode(nodeToUpdate)
n.DebugNode(nodeToUpdate)
n.log.Debug("with")
n.debugNode(&changesToApply)
n.DebugNode(&changesToApply)
nodeToUpdate.Value = changesToApply.Value
nodeToUpdate.Tag = changesToApply.Tag
nodeToUpdate.Kind = changesToApply.Kind
@@ -55,26 +56,33 @@ func (n *navigator) Update(value *yaml.Node, path []string, changesToApply yaml.
func (n *navigator) Visit(value *yaml.Node, path []string, visitor VisitorFn) (*yaml.Node, error) {
realValue := value
if realValue.Kind == yaml.DocumentNode {
n.log.Debugf("its a document! returning the first child")
realValue = value.Content[0]
}
if len(path) > 0 {
n.log.Debugf("diving into %v", path[0])
n.debugNode(value)
n.DebugNode(value)
return n.recurse(realValue, path[0], path[1:], visitor)
}
return visitor(realValue)
}
func (n *navigator) guessKind(tail []string) yaml.Kind {
func (n *navigator) guessKind(tail []string, guess yaml.Kind) yaml.Kind {
n.log.Debug("tail %v", tail)
if len(tail) == 0 {
if len(tail) == 0 && guess == 0 {
n.log.Debug("end of path, must be a scalar")
return yaml.ScalarNode
} else if len(tail) == 0 {
return guess
}
var _, errorParsingInt = strconv.ParseInt(tail[0], 10, 64)
if tail[0] == "*" || tail[0] == "+" || errorParsingInt == nil {
if tail[0] == "+" || errorParsingInt == nil {
return yaml.SequenceNode
}
if tail[0] == "*" && guess == yaml.SequenceNode || guess == yaml.MappingNode {
return guess
}
return yaml.MappingNode
}
@@ -90,7 +98,7 @@ func (n *navigator) getOrReplace(original *yaml.Node, expectedKind yaml.Kind) *y
return original
}
func (n *navigator) debugNode(value *yaml.Node) {
func (n *navigator) DebugNode(value *yaml.Node) {
if n.log.IsEnabledFor(logging.DEBUG) {
buf := new(bytes.Buffer)
encoder := yaml.NewEncoder(buf)
@@ -105,17 +113,33 @@ func (n *navigator) recurse(value *yaml.Node, head string, tail []string, visito
switch value.Kind {
case yaml.MappingNode:
n.log.Debug("its a map with %v entries", len(value.Content)/2)
if head == "*" {
var newNode = yaml.Node{Kind: yaml.SequenceNode}
for index, content := range value.Content {
if index%2 == 0 {
continue
}
content = n.getOrReplace(content, n.guessKind(tail, content.Kind))
var nestedValue, err = n.Visit(content, tail, visitor)
if err != nil {
return nil, err
}
newNode.Content = append(newNode.Content, nestedValue)
}
return &newNode, nil
}
for index, content := range value.Content {
// value.Content is a concatenated array of key, value,
// so keys are in the even indexes, values in odd.
if index%2 == 1 || content.Value != head {
if index%2 == 1 || (content.Value != head) {
continue
}
value.Content[index+1] = n.getOrReplace(value.Content[index+1], n.guessKind(tail))
value.Content[index+1] = n.getOrReplace(value.Content[index+1], n.guessKind(tail, value.Content[index+1].Kind))
return n.Visit(value.Content[index+1], tail, visitor)
}
value.Content = append(value.Content, &yaml.Node{Value: head, Kind: yaml.ScalarNode})
mapEntryValue := yaml.Node{Kind: n.guessKind(tail)}
mapEntryValue := yaml.Node{Kind: n.guessKind(tail, 0)}
value.Content = append(value.Content, &mapEntryValue)
n.log.Debug("adding new node %v", value.Content)
return n.Visit(&mapEntryValue, tail, visitor)
@@ -127,11 +151,11 @@ func (n *navigator) recurse(value *yaml.Node, head string, tail []string, visito
for index, childValue := range value.Content {
n.log.Debug("processing")
n.debugNode(childValue)
childValue = n.getOrReplace(childValue, n.guessKind(tail))
n.DebugNode(childValue)
childValue = n.getOrReplace(childValue, n.guessKind(tail, childValue.Kind))
var nestedValue, err = n.Visit(childValue, tail, visitor)
n.log.Debug("nestedValue")
n.debugNode(nestedValue)
n.DebugNode(nestedValue)
if err != nil {
return nil, err
}
@@ -140,7 +164,7 @@ func (n *navigator) recurse(value *yaml.Node, head string, tail []string, visito
return &newNode, nil
} else if head == "+" {
var newNode = yaml.Node{Kind: n.guessKind(tail)}
var newNode = yaml.Node{Kind: n.guessKind(tail, 0)}
value.Content = append(value.Content, &newNode)
n.log.Debug("appending a new node, %v", value.Content)
return n.Visit(&newNode, tail, visitor)
@@ -152,7 +176,7 @@ func (n *navigator) recurse(value *yaml.Node, head string, tail []string, visito
if index >= int64(len(value.Content)) {
return nil, nil
}
value.Content[index] = n.getOrReplace(value.Content[index], n.guessKind(tail))
value.Content[index] = n.getOrReplace(value.Content[index], n.guessKind(tail, value.Content[index].Kind))
return n.Visit(value.Content[index], tail, visitor)
default:
return nil, nil

694
pkg/yqlib/data_navigator_test.go
View File

@@ -1,397 +1,397 @@
package yqlib
import (
"fmt"
"sort"
"testing"
// import (
// "fmt"
// "sort"
// "testing"
"github.com/mikefarah/yq/v2/test"
logging "gopkg.in/op/go-logging.v1"
)
// "github.com/mikefarah/yq/v2/test"
// logging "gopkg.in/op/go-logging.v1"
// )
func TestDataNavigator(t *testing.T) {
var log = logging.MustGetLogger("yq")
subject := NewDataNavigator(log)
// func TestDataNavigator(t *testing.T) {
// var log = logging.MustGetLogger("yq")
// subject := NewDataNavigator(log)
t.Run("TestReadMap_simple", func(t *testing.T) {
var data = test.ParseData(`
---
b:
c: 2
`)
got, _ := subject.ReadChildValue(data, []string{"b", "c"})
test.AssertResult(t, 2, got)
})
// t.Run("TestReadMap_simple", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// b:
// c: 2
// `)
// got, _ := subject.ReadChildValue(data, []string{"b", "c"})
// test.AssertResult(t, 2, got)
// })
t.Run("TestReadMap_numberKey", func(t *testing.T) {
var data = test.ParseData(`
---
200: things
`)
got, _ := subject.ReadChildValue(data, []string{"200"})
test.AssertResult(t, "things", got)
})
// t.Run("TestReadMap_numberKey", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// 200: things
// `)
// got, _ := subject.ReadChildValue(data, []string{"200"})
// test.AssertResult(t, "things", got)
// })
t.Run("TestReadMap_splat", func(t *testing.T) {
var data = test.ParseData(`
---
mapSplat:
item1: things
item2: whatever
otherThing: cat
`)
res, _ := subject.ReadChildValue(data, []string{"mapSplat", "*"})
test.AssertResult(t, "[things whatever cat]", fmt.Sprintf("%v", res))
})
// t.Run("TestReadMap_splat", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// mapSplat:
// item1: things
// item2: whatever
// otherThing: cat
// `)
// res, _ := subject.ReadChildValue(data, []string{"mapSplat", "*"})
// test.AssertResult(t, "[things whatever cat]", fmt.Sprintf("%v", res))
// })
t.Run("TestReadMap_prefixSplat", func(t *testing.T) {
var data = test.ParseData(`
---
mapSplat:
item1: things
item2: whatever
otherThing: cat
`)
res, _ := subject.ReadChildValue(data, []string{"mapSplat", "item*"})
test.AssertResult(t, "[things whatever]", fmt.Sprintf("%v", res))
})
// t.Run("TestReadMap_prefixSplat", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// mapSplat:
// item1: things
// item2: whatever
// otherThing: cat
// `)
// res, _ := subject.ReadChildValue(data, []string{"mapSplat", "item*"})
// test.AssertResult(t, "[things whatever]", fmt.Sprintf("%v", res))
// })
t.Run("TestReadMap_deep_splat", func(t *testing.T) {
var data = test.ParseData(`
---
mapSplatDeep:
item1:
cats: bananas
item2:
cats: apples
`)
// t.Run("TestReadMap_deep_splat", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// mapSplatDeep:
// item1:
// cats: bananas
// item2:
// cats: apples
// `)
res, _ := subject.ReadChildValue(data, []string{"mapSplatDeep", "*", "cats"})
result := res.([]interface{})
var actual = []string{result[0].(string), result[1].(string)}
sort.Strings(actual)
test.AssertResult(t, "[apples bananas]", fmt.Sprintf("%v", actual))
})
// res, _ := subject.ReadChildValue(data, []string{"mapSplatDeep", "*", "cats"})
// result := res.([]interface{})
// var actual = []string{result[0].(string), result[1].(string)}
// sort.Strings(actual)
// test.AssertResult(t, "[apples bananas]", fmt.Sprintf("%v", actual))
// })
t.Run("TestReadMap_key_doesnt_exist", func(t *testing.T) {
var data = test.ParseData(`
---
b:
c: 2
`)
got, _ := subject.ReadChildValue(data, []string{"b", "x", "f", "c"})
test.AssertResult(t, nil, got)
})
// t.Run("TestReadMap_key_doesnt_exist", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// b:
// c: 2
// `)
// got, _ := subject.ReadChildValue(data, []string{"b", "x", "f", "c"})
// test.AssertResult(t, nil, got)
// })
t.Run("TestReadMap_recurse_against_string", func(t *testing.T) {
var data = test.ParseData(`
---
a: cat
`)
got, _ := subject.ReadChildValue(data, []string{"a", "b"})
test.AssertResult(t, nil, got)
})
// t.Run("TestReadMap_recurse_against_string", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// a: cat
// `)
// got, _ := subject.ReadChildValue(data, []string{"a", "b"})
// test.AssertResult(t, nil, got)
// })
t.Run("TestReadMap_with_array", func(t *testing.T) {
var data = test.ParseData(`
---
b:
d:
- 3
- 4
`)
got, _ := subject.ReadChildValue(data, []string{"b", "d", "1"})
test.AssertResult(t, 4, got)
})
// t.Run("TestReadMap_with_array", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// b:
// d:
// - 3
// - 4
// `)
// got, _ := subject.ReadChildValue(data, []string{"b", "d", "1"})
// test.AssertResult(t, 4, got)
// })
t.Run("TestReadMap_with_array_and_bad_index", func(t *testing.T) {
var data = test.ParseData(`
---
b:
d:
- 3
- 4
`)
_, err := subject.ReadChildValue(data, []string{"b", "d", "x"})
if err == nil {
t.Fatal("Expected error due to invalid path")
}
expectedOutput := `error accessing array: strconv.ParseInt: parsing "x": invalid syntax`
test.AssertResult(t, expectedOutput, err.Error())
})
// t.Run("TestReadMap_with_array_and_bad_index", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// b:
// d:
// - 3
// - 4
// `)
// _, err := subject.ReadChildValue(data, []string{"b", "d", "x"})
// if err == nil {
// t.Fatal("Expected error due to invalid path")
// }
// expectedOutput := `error accessing array: strconv.ParseInt: parsing "x": invalid syntax`
// test.AssertResult(t, expectedOutput, err.Error())
// })
t.Run("TestReadMap_with_mapsplat_array_and_bad_index", func(t *testing.T) {
var data = test.ParseData(`
---
b:
d:
e:
- 3
- 4
f:
- 1
- 2
`)
_, err := subject.ReadChildValue(data, []string{"b", "d", "*", "x"})
if err == nil {
t.Fatal("Expected error due to invalid path")
}
expectedOutput := `error accessing array: strconv.ParseInt: parsing "x": invalid syntax`
test.AssertResult(t, expectedOutput, err.Error())
})
// t.Run("TestReadMap_with_mapsplat_array_and_bad_index", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// b:
// d:
// e:
// - 3
// - 4
// f:
// - 1
// - 2
// `)
// _, err := subject.ReadChildValue(data, []string{"b", "d", "*", "x"})
// if err == nil {
// t.Fatal("Expected error due to invalid path")
// }
// expectedOutput := `error accessing array: strconv.ParseInt: parsing "x": invalid syntax`
// test.AssertResult(t, expectedOutput, err.Error())
// })
t.Run("TestReadMap_with_arraysplat_map_array_and_bad_index", func(t *testing.T) {
var data = test.ParseData(`
---
b:
d:
- names:
- fred
- smith
- names:
- sam
- bo
`)
_, err := subject.ReadChildValue(data, []string{"b", "d", "*", "names", "x"})
if err == nil {
t.Fatal("Expected error due to invalid path")
}
expectedOutput := `error accessing array: strconv.ParseInt: parsing "x": invalid syntax`
test.AssertResult(t, expectedOutput, err.Error())
})
// t.Run("TestReadMap_with_arraysplat_map_array_and_bad_index", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// b:
// d:
// - names:
// - fred
// - smith
// - names:
// - sam
// - bo
// `)
// _, err := subject.ReadChildValue(data, []string{"b", "d", "*", "names", "x"})
// if err == nil {
// t.Fatal("Expected error due to invalid path")
// }
// expectedOutput := `error accessing array: strconv.ParseInt: parsing "x": invalid syntax`
// test.AssertResult(t, expectedOutput, err.Error())
// })
t.Run("TestReadMap_with_array_out_of_bounds", func(t *testing.T) {
var data = test.ParseData(`
---
b:
d:
- 3
- 4
`)
got, _ := subject.ReadChildValue(data, []string{"b", "d", "3"})
test.AssertResult(t, nil, got)
})
// t.Run("TestReadMap_with_array_out_of_bounds", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// b:
// d:
// - 3
// - 4
// `)
// got, _ := subject.ReadChildValue(data, []string{"b", "d", "3"})
// test.AssertResult(t, nil, got)
// })
t.Run("TestReadMap_with_array_out_of_bounds_by_1", func(t *testing.T) {
var data = test.ParseData(`
---
b:
d:
- 3
- 4
`)
got, _ := subject.ReadChildValue(data, []string{"b", "d", "2"})
test.AssertResult(t, nil, got)
})
// t.Run("TestReadMap_with_array_out_of_bounds_by_1", func(t *testing.T) {
// var data = test.ParseData(`
// ---
// b:
// d:
// - 3
// - 4
// `)
// got, _ := subject.ReadChildValue(data, []string{"b", "d", "2"})
// test.AssertResult(t, nil, got)
// })
t.Run("TestReadMap_with_array_splat", func(t *testing.T) {
var data = test.ParseData(`
e:
-
name: Fred
thing: cat
-
name: Sam
thing: dog
`)
got, _ := subject.ReadChildValue(data, []string{"e", "*", "name"})
test.AssertResult(t, "[Fred Sam]", fmt.Sprintf("%v", got))
})
// t.Run("TestReadMap_with_array_splat", func(t *testing.T) {
// var data = test.ParseData(`
// e:
// -
// name: Fred
// thing: cat
// -
// name: Sam
// thing: dog
// `)
// got, _ := subject.ReadChildValue(data, []string{"e", "*", "name"})
// test.AssertResult(t, "[Fred Sam]", fmt.Sprintf("%v", got))
// })
t.Run("TestWrite_really_simple", func(t *testing.T) {
var data = test.ParseData(`
b: 2
`)
// t.Run("TestWrite_really_simple", func(t *testing.T) {
// var data = test.ParseData(`
// b: 2
// `)
updated := subject.UpdatedChildValue(data, []string{"b"}, "4")
test.AssertResult(t, "[{b 4}]", fmt.Sprintf("%v", updated))
})
// updated := subject.UpdatedChildValue(data, []string{"b"}, "4")
// test.AssertResult(t, "[{b 4}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWrite_simple", func(t *testing.T) {
var data = test.ParseData(`
b:
c: 2
`)
// t.Run("TestWrite_simple", func(t *testing.T) {
// var data = test.ParseData(`
// b:
// c: 2
// `)
updated := subject.UpdatedChildValue(data, []string{"b", "c"}, "4")
test.AssertResult(t, "[{b [{c 4}]}]", fmt.Sprintf("%v", updated))
})
// updated := subject.UpdatedChildValue(data, []string{"b", "c"}, "4")
// test.AssertResult(t, "[{b [{c 4}]}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWrite_new", func(t *testing.T) {
var data = test.ParseData(`
b:
c: 2
`)
// t.Run("TestWrite_new", func(t *testing.T) {
// var data = test.ParseData(`
// b:
// c: 2
// `)
updated := subject.UpdatedChildValue(data, []string{"b", "d"}, "4")
test.AssertResult(t, "[{b [{c 2} {d 4}]}]", fmt.Sprintf("%v", updated))
})
// updated := subject.UpdatedChildValue(data, []string{"b", "d"}, "4")
// test.AssertResult(t, "[{b [{c 2} {d 4}]}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWrite_new_deep", func(t *testing.T) {
var data = test.ParseData(`
b:
c: 2
`)
// t.Run("TestWrite_new_deep", func(t *testing.T) {
// var data = test.ParseData(`
// b:
// c: 2
// `)
updated := subject.UpdatedChildValue(data, []string{"b", "d", "f"}, "4")
test.AssertResult(t, "[{b [{c 2} {d [{f 4}]}]}]", fmt.Sprintf("%v", updated))
})
// updated := subject.UpdatedChildValue(data, []string{"b", "d", "f"}, "4")
// test.AssertResult(t, "[{b [{c 2} {d [{f 4}]}]}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWrite_array", func(t *testing.T) {
var data = test.ParseData(`
b:
- aa
`)
// t.Run("TestWrite_array", func(t *testing.T) {
// var data = test.ParseData(`
// b:
// - aa
// `)
updated := subject.UpdatedChildValue(data, []string{"b", "0"}, "bb")
// updated := subject.UpdatedChildValue(data, []string{"b", "0"}, "bb")
test.AssertResult(t, "[{b [bb]}]", fmt.Sprintf("%v", updated))
})
// test.AssertResult(t, "[{b [bb]}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWrite_new_array", func(t *testing.T) {
var data = test.ParseData(`
b:
c: 2
`)
// t.Run("TestWrite_new_array", func(t *testing.T) {
// var data = test.ParseData(`
// b:
// c: 2
// `)
updated := subject.UpdatedChildValue(data, []string{"b", "0"}, "4")
test.AssertResult(t, "[{b [{c 2} {0 4}]}]", fmt.Sprintf("%v", updated))
})
// updated := subject.UpdatedChildValue(data, []string{"b", "0"}, "4")
// test.AssertResult(t, "[{b [{c 2} {0 4}]}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWrite_new_array_deep", func(t *testing.T) {
var data = test.ParseData(`
a: apple
`)
// t.Run("TestWrite_new_array_deep", func(t *testing.T) {
// var data = test.ParseData(`
// a: apple
// `)
updated := subject.UpdatedChildValue(data, []string{"b", "+", "c"}, "4")
test.AssertResult(t, "[{a apple} {b [[{c 4}]]}]", fmt.Sprintf("%v", updated))
})
// updated := subject.UpdatedChildValue(data, []string{"b", "+", "c"}, "4")
// test.AssertResult(t, "[{a apple} {b [[{c 4}]]}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWrite_new_map_array_deep", func(t *testing.T) {
var data = test.ParseData(`
b:
c: 2
`)
// t.Run("TestWrite_new_map_array_deep", func(t *testing.T) {
// var data = test.ParseData(`
// b:
// c: 2
// `)
updated := subject.UpdatedChildValue(data, []string{"b", "d", "+"}, "4")
test.AssertResult(t, "[{b [{c 2} {d [4]}]}]", fmt.Sprintf("%v", updated))
})
// updated := subject.UpdatedChildValue(data, []string{"b", "d", "+"}, "4")
// test.AssertResult(t, "[{b [{c 2} {d [4]}]}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWrite_add_to_array", func(t *testing.T) {
var data = test.ParseData(`
b:
- aa
`)
// t.Run("TestWrite_add_to_array", func(t *testing.T) {
// var data = test.ParseData(`
// b:
// - aa
// `)
updated := subject.UpdatedChildValue(data, []string{"b", "1"}, "bb")
test.AssertResult(t, "[{b [aa bb]}]", fmt.Sprintf("%v", updated))
})
// updated := subject.UpdatedChildValue(data, []string{"b", "1"}, "bb")
// test.AssertResult(t, "[{b [aa bb]}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWrite_with_no_tail", func(t *testing.T) {
var data = test.ParseData(`
b:
c: 2
`)
updated := subject.UpdatedChildValue(data, []string{"b"}, "4")
// t.Run("TestWrite_with_no_tail", func(t *testing.T) {
// var data = test.ParseData(`
// b:
// c: 2
// `)
// updated := subject.UpdatedChildValue(data, []string{"b"}, "4")
test.AssertResult(t, "[{b 4}]", fmt.Sprintf("%v", updated))
})
// test.AssertResult(t, "[{b 4}]", fmt.Sprintf("%v", updated))
// })
t.Run("TestWriteMap_no_paths", func(t *testing.T) {
var data = test.ParseData(`
b: 5
`)
var new = test.ParseData(`
c: 4
`)
result := subject.UpdatedChildValue(data, []string{}, new)
test.AssertResult(t, fmt.Sprintf("%v", new), fmt.Sprintf("%v", result))
})
// t.Run("TestWriteMap_no_paths", func(t *testing.T) {
// var data = test.ParseData(`
// b: 5
// `)
// var new = test.ParseData(`
// c: 4
// `)
// result := subject.UpdatedChildValue(data, []string{}, new)
// test.AssertResult(t, fmt.Sprintf("%v", new), fmt.Sprintf("%v", result))
// })
t.Run("TestWriteArray_no_paths", func(t *testing.T) {
var data = make([]interface{}, 1)
data[0] = "mike"
var new = test.ParseData(`
c: 4
`)
result := subject.UpdatedChildValue(data, []string{}, new)
test.AssertResult(t, fmt.Sprintf("%v", new), fmt.Sprintf("%v", result))
})
// t.Run("TestWriteArray_no_paths", func(t *testing.T) {
// var data = make([]interface{}, 1)
// data[0] = "mike"
// var new = test.ParseData(`
// c: 4
// `)
// result := subject.UpdatedChildValue(data, []string{}, new)
// test.AssertResult(t, fmt.Sprintf("%v", new), fmt.Sprintf("%v", result))
// })
t.Run("TestDelete_MapItem", func(t *testing.T) {
var data = test.ParseData(`
a: 123
b: 456
`)
var expected = test.ParseData(`
b: 456
`)
// t.Run("TestDelete_MapItem", func(t *testing.T) {
// var data = test.ParseData(`
// a: 123
// b: 456
// `)
// var expected = test.ParseData(`
// b: 456
// `)
result, _ := subject.DeleteChildValue(data, []string{"a"})
test.AssertResult(t, fmt.Sprintf("%v", expected), fmt.Sprintf("%v", result))
})
// result, _ := subject.DeleteChildValue(data, []string{"a"})
// test.AssertResult(t, fmt.Sprintf("%v", expected), fmt.Sprintf("%v", result))
// })
// Ensure deleting an index into a string does nothing
t.Run("TestDelete_index_to_string", func(t *testing.T) {
var data = test.ParseData(`
a: mystring
`)
result, _ := subject.DeleteChildValue(data, []string{"a", "0"})
test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
})
// // Ensure deleting an index into a string does nothing
// t.Run("TestDelete_index_to_string", func(t *testing.T) {
// var data = test.ParseData(`
// a: mystring
// `)
// result, _ := subject.DeleteChildValue(data, []string{"a", "0"})
// test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
// })
t.Run("TestDelete_list_index", func(t *testing.T) {
var data = test.ParseData(`
a: [3, 4]
`)
var expected = test.ParseData(`
a: [3]
`)
result, _ := subject.DeleteChildValue(data, []string{"a", "1"})
test.AssertResult(t, fmt.Sprintf("%v", expected), fmt.Sprintf("%v", result))
})
// t.Run("TestDelete_list_index", func(t *testing.T) {
// var data = test.ParseData(`
// a: [3, 4]
// `)
// var expected = test.ParseData(`
// a: [3]
// `)
// result, _ := subject.DeleteChildValue(data, []string{"a", "1"})
// test.AssertResult(t, fmt.Sprintf("%v", expected), fmt.Sprintf("%v", result))
// })
t.Run("TestDelete_list_index_beyond_bounds", func(t *testing.T) {
var data = test.ParseData(`
a: [3, 4]
`)
result, _ := subject.DeleteChildValue(data, []string{"a", "5"})
test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
})
// t.Run("TestDelete_list_index_beyond_bounds", func(t *testing.T) {
// var data = test.ParseData(`
// a: [3, 4]
// `)
// result, _ := subject.DeleteChildValue(data, []string{"a", "5"})
// test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
// })
t.Run("TestDelete_list_index_out_of_bounds_by_1", func(t *testing.T) {
var data = test.ParseData(`
a: [3, 4]
`)
result, _ := subject.DeleteChildValue(data, []string{"a", "2"})
test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
})
// t.Run("TestDelete_list_index_out_of_bounds_by_1", func(t *testing.T) {
// var data = test.ParseData(`
// a: [3, 4]
// `)
// result, _ := subject.DeleteChildValue(data, []string{"a", "2"})
// test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
// })
t.Run("TestDelete_no_paths", func(t *testing.T) {
var data = test.ParseData(`
a: [3, 4]
b:
- name: test
`)
result, _ := subject.DeleteChildValue(data, []string{})
test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
})
// t.Run("TestDelete_no_paths", func(t *testing.T) {
// var data = test.ParseData(`
// a: [3, 4]
// b:
// - name: test
// `)
// result, _ := subject.DeleteChildValue(data, []string{})
// test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
// })
t.Run("TestDelete_array_map_item", func(t *testing.T) {
var data = test.ParseData(`
b:
- name: fred
value: blah
- name: john
value: test
`)
var expected = test.ParseData(`
b:
- value: blah
- name: john
value: test
`)
result, _ := subject.DeleteChildValue(data, []string{"b", "0", "name"})
test.AssertResult(t, fmt.Sprintf("%v", expected), fmt.Sprintf("%v", result))
})
}
// t.Run("TestDelete_array_map_item", func(t *testing.T) {
// var data = test.ParseData(`
// b:
// - name: fred
// value: blah
// - name: john
// value: test
// `)
// var expected = test.ParseData(`
// b:
// - value: blah
// - name: john
// value: test
// `)
// result, _ := subject.DeleteChildValue(data, []string{"b", "0", "name"})
// test.AssertResult(t, fmt.Sprintf("%v", expected), fmt.Sprintf("%v", result))
// })
// }

8
pkg/yqlib/lib.go
View File

@@ -14,6 +14,7 @@ type UpdateCommand struct {
}
type YqLib interface {
DebugNode(node *yaml.Node)
Get(rootNode *yaml.Node, path string) (*yaml.Node, error)
Update(rootNode *yaml.Node, updateCommand UpdateCommand) error
}
@@ -32,10 +33,11 @@ func NewYqLib(l *logging.Logger) YqLib {
}
}
func (l *lib) DebugNode(node *yaml.Node) {
l.navigator.DebugNode(node)
}
func (l *lib) Get(rootNode *yaml.Node, path string) (*yaml.Node, error) {
if path == "" {
return rootNode, nil
}
var paths = l.parser.ParsePath(path)
return l.navigator.Get(rootNode, paths)
}

2
pkg/yqlib/lib_test.go
View File

@@ -4,7 +4,7 @@ import (
"fmt"
"testing"
"github.com/mikefarah/yq/v2/test"
"github.com/mikefarah/yq/v3/test"
logging "gopkg.in/op/go-logging.v1"
)

3
pkg/yqlib/path_parser.go
View File

@@ -11,6 +11,9 @@ func NewPathParser() PathParser {
}
func (p *pathParser) ParsePath(path string) []string {
if path == "" {
return []string{}
}
return p.parsePathAccum([]string{}, path)
}

2
pkg/yqlib/path_parser_test.go
View File

@@ -3,7 +3,7 @@ package yqlib
import (
"testing"
"github.com/mikefarah/yq/v2/test"
"github.com/mikefarah/yq/v3/test"
)
var parsePathsTests = []struct {

2
pkg/yqlib/value_parser_test.go
View File

@@ -3,7 +3,7 @@ package yqlib
import (
"testing"
"github.com/mikefarah/yq/v2/test"
"github.com/mikefarah/yq/v3/test"
)
var parseValueTests = []struct {