add filter operation

pkg/yqlib/lexer_participle.go

@@ -37,6 +37,7 @@ var participleYqRules = []*participleYqRule{
 
 	{"MapValues", `map_?values`, opToken(mapValuesOpType), 0},
 	simpleOp("map", mapOpType),
+	simpleOp("filter", filterOpType),
 	simpleOp("pick", pickOpType),
 
 	{"FlattenWithDepth", `flatten\([0-9]+\)`, flattenWithDepth(), 0},

pkg/yqlib/lib.go

@@ -22,6 +22,9 @@ func InitExpressionParser() {
 }
 
 var log = logging.MustGetLogger("yq-lib")
+func init() {
+	logging.SetLevel(logging.DEBUG, "yq-lib")
+}
 
 var PrettyPrintExp = `(... | (select(tag != "!!str"), select(tag == "!!str") | select(test("(?i)^(y|yes|n|no|on|off)$") | not))  ) style=""`
 
@@ -84,6 +87,7 @@ var expressionOpType = &operationType{Type: "EXP", NumArgs: 0, Precedence: 50, H
 
 var collectOpType = &operationType{Type: "COLLECT", NumArgs: 1, Precedence: 50, Handler: collectOperator}
 var mapOpType = &operationType{Type: "MAP", NumArgs: 1, Precedence: 50, Handler: mapOperator}
+var filterOpType = &operationType{Type: "FILTER", NumArgs: 1, Precedence: 50, Handler: filterOperator}
 var errorOpType = &operationType{Type: "ERROR", NumArgs: 1, Precedence: 50, Handler: errorOperator}
 var pickOpType = &operationType{Type: "PICK", NumArgs: 1, Precedence: 50, Handler: pickOperator}
 var evalOpType = &operationType{Type: "EVAL", NumArgs: 1, Precedence: 50, Handler: evalOperator}

pkg/yqlib/operator_filter.go

@@ -0,0 +1,56 @@
+package yqlib
+
+import (
+	"errors"
+	"container/list"
+)
+
+func filterOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+	log.Debugf("-- filterOperation")
+	var results = list.New()
+
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		children := context.SingleChildContext(candidate)
+		splatted, err := splat(children, traversePreferences{})
+		if err != nil {
+			return Context{}, err
+		}
+
+		if err != nil {
+			return Context{}, err
+		}
+
+		for resultEl := splatted.MatchingNodes.Front(); resultEl != nil; resultEl = resultEl.Next() {
+			result := resultEl.Value.(*CandidateNode)
+			childCtx := context.SingleReadonlyChildContext(result)
+			include, err := d.GetMatchingNodes(childCtx, expressionNode.RHS)
+			if err != nil {
+				return Context{}, err
+			}
+			var includeResult bool
+			var errDecoding error
+			includeEl := include.MatchingNodes.Front()
+			if includeEl.Next() != nil {
+				return Context{}, errors.New("Only expected one child")
+			}
+			includeVal := includeEl.Value.(*CandidateNode)
+			includeResult, errDecoding = isTruthy(includeVal)
+			if errDecoding != nil {
+				return Context{}, errDecoding
+			}
+			log.Debug("isTruthy %v", includeResult)
+			if includeResult {
+				selfExpression := &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
+				collected, err := collectTogether(d, childCtx, selfExpression)
+				if err != nil {
+					return Context{}, err
+				}
+				collected.Node.Style = unwrapDoc(result.Node).Style
+				results.PushBack(collected)
+			}
+		}
+	}
+	return context.ChildContext(results), nil
+}
+