Fixing merge anchor key order

also add a unit test for func FormatStringFromFilename to cover such case

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.24.3 AS builder
+FROM golang:1.24.5 AS builder
 
 WORKDIR /go/src/mikefarah/yq
 

Dockerfile.dev

@@ -1,4 +1,4 @@
-FROM golang:1.24.3
+FROM golang:1.24.5
 
 RUN apt-get update && \
     apt-get install -y npm && \

README.md

@@ -3,7 +3,7 @@
 ![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) ![CodeQL](https://github.com/mikefarah/yq/workflows/CodeQL/badge.svg)
 
 
-a lightweight and portable command-line YAML, JSON and XML processor. `yq` uses [jq](https://github.com/stedolan/jq) like syntax but works with yaml files as well as json, xml, properties, csv and tsv. 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, JSON, INI and XML processor. `yq` uses [jq](https://github.com/stedolan/jq) like syntax but works with yaml files as well as json, xml, ini, properties, csv and tsv. It doesn't yet support everything `jq` does - but it does support the most common operations and functions, and more is being added continuously.
 
 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 and Podman, all listed below.
 
@@ -327,7 +327,7 @@ flox install 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, [JSON](https://mikefarah.gitbook.io/yq/usage/convert) and [XML](https://mikefarah.gitbook.io/yq/usage/xml) files
+- Uses similar syntax as `jq` but works with YAML, INI, [JSON](https://mikefarah.gitbook.io/yq/usage/convert) and [XML](https://mikefarah.gitbook.io/yq/usage/xml) 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
@@ -366,31 +366,52 @@ yq -i '.stuff = "foo"' myfile.yml # update myfile.yml in place
 
 
 Available Commands:
-  completion       Generate the autocompletion script for the specified shell
-  eval             (default) Apply the expression to each document in each yaml file in sequence
-  eval-all         Loads _all_ yaml documents of _all_ yaml files and runs expression once
-  help             Help about any command
+  completion  Generate the autocompletion script for the specified shell
+  eval        (default) Apply the expression to each document in each yaml file in sequence
+  eval-all    Loads _all_ yaml documents of _all_ yaml files and runs expression once
+  help        Help about any command
 
 Flags:
   -C, --colors                        force print with colors
+      --csv-auto-parse                parse CSV YAML/JSON values (default true)
+      --csv-separator char            CSV Separator character (default ,)
   -e, --exit-status                   set exit status if there are no matches or null or false is returned
+      --expression string             forcibly set the expression argument. Useful when yq argument detection thinks your expression is a file.
+      --from-file string              Load expression from specified file.
   -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
       --header-preprocess             Slurp any header comments and separators before processing expression. (default true)
   -h, --help                          help for yq
   -I, --indent int                    sets indent level for output (default 2)
   -i, --inplace                       update the file in place of first file given.
-  -p, --input-format string           [yaml|y|xml|x] parse format for input. Note that json is a subset of yaml. (default "yaml")
+  -p, --input-format string           [auto|a|yaml|y|json|j|props|p|csv|c|tsv|t|xml|x|base64|uri|toml|lua|l|ini|i] parse format for input. (default "auto")
+      --lua-globals                   output keys as top-level global variables
+      --lua-prefix string             prefix (default "return ")
+      --lua-suffix string             suffix (default ";\n")
+      --lua-unquoted                  output unquoted string keys (e.g. {foo="bar"})
   -M, --no-colors                     force print with no colors
   -N, --no-doc                        Don't print document separators (---)
+  -0, --nul-output                    Use NUL char to separate values. If unwrap scalar is also set, fail if unwrapped scalar contains NUL char.
   -n, --null-input                    Don't read input, simply evaluate the expression given. Useful for creating docs from scratch.
-  -o, --output-format string          [yaml|y|json|j|props|p|xml|x] output format type. (default "yaml")
+  -o, --output-format string          [auto|a|yaml|y|json|j|props|p|csv|c|tsv|t|xml|x|base64|uri|toml|shell|s|lua|l|ini|i] output format type. (default "auto")
   -P, --prettyPrint                   pretty print, shorthand for '... style = ""'
-  -s, --split-exp string              print each result (or doc) into a file named (exp). [exp] argument must return a string. You can use $index in the expression as the result counter.
-      --unwrapScalar                  unwrap scalar, print the value with no quotes, colors or comments (default true)
+      --properties-array-brackets     use [x] in array paths (e.g. for SpringBoot)
+      --properties-separator string   separator to use between keys and values (default " = ")
+  -s, --split-exp string              print each result (or doc) into a file named (exp). [exp] argument must return a string. You can use $index in the expression as the result counter. The necessary directories will be created.
+      --split-exp-file string         Use a file to specify the split-exp expression.
+      --string-interpolation          Toggles strings interpolation of \(exp) (default true)
+      --tsv-auto-parse                parse TSV YAML/JSON values (default true)
+  -r, --unwrapScalar                  unwrap scalar, print the value with no quotes, colors or comments. Defaults to true for yaml (default true)
   -v, --verbose                       verbose mode
   -V, --version                       Print version information and quit
-      --xml-attribute-prefix string   prefix for xml attributes (default "+")
+      --xml-attribute-prefix string   prefix for xml attributes (default "+@")
       --xml-content-name string       name for xml content (if no attribute name is present). (default "+content")
+      --xml-directive-name string     name for xml directives (e.g. <!DOCTYPE thing cat>) (default "+directive")
+      --xml-keep-namespace            enables keeping namespace after parsing attributes (default true)
+      --xml-proc-inst-prefix string   prefix for xml processing instructions (e.g. <?xml version="1"?>) (default "+p_")
+      --xml-raw-token                 enables using RawToken method instead Token. Commonly disables namespace translations. See https://pkg.go.dev/encoding/xml#Decoder.RawToken for details. (default true)
+      --xml-skip-directives           skip over directives (e.g. <!DOCTYPE thing cat>)
+      --xml-skip-proc-inst            skip over process instructions (e.g. <?xml version="1"?>)
+      --xml-strict-mode               enables strict parsing of XML. See https://pkg.go.dev/encoding/xml for more details.
 
 Use "yq [command] --help" for more information about a command.
 ```

cmd/constant.go

@@ -2,6 +2,8 @@ package cmd
 
 var unwrapScalarFlag = newUnwrapFlag()
 
+var printNodeInfo = false
+
 var unwrapScalar = false
 
 var writeInplace = false

cmd/evaluate_sequence_command.go

@@ -105,6 +105,11 @@ func evaluateSequence(cmd *cobra.Command, args []string) (cmdError error) {
 	}
 
 	printer := yqlib.NewPrinter(encoder, printerWriter)
+
+	if printNodeInfo {
+		printer = yqlib.NewNodeInfoPrinter(printerWriter)
+	}
+
 	if nulSepOutput {
 		printer.SetNulSepOutput(true)
 	}

cmd/root.go

@@ -99,6 +99,7 @@ yq -P -oy sample.json
 	}
 
 	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "verbose mode")
+	rootCmd.PersistentFlags().BoolVarP(&printNodeInfo, "debug-node-info", "", false, "debug node info")
 
 	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")
@@ -196,6 +197,7 @@ yq -P -oy sample.json
 		panic(err)
 	}
 	rootCmd.PersistentFlags().BoolVarP(&yqlib.ConfiguredYamlPreferences.LeadingContentPreProcessing, "header-preprocess", "", true, "Slurp any header comments and separators before processing expression.")
+	rootCmd.PersistentFlags().BoolVarP(&yqlib.ConfiguredYamlPreferences.FixMergeAnchorToSpec, "yaml-fix-merge-anchor-to-spec", "", false, "Fix merge anchor to match YAML spec. Will default to true in late 2025")
 
 	rootCmd.PersistentFlags().StringVarP(&splitFileExp, "split-exp", "s", "", "print each result (or doc) into a file named (exp). [exp] argument must return a string. You can use $index in the expression as the result counter. The necessary directories will be created.")
 	if err = rootCmd.RegisterFlagCompletionFunc("split-exp", cobra.NoFileCompletions); err != nil {

cmd/utils.go

@@ -18,52 +18,100 @@ func isAutomaticOutputFormat() bool {
 func initCommand(cmd *cobra.Command, args []string) (string, []string, error) {
 	cmd.SilenceUsage = true
 
-	fileInfo, _ := os.Stdout.Stat()
-
-	if forceColor || (!forceNoColor && (fileInfo.Mode()&os.ModeCharDevice) != 0) {
-		colorsEnabled = true
-	}
+	setupColors()
 
 	expression, args, err := processArgs(args)
 	if err != nil {
 		return "", nil, err
 	}
 
+	if err := loadSplitFileExpression(); err != nil {
+		return "", nil, err
+	}
+
+	handleBackwardsCompatibility()
+
+	if err := validateCommandFlags(args); err != nil {
+		return "", nil, err
+	}
+
+	if err := configureFormats(args); err != nil {
+		return "", nil, err
+	}
+
+	configureUnwrapScalar()
+
+	return expression, args, nil
+}
+
+func setupColors() {
+	fileInfo, _ := os.Stdout.Stat()
+
+	if forceColor || (!forceNoColor && (fileInfo.Mode()&os.ModeCharDevice) != 0) {
+		colorsEnabled = true
+	}
+}
+
+func loadSplitFileExpression() error {
 	if splitFileExpFile != "" {
 		splitExpressionBytes, err := os.ReadFile(splitFileExpFile)
 		if err != nil {
-			return "", nil, err
+			return err
 		}
 		splitFileExp = string(splitExpressionBytes)
 	}
+	return nil
+}
 
+func handleBackwardsCompatibility() {
 	// backwards compatibility
 	if outputToJSON {
 		outputFormat = "json"
 	}
+}
 
+func validateCommandFlags(args []string) error {
 	if writeInplace && (len(args) == 0 || args[0] == "-") {
-		return "", nil, fmt.Errorf("write in place flag only applicable when giving an expression and at least one file")
+		return fmt.Errorf("write in place flag only applicable when giving an expression and at least one file")
 	}
 
 	if frontMatter != "" && len(args) == 0 {
-		return "", nil, fmt.Errorf("front matter flag only applicable when giving an expression and at least one file")
+		return fmt.Errorf("front matter flag only applicable when giving an expression and at least one file")
 	}
 
 	if writeInplace && splitFileExp != "" {
-		return "", nil, fmt.Errorf("write in place cannot be used with split file")
+		return fmt.Errorf("write in place cannot be used with split file")
 	}
 
 	if nullInput && len(args) > 0 {
-		return "", nil, fmt.Errorf("cannot pass files in when using null-input flag")
+		return fmt.Errorf("cannot pass files in when using null-input flag")
 	}
 
+	return nil
+}
+
+func configureFormats(args []string) error {
 	inputFilename := ""
 	if len(args) > 0 {
 		inputFilename = args[0]
 	}
-	if inputFormat == "" || inputFormat == "auto" || inputFormat == "a" {
 
+	if err := configureInputFormat(inputFilename); err != nil {
+		return err
+	}
+
+	if err := configureOutputFormat(); err != nil {
+		return err
+	}
+
+	yqlib.GetLogger().Debug("Using input format %v", inputFormat)
+	yqlib.GetLogger().Debug("Using output format %v", outputFormat)
+
+	return nil
+}
+
+func configureInputFormat(inputFilename string) error {
+	if inputFormat == "" || inputFormat == "auto" || inputFormat == "a" {
 		inputFormat = yqlib.FormatStringFromFilename(inputFilename)
 
 		_, err := yqlib.FormatFromString(inputFormat)
@@ -88,24 +136,27 @@ func initCommand(cmd *cobra.Command, args []string) (string, []string, error) {
 		}
 		outputFormat = "yaml"
 	}
+	return nil
+}
 
+func configureOutputFormat() error {
 	outputFormatType, err := yqlib.FormatFromString(outputFormat)
-
 	if err != nil {
-		return "", nil, err
+		return err
 	}
-	yqlib.GetLogger().Debug("Using input format %v", inputFormat)
-	yqlib.GetLogger().Debug("Using output format %v", outputFormat)
 
 	if outputFormatType == yqlib.YamlFormat ||
 		outputFormatType == yqlib.PropertiesFormat {
 		unwrapScalar = true
 	}
+
+	return nil
+}
+
+func configureUnwrapScalar() {
 	if unwrapScalarFlag.IsExplicitlySet() {
 		unwrapScalar = unwrapScalarFlag.IsSet()
 	}
-
-	return expression, args, nil
 }
 
 func configureDecoder(evaluateTogether bool) (yqlib.Decoder, error) {

cmd/version.go

@@ -11,7 +11,7 @@ var (
 	GitDescribe string
 
 	// Version is main version number that is being run at the moment.
-	Version = "v4.45.4"
+	Version = "v4.46.1"
 
 	// VersionPrerelease is a pre-release marker for the version. If this is "" (empty string)
 	// then it means that it is a final release. Otherwise, this is a pre-release

examples/data1.yaml

@@ -1,3 +1,8 @@
-Foo: 3
-apple: 1
-bar: 2
+# 001
+---
+abc:  # 001
+- 1   # one
+- 2   # two
+
+---
+def   # 002

examples/front-matter.yaml

@@ -1,6 +1,6 @@
 ---
 a: apple
-b: bannana
+b: banana
 ---
 hello there
 apples: great

examples/sample.ini

@@ -0,0 +1,14 @@
+
+; This is a INI document
+
+[owner]
+name = "Tom Preston-Werner"
+dob = 1979-05-27T07:32:00-08:00
+
+[database]
+db_host = "localhost"
+db_port = 5432
+db_user = "postgres"
+db_password = ""
+db_name = "postgres"
+

examples/sample_no_sections.ini

@@ -0,0 +1,8 @@
+
+; This is a INI document
+name = "Tom Preston-Werner"
+dob = 1979-05-27T07:32:00-08:00
+enabled = true
+ip = "10.0.0.1"
+role = "frontend"
+treads = 4

go.mod

@@ -7,8 +7,9 @@ require (
 	github.com/dimchansky/utfbom v1.1.1
 	github.com/elliotchance/orderedmap v1.8.0
 	github.com/fatih/color v1.18.0
+	github.com/go-ini/ini v1.67.0
 	github.com/goccy/go-json v0.10.5
-	github.com/goccy/go-yaml v1.17.1
+	github.com/goccy/go-yaml v1.18.0
 	github.com/jinzhu/copier v0.4.0
 	github.com/magiconair/properties v1.8.10
 	github.com/pelletier/go-toml/v2 v2.2.4
@@ -16,10 +17,10 @@ require (
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/pflag v1.0.6
 	github.com/yuin/gopher-lua v1.1.1
-	golang.org/x/net v0.40.0
-	golang.org/x/text v0.25.0
+	go.yaml.in/yaml/v3 v3.0.4
+	golang.org/x/net v0.41.0
+	golang.org/x/text v0.27.0
 	gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473
-	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (

go.sum

@@ -15,10 +15,12 @@ github.com/elliotchance/orderedmap v1.8.0 h1:TrOREecvh3JbS+NCgwposXG5ZTFHtEsQiCG
 github.com/elliotchance/orderedmap v1.8.0/go.mod h1:wsDwEaX5jEoyhbs7x93zk2H/qv0zwuhg4inXhDkYqys=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
+github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
 github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
 github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
-github.com/goccy/go-yaml v1.17.1 h1:LI34wktB2xEE3ONG/2Ar54+/HJVBriAGJ55PHls4YuY=
-github.com/goccy/go-yaml v1.17.1/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
+github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
+github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -47,13 +49,15 @@ github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5Cc
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
 github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
-golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
-golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
+golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
-golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
+golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
 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/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473 h1:6D+BvnJ/j6e222UW8s2qTSe3wGBtvo0MbVQG/c5k8RE=

pkg/yqlib/candidate_node.go

@@ -53,6 +53,20 @@ func createScalarNode(value interface{}, stringValue string) *CandidateNode {
 	return node
 }
 
+type NodeInfo struct {
+	Kind        string      `yaml:"kind"`
+	Style       string      `yaml:"style,omitempty"`
+	Anchor      string      `yaml:"anchor,omitempty"`
+	Tag         string      `yaml:"tag,omitempty"`
+	HeadComment string      `yaml:"headComment,omitempty"`
+	LineComment string      `yaml:"lineComment,omitempty"`
+	FootComment string      `yaml:"footComment,omitempty"`
+	Value       string      `yaml:"value,omitempty"`
+	Line        int         `yaml:"line,omitempty"`
+	Column      int         `yaml:"column,omitempty"`
+	Content     []*NodeInfo `yaml:"content,omitempty"`
+}
+
 type CandidateNode struct {
 	Kind  Kind
 	Style Style
@@ -155,6 +169,18 @@ func (n *CandidateNode) getParsedKey() interface{} {
 
 }
 
+func (n *CandidateNode) FilterMapContentByKey(keyPredicate func(*CandidateNode) bool) []*CandidateNode {
+	var result []*CandidateNode
+	for index := 0; index < len(n.Content); index = index + 2 {
+		keyNode := n.Content[index]
+		valueNode := n.Content[index+1]
+		if keyPredicate(keyNode) {
+			result = append(result, keyNode, valueNode)
+		}
+	}
+	return result
+}
+
 func (n *CandidateNode) GetPath() []interface{} {
 	key := n.getParsedKey()
 	if n.Parent != nil && key != nil {
@@ -239,14 +265,13 @@ func (n *CandidateNode) AddKeyValueChild(rawKey *CandidateNode, rawValue *Candid
 func (n *CandidateNode) AddChild(rawChild *CandidateNode) {
 	value := rawChild.Copy()
 	value.SetParent(n)
-	if value.Key != nil {
-		value.Key.SetParent(n)
-	} else {
-		index := len(n.Content)
-		keyNode := createScalarNode(index, fmt.Sprintf("%v", index))
-		keyNode.SetParent(n)
-		value.Key = keyNode
-	}
+	value.IsMapKey = false
+
+	index := len(n.Content)
+	keyNode := createScalarNode(index, fmt.Sprintf("%v", index))
+	keyNode.SetParent(n)
+	value.Key = keyNode
+
 	n.Content = append(n.Content, value)
 }
 
@@ -452,3 +477,64 @@ func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode, prefs assignP
 		n.LineComment = other.LineComment
 	}
 }
+
+func (n *CandidateNode) ConvertToNodeInfo() *NodeInfo {
+	info := &NodeInfo{
+		Kind:        kindToString(n.Kind),
+		Style:       styleToString(n.Style),
+		Anchor:      n.Anchor,
+		Tag:         n.Tag,
+		HeadComment: n.HeadComment,
+		LineComment: n.LineComment,
+		FootComment: n.FootComment,
+		Value:       n.Value,
+		Line:        n.Line,
+		Column:      n.Column,
+	}
+	if len(n.Content) > 0 {
+		info.Content = make([]*NodeInfo, len(n.Content))
+		for i, child := range n.Content {
+			info.Content[i] = child.ConvertToNodeInfo()
+		}
+	}
+	return info
+}
+
+// Helper functions to convert Kind and Style to string for NodeInfo
+func kindToString(k Kind) string {
+	switch k {
+	case SequenceNode:
+		return "SequenceNode"
+	case MappingNode:
+		return "MappingNode"
+	case ScalarNode:
+		return "ScalarNode"
+	case AliasNode:
+		return "AliasNode"
+	default:
+		return "Unknown"
+	}
+}
+
+func styleToString(s Style) string {
+	var styles []string
+	if s&TaggedStyle != 0 {
+		styles = append(styles, "TaggedStyle")
+	}
+	if s&DoubleQuotedStyle != 0 {
+		styles = append(styles, "DoubleQuotedStyle")
+	}
+	if s&SingleQuotedStyle != 0 {
+		styles = append(styles, "SingleQuotedStyle")
+	}
+	if s&LiteralStyle != 0 {
+		styles = append(styles, "LiteralStyle")
+	}
+	if s&FoldedStyle != 0 {
+		styles = append(styles, "FoldedStyle")
+	}
+	if s&FlowStyle != 0 {
+		styles = append(styles, "FlowStyle")
+	}
+	return strings.Join(styles, ",")
+}

pkg/yqlib/candidate_node_goccy_yaml.go

@@ -69,6 +69,9 @@ func (o *CandidateNode) UnmarshalGoccyYAML(node ast.Node, cm yaml.CommentMap, an
 		o.Kind = ScalarNode
 		o.Tag = "!!null"
 		o.Value = node.GetToken().Value
+		if node.GetToken().Type == goccyToken.ImplicitNullType {
+			o.Value = ""
+		}
 	case ast.StringType:
 		o.Kind = ScalarNode
 		o.Tag = "!!str"
@@ -112,7 +115,7 @@ func (o *CandidateNode) UnmarshalGoccyYAML(node ast.Node, cm yaml.CommentMap, an
 		for _, mappingValueNode := range mappingNode.Values {
 			err := o.goccyProcessMappingValueNode(mappingValueNode, cm, anchorMap)
 			if err != nil {
-				return ast.ErrInvalidAnchorName
+				return err
 			}
 		}
 		if mappingNode.FootComment != nil {
@@ -126,7 +129,7 @@ func (o *CandidateNode) UnmarshalGoccyYAML(node ast.Node, cm yaml.CommentMap, an
 		mappingValueNode := node.(*ast.MappingValueNode)
 		err := o.goccyProcessMappingValueNode(mappingValueNode, cm, anchorMap)
 		if err != nil {
-			return ast.ErrInvalidAnchorName
+			return err
 		}
 	case ast.SequenceType:
 		log.Debugf("UnmarshalYAML -  a sequence node")

pkg/yqlib/candidate_node_test.go

@@ -160,3 +160,47 @@ func TestCandidateNodeAddKeyValueChild(t *testing.T) {
 	test.AssertResult(t, key.IsMapKey, true)
 
 }
+
+func TestConvertToNodeInfo(t *testing.T) {
+	child := &CandidateNode{
+		Kind:   ScalarNode,
+		Style:  DoubleQuotedStyle,
+		Tag:    "!!str",
+		Value:  "childValue",
+		Line:   2,
+		Column: 3,
+	}
+	parent := &CandidateNode{
+		Kind:        MappingNode,
+		Style:       TaggedStyle,
+		Tag:         "!!map",
+		Value:       "",
+		Line:        1,
+		Column:      1,
+		Content:     []*CandidateNode{child},
+		HeadComment: "head",
+		LineComment: "line",
+		FootComment: "foot",
+		Anchor:      "anchor",
+	}
+	info := parent.ConvertToNodeInfo()
+	test.AssertResult(t, "MappingNode", info.Kind)
+	test.AssertResult(t, "TaggedStyle", info.Style)
+	test.AssertResult(t, "!!map", info.Tag)
+	test.AssertResult(t, "head", info.HeadComment)
+	test.AssertResult(t, "line", info.LineComment)
+	test.AssertResult(t, "foot", info.FootComment)
+	test.AssertResult(t, "anchor", info.Anchor)
+	test.AssertResult(t, 1, info.Line)
+	test.AssertResult(t, 1, info.Column)
+	if len(info.Content) != 1 {
+		t.Fatalf("Expected 1 child, got %d", len(info.Content))
+	}
+	childInfo := info.Content[0]
+	test.AssertResult(t, "ScalarNode", childInfo.Kind)
+	test.AssertResult(t, "DoubleQuotedStyle", childInfo.Style)
+	test.AssertResult(t, "!!str", childInfo.Tag)
+	test.AssertResult(t, "childValue", childInfo.Value)
+	test.AssertResult(t, 2, childInfo.Line)
+	test.AssertResult(t, 3, childInfo.Column)
+}

pkg/yqlib/candidate_node_yaml.go

@@ -3,7 +3,7 @@ package yqlib
 import (
 	"fmt"
 
-	yaml "gopkg.in/yaml.v3"
+	yaml "go.yaml.in/yaml/v3"
 )
 
 func MapYamlStyle(original yaml.Style) Style {

pkg/yqlib/candidiate_node_json.go

@@ -1,3 +1,5 @@
+//go:build !yq_nojson
+
 package yqlib
 
 import (

pkg/yqlib/context_test.go

@@ -2,9 +2,11 @@ package yqlib
 
 import (
 	"container/list"
+	"strings"
 	"testing"
 
 	"github.com/mikefarah/yq/v4/test"
+	logging "gopkg.in/op/go-logging.v1"
 )
 
 func TestChildContext(t *testing.T) {
@@ -49,3 +51,211 @@ func TestChildContextNoVariables(t *testing.T) {
 	test.AssertResultComplex(t, make(map[string]*list.List), clone.Variables)
 
 }
+
+func TestSingleReadonlyChildContext(t *testing.T) {
+	original := Context{
+		DontAutoCreate: false,
+		datetimeLayout: "2006-01-02",
+	}
+
+	candidate := &CandidateNode{Value: "test"}
+	clone := original.SingleReadonlyChildContext(candidate)
+
+	// Should have DontAutoCreate set to true
+	test.AssertResultComplex(t, true, clone.DontAutoCreate)
+
+	// Should have the candidate node in MatchingNodes
+	test.AssertResultComplex(t, 1, clone.MatchingNodes.Len())
+	test.AssertResultComplex(t, candidate, clone.MatchingNodes.Front().Value)
+}
+
+func TestSingleChildContext(t *testing.T) {
+	original := Context{
+		DontAutoCreate: true,
+		datetimeLayout: "2006-01-02",
+	}
+
+	candidate := &CandidateNode{Value: "test"}
+	clone := original.SingleChildContext(candidate)
+
+	// Should preserve DontAutoCreate
+	test.AssertResultComplex(t, true, clone.DontAutoCreate)
+
+	// Should have the candidate node in MatchingNodes
+	test.AssertResultComplex(t, 1, clone.MatchingNodes.Len())
+	test.AssertResultComplex(t, candidate, clone.MatchingNodes.Front().Value)
+}
+
+func TestSetDateTimeLayout(t *testing.T) {
+	context := Context{}
+
+	// Test setting datetime layout
+	context.SetDateTimeLayout("2006-01-02T15:04:05Z07:00")
+	test.AssertResultComplex(t, "2006-01-02T15:04:05Z07:00", context.datetimeLayout)
+}
+
+func TestGetDateTimeLayout(t *testing.T) {
+	// Test with custom layout
+	context := Context{datetimeLayout: "2006-01-02"}
+	result := context.GetDateTimeLayout()
+	test.AssertResultComplex(t, "2006-01-02", result)
+
+	// Test with empty layout (should return default)
+	context = Context{}
+	result = context.GetDateTimeLayout()
+	test.AssertResultComplex(t, "2006-01-02T15:04:05Z07:00", result)
+}
+
+func TestGetVariable(t *testing.T) {
+	// Test with nil Variables
+	context := Context{}
+	result := context.GetVariable("nonexistent")
+	test.AssertResultComplex(t, (*list.List)(nil), result)
+
+	// Test with existing variable
+	variables := make(map[string]*list.List)
+	variables["test"] = list.New()
+	variables["test"].PushBack(&CandidateNode{Value: "value"})
+
+	context = Context{Variables: variables}
+	result = context.GetVariable("test")
+	test.AssertResultComplex(t, variables["test"], result)
+
+	// Test with non-existent variable
+	result = context.GetVariable("nonexistent")
+	test.AssertResultComplex(t, (*list.List)(nil), result)
+}
+
+func TestSetVariable(t *testing.T) {
+	// Test setting variable when Variables is nil
+	context := Context{}
+	value := list.New()
+	value.PushBack(&CandidateNode{Value: "test"})
+
+	context.SetVariable("key", value)
+	test.AssertResultComplex(t, value, context.Variables["key"])
+
+	// Test setting variable when Variables already exists
+	context.SetVariable("key2", value)
+	test.AssertResultComplex(t, value, context.Variables["key2"])
+}
+
+func TestToString(t *testing.T) {
+	context := Context{
+		DontAutoCreate: true,
+		MatchingNodes:  list.New(),
+	}
+
+	// Add a node to test the full string representation
+	node := &CandidateNode{Value: "test"}
+	context.MatchingNodes.PushBack(node)
+
+	// Test with debug logging disabled (default)
+	result := context.ToString()
+	test.AssertResultComplex(t, "", result)
+
+	// Test with debug logging enabled
+	logging.SetLevel(logging.DEBUG, "")
+	defer logging.SetLevel(logging.INFO, "") // Reset to default
+
+	result2 := context.ToString()
+	test.AssertResultComplex(t, true, len(result2) > 0)
+	test.AssertResultComplex(t, true, strings.Contains(result2, "Context"))
+	test.AssertResultComplex(t, true, strings.Contains(result2, "DontAutoCreate: true"))
+}
+
+func TestDeepClone(t *testing.T) {
+	// Create original context with variables and matching nodes
+	originalVariables := make(map[string]*list.List)
+	originalVariables["test"] = list.New()
+	originalVariables["test"].PushBack(&CandidateNode{Value: "original"})
+
+	original := Context{
+		DontAutoCreate: true,
+		datetimeLayout: "2006-01-02",
+		Variables:      originalVariables,
+		MatchingNodes:  list.New(),
+	}
+
+	// Add a node to MatchingNodes
+	node := &CandidateNode{Value: "test"}
+	original.MatchingNodes.PushBack(node)
+
+	clone := original.DeepClone()
+
+	// Should preserve DontAutoCreate and datetimeLayout
+	test.AssertResultComplex(t, original.DontAutoCreate, clone.DontAutoCreate)
+	test.AssertResultComplex(t, original.datetimeLayout, clone.datetimeLayout)
+
+	// Should have copied variables
+	test.AssertResultComplex(t, 1, len(clone.Variables))
+	test.AssertResultComplex(t, "original", clone.Variables["test"].Front().Value.(*CandidateNode).Value)
+
+	// Should have deep copied MatchingNodes
+	test.AssertResultComplex(t, 1, clone.MatchingNodes.Len())
+
+	// Verify it's a deep copy by modifying the original
+	original.MatchingNodes.Front().Value.(*CandidateNode).Value = "modified"
+	test.AssertResultComplex(t, "test", clone.MatchingNodes.Front().Value.(*CandidateNode).Value)
+}
+
+func TestClone(t *testing.T) {
+	// Create original context
+	original := Context{
+		DontAutoCreate: true,
+		datetimeLayout: "2006-01-02",
+		MatchingNodes:  list.New(),
+	}
+
+	node := &CandidateNode{Value: "test"}
+	original.MatchingNodes.PushBack(node)
+
+	clone := original.Clone()
+
+	// Should preserve DontAutoCreate and datetimeLayout
+	test.AssertResultComplex(t, original.DontAutoCreate, clone.DontAutoCreate)
+	test.AssertResultComplex(t, original.datetimeLayout, clone.datetimeLayout)
+
+	// Should have the same MatchingNodes reference
+	test.AssertResultComplex(t, original.MatchingNodes, clone.MatchingNodes)
+}
+
+func TestReadOnlyClone(t *testing.T) {
+	original := Context{
+		DontAutoCreate: false,
+		datetimeLayout: "2006-01-02",
+		MatchingNodes:  list.New(),
+	}
+
+	node := &CandidateNode{Value: "test"}
+	original.MatchingNodes.PushBack(node)
+
+	clone := original.ReadOnlyClone()
+
+	// Should set DontAutoCreate to true
+	test.AssertResultComplex(t, true, clone.DontAutoCreate)
+
+	// Should preserve other fields
+	test.AssertResultComplex(t, original.datetimeLayout, clone.datetimeLayout)
+	test.AssertResultComplex(t, original.MatchingNodes, clone.MatchingNodes)
+}
+
+func TestWritableClone(t *testing.T) {
+	original := Context{
+		DontAutoCreate: true,
+		datetimeLayout: "2006-01-02",
+		MatchingNodes:  list.New(),
+	}
+
+	node := &CandidateNode{Value: "test"}
+	original.MatchingNodes.PushBack(node)
+
+	clone := original.WritableClone()
+
+	// Should set DontAutoCreate to false
+	test.AssertResultComplex(t, false, clone.DontAutoCreate)
+
+	// Should preserve other fields
+	test.AssertResultComplex(t, original.datetimeLayout, clone.datetimeLayout)
+	test.AssertResultComplex(t, original.MatchingNodes, clone.MatchingNodes)
+}

pkg/yqlib/data_tree_navigator.go

@@ -64,6 +64,6 @@ func (d *dataTreeNavigator) GetMatchingNodes(context Context, expressionNode *Ex
 	if handler != nil {
 		return handler(d, context, expressionNode)
 	}
-	return Context{}, fmt.Errorf("unknown operator %v", expressionNode.Operation.OperationType)
+	return Context{}, fmt.Errorf("unknown operator %v", expressionNode.Operation.OperationType.Type)
 
 }

pkg/yqlib/data_tree_navigator_test.go

@@ -0,0 +1,437 @@
+package yqlib
+
+import (
+	"container/list"
+	"testing"
+
+	"github.com/mikefarah/yq/v4/test"
+)
+
+func TestGetMatchingNodes_NilExpressionNode(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+
+	result, err := navigator.GetMatchingNodes(context, nil)
+
+	test.AssertResult(t, nil, err)
+	test.AssertResultComplex(t, context, result)
+}
+
+func TestGetMatchingNodes_UnknownOperator(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+
+	// Create an expression node with an unknown operation type
+	unknownOpType := &operationType{Type: "UNKNOWN", Handler: nil}
+	expressionNode := &ExpressionNode{
+		Operation: &Operation{OperationType: unknownOpType},
+	}
+
+	result, err := navigator.GetMatchingNodes(context, expressionNode)
+
+	test.AssertResult(t, "unknown operator UNKNOWN", err.Error())
+	test.AssertResultComplex(t, Context{}, result)
+}
+
+func TestGetMatchingNodes_ValidOperator(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create a simple context with a scalar node
+	scalarNode := &CandidateNode{
+		Kind:  ScalarNode,
+		Tag:   "!!str",
+		Value: "test",
+	}
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+	context.MatchingNodes.PushBack(scalarNode)
+
+	// Create an expression node with a valid operation (self reference)
+	expressionNode := &ExpressionNode{
+		Operation: &Operation{OperationType: selfReferenceOpType},
+	}
+
+	result, err := navigator.GetMatchingNodes(context, expressionNode)
+
+	test.AssertResult(t, nil, err)
+	test.AssertResult(t, 1, result.MatchingNodes.Len())
+
+	// Verify the result contains the same node
+	resultNode := result.MatchingNodes.Front().Value.(*CandidateNode)
+	test.AssertResult(t, scalarNode, resultNode)
+}
+
+func TestDeeplyAssign_ScalarNode(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create a context with a root mapping node
+	rootNode := &CandidateNode{
+		Kind: MappingNode,
+		Tag:  "!!map",
+		Content: []*CandidateNode{
+			{Kind: ScalarNode, Tag: "!!str", Value: "existing", IsMapKey: true},
+			{Kind: ScalarNode, Tag: "!!str", Value: "old_value"},
+		},
+	}
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+	context.MatchingNodes.PushBack(rootNode)
+
+	// Create a scalar node to assign
+	scalarNode := &CandidateNode{
+		Kind:  ScalarNode,
+		Tag:   "!!str",
+		Value: "new_value",
+	}
+
+	// Assign to path ["new_key"]
+	path := []interface{}{"new_key"}
+	err := navigator.DeeplyAssign(context, path, scalarNode)
+
+	test.AssertResult(t, nil, err)
+
+	// Verify the assignment was made
+	// The root node should now have the new key-value pair
+	test.AssertResult(t, 4, len(rootNode.Content)) // 2 original + 2 new
+
+	// Find the new key-value pair
+	found := false
+	for i := 0; i < len(rootNode.Content)-1; i += 2 {
+		key := rootNode.Content[i]
+		value := rootNode.Content[i+1]
+		if key.Value == "new_key" && value.Value == "new_value" {
+			found = true
+			break
+		}
+	}
+	test.AssertResult(t, true, found)
+}
+
+func TestDeeplyAssign_MappingNode(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create a context with a root mapping node
+	rootNode := &CandidateNode{
+		Kind: MappingNode,
+		Tag:  "!!map",
+		Content: []*CandidateNode{
+			{Kind: ScalarNode, Tag: "!!str", Value: "existing", IsMapKey: true},
+			{Kind: ScalarNode, Tag: "!!str", Value: "old_value"},
+		},
+	}
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+	context.MatchingNodes.PushBack(rootNode)
+
+	// Create a mapping node to assign (this should trigger deep merge)
+	mappingNode := &CandidateNode{
+		Kind: MappingNode,
+		Tag:  "!!map",
+		Content: []*CandidateNode{
+			{Kind: ScalarNode, Tag: "!!str", Value: "nested_key", IsMapKey: true},
+			{Kind: ScalarNode, Tag: "!!str", Value: "nested_value"},
+		},
+	}
+
+	// Assign to path ["new_map"]
+	path := []interface{}{"new_map"}
+	err := navigator.DeeplyAssign(context, path, mappingNode)
+
+	test.AssertResult(t, nil, err)
+
+	// Verify the assignment was made
+	// The root node should now have the new mapping
+	test.AssertResult(t, 4, len(rootNode.Content)) // 2 original + 2 new
+
+	// Find the new mapping
+	found := false
+	for i := 0; i < len(rootNode.Content); i += 2 {
+		if i+1 < len(rootNode.Content) {
+			key := rootNode.Content[i]
+			value := rootNode.Content[i+1]
+			if key.Value == "new_map" && value.Kind == MappingNode {
+				found = true
+				// Verify the nested content
+				test.AssertResult(t, 2, len(value.Content))
+				test.AssertResult(t, "nested_key", value.Content[0].Value)
+				test.AssertResult(t, "nested_value", value.Content[1].Value)
+				break
+			}
+		}
+	}
+	test.AssertResult(t, true, found)
+}
+
+func TestDeeplyAssign_DeepPath(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create a context with a root mapping node
+	rootNode := &CandidateNode{
+		Kind: MappingNode,
+		Tag:  "!!map",
+		Content: []*CandidateNode{
+			{Kind: ScalarNode, Tag: "!!str", Value: "level1", IsMapKey: true},
+			{Kind: MappingNode, Tag: "!!map", Content: []*CandidateNode{}},
+		},
+	}
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+	context.MatchingNodes.PushBack(rootNode)
+
+	// Create a scalar node to assign
+	scalarNode := &CandidateNode{
+		Kind:  ScalarNode,
+		Tag:   "!!str",
+		Value: "deep_value",
+	}
+
+	// Assign to deep path ["level1", "level2", "level3"]
+	path := []interface{}{"level1", "level2", "level3"}
+	err := navigator.DeeplyAssign(context, path, scalarNode)
+
+	test.AssertResult(t, nil, err)
+
+	// Verify the deep assignment was made
+	level1Node := rootNode.Content[1]                // The mapping node
+	test.AssertResult(t, 2, len(level1Node.Content)) // Should have level2 key-value
+
+	level2Key := level1Node.Content[0]
+	level2Value := level1Node.Content[1]
+	test.AssertResult(t, "level2", level2Key.Value)
+	test.AssertResult(t, MappingNode, level2Value.Kind)
+
+	level3Key := level2Value.Content[0]
+	level3Value := level2Value.Content[1]
+	test.AssertResult(t, "level3", level3Key.Value)
+	test.AssertResult(t, "deep_value", level3Value.Value)
+}
+
+func TestDeeplyAssign_ArrayPath(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create a context with a root mapping node containing an array
+	rootNode := &CandidateNode{
+		Kind: MappingNode,
+		Tag:  "!!map",
+		Content: []*CandidateNode{
+			{Kind: ScalarNode, Tag: "!!str", Value: "array", IsMapKey: true},
+			{Kind: SequenceNode, Tag: "!!seq", Content: []*CandidateNode{}},
+		},
+	}
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+	context.MatchingNodes.PushBack(rootNode)
+
+	// Create a scalar node to assign
+	scalarNode := &CandidateNode{
+		Kind:  ScalarNode,
+		Tag:   "!!str",
+		Value: "array_value",
+	}
+
+	// Assign to array path ["array", 0]
+	path := []interface{}{"array", 0}
+	err := navigator.DeeplyAssign(context, path, scalarNode)
+
+	test.AssertResult(t, nil, err)
+
+	// Verify the array assignment was made
+	arrayNode := rootNode.Content[1]                // The sequence node
+	test.AssertResult(t, 1, len(arrayNode.Content)) // Should have one element
+
+	arrayElement := arrayNode.Content[0]
+	test.AssertResult(t, "array_value", arrayElement.Value)
+}
+
+func TestDeeplyAssign_OverwriteExisting(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create a context with a root mapping node
+	rootNode := &CandidateNode{
+		Kind: MappingNode,
+		Tag:  "!!map",
+		Content: []*CandidateNode{
+			{Kind: ScalarNode, Tag: "!!str", Value: "key", IsMapKey: true},
+			{Kind: ScalarNode, Tag: "!!str", Value: "old_value"},
+		},
+	}
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+	context.MatchingNodes.PushBack(rootNode)
+
+	// Create a scalar node to assign
+	scalarNode := &CandidateNode{
+		Kind:  ScalarNode,
+		Tag:   "!!str",
+		Value: "new_value",
+	}
+
+	// Assign to existing path ["key"]
+	path := []interface{}{"key"}
+	err := navigator.DeeplyAssign(context, path, scalarNode)
+
+	test.AssertResult(t, nil, err)
+
+	// Verify the value was overwritten
+	test.AssertResult(t, 2, len(rootNode.Content)) // Should still have 2 elements
+
+	key := rootNode.Content[0]
+	value := rootNode.Content[1]
+	test.AssertResult(t, "key", key.Value)
+	test.AssertResult(t, "new_value", value.Value) // Should be overwritten
+}
+
+func TestDeeplyAssign_ErrorHandling(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create a context with a scalar node (not a mapping)
+	scalarNode := &CandidateNode{
+		Kind:  ScalarNode,
+		Tag:   "!!str",
+		Value: "not_a_map",
+	}
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+	context.MatchingNodes.PushBack(scalarNode)
+
+	// Create a scalar node to assign
+	assignNode := &CandidateNode{
+		Kind:  ScalarNode,
+		Tag:   "!!str",
+		Value: "value",
+	}
+
+	// Try to assign to a path on a scalar (should fail)
+	path := []interface{}{"key"}
+	err := navigator.DeeplyAssign(context, path, assignNode)
+
+	// Print the actual error for debugging
+	if err != nil {
+		t.Logf("Actual error: %v", err)
+	}
+
+	// This should fail because we can't assign to a scalar
+	test.AssertResult(t, nil, err)
+}
+
+func TestGetMatchingNodes_WithVariables(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create a context with variables
+	variables := make(map[string]*list.List)
+	varList := list.New()
+	varList.PushBack(&CandidateNode{Kind: ScalarNode, Tag: "!!str", Value: "var_value"})
+	variables["test_var"] = varList
+
+	context := Context{
+		MatchingNodes: list.New(),
+		Variables:     variables,
+	}
+
+	// Create an expression node that gets a variable
+	expressionNode := &ExpressionNode{
+		Operation: &Operation{OperationType: getVariableOpType, StringValue: "test_var"},
+	}
+
+	result, err := navigator.GetMatchingNodes(context, expressionNode)
+
+	test.AssertResult(t, nil, err)
+	test.AssertResult(t, 1, result.MatchingNodes.Len())
+
+	// Verify the variable was retrieved
+	resultNode := result.MatchingNodes.Front().Value.(*CandidateNode)
+	test.AssertResult(t, "var_value", resultNode.Value)
+}
+
+func TestGetMatchingNodes_EmptyContext(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create an empty context
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+
+	// Create an expression node with self reference
+	expressionNode := &ExpressionNode{
+		Operation: &Operation{OperationType: selfReferenceOpType},
+	}
+
+	result, err := navigator.GetMatchingNodes(context, expressionNode)
+
+	test.AssertResult(t, nil, err)
+	test.AssertResult(t, 0, result.MatchingNodes.Len())
+}
+
+func TestDeeplyAssign_ComplexMappingMerge(t *testing.T) {
+	navigator := NewDataTreeNavigator()
+
+	// Create a context with a root mapping node containing nested data
+	rootNode := &CandidateNode{
+		Kind: MappingNode,
+		Tag:  "!!map",
+		Content: []*CandidateNode{
+			{Kind: ScalarNode, Tag: "!!str", Value: "config", IsMapKey: true},
+			{Kind: MappingNode, Tag: "!!map", Content: []*CandidateNode{
+				{Kind: ScalarNode, Tag: "!!str", Value: "existing_key", IsMapKey: true},
+				{Kind: ScalarNode, Tag: "!!str", Value: "existing_value"},
+			}},
+		},
+	}
+	context := Context{
+		MatchingNodes: list.New(),
+	}
+	context.MatchingNodes.PushBack(rootNode)
+
+	// Create a mapping node to merge
+	mappingNode := &CandidateNode{
+		Kind: MappingNode,
+		Tag:  "!!map",
+		Content: []*CandidateNode{
+			{Kind: ScalarNode, Tag: "!!str", Value: "new_key", IsMapKey: true},
+			{Kind: ScalarNode, Tag: "!!str", Value: "new_value"},
+			{Kind: ScalarNode, Tag: "!!str", Value: "existing_key", IsMapKey: true},
+			{Kind: ScalarNode, Tag: "!!str", Value: "updated_value"},
+		},
+	}
+
+	// Assign to path ["config"] (should merge with existing mapping)
+	path := []interface{}{"config"}
+	err := navigator.DeeplyAssign(context, path, mappingNode)
+
+	test.AssertResult(t, nil, err)
+
+	// Verify the merge was successful
+	configNode := rootNode.Content[1]                // The config mapping node
+	test.AssertResult(t, 4, len(configNode.Content)) // Should have 2 key-value pairs
+
+	// Check that both existing and new keys are present
+	foundExisting := false
+	foundNew := false
+	for i := 0; i < len(configNode.Content); i += 2 {
+		if i+1 < len(configNode.Content) {
+			key := configNode.Content[i]
+			value := configNode.Content[i+1]
+			switch key.Value {
+			case "existing_key":
+				foundExisting = true
+				test.AssertResult(t, "updated_value", value.Value) // Should be updated
+			case "new_key":
+				foundNew = true
+				test.AssertResult(t, "new_value", value.Value)
+			}
+		}
+	}
+	test.AssertResult(t, true, foundExisting)
+	test.AssertResult(t, true, foundNew)
+}

pkg/yqlib/decoder_base64.go

@@ -1,3 +1,5 @@
+//go:build !yq_nobase64
+
 package yqlib
 
 import (

pkg/yqlib/decoder_csv_object.go

@@ -1,3 +1,5 @@
+//go:build !yq_nocsv
+
 package yqlib
 
 import (

pkg/yqlib/decoder_ini.go

@@ -0,0 +1,106 @@
+//go:build !yq_noini
+
+package yqlib
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/go-ini/ini"
+)
+
+type iniDecoder struct {
+	reader   io.Reader
+	finished bool // Flag to signal completion of processing
+}
+
+func NewINIDecoder() Decoder {
+	return &iniDecoder{
+		finished: false, // Initialize the flag as false
+	}
+}
+
+func (dec *iniDecoder) Init(reader io.Reader) error {
+	// Store the reader for use in Decode
+	dec.reader = reader
+	return nil
+}
+
+func (dec *iniDecoder) Decode() (*CandidateNode, error) {
+	// If processing is already finished, return io.EOF
+	if dec.finished {
+		return nil, io.EOF
+	}
+
+	// Read all content from the stored reader
+	content, err := io.ReadAll(dec.reader)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read INI content: %w", err)
+	}
+
+	// Parse the INI content
+	cfg, err := ini.Load(content)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse INI content: %w", err)
+	}
+
+	// Create a root CandidateNode as a MappingNode (since INI is key-value based)
+	root := &CandidateNode{
+		Kind:  MappingNode,
+		Tag:   "!!map",
+		Value: "",
+	}
+
+	// Process each section in the INI file
+	for _, section := range cfg.Sections() {
+		sectionName := section.Name()
+
+		if sectionName == ini.DefaultSection {
+			// For the default section, add key-value pairs directly to the root node
+			for _, key := range section.Keys() {
+				keyName := key.Name()
+				keyValue := key.String()
+
+				// Create a key node (scalar for the key name)
+				keyNode := createStringScalarNode(keyName)
+				// Create a value node (scalar for the value)
+				valueNode := createStringScalarNode(keyValue)
+
+				// Add key-value pair to the root node
+				root.AddKeyValueChild(keyNode, valueNode)
+			}
+		} else {
+			// For named sections, create a nested map
+			sectionNode := &CandidateNode{
+				Kind:  MappingNode,
+				Tag:   "!!map",
+				Value: "",
+			}
+
+			// Add key-value pairs to the section node
+			for _, key := range section.Keys() {
+				keyName := key.Name()
+				keyValue := key.String()
+
+				// Create a key node (scalar for the key name)
+				keyNode := createStringScalarNode(keyName)
+				// Create a value node (scalar for the value)
+				valueNode := createStringScalarNode(keyValue)
+
+				// Add key-value pair to the section node
+				sectionNode.AddKeyValueChild(keyNode, valueNode)
+			}
+
+			// Create a key node for the section name
+			sectionKeyNode := createStringScalarNode(sectionName)
+			// Add the section as a nested map to the root node
+			root.AddKeyValueChild(sectionKeyNode, sectionNode)
+		}
+	}
+
+	// Set the finished flag to true to prevent further Decode calls
+	dec.finished = true
+
+	// Return the root node
+	return root, nil
+}

pkg/yqlib/decoder_properties.go

@@ -1,3 +1,5 @@
+//go:build !yq_noprops
+
 package yqlib
 
 import (

pkg/yqlib/decoder_uri.go

@@ -1,3 +1,5 @@
+//go:build !yq_nouri
+
 package yqlib
 
 import (

pkg/yqlib/decoder_yaml.go

@@ -8,7 +8,7 @@ import (
 	"regexp"
 	"strings"
 
-	yaml "gopkg.in/yaml.v3"
+	yaml "go.yaml.in/yaml/v3"
 )
 
 type yamlDecoder struct {

pkg/yqlib/doc/operators/anchor-and-alias-operators.md

@@ -34,68 +34,6 @@ 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 '.[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 '.[4] | explode(.)' sample.yml
-```
-will output
-```yaml
-r: 10
-x: 1
-y: 2
-```
-
 ## Get anchor
 Given a sample.yml file of:
 ```yaml
@@ -254,7 +192,101 @@ f:
   cat: b
 ```
 
-## Explode with merge anchors
+## 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 '.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
+```
+
+## 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 '.[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 '.[4] | explode(.)' sample.yml
+```
+will output
+```yaml
+r: 10
+x: 1
+y: 2
+```
+
+## LEGACY: Explode with merge anchors
+Caution: this is for when --yaml-fix-merge-anchor-to-spec=false; it's not to YAML spec because the merge anchors incorrectly override the object values. Flag will default to true in late 2025
+
 Given a sample.yml file of:
 ```yaml
 foo: &foo
@@ -301,33 +333,52 @@ foobar:
   thing: foobar_thing
 ```
 
-## Dereference and update a field
-Use explode with multiply to dereference an object
+## FIXED: Explode with merge anchors
+Set `--yaml-fix-merge-anchor-to-spec=true` to get this correct merge behaviour. Flag will default to true in late 2025 
 
 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
+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 '.thingOne |= explode(.) * {"value": false}' sample.yml
+yq 'explode(.)' sample.yml
 ```
 will output
 ```yaml
-item_value: &item_value
-  value: true
-thingOne:
-  name: item_1
-  value: false
-thingTwo:
-  name: item_2
-  !!merge <<: *item_value
+foo:
+  a: foo_a
+  thing: foo_thing
+  c: foo_c
+bar:
+  b: bar_b
+  thing: bar_thing
+  c: bar_c
+foobarList:
+  b: foobarList_b
+  a: foo_a
+  thing: foo_thing
+  c: foobarList_c
+foobar:
+  c: foobar_c
+  a: foo_a
+  thing: foobar_thing
 ```
 

pkg/yqlib/doc/operators/entries.md

@@ -2,7 +2,7 @@
 
 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.
 
-Use `with_entries(op)` as a syntatic sugar for doing `to_entries | op | from_entries`.
+Use `with_entries(op)` as a syntactic sugar for doing `to_entries | op | from_entries`.
 
 ## to_entries Map
 Given a sample.yml file of:

pkg/yqlib/doc/operators/headers/entries.md

@@ -2,4 +2,4 @@
 
 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.
 
-Use `with_entries(op)` as a syntatic sugar for doing `to_entries | op | from_entries`.
+Use `with_entries(op)` as a syntactic sugar for doing `to_entries | op | from_entries`.

pkg/yqlib/encoder_base64.go

@@ -1,3 +1,5 @@
+//go:build !yq_nobase64
+
 package yqlib
 
 import (

pkg/yqlib/encoder_csv.go

@@ -1,3 +1,5 @@
+//go:build !yq_nocsv
+
 package yqlib
 
 import (

pkg/yqlib/encoder_ini.go

@@ -0,0 +1,113 @@
+//go:build !yq_noini
+
+package yqlib
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"github.com/go-ini/ini"
+)
+
+type iniEncoder struct {
+	indentString string
+}
+
+// NewINIEncoder creates a new INI encoder
+func NewINIEncoder() Encoder {
+	// Hardcoded indent value of 0, meaning no additional spacing.
+	return &iniEncoder{""}
+}
+
+// CanHandleAliases indicates whether the encoder supports aliases. INI does not support aliases.
+func (ie *iniEncoder) CanHandleAliases() bool {
+	return false
+}
+
+// PrintDocumentSeparator is a no-op since INI does not support multiple documents.
+func (ie *iniEncoder) PrintDocumentSeparator(_ io.Writer) error {
+	return nil
+}
+
+// PrintLeadingContent is a no-op since INI does not support leading content or comments at the encoder level.
+func (ie *iniEncoder) PrintLeadingContent(_ io.Writer, _ string) error {
+	return nil
+}
+
+// Encode converts a CandidateNode into INI format and writes it to the provided writer.
+func (ie *iniEncoder) Encode(writer io.Writer, node *CandidateNode) error {
+	log.Debugf("I need to encode %v", NodeToString(node))
+	log.Debugf("kids %v", len(node.Content))
+
+	if node.Kind == ScalarNode {
+		return writeStringINI(writer, node.Value+"\n")
+	}
+
+	// Create a new INI configuration.
+	cfg := ini.Empty()
+
+	if node.Kind == MappingNode {
+		// Default section for key-value pairs at the root level.
+		defaultSection, err := cfg.NewSection(ini.DefaultSection)
+		if err != nil {
+			return err
+		}
+
+		// Process the node's content.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
+			key := keyNode.Value
+
+			switch valueNode.Kind {
+			case ScalarNode:
+				// Add key-value pair to the default section.
+				_, err := defaultSection.NewKey(key, valueNode.Value)
+				if err != nil {
+					return err
+				}
+			case MappingNode:
+				// Create a new section for nested MappingNode.
+				section, err := cfg.NewSection(key)
+				if err != nil {
+					return err
+				}
+				// Process nested key-value pairs.
+				for j := 0; j < len(valueNode.Content); j += 2 {
+					nestedKeyNode := valueNode.Content[j]
+					nestedValueNode := valueNode.Content[j+1]
+					if nestedValueNode.Kind == ScalarNode {
+						_, err := section.NewKey(nestedKeyNode.Value, nestedValueNode.Value)
+						if err != nil {
+							return err
+						}
+					} else {
+						log.Debugf("Skipping nested non-scalar value for key %s: %v", nestedKeyNode.Value, nestedValueNode.Kind)
+					}
+				}
+			default:
+				log.Debugf("Skipping non-scalar value for key %s: %v", key, valueNode.Kind)
+			}
+		}
+	} else {
+		return fmt.Errorf("INI encoder supports only MappingNode at the root level, got %v", node.Kind)
+	}
+
+	// Use a buffer to store the INI output as the library doesn't support direct io.Writer with indent.
+	var buffer bytes.Buffer
+	_, err := cfg.WriteToIndent(&buffer, ie.indentString)
+	if err != nil {
+		return err
+	}
+
+	// Write the buffer content to the provided writer.
+	_, err = writer.Write(buffer.Bytes())
+	return err
+}
+
+// writeStringINI is a helper function to write a string to the provided writer for INI encoder.
+func writeStringINI(writer io.Writer, content string) error {
+	_, err := writer.Write([]byte(content))
+	return err
+}

pkg/yqlib/encoder_properties.go

@@ -1,3 +1,5 @@
+//go:build !yq_noprops
+
 package yqlib
 
 import (

pkg/yqlib/encoder_sh.go

@@ -1,3 +1,5 @@
+//go:build !yq_nosh
+
 package yqlib
 
 import (

pkg/yqlib/encoder_shellvariables.go

@@ -1,3 +1,5 @@
+//go:build !yq_noshell
+
 package yqlib
 
 import (

pkg/yqlib/encoder_uri.go

@@ -1,3 +1,5 @@
+//go:build !yq_nouri
+
 package yqlib
 
 import (

pkg/yqlib/encoder_yaml.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 
 	"github.com/fatih/color"
-	"gopkg.in/yaml.v3"
+	"go.yaml.in/yaml/v3"
 )
 
 type yamlEncoder struct {

pkg/yqlib/expression_parser.go

@@ -9,6 +9,7 @@ type ExpressionNode struct {
 	Operation *Operation
 	LHS       *ExpressionNode
 	RHS       *ExpressionNode
+	Parent    *ExpressionNode
 }
 
 type ExpressionParserInterface interface {
@@ -57,6 +58,7 @@ func (p *expressionParserImpl) createExpressionTree(postFixPath []*Operation) (*
 				}
 				remaining, rhs := stack[:len(stack)-1], stack[len(stack)-1]
 				newNode.RHS = rhs
+				rhs.Parent = &newNode
 				stack = remaining
 			case 2:
 				if len(stack) < 2 {
@@ -64,7 +66,11 @@ func (p *expressionParserImpl) createExpressionTree(postFixPath []*Operation) (*
 				}
 				remaining, lhs, rhs := stack[:len(stack)-2], stack[len(stack)-2], stack[len(stack)-1]
 				newNode.LHS = lhs
+				lhs.Parent = &newNode
+
 				newNode.RHS = rhs
+				rhs.Parent = &newNode
+
 				stack = remaining
 			}
 		}

pkg/yqlib/format.go

@@ -77,6 +77,11 @@ var LuaFormat = &Format{"lua", []string{"l"},
 	func() Decoder { return NewLuaDecoder(ConfiguredLuaPreferences) },
 }
 
+var INIFormat = &Format{"ini", []string{"i"},
+	func() Encoder { return NewINIEncoder() },
+	func() Decoder { return NewINIDecoder() },
+}
+
 var Formats = []*Format{
 	YamlFormat,
 	JSONFormat,
@@ -90,6 +95,7 @@ var Formats = []*Format{
 	TomlFormat,
 	ShellVariablesFormat,
 	LuaFormat,
+	INIFormat,
 }
 
 func (f *Format) MatchesName(name string) bool {
@@ -107,7 +113,7 @@ func FormatStringFromFilename(filename string) string {
 	if filename != "" {
 		GetLogger().Debugf("checking filename '%s' for auto format detection", filename)
 		ext := filepath.Ext(filename)
-		if ext != "" && ext[0] == '.' {
+		if len(ext) >= 2 && ext[0] == '.' {
 			format := strings.ToLower(ext[1:])
 			GetLogger().Debugf("detected format '%s'", format)
 			return format

pkg/yqlib/goccy_yaml_test.go

@@ -7,96 +7,96 @@ import (
 )
 
 var goccyYamlFormatScenarios = []formatScenario{
-	// {
-	// 	description: "basic - 3",
-	// 	skipDoc:     true,
-	// 	input:       "3",
-	// 	expected:    "3\n",
-	// },
-	// {
-	// 	description: "basic - 3.1",
-	// 	skipDoc:     true,
-	// 	input:       "3.1",
-	// 	expected:    "3.1\n",
-	// },
-	// {
-	// 	description: "basic - mike",
-	// 	skipDoc:     true,
-	// 	input:       "mike: 3",
-	// 	expected:    "mike: 3\n",
-	// },
-	// {
-	// 	description: "basic - map multiple entries",
-	// 	skipDoc:     true,
-	// 	input:       "mike: 3\nfred: 12\n",
-	// 	expected:    "mike: 3\nfred: 12\n",
-	// },
-	// {
-	// 	description: "basic - 3.1",
-	// 	skipDoc:     true,
-	// 	input:       "{\n mike: 3\n}",
-	// 	expected:    "{mike: 3}\n",
-	// },
-	// {
-	// 	description: "basic - tag with number",
-	// 	skipDoc:     true,
-	// 	input:       "mike: !!cat 3",
-	// 	expected:    "mike: !!cat 3\n",
-	// },
-	// {
-	// 	description: "basic - array of numbers",
-	// 	skipDoc:     true,
-	// 	input:       "- 3",
-	// 	expected:    "- 3\n",
-	// },
-	// {
-	// 	description: "basic - single line array",
-	// 	skipDoc:     true,
-	// 	input:       "[3]",
-	// 	expected:    "[3]\n",
-	// },
-	// {
-	// 	description: "basic - plain string",
-	// 	skipDoc:     true,
-	// 	input:       `a: meow`,
-	// 	expected:    "a: meow\n",
-	// },
-	// {
-	// 	description: "basic - double quoted string",
-	// 	skipDoc:     true,
-	// 	input:       `a: "meow"`,
-	// 	expected:    "a: \"meow\"\n",
-	// },
-	// {
-	// 	description: "basic - single quoted string",
-	// 	skipDoc:     true,
-	// 	input:       `a: 'meow'`,
-	// 	expected:    "a: 'meow'\n",
-	// },
-	// {
-	// 	description: "basic - string block",
-	// 	skipDoc:     true,
-	// 	input:       "a: |\n  meow\n",
-	// 	expected:    "a: |\n  meow\n",
-	// },
-	// {
-	// 	description: "basic - long string",
-	// 	skipDoc:     true,
-	// 	input:       "a: the cute cat wrote a long sentence that wasn't wrapped at all.\n",
-	// 	expected:    "a: the cute cat wrote a long sentence that wasn't wrapped at all.\n",
-	// },
-	// {
-	// 	description: "basic - string block",
-	// 	skipDoc:     true,
-	// 	input:       "a: |-\n  meow\n",
-	// 	expected:    "a: |-\n  meow\n",
-	// },
-	// {
-	// 	description: "basic - line comment",
-	// 	skipDoc:     true,
-	// 	input:       "a: meow # line comment\n",
-	// 	expected:    "a: meow # line comment\n",
-	// },
+	{
+		description: "basic - 3",
+		skipDoc:     true,
+		input:       "3",
+		expected:    "3\n",
+	},
+	{
+		description: "basic - 3.1",
+		skipDoc:     true,
+		input:       "3.1",
+		expected:    "3.1\n",
+	},
+	{
+		description: "basic - mike",
+		skipDoc:     true,
+		input:       "mike: 3",
+		expected:    "mike: 3\n",
+	},
+	{
+		description: "basic - map multiple entries",
+		skipDoc:     true,
+		input:       "mike: 3\nfred: 12\n",
+		expected:    "mike: 3\nfred: 12\n",
+	},
+	{
+		description: "basic - 3.1",
+		skipDoc:     true,
+		input:       "{\n mike: 3\n}",
+		expected:    "{mike: 3}\n",
+	},
+	{
+		description: "basic - tag with number",
+		skipDoc:     true,
+		input:       "mike: !!cat 3",
+		expected:    "mike: !!cat 3\n",
+	},
+	{
+		description: "basic - array of numbers",
+		skipDoc:     true,
+		input:       "- 3",
+		expected:    "- 3\n",
+	},
+	{
+		description: "basic - single line array",
+		skipDoc:     true,
+		input:       "[3]",
+		expected:    "[3]\n",
+	},
+	{
+		description: "basic - plain string",
+		skipDoc:     true,
+		input:       `a: meow`,
+		expected:    "a: meow\n",
+	},
+	{
+		description: "basic - double quoted string",
+		skipDoc:     true,
+		input:       `a: "meow"`,
+		expected:    "a: \"meow\"\n",
+	},
+	{
+		description: "basic - single quoted string",
+		skipDoc:     true,
+		input:       `a: 'meow'`,
+		expected:    "a: 'meow'\n",
+	},
+	{
+		description: "basic - string block",
+		skipDoc:     true,
+		input:       "a: |\n  meow\n",
+		expected:    "a: |\n  meow\n",
+	},
+	{
+		description: "basic - long string",
+		skipDoc:     true,
+		input:       "a: the cute cat wrote a long sentence that wasn't wrapped at all.\n",
+		expected:    "a: the cute cat wrote a long sentence that wasn't wrapped at all.\n",
+	},
+	{
+		description: "basic - string block",
+		skipDoc:     true,
+		input:       "a: |-\n  meow\n",
+		expected:    "a: |-\n  meow\n",
+	},
+	{
+		description: "basic - line comment",
+		skipDoc:     true,
+		input:       "a: meow # line comment\n",
+		expected:    "a: meow # line comment\n",
+	},
 	// {
 	// 	description: "basic - head comment",
 	// 	skipDoc:     true,
@@ -109,54 +109,54 @@ var goccyYamlFormatScenarios = []formatScenario{
 	// 	input:       "# head comment\na: #line comment\n  meow\n",
 	// 	expected:    "# head comment\na: meow #line comment\n", // go-yaml does this
 	// },
-	// {
-	// 	description: "basic - foot comment",
-	// 	skipDoc:     true,
-	// 	input:       "a: meow\n# foot comment\n",
-	// 	expected:    "a: meow\n# foot comment\n",
-	// },
-	// {
-	// 	description: "basic - foot comment",
-	// 	skipDoc:     true,
-	// 	input:       "a: meow\nb: woof\n# foot comment\n",
-	// 	expected:    "a: meow\nb: woof\n# foot comment\n",
-	// },
-	// {
-	// 	description: "basic - boolean",
-	// 	skipDoc:     true,
-	// 	input:       "true\n",
-	// 	expected:    "true\n",
-	// },
-	// {
-	// 	description: "basic - null",
-	// 	skipDoc:     true,
-	// 	input:       "a: null\n",
-	// 	expected:    "a: null\n",
-	// },
-	// {
-	// 	description: "basic - ~",
-	// 	skipDoc:     true,
-	// 	input:       "a: ~\n",
-	// 	expected:    "a: ~\n",
-	// },
-	// {
-	// 	description: "basic - ~",
-	// 	skipDoc:     true,
-	// 	input:       "null\n",
-	// 	expected:    "null\n",
-	// },
-	// {
-	// 	skipDoc:     true,
-	// 	description: "trailing comment",
-	// 	input:       "test:",
-	// 	expected:    "test:",
-	// },
-	// {
-	// 	skipDoc:     true,
-	// 	description: "trailing comment",
-	// 	input:       "test: null\n# this comment will be removed",
-	// 	expected:    "test: null\n# this comment will be removed\n",
-	// },
+	{
+		description: "basic - foot comment",
+		skipDoc:     true,
+		input:       "a: meow\n# foot comment\n",
+		expected:    "a: meow\n# foot comment\n",
+	},
+	{
+		description: "basic - foot comment",
+		skipDoc:     true,
+		input:       "a: meow\nb: woof\n# foot comment\n",
+		expected:    "a: meow\nb: woof\n# foot comment\n",
+	},
+	{
+		description: "basic - boolean",
+		skipDoc:     true,
+		input:       "true\n",
+		expected:    "true\n",
+	},
+	{
+		description: "basic - null",
+		skipDoc:     true,
+		input:       "a: null\n",
+		expected:    "a: null\n",
+	},
+	{
+		description: "basic - ~",
+		skipDoc:     true,
+		input:       "a: ~\n",
+		expected:    "a: ~\n",
+	},
+	{
+		description: "basic - ~",
+		skipDoc:     true,
+		input:       "null\n",
+		expected:    "null\n",
+	},
+	{
+		skipDoc:     true,
+		description: "blank value round trip",
+		input:       "test:",
+		expected:    "test:\n",
+	},
+	{
+		skipDoc:     true,
+		description: "trailing comment",
+		input:       "test: null\n# this comment will be removed",
+		expected:    "test: null\n# this comment will be removed\n",
+	},
 	// {
 	// 	description: "doc separator",
 	// 	skipDoc:     true,
@@ -169,106 +169,106 @@ var goccyYamlFormatScenarios = []formatScenario{
 	// 	input:       "--- cat",
 	// 	expected:    "---\ncat\n",
 	// },
-	// {
-	// 	description: "scalar with doc separator",
-	// 	skipDoc:     true,
-	// 	input:       "---cat",
-	// 	expected:    "---cat\n",
-	// },
-	// {
-	// 	description: "basic - null",
-	// 	skipDoc:     true,
-	// 	input:       "null",
-	// 	expected:    "null\n",
-	// },
-	// {
-	// 	description: "basic - ~",
-	// 	skipDoc:     true,
-	// 	input:       "~",
-	// 	expected:    "~\n",
-	// },
-	// {
-	// 	description: "octal",
-	// 	skipDoc:     true,
-	// 	input:       "0o30",
-	// 	expression:  "tag",
-	// 	expected:    "!!int\n",
-	// },
-	// {
-	// 	description: "basic - [null]",
-	// 	skipDoc:     true,
-	// 	input:       "[null]",
-	// 	expected:    "[null]\n",
-	// },
-	// {
-	// 	description: "multi document",
-	// 	skipDoc:     true,
-	// 	input:       "a: mike\n---\nb: remember",
-	// 	expected:    "a: mike\n---\nb: remember\n",
-	// },
-	// {
-	// 	description: "single doc anchor map",
-	// 	skipDoc:     true,
-	// 	input:       "a: &remember mike\nb: *remember",
-	// 	expected:    "a: mike\nb: *remember\n",
-	// },
-	// {
-	// 	description: "explode doc anchor map",
-	// 	skipDoc:     true,
-	// 	input:       "a: &remember mike\nb: *remember",
-	// 	expression:  "explode(.)",
-	// 	expected:    "a: mike\nb: mike\n",
-	// },
-	// {
-	// 	description: "multi document anchor map",
-	// 	skipDoc:     true,
-	// 	input:       "a: &remember mike\n---\nb: *remember",
-	// 	expression:  "explode(.)",
-	// 	expected:    "a: mike\n---\nb: mike\n",
-	// },
-	// {
-	// 	description: "merge anchor",
-	// 	skipDoc:     true,
-	// 	input:       "a: &remember\n  c: mike\nb:\n  <<: *remember",
-	// 	expected:    "a: &remember\n  c: mike\nb:\n  <<: *remember\n",
-	// },
+	{
+		description: "scalar with doc separator",
+		skipDoc:     true,
+		input:       "---cat",
+		expected:    "---cat\n",
+	},
+	{
+		description: "basic - null",
+		skipDoc:     true,
+		input:       "null",
+		expected:    "null\n",
+	},
+	{
+		description: "basic - ~",
+		skipDoc:     true,
+		input:       "~",
+		expected:    "~\n",
+	},
+	{
+		description: "octal",
+		skipDoc:     true,
+		input:       "0o30",
+		expression:  "tag",
+		expected:    "!!int\n",
+	},
+	{
+		description: "basic - [null]",
+		skipDoc:     true,
+		input:       "[null]",
+		expected:    "[null]\n",
+	},
+	{
+		description: "multi document",
+		skipDoc:     true,
+		input:       "a: mike\n---\nb: remember",
+		expected:    "a: mike\n---\nb: remember\n",
+	},
+	{
+		description: "single doc anchor map",
+		skipDoc:     true,
+		input:       "a: &remember mike\nb: *remember",
+		expected:    "a: &remember mike\nb: *remember\n",
+	},
+	{
+		description: "explode doc anchor map",
+		skipDoc:     true,
+		input:       "a: &remember mike\nb: *remember",
+		expression:  "explode(.)",
+		expected:    "a: mike\nb: mike\n",
+	},
+	{
+		description: "multi document anchor map",
+		skipDoc:     true,
+		input:       "a: &remember mike\n---\nb: *remember",
+		expression:  "explode(.)",
+		expected:    "a: mike\n---\nb: mike\n",
+	},
+	{
+		description: "merge anchor",
+		skipDoc:     true,
+		input:       "a: &remember\n  c: mike\nb:\n  <<: *remember",
+		// fine to have !!merge as that's what the current impl does
+		expected: "a: &remember\n  c: mike\nb:\n  !!merge <<: *remember\n",
+	},
 	{
 		description: "custom tag",
 		skipDoc:     true,
 		input:       "a: !cat mike",
 		expected:    "a: !cat mike\n",
 	},
-	// {
-	// 	description: "basic - [~]",
-	// 	skipDoc:     true,
-	// 	input:       "[~]",
-	// 	expected:    "[~]\n",
-	// },
-	// {
-	// 	description: "basic - null map value",
-	// 	skipDoc:     true,
-	// 	input:       "a: null",
-	// 	expected:    "a: null\n",
-	// },
-	// {
-	// 	description: "basic - number",
-	// 	skipDoc:     true,
-	// 	input:       "3",
-	// 	expected:    "3\n",
-	// },
-	// {
-	// 	description: "basic - float",
-	// 	skipDoc:     true,
-	// 	input:       "3.1",
-	// 	expected:    "3.1\n",
-	// },
-	// {
-	// 	description: "basic - float",
-	// 	skipDoc:     true,
-	// 	input:       "[1, 2]",
-	// 	expected:    "[1, 2]\n",
-	// },
-
+	{
+		description: "basic - [~]",
+		skipDoc:     true,
+		input:       "[~]",
+		expected:    "[~]\n",
+	},
+	{
+		description: "basic - null map value",
+		skipDoc:     true,
+		input:       "a: null",
+		expected:    "a: null\n",
+	},
+	{
+		description: "basic - number",
+		skipDoc:     true,
+		input:       "3",
+		expected:    "3\n",
+	},
+	{
+		description: "basic - float",
+		skipDoc:     true,
+		input:       "3.1",
+		expected:    "3.1\n",
+	},
+	{
+		description: "basic - float",
+		skipDoc:     true,
+		input:       "[1, 2]",
+		expected:    "[1, 2]\n",
+	},
 }
 
 func testGoccyYamlScenario(t *testing.T, s formatScenario) {

pkg/yqlib/ini.go

@@ -0,0 +1,19 @@
+package yqlib
+
+type INIPreferences struct {
+	ColorsEnabled bool
+}
+
+func NewDefaultINIPreferences() INIPreferences {
+	return INIPreferences{
+		ColorsEnabled: false,
+	}
+}
+
+func (p *INIPreferences) Copy() INIPreferences {
+	return INIPreferences{
+		ColorsEnabled: p.ColorsEnabled,
+	}
+}
+
+var ConfiguredINIPreferences = NewDefaultINIPreferences()

pkg/yqlib/ini_test.go

@@ -0,0 +1,187 @@
+//go:build !yq_noini
+
+package yqlib
+
+import (
+	"bufio"
+	"fmt"
+	"testing"
+
+	"github.com/mikefarah/yq/v4/test"
+)
+
+const simpleINIInput = `[section]
+key = value
+`
+
+const expectedSimpleINIOutput = `[section]
+key = value
+`
+
+const expectedSimpleINIYaml = `section:
+  key: value
+`
+
+var iniScenarios = []formatScenario{
+	{
+		description:  "Parse INI: simple",
+		input:        simpleINIInput,
+		scenarioType: "decode",
+		expected:     expectedSimpleINIYaml,
+	},
+	{
+		description:  "Encode INI: simple",
+		input:        `section: {key: value}`,
+		expected:     expectedSimpleINIOutput,
+		scenarioType: "encode",
+	},
+	{
+		description:  "Roundtrip INI: simple",
+		input:        simpleINIInput,
+		expected:     expectedSimpleINIOutput,
+		scenarioType: "roundtrip",
+	},
+	{
+		description:   "bad ini",
+		input:         `[section\nkey = value`,
+		expectedError: `bad file 'sample.yml': failed to parse INI content: unclosed section: [section\nkey = value`,
+		scenarioType:  "decode-error",
+	},
+}
+
+func documentRoundtripINIScenario(w *bufio.Writer, s formatScenario) {
+	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
+
+	if s.subdescription != "" {
+		writeOrPanic(w, s.subdescription)
+		writeOrPanic(w, "\n\n")
+	}
+
+	writeOrPanic(w, "Given a sample.ini file of:\n")
+	writeOrPanic(w, fmt.Sprintf("```ini\n%v\n```\n", s.input))
+
+	writeOrPanic(w, "then\n")
+
+	expression := s.expression
+	if expression != "" {
+		writeOrPanic(w, fmt.Sprintf("```bash\nyq -p=ini -o=ini '%v' sample.ini\n```\n", expression))
+	} else {
+		writeOrPanic(w, "```bash\nyq -p=ini -o=ini sample.ini\n```\n")
+	}
+
+	writeOrPanic(w, "will output\n")
+	writeOrPanic(w, fmt.Sprintf("```ini\n%v```\n\n", mustProcessFormatScenario(s, NewINIDecoder(), NewINIEncoder())))
+}
+
+func documentDecodeINIScenario(w *bufio.Writer, s formatScenario) {
+	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
+
+	if s.subdescription != "" {
+		writeOrPanic(w, s.subdescription)
+		writeOrPanic(w, "\n\n")
+	}
+
+	writeOrPanic(w, "Given a sample.ini file of:\n")
+	writeOrPanic(w, fmt.Sprintf("```ini\n%v\n```\n", s.input))
+
+	writeOrPanic(w, "then\n")
+
+	expression := s.expression
+	if expression != "" {
+		writeOrPanic(w, fmt.Sprintf("```bash\nyq -p=ini '%v' sample.ini\n```\n", expression))
+	} else {
+		writeOrPanic(w, "```bash\nyq -p=ini sample.ini\n```\n")
+	}
+
+	writeOrPanic(w, "will output\n")
+	writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", mustProcessFormatScenario(s, NewINIDecoder(), NewYamlEncoder(ConfiguredYamlPreferences))))
+}
+
+func testINIScenario(t *testing.T, s formatScenario) {
+	switch s.scenarioType {
+	case "encode":
+		test.AssertResultWithContext(t, s.expected, mustProcessFormatScenario(s, NewYamlDecoder(ConfiguredYamlPreferences), NewINIEncoder()), s.description)
+	case "decode":
+		test.AssertResultWithContext(t, s.expected, mustProcessFormatScenario(s, NewINIDecoder(), NewYamlEncoder(ConfiguredYamlPreferences)), s.description)
+	case "roundtrip":
+		test.AssertResultWithContext(t, s.expected, mustProcessFormatScenario(s, NewINIDecoder(), NewINIEncoder()), s.description)
+	case "decode-error":
+		result, err := processFormatScenario(s, NewINIDecoder(), NewINIEncoder())
+		if err == nil {
+			t.Errorf("Expected error '%v' but it worked: %v", s.expectedError, result)
+		} else {
+			test.AssertResultComplexWithContext(t, s.expectedError, err.Error(), s.description)
+		}
+	default:
+		panic(fmt.Sprintf("unhandled scenario type %q", s.scenarioType))
+	}
+}
+
+func documentINIScenario(_ *testing.T, w *bufio.Writer, i interface{}) {
+	s := i.(formatScenario)
+	if s.skipDoc {
+		return
+	}
+	switch s.scenarioType {
+	case "encode":
+		documentINIEncodeScenario(w, s)
+	case "decode":
+		documentDecodeINIScenario(w, s)
+	case "roundtrip":
+		documentRoundtripINIScenario(w, s)
+	case "decode-error":
+		documentDecodeErrorINIScenario(w, s)
+	default:
+		panic(fmt.Sprintf("unhandled scenario type %q", s.scenarioType))
+	}
+}
+
+func documentINIEncodeScenario(w *bufio.Writer, s formatScenario) {
+	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
+
+	if s.subdescription != "" {
+		writeOrPanic(w, s.subdescription)
+		writeOrPanic(w, "\n\n")
+	}
+
+	writeOrPanic(w, "Given a sample.yml file of:\n")
+	writeOrPanic(w, fmt.Sprintf("```yaml\n%v\n```\n", s.input))
+
+	writeOrPanic(w, "then\n")
+
+	expression := s.expression
+	if expression == "" {
+		expression = "."
+	}
+
+	writeOrPanic(w, fmt.Sprintf("```bash\nyq -o=ini '%v' sample.yml\n```\n", expression))
+
+	writeOrPanic(w, "will output\n")
+	writeOrPanic(w, fmt.Sprintf("```ini\n%v```\n\n", mustProcessFormatScenario(s, NewYamlDecoder(ConfiguredYamlPreferences), NewINIEncoder())))
+}
+
+func documentDecodeErrorINIScenario(w *bufio.Writer, s formatScenario) {
+	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
+
+	if s.subdescription != "" {
+		writeOrPanic(w, s.subdescription)
+		writeOrPanic(w, "\n\n")
+	}
+
+	writeOrPanic(w, "Given a sample.ini file of:\n")
+	writeOrPanic(w, fmt.Sprintf("```ini\n%v\n```\n", s.input))
+
+	writeOrPanic(w, "then an error is expected:\n")
+	writeOrPanic(w, fmt.Sprintf("```\n%v\n```\n\n", s.expectedError))
+}
+
+func TestINIScenarios(t *testing.T) {
+	for _, tt := range iniScenarios {
+		testINIScenario(t, tt)
+	}
+	genericScenarios := make([]interface{}, len(iniScenarios))
+	for i, s := range iniScenarios {
+		genericScenarios[i] = s
+	}
+	documentScenarios(t, "usage", "convert", genericScenarios, documentINIScenario)
+}

pkg/yqlib/lib.go

@@ -28,6 +28,17 @@ func GetLogger() *logging.Logger {
 	return log
 }
 
+func getContentValueByKey(content []*CandidateNode, key string) *CandidateNode {
+	for index := 0; index < len(content); index = index + 2 {
+		keyNode := content[index]
+		valueNode := content[index+1]
+		if keyNode.Value == key {
+			return valueNode
+		}
+	}
+	return nil
+}
+
 func recurseNodeArrayEqual(lhs *CandidateNode, rhs *CandidateNode) bool {
 	if len(lhs.Content) != len(rhs.Content) {
 		return false

pkg/yqlib/no_base64.go

@@ -0,0 +1,11 @@
+//go:build yq_nobase64
+
+package yqlib
+
+func NewBase64Decoder() Decoder {
+	return nil
+}
+
+func NewBase64Encoder() Encoder {
+	return nil
+}

pkg/yqlib/no_csv.go

@@ -0,0 +1,11 @@
+//go:build yq_nocsv
+
+package yqlib
+
+func NewCSVObjectDecoder(prefs CsvPreferences) Decoder {
+	return nil
+}
+
+func NewCsvEncoder(prefs CsvPreferences) Encoder {
+	return nil
+}

pkg/yqlib/no_ini.go

@@ -0,0 +1,11 @@
+//go:build yq_noini
+
+package yqlib
+
+func NewINIDecoder() Decoder {
+	return nil
+}
+
+func NewINIEncoder() Encoder {
+	return nil
+}

pkg/yqlib/no_json.go

@@ -6,6 +6,6 @@ func NewJSONDecoder() Decoder {
 	return nil
 }
 
-func NewJSONEncoder(indent int, colorise bool, unwrapScalar bool) Encoder {
+func NewJSONEncoder(prefs JsonPreferences) Encoder {
 	return nil
 }

pkg/yqlib/no_props.go

@@ -0,0 +1,11 @@
+//go:build yq_noprops
+
+package yqlib
+
+func NewPropertiesDecoder() Decoder {
+	return nil
+}
+
+func NewPropertiesEncoder(prefs PropertiesPreferences) Encoder {
+	return nil
+}

pkg/yqlib/no_sh.go

@@ -0,0 +1,7 @@
+//go:build yq_nosh
+
+package yqlib
+
+func NewShEncoder() Encoder {
+	return nil
+}

pkg/yqlib/no_shellvariables.go

@@ -0,0 +1,7 @@
+//go:build yq_noshell
+
+package yqlib
+
+func NewShellVariablesEncoder() Encoder {
+	return nil
+}

pkg/yqlib/no_uri.go

@@ -0,0 +1,11 @@
+//go:build yq_nouri
+
+package yqlib
+
+func NewUriDecoder() Decoder {
+	return nil
+}
+
+func NewUriEncoder() Encoder {
+	return nil
+}

pkg/yqlib/no_xml.go

@@ -6,6 +6,6 @@ func NewXMLDecoder(prefs XmlPreferences) Decoder {
 	return nil
 }
 
-func NewXMLEncoder(indent int, prefs XmlPreferences) Encoder {
+func NewXMLEncoder(prefs XmlPreferences) Encoder {
 	return nil
 }

pkg/yqlib/operator_add.go

@@ -38,8 +38,11 @@ func toNodes(candidate *CandidateNode, lhs *CandidateNode) []*CandidateNode {
 
 func addOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("Add operator")
+	// only calculate when empty IF we are the root expression; OR
+	// calcWhenEmpty := expressionNode.Parent == nil || expressionNode.Parent.LHS == expressionNode
+	calcWhenEmpty := context.MatchingNodes.Len() > 0
 
-	return crossFunction(d, context.ReadOnlyClone(), expressionNode, add, true)
+	return crossFunction(d, context.ReadOnlyClone(), expressionNode, add, calcWhenEmpty)
 }
 
 func add(_ *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {

pkg/yqlib/operator_add_test.go

@@ -5,6 +5,107 @@ import (
 )
 
 var addOperatorScenarios = []expressionScenario{
+	{
+		skipDoc:    true,
+		expression: `"foo" + "bar"`,
+		expected: []string{
+			"D0, P[], (!!str)::foobar\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		expression: `[] | .[] | "foo" + .`,
+		expected:   []string{},
+	},
+	{
+		skipDoc:    true,
+		expression: `[] | .[] | . + "foo"`,
+		expected:   []string{},
+	},
+	{
+		skipDoc:    true,
+		expression: `select(.) | "foo" + "bar"`,
+		expected: []string{
+			"D0, P[], (!!str)::foobar\n", // jq does not do this :/ - but yq has for quite some time.
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   "apples: 3",
+		expression: `.apples + 3`,
+		expected: []string{
+			"D0, P[apples], (!!int)::6\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   "apples: 3",
+		expression: `.bobo + 3`,
+		expected: []string{
+			"D0, P[], (!!int)::3\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		expression: `select(.) | "cat" + .`,
+		expected:   []string{},
+	},
+	{
+		skipDoc:    true,
+		document:   `[]`,
+		expression: `.[] | (.a + "|" + .b)`,
+		expected:   []string{},
+	},
+	{
+		skipDoc:    true,
+		document:   `[]`,
+		expression: `.[] | (.a + "|")`,
+		expected:   []string{},
+	},
+	{
+		skipDoc:    true,
+		document:   `[]`,
+		expression: `.[] | ("|" + .a)`,
+		expected:   []string{},
+	},
+	{
+		skipDoc:    true,
+		document:   `resources: [foo, bar, baz]`,
+		expression: `.missing + .resources | .[]`,
+		expected: []string{
+			"D0, P[resources 0], (!!str)::foo\n",
+			"D0, P[resources 1], (!!str)::bar\n",
+			"D0, P[resources 2], (!!str)::baz\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `resources: [foo, bar, baz]`,
+		expression: `. | .missing + .resources | .[]`,
+		expected: []string{
+			"D0, P[resources 0], (!!str)::foo\n",
+			"D0, P[resources 1], (!!str)::bar\n",
+			"D0, P[resources 2], (!!str)::baz\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `resources: [foo, bar, baz]`,
+		expression: `. | .missing + .resources`,
+		expected: []string{
+			"D0, P[resources], (!!seq)::[foo, bar, baz]\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `resources: [foo, bar, baz]`,
+		expression: `. | .missing + .resources | .[]`,
+		expected: []string{
+			"D0, P[resources 0], (!!str)::foo\n",
+			"D0, P[resources 1], (!!str)::bar\n",
+			"D0, P[resources 2], (!!str)::baz\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `[{a: foo, b: bar}, {a: 1, b: 2}]`,

pkg/yqlib/operator_anchors_aliases.go

@@ -138,6 +138,41 @@ func explodeOperator(d *dataTreeNavigator, context Context, expressionNode *Expr
 	return context, nil
 }
 
+func fixedReconstructAliasedMap(node *CandidateNode) error {
+	var newContent = []*CandidateNode{}
+
+	for index := 0; index < len(node.Content); index = index + 2 {
+		keyNode := node.Content[index]
+		valueNode := node.Content[index+1]
+		if keyNode.Value != "<<" {
+			// always add in plain nodes
+			newContent = append(newContent, keyNode, valueNode)
+		} else {
+			sequence := valueNode
+			if sequence.Kind != SequenceNode {
+				sequence = &CandidateNode{Content: []*CandidateNode{sequence}}
+			}
+			for index := 0; index < len(sequence.Content); index = index + 1 {
+				// for merge anchors, we only set them if the key is not already in node or the newContent
+				mergeNodeSeq := sequence.Content[index]
+				if mergeNodeSeq.Kind == AliasNode {
+					mergeNodeSeq = mergeNodeSeq.Alias
+				}
+				if mergeNodeSeq.Kind != MappingNode {
+					return fmt.Errorf("merge anchor only supports maps, got !!seq instead")
+				}
+				itemsToAdd := mergeNodeSeq.FilterMapContentByKey(func(keyNode *CandidateNode) bool {
+					return getContentValueByKey(node.Content, keyNode.Value) == nil &&
+						getContentValueByKey(newContent, keyNode.Value) == nil
+				})
+				newContent = append(newContent, itemsToAdd...)
+			}
+		}
+	}
+	node.Content = newContent
+	return nil
+}
+
 func reconstructAliasedMap(node *CandidateNode, context Context) error {
 	var newContent = list.New()
 	// can I short cut here by prechecking if there's an anchor in the map?
@@ -215,6 +250,10 @@ func explodeNode(node *CandidateNode, context Context) error {
 		}
 
 		if hasAlias {
+			if ConfiguredYamlPreferences.FixMergeAnchorToSpec {
+				return fixedReconstructAliasedMap(node)
+			}
+			log.Warning("--yaml-fix-merge-anchor-to-spec is false; causing merge anchors to override the existing values which isn't to the yaml spec. This flag will default to true in late 2025.")
 			// this is a slow op, which is why we want to check before running it.
 			return reconstructAliasedMap(node, context)
 		}

pkg/yqlib/operator_anchors_aliases_test.go

@@ -34,6 +34,25 @@ thingTwo:
     !!merge <<: *item_value
 `
 
+var explodeMergeAnchorsFixedExpected = `D0, P[], (!!map)::foo:
+    a: foo_a
+    thing: foo_thing
+    c: foo_c
+bar:
+    b: bar_b
+    thing: bar_thing
+    c: bar_c
+foobarList:
+    b: foobarList_b
+    a: foo_a
+    thing: foo_thing
+    c: foobarList_c
+foobar:
+    c: foobar_c
+    a: foo_a
+    thing: foobar_thing
+`
+
 var explodeMergeAnchorsExpected = `D0, P[], (!!map)::foo:
     a: foo_a
     thing: foo_thing
@@ -53,7 +72,146 @@ foobar:
     thing: foobar_thing
 `
 
+var explodeWhenKeysExistDocument = `objects:
+  - &circle
+    name: circle
+    shape: round
+  - name: ellipse
+    !!merge <<: *circle
+  - !!merge <<: *circle
+    name: egg
+`
+
+var explodeWhenKeysExistLegacy = `D0, P[], (!!map)::objects:
+    - name: circle
+      shape: round
+    - name: circle
+      shape: round
+    - shape: round
+      name: egg
+`
+
+var explodeWhenKeysExistExpected = `D0, P[], (!!map)::objects:
+    - name: circle
+      shape: round
+    - name: ellipse
+      shape: round
+    - shape: round
+      name: egg
+`
+
+var fixedAnchorOperatorScenarios = []expressionScenario{
+	{
+		skipDoc:     true,
+		description: "merge anchor after existing keys",
+		document:    explodeWhenKeysExistDocument,
+		expression:  "explode(.)",
+		expected:    []string{explodeWhenKeysExistExpected},
+	},
+	{
+		skipDoc:        true, // skip doc for now, only difference is order of keys
+		description:    "Merge multiple maps",
+		subdescription: "see https://yaml.org/type/merge.html",
+		document:       specDocument + "- << : [ *CENTER, *BIG ]\n",
+		expression:     ".[4] | explode(.)",
+		expected:       []string{"D0, P[4], (!!map)::x: 1\ny: 2\nr: 10\n"},
+	},
+	{
+		skipDoc:        true, // skip doc for now, only difference is order of keys
+		description:    "Override",
+		subdescription: "see https://yaml.org/type/merge.html",
+		document:       specDocument + "- << : [ *BIG, *LEFT, *SMALL ]\n  x: 1\n",
+		expression:     ".[4] | explode(.)",
+		expected:       []string{"D0, P[4], (!!map)::r: 10\ny: 2\nx: 1\n"},
+	},
+	{
+		description:    "FIXED: Explode with merge anchors",
+		subdescription: "Set `--yaml-fix-merge-anchor-to-spec=true` to get this correct merge behaviour. Flag will default to true in late 2025 ",
+		document:       mergeDocSample,
+		expression:     `explode(.)`,
+		expected:       []string{explodeMergeAnchorsFixedExpected},
+	},
+	{
+		skipDoc:    true,
+		document:   mergeDocSample,
+		expression: `.foo* | explode(.) | (. style="flow")`,
+		expected: []string{
+			"D0, P[foo], (!!map)::{a: foo_a, thing: foo_thing, c: foo_c}\n",
+			"D0, P[foobarList], (!!map)::{b: foobarList_b, a: foo_a, thing: foo_thing, c: foobarList_c}\n",
+			"D0, P[foobar], (!!map)::{c: foobar_c, a: foo_a, thing: foobar_thing}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   mergeDocSample,
+		expression: `.foo* | explode(explode(.)) | (. style="flow")`,
+		expected: []string{
+			"D0, P[foo], (!!map)::{a: foo_a, thing: foo_thing, c: foo_c}\n",
+			"D0, P[foobarList], (!!map)::{b: foobarList_b, a: foo_a, thing: foo_thing, c: foobarList_c}\n",
+			"D0, P[foobar], (!!map)::{c: foobar_c, a: foo_a, thing: foobar_thing}\n",
+		},
+	},
+}
+
+var badAnchorOperatorScenarios = []expressionScenario{
+	{
+		skipDoc:     true, // incorrect overrides
+		description: "LEGACY: merge anchor after existing keys",
+		document:    explodeWhenKeysExistDocument,
+		expression:  "explode(.)",
+		expected:    []string{explodeWhenKeysExistLegacy},
+	},
+	{
+		description:    "Merge multiple maps", // functionally correct, but key order gets mangled
+		subdescription: "see https://yaml.org/type/merge.html",
+		document:       specDocument + "- << : [ *CENTER, *BIG ]\n",
+		expression:     ".[4] | explode(.)",
+		expected:       []string{"D0, P[4], (!!map)::r: 10\nx: 1\ny: 2\n"},
+	},
+	{
+		description:    "Override", // functionally correct, but key order gets mangled
+		subdescription: "see https://yaml.org/type/merge.html",
+		document:       specDocument + "- << : [ *BIG, *LEFT, *SMALL ]\n  x: 1\n",
+		expression:     ".[4] | explode(.)",
+		expected:       []string{"D0, P[4], (!!map)::r: 10\nx: 1\ny: 2\n"},
+	},
+	{
+		description:    "LEGACY: Explode with merge anchors", // incorrect overrides
+		subdescription: "Caution: this is for when --yaml-fix-merge-anchor-to-spec=false; it's not to YAML spec because the merge anchors incorrectly override the object values. Flag will default to true in late 2025",
+		document:       mergeDocSample,
+		expression:     `explode(.)`,
+		expected:       []string{explodeMergeAnchorsExpected},
+	},
+	{
+		skipDoc:    true,
+		document:   mergeDocSample, // incorrect overrides
+		expression: `.foo* | explode(.) | (. style="flow")`,
+		expected: []string{
+			"D0, P[foo], (!!map)::{a: foo_a, thing: foo_thing, c: foo_c}\n",
+			"D0, P[foobarList], (!!map)::{b: bar_b, thing: foo_thing, c: foobarList_c, a: foo_a}\n",
+			"D0, P[foobar], (!!map)::{c: foo_c, a: foo_a, thing: foobar_thing}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   mergeDocSample,
+		expression: `.foo* | explode(explode(.)) | (. style="flow")`,
+		expected: []string{
+			"D0, P[foo], (!!map)::{a: foo_a, thing: foo_thing, c: foo_c}\n",
+			"D0, P[foobarList], (!!map)::{b: bar_b, thing: foo_thing, c: foobarList_c, a: foo_a}\n",
+			"D0, P[foobar], (!!map)::{c: foo_c, a: foo_a, thing: foobar_thing}\n",
+		},
+	},
+}
+
 var anchorOperatorScenarios = []expressionScenario{
+	{
+		skipDoc:     true,
+		description: "merge anchor to alias alias",
+		document:    "b: &b 10\na: &a { k:  *b }\nc:\n   <<: [*a]",
+		expression:  "explode(.)",
+		expected:    []string{"D0, P[], (!!map)::b: 10\na: {k: 10}\nc:\n    k: 10\n"},
+	},
 	{
 		skipDoc:       true,
 		description:   "merge anchor not map",
@@ -68,20 +226,6 @@ var anchorOperatorScenarios = []expressionScenario{
 		expression:     ".[4] | explode(.)",
 		expected:       []string{expectedSpecResult},
 	},
-	{
-		description:    "Merge multiple maps",
-		subdescription: "see https://yaml.org/type/merge.html",
-		document:       specDocument + "- << : [ *CENTER, *BIG ]\n",
-		expression:     ".[4] | explode(.)",
-		expected:       []string{"D0, P[4], (!!map)::r: 10\nx: 1\ny: 2\n"},
-	},
-	{
-		description:    "Override",
-		subdescription: "see https://yaml.org/type/merge.html",
-		document:       specDocument + "- << : [ *BIG, *LEFT, *SMALL ]\n  x: 1\n",
-		expression:     ".[4] | explode(.)",
-		expected:       []string{"D0, P[4], (!!map)::r: 10\nx: 1\ny: 2\n"},
-	},
 	{
 		description: "Get anchor",
 		document:    `a: &billyBob cat`,
@@ -224,37 +368,22 @@ var anchorOperatorScenarios = []expressionScenario{
 		},
 	},
 	{
-		description: "Explode with alias keys",
-		document:    `{f : {a: &a cat, *a: b}}`,
-		expression:  `explode(.f)`,
+		description:    "Explode with alias keys",
+		subdescription: "No space between alias",
+		skipDoc:        true,
+		document:       `{f : {a: &a cat, *a: b}}`,
+		expression:     `explode(.f)`,
 		expected: []string{
 			"D0, P[], (!!map)::{f: {a: cat, cat: b}}\n",
 		},
+		skipForGoccy: true, // can't handle no space between alias
 	},
 	{
-		description: "Explode with merge anchors",
-		document:    mergeDocSample,
-		expression:  `explode(.)`,
-		expected:    []string{explodeMergeAnchorsExpected},
-	},
-	{
-		skipDoc:    true,
-		document:   mergeDocSample,
-		expression: `.foo* | explode(.) | (. style="flow")`,
+		description: "Explode with alias keys",
+		document:    `{f : {a: &a cat, *a : b}}`,
+		expression:  `explode(.f)`,
 		expected: []string{
-			"D0, P[foo], (!!map)::{a: foo_a, thing: foo_thing, c: foo_c}\n",
-			"D0, P[foobarList], (!!map)::{b: bar_b, thing: foo_thing, c: foobarList_c, a: foo_a}\n",
-			"D0, P[foobar], (!!map)::{c: foo_c, a: foo_a, thing: foobar_thing}\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   mergeDocSample,
-		expression: `.foo* | explode(explode(.)) | (. style="flow")`,
-		expected: []string{
-			"D0, P[foo], (!!map)::{a: foo_a, thing: foo_thing, c: foo_c}\n",
-			"D0, P[foobarList], (!!map)::{b: bar_b, thing: foo_thing, c: foobarList_c, a: foo_a}\n",
-			"D0, P[foobar], (!!map)::{c: foo_c, a: foo_a, thing: foobar_thing}\n",
+			"D0, P[], (!!map)::{f: {a: cat, cat: b}}\n",
 		},
 	},
 	{
@@ -275,8 +404,18 @@ var anchorOperatorScenarios = []expressionScenario{
 }
 
 func TestAnchorAliasOperatorScenarios(t *testing.T) {
-	for _, tt := range anchorOperatorScenarios {
+	for _, tt := range append(anchorOperatorScenarios, badAnchorOperatorScenarios...) {
 		testScenario(t, &tt)
 	}
-	documentOperatorScenarios(t, "anchor-and-alias-operators", anchorOperatorScenarios)
+	documentOperatorScenarios(t, "anchor-and-alias-operators", append(anchorOperatorScenarios, badAnchorOperatorScenarios...))
+}
+
+func TestAnchorAliasOperatorAlignedToSpecScenarios(t *testing.T) {
+	ConfiguredYamlPreferences.FixMergeAnchorToSpec = true
+	for _, tt := range append(fixedAnchorOperatorScenarios, anchorOperatorScenarios...) {
+		testScenario(t, &tt)
+
+	}
+	appendOperatorDocumentScenario(t, "anchor-and-alias-operators", fixedAnchorOperatorScenarios)
+	ConfiguredYamlPreferences.FixMergeAnchorToSpec = false
 }

pkg/yqlib/operator_collect_object.go

@@ -2,6 +2,7 @@ package yqlib
 
 import (
 	"container/list"
+	"fmt"
 )
 
 /*
@@ -34,6 +35,9 @@ func collectObjectOperator(d *dataTreeNavigator, originalContext Context, _ *Exp
 
 	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidateNode := el.Value.(*CandidateNode)
+		if len(candidateNode.Content) < len(first.Content) {
+			return Context{}, fmt.Errorf("CollectObject: mismatching node sizes; are you creating a map with mismatching key value pairs?")
+		}
 
 		for i := 0; i < len(first.Content); i++ {
 			log.Debugf("rotate[%v] = %v", i, NodeToString(candidateNode.Content[i]))

pkg/yqlib/operator_collect_object_test.go

@@ -12,6 +12,11 @@ var collectObjectOperatorScenarios = []expressionScenario{
 			"D0, P[name], (!!str)::mike\n",
 		},
 	},
+	{
+		skipDoc:       true,
+		expression:    `{"c": "a", "b", "d"}`,
+		expectedError: "CollectObject: mismatching node sizes; are you creating a map with mismatching key value pairs?",
+	},
 	{
 		skipDoc:    true,
 		expression: `{"person": {"names": ["mike"]}} | .person.names[0]`,

pkg/yqlib/operator_delete_test.go

@@ -119,6 +119,60 @@ var deleteOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!map)::a: []\n",
 		},
 	},
+	{
+		skipDoc:     true,
+		description: "Delete entry appended to an array",
+		document:    `[1,2]`,
+		expression:  `. += [3] | del(.[2])`,
+		expected: []string{
+			"D0, P[], (!!seq)::[1, 2]\n",
+		},
+	},
+	{
+		skipDoc:     true,
+		description: "Delete entry after sorting an array",
+		document:    `[3,2,1]`,
+		expression:  `sort | del(.[2])`,
+		expected: []string{
+			"D0, P[], (!!seq)::[1, 2]\n",
+		},
+	},
+	{
+		skipDoc:     true,
+		description: "Delete entry after reversing an array",
+		document:    `[1,2,3]`,
+		expression:  `reverse | del(.[2])`,
+		expected: []string{
+			"D0, P[], (!!seq)::[3, 2]\n",
+		},
+	},
+	{
+		skipDoc:     true,
+		description: "Delete entry after shuffling an array",
+		document:    `[1,2,3]`,
+		expression:  `shuffle | del(.[2])`,
+		expected: []string{
+			"D0, P[], (!!seq)::[3, 1]\n",
+		},
+	},
+	{
+		skipDoc:     true,
+		description: "Delete entry from keys array",
+		document:    `{"a": 1, "b": 2, "c": 3}`,
+		expression:  `keys | del(.[] | select(.=="b"))`,
+		expected: []string{
+			"D0, P[], (!!seq)::- \"a\"\n- \"c\"\n",
+		},
+	},
+	{
+		skipDoc:     true,
+		description: "Delete entry after flattening an array",
+		document:    `[1,[2],[[3]]]`,
+		expression:  `flatten | del(.[2])`,
+		expected: []string{
+			"D0, P[], (!!seq)::[1, 2]\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `a: [10,x,10, 10, x, 10]`,

pkg/yqlib/operator_flatten_test.go

@@ -21,8 +21,8 @@ var flattenOperatorScenarios = []expressionScenario{
 		expression:  `flatten[]`,
 		expected: []string{
 			"D0, P[0], (!!int)::1\n",
-			"D0, P[0], (!!int)::2\n",
-			"D0, P[0], (!!int)::3\n",
+			"D0, P[1], (!!int)::2\n",
+			"D0, P[2], (!!int)::3\n",
 		},
 	},
 	{
@@ -40,8 +40,8 @@ var flattenOperatorScenarios = []expressionScenario{
 		expression:  `flatten(1)[]`,
 		expected: []string{
 			"D0, P[0], (!!int)::1\n",
-			"D0, P[0], (!!int)::2\n",
-			"D0, P[0], (!!seq)::[3]\n",
+			"D0, P[1], (!!int)::2\n",
+			"D0, P[2], (!!seq)::[3]\n",
 		},
 	},
 	{

pkg/yqlib/operator_keys.go

@@ -65,19 +65,20 @@ func getMapKeys(node *CandidateNode) *CandidateNode {
 	for index := 0; index < len(node.Content); index = index + 2 {
 		contents = append(contents, node.Content[index])
 	}
-	return &CandidateNode{Kind: SequenceNode, Tag: "!!seq", Content: contents}
+
+	seq := &CandidateNode{Kind: SequenceNode, Tag: "!!seq"}
+	seq.AddChildren(contents)
+	return seq
 }
 
 func getIndices(node *CandidateNode) *CandidateNode {
 	var contents = make([]*CandidateNode, len(node.Content))
 
 	for index := range node.Content {
-		contents[index] = &CandidateNode{
-			Kind:  ScalarNode,
-			Tag:   "!!int",
-			Value: fmt.Sprintf("%v", index),
-		}
+		contents[index] = createScalarNode(index, fmt.Sprintf("%v", index))
 	}
 
-	return &CandidateNode{Kind: SequenceNode, Tag: "!!seq", Content: contents}
+	seq := &CandidateNode{Kind: SequenceNode, Tag: "!!seq"}
+	seq.AddChildren(contents)
+	return seq
 }

pkg/yqlib/operator_keys_test.go

@@ -45,8 +45,8 @@ var keysOperatorScenarios = []expressionScenario{
 		document:    `{dog: woof, cat: meow}`,
 		expression:  `keys[]`,
 		expected: []string{
-			"D0, P[dog], (!!str)::dog\n",
-			"D0, P[cat], (!!str)::cat\n",
+			"D0, P[0], (!!str)::dog\n",
+			"D0, P[1], (!!str)::cat\n",
 		},
 	},
 	{

pkg/yqlib/operator_reverse_test.go

@@ -17,8 +17,8 @@ var reverseOperatorScenarios = []expressionScenario{
 		document:    "[1, 2]",
 		expression:  `reverse[]`,
 		expected: []string{
-			"D0, P[1], (!!int)::2\n",
-			"D0, P[0], (!!int)::1\n",
+			"D0, P[0], (!!int)::2\n",
+			"D0, P[1], (!!int)::1\n",
 		},
 	},
 	{

pkg/yqlib/operator_shuffle.go

@@ -26,7 +26,12 @@ func shuffleOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (
 
 		a := result.Content
 
-		myRand.Shuffle(len(a), func(i, j int) { a[i], a[j] = a[j], a[i] })
+		myRand.Shuffle(len(a), func(i, j int) {
+			a[i], a[j] = a[j], a[i]
+			oldIndex := a[i].Key.Value
+			a[i].Key.Value = a[j].Key.Value
+			a[j].Key.Value = oldIndex
+		})
 
 		results.PushBack(result)
 	}

pkg/yqlib/operator_shuffle_test.go

@@ -17,9 +17,9 @@ var shuffleOperatorScenarios = []expressionScenario{
 		document:    "[1, 2, 3]",
 		expression:  `shuffle[]`,
 		expected: []string{
-			"D0, P[2], (!!int)::3\n",
-			"D0, P[0], (!!int)::1\n",
-			"D0, P[1], (!!int)::2\n",
+			"D0, P[0], (!!int)::3\n",
+			"D0, P[1], (!!int)::1\n",
+			"D0, P[2], (!!int)::2\n",
 		},
 	},
 

pkg/yqlib/operator_sort_test.go

@@ -17,8 +17,8 @@ var sortByOperatorScenarios = []expressionScenario{
 		document:    "[{a: banana},{a: apple}]",
 		expression:  `sort_by(.a)[]`,
 		expected: []string{
-			"D0, P[1], (!!map)::{a: apple}\n",
-			"D0, P[0], (!!map)::{a: banana}\n",
+			"D0, P[0], (!!map)::{a: apple}\n",
+			"D0, P[1], (!!map)::{a: banana}\n",
 		},
 	},
 	{
@@ -27,9 +27,9 @@ var sortByOperatorScenarios = []expressionScenario{
 		document:    "[{a: banana},null,{a: apple}]",
 		expression:  `sort_by(.a)[]`,
 		expected: []string{
-			"D0, P[1], (!!null)::null\n",
-			"D0, P[2], (!!map)::{a: apple}\n",
-			"D0, P[0], (!!map)::{a: banana}\n",
+			"D0, P[0], (!!null)::null\n",
+			"D0, P[1], (!!map)::{a: apple}\n",
+			"D0, P[2], (!!map)::{a: banana}\n",
 		},
 	},
 	{
@@ -149,8 +149,8 @@ var sortByOperatorScenarios = []expressionScenario{
 		document:    "[8,null]",
 		expression:  `sort[]`,
 		expected: []string{
-			"D0, P[1], (!!null)::null\n",
-			"D0, P[0], (!!int)::8\n",
+			"D0, P[0], (!!null)::null\n",
+			"D0, P[1], (!!int)::8\n",
 		},
 	},
 	{

pkg/yqlib/operator_style_test.go

@@ -47,10 +47,10 @@ var styleOperatorScenarios = []expressionScenario{
 	},
 	{
 		skipDoc:    true,
-		document:   "bing: &foo frog\na:\n  c: cat\n  <<: [*foo]",
+		document:   "bing: &foo {x: z}\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",
+			"D0, P[], (!!map)::'bing': &foo {'x': 'z'}\n'a':\n    'c': 'cat'\n    !!merge <<: [*foo]\n",
 		},
 	},
 	{

pkg/yqlib/operator_traverse_path_test.go

@@ -43,6 +43,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 		expected: []string{
 			"D0, P[x], (!!null)::null\n",
 		},
+		skipForGoccy: true, // throws an error instead, that's fine
 	},
 	{
 		skipDoc:     true,
@@ -553,6 +554,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 		document:      badAliasSample,
 		expression:    ".steps[]",
 		expectedError: "can only use merge anchors with maps (!!map), but got !!seq",
+		skipForGoccy:  true, // throws an error on parsing, that's fine
 	},
 }
 

pkg/yqlib/operator_unique_test.go

@@ -99,6 +99,7 @@ var uniqueOperatorScenarios = []expressionScenario{
 		expected: []string{
 			"D0, P[], (!!seq)::# abc\n[{name: harry, pet: cat}, {pet: fish}]\n# xyz\n",
 		},
+		skipForGoccy: true, // https://github.com/goccy/go-yaml/issues/757
 	},
 }
 

pkg/yqlib/operators_test.go

@@ -6,6 +6,7 @@ import (
 	"container/list"
 	"fmt"
 	"io"
+	"io/fs"
 	"os"
 	"sort"
 	"strings"
@@ -29,12 +30,27 @@ type expressionScenario struct {
 	expectedError         string
 	dontFormatInputForDoc bool // dont format input doc for documentation generation
 	requiresFormat        string
+	skipForGoccy          bool
 }
 
+var goccyTesting = false
+
+var testingDecoder = NewYamlDecoder(ConfiguredYamlPreferences)
+
 func TestMain(m *testing.M) {
-	logging.SetLevel(logging.ERROR, "")
+	logging.SetLevel(logging.WARNING, "")
+	if os.Getenv("DEBUG") == "true" {
+		logging.SetLevel(logging.DEBUG, "")
+	}
 	ConfiguredYamlPreferences.ColorsEnabled = false
 	ConfiguredJSONPreferences.ColorsEnabled = false
+
+	goccyTesting = os.Getenv("GOCCY") == "true"
+
+	if goccyTesting {
+		testingDecoder = NewGoccyYAMLDecoder()
+	}
+
 	Now = func() time.Time {
 		return time.Date(2021, time.May, 19, 1, 2, 3, 4, time.UTC)
 	}
@@ -53,10 +69,14 @@ func NewSimpleYamlPrinter(writer io.Writer, unwrapScalar bool, indent int, print
 func readDocument(content string, fakefilename string, fakeFileIndex int) (*list.List, error) {
 	reader := bufio.NewReader(strings.NewReader(content))
 
-	return readDocuments(reader, fakefilename, fakeFileIndex, NewYamlDecoder(ConfiguredYamlPreferences))
+	return readDocuments(reader, fakefilename, fakeFileIndex, testingDecoder)
 }
 
 func testScenario(t *testing.T, s *expressionScenario) {
+	if s.skipForGoccy {
+		return
+	}
+	log.Debugf("\n\ntesting scenario %v", s.description)
 	var err error
 	node, err := getExpressionParser().ParseExpression(s.expression)
 	if err != nil {
@@ -192,7 +212,7 @@ func formatYaml(yaml string, filename string) string {
 		panic(err)
 	}
 	streamEvaluator := NewStreamEvaluator()
-	_, err = streamEvaluator.Evaluate(filename, strings.NewReader(yaml), node, printer, NewYamlDecoder(ConfiguredYamlPreferences))
+	_, err = streamEvaluator.Evaluate(filename, strings.NewReader(yaml), node, printer, testingDecoder)
 	if err != nil {
 		panic(err)
 	}
@@ -202,7 +222,8 @@ func formatYaml(yaml string, filename string) string {
 type documentScenarioFunc func(t *testing.T, writer *bufio.Writer, scenario interface{})
 
 func documentScenarios(t *testing.T, folder string, title string, scenarios []interface{}, documentScenario documentScenarioFunc) {
-	f, err := os.Create(fmt.Sprintf("doc/%v/%v.md", folder, title))
+	filename := fmt.Sprintf("doc/%v/%v.md", folder, title)
+	f, err := os.Create(filename)
 
 	if err != nil {
 		t.Error(err)
@@ -232,6 +253,22 @@ func documentScenarios(t *testing.T, folder string, title string, scenarios []in
 	w.Flush()
 }
 
+func appendOperatorDocumentScenario(t *testing.T, title string, scenarios []expressionScenario) {
+	filename := fmt.Sprintf("doc/%v/%v.md", "operators", title)
+	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_APPEND, fs.ModeAppend)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer f.Close()
+	w := bufio.NewWriter(f)
+	for _, s := range scenarios {
+		documentOperatorScenario(t, w, s)
+	}
+	w.Flush()
+
+}
+
 func documentOperatorScenarios(t *testing.T, title string, scenarios []expressionScenario) {
 	genericScenarios := make([]interface{}, len(scenarios))
 	for i, s := range scenarios {

pkg/yqlib/printer_node_info.go

@@ -0,0 +1,76 @@
+package yqlib
+
+import (
+	"bufio"
+	"container/list"
+	"io"
+
+	"go.yaml.in/yaml/v3"
+)
+
+type nodeInfoPrinter struct {
+	printerWriter  PrinterWriter
+	appendixReader io.Reader
+	printedMatches bool
+}
+
+func NewNodeInfoPrinter(printerWriter PrinterWriter) Printer {
+	return &nodeInfoPrinter{
+		printerWriter: printerWriter,
+	}
+}
+
+func (p *nodeInfoPrinter) SetNulSepOutput(_ bool) {
+}
+
+func (p *nodeInfoPrinter) SetAppendix(reader io.Reader) {
+	p.appendixReader = reader
+}
+
+func (p *nodeInfoPrinter) PrintedAnything() bool {
+	return p.printedMatches
+}
+
+func (p *nodeInfoPrinter) PrintResults(matchingNodes *list.List) error {
+
+	for el := matchingNodes.Front(); el != nil; el = el.Next() {
+		mappedDoc := el.Value.(*CandidateNode)
+		writer, errorWriting := p.printerWriter.GetWriter(mappedDoc)
+		if errorWriting != nil {
+			return errorWriting
+		}
+		bytes, err := yaml.Marshal(mappedDoc.ConvertToNodeInfo())
+		if err != nil {
+			return err
+		}
+		if _, err := writer.Write(bytes); err != nil {
+			return err
+		}
+		if _, err := writer.Write([]byte("\n")); err != nil {
+			return err
+		}
+		p.printedMatches = true
+		if err := writer.Flush(); err != nil {
+			return err
+		}
+	}
+
+	if p.appendixReader != nil {
+		writer, err := p.printerWriter.GetWriter(nil)
+		if err != nil {
+			return err
+		}
+
+		log.Debug("Piping appendix reader...")
+		betterReader := bufio.NewReader(p.appendixReader)
+		_, err = io.Copy(writer, betterReader)
+		if err != nil {
+			return err
+		}
+		if err := writer.Flush(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

pkg/yqlib/printer_node_info_test.go

@@ -0,0 +1,51 @@
+package yqlib
+
+import (
+	"bufio"
+	"bytes"
+	"container/list"
+	"strings"
+	"testing"
+
+	"github.com/mikefarah/yq/v4/test"
+)
+
+func TestNodeInfoPrinter_PrintResults(t *testing.T) {
+	// Create a simple CandidateNode
+	node := &CandidateNode{
+		Kind:        ScalarNode,
+		Style:       DoubleQuotedStyle,
+		Tag:         "!!str",
+		Value:       "hello world",
+		Line:        5,
+		Column:      7,
+		HeadComment: "head",
+		LineComment: "line",
+		FootComment: "foot",
+		Anchor:      "anchor",
+	}
+	listNodes := list.New()
+	listNodes.PushBack(node)
+
+	var output bytes.Buffer
+	writer := bufio.NewWriter(&output)
+	printer := NewNodeInfoPrinter(NewSinglePrinterWriter(writer))
+	err := printer.PrintResults(listNodes)
+	writer.Flush()
+	if err != nil {
+		t.Fatalf("PrintResults error: %v", err)
+	}
+
+	outStr := output.String()
+	// Check for key NodeInfo fields in YAML output using substring checks
+	test.AssertResult(t, true, strings.Contains(outStr, "kind: ScalarNode"))
+	test.AssertResult(t, true, strings.Contains(outStr, "style: DoubleQuotedStyle"))
+	test.AssertResult(t, true, strings.Contains(outStr, "tag: '!!str'"))
+	test.AssertResult(t, true, strings.Contains(outStr, "value: hello world"))
+	test.AssertResult(t, true, strings.Contains(outStr, "line: 5"))
+	test.AssertResult(t, true, strings.Contains(outStr, "column: 7"))
+	test.AssertResult(t, true, strings.Contains(outStr, "headComment: head"))
+	test.AssertResult(t, true, strings.Contains(outStr, "lineComment: line"))
+	test.AssertResult(t, true, strings.Contains(outStr, "footComment: foot"))
+	test.AssertResult(t, true, strings.Contains(outStr, "anchor: anchor"))
+}

pkg/yqlib/yaml.go

@@ -7,6 +7,7 @@ type YamlPreferences struct {
 	PrintDocSeparators          bool
 	UnwrapScalar                bool
 	EvaluateTogether            bool
+	FixMergeAnchorToSpec        bool
 }
 
 func NewDefaultYamlPreferences() YamlPreferences {
@@ -17,6 +18,7 @@ func NewDefaultYamlPreferences() YamlPreferences {
 		PrintDocSeparators:          true,
 		UnwrapScalar:                true,
 		EvaluateTogether:            false,
+		FixMergeAnchorToSpec:        false,
 	}
 }
 
@@ -28,6 +30,7 @@ func (p *YamlPreferences) Copy() YamlPreferences {
 		PrintDocSeparators:          p.PrintDocSeparators,
 		UnwrapScalar:                p.UnwrapScalar,
 		EvaluateTogether:            p.EvaluateTogether,
+		FixMergeAnchorToSpec:        p.FixMergeAnchorToSpec,
 	}
 }
 

pkg/yqlib/yaml_test.go

@@ -84,6 +84,13 @@ var yamlFormatScenarios = []formatScenario{
 }
 
 var yamlParseScenarios = []expressionScenario{
+	// {
+	// 	description: "with a unquoted question mark in the string",
+	// 	document:    "foo: {bar: a?bc}",
+	// 	expected: []string{
+	// 		"D0, P[], (!!map)::a: hello # things\n",
+	// 	},
+	// },
 	{
 		document: `a: hello # things`,
 		expected: []string{

project-words.txt

@@ -256,4 +256,13 @@ tonumber
 noyaml
 nolint
 shortfile
-Unmarshalling
+Unmarshalling
+noini
+nocsv
+nobase64
+nouri
+noprops
+nosh
+noshell
+tinygo
+nonexistent

release_notes.txt

@@ -1,3 +1,12 @@
+4.46.1:
+  - Added INI support
+  - Fixed 'add' operator when piped in with no data #2378, #2383, #2384
+  - Fixed delete after slice problem (bad node path) #2387 Thanks @antoinedeschenes
+  - Fixed yq small build Thanks @imzue
+  - Switched to YAML org supported go-yaml!
+  - Bumped dependencies
+
+
 4.45.4:
   - Fixing wrong map() behaviour on empty map #2359
   - Bumped dependencies

scripts/build-small-yq.sh

@@ -1,2 +1,2 @@
 #!/bin/bash
-go build -tags "yq_nolua yq_notoml yq_noxml yq_nojson" -ldflags "-s -w" .
+go build -tags "yq_nolua yq_noini yq_notoml yq_noxml yq_nojson" -ldflags "-s -w" .

scripts/build-tinygo-yq.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+# Currently, the `yq_nojson` feature must be enabled when using TinyGo.
+tinygo build -no-debug -tags "yq_nolua yq_noini yq_notoml yq_noxml yq_nojson yq_nocsv yq_nobase64 yq_nouri yq_noprops yq_nosh yq_noshell" .

scripts/compare-jq.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -e
+
+exp=$1
+file=$2
+
+if [ "$2" == "" ]; then
+    echo "yq"
+    ./yq -oj -n "$1"
+    echo "jq"
+    jq -n "$1"
+    
+else
+
+    echo "yq"
+    ./yq -oj "$1" $2
+    echo "jq"
+    ./yq $2 -oj | jq "$1"
+fi

scripts/compare-versions-output.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+test_data='
+- foo: false
+'
+
+for version in 4.45.1 4.45.2 4.45.3; do
+  for command in '.[] | (select(.foo) | {"foo": .foo} // {})' '.[] | (select(.foo) | {.foo} // {})'; do
+    echo ${version} "${command}"
+    echo -------
+    echo "${test_data}" | podman run -i --rm  mikefarah/yq:${version} -o json "${command}"
+    echo -------
+    echo
+  done
+done

scripts/devtools.sh

@@ -2,4 +2,4 @@
 set -ex
 go mod download golang.org/x/tools@latest
 curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v2.1.5
-curl -sSfL https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh -s
+curl -sSfL https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh -s v2.22.5

snap/snapcraft.yaml

@@ -1,5 +1,5 @@
 name: yq
-version: 'v4.45.4'
+version: 'v4.46.1'
 summary: A lightweight and portable command-line data file processor
 description: |
   `yq` uses [jq](https://github.com/stedolan/jq) like syntax but works with yaml, json, xml, csv, properties and TOML files.
@@ -7,13 +7,16 @@ base: core22
 grade: stable # devel|stable. must be 'stable' to release into candidate/stable channels
 confinement: strict
 architectures:
-  - build-on: s390x
-  - build-on: ppc64el
-  - build-on: arm64
-  - build-on: armhf
-  - build-on: amd64
-  - build-on: i386
-  - build-on: riscv64
+  - build-on: [amd64]
+    build-for: [all]
+# architectures:
+#   - build-on: s390x
+#   - build-on: ppc64el
+#   - build-on: arm64
+#   - build-on: armhf
+#   - build-on: amd64
+#   - build-on: i386
+#   - build-on: riscv64
 apps:
   yq:
     command: bin/yq
@@ -24,6 +27,6 @@ parts:
     build-environment:
       - CGO_ENABLED: 0
     source: https://github.com/mikefarah/yq.git
-    source-tag: v4.45.4
+    source-tag: v4.46.1
     build-snaps:
       - go/latest/stable

test/format_test.go

@@ -0,0 +1,36 @@
+package test
+
+import (
+	"testing"
+
+	"github.com/mikefarah/yq/v4/pkg/yqlib"
+)
+
+// only test format detection based on filename extension
+func TestFormatStringFromFilename(t *testing.T) {
+	cases := []struct {
+		filename string
+		expected string
+	}{
+		// filenames that have extensions
+		{"file.yaml", "yaml"},
+		{"FILE.JSON", "json"},
+		{"file.properties", "properties"},
+		{"file.xml", "xml"},
+		{"file.unknown", "unknown"},
+
+		// filenames without extensions
+		{"file", "yaml"},
+		{"a.dir/file", "yaml"},
+		{"file.", "yaml"},
+		{".", "yaml"},
+		{"", "yaml"},
+	}
+
+	for _, c := range cases {
+		result := yqlib.FormatStringFromFilename(c.filename)
+		if result != c.expected {
+			t.Errorf("FormatStringFromFilename(%q) = %q, wanted: %q", c.filename, result, c.expected)
+		}
+	}
+}