yq/pkg/yqlib/operator_booleans.go

152 lines
4.3 KiB
Go
Raw Normal View History

2020-11-03 23:48:43 +00:00
package yqlib
2020-10-17 11:10:47 +00:00
import (
2020-10-21 01:54:58 +00:00
"container/list"
2021-05-14 04:29:55 +00:00
"fmt"
"strings"
2020-10-17 11:10:47 +00:00
)
func isTruthyNode(node *CandidateNode) bool {
if node == nil {
return false
}
2020-10-20 05:27:30 +00:00
if node.Tag == "!!null" {
return false
2020-10-20 05:27:30 +00:00
}
if node.Kind == ScalarNode && node.Tag == "!!bool" {
// yes/y/true/on
return (strings.EqualFold(node.Value, "y") ||
strings.EqualFold(node.Value, "yes") ||
strings.EqualFold(node.Value, "on") ||
strings.EqualFold(node.Value, "true"))
2020-10-17 11:10:47 +00:00
}
return true
}
2020-10-17 11:10:47 +00:00
func getOwner(lhs *CandidateNode, rhs *CandidateNode) *CandidateNode {
owner := lhs
2020-10-17 11:10:47 +00:00
if lhs == nil && rhs == nil {
owner = &CandidateNode{}
} else if lhs == nil {
owner = rhs
}
return owner
}
2020-10-17 11:10:47 +00:00
2024-01-11 02:17:34 +00:00
func returnRhsTruthy(_ *dataTreeNavigator, _ Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
owner := getOwner(lhs, rhs)
rhsBool := isTruthyNode(rhs)
return createBooleanCandidate(owner, rhsBool), nil
}
func returnLHSWhen(targetBool bool) func(lhs *CandidateNode) (*CandidateNode, error) {
return func(lhs *CandidateNode) (*CandidateNode, error) {
var err error
var lhsBool bool
if lhsBool = isTruthyNode(lhs); lhsBool != targetBool {
return nil, err
}
owner := &CandidateNode{}
if lhs != nil {
owner = lhs
2020-10-17 11:10:47 +00:00
}
return createBooleanCandidate(owner, targetBool), nil
2020-10-17 11:10:47 +00:00
}
}
func findBoolean(wantBool bool, d *dataTreeNavigator, context Context, expressionNode *ExpressionNode, sequenceNode *CandidateNode) (bool, error) {
2021-05-14 04:29:55 +00:00
for _, node := range sequenceNode.Content {
2021-05-14 05:01:44 +00:00
if expressionNode != nil {
//need to evaluate the expression against the node
rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(node), expressionNode)
2021-05-14 05:01:44 +00:00
if err != nil {
return false, err
}
if rhs.MatchingNodes.Len() > 0 {
node = rhs.MatchingNodes.Front().Value.(*CandidateNode)
2021-05-14 05:01:44 +00:00
} else {
// no results found, ignore this entry
continue
}
}
if isTruthyNode(node) == wantBool {
2021-05-14 04:29:55 +00:00
return true, nil
}
}
return false, nil
}
func allOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
var results = list.New()
for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
candidate := el.Value.(*CandidateNode)
if candidate.Kind != SequenceNode {
2023-12-13 00:02:22 +00:00
return Context{}, fmt.Errorf("all only supports arrays, was %v", candidate.Tag)
2021-05-14 04:29:55 +00:00
}
booleanResult, err := findBoolean(false, d, context, expressionNode.RHS, candidate)
2021-05-14 04:29:55 +00:00
if err != nil {
return Context{}, err
}
result := createBooleanCandidate(candidate, !booleanResult)
results.PushBack(result)
}
return context.ChildContext(results), nil
}
func anyOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
var results = list.New()
for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
candidate := el.Value.(*CandidateNode)
if candidate.Kind != SequenceNode {
return Context{}, fmt.Errorf("any only supports arrays, was %v", candidate.Tag)
2021-05-14 04:29:55 +00:00
}
booleanResult, err := findBoolean(true, d, context, expressionNode.RHS, candidate)
2021-05-14 04:29:55 +00:00
if err != nil {
return Context{}, err
}
result := createBooleanCandidate(candidate, booleanResult)
results.PushBack(result)
}
return context.ChildContext(results), nil
}
func orOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
prefs := crossFunctionPreferences{
CalcWhenEmpty: true,
Calculation: returnRhsTruthy,
LhsResultValue: returnLHSWhen(true),
}
return crossFunctionWithPrefs(d, context.ReadOnlyClone(), expressionNode, prefs)
2020-10-17 11:10:47 +00:00
}
func andOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
prefs := crossFunctionPreferences{
CalcWhenEmpty: true,
Calculation: returnRhsTruthy,
LhsResultValue: returnLHSWhen(false),
}
return crossFunctionWithPrefs(d, context.ReadOnlyClone(), expressionNode, prefs)
2020-10-17 11:10:47 +00:00
}
2020-11-22 02:16:54 +00:00
2024-01-11 02:17:34 +00:00
func notOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
2020-11-22 02:16:54 +00:00
log.Debugf("-- notOperation")
var results = list.New()
for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
2020-11-22 02:16:54 +00:00
candidate := el.Value.(*CandidateNode)
log.Debug("notOperation checking %v", candidate)
truthy := isTruthyNode(candidate)
2020-11-22 02:16:54 +00:00
result := createBooleanCandidate(candidate, !truthy)
results.PushBack(result)
}
return context.ChildContext(results), nil
2020-11-22 02:16:54 +00:00
}