From c6efd5519bc35398f5d6ec95d92803ce5299cdcd Mon Sep 17 00:00:00 2001 From: Mike Farah Date: Tue, 2 Feb 2021 18:17:59 +1100 Subject: [PATCH] Pass context through operators Allows more sophisticated functionality --- examples/data1.yaml | 10 ++- pkg/yqlib/all_at_once_evaluator.go | 6 +- pkg/yqlib/context.go | 18 ++++ pkg/yqlib/data_tree_navigator.go | 20 ++--- pkg/yqlib/operator_add.go | 11 ++- pkg/yqlib/operator_alternative.go | 10 +-- pkg/yqlib/operator_anchors_aliases.go | 104 ++++++++++++------------ pkg/yqlib/operator_assign.go | 38 ++++----- pkg/yqlib/operator_booleans.go | 20 ++--- pkg/yqlib/operator_collect.go | 14 ++-- pkg/yqlib/operator_collect_object.go | 42 +++++----- pkg/yqlib/operator_comments.go | 32 ++++---- pkg/yqlib/operator_create_map.go | 26 +++--- pkg/yqlib/operator_delete.go | 27 +++--- pkg/yqlib/operator_document_index.go | 6 +- pkg/yqlib/operator_env.go | 9 +- pkg/yqlib/operator_equals.go | 10 +-- pkg/yqlib/operator_file.go | 12 +-- pkg/yqlib/operator_has.go | 14 ++-- pkg/yqlib/operator_keys.go | 8 +- pkg/yqlib/operator_length.go | 6 +- pkg/yqlib/operator_multiply.go | 81 +++--------------- pkg/yqlib/operator_path.go | 6 +- pkg/yqlib/operator_pipe.go | 17 ++-- pkg/yqlib/operator_recursive_descent.go | 14 ++-- pkg/yqlib/operator_select.go | 14 ++-- pkg/yqlib/operator_self.go | 6 +- pkg/yqlib/operator_sort_keys.go | 15 ++-- pkg/yqlib/operator_split_document.go | 10 +-- pkg/yqlib/operator_strings.go | 32 ++++---- pkg/yqlib/operator_style.go | 36 ++++---- pkg/yqlib/operator_tag.go | 32 ++++---- pkg/yqlib/operator_traverse_path.go | 34 ++++---- pkg/yqlib/operator_union.go | 16 ++-- pkg/yqlib/operator_value.go | 6 +- pkg/yqlib/operators.go | 71 ++++++++++++++-- pkg/yqlib/operators_test.go | 9 +- pkg/yqlib/printer.go | 4 +- pkg/yqlib/printer_test.go | 19 +++-- pkg/yqlib/stream_evaluator.go | 8 +- 40 files changed, 439 insertions(+), 434 deletions(-) create mode 100644 pkg/yqlib/context.go diff --git a/examples/data1.yaml b/examples/data1.yaml index 6b87c47f..1467d89f 100644 --- a/examples/data1.yaml +++ b/examples/data1.yaml @@ -1,4 +1,6 @@ -a: simple # just the best -b: [1, 2] -c: - test: 1 +a: + key1: "value1" + key2: 2.6 + ab: + key1: 6 + key2: "h" \ No newline at end of file diff --git a/pkg/yqlib/all_at_once_evaluator.go b/pkg/yqlib/all_at_once_evaluator.go index 7de4a0b0..cfb936b7 100644 --- a/pkg/yqlib/all_at_once_evaluator.go +++ b/pkg/yqlib/all_at_once_evaluator.go @@ -39,7 +39,11 @@ func (e *allAtOnceEvaluator) EvaluateCandidateNodes(expression string, inputCand if err != nil { return nil, err } - return e.treeNavigator.GetMatchingNodes(inputCandidates, node) + context, err := e.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputCandidates}, node) + if err != nil { + return nil, err + } + return context.MatchingNodes, nil } func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer) error { diff --git a/pkg/yqlib/context.go b/pkg/yqlib/context.go new file mode 100644 index 00000000..a6693c5f --- /dev/null +++ b/pkg/yqlib/context.go @@ -0,0 +1,18 @@ +package yqlib + +import "container/list" + +type Context struct { + MatchingNodes *list.List + Variables map[string]*list.List +} + +func (n *Context) SingleChildContext(candidate *CandidateNode) Context { + elMap := list.New() + elMap.PushBack(candidate) + return Context{MatchingNodes: elMap, Variables: n.Variables} +} + +func (n *Context) ChildContext(results *list.List) Context { + return Context{MatchingNodes: results, Variables: n.Variables} +} diff --git a/pkg/yqlib/data_tree_navigator.go b/pkg/yqlib/data_tree_navigator.go index e9b43506..13659eaa 100644 --- a/pkg/yqlib/data_tree_navigator.go +++ b/pkg/yqlib/data_tree_navigator.go @@ -3,16 +3,14 @@ package yqlib import ( "fmt" - "container/list" - logging "gopkg.in/op/go-logging.v1" ) type DataTreeNavigator interface { - // given a list of CandidateEntities and a expressionNode, - // this will process the list against the given expressionNode and return - // a new list of matching candidates - GetMatchingNodes(matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) + // given the context and a expressionNode, + // this will process the against the given expressionNode and return + // a new context of matching candidates + GetMatchingNodes(context Context, expressionNode *ExpressionNode) (Context, error) } type dataTreeNavigator struct { @@ -22,22 +20,22 @@ func NewDataTreeNavigator() DataTreeNavigator { return &dataTreeNavigator{} } -func (d *dataTreeNavigator) GetMatchingNodes(matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func (d *dataTreeNavigator) GetMatchingNodes(context Context, expressionNode *ExpressionNode) (Context, error) { if expressionNode == nil { log.Debugf("getMatchingNodes - nothing to do") - return matchingNodes, nil + return context, nil } log.Debugf("Processing Op: %v", expressionNode.Operation.toString()) if log.IsEnabledFor(logging.DEBUG) { - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { log.Debug(NodeToString(el.Value.(*CandidateNode))) } } log.Debug(">>") handler := expressionNode.Operation.OperationType.Handler if handler != nil { - return handler(d, matchingNodes, expressionNode) + return handler(d, context, expressionNode) } - return nil, fmt.Errorf("Unknown operator %v", expressionNode.Operation.OperationType) + return Context{}, fmt.Errorf("Unknown operator %v", expressionNode.Operation.OperationType) } diff --git a/pkg/yqlib/operator_add.go b/pkg/yqlib/operator_add.go index 90eafb0f..b263d7d8 100644 --- a/pkg/yqlib/operator_add.go +++ b/pkg/yqlib/operator_add.go @@ -3,7 +3,6 @@ package yqlib import ( "fmt" - "container/list" "strconv" yaml "gopkg.in/yaml.v3" @@ -15,12 +14,12 @@ func createAddOp(lhs *ExpressionNode, rhs *ExpressionNode) *ExpressionNode { Rhs: rhs} } -func addAssignOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func addAssignOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { assignmentOp := &Operation{OperationType: assignOpType} assignmentOp.UpdateAssign = false assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: expressionNode.Lhs, Rhs: createAddOp(expressionNode.Lhs, expressionNode.Rhs)} - return d.GetMatchingNodes(matchingNodes, assignmentOpNode) + return d.GetMatchingNodes(context, assignmentOpNode) } func toNodes(candidate *CandidateNode) []*yaml.Node { @@ -37,13 +36,13 @@ func toNodes(candidate *CandidateNode) []*yaml.Node { } -func addOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func addOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("Add operator") - return crossFunction(d, matchingNodes, expressionNode, add) + return crossFunction(d, context, expressionNode, add) } -func add(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { +func add(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { lhs.Node = unwrapDoc(lhs.Node) rhs.Node = unwrapDoc(rhs.Node) diff --git a/pkg/yqlib/operator_alternative.go b/pkg/yqlib/operator_alternative.go index 0823c8c5..3b310325 100644 --- a/pkg/yqlib/operator_alternative.go +++ b/pkg/yqlib/operator_alternative.go @@ -1,18 +1,14 @@ package yqlib -import ( - "container/list" -) - // corssFunction no matches // can boolean use crossfunction -func alternativeOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func alternativeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- alternative") - return crossFunction(d, matchingNodes, expressionNode, alternativeFunc) + return crossFunction(d, context, expressionNode, alternativeFunc) } -func alternativeFunc(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { +func alternativeFunc(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { lhs.Node = unwrapDoc(lhs.Node) rhs.Node = unwrapDoc(rhs.Node) log.Debugf("Alternative LHS: %v", lhs.Node.Tag) diff --git a/pkg/yqlib/operator_anchors_aliases.go b/pkg/yqlib/operator_anchors_aliases.go index da84869e..c1566bcb 100644 --- a/pkg/yqlib/operator_anchors_aliases.go +++ b/pkg/yqlib/operator_anchors_aliases.go @@ -6,146 +6,146 @@ import ( yaml "gopkg.in/yaml.v3" ) -func assignAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func assignAliasOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("AssignAlias operator!") aliasName := "" if !expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - aliasName = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + aliasName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } } - lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs) + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) if err != nil { - return nil, err + return Context{}, err } - for el := lhs.Front(); el != nil; el = el.Next() { + for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) log.Debugf("Setting aliasName : %v", candidate.GetKey()) if expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - aliasName = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + aliasName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } } candidate.Node.Kind = yaml.AliasNode candidate.Node.Value = aliasName } - return matchingNodes, nil + return context, nil } -func getAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func getAliasOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("GetAlias operator!") var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) node := &yaml.Node{Kind: yaml.ScalarNode, Value: candidate.Node.Value, Tag: "!!str"} result := candidate.CreateChild(nil, node) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } -func assignAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func assignAnchorOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("AssignAnchor operator!") anchorName := "" if !expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - anchorName = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + anchorName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } } - lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs) + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) if err != nil { - return nil, err + return Context{}, err } - for el := lhs.Front(); el != nil; el = el.Next() { + for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) log.Debugf("Setting anchorName of : %v", candidate.GetKey()) if expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - anchorName = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + anchorName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } } candidate.Node.Anchor = anchorName } - return matchingNodes, nil + return context, nil } -func getAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func getAnchorOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("GetAnchor operator!") var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) anchor := candidate.Node.Anchor node := &yaml.Node{Kind: yaml.ScalarNode, Value: anchor, Tag: "!!str"} result := candidate.CreateChild(nil, node) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } -func explodeOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func explodeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- ExplodeOperation") - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) - rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - for childEl := rhs.Front(); childEl != nil; childEl = childEl.Next() { - err = explodeNode(childEl.Value.(*CandidateNode).Node) + for childEl := rhs.MatchingNodes.Front(); childEl != nil; childEl = childEl.Next() { + err = explodeNode(childEl.Value.(*CandidateNode).Node, context) if err != nil { - return nil, err + return Context{}, err } } } - return matchMap, nil + return context, nil } -func explodeNode(node *yaml.Node) error { +func explodeNode(node *yaml.Node, context Context) error { node.Anchor = "" switch node.Kind { case yaml.SequenceNode, yaml.DocumentNode: for index, contentNode := range node.Content { log.Debugf("exploding index %v", index) - errorInContent := explodeNode(contentNode) + errorInContent := explodeNode(contentNode, context) if errorInContent != nil { return errorInContent } @@ -169,7 +169,7 @@ func explodeNode(node *yaml.Node) error { valueNode := node.Content[index+1] log.Debugf("traversing %v", keyNode.Value) if keyNode.Value != "<<" { - err := overrideEntry(node, keyNode, valueNode, index, newContent) + err := overrideEntry(node, keyNode, valueNode, index, context.ChildContext(newContent)) if err != nil { return err } @@ -178,14 +178,14 @@ func explodeNode(node *yaml.Node) error { log.Debugf("an alias merge list!") for index := 0; index < len(valueNode.Content); index = index + 1 { aliasNode := valueNode.Content[index] - err := applyAlias(node, aliasNode.Alias, index, newContent) + err := applyAlias(node, aliasNode.Alias, index, context.ChildContext(newContent)) if err != nil { return err } } } else { log.Debugf("an alias merge!") - err := applyAlias(node, valueNode.Alias, index, newContent) + err := applyAlias(node, valueNode.Alias, index, context.ChildContext(newContent)) if err != nil { return err } @@ -205,7 +205,7 @@ func explodeNode(node *yaml.Node) error { } } -func applyAlias(node *yaml.Node, alias *yaml.Node, aliasIndex int, newContent *list.List) error { +func applyAlias(node *yaml.Node, alias *yaml.Node, aliasIndex int, newContent Context) error { if alias == nil { return nil } @@ -221,15 +221,15 @@ func applyAlias(node *yaml.Node, alias *yaml.Node, aliasIndex int, newContent *l return nil } -func overrideEntry(node *yaml.Node, key *yaml.Node, value *yaml.Node, startIndex int, newContent *list.List) error { +func overrideEntry(node *yaml.Node, key *yaml.Node, value *yaml.Node, startIndex int, newContent Context) error { - err := explodeNode(value) + err := explodeNode(value, newContent) if err != nil { return err } - for newEl := newContent.Front(); newEl != nil; newEl = newEl.Next() { + for newEl := newContent.MatchingNodes.Front(); newEl != nil; newEl = newEl.Next() { valueEl := newEl.Next() // move forward twice keyNode := newEl.Value.(*yaml.Node) log.Debugf("checking new content %v:%v", keyNode.Value, valueEl.Value.(*yaml.Node).Value) @@ -250,12 +250,12 @@ func overrideEntry(node *yaml.Node, key *yaml.Node, value *yaml.Node, startIndex } } - err = explodeNode(key) + err = explodeNode(key, newContent) if err != nil { return err } log.Debugf("adding %v:%v", key.Value, value.Value) - newContent.PushBack(key) - newContent.PushBack(value) + newContent.MatchingNodes.PushBack(key) + newContent.MatchingNodes.PushBack(value) return nil } diff --git a/pkg/yqlib/operator_assign.go b/pkg/yqlib/operator_assign.go index 2d6bc407..85744f5c 100644 --- a/pkg/yqlib/operator_assign.go +++ b/pkg/yqlib/operator_assign.go @@ -1,30 +1,28 @@ package yqlib -import "container/list" - -func assignUpdateOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { - lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs) +func assignUpdateOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) if err != nil { - return nil, err + return Context{}, err } - var rhs *list.List + var rhs Context if !expressionNode.Operation.UpdateAssign { - rhs, err = d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) + rhs, err = d.GetMatchingNodes(context, expressionNode.Rhs) } - for el := lhs.Front(); el != nil; el = el.Next() { + for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) if expressionNode.Operation.UpdateAssign { - rhs, err = d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err = d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) } if err != nil { - return nil, err + return Context{}, err } // grab the first value - first := rhs.Front() + first := rhs.MatchingNodes.Front() if first != nil { rhsCandidate := first.Value.(*CandidateNode) @@ -33,30 +31,30 @@ func assignUpdateOperator(d *dataTreeNavigator, matchingNodes *list.List, expres } } - return matchingNodes, nil + return context, nil } // does not update content or values -func assignAttributesOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { - lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs) +func assignAttributesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) if err != nil { - return nil, err + return Context{}, err } - for el := lhs.Front(); el != nil; el = el.Next() { + for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) - rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } // grab the first value - first := rhs.Front() + first := rhs.MatchingNodes.Front() if first != nil { candidate.UpdateAttributesFrom(first.Value.(*CandidateNode)) } } - return matchingNodes, nil + return context, nil } diff --git a/pkg/yqlib/operator_booleans.go b/pkg/yqlib/operator_booleans.go index 123007f3..af689ab0 100644 --- a/pkg/yqlib/operator_booleans.go +++ b/pkg/yqlib/operator_booleans.go @@ -25,8 +25,8 @@ func isTruthy(c *CandidateNode) (bool, error) { type boolOp func(bool, bool) bool -func performBoolOp(op boolOp) func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { - return func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { +func performBoolOp(op boolOp) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { + return func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { lhs.Node = unwrapDoc(lhs.Node) rhs.Node = unwrapDoc(rhs.Node) @@ -44,35 +44,35 @@ func performBoolOp(op boolOp) func(d *dataTreeNavigator, lhs *CandidateNode, rhs } } -func orOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func orOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- orOp") - return crossFunction(d, matchingNodes, expressionNode, performBoolOp( + return crossFunction(d, context, expressionNode, performBoolOp( func(b1 bool, b2 bool) bool { return b1 || b2 })) } -func andOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func andOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- AndOp") - return crossFunction(d, matchingNodes, expressionNode, performBoolOp( + return crossFunction(d, context, expressionNode, performBoolOp( func(b1 bool, b2 bool) bool { return b1 && b2 })) } -func notOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func notOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- notOperation") var results = list.New() - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) log.Debug("notOperation checking %v", candidate) truthy, errDecoding := isTruthy(candidate) if errDecoding != nil { - return nil, errDecoding + return Context{}, errDecoding } result := createBooleanCandidate(candidate, !truthy) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_collect.go b/pkg/yqlib/operator_collect.go index 1b6ad5be..3dcab637 100644 --- a/pkg/yqlib/operator_collect.go +++ b/pkg/yqlib/operator_collect.go @@ -6,21 +6,21 @@ import ( yaml "gopkg.in/yaml.v3" ) -func collectOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func collectOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- collectOperation") - if matchMap.Len() == 0 { + if context.MatchingNodes.Len() == 0 { node := &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq", Value: "[]"} candidate := &CandidateNode{Node: node} - return nodeToMap(candidate), nil + return context.SingleChildContext(candidate), nil } var results = list.New() node := &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq"} var collectC *CandidateNode - if matchMap.Front() != nil { - collectC = matchMap.Front().Value.(*CandidateNode).CreateChild(nil, node) + if context.MatchingNodes.Front() != nil { + collectC = context.MatchingNodes.Front().Value.(*CandidateNode).CreateChild(nil, node) if len(collectC.Path) > 0 { collectC.Path = collectC.Path[:len(collectC.Path)-1] } @@ -28,7 +28,7 @@ func collectOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode * collectC = &CandidateNode{Node: node} } - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) log.Debugf("Collecting %v", NodeToString(candidate)) node.Content = append(node.Content, unwrapDoc(candidate.Node)) @@ -36,5 +36,5 @@ func collectOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode * results.PushBack(collectC) - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_collect_object.go b/pkg/yqlib/operator_collect_object.go index ecd81669..4aa5f63b 100644 --- a/pkg/yqlib/operator_collect_object.go +++ b/pkg/yqlib/operator_collect_object.go @@ -17,22 +17,22 @@ import ( ... */ -func collectObjectOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func collectObjectOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- collectObjectOperation") - if matchMap.Len() == 0 { + if context.MatchingNodes.Len() == 0 { node := &yaml.Node{Kind: yaml.MappingNode, Tag: "!!map", Value: "{}"} candidate := &CandidateNode{Node: node} - return nodeToMap(candidate), nil + return context.SingleChildContext(candidate), nil } - first := matchMap.Front().Value.(*CandidateNode) + first := context.MatchingNodes.Front().Value.(*CandidateNode) var rotated []*list.List = make([]*list.List, len(first.Node.Content)) for i := 0; i < len(first.Node.Content); i++ { rotated[i] = list.New() } - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidateNode := el.Value.(*CandidateNode) for i := 0; i < len(first.Node.Content); i++ { rotated[i].PushBack(candidateNode.CreateChild(i, candidateNode.Node.Content[i])) @@ -41,59 +41,59 @@ func collectObjectOperator(d *dataTreeNavigator, matchMap *list.List, expression newObject := list.New() for i := 0; i < len(first.Node.Content); i++ { - additions, err := collect(d, list.New(), rotated[i]) + additions, err := collect(d, context.ChildContext(list.New()), rotated[i]) if err != nil { - return nil, err + return Context{}, err } - newObject.PushBackList(additions) + newObject.PushBackList(additions.MatchingNodes) } - return newObject, nil + return context.ChildContext(newObject), nil } -func collect(d *dataTreeNavigator, aggregate *list.List, remainingMatches *list.List) (*list.List, error) { +func collect(d *dataTreeNavigator, context Context, remainingMatches *list.List) (Context, error) { if remainingMatches.Len() == 0 { - return aggregate, nil + return context, nil } candidate := remainingMatches.Remove(remainingMatches.Front()).(*CandidateNode) - splatted, err := splat(d, nodeToMap(candidate), + splatted, err := splat(d, context.SingleChildContext(candidate), traversePreferences{DontFollowAlias: true, IncludeMapKeys: false}) - for splatEl := splatted.Front(); splatEl != nil; splatEl = splatEl.Next() { + for splatEl := splatted.MatchingNodes.Front(); splatEl != nil; splatEl = splatEl.Next() { splatEl.Value.(*CandidateNode).Path = nil } if err != nil { - return nil, err + return Context{}, err } - if aggregate.Len() == 0 { + if context.MatchingNodes.Len() == 0 { return collect(d, splatted, remainingMatches) } newAgg := list.New() - for el := aggregate.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { aggCandidate := el.Value.(*CandidateNode) - for splatEl := splatted.Front(); splatEl != nil; splatEl = splatEl.Next() { + for splatEl := splatted.MatchingNodes.Front(); splatEl != nil; splatEl = splatEl.Next() { splatCandidate := splatEl.Value.(*CandidateNode) newCandidate, err := aggCandidate.Copy() if err != nil { - return nil, err + return Context{}, err } newCandidate.Path = nil - newCandidate, err = multiply(multiplyPreferences{AppendArrays: false})(d, newCandidate, splatCandidate) + newCandidate, err = multiply(multiplyPreferences{AppendArrays: false})(d, context, newCandidate, splatCandidate) if err != nil { - return nil, err + return Context{}, err } newAgg.PushBack(newCandidate) } } - return collect(d, newAgg, remainingMatches) + return collect(d, context.ChildContext(newAgg), remainingMatches) } diff --git a/pkg/yqlib/operator_comments.go b/pkg/yqlib/operator_comments.go index b66cba59..5eebf60c 100644 --- a/pkg/yqlib/operator_comments.go +++ b/pkg/yqlib/operator_comments.go @@ -13,41 +13,41 @@ type commentOpPreferences struct { FootComment bool } -func assignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func assignCommentsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("AssignComments operator!") - lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs) + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) if err != nil { - return nil, err + return Context{}, err } preferences := expressionNode.Operation.Preferences.(commentOpPreferences) comment := "" if !expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - comment = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + comment = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } } - for el := lhs.Front(); el != nil; el = el.Next() { + for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) if expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - comment = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + comment = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } } @@ -63,15 +63,15 @@ func assignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, expr } } - return matchingNodes, nil + return context, nil } -func getCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func getCommentsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { preferences := expressionNode.Operation.Preferences.(commentOpPreferences) log.Debugf("GetComments operator!") var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) comment := "" if preferences.LineComment { @@ -87,5 +87,5 @@ func getCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, express result := candidate.CreateChild(nil, node) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_create_map.go b/pkg/yqlib/operator_create_map.go index cd83922f..dda93c46 100644 --- a/pkg/yqlib/operator_create_map.go +++ b/pkg/yqlib/operator_create_map.go @@ -6,7 +6,7 @@ import ( "gopkg.in/yaml.v3" ) -func createMapOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func createMapOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- createMapOperation") //each matchingNodes entry should turn into a sequence of keys to create. @@ -18,29 +18,29 @@ func createMapOperator(d *dataTreeNavigator, matchingNodes *list.List, expressio sequences := list.New() - if matchingNodes.Len() > 0 { + if context.MatchingNodes.Len() > 0 { - for matchingNodeEl := matchingNodes.Front(); matchingNodeEl != nil; matchingNodeEl = matchingNodeEl.Next() { + for matchingNodeEl := context.MatchingNodes.Front(); matchingNodeEl != nil; matchingNodeEl = matchingNodeEl.Next() { matchingNode := matchingNodeEl.Value.(*CandidateNode) - sequenceNode, err := sequenceFor(d, matchingNode, expressionNode) + sequenceNode, err := sequenceFor(d, context, matchingNode, expressionNode) if err != nil { - return nil, err + return Context{}, err } sequences.PushBack(sequenceNode) } } else { - sequenceNode, err := sequenceFor(d, nil, expressionNode) + sequenceNode, err := sequenceFor(d, context, nil, expressionNode) if err != nil { - return nil, err + return Context{}, err } sequences.PushBack(sequenceNode) } - return nodeToMap(&CandidateNode{Node: listToNodeSeq(sequences), Document: document, Path: path}), nil + return context.SingleChildContext(&CandidateNode{Node: listToNodeSeq(sequences), Document: document, Path: path}), nil } -func sequenceFor(d *dataTreeNavigator, matchingNode *CandidateNode, expressionNode *ExpressionNode) (*CandidateNode, error) { +func sequenceFor(d *dataTreeNavigator, context Context, matchingNode *CandidateNode, expressionNode *ExpressionNode) (*CandidateNode, error) { var path []interface{} var document uint = 0 var matches = list.New() @@ -48,11 +48,11 @@ func sequenceFor(d *dataTreeNavigator, matchingNode *CandidateNode, expressionNo if matchingNode != nil { path = matchingNode.Path document = matchingNode.Document - matches = nodeToMap(matchingNode) + matches.PushBack(matchingNode) } - mapPairs, err := crossFunction(d, matches, expressionNode, - func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { + mapPairs, err := crossFunction(d, context.ChildContext(matches), expressionNode, + func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { node := yaml.Node{Kind: yaml.MappingNode, Tag: "!!map"} log.Debugf("LHS:", NodeToString(lhs)) log.Debugf("RHS:", NodeToString(rhs)) @@ -67,7 +67,7 @@ func sequenceFor(d *dataTreeNavigator, matchingNode *CandidateNode, expressionNo if err != nil { return nil, err } - innerList := listToNodeSeq(mapPairs) + innerList := listToNodeSeq(mapPairs.MatchingNodes) innerList.Style = yaml.FlowStyle return &CandidateNode{Node: innerList, Document: document, Path: path}, nil } diff --git a/pkg/yqlib/operator_delete.go b/pkg/yqlib/operator_delete.go index c84039e6..abda4cd2 100644 --- a/pkg/yqlib/operator_delete.go +++ b/pkg/yqlib/operator_delete.go @@ -1,21 +1,20 @@ package yqlib import ( - "container/list" "fmt" yaml "gopkg.in/yaml.v3" ) -func deleteChildOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func deleteChildOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { - nodesToDelete, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) + nodesToDelete, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - for el := nodesToDelete.Front(); el != nil; el = el.Next() { + for el := nodesToDelete.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) deleteImmediateChildOp := &Operation{ @@ -28,26 +27,26 @@ func deleteChildOperator(d *dataTreeNavigator, matchingNodes *list.List, express Rhs: createTraversalTree(candidate.Path[0:len(candidate.Path)-1], traversePreferences{}), } - _, err := d.GetMatchingNodes(matchingNodes, deleteImmediateChildOpNode) + _, err := d.GetMatchingNodes(context, deleteImmediateChildOpNode) if err != nil { - return nil, err + return Context{}, err } } - return matchingNodes, nil + return context, nil } -func deleteImmediateChildOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { - parents, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) +func deleteImmediateChildOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { + parents, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } childPath := expressionNode.Operation.Value log.Debug("childPath to remove %v", childPath) - for el := parents.Front(); el != nil; el = el.Next() { + for el := parents.MatchingNodes.Front(); el != nil; el = el.Next() { parent := el.Value.(*CandidateNode) parentNode := unwrapDoc(parent.Node) if parentNode.Kind == yaml.MappingNode { @@ -55,11 +54,11 @@ func deleteImmediateChildOperator(d *dataTreeNavigator, matchingNodes *list.List } else if parentNode.Kind == yaml.SequenceNode { deleteFromArray(parent, childPath) } else { - return nil, fmt.Errorf("Cannot delete nodes from parent of tag %v", parentNode.Tag) + return Context{}, fmt.Errorf("Cannot delete nodes from parent of tag %v", parentNode.Tag) } } - return matchingNodes, nil + return context, nil } func deleteFromMap(candidate *CandidateNode, childPath interface{}) { diff --git a/pkg/yqlib/operator_document_index.go b/pkg/yqlib/operator_document_index.go index 2647800c..58aa0312 100644 --- a/pkg/yqlib/operator_document_index.go +++ b/pkg/yqlib/operator_document_index.go @@ -7,14 +7,14 @@ import ( "gopkg.in/yaml.v3" ) -func getDocumentIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func getDocumentIndexOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) node := &yaml.Node{Kind: yaml.ScalarNode, Value: fmt.Sprintf("%v", candidate.Document), Tag: "!!int"} scalar := candidate.CreateChild(nil, node) results.PushBack(scalar) } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_env.go b/pkg/yqlib/operator_env.go index 5089f480..f6c5eebc 100644 --- a/pkg/yqlib/operator_env.go +++ b/pkg/yqlib/operator_env.go @@ -1,7 +1,6 @@ package yqlib import ( - "container/list" "fmt" "os" "strings" @@ -13,7 +12,7 @@ type envOpPreferences struct { StringValue bool } -func envOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func envOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { envName := expressionNode.Operation.CandidateNode.Node.Value log.Debug("EnvOperator, env name:", envName) @@ -29,13 +28,13 @@ func envOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *Expr Value: rawValue, } } else if rawValue == "" { - return nil, fmt.Errorf("Value for env variable '%v' not provided in env()", envName) + return Context{}, fmt.Errorf("Value for env variable '%v' not provided in env()", envName) } else { var dataBucket yaml.Node decoder := yaml.NewDecoder(strings.NewReader(rawValue)) errorReading := decoder.Decode(&dataBucket) if errorReading != nil { - return nil, errorReading + return Context{}, errorReading } //first node is a doc node = unwrapDoc(&dataBucket) @@ -46,5 +45,5 @@ func envOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *Expr target := &CandidateNode{Node: node} - return nodeToMap(target), nil + return context.SingleChildContext(target), nil } diff --git a/pkg/yqlib/operator_equals.go b/pkg/yqlib/operator_equals.go index 0c1ddb29..2882c314 100644 --- a/pkg/yqlib/operator_equals.go +++ b/pkg/yqlib/operator_equals.go @@ -1,15 +1,11 @@ package yqlib -import ( - "container/list" -) - -func equalsOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func equalsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- equalsOperation") - return crossFunction(d, matchingNodes, expressionNode, isEquals) + return crossFunction(d, context, expressionNode, isEquals) } -func isEquals(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { +func isEquals(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { value := false lhsNode := unwrapDoc(lhs.Node) diff --git a/pkg/yqlib/operator_file.go b/pkg/yqlib/operator_file.go index 06ad9469..d4eeeb1e 100644 --- a/pkg/yqlib/operator_file.go +++ b/pkg/yqlib/operator_file.go @@ -7,32 +7,32 @@ import ( yaml "gopkg.in/yaml.v3" ) -func getFilenameOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func getFilenameOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("GetFilename") var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) node := &yaml.Node{Kind: yaml.ScalarNode, Value: candidate.Filename, Tag: "!!str"} result := candidate.CreateChild(nil, node) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } -func getFileIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func getFileIndexOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("GetFileIndex") var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) node := &yaml.Node{Kind: yaml.ScalarNode, Value: fmt.Sprintf("%v", candidate.FileIndex), Tag: "!!int"} result := candidate.CreateChild(nil, node) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_has.go b/pkg/yqlib/operator_has.go index cc433a74..21d36327 100644 --- a/pkg/yqlib/operator_has.go +++ b/pkg/yqlib/operator_has.go @@ -7,20 +7,20 @@ import ( yaml "gopkg.in/yaml.v3" ) -func hasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func hasOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- hasOperation") var results = list.New() - rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) - wanted := rhs.Front().Value.(*CandidateNode).Node + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) + wanted := rhs.MatchingNodes.Front().Value.(*CandidateNode).Node wantedKey := wanted.Value if err != nil { - return nil, err + return Context{}, err } - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) // grab the first value @@ -41,7 +41,7 @@ func hasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode if wanted.Tag == "!!int" { var number, errParsingInt = strconv.ParseInt(wantedKey, 10, 64) // nolint if errParsingInt != nil { - return nil, errParsingInt + return Context{}, errParsingInt } candidateHasKey = int64(len(contents)) > number } @@ -50,5 +50,5 @@ func hasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode results.PushBack(createBooleanCandidate(candidate, false)) } } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_keys.go b/pkg/yqlib/operator_keys.go index b778355f..d2fe78ea 100644 --- a/pkg/yqlib/operator_keys.go +++ b/pkg/yqlib/operator_keys.go @@ -7,12 +7,12 @@ import ( "gopkg.in/yaml.v3" ) -func keysOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func keysOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- keysOperator") var results = list.New() - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) node := unwrapDoc(candidate.Node) var targetNode *yaml.Node @@ -21,14 +21,14 @@ func keysOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *Exp } else if node.Kind == yaml.SequenceNode { targetNode = getIndicies(node) } else { - return nil, fmt.Errorf("Cannot get keys of %v, keys only works for maps and arrays", node.Tag) + return Context{}, fmt.Errorf("Cannot get keys of %v, keys only works for maps and arrays", node.Tag) } result := candidate.CreateChild(nil, targetNode) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } func getMapKeys(node *yaml.Node) *yaml.Node { diff --git a/pkg/yqlib/operator_length.go b/pkg/yqlib/operator_length.go index 70888d2e..07ab0c9b 100644 --- a/pkg/yqlib/operator_length.go +++ b/pkg/yqlib/operator_length.go @@ -7,11 +7,11 @@ import ( yaml "gopkg.in/yaml.v3" ) -func lengthOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func lengthOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- lengthOperation") var results = list.New() - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) targetNode := unwrapDoc(candidate.Node) var length int @@ -35,5 +35,5 @@ func lengthOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *E results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_multiply.go b/pkg/yqlib/operator_multiply.go index 7194acc9..ec86c015 100644 --- a/pkg/yqlib/operator_multiply.go +++ b/pkg/yqlib/operator_multiply.go @@ -9,77 +9,18 @@ import ( yaml "gopkg.in/yaml.v3" ) -type crossFunctionCalculation func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) - -func doCrossFunc(d *dataTreeNavigator, contextList *list.List, expressionNode *ExpressionNode, calculation crossFunctionCalculation) (*list.List, error) { - var results = list.New() - lhs, err := d.GetMatchingNodes(contextList, expressionNode.Lhs) - if err != nil { - return nil, err - } - log.Debugf("crossFunction LHS len: %v", lhs.Len()) - - rhs, err := d.GetMatchingNodes(contextList, expressionNode.Rhs) - - if err != nil { - return nil, err - } - - for el := lhs.Front(); el != nil; el = el.Next() { - lhsCandidate := el.Value.(*CandidateNode) - - for rightEl := rhs.Front(); rightEl != nil; rightEl = rightEl.Next() { - log.Debugf("Applying calc") - rhsCandidate := rightEl.Value.(*CandidateNode) - resultCandidate, err := calculation(d, lhsCandidate, rhsCandidate) - if err != nil { - return nil, err - } - results.PushBack(resultCandidate) - } - - } - return results, nil -} - -func crossFunction(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode, calculation crossFunctionCalculation) (*list.List, error) { - var results = list.New() - - var evaluateAllTogether = true - for matchEl := matchingNodes.Front(); matchEl != nil; matchEl = matchEl.Next() { - evaluateAllTogether = evaluateAllTogether && matchEl.Value.(*CandidateNode).EvaluateTogether - if !evaluateAllTogether { - break - } - } - if evaluateAllTogether { - return doCrossFunc(d, matchingNodes, expressionNode, calculation) - } - - for matchEl := matchingNodes.Front(); matchEl != nil; matchEl = matchEl.Next() { - contextList := nodeToMap(matchEl.Value.(*CandidateNode)) - innerResults, err := doCrossFunc(d, contextList, expressionNode, calculation) - if err != nil { - return nil, err - } - results.PushBackList(innerResults) - } - - return results, nil -} - type multiplyPreferences struct { AppendArrays bool TraversePrefs traversePreferences } -func multiplyOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func multiplyOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- MultiplyOperator") - return crossFunction(d, matchingNodes, expressionNode, multiply(expressionNode.Operation.Preferences.(multiplyPreferences))) + return crossFunction(d, context, expressionNode, multiply(expressionNode.Operation.Preferences.(multiplyPreferences))) } -func multiply(preferences multiplyPreferences) func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { - return func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { +func multiply(preferences multiplyPreferences) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { + return func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) { lhs.Node = unwrapDoc(lhs.Node) rhs.Node = unwrapDoc(rhs.Node) log.Debugf("Multipling LHS: %v", lhs.Node.Tag) @@ -89,11 +30,11 @@ func multiply(preferences multiplyPreferences) func(d *dataTreeNavigator, lhs *C (lhs.Node.Kind == yaml.SequenceNode && rhs.Node.Kind == yaml.SequenceNode) { var newBlank = lhs.CreateChild(nil, &yaml.Node{}) - var newThing, err = mergeObjects(d, newBlank, lhs, multiplyPreferences{}) + var newThing, err = mergeObjects(d, context, newBlank, lhs, multiplyPreferences{}) if err != nil { return nil, err } - return mergeObjects(d, newThing, rhs, preferences) + return mergeObjects(d, context, newThing, rhs, preferences) } else if lhs.Node.Tag == "!!int" && rhs.Node.Tag == "!!int" { return multiplyIntegers(lhs, rhs) } @@ -119,14 +60,14 @@ func multiplyIntegers(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, e return target, nil } -func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) (*CandidateNode, error) { +func mergeObjects(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) (*CandidateNode, error) { shouldAppendArrays := preferences.AppendArrays var results = list.New() // shouldn't recurse arrays if appending prefs := recursiveDescentPreferences{RecurseArray: !shouldAppendArrays, TraversePreferences: traversePreferences{DontFollowAlias: true}} - err := recursiveDecent(d, results, nodeToMap(rhs), prefs) + err := recursiveDecent(d, results, context.SingleChildContext(rhs), prefs) if err != nil { return nil, err } @@ -137,7 +78,7 @@ func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode, } for el := results.Front(); el != nil; el = el.Next() { - err := applyAssignment(d, pathIndexToStartFrom, lhs, el.Value.(*CandidateNode), preferences) + err := applyAssignment(d, context, pathIndexToStartFrom, lhs, el.Value.(*CandidateNode), preferences) if err != nil { return nil, err } @@ -145,7 +86,7 @@ func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode, return lhs, nil } -func applyAssignment(d *dataTreeNavigator, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) error { +func applyAssignment(d *dataTreeNavigator, context Context, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) error { shouldAppendArrays := preferences.AppendArrays log.Debugf("merge - applyAssignment lhs %v, rhs: %v", NodeToString(lhs), NodeToString(rhs)) @@ -162,7 +103,7 @@ func applyAssignment(d *dataTreeNavigator, pathIndexToStartFrom int, lhs *Candid assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath, preferences.TraversePrefs), Rhs: &ExpressionNode{Operation: rhsOp}} - _, err := d.GetMatchingNodes(nodeToMap(lhs), assignmentOpNode) + _, err := d.GetMatchingNodes(context.SingleChildContext(lhs), assignmentOpNode) return err } diff --git a/pkg/yqlib/operator_path.go b/pkg/yqlib/operator_path.go index 677d9b14..a9828b43 100644 --- a/pkg/yqlib/operator_path.go +++ b/pkg/yqlib/operator_path.go @@ -16,12 +16,12 @@ func createPathNodeFor(pathElement interface{}) *yaml.Node { } } -func getPathOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func getPathOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("GetPath") var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) node := &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq"} @@ -35,5 +35,5 @@ func getPathOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionN results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_pipe.go b/pkg/yqlib/operator_pipe.go index d922fcb8..2e023521 100644 --- a/pkg/yqlib/operator_pipe.go +++ b/pkg/yqlib/operator_pipe.go @@ -1,11 +1,18 @@ package yqlib -import "container/list" +func pipeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { -func pipeOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { - lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs) + //lhs may update the variable context, we should pass that into the RHS + // BUT we still return the original context back (see jq) + // https://stedolan.github.io/jq/manual/#Variable/SymbolicBindingOperator:...as$identifier|... + + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) if err != nil { - return nil, err + return Context{}, err } - return d.GetMatchingNodes(lhs, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(lhs, expressionNode.Rhs) + if err != nil { + return Context{}, err + } + return context.ChildContext(rhs.MatchingNodes), nil } diff --git a/pkg/yqlib/operator_recursive_descent.go b/pkg/yqlib/operator_recursive_descent.go index ac08eaa1..71095540 100644 --- a/pkg/yqlib/operator_recursive_descent.go +++ b/pkg/yqlib/operator_recursive_descent.go @@ -11,20 +11,20 @@ type recursiveDescentPreferences struct { RecurseArray bool } -func recursiveDescentOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func recursiveDescentOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { var results = list.New() preferences := expressionNode.Operation.Preferences.(recursiveDescentPreferences) - err := recursiveDecent(d, results, matchMap, preferences) + err := recursiveDecent(d, results, context, preferences) if err != nil { - return nil, err + return Context{}, err } - return results, nil + return context.ChildContext(results), nil } -func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.List, preferences recursiveDescentPreferences) error { - for el := matchMap.Front(); el != nil; el = el.Next() { +func recursiveDecent(d *dataTreeNavigator, results *list.List, context Context, preferences recursiveDescentPreferences) error { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) candidate.Node = unwrapDoc(candidate.Node) @@ -35,7 +35,7 @@ func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.Li if candidate.Node.Kind != yaml.AliasNode && len(candidate.Node.Content) > 0 && (preferences.RecurseArray || candidate.Node.Kind != yaml.SequenceNode) { - children, err := splat(d, nodeToMap(candidate), preferences.TraversePreferences) + children, err := splat(d, context.SingleChildContext(candidate), preferences.TraversePreferences) if err != nil { return err diff --git a/pkg/yqlib/operator_select.go b/pkg/yqlib/operator_select.go index 9a29f892..ce5036ba 100644 --- a/pkg/yqlib/operator_select.go +++ b/pkg/yqlib/operator_select.go @@ -4,28 +4,28 @@ import ( "container/list" ) -func selectOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func selectOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- selectOperation") var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) - rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } // grab the first value - first := rhs.Front() + first := rhs.MatchingNodes.Front() if first != nil { result := first.Value.(*CandidateNode) includeResult, errDecoding := isTruthy(result) if errDecoding != nil { - return nil, errDecoding + return Context{}, errDecoding } if includeResult { @@ -33,5 +33,5 @@ func selectOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNo } } } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_self.go b/pkg/yqlib/operator_self.go index a18a68d6..232f7d7d 100644 --- a/pkg/yqlib/operator_self.go +++ b/pkg/yqlib/operator_self.go @@ -1,7 +1,5 @@ package yqlib -import "container/list" - -func selfOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { - return matchMap, nil +func selfOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { + return context, nil } diff --git a/pkg/yqlib/operator_sort_keys.go b/pkg/yqlib/operator_sort_keys.go index 58199495..e5908be0 100644 --- a/pkg/yqlib/operator_sort_keys.go +++ b/pkg/yqlib/operator_sort_keys.go @@ -1,33 +1,32 @@ package yqlib import ( - "container/list" "sort" yaml "gopkg.in/yaml.v3" ) -func sortKeysOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func sortKeysOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) - rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - for childEl := rhs.Front(); childEl != nil; childEl = childEl.Next() { + for childEl := rhs.MatchingNodes.Front(); childEl != nil; childEl = childEl.Next() { node := unwrapDoc(childEl.Value.(*CandidateNode).Node) if node.Kind == yaml.MappingNode { sortKeys(node) } if err != nil { - return nil, err + return Context{}, err } } } - return matchingNodes, nil + return context, nil } func sortKeys(node *yaml.Node) { diff --git a/pkg/yqlib/operator_split_document.go b/pkg/yqlib/operator_split_document.go index 851fa7c0..6cabcd23 100644 --- a/pkg/yqlib/operator_split_document.go +++ b/pkg/yqlib/operator_split_document.go @@ -1,18 +1,14 @@ package yqlib -import ( - "container/list" -) - -func splitDocumentOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func splitDocumentOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- splitDocumentOperator") var index uint = 0 - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) candidate.Document = index index = index + 1 } - return matchMap, nil + return context, nil } diff --git a/pkg/yqlib/operator_strings.go b/pkg/yqlib/operator_strings.go index 479e3395..8a0c5365 100644 --- a/pkg/yqlib/operator_strings.go +++ b/pkg/yqlib/operator_strings.go @@ -8,32 +8,32 @@ import ( "gopkg.in/yaml.v3" ) -func joinStringOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func joinStringOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- joinStringOperator") joinStr := "" - rhs, err := d.GetMatchingNodes(matchMap, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - joinStr = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + joinStr = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } var results = list.New() - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) node := unwrapDoc(candidate.Node) if node.Kind != yaml.SequenceNode { - return nil, fmt.Errorf("Cannot join with %v, can only join arrays of scalars", node.Tag) + return Context{}, fmt.Errorf("Cannot join with %v, can only join arrays of scalars", node.Tag) } targetNode := join(node.Content, joinStr) result := candidate.CreateChild(nil, targetNode) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } func join(content []*yaml.Node, joinStr string) *yaml.Node { @@ -49,35 +49,35 @@ func join(content []*yaml.Node, joinStr string) *yaml.Node { return &yaml.Node{Kind: yaml.ScalarNode, Value: strings.Join(stringsToJoin, joinStr), Tag: "!!str"} } -func splitStringOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func splitStringOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- splitStringOperator") splitStr := "" - rhs, err := d.GetMatchingNodes(matchMap, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - splitStr = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + splitStr = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } var results = list.New() - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) node := unwrapDoc(candidate.Node) if node.Tag == "!!null" { continue } if node.Tag != "!!str" { - return nil, fmt.Errorf("Cannot split %v, can only split strings", node.Tag) + return Context{}, fmt.Errorf("Cannot split %v, can only split strings", node.Tag) } targetNode := split(node.Value, splitStr) result := candidate.CreateChild(nil, targetNode) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } func split(value string, spltStr string) *yaml.Node { diff --git a/pkg/yqlib/operator_style.go b/pkg/yqlib/operator_style.go index 96408c91..693f344f 100644 --- a/pkg/yqlib/operator_style.go +++ b/pkg/yqlib/operator_style.go @@ -26,43 +26,43 @@ func parseStyle(customStyle string) (yaml.Style, error) { return 0, nil } -func assignStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func assignStyleOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("AssignStyleOperator: %v") var style yaml.Style if !expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - style, err = parseStyle(rhs.Front().Value.(*CandidateNode).Node.Value) + if rhs.MatchingNodes.Front() != nil { + style, err = parseStyle(rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value) if err != nil { - return nil, err + return Context{}, err } } } - lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs) + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) if err != nil { - return nil, err + return Context{}, err } - for el := lhs.Front(); el != nil; el = el.Next() { + for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) log.Debugf("Setting style of : %v", candidate.GetKey()) if expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - style, err = parseStyle(rhs.Front().Value.(*CandidateNode).Node.Value) + if rhs.MatchingNodes.Front() != nil { + style, err = parseStyle(rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value) if err != nil { - return nil, err + return Context{}, err } } } @@ -70,15 +70,15 @@ func assignStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, express candidate.Node.Style = style } - return matchingNodes, nil + return context, nil } -func getStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func getStyleOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("GetStyleOperator") var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) var style string switch candidate.Node.Style { @@ -104,5 +104,5 @@ func getStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, expression results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_tag.go b/pkg/yqlib/operator_tag.go index a3c4b84f..60653509 100644 --- a/pkg/yqlib/operator_tag.go +++ b/pkg/yqlib/operator_tag.go @@ -6,58 +6,58 @@ import ( yaml "gopkg.in/yaml.v3" ) -func assignTagOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func assignTagOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("AssignTagOperator: %v") tag := "" if !expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - tag = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + tag = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } } - lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs) + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) if err != nil { - return nil, err + return Context{}, err } - for el := lhs.Front(); el != nil; el = el.Next() { + for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) log.Debugf("Setting tag of : %v", candidate.GetKey()) if expressionNode.Operation.UpdateAssign { - rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - if rhs.Front() != nil { - tag = rhs.Front().Value.(*CandidateNode).Node.Value + if rhs.MatchingNodes.Front() != nil { + tag = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value } } unwrapDoc(candidate.Node).Tag = tag } - return matchingNodes, nil + return context, nil } -func getTagOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func getTagOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("GetTagOperator") var results = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) node := &yaml.Node{Kind: yaml.ScalarNode, Value: unwrapDoc(candidate.Node).Tag, Tag: "!!str"} result := candidate.CreateChild(nil, node) results.PushBack(result) } - return results, nil + return context.ChildContext(results), nil } diff --git a/pkg/yqlib/operator_traverse_path.go b/pkg/yqlib/operator_traverse_path.go index d63b6cec..20754b60 100644 --- a/pkg/yqlib/operator_traverse_path.go +++ b/pkg/yqlib/operator_traverse_path.go @@ -15,23 +15,23 @@ type traversePreferences struct { DontAutoCreate bool // by default, we automatically create entries on the fly. } -func splat(d *dataTreeNavigator, matches *list.List, prefs traversePreferences) (*list.List, error) { - return traverseNodesWithArrayIndices(matches, make([]*yaml.Node, 0), prefs) +func splat(d *dataTreeNavigator, context Context, prefs traversePreferences) (Context, error) { + return traverseNodesWithArrayIndices(context, make([]*yaml.Node, 0), prefs) } -func traversePathOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func traversePathOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debugf("-- Traversing") - var matchingNodeMap = list.New() + var matches = list.New() - for el := matchMap.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { newNodes, err := traverse(d, el.Value.(*CandidateNode), expressionNode.Operation) if err != nil { - return nil, err + return Context{}, err } - matchingNodeMap.PushBackList(newNodes) + matches.PushBackList(newNodes) } - return matchingNodeMap, nil + return context.ChildContext(matches), nil } func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Operation) (*list.List, error) { @@ -74,30 +74,30 @@ func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Oper } } -func traverseArrayOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func traverseArrayOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { // rhs is a collect expression that will yield indexes to retreive of the arrays - rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - var indicesToTraverse = rhs.Front().Value.(*CandidateNode).Node.Content - return traverseNodesWithArrayIndices(matchingNodes, indicesToTraverse, traversePreferences{}) + var indicesToTraverse = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Content + return traverseNodesWithArrayIndices(context, indicesToTraverse, traversePreferences{}) } -func traverseNodesWithArrayIndices(matchingNodes *list.List, indicesToTraverse []*yaml.Node, prefs traversePreferences) (*list.List, error) { +func traverseNodesWithArrayIndices(context Context, indicesToTraverse []*yaml.Node, prefs traversePreferences) (Context, error) { var matchingNodeMap = list.New() - for el := matchingNodes.Front(); el != nil; el = el.Next() { + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { candidate := el.Value.(*CandidateNode) newNodes, err := traverseArrayIndices(candidate, indicesToTraverse, prefs) if err != nil { - return nil, err + return Context{}, err } matchingNodeMap.PushBackList(newNodes) } - return matchingNodeMap, nil + return context.ChildContext(matchingNodeMap), nil } func traverseArrayIndices(matchingNode *CandidateNode, indicesToTraverse []*yaml.Node, prefs traversePreferences) (*list.List, error) { // call this if doc / alias like the other traverse diff --git a/pkg/yqlib/operator_union.go b/pkg/yqlib/operator_union.go index b95c986f..cb64d140 100644 --- a/pkg/yqlib/operator_union.go +++ b/pkg/yqlib/operator_union.go @@ -1,19 +1,17 @@ package yqlib -import "container/list" - -func unionOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { - lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs) +func unionOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) if err != nil { - return nil, err + return Context{}, err } - rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs) + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) if err != nil { - return nil, err + return Context{}, err } - for el := rhs.Front(); el != nil; el = el.Next() { + for el := rhs.MatchingNodes.Front(); el != nil; el = el.Next() { node := el.Value.(*CandidateNode) - lhs.PushBack(node) + lhs.MatchingNodes.PushBack(node) } return lhs, nil } diff --git a/pkg/yqlib/operator_value.go b/pkg/yqlib/operator_value.go index f30459a0..6c70b1f7 100644 --- a/pkg/yqlib/operator_value.go +++ b/pkg/yqlib/operator_value.go @@ -1,8 +1,6 @@ package yqlib -import "container/list" - -func valueOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) { +func valueOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { log.Debug("value = %v", expressionNode.Operation.CandidateNode.Node.Value) - return nodeToMap(expressionNode.Operation.CandidateNode), nil + return context.SingleChildContext(expressionNode.Operation.CandidateNode), nil } diff --git a/pkg/yqlib/operators.go b/pkg/yqlib/operators.go index 37d4b1eb..08e8ad45 100644 --- a/pkg/yqlib/operators.go +++ b/pkg/yqlib/operators.go @@ -7,7 +7,7 @@ import ( "gopkg.in/yaml.v3" ) -type operatorHandler func(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) +type operatorHandler func(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) func unwrapDoc(node *yaml.Node) *yaml.Node { if node.Kind == yaml.DocumentNode { @@ -16,8 +16,67 @@ func unwrapDoc(node *yaml.Node) *yaml.Node { return node } -func emptyOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) { - return list.New(), nil +func emptyOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { + context.MatchingNodes = list.New() + return context, nil +} + +type crossFunctionCalculation func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) + +func doCrossFunc(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode, calculation crossFunctionCalculation) (Context, error) { + var results = list.New() + lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs) + if err != nil { + return Context{}, err + } + log.Debugf("crossFunction LHS len: %v", lhs.MatchingNodes.Len()) + + rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs) + + if err != nil { + return Context{}, err + } + + for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() { + lhsCandidate := el.Value.(*CandidateNode) + + for rightEl := rhs.MatchingNodes.Front(); rightEl != nil; rightEl = rightEl.Next() { + log.Debugf("Applying calc") + rhsCandidate := rightEl.Value.(*CandidateNode) + resultCandidate, err := calculation(d, context, lhsCandidate, rhsCandidate) + if err != nil { + return Context{}, err + } + results.PushBack(resultCandidate) + } + + } + return context.ChildContext(results), nil +} + +func crossFunction(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode, calculation crossFunctionCalculation) (Context, error) { + var results = list.New() + + var evaluateAllTogether = true + for matchEl := context.MatchingNodes.Front(); matchEl != nil; matchEl = matchEl.Next() { + evaluateAllTogether = evaluateAllTogether && matchEl.Value.(*CandidateNode).EvaluateTogether + if !evaluateAllTogether { + break + } + } + if evaluateAllTogether { + return doCrossFunc(d, context, expressionNode, calculation) + } + + for matchEl := context.MatchingNodes.Front(); matchEl != nil; matchEl = matchEl.Next() { + innerResults, err := doCrossFunc(d, context.SingleChildContext(matchEl.Value.(*CandidateNode)), expressionNode, calculation) + if err != nil { + return Context{}, err + } + results.PushBackList(innerResults.MatchingNodes) + } + + return context.ChildContext(results), nil } func createBooleanCandidate(owner *CandidateNode, value bool) *CandidateNode { @@ -29,12 +88,6 @@ func createBooleanCandidate(owner *CandidateNode, value bool) *CandidateNode { return owner.CreateChild(nil, node) } -func nodeToMap(candidate *CandidateNode) *list.List { - elMap := list.New() - elMap.PushBack(candidate) - return elMap -} - func createTraversalTree(path []interface{}, traversePrefs traversePreferences) *ExpressionNode { if len(path) == 0 { return &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}} diff --git a/pkg/yqlib/operators_test.go b/pkg/yqlib/operators_test.go index 71019c15..cd5cbbee 100644 --- a/pkg/yqlib/operators_test.go +++ b/pkg/yqlib/operators_test.go @@ -27,7 +27,6 @@ type expressionScenario struct { } func testScenario(t *testing.T, s *expressionScenario) { - var results *list.List var err error node, err := NewExpressionParser().ParseExpression(s.expression) @@ -66,13 +65,13 @@ func testScenario(t *testing.T, s *expressionScenario) { os.Setenv("myenv", s.environmentVariable) } - results, err = NewDataTreeNavigator().GetMatchingNodes(inputs, node) + context, err := NewDataTreeNavigator().GetMatchingNodes(Context{MatchingNodes: inputs}, node) if err != nil { t.Error(fmt.Errorf("%v: %v", err, s.expression)) return } - test.AssertResultComplexWithContext(t, s.expected, resultsToString(results), fmt.Sprintf("exp: %v\ndoc: %v", s.expression, s.document)) + test.AssertResultComplexWithContext(t, s.expected, resultsToString(context.MatchingNodes), fmt.Sprintf("exp: %v\ndoc: %v", s.expression, s.document)) } func resultsToString(results *list.List) []string { @@ -252,12 +251,12 @@ func documentOutput(t *testing.T, w *bufio.Writer, s expressionScenario, formatt } - results, err := NewDataTreeNavigator().GetMatchingNodes(inputs, node) + context, err := NewDataTreeNavigator().GetMatchingNodes(Context{MatchingNodes: inputs}, node) if err != nil { t.Error(err, s.expression) } - err = printer.PrintResults(results) + err = printer.PrintResults(context.MatchingNodes) if err != nil { t.Error(err, s.expression) } diff --git a/pkg/yqlib/printer.go b/pkg/yqlib/printer.go index 082c02dd..361e3023 100644 --- a/pkg/yqlib/printer.go +++ b/pkg/yqlib/printer.go @@ -74,14 +74,14 @@ func (p *resultsPrinter) safelyFlush(writer *bufio.Writer) { func (p *resultsPrinter) PrintResults(matchingNodes *list.List) error { log.Debug("PrintResults for %v matches", matchingNodes.Len()) - var err error if p.outputToJSON { explodeOp := Operation{OperationType: explodeOpType} explodeNode := ExpressionNode{Operation: &explodeOp} - matchingNodes, err = p.treeNavigator.GetMatchingNodes(matchingNodes, &explodeNode) + context, err := p.treeNavigator.GetMatchingNodes(Context{MatchingNodes: matchingNodes}, &explodeNode) if err != nil { return err } + matchingNodes = context.MatchingNodes } bufferedWriter := bufio.NewWriter(p.writer) diff --git a/pkg/yqlib/printer_test.go b/pkg/yqlib/printer_test.go index aaafb448..fdb51736 100644 --- a/pkg/yqlib/printer_test.go +++ b/pkg/yqlib/printer_test.go @@ -3,6 +3,7 @@ package yqlib import ( "bufio" "bytes" + "container/list" "strings" "testing" @@ -16,6 +17,12 @@ a: apple a: coconut ` +func nodeToList(candidate *CandidateNode) *list.List { + elMap := list.New() + elMap.PushBack(candidate) + return elMap +} + func TestPrinterMultipleDocsInSequence(t *testing.T) { var output bytes.Buffer var writer = bufio.NewWriter(&output) @@ -27,13 +34,13 @@ func TestPrinterMultipleDocsInSequence(t *testing.T) { } el := inputs.Front() - sample1 := nodeToMap(el.Value.(*CandidateNode)) + sample1 := nodeToList(el.Value.(*CandidateNode)) el = el.Next() - sample2 := nodeToMap(el.Value.(*CandidateNode)) + sample2 := nodeToList(el.Value.(*CandidateNode)) el = el.Next() - sample3 := nodeToMap(el.Value.(*CandidateNode)) + sample3 := nodeToList(el.Value.(*CandidateNode)) err = printer.PrintResults(sample1) if err != nil { @@ -68,19 +75,19 @@ func TestPrinterMultipleFilesInSequence(t *testing.T) { elNode := el.Value.(*CandidateNode) elNode.Document = 0 elNode.FileIndex = 0 - sample1 := nodeToMap(elNode) + sample1 := nodeToList(elNode) el = el.Next() elNode = el.Value.(*CandidateNode) elNode.Document = 0 elNode.FileIndex = 1 - sample2 := nodeToMap(elNode) + sample2 := nodeToList(elNode) el = el.Next() elNode = el.Value.(*CandidateNode) elNode.Document = 0 elNode.FileIndex = 2 - sample3 := nodeToMap(elNode) + sample3 := nodeToList(elNode) err = printer.PrintResults(sample1) if err != nil { diff --git a/pkg/yqlib/stream_evaluator.go b/pkg/yqlib/stream_evaluator.go index 1fc1e0c1..093c2777 100644 --- a/pkg/yqlib/stream_evaluator.go +++ b/pkg/yqlib/stream_evaluator.go @@ -41,11 +41,11 @@ func (s *streamEvaluator) EvaluateNew(expression string, printer Printer) error inputList := list.New() inputList.PushBack(candidateNode) - matches, errorParsing := s.treeNavigator.GetMatchingNodes(inputList, node) + result, errorParsing := s.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputList}, node) if errorParsing != nil { return errorParsing } - return printer.PrintResults(matches) + return printer.PrintResults(result.MatchingNodes) } func (s *streamEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer) error { @@ -97,11 +97,11 @@ func (s *streamEvaluator) Evaluate(filename string, reader io.Reader, node *Expr inputList := list.New() inputList.PushBack(candidateNode) - matches, errorParsing := s.treeNavigator.GetMatchingNodes(inputList, node) + result, errorParsing := s.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputList}, node) if errorParsing != nil { return errorParsing } - err := printer.PrintResults(matches) + err := printer.PrintResults(result.MatchingNodes) if err != nil { return err }