mirror of https://github.com/mikefarah/yq.git
125 lines
4.1 KiB
Go
125 lines
4.1 KiB
Go
package yqlib
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"container/list"
|
|
|
|
yaml "gopkg.in/yaml.v3"
|
|
)
|
|
|
|
type crossFunctionCalculation func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error)
|
|
|
|
func crossFunction(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode, calculation crossFunctionCalculation) (*list.List, error) {
|
|
lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
log.Debugf("crossFunction LHS len: %v", lhs.Len())
|
|
|
|
rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
log.Debugf("crossFunction RHS len: %v", rhs.Len())
|
|
|
|
var results = list.New()
|
|
|
|
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
|
|
}
|
|
|
|
type multiplyPreferences struct {
|
|
AppendArrays bool
|
|
TraversePrefs traversePreferences
|
|
}
|
|
|
|
func multiplyOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
|
|
log.Debugf("-- MultiplyOperator")
|
|
return crossFunction(d, matchingNodes, 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) {
|
|
lhs.Node = unwrapDoc(lhs.Node)
|
|
rhs.Node = unwrapDoc(rhs.Node)
|
|
log.Debugf("Multipling LHS: %v", lhs.Node.Tag)
|
|
log.Debugf("- RHS: %v", rhs.Node.Tag)
|
|
|
|
if lhs.Node.Kind == yaml.MappingNode && rhs.Node.Kind == yaml.MappingNode ||
|
|
(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{})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return mergeObjects(d, newThing, rhs, preferences)
|
|
|
|
}
|
|
return nil, fmt.Errorf("Cannot multiply %v with %v", lhs.Node.Tag, rhs.Node.Tag)
|
|
}
|
|
}
|
|
|
|
func mergeObjects(d *dataTreeNavigator, 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)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var pathIndexToStartFrom int = 0
|
|
if results.Front() != nil {
|
|
pathIndexToStartFrom = len(results.Front().Value.(*CandidateNode).Path)
|
|
}
|
|
|
|
for el := results.Front(); el != nil; el = el.Next() {
|
|
err := applyAssignment(d, pathIndexToStartFrom, lhs, el.Value.(*CandidateNode), preferences)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return lhs, nil
|
|
}
|
|
|
|
func applyAssignment(d *dataTreeNavigator, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) error {
|
|
shouldAppendArrays := preferences.AppendArrays
|
|
log.Debugf("merge - applyAssignment lhs %v, rhs: %v", NodeToString(lhs), NodeToString(rhs))
|
|
|
|
lhsPath := rhs.Path[pathIndexToStartFrom:]
|
|
|
|
assignmentOp := &Operation{OperationType: assignAttributesOpType}
|
|
if rhs.Node.Kind == yaml.ScalarNode || rhs.Node.Kind == yaml.AliasNode {
|
|
assignmentOp.OperationType = assignOpType
|
|
assignmentOp.UpdateAssign = false
|
|
} else if shouldAppendArrays && rhs.Node.Kind == yaml.SequenceNode {
|
|
assignmentOp.OperationType = addAssignOpType
|
|
}
|
|
rhsOp := &Operation{OperationType: valueOpType, CandidateNode: rhs}
|
|
|
|
assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath, preferences.TraversePrefs), Rhs: &ExpressionNode{Operation: rhsOp}}
|
|
|
|
_, err := d.GetMatchingNodes(nodeToMap(lhs), assignmentOpNode)
|
|
|
|
return err
|
|
}
|