tests passsing!

.github/ISSUE_TEMPLATE/bug_report_v3.md

@@ -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/...

.github/ISSUE_TEMPLATE/bug_report_v4.md

@@ -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/...

.github/ISSUE_TEMPLATE/feature_request.md

@@ -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:
+Please note that V3 will no longer have any enhancements.
-- how to questions should be posted in the discussion board and not raised as an issue.
-- V3 will no longer have any enhancements.
 
 **Describe the solution you'd like**
 If we have data1.yml like:

.github/workflows/release.yml

@@ -68,9 +68,7 @@ jobs:
  
       - name: Build and push image
         run: |
-          IMAGE_V_VERSION="$(git describe --tags --abbrev=0)"
+          IMAGE_VERSION="$(git describe --tags --abbrev=0)"
-          IMAGE_VERSION=${IMAGE_V_VERSION:1}
-
           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}"

Dockerfile.dev

@@ -4,7 +4,6 @@ COPY scripts/devtools.sh /opt/devtools.sh
 
 RUN set -e -x \
     && /opt/devtools.sh
-ENV PATH=/go/bin:$PATH
 
 # install mkdocs
 RUN set -ex \

README.md

@@ -3,9 +3,9 @@
 ![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.
 
 ## 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! 
@@ -16,31 +16,13 @@ If you've been using v3 and want/need to upgrade, checkout the [upgrade guide](h
 
 ### [Download the latest binary](https://github.com/mikefarah/yq/releases/latest)
 
-### wget
+### MacOS:
-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:
 Using [Homebrew](https://brew.sh/)
 ```
 brew install yq
 ```
 
-### Linux via snap:
+### Ubuntu and other Linux distros supporting `snap` packages:
 ```
 snap install yq
 ```
@@ -63,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:
@@ -165,7 +158,6 @@ Flags:
   -M, --no-colors     force print with no colors
   -N, --no-doc        Don't print document separators (---)
   -n, --null-input    Don't read input, simply evaluate the expression given. Useful for creating yaml docs from scratch.
-  -P, --prettyPrint    pretty print, shorthand for '... style = ""' 
   -j, --tojson        output as json. Set indent to 0 to print json in one line.
   -v, --verbose       verbose mode
   -V, --version       Print version information and quit

cmd/constant.go

@@ -14,6 +14,5 @@ var noDocSeparators = false
 var nullInput = false
 var verbose = false
 var version = false
-var prettyPrint = false
 
 var completedSuccessfully = false

cmd/evaluate_all_command.go

@@ -65,19 +65,19 @@ func evaluateAll(cmd *cobra.Command, args []string) error {
 	switch len(args) {
 	case 0:
 		if pipingStdIn {
-			err = allAtOnceEvaluator.EvaluateFiles(processExpression(""), []string{"-"}, printer)
+			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)
+			err = allAtOnceEvaluator.EvaluateFiles("", []string{args[0]}, printer)
 		}
 	default:
-		err = allAtOnceEvaluator.EvaluateFiles(processExpression(args[0]), args[1:], printer)
+		err = allAtOnceEvaluator.EvaluateFiles(args[0], args[1:], printer)
 	}
 
 	completedSuccessfully = err == nil

cmd/evalute_sequence_command.go

@@ -33,16 +33,6 @@ yq e '.a.b = "cool"' -i file.yaml
 	}
 	return cmdEvalSequence
 }
-
-func processExpression(expression string) string {
-	if prettyPrint && expression == "" {
-		return `... style=""`
-	} else if prettyPrint {
-		return fmt.Sprintf("%v | ... style= \"\"", expression)
-	}
-	return expression
-}
-
 func evaluateSequence(cmd *cobra.Command, args []string) error {
 	cmd.SilenceUsage = true
 	// 0 args, read std in
@@ -86,16 +76,16 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 	switch len(args) {
 	case 0:
 		if pipingStdIn {
-			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{"-"}, printer)
+			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)
+			err = streamEvaluator.EvaluateFiles("", []string{args[0]}, printer)
 		}
 	default:
 		err = streamEvaluator.EvaluateFiles(args[0], args[1:], printer)

cmd/root.go

@@ -48,7 +48,6 @@ func New() *cobra.Command {
 	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")

cmd/version.go

@@ -11,7 +11,7 @@ var (
 	GitDescribe string
 
 	// Version is main version number that is being run at the moment.
-	Version = "4.2.1"
+	Version = "4.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

github-action/Dockerfile

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

pkg/yqlib/candidate_node.go

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

pkg/yqlib/doc/Assign.md

@@ -34,27 +34,6 @@ a:
   g: foof
 ```
 
-## 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

pkg/yqlib/doc/Document Index.md

@@ -26,7 +26,7 @@ a: frog
 ```
 then
 ```bash
-yq eval 'select(documentIndex == 1)' sample.yml
+yq eval 'select(. | documentIndex == 1)' sample.yml
 ```
 will output
 ```yaml
@@ -42,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

pkg/yqlib/doc/File Operators.md

@@ -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,17 +33,3 @@ will output
 0
 ```
 
-## Get file index alias
-Given a sample.yml file of:
-```yaml
-a: cat
-```
-then
-```bash
-yq eval 'fi' sample.yml
-```
-will output
-```yaml
-0
-```
-

pkg/yqlib/doc/Recursive Descent.md

@@ -1,55 +1,8 @@
-This operator recursively matches all children nodes given of a particular element, including that node itself. This is most often used to apply a filter recursively against all matches. It can be used in either the 
+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:
-
-## match values form `..`
-This will, like the `jq` equivalent, recursively match all _value_ nodes. Use it to find/manipulate particular values.
-
-For instance to set the `style` of all _value_ nodes in a yaml doc, excluding map keys:
 
 ```bash
 yq eval '.. style= "flow"' file.yaml
 ```
-
-## match values and map keys form `...`
-The also includes map keys in the results set. This is particularly useful in YAML as unlike JSON, map keys can have their own styling, tags and use anchors and aliases.
-
-For instance to set the `style` of all nodes in a yaml doc, including the map keys:
-
-```bash
-yq eval '... style= "flow"' file.yaml
-```
-## Recurse map (values only)
-Given a sample.yml file of:
-```yaml
-a: frog
-```
-then
-```bash
-yq eval '..' sample.yml
-```
-will output
-```yaml
-a: frog
-frog
-```
-
-## Recurse map (values and keys)
-Note that the map key appears in the results
-
-Given a sample.yml file of:
-```yaml
-a: frog
-```
-then
-```bash
-yq eval '...' sample.yml
-```
-will output
-```yaml
-a: frog
-a
-frog
-```
-
 ## Aliases are not traversed
 Given a sample.yml file of:
 ```yaml

pkg/yqlib/doc/Style.md

@@ -40,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
@@ -146,18 +126,18 @@ will output
 ```
 
 ## 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.
+Set empty (default) quote style
 
 Given a sample.yml file of:
 ```yaml
 a: cat
-"b": 5
+b: 5
-'c': 3.2
+c: 3.2
-"e": true
+e: true
 ```
 then
 ```bash
-yq eval '... style=""' sample.yml
+yq eval '.. style=""' sample.yml
 ```
 will output
 ```yaml

pkg/yqlib/doc/Traverse.md

@@ -106,7 +106,7 @@ b: *cat
 ```
 then
 ```bash
-yq eval '.b[]' sample.yml
+yq eval '.b.[]' sample.yml
 ```
 will output
 ```yaml
@@ -290,7 +290,7 @@ foobar:
 ```
 then
 ```bash
-yq eval '.foobar[]' sample.yml
+yq eval '.foobar.[]' sample.yml
 ```
 will output
 ```yaml
@@ -356,7 +356,7 @@ foobar:
 ```
 then
 ```bash
-yq eval '.foobarList[]' sample.yml
+yq eval '.foobarList.[]' sample.yml
 ```
 will output
 ```yaml

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

@@ -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
 ```

pkg/yqlib/doc/headers/Recursive Descent.md

@@ -1,19 +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. It can be used in either the 
+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:
-
-## 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
 ```

pkg/yqlib/lib.go

@@ -19,7 +19,7 @@ type OperationType struct {
 }
 
 // operators TODO:
-// - keys operator for controlling key metadata (particularly anchors/aliases)
+// - cookbook doc for common things
 // - mergeEmpty (sets only if the document is empty, do I do that now?)
 
 var Or = &OperationType{Type: "OR", NumArgs: 2, Precedence: 20, Handler: OrOperator}

pkg/yqlib/operator_assign.go

@@ -33,9 +33,7 @@ func AssignUpdateOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNo
 		first := rhs.Front()
 
 		if first != nil {
-			rhsCandidate := first.Value.(*CandidateNode)
+			candidate.UpdateFrom(first.Value.(*CandidateNode))
-			rhsCandidate.Node = UnwrapDoc(rhsCandidate.Node)
-			candidate.UpdateFrom(rhsCandidate)
 		}
 	}
 	// // if there was nothing given, perhaps we are creating a new yaml doc

pkg/yqlib/operator_assign_test.go

@@ -20,16 +20,6 @@ var assignOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{a: {g: foof}}\n",
 		},
 	},
-	{
-		description:    "Update node from another file",
-		subdescription: "Note this will also work when the second file is a scalar (string/number)",
-		document:       `{a: apples}`,
-		document2:      "{b: bob}",
-		expression:     `select(fileIndex==0).a = select(fileIndex==1) | select(fileIndex==0)`,
-		expected: []string{
-			"D0, P[], (doc)::{a: {b: bob}}\n",
-		},
-	},
 	{
 		description: "Update node to be the sibling value",
 		document:    `{a: {b: child}, b: sibling}`,

pkg/yqlib/operator_collect_object.go

@@ -67,9 +67,7 @@ func collect(d *dataTreeNavigator, aggregate *list.List, remainingMatches *list.
 	}
 
 	candidate := remainingMatches.Remove(remainingMatches.Front()).(*CandidateNode)
-
+	splatted, err := Splat(d, nodeToMap(candidate))
-	splatted, err := Splat(d, nodeToMap(candidate),
-		&TraversePreferences{FollowAlias: false, IncludeMapKeys: false})
 
 	for splatEl := splatted.Front(); splatEl != nil; splatEl = splatEl.Next() {
 		splatEl.Value.(*CandidateNode).Path = nil

pkg/yqlib/operator_document_index_test.go

@@ -17,7 +17,7 @@ var documentIndexScenarios = []expressionScenario{
 	{
 		description: "Filter by document index",
 		document:    "a: cat\n---\na: frog\n",
-		expression:  `select(documentIndex == 1)`,
+		expression:  `select(. | documentIndex == 1)`,
 		expected: []string{
 			"D1, P[], (doc)::a: frog\n",
 		},
@@ -25,7 +25,7 @@ var documentIndexScenarios = []expressionScenario{
 	{
 		description: "Print Document Index with matches",
 		document:    "a: cat\n---\na: frog\n",
-		expression:  `.a | ({"match": ., "doc": documentIndex})`,
+		expression:  `.a | ({"match": ., "doc": (. | documentIndex)})`,
 		expected: []string{
 			"D0, P[], (!!map)::match: cat\ndoc: 0\n",
 			"D0, P[], (!!map)::match: frog\ndoc: 1\n",

pkg/yqlib/operator_file_test.go

@@ -21,14 +21,6 @@ var fileOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!int)::0\n",
 		},
 	},
-	{
-		description: "Get file index alias",
-		document:    `{a: cat}`,
-		expression:  `fi`,
-		expected: []string{
-			"D0, P[], (!!int)::0\n",
-		},
-	},
 }
 
 func TestFileOperatorsScenarios(t *testing.T) {

pkg/yqlib/operator_multiply.go

@@ -85,9 +85,7 @@ func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode,
 	var results = list.New()
 
 	// shouldn't recurse arrays if appending
-	prefs := &RecursiveDescentPreferences{RecurseArray: !shouldAppendArrays,
+	err := recursiveDecent(d, results, nodeToMap(rhs), !shouldAppendArrays)
-		TraversePreferences: &TraversePreferences{FollowAlias: false}}
-	err := recursiveDecent(d, results, nodeToMap(rhs), prefs)
 	if err != nil {
 		return nil, err
 	}

pkg/yqlib/operator_recursive_descent.go

@@ -6,16 +6,10 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
-type RecursiveDescentPreferences struct {
-	TraversePreferences *TraversePreferences
-	RecurseArray        bool
-}
-
 func RecursiveDescentOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	var results = list.New()
 
-	preferences := pathNode.Operation.Preferences.(*RecursiveDescentPreferences)
+	err := recursiveDecent(d, results, matchMap, true)
-	err := recursiveDecent(d, results, matchMap, preferences)
 	if err != nil {
 		return nil, err
 	}
@@ -23,7 +17,7 @@ func RecursiveDescentOperator(d *dataTreeNavigator, matchMap *list.List, pathNod
 	return results, nil
 }
 
-func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.List, preferences *RecursiveDescentPreferences) error {
+func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.List, recurseArray bool) error {
 	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
@@ -33,14 +27,14 @@ func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.Li
 		results.PushBack(candidate)
 
 		if candidate.Node.Kind != yaml.AliasNode && len(candidate.Node.Content) > 0 &&
-			(preferences.RecurseArray || candidate.Node.Kind != yaml.SequenceNode) {
+			(recurseArray || candidate.Node.Kind != yaml.SequenceNode) {
 
-			children, err := Splat(d, nodeToMap(candidate), preferences.TraversePreferences)
+			children, err := Splat(d, nodeToMap(candidate))
 
 			if err != nil {
 				return err
 			}
-			err = recursiveDecent(d, results, children, preferences)
+			err = recursiveDecent(d, results, children, recurseArray)
 			if err != nil {
 				return err
 			}

pkg/yqlib/operator_recursive_descent_test.go

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

pkg/yqlib/operator_style_test.go

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

pkg/yqlib/operator_traverse_path.go

@@ -10,12 +10,11 @@ import (
 )
 
 type TraversePreferences struct {
-	FollowAlias    bool
+	DontFollowAlias bool
-	IncludeMapKeys bool
 }
 
-func Splat(d *dataTreeNavigator, matches *list.List, prefs *TraversePreferences) (*list.List, error) {
+func Splat(d *dataTreeNavigator, matches *list.List) (*list.List, error) {
-	return traverseNodesWithArrayIndices(matches, make([]*yaml.Node, 0), prefs)
+	return traverseNodesWithArrayIndices(matches, make([]*yaml.Node, 0), false)
 }
 
 func TraversePathOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
@@ -54,8 +53,12 @@ func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Oper
 	switch value.Kind {
 	case yaml.MappingNode:
 		log.Debug("its a map with %v entries", len(value.Content)/2)
-		prefs := &TraversePreferences{FollowAlias: true}
+		followAlias := true
-		return traverseMap(matchingNode, operation.StringValue, prefs, false)
+
+		if operation.Preferences != nil {
+			followAlias = !operation.Preferences.(*TraversePreferences).DontFollowAlias
+		}
+		return traverseMap(matchingNode, operation.StringValue, followAlias, false)
 
 	case yaml.SequenceNode:
 		log.Debug("its a sequence of %v things!", len(value.Content))
@@ -86,15 +89,15 @@ func TraverseArrayOperator(d *dataTreeNavigator, matchingNodes *list.List, pathN
 	}
 
 	var indicesToTraverse = rhs.Front().Value.(*CandidateNode).Node.Content
-	prefs := &TraversePreferences{FollowAlias: true}
+
-	return traverseNodesWithArrayIndices(matchingNodes, indicesToTraverse, prefs)
+	return traverseNodesWithArrayIndices(matchingNodes, indicesToTraverse, true)
 }
 
-func traverseNodesWithArrayIndices(matchingNodes *list.List, indicesToTraverse []*yaml.Node, prefs *TraversePreferences) (*list.List, error) {
+func traverseNodesWithArrayIndices(matchingNodes *list.List, indicesToTraverse []*yaml.Node, followAlias bool) (*list.List, error) {
 	var matchingNodeMap = list.New()
 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		newNodes, err := traverseArrayIndices(candidate, indicesToTraverse, prefs)
+		newNodes, err := traverseArrayIndices(candidate, indicesToTraverse, followAlias)
 		if err != nil {
 			return nil, err
 		}
@@ -104,7 +107,7 @@ func traverseNodesWithArrayIndices(matchingNodes *list.List, indicesToTraverse [
 	return matchingNodeMap, nil
 }
 
-func traverseArrayIndices(matchingNode *CandidateNode, indicesToTraverse []*yaml.Node, prefs *TraversePreferences) (*list.List, error) { // call this if doc / alias like the other traverse
+func traverseArrayIndices(matchingNode *CandidateNode, indicesToTraverse []*yaml.Node, followAlias bool) (*list.List, error) { // call this if doc / alias like the other traverse
 	node := matchingNode.Node
 	if node.Tag == "!!null" {
 		log.Debugf("OperatorArrayTraverse got a null - turning it into an empty array")
@@ -115,32 +118,32 @@ func traverseArrayIndices(matchingNode *CandidateNode, indicesToTraverse []*yaml
 
 	if node.Kind == yaml.AliasNode {
 		matchingNode.Node = node.Alias
-		return traverseArrayIndices(matchingNode, indicesToTraverse, prefs)
+		return traverseArrayIndices(matchingNode, indicesToTraverse, followAlias)
 	} else if node.Kind == yaml.SequenceNode {
 		return traverseArrayWithIndices(matchingNode, indicesToTraverse)
 	} else if node.Kind == yaml.MappingNode {
-		return traverseMapWithIndices(matchingNode, indicesToTraverse, prefs)
+		return traverseMapWithIndices(matchingNode, indicesToTraverse, followAlias)
 	} else if node.Kind == yaml.DocumentNode {
 		return traverseArrayIndices(&CandidateNode{
 			Node:      matchingNode.Node.Content[0],
 			Filename:  matchingNode.Filename,
 			FileIndex: matchingNode.FileIndex,
-			Document:  matchingNode.Document}, indicesToTraverse, prefs)
+			Document:  matchingNode.Document}, indicesToTraverse, followAlias)
 	}
 	log.Debugf("OperatorArrayTraverse skipping %v as its a %v", matchingNode, node.Tag)
 	return list.New(), nil
 }
 
-func traverseMapWithIndices(candidate *CandidateNode, indices []*yaml.Node, prefs *TraversePreferences) (*list.List, error) {
+func traverseMapWithIndices(candidate *CandidateNode, indices []*yaml.Node, followAlias bool) (*list.List, error) {
 	if len(indices) == 0 {
-		return traverseMap(candidate, "", prefs, true)
+		return traverseMap(candidate, "", followAlias, true)
 	}
 
 	var matchingNodeMap = list.New()
 
 	for _, indexNode := range indices {
 		log.Debug("traverseMapWithIndices: %v", indexNode.Value)
-		newNodes, err := traverseMap(candidate, indexNode.Value, prefs, false)
+		newNodes, err := traverseMap(candidate, indexNode.Value, followAlias, false)
 		if err != nil {
 			return nil, err
 		}
@@ -203,9 +206,9 @@ func keyMatches(key *yaml.Node, wantedKey string) bool {
 	return Match(key.Value, wantedKey)
 }
 
-func traverseMap(matchingNode *CandidateNode, key string, prefs *TraversePreferences, splat bool) (*list.List, error) {
+func traverseMap(matchingNode *CandidateNode, key string, followAlias bool, splat bool) (*list.List, error) {
 	var newMatches = orderedmap.NewOrderedMap()
-	err := doTraverseMap(newMatches, matchingNode, key, prefs, splat)
+	err := doTraverseMap(newMatches, matchingNode, key, followAlias, splat)
 
 	if err != nil {
 		return nil, err
@@ -234,7 +237,7 @@ func traverseMap(matchingNode *CandidateNode, key string, prefs *TraversePrefere
 	return results, nil
 }
 
-func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode, wantedKey string, prefs *TraversePreferences, splat bool) error {
+func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode, wantedKey string, followAlias bool, splat bool) error {
 	// value.Content is a concatenated array of key, value,
 	// so keys are in the even indexes, values in odd.
 	// merge aliases are defined first, but we only want to traverse them
@@ -249,22 +252,14 @@ func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode,
 
 		log.Debug("checking %v (%v)", key.Value, key.Tag)
 		//skip the 'merge' tag, find a direct match first
-		if key.Tag == "!!merge" && prefs.FollowAlias {
+		if key.Tag == "!!merge" && followAlias {
 			log.Debug("Merge anchor")
-			err := traverseMergeAnchor(newMatches, candidate, value, wantedKey, prefs, splat)
+			err := traverseMergeAnchor(newMatches, candidate, value, wantedKey, splat)
 			if err != nil {
 				return err
 			}
 		} else if splat || keyMatches(key, wantedKey) {
 			log.Debug("MATCHED")
-			if prefs.IncludeMapKeys {
-				candidateNode := &CandidateNode{
-					Node:     key,
-					Path:     candidate.CreateChildPath(key.Value),
-					Document: candidate.Document,
-				}
-				newMatches.Set(fmt.Sprintf("keyOf-%v", candidateNode.GetKey()), candidateNode)
-			}
 			candidateNode := &CandidateNode{
 				Node:     value,
 				Path:     candidate.CreateChildPath(key.Value),
@@ -277,7 +272,7 @@ func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode,
 	return nil
 }
 
-func traverseMergeAnchor(newMatches *orderedmap.OrderedMap, originalCandidate *CandidateNode, value *yaml.Node, wantedKey string, prefs *TraversePreferences, splat bool) error {
+func traverseMergeAnchor(newMatches *orderedmap.OrderedMap, originalCandidate *CandidateNode, value *yaml.Node, wantedKey string, splat bool) error {
 	switch value.Kind {
 	case yaml.AliasNode:
 		candidateNode := &CandidateNode{
@@ -285,10 +280,10 @@ func traverseMergeAnchor(newMatches *orderedmap.OrderedMap, originalCandidate *C
 			Path:     originalCandidate.Path,
 			Document: originalCandidate.Document,
 		}
-		return doTraverseMap(newMatches, candidateNode, wantedKey, prefs, splat)
+		return doTraverseMap(newMatches, candidateNode, wantedKey, true, splat)
 	case yaml.SequenceNode:
 		for _, childValue := range value.Content {
-			err := traverseMergeAnchor(newMatches, originalCandidate, childValue, wantedKey, prefs, splat)
+			err := traverseMergeAnchor(newMatches, originalCandidate, childValue, wantedKey, splat)
 			if err != nil {
 				return err
 			}

pkg/yqlib/operator_traverse_path_test.go

@@ -137,15 +137,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		description: "Traversing aliases with splat",
 		document:    `{a: &cat {c: frog}, b: *cat}`,
-		expression:  `.b[]`,
+		expression:  `.b.[]`,
-		expected: []string{
-			"D0, P[b c], (!!str)::frog\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `{a: &cat {c: frog}, b: *cat}`,
-		expression: `.b.[]`,
 		expected: []string{
 			"D0, P[b c], (!!str)::frog\n",
 		},
@@ -217,17 +209,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		description: "Splatting merge anchors",
 		document:    mergeDocSample,
-		expression:  `.foobar[]`,
+		expression:  `.foobar.[]`,
-		expected: []string{
-			"D0, P[foobar c], (!!str)::foo_c\n",
-			"D0, P[foobar a], (!!str)::foo_a\n",
-			"D0, P[foobar thing], (!!str)::foobar_thing\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   mergeDocSample,
-		expression: `.foobar.[]`,
 		expected: []string{
 			"D0, P[foobar c], (!!str)::foo_c\n",
 			"D0, P[foobar a], (!!str)::foo_a\n",
@@ -278,18 +260,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		description: "Splatting merge anchor lists",
 		document:    mergeDocSample,
-		expression:  `.foobarList[]`,
+		expression:  `.foobarList.[]`,
-		expected: []string{
-			"D0, P[foobarList b], (!!str)::bar_b\n",
-			"D0, P[foobarList a], (!!str)::foo_a\n",
-			"D0, P[foobarList thing], (!!str)::bar_thing\n",
-			"D0, P[foobarList c], (!!str)::foobarList_c\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   mergeDocSample,
-		expression: `.foobarList.[]`,
 		expected: []string{
 			"D0, P[foobarList b], (!!str)::bar_b\n",
 			"D0, P[foobarList a], (!!str)::foo_a\n",
@@ -341,6 +312,14 @@ var traversePathOperatorScenarios = []expressionScenario{
 			"D0, P[a 2], (!!str)::c\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a.[0]`,
+		expected: []string{
+			"D0, P[a 0], (!!str)::a\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,

pkg/yqlib/operators_test.go

@@ -18,7 +18,6 @@ type expressionScenario struct {
 	description           string
 	subdescription        string
 	document              string
-	document2             string
 	expression            string
 	expected              []string
 	skipDoc               bool
@@ -42,14 +41,6 @@ func testScenario(t *testing.T, s *expressionScenario) {
 			t.Error(err, s.document, s.expression)
 			return
 		}
-		if s.document2 != "" {
-			moreInputs, err := readDocuments(strings.NewReader(s.document2), "another.yml", 1)
-			if err != nil {
-				t.Error(err, s.document, s.expression)
-				return
-			}
-			inputs.PushBackList(moreInputs)
-		}
 	} else {
 		candidateNode := &CandidateNode{
 			Document:  0,
@@ -101,7 +92,7 @@ func copyFromHeader(title string, out *os.File) error {
 	return err
 }
 
-func formatYaml(yaml string, filename string) string {
+func formatYaml(yaml string) string {
 	var output bytes.Buffer
 	printer := NewPrinter(bufio.NewWriter(&output), false, true, false, 2, true)
 
@@ -110,7 +101,7 @@ func formatYaml(yaml string, filename string) string {
 		panic(err)
 	}
 	streamEvaluator := NewStreamEvaluator()
-	err = streamEvaluator.Evaluate(filename, strings.NewReader(yaml), node, printer)
+	err = streamEvaluator.Evaluate("sample.yaml", strings.NewReader(yaml), node, printer)
 	if err != nil {
 		panic(err)
 	}
@@ -137,116 +128,63 @@ func documentScenarios(t *testing.T, title string, scenarios []expressionScenari
 
 	for _, s := range scenarios {
 		if !s.skipDoc {
-			documentScenario(t, w, s)
+
+			writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
+
+			if s.subdescription != "" {
+				writeOrPanic(w, s.subdescription)
+				writeOrPanic(w, "\n\n")
+			}
+			formattedDoc := ""
+			if s.document != "" {
+				if s.dontFormatInputForDoc {
+					formattedDoc = s.document + "\n"
+				} else {
+					formattedDoc = formatYaml(s.document)
+				}
+				//TODO: pretty here
+				writeOrPanic(w, "Given a sample.yml file of:\n")
+
+				writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n", formattedDoc))
+				writeOrPanic(w, "then\n")
+				if s.expression != "" {
+					writeOrPanic(w, fmt.Sprintf("```bash\nyq eval '%v' sample.yml\n```\n", s.expression))
+				} else {
+					writeOrPanic(w, "```bash\nyq eval sample.yml\n```\n")
+				}
+			} else {
+				writeOrPanic(w, "Running\n")
+				writeOrPanic(w, fmt.Sprintf("```bash\nyq eval --null-input '%v'\n```\n", s.expression))
+			}
+
+			writeOrPanic(w, "will output\n")
+
+			var output bytes.Buffer
+			var err error
+			printer := NewPrinter(bufio.NewWriter(&output), false, true, false, 2, true)
+			streamEvaluator := NewStreamEvaluator()
+
+			if s.document != "" {
+				node, err := treeCreator.ParsePath(s.expression)
+				if err != nil {
+					t.Error(err, s.expression)
+				}
+				err = streamEvaluator.Evaluate("sample.yaml", strings.NewReader(formattedDoc), node, printer)
+
+				if err != nil {
+					t.Error(err, s.expression)
+				}
+			} else {
+				err = streamEvaluator.EvaluateNew(s.expression, printer)
+				if err != nil {
+					t.Error(err, s.expression)
+				}
+			}
+
+			writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", output.String()))
+
 		}
+
 	}
 	w.Flush()
 }
-
-func documentScenario(t *testing.T, w *bufio.Writer, s expressionScenario) {
-	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
-
-	if s.subdescription != "" {
-		writeOrPanic(w, s.subdescription)
-		writeOrPanic(w, "\n\n")
-	}
-
-	formattedDoc, formattedDoc2 := documentInput(w, s)
-
-	writeOrPanic(w, "will output\n")
-
-	documentOutput(t, w, s, formattedDoc, formattedDoc2)
-}
-
-func documentInput(w *bufio.Writer, s expressionScenario) (string, string) {
-	formattedDoc := ""
-	formattedDoc2 := ""
-	command := "eval"
-	if s.document != "" {
-		if s.dontFormatInputForDoc {
-			formattedDoc = s.document + "\n"
-		} else {
-			formattedDoc = formatYaml(s.document, "sample.yml")
-		}
-
-		writeOrPanic(w, "Given a sample.yml file of:\n")
-		writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n", formattedDoc))
-
-		files := "sample.yml"
-
-		if s.document2 != "" {
-			if s.dontFormatInputForDoc {
-				formattedDoc2 = s.document2 + "\n"
-			} else {
-				formattedDoc2 = formatYaml(s.document2, "another.yml")
-			}
-
-			writeOrPanic(w, "And another sample another.yml file of:\n")
-			writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n", formattedDoc2))
-			files = "sample.yml another.yml"
-			command = "eval-all"
-		}
-
-		writeOrPanic(w, "then\n")
-		if s.expression != "" {
-			writeOrPanic(w, fmt.Sprintf("```bash\nyq %v '%v' %v\n```\n", command, s.expression, files))
-		} else {
-			writeOrPanic(w, fmt.Sprintf("```bash\nyq %v %v\n```\n", command, files))
-		}
-	} else {
-		writeOrPanic(w, "Running\n")
-		writeOrPanic(w, fmt.Sprintf("```bash\nyq %v --null-input '%v'\n```\n", command, s.expression))
-	}
-	return formattedDoc, formattedDoc2
-}
-
-func documentOutput(t *testing.T, w *bufio.Writer, s expressionScenario, formattedDoc string, formattedDoc2 string) {
-	var output bytes.Buffer
-	var err error
-	printer := NewPrinter(bufio.NewWriter(&output), false, true, false, 2, true)
-
-	node, err := treeCreator.ParsePath(s.expression)
-	if err != nil {
-		t.Error(fmt.Errorf("Error parsing expression %v of %v: %v", s.expression, s.description, err))
-		return
-	}
-
-	inputs := list.New()
-
-	if s.document != "" {
-		inputs, err = readDocuments(strings.NewReader(formattedDoc), "sample.yml", 0)
-		if err != nil {
-			t.Error(err, s.document, s.expression)
-			return
-		}
-		if s.document2 != "" {
-			moreInputs, err := readDocuments(strings.NewReader(formattedDoc2), "another.yml", 1)
-			if err != nil {
-				t.Error(err, s.document, s.expression)
-				return
-			}
-			inputs.PushBackList(moreInputs)
-		}
-	} else {
-		candidateNode := &CandidateNode{
-			Document:  0,
-			Filename:  "",
-			Node:      &yaml.Node{Tag: "!!null"},
-			FileIndex: 0,
-		}
-		inputs.PushBack(candidateNode)
-
-	}
-
-	results, err := treeNavigator.GetMatchingNodes(inputs, node)
-	if err != nil {
-		t.Error(err, s.expression)
-	}
-
-	err = printer.PrintResults(results)
-	if err != nil {
-		t.Error(err, s.expression)
-	}
-
-	writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", output.String()))
-}

pkg/yqlib/path_tokeniser.go

@@ -172,12 +172,9 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`\(`), literalToken(OpenBracket, false))
 	lexer.Add([]byte(`\)`), literalToken(CloseBracket, true))
 
+	// lexer.Add([]byte(`\.\[\]`), pathToken(false)) // traverseCollect(false)
 	lexer.Add([]byte(`\.\[`), literalToken(TraverseArrayCollect, false))
-	lexer.Add([]byte(`\.\.`), opTokenWithPrefs(RecursiveDescent, nil, &RecursiveDescentPreferences{RecurseArray: true,
+	lexer.Add([]byte(`\.\.`), opToken(RecursiveDescent))
-		TraversePreferences: &TraversePreferences{FollowAlias: false, IncludeMapKeys: false}}))
-
-	lexer.Add([]byte(`\.\.\.`), opTokenWithPrefs(RecursiveDescent, nil, &RecursiveDescentPreferences{RecurseArray: true,
-		TraversePreferences: &TraversePreferences{FollowAlias: false, IncludeMapKeys: true}}))
 
 	lexer.Add([]byte(`,`), opToken(Union))
 	lexer.Add([]byte(`:\s*`), opToken(CreateMap))
@@ -200,7 +197,6 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`alias`), opAssignableToken(GetAlias, AssignAlias))
 	lexer.Add([]byte(`filename`), opToken(GetFilename))
 	lexer.Add([]byte(`fileIndex`), opToken(GetFileIndex))
-	lexer.Add([]byte(`fi`), opToken(GetFileIndex))
 	lexer.Add([]byte(`path`), opToken(GetPath))
 
 	lexer.Add([]byte(`lineComment`), opTokenWithPrefs(GetComment, AssignComment, &CommentOpPreferences{LineComment: true}))
@@ -220,6 +216,8 @@ func initLexer() (*lex.Lexer, error) {
 
 	lexer.Add([]byte(`\s*\|=\s*`), opTokenWithPrefs(Assign, nil, &AssignOpPreferences{true}))
 
+	// lexer.Add([]byte(`\.\[-?[0-9]+\]`), arrayIndextoken(true)) // traverseCollect(true)
+
 	lexer.Add([]byte("( |\t|\n|\r)+"), skip)
 
 	lexer.Add([]byte(`d[0-9]+`), documentToken())

release_instructions.txt

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

scripts/check.sh

@@ -3,12 +3,7 @@
 set -o errexit
 set -o pipefail
 
-if command -v golangci-lint &> /dev/null
+./bin/golangci-lint run --timeout=5m
-then
-    golangci-lint run --timeout=5m
-else
-  ./bin/golangci-lint run --timeout=5m
-fi
 
 # ./bin/golangci-lint \
 #   --tests \

scripts/publish-docker.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -ex
+VERSION="$(git describe --tags --abbrev=0)"
+docker build \
+  --target production \
+  --build-arg VERSION=${VERSION} \
+  -t mikefarah/yq:latest \
+  -t mikefarah/yq:${VERSION} \
+  -t mikefarah/yq:4 \
+  .
+
+trivy image mikefarah/yq:${VERSION}

scripts/release.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+set -ex
+GITHUB_TOKEN="${GITHUB_TOKEN:?missing required input \'GITHUB_TOKEN\'}"
+
+CURRENT="$(git describe --tags --abbrev=0)"
+PREVIOUS="$(git describe --tags --abbrev=0 --always "${CURRENT}"^)"
+OWNER="mikefarah"
+REPO="yq"
+
+release() {
+    github-release release \
+        --user "$OWNER" \
+        --draft \
+        --repo "$REPO" \
+        --tag "$CURRENT"
+}
+
+
+
+release
+

scripts/upload.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+set -ex
+GITHUB_TOKEN="${GITHUB_TOKEN:?missing required input \'GITHUB_TOKEN\'}"
+
+CURRENT="$(git describe --tags --abbrev=0)"
+PREVIOUS="$(git describe --tags --abbrev=0 --always "${CURRENT}"^)"
+OWNER="mikefarah"
+REPO="yq"
+
+upload() {
+    mkdir -p ./build-done
+    while IFS=  read -r -d $'\0'; do
+        file=$REPLY
+        BINARY=$(basename "${file}")
+        echo "--> ${BINARY}"
+        github-release upload \
+            --replace \
+            --user "$OWNER" \
+            --repo "$REPO" \
+            --tag "$CURRENT" \
+            --name "${BINARY}" \
+            --file "$file"
+        mv "$file" "./build-done/${BINARY}"
+    done < <(find ./build -mindepth 1 -maxdepth 1 -print0)
+}
+
+
+upload

snap/snapcraft.yaml

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