Fixed cross-function combinatorial bug

.github/FUNDING.yml

@@ -1 +0,0 @@
-github: mikefarah

.github/workflows/release.yml

@@ -40,7 +40,17 @@ jobs:
       IMAGE_NAME: mikefarah/yq
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - name: Get latest release tag      
+        uses: oprypin/find-latest-tag@v1
+        with:
+          repository: mikefarah/yq  # The repository to scan.
+          releases-only: true  # We know that all relevant tags have a GitHub release for them.
+        id: yq  
+        
+      - name: Clone source code
+        uses: actions/checkout@v2
+        with:
+          ref: ${{ steps.yq.outputs.tag }}
       
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v1

README.md

@@ -103,7 +103,7 @@ yq() {
 
 ### Go Get:
 ```
-GO111MODULE=on go get github.com/mikefarah/yq/v4
+GO111MODULE=on go get github.com/mikefarah/yq
 ```
 
 ## Community Supported Installation methods

cmd/evaluate_all_command.go

@@ -42,21 +42,14 @@ func evaluateAll(cmd *cobra.Command, args []string) error {
 		colorsEnabled = true
 	}
 
-	firstFileIndex := -1
-	if !nullInput && len(args) == 1 {
-		firstFileIndex = 0
-	} else if len(args) > 1 {
-		firstFileIndex = 1
-	}
-
-	if writeInplace && (firstFileIndex == -1) {
+	if writeInplace && len(args) < 2 {
 		return fmt.Errorf("Write inplace flag only applicable when giving an expression and at least one file")
 	}
 
 	if writeInplace {
 		// only use colors if its forced
 		colorsEnabled = forceColor
-		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[firstFileIndex])
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[1])
 		out, err = writeInPlaceHandler.CreateTempFile()
 		if err != nil {
 			return err

cmd/evalute_sequence_command.go

@@ -62,21 +62,14 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 		colorsEnabled = true
 	}
 
-	firstFileIndex := -1
-	if !nullInput && len(args) == 1 {
-		firstFileIndex = 0
-	} else if len(args) > 1 {
-		firstFileIndex = 1
-	}
-
-	if writeInplace && (firstFileIndex == -1) {
+	if writeInplace && len(args) < 2 {
 		return fmt.Errorf("Write inplace flag only applicable when giving an expression and at least one file")
 	}
 
 	if writeInplace {
 		// only use colors if its forced
 		colorsEnabled = forceColor
-		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[firstFileIndex])
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[1])
 		out, err = writeInPlaceHandler.CreateTempFile()
 		if err != nil {
 			return err
@@ -109,7 +102,7 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{args[0]}, printer)
 		}
 	default:
-		err = streamEvaluator.EvaluateFiles(processExpression(args[0]), args[1:], printer)
+		err = streamEvaluator.EvaluateFiles(args[0], args[1:], printer)
 	}
 	completedSuccessfully = err == nil
 

cmd/version.go

@@ -11,7 +11,7 @@ var (
 	GitDescribe string
 
 	// Version is main version number that is being run at the moment.
-	Version = "4.5.1"
+	Version = "4.4.0"
 
 	// VersionPrerelease is a pre-release marker for the version. If this is "" (empty string)
 	// then it means that it is a final release. Otherwise, this is a pre-release

examples/data1.yaml

@@ -1,6 +1,4 @@
-a:
-  key1: "value1"
-  key2: 2.6
-  ab:
-    key1: 6
-    key2: "h"
+a: simple # just the best
+b: [1, 2]
+c:
+  test: 1

github-action/Dockerfile

@@ -1,4 +1,4 @@
-FROM mikefarah/yq:4.5.1
+FROM mikefarah/yq:4.4.0
 
 COPY entrypoint.sh /entrypoint.sh
 

go.mod

@@ -1,14 +1,14 @@
 module github.com/mikefarah/yq/v4
 
 require (
-	github.com/elliotchance/orderedmap v1.4.0
+	github.com/elliotchance/orderedmap v1.3.0
 	github.com/fatih/color v1.10.0
-	github.com/goccy/go-yaml v1.8.8
-	github.com/jinzhu/copier v0.2.3
+	github.com/goccy/go-yaml v1.8.4
+	github.com/jinzhu/copier v0.1.0
 	github.com/spf13/cobra v1.1.1
 	github.com/timtadh/data-structures v0.5.3 // indirect
 	github.com/timtadh/lexmachine v0.2.2
-	golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c // indirect
+	golang.org/x/sys v0.0.0-20210105210732-16f7687f5001 // indirect
 	gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
 )

go.sum

@@ -36,8 +36,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/elliotchance/orderedmap v1.4.0 h1:wZtfeEONCbx6in1CZyE6bELEt/vFayMvsxqI5SgsR+A=
-github.com/elliotchance/orderedmap v1.4.0/go.mod h1:wsDwEaX5jEoyhbs7x93zk2H/qv0zwuhg4inXhDkYqys=
+github.com/elliotchance/orderedmap v1.3.0 h1:k6m77/d0zCXTjsk12nX40TkEBkSICq8T4s6R6bpCqU0=
+github.com/elliotchance/orderedmap v1.3.0/go.mod h1:8hdSl6jmveQw8ScByd3AaNHNk51RhbTazdqtTty+NFw=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg=
 github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
@@ -52,8 +52,8 @@ github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTM
 github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
 github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/goccy/go-yaml v1.8.8 h1:MGfRB1GeSn/hWXYWS2Pt67iC2GJNnebdIro01ddyucA=
-github.com/goccy/go-yaml v1.8.8/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
+github.com/goccy/go-yaml v1.8.4 h1:AOEdR7aQgbgwHznGe3BLkDQVujxCPUpHOZZcQcp8Y3M=
+github.com/goccy/go-yaml v1.8.4/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -101,8 +101,8 @@ github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2p
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/jinzhu/copier v0.2.3 h1:Oe09ju+9qft7TffZ7l/04AB2f8u1+V4ZMxmp/nnqeOs=
-github.com/jinzhu/copier v0.2.3/go.mod h1:24xnZezI2Yqac9J61UC6/dG/k76ttpq0DdJI3QmUvro=
+github.com/jinzhu/copier v0.1.0 h1:Vh8xALtH3rrKGB/XIRe5d0yCTHPZFauWPLvdpDAbi88=
+github.com/jinzhu/copier v0.1.0/go.mod h1:24xnZezI2Yqac9J61UC6/dG/k76ttpq0DdJI3QmUvro=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
@@ -182,8 +182,6 @@ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/timtadh/data-structures v0.5.3 h1:F2tEjoG9qWIyUjbvXVgJqEOGJPMIiYn7U5W5mE+i/vQ=
 github.com/timtadh/data-structures v0.5.3/go.mod h1:9R4XODhJ8JdWFEI8P/HJKqxuJctfBQw6fDibMQny2oU=
@@ -259,8 +257,8 @@ golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae h1:/WDfKMnPU+m5M4xB+6x4kaepxRw6jWvR5iDRdvjHgy8=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c h1:VwygUrnw9jn88c4u8GD3rZQbqrP/tgas88tPUbBxQrk=
-golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210105210732-16f7687f5001 h1:/dSxr6gT0FNI1MO5WLJo8mTmItROeOKTkDn+7OwWBos=
+golang.org/x/sys v0.0.0-20210105210732-16f7687f5001/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -326,7 +324,6 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

pkg/yqlib/all_at_once_evaluator.go

@@ -39,11 +39,7 @@ func (e *allAtOnceEvaluator) EvaluateCandidateNodes(expression string, inputCand
 	if err != nil {
 		return nil, err
 	}
-	context, err := e.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputCandidates}, node)
-	if err != nil {
-		return nil, err
-	}
-	return context.MatchingNodes, nil
+	return e.treeNavigator.GetMatchingNodes(inputCandidates, node)
 }
 
 func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer) error {

pkg/yqlib/candidate_node.go

@@ -2,6 +2,8 @@ package yqlib
 
 import (
 	"fmt"
+	"strconv"
+	"strings"
 
 	"github.com/jinzhu/copier"
 	yaml "gopkg.in/yaml.v3"
@@ -16,15 +18,10 @@ type CandidateNode struct {
 	// when performing op against all nodes given, this will treat all the nodes as one
 	// (e.g. top level cross document merge). This property does not propegate to child nodes.
 	EvaluateTogether bool
-	IsMapKey         bool
 }
 
 func (n *CandidateNode) GetKey() string {
-	keyPrefix := ""
-	if n.IsMapKey {
-		keyPrefix = "key-"
-	}
-	return fmt.Sprintf("%v%v - %v", keyPrefix, n.Document, n.Path)
+	return fmt.Sprintf("%v - %v", n.Document, n.Path)
 }
 
 func (n *CandidateNode) CreateChild(path interface{}, node *yaml.Node) *CandidateNode {
@@ -66,10 +63,11 @@ func (n *CandidateNode) UpdateFrom(other *CandidateNode) {
 	n.UpdateAttributesFrom(other)
 	n.Node.Content = other.Node.Content
 	n.Node.Value = other.Node.Value
+	n.Node.Alias = other.Node.Alias
+	n.Node.Anchor = other.Node.Anchor
 }
 
 func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode) {
-	log.Debug("UpdateAttributesFrom: n: %v other: %v", n.GetKey(), other.GetKey())
 	if n.Node.Kind != other.Node.Kind {
 		// clear out the contents when switching to a different type
 		// e.g. map to array
@@ -78,8 +76,6 @@ func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode) {
 	}
 	n.Node.Kind = other.Node.Kind
 	n.Node.Tag = other.Node.Tag
-	n.Node.Alias = other.Node.Alias
-	n.Node.Anchor = other.Node.Anchor
 
 	// merge will pickup the style of the new thing
 	// when autocreating nodes
@@ -90,3 +86,46 @@ func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode) {
 	n.Node.HeadComment = n.Node.HeadComment + other.Node.HeadComment
 	n.Node.LineComment = n.Node.LineComment + other.Node.LineComment
 }
+
+func (n *CandidateNode) PathStackToString() string {
+	return mergePathStackToString(n.Path)
+}
+
+func mergePathStackToString(pathStack []interface{}) string {
+	var sb strings.Builder
+	for index, path := range pathStack {
+		switch path.(type) {
+		case int, int64:
+			// if arrayMergeStrategy == AppendArrayMergeStrategy {
+			// sb.WriteString("[+]")
+			// } else {
+			sb.WriteString(fmt.Sprintf("[%v]", path))
+			// }
+
+		default:
+			s := fmt.Sprintf("%v", path)
+			var _, errParsingInt = strconv.ParseInt(s, 10, 64) // nolint
+
+			hasSpecial := strings.Contains(s, ".") || strings.Contains(s, "[") || strings.Contains(s, "]") || strings.Contains(s, "\"")
+			hasDoubleQuotes := strings.Contains(s, "\"")
+			wrappingCharacterStart := "\""
+			wrappingCharacterEnd := "\""
+			if hasDoubleQuotes {
+				wrappingCharacterStart = "("
+				wrappingCharacterEnd = ")"
+			}
+			if hasSpecial || errParsingInt == nil {
+				sb.WriteString(wrappingCharacterStart)
+			}
+			sb.WriteString(s)
+			if hasSpecial || errParsingInt == nil {
+				sb.WriteString(wrappingCharacterEnd)
+			}
+		}
+
+		if index < len(pathStack)-1 {
+			sb.WriteString(".")
+		}
+	}
+	return sb.String()
+}

pkg/yqlib/context.go

@@ -1,54 +0,0 @@
-package yqlib
-
-import (
-	"container/list"
-
-	"github.com/jinzhu/copier"
-)
-
-type Context struct {
-	MatchingNodes  *list.List
-	Variables      map[string]*list.List
-	DontAutoCreate bool
-}
-
-func (n *Context) SingleChildContext(candidate *CandidateNode) Context {
-	list := list.New()
-	list.PushBack(candidate)
-	return n.ChildContext(list)
-}
-
-func (n *Context) GetVariable(name string) *list.List {
-	if n.Variables == nil {
-		return nil
-	}
-	return n.Variables[name]
-}
-
-func (n *Context) SetVariable(name string, value *list.List) {
-	if n.Variables == nil {
-		n.Variables = make(map[string]*list.List)
-	}
-	n.Variables[name] = value
-}
-
-func (n *Context) ChildContext(results *list.List) Context {
-	clone := Context{}
-	err := copier.Copy(&clone, n)
-	if err != nil {
-		log.Error("Error cloning context :(")
-		panic(err)
-	}
-	clone.MatchingNodes = results
-	return clone
-}
-
-func (n *Context) Clone() Context {
-	clone := Context{}
-	err := copier.Copy(&clone, n)
-	if err != nil {
-		log.Error("Error cloning context :(")
-		panic(err)
-	}
-	return clone
-}

pkg/yqlib/data_tree_navigator.go

@@ -3,14 +3,16 @@ package yqlib
 import (
 	"fmt"
 
+	"container/list"
+
 	logging "gopkg.in/op/go-logging.v1"
 )
 
 type DataTreeNavigator interface {
-	// 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)
+	// 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)
 }
 
 type dataTreeNavigator struct {
@@ -20,22 +22,22 @@ func NewDataTreeNavigator() DataTreeNavigator {
 	return &dataTreeNavigator{}
 }
 
-func (d *dataTreeNavigator) GetMatchingNodes(context Context, expressionNode *ExpressionNode) (Context, error) {
+func (d *dataTreeNavigator) GetMatchingNodes(matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	if expressionNode == nil {
 		log.Debugf("getMatchingNodes - nothing to do")
-		return context, nil
+		return matchingNodes, nil
 	}
 	log.Debugf("Processing Op: %v", expressionNode.Operation.toString())
 	if log.IsEnabledFor(logging.DEBUG) {
-		for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+		for el := 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, context, expressionNode)
+		return handler(d, matchingNodes, expressionNode)
 	}
-	return Context{}, fmt.Errorf("Unknown operator %v", expressionNode.Operation.OperationType)
+	return nil, fmt.Errorf("Unknown operator %v", expressionNode.Operation.OperationType)
 
 }

pkg/yqlib/doc/Add.md

@@ -209,15 +209,3 @@ will output
 a: 4
 ```
 
-## Add to null
-Adding to null simply returns the rhs
-
-Running
-```bash
-yq eval --null-input 'null + "cat"'
-```
-will output
-```yaml
-cat
-```
-

pkg/yqlib/doc/Equals.md

@@ -29,24 +29,6 @@ true
 false
 ```
 
-## Don't match string
-Given a sample.yml file of:
-```yaml
-- cat
-- goat
-- dog
-```
-then
-```bash
-yq eval '.[] | (. != "*at")' sample.yml
-```
-will output
-```yaml
-false
-false
-true
-```
-
 ## Match number
 Given a sample.yml file of:
 ```yaml
@@ -65,24 +47,6 @@ true
 false
 ```
 
-## Dont match number
-Given a sample.yml file of:
-```yaml
-- 3
-- 4
-- 5
-```
-then
-```bash
-yq eval '.[] | (. != 4)' sample.yml
-```
-will output
-```yaml
-true
-false
-true
-```
-
 ## Match nulls
 Running
 ```bash

pkg/yqlib/doc/Length.md

@@ -16,20 +16,6 @@ will output
 3
 ```
 
-## null length
-Given a sample.yml file of:
-```yaml
-a: null
-```
-then
-```bash
-yq eval '.a | length' sample.yml
-```
-will output
-```yaml
-0
-```
-
 ## Map length
 returns number of entries
 

pkg/yqlib/doc/Multiply.md

@@ -71,6 +71,7 @@ Given a sample.yml file of:
 a: {things: great}
 b:
   also: "me"
+
 ```
 then
 ```bash

pkg/yqlib/doc/Traverse.md

@@ -33,7 +33,7 @@ c: banana
 ```
 
 ## Special characters
-Use quotes with brackets around path elements with special characters
+Use quotes around path elements with special characters
 
 Given a sample.yml file of:
 ```yaml
@@ -41,23 +41,7 @@ Given a sample.yml file of:
 ```
 then
 ```bash
-yq eval '.["{}"]' sample.yml
-```
-will output
-```yaml
-frog
-```
-
-## Keys with spaces
-Use quotes with brackets around path elements with special characters
-
-Given a sample.yml file of:
-```yaml
-"red rabbit": frog
-```
-then
-```bash
-yq eval '.["red rabbit"]' sample.yml
+yq eval '."{}"' sample.yml
 ```
 will output
 ```yaml

pkg/yqlib/doc/Variable Operators.md

@@ -1,58 +0,0 @@
-For more complex scenarios, variables can be used to hold values of expression to be used in other expressions.
-
-## Single value variable
-Given a sample.yml file of:
-```yaml
-a: cat
-```
-then
-```bash
-yq eval '.a as $foo | $foo' sample.yml
-```
-will output
-```yaml
-cat
-```
-
-## Multi value variable
-Given a sample.yml file of:
-```yaml
-- cat
-- dog
-```
-then
-```bash
-yq eval '.[] as $foo | $foo' sample.yml
-```
-will output
-```yaml
-cat
-dog
-```
-
-## Using variables as a lookup
-Example taken from [jq](https://stedolan.github.io/jq/manual/#Variable/SymbolicBindingOperator:...as$identifier|...)
-
-Given a sample.yml file of:
-```yaml
-"posts":
-  - "title": Frist psot
-    "author": anon
-  - "title": A well-written article
-    "author": person1
-"realnames":
-  "anon": Anonymous Coward
-  "person1": Person McPherson
-```
-then
-```bash
-yq eval '.realnames as $names | .posts[] | {"title":.title, "author": $names[.author]}' sample.yml
-```
-will output
-```yaml
-title: Frist psot
-author: Anonymous Coward
-title: A well-written article
-author: Person McPherson
-```
-

pkg/yqlib/doc/headers/Variable Operators.md

@@ -1 +0,0 @@
-For more complex scenarios, variables can be used to hold values of expression to be used in other expressions.

pkg/yqlib/encoder.go

@@ -76,8 +76,6 @@ func mapKeysToStrings(node *yaml.Node) {
 
 func NewJsonEncoder(destination io.Writer, indent int) Encoder {
 	var encoder = json.NewEncoder(destination)
-	encoder.SetEscapeHTML(false) // do not escape html chars e.g. &, <, >
-
 	var indentString = ""
 
 	for index := 0; index < indent; index++ {
@@ -155,15 +153,11 @@ func (o *orderedMap) UnmarshalJSON(data []byte) error {
 }
 
 func (o orderedMap) MarshalJSON() ([]byte, error) {
+	if o.kv == nil {
+		return json.Marshal(o.altVal)
+	}
 	buf := new(bytes.Buffer)
 	enc := json.NewEncoder(buf)
-	enc.SetEscapeHTML(false) // do not escape html chars e.g. &, <, >
-	if o.kv == nil {
-		if err := enc.Encode(o.altVal); err != nil {
-			return nil, err
-		}
-		return buf.Bytes(), nil
-	}
 	buf.WriteByte('{')
 	for idx, el := range o.kv {
 		if err := enc.Encode(el.K); err != nil {

pkg/yqlib/encoder_test.go

@@ -9,11 +9,29 @@ import (
 	"github.com/mikefarah/yq/v4/test"
 )
 
-func yamlToJson(sampleYaml string, indent int) string {
+var sampleYaml = `zabbix: winner
+apple: great
+banana:
+- {cobra: kai, angus: bob}
+`
+
+var expectedJson = `{
+  "zabbix": "winner",
+  "apple": "great",
+  "banana": [
+    {
+      "cobra": "kai",
+      "angus": "bob"
+    }
+  ]
+}
+`
+
+func TestJsonEncoderPreservesObjectOrder(t *testing.T) {
 	var output bytes.Buffer
 	writer := bufio.NewWriter(&output)
 
-	var jsonEncoder = NewJsonEncoder(writer, indent)
+	var jsonEncoder = NewJsonEncoder(writer, 2)
 	inputs, err := readDocuments(strings.NewReader(sampleYaml), "sample.yml", 0)
 	if err != nil {
 		panic(err)
@@ -24,33 +42,6 @@ func yamlToJson(sampleYaml string, indent int) string {
 		panic(err)
 	}
 	writer.Flush()
+	test.AssertResult(t, expectedJson, output.String())
 
-	return strings.TrimSuffix(output.String(), "\n")
-}
-
-func TestJsonEncoderPreservesObjectOrder(t *testing.T) {
-	var sampleYaml = `zabbix: winner
-apple: great
-banana:
-- {cobra: kai, angus: bob}
-`
-	var expectedJson = `{
-  "zabbix": "winner",
-  "apple": "great",
-  "banana": [
-    {
-      "cobra": "kai",
-      "angus": "bob"
-    }
-  ]
-}`
-	var actualJson = yamlToJson(sampleYaml, 2)
-	test.AssertResult(t, expectedJson, actualJson)
-}
-
-func TestJsonEncoderDoesNotEscapeHTMLChars(t *testing.T) {
-	var sampleYaml = `build: "( ./lint && ./format && ./compile ) < src.code"`
-	var expectedJson = `{"build":"( ./lint && ./format && ./compile ) < src.code"}`
-	var actualJson = yamlToJson(sampleYaml, 0)
-	test.AssertResult(t, expectedJson, actualJson)
 }

pkg/yqlib/expression_parser.go

@@ -70,7 +70,7 @@ func (p *expressionParserImpl) createExpressionTree(postFixPath []*Operation) (*
 		stack = append(stack, &newNode)
 	}
 	if len(stack) != 1 {
-		return nil, fmt.Errorf("Bad expression, please check expression syntax")
+		return nil, fmt.Errorf("expected end of expression but found '%v', please check expression syntax", strings.TrimSpace(stack[1].Operation.StringValue))
 	}
 	return stack[0], nil
 }

pkg/yqlib/expression_parser_test.go

@@ -38,5 +38,5 @@ func TestPathTreeOneArgForOneArgOp(t *testing.T) {
 
 func TestPathTreeExtraArgs(t *testing.T) {
 	_, err := NewExpressionParser().ParseExpression("sortKeys(.) explode(.)")
-	test.AssertResultComplex(t, "Bad expression, please check expression syntax", err.Error())
+	test.AssertResultComplex(t, "expected end of expression but found 'explode', please check expression syntax", err.Error())
 }

pkg/yqlib/expression_postfix.go

@@ -20,22 +20,20 @@ func newExpressionPostFixer() expressionPostFixer {
 func popOpToResult(opStack []*token, result []*Operation) ([]*token, []*Operation) {
 	var newOp *token
 	opStack, newOp = opStack[0:len(opStack)-1], opStack[len(opStack)-1]
-	log.Debugf("popped %v from opstack to results", newOp.toString(true))
 	return opStack, append(result, newOp.Operation)
 }
 
 func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Operation, error) {
 	var result []*Operation
-	// surround the whole thing with brackets
-	var opStack = []*token{{TokenType: openBracket}}
+	// surround the whole thing with quotes
+	var opStack = []*token{&token{TokenType: openBracket}}
 	var tokens = append(infixTokens, &token{TokenType: closeBracket})
 
 	for _, currentToken := range tokens {
-		log.Debugf("postfix processing currentToken %v", currentToken.toString(true))
+		log.Debugf("postfix processing currentToken %v, %v", currentToken.toString(), currentToken.Operation)
 		switch currentToken.TokenType {
 		case openBracket, openCollect, openCollectObject:
 			opStack = append(opStack, currentToken)
-			log.Debugf("put %v onto the opstack", currentToken.toString(true))
 		case closeCollect, closeCollectObject:
 			var opener tokenType = openCollect
 			var collectOperator *operationType = collectOpType
@@ -43,23 +41,23 @@ func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Ope
 				opener = openCollectObject
 				collectOperator = collectObjectOpType
 			}
-
+			itemsInMiddle := false
 			for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != opener {
 				opStack, result = popOpToResult(opStack, result)
+				itemsInMiddle = true
+			}
+			if !itemsInMiddle {
+				// must be an empty collection, add the empty object as a LHS parameter
+				result = append(result, &Operation{OperationType: emptyOpType})
 			}
 			if len(opStack) == 0 {
 				return nil, errors.New("Bad path expression, got close collect brackets without matching opening bracket")
 			}
-			// now we should have [ as the last element on the opStack, get rid of it
+			// now we should have [] as the last element on the opStack, get rid of it
 			opStack = opStack[0 : len(opStack)-1]
-			log.Debugf("deleteing open bracket from opstack")
-
 			//and append a collect to the opStack
-			result = append(result, &Operation{OperationType: collectOperator})
-			log.Debugf("put collect onto the result")
-			result = append(result, &Operation{OperationType: shortPipeOpType})
-			log.Debugf("put shortpipe onto the result")
-
+			opStack = append(opStack, &token{TokenType: operationToken, Operation: &Operation{OperationType: shortPipeOpType}})
+			opStack = append(opStack, &token{TokenType: operationToken, Operation: &Operation{OperationType: collectOperator}})
 		case closeBracket:
 			for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != openBracket {
 				opStack, result = popOpToResult(opStack, result)
@@ -75,12 +73,11 @@ func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Ope
 			// pop off higher precedent operators onto the result
 			for len(opStack) > 0 &&
 				opStack[len(opStack)-1].TokenType == operationToken &&
-				opStack[len(opStack)-1].Operation.OperationType.Precedence > currentPrecedence {
+				opStack[len(opStack)-1].Operation.OperationType.Precedence >= currentPrecedence {
 				opStack, result = popOpToResult(opStack, result)
 			}
 			// add this operator to the opStack
 			opStack = append(opStack, currentToken)
-			log.Debugf("put %v onto the opstack", currentToken.toString(true))
 		}
 	}
 

pkg/yqlib/expression_processing_test.go

@@ -12,70 +12,40 @@ var pathTests = []struct {
 	expectedTokens  []interface{}
 	expectedPostFix []interface{}
 }{
-	{
-		`.a as $item ireduce (0; . + $item)`, // note - add code to shuffle reduce to this position for postfix
-		append(make([]interface{}, 0), "a", "ASSIGN_VARIABLE", "GET_VARIABLE", "REDUCE", "(", "0 (int64)", "BLOCK", "SELF", "ADD", "GET_VARIABLE", ")"),
-		append(make([]interface{}, 0), "a", "GET_VARIABLE", "ASSIGN_VARIABLE", "0 (int64)", "SELF", "GET_VARIABLE", "ADD", "BLOCK", "REDUCE"),
-	},
-	{
-		`.a | .b | .c`,
-		append(make([]interface{}, 0), "a", "PIPE", "b", "PIPE", "c"),
-		append(make([]interface{}, 0), "a", "b", "c", "PIPE", "PIPE"),
-	},
 	{
 		`[]`,
-		append(make([]interface{}, 0), "[", "EMPTY", "]"),
+		append(make([]interface{}, 0), "[", "]"),
 		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE"),
 	},
-	{
-		`{}`,
-		append(make([]interface{}, 0), "{", "EMPTY", "}"),
-		append(make([]interface{}, 0), "EMPTY", "COLLECT_OBJECT", "SHORT_PIPE"),
-	},
-	{
-		`[{}]`,
-		append(make([]interface{}, 0), "[", "{", "EMPTY", "}", "]"),
-		append(make([]interface{}, 0), "EMPTY", "COLLECT_OBJECT", "SHORT_PIPE", "COLLECT", "SHORT_PIPE"),
-	},
-	{
-		`.realnames as $names | $names["anon"]`,
-		append(make([]interface{}, 0), "realnames", "ASSIGN_VARIABLE", "GET_VARIABLE", "PIPE", "GET_VARIABLE", "TRAVERSE_ARRAY", "[", "anon (string)", "]"),
-		append(make([]interface{}, 0), "realnames", "GET_VARIABLE", "ASSIGN_VARIABLE", "GET_VARIABLE", "anon (string)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "PIPE"),
-	},
-	{
-		`.b[.a]`,
-		append(make([]interface{}, 0), "b", "TRAVERSE_ARRAY", "[", "a", "]"),
-		append(make([]interface{}, 0), "b", "a", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
-	},
 	{
 		`.[]`,
-		append(make([]interface{}, 0), "SELF", "TRAVERSE_ARRAY", "[", "EMPTY", "]"),
-		append(make([]interface{}, 0), "SELF", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+		append(make([]interface{}, 0), "TRAVERSE_ARRAY", "[", "]"),
+		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
 	},
 	{
 		`.a[]`,
-		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "EMPTY", "]"),
-		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
 	},
 	{
 		`.a.[]`,
-		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "EMPTY", "]"),
-		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
 	},
 	{
 		`.a[0]`,
-		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
-		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
+		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
 	},
 	{
 		`.a.[0]`,
-		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
-		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
+		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
 	},
 	{
 		`.a[].c`,
-		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "SHORT_PIPE", "c"),
-		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "c", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]", "SHORT_PIPE", "c"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "c", "SHORT_PIPE"),
 	},
 	{
 		`[3]`,
@@ -99,18 +69,18 @@ var pathTests = []struct {
 	},
 	{
 		`.a | .[].b == "apple"`,
-		append(make([]interface{}, 0), "a", "PIPE", "SELF", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "SHORT_PIPE", "b", "EQUALS", "apple (string)"),
-		append(make([]interface{}, 0), "a", "SELF", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "apple (string)", "EQUALS", "PIPE"),
+		append(make([]interface{}, 0), "a", "PIPE", "TRAVERSE_ARRAY", "[", "]", "SHORT_PIPE", "b", "EQUALS", "apple (string)"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "apple (string)", "EQUALS", "PIPE"),
 	},
 	{
 		`(.a | .[].b) == "apple"`,
-		append(make([]interface{}, 0), "(", "a", "PIPE", "SELF", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "SHORT_PIPE", "b", ")", "EQUALS", "apple (string)"),
-		append(make([]interface{}, 0), "a", "SELF", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "PIPE", "apple (string)", "EQUALS"),
+		append(make([]interface{}, 0), "(", "a", "PIPE", "TRAVERSE_ARRAY", "[", "]", "SHORT_PIPE", "b", ")", "EQUALS", "apple (string)"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "PIPE", "apple (string)", "EQUALS"),
 	},
 	{
 		`.[] | select(. == "*at")`,
-		append(make([]interface{}, 0), "SELF", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "PIPE", "SELECT", "(", "SELF", "EQUALS", "*at (string)", ")"),
-		append(make([]interface{}, 0), "SELF", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SELF", "*at (string)", "EQUALS", "SELECT", "PIPE"),
+		append(make([]interface{}, 0), "TRAVERSE_ARRAY", "[", "]", "PIPE", "SELECT", "(", "SELF", "EQUALS", "*at (string)", ")"),
+		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SELF", "*at (string)", "EQUALS", "SELECT", "PIPE"),
 	},
 	{
 		`[true]`,
@@ -143,9 +113,9 @@ var pathTests = []struct {
 		append(make([]interface{}, 0), "a", "mike (string)", "CREATE_MAP", "COLLECT_OBJECT", "SHORT_PIPE"),
 	},
 	{
-		`{.a: .c, .b.[]: .f.g[]}`,
-		append(make([]interface{}, 0), "{", "a", "CREATE_MAP", "c", "UNION", "b", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "CREATE_MAP", "f", "SHORT_PIPE", "g", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "}"),
-		append(make([]interface{}, 0), "a", "c", "CREATE_MAP", "b", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "f", "g", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "CREATE_MAP", "UNION", "COLLECT_OBJECT", "SHORT_PIPE"),
+		`{.a: .c, .b.[]: .f.g.[]}`,
+		append(make([]interface{}, 0), "{", "a", "CREATE_MAP", "c", "UNION", "b", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]", "CREATE_MAP", "f", "SHORT_PIPE", "g", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]", "}"),
+		append(make([]interface{}, 0), "a", "c", "CREATE_MAP", "b", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "f", "g", "SHORT_PIPE", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "CREATE_MAP", "UNION", "COLLECT_OBJECT", "SHORT_PIPE"),
 	},
 	{
 		`explode(.a.b)`,
@@ -197,6 +167,11 @@ var pathTests = []struct {
 		append(make([]interface{}, 0), "foo*", "PIPE", "(", "SELF", "ASSIGN_STYLE", "flow (string)", ")"),
 		append(make([]interface{}, 0), "foo*", "SELF", "flow (string)", "ASSIGN_STYLE", "PIPE"),
 	},
+	{
+		`{}`,
+		append(make([]interface{}, 0), "{", "}"),
+		append(make([]interface{}, 0), "EMPTY", "COLLECT_OBJECT", "SHORT_PIPE"),
+	},
 }
 
 var tokeniser = newExpressionTokeniser()
@@ -210,7 +185,7 @@ func TestPathParsing(t *testing.T) {
 		}
 		var tokenValues []interface{}
 		for _, token := range tokens {
-			tokenValues = append(tokenValues, token.toString(false))
+			tokenValues = append(tokenValues, token.toString())
 		}
 		test.AssertResultComplexWithContext(t, tt.expectedTokens, tokenValues, fmt.Sprintf("tokenise: %v", tt.path))
 

pkg/yqlib/expression_tokeniser.go

@@ -34,11 +34,9 @@ type token struct {
 
 }
 
-func (t *token) toString(detail bool) string {
+func (t *token) toString() string {
 	if t.TokenType == operationToken {
-		if detail {
-			return fmt.Sprintf("%v (%v)", t.Operation.toString(), t.Operation.OperationType.Precedence)
-		}
+		log.Debug("toString, its an op")
 		return t.Operation.toString()
 	} else if t.TokenType == openBracket {
 		return "("
@@ -182,19 +180,6 @@ func stringValue(wrapped bool) lex.Action {
 	}
 }
 
-func getVariableOpToken() lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		value := string(m.Bytes)
-
-		value = value[1 : len(value)-1]
-
-		getVarOperation := createValueOperation(value, value)
-		getVarOperation.OperationType = getVariableOpType
-
-		return &token{TokenType: operationToken, Operation: getVarOperation, CheckForPostTraverse: true}, nil
-	}
-}
-
 func envOp(strenv bool) lex.Action {
 	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
 		value := string(m.Bytes)
@@ -252,8 +237,6 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`or`), opToken(orOpType))
 	lexer.Add([]byte(`and`), opToken(andOpType))
 	lexer.Add([]byte(`not`), opToken(notOpType))
-	lexer.Add([]byte(`ireduce`), opToken(reduceOpType))
-	lexer.Add([]byte(`;`), opToken(blockOpType))
 	lexer.Add([]byte(`\/\/`), opToken(alternativeOpType))
 
 	lexer.Add([]byte(`documentIndex`), opToken(getDocumentIndexOpType))
@@ -286,7 +269,6 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`collect`), opToken(collectOpType))
 
 	lexer.Add([]byte(`\s*==\s*`), opToken(equalsOpType))
-	lexer.Add([]byte(`\s*!=\s*`), opToken(notEqualsOpType))
 	lexer.Add([]byte(`\s*=\s*`), assignOpToken(false))
 
 	lexer.Add([]byte(`del`), opToken(deleteChildOpType))
@@ -322,8 +304,6 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`\*[\+|\?]*`), multiplyWithPrefs())
 	lexer.Add([]byte(`\+`), opToken(addOpType))
 	lexer.Add([]byte(`\+=`), opToken(addAssignOpType))
-	lexer.Add([]byte(`\$[a-zA-Z_-0-9]+`), getVariableOpToken())
-	lexer.Add([]byte(`as`), opToken(assignVariableOpType))
 
 	err := lexer.Compile()
 	if err != nil {
@@ -359,7 +339,7 @@ func (p *expressionTokeniserImpl) Tokenise(expression string) ([]*token, error)
 
 		if tok != nil {
 			currentToken := tok.(*token)
-			log.Debugf("Tokenising %v", currentToken.toString(true))
+			log.Debugf("Tokenising %v", currentToken.toString())
 			tokens = append(tokens, currentToken)
 		}
 		if err != nil {
@@ -389,12 +369,6 @@ func (p *expressionTokeniserImpl) handleToken(tokens []*token, index int, postPr
 		//need to put a traverse array then a collect currentToken
 		// do this by adding traverse then converting currentToken to collect
 
-		if index == 0 || tokens[index-1].TokenType != operationToken ||
-			tokens[index-1].Operation.OperationType != traversePathOpType {
-			op := &Operation{OperationType: selfReferenceOpType, StringValue: "SELF"}
-			postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
-		}
-
 		op := &Operation{OperationType: traverseArrayOpType, StringValue: "TRAVERSE_ARRAY"}
 		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
 
@@ -412,14 +386,6 @@ func (p *expressionTokeniserImpl) handleToken(tokens []*token, index int, postPr
 
 	postProcessedTokens = append(postProcessedTokens, currentToken)
 
-	if index != len(tokens)-1 &&
-		((currentToken.TokenType == openCollect && tokens[index+1].TokenType == closeCollect) ||
-			(currentToken.TokenType == openCollectObject && tokens[index+1].TokenType == closeCollectObject)) {
-
-		op := &Operation{OperationType: emptyOpType, StringValue: "EMPTY"}
-		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
-	}
-
 	if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
 		tokens[index+1].TokenType == operationToken &&
 		tokens[index+1].Operation.OperationType == traversePathOpType {
@@ -429,8 +395,18 @@ func (p *expressionTokeniserImpl) handleToken(tokens []*token, index int, postPr
 	if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
 		tokens[index+1].TokenType == openCollect {
 
-		op := &Operation{OperationType: traverseArrayOpType}
+		op := &Operation{OperationType: shortPipeOpType, Value: "PIPE"}
 		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
+
+		op = &Operation{OperationType: traverseArrayOpType}
+		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
+	}
+	if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
+		tokens[index+1].TokenType == traverseArrayCollect {
+
+		op := &Operation{OperationType: shortPipeOpType, Value: "PIPE"}
+		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
+
 	}
 	return postProcessedTokens, skipNextToken
 }

pkg/yqlib/lib.go

@@ -25,9 +25,6 @@ type operationType struct {
 
 var orOpType = &operationType{Type: "OR", NumArgs: 2, Precedence: 20, Handler: orOperator}
 var andOpType = &operationType{Type: "AND", NumArgs: 2, Precedence: 20, Handler: andOperator}
-var reduceOpType = &operationType{Type: "REDUCE", NumArgs: 2, Precedence: 5, Handler: reduceOperator}
-
-var blockOpType = &operationType{Type: "BLOCK", Precedence: 10, NumArgs: 2, Handler: emptyOperator}
 
 var unionOpType = &operationType{Type: "UNION", NumArgs: 2, Precedence: 10, Handler: unionOperator}
 
@@ -38,7 +35,6 @@ var addAssignOpType = &operationType{Type: "ADD_ASSIGN", NumArgs: 2, Precedence:
 
 var assignAttributesOpType = &operationType{Type: "ASSIGN_ATTRIBUTES", NumArgs: 2, Precedence: 40, Handler: assignAttributesOperator}
 var assignStyleOpType = &operationType{Type: "ASSIGN_STYLE", NumArgs: 2, Precedence: 40, Handler: assignStyleOperator}
-var assignVariableOpType = &operationType{Type: "ASSIGN_VARIABLE", NumArgs: 2, Precedence: 40, Handler: assignVariableOperator}
 var assignTagOpType = &operationType{Type: "ASSIGN_TAG", NumArgs: 2, Precedence: 40, Handler: assignTagOperator}
 var assignCommentOpType = &operationType{Type: "ASSIGN_COMMENT", NumArgs: 2, Precedence: 40, Handler: assignCommentsOperator}
 var assignAnchorOpType = &operationType{Type: "ASSIGN_ANCHOR", NumArgs: 2, Precedence: 40, Handler: assignAnchorOperator}
@@ -49,7 +45,6 @@ var addOpType = &operationType{Type: "ADD", NumArgs: 2, Precedence: 42, Handler:
 var alternativeOpType = &operationType{Type: "ALTERNATIVE", NumArgs: 2, Precedence: 42, Handler: alternativeOperator}
 
 var equalsOpType = &operationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: equalsOperator}
-var notEqualsOpType = &operationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: notEqualsOperator}
 var createMapOpType = &operationType{Type: "CREATE_MAP", NumArgs: 2, Precedence: 40, Handler: createMapOperator}
 
 var shortPipeOpType = &operationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence: 45, Handler: pipeOperator}
@@ -57,7 +52,6 @@ var shortPipeOpType = &operationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence:
 var lengthOpType = &operationType{Type: "LENGTH", NumArgs: 0, Precedence: 50, Handler: lengthOperator}
 var collectOpType = &operationType{Type: "COLLECT", NumArgs: 0, Precedence: 50, Handler: collectOperator}
 var splitDocumentOpType = &operationType{Type: "SPLIT_DOC", NumArgs: 0, Precedence: 50, Handler: splitDocumentOperator}
-var getVariableOpType = &operationType{Type: "GET_VARIABLE", NumArgs: 0, Precedence: 55, Handler: getVariableOperator}
 var getStyleOpType = &operationType{Type: "GET_STYLE", NumArgs: 0, Precedence: 50, Handler: getStyleOperator}
 var getTagOpType = &operationType{Type: "GET_TAG", NumArgs: 0, Precedence: 50, Handler: getTagOperator}
 var getCommentOpType = &operationType{Type: "GET_COMMENT", NumArgs: 0, Precedence: 50, Handler: getCommentsOperator}
@@ -76,14 +70,14 @@ var splitStringOpType = &operationType{Type: "SPLIT", NumArgs: 1, Precedence: 50
 var keysOpType = &operationType{Type: "KEYS", NumArgs: 0, Precedence: 50, Handler: keysOperator}
 
 var collectObjectOpType = &operationType{Type: "COLLECT_OBJECT", NumArgs: 0, Precedence: 50, Handler: collectObjectOperator}
-var traversePathOpType = &operationType{Type: "TRAVERSE_PATH", NumArgs: 0, Precedence: 55, Handler: traversePathOperator}
-var traverseArrayOpType = &operationType{Type: "TRAVERSE_ARRAY", NumArgs: 2, Precedence: 50, Handler: traverseArrayOperator}
+var traversePathOpType = &operationType{Type: "TRAVERSE_PATH", NumArgs: 0, Precedence: 50, Handler: traversePathOperator}
+var traverseArrayOpType = &operationType{Type: "TRAVERSE_ARRAY", NumArgs: 1, Precedence: 50, Handler: traverseArrayOperator}
 
-var selfReferenceOpType = &operationType{Type: "SELF", NumArgs: 0, Precedence: 55, Handler: selfOperator}
+var selfReferenceOpType = &operationType{Type: "SELF", NumArgs: 0, Precedence: 50, Handler: selfOperator}
 var valueOpType = &operationType{Type: "VALUE", NumArgs: 0, Precedence: 50, Handler: valueOperator}
 var envOpType = &operationType{Type: "ENV", NumArgs: 0, Precedence: 50, Handler: envOperator}
 var notOpType = &operationType{Type: "NOT", NumArgs: 0, Precedence: 50, Handler: notOperator}
-var emptyOpType = &operationType{Type: "EMPTY", Precedence: 50, Handler: emptyOperator}
+var emptyOpType = &operationType{Type: "EMPTY", NumArgs: 50, Handler: emptyOperator}
 
 var recursiveDescentOpType = &operationType{Type: "RECURSIVE_DESCENT", NumArgs: 0, Precedence: 50, Handler: recursiveDescentOperator}
 

pkg/yqlib/operator_add.go

@@ -3,6 +3,7 @@ package yqlib
 import (
 	"fmt"
 
+	"container/list"
 	"strconv"
 
 	yaml "gopkg.in/yaml.v3"
@@ -14,12 +15,12 @@ func createAddOp(lhs *ExpressionNode, rhs *ExpressionNode) *ExpressionNode {
 		Rhs: rhs}
 }
 
-func addAssignOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func addAssignOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	assignmentOp := &Operation{OperationType: assignOpType}
 	assignmentOp.UpdateAssign = false
 
 	assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: expressionNode.Lhs, Rhs: createAddOp(expressionNode.Lhs, expressionNode.Rhs)}
-	return d.GetMatchingNodes(context, assignmentOpNode)
+	return d.GetMatchingNodes(matchingNodes, assignmentOpNode)
 }
 
 func toNodes(candidate *CandidateNode) []*yaml.Node {
@@ -36,23 +37,18 @@ func toNodes(candidate *CandidateNode) []*yaml.Node {
 
 }
 
-func addOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func addOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("Add operator")
 
-	return crossFunction(d, context, expressionNode, add)
+	return crossFunction(d, matchingNodes, expressionNode, add)
 }
 
-func add(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func add(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
 	lhs.Node = unwrapDoc(lhs.Node)
 	rhs.Node = unwrapDoc(rhs.Node)
 
-	lhsNode := lhs.Node
-
-	if lhsNode.Tag == "!!null" {
-		return lhs.CreateChild(nil, rhs.Node), nil
-	}
-
 	target := lhs.CreateChild(nil, &yaml.Node{})
+	lhsNode := lhs.Node
 
 	switch lhsNode.Kind {
 	case yaml.MappingNode:

pkg/yqlib/operator_add_test.go

@@ -112,14 +112,6 @@ var addOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{a: 4}\n",
 		},
 	},
-	{
-		description:    "Add to null",
-		subdescription: "Adding to null simply returns the rhs",
-		expression:     `null + "cat"`,
-		expected: []string{
-			"D0, P[], (!!str)::cat\n",
-		},
-	},
 }
 
 func TestAddOperatorScenarios(t *testing.T) {

pkg/yqlib/operator_alternative.go

@@ -1,14 +1,18 @@
 package yqlib
 
+import (
+	"container/list"
+)
+
 // corssFunction no matches
 // can boolean use crossfunction
 
-func alternativeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func alternativeOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- alternative")
-	return crossFunction(d, context, expressionNode, alternativeFunc)
+	return crossFunction(d, matchingNodes, expressionNode, alternativeFunc)
 }
 
-func alternativeFunc(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func alternativeFunc(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
 	lhs.Node = unwrapDoc(lhs.Node)
 	rhs.Node = unwrapDoc(rhs.Node)
 	log.Debugf("Alternative LHS: %v", lhs.Node.Tag)

pkg/yqlib/operator_anchors_aliases.go

@@ -6,146 +6,146 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func assignAliasOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func assignAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 
 	log.Debugf("AssignAlias operator!")
 
 	aliasName := ""
 	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
-		if rhs.MatchingNodes.Front() != nil {
-			aliasName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+		if rhs.Front() != nil {
+			aliasName = rhs.Front().Value.(*CandidateNode).Node.Value
 		}
 	}
 
-	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
 
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
-	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := lhs.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(context.SingleChildContext(candidate), expressionNode.Rhs)
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
-			if rhs.MatchingNodes.Front() != nil {
-				aliasName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+			if rhs.Front() != nil {
+				aliasName = rhs.Front().Value.(*CandidateNode).Node.Value
 			}
 		}
 
 		candidate.Node.Kind = yaml.AliasNode
 		candidate.Node.Value = aliasName
 	}
-	return context, nil
+	return matchingNodes, nil
 }
 
-func getAliasOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func getAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("GetAlias operator!")
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := 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 context.ChildContext(results), nil
+	return results, nil
 }
 
-func assignAnchorOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func assignAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 
 	log.Debugf("AssignAnchor operator!")
 
 	anchorName := ""
 	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 
-		if rhs.MatchingNodes.Front() != nil {
-			anchorName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+		if rhs.Front() != nil {
+			anchorName = rhs.Front().Value.(*CandidateNode).Node.Value
 		}
 	}
 
-	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
 
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
-	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := lhs.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(context.SingleChildContext(candidate), expressionNode.Rhs)
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 
-			if rhs.MatchingNodes.Front() != nil {
-				anchorName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+			if rhs.Front() != nil {
+				anchorName = rhs.Front().Value.(*CandidateNode).Node.Value
 			}
 		}
 
 		candidate.Node.Anchor = anchorName
 	}
-	return context, nil
+	return matchingNodes, nil
 }
 
-func getAnchorOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func getAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("GetAnchor operator!")
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := 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 context.ChildContext(results), nil
+	return results, nil
 }
 
-func explodeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func explodeOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- ExplodeOperation")
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
-		rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
-		for childEl := rhs.MatchingNodes.Front(); childEl != nil; childEl = childEl.Next() {
-			err = explodeNode(childEl.Value.(*CandidateNode).Node, context)
+		for childEl := rhs.Front(); childEl != nil; childEl = childEl.Next() {
+			err = explodeNode(childEl.Value.(*CandidateNode).Node)
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 		}
 
 	}
 
-	return context, nil
+	return matchMap, nil
 }
 
-func explodeNode(node *yaml.Node, context Context) error {
+func explodeNode(node *yaml.Node) 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, context)
+			errorInContent := explodeNode(contentNode)
 			if errorInContent != nil {
 				return errorInContent
 			}
@@ -169,7 +169,7 @@ func explodeNode(node *yaml.Node, context Context) error {
 			valueNode := node.Content[index+1]
 			log.Debugf("traversing %v", keyNode.Value)
 			if keyNode.Value != "<<" {
-				err := overrideEntry(node, keyNode, valueNode, index, context.ChildContext(newContent))
+				err := overrideEntry(node, keyNode, valueNode, index, newContent)
 				if err != nil {
 					return err
 				}
@@ -178,14 +178,14 @@ func explodeNode(node *yaml.Node, context Context) 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, context.ChildContext(newContent))
+						err := applyAlias(node, aliasNode.Alias, index, newContent)
 						if err != nil {
 							return err
 						}
 					}
 				} else {
 					log.Debugf("an alias merge!")
-					err := applyAlias(node, valueNode.Alias, index, context.ChildContext(newContent))
+					err := applyAlias(node, valueNode.Alias, index, newContent)
 					if err != nil {
 						return err
 					}
@@ -205,7 +205,7 @@ func explodeNode(node *yaml.Node, context Context) error {
 	}
 }
 
-func applyAlias(node *yaml.Node, alias *yaml.Node, aliasIndex int, newContent Context) error {
+func applyAlias(node *yaml.Node, alias *yaml.Node, aliasIndex int, newContent *list.List) error {
 	if alias == nil {
 		return nil
 	}
@@ -221,15 +221,15 @@ func applyAlias(node *yaml.Node, alias *yaml.Node, aliasIndex int, newContent Co
 	return nil
 }
 
-func overrideEntry(node *yaml.Node, key *yaml.Node, value *yaml.Node, startIndex int, newContent Context) error {
+func overrideEntry(node *yaml.Node, key *yaml.Node, value *yaml.Node, startIndex int, newContent *list.List) error {
 
-	err := explodeNode(value, newContent)
+	err := explodeNode(value)
 
 	if err != nil {
 		return err
 	}
 
-	for newEl := newContent.MatchingNodes.Front(); newEl != nil; newEl = newEl.Next() {
+	for newEl := newContent.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, newContent)
+	err = explodeNode(key)
 	if err != nil {
 		return err
 	}
 	log.Debugf("adding %v:%v", key.Value, value.Value)
-	newContent.MatchingNodes.PushBack(key)
-	newContent.MatchingNodes.PushBack(value)
+	newContent.PushBack(key)
+	newContent.PushBack(value)
 	return nil
 }

pkg/yqlib/operator_assign.go

@@ -1,28 +1,30 @@
 package yqlib
 
-func assignUpdateOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+import "container/list"
+
+func assignUpdateOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
-	var rhs Context
+	var rhs *list.List
 	if !expressionNode.Operation.UpdateAssign {
-		rhs, err = d.GetMatchingNodes(context, expressionNode.Rhs)
+		rhs, err = d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 	}
 
-	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
 		if expressionNode.Operation.UpdateAssign {
-			rhs, err = d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs)
+			rhs, err = d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 		}
 
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 
 		// grab the first value
-		first := rhs.MatchingNodes.Front()
+		first := rhs.Front()
 
 		if first != nil {
 			rhsCandidate := first.Value.(*CandidateNode)
@@ -31,31 +33,30 @@ func assignUpdateOperator(d *dataTreeNavigator, context Context, expressionNode
 		}
 	}
 
-	return context, nil
+	return matchingNodes, nil
 }
 
 // does not update content or values
-func assignAttributesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	log.Debug("getting lhs matching nodes for update")
-	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+func assignAttributesOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
-	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
-		rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 
 		// grab the first value
-		first := rhs.MatchingNodes.Front()
+		first := rhs.Front()
 
 		if first != nil {
 			candidate.UpdateAttributesFrom(first.Value.(*CandidateNode))
 		}
 	}
-	return context, nil
+	return matchingNodes, nil
 }

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, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	return func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func performBoolOp(op boolOp) 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)
 
@@ -44,35 +44,35 @@ func performBoolOp(op boolOp) func(d *dataTreeNavigator, context Context, lhs *C
 	}
 }
 
-func orOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func orOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- orOp")
-	return crossFunction(d, context, expressionNode, performBoolOp(
+	return crossFunction(d, matchingNodes, expressionNode, performBoolOp(
 		func(b1 bool, b2 bool) bool {
 			return b1 || b2
 		}))
 }
 
-func andOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func andOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- AndOp")
-	return crossFunction(d, context, expressionNode, performBoolOp(
+	return crossFunction(d, matchingNodes, expressionNode, performBoolOp(
 		func(b1 bool, b2 bool) bool {
 			return b1 && b2
 		}))
 }
 
-func notOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func notOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- notOperation")
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debug("notOperation checking %v", candidate)
 		truthy, errDecoding := isTruthy(candidate)
 		if errDecoding != nil {
-			return Context{}, errDecoding
+			return nil, errDecoding
 		}
 		result := createBooleanCandidate(candidate, !truthy)
 		results.PushBack(result)
 	}
-	return context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_collect.go

@@ -6,21 +6,21 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func collectOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func collectOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- collectOperation")
 
-	if context.MatchingNodes.Len() == 0 {
+	if matchMap.Len() == 0 {
 		node := &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq", Value: "[]"}
 		candidate := &CandidateNode{Node: node}
-		return context.SingleChildContext(candidate), nil
+		return nodeToMap(candidate), nil
 	}
 
 	var results = list.New()
 
 	node := &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq"}
 	var collectC *CandidateNode
-	if context.MatchingNodes.Front() != nil {
-		collectC = context.MatchingNodes.Front().Value.(*CandidateNode).CreateChild(nil, node)
+	if matchMap.Front() != nil {
+		collectC = matchMap.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, context Context, expressionNode *Expr
 		collectC = &CandidateNode{Node: node}
 	}
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchMap.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, context Context, expressionNode *Expr
 
 	results.PushBack(collectC)
 
-	return context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_collect_object.go

@@ -17,22 +17,22 @@ import (
 ...
 */
 
-func collectObjectOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func collectObjectOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- collectObjectOperation")
 
-	if context.MatchingNodes.Len() == 0 {
+	if matchMap.Len() == 0 {
 		node := &yaml.Node{Kind: yaml.MappingNode, Tag: "!!map", Value: "{}"}
 		candidate := &CandidateNode{Node: node}
-		return context.SingleChildContext(candidate), nil
+		return nodeToMap(candidate), nil
 	}
-	first := context.MatchingNodes.Front().Value.(*CandidateNode)
+	first := matchMap.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 := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchMap.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, context Context, expressionNode
 
 	newObject := list.New()
 	for i := 0; i < len(first.Node.Content); i++ {
-		additions, err := collect(d, context.ChildContext(list.New()), rotated[i])
+		additions, err := collect(d, list.New(), rotated[i])
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
-		newObject.PushBackList(additions.MatchingNodes)
+		newObject.PushBackList(additions)
 	}
 
-	return context.ChildContext(newObject), nil
+	return newObject, nil
 
 }
 
-func collect(d *dataTreeNavigator, context Context, remainingMatches *list.List) (Context, error) {
+func collect(d *dataTreeNavigator, aggregate *list.List, remainingMatches *list.List) (*list.List, error) {
 	if remainingMatches.Len() == 0 {
-		return context, nil
+		return aggregate, nil
 	}
 
 	candidate := remainingMatches.Remove(remainingMatches.Front()).(*CandidateNode)
 
-	splatted, err := splat(d, context.SingleChildContext(candidate),
+	splatted, err := splat(d, nodeToMap(candidate),
 		traversePreferences{DontFollowAlias: true, IncludeMapKeys: false})
 
-	for splatEl := splatted.MatchingNodes.Front(); splatEl != nil; splatEl = splatEl.Next() {
+	for splatEl := splatted.Front(); splatEl != nil; splatEl = splatEl.Next() {
 		splatEl.Value.(*CandidateNode).Path = nil
 	}
 
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
-	if context.MatchingNodes.Len() == 0 {
+	if aggregate.Len() == 0 {
 		return collect(d, splatted, remainingMatches)
 	}
 
 	newAgg := list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := aggregate.Front(); el != nil; el = el.Next() {
 		aggCandidate := el.Value.(*CandidateNode)
-		for splatEl := splatted.MatchingNodes.Front(); splatEl != nil; splatEl = splatEl.Next() {
+		for splatEl := splatted.Front(); splatEl != nil; splatEl = splatEl.Next() {
 			splatCandidate := splatEl.Value.(*CandidateNode)
 			newCandidate, err := aggCandidate.Copy()
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 
 			newCandidate.Path = nil
 
-			newCandidate, err = multiply(multiplyPreferences{AppendArrays: false})(d, context, newCandidate, splatCandidate)
+			newCandidate, err = multiply(multiplyPreferences{AppendArrays: false})(d, newCandidate, splatCandidate)
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 			newAgg.PushBack(newCandidate)
 		}
 	}
-	return collect(d, context.ChildContext(newAgg), remainingMatches)
+	return collect(d, newAgg, remainingMatches)
 
 }

pkg/yqlib/operator_comments.go

@@ -13,41 +13,41 @@ type commentOpPreferences struct {
 	FootComment bool
 }
 
-func assignCommentsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func assignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 
 	log.Debugf("AssignComments operator!")
 
-	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
 
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
 	preferences := expressionNode.Operation.Preferences.(commentOpPreferences)
 
 	comment := ""
 	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 
-		if rhs.MatchingNodes.Front() != nil {
-			comment = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+		if rhs.Front() != nil {
+			comment = rhs.Front().Value.(*CandidateNode).Node.Value
 		}
 	}
 
-	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
 		if expressionNode.Operation.UpdateAssign {
-			rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs)
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 
-			if rhs.MatchingNodes.Front() != nil {
-				comment = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+			if rhs.Front() != nil {
+				comment = rhs.Front().Value.(*CandidateNode).Node.Value
 			}
 		}
 
@@ -63,15 +63,15 @@ func assignCommentsOperator(d *dataTreeNavigator, context Context, expressionNod
 		}
 
 	}
-	return context, nil
+	return matchingNodes, nil
 }
 
-func getCommentsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func getCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	preferences := expressionNode.Operation.Preferences.(commentOpPreferences)
 	log.Debugf("GetComments operator!")
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		comment := ""
 		if preferences.LineComment {
@@ -87,5 +87,5 @@ func getCommentsOperator(d *dataTreeNavigator, context Context, expressionNode *
 		result := candidate.CreateChild(nil, node)
 		results.PushBack(result)
 	}
-	return context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_create_map.go

@@ -6,7 +6,7 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-func createMapOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func createMapOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- createMapOperation")
 
 	//each matchingNodes entry should turn into a sequence of keys to create.
@@ -18,29 +18,29 @@ func createMapOperator(d *dataTreeNavigator, context Context, expressionNode *Ex
 
 	sequences := list.New()
 
-	if context.MatchingNodes.Len() > 0 {
+	if matchingNodes.Len() > 0 {
 
-		for matchingNodeEl := context.MatchingNodes.Front(); matchingNodeEl != nil; matchingNodeEl = matchingNodeEl.Next() {
+		for matchingNodeEl := matchingNodes.Front(); matchingNodeEl != nil; matchingNodeEl = matchingNodeEl.Next() {
 			matchingNode := matchingNodeEl.Value.(*CandidateNode)
-			sequenceNode, err := sequenceFor(d, context, matchingNode, expressionNode)
+			sequenceNode, err := sequenceFor(d, matchingNode, expressionNode)
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 			sequences.PushBack(sequenceNode)
 		}
 	} else {
-		sequenceNode, err := sequenceFor(d, context, nil, expressionNode)
+		sequenceNode, err := sequenceFor(d, nil, expressionNode)
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 		sequences.PushBack(sequenceNode)
 	}
 
-	return context.SingleChildContext(&CandidateNode{Node: listToNodeSeq(sequences), Document: document, Path: path}), nil
+	return nodeToMap(&CandidateNode{Node: listToNodeSeq(sequences), Document: document, Path: path}), nil
 
 }
 
-func sequenceFor(d *dataTreeNavigator, context Context, matchingNode *CandidateNode, expressionNode *ExpressionNode) (*CandidateNode, error) {
+func sequenceFor(d *dataTreeNavigator, 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, context Context, matchingNode *CandidateN
 	if matchingNode != nil {
 		path = matchingNode.Path
 		document = matchingNode.Document
-		matches.PushBack(matchingNode)
+		matches = nodeToMap(matchingNode)
 	}
 
-	mapPairs, err := crossFunction(d, context.ChildContext(matches), expressionNode,
-		func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	mapPairs, err := crossFunction(d, matches, expressionNode,
+		func(d *dataTreeNavigator, 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, context Context, matchingNode *CandidateN
 	if err != nil {
 		return nil, err
 	}
-	innerList := listToNodeSeq(mapPairs.MatchingNodes)
+	innerList := listToNodeSeq(mapPairs)
 	innerList.Style = yaml.FlowStyle
 	return &CandidateNode{Node: innerList, Document: document, Path: path}, nil
 }

pkg/yqlib/operator_delete.go

@@ -1,24 +1,23 @@
 package yqlib
 
 import (
+	"container/list"
 	"fmt"
 
 	yaml "gopkg.in/yaml.v3"
 )
 
-func deleteChildOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	contextToUse := context.Clone()
-	contextToUse.DontAutoCreate = true
-	nodesToDelete, err := d.GetMatchingNodes(contextToUse, expressionNode.Rhs)
+func deleteChildOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+
+	nodesToDelete, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
-	//need to iterate backwards to ensure correct indices when deleting multiple
-	for el := nodesToDelete.MatchingNodes.Back(); el != nil; el = el.Prev() {
+
+	for el := nodesToDelete.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
-		if len(candidate.Path) > 0 {
 		deleteImmediateChildOp := &Operation{
 			OperationType: deleteImmediateChildOpType,
 			Value:         candidate.Path[len(candidate.Path)-1],
@@ -26,30 +25,29 @@ func deleteChildOperator(d *dataTreeNavigator, context Context, expressionNode *
 
 		deleteImmediateChildOpNode := &ExpressionNode{
 			Operation: deleteImmediateChildOp,
-				Rhs:       createTraversalTree(candidate.Path[0:len(candidate.Path)-1], traversePreferences{}, false),
+			Rhs:       createTraversalTree(candidate.Path[0:len(candidate.Path)-1], traversePreferences{}),
 		}
 
-			_, err := d.GetMatchingNodes(contextToUse, deleteImmediateChildOpNode)
+		_, err := d.GetMatchingNodes(matchingNodes, deleteImmediateChildOpNode)
 		if err != nil {
-				return Context{}, err
+			return nil, err
 		}
 	}
-	}
-	return context, nil
+	return matchingNodes, nil
 }
 
-func deleteImmediateChildOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	parents, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+func deleteImmediateChildOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+	parents, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
 	childPath := expressionNode.Operation.Value
 
 	log.Debug("childPath to remove %v", childPath)
 
-	for el := parents.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := parents.Front(); el != nil; el = el.Next() {
 		parent := el.Value.(*CandidateNode)
 		parentNode := unwrapDoc(parent.Node)
 		if parentNode.Kind == yaml.MappingNode {
@@ -57,11 +55,11 @@ func deleteImmediateChildOperator(d *dataTreeNavigator, context Context, express
 		} else if parentNode.Kind == yaml.SequenceNode {
 			deleteFromArray(parent, childPath)
 		} else {
-			return Context{}, fmt.Errorf("Cannot delete nodes from parent of tag %v", parentNode.Tag)
+			return nil, fmt.Errorf("Cannot delete nodes from parent of tag %v", parentNode.Tag)
 		}
 
 	}
-	return context, nil
+	return matchingNodes, nil
 }
 
 func deleteFromMap(candidate *CandidateNode, childPath interface{}) {

pkg/yqlib/operator_delete_test.go

@@ -37,38 +37,6 @@ var deleteOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::[1, 3]\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `a: [1,2,3]`,
-		expression: `del(.a[])`,
-		expected: []string{
-			"D0, P[], (doc)::a: []\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `a: [10,x,10, 10, x, 10]`,
-		expression: `del(.a[] | select(. == 10))`,
-		expected: []string{
-			"D0, P[], (doc)::a: [x, x]\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `a: {thing1: yep, thing2: cool, thing3: hi, b: {thing1: cool, great: huh}}`,
-		expression: `del(..)`,
-		expected: []string{
-			"D0, P[], (!!map)::{}\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `a: {thing1: yep, thing2: cool, thing3: hi, b: {thing1: cool, great: huh}}`,
-		expression: `del(.. | select(tag == "!!map") | (.b.thing1,.thing2))`,
-		expected: []string{
-			"D0, P[], (!!map)::a: {thing1: yep, thing3: hi, b: {great: huh}}\n",
-		},
-	},
 	{
 		description: "Delete nested entry in array",
 		document:    `[{a: cat, b: dog}]`,

pkg/yqlib/operator_document_index.go

@@ -7,14 +7,14 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-func getDocumentIndexOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func getDocumentIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := 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 context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_env.go

@@ -1,6 +1,7 @@
 package yqlib
 
 import (
+	"container/list"
 	"fmt"
 	"os"
 	"strings"
@@ -12,7 +13,7 @@ type envOpPreferences struct {
 	StringValue bool
 }
 
-func envOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func envOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	envName := expressionNode.Operation.CandidateNode.Node.Value
 	log.Debug("EnvOperator, env name:", envName)
 
@@ -28,13 +29,13 @@ func envOperator(d *dataTreeNavigator, context Context, expressionNode *Expressi
 			Value: rawValue,
 		}
 	} else if rawValue == "" {
-		return Context{}, fmt.Errorf("Value for env variable '%v' not provided in env()", envName)
+		return nil, 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 Context{}, errorReading
+			return nil, errorReading
 		}
 		//first node is a doc
 		node = unwrapDoc(&dataBucket)
@@ -45,5 +46,5 @@ func envOperator(d *dataTreeNavigator, context Context, expressionNode *Expressi
 
 	target := &CandidateNode{Node: node}
 
-	return context.SingleChildContext(target), nil
+	return nodeToMap(target), nil
 }

pkg/yqlib/operator_equals.go

@@ -1,14 +1,15 @@
 package yqlib
 
-import "gopkg.in/yaml.v3"
+import (
+	"container/list"
+)
 
-func equalsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func equalsOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- equalsOperation")
-	return crossFunction(d, context, expressionNode, isEquals(false))
+	return crossFunction(d, matchingNodes, expressionNode, isEquals)
 }
 
-func isEquals(flip bool) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	return func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func isEquals(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
 	value := false
 
 	lhsNode := unwrapDoc(lhs.Node)
@@ -16,18 +17,9 @@ func isEquals(flip bool) func(d *dataTreeNavigator, context Context, lhs *Candid
 
 	if lhsNode.Tag == "!!null" {
 		value = (rhsNode.Tag == "!!null")
-		} else if lhsNode.Kind == yaml.ScalarNode && rhsNode.Kind == yaml.ScalarNode {
+	} else {
 		value = matchKey(lhsNode.Value, rhsNode.Value)
 	}
 	log.Debugf("%v == %v ? %v", NodeToString(lhs), NodeToString(rhs), value)
-		if flip {
-			value = !value
-		}
 	return createBooleanCandidate(lhs, value), nil
 }
-}
-
-func notEqualsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	log.Debugf("-- equalsOperation")
-	return crossFunction(d, context, expressionNode, isEquals(true))
-}

pkg/yqlib/operator_equals_test.go

@@ -14,14 +14,6 @@ var equalsOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!bool)::false\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   "{a: { b: {things: \"\"}, f: [1], g: [] }}",
-		expression: ".. | select(. == \"\")",
-		expected: []string{
-			"D0, P[a b things], (!!str)::\"\"\n",
-		},
-	},
 	{
 		description: "Match string",
 		document:    `[cat,goat,dog]`,
@@ -31,18 +23,7 @@ var equalsOperatorScenarios = []expressionScenario{
 			"D0, P[1], (!!bool)::true\n",
 			"D0, P[2], (!!bool)::false\n",
 		},
-	},
-	{
-		description: "Don't match string",
-		document:    `[cat,goat,dog]`,
-		expression:  `.[] | (. != "*at")`,
-		expected: []string{
-			"D0, P[0], (!!bool)::false\n",
-			"D0, P[1], (!!bool)::false\n",
-			"D0, P[2], (!!bool)::true\n",
-		},
-	},
-	{
+	}, {
 		description: "Match number",
 		document:    `[3, 4, 5]`,
 		expression:  `.[] | (. == 4)`,
@@ -51,18 +32,7 @@ var equalsOperatorScenarios = []expressionScenario{
 			"D0, P[1], (!!bool)::true\n",
 			"D0, P[2], (!!bool)::false\n",
 		},
-	},
-	{
-		description: "Dont match number",
-		document:    `[3, 4, 5]`,
-		expression:  `.[] | (. != 4)`,
-		expected: []string{
-			"D0, P[0], (!!bool)::true\n",
-			"D0, P[1], (!!bool)::false\n",
-			"D0, P[2], (!!bool)::true\n",
-		},
-	},
-	{
+	}, {
 		skipDoc:    true,
 		document:   `a: { cat: {b: apple, c: whatever}, pat: {b: banana} }`,
 		expression: `.a | (.[].b == "apple")`,

pkg/yqlib/operator_file.go

@@ -7,32 +7,32 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func getFilenameOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func getFilenameOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("GetFilename")
 
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := 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 context.ChildContext(results), nil
+	return results, nil
 }
 
-func getFileIndexOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func getFileIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("GetFileIndex")
 
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := 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 context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_has.go

@@ -7,20 +7,20 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func hasOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func hasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 
 	log.Debugf("-- hasOperation")
 	var results = list.New()
 
-	rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
-	wanted := rhs.MatchingNodes.Front().Value.(*CandidateNode).Node
+	rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
+	wanted := rhs.Front().Value.(*CandidateNode).Node
 	wantedKey := wanted.Value
 
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
 		// grab the first value
@@ -41,7 +41,7 @@ func hasOperator(d *dataTreeNavigator, context Context, expressionNode *Expressi
 			if wanted.Tag == "!!int" {
 				var number, errParsingInt = strconv.ParseInt(wantedKey, 10, 64) // nolint
 				if errParsingInt != nil {
-					return Context{}, errParsingInt
+					return nil, errParsingInt
 				}
 				candidateHasKey = int64(len(contents)) > number
 			}
@@ -50,5 +50,5 @@ func hasOperator(d *dataTreeNavigator, context Context, expressionNode *Expressi
 			results.PushBack(createBooleanCandidate(candidate, false))
 		}
 	}
-	return context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_keys.go

@@ -7,12 +7,12 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-func keysOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func keysOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- keysOperator")
 
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchMap.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, context Context, expressionNode *Express
 		} else if node.Kind == yaml.SequenceNode {
 			targetNode = getIndicies(node)
 		} else {
-			return Context{}, fmt.Errorf("Cannot get keys of %v, keys only works for maps and arrays", node.Tag)
+			return nil, 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 context.ChildContext(results), nil
+	return results, nil
 }
 
 func getMapKeys(node *yaml.Node) *yaml.Node {

pkg/yqlib/operator_length.go

@@ -7,21 +7,17 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func lengthOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func lengthOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- lengthOperation")
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		targetNode := unwrapDoc(candidate.Node)
 		var length int
 		switch targetNode.Kind {
 		case yaml.ScalarNode:
-			if targetNode.Tag == "!!null" {
-				length = 0
-			} else {
 			length = len(targetNode.Value)
-			}
 		case yaml.MappingNode:
 			length = len(targetNode.Content) / 2
 		case yaml.SequenceNode:
@@ -35,5 +31,5 @@ func lengthOperator(d *dataTreeNavigator, context Context, expressionNode *Expre
 		results.PushBack(result)
 	}
 
-	return context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_length_test.go

@@ -14,30 +14,6 @@ var lengthOperatorScenarios = []expressionScenario{
 			"D0, P[a], (!!int)::3\n",
 		},
 	},
-	{
-		description: "null length",
-		document:    `{a: null}`,
-		expression:  `.a | length`,
-		expected: []string{
-			"D0, P[a], (!!int)::0\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `{a: ~}`,
-		expression: `.a | length`,
-		expected: []string{
-			"D0, P[a], (!!int)::0\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `{a: key no exist}`,
-		expression: `.b | length`,
-		expected: []string{
-			"D0, P[b], (!!int)::0\n",
-		},
-	},
 	{
 		description:    "Map length",
 		subdescription: "returns number of entries",

pkg/yqlib/operator_multiply.go

@@ -9,18 +9,77 @@ 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, context Context, expressionNode *ExpressionNode) (Context, error) {
+func multiplyOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- MultiplyOperator")
-	return crossFunction(d, context, expressionNode, multiply(expressionNode.Operation.Preferences.(multiplyPreferences)))
+	return crossFunction(d, matchingNodes, expressionNode, multiply(expressionNode.Operation.Preferences.(multiplyPreferences)))
 }
 
-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) {
+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)
@@ -30,11 +89,11 @@ func multiply(preferences multiplyPreferences) func(d *dataTreeNavigator, contex
 			(lhs.Node.Kind == yaml.SequenceNode && rhs.Node.Kind == yaml.SequenceNode) {
 
 			var newBlank = lhs.CreateChild(nil, &yaml.Node{})
-			var newThing, err = mergeObjects(d, context, newBlank, lhs, multiplyPreferences{})
+			var newThing, err = mergeObjects(d, newBlank, lhs, multiplyPreferences{})
 			if err != nil {
 				return nil, err
 			}
-			return mergeObjects(d, context, newThing, rhs, preferences)
+			return mergeObjects(d, newThing, rhs, preferences)
 		} else if lhs.Node.Tag == "!!int" && rhs.Node.Tag == "!!int" {
 			return multiplyIntegers(lhs, rhs)
 		}
@@ -60,14 +119,14 @@ func multiplyIntegers(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, e
 	return target, nil
 }
 
-func mergeObjects(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) (*CandidateNode, error) {
+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, IncludeMapKeys: true}}
-	err := recursiveDecent(d, results, context.SingleChildContext(rhs), prefs)
+		TraversePreferences: traversePreferences{DontFollowAlias: true}}
+	err := recursiveDecent(d, results, nodeToMap(rhs), prefs)
 	if err != nil {
 		return nil, err
 	}
@@ -78,12 +137,7 @@ func mergeObjects(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs
 	}
 
 	for el := results.Front(); el != nil; el = el.Next() {
-		candidate := el.Value.(*CandidateNode)
-		if candidate.Node.Tag == "!!merge" {
-			continue
-		}
-
-		err := applyAssignment(d, context, pathIndexToStartFrom, lhs, candidate, preferences)
+		err := applyAssignment(d, pathIndexToStartFrom, lhs, el.Value.(*CandidateNode), preferences)
 		if err != nil {
 			return nil, err
 		}
@@ -91,9 +145,9 @@ func mergeObjects(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs
 	return lhs, nil
 }
 
-func applyAssignment(d *dataTreeNavigator, context Context, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) error {
+func applyAssignment(d *dataTreeNavigator, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) error {
 	shouldAppendArrays := preferences.AppendArrays
-	log.Debugf("merge - applyAssignment lhs %v, rhs: %v", lhs.GetKey(), rhs.GetKey())
+	log.Debugf("merge - applyAssignment lhs %v, rhs: %v", NodeToString(lhs), NodeToString(rhs))
 
 	lhsPath := rhs.Path[pathIndexToStartFrom:]
 
@@ -106,9 +160,9 @@ func applyAssignment(d *dataTreeNavigator, context Context, pathIndexToStartFrom
 	}
 	rhsOp := &Operation{OperationType: valueOpType, CandidateNode: rhs}
 
-	assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath, preferences.TraversePrefs, rhs.IsMapKey), Rhs: &ExpressionNode{Operation: rhsOp}}
+	assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath, preferences.TraversePrefs), Rhs: &ExpressionNode{Operation: rhsOp}}
 
-	_, err := d.GetMatchingNodes(context.SingleChildContext(lhs), assignmentOpNode)
+	_, err := d.GetMatchingNodes(nodeToMap(lhs), assignmentOpNode)
 
 	return err
 }

pkg/yqlib/operator_multiply_test.go

@@ -13,30 +13,6 @@ var multiplyOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!map)::{a: {also: me}, b: {also: me}}\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   "# b\nb:\n  # a\n  a: cat",
-		expression: "{} * .",
-		expected: []string{
-			"D0, P[], (!!map)::# b\nb:\n    # a\n    a: cat\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   "# b\nb:\n  # a\n  a: cat",
-		expression: ". * {}",
-		expected: []string{
-			"D0, P[], (!!map)::# b\nb:\n    # a\n    a: cat\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `{a: &a { b: &b { c: &c cat } } }`,
-		expression: `{} * .`,
-		expected: []string{
-			"D0, P[], (!!map)::{a: &a {b: &b {c: &c cat}}}\n",
-		},
-	},
 	{
 		skipDoc:    true,
 		document:   `{a: 2, b: 5}`,
@@ -124,10 +100,16 @@ var multiplyOperatorScenarios = []expressionScenario{
 	{
 		description:           "Merge keeps style of LHS",
 		dontFormatInputForDoc: true,
-		document:              "a: {things: great}\nb:\n  also: \"me\"",
+		document: `a: {things: great}
+b:
+  also: "me"
+`,
 		expression: `. * {"a":.b}`,
 		expected: []string{
-			"D0, P[], (!!map)::a: {things: great, also: \"me\"}\nb:\n    also: \"me\"\n",
+			`D0, P[], (!!map)::a: {things: great, also: "me"}
+b:
+    also: "me"
+`,
 		},
 	},
 	{
@@ -162,14 +144,6 @@ var multiplyOperatorScenarios = []expressionScenario{
 			"D0, P[a], (!!seq)::[{thing: two}]\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `{a: {array: [1]}, b: {}}`,
-		expression: `.b *+ .a`,
-		expected: []string{
-			"D0, P[b], (!!map)::{array: [1]}\n",
-		},
-	},
 	{
 		description: "Merge, appending arrays",
 		document:    `{a: {array: [1, 2, animal: dog], value: coconut}, b: {array: [3, 4, animal: cat], value: banana}}`,

pkg/yqlib/operator_path.go

@@ -16,12 +16,12 @@ func createPathNodeFor(pathElement interface{}) *yaml.Node {
 	}
 }
 
-func getPathOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func getPathOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("GetPath")
 
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := 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, context Context, expressionNode *Expr
 		results.PushBack(result)
 	}
 
-	return context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_pipe.go

@@ -1,18 +1,11 @@
 package yqlib
 
-func pipeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+import "container/list"
 
-	//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)
+func pipeOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
-	rhs, err := d.GetMatchingNodes(lhs, expressionNode.Rhs)
-	if err != nil {
-		return Context{}, err
-	}
-	return context.ChildContext(rhs.MatchingNodes), nil
+	return d.GetMatchingNodes(lhs, expressionNode.Rhs)
 }

pkg/yqlib/operator_recursive_descent.go

@@ -11,20 +11,20 @@ type recursiveDescentPreferences struct {
 	RecurseArray        bool
 }
 
-func recursiveDescentOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func recursiveDescentOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	var results = list.New()
 
 	preferences := expressionNode.Operation.Preferences.(recursiveDescentPreferences)
-	err := recursiveDecent(d, results, context, preferences)
+	err := recursiveDecent(d, results, matchMap, preferences)
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
-	return context.ChildContext(results), nil
+	return results, nil
 }
 
-func recursiveDecent(d *dataTreeNavigator, results *list.List, context Context, preferences recursiveDescentPreferences) error {
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.List, preferences recursiveDescentPreferences) error {
+	for el := matchMap.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, context Context,
 		if candidate.Node.Kind != yaml.AliasNode && len(candidate.Node.Content) > 0 &&
 			(preferences.RecurseArray || candidate.Node.Kind != yaml.SequenceNode) {
 
-			children, err := splat(d, context.SingleChildContext(candidate), preferences.TraversePreferences)
+			children, err := splat(d, nodeToMap(candidate), preferences.TraversePreferences)
 
 			if err != nil {
 				return err

pkg/yqlib/operator_reduce.go

@@ -1,59 +0,0 @@
-package yqlib
-
-import (
-	"container/list"
-	"fmt"
-)
-
-func reduceOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	log.Debugf("-- reduceOp")
-	//.a as $var reduce (0; . + $var)
-	//lhs is the assignment operator
-	//rhs is the reduce block
-	// '.' refers to the current accumulator, initialised to 0
-	// $var references a single element from the .a
-
-	//ensure lhs is actually an assignment
-	//and rhs is a block (empty)
-	if expressionNode.Lhs.Operation.OperationType != assignVariableOpType {
-		return Context{}, fmt.Errorf("reduce must be given a variables assignment, got %v instead", expressionNode.Lhs.Operation.OperationType.Type)
-	} else if expressionNode.Rhs.Operation.OperationType != blockOpType {
-		return Context{}, fmt.Errorf("reduce must be given a block, got %v instead", expressionNode.Rhs.Operation.OperationType.Type)
-	}
-
-	arrayExpNode := expressionNode.Lhs.Lhs
-	array, err := d.GetMatchingNodes(context, arrayExpNode)
-
-	log.Debugf("array of %v things", array.MatchingNodes.Len())
-
-	if err != nil {
-		return Context{}, err
-	}
-
-	variableName := expressionNode.Lhs.Rhs.Operation.StringValue
-
-	initExp := expressionNode.Rhs.Lhs
-
-	accum, err := d.GetMatchingNodes(context, initExp)
-	if err != nil {
-		return Context{}, err
-	}
-
-	log.Debugf("with variable %v", variableName)
-
-	blockExp := expressionNode.Rhs.Rhs
-	for el := array.MatchingNodes.Front(); el != nil; el = el.Next() {
-		candidate := el.Value.(*CandidateNode)
-		log.Debugf("REDUCING WITH %v", NodeToString(candidate))
-		l := list.New()
-		l.PushBack(candidate)
-		accum.SetVariable(variableName, l)
-
-		accum, err = d.GetMatchingNodes(accum, blockExp)
-		if err != nil {
-			return Context{}, err
-		}
-	}
-
-	return accum, nil
-}

pkg/yqlib/operator_reduce_test.go

@@ -1,22 +0,0 @@
-package yqlib
-
-import (
-	"testing"
-)
-
-var reduceOperatorScenarios = []expressionScenario{
-	{
-		document:   `[10,2, 5, 3]`,
-		expression: `.[] as $item ireduce (0; . + $item)`,
-		expected: []string{
-			"D0, P[], (!!int)::20\n",
-		},
-	},
-}
-
-func TestReduceOperatorScenarios(t *testing.T) {
-	for _, tt := range reduceOperatorScenarios {
-		testScenario(t, &tt)
-	}
-	// documentScenarios(t, "Reduce", reduceOperatorScenarios)
-}

pkg/yqlib/operator_select.go

@@ -4,29 +4,28 @@ import (
 	"container/list"
 )
 
-func selectOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func selectOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 
 	log.Debugf("-- selectOperation")
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		childContext := context.SingleChildContext(candidate)
-		childContext.DontAutoCreate = true
-		rhs, err := d.GetMatchingNodes(childContext, expressionNode.Rhs)
+
+		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 
 		// grab the first value
-		first := rhs.MatchingNodes.Front()
+		first := rhs.Front()
 
 		if first != nil {
 			result := first.Value.(*CandidateNode)
 			includeResult, errDecoding := isTruthy(result)
 			if errDecoding != nil {
-				return Context{}, errDecoding
+				return nil, errDecoding
 			}
 
 			if includeResult {
@@ -34,5 +33,5 @@ func selectOperator(d *dataTreeNavigator, context Context, expressionNode *Expre
 			}
 		}
 	}
-	return context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_select_test.go

@@ -14,14 +14,6 @@ var selectOperatorScenarios = []expressionScenario{
 			"D0, P[1], (!!str)::goat\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `[{animal: cat, legs: {cool: true}}, {animal: fish}]`,
-		expression: `(.[] | select(.legs.cool == true).canWalk) = true | (.[] | .alive.things) = "yes"`,
-		expected: []string{
-			"D0, P[], (doc)::[{animal: cat, legs: {cool: true}, canWalk: true, alive: {things: yes}}, {animal: fish, alive: {things: yes}}]\n",
-		},
-	},
 	{
 		skipDoc:    true,
 		document:   `[hot, fot, dog]`,

pkg/yqlib/operator_self.go

@@ -1,5 +1,7 @@
 package yqlib
 
-func selfOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	return context, nil
+import "container/list"
+
+func selfOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+	return matchMap, nil
 }

pkg/yqlib/operator_sort_keys.go

@@ -1,32 +1,33 @@
 package yqlib
 
 import (
+	"container/list"
 	"sort"
 
 	yaml "gopkg.in/yaml.v3"
 )
 
-func sortKeysOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func sortKeysOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 
-		for childEl := rhs.MatchingNodes.Front(); childEl != nil; childEl = childEl.Next() {
+		for childEl := rhs.Front(); childEl != nil; childEl = childEl.Next() {
 			node := unwrapDoc(childEl.Value.(*CandidateNode).Node)
 			if node.Kind == yaml.MappingNode {
 				sortKeys(node)
 			}
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 		}
 
 	}
-	return context, nil
+	return matchingNodes, nil
 }
 
 func sortKeys(node *yaml.Node) {

pkg/yqlib/operator_split_document.go

@@ -1,14 +1,18 @@
 package yqlib
 
-func splitDocumentOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+import (
+	"container/list"
+)
+
+func splitDocumentOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- splitDocumentOperator")
 
 	var index uint = 0
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		candidate.Document = index
 		index = index + 1
 	}
 
-	return context, nil
+	return matchMap, nil
 }

pkg/yqlib/operator_strings.go

@@ -8,32 +8,32 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-func joinStringOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func joinStringOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- joinStringOperator")
 	joinStr := ""
 
-	rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+	rhs, err := d.GetMatchingNodes(matchMap, expressionNode.Rhs)
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
-	if rhs.MatchingNodes.Front() != nil {
-		joinStr = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+	if rhs.Front() != nil {
+		joinStr = rhs.Front().Value.(*CandidateNode).Node.Value
 	}
 
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		node := unwrapDoc(candidate.Node)
 		if node.Kind != yaml.SequenceNode {
-			return Context{}, fmt.Errorf("Cannot join with %v, can only join arrays of scalars", node.Tag)
+			return nil, 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 context.ChildContext(results), nil
+	return 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, context Context, expressionNode *ExpressionNode) (Context, error) {
+func splitStringOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("-- splitStringOperator")
 	splitStr := ""
 
-	rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+	rhs, err := d.GetMatchingNodes(matchMap, expressionNode.Rhs)
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
-	if rhs.MatchingNodes.Front() != nil {
-		splitStr = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+	if rhs.Front() != nil {
+		splitStr = rhs.Front().Value.(*CandidateNode).Node.Value
 	}
 
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		node := unwrapDoc(candidate.Node)
 		if node.Tag == "!!null" {
 			continue
 		}
 		if node.Tag != "!!str" {
-			return Context{}, fmt.Errorf("Cannot split %v, can only split strings", node.Tag)
+			return nil, 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 context.ChildContext(results), nil
+	return results, nil
 }
 
 func split(value string, spltStr string) *yaml.Node {

pkg/yqlib/operator_style.go

@@ -26,43 +26,43 @@ func parseStyle(customStyle string) (yaml.Style, error) {
 	return 0, nil
 }
 
-func assignStyleOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func assignStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 
 	log.Debugf("AssignStyleOperator: %v")
 	var style yaml.Style
 	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 
-		if rhs.MatchingNodes.Front() != nil {
-			style, err = parseStyle(rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value)
+		if rhs.Front() != nil {
+			style, err = parseStyle(rhs.Front().Value.(*CandidateNode).Node.Value)
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 		}
 	}
 
-	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
 
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
-	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := lhs.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(context.SingleChildContext(candidate), expressionNode.Rhs)
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 
-			if rhs.MatchingNodes.Front() != nil {
-				style, err = parseStyle(rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value)
+			if rhs.Front() != nil {
+				style, err = parseStyle(rhs.Front().Value.(*CandidateNode).Node.Value)
 				if err != nil {
-					return Context{}, err
+					return nil, err
 				}
 			}
 		}
@@ -70,15 +70,15 @@ func assignStyleOperator(d *dataTreeNavigator, context Context, expressionNode *
 		candidate.Node.Style = style
 	}
 
-	return context, nil
+	return matchingNodes, nil
 }
 
-func getStyleOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func getStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("GetStyleOperator")
 
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := 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, context Context, expressionNode *Exp
 		results.PushBack(result)
 	}
 
-	return context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_tag.go

@@ -6,58 +6,58 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func assignTagOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func assignTagOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 
 	log.Debugf("AssignTagOperator: %v")
 	tag := ""
 
 	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 
-		if rhs.MatchingNodes.Front() != nil {
-			tag = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+		if rhs.Front() != nil {
+			tag = rhs.Front().Value.(*CandidateNode).Node.Value
 		}
 	}
 
-	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
 
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
-	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := lhs.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(context.SingleChildContext(candidate), expressionNode.Rhs)
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
 			if err != nil {
-				return Context{}, err
+				return nil, err
 			}
 
-			if rhs.MatchingNodes.Front() != nil {
-				tag = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
+			if rhs.Front() != nil {
+				tag = rhs.Front().Value.(*CandidateNode).Node.Value
 			}
 		}
 		unwrapDoc(candidate.Node).Tag = tag
 	}
 
-	return context, nil
+	return matchingNodes, nil
 }
 
-func getTagOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+func getTagOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debugf("GetTagOperator")
 
 	var results = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := 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 context.ChildContext(results), nil
+	return results, nil
 }

pkg/yqlib/operator_traverse_path.go

@@ -13,29 +13,28 @@ type traversePreferences struct {
 	DontFollowAlias bool
 	IncludeMapKeys  bool
 	DontAutoCreate  bool // by default, we automatically create entries on the fly.
-	DontIncludeMapValues bool
 }
 
-func splat(d *dataTreeNavigator, context Context, prefs traversePreferences) (Context, error) {
-	return traverseNodesWithArrayIndices(context, make([]*yaml.Node, 0), prefs)
+func splat(d *dataTreeNavigator, matches *list.List, prefs traversePreferences) (*list.List, error) {
+	return traverseNodesWithArrayIndices(matches, make([]*yaml.Node, 0), prefs)
 }
 
-func traversePathOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	log.Debugf("-- traversePathOperator")
-	var matches = list.New()
+func traversePathOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+	log.Debugf("-- Traversing")
+	var matchingNodeMap = list.New()
 
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
-		newNodes, err := traverse(d, context, el.Value.(*CandidateNode), expressionNode.Operation)
+	for el := matchMap.Front(); el != nil; el = el.Next() {
+		newNodes, err := traverse(d, el.Value.(*CandidateNode), expressionNode.Operation)
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
-		matches.PushBackList(newNodes)
+		matchingNodeMap.PushBackList(newNodes)
 	}
 
-	return context.ChildContext(matches), nil
+	return matchingNodeMap, nil
 }
 
-func traverse(d *dataTreeNavigator, context Context, matchingNode *CandidateNode, operation *Operation) (*list.List, error) {
+func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Operation) (*list.List, error) {
 	log.Debug("Traversing %v", NodeToString(matchingNode))
 	value := matchingNode.Node
 
@@ -56,7 +55,7 @@ func traverse(d *dataTreeNavigator, context Context, matchingNode *CandidateNode
 	switch value.Kind {
 	case yaml.MappingNode:
 		log.Debug("its a map with %v entries", len(value.Content)/2)
-		return traverseMap(context, matchingNode, operation.StringValue, operation.Preferences.(traversePreferences), false)
+		return traverseMap(matchingNode, operation.StringValue, operation.Preferences.(traversePreferences), false)
 
 	case yaml.SequenceNode:
 		log.Debug("its a sequence of %v things!", len(value.Content))
@@ -65,59 +64,43 @@ func traverse(d *dataTreeNavigator, context Context, matchingNode *CandidateNode
 	case yaml.AliasNode:
 		log.Debug("its an alias!")
 		matchingNode.Node = matchingNode.Node.Alias
-		return traverse(d, context, matchingNode, operation)
+		return traverse(d, matchingNode, operation)
 	case yaml.DocumentNode:
 		log.Debug("digging into doc node")
 
-		return traverse(d, context, matchingNode.CreateChild(nil, matchingNode.Node.Content[0]), operation)
+		return traverse(d, matchingNode.CreateChild(nil, matchingNode.Node.Content[0]), operation)
 	default:
 		return list.New(), nil
 	}
 }
 
-func traverseArrayOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-
-	//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 Context{}, err
-	}
-
+func traverseArrayOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	// rhs is a collect expression that will yield indexes to retreive of the arrays
 
-	rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+	rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
 
-	var indicesToTraverse = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Content
-
-	//now we traverse the result of the lhs against the indices we found
-	result, err := traverseNodesWithArrayIndices(lhs, indicesToTraverse, traversePreferences{})
-	if err != nil {
-		return Context{}, err
-	}
-	return context.ChildContext(result.MatchingNodes), nil
+	var indicesToTraverse = rhs.Front().Value.(*CandidateNode).Node.Content
+	return traverseNodesWithArrayIndices(matchingNodes, indicesToTraverse, traversePreferences{})
 }
 
-func traverseNodesWithArrayIndices(context Context, indicesToTraverse []*yaml.Node, prefs traversePreferences) (Context, error) {
+func traverseNodesWithArrayIndices(matchingNodes *list.List, indicesToTraverse []*yaml.Node, prefs traversePreferences) (*list.List, error) {
 	var matchingNodeMap = list.New()
-	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		newNodes, err := traverseArrayIndices(context, candidate, indicesToTraverse, prefs)
+		newNodes, err := traverseArrayIndices(candidate, indicesToTraverse, prefs)
 		if err != nil {
-			return Context{}, err
+			return nil, err
 		}
 		matchingNodeMap.PushBackList(newNodes)
 	}
 
-	return context.ChildContext(matchingNodeMap), nil
+	return matchingNodeMap, nil
 }
 
-func traverseArrayIndices(context Context, matchingNode *CandidateNode, indicesToTraverse []*yaml.Node, prefs traversePreferences) (*list.List, error) { // call this if doc / alias like the other traverse
+func traverseArrayIndices(matchingNode *CandidateNode, indicesToTraverse []*yaml.Node, prefs traversePreferences) (*list.List, error) { // call this if doc / alias like the other traverse
 	node := matchingNode.Node
 	if node.Tag == "!!null" {
 		log.Debugf("OperatorArrayTraverse got a null - turning it into an empty array")
@@ -128,28 +111,28 @@ func traverseArrayIndices(context Context, matchingNode *CandidateNode, indicesT
 
 	if node.Kind == yaml.AliasNode {
 		matchingNode.Node = node.Alias
-		return traverseArrayIndices(context, matchingNode, indicesToTraverse, prefs)
+		return traverseArrayIndices(matchingNode, indicesToTraverse, prefs)
 	} else if node.Kind == yaml.SequenceNode {
 		return traverseArrayWithIndices(matchingNode, indicesToTraverse)
 	} else if node.Kind == yaml.MappingNode {
-		return traverseMapWithIndices(context, matchingNode, indicesToTraverse, prefs)
+		return traverseMapWithIndices(matchingNode, indicesToTraverse, prefs)
 	} else if node.Kind == yaml.DocumentNode {
-		return traverseArrayIndices(context, matchingNode.CreateChild(nil, matchingNode.Node.Content[0]), indicesToTraverse, prefs)
+		return traverseArrayIndices(matchingNode.CreateChild(nil, matchingNode.Node.Content[0]), indicesToTraverse, prefs)
 	}
 	log.Debugf("OperatorArrayTraverse skipping %v as its a %v", matchingNode, node.Tag)
 	return list.New(), nil
 }
 
-func traverseMapWithIndices(context Context, candidate *CandidateNode, indices []*yaml.Node, prefs traversePreferences) (*list.List, error) {
+func traverseMapWithIndices(candidate *CandidateNode, indices []*yaml.Node, prefs traversePreferences) (*list.List, error) {
 	if len(indices) == 0 {
-		return traverseMap(context, candidate, "", prefs, true)
+		return traverseMap(candidate, "", prefs, true)
 	}
 
 	var matchingNodeMap = list.New()
 
 	for _, indexNode := range indices {
 		log.Debug("traverseMapWithIndices: %v", indexNode.Value)
-		newNodes, err := traverseMap(context, candidate, indexNode.Value, prefs, false)
+		newNodes, err := traverseMap(candidate, indexNode.Value, prefs, false)
 		if err != nil {
 			return nil, err
 		}
@@ -204,7 +187,7 @@ func keyMatches(key *yaml.Node, wantedKey string) bool {
 	return matchKey(key.Value, wantedKey)
 }
 
-func traverseMap(context Context, matchingNode *CandidateNode, key string, prefs traversePreferences, splat bool) (*list.List, error) {
+func traverseMap(matchingNode *CandidateNode, key string, prefs traversePreferences, splat bool) (*list.List, error) {
 	var newMatches = orderedmap.NewOrderedMap()
 	err := doTraverseMap(newMatches, matchingNode, key, prefs, splat)
 
@@ -212,25 +195,14 @@ func traverseMap(context Context, matchingNode *CandidateNode, key string, prefs
 		return nil, err
 	}
 
-	if !prefs.DontAutoCreate && !context.DontAutoCreate && newMatches.Len() == 0 {
+	if !prefs.DontAutoCreate && newMatches.Len() == 0 {
 		//no matches, create one automagically
 		valueNode := &yaml.Node{Tag: "!!null", Kind: yaml.ScalarNode, Value: "null"}
-		keyNode := &yaml.Node{Kind: yaml.ScalarNode, Value: key}
 		node := matchingNode.Node
-		node.Content = append(node.Content, keyNode, valueNode)
-
-		if prefs.IncludeMapKeys {
-			log.Debug("including key")
-			candidateNode := matchingNode.CreateChild(key, keyNode)
-			candidateNode.IsMapKey = true
-			newMatches.Set(fmt.Sprintf("keyOf-%v", candidateNode.GetKey()), candidateNode)
-		}
-		if !prefs.DontIncludeMapValues {
-			log.Debug("including value")
+		node.Content = append(node.Content, &yaml.Node{Kind: yaml.ScalarNode, Value: key}, valueNode)
 		candidateNode := matchingNode.CreateChild(key, valueNode)
 		newMatches.Set(candidateNode.GetKey(), candidateNode)
 	}
-	}
 
 	results := list.New()
 	i := 0
@@ -265,18 +237,13 @@ func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode,
 		} else if splat || keyMatches(key, wantedKey) {
 			log.Debug("MATCHED")
 			if prefs.IncludeMapKeys {
-				log.Debug("including key")
 				candidateNode := candidate.CreateChild(key.Value, key)
-				candidateNode.IsMapKey = true
 				newMatches.Set(fmt.Sprintf("keyOf-%v", candidateNode.GetKey()), candidateNode)
 			}
-			if !prefs.DontIncludeMapValues {
-				log.Debug("including value")
 			candidateNode := candidate.CreateChild(key.Value, value)
 			newMatches.Set(candidateNode.GetKey(), candidateNode)
 		}
 	}
-	}
 
 	return nil
 }

pkg/yqlib/operator_traverse_path_test.go

@@ -47,30 +47,13 @@ var traversePathOperatorScenarios = []expressionScenario{
 	},
 	{
 		description:    "Special characters",
-		subdescription: "Use quotes with brackets around path elements with special characters",
+		subdescription: "Use quotes around path elements with special characters",
 		document:       `{"{}": frog}`,
-		expression:     `.["{}"]`,
+		expression:     `."{}"`,
 		expected: []string{
 			"D0, P[{}], (!!str)::frog\n",
 		},
 	},
-	{
-		description:    "Keys with spaces",
-		subdescription: "Use quotes with brackets around path elements with special characters",
-		document:       `{"red rabbit": frog}`,
-		expression:     `.["red rabbit"]`,
-		expected: []string{
-			"D0, P[red rabbit], (!!str)::frog\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `{"flying fox": frog}`,
-		expression: `.["flying fox"]`,
-		expected: []string{
-			"D0, P[flying fox], (!!str)::frog\n",
-		},
-	},
 	{
 		description:    "Dynamic keys",
 		subdescription: `Expressions within [] can be used to dynamically lookup / calculate keys`,
@@ -80,14 +63,6 @@ var traversePathOperatorScenarios = []expressionScenario{
 			"D0, P[apple], (!!str)::crispy yum\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `{b: apple, fruit: {apple: yum, banana: smooth}}`,
-		expression: `.fruit[.b]`,
-		expected: []string{
-			"D0, P[fruit apple], (!!str)::yum\n",
-		},
-	},
 	{
 		description:    "Children don't exist",
 		subdescription: "Nodes are added dynamically while traversing",
@@ -108,7 +83,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{}`,
-		expression: `.a[1]`,
+		expression: `.a.[1]`,
 		expected: []string{
 			"D0, P[a 1], (!!null)::null\n",
 		},
@@ -179,7 +154,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: &cat {c: frog}, b: *cat}`,
-		expression: `.b[]`,
+		expression: `.b.[]`,
 		expected: []string{
 			"D0, P[b c], (!!str)::frog\n",
 		},
@@ -261,7 +236,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   mergeDocSample,
-		expression: `.foobar[]`,
+		expression: `.foobar.[]`,
 		expected: []string{
 			"D0, P[foobar c], (!!str)::foo_c\n",
 			"D0, P[foobar a], (!!str)::foo_a\n",
@@ -323,7 +298,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   mergeDocSample,
-		expression: `.foobarList[]`,
+		expression: `.foobarList.[]`,
 		expected: []string{
 			"D0, P[foobarList b], (!!str)::bar_b\n",
 			"D0, P[foobarList a], (!!str)::foo_a\n",
@@ -369,7 +344,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,
-		expression: `.a[0, 2]`,
+		expression: `.a.[0, 2]`,
 		expected: []string{
 			"D0, P[a 0], (!!str)::a\n",
 			"D0, P[a 2], (!!str)::c\n",
@@ -386,7 +361,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,
-		expression: `.a[-1]`,
+		expression: `.a.[-1]`,
 		expected: []string{
 			"D0, P[a -1], (!!str)::c\n",
 		},
@@ -402,7 +377,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,
-		expression: `.a[-2]`,
+		expression: `.a.[-2]`,
 		expected: []string{
 			"D0, P[a -2], (!!str)::b\n",
 		},
@@ -420,7 +395,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,
-		expression: `.a[]`,
+		expression: `.a.[]`,
 		expected: []string{
 			"D0, P[a 0], (!!str)::a\n",
 			"D0, P[a 1], (!!str)::b\n",
@@ -443,5 +418,5 @@ func TestTraversePathOperatorScenarios(t *testing.T) {
 	for _, tt := range traversePathOperatorScenarios {
 		testScenario(t, &tt)
 	}
-	documentScenarios(t, "Traverse (Read)", traversePathOperatorScenarios)
+	documentScenarios(t, "Traverse", traversePathOperatorScenarios)
 }

pkg/yqlib/operator_union.go

@@ -1,17 +1,19 @@
 package yqlib
 
-func unionOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+import "container/list"
+
+func unionOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
-	rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+	rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
 	if err != nil {
-		return Context{}, err
+		return nil, err
 	}
-	for el := rhs.MatchingNodes.Front(); el != nil; el = el.Next() {
+	for el := rhs.Front(); el != nil; el = el.Next() {
 		node := el.Value.(*CandidateNode)
-		lhs.MatchingNodes.PushBack(node)
+		lhs.PushBack(node)
 	}
 	return lhs, nil
 }

pkg/yqlib/operator_value.go

@@ -1,6 +1,8 @@
 package yqlib
 
-func valueOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+import "container/list"
+
+func valueOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
 	log.Debug("value = %v", expressionNode.Operation.CandidateNode.Node.Value)
-	return context.SingleChildContext(expressionNode.Operation.CandidateNode), nil
+	return nodeToMap(expressionNode.Operation.CandidateNode), nil
 }

pkg/yqlib/operator_variables.go

@@ -1,29 +0,0 @@
-package yqlib
-
-import (
-	"container/list"
-	"fmt"
-)
-
-func getVariableOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	variableName := expressionNode.Operation.StringValue
-	log.Debug("getVariableOperator %v", variableName)
-	result := context.GetVariable(variableName)
-	if result == nil {
-		result = list.New()
-	}
-	return context.ChildContext(result), nil
-}
-
-func assignVariableOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
-	if err != nil {
-		return Context{}, nil
-	}
-	if expressionNode.Rhs.Operation.OperationType.Type != "GET_VARIABLE" {
-		return Context{}, fmt.Errorf("RHS of 'as' operator must be a variable name e.g. $foo")
-	}
-	variableName := expressionNode.Rhs.Operation.StringValue
-	context.SetVariable(variableName, lhs.MatchingNodes)
-	return context, nil
-}

pkg/yqlib/operator_variables_test.go

@@ -1,45 +0,0 @@
-package yqlib
-
-import (
-	"testing"
-)
-
-var variableOperatorScenarios = []expressionScenario{
-	{
-		description: "Single value variable",
-		document:    `a: cat`,
-		expression:  `.a as $foo | $foo`,
-		expected: []string{
-			"D0, P[a], (!!str)::cat\n",
-		},
-	},
-	{
-		description: "Multi value variable",
-		document:    `[cat, dog]`,
-		expression:  `.[] as $foo | $foo`,
-		expected: []string{
-			"D0, P[0], (!!str)::cat\n",
-			"D0, P[1], (!!str)::dog\n",
-		},
-	},
-	{
-		description:    "Using variables as a lookup",
-		subdescription: "Example taken from [jq](https://stedolan.github.io/jq/manual/#Variable/SymbolicBindingOperator:...as$identifier|...)",
-		document: `{"posts": [{"title": "Frist psot", "author": "anon"},
-		{"title": "A well-written article", "author": "person1"}],
-"realnames": {"anon": "Anonymous Coward",
-				"person1": "Person McPherson"}}`,
-		expression: `.realnames as $names | .posts[] | {"title":.title, "author": $names[.author]}`,
-		expected: []string{
-			"D0, P[], (!!map)::title: \"Frist psot\"\nauthor: \"Anonymous Coward\"\n",
-			"D0, P[], (!!map)::title: \"A well-written article\"\nauthor: \"Person McPherson\"\n",
-		},
-	},
-}
-
-func TestVariableOperatorScenarios(t *testing.T) {
-	for _, tt := range variableOperatorScenarios {
-		testScenario(t, &tt)
-	}
-	documentScenarios(t, "Variable Operators", variableOperatorScenarios)
-}

pkg/yqlib/operators.go

@@ -4,11 +4,10 @@ import (
 	"container/list"
 	"fmt"
 
-	"github.com/jinzhu/copier"
 	"gopkg.in/yaml.v3"
 )
 
-type operatorHandler func(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error)
+type operatorHandler func(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error)
 
 func unwrapDoc(node *yaml.Node) *yaml.Node {
 	if node.Kind == yaml.DocumentNode {
@@ -17,67 +16,8 @@ func unwrapDoc(node *yaml.Node) *yaml.Node {
 	return node
 }
 
-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 emptyOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+	return list.New(), nil
 }
 
 func createBooleanCandidate(owner *CandidateNode, value bool) *CandidateNode {
@@ -89,25 +29,22 @@ func createBooleanCandidate(owner *CandidateNode, value bool) *CandidateNode {
 	return owner.CreateChild(nil, node)
 }
 
-func createTraversalTree(path []interface{}, traversePrefs traversePreferences, targetKey bool) *ExpressionNode {
+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}}
 	} else if len(path) == 1 {
-		lastPrefs := traversePrefs
-		if targetKey {
-			err := copier.Copy(&lastPrefs, traversePrefs)
-			if err != nil {
-				panic(err)
-			}
-			lastPrefs.IncludeMapKeys = true
-			lastPrefs.DontIncludeMapValues = true
-		}
-		return &ExpressionNode{Operation: &Operation{OperationType: traversePathOpType, Preferences: lastPrefs, Value: path[0], StringValue: fmt.Sprintf("%v", path[0])}}
+		return &ExpressionNode{Operation: &Operation{OperationType: traversePathOpType, Preferences: traversePrefs, Value: path[0], StringValue: fmt.Sprintf("%v", path[0])}}
 	}
 
 	return &ExpressionNode{
 		Operation: &Operation{OperationType: shortPipeOpType},
-		Lhs:       createTraversalTree(path[0:1], traversePrefs, false),
-		Rhs:       createTraversalTree(path[1:], traversePrefs, targetKey),
+		Lhs:       createTraversalTree(path[0:1], traversePrefs),
+		Rhs:       createTraversalTree(path[1:], traversePrefs),
 	}
 }

pkg/yqlib/operators_test.go

@@ -27,6 +27,7 @@ type expressionScenario struct {
 }
 
 func testScenario(t *testing.T, s *expressionScenario) {
+	var results *list.List
 	var err error
 
 	node, err := NewExpressionParser().ParseExpression(s.expression)
@@ -65,13 +66,13 @@ func testScenario(t *testing.T, s *expressionScenario) {
 		os.Setenv("myenv", s.environmentVariable)
 	}
 
-	context, err := NewDataTreeNavigator().GetMatchingNodes(Context{MatchingNodes: inputs}, node)
+	results, err = NewDataTreeNavigator().GetMatchingNodes(inputs, node)
 
 	if err != nil {
 		t.Error(fmt.Errorf("%v: %v", err, s.expression))
 		return
 	}
-	test.AssertResultComplexWithContext(t, s.expected, resultsToString(context.MatchingNodes), fmt.Sprintf("exp: %v\ndoc: %v", s.expression, s.document))
+	test.AssertResultComplexWithContext(t, s.expected, resultsToString(results), fmt.Sprintf("exp: %v\ndoc: %v", s.expression, s.document))
 }
 
 func resultsToString(results *list.List) []string {
@@ -251,12 +252,12 @@ func documentOutput(t *testing.T, w *bufio.Writer, s expressionScenario, formatt
 
 	}
 
-	context, err := NewDataTreeNavigator().GetMatchingNodes(Context{MatchingNodes: inputs}, node)
+	results, err := NewDataTreeNavigator().GetMatchingNodes(inputs, node)
 	if err != nil {
 		t.Error(err, s.expression)
 	}
 
-	err = printer.PrintResults(context.MatchingNodes)
+	err = printer.PrintResults(results)
 	if err != nil {
 		t.Error(err, s.expression)
 	}

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}
-		context, err := p.treeNavigator.GetMatchingNodes(Context{MatchingNodes: matchingNodes}, &explodeNode)
+		matchingNodes, err = p.treeNavigator.GetMatchingNodes(matchingNodes, &explodeNode)
 		if err != nil {
 			return err
 		}
-		matchingNodes = context.MatchingNodes
 	}
 
 	bufferedWriter := bufio.NewWriter(p.writer)

pkg/yqlib/printer_test.go

@@ -3,7 +3,6 @@ package yqlib
 import (
 	"bufio"
 	"bytes"
-	"container/list"
 	"strings"
 	"testing"
 
@@ -17,12 +16,6 @@ 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)
@@ -34,13 +27,13 @@ func TestPrinterMultipleDocsInSequence(t *testing.T) {
 	}
 
 	el := inputs.Front()
-	sample1 := nodeToList(el.Value.(*CandidateNode))
+	sample1 := nodeToMap(el.Value.(*CandidateNode))
 
 	el = el.Next()
-	sample2 := nodeToList(el.Value.(*CandidateNode))
+	sample2 := nodeToMap(el.Value.(*CandidateNode))
 
 	el = el.Next()
-	sample3 := nodeToList(el.Value.(*CandidateNode))
+	sample3 := nodeToMap(el.Value.(*CandidateNode))
 
 	err = printer.PrintResults(sample1)
 	if err != nil {
@@ -75,19 +68,19 @@ func TestPrinterMultipleFilesInSequence(t *testing.T) {
 	elNode := el.Value.(*CandidateNode)
 	elNode.Document = 0
 	elNode.FileIndex = 0
-	sample1 := nodeToList(elNode)
+	sample1 := nodeToMap(elNode)
 
 	el = el.Next()
 	elNode = el.Value.(*CandidateNode)
 	elNode.Document = 0
 	elNode.FileIndex = 1
-	sample2 := nodeToList(elNode)
+	sample2 := nodeToMap(elNode)
 
 	el = el.Next()
 	elNode = el.Value.(*CandidateNode)
 	elNode.Document = 0
 	elNode.FileIndex = 2
-	sample3 := nodeToList(elNode)
+	sample3 := nodeToMap(elNode)
 
 	err = printer.PrintResults(sample1)
 	if err != nil {

pkg/yqlib/stream_evaluator.go

@@ -41,11 +41,11 @@ func (s *streamEvaluator) EvaluateNew(expression string, printer Printer) error
 	inputList := list.New()
 	inputList.PushBack(candidateNode)
 
-	result, errorParsing := s.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputList}, node)
+	matches, errorParsing := s.treeNavigator.GetMatchingNodes(inputList, node)
 	if errorParsing != nil {
 		return errorParsing
 	}
-	return printer.PrintResults(result.MatchingNodes)
+	return printer.PrintResults(matches)
 }
 
 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)
 
-		result, errorParsing := s.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputList}, node)
+		matches, errorParsing := s.treeNavigator.GetMatchingNodes(inputList, node)
 		if errorParsing != nil {
 			return errorParsing
 		}
-		err := printer.PrintResults(result.MatchingNodes)
+		err := printer.PrintResults(matches)
 		if err != nil {
 			return err
 		}

release_instructions.txt

@@ -2,13 +2,11 @@
 - increment version in snapcraft.yaml
 - increment version in github-action/Dockerfile
 - make sure local build passes
-- commit version update changes
 - tag git with same version number
 - commit vX tag - this will trigger github actions
 - use github actions to publish docker and make github release
 - check github updated yq action in marketplace
 
-
 - snapcraft
   - will auto create a candidate, test it works then promote
   

snap/snapcraft.yaml

@@ -1,5 +1,5 @@
 name: yq
-version: '4.5.1'
+version: '4.4.0'
 summary: A lightweight and portable command-line YAML processor
 description: |
   The aim of the project is to be the jq or sed of yaml files.