Add filter operation

[rbren]

Fixes #1586

[rbren]

This was the best way I could find to turn each value into a truthy value to determine if it should be included. LMK if there's a better way

[mikefarah]

hmm, yeah there should be a cleaner way. What this function is basically doing is a map(select(X)).

You could create a new select expression node and give the expression.RHS to it.

something like:

    selectNodesOp := &ExpressionNode{
      Operation: selectOp,
      RHS:       expression.RHS,
      }
      
      includedNodes, err := d.GetMatchingNodes(splatted, selectNodesOp.RHS)

Pretty sure this could be extended to create a map(select) expression and just delegate the logic to those functions entirely...

[rbren]

One thing I'm not super happy with is arrays-of-arrays. But it works the same for both map and filter.

❯ cat arr.yaml
- - 1
  - 2
  - 3
- - 4
  - 5
  - 6

❯ go run yq.go e '.[] | filter(. > 1)' arr.yaml
- 2
- 3
- 4
- 5
- 6

❯ go run yq.go e '.[] | map(. + 1)' arr.yaml
- 2
- 3
- 4
- 5
- 6
- 7

I'd rather see the latter output

- - 2
  - 3
  - 4
- - 5
  - 6
  - 7

[mikefarah]

Yep - the first expression splats the array of arrays, which becomes the new context- and then it maps (or filters) that context.

This is like the difference between: .a | .b = 3 (which will set the root context to .a before updating .b, and doing .a.b = 3 which will deeply update b without changing the root context.

To get what you want - you'd need to run the expression without changing the context. You can use 'with' to that:

yq 'with(.[]; map(. += 1))'

Hope that makes sense!

[mikefarah]

this isn't actually the right result - this means the filter function is return two arrays - each with a single element. It should return a single array with two elements

"D0, P[], (!!seq)::- 1\n- 2\n",

I think if you refactor to use map and select under the hood - it would do the right thing.

[rbren]

Awesome, I didn't know about with! Interesting that it needs += instead of just +

I also got it to do what I want with this expression:

go run yq.go e '.[] |= map(. + 1) | .[] |= filter(. < 4)' arr.yaml

[fearphage]

Isn't filter(...) just shorthand for map(select(...))?