tests passsing!

wip
2026-08-24 08:22:13 +08:00 · 2020-12-27 22:47:19 +11:00 · 2020-12-27 22:29:00 +11:00 · 2020-12-27 22:14:26 +11:00 · 2020-12-27 09:55:21 +11:00 · 2020-12-27 09:55:21 +11:00
207 changed files with 2427 additions and 12580 deletions
@@ -1 +1 @@
-bin/*
+bin
@@ -1 +0,0 @@
-github: mikefarah
@@ -10,8 +10,6 @@ assignees: ''
 **Describe the bug**
 A clear and concise description of what the bug is.

-Note that any how to questions should be posted in the discussion board and not raised as an issue.
-
 Version of yq: 3.X.X
 Operating system: mac/linux/windows/....
 Installed via: docker/binary release/homebrew/snap/...
@@ -10,8 +10,6 @@ assignees: ''
 **Describe the bug**
 A clear and concise description of what the bug is.

-Note that any how to questions should be posted in the discussion board and not raised as an issue.
-
 Version of yq: 4.X.X
 Operating system: mac/linux/windows/....
 Installed via: docker/binary release/homebrew/snap/...
@@ -9,11 +9,9 @@ assignees: ''

 **Please describe your feature request.**
 A clear and concise description of what the request is and what it would solve. 
-Eg. I wish I could use yq to [...]
+Ex. I wish I could use yq to [...]

-Note:
- how to questions should be posted in the discussion board and not raised as an issue.
- V3 will no longer have any enhancements.
+Please note that V3 will no longer have any enhancements.

 **Describe the solution you'd like**
 If we have data1.yml like:
@@ -40,7 +40,17 @@ jobs:
      IMAGE_NAME: mikefarah/yq
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
+      - name: Get latest release tag      
+        uses: oprypin/find-latest-tag@v1
+        with:
+          repository: mikefarah/yq  # The repository to scan.
+          releases-only: true  # We know that all relevant tags have a GitHub release for them.
+        id: yq  
+        
+      - name: Clone source code
+        uses: actions/checkout@v2
+        with:
+          ref: ${{ steps.yq.outputs.tag }}
      
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v1
@@ -58,9 +68,7 @@ jobs:
 
      - name: Build and push image
        run: |
-          IMAGE_V_VERSION="$(git describe --tags --abbrev=0)"
-          IMAGE_VERSION=${IMAGE_V_VERSION:1}
-
+          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}"
@@ -1,19 +0,0 @@
-name: Test Yq Action
-on: [push]
-jobs:
-
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Get test
-        uses: mikefarah/yq@master
-        with:
-          cmd: yq eval '.a' examples/data1.yaml
-      - name: Write inplace test
-        id: lookupSdkVersion
-        uses: mikefarah/yq@master
-        with:
-          cmd: yq eval -i '.a.b = 5' examples/data1.yaml
@@ -38,5 +38,3 @@ parts/
 prime/
 .snapcraft/
 yq*.snap
-test.yml
-test2.yml
@@ -12,12 +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.13.5 as production
-
-RUN mkdir /home/yq/
-RUN addgroup -g 1000 yq && \
-    adduser -u 1000 -G yq -s /bin/bash -h /home/yq -D yq
-RUN chown -R yq:yq /home/yq/
+FROM alpine:3.12.3 as production

 COPY --from=builder /go/src/mikefarah/yq/yq /usr/bin/yq
 RUN chmod +x /usr/bin/yq
@@ -25,8 +20,6 @@ RUN chmod +x /usr/bin/yq
 ARG VERSION=none
 LABEL version=${VERSION}

-USER yq
-
 WORKDIR /workdir

 ENTRYPOINT ["/usr/bin/yq"]
@@ -4,7 +4,27 @@ COPY scripts/devtools.sh /opt/devtools.sh

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

 ENV CGO_ENABLED 0
 ENV GOPATH /go:/yq
@@ -17,7 +17,6 @@ help:
 	@echo '    make vendor          Install dependencies to vendor directory.'
 	@echo '    make format          Run code formatter.'
 	@echo '    make check           Run static code analysis (lint).'
-	@echo '    make secure          Run gosec.'
 	@echo '    make test            Run tests on project.'
 	@echo '    make cover           Run tests and capture code coverage metrics on project.'
 	@echo '    make clean           Clean the directory tree of produced artifacts.'
@@ -85,10 +84,6 @@ format: vendor
 check: format
 	${DOCKRUN} bash ./scripts/check.sh

-.PHONY: secure
-secure: 
-	${DOCKRUN} bash ./scripts/secure.sh
-
 .PHONY: test
 test: check
 	${DOCKRUN} bash ./scripts/test.sh
@@ -101,6 +96,11 @@ cover: check
 	@find cover -type d -exec chmod 755 {} \; || :
 	@find cover -type f -exec chmod 644 {} \; || :

+.PHONY: build-docs
+build-docs: prepare mkdocs.yml mkdocs/*
+	${DOCKRUN} mkdocs build
+	@find docs -type d -exec chmod 755 {} \; || :
+	@find docs -type f -exec chmod 644 {} \; || :

 .PHONY: release
 release: xcompile
@@ -3,95 +3,30 @@
 ![Build](https://github.com/mikefarah/yq/workflows/Build/badge.svg)  ![Docker Pulls](https://img.shields.io/docker/pulls/mikefarah/yq.svg) ![Github Releases (by Release)](https://img.shields.io/github/downloads/mikefarah/yq/total.svg) ![Go Report](https://goreportcard.com/badge/github.com/mikefarah/yq)


-a lightweight and portable command-line YAML processor. `yq` uses [jq](https://github.com/stedolan/jq) like syntax but works with yaml files as well as json. It doesn't yet support everything `jq` does - but it does support the most common operations and functions, and more is being added continuously.
+a lightweight and portable command-line YAML processor

-yq is written in go - so you can download a dependency free binary for your platform and you are good to go! If you prefer there are a variety of package managers that can be used as well as docker, all listed below.
+The aim of the project is to be the [jq](https://github.com/stedolan/jq) or sed of yaml files.

-## Quick Usage Guide
+## 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! 

-Read a value:
-```bash
-yq e '.a.b[0].c' file.yaml
-```
-
-Pipe from STDIN:
-```bash
-cat file.yaml | yq e '.a.b[0].c' -
-```
-
-Update a yaml file, inplace
-```bash
-yq e -i '.a.b[0].c = "cool"' file.yaml
-```
-
-Update using environment variables
-```bash
-NAME=mike yq e -i '.a.b[0].c = strenv(NAME)' file.yaml
-```
-
-Merge multiple files
-```
-yq ea '. as $item ireduce ({}; . * $item )' path/to/*.yml
-```
-
-Multiple updates to a yaml file
-```bash
-yq e -i '
-  .a.b[0].c = "cool" |
-  .x.y.z = "foobar" |
-  .person.name = strenv(NAME)
-' file.yaml
-```
-
-See the [documentation](https://mikefarah.gitbook.io/yq/) for more.
+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)

-### wget
-Use wget to download the pre-compiled binaries:
-
-#### Compressed via tar.gz
-```bash
-wget https://github.com/mikefarah/yq/releases/download/${VERSION}/${BINARY}.tar.gz -O - |\
-  tar xz && mv ${BINARY} /usr/bin/yq
-```
-
-#### Plain binary
-
-```bash
-wget https://github.com/mikefarah/yq/releases/download/${VERSION}/${BINARY} -O /usr/bin/yq &&\
-    chmod +x /usr/bin/yq
-```
-
-For instance, VERSION=v4.2.0 and BINARY=yq_linux_amd64
-
-### MacOS / Linux via Homebrew:
+### MacOS:
 Using [Homebrew](https://brew.sh/)
 ```
 brew install yq
 ```

-or, for the (deprecated) v3 version:
-
-```
-brew install yq@3
-```
-
-Note that for v3, as it is a versioned brew it will not add the `yq` command to your path automatically. Please follow the instructions given by brew upon installation.
-
-### Linux via snap:
+### Ubuntu and other Linux distros supporting `snap` packages:
 ```
 snap install yq
 ```

-or, for the (deprecated) v3 version:
-
-```
-snap install yq --channel=v3/stable
-```
-
 #### Snap notes
 `yq` installs with [_strict confinement_](https://docs.snapcraft.io/snap-confinement/6233) in snap, this means it doesn't have direct access to root files. To read root files you can:

@@ -110,6 +45,17 @@ sudo mv /etc/myfile.tmp /etc/myfile
 rm /etc/myfile.tmp
 ```

+### wget
+
+Use wget to download the pre-compiled binaries:
+
+```bash
+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:
@@ -118,18 +64,10 @@ rm /etc/myfile.tmp
 docker run --rm -v "${PWD}":/workdir mikefarah/yq <command> [flags] [expression ]FILE...
 ```

-#### Pipe in via STDIN:
-
-You'll need to pass the `-i\--interactive` flag to docker:
-
-```bash
-cat myfile.yml | docker run -i --rm mikefarah/yq e . -
-```
-
 #### Run commands interactively:

 ```bash
-docker run --rm -it -v "${PWD}":/workdir --entrypoint sh mikefarah/yq
+docker run --rm -it -v "${PWD}":/workdir mikefarah/yq sh
 ```

 It can be useful to have a bash function to avoid typing the whole docker command:
@@ -140,56 +78,16 @@ yq() {
 }
 ```

-
-#### Running as root:
-
-`yq`'s docker image no longer runs under root (https://github.com/mikefarah/yq/pull/860). If you'd like to install more things in the docker image, or you're having permissions issues when attempting to read/write files you'll need to either:
-
-
-```
-docker run --user="root" -it --entrypoint sh mikefarah/yq
-```
-
-Or, in your docker file:
-
-```
-FROM mikefarah/yq
-
-USER root
-RUN apk add bash
-USER yq
-```
-
-### GitHub Action
-```
-  - name: Set foobar to cool
-    uses: mikefarah/yq@master
-    with:
-      cmd: yq eval -i '.foo.bar = "cool"' 'config.yml'
-```
-
-See https://mikefarah.gitbook.io/yq/usage/github-action for more.
-
 ### Go Get:
 ```
-GO111MODULE=on go get github.com/mikefarah/yq/v4
+GO111MODULE=on go get github.com/mikefarah/yq
 ```

 ## Community Supported Installation methods
 As these are supported by the community :heart: - however, they may be out of date with the officially supported releases.

-# Webi
-
-```
-webi yq
-```
-
-See [webi](https://webinstall.dev/)
-Supported by @adithyasunil26 (https://github.com/webinstall/webi-installers/tree/master/yq)

 ### Windows:
-[![Chocolatey](https://img.shields.io/chocolatey/v/yq.svg)](https://chocolatey.org/packages/yq)
-[![Chocolatey](https://img.shields.io/chocolatey/dt/yq.svg)](https://chocolatey.org/packages/yq)
 ```
 choco install yq
 ```
@@ -222,24 +120,19 @@ sudo apt install yq -y
 Supported by @rmescandon (https://launchpad.net/~rmescandon/+archive/ubuntu/yq)

 ## Features
- [Detailed documentation with many examples](https://mikefarah.gitbook.io/yq/)
 - Written in portable go, so you can download a lovely dependency free binary
 - Uses similar syntax as `jq` but works with YAML and JSON files
 - Fully supports multi document yaml files
- Supports yaml [front matter](https://mikefarah.gitbook.io/yq/usage/front-matter) blocks (e.g. jekyll/assemble)
 - Colorized yaml output
- [Deeply traverse yaml](https://mikefarah.gitbook.io/yq/operators/traverse-read)
- [Sort yaml by keys](https://mikefarah.gitbook.io/yq/operators/sort-keys)
- Manipulate yaml [comments](https://mikefarah.gitbook.io/yq/operators/comment-operators), [styling](https://mikefarah.gitbook.io/yq/operators/style), [tags](https://mikefarah.gitbook.io/yq/operators/tag) and [anchors and aliases](https://mikefarah.gitbook.io/yq/operators/anchor-and-alias-operators).
+- [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://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/operators/select#select-and-update-matching-values-in-map)
+- [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](https://mikefarah.gitbook.io/yq/v/v4.x/usage/convert)
- [Convert to properties](https://mikefarah.gitbook.io/yq/v/v4.x/usage/properties)
+- [Convert to/from json to yaml](https://mikefarah.gitbook.io/yq/v/v4.x/usage/convert)
 - [Pipe data in by using '-'](https://mikefarah.gitbook.io/yq/v/v4.x/commands/evaluate)
 - [General shell completion scripts (bash/zsh/fish/powershell)](https://mikefarah.gitbook.io/yq/v/v4.x/commands/shell-completion)
- [Reduce](https://mikefarah.gitbook.io/yq/operators/reduce) to merge multiple files or sum an array or other fancy things.
- [Github Action](https://mikefarah.gitbook.io/yq/usage/github-action) to use in your automated pipeline (thanks @devorbitus)

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

@@ -251,31 +144,32 @@ Usage:
  yq [command]

 Available Commands:
-  eval             Apply the expression to each document in each yaml file in sequence
+  eval             Apply expression to each document in each yaml file given in sequence
  eval-all         Loads _all_ yaml documents of _all_ yaml files and runs expression once
  help             Help about any command
  shell-completion Generate completion script

 Flags:
-  -C, --colors                force print with colors
-  -e, --exit-status           set exit status if there are no matches or null or false is returned
-  -f, --front-matter string   (extract|process) first input as yaml front-matter. Extract will pull out the yaml content, process will run the expression against the yaml content, leaving the remaining data intact
-  -h, --help                  help for yq
-  -I, --indent int            sets indent level for output (default 2)
-  -i, --inplace               update the yaml file inplace of first yaml file given.
-  -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.
-      --unwrapScalar          unwrap scalar, print the value with no quotes, colors or comments (default true)
-  -v, --verbose               verbose mode
-  -V, --version               Print version information and quit
+  -C, --colors        force print with colors
+  -e, --exit-status   set exit status if there are no matches or null or false is returned
+  -h, --help          help for yq
+  -I, --indent int    sets indent level for output (default 2)
+  -i, --inplace       update the yaml file inplace of first yaml file given.
+  -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.
+  -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

 Use "yq [command] --help" for more information about a command.
 ```
+
+Simple Example:
+
+```bash
+yq e '.a.b | length' f1.yml f2.yml 
+```
+
 ## 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)
- Powershell has its own...opinions: https://mikefarah.gitbook.io/yq/usage/tips-and-tricks#quotes-in-windows-powershell
-
-See [tips and tricks](https://mikefarah.gitbook.io/yq/usage/tips-and-tricks) for more common problems and solutions.
@@ -1,72 +0,0 @@
-#!/bin/bash
-
-setUp() {
-  rm -f test.yml
-}
-
-testBasicEvalRoundTrip() {
-  ./yq e -n ".a = 123" > test.yml
-  X=$(./yq e '.a' test.yml)
-  assertEquals 123 "$X"
-}
-
-testBasicUpdateInPlaceSequence() {
-  cat >test.yml <<EOL
-a: 0
-EOL
-  ./yq e -i ".a = 10" test.yml
-  X=$(./yq e '.a' test.yml)
-  assertEquals "10" "$X"
-}
-
-testBasicUpdateInPlaceSequenceEvalAll() {
-  cat >test.yml <<EOL
-a: 0
-EOL
-  ./yq ea -i ".a = 10" test.yml
-  X=$(./yq e '.a' test.yml)
-  assertEquals "10" "$X"
-}
-
-testBasicNoExitStatus() {
-  echo "a: cat" > test.yml
-  X=$(./yq e '.z' test.yml)
-  assertEquals "null" "$X"
-}
-
-testBasicExitStatus() {
-  echo "a: cat" > test.yml
-  X=$(./yq e -e '.z' test.yml 2&>/dev/null)
-  assertEquals 1 "$?"
-}
-
-testBasicExtractFieldWithSeperator() {
-    cat >test.yml <<EOL
---
-name: chart-name
-version: 1.2.3
-EOL
-  X=$(./yq e '.name' test.yml)
-  assertEquals "chart-name" "$X"
-}
-
-testBasicExtractMultipleFieldWithSeperator() {
-    cat >test.yml <<EOL
---
-name: chart-name
-version: 1.2.3
---
-name: thing
-version: 1.2.3
-EOL
-
-read -r -d '' expected << EOM
-chart-name
---
-thing
-EOM
-  X=$(./yq e '.name' test.yml)
-  assertEquals "$expected" "$X"
-}
-
-source ./scripts/shunit2
@@ -1,82 +0,0 @@
-#!/bin/bash
-
-setUp() {
-  cat >test.yml <<EOL
-# comment
-EOL
-}
-
-testEmptyEval() {
-  X=$(./yq e test.yml)
-  expected=$(cat test.yml)
-  assertEquals 0 $?
-  assertEquals "$expected" "$X"
-}
-
-testEmptyEvalNoNewLine() {
-  echo -n "#comment" >test.yml
-  X=$(./yq e test.yml)
-  expected=$(cat test.yml)
-  assertEquals 0 $?
-  assertEquals "$expected" "$X"
-}
-
-testEmptyEvalNoNewLineWithExpression() {
-  echo -n "# comment" >test.yml
-  X=$(./yq e '.apple = "tree"' test.yml)
-  read -r -d '' expected << EOM
-# comment
-apple: tree
-EOM
-  assertEquals "$expected" "$X"
-}
-
-testEmptyEvalPipe() {
-  X=$(./yq e - < test.yml)
-  assertEquals 0 $?
-}
-
-testEmptyCommentsWithExpressionEval() {
-  read -r -d '' expected << EOM
-# comment
-apple: tree
-EOM
-
-  X=$(./yq e '.apple="tree"' test.yml)
-
-  assertEquals "$expected" "$X"
-}
-
-testEmptyCommentsWithExpressionEvalAll() {
-  read -r -d '' expected << EOM
-# comment
-apple: tree
-EOM
-
-  X=$(./yq ea '.apple="tree"' test.yml)
-
-  assertEquals "$expected" "$X"
-}
-
-testEmptyWithExpressionEval() {
-  rm test.yml
-  touch test.yml
-  expected="apple: tree"
-
-  X=$(./yq e '.apple="tree"' test.yml)
-
-  assertEquals "$expected" "$X"
-}
-
-testEmptyWithExpressionEvalAll() {
-  rm test.yml
-  touch test.yml
-  expected="apple: tree"
-
-  X=$(./yq ea '.apple="tree"' test.yml)
-
-  assertEquals "$expected" "$X"
-}
-
-
-source ./scripts/shunit2
@@ -1,75 +0,0 @@
-#!/bin/bash
-
-setUp() {
-  cat >test.yml <<EOL
---
-a: apple
-b: cat
---
-not yaml
-c: at
-EOL
-}
-
-testFrontMatterProcessEval() {
-  read -r -d '' expected << EOM
---
-a: apple
-b: dog
---
-not yaml
-c: at
-EOM
-  ./yq e --front-matter="process" '.b = "dog"' test.yml -i
-  assertEquals "$expected" "$(cat test.yml)"
-}
-
-testFrontMatterProcessEvalAll() {
-  read -r -d '' expected << EOM
---
-a: apple
-b: dog
---
-not yaml
-c: at
-EOM
-  ./yq ea --front-matter="process" '.b = "dog"' test.yml -i
-  assertEquals "$expected" "$(cat test.yml)"
-}
-
-testFrontMatterExtractEval() {
-    cat >test.yml <<EOL
-a: apple
-b: cat
---
-not yaml
-c: at
-EOL
-
-  read -r -d '' expected << EOM
-a: apple
-b: dog
-EOM
-  ./yq e --front-matter="extract" '.b = "dog"' test.yml -i
-  assertEquals "$expected" "$(cat test.yml)"
-}
-
-testFrontMatterExtractEvalAll() {
-  cat >test.yml <<EOL
-a: apple
-b: cat
---
-not yaml
-c: at
-EOL
-
-  read -r -d '' expected << EOM
-a: apple
-b: dog
-EOM
-  ./yq ea --front-matter="extract" '.b = "dog"' test.yml -i
-  assertEquals "$expected" "$(cat test.yml)"
-}
-
-
-source ./scripts/shunit2
@@ -1,449 +0,0 @@
-#!/bin/bash
-
-setUp() {
-  cat >test.yml <<EOL
---
-a: test
-EOL
-}
-
-testLeadingSeperatorWithDoc() {
-  cat >test.yml <<EOL
-# hi peeps
-# cool
---
-a: test
---
-b: cool
-EOL
-
-  read -r -d '' expected << EOM
-# hi peeps
-# cool
---
-a: thing
---
-b: cool
-EOM
-
-  X=$(./yq e '(select(di == 0) | .a) = "thing"' - < test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorPipeIntoEvalSeq() {
-  X=$(./yq e - < test.yml)
-  expected=$(cat test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorExtractField() {
-  X=$(./yq e '.a' - < test.yml)
-  assertEquals "test" "$X"
-}
-
-testLeadingSeperatorExtractFieldWithCommentsAfterSep() {
-  cat >test.yml <<EOL
---
-# hi peeps
-# cool
-a: test
-EOL
-  X=$(./yq e '.a' test.yml)
-  assertEquals "test" "$X"
-}
-
-testLeadingSeperatorExtractFieldWithCommentsBeforeSep() {
-  cat >test.yml <<EOL
-# hi peeps
-# cool
---
-a: test
-EOL
-  X=$(./yq e '.a' test.yml)
-  assertEquals "test" "$X"
-}
-
-
-testLeadingSeperatorExtractFieldMultiDoc() {
-  cat >test.yml <<EOL
---
-a: test
---
-a: test2
-EOL
-
-  read -r -d '' expected << EOM
-test
---
-test2
-EOM
-  X=$(./yq e '.a' test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorExtractFieldMultiDocWithComments() {
-  cat >test.yml <<EOL
-# here
---
-# there
-a: test
-# whereever
---
-# you are
-a: test2
-# woop
-EOL
-
-  read -r -d '' expected << EOM
-test
---
-test2
-EOM
-  X=$(./yq e '.a' test.yml)
-  assertEquals "$expected" "$X"
-}
-
-
-testLeadingSeperatorEvalSeq() {
-  X=$(./yq e test.yml)
-  expected=$(cat test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorPipeIntoEvalAll() {
-  X=$(./yq ea - < test.yml)
-  expected=$(cat test.yml)
-  assertEquals "$expected" "$X"
-}
-
-
-testLeadingSeperatorEvalAll() {
-  X=$(./yq ea test.yml)
-  expected=$(cat test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocEvalSimple() {
-  read -r -d '' expected << EOM
---
-a: test
---
-version: 3
-application: MyApp
-EOM
-
-
-  X=$(./yq e '.' test.yml examples/order.yaml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocInOneFile() {
-  cat >test.yml <<EOL
---
-# hi peeps
-# cool
-a: test
---
-b: things
-EOL
-  expected=$(cat test.yml)
-  X=$(./yq e '.' test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocInOneFileEvalAll() {
-  cat >test.yml <<EOL
---
-# hi peeps
-# cool
-a: test
---
-b: things
-EOL
-  expected=$(cat test.yml)
-  X=$(./yq ea '.' test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocEvalComments() {
-  cat >test.yml <<EOL
-# hi peeps
-# cool
-a: test
-EOL
-
-cat >test2.yml <<EOL
-# this is another doc
-# great
-b: sane
-EOL
-
-  read -r -d '' expected << EOM
-# hi peeps
-# cool
-a: test
---
-# this is another doc
-# great
-b: sane
-EOM
-
-
-  X=$(./yq e '.' test.yml test2.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocEvalCommentsTrailingSep() {
-  cat >test.yml <<EOL
-# hi peeps
-# cool
---
-a: test
-EOL
-
-cat >test2.yml <<EOL
-# this is another doc
-# great
---
-b: sane
-EOL
-
-  read -r -d '' expected << EOM
-# hi peeps
-# cool
---
-a: test
---
-# this is another doc
-# great
---
-b: sane
-EOM
-
-
-  X=$(./yq e '.' test.yml test2.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiMultiDocEvalCommentsTrailingSep() {
-  cat >test.yml <<EOL
-# hi peeps
-# cool
---
-a: test
---
-a1: test2
-EOL
-
-cat >test2.yml <<EOL
-# this is another doc
-# great
---
-b: sane
---
-b2: cool
-EOL
-
-  read -r -d '' expected << EOM
-# hi peeps
-# cool
---
-a: test
---
-a1: test2
---
-# this is another doc
-# great
---
-b: sane
---
-b2: cool
-EOM
-
-
-  X=$(./yq e '.' test.yml test2.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocEvalCommentsLeadingSep() {
-  cat >test.yml <<EOL
---
-# hi peeps
-# cool
-a: test
-EOL
-
-cat >test2.yml <<EOL
---
-# this is another doc
-# great
-b: sane
-EOL
-
-  read -r -d '' expected << EOM
---
-# hi peeps
-# cool
-a: test
---
-# this is another doc
-# great
-b: sane
-EOM
-
-
-  X=$(./yq e '.' test.yml test2.yml)
-  assertEquals "$expected" "$X"
-}
-
-# https://github.com/mikefarah/yq/issues/919
-testLeadingSeparatorDoesNotBreakCommentsOnOtherFiles() {
-  cat >test.yml <<EOL
-# a1
-a: 1
-# a2
-EOL
-
-cat >test2.yml <<EOL
-# b1
-b: 2
-# b2
-EOL
-
-  read -r -d '' expected << EOM
-# a1
-a: 1
-# a2
-
-# b1
-b: 2
-# b2
-EOM
-
-
-  X=$(./yq ea 'select(fi == 0) * select(fi == 1)' test.yml test2.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocEvalCommentsStripComments() {
-  cat >test.yml <<EOL
---
-# hi peeps
-# cool
-a: test
---
-# this is another doc
-# great
-b: sane
-EOL
-
-  # it will be hard to remove that top level separator
-  read -r -d '' expected << EOM
-a: test
---
-b: sane
-EOM
-
-  X=$(./yq e '... comments=""'  test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocEvalCommentsLeadingSepNoDocFlag() {
-  cat >test.yml <<EOL
---
-# hi peeps
-# cool
-a: test
---
-# this is another doc
-# great
-b: sane
-EOL
-
-  read -r -d '' expected << EOM
-# hi peeps
-# cool
-a: test
-# this is another doc
-# great
-b: sane
-EOM
-
-
-  X=$(./yq e '.' --no-doc test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocEvalJsonFlag() {
-  cat >test.yml <<EOL
---
-# hi peeps
-# cool
-a: test
-EOL
-
-cat >test2.yml <<EOL
---
-# this is another doc
-# great
-b: sane
-EOL
-
-  read -r -d '' expected << EOM
-{
-  "a": "test"
-}
-{
-  "b": "sane"
-}
-EOM
-
-
-  X=$(./yq e '.' -j test.yml test2.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocEvalAllJsonFlag() {
-  cat >test.yml <<EOL
---
-# hi peeps
-# cool
-a: test
-EOL
-
-cat >test2.yml <<EOL
---
-# this is another doc
-# great
-b: sane
-EOL
-
-  read -r -d '' expected << EOM
-{
-  "a": "test"
-}
-{
-  "b": "sane"
-}
-EOM
-
-
-  X=$(./yq ea '.' -j test.yml test2.yml)
-  assertEquals "$expected" "$X"
-}
-
-testLeadingSeperatorMultiDocEvalAll() {
-  read -r -d '' expected << EOM
---
-a: test
---
-version: 3
-application: MyApp
-EOM
-
-
-  X=$(./yq ea '.' test.yml examples/order.yaml)
-  assertEquals "$expected" "$X"
-}
-
-source ./scripts/shunit2
@@ -1,101 +0,0 @@
-#!/bin/bash
-
-testOutputJsonDeprecated() {
-  cat >test.yml <<EOL
-a: {b: ["cat"]}
-EOL
-
-  read -r -d '' expected << EOM
-{
-  "a": {
-    "b": [
-      "cat"
-    ]
-  }
-}
-EOM
-
-  X=$(./yq e -j test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea -j test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testOutputJson() {
-  cat >test.yml <<EOL
-a: {b: ["cat"]}
-EOL
-
-  read -r -d '' expected << EOM
-{
-  "a": {
-    "b": [
-      "cat"
-    ]
-  }
-}
-EOM
-
-  X=$(./yq e --output-format=json test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea --output-format=json test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testOutputJsonShort() {
-  cat >test.yml <<EOL
-a: {b: ["cat"]}
-EOL
-
-  read -r -d '' expected << EOM
-{
-  "a": {
-    "b": [
-      "cat"
-    ]
-  }
-}
-EOM
-
-  X=$(./yq e -o=j test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea -o=j test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testOutputProperties() {
-  cat >test.yml <<EOL
-a: {b: {c: ["cat"]}}
-EOL
-
-  read -r -d '' expected << EOM
-a.b.c.0 = cat
-EOM
-
-  X=$(./yq e --output-format=props test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea --output-format=props test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testOutputPropertiesShort() {
-  cat >test.yml <<EOL
-a: {b: {c: ["cat"]}}
-EOL
-
-  read -r -d '' expected << EOM
-a.b.c.0 = cat
-EOM
-
-  X=$(./yq e -o=p test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea -o=p test.yml)
-  assertEquals "$expected" "$X"
-}
-
-source ./scripts/shunit2
@@ -1,173 +0,0 @@
-#!/bin/bash
-
-
-testPrettyPrintWithBooleans() {
-  cat >test.yml <<EOL
-leaveUnquoted: [yes, no, on, off, y, n, true, false]
-leaveQuoted: ["yes", "no", "on", "off", "y", "n", "true", "false"]
-
-EOL
-
-  read -r -d '' expected << EOM
-leaveUnquoted:
-  - yes
-  - no
-  - on
-  - off
-  - y
-  - n
-  - true
-  - false
-leaveQuoted:
-  - "yes"
-  - "no"
-  - "on"
-  - "off"
-  - "y"
-  - "n"
-  - "true"
-  - "false"
-EOM
-
-  X=$(./yq e --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testPrettyPrintWithBooleansCapitals() {
-  cat >test.yml <<EOL
-leaveUnquoted: [YES, NO, ON, OFF, Y, N, TRUE, FALSE]
-leaveQuoted: ["YES", "NO", "ON", "OFF", "Y", "N", "TRUE", "FALSE"]
-EOL
-
-  read -r -d '' expected << EOM
-leaveUnquoted:
-  - YES
-  - NO
-  - ON
-  - OFF
-  - Y
-  - N
-  - TRUE
-  - FALSE
-leaveQuoted:
-  - "YES"
-  - "NO"
-  - "ON"
-  - "OFF"
-  - "Y"
-  - "N"
-  - "TRUE"
-  - "FALSE"
-EOM
-
-  X=$(./yq e --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testPrettyPrintOtherStringValues() {
-  cat >test.yml <<EOL
-leaveUnquoted: [yesSir, hellno, bonapite]
-makeUnquoted: ["yesSir", "hellno", "bonapite"]
-EOL
-
-  read -r -d '' expected << EOM
-leaveUnquoted:
-  - yesSir
-  - hellno
-  - bonapite
-makeUnquoted:
-  - yesSir
-  - hellno
-  - bonapite
-EOM
-
-  X=$(./yq e --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testPrettyPrintKeys() {
-  cat >test.yml <<EOL
-"removeQuotes": "please"
-EOL
-
-  read -r -d '' expected << EOM
-removeQuotes: please
-EOM
-
-  X=$(./yq e --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testPrettyPrintOtherStringValues() {
-  cat >test.yml <<EOL
-leaveUnquoted: [yesSir, hellno, bonapite]
-makeUnquoted: ["yesSir", "hellno", "bonapite"]
-EOL
-
-  read -r -d '' expected << EOM
-leaveUnquoted:
-  - yesSir
-  - hellno
-  - bonapite
-makeUnquoted:
-  - yesSir
-  - hellno
-  - bonapite
-EOM
-
-  X=$(./yq e --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testPrettyPrintStringBlocks() {
-  cat >test.yml <<EOL
-"removeQuotes": | 
-  "please"
-EOL
-
-  read -r -d '' expected << EOM
-removeQuotes: |
-  "please"
-EOM
-
-  X=$(./yq e --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-}
-
-testPrettyPrintWithExpression() {
-  cat >test.yml <<EOL
-a: {b: {c: ["cat"]}}
-EOL
-
-  read -r -d '' expected << EOM
-b:
-  c:
-    - cat
-EOM
-
-  X=$(./yq e '.a' --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-
-  X=$(./yq ea '.a' --prettyPrint test.yml)
-  assertEquals "$expected" "$X"
-}
-
-source ./scripts/shunit2
@@ -1,15 +1,11 @@
 name: 'yq - portable yaml processor'
 description: 'create, read, update, delete, merge, validate and do more with yaml'
-branding:
-  icon: command
-  color: gray-dark
+icon: command
+color: gray-dark
 inputs:
  cmd:
    description: 'The Command which should be run'
    required: true
-outputs:
-  result:
-    description: "The complete result from the yq command being run"
 runs:
  using: 'docker'
  image: 'github-action/Dockerfile'
@@ -1,11 +1,9 @@
 package cmd

-var leadingContentPreProcessing = true
 var unwrapScalar = true

 var writeInplace = false
 var outputToJSON = false
-var outputFormat = "yaml"

 var exitStatus = false
 var forceColor = false
@@ -16,9 +14,5 @@ var noDocSeparators = false
 var nullInput = false
 var verbose = false
 var version = false
-var prettyPrint = false
-
-// can be either "" (off), "extract" or "process"
-var frontMatter = ""

 var completedSuccessfully = false
@@ -15,27 +15,10 @@ func createEvaluateAllCommand() *cobra.Command {
 		Aliases: []string{"ea"},
 		Short:   "Loads _all_ yaml documents of _all_ yaml files and runs expression once",
 		Example: `
-# Merge f2.yml into f1.yml (inplace)
-yq eval-all --inplace 'select(fileIndex == 0) * select(fileIndex == 1)' f1.yml f2.yml
-## the same command and expression using shortened names:
-yq ea -i 'select(fi == 0) * select(fi == 1)' f1.yml f2.yml
-
-
-# Merge all given files
-yq ea '. as $item ireduce ({}; . * $item )' file1.yml file2.yml ...
-
-# Pipe from STDIN
-## use '-' as a filename to pipe from STDIN
-cat file2.yml | yq ea '.a.b' file1.yml - file3.yml
-`,
-		Long: `yq is a portable command-line YAML processor (https://github.com/mikefarah/yq/) 
-See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.
-
-## Evaluate All ##
-This command loads _all_ yaml documents of _all_ yaml files and runs expression once
-Useful when you need to run an expression across several yaml documents or files (like merge).
-Note that it consumes more memory than eval.
+# merges f2.yml into f1.yml (inplace)
+yq eval-all --inplace 'select(fileIndex == 0) * select(fileIndex == 1)' f1.yml f2.yml		
 `,
+		Long: "Evaluate All:\nUseful when you need to run an expression across several yaml documents or files. Consumes more memory than eval",
 		RunE: evaluateAll,
 	}
 	return cmdEvalAll
@@ -59,21 +42,14 @@ func evaluateAll(cmd *cobra.Command, args []string) error {
 		colorsEnabled = true
 	}

-	firstFileIndex := -1
-	if !nullInput && len(args) == 1 {
-		firstFileIndex = 0
-	} else if len(args) > 1 {
-		firstFileIndex = 1
-	}
-
-	if writeInplace && (firstFileIndex == -1) {
+	if writeInplace && len(args) < 2 {
 		return fmt.Errorf("Write inplace flag only applicable when giving an expression and at least one file")
 	}

 	if writeInplace {
 		// only use colors if its forced
 		colorsEnabled = forceColor
-		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[firstFileIndex])
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[1])
 		out, err = writeInPlaceHandler.CreateTempFile()
 		if err != nil {
 			return err
@@ -83,54 +59,25 @@ func evaluateAll(cmd *cobra.Command, args []string) error {
 		defer func() { writeInPlaceHandler.FinishWriteInPlace(completedSuccessfully) }()
 	}

-	if nullInput && len(args) > 1 {
-		return errors.New("Cannot pass files in when using null-input flag")
-	}
-	// backwards compatibilty
-	if outputToJSON {
-		outputFormat = "json"
-	}
-
-	format, err := yqlib.OutputFormatFromString(outputFormat)
-	if err != nil {
-		return err
-	}
-
-	printer := yqlib.NewPrinter(out, format, unwrapScalar, colorsEnabled, indent, !noDocSeparators)
-
-	if frontMatter != "" {
-		frontMatterHandler := yqlib.NewFrontMatterHandler(args[firstFileIndex])
-		err = frontMatterHandler.Split()
-		if err != nil {
-			return err
-		}
-		args[firstFileIndex] = frontMatterHandler.GetYamlFrontMatterFilename()
-
-		if frontMatter == "process" {
-			reader := frontMatterHandler.GetContentReader()
-			printer.SetAppendix(reader)
-			defer yqlib.SafelyCloseReader(reader)
-		}
-		defer frontMatterHandler.CleanUp()
-	}
+	printer := yqlib.NewPrinter(out, outputToJSON, unwrapScalar, colorsEnabled, indent, !noDocSeparators)

 	allAtOnceEvaluator := yqlib.NewAllAtOnceEvaluator()
 	switch len(args) {
 	case 0:
 		if pipingStdIn {
-			err = allAtOnceEvaluator.EvaluateFiles(processExpression(""), []string{"-"}, printer, leadingContentPreProcessing)
+			err = allAtOnceEvaluator.EvaluateFiles("", []string{"-"}, printer)
 		} else {
 			cmd.Println(cmd.UsageString())
 			return nil
 		}
 	case 1:
 		if nullInput {
-			err = yqlib.NewStreamEvaluator().EvaluateNew(processExpression(args[0]), printer, "")
+			err = yqlib.NewStreamEvaluator().EvaluateNew(args[0], printer)
 		} else {
-			err = allAtOnceEvaluator.EvaluateFiles(processExpression(""), []string{args[0]}, printer, leadingContentPreProcessing)
+			err = allAtOnceEvaluator.EvaluateFiles("", []string{args[0]}, printer)
 		}
 	default:
-		err = allAtOnceEvaluator.EvaluateFiles(processExpression(args[0]), args[1:], printer, leadingContentPreProcessing)
+		err = allAtOnceEvaluator.EvaluateFiles(args[0], args[1:], printer)
 	}

 	completedSuccessfully = err == nil
@@ -13,46 +13,26 @@ func createEvaluateSequenceCommand() *cobra.Command {
 	var cmdEvalSequence = &cobra.Command{
 		Use:     "eval [expression] [yaml_file1]...",
 		Aliases: []string{"e"},
-		Short:   "Apply the expression to each document in each yaml file in sequence",
+		Short:   "Apply expression to each document in each yaml file given in sequence",
 		Example: `
-# Reads field under the given path for each file
-yq e '.a.b' f1.yml f2.yml 
+# runs the expression against each file, in series
+yq e '.a.b | length' f1.yml f2.yml 

-# Prints out the file
+# prints out the file
 yq e sample.yaml 

-# Pipe from STDIN
-## use '-' as a filename to pipe from STDIN
-cat file2.yml | yq e '.a.b' file1.yml - file3.yml
-
-# Creates a new yaml document
-## Note that editing an empty file does not work.
+# prints a new yaml document
 yq e -n '.a.b.c = "cat"' 

-# Update a file inplace
+
+# updates file.yaml directly
 yq e '.a.b = "cool"' -i file.yaml 
 `,
-		Long: `yq is a portable command-line YAML processor (https://github.com/mikefarah/yq/) 
-See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.
-
-## Evaluate Sequence ##
-This command iterates over each yaml document from each given file, applies the 
-expression and prints the result in sequence.`,
+		Long: "Evaluate Sequence:\nIterate over each yaml document, apply the expression and print the results, in sequence.",
 		RunE: evaluateSequence,
 	}
 	return cmdEvalSequence
 }
-
-func processExpression(expression string) string {
-	var prettyPrintExp = `(... | (select(tag != "!!str"), select(tag == "!!str") | select(test("(?i)^(y|yes|n|no|on|off)$") | not))  ) style=""`
-	if prettyPrint && expression == "" {
-		return prettyPrintExp
-	} else if prettyPrint {
-		return fmt.Sprintf("%v | %v", expression, prettyPrintExp)
-	}
-	return expression
-}
-
 func evaluateSequence(cmd *cobra.Command, args []string) error {
 	cmd.SilenceUsage = true
 	// 0 args, read std in
@@ -72,21 +52,14 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 		colorsEnabled = true
 	}

-	firstFileIndex := -1
-	if !nullInput && len(args) == 1 {
-		firstFileIndex = 0
-	} else if len(args) > 1 {
-		firstFileIndex = 1
-	}
-
-	if writeInplace && (firstFileIndex == -1) {
+	if writeInplace && len(args) < 2 {
 		return fmt.Errorf("Write inplace flag only applicable when giving an expression and at least one file")
 	}

 	if writeInplace {
 		// only use colors if its forced
 		colorsEnabled = forceColor
-		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[firstFileIndex])
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[1])
 		out, err = writeInPlaceHandler.CreateTempFile()
 		if err != nil {
 			return err
@@ -96,56 +69,26 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 		defer func() { writeInPlaceHandler.FinishWriteInPlace(completedSuccessfully) }()
 	}

-	// backwards compatibilty
-	if outputToJSON {
-		outputFormat = "json"
-	}
-
-	format, err := yqlib.OutputFormatFromString(outputFormat)
-	if err != nil {
-		return err
-	}
-
-	printer := yqlib.NewPrinter(out, format, unwrapScalar, colorsEnabled, indent, !noDocSeparators)
+	printer := yqlib.NewPrinter(out, outputToJSON, unwrapScalar, colorsEnabled, indent, !noDocSeparators)

 	streamEvaluator := yqlib.NewStreamEvaluator()

-	if nullInput && len(args) > 1 {
-		return errors.New("Cannot pass files in when using null-input flag")
-	}
-
-	if frontMatter != "" {
-		frontMatterHandler := yqlib.NewFrontMatterHandler(args[firstFileIndex])
-		err = frontMatterHandler.Split()
-		if err != nil {
-			return err
-		}
-		args[firstFileIndex] = frontMatterHandler.GetYamlFrontMatterFilename()
-
-		if frontMatter == "process" {
-			reader := frontMatterHandler.GetContentReader()
-			printer.SetAppendix(reader)
-			defer yqlib.SafelyCloseReader(reader)
-		}
-		defer frontMatterHandler.CleanUp()
-	}
-
 	switch len(args) {
 	case 0:
 		if pipingStdIn {
-			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{"-"}, printer, leadingContentPreProcessing)
+			err = streamEvaluator.EvaluateFiles("", []string{"-"}, printer)
 		} else {
 			cmd.Println(cmd.UsageString())
 			return nil
 		}
 	case 1:
 		if nullInput {
-			err = streamEvaluator.EvaluateNew(processExpression(args[0]), printer, "")
+			err = streamEvaluator.EvaluateNew(args[0], printer)
 		} else {
-			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{args[0]}, printer, leadingContentPreProcessing)
+			err = streamEvaluator.EvaluateFiles("", []string{args[0]}, printer)
 		}
 	default:
-		err = streamEvaluator.EvaluateFiles(processExpression(args[0]), args[1:], printer, leadingContentPreProcessing)
+		err = streamEvaluator.EvaluateFiles(args[0], args[1:], printer)
 	}
 	completedSuccessfully = err == nil

@@ -11,8 +11,7 @@ func New() *cobra.Command {
 	var rootCmd = &cobra.Command{
 		Use:   "yq",
 		Short: "yq is a lightweight and portable command-line YAML processor.",
-		Long: `yq is a portable command-line YAML processor (https://github.com/mikefarah/yq/) 
-See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.`,
+		Long:  `yq is a lightweight and portable command-line YAML processor. It aims to be the jq or sed of yaml files.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if version {
 				cmd.Print(GetVersionDisplay())
@@ -41,14 +40,7 @@ See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.`,
 	}

 	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "verbose mode")
-
-	rootCmd.PersistentFlags().BoolVarP(&outputToJSON, "tojson", "j", false, "(deprecated) output as json. Set indent to 0 to print json in one line.")
-	err := rootCmd.PersistentFlags().MarkDeprecated("tojson", "please use -o=json instead")
-	if err != nil {
-		panic(err)
-	}
-
-	rootCmd.PersistentFlags().StringVarP(&outputFormat, "output-format", "o", "yaml", "[yaml|y|json|j|props|p] output format type.")
+	rootCmd.PersistentFlags().BoolVarP(&outputToJSON, "tojson", "j", false, "output as json. Set indent to 0 to print json in one line.")
 	rootCmd.PersistentFlags().BoolVarP(&nullInput, "null-input", "n", false, "Don't read input, simply evaluate the expression given. Useful for creating yaml docs from scratch.")
 	rootCmd.PersistentFlags().BoolVarP(&noDocSeparators, "no-doc", "N", false, "Don't print document separators (---)")

@@ -56,13 +48,10 @@ See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.`,
 	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")
 	rootCmd.PersistentFlags().BoolVarP(&forceNoColor, "no-colors", "M", false, "force print with no colors")
-	rootCmd.PersistentFlags().StringVarP(&frontMatter, "front-matter", "f", "", "(extract|process) first input as yaml front-matter. Extract will pull out the yaml content, process will run the expression against the yaml content, leaving the remaining data intact")
-	rootCmd.PersistentFlags().BoolVarP(&leadingContentPreProcessing, "header-preprocess", "", true, "Slurp any header comments and seperators before processing expression. This is a workaround for go-yaml to persist header content. This flag will be removed once this feature has been out in the wild for a while.")
 	rootCmd.AddCommand(
 		createEvaluateSequenceCommand(),
 		createEvaluateAllCommand(),
@@ -11,7 +11,7 @@ var (
 	GitDescribe string

 	// Version is main version number that is being run at the moment.
-	Version = "4.13.1"
+	Version = "4.1.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
@@ -25,7 +25,7 @@ const ProductName = "yq"
 // GetVersionDisplay composes the parts of the version in a way that's suitable
 // for displaying to humans.
 func GetVersionDisplay() string {
-	return fmt.Sprintf("yq (https://github.com/mikefarah/yq/) version %s\n", getHumanVersion())
+	return fmt.Sprintf("%s version %s\n", ProductName, getHumanVersion())
 }

 func getHumanVersion() string {
@@ -3,7 +3,7 @@ package cmd
 import "testing"

 func TestGetVersionDisplay(t *testing.T) {
-	var expectedVersion = ProductName + " (https://github.com/mikefarah/yq/) version " + Version
+	var expectedVersion = ProductName + " version " + Version
 	if VersionPrerelease != "" {
 		expectedVersion = expectedVersion + "-" + VersionPrerelease
 	}
@@ -1,28 +1,3 @@
-yq (4.13.0) focal; urgency=medium
-
-  * New `with` operator for making multiple changes to a given path
-  * New `contains` operator, works like the `jq` equivalent
-  * Subtract operator now supports subtracting elements from arrays!
-  * Fixed Swapping values using variables #934
-  * Github Action now properly supports multiline output #936, thanks @pjxiao
-  * Fixed missing closing bracket validation #932
-  * Fix processing of hex numbers #929
-  * Fixed alternative and union operator issues #930
-  * Can now convert yaml to properties properties format (`-o=props`), See [docs](https://mikefarah.gitbook.io/yq/v/v4.x/usage/properties) for more info.
-  * Fixed document header/footer comment handling when merging (https://github.com/mikefarah/yq/issues/919)
-  * pretty print yaml 1.1 compatibility  (https://github.com/mikefarah/yq/issues/914)
-
- -- Roberto Mier Escandon <rmescandon@gmail.com>  Thu, 16 Sep 2021 20:58:30 +0200
-
-yq (4.9.6) focal; urgency=medium
-
-  * Added darwin/arm64 build, thanks @alecthomas
-  * Incremented docker alpine base version, thanks @da6d6i7-bronga
-  * Bug fix: multine expression
-  * Bug fix: special character
-
- -- Roberto Mier Escandon <rmescandon@gmail.com>  Tue, 29 Jun 2021 21:32:14 +0200
-
 yq (3.3.2) focal; urgency=medium

  * Bug fix: existStatus bug (#459)
@@ -3,7 +3,8 @@ Section: devel
 Priority: optional
 Maintainer: Roberto Mier Escandón <rmescandon@gmail.com>
 Build-Depends: debhelper (>=10),
-               golang-1.15,
+               dh-golang (>=1.34),
+               golang-1.13,
               rsync
 Standards-Version: 4.1.4
 Homepage: https://github.com/mikefarah/yq.git
@@ -17,7 +17,7 @@
 PROJECT := yq
 OWNER := mikefarah
 REPO := github.com
-GOVERSION := 1.15
+GOVERSION := 1.13

 export DH_OPTIONS
 export DH_GOPKG := ${REPO}/${OWNER}/${PROJECT}
@@ -34,7 +34,7 @@ BINDIR := /usr/bin
 ASSETSDIR := /usr/share/${PROJECT}

 %:
-	dh $@
+	dh $@ --builddirectory=${GOPATH} --buildsystem=golang

 override_dh_auto_build:
 	mkdir -p ${SRCDIR}
@@ -1,5 +1,4 @@
-Resources:
-  S3Bucket:
-    Type: AWS::CloudFormation::Stack
-    Properties:
-      BucketName: !Ref MyBucketNameA
+a: simple # just the best
+b: [1, 2]
+c:
+  test: 1
@@ -1,3 +1,7 @@
-#b1 
-b: 2
-#b2
+a: other # better than the original
+b: [3, 4]
+c:
+  toast: leave
+  test: 1
+  tell: 1
+  tasty.taco: cool
@@ -1 +1,2 @@
-# comment
+# a: apple
+# b: cat
@@ -1,6 +0,0 @@
---
-a: apple
-b: bannana
---
-hello there
-apples: great
@@ -1,2 +0,0 @@
---
-a: test
@@ -1,8 +1,5 @@
-FROM mikefarah/yq:4.13.1
+FROM mikefarah/yq:3

 COPY entrypoint.sh /entrypoint.sh

-# this seems to be the default user in github actions
-USER 1001
-
 ENTRYPOINT ["/entrypoint.sh"]
@@ -1,9 +1,4 @@
 #!/bin/sh -l
-set -e
-echo "::debug::\$cmd: $1"
-RESULT=$(eval "$1")
-RESULT="${RESULT//'%'/'%25'}"
-RESULT="${RESULT//$'\n'/'%0A'}"
-RESULT="${RESULT//$'\r'/'%0D'}"
-echo "::debug::\$RESULT: $RESULT"
-echo ::set-output name=result::"$RESULT"
+
+echo "$1"
+eval $1
@@ -1,17 +1,18 @@
 module github.com/mikefarah/yq/v4

 require (
-	github.com/elliotchance/orderedmap v1.4.0
-	github.com/fatih/color v1.10.0
-	github.com/goccy/go-yaml v1.8.9
-	github.com/jinzhu/copier v0.2.8
-	github.com/magiconair/properties v1.8.5
-	github.com/spf13/cobra v1.1.3
+	github.com/elliotchance/orderedmap v1.3.0
+	github.com/fatih/color v1.9.0
+	github.com/goccy/go-yaml v1.8.1
+	github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a
+	github.com/mattn/go-colorable v0.1.7 // indirect
+	github.com/spf13/cobra v1.1.1
 	github.com/timtadh/data-structures v0.5.3 // indirect
 	github.com/timtadh/lexmachine v0.2.2
-	golang.org/x/sys v0.0.0-20210510120138-977fb7262007 // indirect
+	golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473
-	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
+	gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776
 )

 go 1.15
@@ -36,24 +36,22 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/elliotchance/orderedmap v1.4.0 h1:wZtfeEONCbx6in1CZyE6bELEt/vFayMvsxqI5SgsR+A=
-github.com/elliotchance/orderedmap v1.4.0/go.mod h1:wsDwEaX5jEoyhbs7x93zk2H/qv0zwuhg4inXhDkYqys=
+github.com/elliotchance/orderedmap v1.3.0 h1:k6m77/d0zCXTjsk12nX40TkEBkSICq8T4s6R6bpCqU0=
+github.com/elliotchance/orderedmap v1.3.0/go.mod h1:8hdSl6jmveQw8ScByd3AaNHNk51RhbTazdqtTty+NFw=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg=
-github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
+github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
+github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
 github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
-github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/goccy/go-yaml v1.8.9 h1:4AEXg2qx+/w29jXnXpMY6mTckmYu1TMoHteKuMf0HFg=
-github.com/goccy/go-yaml v1.8.9/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
+github.com/goccy/go-yaml v1.8.1 h1:JuZRFlqLM5cWF6A+waL8AKVuCcqvKOuhJtUQI+L3ez0=
+github.com/goccy/go-yaml v1.8.1/go.mod h1:wS4gNoLalDSJxo/SpngzPQ2BN4uuZVLCmbM4S3vd4+Y=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -101,8 +99,8 @@ github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2p
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/jinzhu/copier v0.2.8 h1:N8MbL5niMwE3P4dOwurJixz5rMkKfujmMRFmAanSzWE=
-github.com/jinzhu/copier v0.2.8/go.mod h1:24xnZezI2Yqac9J61UC6/dG/k76ttpq0DdJI3QmUvro=
+github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a h1:zPPuIq2jAWWPTrGt70eK/BSch+gFAGrNzecsoENgu2o=
+github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a/go.mod h1:yL958EeXv8Ylng6IfnvG4oflryUi3vgA3xPs9hmII1s=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
@@ -119,12 +117,16 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
-github.com/magiconair/properties v1.8.5 h1:b6kJs+EmPFMYGkow9GiUyCyOvIwYetYJ3fSaWak/Gls=
-github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
-github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
+github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.7 h1:bQGKb3vps/j0E9GfJQ03JyhRuxsvdAanXlT9BTw3mdw=
+github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84=
+github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM=
+github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
 github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
@@ -170,9 +172,10 @@ github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4k
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/spf13/cobra v1.1.3 h1:xghbfqPkxzxP3C/f3n5DdpAbdKLj4ZE4BWQI362l53M=
-github.com/spf13/cobra v1.1.3/go.mod h1:pGADOWyqRD/YMrPZigI/zbliZ2wVD/23d+is3pSWzOo=
+github.com/spf13/cobra v1.1.1 h1:KfztREH0tPxJJ+geloSLaAkaPkr4ki2Er5quFV1TDo4=
+github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
@@ -181,9 +184,8 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/timtadh/data-structures v0.5.3 h1:F2tEjoG9qWIyUjbvXVgJqEOGJPMIiYn7U5W5mE+i/vQ=
 github.com/timtadh/data-structures v0.5.3/go.mod h1:9R4XODhJ8JdWFEI8P/HJKqxuJctfBQw6fDibMQny2oU=
@@ -202,7 +204,6 @@ golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -250,16 +251,22 @@ golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+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-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+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=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -269,6 +276,7 @@ golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd h1:/e+gpKk9r3dJobndpTytxS2gOy6m5uvpg+ISQoEcusQ=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
@@ -283,6 +291,8 @@ golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
@@ -307,22 +317,26 @@ google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZi
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
+gopkg.in/go-playground/validator.v9 v9.30.0/go.mod h1:+c9/zcJMFNgbLvly1L1V+PpxWdVbfP1avr/N00E2vyQ=
 gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473 h1:6D+BvnJ/j6e222UW8s2qTSe3wGBtvo0MbVQG/c5k8RE=
 gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473/go.mod h1:N1eN2tsCx0Ydtgjl4cqmbRCsY4/+z4cYDeqwZTk6zog=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
-gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 h1:tQIYjPdBoyREyB9XMu+nnTclpTYkz2zFM+lzLJFO4gQ=
+gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
@@ -1,66 +1,35 @@
 package yqlib

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

-	yaml "gopkg.in/yaml.v3"
-)
-
-// A yaml expression evaluator that runs the expression once against all files/nodes in memory.
+/**
+	Loads all yaml documents of all files given into memory, then runs the given expression once.
+**/
 type Evaluator interface {
-	EvaluateFiles(expression string, filenames []string, printer Printer, leadingContentPreProcessing bool) error
-
-	// EvaluateNodes takes an expression and one or more yaml nodes, returning a list of matching candidate nodes
-	EvaluateNodes(expression string, nodes ...*yaml.Node) (*list.List, error)
-
-	// EvaluateCandidateNodes takes an expression and list of candidate nodes, returning a list of matching candidate nodes
-	EvaluateCandidateNodes(expression string, inputCandidateNodes *list.List) (*list.List, error)
+	EvaluateFiles(expression string, filenames []string, printer Printer) error
 }

 type allAtOnceEvaluator struct {
 	treeNavigator DataTreeNavigator
-	treeCreator   ExpressionParser
+	treeCreator   PathTreeCreator
 }

 func NewAllAtOnceEvaluator() Evaluator {
-	return &allAtOnceEvaluator{treeNavigator: NewDataTreeNavigator(), treeCreator: NewExpressionParser()}
+	return &allAtOnceEvaluator{treeNavigator: NewDataTreeNavigator(), treeCreator: NewPathTreeCreator()}
 }

-func (e *allAtOnceEvaluator) EvaluateNodes(expression string, nodes ...*yaml.Node) (*list.List, error) {
-	inputCandidates := list.New()
-	for _, node := range nodes {
-		inputCandidates.PushBack(&CandidateNode{Node: node})
-	}
-	return e.EvaluateCandidateNodes(expression, inputCandidates)
-}
-
-func (e *allAtOnceEvaluator) EvaluateCandidateNodes(expression string, inputCandidates *list.List) (*list.List, error) {
-	node, err := e.treeCreator.ParseExpression(expression)
-	if err != nil {
-		return nil, err
-	}
-	context, err := e.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputCandidates}, node)
-	if err != nil {
-		return nil, err
-	}
-	return context.MatchingNodes, nil
-}
-
-func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer, leadingContentPreProcessing bool) error {
+func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer) error {
 	fileIndex := 0
-	firstFileLeadingContent := ""
-
+	node, err := treeCreator.ParsePath(expression)
+	if err != nil {
+		return err
+	}
 	var allDocuments *list.List = list.New()
 	for _, filename := range filenames {
-		reader, leadingContent, err := readStream(filename, fileIndex == 0 && leadingContentPreProcessing)
+		reader, err := readStream(filename)
 		if err != nil {
 			return err
 		}
-
-		if fileIndex == 0 {
-			firstFileLeadingContent = leadingContent
-		}
-
 		fileDocuments, err := readDocuments(reader, filename, fileIndex)
 		if err != nil {
 			return err
@@ -68,20 +37,7 @@ func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string
 		allDocuments.PushBackList(fileDocuments)
 		fileIndex = fileIndex + 1
 	}
-
-	if allDocuments.Len() == 0 {
-		candidateNode := &CandidateNode{
-			Document:  0,
-			Filename:  "",
-			Node:      &yaml.Node{Kind: yaml.DocumentNode, HeadComment: firstFileLeadingContent, Content: []*yaml.Node{{Tag: "!!null", Kind: yaml.ScalarNode}}},
-			FileIndex: 0,
-		}
-		allDocuments.PushBack(candidateNode)
-	} else {
-		allDocuments.Front().Value.(*CandidateNode).Node.HeadComment = firstFileLeadingContent
-	}
-
-	matches, err := e.EvaluateCandidateNodes(expression, allDocuments)
+	matches, err := treeNavigator.GetMatchingNodes(allDocuments, node)
 	if err != nil {
 		return err
 	}
@@ -1,40 +0,0 @@
-package yqlib
-
-import (
-	"testing"
-
-	"github.com/mikefarah/yq/v4/test"
-)
-
-var evaluateNodesScenario = []expressionScenario{
-	{
-		document:   `a: hello`,
-		expression: `.a`,
-		expected: []string{
-			"D0, P[a], (!!str)::hello\n",
-		},
-	},
-	{
-		document:   `a: hello`,
-		expression: `.`,
-		expected: []string{
-			"D0, P[], (doc)::a: hello\n",
-		},
-	},
-	{
-		document:   `- a: "yes"`,
-		expression: `.[] | has("a")`,
-		expected: []string{
-			"D0, P[0], (!!bool)::true\n",
-		},
-	},
-}
-
-func TestAllAtOnceEvaluateNodes(t *testing.T) {
-	var evaluator = NewAllAtOnceEvaluator()
-	for _, tt := range evaluateNodesScenario {
-		node := test.ParseData(tt.document)
-		list, _ := evaluator.EvaluateNodes(tt.expression, &node)
-		test.AssertResultComplex(t, tt.expected, resultsToString(list))
-	}
-}
@@ -2,50 +2,26 @@ package yqlib

 import (
 	"fmt"
+	"strconv"
+	"strings"

 	"github.com/jinzhu/copier"
 	yaml "gopkg.in/yaml.v3"
 )

 type CandidateNode struct {
-	Node      *yaml.Node     // the actual node
-	Parent    *CandidateNode // parent node
-	Path      []interface{}  /// the path we took to get to this node
-	Document  uint           // the document index of this node
+	Node      *yaml.Node    // the actual node
+	Path      []interface{} /// the path we took to get to this node
+	Document  uint          // the document index of this node
 	Filename  string
 	FileIndex int
-	// when performing op against all nodes given, this will treat all the nodes as one
-	// (e.g. top level cross document merge). This property does not propegate to child nodes.
-	EvaluateTogether bool
-	IsMapKey         bool
 }

 func (n *CandidateNode) GetKey() string {
-	keyPrefix := ""
-	if n.IsMapKey {
-		keyPrefix = "key-"
-	}
-	return fmt.Sprintf("%v%v - %v", keyPrefix, n.Document, n.Path)
+	return fmt.Sprintf("%v - %v", n.Document, n.Path)
 }

-func (n *CandidateNode) CreateChild(path interface{}, node *yaml.Node) *CandidateNode {
-	return &CandidateNode{
-		Node:      node,
-		Path:      n.createChildPath(path),
-		Parent:    n,
-		Document:  n.Document,
-		Filename:  n.Filename,
-		FileIndex: n.FileIndex,
-	}
-}
-
-func (n *CandidateNode) createChildPath(path interface{}) []interface{} {
-	if path == nil {
-		newPath := make([]interface{}, len(n.Path))
-		copy(newPath, n.Path)
-		return newPath
-	}
-
+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)
@@ -64,14 +40,13 @@ func (n *CandidateNode) Copy() (*CandidateNode, error) {

 // updates this candidate from the given candidate node
 func (n *CandidateNode) UpdateFrom(other *CandidateNode) {
-
 	n.UpdateAttributesFrom(other)
 	n.Node.Content = other.Node.Content
 	n.Node.Value = other.Node.Value
+	n.Node.Alias = other.Node.Alias
 }

 func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode) {
-	log.Debug("UpdateAttributesFrom: n: %v other: %v", n.GetKey(), other.GetKey())
 	if n.Node.Kind != other.Node.Kind {
 		// clear out the contents when switching to a different type
 		// e.g. map to array
@@ -80,22 +55,56 @@ func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode) {
 	}
 	n.Node.Kind = other.Node.Kind
 	n.Node.Tag = other.Node.Tag
-	n.Node.Alias = other.Node.Alias
-	n.Node.Anchor = other.Node.Anchor

 	// merge will pickup the style of the new thing
 	// when autocreating nodes
 	if n.Node.Style == 0 {
 		n.Node.Style = other.Node.Style
 	}
+	n.Node.FootComment = n.Node.FootComment + other.Node.FootComment
+	n.Node.HeadComment = n.Node.HeadComment + other.Node.HeadComment
+	n.Node.LineComment = n.Node.LineComment + other.Node.LineComment
+}

-	if other.Node.FootComment != "" {
-		n.Node.FootComment = other.Node.FootComment
-	}
-	if other.Node.HeadComment != "" {
-		n.Node.HeadComment = other.Node.HeadComment
-	}
-	if other.Node.LineComment != "" {
-		n.Node.LineComment = other.Node.LineComment
+func (n *CandidateNode) PathStackToString() string {
+	return mergePathStackToString(n.Path)
+}
+
+func mergePathStackToString(pathStack []interface{}) string {
+	var sb strings.Builder
+	for index, path := range pathStack {
+		switch path.(type) {
+		case int, int64:
+			// if arrayMergeStrategy == AppendArrayMergeStrategy {
+			// sb.WriteString("[+]")
+			// } else {
+			sb.WriteString(fmt.Sprintf("[%v]", path))
+			// }
+
+		default:
+			s := fmt.Sprintf("%v", path)
+			var _, errParsingInt = strconv.ParseInt(s, 10, 64) // nolint
+
+			hasSpecial := strings.Contains(s, ".") || strings.Contains(s, "[") || strings.Contains(s, "]") || strings.Contains(s, "\"")
+			hasDoubleQuotes := strings.Contains(s, "\"")
+			wrappingCharacterStart := "\""
+			wrappingCharacterEnd := "\""
+			if hasDoubleQuotes {
+				wrappingCharacterStart = "("
+				wrappingCharacterEnd = ")"
+			}
+			if hasSpecial || errParsingInt == nil {
+				sb.WriteString(wrappingCharacterStart)
+			}
+			sb.WriteString(s)
+			if hasSpecial || errParsingInt == nil {
+				sb.WriteString(wrappingCharacterEnd)
+			}
+		}
+
+		if index < len(pathStack)-1 {
+			sb.WriteString(".")
+		}
 	}
+	return sb.String()
 }
@@ -17,8 +17,8 @@ func format(attr color.Attribute) string {
 	return fmt.Sprintf("%s[%dm", escape, attr)
 }

-func colorizeAndPrint(yamlBytes []byte, writer io.Writer) error {
-	tokens := lexer.Tokenize(string(yamlBytes))
+func ColorizeAndPrint(bytes []byte, writer io.Writer) error {
+	tokens := lexer.Tokenize(string(bytes))
 	var p printer.Printer
 	p.Bool = func() *printer.Property {
 		return &printer.Property{
@@ -1,106 +0,0 @@
-package yqlib
-
-import (
-	"container/list"
-	"fmt"
-
-	"github.com/jinzhu/copier"
-	logging "gopkg.in/op/go-logging.v1"
-)
-
-type Context struct {
-	MatchingNodes  *list.List
-	Variables      map[string]*list.List
-	DontAutoCreate bool
-}
-
-func (n *Context) SingleReadonlyChildContext(candidate *CandidateNode) Context {
-	list := list.New()
-	list.PushBack(candidate)
-	newContext := n.ChildContext(list)
-	newContext.DontAutoCreate = true
-	return newContext
-}
-
-func (n *Context) SingleChildContext(candidate *CandidateNode) Context {
-	list := list.New()
-	list.PushBack(candidate)
-	return n.ChildContext(list)
-}
-
-func (n *Context) GetVariable(name string) *list.List {
-	if n.Variables == nil {
-		return nil
-	}
-	return n.Variables[name]
-}
-
-func (n *Context) SetVariable(name string, value *list.List) {
-	if n.Variables == nil {
-		n.Variables = make(map[string]*list.List)
-	}
-	n.Variables[name] = value
-}
-
-func (n *Context) ChildContext(results *list.List) Context {
-	clone := Context{}
-	err := copier.Copy(&clone, n)
-	if err != nil {
-		log.Error("Error cloning context :(")
-		panic(err)
-	}
-	clone.MatchingNodes = results
-	return clone
-}
-
-func (n *Context) ToString() string {
-	if !log.IsEnabledFor(logging.DEBUG) {
-		return ""
-	}
-	result := fmt.Sprintf("Context\nDontAutoCreate: %v\n", n.DontAutoCreate)
-	return result + NodesToString(n.MatchingNodes)
-}
-
-func (n *Context) DeepClone() Context {
-	clone := Context{}
-	err := copier.Copy(&clone, n)
-	// copier doesn't do lists properly for some reason
-	clone.MatchingNodes = list.New()
-	for el := n.MatchingNodes.Front(); el != nil; el = el.Next() {
-		clonedNode, err := el.Value.(*CandidateNode).Copy()
-		if err != nil {
-			log.Error("Error cloning context :(")
-			panic(err)
-		}
-		clone.MatchingNodes.PushBack(clonedNode)
-	}
-
-	if err != nil {
-		log.Error("Error cloning context :(")
-		panic(err)
-	}
-	return clone
-}
-
-func (n *Context) Clone() Context {
-	clone := Context{}
-	err := copier.Copy(&clone, n)
-
-	if err != nil {
-		log.Error("Error cloning context :(")
-		panic(err)
-	}
-	return clone
-}
-
-func (n *Context) ReadOnlyClone() Context {
-	clone := n.Clone()
-	clone.DontAutoCreate = true
-	return clone
-}
-
-func (n *Context) WritableClone() Context {
-	clone := n.Clone()
-	clone.DontAutoCreate = false
-	return clone
-}
@@ -3,14 +3,16 @@ package yqlib
 import (
 	"fmt"

+	"container/list"
+
 	logging "gopkg.in/op/go-logging.v1"
 )

 type DataTreeNavigator interface {
-	// given the context and a expressionNode,
-	// this will process the against the given expressionNode and return
-	// a new context of matching candidates
-	GetMatchingNodes(context Context, expressionNode *ExpressionNode) (Context, error)
+	// given a list of CandidateEntities and a pathNode,
+	// this will process the list against the given pathNode and return
+	// a new list of matching candidates
+	GetMatchingNodes(matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error)
 }

 type dataTreeNavigator struct {
@@ -20,22 +22,22 @@ func NewDataTreeNavigator() DataTreeNavigator {
 	return &dataTreeNavigator{}
 }

-func (d *dataTreeNavigator) GetMatchingNodes(context Context, expressionNode *ExpressionNode) (Context, error) {
-	if expressionNode == nil {
+func (d *dataTreeNavigator) GetMatchingNodes(matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	if pathNode == nil {
 		log.Debugf("getMatchingNodes - nothing to do")
-		return context, nil
+		return matchingNodes, nil
 	}
-	log.Debugf("Processing Op: %v", expressionNode.Operation.toString())
+	log.Debugf("Processing Op: %v", pathNode.Operation.toString())
 	if log.IsEnabledFor(logging.DEBUG) {
-		for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
+		for el := matchingNodes.Front(); el != nil; el = el.Next() {
 			log.Debug(NodeToString(el.Value.(*CandidateNode)))
 		}
 	}
 	log.Debug(">>")
-	handler := expressionNode.Operation.OperationType.Handler
+	handler := pathNode.Operation.OperationType.Handler
 	if handler != nil {
-		return handler(d, context, expressionNode)
+		return handler(d, matchingNodes, pathNode)
 	}
-	return Context{}, fmt.Errorf("Unknown operator %v", expressionNode.Operation.OperationType)
+	return nil, fmt.Errorf("Unknown operator %v", pathNode.Operation.OperationType)

 }
@@ -1,9 +1,9 @@
 Add behaves differently according to the type of the LHS:
 - arrays: concatenate
- number scalars: arithmetic addition
- string scalars: concatenate
+- number scalars: arithmetic addition (soon)
+- string scalars: concatenate (soon)

-Use `+=` as append assign for things like increment. Note that `.a += .x` is equivalent to running `.a = .a + .x`.
+Use `+=` as append assign for things like increment. `.a += .x` is equivalent to running `.a |= . + .x`.

 ## Concatenate and assign arrays
 Given a sample.yml file of:
@@ -67,19 +67,23 @@ will output
 - 2
 ```

-## Add new object to array
+## Add object to array
 Given a sample.yml file of:
 ```yaml
 a:
-  - dog: woof
+  - 1
+  - 2
+c:
+  cat: meow
 ```
 then
 ```bash
-yq eval '.a + {"cat": "meow"}' sample.yml
+yq eval '.a + .c' sample.yml
 ```
 will output
 ```yaml
- dog: woof
+- 1
+- 2
 - cat: meow
 ```

@@ -101,7 +105,7 @@ will output
 - hello
 ```

-## Append to array
+## Update array (append)
 Given a sample.yml file of:
 ```yaml
 a:
@@ -127,139 +131,3 @@ b:
  - 4
 ```

-## Append another array using +=
-Given a sample.yml file of:
-```yaml
-a:
-  - 1
-  - 2
-b:
-  - 3
-  - 4
-```
-then
-```bash
-yq eval '.a += .b' sample.yml
-```
-will output
-```yaml
-a:
-  - 1
-  - 2
-  - 3
-  - 4
-b:
-  - 3
-  - 4
-```
-
-## Relative append
-Given a sample.yml file of:
-```yaml
-a:
-  a1:
-    b:
-      - cat
-  a2:
-    b:
-      - dog
-  a3: {}
-```
-then
-```bash
-yq eval '.a[].b += ["mouse"]' sample.yml
-```
-will output
-```yaml
-a:
-  a1:
-    b:
-      - cat
-      - mouse
-  a2:
-    b:
-      - dog
-      - mouse
-  a3: {b: [mouse]}
-```
-
-## String concatenation
-Given a sample.yml file of:
-```yaml
-a: cat
-b: meow
-```
-then
-```bash
-yq eval '.a = .a + .b' sample.yml
-```
-will output
-```yaml
-a: catmeow
-b: meow
-```
-
-## Number addition - float
-If the lhs or rhs are floats then the expression will be calculated with floats.
-
-Given a sample.yml file of:
-```yaml
-a: 3
-b: 4.9
-```
-then
-```bash
-yq eval '.a = .a + .b' sample.yml
-```
-will output
-```yaml
-a: 7.9
-b: 4.9
-```
-
-## Number addition - int
-If both the lhs and rhs are ints then the expression will be calculated with ints.
-
-Given a sample.yml file of:
-```yaml
-a: 3
-b: 4
-```
-then
-```bash
-yq eval '.a = .a + .b' sample.yml
-```
-will output
-```yaml
-a: 7
-b: 4
-```
-
-## Increment numbers
-Given a sample.yml file of:
-```yaml
-a: 3
-b: 5
-```
-then
-```bash
-yq eval '.[] += 1' sample.yml
-```
-will output
-```yaml
-a: 4
-b: 6
-```
-
-## Add to null
-Adding to null simply returns the rhs
-
-Running
-```bash
-yq eval --null-input 'null + "cat"'
-```
-will output
-```yaml
-cat
-```
-
@@ -1,99 +1,8 @@
-Use the `alias` and `anchor` operators to read and write yaml aliases and anchors. The `explode` operator normalises a yaml file (dereference (or expands) aliases and remove anchor names).
+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.


-## Merge one map
-see https://yaml.org/type/merge.html
-
-Given a sample.yml file of:
-```yaml
- &CENTER
-  x: 1
-  y: 2
- &LEFT
-  x: 0
-  y: 2
- &BIG
-  r: 10
- &SMALL
-  r: 1
- !!merge <<: *CENTER
-  r: 10
-```
-then
-```bash
-yq eval '.[4] | explode(.)' sample.yml
-```
-will output
-```yaml
-x: 1
-y: 2
-r: 10
-```
-
-## Merge multiple maps
-see https://yaml.org/type/merge.html
-
-Given a sample.yml file of:
-```yaml
- &CENTER
-  x: 1
-  y: 2
- &LEFT
-  x: 0
-  y: 2
- &BIG
-  r: 10
- &SMALL
-  r: 1
- !!merge <<:
-    - *CENTER
-    - *BIG
-```
-then
-```bash
-yq eval '.[4] | explode(.)' sample.yml
-```
-will output
-```yaml
-r: 10
-x: 1
-y: 2
-```
-
-## Override
-see https://yaml.org/type/merge.html
-
-Given a sample.yml file of:
-```yaml
- &CENTER
-  x: 1
-  y: 2
- &LEFT
-  x: 0
-  y: 2
- &BIG
-  r: 10
- &SMALL
-  r: 1
- !!merge <<:
-    - *BIG
-    - *LEFT
-    - *SMALL
-  x: 1
-```
-then
-```bash
-yq eval '.[4] | explode(.)' sample.yml
-```
-will output
-```yaml
-r: 10
-x: 1
-y: 2
-```
-
 ## Get anchor
 Given a sample.yml file of:
 ```yaml
@@ -122,22 +31,6 @@ will output
 a: &foobar cat
 ```

-## Set anchor relatively using assign-update
-Given a sample.yml file of:
-```yaml
-a:
-  b: cat
-```
-then
-```bash
-yq eval '.a anchor |= .b' sample.yml
-```
-will output
-```yaml
-a: &cat
-  b: cat
-```
-
 ## Get alias
 Given a sample.yml file of:
 ```yaml
@@ -169,39 +62,6 @@ b: &meow purr
 a: *meow
 ```

-## Set alias to blank does nothing
-Given a sample.yml file of:
-```yaml
-b: &meow purr
-a: cat
-```
-then
-```bash
-yq eval '.a alias = ""' sample.yml
-```
-will output
-```yaml
-b: &meow purr
-a: cat
-```
-
-## Set alias relatively using assign-update
-Given a sample.yml file of:
-```yaml
-b: &meow purr
-a:
-  f: meow
-```
-then
-```bash
-yq eval '.a alias |= .f' sample.yml
-```
-will output
-```yaml
-b: &meow purr
-a: *meow
-```
-
 ## Explode alias and anchor
 Given a sample.yml file of:
 ```yaml
@@ -290,42 +150,12 @@ bar:
  c: bar_c
 foobarList:
  b: bar_b
-  thing: foo_thing
-  c: foobarList_c
  a: foo_a
+  thing: bar_thing
+  c: foobarList_c
 foobar:
  c: foo_c
  a: foo_a
  thing: foobar_thing
 ```

-## Dereference and update a field
-`Use explode with multiply to dereference an object
-
-Given a sample.yml file of:
-```yaml
-item_value: &item_value
-  value: true
-thingOne:
-  name: item_1
-  !!merge <<: *item_value
-thingTwo:
-  name: item_2
-  !!merge <<: *item_value
-```
-then
-```bash
-yq eval '.thingOne |= explode(.) * {"value": false}' sample.yml
-```
-will output
-```yaml
-item_value: &item_value
-  value: true
-thingOne:
-  name: item_1
-  value: false
-thingTwo:
-  name: item_2
-  !!merge <<: *item_value
-```
-
@@ -1,4 +1,10 @@
+This operator is used to update node values. It can be used in either the:

+### plain form: `=`
+Which will assign the LHS node values to the RHS node values. The RHS expression is run against the matching nodes in the pipeline.
+
+### relative form: `|=`
+This will do a similar thing to the plain form, however, the RHS expression is run against _the LHS nodes_. This is useful for updating values based on old values, e.g. increment.
 ## Create yaml file
 Running
 ```bash
@@ -28,45 +34,6 @@ a:
  g: foof
 ```

-## Double elements in an array
-Given a sample.yml file of:
-```yaml
- 1
- 2
- 3
-```
-then
-```bash
-yq eval '.[] |= . * 2' sample.yml
-```
-will output
-```yaml
- 2
- 4
- 6
-```
-
-## Update node from another file
-Note this will also work when the second file is a scalar (string/number)
-
-Given a sample.yml file of:
-```yaml
-a: apples
-```
-And another sample another.yml file of:
-```yaml
-b: bob
-```
-then
-```bash
-yq eval-all 'select(fileIndex==0).a = select(fileIndex==1) | select(fileIndex==0)' sample.yml another.yml
-```
-will output
-```yaml
-a:
-  b: bob
-```
-
 ## Update node to be the sibling value
 Given a sample.yml file of:
 ```yaml
@@ -93,7 +60,7 @@ c: fieldC
 ```
 then
 ```bash
-yq eval '(.a, .c) = "potatoe"' sample.yml
+yq eval '(.a, .c) |= "potatoe"' sample.yml
 ```
 will output
 ```yaml
@@ -1,14 +1,5 @@
-The `or` and `and` operators take two parameters and return a boolean result. 
-
-`not` flips a boolean from true to false, or vice versa. 
-
-`any` will return `true` if there are any `true` values in a array sequence, and `all` will return true if _all_ elements in an array are true.
-
-`any_c(condition)` and `all_c(condition)` are like `any` and `all` but they take a condition expression that is used against each element to determine if it's `true`. Note: in `jq` you can simply pass a condition to `any` or `all` and it simply works - `yq` isn't that clever..yet
-
-These are most commonly used with the `select` operator to filter particular nodes.
-
-## `or` example
+The `or` and `and` operators take two parameters and return a boolean result. `not` flips a boolean from true to false, or vice versa. These are most commonly used with the `select` operator to filter particular nodes.
+## OR example
 Running
 ```bash
 yq eval --null-input 'true or false'
@@ -18,7 +9,7 @@ will output
 true
 ```

-## `and` example
+## AND example
 Running
 ```bash
 yq eval --null-input 'true and false'
@@ -50,104 +41,6 @@ will output
  b: fly
 ```

-## `any` returns true if any boolean in a given array is true
-Given a sample.yml file of:
-```yaml
- false
- true
-```
-then
-```bash
-yq eval 'any' sample.yml
-```
-will output
-```yaml
-true
-```
-
-## `any` returns false for an empty array
-Given a sample.yml file of:
-```yaml
-[]
-```
-then
-```bash
-yq eval 'any' sample.yml
-```
-will output
-```yaml
-false
-```
-
-## `any_c` returns true if any element in the array is true for the given condition.
-Given a sample.yml file of:
-```yaml
-a:
-  - rad
-  - awesome
-b:
-  - meh
-  - whatever
-```
-then
-```bash
-yq eval '.[] |= any_c(. == "awesome")' sample.yml
-```
-will output
-```yaml
-a: true
-b: false
-```
-
-## `all` returns true if all booleans in a given array are true
-Given a sample.yml file of:
-```yaml
- true
- true
-```
-then
-```bash
-yq eval 'all' sample.yml
-```
-will output
-```yaml
-true
-```
-
-## `all` returns true for an empty array
-Given a sample.yml file of:
-```yaml
-[]
-```
-then
-```bash
-yq eval 'all' sample.yml
-```
-will output
-```yaml
-true
-```
-
-## `all_c` returns true if all elements in the array are true for the given condition.
-Given a sample.yml file of:
-```yaml
-a:
-  - rad
-  - awesome
-b:
-  - meh
-  - 12
-```
-then
-```bash
-yq eval '.[] |= all_c(tag == "!!str")' sample.yml
-```
-will output
-```yaml
-a: true
-b: false
-```
-
 ## Not true is false
 Running
 ```bash
@@ -1,15 +1,4 @@
 Use these comment operators to set or retrieve comments.
-
-Like the `=` and `|=` assign operators, the same syntax applies when updating comments:
-
-
-### plain form: `=`
-This will assign the LHS nodes comments to the expression on the RHS. The RHS is run against the matching nodes in the pipeline
-
-### relative form: `|=` 
-Similar to the plain form, however the RHS evaluates against each matching LHS node! This is useful if you want to set the comments as a relative expression of the node, for instance its value or path.
-
-
 ## Set line comment
 Given a sample.yml file of:
 ```yaml
@@ -24,22 +13,6 @@ will output
 a: cat # single
 ```

-## Use update assign to perform relative updates
-Given a sample.yml file of:
-```yaml
-a: cat
-b: dog
-```
-then
-```bash
-yq eval '.. lineComment |= .' sample.yml
-```
-will output
-```yaml
-a: cat # cat
-b: dog # dog
-```
-
 ## Set head comment
 Given a sample.yml file of:
 ```yaml
@@ -88,23 +61,18 @@ a: cat
 b: dog # leave this
 ```

-## Remove (strip) all comments
-Note the use of `...` to ensure key nodes are included.
-
+## Remove all comments
 Given a sample.yml file of:
 ```yaml
 a: cat # comment
-# great
-b: # key comment
 ```
 then
 ```bash
-yq eval '... comments=""' sample.yml
+yq eval '.. comments=""' sample.yml
 ```
 will output
 ```yaml
 a: cat
-b:
 ```

 ## Get line comment
@@ -1,85 +0,0 @@
-
-## Array contains array
-Array is equal or subset of
-
-Given a sample.yml file of:
-```yaml
- foobar
- foobaz
- blarp
-```
-then
-```bash
-yq eval 'contains(["baz", "bar"])' sample.yml
-```
-will output
-```yaml
-true
-```
-
-## Object included in array
-Given a sample.yml file of:
-```yaml
-"foo": 12
-"bar":
-  - 1
-  - 2
-  - "barp": 12
-    "blip": 13
-```
-then
-```bash
-yq eval 'contains({"bar": [{"barp": 12}]})' sample.yml
-```
-will output
-```yaml
-true
-```
-
-## Object not included in array
-Given a sample.yml file of:
-```yaml
-"foo": 12
-"bar":
-  - 1
-  - 2
-  - "barp": 12
-    "blip": 13
-```
-then
-```bash
-yq eval 'contains({"foo": 12, "bar": [{"barp": 15}]})' sample.yml
-```
-will output
-```yaml
-false
-```
-
-## String contains substring
-Given a sample.yml file of:
-```yaml
-foobar
-```
-then
-```bash
-yq eval 'contains("bar")' sample.yml
-```
-will output
-```yaml
-true
-```
-
-## String equals string
-Given a sample.yml file of:
-```yaml
-meow
-```
-then
-```bash
-yq eval 'contains("meow")' sample.yml
-```
-will output
-```yaml
-true
-```
-
@@ -95,23 +95,3 @@ will output
 b: dog
 ```

-## Recursively delete matching keys
-Given a sample.yml file of:
-```yaml
-a:
-  name: frog
-  b:
-    name: blog
-    age: 12
-```
-then
-```bash
-yq eval 'del(.. | select(has("name")).name)' sample.yml
-```
-will output
-```yaml
-a:
-  b:
-    age: 12
-```
-
@@ -1,4 +1,4 @@
-Use the `documentIndex` operator (or the `di` shorthand) to select nodes of a particular document.
+Use the `documentIndex` operator to select nodes of a particular document.
 ## Retrieve a document index
 Given a sample.yml file of:
 ```yaml
@@ -17,24 +17,6 @@ will output
 1
 ```

-## Retrieve a document index, shorthand
-Given a sample.yml file of:
-```yaml
-a: cat
---
-a: frog
-```
-then
-```bash
-yq eval '.a | di' sample.yml
-```
-will output
-```yaml
-0
---
-1
-```
-
 ## Filter by document index
 Given a sample.yml file of:
 ```yaml
@@ -44,23 +26,7 @@ a: frog
 ```
 then
 ```bash
-yq eval 'select(documentIndex == 1)' sample.yml
-```
-will output
-```yaml
-a: frog
-```
-
-## Filter by document index shorthand
-Given a sample.yml file of:
-```yaml
-a: cat
---
-a: frog
-```
-then
-```bash
-yq eval 'select(di == 1)' sample.yml
+yq eval 'select(. | documentIndex == 1)' sample.yml
 ```
 will output
 ```yaml
@@ -76,7 +42,7 @@ a: frog
 ```
 then
 ```bash
-yq eval '.a | ({"match": ., "doc": documentIndex})' sample.yml
+yq eval '.a | ({"match": ., "doc": (. | documentIndex)})' sample.yml
 ```
 will output
 ```yaml
@@ -1,118 +0,0 @@
-Similar to the same named functions in `jq` these functions convert to/from an object and an array of key-value pairs. This is most useful for performing operations on keys of maps.
-## to_entries Map
-Given a sample.yml file of:
-```yaml
-a: 1
-b: 2
-```
-then
-```bash
-yq eval 'to_entries' sample.yml
-```
-will output
-```yaml
- key: a
-  value: 1
- key: b
-  value: 2
-```
-
-## to_entries Array
-Given a sample.yml file of:
-```yaml
- a
- b
-```
-then
-```bash
-yq eval 'to_entries' sample.yml
-```
-will output
-```yaml
- key: 0
-  value: a
- key: 1
-  value: b
-```
-
-## to_entries null
-Given a sample.yml file of:
-```yaml
-null
-```
-then
-```bash
-yq eval 'to_entries' sample.yml
-```
-will output
-```yaml
-```
-
-## from_entries map
-Given a sample.yml file of:
-```yaml
-a: 1
-b: 2
-```
-then
-```bash
-yq eval 'to_entries | from_entries' sample.yml
-```
-will output
-```yaml
-a: 1
-b: 2
-```
-
-## from_entries with numeric key indexes
-from_entries always creates a map, even for numeric keys
-
-Given a sample.yml file of:
-```yaml
- a
- b
-```
-then
-```bash
-yq eval 'to_entries | from_entries' sample.yml
-```
-will output
-```yaml
-0: a
-1: b
-```
-
-## Use with_entries to update keys
-Given a sample.yml file of:
-```yaml
-a: 1
-b: 2
-```
-then
-```bash
-yq eval 'with_entries(.key |= "KEY_" + .)' sample.yml
-```
-will output
-```yaml
-KEY_a: 1
-KEY_b: 2
-```
-
-## Use with_entries to filter the map
-Given a sample.yml file of:
-```yaml
-a:
-  b: bird
-c:
-  d: dog
-```
-then
-```bash
-yq eval 'with_entries(select(.value | has("b")))' sample.yml
-```
-will output
-```yaml
-a:
-  b: bird
-```
-
@@ -1,78 +0,0 @@
-This operator is used to handle environment variables usage in path expressions. While environment variables can, of course, be passed in via your CLI with string interpolation, this often comes with complex quote escaping and can be tricky to write and read. Note that there are two forms, `env` which will parse the environment variable as a yaml (be it a map, array, string, number of boolean) and `strenv` which will always parse the argument as a string.
-
-
-## Read string environment variable
-Running
-```bash
-myenv="cat meow" yq eval --null-input '.a = env(myenv)'
-```
-will output
-```yaml
-a: cat meow
-```
-
-## Read boolean environment variable
-Running
-```bash
-myenv="true" yq eval --null-input '.a = env(myenv)'
-```
-will output
-```yaml
-a: true
-```
-
-## Read numeric environment variable
-Running
-```bash
-myenv="12" yq eval --null-input '.a = env(myenv)'
-```
-will output
-```yaml
-a: 12
-```
-
-## Read yaml environment variable
-Running
-```bash
-myenv="{b: fish}" yq eval --null-input '.a = env(myenv)'
-```
-will output
-```yaml
-a: {b: fish}
-```
-
-## Read boolean environment variable as a string
-Running
-```bash
-myenv="true" yq eval --null-input '.a = strenv(myenv)'
-```
-will output
-```yaml
-a: "true"
-```
-
-## Read numeric environment variable as a string
-Running
-```bash
-myenv="12" yq eval --null-input '.a = strenv(myenv)'
-```
-will output
-```yaml
-a: "12"
-```
-
-## Dynamic key lookup with environment variable
-Given a sample.yml file of:
-```yaml
-cat: meow
-dog: woof
-```
-then
-```bash
-myenv="cat" yq eval '.[env(myenv)]' sample.yml
-```
-will output
-```yaml
-meow
-```
-
@@ -29,24 +29,6 @@ true
 false
 ```

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

-## Dont match number
-Given a sample.yml file of:
-```yaml
- 3
- 4
- 5
-```
-then
-```bash
-yq eval '.[] | (. != 4)' sample.yml
-```
-will output
-```yaml
-true
-false
-true
-```
-
 ## Match nulls
 Running
 ```bash
@@ -93,31 +57,3 @@ will output
 true
 ```

-## Non exisitant key doesn't equal a value
-Given a sample.yml file of:
-```yaml
-a: frog
-```
-then
-```bash
-yq eval 'select(.b != "thing")' sample.yml
-```
-will output
-```yaml
-a: frog
-```
-
-## Two non existant keys are equal
-Given a sample.yml file of:
-```yaml
-a: frog
-```
-then
-```bash
-yq eval 'select(.b == .c)' sample.yml
-```
-will output
-```yaml
-a: frog
-```
-
@@ -1,11 +1,9 @@
 File operators are most often used with merge when needing to merge specific files together. Note that when doing this, you will need to use `eval-all` to ensure all yaml documents are loaded into memory before performing the merge (as opposed to `eval` which runs the expression once per document).

-Note that the `fileIndex` operator has a short alias of `fi`.
-
 ## Merging files
 Note the use of eval-all to ensure all documents are loaded into memory.
 ```bash
-yq eval-all 'select(fi == 0) * select(filename == "file2.yaml")' file1.yaml file2.yaml
+yq eval-all 'select(fileIndex == 0) * select(filename == "file2.yaml")' file1.yaml file2.yaml
 ```
 ## Get filename
 Given a sample.yml file of:
@@ -18,7 +16,7 @@ yq eval 'filename' sample.yml
 ```
 will output
 ```yaml
-sample.yml
+sample.yaml
 ```

 ## Get file index
@@ -35,37 +33,3 @@ will output
 0
 ```

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

-## Select, checking for existence of deep paths
-Simply pipe in parent expressions into `has`
-
-Given a sample.yml file of:
-```yaml
- a:
-    b:
-      c: cat
- a:
-    b:
-      d: dog
-```
-then
-```bash
-yq eval '.[] | select(.a.b | has("c"))' sample.yml
-```
-will output
-```yaml
-a:
-  b:
-    c: cat
-```
-
 ## Has array index
 Given a sample.yml file of:
 ```yaml
@@ -1,35 +0,0 @@
-# Keys
-
-Use the `keys` operator to return map keys or array indices. 
-## Map keys
-Given a sample.yml file of:
-```yaml
-dog: woof
-cat: meow
-```
-then
-```bash
-yq eval 'keys' sample.yml
-```
-will output
-```yaml
- dog
- cat
-```
-
-## Array keys
-Given a sample.yml file of:
-```yaml
- apple
- banana
-```
-then
-```bash
-yq eval 'keys' sample.yml
-```
-will output
-```yaml
- 0
- 1
-```
-
@@ -16,20 +16,6 @@ will output
 3
 ```

-## null length
-Given a sample.yml file of:
-```yaml
-a: null
-```
-then
-```bash
-yq eval '.a | length' sample.yml
-```
-will output
-```yaml
-0
-```
-
 ## Map length
 returns number of entries

@@ -1,366 +0,0 @@
-Like the multiple operator in jq, depending on the operands, this multiply operator will do different things. Currently numbers, arrays and objects are supported.
-
-## Objects and arrays - merging
-Objects are merged deeply matching on matching keys. By default, array values override and are not deeply merged.
-
-Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.
-
-### Merge Flags
-You can control how objects are merged by using one or more of the following flags. Multiple flags can be used together, e.g. `.a *+? .b`.  See examples below
-
- `+` to append arrays
- `?` to only merge existing fields
- `d` to deeply merge arrays
-
-### Merging files
-Note the use of `eval-all` to ensure all documents are loaded into memory.
-
-```bash
-yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' file1.yaml file2.yaml
-```
-
-## Multiply integers
-Running
-```bash
-yq eval --null-input '3 * 4'
-```
-will output
-```yaml
-12
-```
-
-## Merge objects together, returning merged result only
-Given a sample.yml file of:
-```yaml
-a:
-  field: me
-  fieldA: cat
-b:
-  field:
-    g: wizz
-  fieldB: dog
-```
-then
-```bash
-yq eval '.a * .b' sample.yml
-```
-will output
-```yaml
-field:
-  g: wizz
-fieldA: cat
-fieldB: dog
-```
-
-## Merge objects together, returning parent object
-Given a sample.yml file of:
-```yaml
-a:
-  field: me
-  fieldA: cat
-b:
-  field:
-    g: wizz
-  fieldB: dog
-```
-then
-```bash
-yq eval '. * {"a":.b}' sample.yml
-```
-will output
-```yaml
-a:
-  field:
-    g: wizz
-  fieldA: cat
-  fieldB: dog
-b:
-  field:
-    g: wizz
-  fieldB: dog
-```
-
-## Merge keeps style of LHS
-Given a sample.yml file of:
-```yaml
-a: {things: great}
-b:
-  also: "me"
-```
-then
-```bash
-yq eval '. * {"a":.b}' sample.yml
-```
-will output
-```yaml
-a: {things: great, also: "me"}
-b:
-  also: "me"
-```
-
-## Merge arrays
-Given a sample.yml file of:
-```yaml
-a:
-  - 1
-  - 2
-  - 3
-b:
-  - 3
-  - 4
-  - 5
-```
-then
-```bash
-yq eval '. * {"a":.b}' sample.yml
-```
-will output
-```yaml
-a:
-  - 3
-  - 4
-  - 5
-b:
-  - 3
-  - 4
-  - 5
-```
-
-## Merge, only existing fields
-Given a sample.yml file of:
-```yaml
-a:
-  thing: one
-  cat: frog
-b:
-  missing: two
-  thing: two
-```
-then
-```bash
-yq eval '.a *? .b' sample.yml
-```
-will output
-```yaml
-thing: two
-cat: frog
-```
-
-## Merge, appending arrays
-Given a sample.yml file of:
-```yaml
-a:
-  array:
-    - 1
-    - 2
-    - animal: dog
-  value: coconut
-b:
-  array:
-    - 3
-    - 4
-    - animal: cat
-  value: banana
-```
-then
-```bash
-yq eval '.a *+ .b' sample.yml
-```
-will output
-```yaml
-array:
-  - 1
-  - 2
-  - animal: dog
-  - 3
-  - 4
-  - animal: cat
-value: banana
-```
-
-## Merge, only existing fields, appending arrays
-Given a sample.yml file of:
-```yaml
-a:
-  thing:
-    - 1
-    - 2
-b:
-  thing:
-    - 3
-    - 4
-  another:
-    - 1
-```
-then
-```bash
-yq eval '.a *?+ .b' sample.yml
-```
-will output
-```yaml
-thing:
-  - 1
-  - 2
-  - 3
-  - 4
-```
-
-## Merge, deeply merging arrays
-Merging arrays deeply means arrays are merge like objects, with indexes as their key. In this case, we merge the first item in the array, and do nothing with the second.
-
-Given a sample.yml file of:
-```yaml
-a:
-  - name: fred
-    age: 12
-  - name: bob
-    age: 32
-b:
-  - name: fred
-    age: 34
-```
-then
-```bash
-yq eval '.a *d .b' sample.yml
-```
-will output
-```yaml
- name: fred
-  age: 34
- name: bob
-  age: 32
-```
-
-## Merge arrays of objects together, matching on a key
-It's a complex command, the trickyness comes from needing to have the right context in the expressions.
-First we save the second array into a variable '$two' which lets us reference it later.
-We then need to update the first array. We will use the relative update (|=) because we need to update relative to the current element of the array in the LHS in the RHS expression. 
-We set the current element of the first array as $cur. Now we multiply (merge) $cur with the matching entry in $two, by passing $two through a select filter.
-
-
-Given a sample.yml file of:
-```yaml
- a: apple
-  b: appleB
- a: kiwi
-  b: kiwiB
- a: banana
-  b: bananaB
-```
-And another sample another.yml file of:
-```yaml
- a: banana
-  c: bananaC
- a: apple
-  b: appleB2
- a: dingo
-  c: dingoC
-```
-then
-```bash
-yq eval-all '(select(fi==1) | .[]) as $two | select(fi==0) | .[] |= (. as $cur |  $cur * ($two | select(.a == $cur.a)))' sample.yml another.yml
-```
-will output
-```yaml
- a: apple
-  b: appleB2
- a: kiwi
-  b: kiwiB
- a: banana
-  b: bananaB
-  c: bananaC
-```
-
-## Merge to prefix an element
-Given a sample.yml file of:
-```yaml
-a: cat
-b: dog
-```
-then
-```bash
-yq eval '. * {"a": {"c": .a}}' sample.yml
-```
-will output
-```yaml
-a:
-  c: cat
-b: dog
-```
-
-## Merge with simple aliases
-Given a sample.yml file of:
-```yaml
-a: &cat
-  c: frog
-b:
-  f: *cat
-c:
-  g: thongs
-```
-then
-```bash
-yq eval '.c * .b' sample.yml
-```
-will output
-```yaml
-g: thongs
-f: *cat
-```
-
-## Merge copies anchor names
-Given a sample.yml file of:
-```yaml
-a:
-  c: &cat frog
-b:
-  f: *cat
-c:
-  g: thongs
-```
-then
-```bash
-yq eval '.c * .a' sample.yml
-```
-will output
-```yaml
-g: thongs
-c: &cat frog
-```
-
-## Merge with merge anchors
-Given a sample.yml file of:
-```yaml
-foo: &foo
-  a: foo_a
-  thing: foo_thing
-  c: foo_c
-bar: &bar
-  b: bar_b
-  thing: bar_thing
-  c: bar_c
-foobarList:
-  b: foobarList_b
-  !!merge <<:
-    - *foo
-    - *bar
-  c: foobarList_c
-foobar:
-  c: foobar_c
-  !!merge <<: *foo
-  thing: foobar_thing
-```
-then
-```bash
-yq eval '.foobar * .foobarList' sample.yml
-```
-will output
-```yaml
-c: foobarList_c
-<<:
-  - *foo
-  - *bar
-thing: foobar_thing
-b: foobarList_b
-```
-
@@ -0,0 +1,238 @@
+Like the multiple operator in `jq`, depending on the operands, this multiply operator will do different things. Currently only objects are supported, which have the effect of merging the RHS into the LHS.
+
+Upcoming versions of `yq` will add support for other types of multiplication (numbers, strings).
+
+To concatenate when merging objects, use the `*+` form (see examples below). This will recursively merge objects, appending arrays when it encounters them.
+
+Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.
+
+## Merging files
+Note the use of eval-all to ensure all documents are loaded into memory.
+
+```bash
+yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' file1.yaml file2.yaml
+```
+
+## Merge objects together, returning merged result only
+Given a sample.yml file of:
+```yaml
+a:
+  field: me
+  fieldA: cat
+b:
+  field:
+    g: wizz
+  fieldB: dog
+```
+then
+```bash
+yq eval '.a * .b' sample.yml
+```
+will output
+```yaml
+field:
+  g: wizz
+fieldA: cat
+fieldB: dog
+```
+
+## Merge objects together, returning parent object
+Given a sample.yml file of:
+```yaml
+a:
+  field: me
+  fieldA: cat
+b:
+  field:
+    g: wizz
+  fieldB: dog
+```
+then
+```bash
+yq eval '. * {"a":.b}' sample.yml
+```
+will output
+```yaml
+a:
+  field:
+    g: wizz
+  fieldA: cat
+  fieldB: dog
+b:
+  field:
+    g: wizz
+  fieldB: dog
+```
+
+## Merge keeps style of LHS
+Given a sample.yml file of:
+```yaml
+a: {things: great}
+b:
+  also: "me"
+
+```
+then
+```bash
+yq eval '. * {"a":.b}' sample.yml
+```
+will output
+```yaml
+a: {things: great, also: "me"}
+b:
+  also: "me"
+```
+
+## Merge arrays
+Given a sample.yml file of:
+```yaml
+a:
+  - 1
+  - 2
+  - 3
+b:
+  - 3
+  - 4
+  - 5
+```
+then
+```bash
+yq eval '. * {"a":.b}' sample.yml
+```
+will output
+```yaml
+a:
+  - 3
+  - 4
+  - 5
+b:
+  - 3
+  - 4
+  - 5
+```
+
+## Merge, appending arrays
+Given a sample.yml file of:
+```yaml
+a:
+  array:
+    - 1
+    - 2
+    - animal: dog
+  value: coconut
+b:
+  array:
+    - 3
+    - 4
+    - animal: cat
+  value: banana
+```
+then
+```bash
+yq eval '.a *+ .b' sample.yml
+```
+will output
+```yaml
+array:
+  - 1
+  - 2
+  - animal: dog
+  - 3
+  - 4
+  - animal: cat
+value: banana
+```
+
+## Merge to prefix an element
+Given a sample.yml file of:
+```yaml
+a: cat
+b: dog
+```
+then
+```bash
+yq eval '. * {"a": {"c": .a}}' sample.yml
+```
+will output
+```yaml
+a:
+  c: cat
+b: dog
+```
+
+## Merge with simple aliases
+Given a sample.yml file of:
+```yaml
+a: &cat
+  c: frog
+b:
+  f: *cat
+c:
+  g: thongs
+```
+then
+```bash
+yq eval '.c * .b' sample.yml
+```
+will output
+```yaml
+g: thongs
+f: *cat
+```
+
+## Merge does not copy anchor names
+Given a sample.yml file of:
+```yaml
+a:
+  c: &cat frog
+b:
+  f: *cat
+c:
+  g: thongs
+```
+then
+```bash
+yq eval '.c * .a' sample.yml
+```
+will output
+```yaml
+g: thongs
+c: frog
+```
+
+## Merge with merge anchors
+Given a sample.yml file of:
+```yaml
+foo: &foo
+  a: foo_a
+  thing: foo_thing
+  c: foo_c
+bar: &bar
+  b: bar_b
+  thing: bar_thing
+  c: bar_c
+foobarList:
+  b: foobarList_b
+  !!merge <<:
+    - *foo
+    - *bar
+  c: foobarList_c
+foobar:
+  c: foobar_c
+  !!merge <<: *foo
+  thing: foobar_thing
+```
+then
+```bash
+yq eval '.foobar * .foobarList' sample.yml
+```
+will output
+```yaml
+c: foobarList_c
+<<:
+  - *foo
+  - *bar
+thing: foobar_thing
+b: foobarList_b
+```
+
@@ -1,154 +0,0 @@
-This operator recursively matches (or globs) 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
-```
-
-## Recursively find nodes with keys
-Note that this example has wrapped the expression in `[]` to show that there are two matches returned. You do not have to wrap in `[]` in your path expression.
-
-Given a sample.yml file of:
-```yaml
-a:
-  name: frog
-  b:
-    name: blog
-    age: 12
-```
-then
-```bash
-yq eval '[.. | select(has("name"))]' sample.yml
-```
-will output
-```yaml
- name: frog
-  b:
-    name: blog
-    age: 12
- name: blog
-  age: 12
-```
-
-## Recursively find nodes with values
-Given a sample.yml file of:
-```yaml
-a:
-  nameA: frog
-  b:
-    nameB: frog
-    age: 12
-```
-then
-```bash
-yq eval '.. | select(. == "frog")' sample.yml
-```
-will output
-```yaml
-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: &cat
-  c: frog
-b: *cat
-```
-then
-```bash
-yq eval '[..]' sample.yml
-```
-will output
-```yaml
- a: &cat
-    c: frog
-  b: *cat
- &cat
-  c: frog
- frog
- *cat
-```
-
-## Merge docs are not traversed
-Given a sample.yml file of:
-```yaml
-foo: &foo
-  a: foo_a
-  thing: foo_thing
-  c: foo_c
-bar: &bar
-  b: bar_b
-  thing: bar_thing
-  c: bar_c
-foobarList:
-  b: foobarList_b
-  !!merge <<:
-    - *foo
-    - *bar
-  c: foobarList_c
-foobar:
-  c: foobar_c
-  !!merge <<: *foo
-  thing: foobar_thing
-```
-then
-```bash
-yq eval '.foobar | [..]' sample.yml
-```
-will output
-```yaml
- c: foobar_c
-  !!merge <<: *foo
-  thing: foobar_thing
- foobar_c
- *foo
- foobar_thing
-```
-
@@ -0,0 +1,63 @@
+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:
+
+```bash
+yq eval '.. style= "flow"' file.yaml
+```
+## Aliases are not traversed
+Given a sample.yml file of:
+```yaml
+a: &cat
+  c: frog
+b: *cat
+```
+then
+```bash
+yq eval '[..]' sample.yml
+```
+will output
+```yaml
+- a: &cat
+    c: frog
+  b: *cat
+- &cat
+  c: frog
+- frog
+- *cat
+```
+
+## Merge docs are not traversed
+Given a sample.yml file of:
+```yaml
+foo: &foo
+  a: foo_a
+  thing: foo_thing
+  c: foo_c
+bar: &bar
+  b: bar_b
+  thing: bar_thing
+  c: bar_c
+foobarList:
+  b: foobarList_b
+  !!merge <<:
+    - *foo
+    - *bar
+  c: foobarList_c
+foobar:
+  c: foobar_c
+  !!merge <<: *foo
+  thing: foobar_thing
+```
+then
+```bash
+yq eval '.foobar | [..]' sample.yml
+```
+will output
+```yaml
+- c: foobar_c
+  !!merge <<: *foo
+  thing: foobar_thing
+- foobar_c
+- *foo
+- foobar_thing
+```
+
@@ -1,76 +0,0 @@
-Reduce is a powerful way to process a collection of data into a new form.
-
-```
-<exp> as $<name> ireduce (<init>; <block>)
-```
-
-e.g.
-
-```
-.[] as $item ireduce (0; . + $item)
-```
-
-On the LHS we are configuring the collection of items that will be reduced `<exp>` as well as what each element will be called `$<name>`. Note that the array has been splatted into its individual elements.
-
-On the RHS there is `<init>`, the starting value of the accumulator and `<block>`, the expression that will update the accumulator for each element in the collection. Note that within the block expression, `.` will evaluate to the current value of the accumulator. 
-
-## yq vs jq syntax
-Reduce syntax in `yq` is a little different from `jq` - as `yq` (currently) isn't as sophisticated as `jq` and its only supports infix notation (e.g. a + b, where the operator is in the middle of the two parameters) - where as `jq` uses a mix of infix notation with _prefix_ notation (e.g. `reduce a b` is like writing `+ a b`).
-
-To that end, the reduce operator is called `ireduce` for backwards compatability if a `jq` like prefix version of `reduce` is ever added.
-
-
-## Sum numbers
-Given a sample.yml file of:
-```yaml
- 10
- 2
- 5
- 3
-```
-then
-```bash
-yq eval '.[] as $item ireduce (0; . + $item)' sample.yml
-```
-will output
-```yaml
-20
-```
-
-## Merge all yaml files together
-Given a sample.yml file of:
-```yaml
-a: cat
-```
-And another sample another.yml file of:
-```yaml
-b: dog
-```
-then
-```bash
-yq eval-all '. as $item ireduce ({}; . * $item )' sample.yml another.yml
-```
-will output
-```yaml
-a: cat
-b: dog
-```
-
-## Convert an array to an object
-Given a sample.yml file of:
-```yaml
- name: Cathy
-  has: apples
- name: Bob
-  has: bananas
-```
-then
-```bash
-yq eval '.[] as $item ireduce ({}; .[$item | .name] = ($item | .has) )' sample.yml
-```
-will output
-```yaml
-Cathy: apples
-Bob: bananas
-```
-
@@ -1,31 +0,0 @@
-# Split into Documents
-
-This operator splits all matches into separate documents
-
-## Split empty
-Running
-```bash
-yq eval --null-input 'splitDoc'
-```
-will output
-```yaml
-
-```
-
-## Split array
-Given a sample.yml file of:
-```yaml
- a: cat
- b: dog
-```
-then
-```bash
-yq eval '.[] | splitDoc' sample.yml
-```
-will output
-```yaml
-a: cat
---
-b: dog
-```
-
@@ -1,295 +0,0 @@
-# String Operators
-
-## RegEx
-This uses golangs native regex functions under the hood - See https://github.com/google/re2/wiki/Syntax for the supported syntax.
-
-
-# String blocks, bash and newlines
-Bash is notorious for chomping on precious trailing newline characters, making it tricky to set strings with newlines properly. In particular, the `$( exp )` _will trim trailing newlines_.
-
-For instance to get this yaml:
-
-```
-a: |
-  cat
-```
-
-Using `$( exp )` wont work, as it will trim the trailing new line.
-
-```
-m=$(echo "cat\n") yq e -n '.a = strenv(m)'
-a: cat
-```
-
-However, using printf works:
-```
-printf -v m "cat\n" ; m="$m" yq e -n '.a = strenv(m)'
-a: |
-  cat
-```
-
-As well as having multiline expressions:
-```
-m="cat
-"  yq e -n '.a = strenv(m)'
-a: |
-  cat
-```
-
-Similarly, if you're trying to set the content from a file, and want a trailing new line:
-
-```
-IFS= read -rd '' output < <(cat my_file)
-output=$output ./yq e '.data.values = strenv(output)' first.yml
-```
-## Join strings
-Given a sample.yml file of:
-```yaml
- cat
- meow
- 1
- null
- true
-```
-then
-```bash
-yq eval 'join("; ")' sample.yml
-```
-will output
-```yaml
-cat; meow; 1; ; true
-```
-
-## Match string
-Given a sample.yml file of:
-```yaml
-foo bar foo
-```
-then
-```bash
-yq eval 'match("foo")' sample.yml
-```
-will output
-```yaml
-string: foo
-offset: 0
-length: 3
-captures: []
-```
-
-## Match string, case insensitive
-Given a sample.yml file of:
-```yaml
-foo bar FOO
-```
-then
-```bash
-yq eval '[match("(?i)foo"; "g")]' sample.yml
-```
-will output
-```yaml
- string: foo
-  offset: 0
-  length: 3
-  captures: []
- string: FOO
-  offset: 8
-  length: 3
-  captures: []
-```
-
-## Match with capture groups
-Given a sample.yml file of:
-```yaml
-abc abc
-```
-then
-```bash
-yq eval '[match("(abc)+"; "g")]' sample.yml
-```
-will output
-```yaml
- string: abc
-  offset: 0
-  length: 3
-  captures:
-    - string: abc
-      offset: 0
-      length: 3
- string: abc
-  offset: 4
-  length: 3
-  captures:
-    - string: abc
-      offset: 4
-      length: 3
-```
-
-## Match with named capture groups
-Given a sample.yml file of:
-```yaml
-foo bar foo foo  foo
-```
-then
-```bash
-yq eval '[match("foo (?P<bar123>bar)? foo"; "g")]' sample.yml
-```
-will output
-```yaml
- string: foo bar foo
-  offset: 0
-  length: 11
-  captures:
-    - string: bar
-      offset: 4
-      length: 3
-      name: bar123
- string: foo  foo
-  offset: 12
-  length: 8
-  captures:
-    - string: null
-      offset: -1
-      length: 0
-      name: bar123
-```
-
-## Capture named groups into a map
-Given a sample.yml file of:
-```yaml
-xyzzy-14
-```
-then
-```bash
-yq eval 'capture("(?P<a>[a-z]+)-(?P<n>[0-9]+)")' sample.yml
-```
-will output
-```yaml
-a: xyzzy
-n: "14"
-```
-
-## Match without global flag
-Given a sample.yml file of:
-```yaml
-cat cat
-```
-then
-```bash
-yq eval 'match("cat")' sample.yml
-```
-will output
-```yaml
-string: cat
-offset: 0
-length: 3
-captures: []
-```
-
-## Match with global flag
-Given a sample.yml file of:
-```yaml
-cat cat
-```
-then
-```bash
-yq eval '[match("cat"; "g")]' sample.yml
-```
-will output
-```yaml
- string: cat
-  offset: 0
-  length: 3
-  captures: []
- string: cat
-  offset: 4
-  length: 3
-  captures: []
-```
-
-## Test using regex
-Like jq'q equivalant, this works like match but only returns true/false instead of full match details
-
-Given a sample.yml file of:
-```yaml
- cat
- dog
-```
-then
-```bash
-yq eval '.[] | test("at")' sample.yml
-```
-will output
-```yaml
-true
-false
-```
-
-## Substitute / Replace string
-This uses golang regex, described [here](https://github.com/google/re2/wiki/Syntax)
-Note the use of `|=` to run in context of the current string value.
-
-Given a sample.yml file of:
-```yaml
-a: dogs are great
-```
-then
-```bash
-yq eval '.a |= sub("dogs", "cats")' sample.yml
-```
-will output
-```yaml
-a: cats are great
-```
-
-## Substitute / Replace string with regex
-This uses golang regex, described [here](https://github.com/google/re2/wiki/Syntax)
-Note the use of `|=` to run in context of the current string value.
-
-Given a sample.yml file of:
-```yaml
-a: cat
-b: heat
-```
-then
-```bash
-yq eval '.[] |= sub("(a)", "${1}r")' sample.yml
-```
-will output
-```yaml
-a: cart
-b: heart
-```
-
-## Split strings
-Given a sample.yml file of:
-```yaml
-cat; meow; 1; ; true
-```
-then
-```bash
-yq eval 'split("; ")' sample.yml
-```
-will output
-```yaml
- cat
- meow
- "1"
- ""
- "true"
-```
-
-## Split strings one match
-Given a sample.yml file of:
-```yaml
-word
-```
-then
-```bash
-yq eval 'split("; ")' sample.yml
-```
-will output
-```yaml
- word
-```
-
@@ -1,40 +1,4 @@
 The style operator can be used to get or set the style of nodes (e.g. string style, yaml style)
-## Update and set style of a particular node (simple)
-Given a sample.yml file of:
-```yaml
-a:
-  b: thing
-  c: something
-```
-then
-```bash
-yq eval '.a.b = "new" | .a.b style="double"' sample.yml
-```
-will output
-```yaml
-a:
-  b: "new"
-  c: something
-```
-
-## Update and set style of a particular node using path variables
-Given a sample.yml file of:
-```yaml
-a:
-  b: thing
-  c: something
-```
-then
-```bash
-yq eval 'with(.a.b ; . = "new" | . style="double")' sample.yml
-```
-will output
-```yaml
-a:
-  b: "new"
-  c: something
-```
-
 ## Set tagged style
 Given a sample.yml file of:
 ```yaml
@@ -76,26 +40,6 @@ 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
@@ -181,19 +125,19 @@ will output
 {a: cat, b: 5, c: 3.2, e: true}
 ```

-## Reset style - or pretty print
-Set empty (default) quote style, note the usage of `...` to match keys too. Note that there is a `--prettyPrint/-P` short flag for this.
+## Pretty print
+Set empty (default) quote style

 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
@@ -203,22 +147,6 @@ c: 3.2
 e: true
 ```

-## Set style relatively with assign-update
-Given a sample.yml file of:
-```yaml
-a: single
-b: double
-```
-then
-```bash
-yq eval '.[] style |= .' sample.yml
-```
-will output
-```yaml
-a: 'single'
-b: "double"
-```
-
 ## Read style
 Given a sample.yml file of:
 ```yaml
@@ -1,110 +0,0 @@
-
-## Array subtraction
-Running
-```bash
-yq eval --null-input '[1,2] - [2,3]'
-```
-will output
-```yaml
- 1
-```
-
-## Array subtraction with nested array
-Running
-```bash
-yq eval --null-input '[[1], 1, 2] - [[1], 3]'
-```
-will output
-```yaml
- 1
- 2
-```
-
-## Array subtraction with nested object
-Note that order of the keys does not matter
-
-Given a sample.yml file of:
-```yaml
- a: b
-  c: d
- a: b
-```
-then
-```bash
-yq eval '. - [{"c": "d", "a": "b"}]' sample.yml
-```
-will output
-```yaml
- a: b
-```
-
-## Number subtraction - float
-If the lhs or rhs are floats then the expression will be calculated with floats.
-
-Given a sample.yml file of:
-```yaml
-a: 3
-b: 4.5
-```
-then
-```bash
-yq eval '.a = .a - .b' sample.yml
-```
-will output
-```yaml
-a: -1.5
-b: 4.5
-```
-
-## Number subtraction - float
-If the lhs or rhs are floats then the expression will be calculated with floats.
-
-Given a sample.yml file of:
-```yaml
-a: 3
-b: 4.5
-```
-then
-```bash
-yq eval '.a = .a - .b' sample.yml
-```
-will output
-```yaml
-a: -1.5
-b: 4.5
-```
-
-## Number subtraction - int
-If both the lhs and rhs are ints then the expression will be calculated with ints.
-
-Given a sample.yml file of:
-```yaml
-a: 3
-b: 4
-```
-then
-```bash
-yq eval '.a = .a - .b' sample.yml
-```
-will output
-```yaml
-a: -1
-b: 4
-```
-
-## Decrement numbers
-Given a sample.yml file of:
-```yaml
-a: 3
-b: 5
-```
-then
-```bash
-yq eval '.[] -= 1' sample.yml
-```
-will output
-```yaml
-a: 2
-b: 4
-```
-
@@ -22,21 +22,7 @@ will output
 !!seq
 ```

-## Set custom tag
-Given a sample.yml file of:
-```yaml
-a: str
-```
-then
-```bash
-yq eval '.a tag = "!!mikefarah"' sample.yml
-```
-will output
-```yaml
-a: !!mikefarah str
-```
-
-## Find numbers and convert them to strings
+## Convert numbers to strings
 Given a sample.yml file of:
 ```yaml
 a: cat
@@ -1,4 +1,4 @@
-This is the simplest (and perhaps most used) operator, it is used to navigate deeply into yaml structures.
+This is the simplest (and perhaps most used) operator, it is used to navigate deeply into yaml structurse.
 ## Simple map navigation
 Given a sample.yml file of:
 ```yaml
@@ -32,23 +32,8 @@ b: apple
 c: banana
 ```

-## Optional Splat
-Just like splat, but won't error if you run it against scalars
-
-Given a sample.yml file of:
-```yaml
-cat
-```
-then
-```bash
-yq eval '.[]' sample.yml
-```
-will output
-```yaml
-```
-
 ## Special characters
-Use quotes with brackets around path elements with special characters
+Use quotes around path elements with special characters

 Given a sample.yml file of:
 ```yaml
@@ -56,63 +41,13 @@ Given a sample.yml file of:
 ```
 then
 ```bash
-yq eval '.["{}"]' sample.yml
+yq eval '."{}"' sample.yml
 ```
 will output
 ```yaml
 frog
 ```

-## Nested special characters
-Given a sample.yml file of:
-```yaml
-a:
-  "key.withdots":
-    "another.key": apple
-```
-then
-```bash
-yq eval '.a["key.withdots"]["another.key"]' sample.yml
-```
-will output
-```yaml
-apple
-```
-
-## Keys with spaces
-Use quotes with brackets around path elements with special characters
-
-Given a sample.yml file of:
-```yaml
-"red rabbit": frog
-```
-then
-```bash
-yq eval '.["red rabbit"]' sample.yml
-```
-will output
-```yaml
-frog
-```
-
-## Dynamic keys
-Expressions within [] can be used to dynamically lookup / calculate keys
-
-Given a sample.yml file of:
-```yaml
-b: apple
-apple: crispy yum
-banana: soft yum
-```
-then
-```bash
-yq eval '.[.b]' sample.yml
-```
-will output
-```yaml
-crispy yum
-```
-
 ## Children don't exist
 Nodes are added dynamically while traversing

@@ -129,23 +64,6 @@ will output
 null
 ```

-## Optional identifier
-Like jq, does not output an error when the yaml is not an array or object as expected
-
-Given a sample.yml file of:
-```yaml
- 1
- 2
- 3
-```
-then
-```bash
-yq eval '.a?' sample.yml
-```
-will output
-```yaml
-```
-
 ## Wildcard matching
 Given a sample.yml file of:
 ```yaml
@@ -188,7 +106,7 @@ b: *cat
 ```
 then
 ```bash
-yq eval '.b[]' sample.yml
+yq eval '.b.[]' sample.yml
 ```
 will output
 ```yaml
@@ -227,20 +145,6 @@ will output
 1
 ```

-## Traversing nested arrays by index
-Given a sample.yml file of:
-```yaml
-[[], [cat]]
-```
-then
-```bash
-yq eval '.[1][0]' sample.yml
-```
-will output
-```yaml
-cat
-```
-
 ## Maps with numeric keys
 Given a sample.yml file of:
 ```yaml
@@ -386,7 +290,7 @@ foobar:
 ```
 then
 ```bash
-yq eval '.foobar[]' sample.yml
+yq eval '.foobar.[]' sample.yml
 ```
 will output
 ```yaml
@@ -452,7 +356,7 @@ foobar:
 ```
 then
 ```bash
-yq eval '.foobarList[]' sample.yml
+yq eval '.foobarList.[]' sample.yml
 ```
 will output
 ```yaml
@@ -1,82 +0,0 @@
-This is used to filter out duplicated items in an array.
-
-## Unique array of scalars (string/numbers)
-Given a sample.yml file of:
-```yaml
- 1
- 2
- 3
- 2
-```
-then
-```bash
-yq eval 'unique' sample.yml
-```
-will output
-```yaml
- 1
- 2
- 3
-```
-
-## Unique nulls
-Unique works on the node value, so it considers different representations of nulls to be different
-
-Given a sample.yml file of:
-```yaml
- ~
- null
- ~
- null
-```
-then
-```bash
-yq eval 'unique' sample.yml
-```
-will output
-```yaml
- ~
- null
-```
-
-## Unique all nulls
-Run against the node tag to unique all the nulls
-
-Given a sample.yml file of:
-```yaml
- ~
- null
- ~
- null
-```
-then
-```bash
-yq eval 'unique_by(tag)' sample.yml
-```
-will output
-```yaml
- ~
-```
-
-## Unique array object fields
-Given a sample.yml file of:
-```yaml
- name: harry
-  pet: cat
- name: billy
-  pet: dog
- name: harry
-  pet: dog
-```
-then
-```bash
-yq eval 'unique_by(.name)' sample.yml
-```
-will output
-```yaml
- name: harry
-  pet: cat
- name: billy
-  pet: dog
-```
-
@@ -1,96 +0,0 @@
-Like the `jq` equivalents, variables are sometimes required for the more complex expressions (or swapping values between fields).
-
-Note that there is also an additional `ref` operator that holds a reference (instead of a copy) of the path, allowing you to make multiple changes to the same path.
-
-## Single value variable
-Given a sample.yml file of:
-```yaml
-a: cat
-```
-then
-```bash
-yq eval '.a as $foo | $foo' sample.yml
-```
-will output
-```yaml
-cat
-```
-
-## Multi value variable
-Given a sample.yml file of:
-```yaml
- cat
- dog
-```
-then
-```bash
-yq eval '.[] as $foo | $foo' sample.yml
-```
-will output
-```yaml
-cat
-dog
-```
-
-## Using variables as a lookup
-Example taken from [jq](https://stedolan.github.io/jq/manual/#Variable/SymbolicBindingOperator:...as$identifier|...)
-
-Given a sample.yml file of:
-```yaml
-"posts":
-  - "title": Frist psot
-    "author": anon
-  - "title": A well-written article
-    "author": person1
-"realnames":
-  "anon": Anonymous Coward
-  "person1": Person McPherson
-```
-then
-```bash
-yq eval '.realnames as $names | .posts[] | {"title":.title, "author": $names[.author]}' sample.yml
-```
-will output
-```yaml
-title: Frist psot
-author: Anonymous Coward
-title: A well-written article
-author: Person McPherson
-```
-
-## Using variables to swap values
-Given a sample.yml file of:
-```yaml
-a: a_value
-b: b_value
-```
-then
-```bash
-yq eval '.a as $x  | .b as $y | .b = $x | .a = $y' sample.yml
-```
-will output
-```yaml
-a: b_value
-b: a_value
-```
-
-## Use ref to reference a path repeatedly
-Note: You may find the `with` operator more useful.
-
-Given a sample.yml file of:
-```yaml
-a:
-  b: thing
-  c: something
-```
-then
-```bash
-yq eval '.a.b ref $x | $x = "new" | $x style="double"' sample.yml
-```
-will output
-```yaml
-a:
-  b: "new"
-  c: something
-```
-
@@ -1,62 +0,0 @@
-Use the `with` operator to conveniently make multiple updates to a deeply nested path, or to update array elements relatively to each other. The first argument expression sets the root context, and the second expression runs against that root context.
-
-## Update and style
-Given a sample.yml file of:
-```yaml
-a:
-  deeply:
-    nested: value
-```
-then
-```bash
-yq eval 'with(.a.deeply.nested; . = "newValue" | . style="single")' sample.yml
-```
-will output
-```yaml
-a:
-  deeply:
-    nested: 'newValue'
-```
-
-## Update multiple deeply nested properties
-Given a sample.yml file of:
-```yaml
-a:
-  deeply:
-    nested: value
-    other: thing
-```
-then
-```bash
-yq eval 'with(.a.deeply; .nested = "newValue" | .other= "newThing")' sample.yml
-```
-will output
-```yaml
-a:
-  deeply:
-    nested: newValue
-    other: newThing
-```
-
-## Update array elements relatively
-The second expression runs with each element of the array as it's contextual root. This allows you to make updates relative to the element.
-
-Given a sample.yml file of:
-```yaml
-myArray:
-  - a: apple
-  - a: banana
-```
-then
-```bash
-yq eval 'with(.myArray[]; .b = .a + " yum")' sample.yml
-```
-will output
-```yaml
-myArray:
-  - a: apple
-    b: apple yum
-  - a: banana
-    b: banana yum
-```
-
@@ -1,116 +0,0 @@
-# Operators
-
-In `yq` expressions are made up of operators and pipes. A context of nodes is passed through the expression and each operation takes the context as input and returns a new context as output. That output is piped in as input for the next operation in the expression. To begin with, the context is set to the first yaml document of the first yaml file (if processing in sequence using eval).
-
-Lets look at a couple of examples.
-
-## Example with a simple operator
-
-Given a document like:
-
-```yaml
- [a]
- "cat"
-```
-
-with an expression:
-
-```
-.[] | length
-```
-
-`yq` will initially set the context as single node of the entire yaml document, an array of two elements.
-
-```yaml
- [a]
- "cat"
-```
-
-This gets piped into the splat operator `.[]` which will split out the context into a collection of two nodes `[a]` and `"cat"`. Note that this is _not_ a yaml array.
-
-The `length` operator take no arguments, and will simply return the length of _each_ matching node in the context. So for the context of `[a]` and `"cat"`, it will return a new context of `1` and `3`.
-
-This being the last operation in the expression, the results will be printed out:
-
-```
-1
-3
-```
-
-# Example with an operator that takes arguments.
-
-Given a document like:
-
-```yaml
-a: cat
-b: dog
-```
-
-with an expression:
-
-```
-.a = .b
-```
-
-The `=` operator takes two arguments, a `lhs` expression, which in this case is `.a` and `rhs` expression which is `.b`. 
-
-It pipes the current, lets call it 'root' context through the `lhs` expression of `.a` to return the node 
-
-```yaml
-cat
-```
-
-Note that this node holds not only its value 'cat', but comments and metadata too, including path and parent information.
-
-The `=` operator then pipes the 'root' context through the `rhs` expression of `.b` to return the node
-
-```yaml
-dog
-```
-
-Both sides have now been evaluated, so now the operator copies across the value from the RHS to the value on the LHS, and it returns the now updated context:
-
-```yaml
-a: dog
-b: dog
-```
-
-# Relative update (e.g. `|=`)
-There is another form of the `=` operator which we call the relative form. It's very similar to `=` but with one key difference when evaluating the RHS expression.
-
-In the plain form, we pass in the 'root' level context to the RHS expression. In relative form, we pass in _each result of the LHS_ to the RHS expression. Let's go through an example.
-
-Given a document like:
-
-```yaml
-a: 1
-b: thing
-```
-
-with an expression:
-
-```
-.a |= . + 1
-```
-
-Similar to the `=` operator, `|=` takes two operands, the LHS and RHS.
-
-It pipes the current context (the whole document) through the LHS expression  of `.a` to get the node value:
-
-```
-1
-```
-
-Now it pipes _that LHS context_ into the RHS expression `. + 1` (whereas in the `=` plain form it piped the original document context into the RHS) to yield:
-
-
-```
-2
-```
-
-The assignment operator then copies across the value from the RHS to the value on the LHS, and it returns the now updated 'root' context:
-
-```yaml
-a: 2
-b: thing
-```
@@ -1,6 +1,6 @@
 Add behaves differently according to the type of the LHS:
 - arrays: concatenate
- number scalars: arithmetic addition
- string scalars: concatenate
+- number scalars: arithmetic addition (soon)
+- string scalars: concatenate (soon)

-Use `+=` as append assign for things like increment. Note that `.a += .x` is equivalent to running `.a = .a + .x`.
+Use `+=` as append assign for things like increment. `.a += .x` is equivalent to running `.a |= . + .x`.
@@ -1,4 +1,4 @@
-Use the `alias` and `anchor` operators to read and write yaml aliases and anchors. The `explode` operator normalises a yaml file (dereference (or expands) aliases and remove anchor names).
+Use the `alias` and `anchor` operators to read and write yaml aliases and anchors. The `explode` operator normalises a yaml file (dereference 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.

@@ -1,9 +1 @@
-The `or` and `and` operators take two parameters and return a boolean result. 
-
-`not` flips a boolean from true to false, or vice versa. 
-
-`any` will return `true` if there are any `true` values in a array sequence, and `all` will return true if _all_ elements in an array are true.
-
-`any_c(condition)` and `all_c(condition)` are like `any` and `all` but they take a condition expression that is used against each element to determine if it's `true`. Note: in `jq` you can simply pass a condition to `any` or `all` and it simply works - `yq` isn't that clever..yet
-
-These are most commonly used with the `select` operator to filter particular nodes.
+The `or` and `and` operators take two parameters and return a boolean result. `not` flips a boolean from true to false, or vice versa. These are most commonly used with the `select` operator to filter particular nodes.
@@ -1,11 +1 @@
-Use these comment operators to set or retrieve comments.
-
-Like the `=` and `|=` assign operators, the same syntax applies when updating comments:
-
-
-### plain form: `=`
-This will assign the LHS nodes comments to the expression on the RHS. The RHS is run against the matching nodes in the pipeline
-
-### relative form: `|=` 
-Similar to the plain form, however the RHS evaluates against each matching LHS node! This is useful if you want to set the comments as a relative expression of the node, for instance its value or path.
-
+Use these comment operators to set or retrieve comments.
@@ -1 +1 @@
-Use the `documentIndex` operator (or the `di` shorthand) to select nodes of a particular document.
+Use the `documentIndex` operator to select nodes of a particular document.
@@ -1 +0,0 @@
-Similar to the same named functions in `jq` these functions convert to/from an object and an array of key-value pairs. This is most useful for performing operations on keys of maps.
@@ -1,2 +0,0 @@
-This operator is used to handle environment variables usage in path expressions. While environment variables can, of course, be passed in via your CLI with string interpolation, this often comes with complex quote escaping and can be tricky to write and read. Note that there are two forms, `env` which will parse the environment variable as a yaml (be it a map, array, string, number of boolean) and `strenv` which will always parse the argument as a string.
-
@@ -1,9 +1,7 @@
 File operators are most often used with merge when needing to merge specific files together. Note that when doing this, you will need to use `eval-all` to ensure all yaml documents are loaded into memory before performing the merge (as opposed to `eval` which runs the expression once per document).

-Note that the `fileIndex` operator has a short alias of `fi`.
-
 ## Merging files
 Note the use of eval-all to ensure all documents are loaded into memory.
 ```bash
-yq eval-all 'select(fi == 0) * select(filename == "file2.yaml")' file1.yaml file2.yaml
+yq eval-all 'select(fileIndex == 0) * select(filename == "file2.yaml")' file1.yaml file2.yaml
 ```
@@ -1,3 +0,0 @@
-# Keys
-
-Use the `keys` operator to return map keys or array indices. 
@@ -1,20 +0,0 @@
-Like the multiple operator in jq, depending on the operands, this multiply operator will do different things. Currently numbers, arrays and objects are supported.
-
-## Objects and arrays - merging
-Objects are merged deeply matching on matching keys. By default, array values override and are not deeply merged.
-
-Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.
-
-### Merge Flags
-You can control how objects are merged by using one or more of the following flags. Multiple flags can be used together, e.g. `.a *+? .b`.  See examples below
-
- `+` to append arrays
- `?` to only merge existing fields
- `d` to deeply merge arrays
-
-### Merging files
-Note the use of `eval-all` to ensure all documents are loaded into memory.
-
-```bash
-yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' file1.yaml file2.yaml
-```
@@ -0,0 +1,14 @@
+Like the multiple operator in `jq`, depending on the operands, this multiply operator will do different things. Currently only objects are supported, which have the effect of merging the RHS into the LHS.
+
+Upcoming versions of `yq` will add support for other types of multiplication (numbers, strings).
+
+To concatenate when merging objects, use the `*+` form (see examples below). This will recursively merge objects, appending arrays when it encounters them.
+
+Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.
+
+## Merging files
+Note the use of eval-all to ensure all documents are loaded into memory.
+
+```bash
+yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' file1.yaml file2.yaml
+```
@@ -1,19 +0,0 @@
-This operator recursively matches (or globs) 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
-```
@@ -0,0 +1,5 @@
+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:
+
+```bash
+yq eval '.. style= "flow"' file.yaml
+```
@@ -1,21 +0,0 @@
-Reduce is a powerful way to process a collection of data into a new form.
-
-```
-<exp> as $<name> ireduce (<init>; <block>)
-```
-
-e.g.
-
-```
-.[] as $item ireduce (0; . + $item)
-```
-
-On the LHS we are configuring the collection of items that will be reduced `<exp>` as well as what each element will be called `$<name>`. Note that the array has been splatted into its individual elements.
-
-On the RHS there is `<init>`, the starting value of the accumulator and `<block>`, the expression that will update the accumulator for each element in the collection. Note that within the block expression, `.` will evaluate to the current value of the accumulator. 
-
-## yq vs jq syntax
-Reduce syntax in `yq` is a little different from `jq` - as `yq` (currently) isn't as sophisticated as `jq` and its only supports infix notation (e.g. a + b, where the operator is in the middle of the two parameters) - where as `jq` uses a mix of infix notation with _prefix_ notation (e.g. `reduce a b` is like writing `+ a b`).
-
-To that end, the reduce operator is called `ireduce` for backwards compatability if a `jq` like prefix version of `reduce` is ever added.
-
@@ -1,3 +0,0 @@
-# Split into Documents
-
-This operator splits all matches into separate documents
@@ -1,44 +0,0 @@
-# String Operators
-
-## RegEx
-This uses golangs native regex functions under the hood - See https://github.com/google/re2/wiki/Syntax for the supported syntax.
-
-
-# String blocks, bash and newlines
-Bash is notorious for chomping on precious trailing newline characters, making it tricky to set strings with newlines properly. In particular, the `$( exp )` _will trim trailing newlines_.
-
-For instance to get this yaml:
-
-```
-a: |
-  cat
-```
-
-Using `$( exp )` wont work, as it will trim the trailing new line.
-
-```
-m=$(echo "cat\n") yq e -n '.a = strenv(m)'
-a: cat
-```
-
-However, using printf works:
-```
-printf -v m "cat\n" ; m="$m" yq e -n '.a = strenv(m)'
-a: |
-  cat
-```
-
-As well as having multiline expressions:
-```
-m="cat
-"  yq e -n '.a = strenv(m)'
-a: |
-  cat
-```
-
-Similarly, if you're trying to set the content from a file, and want a trailing new line:
-
-```
-IFS= read -rd '' output < <(cat my_file)
-output=$output ./yq e '.data.values = strenv(output)' first.yml
-```
@@ -1 +1 @@
-This is the simplest (and perhaps most used) operator, it is used to navigate deeply into yaml structures.
+This is the simplest (and perhaps most used) operator, it is used to navigate deeply into yaml structurse.
@@ -1 +0,0 @@
-This is used to filter out duplicated items in an array.
@@ -1,3 +0,0 @@
-Like the `jq` equivalents, variables are sometimes required for the more complex expressions (or swapping values between fields).
-
-Note that there is also an additional `ref` operator that holds a reference (instead of a copy) of the path, allowing you to make multiple changes to the same path.
@@ -1 +0,0 @@
-Use the `with` operator to conveniently make multiple updates to a deeply nested path, or to update array elements relatively to each other. The first argument expression sets the root context, and the second expression runs against that root context.
@@ -50,7 +50,7 @@ func (ye *yamlEncoder) Encode(node *yaml.Node) error {
 	}

 	if ye.colorise {
-		return colorizeAndPrint(tempBuffer.Bytes(), ye.destination)
+		return ColorizeAndPrint(tempBuffer.Bytes(), ye.destination)
 	}
 	return nil
 }
@@ -76,8 +76,6 @@ func mapKeysToStrings(node *yaml.Node) {

 func NewJsonEncoder(destination io.Writer, indent int) Encoder {
 	var encoder = json.NewEncoder(destination)
-	encoder.SetEscapeHTML(false) // do not escape html chars e.g. &, <, >
-
 	var indentString = ""

 	for index := 0; index < indent; index++ {
@@ -155,15 +153,11 @@ func (o *orderedMap) UnmarshalJSON(data []byte) error {
 }

 func (o orderedMap) MarshalJSON() ([]byte, error) {
+	if o.kv == nil {
+		return json.Marshal(o.altVal)
+	}
 	buf := new(bytes.Buffer)
 	enc := json.NewEncoder(buf)
-	enc.SetEscapeHTML(false) // do not escape html chars e.g. &, <, >
-	if o.kv == nil {
-		if err := enc.Encode(o.altVal); err != nil {
-			return nil, err
-		}
-		return buf.Bytes(), nil
-	}
 	buf.WriteByte('{')
 	for idx, el := range o.kv {
 		if err := enc.Encode(el.K); err != nil {
@@ -1,80 +0,0 @@
-package yqlib
-
-import (
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/magiconair/properties"
-	yaml "gopkg.in/yaml.v3"
-)
-
-type propertiesEncoder struct {
-	destination io.Writer
-}
-
-func NewPropertiesEncoder(destination io.Writer) Encoder {
-	return &propertiesEncoder{destination}
-}
-
-func (pe *propertiesEncoder) Encode(node *yaml.Node) error {
-	mapKeysToStrings(node)
-	p := properties.NewProperties()
-	err := pe.doEncode(p, node, "")
-	if err != nil {
-		return err
-	}
-
-	_, err = p.WriteComment(pe.destination, "#", properties.UTF8)
-	return err
-}
-
-func (pe *propertiesEncoder) doEncode(p *properties.Properties, node *yaml.Node, path string) error {
-	p.SetComment(path,
-		strings.Replace(node.HeadComment, "#", "", 1)+
-			strings.Replace(node.LineComment, "#", "", 1))
-	switch node.Kind {
-	case yaml.ScalarNode:
-		_, _, err := p.Set(path, node.Value)
-		return err
-	case yaml.DocumentNode:
-		return pe.doEncode(p, node.Content[0], path)
-	case yaml.SequenceNode:
-		return pe.encodeArray(p, node.Content, path)
-	case yaml.MappingNode:
-		return pe.encodeMap(p, node.Content, path)
-	case yaml.AliasNode:
-		return pe.doEncode(p, node.Alias, path)
-	default:
-		return fmt.Errorf("Unsupported node %v", node.Tag)
-	}
-}
-
-func (pe *propertiesEncoder) appendPath(path string, key interface{}) string {
-	if path == "" {
-		return fmt.Sprintf("%v", key)
-	}
-	return fmt.Sprintf("%v.%v", path, key)
-}
-
-func (pe *propertiesEncoder) encodeArray(p *properties.Properties, kids []*yaml.Node, path string) error {
-	for index, child := range kids {
-		err := pe.doEncode(p, child, pe.appendPath(path, index))
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (pe *propertiesEncoder) encodeMap(p *properties.Properties, kids []*yaml.Node, path string) error {
-	for index := 0; index < len(kids); index = index + 2 {
-		key := kids[index]
-		value := kids[index+1]
-		err := pe.doEncode(p, value, pe.appendPath(path, key.Value))
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
@@ -1,78 +0,0 @@
-package yqlib
-
-import (
-	"bufio"
-	"bytes"
-	"strings"
-	"testing"
-
-	"github.com/mikefarah/yq/v4/test"
-)
-
-func yamlToProps(sampleYaml string) string {
-	var output bytes.Buffer
-	writer := bufio.NewWriter(&output)
-
-	var propsEncoder = NewPropertiesEncoder(writer)
-	inputs, err := readDocuments(strings.NewReader(sampleYaml), "sample.yml", 0)
-	if err != nil {
-		panic(err)
-	}
-	node := inputs.Front().Value.(*CandidateNode).Node
-	err = propsEncoder.Encode(node)
-	if err != nil {
-		panic(err)
-	}
-	writer.Flush()
-
-	return strings.TrimSuffix(output.String(), "\n")
-}
-
-func TestPropertiesEncoderSimple(t *testing.T) {
-	var sampleYaml = `a: 'bob cool'`
-
-	var expectedJson = `a = bob cool`
-	var actualProps = yamlToProps(sampleYaml)
-	test.AssertResult(t, expectedJson, actualProps)
-}
-
-func TestPropertiesEncoderSimpleWithComments(t *testing.T) {
-	var sampleYaml = `a: 'bob cool' # line`
-
-	var expectedJson = `# line
-a = bob cool`
-	var actualProps = yamlToProps(sampleYaml)
-	test.AssertResult(t, expectedJson, actualProps)
-}
-
-func TestPropertiesEncoderDeep(t *testing.T) {
-	var sampleYaml = `a: 
-  b: "bob cool"
-`
-
-	var expectedJson = `a.b = bob cool`
-	var actualProps = yamlToProps(sampleYaml)
-	test.AssertResult(t, expectedJson, actualProps)
-}
-
-func TestPropertiesEncoderDeepWithComments(t *testing.T) {
-	var sampleYaml = `a:  # a thing
-  b: "bob cool" # b thing
-`
-
-	var expectedJson = `# b thing
-a.b = bob cool`
-	var actualProps = yamlToProps(sampleYaml)
-	test.AssertResult(t, expectedJson, actualProps)
-}
-
-func TestPropertiesEncoderArray(t *testing.T) {
-	var sampleYaml = `a: 
-  b: [{c: dog}, {c: cat}]
-`
-
-	var expectedJson = `a.b.0.c = dog
-a.b.1.c = cat`
-	var actualProps = yamlToProps(sampleYaml)
-	test.AssertResult(t, expectedJson, actualProps)
-}
@@ -9,11 +9,29 @@ import (
 	"github.com/mikefarah/yq/v4/test"
 )

-func yamlToJson(sampleYaml string, indent int) string {
+var sampleYaml = `zabbix: winner
+apple: great
+banana:
+- {cobra: kai, angus: bob}
+`
+
+var expectedJson = `{
+  "zabbix": "winner",
+  "apple": "great",
+  "banana": [
+    {
+      "cobra": "kai",
+      "angus": "bob"
+    }
+  ]
+}
+`
+
+func TestJsonEncoderPreservesObjectOrder(t *testing.T) {
 	var output bytes.Buffer
 	writer := bufio.NewWriter(&output)

-	var jsonEncoder = NewJsonEncoder(writer, indent)
+	var jsonEncoder = NewJsonEncoder(writer, 2)
 	inputs, err := readDocuments(strings.NewReader(sampleYaml), "sample.yml", 0)
 	if err != nil {
 		panic(err)
@@ -24,33 +42,6 @@ func yamlToJson(sampleYaml string, indent int) string {
 		panic(err)
 	}
 	writer.Flush()
+	test.AssertResult(t, expectedJson, output.String())

-	return strings.TrimSuffix(output.String(), "\n")
-}
-
-func TestJsonEncoderPreservesObjectOrder(t *testing.T) {
-	var sampleYaml = `zabbix: winner
-apple: great
-banana:
- {cobra: kai, angus: bob}
-`
-	var expectedJson = `{
-  "zabbix": "winner",
-  "apple": "great",
-  "banana": [
-    {
-      "cobra": "kai",
-      "angus": "bob"
-    }
-  ]
-}`
-	var actualJson = yamlToJson(sampleYaml, 2)
-	test.AssertResult(t, expectedJson, actualJson)
-}
-
-func TestJsonEncoderDoesNotEscapeHTMLChars(t *testing.T) {
-	var sampleYaml = `build: "( ./lint && ./format && ./compile ) < src.code"`
-	var expectedJson = `{"build":"( ./lint && ./format && ./compile ) < src.code"}`
-	var actualJson = yamlToJson(sampleYaml, 0)
-	test.AssertResult(t, expectedJson, actualJson)
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mike Farah	822d56a673	tests passsing!	2020-12-27 22:47:19 +11:00
Mike Farah	4e1a1025c3	wip	2020-12-27 22:29:00 +11:00
Mike Farah	7b54bead5e	wip	2020-12-27 22:14:26 +11:00
Mike Farah	f7f8bed955	wip	2020-12-27 09:55:21 +11:00
Mike Farah	6a13c8b78f	Traverse Array Operator	2020-12-27 09:55:21 +11:00
				`@@ -1 +0,0 @@`
				Similar to the same named functions in `jq` these functions convert to/from an object and an array of key-value pairs. This is most useful for performing operations on keys of maps.
				`@@ -1,2 +0,0 @@`
				This operator is used to handle environment variables usage in path expressions. While environment variables can, of course, be passed in via your CLI with string interpolation, this often comes with complex quote escaping and can be tricky to write and read. Note that there are two forms, `env` which will parse the environment variable as a yaml (be it a map, array, string, number of boolean) and `strenv` which will always parse the argument as a string.
				`@@ -1 +0,0 @@`
				`This is used to filter out duplicated items in an array.`
				`@@ -1 +0,0 @@`
				Use the `with` operator to conveniently make multiple updates to a deeply nested path, or to update array elements relatively to each other. The first argument expression sets the root context, and the second expression runs against that root context.