Can assign-update tag

README.md

@@ -12,6 +12,8 @@ V4 is now officially released, it's quite different from V3 (sorry for the migra
 
 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).
 
+Support for v3 will cease August 2021, until then, critical bug and security fixes will still get applied if required.
+
 ## Install
 
 ### [Download the latest binary](https://github.com/mikefarah/yq/releases/latest)
@@ -40,11 +42,25 @@ 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:
 ```
 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:
 

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

@@ -31,6 +31,22 @@ 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
@@ -62,6 +78,23 @@ b: &meow purr
 a: *meow
 ```
 
+## 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

pkg/yqlib/doc/Comment Operators.md

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

pkg/yqlib/doc/Document Index.md

@@ -17,6 +17,24 @@ 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
@@ -33,6 +51,22 @@ will output
 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
+```
+will output
+```yaml
+a: frog
+```
+
 ## Print Document Index with matches
 Given a sample.yml file of:
 ```yaml

pkg/yqlib/doc/Style.md

@@ -145,7 +145,7 @@ will output
 {a: cat, b: 5, c: 3.2, e: true}
 ```
 
-## Pretty print
+## 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.
 
 Given a sample.yml file of:
@@ -167,6 +167,22 @@ 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

pkg/yqlib/doc/Tag.md

@@ -22,7 +22,21 @@ will output
 !!seq
 ```
 
-## Convert numbers to strings
+## 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
 Given a sample.yml file of:
 ```yaml
 a: cat

pkg/yqlib/lib.go

@@ -86,6 +86,7 @@ type Operation struct {
 	StringValue   string
 	CandidateNode *CandidateNode // used for Value Path elements
 	Preferences   interface{}
+	UpdateAssign  bool // used for assign ops, when true it means we evaluate the rhs given the lhs (instead of matching nodes)
 }
 
 func CreateValueOperation(value interface{}, stringValue string) *Operation {

pkg/yqlib/operator_add.go

@@ -16,7 +16,7 @@ func createSelfAddOp(rhs *PathTreeNode) *PathTreeNode {
 
 func AddAssignOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	assignmentOp := &Operation{OperationType: Assign}
-	assignmentOp.Preferences = &AssignOpPreferences{true}
+	assignmentOp.UpdateAssign = true
 
 	assignmentOpNode := &PathTreeNode{Operation: assignmentOp, Lhs: pathNode.Lhs, Rhs: createSelfAddOp(pathNode.Rhs)}
 	return d.GetMatchingNodes(matchingNodes, assignmentOpNode)

pkg/yqlib/operator_anchors_aliases.go

@@ -3,20 +3,22 @@ package yqlib
 import (
 	"container/list"
 
-	"gopkg.in/yaml.v3"
+	yaml "gopkg.in/yaml.v3"
 )
 
 func AssignAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 
 	log.Debugf("AssignAlias operator!")
 
-	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
-	if err != nil {
-		return nil, err
-	}
 	aliasName := ""
-	if rhs.Front() != nil {
-		aliasName = rhs.Front().Value.(*CandidateNode).Node.Value
+	if !pathNode.Operation.UpdateAssign {
+		rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+		if err != nil {
+			return nil, err
+		}
+		if rhs.Front() != nil {
+			aliasName = rhs.Front().Value.(*CandidateNode).Node.Value
+		}
 	}
 
 	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
@@ -28,6 +30,17 @@ func AssignAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNod
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debugf("Setting aliasName : %v", candidate.GetKey())
+
+		if pathNode.Operation.UpdateAssign {
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
+			if err != nil {
+				return nil, err
+			}
+			if rhs.Front() != nil {
+				aliasName = rhs.Front().Value.(*CandidateNode).Node.Value
+			}
+		}
+
 		candidate.Node.Kind = yaml.AliasNode
 		candidate.Node.Value = aliasName
 	}
@@ -51,13 +64,16 @@ func AssignAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNo
 
 	log.Debugf("AssignAnchor operator!")
 
-	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
-	if err != nil {
-		return nil, err
-	}
 	anchorName := ""
-	if rhs.Front() != nil {
-		anchorName = rhs.Front().Value.(*CandidateNode).Node.Value
+	if !pathNode.Operation.UpdateAssign {
+		rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+		if err != nil {
+			return nil, err
+		}
+
+		if rhs.Front() != nil {
+			anchorName = rhs.Front().Value.(*CandidateNode).Node.Value
+		}
 	}
 
 	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
@@ -69,6 +85,18 @@ func AssignAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNo
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debugf("Setting anchorName of : %v", candidate.GetKey())
+
+		if pathNode.Operation.UpdateAssign {
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
+			if err != nil {
+				return nil, err
+			}
+
+			if rhs.Front() != nil {
+				anchorName = rhs.Front().Value.(*CandidateNode).Node.Value
+			}
+		}
+
 		candidate.Node.Anchor = anchorName
 	}
 	return matchingNodes, nil

pkg/yqlib/operator_anchors_aliases_test.go

@@ -21,6 +21,14 @@ var anchorOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::a: &foobar cat\n",
 		},
 	},
+	{
+		description: "Set anchor relatively using assign-update",
+		document:    `a: {b: cat}`,
+		expression:  `.a anchor |= .b`,
+		expected: []string{
+			"D0, P[], (doc)::a: &cat {b: cat}\n",
+		},
+	},
 	{
 		description: "Get alias",
 		document:    `{b: &billyBob meow, a: *billyBob}`,
@@ -37,6 +45,14 @@ var anchorOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{b: &meow purr, a: *meow}\n",
 		},
 	},
+	{
+		description: "Set alias relatively using assign-update",
+		document:    `{b: &meow purr, a: {f: meow}}`,
+		expression:  `.a alias |= .f`,
+		expected: []string{
+			"D0, P[], (doc)::{b: &meow purr, a: *meow}\n",
+		},
+	},
 	{
 		description: "Explode alias and anchor",
 		document:    `{f : {a: &a cat, b: *a}}`,

pkg/yqlib/operator_assign.go

@@ -2,26 +2,20 @@ package yqlib
 
 import "container/list"
 
-type AssignOpPreferences struct {
-	UpdateAssign bool
-}
-
 func AssignUpdateOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
 	if err != nil {
 		return nil, err
 	}
-	preferences := pathNode.Operation.Preferences.(*AssignOpPreferences)
-
 	var rhs *list.List
-	if !preferences.UpdateAssign {
+	if !pathNode.Operation.UpdateAssign {
 		rhs, err = d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
 	}
 
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 
-		if preferences.UpdateAssign {
+		if pathNode.Operation.UpdateAssign {
 			rhs, err = d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
 		}
 

pkg/yqlib/operator_collect_object_test.go

@@ -110,5 +110,5 @@ func TestCollectObjectOperatorScenarios(t *testing.T) {
 	for _, tt := range collectObjectOperatorScenarios {
 		testScenario(t, &tt)
 	}
-	documentScenarios(t, "Collect into Object", collectObjectOperatorScenarios)
+	documentScenarios(t, "Create, Collect into Object", collectObjectOperatorScenarios)
 }

pkg/yqlib/operator_comments.go

@@ -4,7 +4,7 @@ import (
 	"container/list"
 	"strings"
 
-	"gopkg.in/yaml.v3"
+	yaml "gopkg.in/yaml.v3"
 )
 
 type CommentOpPreferences struct {
@@ -17,15 +17,6 @@ func AssignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, path
 
 	log.Debugf("AssignComments operator!")
 
-	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
-	if err != nil {
-		return nil, err
-	}
-	comment := ""
-	if rhs.Front() != nil {
-		comment = rhs.Front().Value.(*CandidateNode).Node.Value
-	}
-
 	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
 
 	if err != nil {
@@ -34,8 +25,32 @@ func AssignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, path
 
 	preferences := pathNode.Operation.Preferences.(*CommentOpPreferences)
 
+	comment := ""
+	if !pathNode.Operation.UpdateAssign {
+		rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+		if err != nil {
+			return nil, err
+		}
+
+		if rhs.Front() != nil {
+			comment = rhs.Front().Value.(*CandidateNode).Node.Value
+		}
+	}
+
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
+
+		if pathNode.Operation.UpdateAssign {
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
+			if err != nil {
+				return nil, err
+			}
+
+			if rhs.Front() != nil {
+				comment = rhs.Front().Value.(*CandidateNode).Node.Value
+			}
+		}
+
 		log.Debugf("Setting comment of : %v", candidate.GetKey())
 		if preferences.LineComment {
 			candidate.Node.LineComment = comment

pkg/yqlib/operator_comments_test.go

@@ -13,6 +13,39 @@ var commentOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::a: cat # single\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   "a: cat\nb: dog",
+		expression: `.a lineComment=.b`,
+		expected: []string{
+			"D0, P[], (doc)::a: cat # dog\nb: dog\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   "a: cat\n---\na: dog",
+		expression: `.a lineComment |= documentIndex`,
+		expected: []string{
+			"D0, P[], (doc)::a: cat # 0\n",
+			"D1, P[], (doc)::a: dog # 1\n",
+		},
+	},
+	{
+		description: "Use update assign to perform relative updates",
+		document:    "a: cat\nb: dog",
+		expression:  `.. lineComment |= .`,
+		expected: []string{
+			"D0, P[], (!!map)::a: cat # cat\nb: dog # dog\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   "a: cat\nb: dog",
+		expression: `.. comments |= .`,
+		expected: []string{
+			"D0, P[], (!!map)::a: cat # cat\n# cat\n\n# cat\nb: dog # dog\n# dog\n\n# dog\n",
+		},
+	},
 	{
 		description: "Set head comment",
 		document:    `a: cat`,

pkg/yqlib/operator_document_index_test.go

@@ -14,6 +14,15 @@ var documentIndexScenarios = []expressionScenario{
 			"D1, P[a], (!!int)::1\n",
 		},
 	},
+	{
+		description: "Retrieve a document index, shorthand",
+		document:    "a: cat\n---\na: frog\n",
+		expression:  `.a | di`,
+		expected: []string{
+			"D0, P[a], (!!int)::0\n",
+			"D1, P[a], (!!int)::1\n",
+		},
+	},
 	{
 		description: "Filter by document index",
 		document:    "a: cat\n---\na: frog\n",
@@ -22,6 +31,14 @@ var documentIndexScenarios = []expressionScenario{
 			"D1, P[], (doc)::a: frog\n",
 		},
 	},
+	{
+		description: "Filter by document index shorthand",
+		document:    "a: cat\n---\na: frog\n",
+		expression:  `select(di == 1)`,
+		expected: []string{
+			"D1, P[], (doc)::a: frog\n",
+		},
+	},
 	{
 		description: "Print Document Index with matches",
 		document:    "a: cat\n---\na: frog\n",

pkg/yqlib/operator_multiply.go

@@ -115,7 +115,7 @@ func applyAssignment(d *dataTreeNavigator, pathIndexToStartFrom int, lhs *Candid
 	assignmentOp := &Operation{OperationType: AssignAttributes}
 	if rhs.Node.Kind == yaml.ScalarNode || rhs.Node.Kind == yaml.AliasNode {
 		assignmentOp.OperationType = Assign
-		assignmentOp.Preferences = &AssignOpPreferences{false}
+		assignmentOp.UpdateAssign = false
 	} else if shouldAppendArrays && rhs.Node.Kind == yaml.SequenceNode {
 		assignmentOp.OperationType = AddAssign
 	}

pkg/yqlib/operator_style.go

@@ -4,39 +4,46 @@ import (
 	"container/list"
 	"fmt"
 
-	"gopkg.in/yaml.v3"
+	yaml "gopkg.in/yaml.v3"
 )
 
+func parseStyle(customStyle string) (yaml.Style, error) {
+	if customStyle == "tagged" {
+		return yaml.TaggedStyle, nil
+	} else if customStyle == "double" {
+		return yaml.DoubleQuotedStyle, nil
+	} else if customStyle == "single" {
+		return yaml.SingleQuotedStyle, nil
+	} else if customStyle == "literal" {
+		return yaml.LiteralStyle, nil
+	} else if customStyle == "folded" {
+		return yaml.FoldedStyle, nil
+	} else if customStyle == "flow" {
+		return yaml.FlowStyle, nil
+	} else if customStyle != "" {
+		return 0, fmt.Errorf("Unknown style %v", customStyle)
+	}
+	return 0, nil
+}
+
 func AssignStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 
 	log.Debugf("AssignStyleOperator: %v")
-
-	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
-	if err != nil {
-		return nil, err
-	}
-	customStyle := ""
-
-	if rhs.Front() != nil {
-		customStyle = rhs.Front().Value.(*CandidateNode).Node.Value
-	}
-
 	var style yaml.Style
-	if customStyle == "tagged" {
-		style = yaml.TaggedStyle
-	} else if customStyle == "double" {
-		style = yaml.DoubleQuotedStyle
-	} else if customStyle == "single" {
-		style = yaml.SingleQuotedStyle
-	} else if customStyle == "literal" {
-		style = yaml.LiteralStyle
-	} else if customStyle == "folded" {
-		style = yaml.FoldedStyle
-	} else if customStyle == "flow" {
-		style = yaml.FlowStyle
-	} else if customStyle != "" {
-		return nil, fmt.Errorf("Unknown style %v", customStyle)
+	if !pathNode.Operation.UpdateAssign {
+		rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+		if err != nil {
+			return nil, err
+		}
+
+		if rhs.Front() != nil {
+			style, err = parseStyle(rhs.Front().Value.(*CandidateNode).Node.Value)
+			if err != nil {
+				return nil, err
+			}
+		}
 	}
+
 	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
 
 	if err != nil {
@@ -46,6 +53,20 @@ func AssignStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNod
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debugf("Setting style of : %v", candidate.GetKey())
+		if pathNode.Operation.UpdateAssign {
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
+			if err != nil {
+				return nil, err
+			}
+
+			if rhs.Front() != nil {
+				style, err = parseStyle(rhs.Front().Value.(*CandidateNode).Node.Value)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+
 		candidate.Node.Style = style
 	}
 

pkg/yqlib/operator_style_test.go

@@ -86,7 +86,7 @@ e: >-
 		},
 	},
 	{
-		description:    "Pretty print",
+		description:    "Reset style - or 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.",
 		document:       `{a: cat, "b": 5, 'c': 3.2, "e": true}`,
 		expression:     `... style=""`,
@@ -94,6 +94,14 @@ e: >-
 			"D0, P[], (!!map)::a: cat\nb: 5\nc: 3.2\ne: true\n",
 		},
 	},
+	{
+		description: "Set style relatively with assign-update",
+		document:    `{a: single, b: double}`,
+		expression:  `.[] style |= .`,
+		expected: []string{
+			"D0, P[], (doc)::{a: 'single', b: \"double\"}\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `{a: cat, b: double}`,

pkg/yqlib/operator_tag.go

@@ -3,21 +3,23 @@ package yqlib
 import (
 	"container/list"
 
-	"gopkg.in/yaml.v3"
+	yaml "gopkg.in/yaml.v3"
 )
 
 func AssignTagOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 
 	log.Debugf("AssignTagOperator: %v")
-
-	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
-	if err != nil {
-		return nil, err
-	}
 	tag := ""
 
-	if rhs.Front() != nil {
-		tag = rhs.Front().Value.(*CandidateNode).Node.Value
+	if !pathNode.Operation.UpdateAssign {
+		rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+		if err != nil {
+			return nil, err
+		}
+
+		if rhs.Front() != nil {
+			tag = rhs.Front().Value.(*CandidateNode).Node.Value
+		}
 	}
 
 	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
@@ -29,6 +31,16 @@ func AssignTagOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debugf("Setting tag of : %v", candidate.GetKey())
+		if pathNode.Operation.UpdateAssign {
+			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
+			if err != nil {
+				return nil, err
+			}
+
+			if rhs.Front() != nil {
+				tag = rhs.Front().Value.(*CandidateNode).Node.Value
+			}
+		}
 		candidate.Node.Tag = tag
 	}
 
@@ -42,7 +54,7 @@ func GetTagOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *Pa
 
 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		node := &yaml.Node{Kind: yaml.ScalarNode, Value: candidate.Node.Tag, Tag: "!!str"}
+		node := &yaml.Node{Kind: yaml.ScalarNode, Value: UnwrapDoc(candidate.Node).Tag, Tag: "!!str"}
 		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
 		results.PushBack(lengthCand)
 	}

pkg/yqlib/operator_tag_test.go

@@ -19,13 +19,37 @@ var tagOperatorScenarios = []expressionScenario{
 		},
 	},
 	{
-		description: "Convert numbers to strings",
+		skipDoc:    true,
+		document:   `{a: cat, b: 5, c: 3.2, e: true, f: []}`,
+		expression: `tag`,
+		expected: []string{
+			"D0, P[], (!!str)::'!!map'\n",
+		},
+	},
+	{
+		description: "Set custom tag",
+		document:    `{a: str}`,
+		expression:  `.a tag = "!!mikefarah"`,
+		expected: []string{
+			"D0, P[], (doc)::{a: !!mikefarah str}\n",
+		},
+	},
+	{
+		description: "Find numbers and convert them to strings",
 		document:    `{a: cat, b: 5, c: 3.2, e: true}`,
 		expression:  `(.. | select(tag == "!!int")) tag= "!!str"`,
 		expected: []string{
 			"D0, P[], (!!map)::{a: cat, b: \"5\", c: 3.2, e: true}\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `{a: "!!frog", b: "!!customTag"}`,
+		expression: `.[] tag |= .`,
+		expected: []string{
+			"D0, P[], (doc)::{a: !!frog \"!!frog\", b: !!customTag \"!!customTag\"}\n",
+		},
+	},
 }
 
 func TestTagOperatorScenarios(t *testing.T) {

pkg/yqlib/path_parse_test.go

@@ -137,6 +137,11 @@ var pathTests = []struct {
 		append(make([]interface{}, 0), "SELF", "ASSIGN_COMMENT", "str (string)"),
 		append(make([]interface{}, 0), "SELF", "str (string)", "ASSIGN_COMMENT"),
 	},
+	{
+		`. lineComment |= "str"`,
+		append(make([]interface{}, 0), "SELF", "ASSIGN_COMMENT", "str (string)"),
+		append(make([]interface{}, 0), "SELF", "str (string)", "ASSIGN_COMMENT"),
+	},
 	{
 		`.a.b tag="!!str"`,
 		append(make([]interface{}, 0), "a", "SHORT_PIPE", "b", "ASSIGN_TAG", "!!str (string)"),

pkg/yqlib/path_tokeniser.go

@@ -92,6 +92,15 @@ func opAssignableToken(opType *OperationType, assignOpType *OperationType) lex.A
 	return opTokenWithPrefs(opType, assignOpType, nil)
 }
 
+func assignOpToken(updateAssign bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		log.Debug("assignOpToken %v", string(m.Bytes))
+		value := string(m.Bytes)
+		op := &Operation{OperationType: Assign, Value: Assign.Type, StringValue: value, UpdateAssign: updateAssign}
+		return &Token{TokenType: OperationToken, Operation: op}, nil
+	}
+}
+
 func opTokenWithPrefs(op *OperationType, assignOpType *OperationType, preferences interface{}) lex.Action {
 	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
 		log.Debug("opTokenWithPrefs %v", string(m.Bytes))
@@ -105,6 +114,21 @@ func opTokenWithPrefs(op *OperationType, assignOpType *OperationType, preference
 	}
 }
 
+func assignAllCommentsOp(updateAssign bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		log.Debug("assignAllCommentsOp %v", string(m.Bytes))
+		value := string(m.Bytes)
+		op := &Operation{
+			OperationType: AssignComment,
+			Value:         AssignComment.Type,
+			StringValue:   value,
+			UpdateAssign:  updateAssign,
+			Preferences:   &CommentOpPreferences{LineComment: true, HeadComment: true, FootComment: true},
+		}
+		return &Token{TokenType: OperationToken, Operation: op}, nil
+	}
+}
+
 func literalToken(pType TokenType, checkForPost bool) lex.Action {
 	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
 		return &Token{TokenType: pType, CheckForPostTraverse: checkForPost}, nil
@@ -192,6 +216,7 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`\/\/`), opToken(Alternative))
 
 	lexer.Add([]byte(`documentIndex`), opToken(GetDocumentIndex))
+	lexer.Add([]byte(`di`), opToken(GetDocumentIndex))
 
 	lexer.Add([]byte(`style`), opAssignableToken(GetStyle, AssignStyle))
 
@@ -209,16 +234,17 @@ func initLexer() (*lex.Lexer, error) {
 
 	lexer.Add([]byte(`footComment`), opTokenWithPrefs(GetComment, AssignComment, &CommentOpPreferences{FootComment: true}))
 
-	lexer.Add([]byte(`comments\s*=`), opTokenWithPrefs(AssignComment, nil, &CommentOpPreferences{LineComment: true, HeadComment: true, FootComment: true}))
+	lexer.Add([]byte(`comments\s*=`), assignAllCommentsOp(false))
+	lexer.Add([]byte(`comments\s*\|=`), assignAllCommentsOp(true))
 
 	lexer.Add([]byte(`collect`), opToken(Collect))
 
 	lexer.Add([]byte(`\s*==\s*`), opToken(Equals))
-	lexer.Add([]byte(`\s*=\s*`), opTokenWithPrefs(Assign, nil, &AssignOpPreferences{false}))
+	lexer.Add([]byte(`\s*=\s*`), assignOpToken(false))
 
 	lexer.Add([]byte(`del`), opToken(DeleteChild))
 
-	lexer.Add([]byte(`\s*\|=\s*`), opTokenWithPrefs(Assign, nil, &AssignOpPreferences{true}))
+	lexer.Add([]byte(`\s*\|=\s*`), assignOpToken(true))
 
 	lexer.Add([]byte("( |\t|\n|\r)+"), skip)
 
@@ -325,6 +351,7 @@ func (p *pathTokeniser) handleToken(tokens []*Token, index int, postProcessedTok
 		tokens[index+1].TokenType == OperationToken &&
 		tokens[index+1].Operation.OperationType == Assign {
 		token.Operation = token.AssignOperation
+		token.Operation.UpdateAssign = tokens[index+1].Operation.UpdateAssign
 		skipNextToken = true
 	}