wip

Updated docs
Added prettyPrint flag
2025-01-18 04:53:17 -08:00 · 2020-12-28 23:01:13 +11:00 · 2020-12-28 11:57:20 +11:00 · 2020-12-28 11:40:41 +11:00 · 2020-12-28 11:24:42 +11:00 · 2020-12-28 10:29:43 +11:00
60 changed files with 1636 additions and 488 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report_v3.md
+++ b/.github/ISSUE_TEMPLATE/bug_report_v3.md
@@ -1,8 +1,8 @@
 ---
-name: Bug report
+name: Bug report - V3
 about: Create a report to help us improve
 title: ''
-labels: bug
+labels: bug, v3
 assignees: ''

 ---
@@ -10,11 +10,12 @@ assignees: ''
 **Describe the bug**
 A clear and concise description of what the bug is.

-version of yq: 
-operating system:
+Version of yq: 3.X.X
+Operating system: mac/linux/windows/....
+Installed via: docker/binary release/homebrew/snap/...

 **Input Yaml**
-Concise yaml document(s) (as simple as possible to show the bug)
+Concise yaml document(s) (as simple as possible to show the bug, please keep it to 10 lines or less)
 data1.yml:
 ```yaml
 this: should really work
--- a/.github/ISSUE_TEMPLATE/bug_report_v4.md
+++ b/.github/ISSUE_TEMPLATE/bug_report_v4.md
@@ -0,0 +1,49 @@
+---
+name: Bug report - V4
+about: Create a report to help us improve
+title: ''
+labels: bug, v4
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+Version of yq: 4.X.X
+Operating system: mac/linux/windows/....
+Installed via: docker/binary release/homebrew/snap/...
+
+**Input Yaml**
+Concise yaml document(s) (as simple as possible to show the bug, please keep it to 10 lines or less)
+data1.yml:
+```yaml
+this: should really work
+```
+
+data2.yml:
+```yaml
+but: it strangely didn't
+```
+
+**Command**
+The command you ran:
+```
+yq eval-all 'select(fileIndex==0) | .a.b.c' data1.yml data2.yml
+```
+
+**Actual behavior**
+
+```yaml
+cat: meow
+```
+
+**Expected behavior**
+
+```yaml
+this: should really work
+but: it strangely didn't
+```
+
+**Additional context**
+Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,17 +1,21 @@
 ---
-name: Feature request
+name: Feature request - V4
 about: Suggest an idea for this project
 title: ''
-labels: enhancement
+labels: enhancement, v4
 assignees: ''

 ---

-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+**Please describe your feature request.**
+A clear and concise description of what the request is and what it would solve. 
+Ex. I wish I could use yq to [...]
+
+Please note that V3 will no longer have any enhancements.

 **Describe the solution you'd like**
 If we have data1.yml like:
+(please keep to around 10 lines )

 ```yaml
 country: Australia
@@ -20,7 +24,7 @@ country: Australia
 And we run a command:

 ```bash
-yq predictWeather data1.yml
+yq eval 'predictWeatherOf(.country)'
 ```

 it could output
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -28,7 +28,4 @@ jobs:
      run: |
        export PATH=${PATH}:`go env GOPATH`/bin
        scripts/devtools.sh
-    - name: Build
-      run: |
-        export PATH=${PATH}:`go env GOPATH`/bin
        make local build
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -0,0 +1,78 @@
+name: Release YQ
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publishGitRelease:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-go@v2
+        with:
+          go-version: '^1.15'
+      - name: Cross compile
+        run: |
+          sudo apt-get install rhash -y
+          go get github.com/mitchellh/gox
+          ./scripts/xcompile.sh
+
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1.0.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: ${{ github.ref }}
+          draft: true
+          prerelease: false
+
+      - uses: shogo82148/actions-upload-release-asset@v1
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: build/*
+
+  publishDocker:
+    environment: dockerhub
+    env:
+      IMAGE_NAME: mikefarah/yq
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get latest release tag      
+        uses: oprypin/find-latest-tag@v1
+        with:
+          repository: mikefarah/yq  # The repository to scan.
+          releases-only: true  # We know that all relevant tags have a GitHub release for them.
+        id: yq  
+        
+      - name: Clone source code
+        uses: actions/checkout@v2
+        with:
+          ref: ${{ steps.yq.outputs.tag }}
+      
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+        with:
+          platforms: all
+  
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v1
+        with:
+          version: latest
+
+      - name: Available platforms
+        run: echo ${{ steps.buildx.outputs.platforms }} && docker version
+ 
+      - name: Build and push image
+        run: |
+          IMAGE_VERSION="$(git describe --tags --abbrev=0)"
+          SHORT_SHA1=$(git rev-parse --short HEAD)
+          PLATFORMS="linux/amd64,linux/ppc64le,linux/arm64"
+          echo "Building and pushing version ${IMAGE_VERSION} of image ${IMAGE_NAME}"
+          echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
+          docker buildx build --platform "${PLATFORMS}" -t "${IMAGE_NAME}:${IMAGE_VERSION}"  -t "${IMAGE_NAME}:latest" -t "${IMAGE_NAME}:4" \
+            --push .
+    
--- a/2
+++ b/2
@@ -12,7 +12,7 @@ RUN CGO_ENABLED=0 make local build

 # Choose alpine as a base image to make this useful for CI, as many
 # CI tools expect an interactive shell inside the container
-FROM alpine:3.12 as production
+FROM alpine:3.12.3 as production

 COPY --from=builder /go/src/mikefarah/yq/yq /usr/bin/yq
 RUN chmod +x /usr/bin/yq
--- a/README.md
+++ b/README.md
@@ -7,11 +7,17 @@ a lightweight and portable command-line YAML processor

 The aim of the project is to be the [jq](https://github.com/stedolan/jq) or sed of yaml files.

+## V4 released!
+V4 is now officially released, it's quite different from V3 (sorry for the migration), however it is much more similar to ```jq```, using a similar expression syntax and therefore support much more complex functionality! 
+
+If you've been using v3 and want/need to upgrade, checkout the [upgrade guide](https://mikefarah.gitbook.io/yq/v/v4.x/upgrading-from-v3).
+
 ## Install

 ### [Download the latest binary](https://github.com/mikefarah/yq/releases/latest)

 ### MacOS:
+Using [Homebrew](https://brew.sh/)
 ```
 brew install yq
 ```
@@ -44,13 +50,12 @@ rm /etc/myfile.tmp
 Use wget to download the pre-compiled binaries:

 ```bash
-wget https://github.com/mikefarah/yq/releases/download/{VERSION}/{BINARY} -O /usr/bin/yq &&\
+wget https://github.com/mikefarah/yq/releases/download/${VERSION}/${BINARY} -O /usr/bin/yq &&\
    chmod +x /usr/bin/yq
 ```

 For instance, VERSION=4.0.0 and BINARY=yq_linux_amd64

-
 ### Run with Docker

 #### Oneshot use:
@@ -75,7 +80,7 @@ yq() {

 ### Go Get:
 ```
-GO111MODULE=on go get github.com/mikefarah/yq/v4
+GO111MODULE=on go get github.com/mikefarah/yq
 ```

 ## Community Supported Installation methods
@@ -88,6 +93,14 @@ choco install yq
 ```
 Supported by @chillum (https://chocolatey.org/packages/yq)

+### Mac:
+Using [MacPorts](https://www.macports.org/)
+```
+sudo port selfupdate
+sudo port install yq
+```
+Supported by @herbygillot (https://ports.macports.org/maintainer/github/herbygillot)
+
 ### Alpine Linux
 - Enable edge/community repo by adding ```$MIRROR/alpine/edge/community``` to ```/etc/apk/repositories```
 - Update database index with ```apk update```
@@ -113,13 +126,13 @@ Supported by @rmescandon (https://launchpad.net/~rmescandon/+archive/ubuntu/yq)
 - Colorized yaml output
 - [Deeply traverse yaml](https://mikefarah.gitbook.io/yq/v/v4.x/traverse)
 - [Sort yaml by keys](https://mikefarah.gitbook.io/yq/v/v4.x/sort-keys)
- Manipulate yaml [comments](https://app.gitbook.com/@mikefarah/s/yq/v/v4.x/comment-operators), [styling](https://app.gitbook.com/@mikefarah/s/yq/v/v4.x/style), [tags](https://app.gitbook.com/@mikefarah/s/yq/v/v4.x/tag) and [anchors](https://app.gitbook.com/@mikefarah/s/yq/v/v4.x/explode).
+- 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).
 - [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)
 - 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)
+- [General shell completion scripts (bash/zsh/fish/powershell)](https://mikefarah.gitbook.io/yq/v/v4.x/commands/shell-completion)

 ## [Usage](https://mikefarah.gitbook.io/yq/)

@@ -145,6 +158,7 @@ Flags:
  -M, --no-colors     force print with no colors
  -N, --no-doc        Don't print document separators (---)
  -n, --null-input    Don't read input, simply evaluate the expression given. Useful for creating yaml docs from scratch.
+  -P, --prettyPrint    pretty print, shorthand for '... style = ""' 
  -j, --tojson        output as json. Set indent to 0 to print json in one line.
  -v, --verbose       verbose mode
  -V, --version       Print version information and quit
@@ -158,8 +172,5 @@ Simple Example:
 yq e '.a.b | length' f1.yml f2.yml 
 ```

-## Upgrade from V3
-If you've been using v3 and want/need to upgrade, checkout the [upgrade guide](https://mikefarah.gitbook.io/yq/v/v4.x/upgrading-from-v3).
-
 ## Known Issues / Missing Features
 - `yq` attempts to preserve comment positions and whitespace as much as possible, but it does not handle all scenarios (see https://github.com/go-yaml/yaml/tree/v3 for details)
--- a/cmd/constant.go
+++ b/cmd/constant.go
@@ -14,5 +14,6 @@ var noDocSeparators = false
 var nullInput = false
 var verbose = false
 var version = false
+var prettyPrint = false

 var completedSuccessfully = false
--- a/cmd/evaluate_all_command.go
+++ b/cmd/evaluate_all_command.go
@@ -65,19 +65,19 @@ func evaluateAll(cmd *cobra.Command, args []string) error {
 	switch len(args) {
 	case 0:
 		if pipingStdIn {
-			err = allAtOnceEvaluator.EvaluateFiles("", []string{"-"}, printer)
+			err = allAtOnceEvaluator.EvaluateFiles(processExpression(""), []string{"-"}, printer)
 		} else {
 			cmd.Println(cmd.UsageString())
 			return nil
 		}
 	case 1:
 		if nullInput {
-			err = yqlib.NewStreamEvaluator().EvaluateNew(args[0], printer)
+			err = yqlib.NewStreamEvaluator().EvaluateNew(processExpression(args[0]), printer)
 		} else {
-			err = allAtOnceEvaluator.EvaluateFiles("", []string{args[0]}, printer)
+			err = allAtOnceEvaluator.EvaluateFiles(processExpression(""), []string{args[0]}, printer)
 		}
 	default:
-		err = allAtOnceEvaluator.EvaluateFiles(args[0], args[1:], printer)
+		err = allAtOnceEvaluator.EvaluateFiles(processExpression(args[0]), args[1:], printer)
 	}

 	completedSuccessfully = err == nil
--- a/cmd/evalute_sequence_command.go
+++ b/cmd/evalute_sequence_command.go
@@ -33,6 +33,16 @@ yq e '.a.b = "cool"' -i file.yaml
 	}
 	return cmdEvalSequence
 }
+
+func processExpression(expression string) string {
+	if prettyPrint && expression == "" {
+		return `... style=""`
+	} else if prettyPrint {
+		return fmt.Sprintf("%v | ... style= \"\"", expression)
+	}
+	return expression
+}
+
 func evaluateSequence(cmd *cobra.Command, args []string) error {
 	cmd.SilenceUsage = true
 	// 0 args, read std in
@@ -76,16 +86,16 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 	switch len(args) {
 	case 0:
 		if pipingStdIn {
-			err = streamEvaluator.EvaluateFiles("", []string{"-"}, printer)
+			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{"-"}, printer)
 		} else {
 			cmd.Println(cmd.UsageString())
 			return nil
 		}
 	case 1:
 		if nullInput {
-			err = streamEvaluator.EvaluateNew(args[0], printer)
+			err = streamEvaluator.EvaluateNew(processExpression(args[0]), printer)
 		} else {
-			err = streamEvaluator.EvaluateFiles("", []string{args[0]}, printer)
+			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{args[0]}, printer)
 		}
 	default:
 		err = streamEvaluator.EvaluateFiles(args[0], args[1:], printer)
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -47,6 +47,8 @@ func New() *cobra.Command {
 	rootCmd.PersistentFlags().IntVarP(&indent, "indent", "I", 2, "sets indent level for output")
 	rootCmd.Flags().BoolVarP(&version, "version", "V", false, "Print version information and quit")
 	rootCmd.PersistentFlags().BoolVarP(&writeInplace, "inplace", "i", false, "update the yaml file inplace of first yaml file given.")
+	rootCmd.PersistentFlags().BoolVarP(&unwrapScalar, "unwrapScalar", "", true, "unwrap scalar, print the value with no quotes, colors or comments")
+	rootCmd.PersistentFlags().BoolVarP(&prettyPrint, "prettyPrint", "P", false, "pretty print, shorthand for '... style = \"\"'")
 	rootCmd.PersistentFlags().BoolVarP(&exitStatus, "exit-status", "e", false, "set exit status if there are no matches or null or false is returned")

 	rootCmd.PersistentFlags().BoolVarP(&forceColor, "colors", "C", false, "force print with colors")
--- a/cmd/version.go
+++ b/cmd/version.go
@@ -11,7 +11,7 @@ var (
 	GitDescribe string

 	// Version is main version number that is being run at the moment.
-	Version = "4.0.0-beta1"
+	Version = "4.2.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
--- a/go.sum
+++ b/go.sum
@@ -263,6 +263,7 @@ golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037 h1:YyJpGZS1sBuBCzLAR1VEpK193GlqGZbnPFnPV/5Rsb4=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/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-20200930185726-fdedc70b468f h1:+Nyd8tzPX9R7BWHguqsrbFdRx3WQ/1ib8I44HXV5yTA=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
--- a/pkg/yqlib/candidate_node.go
+++ b/pkg/yqlib/candidate_node.go
@@ -21,6 +21,14 @@ func (n *CandidateNode) GetKey() string {
 	return fmt.Sprintf("%v - %v", n.Document, n.Path)
 }

+func (n *CandidateNode) CreateChildPath(path interface{}) []interface{} {
+	//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)
+	newPath[len(n.Path)] = path
+	return newPath
+}
+
 func (n *CandidateNode) Copy() (*CandidateNode, error) {
 	clone := &CandidateNode{}
 	err := copier.Copy(clone, n)
--- a/pkg/yqlib/doc/Alternative
+++ b/pkg/yqlib/doc/Alternative
@@ -0,0 +1,73 @@
+This operator is used to provide alternative (or default) values when a particular expression is either null or false.
+
+## LHS is defined
+Given a sample.yml file of:
+```yaml
+a: bridge
+```
+then
+```bash
+yq eval '.a // "hello"' sample.yml
+```
+will output
+```yaml
+bridge
+```
+
+## LHS is not defined
+Given a sample.yml file of:
+```yaml
+{}
+```
+then
+```bash
+yq eval '.a // "hello"' sample.yml
+```
+will output
+```yaml
+hello
+```
+
+## LHS is null
+Given a sample.yml file of:
+```yaml
+a: ~
+```
+then
+```bash
+yq eval '.a // "hello"' sample.yml
+```
+will output
+```yaml
+hello
+```
+
+## LHS is false
+Given a sample.yml file of:
+```yaml
+a: false
+```
+then
+```bash
+yq eval '.a // "hello"' sample.yml
+```
+will output
+```yaml
+hello
+```
+
+## RHS is an expression
+Given a sample.yml file of:
+```yaml
+a: false
+b: cat
+```
+then
+```bash
+yq eval '.a // .b' sample.yml
+```
+will output
+```yaml
+cat
+```
+
--- a/pkg/yqlib/doc/Explode.md
+++ b/pkg/yqlib/doc/Explode.md
@@ -1,4 +1,67 @@
-Explodes (or dereferences) aliases and anchors.
+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).
+
+`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.
+
+
+## Get anchor
+Given a sample.yml file of:
+```yaml
+a: &billyBob cat
+```
+then
+```bash
+yq eval '.a | anchor' sample.yml
+```
+will output
+```yaml
+billyBob
+```
+
+## Set anchor
+Given a sample.yml file of:
+```yaml
+a: cat
+```
+then
+```bash
+yq eval '.a anchor = "foobar"' sample.yml
+```
+will output
+```yaml
+a: &foobar cat
+```
+
+## Get alias
+Given a sample.yml file of:
+```yaml
+b: &billyBob meow
+a: *billyBob
+```
+then
+```bash
+yq eval '.a | alias' sample.yml
+```
+will output
+```yaml
+billyBob
+```
+
+## Set alias
+Given a sample.yml file of:
+```yaml
+b: &meow purr
+a: cat
+```
+then
+```bash
+yq eval '.a alias = "meow"' sample.yml
+```
+will output
+```yaml
+b: &meow purr
+a: *meow
+```
+
 ## Explode alias and anchor
 Given a sample.yml file of:
 ```yaml
--- a/pkg/yqlib/doc/Assign.md
+++ b/pkg/yqlib/doc/Assign.md
@@ -112,7 +112,7 @@ a:
 ```
 then
 ```bash
-yq eval '(.a.[] | select(. == "apple")) = "frog"' sample.yml
+yq eval '(.a[] | select(. == "apple")) = "frog"' sample.yml
 ```
 will output
 ```yaml
--- a/pkg/yqlib/doc/Delete.md
+++ b/pkg/yqlib/doc/Delete.md
@@ -14,6 +14,23 @@ will output
 a: cat
 ```

+## Delete nested entry in map
+Given a sample.yml file of:
+```yaml
+a:
+  a1: fred
+  a2: frood
+```
+then
+```bash
+yq eval 'del(.a.a1)' sample.yml
+```
+will output
+```yaml
+a:
+  a2: frood
+```
+
 ## Delete entry in array
 Given a sample.yml file of:
 ```yaml
@@ -31,6 +48,21 @@ will output
 - 3
 ```

+## Delete nested entry in array
+Given a sample.yml file of:
+```yaml
+- a: cat
+  b: dog
+```
+then
+```bash
+yq eval 'del(.[0].a)' sample.yml
+```
+will output
+```yaml
+- b: dog
+```
+
 ## Delete no matches
 Given a sample.yml file of:
 ```yaml
--- a/pkg/yqlib/doc/Keys.md
+++ b/pkg/yqlib/doc/Keys.md
@@ -0,0 +1,38 @@
+
+## Get Keys
+Given a sample.yml file of:
+```yaml
+a:
+  b: cat
+  c: dog
+  d: frog
+```
+then
+```bash
+yq eval '.a | keys' sample.yml
+```
+will output
+```yaml
+3
+```
+
+## Set key style
+Given a sample.yml file of:
+```yaml
+a:
+  b: cat
+  c: dog
+  d: frog
+```
+then
+```bash
+yq eval '(.a | keys) style = 'single'' sample.yml
+```
+will output
+```yaml
+a:
+  b: cat
+  c: dog
+  d: frog
+```
+
--- a/pkg/yqlib/doc/Recursive
+++ b/pkg/yqlib/doc/Recursive
@@ -1,8 +1,55 @@
-This operator recursively matches all children nodes given of a particular element, including that node itself. This is most often used to apply a filter recursively against all matches, for instance to set the `style` of all nodes in a yaml doc:
+This operator recursively matches all children nodes given of a particular element, including that node itself. This is most often used to apply a filter recursively against all matches. It can be used in either the 
+
+## match values form `..`
+This will, like the `jq` equivalent, recursively match all _value_ nodes. Use it to find/manipulate particular values.
+
+For instance to set the `style` of all _value_ nodes in a yaml doc, excluding map keys:

 ```bash
 yq eval '.. style= "flow"' file.yaml
 ```
+
+## match values and map keys form `...`
+The also includes map keys in the results set. This is particularly useful in YAML as unlike JSON, map keys can have their own styling, tags and use anchors and aliases.
+
+For instance to set the `style` of all nodes in a yaml doc, including the map keys:
+
+```bash
+yq eval '... style= "flow"' file.yaml
+```
+## Recurse map (values only)
+Given a sample.yml file of:
+```yaml
+a: frog
+```
+then
+```bash
+yq eval '..' sample.yml
+```
+will output
+```yaml
+a: frog
+frog
+```
+
+## Recurse map (values and keys)
+Note that the map key appears in the results
+
+Given a sample.yml file of:
+```yaml
+a: frog
+```
+then
+```bash
+yq eval '...' sample.yml
+```
+will output
+```yaml
+a: frog
+a
+frog
+```
+
 ## Aliases are not traversed
 Given a sample.yml file of:
 ```yaml
--- a/pkg/yqlib/doc/Style.md
+++ b/pkg/yqlib/doc/Style.md
@@ -40,6 +40,26 @@ c: "3.2"
 e: "true"
 ```

+## Set double quote style on map keys too
+Given a sample.yml file of:
+```yaml
+a: cat
+b: 5
+c: 3.2
+e: true
+```
+then
+```bash
+yq eval '... style="double"' sample.yml
+```
+will output
+```yaml
+"a": "cat"
+"b": "5"
+"c": "3.2"
+"e": "true"
+```
+
 ## Set single quote style
 Given a sample.yml file of:
 ```yaml
@@ -126,18 +146,18 @@ will output
 ```

 ## Pretty print
-Set empty (default) quote style
+Set empty (default) quote style, note the usage of `...` to match keys too.

 Given a sample.yml file of:
 ```yaml
 a: cat
-b: 5
-c: 3.2
-e: true
+"b": 5
+'c': 3.2
+"e": true
 ```
 then
 ```bash
-yq eval '.. style=""' sample.yml
+yq eval '... style=""' sample.yml
 ```
 will output
 ```yaml
--- a/pkg/yqlib/doc/Traverse.md
+++ b/pkg/yqlib/doc/Traverse.md
@@ -106,7 +106,7 @@ b: *cat
 ```
 then
 ```bash
-yq eval '.b.[]' sample.yml
+yq eval '.b[]' sample.yml
 ```
 will output
 ```yaml
@@ -290,7 +290,7 @@ foobar:
 ```
 then
 ```bash
-yq eval '.foobar.[]' sample.yml
+yq eval '.foobar[]' sample.yml
 ```
 will output
 ```yaml
@@ -356,7 +356,7 @@ foobar:
 ```
 then
 ```bash
-yq eval '.foobarList.[]' sample.yml
+yq eval '.foobarList[]' sample.yml
 ```
 will output
 ```yaml
@@ -366,3 +366,21 @@ bar_thing
 foobarList_c
 ```

+## Select multiple indices
+Given a sample.yml file of:
+```yaml
+a:
+  - a
+  - b
+  - c
+```
+then
+```bash
+yq eval '.a[0, 2]' sample.yml
+```
+will output
+```yaml
+a
+c
+```
+
--- a/pkg/yqlib/doc/headers/Alternative
+++ b/pkg/yqlib/doc/headers/Alternative
@@ -0,0 +1 @@
+This operator is used to provide alternative (or default) values when a particular expression is either null or false.
--- a/pkg/yqlib/doc/headers/Anchor
+++ b/pkg/yqlib/doc/headers/Anchor
@@ -0,0 +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).
+
+`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.
+
--- a/pkg/yqlib/doc/headers/Explode.md
+++ b/pkg/yqlib/doc/headers/Explode.md
@@ -1 +0,0 @@
-Explodes (or dereferences) aliases and anchors.
--- a/pkg/yqlib/doc/headers/Recursive
+++ b/pkg/yqlib/doc/headers/Recursive
@@ -1,5 +1,19 @@
-This operator recursively matches all children nodes given of a particular element, including that node itself. This is most often used to apply a filter recursively against all matches, for instance to set the `style` of all nodes in a yaml doc:
+This operator recursively matches all children nodes given of a particular element, including that node itself. This is most often used to apply a filter recursively against all matches. It can be used in either the 
+
+## match values form `..`
+This will, like the `jq` equivalent, recursively match all _value_ nodes. Use it to find/manipulate particular values.
+
+For instance to set the `style` of all _value_ nodes in a yaml doc, excluding map keys:

 ```bash
 yq eval '.. style= "flow"' file.yaml
+```
+
+## match values and map keys form `...`
+The also includes map keys in the results set. This is particularly useful in YAML as unlike JSON, map keys can have their own styling, tags and use anchors and aliases.
+
+For instance to set the `style` of all nodes in a yaml doc, including the map keys:
+
+```bash
+yq eval '... style= "flow"' file.yaml
 ```
--- a/pkg/yqlib/lib.go
+++ b/pkg/yqlib/lib.go
@@ -19,7 +19,7 @@ type OperationType struct {
 }

 // operators TODO:
-// - cookbook doc for common things
+// - 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}
@@ -36,9 +36,12 @@ var AssignAttributes = &OperationType{Type: "ASSIGN_ATTRIBUTES", NumArgs: 2, Pre
 var AssignStyle = &OperationType{Type: "ASSIGN_STYLE", NumArgs: 2, Precedence: 40, Handler: AssignStyleOperator}
 var AssignTag = &OperationType{Type: "ASSIGN_TAG", NumArgs: 2, Precedence: 40, Handler: AssignTagOperator}
 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 Add = &OperationType{Type: "ADD", NumArgs: 2, Precedence: 45, Handler: AddOperator}
+var Alternative = &OperationType{Type: "ALTERNATIVE", NumArgs: 2, Precedence: 45, Handler: AlternativeOperator}

 var Equals = &OperationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: EqualsOperator}
 var CreateMap = &OperationType{Type: "CREATE_MAP", NumArgs: 2, Precedence: 40, Handler: CreateMapOperator}
@@ -46,10 +49,13 @@ var CreateMap = &OperationType{Type: "CREATE_MAP", NumArgs: 2, Precedence: 40, H
 var ShortPipe = &OperationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence: 45, Handler: PipeOperator}

 var Length = &OperationType{Type: "LENGTH", NumArgs: 0, Precedence: 50, Handler: LengthOperator}
+var Keys = &OperationType{Type: "KEYS", NumArgs: 0, Precedence: 50, Handler: KeysOperator}
 var Collect = &OperationType{Type: "COLLECT", NumArgs: 0, Precedence: 50, Handler: CollectOperator}
 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}
@@ -60,6 +66,7 @@ var SortKeys = &OperationType{Type: "SORT_KEYS", NumArgs: 1, Precedence: 50, Han

 var CollectObject = &OperationType{Type: "COLLECT_OBJECT", NumArgs: 0, Precedence: 50, Handler: CollectObjectOperator}
 var TraversePath = &OperationType{Type: "TRAVERSE_PATH", NumArgs: 0, Precedence: 50, Handler: TraversePathOperator}
+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 SelfReference = &OperationType{Type: "SELF", NumArgs: 0, Precedence: 50, Handler: SelfOperator}
@@ -72,6 +79,7 @@ var RecursiveDescent = &OperationType{Type: "RECURSIVE_DESCENT", NumArgs: 0, Pre
 var Select = &OperationType{Type: "SELECT", NumArgs: 1, Precedence: 50, Handler: SelectOperator}
 var Has = &OperationType{Type: "HAS", NumArgs: 1, Precedence: 50, Handler: HasOperator}
 var DeleteChild = &OperationType{Type: "DELETE", NumArgs: 1, Precedence: 40, Handler: DeleteChildOperator}
+var DeleteImmediateChild = &OperationType{Type: "DELETE_IMMEDIATE_CHILD", NumArgs: 1, Precedence: 40, Handler: DeleteImmediateChildOperator}

 type Operation struct {
 	OperationType *OperationType
--- a/pkg/yqlib/operator_add.go
+++ b/pkg/yqlib/operator_add.go
@@ -22,13 +22,7 @@ func AddAssignOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode
 	return d.GetMatchingNodes(matchingNodes, assignmentOpNode)
 }

-func toNodes(candidates *list.List) []*yaml.Node {
-
-	if candidates.Len() == 0 {
-		return []*yaml.Node{}
-	}
-	candidate := candidates.Front().Value.(*CandidateNode)
-
+func toNodes(candidate *CandidateNode) []*yaml.Node {
 	if candidate.Node.Tag == "!!null" {
 		return []*yaml.Node{}
 	}
@@ -44,40 +38,33 @@ func toNodes(candidates *list.List) []*yaml.Node {

 func AddOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("Add operator")
-	var results = list.New()
-	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
-	if err != nil {
-		return nil, err
-	}
-	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)

-	if err != nil {
-		return nil, err
-	}
-
-	for el := lhs.Front(); el != nil; el = el.Next() {
-		lhsCandidate := el.Value.(*CandidateNode)
-		lhsNode := UnwrapDoc(lhsCandidate.Node)
-
-		target := &CandidateNode{
-			Path:     lhsCandidate.Path,
-			Document: lhsCandidate.Document,
-			Filename: lhsCandidate.Filename,
-			Node:     &yaml.Node{},
-		}
-
-		switch lhsNode.Kind {
-		case yaml.MappingNode:
-			return nil, fmt.Errorf("Maps not yet supported for addition")
-		case yaml.SequenceNode:
-			target.Node.Kind = yaml.SequenceNode
-			target.Node.Style = lhsNode.Style
-			target.Node.Tag = "!!seq"
-			target.Node.Content = append(lhsNode.Content, toNodes(rhs)...)
-			results.PushBack(target)
-		case yaml.ScalarNode:
-			return nil, fmt.Errorf("Scalars not yet supported for addition")
-		}
-	}
-	return results, nil
+	return crossFunction(d, matchingNodes, pathNode, add)
+}
+
+func add(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	lhs.Node = UnwrapDoc(lhs.Node)
+	rhs.Node = UnwrapDoc(rhs.Node)
+
+	target := &CandidateNode{
+		Path:     lhs.Path,
+		Document: lhs.Document,
+		Filename: lhs.Filename,
+		Node:     &yaml.Node{},
+	}
+	lhsNode := lhs.Node
+
+	switch lhsNode.Kind {
+	case yaml.MappingNode:
+		return nil, fmt.Errorf("Maps not yet supported for addition")
+	case yaml.SequenceNode:
+		target.Node.Kind = yaml.SequenceNode
+		target.Node.Style = lhsNode.Style
+		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")
+	}
+
+	return target, nil
 }
--- a/pkg/yqlib/operator_add_test.go
+++ b/pkg/yqlib/operator_add_test.go
@@ -21,6 +21,14 @@ var addOperatorScenarios = []expressionScenario{
 			"D0, P[a], (!!seq)::[1, 2, 3, 4]\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		expression: `[1] + ([2], [3])`,
+		expected: []string{
+			"D0, P[], (!!seq)::- 1\n- 2\n",
+			"D0, P[], (!!seq)::- 1\n- 3\n",
+		},
+	},
 	{
 		description: "Concatenate null to array",
 		document:    `{a: [1,2]}`,
--- a/pkg/yqlib/operator_alternative.go
+++ b/pkg/yqlib/operator_alternative.go
@@ -0,0 +1,28 @@
+package yqlib
+
+import (
+	"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)
+}
+
+func alternativeFunc(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	lhs.Node = UnwrapDoc(lhs.Node)
+	rhs.Node = UnwrapDoc(rhs.Node)
+	log.Debugf("Alternative LHS: %v", lhs.Node.Tag)
+	log.Debugf("-          RHS: %v", rhs.Node.Tag)
+
+	isTrue, err := isTruthy(lhs)
+	if err != nil {
+		return nil, err
+	} else if isTrue {
+		return lhs, nil
+	}
+	return rhs, nil
+}
--- a/pkg/yqlib/operator_alternative_test.go
+++ b/pkg/yqlib/operator_alternative_test.go
@@ -0,0 +1,62 @@
+package yqlib
+
+import (
+	"testing"
+)
+
+var alternativeOperatorScenarios = []expressionScenario{
+	{
+		description: "LHS is defined",
+		expression:  `.a // "hello"`,
+		document:    `{a: bridge}`,
+		expected: []string{
+			"D0, P[a], (!!str)::bridge\n",
+		},
+	},
+	{
+		description: "LHS is not defined",
+		expression:  `.a // "hello"`,
+		document:    `{}`,
+		expected: []string{
+			"D0, P[], (!!str)::hello\n",
+		},
+	},
+	{
+		description: "LHS is null",
+		expression:  `.a // "hello"`,
+		document:    `{a: ~}`,
+		expected: []string{
+			"D0, P[], (!!str)::hello\n",
+		},
+	},
+	{
+		description: "LHS is false",
+		expression:  `.a // "hello"`,
+		document:    `{a: false}`,
+		expected: []string{
+			"D0, P[], (!!str)::hello\n",
+		},
+	},
+	{
+		description: "RHS is an expression",
+		expression:  `.a // .b`,
+		document:    `{a: false, b: cat}`,
+		expected: []string{
+			"D0, P[b], (!!str)::cat\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		expression: `false // true`,
+		expected: []string{
+			"D0, P[], (!!bool)::true\n",
+		},
+	},
+}
+
+func TestAlternativeOperatorScenarios(t *testing.T) {
+	for _, tt := range alternativeOperatorScenarios {
+		testScenario(t, &tt)
+	}
+	documentScenarios(t, "Alternative (Default value)", alternativeOperatorScenarios)
+}
--- a/pkg/yqlib/operator_anchors_aliases.go
+++ b/pkg/yqlib/operator_anchors_aliases.go
@@ -6,6 +6,88 @@ import (
 	"gopkg.in/yaml.v3"
 )

+func AssignAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+
+	log.Debugf("AssignAlias operator!")
+
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	if err != nil {
+		return nil, err
+	}
+	aliasName := ""
+	if rhs.Front() != nil {
+		aliasName = rhs.Front().Value.(*CandidateNode).Node.Value
+	}
+
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for el := lhs.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		log.Debugf("Setting aliasName : %v", candidate.GetKey())
+		candidate.Node.Kind = yaml.AliasNode
+		candidate.Node.Value = aliasName
+	}
+	return matchingNodes, nil
+}
+
+func GetAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	log.Debugf("GetAlias operator!")
+	var results = list.New()
+
+	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		node := &yaml.Node{Kind: yaml.ScalarNode, Value: candidate.Node.Value, Tag: "!!str"}
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
+	}
+	return results, nil
+}
+
+func AssignAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+
+	log.Debugf("AssignAnchor operator!")
+
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	if err != nil {
+		return nil, err
+	}
+	anchorName := ""
+	if rhs.Front() != nil {
+		anchorName = rhs.Front().Value.(*CandidateNode).Node.Value
+	}
+
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for el := lhs.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		log.Debugf("Setting anchorName of : %v", candidate.GetKey())
+		candidate.Node.Anchor = anchorName
+	}
+	return matchingNodes, nil
+}
+
+func GetAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	log.Debugf("GetAnchor operator!")
+	var results = list.New()
+
+	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		anchor := candidate.Node.Anchor
+		node := &yaml.Node{Kind: yaml.ScalarNode, Value: anchor, Tag: "!!str"}
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
+	}
+	return results, nil
+}
+
 func ExplodeOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- ExplodeOperation")

--- a/pkg/yqlib/operator_anchors_aliases_test.go
+++ b/pkg/yqlib/operator_anchors_aliases_test.go
@@ -4,7 +4,39 @@ import (
 	"testing"
 )

-var explodeTest = []expressionScenario{
+var anchorOperatorScenarios = []expressionScenario{
+	{
+		description: "Get anchor",
+		document:    `a: &billyBob cat`,
+		expression:  `.a | anchor`,
+		expected: []string{
+			"D0, P[a], (!!str)::billyBob\n",
+		},
+	},
+	{
+		description: "Set anchor",
+		document:    `a: cat`,
+		expression:  `.a anchor = "foobar"`,
+		expected: []string{
+			"D0, P[], (doc)::a: &foobar cat\n",
+		},
+	},
+	{
+		description: "Get alias",
+		document:    `{b: &billyBob meow, a: *billyBob}`,
+		expression:  `.a | alias`,
+		expected: []string{
+			"D0, P[a], (!!str)::billyBob\n",
+		},
+	},
+	{
+		description: "Set alias",
+		document:    `{b: &meow purr, a: cat}`,
+		expression:  `.a alias = "meow"`,
+		expected: []string{
+			"D0, P[], (doc)::{b: &meow purr, a: *meow}\n",
+		},
+	},
 	{
 		description: "Explode alias and anchor",
 		document:    `{f : {a: &a cat, b: *a}}`,
@@ -82,9 +114,9 @@ foobar:
 	},
 }

-func TestExplodeOperatorScenarios(t *testing.T) {
-	for _, tt := range explodeTest {
+func TestAnchorAliaseOperatorScenarios(t *testing.T) {
+	for _, tt := range anchorOperatorScenarios {
 		testScenario(t, &tt)
 	}
-	documentScenarios(t, "Explode", explodeTest)
+	documentScenarios(t, "Anchor and Alias Operators", anchorOperatorScenarios)
 }
--- a/pkg/yqlib/operator_assign_test.go
+++ b/pkg/yqlib/operator_assign_test.go
@@ -80,7 +80,15 @@ var assignOperatorScenarios = []expressionScenario{
 	{
 		description: "Update selected results",
 		document:    `{a: {b: apple, c: cactus}}`,
-		expression:  `(.a.[] | select(. == "apple")) = "frog"`,
+		expression:  `(.a[] | select(. == "apple")) = "frog"`,
+		expected: []string{
+			"D0, P[], (doc)::{a: {b: frog, c: cactus}}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: {b: apple, c: cactus}}`,
+		expression: `(.a.[] | select(. == "apple")) = "frog"`,
 		expected: []string{
 			"D0, P[], (doc)::{a: {b: frog, c: cactus}}\n",
 		},
--- a/pkg/yqlib/operator_booleans.go
+++ b/pkg/yqlib/operator_booleans.go
@@ -25,74 +25,39 @@ func isTruthy(c *CandidateNode) (bool, error) {

 type boolOp func(bool, bool) bool

-func performBoolOp(results *list.List, lhs *list.List, rhs *list.List, op boolOp) error {
-	for lhsChild := lhs.Front(); lhsChild != nil; lhsChild = lhsChild.Next() {
-		lhsCandidate := lhsChild.Value.(*CandidateNode)
-		lhsTrue, errDecoding := isTruthy(lhsCandidate)
+func performBoolOp(op boolOp) func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	return func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+		lhs.Node = UnwrapDoc(lhs.Node)
+		rhs.Node = UnwrapDoc(rhs.Node)
+
+		lhsTrue, errDecoding := isTruthy(lhs)
 		if errDecoding != nil {
-			return errDecoding
+			return nil, errDecoding
 		}

-		for rhsChild := rhs.Front(); rhsChild != nil; rhsChild = rhsChild.Next() {
-			rhsCandidate := rhsChild.Value.(*CandidateNode)
-			rhsTrue, errDecoding := isTruthy(rhsCandidate)
-			if errDecoding != nil {
-				return errDecoding
-			}
-			boolResult := createBooleanCandidate(lhsCandidate, op(lhsTrue, rhsTrue))
-			results.PushBack(boolResult)
+		rhsTrue, errDecoding := isTruthy(rhs)
+		if errDecoding != nil {
+			return nil, errDecoding
 		}
+
+		return createBooleanCandidate(lhs, op(lhsTrue, rhsTrue)), nil
 	}
-	return nil
-}
-
-func booleanOp(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode, op boolOp) (*list.List, error) {
-	var results = list.New()
-
-	if matchingNodes.Len() == 0 {
-		lhs, err := d.GetMatchingNodes(list.New(), pathNode.Lhs)
-		if err != nil {
-			return nil, err
-		}
-		rhs, err := d.GetMatchingNodes(list.New(), pathNode.Rhs)
-		if err != nil {
-			return nil, err
-		}
-		return results, performBoolOp(results, lhs, rhs, op)
-	}
-
-	for el := matchingNodes.Front(); el != nil; el = el.Next() {
-		candidate := el.Value.(*CandidateNode)
-		lhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Lhs)
-		if err != nil {
-			return nil, err
-		}
-		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
-		if err != nil {
-			return nil, err
-		}
-
-		err = performBoolOp(results, lhs, rhs, op)
-		if err != nil {
-			return nil, err
-		}
-
-	}
-	return results, nil
 }

 func OrOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- orOp")
-	return booleanOp(d, matchingNodes, pathNode, func(b1 bool, b2 bool) bool {
-		return b1 || b2
-	})
+	return crossFunction(d, matchingNodes, pathNode, performBoolOp(
+		func(b1 bool, b2 bool) bool {
+			return b1 || b2
+		}))
 }

 func AndOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- AndOp")
-	return booleanOp(d, matchingNodes, pathNode, func(b1 bool, b2 bool) bool {
-		return b1 && b2
-	})
+	return crossFunction(d, matchingNodes, pathNode, performBoolOp(
+		func(b1 bool, b2 bool) bool {
+			return b1 && b2
+		}))
 }

 func NotOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
--- a/pkg/yqlib/operator_collect_object.go
+++ b/pkg/yqlib/operator_collect_object.go
@@ -55,7 +55,7 @@ func CollectObjectOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *
 func createChildCandidate(candidate *CandidateNode, index int) *CandidateNode {
 	return &CandidateNode{
 		Document: candidate.Document,
-		Path:     append(candidate.Path, index),
+		Path:     candidate.CreateChildPath(index),
 		Filename: candidate.Filename,
 		Node:     candidate.Node.Content[index],
 	}
@@ -67,7 +67,9 @@ func collect(d *dataTreeNavigator, aggregate *list.List, remainingMatches *list.
 	}

 	candidate := remainingMatches.Remove(remainingMatches.Front()).(*CandidateNode)
-	splatted, err := Splat(d, nodeToMap(candidate))
+
+	splatted, err := Splat(d, nodeToMap(candidate),
+		&TraversePreferences{FollowAlias: false, IncludeMapKeys: false})

 	for splatEl := splatted.Front(); splatEl != nil; splatEl = splatEl.Next() {
 		splatEl.Value.(*CandidateNode).Path = nil
--- a/pkg/yqlib/operator_delete.go
+++ b/pkg/yqlib/operator_delete.go
@@ -2,39 +2,67 @@ package yqlib

 import (
 	"container/list"
+	"fmt"

 	yaml "gopkg.in/yaml.v3"
 )

 func DeleteChildOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
-	// for each lhs, splat the node,
-	// the intersect it against the rhs expression
-	// recreate the contents using only the intersection result.

-	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+	nodesToDelete, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for el := nodesToDelete.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		elMap := list.New()
-		elMap.PushBack(candidate)
-		nodesToDelete, err := d.GetMatchingNodes(elMap, pathNode.Rhs)
-		log.Debug("nodesToDelete:\n%v", NodesToString(nodesToDelete))
-		if err != nil {
-			return nil, err
+
+		deleteImmediateChildOp := &Operation{
+			OperationType: DeleteImmediateChild,
+			Value:         candidate.Path[len(candidate.Path)-1],
 		}

-		realNode := UnwrapDoc(candidate.Node)
+		deleteImmediateChildOpNode := &PathTreeNode{
+			Operation: deleteImmediateChildOp,
+			Rhs:       createTraversalTree(candidate.Path[0 : len(candidate.Path)-1]),
+		}

-		if realNode.Kind == yaml.SequenceNode {
-			deleteFromArray(candidate, nodesToDelete)
-		} else if realNode.Kind == yaml.MappingNode {
-			deleteFromMap(candidate, nodesToDelete)
-		} else {
-			log.Debug("Cannot delete from node that's not a map or array %v", NodeToString(candidate))
+		_, err := d.GetMatchingNodes(matchingNodes, deleteImmediateChildOpNode)
+		if err != nil {
+			return nil, err
 		}
 	}
 	return matchingNodes, nil
 }

-func deleteFromMap(candidate *CandidateNode, nodesToDelete *list.List) {
+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)
+		} else if parentNode.Kind == yaml.SequenceNode {
+			deleteFromArray(parent, childPath)
+		} else {
+			return nil, fmt.Errorf("Cannot delete nodes from parent of tag %v", parentNode.Tag)
+		}
+
+	}
+	return matchingNodes, nil
+}
+
+func deleteFromMap(candidate *CandidateNode, childPath interface{}) {
 	log.Debug("deleteFromMap")
 	node := UnwrapDoc(candidate.Node)
 	contents := node.Content
@@ -47,15 +75,10 @@ func deleteFromMap(candidate *CandidateNode, nodesToDelete *list.List) {
 		childCandidate := &CandidateNode{
 			Node:     value,
 			Document: candidate.Document,
-			Path:     append(candidate.Path, key.Value),
+			Path:     candidate.CreateChildPath(key.Value),
 		}

-		shouldDelete := false
-		for el := nodesToDelete.Front(); el != nil && !shouldDelete; el = el.Next() {
-			if el.Value.(*CandidateNode).GetKey() == childCandidate.GetKey() {
-				shouldDelete = true
-			}
-		}
+		shouldDelete := key.Value == childPath

 		log.Debugf("shouldDelete %v ? %v", childCandidate.GetKey(), shouldDelete)

@@ -66,7 +89,7 @@ func deleteFromMap(candidate *CandidateNode, nodesToDelete *list.List) {
 	node.Content = newContents
 }

-func deleteFromArray(candidate *CandidateNode, nodesToDelete *list.List) {
+func deleteFromArray(candidate *CandidateNode, childPath interface{}) {
 	log.Debug("deleteFromArray")
 	node := UnwrapDoc(candidate.Node)
 	contents := node.Content
@@ -75,18 +98,7 @@ func deleteFromArray(candidate *CandidateNode, nodesToDelete *list.List) {
 	for index := 0; index < len(contents); index = index + 1 {
 		value := contents[index]

-		childCandidate := &CandidateNode{
-			Node:     value,
-			Document: candidate.Document,
-			Path:     append(candidate.Path, index),
-		}
-
-		shouldDelete := false
-		for el := nodesToDelete.Front(); el != nil && !shouldDelete; el = el.Next() {
-			if el.Value.(*CandidateNode).GetKey() == childCandidate.GetKey() {
-				shouldDelete = true
-			}
-		}
+		shouldDelete := fmt.Sprintf("%v", index) == fmt.Sprintf("%v", childPath)

 		if !shouldDelete {
 			newContents = append(newContents, value)
--- a/pkg/yqlib/operator_delete_test.go
+++ b/pkg/yqlib/operator_delete_test.go
@@ -13,6 +13,22 @@ var deleteOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{a: cat}\n",
 		},
 	},
+	{
+		description: "Delete nested entry in map",
+		document:    `{a: {a1: fred, a2: frood}}`,
+		expression:  `del(.a.a1)`,
+		expected: []string{
+			"D0, P[], (doc)::{a: {a2: frood}}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: {a1: fred, a2: frood}}`,
+		expression: `del(.. | select(.=="frood"))`,
+		expected: []string{
+			"D0, P[], (!!map)::{a: {a1: fred}}\n",
+		},
+	},
 	{
 		description: "Delete entry in array",
 		document:    `[1,2,3]`,
@@ -21,6 +37,14 @@ var deleteOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::[1, 3]\n",
 		},
 	},
+	{
+		description: "Delete nested entry in array",
+		document:    `[{a: cat, b: dog}]`,
+		expression:  `del(.[0].a)`,
+		expected: []string{
+			"D0, P[], (doc)::[{b: dog}]\n",
+		},
+	},
 	{
 		description: "Delete no matches",
 		document:    `{a: cat, b: dog}`,
--- a/pkg/yqlib/operator_keys.go
+++ b/pkg/yqlib/operator_keys.go
@@ -0,0 +1,34 @@
+package yqlib
+
+import (
+	"container/list"
+	"fmt"
+
+	yaml "gopkg.in/yaml.v3"
+)
+
+func KeysOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	log.Debugf("-- KeyOperation")
+	var results = list.New()
+
+	for el := matchMap.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		targetNode := UnwrapDoc(candidate.Node)
+
+		switch targetNode.Kind {
+		case yaml.MappingNode:
+			node := &yaml.Node{Kind: yaml.SequenceNode, Value: fmt.Sprintf("%v", length), Tag: "!!int"}
+
+		case yaml.SequenceNode:
+			length = len(targetNode.Content)
+		default:
+			length = 0
+		}
+
+		node := &yaml.Node{Kind: yaml.ScalarNode, Value: fmt.Sprintf("%v", length), Tag: "!!int"}
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
+	}
+
+	return results, nil
+}
--- a/pkg/yqlib/operator_keys_test.go
+++ b/pkg/yqlib/operator_keys_test.go
@@ -0,0 +1,88 @@
+package yqlib
+
+import (
+	"testing"
+)
+
+var keyOperatorScenarios = []expressionScenario{
+	{
+		description: "Get Keys of map",
+		document:    `{a: {b: cat, c: dog, d: frog}}`,
+		expression:  `.a | keys`,
+		expected: []string{
+			"D0, P[a], (!!seq)::- b\n- c\n- d\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a1: {b: cat, c: dog, d: frog}, a2: {e: cat, f: dog, g: frog}}`,
+		expression: `(.a1, .a2) | keys`,
+		expected: []string{
+			"D0, P[a1], (!!seq)::- b\n- c\n- d\n",
+			"D0, P[a2], (!!seq)::- e\n- f\n- g\n",
+		},
+	},
+	{
+		description: "Get Keys of array",
+		document:    `{a: [0,1,2]}`,
+		expression:  `.a | keys`,
+		expected: []string{
+			"D0, P[a], (!!seq)::0\n",
+			"D0, P[a], (!!int)::1\n",
+			"D0, P[a], (!!int)::2\n",
+		},
+	},
+	{
+		description: "Set key style",
+		document:    `{a: {b: cat, c: dog, d: frog}}`,
+		expression:  `(.a | keys | ..) style = 'single'`,
+		expected: []string{
+			"D0, P[], (!!doc)::{a: {'b': cat, 'c': dog, 'd': frog}}\n",
+		},
+	},
+	{
+		description: "Set key alias",
+		document:    `{a: {b: cat, c: dog, d: frog}}`,
+		expression:  `(.a | keys | .. | select(.=="b")) alias = 'boo'`,
+		expected: []string{
+			"D0, P[], (!!doc)::{a: {*meow: cat, c: dog, d: frog}}\n",
+		},
+	},
+	{
+		description: "Set key alias",
+		document:    `{a: {b: cat, c: dog, d: frog}}`,
+		expression:  `(.a | key("b")) alias = 'boo'`,
+		expected: []string{
+			"D0, P[], (!!doc)::{a: {*meow: cat, c: dog, d: frog}}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [0,1,2]}`,
+		expression: `(.a | keys) style = 'single'`,
+		expected: []string{
+			"D0, P[a], (!!int)::0\n",
+			"D0, P[a], (!!int)::1\n",
+			"D0, P[a], (!!int)::2\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `a: cat`,
+		expression: `.a | keys`,
+		expected:   []string{},
+	},
+	{
+		skipDoc:    true,
+		document:   `{}`,
+		expression: `.a | keys`,
+		expected:   []string{},
+	},
+}
+
+func TestKeyOperatorScenarios(t *testing.T) {
+	for _, tt := range keyOperatorScenarios {
+		testScenario(t, &tt)
+	}
+	documentScenarios(t, "Keys", keyOperatorScenarios)
+}
--- a/pkg/yqlib/operator_multiply.go
+++ b/pkg/yqlib/operator_multiply.go
@@ -85,7 +85,9 @@ func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode,
 	var results = list.New()

 	// shouldn't recurse arrays if appending
-	err := recursiveDecent(d, results, nodeToMap(rhs), !shouldAppendArrays)
+	prefs := &RecursiveDescentPreferences{RecurseArray: !shouldAppendArrays,
+		TraversePreferences: &TraversePreferences{FollowAlias: false}}
+	err := recursiveDecent(d, results, nodeToMap(rhs), prefs)
 	if err != nil {
 		return nil, err
 	}
@@ -104,19 +106,6 @@ func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode,
 	return lhs, nil
 }

-func createTraversalTree(path []interface{}) *PathTreeNode {
-	if len(path) == 0 {
-		return &PathTreeNode{Operation: &Operation{OperationType: SelfReference}}
-	} else if len(path) == 1 {
-		return &PathTreeNode{Operation: &Operation{OperationType: TraversePath, Value: path[0], StringValue: fmt.Sprintf("%v", path[0])}}
-	}
-	return &PathTreeNode{
-		Operation: &Operation{OperationType: ShortPipe},
-		Lhs:       createTraversalTree(path[0:1]),
-		Rhs:       createTraversalTree(path[1:])}
-
-}
-
 func applyAssignment(d *dataTreeNavigator, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, shouldAppendArrays bool) error {

 	log.Debugf("merge - applyAssignment lhs %v, rhs: %v", NodeToString(lhs), NodeToString(rhs))
--- a/pkg/yqlib/operator_path_test.go
+++ b/pkg/yqlib/operator_path_test.go
@@ -13,6 +13,23 @@ var pathOperatorScenarios = []expressionScenario{
 			"D0, P[a b], (!!seq)::- a\n- b\n",
 		},
 	},
+	{
+		skipDoc: true,
+		document: `a:
+  b:
+    c:
+    - 0
+    - 1
+    - 2
+    - 3`,
+		expression: `.a.b.c.[]`,
+		expected: []string{
+			"D0, P[a b c 0], (!!int)::0\n",
+			"D0, P[a b c 1], (!!int)::1\n",
+			"D0, P[a b c 2], (!!int)::2\n",
+			"D0, P[a b c 3], (!!int)::3\n",
+		},
+	},
 	{
 		description: "Get map key",
 		document:    `{a: {b: cat}}`,
--- a/pkg/yqlib/operator_recursive_descent.go
+++ b/pkg/yqlib/operator_recursive_descent.go
@@ -6,10 +6,16 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

+type RecursiveDescentPreferences struct {
+	TraversePreferences *TraversePreferences
+	RecurseArray        bool
+}
+
 func RecursiveDescentOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	var results = list.New()

-	err := recursiveDecent(d, results, matchMap, true)
+	preferences := pathNode.Operation.Preferences.(*RecursiveDescentPreferences)
+	err := recursiveDecent(d, results, matchMap, preferences)
 	if err != nil {
 		return nil, err
 	}
@@ -17,7 +23,7 @@ func RecursiveDescentOperator(d *dataTreeNavigator, matchMap *list.List, pathNod
 	return results, nil
 }

-func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.List, recurseArray bool) error {
+func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.List, preferences *RecursiveDescentPreferences) error {
 	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)

@@ -27,14 +33,14 @@ func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.Li
 		results.PushBack(candidate)

 		if candidate.Node.Kind != yaml.AliasNode && len(candidate.Node.Content) > 0 &&
-			(recurseArray || candidate.Node.Kind != yaml.SequenceNode) {
+			(preferences.RecurseArray || candidate.Node.Kind != yaml.SequenceNode) {

-			children, err := Splat(d, nodeToMap(candidate))
+			children, err := Splat(d, nodeToMap(candidate), preferences.TraversePreferences)

 			if err != nil {
 				return err
 			}
-			err = recursiveDecent(d, results, children, recurseArray)
+			err = recursiveDecent(d, results, children, preferences)
 			if err != nil {
 				return err
 			}
--- a/pkg/yqlib/operator_recursive_descent_test.go
+++ b/pkg/yqlib/operator_recursive_descent_test.go
@@ -13,6 +13,14 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!map)::{}\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `{}`,
+		expression: `...`,
+		expected: []string{
+			"D0, P[], (!!map)::{}\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `[]`,
@@ -21,6 +29,14 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!seq)::[]\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `[]`,
+		expression: `...`,
+		expected: []string{
+			"D0, P[], (!!seq)::[]\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `cat`,
@@ -31,13 +47,32 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 	},
 	{
 		skipDoc:    true,
-		document:   `{a: frog}`,
-		expression: `..`,
+		document:   `cat`,
+		expression: `...`,
+		expected: []string{
+			"D0, P[], (!!str)::cat\n",
+		},
+	},
+	{
+		description: "Recurse map (values only)",
+		document:    `{a: frog}`,
+		expression:  `..`,
 		expected: []string{
 			"D0, P[], (!!map)::{a: frog}\n",
 			"D0, P[a], (!!str)::frog\n",
 		},
 	},
+	{
+		description:    "Recurse map (values and keys)",
+		subdescription: "Note that the map key appears in the results",
+		document:       `{a: frog}`,
+		expression:     `...`,
+		expected: []string{
+			"D0, P[], (!!map)::{a: frog}\n",
+			"D0, P[a], (!!str)::a\n",
+			"D0, P[a], (!!str)::frog\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `{a: {b: apple}}`,
@@ -48,6 +83,18 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[a b], (!!str)::apple\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `{a: {b: apple}}`,
+		expression: `...`,
+		expected: []string{
+			"D0, P[], (!!map)::{a: {b: apple}}\n",
+			"D0, P[a], (!!str)::a\n",
+			"D0, P[a], (!!map)::{b: apple}\n",
+			"D0, P[a b], (!!str)::b\n",
+			"D0, P[a b], (!!str)::apple\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `[1,2,3]`,
@@ -59,6 +106,17 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[2], (!!int)::3\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `[1,2,3]`,
+		expression: `...`,
+		expected: []string{
+			"D0, P[], (!!seq)::[1, 2, 3]\n",
+			"D0, P[0], (!!int)::1\n",
+			"D0, P[1], (!!int)::2\n",
+			"D0, P[2], (!!int)::3\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `[{a: cat},2,true]`,
@@ -71,6 +129,19 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[2], (!!bool)::true\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `[{a: cat},2,true]`,
+		expression: `...`,
+		expected: []string{
+			"D0, P[], (!!seq)::[{a: cat}, 2, true]\n",
+			"D0, P[0], (!!map)::{a: cat}\n",
+			"D0, P[0 a], (!!str)::a\n",
+			"D0, P[0 a], (!!str)::cat\n",
+			"D0, P[1], (!!int)::2\n",
+			"D0, P[2], (!!bool)::true\n",
+		},
+	},
 	{
 		description: "Aliases are not traversed",
 		document:    `{a: &cat {c: frog}, b: *cat}`,
@@ -79,6 +150,20 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[a], (!!seq)::- {a: &cat {c: frog}, b: *cat}\n- &cat {c: frog}\n- frog\n- *cat\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `{a: &cat {c: frog}, b: *cat}`,
+		expression: `...`,
+		expected: []string{
+			"D0, P[], (!!map)::{a: &cat {c: frog}, b: *cat}\n",
+			"D0, P[a], (!!str)::a\n",
+			"D0, P[a], (!!map)::&cat {c: frog}\n",
+			"D0, P[a c], (!!str)::c\n",
+			"D0, P[a c], (!!str)::frog\n",
+			"D0, P[b], (!!str)::b\n",
+			"D0, P[b], (alias)::*cat\n",
+		},
+	},
 	{
 		description: "Merge docs are not traversed",
 		document:    mergeDocSample,
@@ -87,6 +172,14 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[foobar], (!!seq)::- c: foobar_c\n  !!merge <<: *foo\n  thing: foobar_thing\n- foobar_c\n- *foo\n- foobar_thing\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   mergeDocSample,
+		expression: `.foobar | [...]`,
+		expected: []string{
+			"D0, P[foobar], (!!seq)::- c: foobar_c\n  !!merge <<: *foo\n  thing: foobar_thing\n- c\n- foobar_c\n- !!merge <<\n- *foo\n- thing\n- foobar_thing\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   mergeDocSample,
@@ -100,6 +193,22 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[foobarList c], (!!str)::foobarList_c\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   mergeDocSample,
+		expression: `.foobarList | ...`,
+		expected: []string{
+			"D0, P[foobarList], (!!map)::b: foobarList_b\n!!merge <<: [*foo, *bar]\nc: foobarList_c\n",
+			"D0, P[foobarList b], (!!str)::b\n",
+			"D0, P[foobarList b], (!!str)::foobarList_b\n",
+			"D0, P[foobarList <<], (!!merge)::!!merge <<\n",
+			"D0, P[foobarList <<], (!!seq)::[*foo, *bar]\n",
+			"D0, P[foobarList << 0], (alias)::*foo\n",
+			"D0, P[foobarList << 1], (alias)::*bar\n",
+			"D0, P[foobarList c], (!!str)::c\n",
+			"D0, P[foobarList c], (!!str)::foobarList_c\n",
+		},
+	},
 }

 func TestRecursiveDescentOperatorScenarios(t *testing.T) {
--- a/pkg/yqlib/operator_style_test.go
+++ b/pkg/yqlib/operator_style_test.go
@@ -21,6 +21,22 @@ var styleOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!map)::a: \"cat\"\nb: \"5\"\nc: \"3.2\"\ne: \"true\"\n",
 		},
 	},
+	{
+		description: "Set double quote style on map keys too",
+		document:    `{a: cat, b: 5, c: 3.2, e: true}`,
+		expression:  `... style="double"`,
+		expected: []string{
+			"D0, P[], (!!map)::\"a\": \"cat\"\n\"b\": \"5\"\n\"c\": \"3.2\"\n\"e\": \"true\"\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   "bing: &foo frog\na:\n  c: cat\n  <<: [*foo]",
+		expression: `(... | select(tag=="!!str")) style="single"`,
+		expected: []string{
+			"D0, P[], (!!map)::'bing': &foo 'frog'\n'a':\n    'c': 'cat'\n    !!merge <<: [*foo]\n",
+		},
+	},
 	{
 		description: "Set single quote style",
 		document:    `{a: cat, b: 5, c: 3.2, e: true}`,
@@ -71,9 +87,9 @@ e: >-
 	},
 	{
 		description:    "Pretty print",
-		subdescription: "Set empty (default) quote style",
-		document:       `{a: cat, b: 5, c: 3.2, e: true}`,
-		expression:     `.. style=""`,
+		subdescription: "Set empty (default) quote style, note the usage of `...` to match keys too. Note that there is a `--prettyPrint/-P` short flag for this.",
+		document:       `{a: cat, "b": 5, 'c': 3.2, "e": true}`,
+		expression:     `... style=""`,
 		expected: []string{
 			"D0, P[], (!!map)::a: cat\nb: 5\nc: 3.2\ne: true\n",
 		},
--- a/pkg/yqlib/operator_traverse_path.go
+++ b/pkg/yqlib/operator_traverse_path.go
@@ -1,46 +1,39 @@
 package yqlib

 import (
-	"fmt"
-
 	"container/list"
+	"fmt"
+	"strconv"

 	"github.com/elliotchance/orderedmap"
-
-	"gopkg.in/yaml.v3"
+	yaml "gopkg.in/yaml.v3"
 )

 type TraversePreferences struct {
-	DontFollowAlias bool
+	FollowAlias    bool
+	IncludeMapKeys bool
 }

-func Splat(d *dataTreeNavigator, matches *list.List) (*list.List, error) {
-	preferences := &TraversePreferences{DontFollowAlias: true}
-	splatOperation := &Operation{OperationType: TraversePath, Value: "[]", Preferences: preferences}
-	splatTreeNode := &PathTreeNode{Operation: splatOperation}
-	return TraversePathOperator(d, matches, splatTreeNode)
+func Splat(d *dataTreeNavigator, matches *list.List, prefs *TraversePreferences) (*list.List, error) {
+	return traverseNodesWithArrayIndices(matches, make([]*yaml.Node, 0), prefs)
 }

 func TraversePathOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- Traversing")
 	var matchingNodeMap = list.New()
-	var newNodes []*CandidateNode
-	var err error

 	for el := matchMap.Front(); el != nil; el = el.Next() {
-		newNodes, err = traverse(d, el.Value.(*CandidateNode), pathNode.Operation)
+		newNodes, err := traverse(d, el.Value.(*CandidateNode), pathNode.Operation)
 		if err != nil {
 			return nil, err
 		}
-		for _, n := range newNodes {
-			matchingNodeMap.PushBack(n)
-		}
+		matchingNodeMap.PushBackList(newNodes)
 	}

 	return matchingNodeMap, nil
 }

-func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Operation) ([]*CandidateNode, error) {
+func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Operation) (*list.List, error) {
 	log.Debug("Traversing %v", NodeToString(matchingNode))
 	value := matchingNode.Node

@@ -61,34 +54,8 @@ func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Oper
 	switch value.Kind {
 	case yaml.MappingNode:
 		log.Debug("its a map with %v entries", len(value.Content)/2)
-		var newMatches = orderedmap.NewOrderedMap()
-		err := traverseMap(newMatches, matchingNode, operation)
-
-		if err != nil {
-			return nil, err
-		}
-
-		if newMatches.Len() == 0 {
-			//no matches, create one automagically
-			valueNode := &yaml.Node{Tag: "!!null", Kind: yaml.ScalarNode, Value: "null"}
-			node := matchingNode.Node
-			node.Content = append(node.Content, &yaml.Node{Kind: yaml.ScalarNode, Value: operation.StringValue}, valueNode)
-			candidateNode := &CandidateNode{
-				Node:     valueNode,
-				Path:     append(matchingNode.Path, operation.StringValue),
-				Document: matchingNode.Document,
-			}
-			newMatches.Set(candidateNode.GetKey(), candidateNode)
-
-		}
-
-		arrayMatches := make([]*CandidateNode, newMatches.Len())
-		i := 0
-		for el := newMatches.Front(); el != nil; el = el.Next() {
-			arrayMatches[i] = el.Value.(*CandidateNode)
-			i++
-		}
-		return arrayMatches, nil
+		prefs := &TraversePreferences{FollowAlias: true}
+		return traverseMap(matchingNode, operation.StringValue, prefs, false)

 	case yaml.SequenceNode:
 		log.Debug("its a sequence of %v things!", len(value.Content))
@@ -101,105 +68,118 @@ func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Oper
 	case yaml.DocumentNode:
 		log.Debug("digging into doc node")
 		return traverse(d, &CandidateNode{
-			Node:     matchingNode.Node.Content[0],
-			Document: matchingNode.Document}, operation)
+			Node:      matchingNode.Node.Content[0],
+			Filename:  matchingNode.Filename,
+			FileIndex: matchingNode.FileIndex,
+			Document:  matchingNode.Document}, operation)
 	default:
-		return nil, nil
+		return list.New(), nil
 	}
 }

-func keyMatches(key *yaml.Node, pathNode *Operation) bool {
-	return pathNode.Value == "[]" || Match(key.Value, pathNode.StringValue)
-}
+func TraverseArrayOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	// rhs is a collect expression that will yield indexes to retreive of the arrays

-func traverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode, operation *Operation) error {
-	// value.Content is a concatenated array of key, value,
-	// so keys are in the even indexes, values in odd.
-	// merge aliases are defined first, but we only want to traverse them
-	// if we don't find a match directly on this node first.
-	//TODO ALIASES, auto creation?
-
-	node := candidate.Node
-
-	followAlias := true
-
-	if operation.Preferences != nil {
-		followAlias = !operation.Preferences.(*TraversePreferences).DontFollowAlias
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	if err != nil {
+		return nil, err
 	}

-	var contents = node.Content
-	for index := 0; index < len(contents); index = index + 2 {
-		key := contents[index]
-		value := contents[index+1]
+	var indicesToTraverse = rhs.Front().Value.(*CandidateNode).Node.Content
+	prefs := &TraversePreferences{FollowAlias: true}
+	return traverseNodesWithArrayIndices(matchingNodes, indicesToTraverse, prefs)
+}

-		log.Debug("checking %v (%v)", key.Value, key.Tag)
-		//skip the 'merge' tag, find a direct match first
-		if key.Tag == "!!merge" && followAlias {
-			log.Debug("Merge anchor")
-			err := traverseMergeAnchor(newMatches, candidate, value, operation)
-			if err != nil {
-				return err
-			}
-		} else if keyMatches(key, operation) {
-			log.Debug("MATCHED")
-			candidateNode := &CandidateNode{
-				Node:     value,
-				Path:     append(candidate.Path, key.Value),
-				Document: candidate.Document,
-			}
-			newMatches.Set(candidateNode.GetKey(), candidateNode)
+func traverseNodesWithArrayIndices(matchingNodes *list.List, indicesToTraverse []*yaml.Node, prefs *TraversePreferences) (*list.List, error) {
+	var matchingNodeMap = list.New()
+	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		newNodes, err := traverseArrayIndices(candidate, indicesToTraverse, prefs)
+		if err != nil {
+			return nil, err
 		}
+		matchingNodeMap.PushBackList(newNodes)
 	}

-	return nil
+	return matchingNodeMap, nil
 }

-func traverseMergeAnchor(newMatches *orderedmap.OrderedMap, originalCandidate *CandidateNode, value *yaml.Node, operation *Operation) error {
-	switch value.Kind {
-	case yaml.AliasNode:
-		candidateNode := &CandidateNode{
-			Node:     value.Alias,
-			Path:     originalCandidate.Path,
-			Document: originalCandidate.Document,
-		}
-		return traverseMap(newMatches, candidateNode, operation)
-	case yaml.SequenceNode:
-		for _, childValue := range value.Content {
-			err := traverseMergeAnchor(newMatches, originalCandidate, childValue, operation)
-			if err != nil {
-				return err
-			}
-		}
+func traverseArrayIndices(matchingNode *CandidateNode, indicesToTraverse []*yaml.Node, prefs *TraversePreferences) (*list.List, error) { // call this if doc / alias like the other traverse
+	node := matchingNode.Node
+	if node.Tag == "!!null" {
+		log.Debugf("OperatorArrayTraverse got a null - turning it into an empty array")
+		// auto vivification, make it into an empty array
+		node.Tag = ""
+		node.Kind = yaml.SequenceNode
 	}
-	return nil
+
+	if node.Kind == yaml.AliasNode {
+		matchingNode.Node = node.Alias
+		return traverseArrayIndices(matchingNode, indicesToTraverse, prefs)
+	} else if node.Kind == yaml.SequenceNode {
+		return traverseArrayWithIndices(matchingNode, indicesToTraverse)
+	} else if node.Kind == yaml.MappingNode {
+		return traverseMapWithIndices(matchingNode, indicesToTraverse, prefs)
+	} else if node.Kind == yaml.DocumentNode {
+		return traverseArrayIndices(&CandidateNode{
+			Node:      matchingNode.Node.Content[0],
+			Filename:  matchingNode.Filename,
+			FileIndex: matchingNode.FileIndex,
+			Document:  matchingNode.Document}, indicesToTraverse, prefs)
+	}
+	log.Debugf("OperatorArrayTraverse skipping %v as its a %v", matchingNode, node.Tag)
+	return list.New(), nil
 }

-func traverseArray(candidate *CandidateNode, operation *Operation) ([]*CandidateNode, error) {
-	log.Debug("operation Value %v", operation.Value)
-	if operation.Value == "[]" {
+func traverseMapWithIndices(candidate *CandidateNode, indices []*yaml.Node, prefs *TraversePreferences) (*list.List, error) {
+	if len(indices) == 0 {
+		return traverseMap(candidate, "", prefs, true)
+	}

-		var contents = candidate.Node.Content
-		var newMatches = make([]*CandidateNode, len(contents))
+	var matchingNodeMap = list.New()
+
+	for _, indexNode := range indices {
+		log.Debug("traverseMapWithIndices: %v", indexNode.Value)
+		newNodes, err := traverseMap(candidate, indexNode.Value, prefs, false)
+		if err != nil {
+			return nil, err
+		}
+		matchingNodeMap.PushBackList(newNodes)
+	}
+
+	return matchingNodeMap, nil
+}
+
+func traverseArrayWithIndices(candidate *CandidateNode, indices []*yaml.Node) (*list.List, error) {
+	log.Debug("traverseArrayWithIndices")
+	var newMatches = list.New()
+	node := UnwrapDoc(candidate.Node)
+	if len(indices) == 0 {
+		log.Debug("splatting")
 		var index int64
-		for index = 0; index < int64(len(contents)); index = index + 1 {
-			newMatches[index] = &CandidateNode{
+		for index = 0; index < int64(len(node.Content)); index = index + 1 {
+
+			newMatches.PushBack(&CandidateNode{
 				Document: candidate.Document,
-				Path:     append(candidate.Path, index),
-				Node:     contents[index],
-			}
+				Path:     candidate.CreateChildPath(index),
+				Node:     node.Content[index],
+			})
 		}
 		return newMatches, nil

 	}

-	switch operation.Value.(type) {
-	case int64:
-		index := operation.Value.(int64)
+	for _, indexNode := range indices {
+		log.Debug("traverseArrayWithIndices: '%v'", indexNode.Value)
+		index, err := strconv.ParseInt(indexNode.Value, 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("Cannot index array with '%v' (%v)", indexNode.Value, err)
+		}
 		indexToUse := index
-		contentLength := int64(len(candidate.Node.Content))
+		contentLength := int64(len(node.Content))
 		for contentLength <= index {
-			candidate.Node.Content = append(candidate.Node.Content, &yaml.Node{Tag: "!!null", Kind: yaml.ScalarNode, Value: "null"})
-			contentLength = int64(len(candidate.Node.Content))
+			node.Content = append(node.Content, &yaml.Node{Tag: "!!null", Kind: yaml.ScalarNode, Value: "null"})
+			contentLength = int64(len(node.Content))
 		}

 		if indexToUse < 0 {
@@ -210,14 +190,115 @@ func traverseArray(candidate *CandidateNode, operation *Operation) ([]*Candidate
 			return nil, fmt.Errorf("Index [%v] out of range, array size is %v", index, contentLength)
 		}

-		return []*CandidateNode{&CandidateNode{
-			Node:     candidate.Node.Content[indexToUse],
+		newMatches.PushBack(&CandidateNode{
+			Node:     node.Content[indexToUse],
 			Document: candidate.Document,
-			Path:     append(candidate.Path, index),
-		}}, nil
-	default:
-		log.Debug("argument not an int (%v), no array matches", operation.Value)
-		return nil, nil
+			Path:     candidate.CreateChildPath(index),
+		})
+	}
+	return newMatches, nil
+}
+
+func keyMatches(key *yaml.Node, wantedKey string) bool {
+	return Match(key.Value, wantedKey)
+}
+
+func traverseMap(matchingNode *CandidateNode, key string, prefs *TraversePreferences, splat bool) (*list.List, error) {
+	var newMatches = orderedmap.NewOrderedMap()
+	err := doTraverseMap(newMatches, matchingNode, key, prefs, splat)
+
+	if err != nil {
+		return nil, err
 	}

+	if newMatches.Len() == 0 {
+		//no matches, create one automagically
+		valueNode := &yaml.Node{Tag: "!!null", Kind: yaml.ScalarNode, Value: "null"}
+		node := matchingNode.Node
+		node.Content = append(node.Content, &yaml.Node{Kind: yaml.ScalarNode, Value: key}, valueNode)
+		candidateNode := &CandidateNode{
+			Node:     valueNode,
+			Path:     append(matchingNode.Path, key),
+			Document: matchingNode.Document,
+		}
+		newMatches.Set(candidateNode.GetKey(), candidateNode)
+
+	}
+
+	results := list.New()
+	i := 0
+	for el := newMatches.Front(); el != nil; el = el.Next() {
+		results.PushBack(el.Value)
+		i++
+	}
+	return results, nil
+}
+
+func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode, wantedKey string, prefs *TraversePreferences, splat bool) error {
+	// value.Content is a concatenated array of key, value,
+	// so keys are in the even indexes, values in odd.
+	// merge aliases are defined first, but we only want to traverse them
+	// if we don't find a match directly on this node first.
+
+	node := candidate.Node
+
+	var contents = node.Content
+	for index := 0; index < len(contents); index = index + 2 {
+		key := contents[index]
+		value := contents[index+1]
+
+		log.Debug("checking %v (%v)", key.Value, key.Tag)
+		//skip the 'merge' tag, find a direct match first
+		if key.Tag == "!!merge" && prefs.FollowAlias {
+			log.Debug("Merge anchor")
+			err := traverseMergeAnchor(newMatches, candidate, value, wantedKey, prefs, splat)
+			if err != nil {
+				return err
+			}
+		} else if splat || keyMatches(key, wantedKey) {
+			log.Debug("MATCHED")
+			if prefs.IncludeMapKeys {
+				candidateNode := &CandidateNode{
+					Node:     key,
+					Path:     candidate.CreateChildPath(key.Value),
+					Document: candidate.Document,
+				}
+				newMatches.Set(fmt.Sprintf("keyOf-%v", candidateNode.GetKey()), candidateNode)
+			}
+			candidateNode := &CandidateNode{
+				Node:     value,
+				Path:     candidate.CreateChildPath(key.Value),
+				Document: candidate.Document,
+			}
+			newMatches.Set(candidateNode.GetKey(), candidateNode)
+		}
+	}
+
+	return nil
+}
+
+func traverseMergeAnchor(newMatches *orderedmap.OrderedMap, originalCandidate *CandidateNode, value *yaml.Node, wantedKey string, prefs *TraversePreferences, splat bool) error {
+	switch value.Kind {
+	case yaml.AliasNode:
+		candidateNode := &CandidateNode{
+			Node:     value.Alias,
+			Path:     originalCandidate.Path,
+			Document: originalCandidate.Document,
+		}
+		return doTraverseMap(newMatches, candidateNode, wantedKey, prefs, splat)
+	case yaml.SequenceNode:
+		for _, childValue := range value.Content {
+			err := traverseMergeAnchor(newMatches, originalCandidate, childValue, wantedKey, prefs, splat)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func traverseArray(candidate *CandidateNode, operation *Operation) (*list.List, error) {
+	log.Debug("operation Value %v", operation.Value)
+	indices := []*yaml.Node{&yaml.Node{Value: operation.StringValue}}
+	return traverseArrayWithIndices(candidate, indices)
 }
--- a/pkg/yqlib/operator_traverse_path_test.go
+++ b/pkg/yqlib/operator_traverse_path_test.go
@@ -65,7 +65,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	},
 	{
 		skipDoc:    true,
-		document:   `{}`,
+		document:   ``,
 		expression: `.[1].a`,
 		expected: []string{
 			"D0, P[1 a], (!!null)::null\n",
@@ -137,7 +137,15 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		description: "Traversing aliases with splat",
 		document:    `{a: &cat {c: frog}, b: *cat}`,
-		expression:  `.b.[]`,
+		expression:  `.b[]`,
+		expected: []string{
+			"D0, P[b c], (!!str)::frog\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: &cat {c: frog}, b: *cat}`,
+		expression: `.b.[]`,
 		expected: []string{
 			"D0, P[b c], (!!str)::frog\n",
 		},
@@ -150,12 +158,6 @@ var traversePathOperatorScenarios = []expressionScenario{
 			"D0, P[b c], (!!str)::frog\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `[1,2,3]`,
-		expression: `.b`,
-		expected:   []string{},
-	},
 	{
 		description: "Traversing arrays by index",
 		document:    `[1,2,3]`,
@@ -215,7 +217,17 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		description: "Splatting merge anchors",
 		document:    mergeDocSample,
-		expression:  `.foobar.[]`,
+		expression:  `.foobar[]`,
+		expected: []string{
+			"D0, P[foobar c], (!!str)::foo_c\n",
+			"D0, P[foobar a], (!!str)::foo_a\n",
+			"D0, P[foobar thing], (!!str)::foobar_thing\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   mergeDocSample,
+		expression: `.foobar.[]`,
 		expected: []string{
 			"D0, P[foobar c], (!!str)::foo_c\n",
 			"D0, P[foobar a], (!!str)::foo_a\n",
@@ -266,7 +278,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		description: "Splatting merge anchor lists",
 		document:    mergeDocSample,
-		expression:  `.foobarList.[]`,
+		expression:  `.foobarList[]`,
 		expected: []string{
 			"D0, P[foobarList b], (!!str)::bar_b\n",
 			"D0, P[foobarList a], (!!str)::foo_a\n",
@@ -274,6 +286,123 @@ var traversePathOperatorScenarios = []expressionScenario{
 			"D0, P[foobarList c], (!!str)::foobarList_c\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   mergeDocSample,
+		expression: `.foobarList.[]`,
+		expected: []string{
+			"D0, P[foobarList b], (!!str)::bar_b\n",
+			"D0, P[foobarList a], (!!str)::foo_a\n",
+			"D0, P[foobarList thing], (!!str)::bar_thing\n",
+			"D0, P[foobarList c], (!!str)::foobarList_c\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `[a,b,c]`,
+		expression: `.[]`,
+		expected: []string{
+			"D0, P[0], (!!str)::a\n",
+			"D0, P[1], (!!str)::b\n",
+			"D0, P[2], (!!str)::c\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `[a,b,c]`,
+		expression: `[]`,
+		expected: []string{
+			"D0, P[], (!!seq)::[]\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a[0]`,
+		expected: []string{
+			"D0, P[a 0], (!!str)::a\n",
+		},
+	},
+	{
+		description: "Select multiple indices",
+		document:    `{a: [a,b,c]}`,
+		expression:  `.a[0, 2]`,
+		expected: []string{
+			"D0, P[a 0], (!!str)::a\n",
+			"D0, P[a 2], (!!str)::c\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a.[0, 2]`,
+		expected: []string{
+			"D0, P[a 0], (!!str)::a\n",
+			"D0, P[a 2], (!!str)::c\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a[-1]`,
+		expected: []string{
+			"D0, P[a -1], (!!str)::c\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a.[-1]`,
+		expected: []string{
+			"D0, P[a -1], (!!str)::c\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a[-2]`,
+		expected: []string{
+			"D0, P[a -2], (!!str)::b\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a.[-2]`,
+		expected: []string{
+			"D0, P[a -2], (!!str)::b\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a[]`,
+		expected: []string{
+			"D0, P[a 0], (!!str)::a\n",
+			"D0, P[a 1], (!!str)::b\n",
+			"D0, P[a 2], (!!str)::c\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a.[]`,
+		expected: []string{
+			"D0, P[a 0], (!!str)::a\n",
+			"D0, P[a 1], (!!str)::b\n",
+			"D0, P[a 2], (!!str)::c\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a | .[]`,
+		expected: []string{
+			"D0, P[a 0], (!!str)::a\n",
+			"D0, P[a 1], (!!str)::b\n",
+			"D0, P[a 2], (!!str)::c\n",
+		},
+	},
 }

 func TestTraversePathOperatorScenarios(t *testing.T) {
--- a/pkg/yqlib/operator_value_test.go
+++ b/pkg/yqlib/operator_value_test.go
@@ -36,13 +36,22 @@ var valueOperatorScenarios = []expressionScenario{
 		expected: []string{
 			"D0, P[], (!!float)::5e-10\n",
 		},
-	}, {
+	},
+	{
 		document:   ``,
 		expression: `"cat"`,
 		expected: []string{
 			"D0, P[], (!!str)::cat\n",
 		},
-	}, {
+	},
+	{
+		document:   ``,
+		expression: `"frog jumps"`,
+		expected: []string{
+			"D0, P[], (!!str)::frog jumps\n",
+		},
+	},
+	{
 		document:   ``,
 		expression: `"1.3"`,
 		expected: []string{
--- a/pkg/yqlib/operators.go
+++ b/pkg/yqlib/operators.go
@@ -2,6 +2,7 @@ package yqlib

 import (
 	"container/list"
+	"fmt"

 	"gopkg.in/yaml.v3"
 )
@@ -33,3 +34,15 @@ func nodeToMap(candidate *CandidateNode) *list.List {
 	elMap.PushBack(candidate)
 	return elMap
 }
+
+func createTraversalTree(path []interface{}) *PathTreeNode {
+	if len(path) == 0 {
+		return &PathTreeNode{Operation: &Operation{OperationType: SelfReference}}
+	} else if len(path) == 1 {
+		return &PathTreeNode{Operation: &Operation{OperationType: TraversePath, Value: path[0], StringValue: fmt.Sprintf("%v", path[0])}}
+	}
+	return &PathTreeNode{
+		Operation: &Operation{OperationType: ShortPipe},
+		Lhs:       createTraversalTree(path[0:1]),
+		Rhs:       createTraversalTree(path[1:])}
+}
--- a/pkg/yqlib/operators_test.go
+++ b/pkg/yqlib/operators_test.go
@@ -38,7 +38,7 @@ func testScenario(t *testing.T, s *expressionScenario) {
 	if s.document != "" {
 		inputs, err = readDocuments(strings.NewReader(s.document), "sample.yml", 0)
 		if err != nil {
-			t.Error(err, s.document)
+			t.Error(err, s.document, s.expression)
 			return
 		}
 	} else {
@@ -55,7 +55,7 @@ func testScenario(t *testing.T, s *expressionScenario) {
 	results, err = treeNavigator.GetMatchingNodes(inputs, node)

 	if err != nil {
-		t.Error(err)
+		t.Error(fmt.Errorf("%v: %v", err, s.expression))
 		return
 	}
 	test.AssertResultComplexWithContext(t, s.expected, resultsToString(results), fmt.Sprintf("exp: %v\ndoc: %v", s.expression, s.document))
@@ -167,17 +167,17 @@ func documentScenarios(t *testing.T, title string, scenarios []expressionScenari
 			if s.document != "" {
 				node, err := treeCreator.ParsePath(s.expression)
 				if err != nil {
-					t.Error(err)
+					t.Error(err, s.expression)
 				}
 				err = streamEvaluator.Evaluate("sample.yaml", strings.NewReader(formattedDoc), node, printer)

 				if err != nil {
-					t.Error(err)
+					t.Error(err, s.expression)
 				}
 			} else {
 				err = streamEvaluator.EvaluateNew(s.expression, printer)
 				if err != nil {
-					t.Error(err)
+					t.Error(err, s.expression)
 				}
 			}

--- a/pkg/yqlib/path_parse_test.go
+++ b/pkg/yqlib/path_parse_test.go
@@ -17,20 +17,35 @@ var pathTests = []struct {
 		append(make([]interface{}, 0), "[", "]"),
 		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE"),
 	},
+	{
+		`.[]`,
+		append(make([]interface{}, 0), "TRAVERSE_ARRAY", "[", "]"),
+		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+	},
 	{
 		`.a[]`,
-		append(make([]interface{}, 0), "a", "SHORT_PIPE", "[]"),
-		append(make([]interface{}, 0), "a", "[]", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
 	},
 	{
 		`.a.[]`,
-		append(make([]interface{}, 0), "a", "SHORT_PIPE", "[]"),
-		append(make([]interface{}, 0), "a", "[]", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
+	},
+	{
+		`.a[0]`,
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
+		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
+	},
+	{
+		`.a.[0]`,
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
+		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
 	},
 	{
 		`.a[].c`,
-		append(make([]interface{}, 0), "a", "SHORT_PIPE", "[]", "SHORT_PIPE", "c"),
-		append(make([]interface{}, 0), "a", "[]", "SHORT_PIPE", "c", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]", "SHORT_PIPE", "c"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "c", "SHORT_PIPE"),
 	},
 	{
 		`[3]`,
@@ -44,18 +59,18 @@ var pathTests = []struct {
 	},
 	{
 		`.a | .[].b == "apple"`,
-		append(make([]interface{}, 0), "a", "PIPE", "[]", "SHORT_PIPE", "b", "EQUALS", "apple (string)"),
-		append(make([]interface{}, 0), "a", "[]", "b", "SHORT_PIPE", "apple (string)", "EQUALS", "PIPE"),
+		append(make([]interface{}, 0), "a", "PIPE", "TRAVERSE_ARRAY", "[", "]", "SHORT_PIPE", "b", "EQUALS", "apple (string)"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "apple (string)", "EQUALS", "PIPE"),
 	},
 	{
 		`(.a | .[].b) == "apple"`,
-		append(make([]interface{}, 0), "(", "a", "PIPE", "[]", "SHORT_PIPE", "b", ")", "EQUALS", "apple (string)"),
-		append(make([]interface{}, 0), "a", "[]", "b", "SHORT_PIPE", "PIPE", "apple (string)", "EQUALS"),
+		append(make([]interface{}, 0), "(", "a", "PIPE", "TRAVERSE_ARRAY", "[", "]", "SHORT_PIPE", "b", ")", "EQUALS", "apple (string)"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "PIPE", "apple (string)", "EQUALS"),
 	},
 	{
 		`.[] | select(. == "*at")`,
-		append(make([]interface{}, 0), "[]", "PIPE", "SELECT", "(", "SELF", "EQUALS", "*at (string)", ")"),
-		append(make([]interface{}, 0), "[]", "SELF", "*at (string)", "EQUALS", "SELECT", "PIPE"),
+		append(make([]interface{}, 0), "TRAVERSE_ARRAY", "[", "]", "PIPE", "SELECT", "(", "SELF", "EQUALS", "*at (string)", ")"),
+		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SELF", "*at (string)", "EQUALS", "SELECT", "PIPE"),
 	},
 	{
 		`[true]`,
@@ -89,8 +104,8 @@ var pathTests = []struct {
 	},
 	{
 		`{.a: .c, .b.[]: .f.g.[]}`,
-		append(make([]interface{}, 0), "{", "a", "CREATE_MAP", "c", "UNION", "b", "SHORT_PIPE", "[]", "CREATE_MAP", "f", "SHORT_PIPE", "g", "SHORT_PIPE", "[]", "}"),
-		append(make([]interface{}, 0), "a", "c", "CREATE_MAP", "b", "[]", "SHORT_PIPE", "f", "g", "SHORT_PIPE", "[]", "SHORT_PIPE", "CREATE_MAP", "UNION", "COLLECT_OBJECT", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "{", "a", "CREATE_MAP", "c", "UNION", "b", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]", "CREATE_MAP", "f", "SHORT_PIPE", "g", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]", "}"),
+		append(make([]interface{}, 0), "a", "c", "CREATE_MAP", "b", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "f", "g", "SHORT_PIPE", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "CREATE_MAP", "UNION", "COLLECT_OBJECT", "SHORT_PIPE"),
 	},
 	{
 		`explode(.a.b)`,
@@ -122,7 +137,6 @@ var pathTests = []struct {
 		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)"),
--- a/pkg/yqlib/path_tokeniser.go
+++ b/pkg/yqlib/path_tokeniser.go
@@ -22,7 +22,7 @@ const (
 	CloseCollect
 	OpenCollectObject
 	CloseCollectObject
-	SplatOrEmptyCollect
+	TraverseArrayCollect
 )

 type Token struct {
@@ -49,8 +49,9 @@ func (t *Token) toString() string {
 		return "{"
 	} else if t.TokenType == CloseCollectObject {
 		return "}"
-	} else if t.TokenType == SplatOrEmptyCollect {
-		return "[]?"
+	} else if t.TokenType == TraverseArrayCollect {
+		return ".["
+
 	} else {
 		return "NFI"
 	}
@@ -114,23 +115,6 @@ func unwrap(value string) string {
 	return value[1 : len(value)-1]
 }

-func arrayIndextoken(precedingDot bool) lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		var numberString = string(m.Bytes)
-		startIndex := 1
-		if precedingDot {
-			startIndex = 2
-		}
-		numberString = numberString[startIndex : len(numberString)-1]
-		var number, errParsingInt = strconv.ParseInt(numberString, 10, 64) // nolint
-		if errParsingInt != nil {
-			return nil, errParsingInt
-		}
-		op := &Operation{OperationType: TraversePath, Value: number, StringValue: numberString}
-		return &Token{TokenType: OperationToken, Operation: op, CheckForPostTraverse: true}, nil
-	}
-}
-
 func numberValue() lex.Action {
 	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
 		var numberString = string(m.Bytes)
@@ -188,12 +172,17 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`\(`), literalToken(OpenBracket, false))
 	lexer.Add([]byte(`\)`), literalToken(CloseBracket, true))

-	lexer.Add([]byte(`\.\[\]`), pathToken(false))
-	lexer.Add([]byte(`\.\.`), opToken(RecursiveDescent))
+	lexer.Add([]byte(`\.\[`), literalToken(TraverseArrayCollect, false))
+	lexer.Add([]byte(`\.\.`), opTokenWithPrefs(RecursiveDescent, nil, &RecursiveDescentPreferences{RecurseArray: true,
+		TraversePreferences: &TraversePreferences{FollowAlias: false, IncludeMapKeys: false}}))
+
+	lexer.Add([]byte(`\.\.\.`), opTokenWithPrefs(RecursiveDescent, nil, &RecursiveDescentPreferences{RecurseArray: true,
+		TraversePreferences: &TraversePreferences{FollowAlias: false, IncludeMapKeys: true}}))

 	lexer.Add([]byte(`,`), opToken(Union))
 	lexer.Add([]byte(`:\s*`), opToken(CreateMap))
 	lexer.Add([]byte(`length`), opToken(Length))
+	lexer.Add([]byte(`keys`), opToken(Keys))
 	lexer.Add([]byte(`sortKeys`), opToken(SortKeys))
 	lexer.Add([]byte(`select`), opToken(Select))
 	lexer.Add([]byte(`has`), opToken(Has))
@@ -201,12 +190,15 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`or`), opToken(Or))
 	lexer.Add([]byte(`and`), opToken(And))
 	lexer.Add([]byte(`not`), opToken(Not))
+	lexer.Add([]byte(`\/\/`), opToken(Alternative))

 	lexer.Add([]byte(`documentIndex`), opToken(GetDocumentIndex))

 	lexer.Add([]byte(`style`), opAssignableToken(GetStyle, AssignStyle))

 	lexer.Add([]byte(`tag`), opAssignableToken(GetTag, AssignTag))
+	lexer.Add([]byte(`anchor`), opAssignableToken(GetAnchor, AssignAnchor))
+	lexer.Add([]byte(`alias`), opAssignableToken(GetAlias, AssignAlias))
 	lexer.Add([]byte(`filename`), opToken(GetFilename))
 	lexer.Add([]byte(`fileIndex`), opToken(GetFileIndex))
 	lexer.Add([]byte(`path`), opToken(GetPath))
@@ -228,8 +220,6 @@ func initLexer() (*lex.Lexer, error) {

 	lexer.Add([]byte(`\s*\|=\s*`), opTokenWithPrefs(Assign, nil, &AssignOpPreferences{true}))

-	lexer.Add([]byte(`\.\[-?[0-9]+\]`), arrayIndextoken(true))
-
 	lexer.Add([]byte("( |\t|\n|\r)+"), skip)

 	lexer.Add([]byte(`d[0-9]+`), documentToken())
@@ -249,9 +239,7 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`[Nn][Uu][Ll][Ll]`), nullValue())
 	lexer.Add([]byte(`~`), nullValue())

-	lexer.Add([]byte(`"[^ "]*"`), stringValue(true))
-
-	lexer.Add([]byte(`\[\]`), literalToken(SplatOrEmptyCollect, true))
+	lexer.Add([]byte(`"[^"]*"`), stringValue(true))

 	lexer.Add([]byte(`\[`), literalToken(OpenCollect, false))
 	lexer.Add([]byte(`\]`), literalToken(CloseCollect, true))
@@ -321,24 +309,16 @@ func (p *pathTokeniser) Tokenise(path string) ([]*Token, error) {
 func (p *pathTokeniser) handleToken(tokens []*Token, index int, postProcessedTokens []*Token) (tokensAccum []*Token, skipNextToken bool) {
 	skipNextToken = false
 	token := tokens[index]
-	if token.TokenType == SplatOrEmptyCollect {
-		if index > 0 && tokens[index-1].TokenType == OperationToken &&
-			tokens[index-1].Operation.OperationType == TraversePath {
-			// must be a splat without a preceding dot , e.g. .a[]
-			// lets put a pipe in front of it, and convert it to a traverse "[]" token
-			pipeOp := &Operation{OperationType: ShortPipe, Value: "PIPE"}

-			postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: pipeOp})
+	if token.TokenType == TraverseArrayCollect {
+		//need to put a traverse array then a collect token
+		// do this by adding traverse then converting token to collect

-			traverseOp := &Operation{OperationType: TraversePath, Value: "[]", StringValue: "[]"}
-			token = &Token{TokenType: OperationToken, Operation: traverseOp, CheckForPostTraverse: true}
+		op := &Operation{OperationType: TraverseArray, StringValue: "TRAVERSE_ARRAY"}
+		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
+
+		token = &Token{TokenType: OpenCollect}

-		} else {
-			// gotta be a collect empty array, we need to split this into two tokens
-			// one OpenCollect, the other CloseCollect
-			postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OpenCollect})
-			token = &Token{TokenType: CloseCollect, CheckForPostTraverse: true}
-		}
 	}

 	if index != len(tokens)-1 && token.AssignOperation != nil &&
@@ -356,5 +336,21 @@ func (p *pathTokeniser) handleToken(tokens []*Token, index int, postProcessedTok
 		op := &Operation{OperationType: ShortPipe, Value: "PIPE"}
 		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
 	}
+	if index != len(tokens)-1 && token.CheckForPostTraverse &&
+		tokens[index+1].TokenType == OpenCollect {
+
+		op := &Operation{OperationType: ShortPipe, Value: "PIPE"}
+		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
+
+		op = &Operation{OperationType: TraverseArray}
+		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
+	}
+	if index != len(tokens)-1 && token.CheckForPostTraverse &&
+		tokens[index+1].TokenType == TraverseArrayCollect {
+
+		op := &Operation{OperationType: ShortPipe, Value: "PIPE"}
+		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
+
+	}
 	return postProcessedTokens, skipNextToken
 }
--- a/pkg/yqlib/test.yml
+++ b/pkg/yqlib/test.yml
@@ -0,0 +1,10 @@
+{
+  "a1": {
+    "b": "cat",
+    "c": "dog"
+  },
+  "a2": {
+    "d": "cat",
+    "e": "dog"
+  }
+}
--- a/release_instructions.txt
+++ b/release_instructions.txt
@@ -1,15 +1,9 @@
 - increment version in version.go
 - increment version in snapcraft.yaml
- commit
- tag git with same version number
 - make sure local build passes
- push tag to git
-  - git push --tags
- make local xcompile (builds binaries for all platforms)
-
- git release
-  ./scripts/release.sh
-  ./scripts/upload.sh
+- tag git with same version number
+- commit vX tag - this will trigger github actions
+- use github actions to publish docker and make github release

 - snapcraft
  - will auto create a candidate, test it works then promote
@@ -30,7 +24,7 @@

 - docker
  - build and push latest and new version tag
-  - docker build .  -t mikefarah/yq:latest -t mikefarah/yq:VERSION 
+  - docker build .  -t mikefarah/yq:latest -t mikefarah/yq:3 -t mikefarah/yq:3.X

 - debian package
  - ensure you get all vendor dependencies before packaging
--- a/scripts/check.sh
+++ b/scripts/check.sh
@@ -3,7 +3,7 @@
 set -o errexit
 set -o pipefail

-./bin/golangci-lint run
+./bin/golangci-lint run --timeout=5m

 # ./bin/golangci-lint \
 #   --tests \
--- a/scripts/format.sh
+++ b/scripts/format.sh
@@ -2,3 +2,4 @@

 find . \( -path ./vendor \) -prune -o -name "*.go" -exec goimports -w {} \;
 go mod tidy
+go mod vendor
--- a/scripts/publish-docker.sh
+++ b/scripts/publish-docker.sh
@@ -6,4 +6,7 @@ docker build \
  --build-arg VERSION=${VERSION} \
  -t mikefarah/yq:latest \
  -t mikefarah/yq:${VERSION} \
-  .
+  -t mikefarah/yq:4 \
+  .
+
+trivy image mikefarah/yq:${VERSION}
--- a/scripts/xcompile.sh
+++ b/scripts/xcompile.sh
@@ -1,14 +1,24 @@
 #!/bin/bash
-
+set -e
 # This assumes that gonative and gox is installed as per the 'one time setup' instructions
 # at https://github.com/inconshreveable/gonative


-CGO_ENABLED=0 gox -ldflags "${LDFLAGS}" -output="build/yq_{{.OS}}_{{.Arch}}"
-# include non-default linux builds too
-CGO_ENABLED=0 gox -ldflags "${LDFLAGS}" -os=linux  -output="build/yq_{{.OS}}_{{.Arch}}"
+CGO_ENABLED=0 gox -ldflags "${LDFLAGS}" -output="build/yq_{{.OS}}_{{.Arch}}" --osarch="darwin/amd64 freebsd/386 freebsd/amd64 freebsd/arm linux/386 linux/amd64 linux/arm linux/arm64 linux/mips linux/mips64 linux/mips64le linux/mipsle linux/ppc64 linux/ppc64le linux/s390x netbsd/386 netbsd/amd64 netbsd/arm openbsd/386 openbsd/amd64 windows/386 windows/amd64"

 cd build
-rhash -r -a . -P -o checksums
+rhash -r -a . -o checksums

-rhash --list-hashes > checksums_hashes_order
+rhash --list-hashes > checksums_hashes_order
+
+find . -executable -type f | xargs -I {} tar czvf {}.tar.gz {}
+
+# just in case find thinks this is executable...
+rm -f checksums_hashes_order.tar.gz 
+rm -f checksums.tar.gz
+
+rm yq_windows_386.exe.tar.gz
+rm yq_windows_amd64.exe.tar.gz
+
+zip yq_windows_386.zip yq_windows_386.exe
+zip yq_windows_amd64.zip yq_windows_amd64.exe
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -1,5 +1,5 @@
 name: yq
-version: '4.0.0-beta1'
+version: '4.2.0'
 summary: A lightweight and portable command-line YAML processor
 description: |
  The aim of the project is to be the jq or sed of yaml files.
--- a/yq_test.go
+++ b/yq_test.go
@@ -1,60 +0,0 @@
-package main
-
-// import (
-// 	"fmt"
-// 	"runtime"
-// 	"testing"
-
-// 	"github.com/mikefarah/yq/v2/pkg/marshal"
-// 	"github.com/mikefarah/yq/v2/test"
-// )
-
-// func TestMultilineString(t *testing.T) {
-// 	testString := `
-// 	abcd
-// 	efg`
-// 	formattedResult, _ := marshal.NewYamlConverter().YamlToString(testString, false)
-// 	test.AssertResult(t, testString, formattedResult)
-// }
-
-// func TestNewYaml(t *testing.T) {
-// 	result, _ := newYaml([]string{"b.c", "3"})
-// 	formattedResult := fmt.Sprintf("%v", result)
-// 	test.AssertResult(t,
-// 		"[{b [{c 3}]}]",
-// 		formattedResult)
-// }
-
-// func TestNewYamlArray(t *testing.T) {
-// 	result, _ := newYaml([]string{"[0].cat", "meow"})
-// 	formattedResult := fmt.Sprintf("%v", result)
-// 	test.AssertResult(t,
-// 		"[[{cat meow}]]",
-// 		formattedResult)
-// }
-
-// func TestNewYaml_WithScript(t *testing.T) {
-// 	writeScript = "examples/instruction_sample.yaml"
-// 	expectedResult := `b:
-//   c: cat
-//   e:
-//   - name: Mike Farah`
-// 	result, _ := newYaml([]string{""})
-// 	actualResult, _ := marshal.NewYamlConverter().YamlToString(result, true)
-// 	test.AssertResult(t, expectedResult, actualResult)
-// }
-
-// func TestNewYaml_WithUnknownScript(t *testing.T) {
-// 	writeScript = "fake-unknown"
-// 	_, err := newYaml([]string{""})
-// 	if err == nil {
-// 		t.Error("Expected error due to unknown file")
-// 	}
-// 	var expectedOutput string
-// 	if runtime.GOOS == "windows" {
-// 		expectedOutput = `open fake-unknown: The system cannot find the file specified.`
-// 	} else {
-// 		expectedOutput = `open fake-unknown: no such file or directory`
-// 	}
-// 	test.AssertResult(t, expectedOutput, err.Error())
-// }
Author	SHA1	Message	Date
Mike Farah	f46c60f74d	wip	2020-12-28 23:01:13 +11:00
Mike Farah	94a563dfd8	Updated docs	2020-12-28 11:57:20 +11:00
Mike Farah	0328cfd619	Added prettyPrint flag	2020-12-28 11:40:41 +11:00
Mike Farah	88663a6ce3	Added recurse keys operator	2020-12-28 11:24:42 +11:00
Mike Farah	b10a9ccfc6	Removed TraversePrefs	2020-12-28 10:29:43 +11:00
Mike Farah	9e9e15df73	More scenarios	2020-12-27 23:00:46 +11:00
Mike Farah	6cc6fdf322	Cleaning code	2020-12-27 22:56:15 +11:00
Mike Farah	a88c2dc5d3	Traverse Array Operator	2020-12-27 22:48:20 +11:00
Mike Farah	ea231006ed	Refactoring traverse	2020-12-27 09:55:08 +11:00
Mike Farah	80f187f1a4	Refactoring traverse	2020-12-27 09:51:34 +11:00
Mike Farah	98e8b3479f	Fixed nested array splat path	2020-12-25 12:49:05 +11:00
Mike Farah	eb539ff326	Fixed doc links	2020-12-23 10:37:51 +11:00
Mike Farah	c09f7aa707	Cleaning up docs	2020-12-23 10:30:13 +11:00
Mike Farah	7f5c380d16	v4.1.0	2020-12-23 10:23:54 +11:00
Mike Farah	6a05e517f1	Updated release instructions, remove gate for release	2020-12-23 10:23:09 +11:00
Mike Farah	8ee6f7dc1a	fixing xcompile for git action	2020-12-22 22:50:01 +11:00
Mike Farah	8bd54cd603	fixing xcompile for git action	2020-12-22 22:31:28 +11:00
Mike Farah	f2f7b6db0f	only tar executable files	2020-12-22 20:50:52 +11:00
Mike Farah	e082fee5d4	Fixed rhash call	2020-12-22 20:37:35 +11:00
Mike Farah	412911561f	Fixed xcompile.sh	2020-12-22 20:23:13 +11:00
Mike Farah	52ae633cb7	trialing github release actions	2020-12-22 20:05:23 +11:00
Mike Farah	9356ca59bb	trialing github release actions	2020-12-22 20:03:01 +11:00
Mike Farah	6dec167f74	trialing github release actions	2020-12-22 20:01:21 +11:00
Mike Farah	00f6981314	trialing github release actions	2020-12-22 19:56:56 +11:00
Mike Farah	4c60a2a967	trialing github release actions	2020-12-22 19:52:44 +11:00
Mike Farah	f4529614c4	trialing github release actions	2020-12-22 19:19:48 +11:00
Mike Farah	f059e13f94	automated docker releases!	2020-12-22 16:16:31 +11:00
Mike Farah	4dbf158505	playing with release action	2020-12-22 16:01:00 +11:00
Mike Farah	39a93a2836	playing with release action	2020-12-22 16:00:15 +11:00
Mike Farah	7c158fce26	playing with release action	2020-12-22 15:58:56 +11:00
Mike Farah	0bf43d2a55	playing with release action	2020-12-22 15:47:59 +11:00
Mike Farah	1b0bce5da6	Added alias operator; alias, anchor and explode ops are now all documented together	2020-12-22 12:23:13 +11:00
Mike Farah	f112bde5fe	Added anchor operator	2020-12-22 11:57:41 +11:00
Mike Farah	e5aa4a87a4	fixed test name	2020-12-22 11:47:58 +11:00
Mike Farah	f305e8fa12	Fixed delete full path	2020-12-22 11:45:51 +11:00
Mike Farah	d2d0c2c111	Added missing flag	2020-12-22 10:40:20 +11:00
Mike Farah	2aab79431c	moved string space test to op values test cases	2020-12-22 10:38:52 +11:00
djajcevic	540d4953f5	#607 Fix string value with spaces error	2020-12-22 10:29:21 +11:00
Mike Farah	7849232255	tar files to keep permissions of exectuable	2020-12-22 10:25:15 +11:00
Mike Farah	57cd67f055	Added compressed binaries for download managers and better file size	2020-12-21 21:40:08 +11:00
Mike Farah	6b17fd4fc1	Added trivy to docker build, bumped alpine image	2020-12-21 15:48:25 +11:00
Mike Farah	ca8cd78616	Add now uses crossFunction	2020-12-21 11:54:03 +11:00
Mike Farah	9876b0ce8f	Boolean operators now use the crossFunction util func	2020-12-21 11:42:35 +11:00
Mike Farah	a23272727d	Added Alternative op	2020-12-21 11:32:34 +11:00
Mike Farah	1fb37785d6	Better readme	2020-12-20 13:34:58 +11:00
Mike Farah	efb9027540	Merge branch 'v4'	2020-12-20 13:31:23 +11:00
Mike Farah	2577fe5425	Increment version	2020-12-20 13:29:12 +11:00
Shashank Veerapaneni	8846255d1c	Update README.md Fix the wget download command	2020-12-02 19:42:05 +11:00
Mike Farah	fbe53885ae	Update README.md	2020-12-01 17:24:14 +11:00
Mike Farah	f42728eef7	updated issue templates	2020-11-25 22:33:50 +11:00
Mike Farah	93136ba840	updated issue templates	2020-11-25 22:32:47 +11:00
Mike Farah	5665dc7b71	updated issue templates	2020-11-25 22:31:55 +11:00
Mike Farah	9302279dd2	updated issue templates	2020-11-25 22:22:16 +11:00
Mike Farah	5972bb2f23	attempt to fix pipeline	2020-11-25 11:17:28 +11:00
Mike Farah	ec43f5e7c3	go mod tidy	2020-11-25 11:06:43 +11:00
Mike Farah	62f262147c	Attempt to fix git pipeline	2020-11-20 14:00:24 +11:00
Mike Farah	0259bb44c1	Updated readme	2020-11-20 13:55:18 +11:00
bahetiamit	e07a5b6065	Adding github action on release to publish multi-arch image	2020-11-20 13:48:35 +11:00
Mike Farah	f69a81b79b	Updated readme re v4	2020-11-19 22:56:13 +11:00
Mike Farah	ccb718cd0f	Moved macports to community, announced v4	2020-10-20 13:58:45 +11:00
Herby Gillot	815edef86a	README: add instructions for installing with MacPorts	2020-10-20 13:50:10 +11:00
Mike Farah	cd83d94b6a	updating release instructions	2020-10-19 09:01:52 +11:00
Mike Farah	6afc2e9189	3.4.1	2020-10-19 08:40:59 +11:00
				`@@ -0,0 +1 @@`
				`This operator is used to provide alternative (or default) values when a particular expression is either null or false.`
				`@@ -1 +0,0 @@`
				`Explodes (or dereferences) aliases and anchors.`