Increment version

Fixes #716 #715

.dockerignore

@@ -1 +1 @@
-bin
+bin/*

.github/FUNDING.yml

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

.github/workflows/release.yml

@@ -40,17 +40,7 @@ jobs:
       IMAGE_NAME: mikefarah/yq
     runs-on: ubuntu-latest
     steps:
-      - name: Get latest release tag      
+      - uses: actions/checkout@v2
-        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

Dockerfile.dev

@@ -6,26 +6,5 @@ RUN set -e -x \
     && /opt/devtools.sh
 ENV PATH=/go/bin:$PATH
 
-# install mkdocs
-RUN set -ex \
-    && buildDeps=' \
-        build-essential \
-        python3-dev \
-    ' \
-    && apt-get update && apt-get install -y --no-install-recommends \
-        $buildDeps \
-        python3 \
-        python3-setuptools \
-        python3-wheel \
-        python3-pip \
-    && pip3 install --upgrade \
-        pip \
-        'Markdown>=2.6.9' \
-        'mkdocs>=0.16.3' \
-        'mkdocs-material>=1.10.1' \
-        'markdown-include>=0.5.1' \
-    && apt-get purge -y --auto-remove $buildDeps \
-    && rm -rf /var/lib/apt/lists/*
-
 ENV CGO_ENABLED 0
 ENV GOPATH /go:/yq

Makefile

@@ -17,6 +17,7 @@ help:
 	@echo '    make vendor          Install dependencies to vendor directory.'
 	@echo '    make format          Run code formatter.'
 	@echo '    make check           Run static code analysis (lint).'
+	@echo '    make secure          Run gosec.'
 	@echo '    make test            Run tests on project.'
 	@echo '    make cover           Run tests and capture code coverage metrics on project.'
 	@echo '    make clean           Clean the directory tree of produced artifacts.'
@@ -84,6 +85,10 @@ format: vendor
 check: format
 	${DOCKRUN} bash ./scripts/check.sh
 
+.PHONY: secure
+secure: 
+	${DOCKRUN} bash ./scripts/secure.sh
+
 .PHONY: test
 test: check
 	${DOCKRUN} bash ./scripts/test.sh
@@ -96,11 +101,6 @@ cover: check
 	@find cover -type d -exec chmod 755 {} \; || :
 	@find cover -type f -exec chmod 644 {} \; || :
 
-.PHONY: build-docs
-build-docs: prepare mkdocs.yml mkdocs/*
-	${DOCKRUN} mkdocs build
-	@find docs -type d -exec chmod 755 {} \; || :
-	@find docs -type f -exec chmod 644 {} \; || :
 
 .PHONY: release
 release: xcompile

README.md

@@ -90,7 +90,7 @@ docker run --rm -v "${PWD}":/workdir mikefarah/yq <command> [flags] [expression
 #### Run commands interactively:
 
 ```bash
-docker run --rm -it -v "${PWD}":/workdir mikefarah/yq sh
+docker run --rm -it -v "${PWD}":/workdir --entrypoint sh mikefarah/yq
 ```
 
 It can be useful to have a bash function to avoid typing the whole docker command:
@@ -103,7 +103,7 @@ yq() {
 
 ### Go Get:
 ```
-GO111MODULE=on go get github.com/mikefarah/yq
+GO111MODULE=on go get github.com/mikefarah/yq/v4
 ```
 
 ## Community Supported Installation methods
@@ -119,6 +119,8 @@ See [webi](https://webinstall.dev/)
 Supported by @adithyasunil26 (https://github.com/webinstall/webi-installers/tree/master/yq)
 
 ### Windows:
+[![Chocolatey](https://img.shields.io/chocolatey/v/yq.svg)](https://chocolatey.org/packages/yq)
+[![Chocolatey](https://img.shields.io/chocolatey/dt/yq.svg)](https://chocolatey.org/packages/yq)
 ```
 choco install yq
 ```
@@ -151,19 +153,21 @@ sudo apt install yq -y
 Supported by @rmescandon (https://launchpad.net/~rmescandon/+archive/ubuntu/yq)
 
 ## Features
+- [Detailed documentation with many examples](https://mikefarah.gitbook.io/yq/)
 - Written in portable go, so you can download a lovely dependency free binary
 - Uses similar syntax as `jq` but works with YAML and JSON files
 - Fully supports multi document yaml files
 - Colorized yaml output
-- [Deeply traverse yaml](https://mikefarah.gitbook.io/yq/v/v4.x/traverse)
+- [Deeply traverse yaml](https://mikefarah.gitbook.io/yq/operators/traverse-read)
-- [Sort yaml by keys](https://mikefarah.gitbook.io/yq/v/v4.x/sort-keys)
+- [Sort yaml by keys](https://mikefarah.gitbook.io/yq/operators/sort-keys)
-- Manipulate yaml [comments](https://mikefarah.gitbook.io/yq/comment-operators), [styling](https://mikefarah.gitbook.io/yq/style), [tags](https://mikefarah.gitbook.io/yq/tag) and [anchors and aliases](https://mikefarah.gitbook.io/yq/anchor-and-alias-operators).
+- Manipulate yaml [comments](https://mikefarah.gitbook.io/yq/operators/comment-operators), [styling](https://mikefarah.gitbook.io/yq/operators/style), [tags](https://mikefarah.gitbook.io/yq/operators/tag) and [anchors and aliases](https://mikefarah.gitbook.io/yq/operators/anchor-and-alias-operators).
 - [Update yaml inplace](https://mikefarah.gitbook.io/yq/v/v4.x/commands/evaluate#flags)
-- [Complex expressions to select and update](https://mikefarah.gitbook.io/yq/v/v4.x/select#select-and-update-matching-values-in-map)
+- [Complex expressions to select and update](https://mikefarah.gitbook.io/yq/operators/select#select-and-update-matching-values-in-map)
 - Keeps yaml formatting and comments when updating (though there are issues with whitespace)
 - [Convert to/from json to yaml](https://mikefarah.gitbook.io/yq/v/v4.x/usage/convert)
 - [Pipe data in by using '-'](https://mikefarah.gitbook.io/yq/v/v4.x/commands/evaluate)
 - [General shell completion scripts (bash/zsh/fish/powershell)](https://mikefarah.gitbook.io/yq/v/v4.x/commands/shell-completion)
+- [Reduce](https://mikefarah.gitbook.io/yq/operators/reduce) to merge multiple files or sum an array or other fancy things.
 
 ## [Usage](https://mikefarah.gitbook.io/yq/)
 

cmd/evaluate_all_command.go

@@ -17,6 +17,9 @@ func createEvaluateAllCommand() *cobra.Command {
 		Example: `
 # merges f2.yml into f1.yml (inplace)
 yq eval-all --inplace 'select(fileIndex == 0) * select(fileIndex == 1)' f1.yml f2.yml		
+
+# use '-' as a filename to read from STDIN
+cat file2.yml | yq ea '.a.b' file1.yml - file3.yml
 `,
 		Long: "Evaluate All:\nUseful when you need to run an expression across several yaml documents or files. Consumes more memory than eval",
 		RunE: evaluateAll,
@@ -42,14 +45,21 @@ func evaluateAll(cmd *cobra.Command, args []string) error {
 		colorsEnabled = true
 	}
 
-	if writeInplace && len(args) < 2 {
+	firstFileIndex := -1
+	if !nullInput && len(args) == 1 {
+		firstFileIndex = 0
+	} else if len(args) > 1 {
+		firstFileIndex = 1
+	}
+
+	if writeInplace && (firstFileIndex == -1) {
 		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[1])
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[firstFileIndex])
 		out, err = writeInPlaceHandler.CreateTempFile()
 		if err != nil {
 			return err
@@ -59,6 +69,10 @@ func evaluateAll(cmd *cobra.Command, args []string) error {
 		defer func() { writeInPlaceHandler.FinishWriteInPlace(completedSuccessfully) }()
 	}
 
+	if nullInput && len(args) > 1 {
+		return errors.New("Cannot pass files in when using null-input flag")
+	}
+
 	printer := yqlib.NewPrinter(out, outputToJSON, unwrapScalar, colorsEnabled, indent, !noDocSeparators)
 
 	allAtOnceEvaluator := yqlib.NewAllAtOnceEvaluator()

cmd/evalute_sequence_command.go

@@ -21,6 +21,9 @@ yq e '.a.b | length' f1.yml f2.yml
 # prints out the file
 yq e sample.yaml 
 
+# use '-' as a filename to read from STDIN
+cat file2.yml | yq e '.a.b' file1.yml - file3.yml
+
 # prints a new yaml document
 yq e -n '.a.b.c = "cat"' 
 
@@ -62,14 +65,21 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 		colorsEnabled = true
 	}
 
-	if writeInplace && len(args) < 2 {
+	firstFileIndex := -1
+	if !nullInput && len(args) == 1 {
+		firstFileIndex = 0
+	} else if len(args) > 1 {
+		firstFileIndex = 1
+	}
+
+	if writeInplace && (firstFileIndex == -1) {
 		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[1])
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[firstFileIndex])
 		out, err = writeInPlaceHandler.CreateTempFile()
 		if err != nil {
 			return err
@@ -83,6 +93,10 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 
 	streamEvaluator := yqlib.NewStreamEvaluator()
 
+	if nullInput && len(args) > 1 {
+		return errors.New("Cannot pass files in when using null-input flag")
+	}
+
 	switch len(args) {
 	case 0:
 		if pipingStdIn {
@@ -98,7 +112,7 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{args[0]}, printer)
 		}
 	default:
-		err = streamEvaluator.EvaluateFiles(args[0], args[1:], printer)
+		err = streamEvaluator.EvaluateFiles(processExpression(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.2.1"
+	Version = "4.8.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,4 +1,6 @@
-a: simple # just the best
+a:
-b: [1, 2]
+  key1: "value1"
-c:
+  key2: 2.6
-  test: 1
+  ab:
+    key1: 6
+    key2: "h"

github-action/Dockerfile

@@ -1,4 +1,4 @@
-FROM mikefarah/yq:4.2.1
+FROM mikefarah/yq:4.8.0
 
 COPY entrypoint.sh /entrypoint.sh
 

go.mod

@@ -1,14 +1,14 @@
 module github.com/mikefarah/yq/v4
 
 require (
-	github.com/elliotchance/orderedmap v1.3.0
+	github.com/elliotchance/orderedmap v1.4.0
 	github.com/fatih/color v1.10.0
-	github.com/goccy/go-yaml v1.8.4
+	github.com/goccy/go-yaml v1.8.9
-	github.com/jinzhu/copier v0.1.0
+	github.com/jinzhu/copier v0.2.8
-	github.com/spf13/cobra v1.1.1
+	github.com/spf13/cobra v1.1.3
 	github.com/timtadh/data-structures v0.5.3 // indirect
 	github.com/timtadh/lexmachine v0.2.2
-	golang.org/x/sys v0.0.0-20210105210732-16f7687f5001 // indirect
+	golang.org/x/sys v0.0.0-20210317225723-c4fcb01b228e // 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.3.0 h1:k6m77/d0zCXTjsk12nX40TkEBkSICq8T4s6R6bpCqU0=
+github.com/elliotchance/orderedmap v1.4.0 h1:wZtfeEONCbx6in1CZyE6bELEt/vFayMvsxqI5SgsR+A=
-github.com/elliotchance/orderedmap v1.3.0/go.mod h1:8hdSl6jmveQw8ScByd3AaNHNk51RhbTazdqtTty+NFw=
+github.com/elliotchance/orderedmap v1.4.0/go.mod h1:wsDwEaX5jEoyhbs7x93zk2H/qv0zwuhg4inXhDkYqys=
 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.4 h1:AOEdR7aQgbgwHznGe3BLkDQVujxCPUpHOZZcQcp8Y3M=
+github.com/goccy/go-yaml v1.8.9 h1:4AEXg2qx+/w29jXnXpMY6mTckmYu1TMoHteKuMf0HFg=
-github.com/goccy/go-yaml v1.8.4/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
+github.com/goccy/go-yaml v1.8.9/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.1.0 h1:Vh8xALtH3rrKGB/XIRe5d0yCTHPZFauWPLvdpDAbi88=
+github.com/jinzhu/copier v0.2.8 h1:N8MbL5niMwE3P4dOwurJixz5rMkKfujmMRFmAanSzWE=
-github.com/jinzhu/copier v0.1.0/go.mod h1:24xnZezI2Yqac9J61UC6/dG/k76ttpq0DdJI3QmUvro=
+github.com/jinzhu/copier v0.2.8/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=
@@ -168,10 +168,9 @@ github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4k
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/spf13/cobra v1.1.1 h1:KfztREH0tPxJJ+geloSLaAkaPkr4ki2Er5quFV1TDo4=
+github.com/spf13/cobra v1.1.3 h1:xghbfqPkxzxP3C/f3n5DdpAbdKLj4ZE4BWQI362l53M=
-github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI=
+github.com/spf13/cobra v1.1.3/go.mod h1:pGADOWyqRD/YMrPZigI/zbliZ2wVD/23d+is3pSWzOo=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
-github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
@@ -180,8 +179,9 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 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=
@@ -255,10 +255,9 @@ golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 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-20210105210732-16f7687f5001 h1:/dSxr6gT0FNI1MO5WLJo8mTmItROeOKTkDn+7OwWBos=
+golang.org/x/sys v0.0.0-20210317225723-c4fcb01b228e h1:XNp2Flc/1eWQGk5BLzqTAN7fQIwIbfyVTuVxXxZh73M=
-golang.org/x/sys v0.0.0-20210105210732-16f7687f5001/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210317225723-c4fcb01b228e/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=
@@ -268,7 +267,6 @@ golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd h1:/e+gpKk9r3dJobndpTytxS2gOy6m5uvpg+ISQoEcusQ=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
@@ -307,7 +305,6 @@ google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZi
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -318,11 +315,10 @@ gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473/go.mod h1:N1eN2tsCx
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 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.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-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

@@ -1,29 +1,54 @@
 package yqlib
 
-import "container/list"
+import (
+	"container/list"
 
-/**
+	yaml "gopkg.in/yaml.v3"
-	Loads all yaml documents of all files given into memory, then runs the given expression once.
+)
-**/
+
+// A yaml expression evaluator that runs the expression once against all files/nodes in memory.
 type Evaluator interface {
 	EvaluateFiles(expression string, filenames []string, printer Printer) error
+
+	// EvaluateNodes takes an expression and one or more yaml nodes, returning a list of matching candidate nodes
+	EvaluateNodes(expression string, nodes ...*yaml.Node) (*list.List, error)
+
+	// EvaluateCandidateNodes takes an expression and list of candidate nodes, returning a list of matching candidate nodes
+	EvaluateCandidateNodes(expression string, inputCandidateNodes *list.List) (*list.List, error)
 }
 
 type allAtOnceEvaluator struct {
 	treeNavigator DataTreeNavigator
-	treeCreator   PathTreeCreator
+	treeCreator   ExpressionParser
 }
 
 func NewAllAtOnceEvaluator() Evaluator {
-	return &allAtOnceEvaluator{treeNavigator: NewDataTreeNavigator(), treeCreator: NewPathTreeCreator()}
+	return &allAtOnceEvaluator{treeNavigator: NewDataTreeNavigator(), treeCreator: NewExpressionParser()}
+}
+
+func (e *allAtOnceEvaluator) EvaluateNodes(expression string, nodes ...*yaml.Node) (*list.List, error) {
+	inputCandidates := list.New()
+	for _, node := range nodes {
+		inputCandidates.PushBack(&CandidateNode{Node: node})
+	}
+	return e.EvaluateCandidateNodes(expression, inputCandidates)
+}
+
+func (e *allAtOnceEvaluator) EvaluateCandidateNodes(expression string, inputCandidates *list.List) (*list.List, error) {
+	node, err := e.treeCreator.ParseExpression(expression)
+	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
 }
 
 func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer) error {
 	fileIndex := 0
-	node, err := treeCreator.ParsePath(expression)
+
-	if err != nil {
-		return err
-	}
 	var allDocuments *list.List = list.New()
 	for _, filename := range filenames {
 		reader, err := readStream(filename)
@@ -37,7 +62,7 @@ func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string
 		allDocuments.PushBackList(fileDocuments)
 		fileIndex = fileIndex + 1
 	}
-	matches, err := treeNavigator.GetMatchingNodes(allDocuments, node)
+	matches, err := e.EvaluateCandidateNodes(expression, allDocuments)
 	if err != nil {
 		return err
 	}

pkg/yqlib/all_at_once_evaluator_test.go

@@ -0,0 +1,40 @@
+package yqlib
+
+import (
+	"testing"
+
+	"github.com/mikefarah/yq/v4/test"
+)
+
+var evaluateNodesScenario = []expressionScenario{
+	{
+		document:   `a: hello`,
+		expression: `.a`,
+		expected: []string{
+			"D0, P[a], (!!str)::hello\n",
+		},
+	},
+	{
+		document:   `a: hello`,
+		expression: `.`,
+		expected: []string{
+			"D0, P[], (doc)::a: hello\n",
+		},
+	},
+	{
+		document:   `- a: "yes"`,
+		expression: `.[] | has("a")`,
+		expected: []string{
+			"D0, P[0], (!!bool)::true\n",
+		},
+	},
+}
+
+func TestAllAtOnceEvaluateNodes(t *testing.T) {
+	var evaluator = NewAllAtOnceEvaluator()
+	for _, tt := range evaluateNodesScenario {
+		node := test.ParseData(tt.document)
+		list, _ := evaluator.EvaluateNodes(tt.expression, &node)
+		test.AssertResultComplex(t, tt.expected, resultsToString(list))
+	}
+}

pkg/yqlib/candidate_node.go

@@ -2,26 +2,50 @@ package yqlib
 
 import (
 	"fmt"
-	"strconv"
-	"strings"
 
 	"github.com/jinzhu/copier"
 	yaml "gopkg.in/yaml.v3"
 )
 
 type CandidateNode struct {
-	Node      *yaml.Node    // the actual node
+	Node      *yaml.Node     // the actual node
-	Path      []interface{} /// the path we took to get to this node
+	Parent    *CandidateNode // parent node
-	Document  uint          // the document index of this node
+	Path      []interface{}  /// the path we took to get to this node
+	Document  uint           // the document index of this node
 	Filename  string
 	FileIndex int
+	// 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 {
-	return fmt.Sprintf("%v - %v", n.Document, n.Path)
+	keyPrefix := ""
+	if n.IsMapKey {
+		keyPrefix = "key-"
+	}
+	return fmt.Sprintf("%v%v - %v", keyPrefix, n.Document, n.Path)
 }
 
-func (n *CandidateNode) CreateChildPath(path interface{}) []interface{} {
+func (n *CandidateNode) CreateChild(path interface{}, node *yaml.Node) *CandidateNode {
+	return &CandidateNode{
+		Node:      node,
+		Path:      n.createChildPath(path),
+		Parent:    n,
+		Document:  n.Document,
+		Filename:  n.Filename,
+		FileIndex: n.FileIndex,
+	}
+}
+
+func (n *CandidateNode) createChildPath(path interface{}) []interface{} {
+	if path == nil {
+		newPath := make([]interface{}, len(n.Path))
+		copy(newPath, n.Path)
+		return newPath
+	}
+
 	//don't use append as they may actually modify the path of the orignal node!
 	newPath := make([]interface{}, len(n.Path)+1)
 	copy(newPath, n.Path)
@@ -44,10 +68,10 @@ 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
 }
 
 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
@@ -56,56 +80,22 @@ 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
 	if n.Node.Style == 0 {
 		n.Node.Style = other.Node.Style
 	}
-	n.Node.FootComment = n.Node.FootComment + other.Node.FootComment
-	n.Node.HeadComment = n.Node.HeadComment + other.Node.HeadComment
-	n.Node.LineComment = n.Node.LineComment + other.Node.LineComment
-}
 
-func (n *CandidateNode) PathStackToString() string {
+	if other.Node.FootComment != "" {
-	return mergePathStackToString(n.Path)
+		n.Node.FootComment = other.Node.FootComment
-}
+	}
-
+	if other.Node.HeadComment != "" {
-func mergePathStackToString(pathStack []interface{}) string {
+		n.Node.HeadComment = other.Node.HeadComment
-	var sb strings.Builder
+	}
-	for index, path := range pathStack {
+	if other.Node.LineComment != "" {
-		switch path.(type) {
+		n.Node.LineComment = other.Node.LineComment
-		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/color_print.go

@@ -17,8 +17,8 @@ func format(attr color.Attribute) string {
 	return fmt.Sprintf("%s[%dm", escape, attr)
 }
 
-func ColorizeAndPrint(bytes []byte, writer io.Writer) error {
+func colorizeAndPrint(yamlBytes []byte, writer io.Writer) error {
-	tokens := lexer.Tokenize(string(bytes))
+	tokens := lexer.Tokenize(string(yamlBytes))
 	var p printer.Printer
 	p.Bool = func() *printer.Property {
 		return &printer.Property{

pkg/yqlib/context.go

@@ -0,0 +1,54 @@
+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,16 +3,14 @@ package yqlib
 import (
 	"fmt"
 
-	"container/list"
-
 	logging "gopkg.in/op/go-logging.v1"
 )
 
 type DataTreeNavigator interface {
-	// given a list of CandidateEntities and a pathNode,
+	// given the context and a expressionNode,
-	// this will process the list against the given pathNode and return
+	// this will process the against the given expressionNode and return
-	// a new list of matching candidates
+	// a new context of matching candidates
-	GetMatchingNodes(matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error)
+	GetMatchingNodes(context Context, expressionNode *ExpressionNode) (Context, error)
 }
 
 type dataTreeNavigator struct {
@@ -22,22 +20,22 @@ func NewDataTreeNavigator() DataTreeNavigator {
 	return &dataTreeNavigator{}
 }
 
-func (d *dataTreeNavigator) GetMatchingNodes(matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func (d *dataTreeNavigator) GetMatchingNodes(context Context, expressionNode *ExpressionNode) (Context, error) {
-	if pathNode == nil {
+	if expressionNode == nil {
 		log.Debugf("getMatchingNodes - nothing to do")
-		return matchingNodes, nil
+		return context, nil
 	}
-	log.Debugf("Processing Op: %v", pathNode.Operation.toString())
+	log.Debugf("Processing Op: %v", expressionNode.Operation.toString())
 	if log.IsEnabledFor(logging.DEBUG) {
-		for el := matchingNodes.Front(); el != nil; el = el.Next() {
+		for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 			log.Debug(NodeToString(el.Value.(*CandidateNode)))
 		}
 	}
 	log.Debug(">>")
-	handler := pathNode.Operation.OperationType.Handler
+	handler := expressionNode.Operation.OperationType.Handler
 	if handler != nil {
-		return handler(d, matchingNodes, pathNode)
+		return handler(d, context, expressionNode)
 	}
-	return nil, fmt.Errorf("Unknown operator %v", pathNode.Operation.OperationType)
+	return Context{}, fmt.Errorf("Unknown operator %v", expressionNode.Operation.OperationType)
 
 }

pkg/yqlib/doc/Add.md

@@ -1,9 +1,9 @@
 Add behaves differently according to the type of the LHS:
 - arrays: concatenate
-- number scalars: arithmetic addition (soon)
+- number scalars: arithmetic addition
-- string scalars: concatenate (soon)
+- string scalars: concatenate
 
-Use `+=` as append assign for things like increment. `.a += .x` is equivalent to running `.a |= . + .x`.
+Use `+=` as append assign for things like increment. Note that `.a += .x` is equivalent to running `.a = .a + .x`.
 
 ## Concatenate and assign arrays
 Given a sample.yml file of:
@@ -67,23 +67,19 @@ will output
 - 2
 ```
 
-## Add object to array
+## Add new object to array
 Given a sample.yml file of:
 ```yaml
 a:
-  - 1
+  - dog: woof
-  - 2
-c:
-  cat: meow
 ```
 then
 ```bash
-yq eval '.a + .c' sample.yml
+yq eval '.a + {"cat": "meow"}' sample.yml
 ```
 will output
 ```yaml
-- 1
+- dog: woof
-- 2
 - cat: meow
 ```
 
@@ -105,7 +101,7 @@ will output
 - hello
 ```
 
-## Update array (append)
+## Append to array
 Given a sample.yml file of:
 ```yaml
 a:
@@ -131,3 +127,113 @@ b:
   - 4
 ```
 
+## Relative append
+Given a sample.yml file of:
+```yaml
+a:
+  a1:
+    b:
+      - cat
+  a2:
+    b:
+      - dog
+  a3: {}
+```
+then
+```bash
+yq eval '.a[].b += ["mouse"]' sample.yml
+```
+will output
+```yaml
+a:
+  a1:
+    b:
+      - cat
+      - mouse
+  a2:
+    b:
+      - dog
+      - mouse
+  a3: {b: [mouse]}
+```
+
+## String concatenation
+Given a sample.yml file of:
+```yaml
+a: cat
+b: meow
+```
+then
+```bash
+yq eval '.a = .a + .b' sample.yml
+```
+will output
+```yaml
+a: catmeow
+b: meow
+```
+
+## Number addition - float
+If the lhs or rhs are floats then the expression will be calculated with floats.
+
+Given a sample.yml file of:
+```yaml
+a: 3
+b: 4.9
+```
+then
+```bash
+yq eval '.a = .a + .b' sample.yml
+```
+will output
+```yaml
+a: 7.9
+b: 4.9
+```
+
+## Number addition - int
+If both the lhs and rhs are ints then the expression will be calculated with ints.
+
+Given a sample.yml file of:
+```yaml
+a: 3
+b: 4
+```
+then
+```bash
+yq eval '.a = .a + .b' sample.yml
+```
+will output
+```yaml
+a: 7
+b: 4
+```
+
+## Increment numbers
+Given a sample.yml file of:
+```yaml
+a: 3
+b: 5
+```
+then
+```bash
+yq eval '.[] += 1' sample.yml
+```
+will output
+```yaml
+a: 4
+b: 6
+```
+
+## 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/Anchor and Alias Operators.md

@@ -1,8 +1,99 @@
-Use the `alias` and `anchor` operators to read and write yaml aliases and anchors. The `explode` operator normalises a yaml file (dereference aliases and remove anchor names).
+Use the `alias` and `anchor` operators to read and write yaml aliases and anchors. The `explode` operator normalises a yaml file (dereference (or expands) aliases and remove anchor names).
 
 `yq` supports merge aliases (like `<<: *blah`) however this is no longer in the standard yaml spec (1.2) and so `yq` will automatically add the `!!merge` tag to these nodes as it is effectively a custom tag.
 
 
+## Merge one map
+see https://yaml.org/type/merge.html
+
+Given a sample.yml file of:
+```yaml
+- &CENTER
+  x: 1
+  y: 2
+- &LEFT
+  x: 0
+  y: 2
+- &BIG
+  r: 10
+- &SMALL
+  r: 1
+- !!merge <<: *CENTER
+  r: 10
+```
+then
+```bash
+yq eval '.[4] | explode(.)' sample.yml
+```
+will output
+```yaml
+x: 1
+y: 2
+r: 10
+```
+
+## Merge multiple maps
+see https://yaml.org/type/merge.html
+
+Given a sample.yml file of:
+```yaml
+- &CENTER
+  x: 1
+  y: 2
+- &LEFT
+  x: 0
+  y: 2
+- &BIG
+  r: 10
+- &SMALL
+  r: 1
+- !!merge <<:
+    - *CENTER
+    - *BIG
+```
+then
+```bash
+yq eval '.[4] | explode(.)' sample.yml
+```
+will output
+```yaml
+r: 10
+x: 1
+y: 2
+```
+
+## Override
+see https://yaml.org/type/merge.html
+
+Given a sample.yml file of:
+```yaml
+- &CENTER
+  x: 1
+  y: 2
+- &LEFT
+  x: 0
+  y: 2
+- &BIG
+  r: 10
+- &SMALL
+  r: 1
+- !!merge <<:
+    - *BIG
+    - *LEFT
+    - *SMALL
+  x: 1
+```
+then
+```bash
+yq eval '.[4] | explode(.)' sample.yml
+```
+will output
+```yaml
+r: 10
+x: 1
+y: 2
+```
+
 ## Get anchor
 Given a sample.yml file of:
 ```yaml
@@ -183,9 +274,9 @@ bar:
   c: bar_c
 foobarList:
   b: bar_b
-  a: foo_a
+  thing: foo_thing
-  thing: bar_thing
   c: foobarList_c
+  a: foo_a
 foobar:
   c: foo_c
   a: foo_a

pkg/yqlib/doc/Assign (Update).md

@@ -1,10 +1,4 @@
-This operator is used to update node values. It can be used in either the:
 
-### plain form: `=`
-Which will assign the LHS node values to the RHS node values. The RHS expression is run against the matching nodes in the pipeline.
-
-### relative form: `|=`
-This will do a similar thing to the plain form, however, the RHS expression is run against _the LHS nodes_. This is useful for updating values based on old values, e.g. increment.
 ## Create yaml file
 Running
 ```bash

pkg/yqlib/doc/Comment Operators.md

@@ -1,4 +1,15 @@
 Use these comment operators to set or retrieve comments.
+
+Like the `=` and `|=` assign operators, the same syntax applies when updating comments:
+
+
+### plain form: `=`
+This will assign the LHS nodes comments to the expression on the RHS. The RHS is run against the matching nodes in the pipeline
+
+### relative form: `|=` 
+Similar to the plain form, however the RHS evaluates against each matching LHS node! This is useful if you want to set the comments as a relative expression of the node, for instance its value or path.
+
+
 ## Set line comment
 Given a sample.yml file of:
 ```yaml
@@ -77,18 +88,23 @@ a: cat
 b: dog # leave this
 ```
 
-## Remove all comments
+## Remove (strip) all comments
+Note the use of `...` to ensure key nodes are included.
+
 Given a sample.yml file of:
 ```yaml
 a: cat # comment
+# great
+b: # key comment
 ```
 then
 ```bash
-yq eval '.. comments=""' sample.yml
+yq eval '... comments=""' sample.yml
 ```
 will output
 ```yaml
 a: cat
+b:
 ```
 
 ## Get line comment

pkg/yqlib/doc/Document Index.md

@@ -1,4 +1,4 @@
-Use the `documentIndex` operator to select nodes of a particular document.
+Use the `documentIndex` operator (or the `di` shorthand) to select nodes of a particular document.
 ## Retrieve a document index
 Given a sample.yml file of:
 ```yaml

pkg/yqlib/doc/Entries.md

@@ -0,0 +1,87 @@
+Similar to the same named functions in `jq` these functions convert to/from an object and an array of key-value pairs. This is most useful for performing operations on keys of maps.
+## to_entries Map
+Given a sample.yml file of:
+```yaml
+a: 1
+b: 2
+```
+then
+```bash
+yq eval 'to_entries' sample.yml
+```
+will output
+```yaml
+- key: a
+  value: 1
+- key: b
+  value: 2
+```
+
+## to_entries Array
+Given a sample.yml file of:
+```yaml
+- a
+- b
+```
+then
+```bash
+yq eval 'to_entries' sample.yml
+```
+will output
+```yaml
+- key: 0
+  value: a
+- key: 1
+  value: b
+```
+
+## from_entries map
+Given a sample.yml file of:
+```yaml
+a: 1
+b: 2
+```
+then
+```bash
+yq eval 'to_entries | from_entries' sample.yml
+```
+will output
+```yaml
+a: 1
+b: 2
+```
+
+## from_entries with numeric key indexes
+from_entries always creates a map, even for numeric keys
+
+Given a sample.yml file of:
+```yaml
+- a
+- b
+```
+then
+```bash
+yq eval 'to_entries | from_entries' sample.yml
+```
+will output
+```yaml
+0: a
+1: b
+```
+
+## Use with_entries to update keys
+Given a sample.yml file of:
+```yaml
+a: 1
+b: 2
+```
+then
+```bash
+yq eval 'with_entries(.key |= "KEY_" + .)' sample.yml
+```
+will output
+```yaml
+KEY_a: 1
+KEY_b: 2
+```
+

pkg/yqlib/doc/Env Variable Operators.md

@@ -1,3 +1,5 @@
+This operator is used to handle environment variables usage in path expressions. While environment variables can, of course, be passed in via your CLI with string interpolation, this often comes with complex quote escaping and can be tricky to write and read. Note that there are two forms, `env` which will parse the environment variable as a yaml (be it a map, array, string, number of boolean) and `strenv` which will always parse the argument as a string.
+
 
 ## Read string environment variable
 Running

pkg/yqlib/doc/Equals.md

@@ -29,6 +29,24 @@ 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
@@ -47,6 +65,24 @@ 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
@@ -57,3 +93,31 @@ will output
 true
 ```
 
+## Non exisitant key doesn't equal a value
+Given a sample.yml file of:
+```yaml
+a: frog
+```
+then
+```bash
+yq eval 'select(.b != "thing")' sample.yml
+```
+will output
+```yaml
+a: frog
+```
+
+## Two non existant keys are equal
+Given a sample.yml file of:
+```yaml
+a: frog
+```
+then
+```bash
+yq eval 'select(.b == .c)' sample.yml
+```
+will output
+```yaml
+a: frog
+```
+

pkg/yqlib/doc/File Operators.md

@@ -35,6 +35,26 @@ will output
 0
 ```
 
+## Get file indices of multiple documents
+Given a sample.yml file of:
+```yaml
+a: cat
+```
+And another sample another.yml file of:
+```yaml
+a: cat
+```
+then
+```bash
+yq eval-all 'fileIndex' sample.yml another.yml
+```
+will output
+```yaml
+0
+---
+1
+```
+
 ## Get file index alias
 Given a sample.yml file of:
 ```yaml

pkg/yqlib/doc/Has.md

@@ -19,6 +19,29 @@ true
 false
 ```
 
+## Select, checking for existence of deep paths
+Simply pipe in parent expressions into `has`
+
+Given a sample.yml file of:
+```yaml
+- a:
+    b:
+      c: cat
+- a:
+    b:
+      d: dog
+```
+then
+```bash
+yq eval '.[] | select(.a.b | has("c"))' sample.yml
+```
+will output
+```yaml
+a:
+  b:
+    c: cat
+```
+
 ## Has array index
 Given a sample.yml file of:
 ```yaml

pkg/yqlib/doc/Keys.md

@@ -0,0 +1,35 @@
+# Keys
+
+Use the `keys` operator to return map keys or array indices. 
+## Map keys
+Given a sample.yml file of:
+```yaml
+dog: woof
+cat: meow
+```
+then
+```bash
+yq eval 'keys' sample.yml
+```
+will output
+```yaml
+- dog
+- cat
+```
+
+## Array keys
+Given a sample.yml file of:
+```yaml
+- apple
+- banana
+```
+then
+```bash
+yq eval 'keys' sample.yml
+```
+will output
+```yaml
+- 0
+- 1
+```
+

pkg/yqlib/doc/Length.md

@@ -16,6 +16,20 @@ 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 (Merge).md

@@ -0,0 +1,366 @@
+Like the multiple operator in jq, depending on the operands, this multiply operator will do different things. Currently numbers, arrays and objects are supported.
+
+## Objects and arrays - merging
+Objects are merged deeply matching on matching keys. By default, array values override and are not deeply merged.
+
+Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.
+
+### Merge Flags
+You can control how objects are merged by using one or more of the following flags. Multiple flags can be used together, e.g. `.a *+? .b`.  See examples below
+
+- `+` to append arrays
+- `?` to only merge existing fields
+- `d` to deeply merge arrays
+
+### Merging files
+Note the use of `eval-all` to ensure all documents are loaded into memory.
+
+```bash
+yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' file1.yaml file2.yaml
+```
+
+## Multiply integers
+Running
+```bash
+yq eval --null-input '3 * 4'
+```
+will output
+```yaml
+12
+```
+
+## Merge objects together, returning merged result only
+Given a sample.yml file of:
+```yaml
+a:
+  field: me
+  fieldA: cat
+b:
+  field:
+    g: wizz
+  fieldB: dog
+```
+then
+```bash
+yq eval '.a * .b' sample.yml
+```
+will output
+```yaml
+field:
+  g: wizz
+fieldA: cat
+fieldB: dog
+```
+
+## Merge objects together, returning parent object
+Given a sample.yml file of:
+```yaml
+a:
+  field: me
+  fieldA: cat
+b:
+  field:
+    g: wizz
+  fieldB: dog
+```
+then
+```bash
+yq eval '. * {"a":.b}' sample.yml
+```
+will output
+```yaml
+a:
+  field:
+    g: wizz
+  fieldA: cat
+  fieldB: dog
+b:
+  field:
+    g: wizz
+  fieldB: dog
+```
+
+## Merge keeps style of LHS
+Given a sample.yml file of:
+```yaml
+a: {things: great}
+b:
+  also: "me"
+```
+then
+```bash
+yq eval '. * {"a":.b}' sample.yml
+```
+will output
+```yaml
+a: {things: great, also: "me"}
+b:
+  also: "me"
+```
+
+## Merge arrays
+Given a sample.yml file of:
+```yaml
+a:
+  - 1
+  - 2
+  - 3
+b:
+  - 3
+  - 4
+  - 5
+```
+then
+```bash
+yq eval '. * {"a":.b}' sample.yml
+```
+will output
+```yaml
+a:
+  - 3
+  - 4
+  - 5
+b:
+  - 3
+  - 4
+  - 5
+```
+
+## Merge, only existing fields
+Given a sample.yml file of:
+```yaml
+a:
+  thing: one
+  cat: frog
+b:
+  missing: two
+  thing: two
+```
+then
+```bash
+yq eval '.a *? .b' sample.yml
+```
+will output
+```yaml
+thing: two
+cat: frog
+```
+
+## Merge, appending arrays
+Given a sample.yml file of:
+```yaml
+a:
+  array:
+    - 1
+    - 2
+    - animal: dog
+  value: coconut
+b:
+  array:
+    - 3
+    - 4
+    - animal: cat
+  value: banana
+```
+then
+```bash
+yq eval '.a *+ .b' sample.yml
+```
+will output
+```yaml
+array:
+  - 1
+  - 2
+  - animal: dog
+  - 3
+  - 4
+  - animal: cat
+value: banana
+```
+
+## Merge, only existing fields, appending arrays
+Given a sample.yml file of:
+```yaml
+a:
+  thing:
+    - 1
+    - 2
+b:
+  thing:
+    - 3
+    - 4
+  another:
+    - 1
+```
+then
+```bash
+yq eval '.a *?+ .b' sample.yml
+```
+will output
+```yaml
+thing:
+  - 1
+  - 2
+  - 3
+  - 4
+```
+
+## Merge, deeply merging arrays
+Merging arrays deeply means arrays are merge like objects, with indexes as their key. In this case, we merge the first item in the array, and do nothing with the second.
+
+Given a sample.yml file of:
+```yaml
+a:
+  - name: fred
+    age: 12
+  - name: bob
+    age: 32
+b:
+  - name: fred
+    age: 34
+```
+then
+```bash
+yq eval '.a *d .b' sample.yml
+```
+will output
+```yaml
+- name: fred
+  age: 34
+- name: bob
+  age: 32
+```
+
+## Merge arrays of objects together, matching on a key
+It's a complex command, the trickyness comes from needing to have the right context in the expressions.
+First we save the second array into a variable '$two' which lets us reference it later.
+We then need to update the first array. We will use the relative update (|=) because we need to update relative to the current element of the array in the LHS in the RHS expression. 
+We set the current element of the first array as $cur. Now we multiply (merge) $cur with the matching entry in $two, by passing $two through a select filter.
+
+
+Given a sample.yml file of:
+```yaml
+- a: apple
+  b: appleB
+- a: kiwi
+  b: kiwiB
+- a: banana
+  b: bananaB
+```
+And another sample another.yml file of:
+```yaml
+- a: banana
+  c: bananaC
+- a: apple
+  b: appleB2
+- a: dingo
+  c: dingoC
+```
+then
+```bash
+yq eval-all '(select(fi==1) | .[]) as $two | select(fi==0) | .[] |= (. as $cur |  $cur * ($two | select(.a == $cur.a)))' sample.yml another.yml
+```
+will output
+```yaml
+- a: apple
+  b: appleB2
+- a: kiwi
+  b: kiwiB
+- a: banana
+  b: bananaB
+  c: bananaC
+```
+
+## Merge to prefix an element
+Given a sample.yml file of:
+```yaml
+a: cat
+b: dog
+```
+then
+```bash
+yq eval '. * {"a": {"c": .a}}' sample.yml
+```
+will output
+```yaml
+a:
+  c: cat
+b: dog
+```
+
+## Merge with simple aliases
+Given a sample.yml file of:
+```yaml
+a: &cat
+  c: frog
+b:
+  f: *cat
+c:
+  g: thongs
+```
+then
+```bash
+yq eval '.c * .b' sample.yml
+```
+will output
+```yaml
+g: thongs
+f: *cat
+```
+
+## Merge copies anchor names
+Given a sample.yml file of:
+```yaml
+a:
+  c: &cat frog
+b:
+  f: *cat
+c:
+  g: thongs
+```
+then
+```bash
+yq eval '.c * .a' sample.yml
+```
+will output
+```yaml
+g: thongs
+c: &cat frog
+```
+
+## Merge with merge anchors
+Given a sample.yml file of:
+```yaml
+foo: &foo
+  a: foo_a
+  thing: foo_thing
+  c: foo_c
+bar: &bar
+  b: bar_b
+  thing: bar_thing
+  c: bar_c
+foobarList:
+  b: foobarList_b
+  !!merge <<:
+    - *foo
+    - *bar
+  c: foobarList_c
+foobar:
+  c: foobar_c
+  !!merge <<: *foo
+  thing: foobar_thing
+```
+then
+```bash
+yq eval '.foobar * .foobarList' sample.yml
+```
+will output
+```yaml
+c: foobarList_c
+<<:
+  - *foo
+  - *bar
+thing: foobar_thing
+b: foobarList_b
+```
+

pkg/yqlib/doc/Multiply.md

@@ -1,238 +0,0 @@
-Like the multiple operator in `jq`, depending on the operands, this multiply operator will do different things. Currently only objects are supported, which have the effect of merging the RHS into the LHS.
-
-Upcoming versions of `yq` will add support for other types of multiplication (numbers, strings).
-
-To concatenate when merging objects, use the `*+` form (see examples below). This will recursively merge objects, appending arrays when it encounters them.
-
-Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.
-
-## Merging files
-Note the use of eval-all to ensure all documents are loaded into memory.
-
-```bash
-yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' file1.yaml file2.yaml
-```
-
-## Merge objects together, returning merged result only
-Given a sample.yml file of:
-```yaml
-a:
-  field: me
-  fieldA: cat
-b:
-  field:
-    g: wizz
-  fieldB: dog
-```
-then
-```bash
-yq eval '.a * .b' sample.yml
-```
-will output
-```yaml
-field:
-  g: wizz
-fieldA: cat
-fieldB: dog
-```
-
-## Merge objects together, returning parent object
-Given a sample.yml file of:
-```yaml
-a:
-  field: me
-  fieldA: cat
-b:
-  field:
-    g: wizz
-  fieldB: dog
-```
-then
-```bash
-yq eval '. * {"a":.b}' sample.yml
-```
-will output
-```yaml
-a:
-  field:
-    g: wizz
-  fieldA: cat
-  fieldB: dog
-b:
-  field:
-    g: wizz
-  fieldB: dog
-```
-
-## Merge keeps style of LHS
-Given a sample.yml file of:
-```yaml
-a: {things: great}
-b:
-  also: "me"
-
-```
-then
-```bash
-yq eval '. * {"a":.b}' sample.yml
-```
-will output
-```yaml
-a: {things: great, also: "me"}
-b:
-  also: "me"
-```
-
-## Merge arrays
-Given a sample.yml file of:
-```yaml
-a:
-  - 1
-  - 2
-  - 3
-b:
-  - 3
-  - 4
-  - 5
-```
-then
-```bash
-yq eval '. * {"a":.b}' sample.yml
-```
-will output
-```yaml
-a:
-  - 3
-  - 4
-  - 5
-b:
-  - 3
-  - 4
-  - 5
-```
-
-## Merge, appending arrays
-Given a sample.yml file of:
-```yaml
-a:
-  array:
-    - 1
-    - 2
-    - animal: dog
-  value: coconut
-b:
-  array:
-    - 3
-    - 4
-    - animal: cat
-  value: banana
-```
-then
-```bash
-yq eval '.a *+ .b' sample.yml
-```
-will output
-```yaml
-array:
-  - 1
-  - 2
-  - animal: dog
-  - 3
-  - 4
-  - animal: cat
-value: banana
-```
-
-## Merge to prefix an element
-Given a sample.yml file of:
-```yaml
-a: cat
-b: dog
-```
-then
-```bash
-yq eval '. * {"a": {"c": .a}}' sample.yml
-```
-will output
-```yaml
-a:
-  c: cat
-b: dog
-```
-
-## Merge with simple aliases
-Given a sample.yml file of:
-```yaml
-a: &cat
-  c: frog
-b:
-  f: *cat
-c:
-  g: thongs
-```
-then
-```bash
-yq eval '.c * .b' sample.yml
-```
-will output
-```yaml
-g: thongs
-f: *cat
-```
-
-## Merge does not copy anchor names
-Given a sample.yml file of:
-```yaml
-a:
-  c: &cat frog
-b:
-  f: *cat
-c:
-  g: thongs
-```
-then
-```bash
-yq eval '.c * .a' sample.yml
-```
-will output
-```yaml
-g: thongs
-c: frog
-```
-
-## Merge with merge anchors
-Given a sample.yml file of:
-```yaml
-foo: &foo
-  a: foo_a
-  thing: foo_thing
-  c: foo_c
-bar: &bar
-  b: bar_b
-  thing: bar_thing
-  c: bar_c
-foobarList:
-  b: foobarList_b
-  !!merge <<:
-    - *foo
-    - *bar
-  c: foobarList_c
-foobar:
-  c: foobar_c
-  !!merge <<: *foo
-  thing: foobar_thing
-```
-then
-```bash
-yq eval '.foobar * .foobarList' sample.yml
-```
-will output
-```yaml
-c: foobarList_c
-<<:
-  - *foo
-  - *bar
-thing: foobar_thing
-b: foobarList_b
-```
-

pkg/yqlib/doc/Recursive Descent (Glob).md

@@ -33,6 +33,8 @@ frog
 ```
 
 ## Recursively find nodes with keys
+Note that this example has wrapped the expression in `[]` to show that there are two matches returned. You do not have to wrap in `[]` in your path expression.
+
 Given a sample.yml file of:
 ```yaml
 a:
@@ -43,16 +45,16 @@ a:
 ```
 then
 ```bash
-yq eval '.. | select(has("name"))' sample.yml
+yq eval '[.. | select(has("name"))]' sample.yml
 ```
 will output
 ```yaml
-name: frog
+- name: frog
-b:
+  b:
-  name: blog
+    name: blog
+    age: 12
+- name: blog
   age: 12
-name: blog
-age: 12
 ```
 
 ## Recursively find nodes with values

pkg/yqlib/doc/Reduce.md

@@ -0,0 +1,76 @@
+Reduce is a powerful way to process a collection of data into a new form.
+
+```
+<exp> as $<name> ireduce (<init>; <block>)
+```
+
+e.g.
+
+```
+.[] as $item ireduce (0; . + $item)
+```
+
+On the LHS we are configuring the collection of items that will be reduced `<exp>` as well as what each element will be called `$<name>`. Note that the array has been splatted into its individual elements.
+
+On the RHS there is `<init>`, the starting value of the accumulator and `<block>`, the expression that will update the accumulator for each element in the collection. Note that within the block expression, `.` will evaluate to the current value of the accumulator. 
+
+## yq vs jq syntax
+Reduce syntax in `yq` is a little different from `jq` - as `yq` (currently) isn't as sophisticated as `jq` and its only supports infix notation (e.g. a + b, where the operator is in the middle of the two parameters) - where as `jq` uses a mix of infix notation with _prefix_ notation (e.g. `reduce a b` is like writing `+ a b`).
+
+To that end, the reduce operator is called `ireduce` for backwards compatability if a `jq` like prefix version of `reduce` is ever added.
+
+
+## Sum numbers
+Given a sample.yml file of:
+```yaml
+- 10
+- 2
+- 5
+- 3
+```
+then
+```bash
+yq eval '.[] as $item ireduce (0; . + $item)' sample.yml
+```
+will output
+```yaml
+20
+```
+
+## Merge all yaml files together
+Given a sample.yml file of:
+```yaml
+a: cat
+```
+And another sample another.yml file of:
+```yaml
+b: dog
+```
+then
+```bash
+yq eval-all '. as $item ireduce ({}; . * $item )' sample.yml another.yml
+```
+will output
+```yaml
+a: cat
+b: dog
+```
+
+## Convert an array to an object
+Given a sample.yml file of:
+```yaml
+- name: Cathy
+  has: apples
+- name: Bob
+  has: bananas
+```
+then
+```bash
+yq eval '.[] as $item ireduce ({}; .[$item | .name] = ($item | .has) )' sample.yml
+```
+will output
+```yaml
+Cathy: apples
+Bob: bananas
+```
+

pkg/yqlib/doc/Split into Documents.md

@@ -0,0 +1,31 @@
+# Split into Documents
+
+This operator splits all matches into separate documents
+
+## Split empty
+Running
+```bash
+yq eval --null-input 'splitDoc'
+```
+will output
+```yaml
+
+```
+
+## Split array
+Given a sample.yml file of:
+```yaml
+- a: cat
+- b: dog
+```
+then
+```bash
+yq eval '.[] | splitDoc' sample.yml
+```
+will output
+```yaml
+a: cat
+---
+b: dog
+```
+

pkg/yqlib/doc/String Operators.md

@@ -0,0 +1,88 @@
+# String Operators
+
+## Join strings
+Given a sample.yml file of:
+```yaml
+- cat
+- meow
+- 1
+- null
+- true
+```
+then
+```bash
+yq eval 'join("; ")' sample.yml
+```
+will output
+```yaml
+cat; meow; 1; ; true
+```
+
+## Substitute / Replace string
+This uses golang regex, described [here](https://github.com/google/re2/wiki/Syntax)
+Note the use of `|=` to run in context of the current string value.
+
+Given a sample.yml file of:
+```yaml
+a: dogs are great
+```
+then
+```bash
+yq eval '.a |= sub("dogs", "cats")' sample.yml
+```
+will output
+```yaml
+a: cats are great
+```
+
+## Substitute / Replace string with regex
+This uses golang regex, described [here](https://github.com/google/re2/wiki/Syntax)
+Note the use of `|=` to run in context of the current string value.
+
+Given a sample.yml file of:
+```yaml
+a: cat
+b: heat
+```
+then
+```bash
+yq eval '.[] |= sub("(a)", "${1}r")' sample.yml
+```
+will output
+```yaml
+a: cart
+b: heart
+```
+
+## Split strings
+Given a sample.yml file of:
+```yaml
+cat; meow; 1; ; true
+```
+then
+```bash
+yq eval 'split("; ")' sample.yml
+```
+will output
+```yaml
+- cat
+- meow
+- "1"
+- ""
+- "true"
+```
+
+## Split strings one match
+Given a sample.yml file of:
+```yaml
+word
+```
+then
+```bash
+yq eval 'split("; ")' sample.yml
+```
+will output
+```yaml
+- word
+```
+

pkg/yqlib/doc/Style.md

@@ -1,4 +1,42 @@
 The style operator can be used to get or set the style of nodes (e.g. string style, yaml style)
+## Update and set style of a particular node (simple)
+Given a sample.yml file of:
+```yaml
+a:
+  b: thing
+  c: something
+```
+then
+```bash
+yq eval '.a.b = "new" | .a.b style="double"' sample.yml
+```
+will output
+```yaml
+a:
+  b: "new"
+  c: something
+```
+
+## Update and set style of a particular node using path variables
+You can use a variable to re-use a path
+
+Given a sample.yml file of:
+```yaml
+a:
+  b: thing
+  c: something
+```
+then
+```bash
+yq eval '.a.b as $x | $x = "new" | $x style="double"' sample.yml
+```
+will output
+```yaml
+a:
+  b: "new"
+  c: something
+```
+
 ## Set tagged style
 Given a sample.yml file of:
 ```yaml

pkg/yqlib/doc/Subtract.md

@@ -0,0 +1,71 @@
+
+## Number subtraction - float
+If the lhs or rhs are floats then the expression will be calculated with floats.
+
+Given a sample.yml file of:
+```yaml
+a: 3
+b: 4.5
+```
+then
+```bash
+yq eval '.a = .a - .b' sample.yml
+```
+will output
+```yaml
+a: -1.5
+b: 4.5
+```
+
+## Number subtraction - float
+If the lhs or rhs are floats then the expression will be calculated with floats.
+
+Given a sample.yml file of:
+```yaml
+a: 3
+b: 4.5
+```
+then
+```bash
+yq eval '.a = .a - .b' sample.yml
+```
+will output
+```yaml
+a: -1.5
+b: 4.5
+```
+
+## Number subtraction - int
+If both the lhs and rhs are ints then the expression will be calculated with ints.
+
+Given a sample.yml file of:
+```yaml
+a: 3
+b: 4
+```
+then
+```bash
+yq eval '.a = .a - .b' sample.yml
+```
+will output
+```yaml
+a: -1
+b: 4
+```
+
+## Decrement numbers
+Given a sample.yml file of:
+```yaml
+a: 3
+b: 5
+```
+then
+```bash
+yq eval '.[] -= 1' sample.yml
+```
+will output
+```yaml
+a: 2
+b: 4
+```
+

pkg/yqlib/doc/Traverse (Read).md

@@ -32,8 +32,23 @@ b: apple
 c: banana
 ```
 
+## Optional Splat
+Just like splat, but won't error if you run it against scalars
+
+Given a sample.yml file of:
+```yaml
+cat
+```
+then
+```bash
+yq eval '.[]' sample.yml
+```
+will output
+```yaml
+```
+
 ## Special characters
-Use quotes around path elements with special characters
+Use quotes with brackets around path elements with special characters
 
 Given a sample.yml file of:
 ```yaml
@@ -41,7 +56,23 @@ Given a sample.yml file of:
 ```
 then
 ```bash
-yq eval '."{}"' sample.yml
+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
 ```
 will output
 ```yaml
@@ -82,6 +113,23 @@ will output
 null
 ```
 
+## Optional identifier
+Like jq, does not output an error when the yaml is not an array or object as expected
+
+Given a sample.yml file of:
+```yaml
+- 1
+- 2
+- 3
+```
+then
+```bash
+yq eval '.a?' sample.yml
+```
+will output
+```yaml
+```
+
 ## Wildcard matching
 Given a sample.yml file of:
 ```yaml

pkg/yqlib/doc/Variable Operators.md

@@ -0,0 +1,58 @@
+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/aa.md

@@ -0,0 +1,81 @@
+# Operators
+
+In `yq` expressions are made up of operators and pipes. A context of nodes is passed through the expression and each operation takes the context as input and returns a new context as output. That output is piped in as input for the next operation in the expression. To begin with, the context is set to the first yaml document of the first yaml file (if processing in sequence using eval).
+
+Lets look at a couple of examples.
+
+## Example with a simple operator
+
+Given a document like:
+
+```yaml
+- [a]
+- "cat"
+```
+
+with an expression:
+
+```
+.[] | length
+```
+
+`yq` will initially set the context as single node of the entire yaml document, an array of two elements.
+
+```yaml
+- [a]
+- "cat"
+```
+
+This gets piped into the splat operator `.[]` which will split out the context into a collection of two nodes `[a]` and `"cat"`. Note that this is _not_ a yaml array.
+
+The `length` operator take no arguments, and will simply return the length of _each_ matching node in the context. So for the context of `[a]` and `"cat"`, it will return a new context of `1` and `3`.
+
+This being the last operation in the expression, the results will be printed out:
+
+```
+1
+3
+```
+
+# Example with an operator that takes arguments.
+
+Given a document like:
+
+```yaml
+a: cat
+b: dog
+```
+
+with an expression:
+
+```
+.a = .b
+```
+
+The `=` operator takes two arguments, a `lhs` expression, which in this case is `.a` and `rhs` expression which is `.b`. 
+
+It pipes the current, lets call it 'root' context through the `lhs` expression of `.a` to return the node 
+
+```yaml
+cat
+```
+
+Note that this node holds not only its value 'cat', but comments and metadata too, including path and parent information.
+
+The `=` operator then pipes the 'root' context through the `rhs` expression of `.b` to retun the node
+
+```yaml
+dog
+```
+
+Both sides have now been evaluated, so the operator performs its actual operation of assignment, and copies across the value from the RHS to the value on the LHS, and it returns the now updated 'root' context:
+
+```yaml
+a: cat
+b: dog
+```
+
+# Relative update (e.g. `|=`)
+There is another form of the `=` operator which we call the relative form. It's very similar to `=` but with one key differnce when evaluating the RHS expression.
+
+In the plain form, we pass in the 'root' level context to the RHS expresssion. In relative form, we pass in each result of the LHS to the RHS expression. Let's go through an example.

pkg/yqlib/doc/headers/Add.md

@@ -1,6 +1,6 @@
 Add behaves differently according to the type of the LHS:
 - arrays: concatenate
-- number scalars: arithmetic addition (soon)
+- number scalars: arithmetic addition
-- string scalars: concatenate (soon)
+- string scalars: concatenate
 
-Use `+=` as append assign for things like increment. `.a += .x` is equivalent to running `.a |= . + .x`.
+Use `+=` as append assign for things like increment. Note that `.a += .x` is equivalent to running `.a = .a + .x`.

pkg/yqlib/doc/headers/Anchor and Alias Operators.md

@@ -1,4 +1,4 @@
-Use the `alias` and `anchor` operators to read and write yaml aliases and anchors. The `explode` operator normalises a yaml file (dereference aliases and remove anchor names).
+Use the `alias` and `anchor` operators to read and write yaml aliases and anchors. The `explode` operator normalises a yaml file (dereference (or expands) aliases and remove anchor names).
 
 `yq` supports merge aliases (like `<<: *blah`) however this is no longer in the standard yaml spec (1.2) and so `yq` will automatically add the `!!merge` tag to these nodes as it is effectively a custom tag.
 

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

@@ -1 +1,11 @@
-Use these comment operators to set or retrieve comments.
+Use these comment operators to set or retrieve comments.
+
+Like the `=` and `|=` assign operators, the same syntax applies when updating comments:
+
+
+### plain form: `=`
+This will assign the LHS nodes comments to the expression on the RHS. The RHS is run against the matching nodes in the pipeline
+
+### relative form: `|=` 
+Similar to the plain form, however the RHS evaluates against each matching LHS node! This is useful if you want to set the comments as a relative expression of the node, for instance its value or path.
+

pkg/yqlib/doc/headers/Document Index.md

@@ -1 +1 @@
-Use the `documentIndex` operator to select nodes of a particular document.
+Use the `documentIndex` operator (or the `di` shorthand) to select nodes of a particular document.

pkg/yqlib/doc/headers/Entries.md

@@ -0,0 +1 @@
+Similar to the same named functions in `jq` these functions convert to/from an object and an array of key-value pairs. This is most useful for performing operations on keys of maps.

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

@@ -0,0 +1,2 @@
+This operator is used to handle environment variables usage in path expressions. While environment variables can, of course, be passed in via your CLI with string interpolation, this often comes with complex quote escaping and can be tricky to write and read. Note that there are two forms, `env` which will parse the environment variable as a yaml (be it a map, array, string, number of boolean) and `strenv` which will always parse the argument as a string.
+

pkg/yqlib/doc/headers/Keys.md

@@ -0,0 +1,3 @@
+# Keys
+
+Use the `keys` operator to return map keys or array indices. 

pkg/yqlib/doc/headers/Multiply (Merge).md

@@ -0,0 +1,20 @@
+Like the multiple operator in jq, depending on the operands, this multiply operator will do different things. Currently numbers, arrays and objects are supported.
+
+## Objects and arrays - merging
+Objects are merged deeply matching on matching keys. By default, array values override and are not deeply merged.
+
+Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.
+
+### Merge Flags
+You can control how objects are merged by using one or more of the following flags. Multiple flags can be used together, e.g. `.a *+? .b`.  See examples below
+
+- `+` to append arrays
+- `?` to only merge existing fields
+- `d` to deeply merge arrays
+
+### Merging files
+Note the use of `eval-all` to ensure all documents are loaded into memory.
+
+```bash
+yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' file1.yaml file2.yaml
+```

pkg/yqlib/doc/headers/Multiply.md

@@ -1,14 +0,0 @@
-Like the multiple operator in `jq`, depending on the operands, this multiply operator will do different things. Currently only objects are supported, which have the effect of merging the RHS into the LHS.
-
-Upcoming versions of `yq` will add support for other types of multiplication (numbers, strings).
-
-To concatenate when merging objects, use the `*+` form (see examples below). This will recursively merge objects, appending arrays when it encounters them.
-
-Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.
-
-## Merging files
-Note the use of eval-all to ensure all documents are loaded into memory.
-
-```bash
-yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' file1.yaml file2.yaml
-```

pkg/yqlib/doc/headers/Reduce.md

@@ -0,0 +1,21 @@
+Reduce is a powerful way to process a collection of data into a new form.
+
+```
+<exp> as $<name> ireduce (<init>; <block>)
+```
+
+e.g.
+
+```
+.[] as $item ireduce (0; . + $item)
+```
+
+On the LHS we are configuring the collection of items that will be reduced `<exp>` as well as what each element will be called `$<name>`. Note that the array has been splatted into its individual elements.
+
+On the RHS there is `<init>`, the starting value of the accumulator and `<block>`, the expression that will update the accumulator for each element in the collection. Note that within the block expression, `.` will evaluate to the current value of the accumulator. 
+
+## yq vs jq syntax
+Reduce syntax in `yq` is a little different from `jq` - as `yq` (currently) isn't as sophisticated as `jq` and its only supports infix notation (e.g. a + b, where the operator is in the middle of the two parameters) - where as `jq` uses a mix of infix notation with _prefix_ notation (e.g. `reduce a b` is like writing `+ a b`).
+
+To that end, the reduce operator is called `ireduce` for backwards compatability if a `jq` like prefix version of `reduce` is ever added.
+

pkg/yqlib/doc/headers/Split into Documents.md

@@ -0,0 +1,3 @@
+# Split into Documents
+
+This operator splits all matches into separate documents

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

@@ -0,0 +1 @@
+# String Operators

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

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

pkg/yqlib/encoder.go

@@ -50,7 +50,7 @@ func (ye *yamlEncoder) Encode(node *yaml.Node) error {
 	}
 
 	if ye.colorise {
-		return ColorizeAndPrint(tempBuffer.Bytes(), ye.destination)
+		return colorizeAndPrint(tempBuffer.Bytes(), ye.destination)
 	}
 	return nil
 }
@@ -76,6 +76,8 @@ 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++ {
@@ -153,11 +155,15 @@ 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,29 +9,11 @@ import (
 	"github.com/mikefarah/yq/v4/test"
 )
 
-var sampleYaml = `zabbix: winner
+func yamlToJson(sampleYaml string, indent int) string {
-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, 2)
+	var jsonEncoder = NewJsonEncoder(writer, indent)
 	inputs, err := readDocuments(strings.NewReader(sampleYaml), "sample.yml", 0)
 	if err != nil {
 		panic(err)
@@ -42,6 +24,33 @@ func TestJsonEncoderPreservesObjectOrder(t *testing.T) {
 		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

@@ -5,49 +5,47 @@ import (
 	"strings"
 )
 
-var myPathTokeniser = NewPathTokeniser()
+type ExpressionNode struct {
-var myPathPostfixer = NewPathPostFixer()
-
-type PathTreeNode struct {
 	Operation *Operation
-	Lhs       *PathTreeNode
+	Lhs       *ExpressionNode
-	Rhs       *PathTreeNode
+	Rhs       *ExpressionNode
 }
 
-type PathTreeCreator interface {
+type ExpressionParser interface {
-	ParsePath(path string) (*PathTreeNode, error)
+	ParseExpression(expression string) (*ExpressionNode, error)
-	CreatePathTree(postFixPath []*Operation) (*PathTreeNode, error)
 }
 
-type pathTreeCreator struct {
+type expressionParserImpl struct {
+	pathTokeniser expressionTokeniser
+	pathPostFixer expressionPostFixer
 }
 
-func NewPathTreeCreator() PathTreeCreator {
+func NewExpressionParser() ExpressionParser {
-	return &pathTreeCreator{}
+	return &expressionParserImpl{newExpressionTokeniser(), newExpressionPostFixer()}
 }
 
-func (p *pathTreeCreator) ParsePath(path string) (*PathTreeNode, error) {
+func (p *expressionParserImpl) ParseExpression(expression string) (*ExpressionNode, error) {
-	tokens, err := myPathTokeniser.Tokenise(path)
+	tokens, err := p.pathTokeniser.Tokenise(expression)
 	if err != nil {
 		return nil, err
 	}
 	var Operations []*Operation
-	Operations, err = myPathPostfixer.ConvertToPostfix(tokens)
+	Operations, err = p.pathPostFixer.ConvertToPostfix(tokens)
 	if err != nil {
 		return nil, err
 	}
-	return p.CreatePathTree(Operations)
+	return p.createExpressionTree(Operations)
 }
 
-func (p *pathTreeCreator) CreatePathTree(postFixPath []*Operation) (*PathTreeNode, error) {
+func (p *expressionParserImpl) createExpressionTree(postFixPath []*Operation) (*ExpressionNode, error) {
-	var stack = make([]*PathTreeNode, 0)
+	var stack = make([]*ExpressionNode, 0)
 
 	if len(postFixPath) == 0 {
 		return nil, nil
 	}
 
 	for _, Operation := range postFixPath {
-		var newNode = PathTreeNode{Operation: Operation}
+		var newNode = ExpressionNode{Operation: Operation}
 		log.Debugf("pathTree %v ", Operation.toString())
 		if Operation.OperationType.NumArgs > 0 {
 			numArgs := Operation.OperationType.NumArgs
@@ -71,7 +69,7 @@ func (p *pathTreeCreator) CreatePathTree(postFixPath []*Operation) (*PathTreeNod
 		stack = append(stack, &newNode)
 	}
 	if len(stack) != 1 {
-		return nil, fmt.Errorf("expected end of expression but found '%v', please check expression syntax", strings.TrimSpace(stack[1].Operation.StringValue))
+		return nil, fmt.Errorf("Bad expression, please check expression syntax")
 	}
 	return stack[0], nil
 }

pkg/yqlib/expression_parser_test.go

@@ -7,36 +7,36 @@ import (
 )
 
 func TestPathTreeNoArgsForTwoArgOp(t *testing.T) {
-	_, err := treeCreator.ParsePath("=")
+	_, err := NewExpressionParser().ParseExpression("=")
 	test.AssertResultComplex(t, "'=' expects 2 args but there is 0", err.Error())
 }
 
 func TestPathTreeOneLhsArgsForTwoArgOp(t *testing.T) {
-	_, err := treeCreator.ParsePath(".a =")
+	_, err := NewExpressionParser().ParseExpression(".a =")
 	test.AssertResultComplex(t, "'=' expects 2 args but there is 1", err.Error())
 }
 
 func TestPathTreeOneRhsArgsForTwoArgOp(t *testing.T) {
-	_, err := treeCreator.ParsePath("= .a")
+	_, err := NewExpressionParser().ParseExpression("= .a")
 	test.AssertResultComplex(t, "'=' expects 2 args but there is 1", err.Error())
 }
 
 func TestPathTreeTwoArgsForTwoArgOp(t *testing.T) {
-	_, err := treeCreator.ParsePath(".a = .b")
+	_, err := NewExpressionParser().ParseExpression(".a = .b")
 	test.AssertResultComplex(t, nil, err)
 }
 
 func TestPathTreeNoArgsForOneArgOp(t *testing.T) {
-	_, err := treeCreator.ParsePath("explode")
+	_, err := NewExpressionParser().ParseExpression("explode")
 	test.AssertResultComplex(t, "'explode' expects 1 arg but received none", err.Error())
 }
 
 func TestPathTreeOneArgForOneArgOp(t *testing.T) {
-	_, err := treeCreator.ParsePath("explode(.)")
+	_, err := NewExpressionParser().ParseExpression("explode(.)")
 	test.AssertResultComplex(t, nil, err)
 }
 
 func TestPathTreeExtraArgs(t *testing.T) {
-	_, err := treeCreator.ParsePath("sortKeys(.) explode(.)")
+	_, err := NewExpressionParser().ParseExpression("sortKeys(.) explode(.)")
-	test.AssertResultComplex(t, "expected end of expression but found 'explode', please check expression syntax", err.Error())
+	test.AssertResultComplex(t, "Bad expression, please check expression syntax", err.Error())
 }

pkg/yqlib/expression_postfix.go

@@ -0,0 +1,103 @@
+package yqlib
+
+import (
+	"errors"
+
+	logging "gopkg.in/op/go-logging.v1"
+)
+
+type expressionPostFixer interface {
+	ConvertToPostfix([]*token) ([]*Operation, error)
+}
+
+type expressionPostFixerImpl struct {
+}
+
+func newExpressionPostFixer() expressionPostFixer {
+	return &expressionPostFixerImpl{}
+}
+
+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}}
+	var tokens = append(infixTokens, &token{TokenType: closeBracket})
+
+	for _, currentToken := range tokens {
+		log.Debugf("postfix processing currentToken %v", currentToken.toString(true))
+		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
+			if currentToken.TokenType == closeCollectObject {
+				opener = openCollectObject
+				collectOperator = collectObjectOpType
+			}
+
+			for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != opener {
+				opStack, result = popOpToResult(opStack, result)
+			}
+			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
+			opStack = opStack[0 : len(opStack)-1]
+			log.Debugf("deleteing open bracket from opstack")
+
+			//and append a collect to the opStack
+			// hack - see if there's the optional traverse flag
+			// on the close op - move it to the collect op.
+			// allows for .["cat"]?
+			prefs := traversePreferences{}
+			closeTokenMatch := string(currentToken.Match.Bytes)
+			if closeTokenMatch[len(closeTokenMatch)-1:] == "?" {
+				prefs.OptionalTraverse = true
+			}
+			result = append(result, &Operation{OperationType: collectOperator, Preferences: prefs})
+			log.Debugf("put collect onto the result")
+			result = append(result, &Operation{OperationType: shortPipeOpType})
+			log.Debugf("put shortpipe onto the result")
+
+		case closeBracket:
+			for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != openBracket {
+				opStack, result = popOpToResult(opStack, result)
+			}
+			if len(opStack) == 0 {
+				return nil, errors.New("Bad path expression, got close brackets without matching opening bracket")
+			}
+			// now we should have ( as the last element on the opStack, get rid of it
+			opStack = opStack[0 : len(opStack)-1]
+
+		default:
+			var currentPrecedence = currentToken.Operation.OperationType.Precedence
+			// 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, result = popOpToResult(opStack, result)
+			}
+			// add this operator to the opStack
+			opStack = append(opStack, currentToken)
+			log.Debugf("put %v onto the opstack", currentToken.toString(true))
+		}
+	}
+
+	if log.IsEnabledFor(logging.DEBUG) {
+		log.Debugf("PostFix Result:")
+		for _, currentToken := range result {
+			log.Debugf("> %v", currentToken.toString())
+		}
+	}
+
+	return result, nil
+}

pkg/yqlib/expression_processing_test.go

@@ -0,0 +1,261 @@
+package yqlib
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/mikefarah/yq/v4/test"
+)
+
+var pathTests = []struct {
+	path            string
+	expectedTokens  []interface{}
+	expectedPostFix []interface{}
+}{
+	{
+		`[]|join(".")`,
+		append(make([]interface{}, 0), "[", "EMPTY", "]", "PIPE", "JOIN", "(", ". (string)", ")"),
+		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE", ". (string)", "JOIN", "PIPE"),
+	},
+	{
+		`{"cool": .b or .c}`,
+		append(make([]interface{}, 0), "{", "cool (string)", "CREATE_MAP", "b", "OR", "c", "}"),
+		append(make([]interface{}, 0), "cool (string)", "b", "c", "OR", "CREATE_MAP", "COLLECT_OBJECT", "SHORT_PIPE"),
+	},
+	{
+		`{"cool": []|join(".")}`,
+		append(make([]interface{}, 0), "{", "cool (string)", "CREATE_MAP", "[", "EMPTY", "]", "PIPE", "JOIN", "(", ". (string)", ")", "}"),
+		append(make([]interface{}, 0), "cool (string)", "EMPTY", "COLLECT", "SHORT_PIPE", ". (string)", "JOIN", "PIPE", "CREATE_MAP", "COLLECT_OBJECT", "SHORT_PIPE"),
+	},
+	{
+		`.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), "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"),
+	},
+	{
+		`.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"),
+	},
+	{
+		`.a[]`,
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "EMPTY", "]"),
+		append(make([]interface{}, 0), "a", "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"),
+	},
+	{
+		`.a.[]`,
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "EMPTY", "]"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+	},
+	{
+		`.a[0]`,
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
+		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+	},
+	{
+		`.a[0]?`,
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
+		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+	},
+	{
+		`.a.[0]`,
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
+		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+	},
+	{
+		`.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"),
+	},
+	{
+		`[3]`,
+		append(make([]interface{}, 0), "[", "3 (int64)", "]"),
+		append(make([]interface{}, 0), "3 (int64)", "COLLECT", "SHORT_PIPE"),
+	},
+	{
+		`.key.array + .key.array2`,
+		append(make([]interface{}, 0), "key", "SHORT_PIPE", "array", "ADD", "key", "SHORT_PIPE", "array2"),
+		append(make([]interface{}, 0), "key", "array", "SHORT_PIPE", "key", "array2", "SHORT_PIPE", "ADD"),
+	},
+	{
+		`.key.array * .key.array2`,
+		append(make([]interface{}, 0), "key", "SHORT_PIPE", "array", "MULTIPLY", "key", "SHORT_PIPE", "array2"),
+		append(make([]interface{}, 0), "key", "array", "SHORT_PIPE", "key", "array2", "SHORT_PIPE", "MULTIPLY"),
+	},
+	{
+		`.key.array // .key.array2`,
+		append(make([]interface{}, 0), "key", "SHORT_PIPE", "array", "ALTERNATIVE", "key", "SHORT_PIPE", "array2"),
+		append(make([]interface{}, 0), "key", "array", "SHORT_PIPE", "key", "array2", "SHORT_PIPE", "ALTERNATIVE"),
+	},
+	{
+		`.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"),
+	},
+	{
+		`(.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"),
+	},
+	{
+		`.[] | 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"),
+	},
+	{
+		`[true]`,
+		append(make([]interface{}, 0), "[", "true (bool)", "]"),
+		append(make([]interface{}, 0), "true (bool)", "COLLECT", "SHORT_PIPE"),
+	},
+	{
+		`[true, false]`,
+		append(make([]interface{}, 0), "[", "true (bool)", "UNION", "false (bool)", "]"),
+		append(make([]interface{}, 0), "true (bool)", "false (bool)", "UNION", "COLLECT", "SHORT_PIPE"),
+	},
+	{
+		`"mike": .a`,
+		append(make([]interface{}, 0), "mike (string)", "CREATE_MAP", "a"),
+		append(make([]interface{}, 0), "mike (string)", "a", "CREATE_MAP"),
+	},
+	{
+		`.a: "mike"`,
+		append(make([]interface{}, 0), "a", "CREATE_MAP", "mike (string)"),
+		append(make([]interface{}, 0), "a", "mike (string)", "CREATE_MAP"),
+	},
+	{
+		`{"mike": .a}`,
+		append(make([]interface{}, 0), "{", "mike (string)", "CREATE_MAP", "a", "}"),
+		append(make([]interface{}, 0), "mike (string)", "a", "CREATE_MAP", "COLLECT_OBJECT", "SHORT_PIPE"),
+	},
+	{
+		`{.a: "mike"}`,
+		append(make([]interface{}, 0), "{", "a", "CREATE_MAP", "mike (string)", "}"),
+		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"),
+	},
+	{
+		`explode(.a.b)`,
+		append(make([]interface{}, 0), "EXPLODE", "(", "a", "SHORT_PIPE", "b", ")"),
+		append(make([]interface{}, 0), "a", "b", "SHORT_PIPE", "EXPLODE"),
+	},
+	{
+		`.a.b style="folded"`,
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "b", "ASSIGN_STYLE", "folded (string)"),
+		append(make([]interface{}, 0), "a", "b", "SHORT_PIPE", "folded (string)", "ASSIGN_STYLE"),
+	},
+	{
+		`tag == "str"`,
+		append(make([]interface{}, 0), "GET_TAG", "EQUALS", "str (string)"),
+		append(make([]interface{}, 0), "GET_TAG", "str (string)", "EQUALS"),
+	},
+	{
+		`. tag= "str"`,
+		append(make([]interface{}, 0), "SELF", "ASSIGN_TAG", "str (string)"),
+		append(make([]interface{}, 0), "SELF", "str (string)", "ASSIGN_TAG"),
+	},
+	{
+		`lineComment == "str"`,
+		append(make([]interface{}, 0), "GET_COMMENT", "EQUALS", "str (string)"),
+		append(make([]interface{}, 0), "GET_COMMENT", "str (string)", "EQUALS"),
+	},
+	{
+		`. lineComment= "str"`,
+		append(make([]interface{}, 0), "SELF", "ASSIGN_COMMENT", "str (string)"),
+		append(make([]interface{}, 0), "SELF", "str (string)", "ASSIGN_COMMENT"),
+	},
+	{
+		`. lineComment |= "str"`,
+		append(make([]interface{}, 0), "SELF", "ASSIGN_COMMENT", "str (string)"),
+		append(make([]interface{}, 0), "SELF", "str (string)", "ASSIGN_COMMENT"),
+	},
+	{
+		`.a.b tag="!!str"`,
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "b", "ASSIGN_TAG", "!!str (string)"),
+		append(make([]interface{}, 0), "a", "b", "SHORT_PIPE", "!!str (string)", "ASSIGN_TAG"),
+	},
+	{
+		`""`,
+		append(make([]interface{}, 0), " (string)"),
+		append(make([]interface{}, 0), " (string)"),
+	},
+	{
+		`.foo* | (. style="flow")`,
+		append(make([]interface{}, 0), "foo*", "PIPE", "(", "SELF", "ASSIGN_STYLE", "flow (string)", ")"),
+		append(make([]interface{}, 0), "foo*", "SELF", "flow (string)", "ASSIGN_STYLE", "PIPE"),
+	},
+}
+
+var tokeniser = newExpressionTokeniser()
+var postFixer = newExpressionPostFixer()
+
+func TestPathParsing(t *testing.T) {
+	for _, tt := range pathTests {
+		tokens, err := tokeniser.Tokenise(tt.path)
+		if err != nil {
+			t.Error(tt.path, err)
+		}
+		var tokenValues []interface{}
+		for _, token := range tokens {
+			tokenValues = append(tokenValues, token.toString(false))
+		}
+		test.AssertResultComplexWithContext(t, tt.expectedTokens, tokenValues, fmt.Sprintf("tokenise: %v", tt.path))
+
+		results, errorP := postFixer.ConvertToPostfix(tokens)
+
+		var readableResults []interface{}
+		for _, token := range results {
+			readableResults = append(readableResults, token.toString())
+		}
+
+		if errorP != nil {
+			t.Error(tt.path, err)
+		}
+
+		test.AssertResultComplexWithContext(t, tt.expectedPostFix, readableResults, fmt.Sprintf("postfix: %v", tt.path))
+
+	}
+}

pkg/yqlib/expression_tokeniser.go

@@ -0,0 +1,454 @@
+package yqlib
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	lex "github.com/timtadh/lexmachine"
+	"github.com/timtadh/lexmachine/machines"
+)
+
+func skip(*lex.Scanner, *machines.Match) (interface{}, error) {
+	return nil, nil
+}
+
+type tokenType uint32
+
+const (
+	operationToken = 1 << iota
+	openBracket
+	closeBracket
+	openCollect
+	closeCollect
+	openCollectObject
+	closeCollectObject
+	traverseArrayCollect
+)
+
+type token struct {
+	TokenType            tokenType
+	Operation            *Operation
+	AssignOperation      *Operation      // e.g. tag (GetTag) op becomes AssignTag if '=' follows it
+	CheckForPostTraverse bool            // e.g. [1]cat should really be [1].cat
+	Match                *machines.Match // match that created this token
+
+}
+
+func (t *token) toString(detail bool) string {
+	if t.TokenType == operationToken {
+		if detail {
+			return fmt.Sprintf("%v (%v)", t.Operation.toString(), t.Operation.OperationType.Precedence)
+		}
+		return t.Operation.toString()
+	} else if t.TokenType == openBracket {
+		return "("
+	} else if t.TokenType == closeBracket {
+		return ")"
+	} else if t.TokenType == openCollect {
+		return "["
+	} else if t.TokenType == closeCollect {
+		return "]"
+	} else if t.TokenType == openCollectObject {
+		return "{"
+	} else if t.TokenType == closeCollectObject {
+		return "}"
+	} else if t.TokenType == traverseArrayCollect {
+		return ".["
+
+	} else {
+		return "NFI"
+	}
+}
+
+func pathToken(wrapped bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		value := string(m.Bytes)
+		prefs := traversePreferences{}
+
+		if value[len(value)-1:] == "?" {
+			prefs.OptionalTraverse = true
+			value = value[:len(value)-1]
+		}
+
+		value = value[1:]
+		if wrapped {
+			value = unwrap(value)
+		}
+		log.Debug("PathToken %v", value)
+		op := &Operation{OperationType: traversePathOpType, Value: value, StringValue: value, Preferences: prefs}
+		return &token{TokenType: operationToken, Operation: op, CheckForPostTraverse: true}, nil
+	}
+}
+
+func opToken(op *operationType) lex.Action {
+	return opTokenWithPrefs(op, nil, nil)
+}
+
+func opAssignableToken(opType *operationType, assignOpType *operationType) lex.Action {
+	return opTokenWithPrefs(opType, assignOpType, nil)
+}
+
+func assignOpToken(updateAssign bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		log.Debug("assignOpToken %v", string(m.Bytes))
+		value := string(m.Bytes)
+		op := &Operation{OperationType: assignOpType, Value: assignOpType.Type, StringValue: value, UpdateAssign: updateAssign}
+		return &token{TokenType: operationToken, Operation: op}, nil
+	}
+}
+
+func multiplyWithPrefs() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		prefs := multiplyPreferences{}
+		options := string(m.Bytes)
+		if strings.Contains(options, "+") {
+			prefs.AppendArrays = true
+		}
+		if strings.Contains(options, "?") {
+			prefs.TraversePrefs = traversePreferences{DontAutoCreate: true}
+		}
+		if strings.Contains(options, "d") {
+			prefs.DeepMergeArrays = true
+		}
+		op := &Operation{OperationType: multiplyOpType, Value: multiplyOpType.Type, StringValue: options, Preferences: prefs}
+		return &token{TokenType: operationToken, Operation: op}, nil
+	}
+}
+
+func opTokenWithPrefs(op *operationType, assignOpType *operationType, preferences interface{}) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		log.Debug("opTokenWithPrefs %v", string(m.Bytes))
+		value := string(m.Bytes)
+		op := &Operation{OperationType: op, Value: op.Type, StringValue: value, Preferences: preferences}
+		var assign *Operation
+		if assignOpType != nil {
+			assign = &Operation{OperationType: assignOpType, Value: assignOpType.Type, StringValue: value, Preferences: preferences}
+		}
+		return &token{TokenType: operationToken, Operation: op, AssignOperation: assign}, nil
+	}
+}
+
+func assignAllCommentsOp(updateAssign bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		log.Debug("assignAllCommentsOp %v", string(m.Bytes))
+		value := string(m.Bytes)
+		op := &Operation{
+			OperationType: assignCommentOpType,
+			Value:         assignCommentOpType.Type,
+			StringValue:   value,
+			UpdateAssign:  updateAssign,
+			Preferences:   commentOpPreferences{LineComment: true, HeadComment: true, FootComment: true},
+		}
+		return &token{TokenType: operationToken, Operation: op}, nil
+	}
+}
+
+func literalToken(pType tokenType, checkForPost bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		return &token{TokenType: pType, CheckForPostTraverse: checkForPost, Match: m}, nil
+	}
+}
+
+func unwrap(value string) string {
+	return value[1 : len(value)-1]
+}
+
+func numberValue() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		var numberString = string(m.Bytes)
+		var number, errParsingInt = strconv.ParseInt(numberString, 10, 64) // nolint
+		if errParsingInt != nil {
+			return nil, errParsingInt
+		}
+
+		return &token{TokenType: operationToken, Operation: createValueOperation(number, numberString)}, nil
+	}
+}
+
+func floatValue() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		var numberString = string(m.Bytes)
+		var number, errParsingInt = strconv.ParseFloat(numberString, 64) // nolint
+		if errParsingInt != nil {
+			return nil, errParsingInt
+		}
+		return &token{TokenType: operationToken, Operation: createValueOperation(number, numberString)}, nil
+	}
+}
+
+func booleanValue(val bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		return &token{TokenType: operationToken, Operation: createValueOperation(val, string(m.Bytes))}, nil
+	}
+}
+
+func stringValue(wrapped bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		value := string(m.Bytes)
+		if wrapped {
+			value = unwrap(value)
+		}
+		return &token{TokenType: operationToken, Operation: createValueOperation(value, value)}, nil
+	}
+}
+
+func getVariableOpToken() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		value := string(m.Bytes)
+
+		value = 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)
+		preferences := envOpPreferences{}
+
+		if strenv {
+			// strenv( )
+			value = value[7 : len(value)-1]
+			preferences.StringValue = true
+		} else {
+			//env( )
+			value = value[4 : len(value)-1]
+		}
+
+		envOperation := createValueOperation(value, value)
+		envOperation.OperationType = envOpType
+		envOperation.Preferences = preferences
+
+		return &token{TokenType: operationToken, Operation: envOperation}, nil
+	}
+}
+
+func nullValue() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		return &token{TokenType: operationToken, Operation: createValueOperation(nil, string(m.Bytes))}, nil
+	}
+}
+
+func selfToken() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		op := &Operation{OperationType: selfReferenceOpType}
+		return &token{TokenType: operationToken, Operation: op}, nil
+	}
+}
+
+func initLexer() (*lex.Lexer, error) {
+	lexer := lex.NewLexer()
+	lexer.Add([]byte(`\(`), literalToken(openBracket, false))
+	lexer.Add([]byte(`\)`), literalToken(closeBracket, true))
+
+	lexer.Add([]byte(`\.\[`), literalToken(traverseArrayCollect, false))
+	lexer.Add([]byte(`\.\.`), opTokenWithPrefs(recursiveDescentOpType, nil, recursiveDescentPreferences{RecurseArray: true,
+		TraversePreferences: traversePreferences{DontFollowAlias: true, IncludeMapKeys: false}}))
+
+	lexer.Add([]byte(`\.\.\.`), opTokenWithPrefs(recursiveDescentOpType, nil, recursiveDescentPreferences{RecurseArray: true,
+		TraversePreferences: traversePreferences{DontFollowAlias: true, IncludeMapKeys: true}}))
+
+	lexer.Add([]byte(`,`), opToken(unionOpType))
+	lexer.Add([]byte(`:\s*`), opToken(createMapOpType))
+	lexer.Add([]byte(`length`), opToken(lengthOpType))
+	lexer.Add([]byte(`sortKeys`), opToken(sortKeysOpType))
+	lexer.Add([]byte(`select`), opToken(selectOpType))
+	lexer.Add([]byte(`has`), opToken(hasOpType))
+	lexer.Add([]byte(`explode`), opToken(explodeOpType))
+	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))
+	lexer.Add([]byte(`di`), opToken(getDocumentIndexOpType))
+	lexer.Add([]byte(`splitDoc`), opToken(splitDocumentOpType))
+
+	lexer.Add([]byte(`join`), opToken(joinStringOpType))
+	lexer.Add([]byte(`sub`), opToken(subStringOpType))
+
+	lexer.Add([]byte(`split`), opToken(splitStringOpType))
+	lexer.Add([]byte(`keys`), opToken(keysOpType))
+
+	lexer.Add([]byte(`style`), opAssignableToken(getStyleOpType, assignStyleOpType))
+
+	lexer.Add([]byte(`tag`), opAssignableToken(getTagOpType, assignTagOpType))
+	lexer.Add([]byte(`anchor`), opAssignableToken(getAnchorOpType, assignAnchorOpType))
+	lexer.Add([]byte(`alias`), opAssignableToken(getAliasOptype, assignAliasOpType))
+	lexer.Add([]byte(`filename`), opToken(getFilenameOpType))
+	lexer.Add([]byte(`fileIndex`), opToken(getFileIndexOpType))
+	lexer.Add([]byte(`fi`), opToken(getFileIndexOpType))
+	lexer.Add([]byte(`path`), opToken(getPathOpType))
+	lexer.Add([]byte(`to_entries`), opToken(toEntriesOpType))
+	lexer.Add([]byte(`from_entries`), opToken(fromEntriesOpType))
+	lexer.Add([]byte(`with_entries`), opToken(withEntriesOpType))
+
+	lexer.Add([]byte(`lineComment`), opTokenWithPrefs(getCommentOpType, assignCommentOpType, commentOpPreferences{LineComment: true}))
+
+	lexer.Add([]byte(`headComment`), opTokenWithPrefs(getCommentOpType, assignCommentOpType, commentOpPreferences{HeadComment: true}))
+
+	lexer.Add([]byte(`footComment`), opTokenWithPrefs(getCommentOpType, assignCommentOpType, commentOpPreferences{FootComment: true}))
+
+	lexer.Add([]byte(`comments\s*=`), assignAllCommentsOp(false))
+	lexer.Add([]byte(`comments\s*\|=`), assignAllCommentsOp(true))
+
+	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))
+
+	lexer.Add([]byte(`\s*\|=\s*`), assignOpToken(true))
+
+	lexer.Add([]byte("( |\t|\n|\r)+"), skip)
+
+	lexer.Add([]byte(`\."[^ "]+"\??`), pathToken(true))
+	lexer.Add([]byte(`\.[^ \}\{\:\[\],\|\.\[\(\)=]+\??`), pathToken(false))
+	lexer.Add([]byte(`\.`), selfToken())
+
+	lexer.Add([]byte(`\|`), opToken(pipeOpType))
+
+	lexer.Add([]byte(`-?\d+(\.\d+)`), floatValue())
+	lexer.Add([]byte(`-?[1-9](\.\d+)?[Ee][-+]?\d+`), floatValue())
+	lexer.Add([]byte(`-?\d+`), numberValue())
+
+	lexer.Add([]byte(`[Tt][Rr][Uu][Ee]`), booleanValue(true))
+	lexer.Add([]byte(`[Ff][Aa][Ll][Ss][Ee]`), booleanValue(false))
+
+	lexer.Add([]byte(`[Nn][Uu][Ll][Ll]`), nullValue())
+	lexer.Add([]byte(`~`), nullValue())
+
+	lexer.Add([]byte(`"[^"]*"`), stringValue(true))
+	lexer.Add([]byte(`strenv\([^\)]+\)`), envOp(true))
+	lexer.Add([]byte(`env\([^\)]+\)`), envOp(false))
+
+	lexer.Add([]byte(`\[`), literalToken(openCollect, false))
+	lexer.Add([]byte(`\]\??`), literalToken(closeCollect, true))
+	lexer.Add([]byte(`\{`), literalToken(openCollectObject, false))
+	lexer.Add([]byte(`\}`), literalToken(closeCollectObject, true))
+	lexer.Add([]byte(`\*[\+|\?d]*`), multiplyWithPrefs())
+	lexer.Add([]byte(`\+`), opToken(addOpType))
+	lexer.Add([]byte(`\+=`), opToken(addAssignOpType))
+	lexer.Add([]byte(`\-`), opToken(subtractOpType))
+	lexer.Add([]byte(`\-=`), opToken(subtractAssignOpType))
+	lexer.Add([]byte(`\$[a-zA-Z_-0-9]+`), getVariableOpToken())
+	lexer.Add([]byte(`as`), opToken(assignVariableOpType))
+
+	err := lexer.CompileNFA()
+	if err != nil {
+		return nil, err
+	}
+	return lexer, nil
+}
+
+type expressionTokeniser interface {
+	Tokenise(expression string) ([]*token, error)
+}
+
+type expressionTokeniserImpl struct {
+	lexer *lex.Lexer
+}
+
+func newExpressionTokeniser() expressionTokeniser {
+	var lexer, err = initLexer()
+	if err != nil {
+		panic(err)
+	}
+	return &expressionTokeniserImpl{lexer}
+}
+
+func (p *expressionTokeniserImpl) Tokenise(expression string) ([]*token, error) {
+	scanner, err := p.lexer.Scanner([]byte(expression))
+
+	if err != nil {
+		return nil, fmt.Errorf("Parsing expression: %v", err)
+	}
+	var tokens []*token
+	for tok, err, eof := scanner.Next(); !eof; tok, err, eof = scanner.Next() {
+
+		if tok != nil {
+			currentToken := tok.(*token)
+			log.Debugf("Tokenising %v", currentToken.toString(true))
+			tokens = append(tokens, currentToken)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("Parsing expression: %v", err)
+		}
+	}
+	var postProcessedTokens = make([]*token, 0)
+
+	skipNextToken := false
+
+	for index := range tokens {
+		if skipNextToken {
+			skipNextToken = false
+		} else {
+			postProcessedTokens, skipNextToken = p.handleToken(tokens, index, postProcessedTokens)
+		}
+	}
+
+	return postProcessedTokens, nil
+}
+
+func (p *expressionTokeniserImpl) handleToken(tokens []*token, index int, postProcessedTokens []*token) (tokensAccum []*token, skipNextToken bool) {
+	skipNextToken = false
+	currentToken := tokens[index]
+
+	if currentToken.TokenType == traverseArrayCollect {
+		//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})
+
+		currentToken = &token{TokenType: openCollect}
+
+	}
+
+	if index != len(tokens)-1 && currentToken.AssignOperation != nil &&
+		tokens[index+1].TokenType == operationToken &&
+		tokens[index+1].Operation.OperationType == assignOpType {
+		currentToken.Operation = currentToken.AssignOperation
+		currentToken.Operation.UpdateAssign = tokens[index+1].Operation.UpdateAssign
+		skipNextToken = true
+	}
+
+	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 {
+		op := &Operation{OperationType: shortPipeOpType, Value: "PIPE"}
+		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
+	}
+	if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
+		tokens[index+1].TokenType == openCollect {
+
+		op := &Operation{OperationType: traverseArrayOpType}
+		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
+	}
+	return postProcessedTokens, skipNextToken
+}

pkg/yqlib/lib.go

@@ -1,3 +1,5 @@
+// Use the top level Evaluator or StreamEvaluator to evaluate expressions and return matches.
+//
 package yqlib
 
 import (
@@ -11,86 +13,104 @@ import (
 
 var log = logging.MustGetLogger("yq-lib")
 
-type OperationType struct {
+type operationType struct {
 	Type       string
 	NumArgs    uint // number of arguments to the op
 	Precedence uint
-	Handler    OperatorHandler
+	Handler    operatorHandler
 }
 
 // operators TODO:
-// - keys operator for controlling key metadata (particularly anchors/aliases)
 // - mergeEmpty (sets only if the document is empty, do I do that now?)
 
-var Or = &OperationType{Type: "OR", NumArgs: 2, Precedence: 20, Handler: OrOperator}
+var orOpType = &operationType{Type: "OR", NumArgs: 2, Precedence: 20, Handler: orOperator}
-var And = &OperationType{Type: "AND", NumArgs: 2, Precedence: 20, Handler: AndOperator}
+var andOpType = &operationType{Type: "AND", NumArgs: 2, Precedence: 20, Handler: andOperator}
+var reduceOpType = &operationType{Type: "REDUCE", NumArgs: 2, Precedence: 35, Handler: reduceOperator}
 
-var Union = &OperationType{Type: "UNION", NumArgs: 2, Precedence: 10, Handler: UnionOperator}
+var blockOpType = &operationType{Type: "BLOCK", Precedence: 10, NumArgs: 2, Handler: emptyOperator}
 
-var Pipe = &OperationType{Type: "PIPE", NumArgs: 2, Precedence: 30, Handler: PipeOperator}
+var unionOpType = &operationType{Type: "UNION", NumArgs: 2, Precedence: 10, Handler: unionOperator}
 
-var Assign = &OperationType{Type: "ASSIGN", NumArgs: 2, Precedence: 40, Handler: AssignUpdateOperator}
+var pipeOpType = &operationType{Type: "PIPE", NumArgs: 2, Precedence: 30, Handler: pipeOperator}
-var AddAssign = &OperationType{Type: "ADD_ASSIGN", NumArgs: 2, Precedence: 40, Handler: AddAssignOperator}
 
-var AssignAttributes = &OperationType{Type: "ASSIGN_ATTRIBUTES", NumArgs: 2, Precedence: 40, Handler: AssignAttributesOperator}
+var assignOpType = &operationType{Type: "ASSIGN", NumArgs: 2, Precedence: 40, Handler: assignUpdateOperator}
-var AssignStyle = &OperationType{Type: "ASSIGN_STYLE", NumArgs: 2, Precedence: 40, Handler: AssignStyleOperator}
+var addAssignOpType = &operationType{Type: "ADD_ASSIGN", NumArgs: 2, Precedence: 40, Handler: addAssignOperator}
-var AssignTag = &OperationType{Type: "ASSIGN_TAG", NumArgs: 2, Precedence: 40, Handler: AssignTagOperator}
+var subtractAssignOpType = &operationType{Type: "SUBTRACT_ASSIGN", NumArgs: 2, Precedence: 40, Handler: subtractAssignOperator}
-var AssignComment = &OperationType{Type: "ASSIGN_COMMENT", NumArgs: 2, Precedence: 40, Handler: AssignCommentsOperator}
-var AssignAnchor = &OperationType{Type: "ASSIGN_ANCHOR", NumArgs: 2, Precedence: 40, Handler: AssignAnchorOperator}
-var AssignAlias = &OperationType{Type: "ASSIGN_ALIAS", NumArgs: 2, Precedence: 40, Handler: AssignAliasOperator}
 
-var Multiply = &OperationType{Type: "MULTIPLY", NumArgs: 2, Precedence: 45, Handler: MultiplyOperator}
+var assignAttributesOpType = &operationType{Type: "ASSIGN_ATTRIBUTES", NumArgs: 2, Precedence: 40, Handler: assignAttributesOperator}
-var Add = &OperationType{Type: "ADD", NumArgs: 2, Precedence: 45, Handler: AddOperator}
+var assignStyleOpType = &operationType{Type: "ASSIGN_STYLE", NumArgs: 2, Precedence: 40, Handler: assignStyleOperator}
-var Alternative = &OperationType{Type: "ALTERNATIVE", NumArgs: 2, Precedence: 45, Handler: AlternativeOperator}
+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}
+var assignAliasOpType = &operationType{Type: "ASSIGN_ALIAS", NumArgs: 2, Precedence: 40, Handler: assignAliasOperator}
 
-var Equals = &OperationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: EqualsOperator}
+var multiplyOpType = &operationType{Type: "MULTIPLY", NumArgs: 2, Precedence: 42, Handler: multiplyOperator}
-var CreateMap = &OperationType{Type: "CREATE_MAP", NumArgs: 2, Precedence: 40, Handler: CreateMapOperator}
+var addOpType = &operationType{Type: "ADD", NumArgs: 2, Precedence: 42, Handler: addOperator}
+var subtractOpType = &operationType{Type: "SUBTRACT", NumArgs: 2, Precedence: 42, Handler: subtractOperator}
+var alternativeOpType = &operationType{Type: "ALTERNATIVE", NumArgs: 2, Precedence: 42, Handler: alternativeOperator}
 
-var ShortPipe = &OperationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence: 45, Handler: PipeOperator}
+var equalsOpType = &operationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: equalsOperator}
+var notEqualsOpType = &operationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: notEqualsOperator}
 
-var Length = &OperationType{Type: "LENGTH", NumArgs: 0, Precedence: 50, Handler: LengthOperator}
+//createmap needs to be above union, as we use union to build the components of the objects
-var Collect = &OperationType{Type: "COLLECT", NumArgs: 0, Precedence: 50, Handler: CollectOperator}
+var createMapOpType = &operationType{Type: "CREATE_MAP", NumArgs: 2, Precedence: 15, Handler: createMapOperator}
-var GetStyle = &OperationType{Type: "GET_STYLE", NumArgs: 0, Precedence: 50, Handler: GetStyleOperator}
-var GetTag = &OperationType{Type: "GET_TAG", NumArgs: 0, Precedence: 50, Handler: GetTagOperator}
-var GetComment = &OperationType{Type: "GET_COMMENT", NumArgs: 0, Precedence: 50, Handler: GetCommentsOperator}
-var GetAnchor = &OperationType{Type: "GET_ANCHOR", NumArgs: 0, Precedence: 50, Handler: GetAnchorOperator}
-var GetAlias = &OperationType{Type: "GET_ALIAS", NumArgs: 0, Precedence: 50, Handler: GetAliasOperator}
-var GetDocumentIndex = &OperationType{Type: "GET_DOCUMENT_INDEX", NumArgs: 0, Precedence: 50, Handler: GetDocumentIndexOperator}
-var GetFilename = &OperationType{Type: "GET_FILENAME", NumArgs: 0, Precedence: 50, Handler: GetFilenameOperator}
-var GetFileIndex = &OperationType{Type: "GET_FILE_INDEX", NumArgs: 0, Precedence: 50, Handler: GetFileIndexOperator}
-var GetPath = &OperationType{Type: "GET_PATH", NumArgs: 0, Precedence: 50, Handler: GetPathOperator}
 
-var Explode = &OperationType{Type: "EXPLODE", NumArgs: 1, Precedence: 50, Handler: ExplodeOperator}
+var shortPipeOpType = &operationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence: 45, Handler: pipeOperator}
-var SortKeys = &OperationType{Type: "SORT_KEYS", NumArgs: 1, Precedence: 50, Handler: SortKeysOperator}
 
-var CollectObject = &OperationType{Type: "COLLECT_OBJECT", NumArgs: 0, Precedence: 50, Handler: CollectObjectOperator}
+var lengthOpType = &operationType{Type: "LENGTH", NumArgs: 0, Precedence: 50, Handler: lengthOperator}
-var TraversePath = &OperationType{Type: "TRAVERSE_PATH", NumArgs: 0, Precedence: 50, Handler: TraversePathOperator}
+var collectOpType = &operationType{Type: "COLLECT", NumArgs: 0, Precedence: 50, Handler: collectOperator}
-var TraverseArray = &OperationType{Type: "TRAVERSE_ARRAY", NumArgs: 1, Precedence: 50, Handler: TraverseArrayOperator}
 
-var DocumentFilter = &OperationType{Type: "DOCUMENT_FILTER", NumArgs: 0, Precedence: 50, Handler: TraversePathOperator}
+var toEntriesOpType = &operationType{Type: "TO_ENTRIES", NumArgs: 0, Precedence: 50, Handler: toEntriesOperator}
-var SelfReference = &OperationType{Type: "SELF", NumArgs: 0, Precedence: 50, Handler: SelfOperator}
+var fromEntriesOpType = &operationType{Type: "FROM_ENTRIES", NumArgs: 0, Precedence: 50, Handler: fromEntriesOperator}
-var ValueOp = &OperationType{Type: "VALUE", NumArgs: 0, Precedence: 50, Handler: ValueOperator}
+var withEntriesOpType = &operationType{Type: "WITH_ENTRIES", NumArgs: 1, Precedence: 50, Handler: withEntriesOperator}
-var EnvOp = &OperationType{Type: "ENV", NumArgs: 0, Precedence: 50, Handler: EnvOperator}
-var Not = &OperationType{Type: "NOT", NumArgs: 0, Precedence: 50, Handler: NotOperator}
-var Empty = &OperationType{Type: "EMPTY", NumArgs: 50, Handler: EmptyOperator}
 
-var RecursiveDescent = &OperationType{Type: "RECURSIVE_DESCENT", NumArgs: 0, Precedence: 50, Handler: RecursiveDescentOperator}
+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}
+var getAnchorOpType = &operationType{Type: "GET_ANCHOR", NumArgs: 0, Precedence: 50, Handler: getAnchorOperator}
+var getAliasOptype = &operationType{Type: "GET_ALIAS", NumArgs: 0, Precedence: 50, Handler: getAliasOperator}
+var getDocumentIndexOpType = &operationType{Type: "GET_DOCUMENT_INDEX", NumArgs: 0, Precedence: 50, Handler: getDocumentIndexOperator}
+var getFilenameOpType = &operationType{Type: "GET_FILENAME", NumArgs: 0, Precedence: 50, Handler: getFilenameOperator}
+var getFileIndexOpType = &operationType{Type: "GET_FILE_INDEX", NumArgs: 0, Precedence: 50, Handler: getFileIndexOperator}
+var getPathOpType = &operationType{Type: "GET_PATH", NumArgs: 0, Precedence: 50, Handler: getPathOperator}
 
-var Select = &OperationType{Type: "SELECT", NumArgs: 1, Precedence: 50, Handler: SelectOperator}
+var explodeOpType = &operationType{Type: "EXPLODE", NumArgs: 1, Precedence: 50, Handler: explodeOperator}
-var Has = &OperationType{Type: "HAS", NumArgs: 1, Precedence: 50, Handler: HasOperator}
+var sortKeysOpType = &operationType{Type: "SORT_KEYS", NumArgs: 1, Precedence: 50, Handler: sortKeysOperator}
-var DeleteChild = &OperationType{Type: "DELETE", NumArgs: 1, Precedence: 40, Handler: DeleteChildOperator}
+var joinStringOpType = &operationType{Type: "JOIN", NumArgs: 1, Precedence: 50, Handler: joinStringOperator}
-var DeleteImmediateChild = &OperationType{Type: "DELETE_IMMEDIATE_CHILD", NumArgs: 1, Precedence: 40, Handler: DeleteImmediateChildOperator}
+var subStringOpType = &operationType{Type: "SUBSTR", NumArgs: 1, Precedence: 50, Handler: substituteStringOperator}
+var splitStringOpType = &operationType{Type: "SPLIT", NumArgs: 1, Precedence: 50, Handler: splitStringOperator}
+
+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 selfReferenceOpType = &operationType{Type: "SELF", NumArgs: 0, Precedence: 55, 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 recursiveDescentOpType = &operationType{Type: "RECURSIVE_DESCENT", NumArgs: 0, Precedence: 50, Handler: recursiveDescentOperator}
+
+var selectOpType = &operationType{Type: "SELECT", NumArgs: 1, Precedence: 50, Handler: selectOperator}
+var hasOpType = &operationType{Type: "HAS", NumArgs: 1, Precedence: 50, Handler: hasOperator}
+var deleteChildOpType = &operationType{Type: "DELETE", NumArgs: 1, Precedence: 40, Handler: deleteChildOperator}
 
 type Operation struct {
-	OperationType *OperationType
+	OperationType *operationType
 	Value         interface{}
 	StringValue   string
 	CandidateNode *CandidateNode // used for Value Path elements
 	Preferences   interface{}
-	UpdateAssign  bool // used for assign ops, when true it means we evaluate the rhs given the lhs (instead of matching nodes)
+	UpdateAssign  bool // used for assign ops, when true it means we evaluate the rhs given the lhs
 }
 
-func CreateValueOperation(value interface{}, stringValue string) *Operation {
+func createValueOperation(value interface{}, stringValue string) *Operation {
 	var node yaml.Node = yaml.Node{Kind: yaml.ScalarNode}
 	node.Value = stringValue
 
@@ -108,7 +128,7 @@ func CreateValueOperation(value interface{}, stringValue string) *Operation {
 	}
 
 	return &Operation{
-		OperationType: ValueOp,
+		OperationType: valueOpType,
 		Value:         value,
 		StringValue:   stringValue,
 		CandidateNode: &CandidateNode{Node: &node},
@@ -117,13 +137,11 @@ func CreateValueOperation(value interface{}, stringValue string) *Operation {
 
 // debugging purposes only
 func (p *Operation) toString() string {
-	if p.OperationType == TraversePath {
+	if p.OperationType == traversePathOpType {
 		return fmt.Sprintf("%v", p.Value)
-	} else if p.OperationType == DocumentFilter {
+	} else if p.OperationType == selfReferenceOpType {
-		return fmt.Sprintf("d%v", p.Value)
-	} else if p.OperationType == SelfReference {
 		return "SELF"
-	} else if p.OperationType == ValueOp {
+	} else if p.OperationType == valueOpType {
 		return fmt.Sprintf("%v (%T)", p.Value, p.Value)
 	} else {
 		return fmt.Sprintf("%v", p.OperationType.Type)

pkg/yqlib/matchKeyString.go

@@ -1,6 +1,6 @@
 package yqlib
 
-func Match(name string, pattern string) (matched bool) {
+func matchKey(name string, pattern string) (matched bool) {
 	if pattern == "" {
 		return name == pattern
 	}

pkg/yqlib/operator_add.go

@@ -3,23 +3,23 @@ package yqlib
 import (
 	"fmt"
 
-	"container/list"
+	"strconv"
 
 	yaml "gopkg.in/yaml.v3"
 )
 
-func createSelfAddOp(rhs *PathTreeNode) *PathTreeNode {
+func createAddOp(lhs *ExpressionNode, rhs *ExpressionNode) *ExpressionNode {
-	return &PathTreeNode{Operation: &Operation{OperationType: Add},
+	return &ExpressionNode{Operation: &Operation{OperationType: addOpType},
-		Lhs: &PathTreeNode{Operation: &Operation{OperationType: SelfReference}},
+		Lhs: lhs,
 		Rhs: rhs}
 }
 
-func AddAssignOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func addAssignOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	assignmentOp := &Operation{OperationType: Assign}
+	assignmentOp := &Operation{OperationType: assignOpType}
 	assignmentOp.UpdateAssign = true
-
+	selfExpression := &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
-	assignmentOpNode := &PathTreeNode{Operation: assignmentOp, Lhs: pathNode.Lhs, Rhs: createSelfAddOp(pathNode.Rhs)}
+	assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: expressionNode.Lhs, Rhs: createAddOp(selfExpression, expressionNode.Rhs)}
-	return d.GetMatchingNodes(matchingNodes, assignmentOpNode)
+	return d.GetMatchingNodes(context, assignmentOpNode)
 }
 
 func toNodes(candidate *CandidateNode) []*yaml.Node {
@@ -36,24 +36,24 @@ func toNodes(candidate *CandidateNode) []*yaml.Node {
 
 }
 
-func AddOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func addOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("Add operator")
 
-	return crossFunction(d, matchingNodes, pathNode, add)
+	return crossFunction(d, context, expressionNode, add, false)
 }
 
-func add(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func add(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	lhs.Node = UnwrapDoc(lhs.Node)
+	lhs.Node = unwrapDoc(lhs.Node)
-	rhs.Node = UnwrapDoc(rhs.Node)
+	rhs.Node = unwrapDoc(rhs.Node)
 
-	target := &CandidateNode{
-		Path:     lhs.Path,
-		Document: lhs.Document,
-		Filename: lhs.Filename,
-		Node:     &yaml.Node{},
-	}
 	lhsNode := lhs.Node
 
+	if lhsNode.Tag == "!!null" {
+		return lhs.CreateChild(nil, rhs.Node), nil
+	}
+
+	target := lhs.CreateChild(nil, &yaml.Node{})
+
 	switch lhsNode.Kind {
 	case yaml.MappingNode:
 		return nil, fmt.Errorf("Maps not yet supported for addition")
@@ -63,7 +63,48 @@ func add(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*Candida
 		target.Node.Tag = "!!seq"
 		target.Node.Content = append(lhsNode.Content, toNodes(rhs)...)
 	case yaml.ScalarNode:
-		return nil, fmt.Errorf("Scalars not yet supported for addition")
+		if rhs.Node.Kind != yaml.ScalarNode {
+			return nil, fmt.Errorf("%v (%v) cannot be added to a %v", rhs.Node.Tag, rhs.Path, lhsNode.Tag)
+		}
+		target.Node.Kind = yaml.ScalarNode
+		target.Node.Style = lhsNode.Style
+		return addScalars(target, lhsNode, rhs.Node)
+	}
+
+	return target, nil
+}
+
+func addScalars(target *CandidateNode, lhs *yaml.Node, rhs *yaml.Node) (*CandidateNode, error) {
+
+	if lhs.Tag == "!!str" {
+		target.Node.Tag = "!!str"
+		target.Node.Value = lhs.Value + rhs.Value
+	} else if lhs.Tag == "!!int" && rhs.Tag == "!!int" {
+		lhsNum, err := strconv.Atoi(lhs.Value)
+		if err != nil {
+			return nil, err
+		}
+		rhsNum, err := strconv.Atoi(rhs.Value)
+		if err != nil {
+			return nil, err
+		}
+		sum := lhsNum + rhsNum
+		target.Node.Tag = "!!int"
+		target.Node.Value = fmt.Sprintf("%v", sum)
+	} else if (lhs.Tag == "!!int" || lhs.Tag == "!!float") && (rhs.Tag == "!!int" || rhs.Tag == "!!float") {
+		lhsNum, err := strconv.ParseFloat(lhs.Value, 64)
+		if err != nil {
+			return nil, err
+		}
+		rhsNum, err := strconv.ParseFloat(rhs.Value, 64)
+		if err != nil {
+			return nil, err
+		}
+		sum := lhsNum + rhsNum
+		target.Node.Tag = "!!float"
+		target.Node.Value = fmt.Sprintf("%v", sum)
+	} else {
+		return nil, fmt.Errorf("%v cannot be added to %v", lhs.Tag, rhs.Tag)
 	}
 
 	return target, nil

pkg/yqlib/operator_add_test.go

@@ -5,6 +5,15 @@ import (
 )
 
 var addOperatorScenarios = []expressionScenario{
+	{
+		skipDoc:    true,
+		document:   `[{a: foo, b: bar}, {a: 1, b: 2}]`,
+		expression: ".[] | .a + .b",
+		expected: []string{
+			"D0, P[0 a], (!!str)::foobar\n",
+			"D0, P[1 a], (!!int)::3\n",
+		},
+	},
 	{
 		description: "Concatenate and assign arrays",
 		document:    `{a: {val: thing, b: [cat,dog]}}`,
@@ -38,11 +47,11 @@ var addOperatorScenarios = []expressionScenario{
 		},
 	},
 	{
-		description: "Add object to array",
+		description: "Add new object to array",
-		document:    `{a: [1,2], c: {cat: meow}}`,
+		document:    `a: [{dog: woof}]`,
-		expression:  `.a + .c`,
+		expression:  `.a + {"cat": "meow"}`,
 		expected: []string{
-			"D0, P[a], (!!seq)::[1, 2, {cat: meow}]\n",
+			"D0, P[a], (!!seq)::[{dog: woof}, {cat: meow}]\n",
 		},
 	},
 	{
@@ -54,13 +63,63 @@ var addOperatorScenarios = []expressionScenario{
 		},
 	},
 	{
-		description: "Update array (append)",
+		description: "Append to array",
 		document:    `{a: [1,2], b: [3,4]}`,
 		expression:  `.a = .a + .b`,
 		expected: []string{
 			"D0, P[], (doc)::{a: [1, 2, 3, 4], b: [3, 4]}\n",
 		},
 	},
+	{
+		description: "Relative append",
+		document:    `a: { a1: {b: [cat]}, a2: {b: [dog]}, a3: {} }`,
+		expression:  `.a[].b += ["mouse"]`,
+		expected: []string{
+			"D0, P[], (doc)::a: {a1: {b: [cat, mouse]}, a2: {b: [dog, mouse]}, a3: {b: [mouse]}}\n",
+		},
+	},
+	{
+		description: "String concatenation",
+		document:    `{a: cat, b: meow}`,
+		expression:  `.a = .a + .b`,
+		expected: []string{
+			"D0, P[], (doc)::{a: catmeow, b: meow}\n",
+		},
+	},
+	{
+		description:    "Number addition - float",
+		subdescription: "If the lhs or rhs are floats then the expression will be calculated with floats.",
+		document:       `{a: 3, b: 4.9}`,
+		expression:     `.a = .a + .b`,
+		expected: []string{
+			"D0, P[], (doc)::{a: 7.9, b: 4.9}\n",
+		},
+	},
+	{
+		description:    "Number addition - int",
+		subdescription: "If both the lhs and rhs are ints then the expression will be calculated with ints.",
+		document:       `{a: 3, b: 4}`,
+		expression:     `.a = .a + .b`,
+		expected: []string{
+			"D0, P[], (doc)::{a: 7, b: 4}\n",
+		},
+	},
+	{
+		description: "Increment numbers",
+		document:    `{a: 3, b: 5}`,
+		expression:  `.[] += 1`,
+		expected: []string{
+			"D0, P[], (doc)::{a: 4, b: 6}\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,20 +1,16 @@
 package yqlib
 
-import (
+func alternativeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	"container/list"
-)
-
-// corssFunction no matches
-// can boolean use crossfunction
-
-func AlternativeOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- alternative")
-	return crossFunction(d, matchingNodes, pathNode, alternativeFunc)
+	return crossFunction(d, context, expressionNode, alternativeFunc, true)
 }
 
-func alternativeFunc(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func alternativeFunc(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	lhs.Node = UnwrapDoc(lhs.Node)
+	if lhs == nil {
-	rhs.Node = UnwrapDoc(rhs.Node)
+		return rhs, nil
+	}
+	lhs.Node = unwrapDoc(lhs.Node)
+	rhs.Node = unwrapDoc(rhs.Node)
 	log.Debugf("Alternative LHS: %v", lhs.Node.Tag)
 	log.Debugf("-          RHS: %v", rhs.Node.Tag)
 

pkg/yqlib/operator_alternative_test.go

@@ -13,6 +13,14 @@ var alternativeOperatorScenarios = []expressionScenario{
 			"D0, P[a], (!!str)::bridge\n",
 		},
 	},
+	{
+		expression: `select(tag == "seq") // "cat"`,
+		skipDoc:    true,
+		document:   `a: frog`,
+		expected: []string{
+			"D0, P[], (!!str)::cat\n",
+		},
+	},
 	{
 		description: "LHS is not defined",
 		expression:  `.a // "hello"`,

pkg/yqlib/operator_anchors_aliases.go

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

pkg/yqlib/operator_anchors_aliases_test.go

@@ -4,7 +4,36 @@ import (
 	"testing"
 )
 
+var specDocument = `- &CENTER { x: 1, y: 2 }
+- &LEFT { x: 0, y: 2 }
+- &BIG { r: 10 }
+- &SMALL { r: 1 }
+`
+
+var expectedSpecResult = "D0, P[4], (!!map)::x: 1\ny: 2\nr: 10\n"
+
 var anchorOperatorScenarios = []expressionScenario{
+	{
+		description:    "Merge one map",
+		subdescription: "see https://yaml.org/type/merge.html",
+		document:       specDocument + "- << : *CENTER\n  r: 10\n",
+		expression:     ".[4] | explode(.)",
+		expected:       []string{expectedSpecResult},
+	},
+	{
+		description:    "Merge multiple maps",
+		subdescription: "see https://yaml.org/type/merge.html",
+		document:       specDocument + "- << : [ *CENTER, *BIG ]\n",
+		expression:     ".[4] | explode(.)",
+		expected:       []string{"D0, P[4], (!!map)::r: 10\nx: 1\ny: 2\n"},
+	},
+	{
+		description:    "Override",
+		subdescription: "see https://yaml.org/type/merge.html",
+		document:       specDocument + "- << : [ *BIG, *LEFT, *SMALL ]\n  x: 1\n",
+		expression:     ".[4] | explode(.)",
+		expected:       []string{"D0, P[4], (!!map)::r: 10\nx: 1\ny: 2\n"},
+	},
 	{
 		description: "Get anchor",
 		document:    `a: &billyBob cat`,
@@ -91,9 +120,9 @@ bar:
     c: bar_c
 foobarList:
     b: bar_b
-    a: foo_a
+    thing: foo_thing
-    thing: bar_thing
     c: foobarList_c
+    a: foo_a
 foobar:
     c: foo_c
     a: foo_a
@@ -106,7 +135,7 @@ foobar:
 		expression: `.foo* | explode(.) | (. style="flow")`,
 		expected: []string{
 			"D0, P[foo], (!!map)::{a: foo_a, thing: foo_thing, c: foo_c}\n",
-			"D0, P[foobarList], (!!map)::{b: bar_b, a: foo_a, thing: bar_thing, c: foobarList_c}\n",
+			"D0, P[foobarList], (!!map)::{b: bar_b, thing: foo_thing, c: foobarList_c, a: foo_a}\n",
 			"D0, P[foobar], (!!map)::{c: foo_c, a: foo_a, thing: foobar_thing}\n",
 		},
 	},
@@ -116,7 +145,7 @@ foobar:
 		expression: `.foo* | explode(explode(.)) | (. style="flow")`,
 		expected: []string{
 			"D0, P[foo], (!!map)::{a: foo_a, thing: foo_thing, c: foo_c}\n",
-			"D0, P[foobarList], (!!map)::{b: bar_b, a: foo_a, thing: bar_thing, c: foobarList_c}\n",
+			"D0, P[foobarList], (!!map)::{b: bar_b, thing: foo_thing, c: foobarList_c, a: foo_a}\n",
 			"D0, P[foobar], (!!map)::{c: foo_c, a: foo_a, thing: foobar_thing}\n",
 		},
 	},

pkg/yqlib/operator_assign.go

@@ -1,66 +1,61 @@
 package yqlib
 
-import "container/list"
+func assignUpdateOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-
+	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
-func AssignUpdateOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
-	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
 	if err != nil {
-		return nil, err
+		return Context{}, err
 	}
-	var rhs *list.List
+	var rhs Context
-	if !pathNode.Operation.UpdateAssign {
+	if !expressionNode.Operation.UpdateAssign {
-		rhs, err = d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+		rhs, err = d.GetMatchingNodes(context, expressionNode.Rhs)
 	}
 
-	for el := lhs.Front(); el != nil; el = el.Next() {
+	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
-		if pathNode.Operation.UpdateAssign {
+		if expressionNode.Operation.UpdateAssign {
-			rhs, err = d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
+			rhs, err = d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs)
 		}
 
 		if err != nil {
-			return nil, err
+			return Context{}, err
 		}
 
 		// grab the first value
-		first := rhs.Front()
+		first := rhs.MatchingNodes.Front()
 
 		if first != nil {
 			rhsCandidate := first.Value.(*CandidateNode)
-			rhsCandidate.Node = UnwrapDoc(rhsCandidate.Node)
+			rhsCandidate.Node = unwrapDoc(rhsCandidate.Node)
 			candidate.UpdateFrom(rhsCandidate)
 		}
 	}
-	// // if there was nothing given, perhaps we are creating a new yaml doc
+
-	// if matchingNodes.Len() == 0 {
+	return context, nil
-	// 	log.Debug("started with nothing, returning LHS, %v", lhs.Len())
-	// 	return lhs, nil
-	// }
-	return matchingNodes, nil
 }
 
 // does not update content or values
-func AssignAttributesOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func assignAttributesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
+	log.Debug("getting lhs matching nodes for update")
+	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
 	if err != nil {
-		return nil, err
+		return Context{}, err
 	}
-	for el := lhs.Front(); el != nil; el = el.Next() {
+	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
-		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
+		rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs)
 
 		if err != nil {
-			return nil, err
+			return Context{}, err
 		}
 
 		// grab the first value
-		first := rhs.Front()
+		first := rhs.MatchingNodes.Front()
 
 		if first != nil {
 			candidate.UpdateAttributesFrom(first.Value.(*CandidateNode))
 		}
 	}
-	return matchingNodes, nil
+	return context, nil
 }

pkg/yqlib/operator_assign_test.go

@@ -143,5 +143,5 @@ func TestAssignOperatorScenarios(t *testing.T) {
 	for _, tt := range assignOperatorScenarios {
 		testScenario(t, &tt)
 	}
-	documentScenarios(t, "Assign", assignOperatorScenarios)
+	documentScenarios(t, "Assign (Update)", assignOperatorScenarios)
 }

pkg/yqlib/operator_booleans.go

@@ -7,7 +7,7 @@ import (
 )
 
 func isTruthy(c *CandidateNode) (bool, error) {
-	node := UnwrapDoc(c.Node)
+	node := unwrapDoc(c.Node)
 	value := true
 
 	if node.Tag == "!!null" {
@@ -25,54 +25,72 @@ func isTruthy(c *CandidateNode) (bool, error) {
 
 type boolOp func(bool, bool) bool
 
-func performBoolOp(op boolOp) func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func performBoolOp(op boolOp) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	return func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	return func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-		lhs.Node = UnwrapDoc(lhs.Node)
+		owner := lhs
-		rhs.Node = UnwrapDoc(rhs.Node)
 
-		lhsTrue, errDecoding := isTruthy(lhs)
+		if lhs == nil && rhs == nil {
-		if errDecoding != nil {
+			owner = &CandidateNode{}
-			return nil, errDecoding
+		} else if lhs == nil {
+			owner = rhs
 		}
 
-		rhsTrue, errDecoding := isTruthy(rhs)
+		var errDecoding error
-		if errDecoding != nil {
+		lhsTrue := false
-			return nil, errDecoding
+		if lhs != nil {
-		}
+			lhs.Node = unwrapDoc(lhs.Node)
+			lhsTrue, errDecoding = isTruthy(lhs)
 
-		return createBooleanCandidate(lhs, op(lhsTrue, rhsTrue)), nil
+			if errDecoding != nil {
+				return nil, errDecoding
+			}
+		}
+		log.Debugf("-- lhsTrue", lhsTrue)
+
+		rhsTrue := false
+		if rhs != nil {
+			rhs.Node = unwrapDoc(rhs.Node)
+			rhsTrue, errDecoding = isTruthy(rhs)
+			if errDecoding != nil {
+				return nil, errDecoding
+			}
+		}
+		log.Debugf("-- rhsTrue", rhsTrue)
+
+		return createBooleanCandidate(owner, op(lhsTrue, rhsTrue)), nil
 	}
 }
 
-func OrOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func orOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("-- orOp")
-	return crossFunction(d, matchingNodes, pathNode, performBoolOp(
+	return crossFunction(d, context, expressionNode, performBoolOp(
 		func(b1 bool, b2 bool) bool {
+			log.Debugf("-- peformingOrOp with %v and %v", b1, b2)
 			return b1 || b2
-		}))
+		}), true)
 }
 
-func AndOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func andOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("-- AndOp")
-	return crossFunction(d, matchingNodes, pathNode, performBoolOp(
+	return crossFunction(d, context, expressionNode, performBoolOp(
 		func(b1 bool, b2 bool) bool {
 			return b1 && b2
-		}))
+		}), true)
 }
 
-func NotOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func notOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("-- notOperation")
 	var results = list.New()
 
-	for el := matchMap.Front(); el != nil; el = el.Next() {
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debug("notOperation checking %v", candidate)
 		truthy, errDecoding := isTruthy(candidate)
 		if errDecoding != nil {
-			return nil, errDecoding
+			return Context{}, errDecoding
 		}
 		result := createBooleanCandidate(candidate, !truthy)
 		results.PushBack(result)
 	}
-	return results, nil
+	return context.ChildContext(results), nil
 }

pkg/yqlib/operator_booleans_test.go

@@ -12,6 +12,22 @@ var booleanOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!bool)::true\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   "b: hi",
+		expression: `select(.a or .b)`,
+		expected: []string{
+			"D0, P[], (doc)::b: hi\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   "b: hi",
+		expression: `select((.a and .b) | not)`,
+		expected: []string{
+			"D0, P[], (doc)::b: hi\n",
+		},
+	},
 	{
 		description: "AND example",
 		expression:  `true and false`,

pkg/yqlib/operator_collect.go

@@ -6,34 +6,35 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func CollectOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func collectOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("-- collectOperation")
 
-	if matchMap.Len() == 0 {
+	if context.MatchingNodes.Len() == 0 {
 		node := &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq", Value: "[]"}
 		candidate := &CandidateNode{Node: node}
-		return nodeToMap(candidate), nil
+		return context.SingleChildContext(candidate), nil
 	}
 
 	var results = list.New()
 
 	node := &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq"}
-
+	var collectC *CandidateNode
-	var document uint = 0
+	if context.MatchingNodes.Front() != nil {
-	var path []interface{}
+		collectC = context.MatchingNodes.Front().Value.(*CandidateNode).CreateChild(nil, node)
-
+		if len(collectC.Path) > 0 {
-	for el := matchMap.Front(); el != nil; el = el.Next() {
+			collectC.Path = collectC.Path[:len(collectC.Path)-1]
-		candidate := el.Value.(*CandidateNode)
-		log.Debugf("Collecting %v", NodeToString(candidate))
-		if path == nil && candidate.Path != nil && len(candidate.Path) > 1 {
-			path = candidate.Path[:len(candidate.Path)-1]
-			document = candidate.Document
 		}
-		node.Content = append(node.Content, candidate.Node)
+	} else {
+		collectC = &CandidateNode{Node: node}
+	}
+
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		log.Debugf("Collecting %v", NodeToString(candidate))
+		node.Content = append(node.Content, unwrapDoc(candidate.Node))
 	}
 
-	collectC := &CandidateNode{Node: node, Document: document, Path: path}
 	results.PushBack(collectC)
 
-	return results, nil
+	return context.ChildContext(results), nil
 }

pkg/yqlib/operator_collect_object.go

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

pkg/yqlib/operator_collect_test.go

@@ -13,6 +13,15 @@ var collectOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!seq)::[]\n",
 		},
 	},
+	{
+		skipDoc:  true,
+		document: "{a: apple}\n---\n{b: frog}",
+
+		expression: `[.]`,
+		expected: []string{
+			"D0, P[], (!!seq)::- {a: apple}\n- {b: frog}\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   ``,

pkg/yqlib/operator_comments.go

@@ -7,47 +7,47 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-type CommentOpPreferences struct {
+type commentOpPreferences struct {
 	LineComment bool
 	HeadComment bool
 	FootComment bool
 }
 
-func AssignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func assignCommentsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 
 	log.Debugf("AssignComments operator!")
 
-	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
+	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
 
 	if err != nil {
-		return nil, err
+		return Context{}, err
 	}
 
-	preferences := pathNode.Operation.Preferences.(*CommentOpPreferences)
+	preferences := expressionNode.Operation.Preferences.(commentOpPreferences)
 
 	comment := ""
-	if !pathNode.Operation.UpdateAssign {
+	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+		rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
 		if err != nil {
-			return nil, err
+			return Context{}, err
 		}
 
-		if rhs.Front() != nil {
+		if rhs.MatchingNodes.Front() != nil {
-			comment = rhs.Front().Value.(*CandidateNode).Node.Value
+			comment = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
 		}
 	}
 
-	for el := lhs.Front(); el != nil; el = el.Next() {
+	for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
-		if pathNode.Operation.UpdateAssign {
+		if expressionNode.Operation.UpdateAssign {
-			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
+			rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.Rhs)
 			if err != nil {
-				return nil, err
+				return Context{}, err
 			}
 
-			if rhs.Front() != nil {
+			if rhs.MatchingNodes.Front() != nil {
-				comment = rhs.Front().Value.(*CandidateNode).Node.Value
+				comment = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Value
 			}
 		}
 
@@ -63,15 +63,15 @@ func AssignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, path
 		}
 
 	}
-	return matchingNodes, nil
+	return context, nil
 }
 
-func GetCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func getCommentsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	preferences := pathNode.Operation.Preferences.(*CommentOpPreferences)
+	preferences := expressionNode.Operation.Preferences.(commentOpPreferences)
 	log.Debugf("GetComments operator!")
 	var results = list.New()
 
-	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		comment := ""
 		if preferences.LineComment {
@@ -84,8 +84,8 @@ func GetCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNod
 		comment = strings.Replace(comment, "# ", "", 1)
 
 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: comment, Tag: "!!str"}
-		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		result := candidate.CreateChild(nil, node)
-		results.PushBack(lengthCand)
+		results.PushBack(result)
 	}
-	return results, nil
+	return context.ChildContext(results), nil
 }

pkg/yqlib/operator_comments_test.go

@@ -71,11 +71,12 @@ var commentOperatorScenarios = []expressionScenario{
 		},
 	},
 	{
-		description: "Remove all comments",
+		description:    "Remove (strip) all comments",
-		document:    "# hi\n\na: cat # comment\n\n# great\n",
+		subdescription: "Note the use of `...` to ensure key nodes are included.",
-		expression:  `.. comments=""`,
+		document:       "# hi\n\na: cat # comment\n\n# great\n\nb: # key comment",
+		expression:     `... comments=""`,
 		expected: []string{
-			"D0, P[], (!!map)::a: cat\n",
+			"D0, P[], (!!map)::a: cat\nb:\n",
 		},
 	},
 	{

pkg/yqlib/operator_create_map.go

@@ -6,7 +6,7 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-func CreateMapOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func createMapOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("-- createMapOperation")
 
 	//each matchingNodes entry should turn into a sequence of keys to create.
@@ -18,29 +18,29 @@ func CreateMapOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode
 
 	sequences := list.New()
 
-	if matchingNodes.Len() > 0 {
+	if context.MatchingNodes.Len() > 0 {
 
-		for matchingNodeEl := matchingNodes.Front(); matchingNodeEl != nil; matchingNodeEl = matchingNodeEl.Next() {
+		for matchingNodeEl := context.MatchingNodes.Front(); matchingNodeEl != nil; matchingNodeEl = matchingNodeEl.Next() {
 			matchingNode := matchingNodeEl.Value.(*CandidateNode)
-			sequenceNode, err := sequenceFor(d, matchingNode, pathNode)
+			sequenceNode, err := sequenceFor(d, context, matchingNode, expressionNode)
 			if err != nil {
-				return nil, err
+				return Context{}, err
 			}
 			sequences.PushBack(sequenceNode)
 		}
 	} else {
-		sequenceNode, err := sequenceFor(d, nil, pathNode)
+		sequenceNode, err := sequenceFor(d, context, nil, expressionNode)
 		if err != nil {
-			return nil, err
+			return Context{}, err
 		}
 		sequences.PushBack(sequenceNode)
 	}
 
-	return nodeToMap(&CandidateNode{Node: listToNodeSeq(sequences), Document: document, Path: path}), nil
+	return context.SingleChildContext(&CandidateNode{Node: listToNodeSeq(sequences), Document: document, Path: path}), nil
 
 }
 
-func sequenceFor(d *dataTreeNavigator, matchingNode *CandidateNode, pathNode *PathTreeNode) (*CandidateNode, error) {
+func sequenceFor(d *dataTreeNavigator, context Context, matchingNode *CandidateNode, expressionNode *ExpressionNode) (*CandidateNode, error) {
 	var path []interface{}
 	var document uint = 0
 	var matches = list.New()
@@ -48,26 +48,26 @@ func sequenceFor(d *dataTreeNavigator, matchingNode *CandidateNode, pathNode *Pa
 	if matchingNode != nil {
 		path = matchingNode.Path
 		document = matchingNode.Document
-		matches = nodeToMap(matchingNode)
+		matches.PushBack(matchingNode)
 	}
 
-	mapPairs, err := crossFunction(d, matches, pathNode,
+	mapPairs, err := crossFunction(d, context.ChildContext(matches), expressionNode,
-		func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+		func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
 			node := yaml.Node{Kind: yaml.MappingNode, Tag: "!!map"}
 			log.Debugf("LHS:", NodeToString(lhs))
 			log.Debugf("RHS:", NodeToString(rhs))
 			node.Content = []*yaml.Node{
-				UnwrapDoc(lhs.Node),
+				unwrapDoc(lhs.Node),
-				UnwrapDoc(rhs.Node),
+				unwrapDoc(rhs.Node),
 			}
 
 			return &CandidateNode{Node: &node, Document: document, Path: path}, nil
-		})
+		}, false)
 
 	if err != nil {
 		return nil, err
 	}
-	innerList := listToNodeSeq(mapPairs)
+	innerList := listToNodeSeq(mapPairs.MatchingNodes)
 	innerList.Style = yaml.FlowStyle
 	return &CandidateNode{Node: innerList, Document: document, Path: path}, nil
 }

pkg/yqlib/operator_delete.go

@@ -1,70 +1,47 @@
 package yqlib
 
 import (
-	"container/list"
 	"fmt"
 
 	yaml "gopkg.in/yaml.v3"
 )
 
-func DeleteChildOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func deleteChildOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-
+	contextToUse := context.Clone()
-	nodesToDelete, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	contextToUse.DontAutoCreate = true
+	nodesToDelete, err := d.GetMatchingNodes(contextToUse, expressionNode.Rhs)
 
 	if err != nil {
-		return nil, err
+		return Context{}, err
 	}
-
+	//need to iterate backwards to ensure correct indices when deleting multiple
-	for el := nodesToDelete.Front(); el != nil; el = el.Next() {
+	for el := nodesToDelete.MatchingNodes.Back(); el != nil; el = el.Prev() {
 		candidate := el.Value.(*CandidateNode)
 
-		deleteImmediateChildOp := &Operation{
+		//problem: context may already be '.a' and then I pass in '.a.a2'.
-			OperationType: DeleteImmediateChild,
+		// should pass in .a2.
-			Value:         candidate.Path[len(candidate.Path)-1],
+		if candidate.Parent == nil {
+			log.Info("Could not find parent of %v", candidate.GetKey())
+			return context, nil
 		}
 
-		deleteImmediateChildOpNode := &PathTreeNode{
+		parentNode := candidate.Parent.Node
-			Operation: deleteImmediateChildOp,
+		childPath := candidate.Path[len(candidate.Path)-1]
-			Rhs:       createTraversalTree(candidate.Path[0 : len(candidate.Path)-1]),
-		}
 
-		_, err := d.GetMatchingNodes(matchingNodes, deleteImmediateChildOpNode)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return matchingNodes, nil
-}
-
-func DeleteImmediateChildOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
-	parents, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
-
-	if err != nil {
-		return nil, err
-	}
-
-	childPath := pathNode.Operation.Value
-
-	log.Debug("childPath to remove %v", childPath)
-
-	for el := parents.Front(); el != nil; el = el.Next() {
-		parent := el.Value.(*CandidateNode)
-		parentNode := UnwrapDoc(parent.Node)
 		if parentNode.Kind == yaml.MappingNode {
-			deleteFromMap(parent, childPath)
+			deleteFromMap(candidate.Parent, childPath)
 		} else if parentNode.Kind == yaml.SequenceNode {
-			deleteFromArray(parent, childPath)
+			deleteFromArray(candidate.Parent, childPath)
 		} else {
-			return nil, fmt.Errorf("Cannot delete nodes from parent of tag %v", parentNode.Tag)
+			return Context{}, fmt.Errorf("Cannot delete nodes from parent of tag %v", parentNode.Tag)
 		}
-
 	}
-	return matchingNodes, nil
+	return context, nil
 }
 
 func deleteFromMap(candidate *CandidateNode, childPath interface{}) {
 	log.Debug("deleteFromMap")
-	node := UnwrapDoc(candidate.Node)
+	node := unwrapDoc(candidate.Node)
 	contents := node.Content
 	newContents := make([]*yaml.Node, 0)
 
@@ -72,11 +49,7 @@ func deleteFromMap(candidate *CandidateNode, childPath interface{}) {
 		key := contents[index]
 		value := contents[index+1]
 
-		childCandidate := &CandidateNode{
+		childCandidate := candidate.CreateChild(key.Value, value)
-			Node:     value,
-			Document: candidate.Document,
-			Path:     candidate.CreateChildPath(key.Value),
-		}
 
 		shouldDelete := key.Value == childPath
 
@@ -91,7 +64,7 @@ func deleteFromMap(candidate *CandidateNode, childPath interface{}) {
 
 func deleteFromArray(candidate *CandidateNode, childPath interface{}) {
 	log.Debug("deleteFromArray")
-	node := UnwrapDoc(candidate.Node)
+	node := unwrapDoc(candidate.Node)
 	contents := node.Content
 	newContents := make([]*yaml.Node, 0)
 

pkg/yqlib/operator_delete_test.go

@@ -21,6 +21,70 @@ var deleteOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{a: {a2: frood}}\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `{a: {a1: fred, a2: frood}}`,
+		expression: `.a | del(.a1)`,
+		expected: []string{
+			"D0, P[a], (!!map)::{a2: frood}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `a: [1,2,3]`,
+		expression: `.a | del(.[1])`,
+		expected: []string{
+			"D0, P[a], (!!seq)::[1, 3]\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `[0, {a: cat, b: dog}]`,
+		expression: `.[1] | del(.a)`,
+		expected: []string{
+			"D0, P[1], (!!map)::{b: dog}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `[{a: cat, b: dog}]`,
+		expression: `.[0] | del(.a)`,
+		expected: []string{
+			"D0, P[0], (!!map)::{b: dog}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `[{a: {b: thing, c: frog}}]`,
+		expression: `.[0].a | del(.b)`,
+		expected: []string{
+			"D0, P[0 a], (!!map)::{c: frog}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `[{a: {b: thing, c: frog}}]`,
+		expression: `.[0] | del(.a.b)`,
+		expected: []string{
+			"D0, P[0], (!!map)::{a: {c: frog}}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [0, {b: thing, c: frog}]}`,
+		expression: `.a[1] | del(.b)`,
+		expected: []string{
+			"D0, P[a 1], (!!map)::{c: frog}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [0, {b: thing, c: frog}]}`,
+		expression: `.a | del(.[1].b)`,
+		expected: []string{
+			"D0, P[a], (!!seq)::[0, {c: frog}]\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `{a: {a1: fred, a2: frood}}`,
@@ -37,6 +101,38 @@ 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, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func getDocumentIndexOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	var results = list.New()
 
-	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+	for el := context.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 := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		scalar := candidate.CreateChild(nil, node)
 		results.PushBack(scalar)
 	}
-	return results, nil
+	return context.ChildContext(results), nil
 }

pkg/yqlib/operator_entries.go

@@ -0,0 +1,160 @@
+package yqlib
+
+import (
+	"container/list"
+	"fmt"
+
+	yaml "gopkg.in/yaml.v3"
+)
+
+func entrySeqFor(key *yaml.Node, value *yaml.Node) *yaml.Node {
+	var keyKey = &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: "key"}
+	var valueKey = &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: "value"}
+
+	return &yaml.Node{
+		Kind:    yaml.MappingNode,
+		Tag:     "!!map",
+		Content: []*yaml.Node{keyKey, key, valueKey, value},
+	}
+}
+
+func toEntriesFromMap(candidateNode *CandidateNode) *CandidateNode {
+	var sequence = &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq"}
+	var entriesNode = candidateNode.CreateChild(nil, sequence)
+
+	var contents = unwrapDoc(candidateNode.Node).Content
+	for index := 0; index < len(contents); index = index + 2 {
+		key := contents[index]
+		value := contents[index+1]
+
+		sequence.Content = append(sequence.Content, entrySeqFor(key, value))
+	}
+	return entriesNode
+}
+
+func toEntriesfromSeq(candidateNode *CandidateNode) *CandidateNode {
+	var sequence = &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq"}
+	var entriesNode = candidateNode.CreateChild(nil, sequence)
+
+	var contents = unwrapDoc(candidateNode.Node).Content
+	for index := 0; index < len(contents); index = index + 1 {
+		key := &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!int", Value: fmt.Sprintf("%v", index)}
+		value := contents[index]
+
+		sequence.Content = append(sequence.Content, entrySeqFor(key, value))
+	}
+	return entriesNode
+}
+
+func toEntriesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+	var results = list.New()
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		candidateNode := unwrapDoc(candidate.Node)
+
+		switch candidateNode.Kind {
+		case yaml.MappingNode:
+			results.PushBack(toEntriesFromMap(candidate))
+
+		case yaml.SequenceNode:
+			results.PushBack(toEntriesfromSeq(candidate))
+		default:
+			return Context{}, fmt.Errorf("%v has no keys", candidate.Node.Tag)
+		}
+	}
+
+	return context.ChildContext(results), nil
+}
+
+func parseEntry(d *dataTreeNavigator, entry *yaml.Node, position int) (*yaml.Node, *yaml.Node, error) {
+	prefs := traversePreferences{DontAutoCreate: true}
+	candidateNode := &CandidateNode{Node: entry}
+
+	keyResults, err := traverseMap(Context{}, candidateNode, "key", prefs, false)
+
+	if err != nil {
+		return nil, nil, err
+	} else if keyResults.Len() != 1 {
+		return nil, nil, fmt.Errorf("Expected to find one 'key' entry but found %v in position %v", keyResults.Len(), position)
+	}
+
+	valueResults, err := traverseMap(Context{}, candidateNode, "value", prefs, false)
+
+	if err != nil {
+		return nil, nil, err
+	} else if valueResults.Len() != 1 {
+		return nil, nil, fmt.Errorf("Expected to find one 'value' entry but found %v in position %v", valueResults.Len(), position)
+	}
+
+	return keyResults.Front().Value.(*CandidateNode).Node, valueResults.Front().Value.(*CandidateNode).Node, nil
+
+}
+
+func fromEntries(d *dataTreeNavigator, candidateNode *CandidateNode) (*CandidateNode, error) {
+	var node = &yaml.Node{Kind: yaml.MappingNode, Tag: "!!map"}
+	var mapCandidateNode = candidateNode.CreateChild(nil, node)
+
+	var contents = unwrapDoc(candidateNode.Node).Content
+
+	for index := 0; index < len(contents); index = index + 1 {
+		key, value, err := parseEntry(d, contents[index], index)
+		if err != nil {
+			return nil, err
+		}
+
+		node.Content = append(node.Content, key, value)
+	}
+	return mapCandidateNode, nil
+}
+
+func fromEntriesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+	var results = list.New()
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		candidateNode := unwrapDoc(candidate.Node)
+
+		switch candidateNode.Kind {
+		case yaml.SequenceNode:
+			mapResult, err := fromEntries(d, candidate)
+			if err != nil {
+				return Context{}, err
+			}
+			results.PushBack(mapResult)
+		default:
+			return Context{}, fmt.Errorf("from entries only runs against arrays")
+		}
+	}
+
+	return context.ChildContext(results), nil
+}
+
+func withEntriesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+
+	//to_entries on the context
+	toEntries, err := toEntriesOperator(d, context, expressionNode)
+	if err != nil {
+		return Context{}, nil
+	}
+
+	//run expression against entries
+	// splat toEntries and pipe it into Rhs
+	splatted, err := splat(d, toEntries, traversePreferences{})
+	if err != nil {
+		return Context{}, nil
+	}
+
+	result, err := d.GetMatchingNodes(splatted, expressionNode.Rhs)
+	log.Debug("expressionNode.Rhs %v", expressionNode.Rhs.Operation.OperationType)
+	log.Debug("result %v", result)
+	if err != nil {
+		return Context{}, nil
+	}
+
+	collected, err := collectOperator(d, result, expressionNode)
+	if err != nil {
+		return Context{}, nil
+	}
+
+	//from_entries on the result
+	return fromEntriesOperator(d, collected, expressionNode)
+}

pkg/yqlib/operator_entries_test.go

@@ -0,0 +1,56 @@
+package yqlib
+
+import (
+	"testing"
+)
+
+var entriesOperatorScenarios = []expressionScenario{
+	{
+		description: "to_entries Map",
+		document:    `{a: 1, b: 2}`,
+		expression:  `to_entries`,
+		expected: []string{
+			"D0, P[], (!!seq)::- key: a\n  value: 1\n- key: b\n  value: 2\n",
+		},
+	},
+	{
+		description: "to_entries Array",
+		document:    `[a, b]`,
+		expression:  `to_entries`,
+		expected: []string{
+			"D0, P[], (!!seq)::- key: 0\n  value: a\n- key: 1\n  value: b\n",
+		},
+	},
+	{
+		description: "from_entries map",
+		document:    `{a: 1, b: 2}`,
+		expression:  `to_entries | from_entries`,
+		expected: []string{
+			"D0, P[], (!!map)::a: 1\nb: 2\n",
+		},
+	},
+	{
+		description:    "from_entries with numeric key indexes",
+		subdescription: "from_entries always creates a map, even for numeric keys",
+		document:       `[a,b]`,
+		expression:     `to_entries | from_entries`,
+		expected: []string{
+			"D0, P[], (!!map)::0: a\n1: b\n",
+		},
+	},
+	{
+		description: "Use with_entries to update keys",
+		document:    `{a: 1, b: 2}`,
+		expression:  `with_entries(.key |= "KEY_" + .)`,
+		expected: []string{
+			"D0, P[], (!!map)::KEY_a: 1\nKEY_b: 2\n",
+		},
+	},
+}
+
+func TestEntriesOperatorScenarios(t *testing.T) {
+	for _, tt := range entriesOperatorScenarios {
+		testScenario(t, &tt)
+	}
+	documentScenarios(t, "Entries", entriesOperatorScenarios)
+}

pkg/yqlib/operator_env.go

@@ -1,24 +1,24 @@
 package yqlib
 
 import (
-	"container/list"
+	"fmt"
 	"os"
 	"strings"
 
 	yaml "gopkg.in/yaml.v3"
 )
 
-type EnvOpPreferences struct {
+type envOpPreferences struct {
 	StringValue bool
 }
 
-func EnvOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func envOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	envName := pathNode.Operation.CandidateNode.Node.Value
+	envName := expressionNode.Operation.CandidateNode.Node.Value
 	log.Debug("EnvOperator, env name:", envName)
 
 	rawValue := os.Getenv(envName)
 
-	preferences := pathNode.Operation.Preferences.(*EnvOpPreferences)
+	preferences := expressionNode.Operation.Preferences.(envOpPreferences)
 
 	var node *yaml.Node
 	if preferences.StringValue {
@@ -27,26 +27,23 @@ func EnvOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNo
 			Tag:   "!!str",
 			Value: rawValue,
 		}
+	} else if rawValue == "" {
+		return Context{}, 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 nil, errorReading
+			return Context{}, errorReading
 		}
 		//first node is a doc
-		node = UnwrapDoc(&dataBucket)
+		node = unwrapDoc(&dataBucket)
 	}
 	log.Debug("ENV tag", node.Tag)
 	log.Debug("ENV value", node.Value)
 	log.Debug("ENV Kind", node.Kind)
 
-	target := &CandidateNode{
+	target := &CandidateNode{Node: node}
-		Path:     make([]interface{}, 0),
-		Document: 0,
-		Filename: "",
-		Node:     node,
-	}
 
-	return nodeToMap(target), nil
+	return context.SingleChildContext(target), nil
 }

pkg/yqlib/operator_equals.go

@@ -1,22 +1,42 @@
 package yqlib
 
-import (
+import "gopkg.in/yaml.v3"
-	"container/list"
-)
 
-func EqualsOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func equalsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("-- equalsOperation")
-	return crossFunction(d, matchingNodes, pathNode, isEquals)
+	return crossFunction(d, context, expressionNode, isEquals(false), true)
 }
 
-func isEquals(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func isEquals(flip bool) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	value := false
+	return func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+		value := false
 
-	if lhs.Node.Tag == "!!null" {
+		if lhs == nil && rhs == nil {
-		value = (rhs.Node.Tag == "!!null")
+			owner := &CandidateNode{}
-	} else {
+			return createBooleanCandidate(owner, !flip), nil
-		value = Match(lhs.Node.Value, rhs.Node.Value)
+		} else if lhs == nil {
+			return createBooleanCandidate(rhs, flip), nil
+		} else if rhs == nil {
+			return createBooleanCandidate(lhs, flip), nil
+		}
+
+		lhsNode := unwrapDoc(lhs.Node)
+		rhsNode := unwrapDoc(rhs.Node)
+
+		if lhsNode.Tag == "!!null" {
+			value = (rhsNode.Tag == "!!null")
+		} else if lhsNode.Kind == yaml.ScalarNode && rhsNode.Kind == yaml.ScalarNode {
+			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
 	}
-	log.Debugf("%v == %v ? %v", NodeToString(lhs), NodeToString(rhs), 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), true)
 }

pkg/yqlib/operator_equals_test.go

@@ -5,6 +5,23 @@ import (
 )
 
 var equalsOperatorScenarios = []expressionScenario{
+	{
+		skipDoc:    true,
+		document:   "cat",
+		document2:  "dog",
+		expression: "select(fi==0) == select(fi==1)",
+		expected: []string{
+			"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]`,
@@ -14,7 +31,18 @@ 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)`,
@@ -23,7 +51,18 @@ 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")`,
@@ -48,6 +87,22 @@ var equalsOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!bool)::true\n",
 		},
 	},
+	{
+		description: "Non exisitant key doesn't equal a value",
+		document:    "a: frog",
+		expression:  `select(.b != "thing")`,
+		expected: []string{
+			"D0, P[], (doc)::a: frog\n",
+		},
+	},
+	{
+		description: "Two non existant keys are equal",
+		document:    "a: frog",
+		expression:  `select(.b == .c)`,
+		expected: []string{
+			"D0, P[], (doc)::a: frog\n",
+		},
+	},
 }
 
 func TestEqualOperatorScenarios(t *testing.T) {

pkg/yqlib/operator_file.go

@@ -7,32 +7,32 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func GetFilenameOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func getFilenameOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("GetFilename")
 
 	var results = list.New()
 
-	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: candidate.Filename, Tag: "!!str"}
-		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		result := candidate.CreateChild(nil, node)
-		results.PushBack(lengthCand)
+		results.PushBack(result)
 	}
 
-	return results, nil
+	return context.ChildContext(results), nil
 }
 
-func GetFileIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func getFileIndexOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("GetFileIndex")
 
 	var results = list.New()
 
-	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+	for el := context.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"}
-		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		result := candidate.CreateChild(nil, node)
-		results.PushBack(lengthCand)
+		results.PushBack(result)
 	}
 
-	return results, nil
+	return context.ChildContext(results), nil
 }

pkg/yqlib/operator_file_test.go

@@ -21,6 +21,16 @@ var fileOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!int)::0\n",
 		},
 	},
+	{
+		description: "Get file indices of multiple documents",
+		document:    `{a: cat}`,
+		document2:   `{a: cat}`,
+		expression:  `fileIndex`,
+		expected: []string{
+			"D0, P[], (!!int)::0\n",
+			"D0, P[], (!!int)::1\n",
+		},
+	},
 	{
 		description: "Get file index alias",
 		document:    `{a: cat}`,
@@ -29,6 +39,14 @@ var fileOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!int)::0\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   "a: cat\nb: dog",
+		expression: `.. lineComment |= filename`,
+		expected: []string{
+			"D0, P[], (!!map)::a: cat # sample.yml\nb: dog # sample.yml\n",
+		},
+	},
 }
 
 func TestFileOperatorsScenarios(t *testing.T) {

pkg/yqlib/operator_has.go

@@ -7,25 +7,26 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func HasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func hasOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 
 	log.Debugf("-- hasOperation")
 	var results = list.New()
 
-	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
-	wanted := rhs.Front().Value.(*CandidateNode).Node
+	wanted := rhs.MatchingNodes.Front().Value.(*CandidateNode).Node
 	wantedKey := wanted.Value
 
 	if err != nil {
-		return nil, err
+		return Context{}, err
 	}
 
-	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
 		// grab the first value
-		var contents = candidate.Node.Content
+		candidateNode := unwrapDoc(candidate.Node)
-		switch candidate.Node.Kind {
+		var contents = candidateNode.Content
+		switch candidateNode.Kind {
 		case yaml.MappingNode:
 			candidateHasKey := false
 			for index := 0; index < len(contents) && !candidateHasKey; index = index + 2 {
@@ -40,7 +41,7 @@ func HasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathT
 			if wanted.Tag == "!!int" {
 				var number, errParsingInt = strconv.ParseInt(wantedKey, 10, 64) // nolint
 				if errParsingInt != nil {
-					return nil, errParsingInt
+					return Context{}, errParsingInt
 				}
 				candidateHasKey = int64(len(contents)) > number
 			}
@@ -49,5 +50,5 @@ func HasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathT
 			results.PushBack(createBooleanCandidate(candidate, false))
 		}
 	}
-	return results, nil
+	return context.ChildContext(results), nil
 }

pkg/yqlib/operator_has_test.go

@@ -5,6 +5,14 @@ import (
 )
 
 var hasOperatorScenarios = []expressionScenario{
+	{
+		skipDoc:    true,
+		document:   `a: hello`,
+		expression: `has("a")`,
+		expected: []string{
+			"D0, P[], (!!bool)::true\n",
+		},
+	},
 	{
 		description: "Has map key",
 		document: `- a: "yes"
@@ -20,6 +28,15 @@ var hasOperatorScenarios = []expressionScenario{
 			"D0, P[3], (!!bool)::false\n",
 		},
 	},
+	{
+		description:    "Select, checking for existence of deep paths",
+		subdescription: "Simply pipe in parent expressions into `has`",
+		document:       "- {a: {b: {c: cat}}}\n- {a: {b: {d: dog}}}",
+		expression:     `.[] | select(.a.b | has("c"))`,
+		expected: []string{
+			"D0, P[0], (!!map)::{a: {b: {c: cat}}}\n",
+		},
+	},
 	{
 		dontFormatInputForDoc: true,
 		description:           "Has array index",

pkg/yqlib/operator_keys.go

@@ -0,0 +1,54 @@
+package yqlib
+
+import (
+	"container/list"
+	"fmt"
+
+	"gopkg.in/yaml.v3"
+)
+
+func keysOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+	log.Debugf("-- keysOperator")
+
+	var results = list.New()
+
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		node := unwrapDoc(candidate.Node)
+		var targetNode *yaml.Node
+		if node.Kind == yaml.MappingNode {
+			targetNode = getMapKeys(node)
+		} 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)
+		}
+
+		result := candidate.CreateChild(nil, targetNode)
+		results.PushBack(result)
+	}
+
+	return context.ChildContext(results), nil
+}
+
+func getMapKeys(node *yaml.Node) *yaml.Node {
+	contents := make([]*yaml.Node, 0)
+	for index := 0; index < len(node.Content); index = index + 2 {
+		contents = append(contents, node.Content[index])
+	}
+	return &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq", Content: contents}
+}
+
+func getIndicies(node *yaml.Node) *yaml.Node {
+	var contents = make([]*yaml.Node, len(node.Content))
+
+	for index := range node.Content {
+		contents[index] = &yaml.Node{
+			Kind:  yaml.ScalarNode,
+			Tag:   "!!int",
+			Value: fmt.Sprintf("%v", index),
+		}
+	}
+
+	return &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq", Content: contents}
+}

pkg/yqlib/operator_keys_test.go

@@ -0,0 +1,47 @@
+package yqlib
+
+import (
+	"testing"
+)
+
+var keysOperatorScenarios = []expressionScenario{
+	{
+		description: "Map keys",
+		document:    `{dog: woof, cat: meow}`,
+		expression:  `keys`,
+		expected: []string{
+			"D0, P[], (!!seq)::- dog\n- cat\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{}`,
+		expression: `keys`,
+		expected: []string{
+			"D0, P[], (!!seq)::[]\n",
+		},
+	},
+	{
+		description: "Array keys",
+		document:    `[apple, banana]`,
+		expression:  `keys`,
+		expected: []string{
+			"D0, P[], (!!seq)::- 0\n- 1\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `[]`,
+		expression: `keys`,
+		expected: []string{
+			"D0, P[], (!!seq)::[]\n",
+		},
+	},
+}
+
+func TestKeysOperatorScenarios(t *testing.T) {
+	for _, tt := range keysOperatorScenarios {
+		testScenario(t, &tt)
+	}
+	documentScenarios(t, "Keys", keysOperatorScenarios)
+}

pkg/yqlib/operator_length.go

@@ -7,17 +7,21 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-func LengthOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
+func lengthOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("-- lengthOperation")
 	var results = list.New()
 
-	for el := matchMap.Front(); el != nil; el = el.Next() {
+	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		targetNode := UnwrapDoc(candidate.Node)
+		targetNode := unwrapDoc(candidate.Node)
 		var length int
 		switch targetNode.Kind {
 		case yaml.ScalarNode:
-			length = len(targetNode.Value)
+			if targetNode.Tag == "!!null" {
+				length = 0
+			} else {
+				length = len(targetNode.Value)
+			}
 		case yaml.MappingNode:
 			length = len(targetNode.Content) / 2
 		case yaml.SequenceNode:
@@ -27,9 +31,9 @@ func LengthOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTre
 		}
 
 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: fmt.Sprintf("%v", length), Tag: "!!int"}
-		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		result := candidate.CreateChild(nil, node)
-		results.PushBack(lengthCand)
+		results.PushBack(result)
 	}
 
-	return results, nil
+	return context.ChildContext(results), nil
 }

pkg/yqlib/operator_length_test.go

@@ -14,6 +14,30 @@ 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

@@ -2,92 +2,94 @@ package yqlib
 
 import (
 	"fmt"
+	"strconv"
 
 	"container/list"
 
 	yaml "gopkg.in/yaml.v3"
 )
 
-type CrossFunctionCalculation func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error)
+type multiplyPreferences struct {
-
+	AppendArrays    bool
-func crossFunction(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode, calculation CrossFunctionCalculation) (*list.List, error) {
+	DeepMergeArrays bool
-	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
+	TraversePrefs   traversePreferences
-	if err != nil {
-		return nil, err
-	}
-	log.Debugf("crossFunction LHS len: %v", lhs.Len())
-
-	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
-
-	if err != nil {
-		return nil, err
-	}
-	log.Debugf("crossFunction RHS len: %v", rhs.Len())
-
-	var results = list.New()
-
-	for el := lhs.Front(); el != nil; el = el.Next() {
-		lhsCandidate := el.Value.(*CandidateNode)
-
-		for rightEl := rhs.Front(); rightEl != nil; rightEl = rightEl.Next() {
-			log.Debugf("Applying calc")
-			rhsCandidate := rightEl.Value.(*CandidateNode)
-			resultCandidate, err := calculation(d, lhsCandidate, rhsCandidate)
-			if err != nil {
-				return nil, err
-			}
-			results.PushBack(resultCandidate)
-		}
-
-	}
-	return results, nil
 }
 
-type MultiplyPreferences struct {
+func multiplyOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	AppendArrays bool
-}
-
-func MultiplyOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- MultiplyOperator")
-	return crossFunction(d, matchingNodes, pathNode, multiply(pathNode.Operation.Preferences.(*MultiplyPreferences)))
+	return crossFunction(d, context, expressionNode, multiply(expressionNode.Operation.Preferences.(multiplyPreferences)), false)
 }
 
-func multiply(preferences *MultiplyPreferences) func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func multiply(preferences multiplyPreferences) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	return func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	return func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-		lhs.Node = UnwrapDoc(lhs.Node)
+		lhs.Node = unwrapDoc(lhs.Node)
-		rhs.Node = UnwrapDoc(rhs.Node)
+		rhs.Node = unwrapDoc(rhs.Node)
 		log.Debugf("Multipling LHS: %v", lhs.Node.Tag)
 		log.Debugf("-          RHS: %v", rhs.Node.Tag)
 
-		shouldAppendArrays := preferences.AppendArrays
-
 		if lhs.Node.Kind == yaml.MappingNode && rhs.Node.Kind == yaml.MappingNode ||
 			(lhs.Node.Kind == yaml.SequenceNode && rhs.Node.Kind == yaml.SequenceNode) {
 
-			var newBlank = &CandidateNode{
+			var newBlank = lhs.CreateChild(nil, &yaml.Node{})
-				Path:     lhs.Path,
+
-				Document: lhs.Document,
+			var newThing, err = mergeObjects(d, context, newBlank, lhs, multiplyPreferences{})
-				Filename: lhs.Filename,
-				Node:     &yaml.Node{},
-			}
-			var newThing, err = mergeObjects(d, newBlank, lhs, false)
 			if err != nil {
 				return nil, err
 			}
-			return mergeObjects(d, newThing, rhs, shouldAppendArrays)
+			return mergeObjects(d, context, newThing, rhs, preferences)
-
+		} else if lhs.Node.Tag == "!!int" && rhs.Node.Tag == "!!int" {
+			return multiplyIntegers(lhs, rhs)
+		} else if (lhs.Node.Tag == "!!int" || lhs.Node.Tag == "!!float") && (rhs.Node.Tag == "!!int" || rhs.Node.Tag == "!!float") {
+			return multiplyFloats(lhs, rhs)
 		}
 		return nil, fmt.Errorf("Cannot multiply %v with %v", lhs.Node.Tag, rhs.Node.Tag)
 	}
 }
 
-func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode, shouldAppendArrays bool) (*CandidateNode, error) {
+func multiplyFloats(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	target := lhs.CreateChild(nil, &yaml.Node{})
+	target.Node.Kind = yaml.ScalarNode
+	target.Node.Style = lhs.Node.Style
+	target.Node.Tag = "!!float"
+
+	lhsNum, err := strconv.ParseFloat(lhs.Node.Value, 64)
+	if err != nil {
+		return nil, err
+	}
+	rhsNum, err := strconv.ParseFloat(rhs.Node.Value, 64)
+	if err != nil {
+		return nil, err
+	}
+	target.Node.Value = fmt.Sprintf("%v", lhsNum*rhsNum)
+	return target, nil
+}
+
+func multiplyIntegers(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	target := lhs.CreateChild(nil, &yaml.Node{})
+	target.Node.Kind = yaml.ScalarNode
+	target.Node.Style = lhs.Node.Style
+	target.Node.Tag = "!!int"
+
+	lhsNum, err := strconv.Atoi(lhs.Node.Value)
+	if err != nil {
+		return nil, err
+	}
+	rhsNum, err := strconv.Atoi(rhs.Node.Value)
+	if err != nil {
+		return nil, err
+	}
+	target.Node.Value = fmt.Sprintf("%v", lhsNum*rhsNum)
+	return target, nil
+}
+
+func mergeObjects(d *dataTreeNavigator, context Context, 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,
+	prefs := recursiveDescentPreferences{RecurseArray: !shouldAppendArrays,
-		TraversePreferences: &TraversePreferences{FollowAlias: false}}
+		TraversePreferences: traversePreferences{DontFollowAlias: true, IncludeMapKeys: true}}
-	err := recursiveDecent(d, results, nodeToMap(rhs), prefs)
+	err := recursiveDecent(d, results, context.SingleChildContext(rhs), prefs)
 	if err != nil {
 		return nil, err
 	}
@@ -98,7 +100,12 @@ func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode,
 	}
 
 	for el := results.Front(); el != nil; el = el.Next() {
-		err := applyAssignment(d, pathIndexToStartFrom, lhs, el.Value.(*CandidateNode), shouldAppendArrays)
+		candidate := el.Value.(*CandidateNode)
+		if candidate.Node.Tag == "!!merge" {
+			continue
+		}
+
+		err := applyAssignment(d, context, pathIndexToStartFrom, lhs, candidate, preferences)
 		if err != nil {
 			return nil, err
 		}
@@ -106,24 +113,25 @@ func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode,
 	return lhs, nil
 }
 
-func applyAssignment(d *dataTreeNavigator, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, shouldAppendArrays bool) error {
+func applyAssignment(d *dataTreeNavigator, context Context, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) error {
-
+	shouldAppendArrays := preferences.AppendArrays
-	log.Debugf("merge - applyAssignment lhs %v, rhs: %v", NodeToString(lhs), NodeToString(rhs))
+	log.Debugf("merge - applyAssignment lhs %v, rhs: %v", lhs.GetKey(), rhs.GetKey())
 
 	lhsPath := rhs.Path[pathIndexToStartFrom:]
 
-	assignmentOp := &Operation{OperationType: AssignAttributes}
+	assignmentOp := &Operation{OperationType: assignAttributesOpType}
-	if rhs.Node.Kind == yaml.ScalarNode || rhs.Node.Kind == yaml.AliasNode {
+	if shouldAppendArrays && rhs.Node.Kind == yaml.SequenceNode {
-		assignmentOp.OperationType = Assign
+		assignmentOp.OperationType = addAssignOpType
+	} else if !preferences.DeepMergeArrays && rhs.Node.Kind == yaml.SequenceNode ||
+		(rhs.Node.Kind == yaml.ScalarNode || rhs.Node.Kind == yaml.AliasNode) {
+		assignmentOp.OperationType = assignOpType
 		assignmentOp.UpdateAssign = false
-	} else if shouldAppendArrays && rhs.Node.Kind == yaml.SequenceNode {
-		assignmentOp.OperationType = AddAssign
 	}
-	rhsOp := &Operation{OperationType: ValueOp, CandidateNode: rhs}
+	rhsOp := &Operation{OperationType: valueOpType, CandidateNode: rhs}
 
-	assignmentOpNode := &PathTreeNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath), Rhs: &PathTreeNode{Operation: rhsOp}}
+	assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath, preferences.TraversePrefs, rhs.IsMapKey), Rhs: &ExpressionNode{Operation: rhsOp}}
 
-	_, err := d.GetMatchingNodes(nodeToMap(lhs), assignmentOpNode)
+	_, err := d.GetMatchingNodes(context.SingleChildContext(lhs), assignmentOpNode)
 
 	return err
 }