package cmd

import (
        "os"

        "github.com/spf13/cobra"
)

var completionCmd = &cobra.Command{
        Use:     "completion [bash|zsh|fish|powershell]",
        Aliases: []string{"shell-completion"},
        Short:   "Generate the autocompletion script for the specified shell",
        Long: `To load completions:

Bash:

$ source <(yq completion bash)

# To load completions for each session, execute once:
Linux:
  $ yq completion bash > /etc/bash_completion.d/yq
MacOS:
  $ yq completion bash > /usr/local/etc/bash_completion.d/yq

Zsh:

# If shell completion is not already enabled in your environment you will need
# to enable it.  You can execute the following once:

$ echo "autoload -U compinit; compinit" >> ~/.zshrc

# To load completions for each session, execute once:
$ yq completion zsh > "${fpath[1]}/_yq"

# You will need to start a new shell for this setup to take effect.

Fish:

$ yq completion fish | source

# To load completions for each session, execute once:
$ yq completion fish > ~/.config/fish/completions/yq.fish
`,
        DisableFlagsInUseLine: true,
        ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
        Args:                  cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
        RunE: func(cmd *cobra.Command, args []string) error {
                var err error = nil
                switch args[0] {
                case "bash":
                        err = cmd.Root().GenBashCompletionV2(os.Stdout, true)
                case "zsh":
                        err = cmd.Root().GenZshCompletion(os.Stdout)
                case "fish":
                        err = cmd.Root().GenFishCompletion(os.Stdout, true)
                case "powershell":
                        err = cmd.Root().GenPowerShellCompletion(os.Stdout)
                }
                return err

        },
}

package cmd

import (
        "errors"

        "github.com/mikefarah/yq/v4/pkg/yqlib"
        "github.com/spf13/cobra"
)

func createEvaluateAllCommand() *cobra.Command {
        var cmdEvalAll = &cobra.Command{
                Use:     "eval-all [expression] [yaml_file1]...",
                Aliases: []string{"ea"},
                Short:   "Loads _all_ yaml documents of _all_ yaml files and runs expression once",
                ValidArgsFunction: func(_ *cobra.Command, args []string, _ string) ([]string, cobra.ShellCompDirective) {
                        if len(args) == 0 {
                                return nil, cobra.ShellCompDirectiveNoFileComp
                        }
                        return nil, cobra.ShellCompDirectiveDefault
                },
                Example: `
# Merge f2.yml into f1.yml (in place)
yq eval-all --inplace 'select(fileIndex == 0) * select(fileIndex == 1)' f1.yml f2.yml
## the same command and expression using shortened names:
yq ea -i 'select(fi == 0) * select(fi == 1)' f1.yml f2.yml


# Merge all given files
yq ea '. as $item ireduce ({}; . * $item )' file1.yml file2.yml ...

# Pipe from STDIN
## use '-' as a filename to pipe from STDIN
cat file2.yml | yq ea '.a.b' file1.yml - file3.yml
`,
                Long: `yq is a portable command-line data file processor (https://github.com/mikefarah/yq/) 
See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.

## Evaluate All ##
This command loads _all_ yaml documents of _all_ yaml files and runs expression once
Useful when you need to run an expression across several yaml documents or files (like merge).
Note that it consumes more memory than eval.
`,
                RunE: evaluateAll,
        }
        return cmdEvalAll
}
func evaluateAll(cmd *cobra.Command, args []string) (cmdError error) {
        // 0 args, read std in
        // 1 arg, null input, process expression
        // 1 arg, read file in sequence
        // 2+ args, [0] = expression, file the rest

        var err error

        expression, args, err := initCommand(cmd, args)
        if err != nil {
                return err
        }

        out := cmd.OutOrStdout()

        if writeInplace {
                // only use colours if its forced
                colorsEnabled = forceColor
                writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[0])
                out, err = writeInPlaceHandler.CreateTempFile()
                if err != nil {
                        return err
                }
                // need to indirectly call the function so  that completedSuccessfully is
                // passed when we finish execution as opposed to now
                defer func() {
                        if cmdError == nil {
                                cmdError = writeInPlaceHandler.FinishWriteInPlace(completedSuccessfully)
                        }
                }()
        }

        format, err := yqlib.FormatFromString(outputFormat)
        if err != nil {
                return err
        }

        decoder, err := configureDecoder(true)
        if err != nil {
                return err
        }

        printerWriter, err := configurePrinterWriter(format, out)
        if err != nil {
                return err
        }
        encoder, err := configureEncoder()
        if err != nil {
                return err
        }

        printer := yqlib.NewPrinter(encoder, printerWriter)
        if nulSepOutput {
                printer.SetNulSepOutput(true)
        }

        if frontMatter != "" {
                frontMatterHandler := yqlib.NewFrontMatterHandler(args[0])
                err = frontMatterHandler.Split()
                if err != nil {
                        return err
                }
                args[0] = frontMatterHandler.GetYamlFrontMatterFilename()

                if frontMatter == "process" {
                        reader := frontMatterHandler.GetContentReader()
                        printer.SetAppendix(reader)
                        defer yqlib.SafelyCloseReader(reader)
                }
                defer frontMatterHandler.CleanUp()
        }

        allAtOnceEvaluator := yqlib.NewAllAtOnceEvaluator()

        switch len(args) {
        case 0:
                if nullInput {
                        err = yqlib.NewStreamEvaluator().EvaluateNew(processExpression(expression), printer)
                } else {
                        cmd.Println(cmd.UsageString())
                        return nil
                }
        default:
                err = allAtOnceEvaluator.EvaluateFiles(processExpression(expression), args, printer, decoder)
        }

        completedSuccessfully = err == nil

        if err == nil && exitStatus && !printer.PrintedAnything() {
                return errors.New("no matches found")
        }

        return err
}

package cmd

import (
        "errors"
        "fmt"

        "github.com/mikefarah/yq/v4/pkg/yqlib"
        "github.com/spf13/cobra"
)

func createEvaluateSequenceCommand() *cobra.Command {
        var cmdEvalSequence = &cobra.Command{
                Use:     "eval [expression] [yaml_file1]...",
                Aliases: []string{"e"},
                Short:   "(default) Apply the expression to each document in each yaml file in sequence",
                ValidArgsFunction: func(_ *cobra.Command, args []string, _ string) ([]string, cobra.ShellCompDirective) {
                        if len(args) == 0 {
                                return nil, cobra.ShellCompDirectiveNoFileComp
                        }
                        return nil, cobra.ShellCompDirectiveDefault
                },
                Example: `
# Reads field under the given path for each file
yq e '.a.b' f1.yml f2.yml 

# Prints out the file
yq e sample.yaml 

# Pipe from STDIN
## use '-' as a filename to pipe from STDIN
cat file2.yml | yq e '.a.b' file1.yml - file3.yml

# Creates a new yaml document
## Note that editing an empty file does not work.
yq e -n '.a.b.c = "cat"' 

# Update a file in place
yq e '.a.b = "cool"' -i file.yaml 
`,
                Long: `yq is a portable command-line data file processor (https://github.com/mikefarah/yq/) 
See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.

## Evaluate Sequence ##
This command iterates over each yaml document from each given file, applies the 
expression and prints the result in sequence.`,
                RunE: evaluateSequence,
        }
        return cmdEvalSequence
}

func processExpression(expression string) string {

        if prettyPrint && expression == "" {
                return yqlib.PrettyPrintExp
        } else if prettyPrint {
                return fmt.Sprintf("%v | %v", expression, yqlib.PrettyPrintExp)
        }
        return expression
}

func evaluateSequence(cmd *cobra.Command, args []string) (cmdError error) {
        // 0 args, read std in
        // 1 arg, null input, process expression
        // 1 arg, read file in sequence
        // 2+ args, [0] = expression, file the rest

        out := cmd.OutOrStdout()

        var err error

        expression, args, err := initCommand(cmd, args)
        if err != nil {
                return err
        }

        if writeInplace {
                // only use colours if its forced
                colorsEnabled = forceColor
                writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[0])
                out, err = writeInPlaceHandler.CreateTempFile()
                if err != nil {
                        return err
                }
                // need to indirectly call the function so  that completedSuccessfully is
                // passed when we finish execution as opposed to now
                defer func() {
                        if cmdError == nil {
                                cmdError = writeInPlaceHandler.FinishWriteInPlace(completedSuccessfully)
                        }
                }()
        }

        format, err := yqlib.FormatFromString(outputFormat)
        if err != nil {
                return err
        }

        printerWriter, err := configurePrinterWriter(format, out)
        if err != nil {
                return err
        }
        encoder, err := configureEncoder()
        if err != nil {
                return err
        }

        printer := yqlib.NewPrinter(encoder, printerWriter)

        if printNodeInfo {
                printer = yqlib.NewNodeInfoPrinter(printerWriter)
        }

        if nulSepOutput {
                printer.SetNulSepOutput(true)
        }

        decoder, err := configureDecoder(false)
        if err != nil {
                return err
        }
        streamEvaluator := yqlib.NewStreamEvaluator()

        if frontMatter != "" {
                yqlib.GetLogger().Debug("using front matter handler")
                frontMatterHandler := yqlib.NewFrontMatterHandler(args[0])
                err = frontMatterHandler.Split()
                if err != nil {
                        return err
                }
                args[0] = frontMatterHandler.GetYamlFrontMatterFilename()

                if frontMatter == "process" {
                        reader := frontMatterHandler.GetContentReader()
                        printer.SetAppendix(reader)
                        defer yqlib.SafelyCloseReader(reader)
                }
                defer frontMatterHandler.CleanUp()
        }

        switch len(args) {
        case 0:
                if nullInput {
                        err = streamEvaluator.EvaluateNew(processExpression(expression), printer)
                } else {
                        cmd.Println(cmd.UsageString())
                        return nil
                }
        default:
                err = streamEvaluator.EvaluateFiles(processExpression(expression), args, printer, decoder)
        }
        completedSuccessfully = err == nil

        if err == nil && exitStatus && !printer.PrintedAnything() {
                return errors.New("no matches found")
        }

        return err
}

package cmd

import (
        "fmt"
        "os"
        "strings"

        "github.com/mikefarah/yq/v4/pkg/yqlib"
        "github.com/spf13/cobra"
        logging "gopkg.in/op/go-logging.v1"
)

type runeValue rune

func newRuneVar(p *rune) *runeValue {
        return (*runeValue)(p)
}

func (r *runeValue) String() string {
        return string(*r)
}

func (r *runeValue) Set(rawVal string) error {
        val := strings.ReplaceAll(rawVal, "\\n", "\n")
        val = strings.ReplaceAll(val, "\\t", "\t")
        val = strings.ReplaceAll(val, "\\r", "\r")
        val = strings.ReplaceAll(val, "\\f", "\f")
        val = strings.ReplaceAll(val, "\\v", "\v")
        if len(val) != 1 {
                return fmt.Errorf("[%v] is not a valid character. Must be length 1 was %v", val, len(val))
        }
        *r = runeValue(rune(val[0]))
        return nil
}

func (r *runeValue) Type() string {
        return "char"
}

func New() *cobra.Command {
        var rootCmd = &cobra.Command{
                Use:   "yq",
                Short: "yq is a lightweight and portable command-line data file processor.",
                Long: `yq is a portable command-line data file processor (https://github.com/mikefarah/yq/) 
See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.`,
                Example: `
# yq tries to auto-detect the file format based off the extension, and defaults to YAML if it's unknown (or piping through STDIN)
# Use the '-p/--input-format' flag to specify a format type.
cat file.xml | yq -p xml

# read the "stuff" node from "myfile.yml"
yq '.stuff' < myfile.yml

# update myfile.yml in place
yq -i '.stuff = "foo"' myfile.yml

# print contents of sample.json as idiomatic YAML
yq -P -oy sample.json
`,

                RunE: func(cmd *cobra.Command, args []string) error {
                        if version {
                                cmd.Print(GetVersionDisplay())
                                return nil
                        }
                        return evaluateSequence(cmd, args)

                },
                PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
                        cmd.SetOut(cmd.OutOrStdout())
                        level := logging.WARNING
                        stringFormat := `[%{level}] %{color}%{time:15:04:05}%{color:reset} %{message}`

                        // when NO_COLOR environment variable presents and not an empty string the coloured output should be disabled;
                        // refer to no-color.org
                        forceNoColor = forceNoColor || os.Getenv("NO_COLOR") != ""

                        if verbose && forceNoColor {
                                level = logging.DEBUG
                                stringFormat = `[%{level:5.5s}] %{time:15:04:05} %{shortfile:-33s} %{shortfunc:-25s} %{message}`
                        } else if verbose {
                                level = logging.DEBUG
                                stringFormat = `[%{level:5.5s}] %{color}%{time:15:04:05}%{color:bold} %{shortfile:-33s} %{shortfunc:-25s}%{color:reset} %{message}`
                        } else if forceNoColor {
                                stringFormat = `[%{level}] %{time:15:04:05} %{message}`
                        }

                        var format = logging.MustStringFormatter(stringFormat)
                        var backend = logging.AddModuleLevel(
                                logging.NewBackendFormatter(logging.NewLogBackend(os.Stderr, "", 0), format))

                        backend.SetLevel(level, "")

                        logging.SetBackend(backend)
                        yqlib.InitExpressionParser()

                        return nil
                },
        }

        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")
        if err != nil {
                panic(err)
        }

        rootCmd.PersistentFlags().StringVarP(&outputFormat, "output-format", "o", "auto", fmt.Sprintf("[auto|a|%v] output format type.", yqlib.GetAvailableOutputFormatString()))
        var outputCompletions = []string{"auto"}
        for _, formats := range yqlib.GetAvailableOutputFormats() {
                outputCompletions = append(outputCompletions, formats.FormalName)
        }

        if err = rootCmd.RegisterFlagCompletionFunc("output-format", cobra.FixedCompletions(outputCompletions, cobra.ShellCompDirectiveNoFileComp)); err != nil {
                panic(err)
        }
        rootCmd.PersistentFlags().StringVarP(&inputFormat, "input-format", "p", "auto", fmt.Sprintf("[auto|a|%v] parse format for input.", yqlib.GetAvailableInputFormatString()))

        var inputCompletions = []string{"auto"}
        for _, formats := range yqlib.GetAvailableInputFormats() {
                inputCompletions = append(inputCompletions, formats.FormalName)
        }

        if err = rootCmd.RegisterFlagCompletionFunc("input-format", cobra.FixedCompletions(inputCompletions, cobra.ShellCompDirectiveNoFileComp)); err != nil {
                panic(err)
        }

        rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredXMLPreferences.AttributePrefix, "xml-attribute-prefix", yqlib.ConfiguredXMLPreferences.AttributePrefix, "prefix for xml attributes")
        if err = rootCmd.RegisterFlagCompletionFunc("xml-attribute-prefix", cobra.NoFileCompletions); err != nil {
                panic(err)
        }
        rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredXMLPreferences.ContentName, "xml-content-name", yqlib.ConfiguredXMLPreferences.ContentName, "name for xml content (if no attribute name is present).")
        if err = rootCmd.RegisterFlagCompletionFunc("xml-content-name", cobra.NoFileCompletions); err != nil {
                panic(err)
        }
        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.StrictMode, "xml-strict-mode", yqlib.ConfiguredXMLPreferences.StrictMode, "enables strict parsing of XML. See https://pkg.go.dev/encoding/xml for more details.")
        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.KeepNamespace, "xml-keep-namespace", yqlib.ConfiguredXMLPreferences.KeepNamespace, "enables keeping namespace after parsing attributes")
        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.UseRawToken, "xml-raw-token", yqlib.ConfiguredXMLPreferences.UseRawToken, "enables using RawToken method instead Token. Commonly disables namespace translations. See https://pkg.go.dev/encoding/xml#Decoder.RawToken for details.")
        rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredXMLPreferences.ProcInstPrefix, "xml-proc-inst-prefix", yqlib.ConfiguredXMLPreferences.ProcInstPrefix, "prefix for xml processing instructions (e.g. <?xml version=\"1\"?>)")
        if err = rootCmd.RegisterFlagCompletionFunc("xml-proc-inst-prefix", cobra.NoFileCompletions); err != nil {
                panic(err)
        }
        rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredXMLPreferences.DirectiveName, "xml-directive-name", yqlib.ConfiguredXMLPreferences.DirectiveName, "name for xml directives (e.g. <!DOCTYPE thing cat>)")
        if err = rootCmd.RegisterFlagCompletionFunc("xml-directive-name", cobra.NoFileCompletions); err != nil {
                panic(err)
        }
        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.SkipProcInst, "xml-skip-proc-inst", yqlib.ConfiguredXMLPreferences.SkipProcInst, "skip over process instructions (e.g. <?xml version=\"1\"?>)")
        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.SkipDirectives, "xml-skip-directives", yqlib.ConfiguredXMLPreferences.SkipDirectives, "skip over directives (e.g. <!DOCTYPE thing cat>)")

        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredCsvPreferences.AutoParse, "csv-auto-parse", yqlib.ConfiguredCsvPreferences.AutoParse, "parse CSV YAML/JSON values")
        rootCmd.PersistentFlags().Var(newRuneVar(&yqlib.ConfiguredCsvPreferences.Separator), "csv-separator", "CSV Separator character")

        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredTsvPreferences.AutoParse, "tsv-auto-parse", yqlib.ConfiguredTsvPreferences.AutoParse, "parse TSV YAML/JSON values")

        rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredLuaPreferences.DocPrefix, "lua-prefix", yqlib.ConfiguredLuaPreferences.DocPrefix, "prefix")
        if err = rootCmd.RegisterFlagCompletionFunc("lua-prefix", cobra.NoFileCompletions); err != nil {
                panic(err)
        }
        rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredLuaPreferences.DocSuffix, "lua-suffix", yqlib.ConfiguredLuaPreferences.DocSuffix, "suffix")
        if err = rootCmd.RegisterFlagCompletionFunc("lua-suffix", cobra.NoFileCompletions); err != nil {
                panic(err)
        }
        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredLuaPreferences.UnquotedKeys, "lua-unquoted", yqlib.ConfiguredLuaPreferences.UnquotedKeys, "output unquoted string keys (e.g. {foo=\"bar\"})")
        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredLuaPreferences.Globals, "lua-globals", yqlib.ConfiguredLuaPreferences.Globals, "output keys as top-level global variables")

        rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredPropertiesPreferences.KeyValueSeparator, "properties-separator", yqlib.ConfiguredPropertiesPreferences.KeyValueSeparator, "separator to use between keys and values")
        rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredPropertiesPreferences.UseArrayBrackets, "properties-array-brackets", yqlib.ConfiguredPropertiesPreferences.UseArrayBrackets, "use [x] in array paths (e.g. for SpringBoot)")

        rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredShellVariablesPreferences.KeySeparator, "shell-key-separator", yqlib.ConfiguredShellVariablesPreferences.KeySeparator, "separator for shell variable key paths")
        if err = rootCmd.RegisterFlagCompletionFunc("shell-key-separator", cobra.NoFileCompletions); err != nil {
                panic(err)
        }

        rootCmd.PersistentFlags().BoolVar(&yqlib.StringInterpolationEnabled, "string-interpolation", yqlib.StringInterpolationEnabled, "Toggles strings interpolation of \\(exp)")

        rootCmd.PersistentFlags().BoolVarP(&nullInput, "null-input", "n", false, "Don't read input, simply evaluate the expression given. Useful for creating docs from scratch.")
        rootCmd.PersistentFlags().BoolVarP(&noDocSeparators, "no-doc", "N", false, "Don't print document separators (---)")

        rootCmd.PersistentFlags().IntVarP(&indent, "indent", "I", 2, "sets indent level for output")
        if err = rootCmd.RegisterFlagCompletionFunc("indent", cobra.NoFileCompletions); err != nil {
                panic(err)
        }
        rootCmd.Flags().BoolVarP(&version, "version", "V", false, "Print version information and quit")
        rootCmd.PersistentFlags().BoolVarP(&writeInplace, "inplace", "i", false, "update the file in place of first file given.")
        rootCmd.PersistentFlags().VarP(unwrapScalarFlag, "unwrapScalar", "r", "unwrap scalar, print the value with no quotes, colours or comments. Defaults to true for yaml")
        rootCmd.PersistentFlags().Lookup("unwrapScalar").NoOptDefVal = "true"
        rootCmd.PersistentFlags().BoolVarP(&nulSepOutput, "nul-output", "0", false, "Use NUL char to separate values. If unwrap scalar is also set, fail if unwrapped scalar contains NUL char.")

        rootCmd.PersistentFlags().BoolVarP(&prettyPrint, "prettyPrint", "P", false, "pretty print, shorthand for '... style = \"\"'")
        rootCmd.PersistentFlags().BoolVarP(&exitStatus, "exit-status", "e", false, "set exit status if there are no matches or null or false is returned")

        rootCmd.PersistentFlags().BoolVarP(&forceColor, "colors", "C", false, "force print with colors")
        rootCmd.PersistentFlags().BoolVarP(&forceNoColor, "no-colors", "M", forceNoColor, "force print with no colors")
        rootCmd.PersistentFlags().StringVarP(&frontMatter, "front-matter", "f", "", "(extract|process) first input as yaml front-matter. Extract will pull out the yaml content, process will run the expression against the yaml content, leaving the remaining data intact")
        if err = rootCmd.RegisterFlagCompletionFunc("front-matter", cobra.FixedCompletions([]string{"extract", "process"}, cobra.ShellCompDirectiveNoFileComp)); err != nil {
                panic(err)
        }
        rootCmd.PersistentFlags().StringVarP(&forceExpression, "expression", "", "", "forcibly set the expression argument. Useful when yq argument detection thinks your expression is a file.")
        if err = rootCmd.RegisterFlagCompletionFunc("expression", cobra.NoFileCompletions); err != nil {
                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 {
                panic(err)
        }
        rootCmd.PersistentFlags().StringVarP(&splitFileExpFile, "split-exp-file", "", "", "Use a file to specify the split-exp expression.")
        if err = rootCmd.MarkPersistentFlagFilename("split-exp-file"); err != nil {
                panic(err)
        }

        rootCmd.PersistentFlags().StringVarP(&expressionFile, "from-file", "", "", "Load expression from specified file.")
        if err = rootCmd.MarkPersistentFlagFilename("from-file"); err != nil {
                panic(err)
        }

        rootCmd.PersistentFlags().BoolVarP(&yqlib.ConfiguredSecurityPreferences.DisableEnvOps, "security-disable-env-ops", "", false, "Disable env related operations.")
        rootCmd.PersistentFlags().BoolVarP(&yqlib.ConfiguredSecurityPreferences.DisableFileOps, "security-disable-file-ops", "", false, "Disable file related operations (e.g. load)")

        rootCmd.AddCommand(
                createEvaluateSequenceCommand(),
                createEvaluateAllCommand(),
                completionCmd,
        )
        return rootCmd
}

package cmd

import (
        "strconv"

        "github.com/spf13/pflag"
)

type boolFlag interface {
        pflag.Value
        IsExplicitlySet() bool
        IsSet() bool
}

type unwrapScalarFlagStrc struct {
        explicitlySet bool
        value         bool
}

func newUnwrapFlag() boolFlag {
        return &unwrapScalarFlagStrc{value: true}
}

func (f *unwrapScalarFlagStrc) IsExplicitlySet() bool {
        return f.explicitlySet
}

func (f *unwrapScalarFlagStrc) IsSet() bool {
        return f.value
}

func (f *unwrapScalarFlagStrc) String() string {
        return strconv.FormatBool(f.value)
}

func (f *unwrapScalarFlagStrc) Set(value string) error {

        v, err := strconv.ParseBool(value)
        f.value = v
        f.explicitlySet = true
        return err
}

func (*unwrapScalarFlagStrc) Type() string {
        return "bool"
}

package cmd

import (
        "fmt"
        "io"
        "os"
        "strings"

        "github.com/mikefarah/yq/v4/pkg/yqlib"
        "github.com/spf13/cobra"
        "gopkg.in/op/go-logging.v1"
)

func isAutomaticOutputFormat() bool {
        return outputFormat == "" || outputFormat == "auto" || outputFormat == "a"
}

func initCommand(cmd *cobra.Command, args []string) (string, []string, error) {
        cmd.SilenceUsage = 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 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 fmt.Errorf("write in place flag only applicable when giving an expression and at least one file")
        }

        if frontMatter != "" && len(args) == 0 {
                return fmt.Errorf("front matter flag only applicable when giving an expression and at least one file")
        }

        if writeInplace && splitFileExp != "" {
                return fmt.Errorf("write in place cannot be used with split file")
        }

        if nullInput && len(args) > 0 {
                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 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)
                if err != nil {
                        // unknown file type, default to yaml
                        yqlib.GetLogger().Debug("Unknown file format extension '%v', defaulting to yaml", inputFormat)
                        inputFormat = "yaml"
                        if isAutomaticOutputFormat() {
                                outputFormat = "yaml"
                        }
                } else if isAutomaticOutputFormat() {
                        outputFormat = inputFormat
                }
        } else if isAutomaticOutputFormat() {
                // backwards compatibility -
                // before this was introduced, `yq -pcsv things.csv`
                // would produce *yaml* output.
                //
                outputFormat = yqlib.FormatStringFromFilename(inputFilename)
                if inputFilename != "-" {
                        yqlib.GetLogger().Warning("yq default output is now 'auto' (based on the filename extension). Normally yq would output '%v', but for backwards compatibility 'yaml' has been set. Please use -oy to specify yaml, or drop the -p flag.", outputFormat)
                }
                outputFormat = "yaml"
        }
        return nil
}

func configureOutputFormat() error {
        outputFormatType, err := yqlib.FormatFromString(outputFormat)
        if err != nil {
                return err
        }

        if outputFormatType == yqlib.YamlFormat ||
                outputFormatType == yqlib.PropertiesFormat {
                unwrapScalar = true
        }

        return nil
}

func configureUnwrapScalar() {
        if unwrapScalarFlag.IsExplicitlySet() {
                unwrapScalar = unwrapScalarFlag.IsSet()
        }
}

func configureDecoder(evaluateTogether bool) (yqlib.Decoder, error) {
        format, err := yqlib.FormatFromString(inputFormat)
        if err != nil {
                return nil, err
        }
        yqlib.ConfiguredYamlPreferences.EvaluateTogether = evaluateTogether

        if format.DecoderFactory == nil {
                return nil, fmt.Errorf("no support for %s input format", inputFormat)
        }
        yqlibDecoder := format.DecoderFactory()
        if yqlibDecoder == nil {
                return nil, fmt.Errorf("no support for %s input format", inputFormat)
        }
        return yqlibDecoder, nil
}

func configurePrinterWriter(format *yqlib.Format, out io.Writer) (yqlib.PrinterWriter, error) {

        var printerWriter yqlib.PrinterWriter

        if splitFileExp != "" {
                colorsEnabled = forceColor
                splitExp, err := yqlib.ExpressionParser.ParseExpression(splitFileExp)
                if err != nil {
                        return nil, fmt.Errorf("bad split document expression: %w", err)
                }
                printerWriter = yqlib.NewMultiPrinterWriter(splitExp, format)
        } else {
                printerWriter = yqlib.NewSinglePrinterWriter(out)
        }
        return printerWriter, nil
}

func configureEncoder() (yqlib.Encoder, error) {
        yqlibOutputFormat, err := yqlib.FormatFromString(outputFormat)
        if err != nil {
                return nil, err
        }
        yqlib.ConfiguredXMLPreferences.Indent = indent
        yqlib.ConfiguredYamlPreferences.Indent = indent
        yqlib.ConfiguredKYamlPreferences.Indent = indent
        yqlib.ConfiguredJSONPreferences.Indent = indent

        yqlib.ConfiguredYamlPreferences.UnwrapScalar = unwrapScalar
        yqlib.ConfiguredKYamlPreferences.UnwrapScalar = unwrapScalar
        yqlib.ConfiguredPropertiesPreferences.UnwrapScalar = unwrapScalar
        yqlib.ConfiguredJSONPreferences.UnwrapScalar = unwrapScalar

        yqlib.ConfiguredYamlPreferences.ColorsEnabled = colorsEnabled
        yqlib.ConfiguredKYamlPreferences.ColorsEnabled = colorsEnabled
        yqlib.ConfiguredJSONPreferences.ColorsEnabled = colorsEnabled
        yqlib.ConfiguredHclPreferences.ColorsEnabled = colorsEnabled
        yqlib.ConfiguredTomlPreferences.ColorsEnabled = colorsEnabled

        yqlib.ConfiguredYamlPreferences.PrintDocSeparators = !noDocSeparators
        yqlib.ConfiguredKYamlPreferences.PrintDocSeparators = !noDocSeparators

        encoder := yqlibOutputFormat.EncoderFactory()

        if encoder == nil {
                return nil, fmt.Errorf("no support for %s output format", outputFormat)
        }
        return encoder, err
}

// this is a hack to enable backwards compatibility with githubactions (which pipe /dev/null into everything)
// and being able to call yq with the filename as a single parameter
//
// without this - yq detects there is stdin (thanks githubactions),
// then tries to parse the filename as an expression
func maybeFile(str string) bool {
        yqlib.GetLogger().Debugf("checking '%v' is a file", str)
        stat, err := os.Stat(str) // #nosec
        result := err == nil && !stat.IsDir()
        if yqlib.GetLogger().IsEnabledFor(logging.DEBUG) {
                if err != nil {
                        yqlib.GetLogger().Debugf("error: %v", err)
                } else {
                        yqlib.GetLogger().Debugf("error: %v, dir: %v", err, stat.IsDir())
                }
                yqlib.GetLogger().Debugf("result: %v", result)
        }
        return result
}

func processStdInArgs(args []string) []string {
        stat, err := os.Stdin.Stat()
        if err != nil {
                yqlib.GetLogger().Debugf("error getting stdin: %v", err)
        }
        pipingStdin := stat != nil && (stat.Mode()&os.ModeCharDevice) == 0

        // if we've been given a file, don't automatically
        // read from stdin.
        // this happens if there is more than one argument
        // or only one argument and its a file
        if nullInput || !pipingStdin || len(args) > 1 || (len(args) > 0 && maybeFile(args[0])) {
                return args
        }

        for _, arg := range args {
                if arg == "-" {
                        return args
                }
        }
        yqlib.GetLogger().Debugf("missing '-', adding it to the end")

        // we're piping from stdin, but there's no '-' arg
        // lets add one to the end
        return append(args, "-")
}

func processArgs(originalArgs []string) (string, []string, error) {
        expression := forceExpression
        args := processStdInArgs(originalArgs)
        maybeFirstArgIsAFile := len(args) > 0 && maybeFile(args[0])

        if expressionFile == "" && maybeFirstArgIsAFile && strings.HasSuffix(args[0], ".yq") {
                // lets check if an expression file was given
                yqlib.GetLogger().Debug("Assuming arg %v is an expression file", args[0])
                expressionFile = args[0]
                args = args[1:]
        }

        if expressionFile != "" {
                expressionBytes, err := os.ReadFile(expressionFile)
                if err != nil {
                        return "", nil, err
                }
                //replace \r\n (windows) with good ol' unix file endings.
                expression = strings.ReplaceAll(string(expressionBytes), "\r\n", "\n")
        }

        yqlib.GetLogger().Debugf("processed args: %v", args)
        if expression == "" && len(args) > 0 && args[0] != "-" && !maybeFile(args[0]) {
                yqlib.GetLogger().Debug("assuming expression is '%v'", args[0])
                expression = args[0]
                args = args[1:]
        }
        return expression, args, nil
}

package cmd

import (
        "fmt"
        "strings"
)

// The git commit that was compiled. This will be filled in by the compiler.
var (
        GitCommit   string
        GitDescribe string

        // Version is main version number that is being run at the moment.
        Version = "v4.50.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
        // such as "dev" (in development), "beta", "rc1", etc.
        VersionPrerelease = ""
)

// ProductName is the name of the product
const ProductName = "yq"

// GetVersionDisplay composes the parts of the version in a way that's suitable
// for displaying to humans.
func GetVersionDisplay() string {
        return fmt.Sprintf("yq (https://github.com/mikefarah/yq/) version %s\n", getHumanVersion())
}

func getHumanVersion() string {
        version := Version
        if GitDescribe != "" {
                version = GitDescribe
        }

        release := VersionPrerelease
        if release != "" {
                if !strings.Contains(version, release) {
                        version += fmt.Sprintf("-%s", release)
                }
                if GitCommit != "" {
                        version += fmt.Sprintf(" (%s)", GitCommit)
                }
        }

        // Strip off any single quotes added by the git information.
        return strings.ReplaceAll(version, "'", "")
}

package yqlib

import (
        "container/list"
)

// A yaml expression evaluator that runs the expression once against all files/nodes in memory.
type Evaluator interface {
        EvaluateFiles(expression string, filenames []string, printer Printer, decoder Decoder) error

        // EvaluateNodes takes an expression and one or more yaml nodes, returning a list of matching candidate nodes
        EvaluateNodes(expression string, nodes ...*CandidateNode) (*list.List, error)

        // EvaluateCandidateNodes takes an expression and list of candidate nodes, returning a list of matching candidate nodes
        EvaluateCandidateNodes(expression string, inputCandidateNodes *list.List) (*list.List, error)
}

type allAtOnceEvaluator struct {
        treeNavigator DataTreeNavigator
}

func NewAllAtOnceEvaluator() Evaluator {
        InitExpressionParser()
        return &allAtOnceEvaluator{treeNavigator: NewDataTreeNavigator()}
}

func (e *allAtOnceEvaluator) EvaluateNodes(expression string, nodes ...*CandidateNode) (*list.List, error) {
        inputCandidates := list.New()
        for _, node := range nodes {
                inputCandidates.PushBack(node)
        }
        return e.EvaluateCandidateNodes(expression, inputCandidates)
}

func (e *allAtOnceEvaluator) EvaluateCandidateNodes(expression string, inputCandidates *list.List) (*list.List, error) {
        node, err := ExpressionParser.ParseExpression(expression)
        if err != nil {
                return nil, err
        }
        context, err := e.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputCandidates}, node)
        if err != nil {
                return nil, err
        }
        return context.MatchingNodes, nil
}

func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer, decoder Decoder) error {
        fileIndex := 0

        var allDocuments = list.New()
        for _, filename := range filenames {
                reader, err := readStream(filename)
                if err != nil {
                        return err
                }

                fileDocuments, err := readDocuments(reader, filename, fileIndex, decoder)
                if err != nil {
                        return err
                }
                allDocuments.PushBackList(fileDocuments)
                fileIndex = fileIndex + 1
        }

        if allDocuments.Len() == 0 {
                candidateNode := createScalarNode(nil, "")
                allDocuments.PushBack(candidateNode)
        }

        matches, err := e.EvaluateCandidateNodes(expression, allDocuments)
        if err != nil {
                return err
        }
        return printer.PrintResults(matches)
}

package yqlib

import (
        "container/list"
        "fmt"
        "strconv"
        "strings"
)

type Kind uint32

const (
        SequenceNode Kind = 1 << iota
        MappingNode
        ScalarNode
        AliasNode
)

type Style uint32

const (
        TaggedStyle Style = 1 << iota
        DoubleQuotedStyle
        SingleQuotedStyle
        LiteralStyle
        FoldedStyle
        FlowStyle
)

func createStringScalarNode(stringValue string) *CandidateNode {
        var node = &CandidateNode{Kind: ScalarNode}
        node.Value = stringValue
        node.Tag = "!!str"
        return node
}

func createScalarNode(value interface{}, stringValue string) *CandidateNode {
        var node = &CandidateNode{Kind: ScalarNode}
        node.Value = stringValue

        switch value.(type) {
        case float32, float64:
                node.Tag = "!!float"
        case int, int64, int32:
                node.Tag = "!!int"
        case bool:
                node.Tag = "!!bool"
        case string:
                node.Tag = "!!str"
        case nil:
                node.Tag = "!!null"
        }
        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

        Tag     string
        Value   string
        Anchor  string
        Alias   *CandidateNode
        Content []*CandidateNode

        HeadComment string
        LineComment string
        FootComment string

        Parent *CandidateNode // parent node
        Key    *CandidateNode // node key, if this is a value from a map (or index in an array)

        LeadingContent string

        document uint // the document index of this node
        filename string

        Line   int
        Column int

        fileIndex int
        // when performing op against all nodes given, this will treat all the nodes as one
        // (e.g. top level cross document merge). This property does not propagate to child nodes.
        EvaluateTogether bool
        IsMapKey         bool
        // For formats like HCL and TOML: indicates that child entries should be emitted as separate blocks/tables
        // rather than consolidated into nested mappings (default behaviour)
        EncodeSeparate bool
}

func (n *CandidateNode) CreateChild() *CandidateNode {
        return &CandidateNode{
                Parent: n,
        }
}

func (n *CandidateNode) SetDocument(idx uint) {
        n.document = idx
}

func (n *CandidateNode) GetDocument() uint {
        // defer to parent
        if n.Parent != nil {
                return n.Parent.GetDocument()
        }
        return n.document
}

func (n *CandidateNode) SetFilename(name string) {
        n.filename = name
}

func (n *CandidateNode) GetFilename() string {
        if n.Parent != nil {
                return n.Parent.GetFilename()
        }
        return n.filename
}

func (n *CandidateNode) SetFileIndex(idx int) {
        n.fileIndex = idx
}

func (n *CandidateNode) GetFileIndex() int {
        if n.Parent != nil {
                return n.Parent.GetFileIndex()
        }
        return n.fileIndex
}

func (n *CandidateNode) GetKey() string {
        keyPrefix := ""
        if n.IsMapKey {
                keyPrefix = fmt.Sprintf("key-%v-", n.Value)
        }
        key := ""
        if n.Key != nil {
                key = n.Key.Value
        }
        return fmt.Sprintf("%v%v - %v", keyPrefix, n.GetDocument(), key)
}

func (n *CandidateNode) getParsedKey() interface{} {
        if n.IsMapKey {
                return n.Value
        }
        if n.Key == nil {
                return nil
        }
        if n.Key.Tag == "!!str" {
                return n.Key.Value
        }
        index, err := parseInt(n.Key.Value)
        if err != nil {
                return n.Key.Value
        }
        return index

}

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 {
                return append(n.Parent.GetPath(), key)
        }

        if key != nil {
                return []interface{}{key}
        }
        return make([]interface{}, 0)
}

func (n *CandidateNode) GetNicePath() string {
        var sb strings.Builder
        path := n.GetPath()
        for i, element := range path {
                elementStr := fmt.Sprintf("%v", element)
                switch element.(type) {
                case int:
                        sb.WriteString("[" + elementStr + "]")
                default:
                        if i == 0 {
                                sb.WriteString(elementStr)
                        } else if strings.ContainsRune(elementStr, '.') {
                                sb.WriteString("[" + elementStr + "]")
                        } else {
                                sb.WriteString("." + elementStr)
                        }
                }
        }
        return sb.String()
}

func (n *CandidateNode) AsList() *list.List {
        elMap := list.New()
        elMap.PushBack(n)
        return elMap
}

func (n *CandidateNode) SetParent(parent *CandidateNode) {
        n.Parent = parent
}

type ValueVisitor func(*CandidateNode) error

func (n *CandidateNode) VisitValues(visitor ValueVisitor) error {
        switch n.Kind {
        case MappingNode:
                for i := 1; i < len(n.Content); i = i + 2 {
                        if err := visitor(n.Content[i]); err != nil {
                                return err
                        }
                }
        case SequenceNode:
                for i := 0; i < len(n.Content); i = i + 1 {
                        if err := visitor(n.Content[i]); err != nil {
                                return err
                        }
                }
        }
        return nil
}

func (n *CandidateNode) CanVisitValues() bool {
        return n.Kind == MappingNode || n.Kind == SequenceNode
}

func (n *CandidateNode) AddKeyValueChild(rawKey *CandidateNode, rawValue *CandidateNode) (*CandidateNode, *CandidateNode) {
        key := rawKey.Copy()
        key.SetParent(n)
        key.IsMapKey = true

        value := rawValue.Copy()
        value.SetParent(n)
        value.IsMapKey = false // force this, incase we are creating a value from a key
        value.Key = key

        n.Content = append(n.Content, key, value)
        return key, value
}

func (n *CandidateNode) AddChild(rawChild *CandidateNode) {
        value := rawChild.Copy()
        value.SetParent(n)
        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)
}

func (n *CandidateNode) AddChildren(children []*CandidateNode) {
        if n.Kind == MappingNode {
                for i := 0; i < len(children); i += 2 {
                        key := children[i]
                        value := children[i+1]
                        n.AddKeyValueChild(key, value)
                }

        } else {
                for _, rawChild := range children {
                        n.AddChild(rawChild)
                }
        }
}

func (n *CandidateNode) GetValueRep() (interface{}, error) {
        log.Debugf("GetValueRep for %v value: %v", n.GetNicePath(), n.Value)
        realTag := n.guessTagFromCustomType()

        switch realTag {
        case "!!int":
                _, val, err := parseInt64(n.Value)
                return val, err
        case "!!float":
                // need to test this
                return strconv.ParseFloat(n.Value, 64)
        case "!!bool":
                return isTruthyNode(n), nil
        case "!!null":
                return nil, nil
        }

        return n.Value, nil
}

func (n *CandidateNode) guessTagFromCustomType() string {
        if strings.HasPrefix(n.Tag, "!!") {
                return n.Tag
        } else if n.Value == "" {
                log.Debug("guessTagFromCustomType: node has no value to guess the type with")
                return n.Tag
        }
        dataBucket, errorReading := parseSnippet(n.Value)

        if errorReading != nil {
                log.Debug("guessTagFromCustomType: could not guess underlying tag type %v", errorReading)
                return n.Tag
        }
        guessedTag := dataBucket.Tag
        log.Info("im guessing the tag %v is a %v", n.Tag, guessedTag)
        return guessedTag
}

func (n *CandidateNode) CreateReplacement(kind Kind, tag string, value string) *CandidateNode {
        node := &CandidateNode{
                Kind:  kind,
                Tag:   tag,
                Value: value,
        }
        return n.CopyAsReplacement(node)
}

func (n *CandidateNode) CopyAsReplacement(replacement *CandidateNode) *CandidateNode {
        newCopy := replacement.Copy()
        newCopy.Parent = n.Parent

        if n.IsMapKey {
                newCopy.Key = n
        } else {
                newCopy.Key = n.Key
        }

        return newCopy
}

func (n *CandidateNode) CreateReplacementWithComments(kind Kind, tag string, style Style) *CandidateNode {
        replacement := n.CreateReplacement(kind, tag, "")
        replacement.LeadingContent = n.LeadingContent
        replacement.HeadComment = n.HeadComment
        replacement.LineComment = n.LineComment
        replacement.FootComment = n.FootComment
        replacement.Style = style
        return replacement
}

func (n *CandidateNode) Copy() *CandidateNode {
        return n.doCopy(true)
}

func (n *CandidateNode) CopyWithoutContent() *CandidateNode {
        return n.doCopy(false)
}

func (n *CandidateNode) doCopy(cloneContent bool) *CandidateNode {
        var content []*CandidateNode

        var copyKey *CandidateNode
        if n.Key != nil {
                copyKey = n.Key.Copy()
        }

        clone := &CandidateNode{
                Kind:  n.Kind,
                Style: n.Style,

                Tag:    n.Tag,
                Value:  n.Value,
                Anchor: n.Anchor,

                // ok not to clone this,
                // as its a reference to somewhere else.
                Alias:   n.Alias,
                Content: content,

                HeadComment: n.HeadComment,
                LineComment: n.LineComment,
                FootComment: n.FootComment,

                Parent: n.Parent,
                Key:    copyKey,

                LeadingContent: n.LeadingContent,

                document:  n.document,
                filename:  n.filename,
                fileIndex: n.fileIndex,

                Line:   n.Line,
                Column: n.Column,

                EvaluateTogether: n.EvaluateTogether,
                IsMapKey:         n.IsMapKey,

                EncodeSeparate: n.EncodeSeparate,
        }

        if cloneContent {
                clone.AddChildren(n.Content)
        }

        return clone
}

// updates this candidate from the given candidate node
func (n *CandidateNode) UpdateFrom(other *CandidateNode, prefs assignPreferences) {
        if n == other {
                log.Debugf("UpdateFrom, no need to update from myself.")
                return
        }
        // if this is an empty map or empty array, use the style of other node.
        if (n.Kind != ScalarNode && len(n.Content) == 0) ||
                // if the tag has changed (e.g. from str to bool)
                (n.guessTagFromCustomType() != other.guessTagFromCustomType()) {
                n.Style = other.Style
        }

        n.Content = make([]*CandidateNode, 0)
        n.Kind = other.Kind
        n.AddChildren(other.Content)

        n.Value = other.Value

        n.UpdateAttributesFrom(other, prefs)

}

func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode, prefs assignPreferences) {
        log.Debug("UpdateAttributesFrom: n: %v other: %v", NodeToString(n), NodeToString(other))
        if n.Kind != other.Kind {
                // clear out the contents when switching to a different type
                // e.g. map to array
                n.Content = make([]*CandidateNode, 0)
                n.Value = ""
        }
        n.Kind = other.Kind

        // don't clobber custom tags...
        if prefs.ClobberCustomTags || strings.HasPrefix(n.Tag, "!!") || n.Tag == "" {
                n.Tag = other.Tag
        }

        n.Alias = other.Alias

        if !prefs.DontOverWriteAnchor {
                n.Anchor = other.Anchor
        }

        // Preserve EncodeSeparate flag for format-specific encoding hints
        n.EncodeSeparate = other.EncodeSeparate

        // merge will pickup the style of the new thing
        // when autocreating nodes

        if n.Style == 0 {
                n.Style = other.Style
        }

        if other.FootComment != "" {
                n.FootComment = other.FootComment
        }
        if other.HeadComment != "" {
                n.HeadComment = other.HeadComment
        }
        if other.LineComment != "" {
                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, ",")
}

package yqlib

import (
        "fmt"
        "strings"

        yaml "github.com/goccy/go-yaml"
        "github.com/goccy/go-yaml/ast"
        goccyToken "github.com/goccy/go-yaml/token"
)

func (o *CandidateNode) goccyDecodeIntoChild(childNode ast.Node, cm yaml.CommentMap, anchorMap map[string]*CandidateNode) (*CandidateNode, error) {
        newChild := o.CreateChild()

        err := newChild.UnmarshalGoccyYAML(childNode, cm, anchorMap)
        return newChild, err
}

func (o *CandidateNode) UnmarshalGoccyYAML(node ast.Node, cm yaml.CommentMap, anchorMap map[string]*CandidateNode) error {
        log.Debugf("UnmarshalYAML %v", node)
        log.Debugf("UnmarshalYAML %v", node.Type().String())
        log.Debugf("UnmarshalYAML Node Value: %v", node.String())
        log.Debugf("UnmarshalYAML Node GetComment: %v", node.GetComment())

        if node.GetComment() != nil {
                commentMapComments := cm[node.GetPath()]
                for _, comment := range node.GetComment().Comments {
                        // need to use the comment map to find the position :/
                        log.Debugf("%v has a comment of [%v]", node.GetPath(), comment.Token.Value)
                        for _, commentMapComment := range commentMapComments {
                                commentMapValue := strings.Join(commentMapComment.Texts, "\n")
                                if commentMapValue == comment.Token.Value {
                                        log.Debug("found a matching entry in comment map")
                                        // we found the comment in the comment map,
                                        // now we can process the position
                                        switch commentMapComment.Position {
                                        case yaml.CommentHeadPosition:
                                                o.HeadComment = comment.String()
                                                log.Debug("its a head comment %v", comment.String())
                                        case yaml.CommentLinePosition:
                                                o.LineComment = comment.String()
                                                log.Debug("its a line comment %v", comment.String())
                                        case yaml.CommentFootPosition:
                                                o.FootComment = comment.String()
                                                log.Debug("its a foot comment %v", comment.String())
                                        }
                                }
                        }

                }
        }

        o.Value = node.String()
        o.Line = node.GetToken().Position.Line
        o.Column = node.GetToken().Position.Column

        switch node.Type() {
        case ast.IntegerType:
                o.Kind = ScalarNode
                o.Tag = "!!int"
        case ast.FloatType:
                o.Kind = ScalarNode
                o.Tag = "!!float"
        case ast.BoolType:
                o.Kind = ScalarNode
                o.Tag = "!!bool"
        case ast.NullType:
                log.Debugf("its a null type with value %v", node.GetToken().Value)
                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"
                switch node.GetToken().Type {
                case goccyToken.SingleQuoteType:
                        o.Style = SingleQuotedStyle
                case goccyToken.DoubleQuoteType:
                        o.Style = DoubleQuotedStyle
                }
                o.Value = node.(*ast.StringNode).Value
                log.Debugf("string value %v", node.(*ast.StringNode).Value)
        case ast.LiteralType:
                o.Kind = ScalarNode
                o.Tag = "!!str"
                o.Style = LiteralStyle
                astLiteral := node.(*ast.LiteralNode)
                log.Debugf("astLiteral.Start.Type %v", astLiteral.Start.Type)
                if astLiteral.Start.Type == goccyToken.FoldedType {
                        log.Debugf("folded Type %v", astLiteral.Start.Type)
                        o.Style = FoldedStyle
                }
                log.Debug("start value: %v ", node.(*ast.LiteralNode).Start.Value)
                log.Debug("start value: %v ", node.(*ast.LiteralNode).Start.Type)
                // TODO: here I could put the original value with line breaks
                // to solve the multiline > problem
                o.Value = astLiteral.Value.Value
        case ast.TagType:
                if err := o.UnmarshalGoccyYAML(node.(*ast.TagNode).Value, cm, anchorMap); err != nil {
                        return err
                }
                o.Tag = node.(*ast.TagNode).Start.Value
        case ast.MappingType:
                log.Debugf("UnmarshalYAML -  a mapping node")
                o.Kind = MappingNode
                o.Tag = "!!map"

                mappingNode := node.(*ast.MappingNode)
                if mappingNode.IsFlowStyle {
                        o.Style = FlowStyle
                }
                for _, mappingValueNode := range mappingNode.Values {
                        err := o.goccyProcessMappingValueNode(mappingValueNode, cm, anchorMap)
                        if err != nil {
                                return err
                        }
                }
                if mappingNode.FootComment != nil {
                        log.Debugf("mapping node has a foot comment of: %v", mappingNode.FootComment)
                        o.FootComment = mappingNode.FootComment.String()
                }
        case ast.MappingValueType:
                log.Debugf("UnmarshalYAML -  a mapping node")
                o.Kind = MappingNode
                o.Tag = "!!map"
                mappingValueNode := node.(*ast.MappingValueNode)
                err := o.goccyProcessMappingValueNode(mappingValueNode, cm, anchorMap)
                if err != nil {
                        return err
                }
        case ast.SequenceType:
                log.Debugf("UnmarshalYAML -  a sequence node")
                o.Kind = SequenceNode
                o.Tag = "!!seq"
                sequenceNode := node.(*ast.SequenceNode)
                if sequenceNode.IsFlowStyle {
                        o.Style = FlowStyle
                }
                astSeq := sequenceNode.Values
                o.Content = make([]*CandidateNode, len(astSeq))
                for i := 0; i < len(astSeq); i++ {
                        keyNode := o.CreateChild()
                        keyNode.IsMapKey = true
                        keyNode.Tag = "!!int"
                        keyNode.Kind = ScalarNode
                        keyNode.Value = fmt.Sprintf("%v", i)

                        valueNode, err := o.goccyDecodeIntoChild(astSeq[i], cm, anchorMap)
                        if err != nil {
                                return err
                        }

                        valueNode.Key = keyNode
                        o.Content[i] = valueNode
                }
        case ast.AnchorType:
                log.Debugf("UnmarshalYAML -  an anchor node")
                anchorNode := node.(*ast.AnchorNode)
                err := o.UnmarshalGoccyYAML(anchorNode.Value, cm, anchorMap)
                if err != nil {
                        return err
                }
                o.Anchor = anchorNode.Name.String()
                anchorMap[o.Anchor] = o

        case ast.AliasType:
                log.Debugf("UnmarshalYAML -  an alias node")
                aliasNode := node.(*ast.AliasNode)
                o.Kind = AliasNode
                o.Value = aliasNode.Value.String()
                o.Alias = anchorMap[o.Value]

        case ast.MergeKeyType:
                log.Debugf("UnmarshalYAML -  a merge key")
                o.Kind = ScalarNode
                o.Tag = "!!merge" // note - I should be able to get rid of this.
                o.Value = "<<"

        default:
                log.Debugf("UnmarshalYAML -  no idea of the type!!\n%v: %v", node.Type(), node.String())
        }
        log.Debugf("KIND: %v", o.Kind)
        return nil
}

func (o *CandidateNode) goccyProcessMappingValueNode(mappingEntry *ast.MappingValueNode, cm yaml.CommentMap, anchorMap map[string]*CandidateNode) error {
        log.Debug("UnmarshalYAML MAP KEY entry %v", mappingEntry.Key)

        // AddKeyValueFirst because it clones the nodes, and we want to have the real refs when Unmarshalling
        // particularly for the anchorMap
        keyNode, valueNode := o.AddKeyValueChild(&CandidateNode{}, &CandidateNode{})

        if err := keyNode.UnmarshalGoccyYAML(mappingEntry.Key, cm, anchorMap); err != nil {
                return err
        }

        log.Debug("UnmarshalYAML MAP VALUE entry %v", mappingEntry.Value)
        if err := valueNode.UnmarshalGoccyYAML(mappingEntry.Value, cm, anchorMap); err != nil {
                return err
        }

        if mappingEntry.FootComment != nil {
                valueNode.FootComment = mappingEntry.FootComment.String()
        }

        return nil
}

package yqlib

import (
        "fmt"

        yaml "go.yaml.in/yaml/v4"
)

func MapYamlStyle(original yaml.Style) Style {
        switch original {
        case yaml.TaggedStyle:
                return TaggedStyle
        case yaml.DoubleQuotedStyle:
                return DoubleQuotedStyle
        case yaml.SingleQuotedStyle:
                return SingleQuotedStyle
        case yaml.LiteralStyle:
                return LiteralStyle
        case yaml.FoldedStyle:
                return FoldedStyle
        case yaml.FlowStyle:
                return FlowStyle
        case 0:
                return 0
        }
        return Style(original)
}

func MapToYamlStyle(original Style) yaml.Style {
        switch original {
        case TaggedStyle:
                return yaml.TaggedStyle
        case DoubleQuotedStyle:
                return yaml.DoubleQuotedStyle
        case SingleQuotedStyle:
                return yaml.SingleQuotedStyle
        case LiteralStyle:
                return yaml.LiteralStyle
        case FoldedStyle:
                return yaml.FoldedStyle
        case FlowStyle:
                return yaml.FlowStyle
        case 0:
                return 0
        }
        return yaml.Style(original)
}

func (o *CandidateNode) copyFromYamlNode(node *yaml.Node, anchorMap map[string]*CandidateNode) {
        o.Style = MapYamlStyle(node.Style)

        o.Tag = node.Tag
        o.Value = node.Value
        o.Anchor = node.Anchor

        if o.Anchor != "" {
                anchorMap[o.Anchor] = o
                log.Debug("set anchor %v to %v", o.Anchor, NodeToString(o))
        }

        // its a single alias
        if node.Alias != nil && node.Alias.Anchor != "" {
                o.Alias = anchorMap[node.Alias.Anchor]
                log.Debug("set alias to %v", NodeToString(anchorMap[node.Alias.Anchor]))
        }
        o.HeadComment = node.HeadComment
        o.LineComment = node.LineComment
        o.FootComment = node.FootComment

        o.Line = node.Line
        o.Column = node.Column
}

func (o *CandidateNode) copyToYamlNode(node *yaml.Node) {
        node.Style = MapToYamlStyle(o.Style)

        node.Tag = o.Tag
        node.Value = o.Value
        node.Anchor = o.Anchor

        node.HeadComment = o.HeadComment

        node.LineComment = o.LineComment
        node.FootComment = o.FootComment

        node.Line = o.Line
        node.Column = o.Column
}

func (o *CandidateNode) decodeIntoChild(childNode *yaml.Node, anchorMap map[string]*CandidateNode) (*CandidateNode, error) {
        newChild := o.CreateChild()

        // null yaml.Nodes to not end up calling UnmarshalYAML
        // so we call it explicitly
        if childNode.Tag == "!!null" {
                newChild.Kind = ScalarNode
                newChild.copyFromYamlNode(childNode, anchorMap)
                return newChild, nil
        }

        err := newChild.UnmarshalYAML(childNode, anchorMap)
        return newChild, err
}

func (o *CandidateNode) UnmarshalYAML(node *yaml.Node, anchorMap map[string]*CandidateNode) error {
        log.Debugf("UnmarshalYAML %v", node.Tag)
        switch node.Kind {
        case yaml.AliasNode:
                log.Debug("UnmarshalYAML - alias from yaml: %v", o.Tag)
                o.Kind = AliasNode
                o.copyFromYamlNode(node, anchorMap)
                return nil
        case yaml.ScalarNode:
                log.Debugf("UnmarshalYAML -  a scalar")
                o.Kind = ScalarNode
                o.copyFromYamlNode(node, anchorMap)
                return nil
        case yaml.MappingNode:
                log.Debugf("UnmarshalYAML -  a mapping node")
                o.Kind = MappingNode
                o.copyFromYamlNode(node, anchorMap)
                o.Content = make([]*CandidateNode, len(node.Content))
                for i := 0; i < len(node.Content); i += 2 {

                        keyNode, err := o.decodeIntoChild(node.Content[i], anchorMap)
                        if err != nil {
                                return err
                        }

                        keyNode.IsMapKey = true

                        valueNode, err := o.decodeIntoChild(node.Content[i+1], anchorMap)
                        if err != nil {
                                return err
                        }

                        valueNode.Key = keyNode

                        o.Content[i] = keyNode
                        o.Content[i+1] = valueNode
                }
                log.Debugf("UnmarshalYAML -  finished mapping node")
                return nil
        case yaml.SequenceNode:
                log.Debugf("UnmarshalYAML -  a sequence: %v", len(node.Content))
                o.Kind = SequenceNode

                o.copyFromYamlNode(node, anchorMap)
                log.Debugf("node Style: %v", node.Style)
                log.Debugf("o Style: %v", o.Style)
                o.Content = make([]*CandidateNode, len(node.Content))
                for i := 0; i < len(node.Content); i++ {
                        keyNode := o.CreateChild()
                        keyNode.IsMapKey = true
                        keyNode.Tag = "!!int"
                        keyNode.Kind = ScalarNode
                        keyNode.Value = fmt.Sprintf("%v", i)

                        valueNode, err := o.decodeIntoChild(node.Content[i], anchorMap)
                        if err != nil {
                                return err
                        }

                        valueNode.Key = keyNode
                        o.Content[i] = valueNode
                }
                return nil
        case 0:
                // not sure when this happens
                o.copyFromYamlNode(node, anchorMap)
                log.Debugf("UnmarshalYAML -  err.. %v", NodeToString(o))
                return nil
        default:
                return fmt.Errorf("orderedMap: invalid yaml node")
        }
}

func (o *CandidateNode) MarshalYAML() (*yaml.Node, error) {
        log.Debug("MarshalYAML to yaml: %v", o.Tag)
        switch o.Kind {
        case AliasNode:
                log.Debug("MarshalYAML - alias to yaml: %v", o.Tag)
                target := &yaml.Node{Kind: yaml.AliasNode}
                o.copyToYamlNode(target)
                return target, nil
        case ScalarNode:
                log.Debug("MarshalYAML - scalar: %v", o.Value)
                target := &yaml.Node{Kind: yaml.ScalarNode}
                o.copyToYamlNode(target)
                return target, nil
        case MappingNode, SequenceNode:
                targetKind := yaml.MappingNode
                if o.Kind == SequenceNode {
                        targetKind = yaml.SequenceNode
                }
                target := &yaml.Node{Kind: targetKind}
                o.copyToYamlNode(target)
                log.Debugf("original style: %v", o.Style)
                log.Debugf("original: %v, tag: %v, style: %v, kind: %v", NodeToString(o), target.Tag, target.Style, target.Kind == yaml.SequenceNode)
                target.Content = make([]*yaml.Node, len(o.Content))
                for i := 0; i < len(o.Content); i++ {

                        child, err := o.Content[i].MarshalYAML()

                        if err != nil {
                                return nil, err
                        }
                        target.Content[i] = child
                }
                return target, nil
        }
        target := &yaml.Node{}
        o.copyToYamlNode(target)
        return target, nil
}

//go:build !yq_nojson

package yqlib

import (
        "bytes"
        "errors"
        "fmt"
        "io"

        "github.com/goccy/go-json"
)

func (o *CandidateNode) setScalarFromJson(value interface{}) error {
        o.Kind = ScalarNode
        switch rawData := value.(type) {
        case nil:
                o.Tag = "!!null"
                o.Value = "null"
        case float64, float32:
                o.Value = fmt.Sprintf("%v", value)
                o.Tag = "!!float"
                // json decoder returns ints as float.
                if value == float64(int64(rawData.(float64))) {
                        // aha it's an int disguised as a float
                        o.Tag = "!!int"
                        o.Value = fmt.Sprintf("%v", int64(value.(float64)))
                }
        case int, int64, int32:
                o.Value = fmt.Sprintf("%v", value)
                o.Tag = "!!int"
        case bool:
                o.Value = fmt.Sprintf("%v", value)
                o.Tag = "!!bool"
        case string:
                o.Value = rawData
                o.Tag = "!!str"
        default:
                return fmt.Errorf("unrecognised type :( %v", rawData)
        }
        return nil
}

func (o *CandidateNode) UnmarshalJSON(data []byte) error {
        log.Debug("UnmarshalJSON")
        switch data[0] {
        case '{':
                log.Debug("UnmarshalJSON -  its a map!")
                // its a map
                o.Kind = MappingNode
                o.Tag = "!!map"

                dec := json.NewDecoder(bytes.NewReader(data))
                _, err := dec.Token() // open object
                if err != nil {
                        return err
                }

                // cycle through k/v
                var tok json.Token
                for tok, err = dec.Token(); err == nil; tok, err = dec.Token() {
                        // we can expect two types: string or Delim. Delim automatically means
                        // that it is the closing bracket of the object, whereas string means
                        // that there is another key.
                        if _, ok := tok.(json.Delim); ok {
                                break
                        }

                        childKey := o.CreateChild()
                        childKey.IsMapKey = true
                        childKey.Value = tok.(string)
                        childKey.Kind = ScalarNode
                        childKey.Tag = "!!str"

                        childValue := o.CreateChild()
                        childValue.Key = childKey

                        if err := dec.Decode(childValue); err != nil {
                                return err
                        }
                        o.Content = append(o.Content, childKey, childValue)
                }
                // unexpected error
                if err != nil && !errors.Is(err, io.EOF) {
                        return err
                }
                return nil
        case '[':
                o.Kind = SequenceNode
                o.Tag = "!!seq"
                log.Debug("UnmarshalJSON -  its an array!")
                var children []*CandidateNode
                if err := json.Unmarshal(data, &children); err != nil {
                        return err
                }
                // now we put the children into the content, and set a key value for them
                for i, child := range children {

                        if child == nil {
                                // need to represent it as a null scalar
                                child = createScalarNode(nil, "null")
                        }
                        childKey := o.CreateChild()
                        childKey.Kind = ScalarNode
                        childKey.Tag = "!!int"
                        childKey.Value = fmt.Sprintf("%v", i)
                        childKey.IsMapKey = true

                        child.Parent = o
                        child.Key = childKey
                        o.Content = append(o.Content, child)
                }
                return nil
        }
        log.Debug("UnmarshalJSON -  its a scalar!")
        // otherwise, must be a scalar
        var scalar interface{}
        err := json.Unmarshal(data, &scalar)

        if err != nil {
                return err
        }
        log.Debug("UnmarshalJSON -  scalar is %v", scalar)

        return o.setScalarFromJson(scalar)

}

func (o *CandidateNode) MarshalJSON() ([]byte, error) {
        log.Debugf("MarshalJSON %v", NodeToString(o))
        buf := new(bytes.Buffer)
        enc := json.NewEncoder(buf)
        enc.SetIndent("", " ")
        enc.SetEscapeHTML(false) // do not escape html chars e.g. &, <, >

        switch o.Kind {
        case AliasNode:
                log.Debugf("MarshalJSON AliasNode")
                err := enc.Encode(o.Alias)
                return buf.Bytes(), err
        case ScalarNode:
                log.Debugf("MarshalJSON ScalarNode")
                value, err := o.GetValueRep()
                if err != nil {
                        return buf.Bytes(), err
                }
                err = enc.Encode(value)
                return buf.Bytes(), err
        case MappingNode:
                log.Debugf("MarshalJSON MappingNode")
                buf.WriteByte('{')
                for i := 0; i < len(o.Content); i += 2 {
                        if err := enc.Encode(o.Content[i].Value); err != nil {
                                return nil, err
                        }
                        buf.WriteByte(':')
                        if err := enc.Encode(o.Content[i+1]); err != nil {
                                return nil, err
                        }
                        if i != len(o.Content)-2 {
                                buf.WriteByte(',')
                        }
                }
                buf.WriteByte('}')
                return buf.Bytes(), nil
        case SequenceNode:
                log.Debugf("MarshalJSON SequenceNode, %v, len: %v", o.Content, len(o.Content))
                var err error
                if len(o.Content) == 0 {
                        buf.WriteString("[]")
                } else {
                        err = enc.Encode(o.Content)
                }
                return buf.Bytes(), err
        default:
                err := enc.Encode(nil)
                return buf.Bytes(), err
        }
}

//go:build linux

package yqlib

import (
        "io/fs"
        "os"
        "syscall"
)

func changeOwner(info fs.FileInfo, file *os.File) error {
        if stat, ok := info.Sys().(*syscall.Stat_t); ok {
                uid := int(stat.Uid)
                gid := int(stat.Gid)

                err := os.Chown(file.Name(), uid, gid)
                if err != nil {
                        // this happens with snap confinement
                        // not really a big issue as users can chown
                        // the file themselves if required.
                        log.Info("Skipping chown: %v", err)
                }
        }
        return nil
}

package yqlib

import (
        "fmt"
        "io"

        "github.com/fatih/color"
        "github.com/goccy/go-yaml/lexer"
        "github.com/goccy/go-yaml/printer"
)

// Thanks @risentveber!

const escape = "\x1b"

func format(attr color.Attribute) string {
        return fmt.Sprintf("%s[%dm", escape, attr)
}

func colorizeAndPrint(yamlBytes []byte, writer io.Writer) error {
        tokens := lexer.Tokenize(string(yamlBytes))
        var p printer.Printer
        p.Bool = func() *printer.Property {
                return &printer.Property{
                        Prefix: format(color.FgHiMagenta),
                        Suffix: format(color.Reset),
                }
        }
        p.Number = func() *printer.Property {
                return &printer.Property{
                        Prefix: format(color.FgHiMagenta),
                        Suffix: format(color.Reset),
                }
        }
        p.MapKey = func() *printer.Property {
                return &printer.Property{
                        Prefix: format(color.FgCyan),
                        Suffix: format(color.Reset),
                }
        }
        p.Anchor = func() *printer.Property {
                return &printer.Property{
                        Prefix: format(color.FgHiYellow),
                        Suffix: format(color.Reset),
                }
        }
        p.Alias = func() *printer.Property {
                return &printer.Property{
                        Prefix: format(color.FgHiYellow),
                        Suffix: format(color.Reset),
                }
        }
        p.String = func() *printer.Property {
                return &printer.Property{
                        Prefix: format(color.FgGreen),
                        Suffix: format(color.Reset),
                }
        }
        p.Comment = func() *printer.Property {
                return &printer.Property{
                        Prefix: format(color.FgHiBlack),
                        Suffix: format(color.Reset),
                }
        }
        _, err := writer.Write([]byte(p.PrintTokens(tokens) + "\n"))
        return err
}

package yqlib

import (
        "container/list"
        "fmt"
        "time"

        logging "gopkg.in/op/go-logging.v1"
)

type Context struct {
        MatchingNodes  *list.List
        Variables      map[string]*list.List
        DontAutoCreate bool
        datetimeLayout string
}

func (n *Context) SingleReadonlyChildContext(candidate *CandidateNode) Context {
        list := list.New()
        list.PushBack(candidate)
        newContext := n.ChildContext(list)
        newContext.DontAutoCreate = true
        return newContext
}

func (n *Context) SingleChildContext(candidate *CandidateNode) Context {
        list := list.New()
        list.PushBack(candidate)
        return n.ChildContext(list)
}

func (n *Context) SetDateTimeLayout(newDateTimeLayout string) {
        n.datetimeLayout = newDateTimeLayout
}

func (n *Context) GetDateTimeLayout() string {
        if n.datetimeLayout != "" {
                return n.datetimeLayout
        }
        return time.RFC3339
}

func (n *Context) GetVariable(name string) *list.List {
        if n.Variables == nil {
                return nil
        }
        return n.Variables[name]
}

func (n *Context) SetVariable(name string, value *list.List) {
        if n.Variables == nil {
                n.Variables = make(map[string]*list.List)
        }
        n.Variables[name] = value
}

func (n *Context) ChildContext(results *list.List) Context {
        clone := Context{DontAutoCreate: n.DontAutoCreate, datetimeLayout: n.datetimeLayout}
        clone.Variables = make(map[string]*list.List)
        for variableKey, originalValueList := range n.Variables {

                variableCopyList := list.New()
                for el := originalValueList.Front(); el != nil; el = el.Next() {
                        // note that we dont make a copy of the candidate node
                        // this is so the 'ref' operator can work correctly.
                        clonedNode := el.Value.(*CandidateNode)
                        variableCopyList.PushBack(clonedNode)
                }

                clone.Variables[variableKey] = variableCopyList
        }

        clone.MatchingNodes = results
        return clone
}

func (n *Context) ToString() string {
        if !log.IsEnabledFor(logging.DEBUG) {
                return ""
        }
        result := fmt.Sprintf("Context\nDontAutoCreate: %v\n", n.DontAutoCreate)
        return result + NodesToString(n.MatchingNodes)
}

func (n *Context) DeepClone() Context {

        clonedContent := list.New()
        for el := n.MatchingNodes.Front(); el != nil; el = el.Next() {
                clonedNode := el.Value.(*CandidateNode).Copy()
                clonedContent.PushBack(clonedNode)
        }

        return n.ChildContext(clonedContent)
}

func (n *Context) Clone() Context {
        return n.ChildContext(n.MatchingNodes)
}

func (n *Context) ReadOnlyClone() Context {
        clone := n.Clone()
        clone.DontAutoCreate = true
        return clone
}

func (n *Context) WritableClone() Context {
        clone := n.Clone()
        clone.DontAutoCreate = false
        return clone
}

package yqlib

type CsvPreferences struct {
        Separator rune
        AutoParse bool
}

func NewDefaultCsvPreferences() CsvPreferences {
        return CsvPreferences{
                Separator: ',',
                AutoParse: true,
        }
}

func NewDefaultTsvPreferences() CsvPreferences {
        return CsvPreferences{
                Separator: '\t',
                AutoParse: true,
        }
}

var ConfiguredCsvPreferences = NewDefaultCsvPreferences()
var ConfiguredTsvPreferences = NewDefaultTsvPreferences()

package yqlib

import (
        "fmt"

        logging "gopkg.in/op/go-logging.v1"
)

type DataTreeNavigator interface {
        // given the context and an expressionNode,
        // this will process the against the given expressionNode and return
        // a new context of matching candidates
        GetMatchingNodes(context Context, expressionNode *ExpressionNode) (Context, error)

        DeeplyAssign(context Context, path []interface{}, rhsNode *CandidateNode) error
}

type dataTreeNavigator struct {
}

func NewDataTreeNavigator() DataTreeNavigator {
        return &dataTreeNavigator{}
}

func (d *dataTreeNavigator) DeeplyAssign(context Context, path []interface{}, rhsCandidateNode *CandidateNode) error {

        assignmentOp := &Operation{OperationType: assignOpType, Preferences: assignPreferences{}}

        if rhsCandidateNode.Kind == MappingNode {
                log.Debug("DeeplyAssign: deeply merging object")
                // if the rhs is a map, we need to deeply merge it in.
                // otherwise we'll clobber any existing fields
                assignmentOp = &Operation{OperationType: multiplyAssignOpType, Preferences: multiplyPreferences{
                        AppendArrays:  true,
                        TraversePrefs: traversePreferences{DontFollowAlias: true},
                        AssignPrefs:   assignPreferences{},
                }}
        }

        rhsOp := &Operation{OperationType: valueOpType, CandidateNode: rhsCandidateNode}

        assignmentOpNode := &ExpressionNode{
                Operation: assignmentOp,
                LHS:       createTraversalTree(path, traversePreferences{}, false),
                RHS:       &ExpressionNode{Operation: rhsOp},
        }

        _, err := d.GetMatchingNodes(context, assignmentOpNode)
        return err
}

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

}

//go:build !yq_nobase64

package yqlib

import (
        "bytes"
        "encoding/base64"
        "io"
        "strings"
)

type base64Decoder struct {
        reader       io.Reader
        finished     bool
        readAnything bool
        encoding     base64.Encoding
}

func NewBase64Decoder() Decoder {
        return &base64Decoder{finished: false, encoding: *base64.StdEncoding}
}

func (dec *base64Decoder) Init(reader io.Reader) error {
        // Read all data from the reader and strip leading/trailing whitespace
        // This is necessary because base64 decoding needs to see the complete input
        // to handle padding correctly, and we need to strip whitespace before decoding.
        buf := new(bytes.Buffer)
        if _, err := buf.ReadFrom(reader); err != nil {
                return err
        }

        // Strip leading and trailing whitespace
        stripped := strings.TrimSpace(buf.String())

        // Add padding if needed (base64 strings should be a multiple of 4 characters)
        padLen := len(stripped) % 4
        if padLen > 0 {
                stripped += strings.Repeat("=", 4-padLen)
        }

        // Create a new reader from the stripped and padded data
        dec.reader = strings.NewReader(stripped)
        dec.readAnything = false
        dec.finished = false
        return nil
}

func (dec *base64Decoder) Decode() (*CandidateNode, error) {
        if dec.finished {
                return nil, io.EOF
        }
        base64Reader := base64.NewDecoder(&dec.encoding, dec.reader)
        buf := new(bytes.Buffer)

        if _, err := buf.ReadFrom(base64Reader); err != nil {
                return nil, err
        }
        if buf.Len() == 0 {
                dec.finished = true

                // if we've read _only_ an empty string, lets return that
                // otherwise if we've already read some bytes, and now we get
                // an empty string, then we are done.
                if dec.readAnything {
                        return nil, io.EOF
                }
        }
        dec.readAnything = true
        return createStringScalarNode(buf.String()), nil
}

//go:build !yq_nocsv

package yqlib

import (
        "encoding/csv"
        "errors"
        "io"

        "github.com/dimchansky/utfbom"
)

type csvObjectDecoder struct {
        prefs    CsvPreferences
        reader   csv.Reader
        finished bool
}

func NewCSVObjectDecoder(prefs CsvPreferences) Decoder {
        return &csvObjectDecoder{prefs: prefs}
}

func (dec *csvObjectDecoder) Init(reader io.Reader) error {
        cleanReader, enc := utfbom.Skip(reader)
        log.Debugf("Detected encoding: %s\n", enc)
        dec.reader = *csv.NewReader(cleanReader)
        dec.reader.Comma = dec.prefs.Separator
        dec.finished = false
        return nil
}

func (dec *csvObjectDecoder) convertToNode(content string) *CandidateNode {
        node, err := parseSnippet(content)
        // if we're not auto-parsing, then we wont put in parsed objects or arrays
        // but we still parse scalars
        if err != nil || (!dec.prefs.AutoParse && (node.Kind != ScalarNode || node.Value != content)) {
                return createScalarNode(content, content)
        }
        return node
}

func (dec *csvObjectDecoder) createObject(headerRow []string, contentRow []string) *CandidateNode {
        objectNode := &CandidateNode{Kind: MappingNode, Tag: "!!map"}

        for i, header := range headerRow {
                objectNode.AddKeyValueChild(createScalarNode(header, header), dec.convertToNode(contentRow[i]))
        }
        return objectNode
}

func (dec *csvObjectDecoder) Decode() (*CandidateNode, error) {
        if dec.finished {
                return nil, io.EOF
        }
        headerRow, err := dec.reader.Read()
        log.Debugf(": headerRow%v", headerRow)
        if err != nil {
                return nil, err
        }

        rootArray := &CandidateNode{Kind: SequenceNode, Tag: "!!seq"}

        contentRow, err := dec.reader.Read()

        for err == nil && len(contentRow) > 0 {
                log.Debugf("Adding contentRow: %v", contentRow)
                rootArray.AddChild(dec.createObject(headerRow, contentRow))
                contentRow, err = dec.reader.Read()
                log.Debugf("Read next contentRow: %v, %v", contentRow, err)
        }
        if !errors.Is(err, io.EOF) {
                return nil, err
        }

        return rootArray, nil
}

//go:build !yq_noyaml

//
// NOTE this is still a WIP - not yet ready.
//

package yqlib

import (
        "io"

        yaml "github.com/goccy/go-yaml"
        "github.com/goccy/go-yaml/ast"
)

type goccyYamlDecoder struct {
        decoder yaml.Decoder
        cm      yaml.CommentMap
        // anchor map persists over multiple documents for convenience.
        anchorMap map[string]*CandidateNode
}

func NewGoccyYAMLDecoder() Decoder {
        return &goccyYamlDecoder{}
}

func (dec *goccyYamlDecoder) Init(reader io.Reader) error {
        dec.cm = yaml.CommentMap{}
        dec.decoder = *yaml.NewDecoder(reader, yaml.CommentToMap(dec.cm), yaml.UseOrderedMap())
        dec.anchorMap = make(map[string]*CandidateNode)
        return nil
}

func (dec *goccyYamlDecoder) Decode() (*CandidateNode, error) {

        var ast ast.Node

        err := dec.decoder.Decode(&ast)
        if err != nil {
                return nil, err
        }

        candidateNode := &CandidateNode{}
        if err := candidateNode.UnmarshalGoccyYAML(ast, dec.cm, dec.anchorMap); err != nil {
                return nil, err
        }

        return candidateNode, nil
}

//go:build !yq_nohcl

package yqlib

import (
        "fmt"
        "io"
        "math/big"
        "sort"
        "strconv"
        "strings"

        "github.com/hashicorp/hcl/v2"
        "github.com/hashicorp/hcl/v2/hclsyntax"
        "github.com/zclconf/go-cty/cty"
)

type hclDecoder struct {
        file          *hcl.File
        fileBytes     []byte
        readAnything  bool
        documentIndex uint
}

func NewHclDecoder() Decoder {
        return &hclDecoder{}
}

// sortedAttributes returns attributes in declaration order by source position
func sortedAttributes(attrs hclsyntax.Attributes) []*attributeWithName {
        var sorted []*attributeWithName
        for name, attr := range attrs {
                sorted = append(sorted, &attributeWithName{Name: name, Attr: attr})
        }
        sort.Slice(sorted, func(i, j int) bool {
                return sorted[i].Attr.Range().Start.Byte < sorted[j].Attr.Range().Start.Byte
        })
        return sorted
}

type attributeWithName struct {
        Name string
        Attr *hclsyntax.Attribute
}

// extractLineComment extracts any inline comment after the given position
func extractLineComment(src []byte, endPos int) string {
        // Look for # comment after the token
        for i := endPos; i < len(src); i++ {
                if src[i] == '#' {
                        // Found comment, extract until end of line
                        start := i
                        for i < len(src) && src[i] != '\n' {
                                i++
                        }
                        return strings.TrimSpace(string(src[start:i]))
                }
                if src[i] == '\n' {
                        // Hit newline before comment
                        break
                }
                // Skip whitespace and other characters
        }
        return ""
}

// extractHeadComment extracts comments before a given start position
func extractHeadComment(src []byte, startPos int) string {
        var comments []string

        // Start just before the token and skip trailing whitespace
        i := startPos - 1
        for i >= 0 && (src[i] == ' ' || src[i] == '\t' || src[i] == '\n' || src[i] == '\r') {
                i--
        }

        for i >= 0 {
                // Find line boundaries
                lineEnd := i
                for i >= 0 && src[i] != '\n' {
                        i--
                }
                lineStart := i + 1

                line := strings.TrimRight(string(src[lineStart:lineEnd+1]), " \t\r")
                trimmed := strings.TrimSpace(line)

                if trimmed == "" {
                        break
                }

                if !strings.HasPrefix(trimmed, "#") {
                        break
                }

                comments = append([]string{trimmed}, comments...)

                // Move to previous line (skip any whitespace/newlines)
                i = lineStart - 1
                for i >= 0 && (src[i] == ' ' || src[i] == '\t' || src[i] == '\n' || src[i] == '\r') {
                        i--
                }
        }

        if len(comments) > 0 {
                return strings.Join(comments, "\n")
        }
        return ""
}

func (dec *hclDecoder) Init(reader io.Reader) error {
        data, err := io.ReadAll(reader)
        if err != nil {
                return err
        }
        file, diags := hclsyntax.ParseConfig(data, "input.hcl", hcl.Pos{Line: 1, Column: 1})
        if diags != nil && diags.HasErrors() {
                return fmt.Errorf("hcl parse error: %w", diags)
        }
        dec.file = file
        dec.fileBytes = data
        dec.readAnything = false
        dec.documentIndex = 0
        return nil
}

func (dec *hclDecoder) Decode() (*CandidateNode, error) {
        if dec.readAnything {
                return nil, io.EOF
        }
        dec.readAnything = true

        if dec.file == nil {
                return nil, fmt.Errorf("no hcl file parsed")
        }

        root := &CandidateNode{Kind: MappingNode}

        // process attributes in declaration order
        body := dec.file.Body.(*hclsyntax.Body)
        firstAttr := true
        for _, attrWithName := range sortedAttributes(body.Attributes) {
                keyNode := createStringScalarNode(attrWithName.Name)
                valNode := convertHclExprToNode(attrWithName.Attr.Expr, dec.fileBytes)

                // Attach comments if any
                attrRange := attrWithName.Attr.Range()
                headComment := extractHeadComment(dec.fileBytes, attrRange.Start.Byte)
                if firstAttr && headComment != "" {
                        // For the first attribute, apply its head comment to the root
                        root.HeadComment = headComment
                        firstAttr = false
                } else if headComment != "" {
                        keyNode.HeadComment = headComment
                }
                if lineComment := extractLineComment(dec.fileBytes, attrRange.End.Byte); lineComment != "" {
                        valNode.LineComment = lineComment
                }

                root.AddKeyValueChild(keyNode, valNode)
        }

        // process blocks
        // Count blocks by type at THIS level to detect multiple separate blocks
        blocksByType := make(map[string]int)
        for _, block := range body.Blocks {
                blocksByType[block.Type]++
        }

        for _, block := range body.Blocks {
                addBlockToMapping(root, block, dec.fileBytes, blocksByType[block.Type] > 1)
        }

        dec.documentIndex++
        root.document = dec.documentIndex - 1
        return root, nil
}

func hclBodyToNode(body *hclsyntax.Body, src []byte) *CandidateNode {
        node := &CandidateNode{Kind: MappingNode}
        for _, attrWithName := range sortedAttributes(body.Attributes) {
                key := createStringScalarNode(attrWithName.Name)
                val := convertHclExprToNode(attrWithName.Attr.Expr, src)

                // Attach comments if any
                attrRange := attrWithName.Attr.Range()
                if headComment := extractHeadComment(src, attrRange.Start.Byte); headComment != "" {
                        key.HeadComment = headComment
                }
                if lineComment := extractLineComment(src, attrRange.End.Byte); lineComment != "" {
                        val.LineComment = lineComment
                }

                node.AddKeyValueChild(key, val)
        }

        // Process nested blocks, counting blocks by type at THIS level
        // to detect which block types appear multiple times
        blocksByType := make(map[string]int)
        for _, block := range body.Blocks {
                blocksByType[block.Type]++
        }

        for _, block := range body.Blocks {
                addBlockToMapping(node, block, src, blocksByType[block.Type] > 1)
        }
        return node
}

// addBlockToMapping nests block type and labels into the parent mapping, merging children.
// isMultipleBlocksOfType indicates if there are multiple blocks of this type at THIS level
func addBlockToMapping(parent *CandidateNode, block *hclsyntax.Block, src []byte, isMultipleBlocksOfType bool) {
        bodyNode := hclBodyToNode(block.Body, src)
        current := parent

        // ensure block type mapping exists
        var typeNode *CandidateNode
        for i := 0; i < len(current.Content); i += 2 {
                if current.Content[i].Value == block.Type {
                        typeNode = current.Content[i+1]
                        break
                }
        }
        if typeNode == nil {
                _, typeNode = current.AddKeyValueChild(createStringScalarNode(block.Type), &CandidateNode{Kind: MappingNode})
                // Mark the type node if there are multiple blocks of this type at this level
                // This tells the encoder to emit them as separate blocks rather than consolidating them
                if isMultipleBlocksOfType {
                        typeNode.EncodeSeparate = true
                }
        }
        current = typeNode

        // walk labels, creating/merging mappings
        for _, label := range block.Labels {
                var next *CandidateNode
                for i := 0; i < len(current.Content); i += 2 {
                        if current.Content[i].Value == label {
                                next = current.Content[i+1]
                                break
                        }
                }
                if next == nil {
                        _, next = current.AddKeyValueChild(createStringScalarNode(label), &CandidateNode{Kind: MappingNode})
                }
                current = next
        }

        // merge body attributes/blocks into the final mapping
        for i := 0; i < len(bodyNode.Content); i += 2 {
                current.AddKeyValueChild(bodyNode.Content[i], bodyNode.Content[i+1])
        }
}

func convertHclExprToNode(expr hclsyntax.Expression, src []byte) *CandidateNode {
        // handle literal values directly
        switch e := expr.(type) {
        case *hclsyntax.LiteralValueExpr:
                v := e.Val
                if v.IsNull() {
                        return createScalarNode(nil, "")
                }
                switch {
                case v.Type().Equals(cty.String):
                        // prefer to extract exact source (to avoid extra quoting) when available
                        // Prefer the actual cty string value
                        s := v.AsString()
                        node := createScalarNode(s, s)
                        // Don't set style for regular quoted strings - let YAML handle naturally
                        return node
                case v.Type().Equals(cty.Bool):
                        b := v.True()
                        return createScalarNode(b, strconv.FormatBool(b))
                case v.Type() == cty.Number:
                        // prefer integers when the numeric value is integral
                        bf := v.AsBigFloat()
                        if bf == nil {
                                // fallback to string
                                return createStringScalarNode(v.GoString())
                        }
                        // check if bf represents an exact integer
                        if intVal, acc := bf.Int(nil); acc == big.Exact {
                                s := intVal.String()
                                return createScalarNode(intVal.Int64(), s)
                        }
                        s := bf.Text('g', -1)
                        return createScalarNode(0.0, s)
                case v.Type().IsTupleType() || v.Type().IsListType() || v.Type().IsSetType():
                        seq := &CandidateNode{Kind: SequenceNode}
                        it := v.ElementIterator()
                        for it.Next() {
                                _, val := it.Element()
                                // convert cty.Value to a node by wrapping in literal expr via string representation
                                child := convertCtyValueToNode(val)
                                seq.AddChild(child)
                        }
                        return seq
                case v.Type().IsMapType() || v.Type().IsObjectType():
                        m := &CandidateNode{Kind: MappingNode}
                        it := v.ElementIterator()
                        for it.Next() {
                                key, val := it.Element()
                                keyStr := key.AsString()
                                keyNode := createStringScalarNode(keyStr)
                                valNode := convertCtyValueToNode(val)
                                m.AddKeyValueChild(keyNode, valNode)
                        }
                        return m
                default:
                        // fallback to string
                        s := v.GoString()
                        return createStringScalarNode(s)
                }
        case *hclsyntax.TupleConsExpr:
                // parse tuple/list into YAML sequence
                seq := &CandidateNode{Kind: SequenceNode}
                for _, exprVal := range e.Exprs {
                        child := convertHclExprToNode(exprVal, src)
                        seq.AddChild(child)
                }
                return seq
        case *hclsyntax.ObjectConsExpr:
                // parse object into YAML mapping
                m := &CandidateNode{Kind: MappingNode}
                m.Style = FlowStyle // Mark as inline object (flow style) for encoder
                for _, item := range e.Items {
                        // evaluate key expression to get the key string
                        keyVal, keyDiags := item.KeyExpr.Value(nil)
                        if keyDiags != nil && keyDiags.HasErrors() {
                                // fallback: try to extract key from source
                                r := item.KeyExpr.Range()
                                start := r.Start.Byte
                                end := r.End.Byte
                                if start >= 0 && end >= start && end <= len(src) {
                                        keyNode := createStringScalarNode(strings.TrimSpace(string(src[start:end])))
                                        valNode := convertHclExprToNode(item.ValueExpr, src)
                                        m.AddKeyValueChild(keyNode, valNode)
                                }
                                continue
                        }
                        keyStr := keyVal.AsString()
                        keyNode := createStringScalarNode(keyStr)
                        valNode := convertHclExprToNode(item.ValueExpr, src)
                        m.AddKeyValueChild(keyNode, valNode)
                }
                return m
        case *hclsyntax.TemplateExpr:
                // Reconstruct template string, preserving ${} syntax for interpolations
                var parts []string
                for _, p := range e.Parts {
                        switch lp := p.(type) {
                        case *hclsyntax.LiteralValueExpr:
                                if lp.Val.Type().Equals(cty.String) {
                                        parts = append(parts, lp.Val.AsString())
                                } else {
                                        parts = append(parts, lp.Val.GoString())
                                }
                        default:
                                // Non-literal expression - reconstruct with ${} wrapper
                                r := p.Range()
                                start := r.Start.Byte
                                end := r.End.Byte
                                if start >= 0 && end >= start && end <= len(src) {
                                        exprText := string(src[start:end])
                                        parts = append(parts, "${"+exprText+"}")
                                } else {
                                        parts = append(parts, fmt.Sprintf("${%v}", p))
                                }
                        }
                }
                combined := strings.Join(parts, "")
                node := createScalarNode(combined, combined)
                // Set DoubleQuotedStyle for all templates (which includes all quoted strings in HCL)
                // This ensures HCL roundtrips preserve quotes, and YAML properly quotes strings with ${}
                node.Style = DoubleQuotedStyle
                return node
        case *hclsyntax.ScopeTraversalExpr:
                // Simple identifier/traversal (e.g. unquoted string literal in HCL)
                r := e.Range()
                start := r.Start.Byte
                end := r.End.Byte
                if start >= 0 && end >= start && end <= len(src) {
                        text := strings.TrimSpace(string(src[start:end]))
                        return createStringScalarNode(text)
                }
                // Fallback to root name if source unavailable
                if len(e.Traversal) > 0 {
                        if root, ok := e.Traversal[0].(hcl.TraverseRoot); ok {
                                return createStringScalarNode(root.Name)
                        }
                }
                return createStringScalarNode("")
        case *hclsyntax.FunctionCallExpr:
                // Preserve function calls as raw expressions for roundtrip
                r := e.Range()
                start := r.Start.Byte
                end := r.End.Byte
                if start >= 0 && end >= start && end <= len(src) {
                        text := strings.TrimSpace(string(src[start:end]))
                        node := createStringScalarNode(text)
                        node.Style = 0
                        return node
                }
                node := createStringScalarNode(e.Name)
                node.Style = 0
                return node
        default:
                // try to evaluate the expression (handles unary, binary ops, etc.)
                val, diags := expr.Value(nil)
                if diags == nil || !diags.HasErrors() {
                        // successfully evaluated, convert cty.Value to node
                        return convertCtyValueToNode(val)
                }
                // fallback: extract source text for the expression
                r := expr.Range()
                start := r.Start.Byte
                end := r.End.Byte
                if start >= 0 && end >= start && end <= len(src) {
                        text := string(src[start:end])
                        // Mark as unquoted expression so encoder emits without quoting
                        node := createStringScalarNode(text)
                        node.Style = 0
                        return node
                }
                return createStringScalarNode(fmt.Sprintf("%v", expr))
        }
}

func convertCtyValueToNode(v cty.Value) *CandidateNode {
        if v.IsNull() {
                return createScalarNode(nil, "")
        }
        switch {
        case v.Type().Equals(cty.String):
                return createScalarNode("", v.AsString())
        case v.Type().Equals(cty.Bool):
                b := v.True()
                return createScalarNode(b, strconv.FormatBool(b))
        case v.Type() == cty.Number:
                bf := v.AsBigFloat()
                if bf == nil {
                        return createStringScalarNode(v.GoString())
                }
                if intVal, acc := bf.Int(nil); acc == big.Exact {
                        s := intVal.String()
                        return createScalarNode(intVal.Int64(), s)
                }
                s := bf.Text('g', -1)
                return createScalarNode(0.0, s)
        case v.Type().IsTupleType() || v.Type().IsListType() || v.Type().IsSetType():
                seq := &CandidateNode{Kind: SequenceNode}
                it := v.ElementIterator()
                for it.Next() {
                        _, val := it.Element()
                        seq.AddChild(convertCtyValueToNode(val))
                }
                return seq
        case v.Type().IsMapType() || v.Type().IsObjectType():
                m := &CandidateNode{Kind: MappingNode}
                it := v.ElementIterator()
                for it.Next() {
                        key, val := it.Element()
                        keyNode := createStringScalarNode(key.AsString())
                        valNode := convertCtyValueToNode(val)
                        m.AddKeyValueChild(keyNode, valNode)
                }
                return m
        default:
                return createStringScalarNode(v.GoString())
        }
}

//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, // Initialise 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
}

//go:build !yq_nojson

package yqlib

import (
        "io"

        "github.com/goccy/go-json"
)

type jsonDecoder struct {
        decoder json.Decoder
}

func NewJSONDecoder() Decoder {
        return &jsonDecoder{}
}

func (dec *jsonDecoder) Init(reader io.Reader) error {
        dec.decoder = *json.NewDecoder(reader)
        return nil
}

func (dec *jsonDecoder) Decode() (*CandidateNode, error) {

        var dataBucket CandidateNode
        err := dec.decoder.Decode(&dataBucket)
        if err != nil {
                return nil, err
        }

        return &dataBucket, nil
}

//go:build !yq_nolua

package yqlib

import (
        "fmt"
        "io"
        "math"

        lua "github.com/yuin/gopher-lua"
)

type luaDecoder struct {
        reader   io.Reader
        finished bool
        prefs    LuaPreferences
}

func NewLuaDecoder(prefs LuaPreferences) Decoder {
        return &luaDecoder{
                prefs: prefs,
        }
}

func (dec *luaDecoder) Init(reader io.Reader) error {
        dec.reader = reader
        return nil
}

func (dec *luaDecoder) convertToYamlNode(ls *lua.LState, lv lua.LValue) *CandidateNode {
        switch lv.Type() {
        case lua.LTNil:
                return &CandidateNode{
                        Kind:  ScalarNode,
                        Tag:   "!!null",
                        Value: "",
                }
        case lua.LTBool:
                return &CandidateNode{
                        Kind:  ScalarNode,
                        Tag:   "!!bool",
                        Value: lv.String(),
                }
        case lua.LTNumber:
                n := float64(lua.LVAsNumber(lv))
                // various special case floats
                if math.IsNaN(n) {
                        return &CandidateNode{
                                Kind:  ScalarNode,
                                Tag:   "!!float",
                                Value: ".nan",
                        }
                }
                if math.IsInf(n, 1) {
                        return &CandidateNode{
                                Kind:  ScalarNode,
                                Tag:   "!!float",
                                Value: ".inf",
                        }
                }
                if math.IsInf(n, -1) {
                        return &CandidateNode{
                                Kind:  ScalarNode,
                                Tag:   "!!float",
                                Value: "-.inf",
                        }
                }

                // does it look like an integer?
                if n == float64(int(n)) {
                        return &CandidateNode{
                                Kind:  ScalarNode,
                                Tag:   "!!int",
                                Value: lv.String(),
                        }
                }

                return &CandidateNode{
                        Kind:  ScalarNode,
                        Tag:   "!!float",
                        Value: lv.String(),
                }
        case lua.LTString:
                return &CandidateNode{
                        Kind:  ScalarNode,
                        Tag:   "!!str",
                        Value: lv.String(),
                }
        case lua.LTFunction:
                return &CandidateNode{
                        Kind:  ScalarNode,
                        Tag:   "tag:lua.org,2006,function",
                        Value: lv.String(),
                }
        case lua.LTTable:
                // Simultaneously create a sequence and a map, pick which one to return
                // based on whether all keys were consecutive integers
                i := 1
                yaml_sequence := &CandidateNode{
                        Kind: SequenceNode,
                        Tag:  "!!seq",
                }
                yaml_map := &CandidateNode{
                        Kind: MappingNode,
                        Tag:  "!!map",
                }
                t := lv.(*lua.LTable)
                k, v := ls.Next(t, lua.LNil)
                for k != lua.LNil {
                        if ki, ok := k.(lua.LNumber); i != 0 && ok && math.Mod(float64(ki), 1) == 0 && int(ki) == i {
                                i++
                        } else {
                                i = 0
                        }
                        newKey := dec.convertToYamlNode(ls, k)

                        yv := dec.convertToYamlNode(ls, v)
                        yaml_map.AddKeyValueChild(newKey, yv)

                        if i != 0 {
                                yaml_sequence.AddChild(yv)
                        }
                        k, v = ls.Next(t, k)
                }
                if i != 0 {
                        return yaml_sequence
                }
                return yaml_map
        default:
                return &CandidateNode{
                        Kind:        ScalarNode,
                        LineComment: fmt.Sprintf("Unhandled Lua type: %s", lv.Type().String()),
                        Tag:         "!!null",
                        Value:       lv.String(),
                }
        }
}

func (dec *luaDecoder) decideTopLevelNode(ls *lua.LState) *CandidateNode {
        if ls.GetTop() == 0 {
                // no items were explicitly returned, encode the globals table instead
                return dec.convertToYamlNode(ls, ls.Get(lua.GlobalsIndex))
        }
        return dec.convertToYamlNode(ls, ls.Get(1))
}

func (dec *luaDecoder) Decode() (*CandidateNode, error) {
        if dec.finished {
                return nil, io.EOF
        }
        ls := lua.NewState(lua.Options{SkipOpenLibs: true})
        defer ls.Close()
        fn, err := ls.Load(dec.reader, "@input")
        if err != nil {
                return nil, err
        }
        ls.Push(fn)
        err = ls.PCall(0, lua.MultRet, nil)
        if err != nil {
                return nil, err
        }
        firstNode := dec.decideTopLevelNode(ls)
        dec.finished = true
        return firstNode, nil
}

//go:build !yq_noprops

package yqlib

import (
        "bytes"
        "fmt"
        "io"
        "strconv"
        "strings"

        "github.com/magiconair/properties"
)

type propertiesDecoder struct {
        reader   io.Reader
        finished bool
        d        DataTreeNavigator
}

func NewPropertiesDecoder() Decoder {
        return &propertiesDecoder{d: NewDataTreeNavigator(), finished: false}
}

func (dec *propertiesDecoder) Init(reader io.Reader) error {
        dec.reader = reader
        dec.finished = false
        return nil
}

func parsePropKey(key string) []interface{} {
        pathStrArray := strings.Split(key, ".")
        path := make([]interface{}, len(pathStrArray))
        for i, pathStr := range pathStrArray {
                num, err := strconv.ParseInt(pathStr, 10, 32)
                if err == nil {
                        path[i] = num
                } else {
                        path[i] = pathStr
                }
        }
        return path
}

func (dec *propertiesDecoder) processComment(c string) string {
        if c == "" {
                return ""
        }
        return "# " + c
}

func (dec *propertiesDecoder) applyPropertyComments(context Context, path []interface{}, comments []string) error {
        assignmentOp := &Operation{OperationType: assignOpType, Preferences: assignPreferences{}}

        rhsCandidateNode := &CandidateNode{
                Tag:         "!!str",
                Value:       fmt.Sprintf("%v", path[len(path)-1]),
                HeadComment: dec.processComment(strings.Join(comments, "\n")),
                Kind:        ScalarNode,
        }

        rhsCandidateNode.Tag = rhsCandidateNode.guessTagFromCustomType()

        rhsOp := &Operation{OperationType: referenceOpType, CandidateNode: rhsCandidateNode}

        assignmentOpNode := &ExpressionNode{
                Operation: assignmentOp,
                LHS:       createTraversalTree(path, traversePreferences{}, true),
                RHS:       &ExpressionNode{Operation: rhsOp},
        }

        _, err := dec.d.GetMatchingNodes(context, assignmentOpNode)
        return err
}

func (dec *propertiesDecoder) applyProperty(context Context, properties *properties.Properties, key string) error {
        value, _ := properties.Get(key)
        path := parsePropKey(key)

        propertyComments := properties.GetComments(key)
        if len(propertyComments) > 0 {
                err := dec.applyPropertyComments(context, path, propertyComments)
                if err != nil {
                        return nil
                }
        }

        rhsNode := createStringScalarNode(value)
        rhsNode.Tag = rhsNode.guessTagFromCustomType()

        return dec.d.DeeplyAssign(context, path, rhsNode)
}

func (dec *propertiesDecoder) Decode() (*CandidateNode, error) {
        if dec.finished {
                return nil, io.EOF
        }
        buf := new(bytes.Buffer)

        if _, err := buf.ReadFrom(dec.reader); err != nil {
                return nil, err
        }
        if buf.Len() == 0 {
                dec.finished = true
                return nil, io.EOF
        }
        properties, err := properties.LoadString(buf.String())
        if err != nil {
                return nil, err
        }
        properties.DisableExpansion = true

        rootMap := &CandidateNode{
                Kind: MappingNode,
                Tag:  "!!map",
        }

        context := Context{}
        context = context.SingleChildContext(rootMap)

        for _, key := range properties.Keys() {
                if err := dec.applyProperty(context, properties, key); err != nil {
                        return nil, err
                }

        }
        dec.finished = true

        return rootMap, nil

}

//go:build !yq_notoml

package yqlib

import (
        "bytes"
        "errors"
        "fmt"
        "io"
        "strconv"
        "strings"
        "time"

        toml "github.com/pelletier/go-toml/v2/unstable"
)

type tomlDecoder struct {
        parser           toml.Parser
        finished         bool
        d                DataTreeNavigator
        rootMap          *CandidateNode
        pendingComments  []string // Head comments collected from Comment nodes
        firstContentSeen bool     // Track if we've processed the first non-comment node
}

func NewTomlDecoder() Decoder {
        return &tomlDecoder{
                finished: false,
                d:        NewDataTreeNavigator(),
        }
}

func (dec *tomlDecoder) Init(reader io.Reader) error {
        dec.parser = toml.Parser{KeepComments: true}
        buf := new(bytes.Buffer)
        _, err := buf.ReadFrom(reader)
        if err != nil {
                return err
        }
        dec.parser.Reset(buf.Bytes())
        dec.rootMap = &CandidateNode{
                Kind: MappingNode,
                Tag:  "!!map",
        }
        dec.pendingComments = make([]string, 0)
        dec.firstContentSeen = false
        return nil
}

func (dec *tomlDecoder) getFullPath(tomlNode *toml.Node) []interface{} {
        path := make([]interface{}, 0)
        for {
                path = append(path, string(tomlNode.Data))
                tomlNode = tomlNode.Next()
                if tomlNode == nil {
                        return path
                }
        }
}

func (dec *tomlDecoder) processKeyValueIntoMap(rootMap *CandidateNode, tomlNode *toml.Node) error {
        value := tomlNode.Value()
        path := dec.getFullPath(value.Next())

        valueNode, err := dec.decodeNode(value)
        if err != nil {
                return err
        }

        // Attach pending head comments
        if len(dec.pendingComments) > 0 {
                valueNode.HeadComment = strings.Join(dec.pendingComments, "\n")
                dec.pendingComments = make([]string, 0)
        }

        // Check for inline comment chained to the KeyValue node
        nextNode := tomlNode.Next()
        if nextNode != nil && nextNode.Kind == toml.Comment {
                valueNode.LineComment = string(nextNode.Data)
        }

        context := Context{}
        context = context.SingleChildContext(rootMap)

        return dec.d.DeeplyAssign(context, path, valueNode)
}

func (dec *tomlDecoder) decodeKeyValuesIntoMap(rootMap *CandidateNode, tomlNode *toml.Node) (bool, error) {
        log.Debug("decodeKeyValuesIntoMap -- processing first (current) entry")
        if err := dec.processKeyValueIntoMap(rootMap, tomlNode); err != nil {
                return false, err
        }

        for dec.parser.NextExpression() {
                nextItem := dec.parser.Expression()
                log.Debug("decodeKeyValuesIntoMap -- next exp, its a %v", nextItem.Kind)

                switch nextItem.Kind {
                case toml.KeyValue:
                        if err := dec.processKeyValueIntoMap(rootMap, nextItem); err != nil {
                                return false, err
                        }
                case toml.Comment:
                        // Standalone comment - add to pending for next element
                        dec.pendingComments = append(dec.pendingComments, string(nextItem.Data))
                default:
                        // run out of key values
                        log.Debug("done in decodeKeyValuesIntoMap, gota a %v", nextItem.Kind)
                        return true, nil
                }
        }
        log.Debug("no more things to read in")
        return false, nil
}

func (dec *tomlDecoder) createInlineTableMap(tomlNode *toml.Node) (*CandidateNode, error) {
        content := make([]*CandidateNode, 0)
        log.Debug("createInlineTableMap")

        iterator := tomlNode.Children()
        for iterator.Next() {
                child := iterator.Node()
                if child.Kind != toml.KeyValue {
                        return nil, fmt.Errorf("only keyvalue pairs are supported in inlinetables, got %v instead", child.Kind)
                }

                keyValues := &CandidateNode{
                        Kind: MappingNode,
                        Tag:  "!!map",
                }

                if err := dec.processKeyValueIntoMap(keyValues, child); err != nil {
                        return nil, err
                }

                content = append(content, keyValues.Content...)
        }

        return &CandidateNode{
                Kind:    MappingNode,
                Tag:     "!!map",
                Content: content,
        }, nil
}

func (dec *tomlDecoder) createArray(tomlNode *toml.Node) (*CandidateNode, error) {
        content := make([]*CandidateNode, 0)
        iterator := tomlNode.Children()
        for iterator.Next() {
                child := iterator.Node()
                yamlNode, err := dec.decodeNode(child)
                if err != nil {
                        return nil, err
                }
                content = append(content, yamlNode)
        }

        return &CandidateNode{
                Kind:    SequenceNode,
                Tag:     "!!seq",
                Content: content,
        }, nil

}

func (dec *tomlDecoder) createStringScalar(tomlNode *toml.Node) (*CandidateNode, error) {
        content := string(tomlNode.Data)
        return createScalarNode(content, content), nil
}

func (dec *tomlDecoder) createBoolScalar(tomlNode *toml.Node) (*CandidateNode, error) {
        content := string(tomlNode.Data)
        return createScalarNode(content == "true", content), nil
}

func (dec *tomlDecoder) createIntegerScalar(tomlNode *toml.Node) (*CandidateNode, error) {
        content := string(tomlNode.Data)
        _, num, err := parseInt64(content)
        return createScalarNode(num, content), err
}

func (dec *tomlDecoder) createDateTimeScalar(tomlNode *toml.Node) (*CandidateNode, error) {
        content := string(tomlNode.Data)
        val, err := parseDateTime(time.RFC3339, content)
        return createScalarNode(val, content), err
}

func (dec *tomlDecoder) createFloatScalar(tomlNode *toml.Node) (*CandidateNode, error) {
        content := string(tomlNode.Data)
        num, err := strconv.ParseFloat(content, 64)
        return createScalarNode(num, content), err
}

func (dec *tomlDecoder) decodeNode(tomlNode *toml.Node) (*CandidateNode, error) {
        switch tomlNode.Kind {
        case toml.Key, toml.String:
                return dec.createStringScalar(tomlNode)
        case toml.Bool:
                return dec.createBoolScalar(tomlNode)
        case toml.Integer:
                return dec.createIntegerScalar(tomlNode)
        case toml.DateTime:
                return dec.createDateTimeScalar(tomlNode)
        case toml.Float:
                return dec.createFloatScalar(tomlNode)
        case toml.Array:
                return dec.createArray(tomlNode)
        case toml.InlineTable:
                return dec.createInlineTableMap(tomlNode)
        default:
                return nil, fmt.Errorf("unsupported type %v", tomlNode.Kind)
        }

}

func (dec *tomlDecoder) Decode() (*CandidateNode, error) {
        if dec.finished {
                return nil, io.EOF
        }
        //
        // toml library likes to panic
        var deferredError error
        defer func() { //catch or finally
                if r := recover(); r != nil {
                        var ok bool
                        deferredError, ok = r.(error)
                        if !ok {
                                deferredError = fmt.Errorf("pkg: %v", r)
                        }
                }
        }()

        log.Debug("ok here we go")
        var runAgainstCurrentExp = false
        var err error
        for runAgainstCurrentExp || dec.parser.NextExpression() {

                if runAgainstCurrentExp {
                        log.Debug("running against current exp")
                }

                currentNode := dec.parser.Expression()

                log.Debug("currentNode: %v ", currentNode.Kind)
                runAgainstCurrentExp, err = dec.processTopLevelNode(currentNode)
                if err != nil {
                        return dec.rootMap, err
                }

        }

        err = dec.parser.Error()
        if err != nil {
                return nil, err
        }

        // must have finished
        dec.finished = true

        if len(dec.rootMap.Content) == 0 {
                return nil, io.EOF
        }

        return dec.rootMap, deferredError

}

func (dec *tomlDecoder) processTopLevelNode(currentNode *toml.Node) (bool, error) {
        var runAgainstCurrentExp bool
        var err error
        log.Debug("processTopLevelNode: Going to process %v state is current %v", currentNode.Kind, NodeToString(dec.rootMap))
        switch currentNode.Kind {
        case toml.Comment:
                // Collect comment to attach to next element
                commentText := string(currentNode.Data)
                // If we haven't seen any content yet, accumulate comments for root
                if !dec.firstContentSeen {
                        if dec.rootMap.HeadComment == "" {
                                dec.rootMap.HeadComment = commentText
                        } else {
                                dec.rootMap.HeadComment = dec.rootMap.HeadComment + "\n" + commentText
                        }
                } else {
                        // We've seen content, so these comments are for the next element
                        dec.pendingComments = append(dec.pendingComments, commentText)
                }
                return false, nil
        case toml.Table:
                dec.firstContentSeen = true
                runAgainstCurrentExp, err = dec.processTable(currentNode)
        case toml.ArrayTable:
                dec.firstContentSeen = true
                runAgainstCurrentExp, err = dec.processArrayTable(currentNode)
        default:
                dec.firstContentSeen = true
                runAgainstCurrentExp, err = dec.decodeKeyValuesIntoMap(dec.rootMap, currentNode)
        }

        log.Debug("processTopLevelNode: DONE Processing state is now %v", NodeToString(dec.rootMap))
        return runAgainstCurrentExp, err
}

func (dec *tomlDecoder) processTable(currentNode *toml.Node) (bool, error) {
        log.Debug("Enter processTable")
        child := currentNode.Child()
        fullPath := dec.getFullPath(child)
        log.Debug("fullpath: %v", fullPath)

        c := Context{}
        c = c.SingleChildContext(dec.rootMap)

        fullPath, err := getPathToUse(fullPath, dec, c)
        if err != nil {
                return false, err
        }

        tableNodeValue := &CandidateNode{
                Kind:           MappingNode,
                Tag:            "!!map",
                Content:        make([]*CandidateNode, 0),
                EncodeSeparate: true,
        }

        // Attach pending head comments to the table
        if len(dec.pendingComments) > 0 {
                tableNodeValue.HeadComment = strings.Join(dec.pendingComments, "\n")
                dec.pendingComments = make([]string, 0)
        }

        var tableValue *toml.Node
        runAgainstCurrentExp := false
        hasValue := dec.parser.NextExpression()
        // check to see if there is any table data
        if hasValue {
                tableValue = dec.parser.Expression()
                // next expression is not table data, so we are done
                if tableValue.Kind != toml.KeyValue {
                        log.Debug("got an empty table")
                        runAgainstCurrentExp = true
                } else {
                        runAgainstCurrentExp, err = dec.decodeKeyValuesIntoMap(tableNodeValue, tableValue)
                        if err != nil && !errors.Is(err, io.EOF) {
                                return false, err
                        }
                }
        }

        err = dec.d.DeeplyAssign(c, fullPath, tableNodeValue)
        if err != nil {
                return false, err
        }
        return runAgainstCurrentExp, nil
}

func (dec *tomlDecoder) arrayAppend(context Context, path []interface{}, rhsNode *CandidateNode) error {
        log.Debug("arrayAppend to path: %v,%v", path, NodeToString(rhsNode))
        rhsCandidateNode := &CandidateNode{
                Kind:    SequenceNode,
                Tag:     "!!seq",
                Content: []*CandidateNode{rhsNode},
        }

        assignmentOp := &Operation{OperationType: addAssignOpType}

        rhsOp := &Operation{OperationType: valueOpType, CandidateNode: rhsCandidateNode}

        assignmentOpNode := &ExpressionNode{
                Operation: assignmentOp,
                LHS:       createTraversalTree(path, traversePreferences{}, false),
                RHS:       &ExpressionNode{Operation: rhsOp},
        }

        _, err := dec.d.GetMatchingNodes(context, assignmentOpNode)
        return err
}

func (dec *tomlDecoder) processArrayTable(currentNode *toml.Node) (bool, error) {
        log.Debug("Enter processArrayTable")
        child := currentNode.Child()
        fullPath := dec.getFullPath(child)
        log.Debug("Fullpath: %v", fullPath)

        c := Context{}
        c = c.SingleChildContext(dec.rootMap)

        fullPath, err := getPathToUse(fullPath, dec, c)
        if err != nil {
                return false, err
        }

        // need to use the array append exp to add another entry to
        // this array: fullpath += [ thing ]
        hasValue := dec.parser.NextExpression()

        tableNodeValue := &CandidateNode{
                Kind:           MappingNode,
                Tag:            "!!map",
                EncodeSeparate: true,
        }

        // Attach pending head comments to the array table
        if len(dec.pendingComments) > 0 {
                tableNodeValue.HeadComment = strings.Join(dec.pendingComments, "\n")
                dec.pendingComments = make([]string, 0)
        }

        runAgainstCurrentExp := false
        // if the next value is a ArrayTable or Table, then its not part of this declaration (not a key value pair)
        // so lets leave that expression for the next round of parsing
        if hasValue && (dec.parser.Expression().Kind == toml.ArrayTable || dec.parser.Expression().Kind == toml.Table) {
                runAgainstCurrentExp = true
        } else if hasValue {
                // otherwise, if there is a value, it must be some key value pairs of the
                // first object in the array!
                tableValue := dec.parser.Expression()
                runAgainstCurrentExp, err = dec.decodeKeyValuesIntoMap(tableNodeValue, tableValue)
                if err != nil && !errors.Is(err, io.EOF) {
                        return false, err
                }
        }

        // += function
        err = dec.arrayAppend(c, fullPath, tableNodeValue)

        return runAgainstCurrentExp, err
}

// if fullPath points to an array of maps rather than a map
// then it should set this element into the _last_ element of that array.
// Because TOML. So we'll inject the last index into the path.

func getPathToUse(fullPath []interface{}, dec *tomlDecoder, c Context) ([]interface{}, error) {
        pathToCheck := fullPath
        if len(fullPath) >= 1 {
                pathToCheck = fullPath[:len(fullPath)-1]
        }
        readOp := createTraversalTree(pathToCheck, traversePreferences{DontAutoCreate: true}, false)

        resultContext, err := dec.d.GetMatchingNodes(c, readOp)
        if err != nil {
                return nil, err
        }
        if resultContext.MatchingNodes.Len() >= 1 {
                match := resultContext.MatchingNodes.Front().Value.(*CandidateNode)
                // path refers to an array, we need to add this to the last element in the array
                if match.Kind == SequenceNode {
                        fullPath = append(pathToCheck, len(match.Content)-1, fullPath[len(fullPath)-1])
                        log.Debugf("Adding to end of %v array, using path: %v", pathToCheck, fullPath)
                }
        }
        return fullPath, err
}

//go:build !yq_nouri

package yqlib

import (
        "bytes"
        "io"
        "net/url"
)

type uriDecoder struct {
        reader       io.Reader
        finished     bool
        readAnything bool
}

func NewUriDecoder() Decoder {
        return &uriDecoder{finished: false}
}

func (dec *uriDecoder) Init(reader io.Reader) error {
        dec.reader = reader
        dec.readAnything = false
        dec.finished = false
        return nil
}

func (dec *uriDecoder) Decode() (*CandidateNode, error) {
        if dec.finished {
                return nil, io.EOF
        }

        buf := new(bytes.Buffer)

        if _, err := buf.ReadFrom(dec.reader); err != nil {
                return nil, err
        }
        if buf.Len() == 0 {
                dec.finished = true

                // if we've read _only_ an empty string, lets return that
                // otherwise if we've already read some bytes, and now we get
                // an empty string, then we are done.
                if dec.readAnything {
                        return nil, io.EOF
                }
        }
        newValue, err := url.QueryUnescape(buf.String())
        if err != nil {
                return nil, err
        }
        dec.readAnything = true
        return createStringScalarNode(newValue), nil
}

//go:build !yq_noxml

package yqlib

import (
        "encoding/xml"
        "errors"
        "fmt"
        "io"
        "regexp"
        "strings"
        "unicode"

        "golang.org/x/net/html/charset"
)

type xmlDecoder struct {
        reader       io.Reader
        readAnything bool
        finished     bool
        prefs        XmlPreferences
}

func NewXMLDecoder(prefs XmlPreferences) Decoder {
        return &xmlDecoder{
                finished: false,
                prefs:    prefs,
        }
}

func (dec *xmlDecoder) Init(reader io.Reader) error {
        dec.reader = reader
        dec.readAnything = false
        dec.finished = false
        return nil
}

func (dec *xmlDecoder) createSequence(nodes []*xmlNode) (*CandidateNode, error) {
        yamlNode := &CandidateNode{Kind: SequenceNode, Tag: "!!seq"}
        for _, child := range nodes {
                yamlChild, err := dec.convertToYamlNode(child)
                if err != nil {
                        return nil, err
                }
                yamlNode.AddChild(yamlChild)
        }

        return yamlNode, nil
}

var decoderCommentPrefix = regexp.MustCompile(`(^|\n)([[:alpha:]])`)

func (dec *xmlDecoder) processComment(c string) string {
        if c == "" {
                return ""
        }
        //need to replace "cat " with "# cat"
        // "\ncat\n" with "\n cat\n"
        // ensure non-empty comments starting with newline have a space in front

        replacement := decoderCommentPrefix.ReplaceAllString(c, "$1 $2")
        replacement = "#" + strings.ReplaceAll(strings.TrimRight(replacement, " "), "\n", "\n#")
        return replacement
}

func (dec *xmlDecoder) createMap(n *xmlNode) (*CandidateNode, error) {
        log.Debug("createMap: headC: %v, lineC: %v, footC: %v", n.HeadComment, n.LineComment, n.FootComment)
        yamlNode := &CandidateNode{Kind: MappingNode, Tag: "!!map"}

        if len(n.Data) > 0 {
                log.Debugf("creating content node for map: %v", dec.prefs.ContentName)
                label := dec.prefs.ContentName
                labelNode := createScalarNode(label, label)
                labelNode.HeadComment = dec.processComment(n.HeadComment)
                labelNode.LineComment = dec.processComment(n.LineComment)
                labelNode.FootComment = dec.processComment(n.FootComment)
                yamlNode.AddKeyValueChild(labelNode, dec.createValueNodeFromData(n.Data))
        }

        for i, keyValuePair := range n.Children {
                label := keyValuePair.K
                children := keyValuePair.V
                labelNode := createScalarNode(label, label)
                var valueNode *CandidateNode
                var err error

                if i == 0 {
                        log.Debugf("head comment here")
                        labelNode.HeadComment = dec.processComment(n.HeadComment)

                }
                log.Debugf("label=%v, i=%v, keyValuePair.FootComment: %v", label, i, keyValuePair.FootComment)
                labelNode.FootComment = dec.processComment(keyValuePair.FootComment)

                log.Debug("len of children in %v is %v", label, len(children))
                if len(children) > 1 {
                        valueNode, err = dec.createSequence(children)
                        if err != nil {
                                return nil, err
                        }
                } else {
                        // comment hack for maps of scalars
                        // if the value is a scalar, the head comment of the scalar needs to go on the key?
                        // add tests for <z/> as well as multiple <ds> of inputXmlWithComments > yaml
                        if len(children[0].Children) == 0 && children[0].HeadComment != "" {
                                if len(children[0].Data) > 0 {

                                        log.Debug("scalar comment hack, currentlabel [%v]", labelNode.HeadComment)
                                        labelNode.HeadComment = joinComments([]string{labelNode.HeadComment, strings.TrimSpace(children[0].HeadComment)}, "\n")
                                        children[0].HeadComment = ""
                                } else {
                                        // child is null, put the headComment as a linecomment for reasons
                                        children[0].LineComment = children[0].HeadComment
                                        children[0].HeadComment = ""
                                }
                        }
                        valueNode, err = dec.convertToYamlNode(children[0])
                        if err != nil {
                                return nil, err
                        }
                }
                yamlNode.AddKeyValueChild(labelNode, valueNode)
        }

        return yamlNode, nil
}

func (dec *xmlDecoder) createValueNodeFromData(values []string) *CandidateNode {
        switch len(values) {
        case 0:
                return createScalarNode(nil, "")
        case 1:
                return createScalarNode(values[0], values[0])
        default:
                content := make([]*CandidateNode, 0)
                for _, value := range values {
                        content = append(content, createScalarNode(value, value))
                }
                return &CandidateNode{
                        Kind:    SequenceNode,
                        Tag:     "!!seq",
                        Content: content,
                }
        }
}

func (dec *xmlDecoder) convertToYamlNode(n *xmlNode) (*CandidateNode, error) {
        if len(n.Children) > 0 {
                return dec.createMap(n)
        }

        scalar := dec.createValueNodeFromData(n.Data)

        log.Debug("scalar (%v), headC: %v, lineC: %v, footC: %v", scalar.Tag, n.HeadComment, n.LineComment, n.FootComment)
        scalar.HeadComment = dec.processComment(n.HeadComment)
        scalar.LineComment = dec.processComment(n.LineComment)
        if scalar.Tag == "!!seq" {
                scalar.Content[0].HeadComment = scalar.LineComment
                scalar.LineComment = ""
        }

        scalar.FootComment = dec.processComment(n.FootComment)

        return scalar, nil
}

func (dec *xmlDecoder) Decode() (*CandidateNode, error) {
        if dec.finished {
                return nil, io.EOF
        }
        root := &xmlNode{}
        // cant use xj - it doesn't keep map order.
        err := dec.decodeXML(root)

        if err != nil {
                return nil, err
        }
        firstNode, err := dec.convertToYamlNode(root)

        if err != nil {
                return nil, err
        } else if firstNode.Tag == "!!null" {
                dec.finished = true
                if dec.readAnything {
                        return nil, io.EOF
                }
        }
        dec.readAnything = true
        dec.finished = true

        return firstNode, nil
}

type xmlNode struct {
        Children    []*xmlChildrenKv
        HeadComment string
        FootComment string
        LineComment string
        Data        []string
}

type xmlChildrenKv struct {
        K           string
        V           []*xmlNode
        FootComment string
}

// AddChild appends a node to the list of children
func (n *xmlNode) AddChild(s string, c *xmlNode) {

        if n.Children == nil {
                n.Children = make([]*xmlChildrenKv, 0)
        }
        log.Debug("looking for %s", s)
        // see if we can find an existing entry to add to
        for _, childEntry := range n.Children {
                if childEntry.K == s {
                        log.Debug("found it, appending an entry%s", s)
                        childEntry.V = append(childEntry.V, c)
                        log.Debug("yay len of children in %v is %v", s, len(childEntry.V))
                        return
                }
        }
        log.Debug("not there, making a new one %s", s)
        n.Children = append(n.Children, &xmlChildrenKv{K: s, V: []*xmlNode{c}})
}

type element struct {
        parent *element
        n      *xmlNode
        label  string
        state  string
}

// this code is heavily based on https://github.com/basgys/goxml2json
// main changes are to decode into a structure that preserves the original order
// of the map keys.
func (dec *xmlDecoder) decodeXML(root *xmlNode) error {
        xmlDec := xml.NewDecoder(dec.reader)
        xmlDec.Strict = dec.prefs.StrictMode
        // That will convert the charset if the provided XML is non-UTF-8
        xmlDec.CharsetReader = charset.NewReaderLabel

        started := false

        // Create first element from the root node
        elem := &element{
                parent: nil,
                n:      root,
        }

        getToken := func() (xml.Token, error) {
                if dec.prefs.UseRawToken {
                        return xmlDec.RawToken()
                }
                return xmlDec.Token()
        }

        for {
                t, e := getToken()
                if e != nil && !errors.Is(e, io.EOF) {
                        return e
                }
                if t == nil {
                        break
                }

                switch se := t.(type) {
                case xml.StartElement:
                        log.Debug("start element %v", se.Name.Local)
                        elem.state = "started"
                        // Build new a new current element and link it to its parent
                        var label = se.Name.Local
                        if dec.prefs.KeepNamespace {
                                if se.Name.Space != "" {
                                        label = se.Name.Space + ":" + se.Name.Local
                                }
                        }
                        elem = &element{
                                parent: elem,
                                n:      &xmlNode{},
                                label:  label,
                        }

                        // Extract attributes as children
                        for _, a := range se.Attr {
                                if dec.prefs.KeepNamespace {
                                        if a.Name.Space != "" {
                                                a.Name.Local = a.Name.Space + ":" + a.Name.Local
                                        }
                                }
                                elem.n.AddChild(dec.prefs.AttributePrefix+a.Name.Local, &xmlNode{Data: []string{a.Value}})
                        }
                case xml.CharData:

                        // Extract XML data (if any)
                        newBit := trimNonGraphic(string(se))
                        if !started && len(newBit) > 0 {
                                return fmt.Errorf("invalid XML: Encountered chardata [%v] outside of XML node", newBit)
                        }

                        if len(newBit) > 0 {
                                elem.n.Data = append(elem.n.Data, newBit)
                                elem.state = "chardata"
                                log.Debug("chardata [%v] for %v", elem.n.Data, elem.label)
                        }
                case xml.EndElement:
                        if elem == nil {
                                log.Debug("no element, probably bad xml")
                                continue
                        }
                        log.Debug("end element %v", elem.label)
                        elem.state = "finished"
                        // And add it to its parent list
                        if elem.parent != nil {
                                elem.parent.n.AddChild(elem.label, elem.n)
                        }

                        // Then change the current element to its parent
                        elem = elem.parent
                case xml.Comment:

                        commentStr := string(xml.CharData(se))
                        switch elem.state {
                        case "started":
                                applyFootComment(elem, commentStr)

                        case "chardata":
                                log.Debug("got a line comment for (%v) %v: [%v]", elem.state, elem.label, commentStr)
                                elem.n.LineComment = joinComments([]string{elem.n.LineComment, commentStr}, " ")
                        default:
                                log.Debug("got a head comment for (%v) %v: [%v]", elem.state, elem.label, commentStr)
                                elem.n.HeadComment = joinComments([]string{elem.n.HeadComment, commentStr}, " ")
                        }

                case xml.ProcInst:
                        if !dec.prefs.SkipProcInst {
                                elem.n.AddChild(dec.prefs.ProcInstPrefix+se.Target, &xmlNode{Data: []string{string(se.Inst)}})
                        }
                case xml.Directive:
                        if !dec.prefs.SkipDirectives {
                                elem.n.AddChild(dec.prefs.DirectiveName, &xmlNode{Data: []string{string(se)}})
                        }
                }
                started = true
        }

        return nil
}

func applyFootComment(elem *element, commentStr string) {

        // first lets try to put the comment on the last child
        if len(elem.n.Children) > 0 {
                lastChildIndex := len(elem.n.Children) - 1
                childKv := elem.n.Children[lastChildIndex]
                log.Debug("got a foot comment, putting on last child for %v: [%v]", childKv.K, commentStr)
                // if it's an array of scalars, put the foot comment on the scalar itself
                if len(childKv.V) > 0 && len(childKv.V[0].Children) == 0 {
                        nodeToUpdate := childKv.V[len(childKv.V)-1]
                        nodeToUpdate.FootComment = joinComments([]string{nodeToUpdate.FootComment, commentStr}, " ")
                } else {
                        childKv.FootComment = joinComments([]string{elem.n.FootComment, commentStr}, " ")
                }
        } else {
                log.Debug("got a foot comment for %v: [%v]", elem.label, commentStr)
                elem.n.FootComment = joinComments([]string{elem.n.FootComment, commentStr}, " ")
        }
}

func joinComments(rawStrings []string, joinStr string) string {
        stringsToJoin := make([]string, 0)
        for _, str := range rawStrings {
                if str != "" {
                        stringsToJoin = append(stringsToJoin, str)
                }
        }
        return strings.Join(stringsToJoin, joinStr)
}

// trimNonGraphic returns a slice of the string s, with all leading and trailing
// non graphic characters and spaces removed.
//
// Graphic characters include letters, marks, numbers, punctuation, symbols,
// and spaces, from categories L, M, N, P, S, Zs.
// Spacing characters are set by category Z and property Pattern_White_Space.
func trimNonGraphic(s string) string {
        if s == "" {
                return s
        }

        var first *int
        var last int
        for i, r := range []rune(s) {
                if !unicode.IsGraphic(r) || unicode.IsSpace(r) {
                        continue
                }

                if first == nil {
                        f := i // copy i
                        first = &f
                        last = i
                } else {
                        last = i
                }
        }

        // If first is nil, it means there are no graphic characters
        if first == nil {
                return ""
        }

        return string([]rune(s)[*first : last+1])
}

package yqlib

import (
        "bufio"
        "bytes"
        "errors"
        "io"
        "regexp"
        "strings"

        yaml "go.yaml.in/yaml/v4"
)

var (
        commentLineRe       = regexp.MustCompile(`^\s*#`)
        yamlDirectiveLineRe = regexp.MustCompile(`^\s*%YAML`)
        separatorLineRe     = regexp.MustCompile(`^\s*---\s*$`)
        separatorPrefixRe   = regexp.MustCompile(`^\s*---\s+`)
)

type yamlDecoder struct {
        decoder yaml.Decoder

        prefs YamlPreferences

        // work around of various parsing issues by yaml.v3 with document headers
        leadingContent string
        bufferRead     bytes.Buffer

        // anchor map persists over multiple documents for convenience.
        anchorMap map[string]*CandidateNode

        readAnything  bool
        firstFile     bool
        documentIndex uint
}

func NewYamlDecoder(prefs YamlPreferences) Decoder {
        return &yamlDecoder{prefs: prefs, firstFile: true}
}

func (dec *yamlDecoder) processReadStream(reader *bufio.Reader) (io.Reader, string, error) {
        var sb strings.Builder

        for {
                line, err := reader.ReadString('\n')
                if errors.Is(err, io.EOF) && line == "" {
                        // no more data
                        return reader, sb.String(), nil
                }
                if err != nil && !errors.Is(err, io.EOF) {
                        return reader, sb.String(), err
                }

                // Determine newline style and strip it for inspection
                newline := ""
                if strings.HasSuffix(line, "\r\n") {
                        newline = "\r\n"
                        line = strings.TrimSuffix(line, "\r\n")
                } else if strings.HasSuffix(line, "\n") {
                        newline = "\n"
                        line = strings.TrimSuffix(line, "\n")
                }

                trimmed := strings.TrimSpace(line)

                // Document separator: exact line '---' or a '--- ' prefix followed by content
                if separatorLineRe.MatchString(trimmed) {
                        sb.WriteString("$yqDocSeparator$")
                        sb.WriteString(newline)
                        if errors.Is(err, io.EOF) {
                                return reader, sb.String(), nil
                        }
                        continue
                }

                // Handle lines that start with '--- ' followed by more content (e.g. '--- cat')
                if separatorPrefixRe.MatchString(line) {
                        match := separatorPrefixRe.FindString(line)
                        remainder := line[len(match):]
                        // normalise separator newline: if original had none, default to LF
                        sepNewline := newline
                        if sepNewline == "" {
                                sepNewline = "\n"
                        }
                        sb.WriteString("$yqDocSeparator$")
                        sb.WriteString(sepNewline)
                        // push the remainder back onto the reader and continue processing
                        reader = bufio.NewReader(io.MultiReader(strings.NewReader(remainder), reader))
                        if errors.Is(err, io.EOF) && remainder == "" {
                                return reader, sb.String(), nil
                        }
                        continue
                }

                // Comments, YAML directives, and blank lines are leading content
                if commentLineRe.MatchString(line) || yamlDirectiveLineRe.MatchString(line) || trimmed == "" {
                        sb.WriteString(line)
                        sb.WriteString(newline)
                        if errors.Is(err, io.EOF) {
                                return reader, sb.String(), nil
                        }
                        continue
                }

                // First non-leading line: push it back onto a reader and return
                originalLine := line + newline
                return io.MultiReader(strings.NewReader(originalLine), reader), sb.String(), nil
        }
}

func (dec *yamlDecoder) Init(reader io.Reader) error {
        readerToUse := reader
        leadingContent := ""
        dec.bufferRead = bytes.Buffer{}
        var err error
        // if we 'evaluating together' - we only process the leading content
        // of the first file - this ensures comments from subsequent files are
        // merged together correctly.
        if dec.prefs.LeadingContentPreProcessing && (!dec.prefs.EvaluateTogether || dec.firstFile) {
                readerToUse, leadingContent, err = dec.processReadStream(bufio.NewReader(reader))
                if err != nil {
                        return err
                }
        } else if !dec.prefs.LeadingContentPreProcessing {
                // if we're not process the leading content
                // keep a copy of what we've read. This is incase its a
                // doc with only comments - the decoder will return nothing
                // then we can read the comments from bufferRead
                readerToUse = io.TeeReader(reader, &dec.bufferRead)
        }
        dec.leadingContent = leadingContent
        dec.readAnything = false
        dec.decoder = *yaml.NewDecoder(readerToUse)
        dec.firstFile = false
        dec.documentIndex = 0
        dec.anchorMap = make(map[string]*CandidateNode)
        return nil
}

func (dec *yamlDecoder) Decode() (*CandidateNode, error) {
        var yamlNode yaml.Node
        err := dec.decoder.Decode(&yamlNode)

        if errors.Is(err, io.EOF) && dec.leadingContent != "" && !dec.readAnything {
                // force returning an empty node with a comment.
                dec.readAnything = true
                return dec.blankNodeWithComment(), nil
        } else if errors.Is(err, io.EOF) && !dec.prefs.LeadingContentPreProcessing && !dec.readAnything {
                // didn't find any yaml,
                // check the tee buffer, maybe there were comments
                dec.readAnything = true
                dec.leadingContent = dec.bufferRead.String()
                if dec.leadingContent != "" {
                        return dec.blankNodeWithComment(), nil
                }
                return nil, err
        } else if err != nil {
                return nil, err
        } else if len(yamlNode.Content) == 0 {
                return nil, errors.New("yaml node has no content")
        }

        candidateNode := CandidateNode{document: dec.documentIndex}
        // don't bother with the DocumentNode
        err = candidateNode.UnmarshalYAML(yamlNode.Content[0], dec.anchorMap)
        if err != nil {
                return nil, err
        }

        candidateNode.HeadComment = yamlNode.HeadComment + candidateNode.HeadComment
        candidateNode.FootComment = yamlNode.FootComment + candidateNode.FootComment

        if dec.leadingContent != "" {
                candidateNode.LeadingContent = dec.leadingContent
                dec.leadingContent = ""
        }
        dec.readAnything = true
        dec.documentIndex++
        return &candidateNode, nil
}

func (dec *yamlDecoder) blankNodeWithComment() *CandidateNode {
        node := createScalarNode(nil, "")
        node.LeadingContent = dec.leadingContent
        return node
}

package yqlib

import (
        "bufio"
        "errors"
        "io"
        "strings"

        "github.com/fatih/color"
)

type Encoder interface {
        Encode(writer io.Writer, node *CandidateNode) error
        PrintDocumentSeparator(writer io.Writer) error
        PrintLeadingContent(writer io.Writer, content string) error
        CanHandleAliases() bool
}

func mapKeysToStrings(node *CandidateNode) {

        if node.Kind == MappingNode {
                for index, child := range node.Content {
                        if index%2 == 0 { // its a map key
                                child.Tag = "!!str"
                        }
                }
        }

        for _, child := range node.Content {
                mapKeysToStrings(child)
        }
}

// Some funcs are shared between encoder_yaml and encoder_kyaml
func PrintYAMLDocumentSeparator(writer io.Writer, PrintDocSeparators bool) error {
        if PrintDocSeparators {
                log.Debug("writing doc sep")
                if err := writeString(writer, "---\n"); err != nil {
                        return err
                }
        }
        return nil
}
func PrintYAMLLeadingContent(writer io.Writer, content string, PrintDocSeparators bool, ColorsEnabled bool) error {
        reader := bufio.NewReader(strings.NewReader(content))

        // reuse precompiled package-level regex
        // (declared in decoder_yaml.go)

        for {

                readline, errReading := reader.ReadString('\n')
                if errReading != nil && !errors.Is(errReading, io.EOF) {
                        return errReading
                }
                if strings.Contains(readline, "$yqDocSeparator$") {
                        // Preserve the original line ending (CRLF or LF)
                        lineEnding := "\n"
                        if strings.HasSuffix(readline, "\r\n") {
                                lineEnding = "\r\n"
                        }
                        if PrintDocSeparators {
                                if err := writeString(writer, "---"+lineEnding); err != nil {
                                        return err
                                }
                        }

                } else {
                        if len(readline) > 0 && readline != "\n" && readline[0] != '%' && !commentLineRe.MatchString(readline) {
                                readline = "# " + readline
                        }
                        if ColorsEnabled && strings.TrimSpace(readline) != "" {
                                readline = format(color.FgHiBlack) + readline + format(color.Reset)
                        }
                        if err := writeString(writer, readline); err != nil {
                                return err
                        }
                }

                if errors.Is(errReading, io.EOF) {
                        if readline != "" {
                                // the last comment we read didn't have a newline, put one in
                                if err := writeString(writer, "\n"); err != nil {
                                        return err
                                }
                        }
                        break
                }
        }

        return nil
}

//go:build !yq_nobase64

package yqlib

import (
        "encoding/base64"
        "fmt"
        "io"
)

type base64Encoder struct {
        encoding base64.Encoding
}

func NewBase64Encoder() Encoder {
        return &base64Encoder{encoding: *base64.StdEncoding}
}

func (e *base64Encoder) CanHandleAliases() bool {
        return false
}

func (e *base64Encoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (e *base64Encoder) PrintLeadingContent(_ io.Writer, _ string) error {
        return nil
}

func (e *base64Encoder) Encode(writer io.Writer, node *CandidateNode) error {
        if node.guessTagFromCustomType() != "!!str" {
                return fmt.Errorf("cannot encode %v as base64, can only operate on strings", node.Tag)
        }
        _, err := writer.Write([]byte(e.encoding.EncodeToString([]byte(node.Value))))
        return err
}

//go:build !yq_nocsv

package yqlib

import (
        "encoding/csv"
        "fmt"
        "io"
)

type csvEncoder struct {
        separator rune
}

func NewCsvEncoder(prefs CsvPreferences) Encoder {
        return &csvEncoder{separator: prefs.Separator}
}

func (e *csvEncoder) CanHandleAliases() bool {
        return false
}

func (e *csvEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (e *csvEncoder) PrintLeadingContent(_ io.Writer, _ string) error {
        return nil
}

func (e *csvEncoder) encodeRow(csvWriter *csv.Writer, contents []*CandidateNode) error {
        stringValues := make([]string, len(contents))

        for i, child := range contents {

                if child.Kind != ScalarNode {
                        return fmt.Errorf("csv encoding only works for arrays of scalars (string/numbers/booleans), child[%v] is a %v", i, child.Tag)
                }
                stringValues[i] = child.Value
        }
        return csvWriter.Write(stringValues)
}

func (e *csvEncoder) encodeArrays(csvWriter *csv.Writer, content []*CandidateNode) error {
        for i, child := range content {

                if child.Kind != SequenceNode {
                        return fmt.Errorf("csv encoding only works for arrays of scalars (string/numbers/booleans), child[%v] is a %v", i, child.Tag)
                }
                err := e.encodeRow(csvWriter, child.Content)
                if err != nil {
                        return err
                }
        }
        return nil
}

func (e *csvEncoder) extractHeader(child *CandidateNode) ([]*CandidateNode, error) {
        if child.Kind != MappingNode {
                return nil, fmt.Errorf("csv object encoding only works for arrays of flat objects (string key => string/numbers/boolean value), child[0] is a %v", child.Tag)
        }
        mapKeys := getMapKeys(child)
        return mapKeys.Content, nil
}

func (e *csvEncoder) createChildRow(child *CandidateNode, headers []*CandidateNode) []*CandidateNode {
        childRow := make([]*CandidateNode, 0)
        for _, header := range headers {
                keyIndex := findKeyInMap(child, header)
                value := createScalarNode(nil, "")
                if keyIndex != -1 {
                        value = child.Content[keyIndex+1]
                }
                childRow = append(childRow, value)
        }
        return childRow

}

func (e *csvEncoder) encodeObjects(csvWriter *csv.Writer, content []*CandidateNode) error {
        headers, err := e.extractHeader(content[0])
        if err != nil {
                return nil
        }

        err = e.encodeRow(csvWriter, headers)
        if err != nil {
                return nil
        }

        for i, child := range content {
                if child.Kind != MappingNode {
                        return fmt.Errorf("csv object encoding only works for arrays of flat objects (string key => string/numbers/boolean value), child[%v] is a %v", i, child.Tag)
                }
                row := e.createChildRow(child, headers)
                err = e.encodeRow(csvWriter, row)
                if err != nil {
                        return err
                }

        }
        return nil
}

func (e *csvEncoder) Encode(writer io.Writer, node *CandidateNode) error {
        if node.Kind == ScalarNode {
                return writeString(writer, node.Value+"\n")
        }

        csvWriter := csv.NewWriter(writer)
        csvWriter.Comma = e.separator

        // node must be a sequence
        if node.Kind != SequenceNode {
                return fmt.Errorf("csv encoding only works for arrays, got: %v", node.Tag)
        } else if len(node.Content) == 0 {
                return nil
        }
        if node.Content[0].Kind == ScalarNode {
                return e.encodeRow(csvWriter, node.Content)
        }

        if node.Content[0].Kind == MappingNode {
                return e.encodeObjects(csvWriter, node.Content)
        }

        return e.encodeArrays(csvWriter, node.Content)

}

//go:build !yq_nohcl

package yqlib

import (
        "fmt"
        "io"
        "regexp"
        "strings"

        "github.com/fatih/color"
        "github.com/hashicorp/hcl/v2"
        "github.com/hashicorp/hcl/v2/hclsyntax"
        hclwrite "github.com/hashicorp/hcl/v2/hclwrite"
        "github.com/zclconf/go-cty/cty"
)

type hclEncoder struct {
        prefs HclPreferences
}

// commentPathSep is used to join path segments when collecting comments.
// It uses a rarely used ASCII control character to avoid collisions with
// normal key names (including dots).
const commentPathSep = "\x1e"

// NewHclEncoder creates a new HCL encoder
func NewHclEncoder(prefs HclPreferences) Encoder {
        return &hclEncoder{prefs: prefs}
}

func (he *hclEncoder) CanHandleAliases() bool {
        return false
}

func (he *hclEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (he *hclEncoder) PrintLeadingContent(_ io.Writer, _ string) error {
        return nil
}

func (he *hclEncoder) Encode(writer io.Writer, node *CandidateNode) error {
        log.Debugf("I need to encode %v", NodeToString(node))
        if node.Kind == ScalarNode {
                return writeString(writer, node.Value+"\n")
        }

        f := hclwrite.NewEmptyFile()
        body := f.Body()

        // Collect comments as we encode
        commentMap := make(map[string]string)
        he.collectComments(node, "", commentMap)

        if err := he.encodeNode(body, node); err != nil {
                return fmt.Errorf("failed to encode HCL: %w", err)
        }

        // Get the formatted output and remove extra spacing before '='
        output := f.Bytes()
        compactOutput := he.compactSpacing(output)

        // Inject comments back into the output
        finalOutput := he.injectComments(compactOutput, commentMap)

        if he.prefs.ColorsEnabled {
                colourized := he.colorizeHcl(finalOutput)
                _, err := writer.Write(colourized)
                return err
        }

        _, err := writer.Write(finalOutput)
        return err
}

// compactSpacing removes extra whitespace before '=' in attribute assignments
func (he *hclEncoder) compactSpacing(input []byte) []byte {
        // Use regex to replace multiple spaces before = with single space
        re := regexp.MustCompile(`(\S)\s{2,}=`)
        return re.ReplaceAll(input, []byte("$1 ="))
}

// collectComments recursively collects comments from nodes for later injection
func (he *hclEncoder) collectComments(node *CandidateNode, prefix string, commentMap map[string]string) {
        if node == nil {
                return
        }

        // For mapping nodes, collect comments from keys and values
        if node.Kind == MappingNode {
                // Collect root-level head comment if at root (prefix is empty)
                if prefix == "" && node.HeadComment != "" {
                        commentMap[joinCommentPath("__root__", "head")] = node.HeadComment
                }

                for i := 0; i < len(node.Content); i += 2 {
                        keyNode := node.Content[i]
                        valueNode := node.Content[i+1]
                        key := keyNode.Value

                        // Create a path for this key
                        path := joinCommentPath(prefix, key)

                        // Store comments from the key (head comments appear before the attribute)
                        if keyNode.HeadComment != "" {
                                commentMap[joinCommentPath(path, "head")] = keyNode.HeadComment
                        }
                        // Store comments from the value (line comments appear after the value)
                        if valueNode.LineComment != "" {
                                commentMap[joinCommentPath(path, "line")] = valueNode.LineComment
                        }
                        if valueNode.FootComment != "" {
                                commentMap[joinCommentPath(path, "foot")] = valueNode.FootComment
                        }

                        // Recurse into nested mappings
                        if valueNode.Kind == MappingNode {
                                he.collectComments(valueNode, path, commentMap)
                        }
                }
        }
}

// joinCommentPath concatenates path segments using commentPathSep, safely handling empty prefixes.
func joinCommentPath(prefix, segment string) string {
        if prefix == "" {
                return segment
        }
        return prefix + commentPathSep + segment
}

// injectComments adds collected comments back into the HCL output
func (he *hclEncoder) injectComments(output []byte, commentMap map[string]string) []byte {
        // Convert output to string for easier manipulation
        result := string(output)

        // Root-level head comment (stored on the synthetic __root__/head path)
        for path, comment := range commentMap {
                if path == joinCommentPath("__root__", "head") {
                        trimmed := strings.TrimSpace(comment)
                        if trimmed != "" && !strings.HasPrefix(result, trimmed) {
                                result = trimmed + "\n" + result
                        }
                }
        }

        // Attribute head comments: insert above matching assignment
        for path, comment := range commentMap {
                parts := strings.Split(path, commentPathSep)
                if len(parts) < 2 {
                        continue
                }

                commentType := parts[len(parts)-1]
                key := parts[len(parts)-2]
                if commentType != "head" || key == "" {
                        continue
                }

                trimmed := strings.TrimSpace(comment)
                if trimmed == "" {
                        continue
                }

                re := regexp.MustCompile(`(?m)^(\s*)` + regexp.QuoteMeta(key) + `\s*=`)
                if re.MatchString(result) {
                        result = re.ReplaceAllString(result, "$1"+trimmed+"\n$0")
                }
        }

        return []byte(result)
}

func (he *hclEncoder) colorizeHcl(input []byte) []byte {
        hcl := string(input)
        result := strings.Builder{}

        // Create colour functions for different token types
        commentColor := color.New(color.FgHiBlack).SprintFunc()
        stringColor := color.New(color.FgGreen).SprintFunc()
        numberColor := color.New(color.FgHiMagenta).SprintFunc()
        keyColor := color.New(color.FgCyan).SprintFunc()
        boolColor := color.New(color.FgHiMagenta).SprintFunc()

        // Simple tokenization for HCL colouring
        i := 0
        for i < len(hcl) {
                ch := hcl[i]

                // Comments - from # to end of line
                if ch == '#' {
                        end := i
                        for end < len(hcl) && hcl[end] != '\n' {
                                end++
                        }
                        result.WriteString(commentColor(hcl[i:end]))
                        i = end
                        continue
                }

                // Strings - quoted text
                if ch == '"' || ch == '\'' {
                        quote := ch
                        end := i + 1
                        for end < len(hcl) && hcl[end] != quote {
                                if hcl[end] == '\\' {
                                        end++ // skip escaped char
                                }
                                end++
                        }
                        if end < len(hcl) {
                                end++ // include closing quote
                        }
                        result.WriteString(stringColor(hcl[i:end]))
                        i = end
                        continue
                }

                // Numbers - sequences of digits, possibly with decimal point or minus
                if (ch >= '0' && ch <= '9') || (ch == '-' && i+1 < len(hcl) && hcl[i+1] >= '0' && hcl[i+1] <= '9') {
                        end := i
                        if ch == '-' {
                                end++
                        }
                        for end < len(hcl) && ((hcl[end] >= '0' && hcl[end] <= '9') || hcl[end] == '.') {
                                end++
                        }
                        result.WriteString(numberColor(hcl[i:end]))
                        i = end
                        continue
                }

                // Identifiers/keys - alphanumeric + underscore
                if (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' {
                        end := i
                        for end < len(hcl) && ((hcl[end] >= 'a' && hcl[end] <= 'z') ||
                                (hcl[end] >= 'A' && hcl[end] <= 'Z') ||
                                (hcl[end] >= '0' && hcl[end] <= '9') ||
                                hcl[end] == '_' || hcl[end] == '-') {
                                end++
                        }
                        ident := hcl[i:end]

                        // Check if this is a keyword/reserved word
                        switch ident {
                        case "true", "false", "null":
                                result.WriteString(boolColor(ident))
                        default:
                                // Check if followed by = (it's a key)
                                j := end
                                for j < len(hcl) && (hcl[j] == ' ' || hcl[j] == '\t') {
                                        j++
                                }
                                if j < len(hcl) && hcl[j] == '=' {
                                        result.WriteString(keyColor(ident))
                                } else if j < len(hcl) && hcl[j] == '{' {
                                        // Block type
                                        result.WriteString(keyColor(ident))
                                } else {
                                        result.WriteString(ident) // plain text for other identifiers
                                }
                        }
                        i = end
                        continue
                }

                // Everything else (whitespace, operators, brackets) - no color
                result.WriteByte(ch)
                i++
        }

        return []byte(result.String())
}

// Helper runes for unquoted identifiers
func isHCLIdentifierStart(r rune) bool {
        return (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || r == '_'
}

func isHCLIdentifierPart(r rune) bool {
        return (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_' || r == '-'
}

func isValidHCLIdentifier(s string) bool {
        if s == "" {
                return false
        }
        // HCL identifiers must start with a letter or underscore
        // and contain only letters, digits, underscores, and hyphens
        for i, r := range s {
                if i == 0 {
                        if !isHCLIdentifierStart(r) {
                                return false
                        }
                        continue
                }
                if !isHCLIdentifierPart(r) {
                        return false
                }
        }
        return true
}

// tokensForRawHCLExpr produces a minimal token stream for a simple HCL expression so we can
// write it without introducing quotes (e.g. function calls like upper(message)).
func tokensForRawHCLExpr(expr string) (hclwrite.Tokens, error) {
        var tokens hclwrite.Tokens
        for i := 0; i < len(expr); {
                ch := expr[i]
                switch {
                case ch == ' ' || ch == '\t':
                        i++
                        continue
                case isHCLIdentifierStart(rune(ch)):
                        start := i
                        i++
                        for i < len(expr) && isHCLIdentifierPart(rune(expr[i])) {
                                i++
                        }
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenIdent, Bytes: []byte(expr[start:i])})
                        continue
                case ch >= '0' && ch <= '9':
                        start := i
                        i++
                        for i < len(expr) && ((expr[i] >= '0' && expr[i] <= '9') || expr[i] == '.') {
                                i++
                        }
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenNumberLit, Bytes: []byte(expr[start:i])})
                        continue
                case ch == '(':
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenOParen, Bytes: []byte{'('}})
                case ch == ')':
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenCParen, Bytes: []byte{')'}})
                case ch == ',':
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenComma, Bytes: []byte{','}})
                case ch == '.':
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenDot, Bytes: []byte{'.'}})
                case ch == '+':
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenPlus, Bytes: []byte{'+'}})
                case ch == '-':
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenMinus, Bytes: []byte{'-'}})
                case ch == '*':
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenStar, Bytes: []byte{'*'}})
                case ch == '/':
                        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenSlash, Bytes: []byte{'/'}})
                default:
                        return nil, fmt.Errorf("unsupported character %q in raw HCL expression", ch)
                }
                i++
        }
        return tokens, nil
}

// encodeAttribute encodes a value as an HCL attribute
func (he *hclEncoder) encodeAttribute(body *hclwrite.Body, key string, valueNode *CandidateNode) error {
        if valueNode.Kind == ScalarNode && valueNode.Tag == "!!str" {
                // Handle unquoted expressions (as-is, without quotes)
                if valueNode.Style == 0 {
                        tokens, err := tokensForRawHCLExpr(valueNode.Value)
                        if err != nil {
                                return err
                        }
                        body.SetAttributeRaw(key, tokens)
                        return nil
                }
                if valueNode.Style&LiteralStyle != 0 {
                        tokens, err := tokensForRawHCLExpr(valueNode.Value)
                        if err != nil {
                                return err
                        }
                        body.SetAttributeRaw(key, tokens)
                        return nil
                }
                // Check if template with interpolation
                if valueNode.Style&DoubleQuotedStyle != 0 && strings.Contains(valueNode.Value, "${") {
                        return he.encodeTemplateAttribute(body, key, valueNode.Value)
                }
                // Check if unquoted identifier
                if isValidHCLIdentifier(valueNode.Value) && valueNode.Style == 0 {
                        traversal := hcl.Traversal{
                                hcl.TraverseRoot{Name: valueNode.Value},
                        }
                        body.SetAttributeTraversal(key, traversal)
                        return nil
                }
        }
        // Default: use cty.Value for quoted strings and all other types
        ctyValue, err := nodeToCtyValue(valueNode)
        if err != nil {
                return err
        }
        body.SetAttributeValue(key, ctyValue)
        return nil
}

// encodeTemplateAttribute encodes a template string with ${} interpolations
func (he *hclEncoder) encodeTemplateAttribute(body *hclwrite.Body, key string, templateStr string) error {
        tokens := hclwrite.Tokens{
                {Type: hclsyntax.TokenOQuote, Bytes: []byte{'"'}},
        }

        for i := 0; i < len(templateStr); i++ {
                if i < len(templateStr)-1 && templateStr[i] == '$' && templateStr[i+1] == '{' {
                        // Start of template interpolation
                        tokens = append(tokens, &hclwrite.Token{
                                Type:  hclsyntax.TokenTemplateInterp,
                                Bytes: []byte("${"),
                        })
                        i++ // skip the '{'
                        // Find the matching '}'
                        start := i + 1
                        depth := 1
                        for i++; i < len(templateStr) && depth > 0; i++ {
                                switch templateStr[i] {
                                case '{':
                                        depth++
                                case '}':
                                        depth--
                                }
                        }
                        i-- // back up to the '}'
                        interpExpr := templateStr[start:i]
                        tokens = append(tokens, &hclwrite.Token{
                                Type:  hclsyntax.TokenIdent,
                                Bytes: []byte(interpExpr),
                        })
                        tokens = append(tokens, &hclwrite.Token{
                                Type:  hclsyntax.TokenTemplateSeqEnd,
                                Bytes: []byte("}"),
                        })
                } else {
                        // Regular character
                        tokens = append(tokens, &hclwrite.Token{
                                Type:  hclsyntax.TokenQuotedLit,
                                Bytes: []byte{templateStr[i]},
                        })
                }
        }
        tokens = append(tokens, &hclwrite.Token{Type: hclsyntax.TokenCQuote, Bytes: []byte{'"'}})
        body.SetAttributeRaw(key, tokens)
        return nil
}

// encodeBlockIfMapping attempts to encode a value as a block. Returns true if it was encoded as a block.
func (he *hclEncoder) encodeBlockIfMapping(body *hclwrite.Body, key string, valueNode *CandidateNode) bool {
        if valueNode.Kind != MappingNode || valueNode.Style == FlowStyle {
                return false
        }

        // If EncodeSeparate is set, emit children as separate blocks regardless of label extraction
        if valueNode.EncodeSeparate {
                if handled, _ := he.encodeMappingChildrenAsBlocks(body, key, valueNode); handled {
                        return true
                }
        }

        // Try to extract block labels from a single-entry mapping chain
        if labels, bodyNode, ok := extractBlockLabels(valueNode); ok {
                if len(labels) > 1 && mappingChildrenAllMappings(bodyNode) {
                        primaryLabels := labels[:len(labels)-1]
                        nestedType := labels[len(labels)-1]
                        block := body.AppendNewBlock(key, primaryLabels)
                        if handled, err := he.encodeMappingChildrenAsBlocks(block.Body(), nestedType, bodyNode); err == nil && handled {
                                return true
                        }
                        if err := he.encodeNodeAttributes(block.Body(), bodyNode); err == nil {
                                return true
                        }
                }
                block := body.AppendNewBlock(key, labels)
                if err := he.encodeNodeAttributes(block.Body(), bodyNode); err == nil {
                        return true
                }
        }

        // If all child values are mappings, treat each child key as a labelled instance of this block type
        if handled, _ := he.encodeMappingChildrenAsBlocks(body, key, valueNode); handled {
                return true
        }

        // No labels detected, render as unlabelled block
        block := body.AppendNewBlock(key, nil)
        if err := he.encodeNodeAttributes(block.Body(), valueNode); err == nil {
                return true
        }

        return false
}

// encodeNode encodes a CandidateNode directly to HCL, preserving style information
func (he *hclEncoder) encodeNode(body *hclwrite.Body, node *CandidateNode) error {
        if node.Kind != MappingNode {
                return fmt.Errorf("HCL encoder expects a mapping at the root level, got %v", kindToString(node.Kind))
        }

        for i := 0; i < len(node.Content); i += 2 {
                keyNode := node.Content[i]
                valueNode := node.Content[i+1]
                key := keyNode.Value

                // Render as block or attribute depending on value type
                if he.encodeBlockIfMapping(body, key, valueNode) {
                        continue
                }

                // Render as attribute: key = value
                if err := he.encodeAttribute(body, key, valueNode); err != nil {
                        return err
                }
        }
        return nil
}

// mappingChildrenAllMappings reports whether all values in a mapping node are non-flow mappings.
func mappingChildrenAllMappings(node *CandidateNode) bool {
        if node == nil || node.Kind != MappingNode || node.Style == FlowStyle {
                return false
        }
        if len(node.Content) == 0 {
                return false
        }
        for i := 0; i < len(node.Content); i += 2 {
                childVal := node.Content[i+1]
                if childVal.Kind != MappingNode || childVal.Style == FlowStyle {
                        return false
                }
        }
        return true
}

// encodeMappingChildrenAsBlocks emits a block for each mapping child, treating the child key as a label.
// Returns handled=true when it emitted blocks.
func (he *hclEncoder) encodeMappingChildrenAsBlocks(body *hclwrite.Body, blockType string, valueNode *CandidateNode) (bool, error) {
        if !mappingChildrenAllMappings(valueNode) {
                return false, nil
        }

        // Only emit as separate blocks if EncodeSeparate is true
        // This allows the encoder to respect the original block structure preserved by the decoder
        if !valueNode.EncodeSeparate {
                return false, nil
        }

        for i := 0; i < len(valueNode.Content); i += 2 {
                childKey := valueNode.Content[i].Value
                childVal := valueNode.Content[i+1]

                // Check if this child also represents multiple blocks (all children are mappings)
                if mappingChildrenAllMappings(childVal) {
                        // Recursively emit each grandchild as a separate block with extended labels
                        for j := 0; j < len(childVal.Content); j += 2 {
                                grandchildKey := childVal.Content[j].Value
                                grandchildVal := childVal.Content[j+1]
                                labels := []string{childKey, grandchildKey}

                                // Try to extract additional labels if this is a single-entry chain
                                if extraLabels, bodyNode, ok := extractBlockLabels(grandchildVal); ok {
                                        labels = append(labels, extraLabels...)
                                        grandchildVal = bodyNode
                                }

                                block := body.AppendNewBlock(blockType, labels)
                                if err := he.encodeNodeAttributes(block.Body(), grandchildVal); err != nil {
                                        return true, err
                                }
                        }
                } else {
                        // Single block with this child as label(s)
                        labels := []string{childKey}
                        if extraLabels, bodyNode, ok := extractBlockLabels(childVal); ok {
                                labels = append(labels, extraLabels...)
                                childVal = bodyNode
                        }
                        block := body.AppendNewBlock(blockType, labels)
                        if err := he.encodeNodeAttributes(block.Body(), childVal); err != nil {
                                return true, err
                        }
                }
        }

        return true, nil
}

// encodeNodeAttributes encodes the attributes of a mapping node (used for blocks)
func (he *hclEncoder) encodeNodeAttributes(body *hclwrite.Body, node *CandidateNode) error {
        if node.Kind != MappingNode {
                return fmt.Errorf("expected mapping node for block body")
        }

        for i := 0; i < len(node.Content); i += 2 {
                keyNode := node.Content[i]
                valueNode := node.Content[i+1]
                key := keyNode.Value

                // Render as block or attribute depending on value type
                if he.encodeBlockIfMapping(body, key, valueNode) {
                        continue
                }

                // Render attribute for non-block value
                if err := he.encodeAttribute(body, key, valueNode); err != nil {
                        return err
                }
        }
        return nil
}

// extractBlockLabels detects a chain of single-entry mappings that encode block labels.
// It returns the collected labels and the final mapping to be used as the block body.
// Pattern: {label1: {label2: { ... {bodyMap} }}}
func extractBlockLabels(node *CandidateNode) ([]string, *CandidateNode, bool) {
        var labels []string
        current := node
        for current != nil && current.Kind == MappingNode && len(current.Content) == 2 {
                keyNode := current.Content[0]
                valNode := current.Content[1]
                if valNode.Kind != MappingNode {
                        break
                }
                labels = append(labels, keyNode.Value)
                // If the child is itself a single mapping entry with a mapping value, keep descending.
                if len(valNode.Content) == 2 && valNode.Content[1].Kind == MappingNode {
                        current = valNode
                        continue
                }
                // Otherwise, we have reached the body mapping.
                return labels, valNode, true
        }
        return nil, nil, false
}

// nodeToCtyValue converts a CandidateNode directly to cty.Value, preserving order
func nodeToCtyValue(node *CandidateNode) (cty.Value, error) {
        switch node.Kind {
        case ScalarNode:
                // Parse scalar value based on its tag
                switch node.Tag {
                case "!!bool":
                        return cty.BoolVal(node.Value == "true"), nil
                case "!!int":
                        var i int64
                        _, err := fmt.Sscanf(node.Value, "%d", &i)
                        if err != nil {
                                return cty.NilVal, err
                        }
                        return cty.NumberIntVal(i), nil
                case "!!float":
                        var f float64
                        _, err := fmt.Sscanf(node.Value, "%f", &f)
                        if err != nil {
                                return cty.NilVal, err
                        }
                        return cty.NumberFloatVal(f), nil
                case "!!null":
                        return cty.NullVal(cty.DynamicPseudoType), nil
                default:
                        // Default to string
                        return cty.StringVal(node.Value), nil
                }
        case MappingNode:
                // Preserve order by iterating Content directly
                m := make(map[string]cty.Value)
                for i := 0; i < len(node.Content); i += 2 {
                        keyNode := node.Content[i]
                        valueNode := node.Content[i+1]
                        v, err := nodeToCtyValue(valueNode)
                        if err != nil {
                                return cty.NilVal, err
                        }
                        m[keyNode.Value] = v
                }
                return cty.ObjectVal(m), nil
        case SequenceNode:
                vals := make([]cty.Value, len(node.Content))
                for i, item := range node.Content {
                        v, err := nodeToCtyValue(item)
                        if err != nil {
                                return cty.NilVal, err
                        }
                        vals[i] = v
                }
                return cty.TupleVal(vals), nil
        case AliasNode:
                return cty.NilVal, fmt.Errorf("HCL encoder does not support aliases")
        default:
                return cty.NilVal, fmt.Errorf("unsupported node kind: %v", node.Kind)
        }
}

//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
}

//go:build !yq_nojson

package yqlib

import (
        "bytes"
        "io"

        "github.com/goccy/go-json"
)

type jsonEncoder struct {
        prefs        JsonPreferences
        indentString string
}

func NewJSONEncoder(prefs JsonPreferences) Encoder {
        var indentString = ""

        for index := 0; index < prefs.Indent; index++ {
                indentString = indentString + " "
        }

        return &jsonEncoder{prefs, indentString}
}

func (je *jsonEncoder) CanHandleAliases() bool {
        return false
}

func (je *jsonEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (je *jsonEncoder) PrintLeadingContent(_ io.Writer, _ string) error {
        return nil
}

func (je *jsonEncoder) 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 && je.prefs.UnwrapScalar {
                return writeString(writer, node.Value+"\n")
        }

        destination := writer
        tempBuffer := bytes.NewBuffer(nil)
        if je.prefs.ColorsEnabled {
                destination = tempBuffer
        }

        var encoder = json.NewEncoder(destination)
        encoder.SetEscapeHTML(false) // do not escape html chars e.g. &, <, >
        encoder.SetIndent("", je.indentString)

        err := encoder.Encode(node)
        if err != nil {
                return err
        }
        if je.prefs.ColorsEnabled {
                return colorizeAndPrint(tempBuffer.Bytes(), writer)
        }
        return nil
}

//go:build !yq_nokyaml

package yqlib

import (
        "bytes"
        "io"
        "regexp"
        "strconv"
        "strings"
)

type kyamlEncoder struct {
        prefs KYamlPreferences
}

func NewKYamlEncoder(prefs KYamlPreferences) Encoder {
        return &kyamlEncoder{prefs: prefs}
}

func (ke *kyamlEncoder) CanHandleAliases() bool {
        // KYAML is a restricted subset; avoid emitting anchors/aliases.
        return false
}

func (ke *kyamlEncoder) PrintDocumentSeparator(writer io.Writer) error {
        return PrintYAMLDocumentSeparator(writer, ke.prefs.PrintDocSeparators)
}

func (ke *kyamlEncoder) PrintLeadingContent(writer io.Writer, content string) error {
        return PrintYAMLLeadingContent(writer, content, ke.prefs.PrintDocSeparators, ke.prefs.ColorsEnabled)
}

func (ke *kyamlEncoder) Encode(writer io.Writer, node *CandidateNode) error {
        log.Debug("encoderKYaml - going to print %v", NodeToString(node))
        if node.Kind == ScalarNode && ke.prefs.UnwrapScalar {
                return writeString(writer, node.Value+"\n")
        }

        destination := writer
        tempBuffer := bytes.NewBuffer(nil)
        if ke.prefs.ColorsEnabled {
                destination = tempBuffer
        }

        // Mirror the YAML encoder behaviour: trailing comments on the document root
        // are stored in FootComment and need to be printed after the document.
        trailingContent := node.FootComment

        if err := ke.writeCommentBlock(destination, node.HeadComment, 0); err != nil {
                return err
        }
        if err := ke.writeNode(destination, node, 0); err != nil {
                return err
        }
        if err := ke.writeInlineComment(destination, node.LineComment); err != nil {
                return err
        }
        if err := writeString(destination, "\n"); err != nil {
                return err
        }
        if err := ke.PrintLeadingContent(destination, trailingContent); err != nil {
                return err
        }

        if ke.prefs.ColorsEnabled {
                return colorizeAndPrint(tempBuffer.Bytes(), writer)
        }
        return nil
}

func (ke *kyamlEncoder) writeNode(writer io.Writer, node *CandidateNode, indent int) error {
        switch node.Kind {
        case MappingNode:
                return ke.writeMapping(writer, node, indent)
        case SequenceNode:
                return ke.writeSequence(writer, node, indent)
        case ScalarNode:
                return writeString(writer, ke.formatScalar(node))
        case AliasNode:
                // Should have been exploded by the printer, but handle defensively.
                if node.Alias == nil {
                        return writeString(writer, "null")
                }
                return ke.writeNode(writer, node.Alias, indent)
        default:
                return writeString(writer, "null")
        }
}

func (ke *kyamlEncoder) writeMapping(writer io.Writer, node *CandidateNode, indent int) error {
        if len(node.Content) == 0 {
                return writeString(writer, "{}")
        }
        if err := writeString(writer, "{\n"); err != nil {
                return err
        }

        for i := 0; i+1 < len(node.Content); i += 2 {
                keyNode := node.Content[i]
                valueNode := node.Content[i+1]

                entryIndent := indent + ke.prefs.Indent
                if err := ke.writeCommentBlock(writer, keyNode.HeadComment, entryIndent); err != nil {
                        return err
                }
                if valueNode.HeadComment != "" && valueNode.HeadComment != keyNode.HeadComment {
                        if err := ke.writeCommentBlock(writer, valueNode.HeadComment, entryIndent); err != nil {
                                return err
                        }
                }

                if err := ke.writeIndent(writer, entryIndent); err != nil {
                        return err
                }
                if err := writeString(writer, ke.formatKey(keyNode)); err != nil {
                        return err
                }
                if err := writeString(writer, ": "); err != nil {
                        return err
                }
                if err := ke.writeNode(writer, valueNode, entryIndent); err != nil {
                        return err
                }

                // Always emit a trailing comma; KYAML encourages explicit separators,
                // and this ensures all quoted strings have a trailing `",` as requested.
                if err := writeString(writer, ","); err != nil {
                        return err
                }
                inline := valueNode.LineComment
                if inline == "" {
                        inline = keyNode.LineComment
                }
                if err := ke.writeInlineComment(writer, inline); err != nil {
                        return err
                }
                if err := writeString(writer, "\n"); err != nil {
                        return err
                }

                foot := valueNode.FootComment
                if foot == "" {
                        foot = keyNode.FootComment
                }
                if err := ke.writeCommentBlock(writer, foot, entryIndent); err != nil {
                        return err
                }
        }

        if err := ke.writeIndent(writer, indent); err != nil {
                return err
        }
        return writeString(writer, "}")
}

func (ke *kyamlEncoder) writeSequence(writer io.Writer, node *CandidateNode, indent int) error {
        if len(node.Content) == 0 {
                return writeString(writer, "[]")
        }
        if err := writeString(writer, "[\n"); err != nil {
                return err
        }

        for _, child := range node.Content {
                itemIndent := indent + ke.prefs.Indent
                if err := ke.writeCommentBlock(writer, child.HeadComment, itemIndent); err != nil {
                        return err
                }
                if err := ke.writeIndent(writer, itemIndent); err != nil {
                        return err
                }
                if err := ke.writeNode(writer, child, itemIndent); err != nil {
                        return err
                }
                if err := writeString(writer, ","); err != nil {
                        return err
                }
                if err := ke.writeInlineComment(writer, child.LineComment); err != nil {
                        return err
                }
                if err := writeString(writer, "\n"); err != nil {
                        return err
                }
                if err := ke.writeCommentBlock(writer, child.FootComment, itemIndent); err != nil {
                        return err
                }
        }

        if err := ke.writeIndent(writer, indent); err != nil {
                return err
        }
        return writeString(writer, "]")
}

func (ke *kyamlEncoder) writeIndent(writer io.Writer, indent int) error {
        if indent <= 0 {
                return nil
        }
        return writeString(writer, strings.Repeat(" ", indent))
}

func (ke *kyamlEncoder) formatKey(keyNode *CandidateNode) string {
        // KYAML examples use bare keys. Quote keys only when needed.
        key := keyNode.Value
        if isValidKYamlBareKey(key) {
                return key
        }
        return `"` + escapeDoubleQuotedString(key) + `"`
}

func (ke *kyamlEncoder) formatScalar(node *CandidateNode) string {
        switch node.Tag {
        case "!!null":
                return "null"
        case "!!bool":
                return strings.ToLower(node.Value)
        case "!!int", "!!float":
                return node.Value
        case "!!str":
                return `"` + escapeDoubleQuotedString(node.Value) + `"`
        default:
                // Fall back to a string representation to avoid implicit typing surprises.
                return `"` + escapeDoubleQuotedString(node.Value) + `"`
        }
}

var kyamlBareKeyRe = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_-]*$`)

func isValidKYamlBareKey(s string) bool {
        // Conservative: require an identifier-like key; otherwise quote.
        if s == "" {
                return false
        }
        return kyamlBareKeyRe.MatchString(s)
}

func escapeDoubleQuotedString(s string) string {
        var b strings.Builder
        b.Grow(len(s) + 2)

        for _, r := range s {
                switch r {
                case '\\':
                        b.WriteString(`\\`)
                case '"':
                        b.WriteString(`\"`)
                case '\n':
                        b.WriteString(`\n`)
                case '\r':
                        b.WriteString(`\r`)
                case '\t':
                        b.WriteString(`\t`)
                default:
                        if r < 0x20 {
                                // YAML double-quoted strings support \uXXXX escapes.
                                b.WriteString(`\u`)
                                hex := "0000" + strings.ToUpper(strconv.FormatInt(int64(r), 16))
                                b.WriteString(hex[len(hex)-4:])
                        } else {
                                b.WriteRune(r)
                        }
                }
        }
        return b.String()
}

func (ke *kyamlEncoder) writeCommentBlock(writer io.Writer, comment string, indent int) error {
        if strings.TrimSpace(comment) == "" {
                return nil
        }

        lines := strings.Split(strings.ReplaceAll(comment, "\r\n", "\n"), "\n")
        for _, line := range lines {
                trimmed := strings.TrimSpace(line)
                if trimmed == "" {
                        continue
                }

                if err := ke.writeIndent(writer, indent); err != nil {
                        return err
                }

                toWrite := line
                if !commentLineRe.MatchString(toWrite) {
                        toWrite = "# " + toWrite
                }
                if err := writeString(writer, toWrite); err != nil {
                        return err
                }
                if err := writeString(writer, "\n"); err != nil {
                        return err
                }
        }
        return nil
}

func (ke *kyamlEncoder) writeInlineComment(writer io.Writer, comment string) error {
        comment = strings.TrimSpace(strings.ReplaceAll(comment, "\r\n", "\n"))
        if comment == "" {
                return nil
        }

        lines := strings.Split(comment, "\n")
        first := strings.TrimSpace(lines[0])
        if first == "" {
                return nil
        }

        if !strings.HasPrefix(first, "#") {
                first = "# " + first
        }

        if err := writeString(writer, " "); err != nil {
                return err
        }
        return writeString(writer, first)
}

//go:build !yq_nolua

package yqlib

import (
        "fmt"
        "io"
        "strings"
)

type luaEncoder struct {
        docPrefix string
        docSuffix string
        indent    int
        indentStr string
        unquoted  bool
        globals   bool
        escape    *strings.Replacer
}

func (le *luaEncoder) CanHandleAliases() bool {
        return false
}

func NewLuaEncoder(prefs LuaPreferences) Encoder {
        escape := strings.NewReplacer(
                "\000", "\\000",
                "\001", "\\001",
                "\002", "\\002",
                "\003", "\\003",
                "\004", "\\004",
                "\005", "\\005",
                "\006", "\\006",
                "\007", "\\a",
                "\010", "\\b",
                "\011", "\\t",
                "\012", "\\n",
                "\013", "\\v",
                "\014", "\\f",
                "\015", "\\r",
                "\016", "\\014",
                "\017", "\\015",
                "\020", "\\016",
                "\021", "\\017",
                "\022", "\\018",
                "\023", "\\019",
                "\024", "\\020",
                "\025", "\\021",
                "\026", "\\022",
                "\027", "\\023",
                "\030", "\\024",
                "\031", "\\025",
                "\032", "\\026",
                "\033", "\\027",
                "\034", "\\028",
                "\035", "\\029",
                "\036", "\\030",
                "\037", "\\031",
                "\"", "\\\"",
                "'", "\\'",
                "\\", "\\\\",
                "\177", "\\127",
        )
        unescape := strings.NewReplacer(
                "\\'", "'",
                "\\\"", "\"",
                "\\n", "\n",
                "\\r", "\r",
                "\\t", "\t",
                "\\\\", "\\",
        )
        return &luaEncoder{unescape.Replace(prefs.DocPrefix), unescape.Replace(prefs.DocSuffix), 0, "\t", prefs.UnquotedKeys, prefs.Globals, escape}
}

func (le *luaEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (le *luaEncoder) PrintLeadingContent(_ io.Writer, _ string) error {
        return nil
}

func (le *luaEncoder) encodeString(writer io.Writer, node *CandidateNode) error {
        quote := "\""
        switch node.Style {
        case LiteralStyle, FoldedStyle, FlowStyle:
                for i := 0; i < 10; i++ {
                        if !strings.Contains(node.Value, "]"+strings.Repeat("=", i)+"]") {
                                err := writeString(writer, "["+strings.Repeat("=", i)+"[\n")
                                if err != nil {
                                        return err
                                }
                                err = writeString(writer, node.Value)
                                if err != nil {
                                        return err
                                }
                                return writeString(writer, "]"+strings.Repeat("=", i)+"]")
                        }
                }
        case SingleQuotedStyle:
                quote = "'"

                // fallthrough to regular ol' string
        }
        return writeString(writer, quote+le.escape.Replace(node.Value)+quote)
}

func (le *luaEncoder) writeIndent(writer io.Writer) error {
        if le.indentStr == "" {
                return nil
        }
        err := writeString(writer, "\n")
        if err != nil {
                return err
        }
        return writeString(writer, strings.Repeat(le.indentStr, le.indent))
}

func (le *luaEncoder) encodeArray(writer io.Writer, node *CandidateNode) error {
        err := writeString(writer, "{")
        if err != nil {
                return err
        }
        le.indent++
        for _, child := range node.Content {
                err = le.writeIndent(writer)
                if err != nil {
                        return err
                }
                err := le.encodeAny(writer, child)
                if err != nil {
                        return err
                }
                err = writeString(writer, ",")
                if err != nil {
                        return err
                }
                if child.LineComment != "" {
                        sansPrefix, _ := strings.CutPrefix(child.LineComment, "#")
                        err = writeString(writer, " --"+sansPrefix)
                        if err != nil {
                                return err
                        }
                }
        }
        le.indent--
        if len(node.Content) != 0 {
                err = le.writeIndent(writer)
                if err != nil {
                        return err
                }
        }
        return writeString(writer, "}")
}

func needsQuoting(s string) bool {
        // known keywords as of Lua 5.4
        switch s {
        case "do", "and", "else", "break",
                "if", "end", "goto", "false",
                "in", "for", "then", "local",
                "or", "nil", "true", "until",
                "elseif", "function", "not",
                "repeat", "return", "while":
                return true
        }
        // [%a_][%w_]*
        for i, c := range s {
                if i == 0 {
                        // keeping for legacy reasons, upgraded linter
                        //nolint:staticcheck
                        if !((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_') {
                                return true
                        }
                } else {
                        // keeping for legacy reasons, upgraded linter
                        //nolint:staticcheck
                        if !((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_') {
                                return true
                        }
                }
        }
        return false
}

func (le *luaEncoder) encodeMap(writer io.Writer, node *CandidateNode, global bool) error {
        if !global {
                err := writeString(writer, "{")
                if err != nil {
                        return err
                }
                le.indent++
        }
        for i, child := range node.Content {
                if (i % 2) == 1 {
                        // value
                        err := le.encodeAny(writer, child)
                        if err != nil {
                                return err
                        }
                        err = writeString(writer, ";")
                        if err != nil {
                                return err
                        }
                } else {
                        // key
                        if !global || i > 0 {
                                err := le.writeIndent(writer)
                                if err != nil {
                                        return err
                                }
                        }
                        if (le.unquoted || global) && child.Tag == "!!str" && !needsQuoting(child.Value) {
                                err := writeString(writer, child.Value+" = ")
                                if err != nil {
                                        return err
                                }
                        } else {
                                if global {
                                        // This only works in Lua 5.2+
                                        err := writeString(writer, "_ENV")
                                        if err != nil {
                                                return err
                                        }
                                }
                                err := writeString(writer, "[")
                                if err != nil {
                                        return err
                                }
                                err = le.encodeAny(writer, child)
                                if err != nil {
                                        return err
                                }
                                err = writeString(writer, "] = ")
                                if err != nil {
                                        return err
                                }
                        }
                }
                if child.LineComment != "" {
                        sansPrefix, _ := strings.CutPrefix(child.LineComment, "#")
                        err := writeString(writer, strings.Repeat(" ", i%2)+"--"+sansPrefix)
                        if err != nil {
                                return err
                        }
                        if (i % 2) == 0 {
                                // newline and indent after comments on keys
                                err = le.writeIndent(writer)
                                if err != nil {
                                        return err
                                }
                        }
                }
        }
        if global {
                return writeString(writer, "\n")
        }
        le.indent--
        if len(node.Content) != 0 {
                err := le.writeIndent(writer)
                if err != nil {
                        return err
                }
        }
        return writeString(writer, "}")
}

func (le *luaEncoder) encodeAny(writer io.Writer, node *CandidateNode) error {
        switch node.Kind {
        case SequenceNode:
                return le.encodeArray(writer, node)
        case MappingNode:
                return le.encodeMap(writer, node, false)
        case ScalarNode:
                switch node.Tag {
                case "!!str":
                        return le.encodeString(writer, node)
                case "!!null":
                        // TODO reject invalid use as a table key
                        return writeString(writer, "nil")
                case "!!bool":
                        // Yaml 1.2 has case variation e.g. True, FALSE etc but Lua only has
                        // lower case
                        return writeString(writer, strings.ToLower(node.Value))
                case "!!int":
                        if strings.HasPrefix(node.Value, "0o") {
                                _, octalValue, err := parseInt64(node.Value)
                                if err != nil {
                                        return err
                                }
                                return writeString(writer, fmt.Sprintf("%d", octalValue))
                        }
                        return writeString(writer, strings.ToLower(node.Value))
                case "!!float":
                        switch strings.ToLower(node.Value) {
                        case ".inf", "+.inf":
                                return writeString(writer, "(1/0)")
                        case "-.inf":
                                return writeString(writer, "(-1/0)")
                        case ".nan":
                                return writeString(writer, "(0/0)")
                        default:
                                return writeString(writer, node.Value)
                        }
                default:
                        return fmt.Errorf("lua encoder NYI -- %s", node.Tag)
                }
        default:
                return fmt.Errorf("lua encoder NYI -- %s", node.Tag)
        }
}

func (le *luaEncoder) encodeTopLevel(writer io.Writer, node *CandidateNode) error {
        err := writeString(writer, le.docPrefix)
        if err != nil {
                return err
        }
        err = le.encodeAny(writer, node)
        if err != nil {
                return err
        }
        return writeString(writer, le.docSuffix)
}

func (le *luaEncoder) Encode(writer io.Writer, node *CandidateNode) error {

        if le.globals {
                if node.Kind != MappingNode {
                        return fmt.Errorf("--lua-global requires a top level MappingNode")
                }
                return le.encodeMap(writer, node, true)
        }
        return le.encodeTopLevel(writer, node)
}

//go:build !yq_noprops

package yqlib

import (
        "bufio"
        "errors"
        "fmt"
        "io"
        "strings"

        "github.com/magiconair/properties"
)

type propertiesEncoder struct {
        prefs PropertiesPreferences
}

func NewPropertiesEncoder(prefs PropertiesPreferences) Encoder {
        return &propertiesEncoder{
                prefs: prefs,
        }
}

func (pe *propertiesEncoder) CanHandleAliases() bool {
        return false
}

func (pe *propertiesEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (pe *propertiesEncoder) PrintLeadingContent(writer io.Writer, content string) error {
        reader := bufio.NewReader(strings.NewReader(content))
        for {

                readline, errReading := reader.ReadString('\n')
                if errReading != nil && !errors.Is(errReading, io.EOF) {
                        return errReading
                }
                if strings.Contains(readline, "$yqDocSeparator$") {

                        if err := pe.PrintDocumentSeparator(writer); err != nil {
                                return err
                        }

                } else {
                        if err := writeString(writer, readline); err != nil {
                                return err
                        }
                }

                if errors.Is(errReading, io.EOF) {
                        if readline != "" {
                                // the last comment we read didn't have a newline, put one in
                                if err := writeString(writer, "\n"); err != nil {
                                        return err
                                }
                        }
                        break
                }
        }
        return nil
}

func (pe *propertiesEncoder) Encode(writer io.Writer, node *CandidateNode) error {

        if node.Kind == ScalarNode {
                return writeString(writer, node.Value+"\n")
        }

        mapKeysToStrings(node)
        p := properties.NewProperties()
        p.WriteSeparator = pe.prefs.KeyValueSeparator
        err := pe.doEncode(p, node, "", nil)
        if err != nil {
                return err
        }

        _, err = p.WriteComment(writer, "#", properties.UTF8)
        return err
}

func (pe *propertiesEncoder) doEncode(p *properties.Properties, node *CandidateNode, path string, keyNode *CandidateNode) error {

        comments := ""
        if keyNode != nil {
                // include the key node comments if present
                comments = headAndLineComment(keyNode)
        }
        comments = comments + headAndLineComment(node)
        commentsWithSpaces := strings.ReplaceAll(comments, "\n", "\n ")
        p.SetComments(path, strings.Split(commentsWithSpaces, "\n"))

        switch node.Kind {
        case ScalarNode:
                var nodeValue string
                if pe.prefs.UnwrapScalar || !strings.Contains(node.Value, " ") {
                        nodeValue = node.Value
                } else {
                        nodeValue = fmt.Sprintf("%q", node.Value)
                }
                _, _, err := p.Set(path, nodeValue)
                return err
        case SequenceNode:
                return pe.encodeArray(p, node.Content, path)
        case MappingNode:
                return pe.encodeMap(p, node.Content, path)
        case AliasNode:
                return pe.doEncode(p, node.Alias, path, nil)
        default:
                return fmt.Errorf("unsupported node %v", node.Tag)
        }
}

func (pe *propertiesEncoder) appendPath(path string, key interface{}) string {
        if path == "" {
                return fmt.Sprintf("%v", key)
        }
        switch key.(type) {
        case int:
                if pe.prefs.UseArrayBrackets {
                        return fmt.Sprintf("%v[%v]", path, key)
                }

        }
        return fmt.Sprintf("%v.%v", path, key)
}

func (pe *propertiesEncoder) encodeArray(p *properties.Properties, kids []*CandidateNode, path string) error {
        for index, child := range kids {
                err := pe.doEncode(p, child, pe.appendPath(path, index), nil)
                if err != nil {
                        return err
                }
        }
        return nil
}

func (pe *propertiesEncoder) encodeMap(p *properties.Properties, kids []*CandidateNode, path string) error {
        for index := 0; index < len(kids); index = index + 2 {
                key := kids[index]
                value := kids[index+1]
                err := pe.doEncode(p, value, pe.appendPath(path, key.Value), key)
                if err != nil {
                        return err
                }
        }
        return nil
}

//go:build !yq_nosh

package yqlib

import (
        "fmt"
        "io"
        "regexp"
        "strings"
)

var unsafeChars = regexp.MustCompile(`[^\w@%+=:,./-]`)

type shEncoder struct {
        quoteAll bool
}

func NewShEncoder() Encoder {
        return &shEncoder{false}
}

func (e *shEncoder) CanHandleAliases() bool {
        return false
}

func (e *shEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (e *shEncoder) PrintLeadingContent(_ io.Writer, _ string) error {
        return nil
}

func (e *shEncoder) Encode(writer io.Writer, node *CandidateNode) error {
        if node.guessTagFromCustomType() != "!!str" {
                return fmt.Errorf("cannot encode %v as URI, can only operate on strings. Please first pipe through another encoding operator to convert the value to a string", node.Tag)
        }

        return writeString(writer, e.encode(node.Value))
}

// put any (shell-unsafe) characters into a single-quoted block, close the block lazily
func (e *shEncoder) encode(input string) string {
        const quote = '\''
        var inQuoteBlock = false
        var encoded strings.Builder
        encoded.Grow(len(input))

        for _, ir := range input {
                // open or close a single-quote block
                if ir == quote {
                        if inQuoteBlock {
                                // get out of a quote block for an input quote
                                encoded.WriteRune(quote)
                                inQuoteBlock = !inQuoteBlock
                        }
                        // escape the quote with a backslash
                        encoded.WriteRune('\\')
                } else {
                        if e.shouldQuote(ir) && !inQuoteBlock {
                                // start a quote block for any (unsafe) characters
                                encoded.WriteRune(quote)
                                inQuoteBlock = !inQuoteBlock
                        }
                }
                // pass on the input character
                encoded.WriteRune(ir)
        }
        // close any pending quote block
        if inQuoteBlock {
                encoded.WriteRune(quote)
        }
        return encoded.String()
}

func (e *shEncoder) shouldQuote(ir rune) bool {
        return e.quoteAll || unsafeChars.MatchString(string(ir))
}

//go:build !yq_noshell

package yqlib

import (
        "fmt"
        "io"
        "strings"
        "unicode/utf8"

        "golang.org/x/text/unicode/norm"
)

type shellVariablesEncoder struct {
        prefs ShellVariablesPreferences
}

func NewShellVariablesEncoder() Encoder {
        return &shellVariablesEncoder{
                prefs: ConfiguredShellVariablesPreferences,
        }
}

func (pe *shellVariablesEncoder) CanHandleAliases() bool {
        return false
}

func (pe *shellVariablesEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (pe *shellVariablesEncoder) PrintLeadingContent(_ io.Writer, _ string) error {
        return nil
}

func (pe *shellVariablesEncoder) Encode(writer io.Writer, node *CandidateNode) error {

        mapKeysToStrings(node)
        err := pe.doEncode(&writer, node, "")
        if err != nil {
                return err
        }

        return err
}

func (pe *shellVariablesEncoder) doEncode(w *io.Writer, node *CandidateNode, path string) error {

        // Note this drops all comments.

        switch node.Kind {
        case ScalarNode:
                nonemptyPath := path
                if path == "" {
                        // We can't assign an empty variable "=somevalue" because that would error out if sourced in a shell,
                        // nor can we use "_" as a variable name ($_ is a special shell variable that can't be assigned)...
                        // let's just pick a fallback key to use if we are encoding a single scalar
                        nonemptyPath = "value"
                }
                _, err := io.WriteString(*w, nonemptyPath+"="+quoteValue(node.Value)+"\n")
                return err
        case SequenceNode:
                for index, child := range node.Content {
                        err := pe.doEncode(w, child, pe.appendPath(path, index))
                        if err != nil {
                                return err
                        }
                }
                return nil
        case MappingNode:
                for index := 0; index < len(node.Content); index = index + 2 {
                        key := node.Content[index]
                        value := node.Content[index+1]
                        err := pe.doEncode(w, value, pe.appendPath(path, key.Value))
                        if err != nil {
                                return err
                        }
                }
                return nil
        case AliasNode:
                return pe.doEncode(w, node.Alias, path)
        default:
                return fmt.Errorf("unsupported node %v", node.Tag)
        }
}

func (pe *shellVariablesEncoder) appendPath(cookedPath string, rawKey interface{}) string {

        // Shell variable names must match
        //    [a-zA-Z_]+[a-zA-Z0-9_]*
        //
        // While this is not mandated by POSIX, which is quite lenient, it is
        // what shells (for example busybox ash *) allow in practice.
        //
        // Since yaml names can contain basically any character, we will process them according to these steps:
        //
        //     1. apply unicode compatibility decomposition NFKD (this will convert accented
        //        letters to letters followed by accents, split ligatures, replace exponents
        //        with the corresponding digit, etc.
        //
        //     2. discard non-ASCII characters as well as ASCII control characters (ie. anything
        //        with code point < 32 or > 126), this will eg. discard accents but keep the base
        //        unaccented letter because of NFKD above
        //
        //     3. replace all non-alphanumeric characters with _
        //
        // Moreover, for the root key only, we will prepend an underscore if what results from the steps above
        // does not start with [a-zA-Z_] (ie. if the root key starts with a digit).
        //
        // Note this is NOT a 1:1 mapping.
        //
        // (*) see endofname.c from https://git.busybox.net/busybox/tag/?h=1_36_0

        // XXX empty strings

        key := strings.Map(func(r rune) rune {
                if isAlphaNumericOrUnderscore(r) {
                        return r
                } else if r < 32 || 126 < r {
                        return -1
                }
                return '_'
        }, norm.NFKD.String(fmt.Sprintf("%v", rawKey)))

        if cookedPath == "" {
                firstRune, _ := utf8.DecodeRuneInString(key)
                if !isAlphaOrUnderscore(firstRune) {
                        return "_" + key
                }
                return key
        }
        return cookedPath + pe.prefs.KeySeparator + key
}

func quoteValue(value string) string {
        needsQuoting := false
        for _, r := range value {
                if !isAlphaNumericOrUnderscore(r) {
                        needsQuoting = true
                        break
                }
        }
        if needsQuoting {
                return "'" + strings.ReplaceAll(value, "'", "'\"'\"'") + "'"
        }
        return value
}

func isAlphaOrUnderscore(r rune) bool {
        return ('a' <= r && r <= 'z') || ('A' <= r && r <= 'Z') || r == '_'
}

func isAlphaNumericOrUnderscore(r rune) bool {
        return isAlphaOrUnderscore(r) || ('0' <= r && r <= '9')
}

package yqlib

import (
        "bytes"
        "fmt"
        "io"
        "strings"

        "github.com/fatih/color"
)

type tomlEncoder struct {
        wroteRootAttr bool // Track if we wrote root-level attributes before tables
        prefs         TomlPreferences
}

func NewTomlEncoder() Encoder {
        return NewTomlEncoderWithPrefs(ConfiguredTomlPreferences)
}

func NewTomlEncoderWithPrefs(prefs TomlPreferences) Encoder {
        return &tomlEncoder{prefs: prefs}
}

func (te *tomlEncoder) Encode(writer io.Writer, node *CandidateNode) error {
        if node.Kind != MappingNode {
                // For standalone selections, TOML tests expect raw value for scalars
                if node.Kind == ScalarNode {
                        return writeString(writer, node.Value+"\n")
                }
                return fmt.Errorf("TOML encoder expects a mapping at the root level")
        }

        // Encode to a buffer first if colors are enabled
        var buf bytes.Buffer
        var targetWriter io.Writer
        targetWriter = writer
        if te.prefs.ColorsEnabled {
                targetWriter = &buf
        }

        // Encode a root mapping as a sequence of attributes, tables, and arrays of tables
        if err := te.encodeRootMapping(targetWriter, node); err != nil {
                return err
        }

        if te.prefs.ColorsEnabled {
                colourised := te.colorizeToml(buf.Bytes())
                _, err := writer.Write(colourised)
                return err
        }

        return nil
}

func (te *tomlEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (te *tomlEncoder) PrintLeadingContent(_ io.Writer, _ string) error {
        return nil
}

func (te *tomlEncoder) CanHandleAliases() bool {
        return false
}

// ---- helpers ----

func (te *tomlEncoder) writeComment(w io.Writer, comment string) error {
        if comment == "" {
                return nil
        }
        lines := strings.Split(comment, "\n")
        for _, line := range lines {
                line = strings.TrimSpace(line)
                if !strings.HasPrefix(line, "#") {
                        line = "# " + line
                }
                if _, err := w.Write([]byte(line + "\n")); err != nil {
                        return err
                }
        }
        return nil
}

func (te *tomlEncoder) formatScalar(node *CandidateNode) string {
        switch node.Tag {
        case "!!str":
                // Quote strings per TOML spec
                return fmt.Sprintf("%q", node.Value)
        case "!!bool", "!!int", "!!float":
                return node.Value
        case "!!null":
                // TOML does not have null; encode as empty string
                return `""`
        default:
                return node.Value
        }
}

func (te *tomlEncoder) encodeRootMapping(w io.Writer, node *CandidateNode) error {
        te.wroteRootAttr = false // Reset state

        // Write root head comment if present (at the very beginning, no leading blank line)
        if node.HeadComment != "" {
                if err := te.writeComment(w, node.HeadComment); err != nil {
                        return err
                }
        }

        // Preserve existing order by iterating Content
        for i := 0; i < len(node.Content); i += 2 {
                keyNode := node.Content[i]
                valNode := node.Content[i+1]
                if err := te.encodeTopLevelEntry(w, []string{keyNode.Value}, valNode); err != nil {
                        return err
                }
        }
        return nil
}

// encodeTopLevelEntry encodes a key/value at the root, dispatching to attribute, table, or array-of-tables
func (te *tomlEncoder) encodeTopLevelEntry(w io.Writer, path []string, node *CandidateNode) error {
        if len(path) == 0 {
                return fmt.Errorf("cannot encode TOML entry with empty path")
        }

        switch node.Kind {
        case ScalarNode:
                // key = value
                return te.writeAttribute(w, path[len(path)-1], node)
        case SequenceNode:
                // Empty arrays should be encoded as [] attributes
                if len(node.Content) == 0 {
                        return te.writeArrayAttribute(w, path[len(path)-1], node)
                }

                // If all items are mappings => array of tables; else => array attribute
                allMaps := true
                for _, it := range node.Content {
                        if it.Kind != MappingNode {
                                allMaps = false
                                break
                        }
                }
                if allMaps {
                        key := path[len(path)-1]
                        for _, it := range node.Content {
                                // [[key]] then body
                                if _, err := w.Write([]byte("[[" + key + "]]\n")); err != nil {
                                        return err
                                }
                                if err := te.encodeMappingBodyWithPath(w, []string{key}, it); err != nil {
                                        return err
                                }
                        }
                        return nil
                }
                // Regular array attribute
                return te.writeArrayAttribute(w, path[len(path)-1], node)
        case MappingNode:
                // Inline table if not EncodeSeparate, else emit separate tables/arrays of tables for children under this path
                if !node.EncodeSeparate {
                        // If children contain mappings or arrays of mappings, prefer separate sections
                        if te.hasEncodeSeparateChild(node) || te.hasStructuralChildren(node) {
                                return te.encodeSeparateMapping(w, path, node)
                        }
                        return te.writeInlineTableAttribute(w, path[len(path)-1], node)
                }
                return te.encodeSeparateMapping(w, path, node)
        default:
                return fmt.Errorf("unsupported node kind for TOML: %v", node.Kind)
        }
}

func (te *tomlEncoder) writeAttribute(w io.Writer, key string, value *CandidateNode) error {
        te.wroteRootAttr = true // Mark that we wrote a root attribute

        // Write head comment before the attribute
        if err := te.writeComment(w, value.HeadComment); err != nil {
                return err
        }

        // Write the attribute
        line := key + " = " + te.formatScalar(value)

        // Add line comment if present
        if value.LineComment != "" {
                lineComment := strings.TrimSpace(value.LineComment)
                if !strings.HasPrefix(lineComment, "#") {
                        lineComment = "# " + lineComment
                }
                line += "  " + lineComment
        }

        _, err := w.Write([]byte(line + "\n"))
        return err
}

func (te *tomlEncoder) writeArrayAttribute(w io.Writer, key string, seq *CandidateNode) error {
        te.wroteRootAttr = true // Mark that we wrote a root attribute

        // Write head comment before the array
        if err := te.writeComment(w, seq.HeadComment); err != nil {
                return err
        }

        // Handle empty arrays
        if len(seq.Content) == 0 {
                line := key + " = []"
                if seq.LineComment != "" {
                        lineComment := strings.TrimSpace(seq.LineComment)
                        if !strings.HasPrefix(lineComment, "#") {
                                lineComment = "# " + lineComment
                        }
                        line += "  " + lineComment
                }
                _, err := w.Write([]byte(line + "\n"))
                return err
        }

        // Join scalars or nested arrays recursively into TOML array syntax
        items := make([]string, 0, len(seq.Content))
        for _, it := range seq.Content {
                switch it.Kind {
                case ScalarNode:
                        items = append(items, te.formatScalar(it))
                case SequenceNode:
                        // Nested arrays: encode inline
                        nested, err := te.sequenceToInlineArray(it)
                        if err != nil {
                                return err
                        }
                        items = append(items, nested)
                case MappingNode:
                        // Inline table inside array
                        inline, err := te.mappingToInlineTable(it)
                        if err != nil {
                                return err
                        }
                        items = append(items, inline)
                case AliasNode:
                        return fmt.Errorf("aliases are not supported in TOML")
                default:
                        return fmt.Errorf("unsupported array item kind: %v", it.Kind)
                }
        }

        line := key + " = [" + strings.Join(items, ", ") + "]"

        // Add line comment if present
        if seq.LineComment != "" {
                lineComment := strings.TrimSpace(seq.LineComment)
                if !strings.HasPrefix(lineComment, "#") {
                        lineComment = "# " + lineComment
                }
                line += "  " + lineComment
        }

        _, err := w.Write([]byte(line + "\n"))
        return err
}

func (te *tomlEncoder) sequenceToInlineArray(seq *CandidateNode) (string, error) {
        items := make([]string, 0, len(seq.Content))
        for _, it := range seq.Content {
                switch it.Kind {
                case ScalarNode:
                        items = append(items, te.formatScalar(it))
                case SequenceNode:
                        nested, err := te.sequenceToInlineArray(it)
                        if err != nil {
                                return "", err
                        }
                        items = append(items, nested)
                case MappingNode:
                        inline, err := te.mappingToInlineTable(it)
                        if err != nil {
                                return "", err
                        }
                        items = append(items, inline)
                default:
                        return "", fmt.Errorf("unsupported array item kind: %v", it.Kind)
                }
        }
        return "[" + strings.Join(items, ", ") + "]", nil
}

func (te *tomlEncoder) mappingToInlineTable(m *CandidateNode) (string, error) {
        // key = { a = 1, b = "x" }
        parts := make([]string, 0, len(m.Content)/2)
        for i := 0; i < len(m.Content); i += 2 {
                k := m.Content[i].Value
                v := m.Content[i+1]
                switch v.Kind {
                case ScalarNode:
                        parts = append(parts, fmt.Sprintf("%s = %s", k, te.formatScalar(v)))
                case SequenceNode:
                        // inline array in inline table
                        arr, err := te.sequenceToInlineArray(v)
                        if err != nil {
                                return "", err
                        }
                        parts = append(parts, fmt.Sprintf("%s = %s", k, arr))
                case MappingNode:
                        // nested inline table
                        inline, err := te.mappingToInlineTable(v)
                        if err != nil {
                                return "", err
                        }
                        parts = append(parts, fmt.Sprintf("%s = %s", k, inline))
                default:
                        return "", fmt.Errorf("unsupported inline table value kind: %v", v.Kind)
                }
        }
        return "{ " + strings.Join(parts, ", ") + " }", nil
}

func (te *tomlEncoder) writeInlineTableAttribute(w io.Writer, key string, m *CandidateNode) error {
        inline, err := te.mappingToInlineTable(m)
        if err != nil {
                return err
        }
        _, err = w.Write([]byte(key + " = " + inline + "\n"))
        return err
}

func (te *tomlEncoder) writeTableHeader(w io.Writer, path []string, m *CandidateNode) error {
        // Add blank line before table header (or before comment if present) if we wrote root attributes
        needsBlankLine := te.wroteRootAttr
        if needsBlankLine {
                if _, err := w.Write([]byte("\n")); err != nil {
                        return err
                }
                te.wroteRootAttr = false // Only add once
        }

        // Write head comment before the table header
        if m.HeadComment != "" {
                if err := te.writeComment(w, m.HeadComment); err != nil {
                        return err
                }
        }

        // Write table header [a.b.c]
        header := "[" + strings.Join(path, ".") + "]\n"
        _, err := w.Write([]byte(header))
        return err
}

// encodeSeparateMapping handles a mapping that should be encoded as table sections.
// It emits the table header for this mapping if it has any content, then processes children.
func (te *tomlEncoder) encodeSeparateMapping(w io.Writer, path []string, m *CandidateNode) error {
        // Check if this mapping has any non-mapping, non-array-of-tables children (i.e., attributes)
        hasAttrs := false
        for i := 0; i < len(m.Content); i += 2 {
                v := m.Content[i+1]
                if v.Kind == ScalarNode {
                        hasAttrs = true
                        break
                }
                if v.Kind == SequenceNode {
                        // Check if it's NOT an array of tables
                        allMaps := true
                        for _, it := range v.Content {
                                if it.Kind != MappingNode {
                                        allMaps = false
                                        break
                                }
                        }
                        if !allMaps {
                                hasAttrs = true
                                break
                        }
                }
        }

        // If there are attributes or if the mapping is empty, emit the table header
        if hasAttrs || len(m.Content) == 0 {
                if err := te.writeTableHeader(w, path, m); err != nil {
                        return err
                }
                if err := te.encodeMappingBodyWithPath(w, path, m); err != nil {
                        return err
                }
                return nil
        }

        // No attributes, just nested structures - process children
        for i := 0; i < len(m.Content); i += 2 {
                k := m.Content[i].Value
                v := m.Content[i+1]
                switch v.Kind {
                case MappingNode:
                        // Emit [path.k]
                        newPath := append(append([]string{}, path...), k)
                        if err := te.writeTableHeader(w, newPath, v); err != nil {
                                return err
                        }
                        if err := te.encodeMappingBodyWithPath(w, newPath, v); err != nil {
                                return err
                        }
                case SequenceNode:
                        // If sequence of maps, emit [[path.k]] per element
                        allMaps := true
                        for _, it := range v.Content {
                                if it.Kind != MappingNode {
                                        allMaps = false
                                        break
                                }
                        }
                        if allMaps {
                                key := strings.Join(append(append([]string{}, path...), k), ".")
                                for _, it := range v.Content {
                                        if _, err := w.Write([]byte("[[" + key + "]]\n")); err != nil {
                                                return err
                                        }
                                        if err := te.encodeMappingBodyWithPath(w, append(append([]string{}, path...), k), it); err != nil {
                                                return err
                                        }
                                }
                        } else {
                                // Regular array attribute under the current table path
                                if err := te.writeArrayAttribute(w, k, v); err != nil {
                                        return err
                                }
                        }
                case ScalarNode:
                        // Attributes directly under the current table path
                        if err := te.writeAttribute(w, k, v); err != nil {
                                return err
                        }
                }
        }
        return nil
}

func (te *tomlEncoder) hasEncodeSeparateChild(m *CandidateNode) bool {
        for i := 0; i < len(m.Content); i += 2 {
                v := m.Content[i+1]
                if v.Kind == MappingNode && v.EncodeSeparate {
                        return true
                }
        }
        return false
}

func (te *tomlEncoder) hasStructuralChildren(m *CandidateNode) bool {
        for i := 0; i < len(m.Content); i += 2 {
                v := m.Content[i+1]
                // Only consider it structural if mapping has EncodeSeparate or is non-empty
                if v.Kind == MappingNode && v.EncodeSeparate {
                        return true
                }
                if v.Kind == SequenceNode {
                        allMaps := true
                        for _, it := range v.Content {
                                if it.Kind != MappingNode {
                                        allMaps = false
                                        break
                                }
                        }
                        if allMaps {
                                return true
                        }
                }
        }
        return false
}

// encodeMappingBodyWithPath encodes attributes and nested arrays of tables using full dotted path context
func (te *tomlEncoder) encodeMappingBodyWithPath(w io.Writer, path []string, m *CandidateNode) error {
        // First, attributes (scalars and non-map arrays)
        for i := 0; i < len(m.Content); i += 2 {
                k := m.Content[i].Value
                v := m.Content[i+1]
                switch v.Kind {
                case ScalarNode:
                        if err := te.writeAttribute(w, k, v); err != nil {
                                return err
                        }
                case SequenceNode:
                        allMaps := true
                        for _, it := range v.Content {
                                if it.Kind != MappingNode {
                                        allMaps = false
                                        break
                                }
                        }
                        if !allMaps {
                                if err := te.writeArrayAttribute(w, k, v); err != nil {
                                        return err
                                }
                        }
                }
        }

        // Then, nested arrays of tables with full path
        for i := 0; i < len(m.Content); i += 2 {
                k := m.Content[i].Value
                v := m.Content[i+1]
                if v.Kind == SequenceNode {
                        allMaps := true
                        for _, it := range v.Content {
                                if it.Kind != MappingNode {
                                        allMaps = false
                                        break
                                }
                        }
                        if allMaps {
                                dotted := strings.Join(append(append([]string{}, path...), k), ".")
                                for _, it := range v.Content {
                                        if _, err := w.Write([]byte("[[" + dotted + "]]\n")); err != nil {
                                                return err
                                        }
                                        if err := te.encodeMappingBodyWithPath(w, append(append([]string{}, path...), k), it); err != nil {
                                                return err
                                        }
                                }
                        }
                }
        }

        // Finally, child mappings that are not marked EncodeSeparate get inlined as attributes
        for i := 0; i < len(m.Content); i += 2 {
                k := m.Content[i].Value
                v := m.Content[i+1]
                if v.Kind == MappingNode && !v.EncodeSeparate {
                        if err := te.writeInlineTableAttribute(w, k, v); err != nil {
                                return err
                        }
                }
        }
        return nil
}

// colorizeToml applies syntax highlighting to TOML output using fatih/color
func (te *tomlEncoder) colorizeToml(input []byte) []byte {
        toml := string(input)
        result := strings.Builder{}

        // Force color output (don't check for TTY)
        color.NoColor = false

        // Create color functions for different token types
        commentColor := color.New(color.FgHiBlack).SprintFunc()
        stringColor := color.New(color.FgGreen).SprintFunc()
        numberColor := color.New(color.FgHiMagenta).SprintFunc()
        keyColor := color.New(color.FgCyan).SprintFunc()
        boolColor := color.New(color.FgHiMagenta).SprintFunc()
        sectionColor := color.New(color.FgYellow, color.Bold).SprintFunc()

        // Simple tokenization for TOML colouring
        i := 0
        for i < len(toml) {
                ch := toml[i]

                // Comments - from # to end of line
                if ch == '#' {
                        end := i
                        for end < len(toml) && toml[end] != '\n' {
                                end++
                        }
                        result.WriteString(commentColor(toml[i:end]))
                        i = end
                        continue
                }

                // Table sections - [section] or [[array]]
                // Only treat '[' as a table section if it appears at the start of the line
                // (possibly after whitespace). This avoids mis-colouring inline arrays like
                // "ports = [8000, 8001]" as table sections.
                if ch == '[' {
                        isSectionHeader := true
                        if i > 0 {
                                isSectionHeader = false
                                j := i - 1
                                for j >= 0 && toml[j] != '\n' {
                                        if toml[j] != ' ' && toml[j] != '\t' && toml[j] != '\r' {
                                                // Found a non-whitespace character before this '[' on the same line,
                                                // so this is not a table header.
                                                break
                                        }
                                        j--
                                }
                                if j < 0 || toml[j] == '\n' {
                                        // Reached the start of the string or a newline without encountering
                                        // any non-whitespace, so '[' is at the logical start of the line.
                                        isSectionHeader = true
                                }
                        }
                        if isSectionHeader {
                                end := i + 1
                                // Check for [[
                                if end < len(toml) && toml[end] == '[' {
                                        end++
                                }
                                // Find closing ]
                                for end < len(toml) && toml[end] != ']' {
                                        end++
                                }
                                // Include closing ]
                                if end < len(toml) {
                                        end++
                                        // Check for ]]
                                        if end < len(toml) && toml[end] == ']' {
                                                end++
                                        }
                                }
                                result.WriteString(sectionColor(toml[i:end]))
                                i = end
                                continue
                        }
                }

                // Strings - quoted text (double or single quotes)
                if ch == '"' || ch == '\'' {
                        quote := ch
                        end := i + 1
                        for end < len(toml) {
                                if toml[end] == quote {
                                        break
                                }
                                if toml[end] == '\\' && end+1 < len(toml) {
                                        // Skip the backslash and the escaped character
                                        end += 2
                                        continue
                                }
                                end++
                        }
                        if end < len(toml) {
                                end++ // include closing quote
                        }
                        result.WriteString(stringColor(toml[i:end]))
                        i = end
                        continue
                }

                // Numbers - sequences of digits, possibly with decimal point or minus
                if (ch >= '0' && ch <= '9') || (ch == '-' && i+1 < len(toml) && toml[i+1] >= '0' && toml[i+1] <= '9') {
                        end := i
                        if ch == '-' {
                                end++
                        }
                        for end < len(toml) {
                                c := toml[end]
                                if (c >= '0' && c <= '9') || c == '.' || c == 'e' || c == 'E' {
                                        end++
                                } else if (c == '+' || c == '-') && end > 0 && (toml[end-1] == 'e' || toml[end-1] == 'E') {
                                        // Only allow + or - immediately after 'e' or 'E' for scientific notation
                                        end++
                                } else {
                                        break
                                }
                        }
                        result.WriteString(numberColor(toml[i:end]))
                        i = end
                        continue
                }

                // Identifiers/keys - alphanumeric + underscore + dash
                if (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' {
                        end := i
                        for end < len(toml) && ((toml[end] >= 'a' && toml[end] <= 'z') ||
                                (toml[end] >= 'A' && toml[end] <= 'Z') ||
                                (toml[end] >= '0' && toml[end] <= '9') ||
                                toml[end] == '_' || toml[end] == '-') {
                                end++
                        }
                        ident := toml[i:end]

                        // Check if this is a boolean/null keyword
                        switch ident {
                        case "true", "false":
                                result.WriteString(boolColor(ident))
                        default:
                                // Check if followed by = or whitespace then = (it's a key)
                                j := end
                                for j < len(toml) && (toml[j] == ' ' || toml[j] == '\t') {
                                        j++
                                }
                                if j < len(toml) && toml[j] == '=' {
                                        result.WriteString(keyColor(ident))
                                } else {
                                        result.WriteString(ident) // plain text for other identifiers
                                }
                        }
                        i = end
                        continue
                }

                // Everything else (whitespace, operators, brackets) - no color
                result.WriteByte(ch)
                i++
        }

        return []byte(result.String())
}

//go:build !yq_nouri

package yqlib

import (
        "fmt"
        "io"
        "net/url"
)

type uriEncoder struct {
}

func NewUriEncoder() Encoder {
        return &uriEncoder{}
}

func (e *uriEncoder) CanHandleAliases() bool {
        return false
}

func (e *uriEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (e *uriEncoder) PrintLeadingContent(_ io.Writer, _ string) error {
        return nil
}

func (e *uriEncoder) Encode(writer io.Writer, node *CandidateNode) error {
        if node.guessTagFromCustomType() != "!!str" {
                return fmt.Errorf("cannot encode %v as URI, can only operate on strings. Please first pipe through another encoding operator to convert the value to a string", node.Tag)
        }
        _, err := writer.Write([]byte(url.QueryEscape(node.Value)))
        return err
}

//go:build !yq_noxml

package yqlib

import (
        "encoding/xml"
        "fmt"
        "io"
        "regexp"
        "strings"
)

type xmlEncoder struct {
        indentString   string
        writer         io.Writer
        prefs          XmlPreferences
        leadingContent string
}

func NewXMLEncoder(prefs XmlPreferences) Encoder {
        var indentString = ""

        for index := 0; index < prefs.Indent; index++ {
                indentString = indentString + " "
        }
        return &xmlEncoder{indentString, nil, prefs, ""}
}

func (e *xmlEncoder) CanHandleAliases() bool {
        return false
}

func (e *xmlEncoder) PrintDocumentSeparator(_ io.Writer) error {
        return nil
}

func (e *xmlEncoder) PrintLeadingContent(_ io.Writer, content string) error {
        e.leadingContent = content
        return nil
}

func (e *xmlEncoder) Encode(writer io.Writer, node *CandidateNode) error {
        encoder := xml.NewEncoder(writer)
        // hack so we can manually add newlines to procInst and directives
        e.writer = writer
        encoder.Indent("", e.indentString)
        var newLine xml.CharData = []byte("\n")

        if node.Tag == "!!map" {
                // make sure <?xml .. ?> processing instructions are encoded first
                for i := 0; i < len(node.Content); i += 2 {
                        key := node.Content[i]
                        value := node.Content[i+1]

                        if key.Value == (e.prefs.ProcInstPrefix + "xml") {
                                name := strings.Replace(key.Value, e.prefs.ProcInstPrefix, "", 1)
                                procInst := xml.ProcInst{Target: name, Inst: []byte(value.Value)}
                                if err := encoder.EncodeToken(procInst); err != nil {
                                        return err
                                }
                                if _, err := e.writer.Write([]byte("\n")); err != nil {
                                        log.Warning("Unable to write newline, skipping: %w", err)
                                }
                        }
                }
        }

        if e.leadingContent != "" {

                // remove first and last newlines if present
                err := e.encodeComment(encoder, e.leadingContent)
                if err != nil {
                        return err
                }
                err = encoder.EncodeToken(newLine)
                if err != nil {
                        return err
                }
        }

        switch node.Kind {
        case MappingNode:
                err := e.encodeTopLevelMap(encoder, node)
                if err != nil {
                        return err
                }
        case ScalarNode:
                var charData xml.CharData = []byte(node.Value)
                err := encoder.EncodeToken(charData)
                if err != nil {
                        return err
                }
                return encoder.Flush()
        default:
                return fmt.Errorf("cannot encode %v to XML - only maps can be encoded", node.Tag)
        }

        return encoder.EncodeToken(newLine)

}

func (e *xmlEncoder) encodeTopLevelMap(encoder *xml.Encoder, node *CandidateNode) error {
        err := e.encodeComment(encoder, headAndLineComment(node))
        if err != nil {
                return err
        }
        for i := 0; i < len(node.Content); i += 2 {
                key := node.Content[i]
                value := node.Content[i+1]

                start := xml.StartElement{Name: xml.Name{Local: key.Value}}
                log.Debugf("comments of key %v", key.Value)
                err := e.encodeComment(encoder, headAndLineComment(key))
                if err != nil {
                        return err
                }
                if headAndLineComment(key) != "" {
                        var newLine xml.CharData = []byte("\n")
                        err = encoder.EncodeToken(newLine)
                        if err != nil {
                                return err
                        }
                }

                if key.Value == (e.prefs.ProcInstPrefix + "xml") { //nolint
                        // dont double process these.
                } else if strings.HasPrefix(key.Value, e.prefs.ProcInstPrefix) {
                        name := strings.Replace(key.Value, e.prefs.ProcInstPrefix, "", 1)
                        procInst := xml.ProcInst{Target: name, Inst: []byte(value.Value)}
                        if err := encoder.EncodeToken(procInst); err != nil {
                                return err
                        }
                        if _, err := e.writer.Write([]byte("\n")); err != nil {
                                log.Warning("Unable to write newline, skipping: %w", err)
                        }
                } else if key.Value == e.prefs.DirectiveName {
                        var directive xml.Directive = []byte(value.Value)
                        if err := encoder.EncodeToken(directive); err != nil {
                                return err
                        }
                        if _, err := e.writer.Write([]byte("\n")); err != nil {
                                log.Warning("Unable to write newline, skipping: %w", err)
                        }
                } else {

                        log.Debugf("recursing")

                        err = e.doEncode(encoder, value, start)
                        if err != nil {
                                return err
                        }
                }
                err = e.encodeComment(encoder, footComment(key))
                if err != nil {
                        return err
                }
        }
        return e.encodeComment(encoder, footComment(node))
}

func (e *xmlEncoder) encodeStart(encoder *xml.Encoder, node *CandidateNode, start xml.StartElement) error {
        err := encoder.EncodeToken(start)
        if err != nil {
                return err
        }
        return e.encodeComment(encoder, headComment(node))
}

func (e *xmlEncoder) encodeEnd(encoder *xml.Encoder, node *CandidateNode, start xml.StartElement) error {
        err := encoder.EncodeToken(start.End())
        if err != nil {
                return err
        }
        return e.encodeComment(encoder, footComment(node))
}

func (e *xmlEncoder) doEncode(encoder *xml.Encoder, node *CandidateNode, start xml.StartElement) error {
        switch node.Kind {
        case MappingNode:
                return e.encodeMap(encoder, node, start)
        case SequenceNode:
                return e.encodeArray(encoder, node, start)
        case ScalarNode:
                err := e.encodeStart(encoder, node, start)
                if err != nil {
                        return err
                }

                var charData xml.CharData = []byte(node.Value)
                err = encoder.EncodeToken(charData)
                if err != nil {
                        return err
                }

                if err = e.encodeComment(encoder, lineComment(node)); err != nil {
                        return err
                }

                return e.encodeEnd(encoder, node, start)
        }
        return fmt.Errorf("unsupported type %v", node.Tag)
}

var xmlEncodeMultilineCommentRegex = regexp.MustCompile(`(^|\n) *# ?(.*)`)
var xmlEncodeSingleLineCommentRegex = regexp.MustCompile(`^\s*#(.*)\n?`)
var chompRegexp = regexp.MustCompile(`\n$`)

func (e *xmlEncoder) encodeComment(encoder *xml.Encoder, commentStr string) error {
        if commentStr != "" {
                log.Debugf("got comment [%v]", commentStr)
                // multi line string
                if len(commentStr) > 2 && strings.Contains(commentStr[1:len(commentStr)-1], "\n") {
                        commentStr = chompRegexp.ReplaceAllString(commentStr, "")
                        log.Debugf("chompRegexp [%v]", commentStr)
                        commentStr = xmlEncodeMultilineCommentRegex.ReplaceAllString(commentStr, "$1$2")
                        log.Debugf("processed multiline [%v]", commentStr)
                        // if the first line is non blank, add a space
                        if commentStr[0] != '\n' && commentStr[0] != ' ' {
                                commentStr = " " + commentStr
                        }

                } else {
                        commentStr = xmlEncodeSingleLineCommentRegex.ReplaceAllString(commentStr, "$1")
                }

                if !strings.HasSuffix(commentStr, " ") && !strings.HasSuffix(commentStr, "\n") {
                        commentStr = commentStr + " "
                        log.Debugf("added suffix [%v]", commentStr)
                }
                log.Debugf("encoding comment [%v]", commentStr)

                var comment xml.Comment = []byte(commentStr)
                err := encoder.EncodeToken(comment)
                if err != nil {
                        return err
                }
        }
        return nil
}

func (e *xmlEncoder) encodeArray(encoder *xml.Encoder, node *CandidateNode, start xml.StartElement) error {

        if err := e.encodeComment(encoder, headAndLineComment(node)); err != nil {
                return err
        }

        for i := 0; i < len(node.Content); i++ {
                value := node.Content[i]
                if err := e.doEncode(encoder, value, start.Copy()); err != nil {
                        return err
                }
        }
        return e.encodeComment(encoder, footComment(node))
}

func (e *xmlEncoder) isAttribute(name string) bool {
        return strings.HasPrefix(name, e.prefs.AttributePrefix) &&
                name != e.prefs.ContentName &&
                name != e.prefs.DirectiveName &&
                !strings.HasPrefix(name, e.prefs.ProcInstPrefix)
}

func (e *xmlEncoder) encodeMap(encoder *xml.Encoder, node *CandidateNode, start xml.StartElement) error {
        log.Debug("its a map")

        //first find all the attributes and put them on the start token
        for i := 0; i < len(node.Content); i += 2 {
                key := node.Content[i]
                value := node.Content[i+1]

                if e.isAttribute(key.Value) {
                        if value.Kind == ScalarNode {
                                attributeName := strings.Replace(key.Value, e.prefs.AttributePrefix, "", 1)
                                start.Attr = append(start.Attr, xml.Attr{Name: xml.Name{Local: attributeName}, Value: value.Value})
                        } else {
                                return fmt.Errorf("cannot use %v as attribute, only scalars are supported", value.Tag)
                        }
                }
        }

        err := e.encodeStart(encoder, node, start)
        if err != nil {
                return err
        }

        //now we encode non attribute tokens
        for i := 0; i < len(node.Content); i += 2 {
                key := node.Content[i]
                value := node.Content[i+1]

                err := e.encodeComment(encoder, headAndLineComment(key))
                if err != nil {
                        return err
                }
                if strings.HasPrefix(key.Value, e.prefs.ProcInstPrefix) {
                        name := strings.Replace(key.Value, e.prefs.ProcInstPrefix, "", 1)
                        procInst := xml.ProcInst{Target: name, Inst: []byte(value.Value)}
                        if err := encoder.EncodeToken(procInst); err != nil {
                                return err
                        }
                } else if key.Value == e.prefs.DirectiveName {
                        var directive xml.Directive = []byte(value.Value)
                        if err := encoder.EncodeToken(directive); err != nil {
                                return err
                        }
                } else if key.Value == e.prefs.ContentName {
                        // directly encode the contents
                        err = e.encodeComment(encoder, headAndLineComment(value))
                        if err != nil {
                                return err
                        }
                        var charData xml.CharData = []byte(value.Value)
                        err = encoder.EncodeToken(charData)
                        if err != nil {
                                return err
                        }
                        err = e.encodeComment(encoder, footComment(value))
                        if err != nil {
                                return err
                        }
                } else if !e.isAttribute(key.Value) {
                        start := xml.StartElement{Name: xml.Name{Local: key.Value}}
                        err := e.doEncode(encoder, value, start)
                        if err != nil {
                                return err
                        }
                }
                err = e.encodeComment(encoder, footComment(key))
                if err != nil {
                        return err
                }
        }

        return e.encodeEnd(encoder, node, start)
}

package yqlib

import (
        "bytes"
        "io"
        "strings"

        "go.yaml.in/yaml/v4"
)

type yamlEncoder struct {
        prefs YamlPreferences
}

func NewYamlEncoder(prefs YamlPreferences) Encoder {
        return &yamlEncoder{prefs}
}

func (ye *yamlEncoder) CanHandleAliases() bool {
        return true
}

func (ye *yamlEncoder) PrintDocumentSeparator(writer io.Writer) error {
        return PrintYAMLDocumentSeparator(writer, ye.prefs.PrintDocSeparators)
}

func (ye *yamlEncoder) PrintLeadingContent(writer io.Writer, content string) error {
        return PrintYAMLLeadingContent(writer, content, ye.prefs.PrintDocSeparators, ye.prefs.ColorsEnabled)
}

func (ye *yamlEncoder) Encode(writer io.Writer, node *CandidateNode) error {
        log.Debug("encoderYaml - going to print %v", NodeToString(node))
        // Detect line ending style from LeadingContent
        lineEnding := "\n"
        if strings.Contains(node.LeadingContent, "\r\n") {
                lineEnding = "\r\n"
        }
        if node.Kind == ScalarNode && ye.prefs.UnwrapScalar {
                valueToPrint := node.Value
                if node.LeadingContent == "" || valueToPrint != "" {
                        valueToPrint = valueToPrint + lineEnding
                }
                return writeString(writer, valueToPrint)
        }

        destination := writer
        tempBuffer := bytes.NewBuffer(nil)
        if ye.prefs.ColorsEnabled {
                destination = tempBuffer
        }

        var encoder = yaml.NewEncoder(destination)

        encoder.SetIndent(ye.prefs.Indent)

        target, err := node.MarshalYAML()

        if err != nil {
                return err
        }

        trailingContent := target.FootComment
        target.FootComment = ""

        if err := encoder.Encode(target); err != nil {
                return err
        }

        if err := ye.PrintLeadingContent(destination, trailingContent); err != nil {
                return err
        }

        if ye.prefs.ColorsEnabled {
                return colorizeAndPrint(tempBuffer.Bytes(), writer)
        }
        return nil
}

package yqlib

import (
        "fmt"
        "strings"
)

type ExpressionNode struct {
        Operation *Operation
        LHS       *ExpressionNode
        RHS       *ExpressionNode
        Parent    *ExpressionNode
}

type ExpressionParserInterface interface {
        ParseExpression(expression string) (*ExpressionNode, error)
}

type expressionParserImpl struct {
        pathTokeniser expressionTokeniser
        pathPostFixer expressionPostFixer
}

func newExpressionParser() ExpressionParserInterface {
        return &expressionParserImpl{newParticipleLexer(), newExpressionPostFixer()}
}

func (p *expressionParserImpl) ParseExpression(expression string) (*ExpressionNode, error) {
        log.Debug("Parsing expression: [%v]", expression)
        tokens, err := p.pathTokeniser.Tokenise(expression)
        if err != nil {
                return nil, err
        }
        var Operations []*Operation
        Operations, err = p.pathPostFixer.ConvertToPostfix(tokens)
        if err != nil {
                return nil, err
        }
        return p.createExpressionTree(Operations)
}

func (p *expressionParserImpl) createExpressionTree(postFixPath []*Operation) (*ExpressionNode, error) {
        var stack = make([]*ExpressionNode, 0)

        if len(postFixPath) == 0 {
                return nil, nil
        }

        for _, Operation := range postFixPath {
                var newNode = ExpressionNode{Operation: Operation}
                log.Debugf("pathTree %v ", Operation.toString())
                if Operation.OperationType.NumArgs > 0 {
                        numArgs := Operation.OperationType.NumArgs
                        switch numArgs {
                        case 1:
                                if len(stack) < 1 {
                                        // Allow certain unary ops to accept zero args by interpreting missing RHS as nil
                                        // TODO - make this more general on OperationType
                                        if Operation.OperationType == firstOpType {
                                                // no RHS provided; proceed without popping
                                                break
                                        }
                                        return nil, fmt.Errorf("'%v' expects 1 arg but received none", strings.TrimSpace(Operation.StringValue))
                                }
                                remaining, rhs := stack[:len(stack)-1], stack[len(stack)-1]
                                newNode.RHS = rhs
                                rhs.Parent = &newNode
                                stack = remaining
                        case 2:
                                if len(stack) < 2 {
                                        return nil, fmt.Errorf("'%v' expects 2 args but there is %v", strings.TrimSpace(Operation.StringValue), len(stack))
                                }
                                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
                        }
                }
                stack = append(stack, &newNode)
        }
        if len(stack) != 1 {
                return nil, fmt.Errorf("bad expression, please check expression syntax")
        }
        return stack[0], nil
}

package yqlib

import (
        "errors"
        "fmt"

        logging "gopkg.in/op/go-logging.v1"
)

type expressionPostFixer interface {
        ConvertToPostfix([]*token) ([]*Operation, error)
}

type expressionPostFixerImpl struct {
}

func newExpressionPostFixer() expressionPostFixer {
        return &expressionPostFixerImpl{}
}

func popOpToResult(opStack []*token, result []*Operation) ([]*token, []*Operation) {
        var newOp *token
        opStack, newOp = opStack[0:len(opStack)-1], opStack[len(opStack)-1]
        log.Debugf("popped %v from opstack to results", newOp.toString(true))
        return opStack, append(result, newOp.Operation)
}

func validateNoOpenTokens(token *token) error {
        switch token.TokenType {
        case openCollect:
                return fmt.Errorf(("bad expression, could not find matching `]`"))
        case openCollectObject:
                return fmt.Errorf(("bad expression, could not find matching `}`"))
        case openBracket:
                return fmt.Errorf(("bad expression, could not find matching `)`"))
        }
        return nil
}

func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Operation, error) {
        var result []*Operation
        // surround the whole thing with brackets
        var opStack = []*token{{TokenType: openBracket}}
        var tokens = append(infixTokens, &token{TokenType: closeBracket})

        for _, currentToken := range tokens {
                log.Debugf("postfix processing currentToken %v", currentToken.toString(true))
                switch currentToken.TokenType {
                case openBracket, openCollect, openCollectObject:
                        opStack = append(opStack, currentToken)
                        log.Debugf("put %v onto the opstack", currentToken.toString(true))
                case closeCollect, closeCollectObject:
                        var opener tokenType = openCollect
                        var collectOperator = collectOpType
                        if currentToken.TokenType == closeCollectObject {
                                opener = openCollectObject
                                collectOperator = collectObjectOpType
                        }

                        for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != opener {
                                missingClosingTokenErr := validateNoOpenTokens(opStack[len(opStack)-1])
                                if missingClosingTokenErr != nil {
                                        return nil, missingClosingTokenErr
                                }
                                opStack, result = popOpToResult(opStack, result)
                        }
                        if len(opStack) == 0 {
                                return nil, errors.New("bad path expression, got close collect brackets without matching opening bracket")
                        }
                        // now we should have [ as the last element on the opStack, get rid of it
                        opStack = opStack[0 : len(opStack)-1]
                        log.Debugf("deleting open bracket from opstack")

                        //and append a collect to the result

                        // hack - see if there's the optional traverse flag
                        // on the close op - move it to the traverse array op
                        // allows for .["cat"]?
                        prefs := traversePreferences{}
                        closeTokenMatch := currentToken.Match
                        if closeTokenMatch[len(closeTokenMatch)-1:] == "?" {
                                prefs.OptionalTraverse = true
                        }
                        result = append(result, &Operation{OperationType: collectOperator})
                        log.Debugf("put collect onto the result")
                        if opener != openCollect {
                                result = append(result, &Operation{OperationType: shortPipeOpType})
                                log.Debugf("put shortpipe onto the result")
                        }

                        //traverseArrayCollect is a sneaky op that needs to be included too
                        //when closing a ]
                        if len(opStack) > 0 && opStack[len(opStack)-1].Operation != nil && opStack[len(opStack)-1].Operation.OperationType == traverseArrayOpType {
                                opStack[len(opStack)-1].Operation.Preferences = prefs
                                opStack, result = popOpToResult(opStack, result)
                        }

                case closeBracket:
                        for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != openBracket {
                                missingClosingTokenErr := validateNoOpenTokens(opStack[len(opStack)-1])
                                if missingClosingTokenErr != nil {
                                        return nil, missingClosingTokenErr
                                }

                                opStack, result = popOpToResult(opStack, result)
                        }
                        if len(opStack) == 0 {
                                return nil, errors.New("bad expression, got close brackets without matching opening bracket")
                        }
                        // now we should have ( as the last element on the opStack, get rid of it
                        opStack = opStack[0 : len(opStack)-1]

                default:
                        var currentPrecedence = currentToken.Operation.OperationType.Precedence
                        // pop off higher precedent operators onto the result
                        for len(opStack) > 0 &&
                                opStack[len(opStack)-1].TokenType == operationToken &&
                                opStack[len(opStack)-1].Operation.OperationType.Precedence > currentPrecedence {
                                opStack, result = popOpToResult(opStack, result)
                        }
                        // add this operator to the opStack
                        opStack = append(opStack, currentToken)
                        log.Debugf("put %v onto the opstack", currentToken.toString(true))
                }
        }

        log.Debugf("opstackLen: %v", len(opStack))
        if len(opStack) > 0 {
                log.Debugf("opstack:")
                for _, token := range opStack {
                        log.Debugf("- %v", token.toString(true))
                }

                return nil, fmt.Errorf("bad expression - probably missing close bracket on %v", opStack[len(opStack)-1].toString(false))
        }

        if log.IsEnabledFor(logging.DEBUG) {
                log.Debugf("PostFix Result:")
                for _, currentToken := range result {
                        log.Debugf("> %v", currentToken.toString())
                }
        }

        return result, nil
}

package yqlib

import (
        "fmt"
        "io"
        "os"
)

func tryRenameFile(from string, to string) error {
        if renameError := os.Rename(from, to); renameError != nil {
                log.Debugf("Error renaming from %v to %v, attempting to copy contents", from, to)
                log.Debug(renameError.Error())
                log.Debug("going to try copying instead")
                // can't do this rename when running in docker to a file targeted in a mounted volume,
                // so gracefully degrade to copying the entire contents.
                if copyError := copyFileContents(from, to); copyError != nil {
                        return fmt.Errorf("failed copying from %v to %v: %w", from, to, copyError)
                }
                tryRemoveTempFile(from)
        }
        return nil
}

func tryRemoveTempFile(filename string) {
        log.Debug("Removing temp file: %v", filename)
        removeErr := os.Remove(filename)
        if removeErr != nil {
                log.Errorf("Failed to remove temp file: %v", filename)
        }
}

// thanks https://stackoverflow.com/questions/21060945/simple-way-to-copy-a-file-in-golang
func copyFileContents(src, dst string) (err error) {
        // ignore CWE-22 gosec issue - that's more targeted for http based apps that run in a public directory,
        // and ensuring that it's not possible to give a path to a file outside thar directory.

        in, err := os.Open(src) // #nosec
        if err != nil {
                return err
        }
        defer safelyCloseFile(in)
        out, err := os.Create(dst) // #nosec
        if err != nil {
                return err
        }
        defer safelyCloseFile(out)
        if _, err = io.Copy(out, in); err != nil {
                return err
        }
        return out.Sync()
}

func SafelyCloseReader(reader io.Reader) {
        switch reader := reader.(type) {
        case *os.File:
                safelyCloseFile(reader)
        }
}

func safelyCloseFile(file *os.File) {
        err := file.Close()
        if err != nil {
                log.Error("Error closing file!")
                log.Error(err.Error())
        }
}

func createTempFile() (*os.File, error) {
        _, err := os.Stat(os.TempDir())
        if os.IsNotExist(err) {
                err = os.Mkdir(os.TempDir(), 0700)
                if err != nil {
                        return nil, err
                }
        } else if err != nil {
                return nil, err
        }

        file, err := os.CreateTemp("", "temp")
        if err != nil {
                return nil, err
        }

        return file, err
}

package yqlib

import (
        "fmt"
        "path/filepath"
        "slices"
        "strings"
)

type EncoderFactoryFunction func() Encoder
type DecoderFactoryFunction func() Decoder

type Format struct {
        FormalName     string
        Names          []string
        EncoderFactory EncoderFactoryFunction
        DecoderFactory DecoderFactoryFunction
}

var YamlFormat = &Format{"yaml", []string{"y", "yml"},
        func() Encoder { return NewYamlEncoder(ConfiguredYamlPreferences) },
        func() Decoder { return NewYamlDecoder(ConfiguredYamlPreferences) },
}

var KYamlFormat = &Format{"kyaml", []string{"ky"},
        func() Encoder { return NewKYamlEncoder(ConfiguredKYamlPreferences) },
        // KYaml is stricter YAML
        func() Decoder { return NewYamlDecoder(ConfiguredYamlPreferences) },
}

var JSONFormat = &Format{"json", []string{"j"},
        func() Encoder { return NewJSONEncoder(ConfiguredJSONPreferences) },
        func() Decoder { return NewJSONDecoder() },
}

var PropertiesFormat = &Format{"props", []string{"p", "properties"},
        func() Encoder { return NewPropertiesEncoder(ConfiguredPropertiesPreferences) },
        func() Decoder { return NewPropertiesDecoder() },
}

var CSVFormat = &Format{"csv", []string{"c"},
        func() Encoder { return NewCsvEncoder(ConfiguredCsvPreferences) },
        func() Decoder { return NewCSVObjectDecoder(ConfiguredCsvPreferences) },
}

var TSVFormat = &Format{"tsv", []string{"t"},
        func() Encoder { return NewCsvEncoder(ConfiguredTsvPreferences) },
        func() Decoder { return NewCSVObjectDecoder(ConfiguredTsvPreferences) },
}

var XMLFormat = &Format{"xml", []string{"x"},
        func() Encoder { return NewXMLEncoder(ConfiguredXMLPreferences) },
        func() Decoder { return NewXMLDecoder(ConfiguredXMLPreferences) },
}

var Base64Format = &Format{"base64", []string{},
        func() Encoder { return NewBase64Encoder() },
        func() Decoder { return NewBase64Decoder() },
}

var UriFormat = &Format{"uri", []string{},
        func() Encoder { return NewUriEncoder() },
        func() Decoder { return NewUriDecoder() },
}

var ShFormat = &Format{"", nil,
        func() Encoder { return NewShEncoder() },
        nil,
}

var TomlFormat = &Format{"toml", []string{},
        func() Encoder { return NewTomlEncoderWithPrefs(ConfiguredTomlPreferences) },
        func() Decoder { return NewTomlDecoder() },
}

var HclFormat = &Format{"hcl", []string{"h", "tf"},
        func() Encoder { return NewHclEncoder(ConfiguredHclPreferences) },
        func() Decoder { return NewHclDecoder() },
}

var ShellVariablesFormat = &Format{"shell", []string{"s", "sh"},
        func() Encoder { return NewShellVariablesEncoder() },
        nil,
}

var LuaFormat = &Format{"lua", []string{"l"},
        func() Encoder { return NewLuaEncoder(ConfiguredLuaPreferences) },
        func() Decoder { return NewLuaDecoder(ConfiguredLuaPreferences) },
}

var INIFormat = &Format{"ini", []string{"i"},
        func() Encoder { return NewINIEncoder() },
        func() Decoder { return NewINIDecoder() },
}

var Formats = []*Format{
        YamlFormat,
        KYamlFormat,
        JSONFormat,
        PropertiesFormat,
        CSVFormat,
        TSVFormat,
        XMLFormat,
        Base64Format,
        UriFormat,
        ShFormat,
        TomlFormat,
        HclFormat,
        ShellVariablesFormat,
        LuaFormat,
        INIFormat,
}

func (f *Format) MatchesName(name string) bool {
        if f.FormalName == name {
                return true
        }
        return slices.Contains(f.Names, name)
}

func (f *Format) GetConfiguredEncoder() Encoder {
        return f.EncoderFactory()
}

func FormatStringFromFilename(filename string) string {
        if filename != "" {
                GetLogger().Debugf("checking filename '%s' for auto format detection", filename)
                ext := filepath.Ext(filename)
                if len(ext) >= 2 && ext[0] == '.' {
                        format := strings.ToLower(ext[1:])
                        GetLogger().Debugf("detected format '%s'", format)
                        return format
                }
        }

        GetLogger().Debugf("using default inputFormat 'yaml'")
        return "yaml"
}

func FormatFromString(format string) (*Format, error) {
        if format != "" {
                for _, printerFormat := range Formats {
                        if printerFormat.MatchesName(format) {
                                return printerFormat, nil
                        }
                }
        }
        return nil, fmt.Errorf("unknown format '%v' please use [%v]", format, GetAvailableOutputFormatString())
}

func GetAvailableOutputFormats() []*Format {
        var formats = []*Format{}
        for _, printerFormat := range Formats {
                if printerFormat.EncoderFactory != nil {
                        formats = append(formats, printerFormat)
                }
        }
        return formats
}

func GetAvailableOutputFormatString() string {
        var formats = []string{}
        for _, printerFormat := range GetAvailableOutputFormats() {

                if printerFormat.FormalName != "" {
                        formats = append(formats, printerFormat.FormalName)
                }
                if len(printerFormat.Names) >= 1 {
                        formats = append(formats, printerFormat.Names[0])
                }
        }
        return strings.Join(formats, "|")
}

func GetAvailableInputFormats() []*Format {
        var formats = []*Format{}
        for _, printerFormat := range Formats {
                if printerFormat.DecoderFactory != nil {
                        formats = append(formats, printerFormat)
                }
        }
        return formats
}

func GetAvailableInputFormatString() string {
        var formats = []string{}
        for _, printerFormat := range GetAvailableInputFormats() {

                if printerFormat.FormalName != "" {
                        formats = append(formats, printerFormat.FormalName)
                }
                if len(printerFormat.Names) >= 1 {
                        formats = append(formats, printerFormat.Names[0])
                }
        }
        return strings.Join(formats, "|")
}

package yqlib

import (
        "bufio"
        "errors"
        "io"
        "os"
)

type frontMatterHandler interface {
        Split() error
        GetYamlFrontMatterFilename() string
        GetContentReader() io.Reader
        CleanUp()
}

type frontMatterHandlerImpl struct {
        originalFilename        string
        yamlFrontMatterFilename string
        contentReader           io.Reader
}

func NewFrontMatterHandler(originalFilename string) frontMatterHandler {
        return &frontMatterHandlerImpl{originalFilename, "", nil}
}

func (f *frontMatterHandlerImpl) GetYamlFrontMatterFilename() string {
        return f.yamlFrontMatterFilename
}

func (f *frontMatterHandlerImpl) GetContentReader() io.Reader {
        return f.contentReader
}

func (f *frontMatterHandlerImpl) CleanUp() {
        tryRemoveTempFile(f.yamlFrontMatterFilename)
}

// Splits the given file by yaml front matter
// yaml content will be saved to first temporary file
// remaining content will be saved to second temporary file
func (f *frontMatterHandlerImpl) Split() error {
        var reader *bufio.Reader
        var err error
        if f.originalFilename == "-" {
                reader = bufio.NewReader(os.Stdin)
        } else {
                file, err := os.Open(f.originalFilename) // #nosec
                if err != nil {
                        return err
                }
                reader = bufio.NewReader(file)
        }
        f.contentReader = reader

        yamlTempFile, err := createTempFile()
        if err != nil {
                return err
        }
        f.yamlFrontMatterFilename = yamlTempFile.Name()
        log.Debug("yamlTempFile: %v", yamlTempFile.Name())

        lineCount := 0

        for {
                peekBytes, err := reader.Peek(3)
                if errors.Is(err, io.EOF) {
                        // we've finished reading the yaml content..I guess
                        break
                } else if err != nil {
                        return err
                }
                if lineCount > 0 && string(peekBytes) == "---" {
                        // we've finished reading the yaml content..
                        break
                }
                line, errReading := reader.ReadString('\n')
                lineCount = lineCount + 1
                if errReading != nil && !errors.Is(errReading, io.EOF) {
                        return errReading
                }

                _, errWriting := yamlTempFile.WriteString(line)

                if errWriting != nil {
                        return errWriting
                }
        }

        safelyCloseFile(yamlTempFile)

        return nil

}

package yqlib

type HclPreferences struct {
        ColorsEnabled bool
}

func NewDefaultHclPreferences() HclPreferences {
        return HclPreferences{ColorsEnabled: false}
}

func (p *HclPreferences) Copy() HclPreferences {
        return HclPreferences{ColorsEnabled: p.ColorsEnabled}
}

var ConfiguredHclPreferences = NewDefaultHclPreferences()

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()

package yqlib

type JsonPreferences struct {
        Indent        int
        ColorsEnabled bool
        UnwrapScalar  bool
}

func NewDefaultJsonPreferences() JsonPreferences {
        return JsonPreferences{
                Indent:        2,
                ColorsEnabled: true,
                UnwrapScalar:  true,
        }
}

func (p *JsonPreferences) Copy() JsonPreferences {
        return JsonPreferences{
                Indent:        p.Indent,
                ColorsEnabled: p.ColorsEnabled,
                UnwrapScalar:  p.UnwrapScalar,
        }
}

var ConfiguredJSONPreferences = NewDefaultJsonPreferences()

//go:build !yq_nokyaml

package yqlib

type KYamlPreferences struct {
        Indent             int
        ColorsEnabled      bool
        PrintDocSeparators bool
        UnwrapScalar       bool
}

func NewDefaultKYamlPreferences() KYamlPreferences {
        return KYamlPreferences{
                Indent:             2,
                ColorsEnabled:      false,
                PrintDocSeparators: true,
                UnwrapScalar:       true,
        }
}

func (p *KYamlPreferences) Copy() KYamlPreferences {
        return KYamlPreferences{
                Indent:             p.Indent,
                ColorsEnabled:      p.ColorsEnabled,
                PrintDocSeparators: p.PrintDocSeparators,
                UnwrapScalar:       p.UnwrapScalar,
        }
}

var ConfiguredKYamlPreferences = NewDefaultKYamlPreferences()

package yqlib

import (
        "fmt"
        "regexp"
)

type expressionTokeniser interface {
        Tokenise(expression string) ([]*token, error)
}

type tokenType uint32

const (
        operationToken = 1 << iota
        openBracket
        closeBracket
        openCollect
        closeCollect
        openCollectObject
        closeCollectObject
        traverseArrayCollect
)

type token struct {
        TokenType            tokenType
        Operation            *Operation
        AssignOperation      *Operation // e.g. tag (GetTag) op becomes AssignTag if '=' follows it
        CheckForPostTraverse bool       // e.g. [1]cat should really be [1].cat
        Match                string
}

func (t *token) toString(detail bool) string {
        switch t.TokenType {
        case operationToken:
                if detail {
                        return fmt.Sprintf("%v (%v)", t.Operation.toString(), t.Operation.OperationType.Precedence)
                }
                return t.Operation.toString()
        case openBracket:
                return "("
        case closeBracket:
                return ")"
        case openCollect:
                return "["
        case closeCollect:
                return "]"
        case openCollectObject:
                return "{"
        case closeCollectObject:
                return "}"
        case traverseArrayCollect:
                return ".["

        }
        return "NFI"
}

func unwrap(value string) string {
        return value[1 : len(value)-1]
}

func extractNumberParameter(value string) (int, error) {
        parameterParser := regexp.MustCompile(`.*\((-?[0-9]+)\)`)
        matches := parameterParser.FindStringSubmatch(value)
        var indent, errParsingInt = parseInt(matches[1])
        if errParsingInt != nil {
                return 0, errParsingInt
        }
        return indent, nil
}

func hasOptionParameter(value string, option string) bool {
        parameterParser := regexp.MustCompile(`.*\([^\)]*\)`)
        matches := parameterParser.FindStringSubmatch(value)
        if len(matches) == 0 {
                return false
        }
        parameterString := matches[0]
        optionParser := regexp.MustCompile(fmt.Sprintf("\\b%v\\b", option))
        return len(optionParser.FindStringSubmatch(parameterString)) > 0
}

func postProcessTokens(tokens []*token) []*token {
        var postProcessedTokens = make([]*token, 0)

        skipNextToken := false

        for index := range tokens {
                if skipNextToken {
                        skipNextToken = false
                } else {
                        postProcessedTokens, skipNextToken = handleToken(tokens, index, postProcessedTokens)
                }
        }

        return postProcessedTokens
}

func tokenIsOpType(token *token, opType *operationType) bool {
        return token.TokenType == operationToken && token.Operation.OperationType == opType
}

func handleToken(tokens []*token, index int, postProcessedTokens []*token) (tokensAccum []*token, skipNextToken bool) {
        skipNextToken = false
        currentToken := tokens[index]

        log.Debug("processing %v", currentToken.toString(true))

        if currentToken.TokenType == traverseArrayCollect {
                // `.[exp]`` works by creating a traversal array of [self, exp] and piping that into the traverse array operator
                //need to put a traverse array then a collect currentToken
                // do this by adding traverse then converting currentToken to collect

                log.Debug("adding self")
                op := &Operation{OperationType: selfReferenceOpType, StringValue: "SELF"}
                postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})

                log.Debug("adding traverse array")
                op = &Operation{OperationType: traverseArrayOpType, StringValue: "TRAVERSE_ARRAY"}
                postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})

                currentToken = &token{TokenType: openCollect}

        }

        if tokenIsOpType(currentToken, createMapOpType) {
                log.Debugf("tokenIsOpType: createMapOpType")
                // check the previous token is '[', means we are slice, but dont have a first number
                if index > 0 && tokens[index-1].TokenType == traverseArrayCollect {
                        log.Debugf("previous token is : traverseArrayOpType")
                        // need to put the number 0 before this token, as that is implied
                        postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: createValueOperation(0, "0")})
                }
        }

        if index != len(tokens)-1 && currentToken.AssignOperation != nil &&
                tokenIsOpType(tokens[index+1], assignOpType) {
                log.Debug("its an update assign")
                currentToken.Operation = currentToken.AssignOperation
                currentToken.Operation.UpdateAssign = tokens[index+1].Operation.UpdateAssign
                skipNextToken = true
        }

        log.Debug("adding token to the fixed list")
        postProcessedTokens = append(postProcessedTokens, currentToken)

        if tokenIsOpType(currentToken, createMapOpType) {
                log.Debugf("tokenIsOpType: createMapOpType")
                // check the next token is ']', means we are slice, but dont have a second number
                if index != len(tokens)-1 && tokens[index+1].TokenType == closeCollect {
                        log.Debugf("next token is : closeCollect")
                        // need to put the number 0 before this token, as that is implied
                        lengthOp := &Operation{OperationType: lengthOpType}
                        postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: lengthOp})
                }
        }

        if index != len(tokens)-1 &&
                ((currentToken.TokenType == openCollect && tokens[index+1].TokenType == closeCollect) ||
                        (currentToken.TokenType == openCollectObject && tokens[index+1].TokenType == closeCollectObject)) {
                log.Debug("adding empty")
                op := &Operation{OperationType: emptyOpType, StringValue: "EMPTY"}
                postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
        }

        if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&

                (tokenIsOpType(tokens[index+1], traversePathOpType) ||
                        (tokens[index+1].TokenType == traverseArrayCollect)) {
                log.Debug("adding pipe because the next thing is traverse")
                op := &Operation{OperationType: shortPipeOpType, Value: "PIPE", StringValue: "."}
                postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
        }
        if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
                tokens[index+1].TokenType == openCollect {

                log.Debug("adding traverseArray because next is opencollect")
                op := &Operation{OperationType: traverseArrayOpType}
                postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
        }
        return postProcessedTokens, skipNextToken
}

package yqlib

import (
        "strconv"
        "strings"

        "github.com/alecthomas/participle/v2/lexer"
)

var participleYqRules = []*participleYqRule{
        {"LINE_COMMENT", `line_?comment|lineComment`, opTokenWithPrefs(getCommentOpType, assignCommentOpType, commentOpPreferences{LineComment: true}), 0},
        {"HEAD_COMMENT", `head_?comment|headComment`, opTokenWithPrefs(getCommentOpType, assignCommentOpType, commentOpPreferences{HeadComment: true}), 0},
        {"FOOT_COMMENT", `foot_?comment|footComment`, opTokenWithPrefs(getCommentOpType, assignCommentOpType, commentOpPreferences{FootComment: true}), 0},

        {"OpenBracket", `\(`, literalToken(openBracket, false), 0},
        {"CloseBracket", `\)`, literalToken(closeBracket, true), 0},
        {"OpenTraverseArrayCollect", `\.\[`, literalToken(traverseArrayCollect, false), 0},

        {"OpenCollect", `\[`, literalToken(openCollect, false), 0},
        {"CloseCollect", `\]\??`, literalToken(closeCollect, true), 0},

        {"OpenCollectObject", `\{`, literalToken(openCollectObject, false), 0},
        {"CloseCollectObject", `\}`, literalToken(closeCollectObject, true), 0},

        {"RecursiveDecentIncludingKeys", `\.\.\.`, recursiveDecentOpToken(true), 0},
        {"RecursiveDecent", `\.\.`, recursiveDecentOpToken(false), 0},

        {"GetVariable", `\$[a-zA-Z_\-0-9]+`, getVariableOpToken(), 0},
        {"AssignAsVariable", `as`, opTokenWithPrefs(assignVariableOpType, nil, assignVarPreferences{}), 0},
        {"AssignRefVariable", `ref`, opTokenWithPrefs(assignVariableOpType, nil, assignVarPreferences{IsReference: true}), 0},

        {"CreateMap", `:\s*`, opToken(createMapOpType), 0},
        simpleOp("length", lengthOpType),
        simpleOp("line", lineOpType),
        simpleOp("column", columnOpType),
        simpleOp("eval", evalOpType),
        simpleOp("to_?number", toNumberOpType),

        {"MapValues", `map_?values`, opToken(mapValuesOpType), 0},
        simpleOp("map", mapOpType),
        simpleOp("filter", filterOpType),
        simpleOp("pick", pickOpType),
        simpleOp("omit", omitOpType),

        {"FlattenWithDepth", `flatten\([0-9]+\)`, flattenWithDepth(), 0},
        {"Flatten", `flatten`, opTokenWithPrefs(flattenOpType, nil, flattenPreferences{depth: -1}), 0},

        simpleOp("format_datetime", formatDateTimeOpType),
        simpleOp("now", nowOpType),
        simpleOp("tz", tzOpType),
        simpleOp("from_?unix", fromUnixOpType),
        simpleOp("to_?unix", toUnixOpType),
        simpleOp("with_dtf", withDtFormatOpType),
        simpleOp("error", errorOpType),
        simpleOp("shuffle", shuffleOpType),
        simpleOp("sortKeys", sortKeysOpType),
        simpleOp("sort_?keys", sortKeysOpType),

        {"ArrayToMap", "array_?to_?map", expressionOpToken(`(.[] | select(. != null) ) as $i ireduce({}; .[$i | key] = $i)`), 0},
        {"Root", "root", expressionOpToken(`parent(-1)`), 0},
        {"YamlEncodeWithIndent", `to_?yaml\([0-9]+\)`, encodeParseIndent(YamlFormat), 0},
        {"XMLEncodeWithIndent", `to_?xml\([0-9]+\)`, encodeParseIndent(XMLFormat), 0},
        {"JSONEncodeWithIndent", `to_?json\([0-9]+\)`, encodeParseIndent(JSONFormat), 0},

        {"YamlDecode", `from_?yaml|@yamld|from_?json|@jsond`, decodeOp(YamlFormat), 0},
        {"YamlEncode", `to_?yaml|@yaml`, encodeWithIndent(YamlFormat, 2), 0},

        {"JSONEncode", `to_?json`, encodeWithIndent(JSONFormat, 2), 0},
        {"JSONEncodeNoIndent", `@json`, encodeWithIndent(JSONFormat, 0), 0},

        {"PropertiesDecode", `from_?props|@propsd`, decodeOp(PropertiesFormat), 0},
        {"PropsEncode", `to_?props|@props`, encodeWithIndent(PropertiesFormat, 2), 0},

        {"XmlDecode", `from_?xml|@xmld`, decodeOp(XMLFormat), 0},
        {"XMLEncode", `to_?xml`, encodeWithIndent(XMLFormat, 2), 0},
        {"XMLEncodeNoIndent", `@xml`, encodeWithIndent(XMLFormat, 0), 0},

        {"CSVDecode", `from_?csv|@csvd`, decodeOp(CSVFormat), 0},
        {"CSVEncode", `to_?csv|@csv`, encodeWithIndent(CSVFormat, 0), 0},

        {"TSVDecode", `from_?tsv|@tsvd`, decodeOp(TSVFormat), 0},
        {"TSVEncode", `to_?tsv|@tsv`, encodeWithIndent(TSVFormat, 0), 0},

        {"Base64d", `@base64d`, decodeOp(Base64Format), 0},
        {"Base64", `@base64`, encodeWithIndent(Base64Format, 0), 0},

        {"Urid", `@urid`, decodeOp(UriFormat), 0},
        {"Uri", `@uri`, encodeWithIndent(UriFormat, 0), 0},
        {"SH", `@sh`, encodeWithIndent(ShFormat, 0), 0},

        {"LoadXML", `load_?xml|xml_?load`, loadOp(NewXMLDecoder(ConfiguredXMLPreferences)), 0},

        {"LoadBase64", `load_?base64`, loadOp(NewBase64Decoder()), 0},

        {"LoadProperties", `load_?props`, loadOp(NewPropertiesDecoder()), 0},
        simpleOp("load_?str|str_?load", loadStringOpType),
        {"LoadYaml", `load`, loadOp(NewYamlDecoder(LoadYamlPreferences)), 0},

        {"SplitDocument", `splitDoc|split_?doc`, opToken(splitDocumentOpType), 0},

        simpleOp("select", selectOpType),
        simpleOp("has", hasOpType),
        simpleOp("unique_?by", uniqueByOpType),
        simpleOp("unique", uniqueOpType),

        simpleOp("group_?by", groupByOpType),
        simpleOp("explode", explodeOpType),
        simpleOp("or", orOpType),
        simpleOp("and", andOpType),
        simpleOp("not", notOpType),
        simpleOp("ireduce", reduceOpType),

        simpleOp("join", joinStringOpType),
        simpleOp("sub", subStringOpType),
        simpleOp("match", matchOpType),
        simpleOp("capture", captureOpType),
        simpleOp("test", testOpType),

        simpleOp("sort_?by", sortByOpType),
        simpleOp("sort", sortOpType),
        simpleOp("first", firstOpType),

        simpleOp("reverse", reverseOpType),

        simpleOp("any_c", anyConditionOpType),
        simpleOp("any", anyOpType),

        simpleOp("all_c", allConditionOpType),
        simpleOp("all", allOpType),

        simpleOp("contains", containsOpType),
        simpleOp("split", splitStringOpType),

        simpleOp("parents", getParentsOpType),
        {"ParentWithLevel", `parent\(-?[0-9]+\)`, parentWithLevel(), 0},
        {"ParentWithDefaultLevel", `parent`, parentWithDefaultLevel(), 0},

        simpleOp("keys", keysOpType),
        simpleOp("key", getKeyOpType),
        simpleOp("is_?key", isKeyOpType),

        simpleOp("file_?name|fileName", getFilenameOpType),
        simpleOp("file_?index|fileIndex|fi", getFileIndexOpType),
        simpleOp("path", getPathOpType),
        simpleOp("set_?path", setPathOpType),
        simpleOp("del_?paths", delPathsOpType),

        simpleOp("to_?entries|toEntries", toEntriesOpType),
        simpleOp("from_?entries|fromEntries", fromEntriesOpType),
        simpleOp("with_?entries|withEntries", withEntriesOpType),

        simpleOp("with", withOpType),

        simpleOp("collect", collectOpType),
        simpleOp("del", deleteChildOpType),

        assignableOp("style", getStyleOpType, assignStyleOpType),
        assignableOp("tag|type", getTagOpType, assignTagOpType),
        simpleOp("kind", getKindOpType),
        assignableOp("anchor", getAnchorOpType, assignAnchorOpType),
        assignableOp("alias", getAliasOpType, assignAliasOpType),

        {"ALL_COMMENTS", `comments\s*=`, assignAllCommentsOp(false), 0},
        {"ALL_COMMENTS_ASSIGN_RELATIVE", `comments\s*\|=`, assignAllCommentsOp(true), 0},

        {"Block", `;`, opToken(blockOpType), 0},
        {"Alternative", `\/\/`, opToken(alternativeOpType), 0},

        {"DocumentIndex", `documentIndex|document_?index|di`, opToken(getDocumentIndexOpType), 0},

        {"Uppercase", `upcase|ascii_?upcase`, opTokenWithPrefs(changeCaseOpType, nil, changeCasePrefs{ToUpperCase: true}), 0},
        {"Downcase", `downcase|ascii_?downcase`, opTokenWithPrefs(changeCaseOpType, nil, changeCasePrefs{ToUpperCase: false}), 0},
        simpleOp("trim", trimOpType),
        simpleOp("to_?string", toStringOpType),

        {"HexValue", `0[xX][0-9A-Fa-f]+`, hexValue(), 0},
        {"FloatValueScientific", `-?[1-9](\.\d+)?[Ee][-+]?\d+`, floatValue(), 0},
        {"FloatValue", `-?\d+(\.\d+)`, floatValue(), 0},

        {"NumberValue", `-?\d+`, numberValue(), 0},

        {"TrueBooleanValue", `[Tt][Rr][Uu][Ee]`, booleanValue(true), 0},
        {"FalseBooleanValue", `[Ff][Aa][Ll][Ss][Ee]`, booleanValue(false), 0},

        {"NullValue", `[Nn][Uu][Ll][Ll]|~`, nullValue(), 0},

        {"QuotedStringValue", `"([^"\\]*(\\.[^"\\]*)*)"`, stringValue(), 0},

        {"StrEnvOp", `strenv\([^\)]+\)`, envOp(true), 0},
        {"EnvOp", `env\([^\)]+\)`, envOp(false), 0},

        {"EnvSubstWithOptions", `envsubst\((ne|nu|ff| |,)+\)`, envSubstWithOptions(), 0},
        simpleOp("envsubst", envsubstOpType),

        {"Equals", `\s*==\s*`, opToken(equalsOpType), 0},
        {"NotEquals", `\s*!=\s*`, opToken(notEqualsOpType), 0},

        {"GreaterThanEquals", `\s*>=\s*`, opTokenWithPrefs(compareOpType, nil, compareTypePref{OrEqual: true, Greater: true}), 0},
        {"LessThanEquals", `\s*<=\s*`, opTokenWithPrefs(compareOpType, nil, compareTypePref{OrEqual: true, Greater: false}), 0},

        {"GreaterThan", `\s*>\s*`, opTokenWithPrefs(compareOpType, nil, compareTypePref{OrEqual: false, Greater: true}), 0},
        {"LessThan", `\s*<\s*`, opTokenWithPrefs(compareOpType, nil, compareTypePref{OrEqual: false, Greater: false}), 0},

        simpleOp("min", minOpType),
        simpleOp("max", maxOpType),

        {"AssignRelative", `\|=[c]*`, assignOpToken(true), 0},
        {"Assign", `=[c]*`, assignOpToken(false), 0},

        {`whitespace`, `[ \t\n]+`, nil, 0},

        {"WrappedPathElement", `\."[^ "]+"\??`, pathToken(true), 0},
        {"PathElement", `\.[^ ;\}\{\:\[\],\|\.\[\(\)=\n!]+\??`, pathToken(false), 0},
        {"Pipe", `\|`, opToken(pipeOpType), 0},
        {"Self", `\.`, opToken(selfReferenceOpType), 0},

        {"Union", `,`, opToken(unionOpType), 0},

        {"MultiplyAssign", `\*=[\+|\?cdn]*`, multiplyWithPrefs(multiplyAssignOpType), 0},
        {"Multiply", `\*[\+|\?cdn]*`, multiplyWithPrefs(multiplyOpType), 0},

        {"Divide", `\/`, opToken(divideOpType), 0},

        {"Modulo", `%`, opToken(moduloOpType), 0},

        {"AddAssign", `\+=`, opToken(addAssignOpType), 0},
        {"Add", `\+`, opToken(addOpType), 0},

        {"SubtractAssign", `\-=`, opToken(subtractAssignOpType), 0},
        {"Subtract", `\-`, opToken(subtractOpType), 0},
        {"Comment", `#.*`, nil, 0},

        simpleOp("pivot", pivotOpType),
}

type yqAction func(lexer.Token) (*token, error)

type participleYqRule struct {
        Name                string
        Pattern             string
        CreateYqToken       yqAction
        ParticipleTokenType lexer.TokenType
}

type participleLexer struct {
        lexerDefinition lexer.StringDefinition
}

func simpleOp(name string, opType *operationType) *participleYqRule {
        return &participleYqRule{strings.ToUpper(string(name[1])) + name[1:], name, opToken(opType), 0}
}

func assignableOp(name string, opType *operationType, assignOpType *operationType) *participleYqRule {
        return &participleYqRule{strings.ToUpper(string(name[1])) + name[1:], name, opTokenWithPrefs(opType, assignOpType, nil), 0}
}

func newParticipleLexer() expressionTokeniser {
        simpleRules := make([]lexer.SimpleRule, len(participleYqRules))
        for i, yqRule := range participleYqRules {
                simpleRules[i] = lexer.SimpleRule{Name: yqRule.Name, Pattern: yqRule.Pattern}
        }
        lexerDefinition := lexer.MustSimple(simpleRules)
        symbols := lexerDefinition.Symbols()

        for _, yqRule := range participleYqRules {
                yqRule.ParticipleTokenType = symbols[yqRule.Name]
        }

        return &participleLexer{lexerDefinition}
}

func pathToken(wrapped bool) yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                value := rawToken.Value
                prefs := traversePreferences{}

                if value[len(value)-1:] == "?" {
                        prefs.OptionalTraverse = true
                        value = value[:len(value)-1]
                }

                value = value[1:]
                if wrapped {
                        value = unwrap(value)
                }
                log.Debug("PathToken %v", value)
                op := &Operation{OperationType: traversePathOpType, Value: value, StringValue: value, Preferences: prefs}
                return &token{TokenType: operationToken, Operation: op, CheckForPostTraverse: true}, nil
        }
}

func recursiveDecentOpToken(includeMapKeys bool) yqAction {
        prefs := recursiveDescentPreferences{
                RecurseArray: true,
                TraversePreferences: traversePreferences{
                        DontFollowAlias: true,
                        IncludeMapKeys:  includeMapKeys,
                },
        }
        return opTokenWithPrefs(recursiveDescentOpType, nil, prefs)
}

func opTokenWithPrefs(opType *operationType, assignOpType *operationType, preferences interface{}) yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                value := rawToken.Value
                op := &Operation{OperationType: opType, Value: opType.Type, StringValue: value, Preferences: preferences}
                var assign *Operation
                if assignOpType != nil {
                        assign = &Operation{OperationType: assignOpType, Value: assignOpType.Type, StringValue: value, Preferences: preferences}
                }
                return &token{TokenType: operationToken, Operation: op, AssignOperation: assign, CheckForPostTraverse: op.OperationType.CheckForPostTraverse}, nil
        }
}

func expressionOpToken(expression string) yqAction {
        return func(_ lexer.Token) (*token, error) {
                prefs := expressionOpPreferences{expression: expression}
                expressionOp := &Operation{OperationType: expressionOpType, Preferences: prefs}
                return &token{TokenType: operationToken, Operation: expressionOp}, nil
        }
}

func flattenWithDepth() yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                value := rawToken.Value
                var depth, errParsingInt = extractNumberParameter(value)
                if errParsingInt != nil {
                        return nil, errParsingInt
                }

                prefs := flattenPreferences{depth: depth}
                op := &Operation{OperationType: flattenOpType, Value: flattenOpType.Type, StringValue: value, Preferences: prefs}
                return &token{TokenType: operationToken, Operation: op, CheckForPostTraverse: flattenOpType.CheckForPostTraverse}, nil
        }
}

func assignAllCommentsOp(updateAssign bool) yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                log.Debug("assignAllCommentsOp %v", rawToken.Value)
                value := rawToken.Value
                op := &Operation{
                        OperationType: assignCommentOpType,
                        Value:         assignCommentOpType.Type,
                        StringValue:   value,
                        UpdateAssign:  updateAssign,
                        Preferences:   commentOpPreferences{LineComment: true, HeadComment: true, FootComment: true},
                }
                return &token{TokenType: operationToken, Operation: op}, nil
        }
}

func assignOpToken(updateAssign bool) yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                log.Debug("assignOpToken %v", rawToken.Value)
                value := rawToken.Value
                prefs := assignPreferences{DontOverWriteAnchor: true}
                if strings.Contains(value, "c") {
                        prefs.ClobberCustomTags = true
                }
                op := &Operation{OperationType: assignOpType, Value: assignOpType.Type, StringValue: value, UpdateAssign: updateAssign, Preferences: prefs}
                return &token{TokenType: operationToken, Operation: op}, nil
        }
}

func booleanValue(val bool) yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                return &token{TokenType: operationToken, Operation: createValueOperation(val, rawToken.Value)}, nil
        }
}

func nullValue() yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                return &token{TokenType: operationToken, Operation: createValueOperation(nil, rawToken.Value)}, nil
        }
}

func stringValue() yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                log.Debug("rawTokenvalue: %v", rawToken.Value)
                value := unwrap(rawToken.Value)
                log.Debug("unwrapped: %v", value)
                value = processEscapeCharacters(value)
                return &token{TokenType: operationToken, Operation: &Operation{
                        OperationType: stringInterpolationOpType,
                        StringValue:   value,
                        Value:         value,
                }}, nil
        }
}

func envOp(strenv bool) yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                value := rawToken.Value
                preferences := envOpPreferences{}

                if strenv {
                        // strenv( )
                        value = value[7 : len(value)-1]
                        preferences.StringValue = true
                } else {
                        //env( )
                        value = value[4 : len(value)-1]
                }

                envOperation := createValueOperation(value, value)
                envOperation.OperationType = envOpType
                envOperation.Preferences = preferences

                return &token{TokenType: operationToken, Operation: envOperation, CheckForPostTraverse: envOpType.CheckForPostTraverse}, nil
        }
}

func envSubstWithOptions() yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                value := rawToken.Value
                noEmpty := hasOptionParameter(value, "ne")
                noUnset := hasOptionParameter(value, "nu")
                failFast := hasOptionParameter(value, "ff")
                envsubstOpType.Type = "ENVSUBST"
                prefs := envOpPreferences{NoUnset: noUnset, NoEmpty: noEmpty, FailFast: failFast}
                if noEmpty {
                        envsubstOpType.Type = envsubstOpType.Type + "_NO_EMPTY"
                }
                if noUnset {
                        envsubstOpType.Type = envsubstOpType.Type + "_NO_UNSET"
                }

                op := &Operation{OperationType: envsubstOpType, Value: envsubstOpType.Type, StringValue: value, Preferences: prefs}
                return &token{TokenType: operationToken, Operation: op}, nil
        }
}

func multiplyWithPrefs(op *operationType) yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                prefs := multiplyPreferences{}
                prefs.AssignPrefs = assignPreferences{}
                options := rawToken.Value
                if strings.Contains(options, "+") {
                        prefs.AppendArrays = true
                }
                if strings.Contains(options, "?") {
                        prefs.TraversePrefs = traversePreferences{DontAutoCreate: true}
                }
                if strings.Contains(options, "n") {
                        prefs.AssignPrefs.OnlyWriteNull = true
                }
                if strings.Contains(options, "d") {
                        prefs.DeepMergeArrays = true
                }
                if strings.Contains(options, "c") {
                        prefs.AssignPrefs.ClobberCustomTags = true
                }
                prefs.TraversePrefs.DontFollowAlias = true
                op := &Operation{OperationType: op, Value: multiplyOpType.Type, StringValue: options, Preferences: prefs}
                return &token{TokenType: operationToken, Operation: op}, nil
        }

}

func getVariableOpToken() yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                value := rawToken.Value

                value = value[1:]

                getVarOperation := createValueOperation(value, value)
                getVarOperation.OperationType = getVariableOpType

                return &token{TokenType: operationToken, Operation: getVarOperation, CheckForPostTraverse: true}, nil
        }
}

func hexValue() yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                var originalString = rawToken.Value
                var numberString = originalString[2:]
                log.Debugf("numberString: %v", numberString)
                var number, errParsingInt = strconv.ParseInt(numberString, 16, 64)
                if errParsingInt != nil {
                        return nil, errParsingInt
                }

                return &token{TokenType: operationToken, Operation: createValueOperation(number, originalString)}, nil
        }
}

func floatValue() yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                var numberString = rawToken.Value
                var number, errParsingInt = strconv.ParseFloat(numberString, 64)
                if errParsingInt != nil {
                        return nil, errParsingInt
                }
                return &token{TokenType: operationToken, Operation: createValueOperation(number, numberString)}, nil
        }
}

func numberValue() yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                var numberString = rawToken.Value
                var number, errParsingInt = strconv.ParseInt(numberString, 10, 64)
                if errParsingInt != nil {
                        return nil, errParsingInt
                }

                return &token{TokenType: operationToken, Operation: createValueOperation(number, numberString)}, nil
        }
}

func parentWithLevel() yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                value := rawToken.Value
                var level, errParsingInt = extractNumberParameter(value)
                if errParsingInt != nil {
                        return nil, errParsingInt
                }

                prefs := parentOpPreferences{Level: level}
                op := &Operation{OperationType: getParentOpType, Value: getParentOpType.Type, StringValue: value, Preferences: prefs}
                return &token{TokenType: operationToken, Operation: op, CheckForPostTraverse: true}, nil
        }
}

func parentWithDefaultLevel() yqAction {
        return func(_ lexer.Token) (*token, error) {
                prefs := parentOpPreferences{Level: 1}
                op := &Operation{OperationType: getParentOpType, Value: getParentOpType.Type, StringValue: getParentOpType.Type, Preferences: prefs}
                return &token{TokenType: operationToken, Operation: op, CheckForPostTraverse: true}, nil
        }
}

func encodeParseIndent(outputFormat *Format) yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                value := rawToken.Value
                var indent, errParsingInt = extractNumberParameter(value)
                if errParsingInt != nil {
                        return nil, errParsingInt
                }

                prefs := encoderPreferences{format: outputFormat, indent: indent}
                op := &Operation{OperationType: encodeOpType, Value: encodeOpType.Type, StringValue: value, Preferences: prefs}
                return &token{TokenType: operationToken, Operation: op}, nil
        }
}

func encodeWithIndent(outputFormat *Format, indent int) yqAction {
        prefs := encoderPreferences{format: outputFormat, indent: indent}
        return opTokenWithPrefs(encodeOpType, nil, prefs)
}

func decodeOp(format *Format) yqAction {
        prefs := decoderPreferences{format: format}
        return opTokenWithPrefs(decodeOpType, nil, prefs)
}

func loadOp(decoder Decoder) yqAction {
        prefs := loadPrefs{decoder}
        return opTokenWithPrefs(loadOpType, nil, prefs)
}

func opToken(op *operationType) yqAction {
        return opTokenWithPrefs(op, nil, nil)
}

func literalToken(tt tokenType, checkForPost bool) yqAction {
        return func(rawToken lexer.Token) (*token, error) {
                return &token{TokenType: tt, CheckForPostTraverse: checkForPost, Match: rawToken.Value}, nil
        }
}

func (p *participleLexer) getYqDefinition(rawToken lexer.Token) *participleYqRule {
        for _, yqRule := range participleYqRules {
                if yqRule.ParticipleTokenType == rawToken.Type {
                        return yqRule
                }
        }
        return &participleYqRule{}
}

func (p *participleLexer) Tokenise(expression string) ([]*token, error) {
        myLexer, err := p.lexerDefinition.LexString("", expression)
        if err != nil {
                return nil, err
        }
        tokens := make([]*token, 0)

        for {
                rawToken, e := myLexer.Next()
                if e != nil {
                        return nil, e
                } else if rawToken.Type == lexer.EOF {
                        return postProcessTokens(tokens), nil
                }

                definition := p.getYqDefinition(rawToken)
                if definition.CreateYqToken != nil {
                        token, e := definition.CreateYqToken(rawToken)
                        if e != nil {
                                return nil, e
                        }
                        tokens = append(tokens, token)
                }

        }

}

// Use the top level Evaluator or StreamEvaluator to evaluate expressions and return matches.
package yqlib

import (
        "container/list"
        "fmt"
        "math"
        "strconv"
        "strings"

        logging "gopkg.in/op/go-logging.v1"
)

var ExpressionParser ExpressionParserInterface

func InitExpressionParser() {
        if ExpressionParser == nil {
                ExpressionParser = newExpressionParser()
        }
}

var log = logging.MustGetLogger("yq-lib")

var PrettyPrintExp = `(... | (select(tag != "!!str"), select(tag == "!!str") | select(test("(?i)^(y|yes|n|no|on|off)$") | not))  ) style=""`

// GetLogger returns the yq logger instance.
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
        }

        for index := 0; index < len(lhs.Content); index = index + 1 {
                if !recursiveNodeEqual(lhs.Content[index], rhs.Content[index]) {
                        return false
                }
        }
        return true
}

func findInArray(array *CandidateNode, item *CandidateNode) int {

        for index := 0; index < len(array.Content); index = index + 1 {
                if recursiveNodeEqual(array.Content[index], item) {
                        return index
                }
        }
        return -1
}

func findKeyInMap(dataMap *CandidateNode, item *CandidateNode) int {

        for index := 0; index < len(dataMap.Content); index = index + 2 {
                if recursiveNodeEqual(dataMap.Content[index], item) {
                        return index
                }
        }
        return -1
}

func recurseNodeObjectEqual(lhs *CandidateNode, rhs *CandidateNode) bool {
        if len(lhs.Content) != len(rhs.Content) {
                return false
        }

        for index := 0; index < len(lhs.Content); index = index + 2 {
                key := lhs.Content[index]
                value := lhs.Content[index+1]

                indexInRHS := findInArray(rhs, key)

                if indexInRHS == -1 || !recursiveNodeEqual(value, rhs.Content[indexInRHS+1]) {
                        return false
                }
        }
        return true
}

func parseSnippet(value string) (*CandidateNode, error) {
        if value == "" {
                return &CandidateNode{
                        Kind: ScalarNode,
                        Tag:  "!!null",
                }, nil
        }
        decoder := NewYamlDecoder(ConfiguredYamlPreferences)
        err := decoder.Init(strings.NewReader(value))
        if err != nil {
                return nil, err
        }
        result, err := decoder.Decode()
        if err != nil {
                return nil, err
        }

        if result.Kind == ScalarNode {
                result.LineComment = result.LeadingContent
        } else {
                result.HeadComment = result.LeadingContent
        }
        result.LeadingContent = ""

        if result.Tag == "!!str" {
                // use the original string value, as
                // decoding drops new lines
                newNode := createScalarNode(value, value)
                newNode.LineComment = result.LineComment
                return newNode, nil
        }
        result.Line = 0
        result.Column = 0
        return result, err
}

func recursiveNodeEqual(lhs *CandidateNode, rhs *CandidateNode) bool {
        if lhs.Kind != rhs.Kind {
                return false
        }

        if lhs.Kind == ScalarNode {
                //process custom tags of scalar nodes.
                //dont worry about matching tags of maps or arrays.

                lhsTag := lhs.guessTagFromCustomType()
                rhsTag := rhs.guessTagFromCustomType()

                if lhsTag != rhsTag {
                        return false
                }
        }

        if lhs.Tag == "!!null" {
                return true

        } else if lhs.Kind == ScalarNode {
                return lhs.Value == rhs.Value
        } else if lhs.Kind == SequenceNode {
                return recurseNodeArrayEqual(lhs, rhs)
        } else if lhs.Kind == MappingNode {
                return recurseNodeObjectEqual(lhs, rhs)
        }
        return false
}

// yaml numbers can have underscores, be hex and octal encoded...
func parseInt64(numberString string) (string, int64, error) {
        if strings.Contains(numberString, "_") {
                numberString = strings.ReplaceAll(numberString, "_", "")
        }

        if strings.HasPrefix(numberString, "0x") ||
                strings.HasPrefix(numberString, "0X") {
                num, err := strconv.ParseInt(numberString[2:], 16, 64)
                return "0x%X", num, err
        } else if strings.HasPrefix(numberString, "0o") {
                num, err := strconv.ParseInt(numberString[2:], 8, 64)
                return "0o%o", num, err
        }
        num, err := strconv.ParseInt(numberString, 10, 64)
        return "%v", num, err
}

func parseInt(numberString string) (int, error) {
        _, parsed, err := parseInt64(numberString)

        if err != nil {
                return 0, err
        } else if parsed > math.MaxInt || parsed < math.MinInt {
                return 0, fmt.Errorf("%v is not within [%v, %v]", parsed, math.MinInt, math.MaxInt)
        }

        return int(parsed), err
}

func processEscapeCharacters(original string) string {
        if original == "" {
                return original
        }

        var result strings.Builder
        runes := []rune(original)

        for i := 0; i < len(runes); i++ {
                if runes[i] == '\\' && i < len(runes)-1 {
                        next := runes[i+1]
                        switch next {
                        case '\\':
                                // Check if followed by opening bracket - if so, preserve both backslashes
                                // this is required for string interpolation to work correctly.
                                if i+2 < len(runes) && runes[i+2] == '(' {
                                        // Preserve \\ when followed by (
                                        result.WriteRune('\\')
                                        result.WriteRune('\\')
                                        i++ // Skip the next backslash (we'll process the ( normally on next iteration)
                                        continue
                                }
                                // Escaped backslash: \\ -> \
                                result.WriteRune('\\')
                                i++ // Skip the next backslash
                                continue
                        case '"':
                                result.WriteRune('"')
                                i++ // Skip the quote
                                continue
                        case 'n':
                                result.WriteRune('\n')
                                i++ // Skip the 'n'
                                continue
                        case 't':
                                result.WriteRune('\t')
                                i++ // Skip the 't'
                                continue
                        case 'r':
                                result.WriteRune('\r')
                                i++ // Skip the 'r'
                                continue
                        case 'f':
                                result.WriteRune('\f')
                                i++ // Skip the 'f'
                                continue
                        case 'v':
                                result.WriteRune('\v')
                                i++ // Skip the 'v'
                                continue
                        case 'b':
                                result.WriteRune('\b')
                                i++ // Skip the 'b'
                                continue
                        case 'a':
                                result.WriteRune('\a')
                                i++ // Skip the 'a'
                                continue
                        }
                }
                result.WriteRune(runes[i])
        }

        value := result.String()
        if value != original {
                log.Debug("processEscapeCharacters from [%v] to [%v]", original, value)
        }
        return value
}

func headAndLineComment(node *CandidateNode) string {
        return headComment(node) + lineComment(node)
}

func headComment(node *CandidateNode) string {
        return strings.Replace(node.HeadComment, "#", "", 1)
}

func lineComment(node *CandidateNode) string {
        return strings.Replace(node.LineComment, "#", "", 1)
}

func footComment(node *CandidateNode) string {
        return strings.Replace(node.FootComment, "#", "", 1)
}

// use for debugging only
func NodesToString(collection *list.List) string {
        if !log.IsEnabledFor(logging.DEBUG) {
                return ""
        }

        result := fmt.Sprintf("%v results\n", collection.Len())
        for el := collection.Front(); el != nil; el = el.Next() {
                result = result + "\n" + NodeToString(el.Value.(*CandidateNode))
        }
        return result
}

func NodeToString(node *CandidateNode) string {
        if !log.IsEnabledFor(logging.DEBUG) {
                return ""
        }
        if node == nil {
                return "-- nil --"
        }
        tag := node.Tag
        if node.Kind == AliasNode {
                tag = "alias"
        }
        valueToUse := node.Value
        if valueToUse == "" {
                valueToUse = fmt.Sprintf("%v kids", len(node.Content))
        }
        return fmt.Sprintf(`D%v, P%v, %v (%v)::%v`, node.GetDocument(), node.GetNicePath(), KindString(node.Kind), tag, valueToUse)
}

func NodeContentToString(node *CandidateNode, depth int) string {
        if !log.IsEnabledFor(logging.DEBUG) {
                return ""
        }
        var sb strings.Builder
        for _, child := range node.Content {
                for i := 0; i < depth; i++ {
                        sb.WriteString(" ")
                }
                sb.WriteString("- ")
                sb.WriteString(NodeToString(child))
                sb.WriteString("\n")
                sb.WriteString(NodeContentToString(child, depth+1))
        }
        return sb.String()
}

func KindString(kind Kind) string {
        switch kind {
        case ScalarNode:
                return "ScalarNode"
        case SequenceNode:
                return "SequenceNode"
        case MappingNode:
                return "MappingNode"
        case AliasNode:
                return "AliasNode"
        default:
                return "unknown!"
        }
}

package yqlib

type LuaPreferences struct {
        DocPrefix    string
        DocSuffix    string
        UnquotedKeys bool
        Globals      bool
}

func NewDefaultLuaPreferences() LuaPreferences {
        return LuaPreferences{
                DocPrefix:    "return ",
                DocSuffix:    ";\n",
                UnquotedKeys: false,
                Globals:      false,
        }
}

var ConfiguredLuaPreferences = NewDefaultLuaPreferences()

package yqlib

func matchKey(name string, pattern string) (matched bool) {
        if pattern == "" {
                return name == pattern
        }
        if pattern == "*" {
                log.Debug("wild!")
                return true
        }
        return deepMatch(name, pattern)
}

// deepMatch reports whether the name matches the pattern in linear time.
// Source https://research.swtch.com/glob
func deepMatch(name, pattern string) bool {
        px := 0
        nx := 0
        nextPx := 0
        nextNx := 0
        for px < len(pattern) || nx < len(name) {
                if px < len(pattern) {
                        c := pattern[px]
                        switch c {
                        default: // ordinary character
                                if nx < len(name) && name[nx] == c {
                                        px++
                                        nx++
                                        continue
                                }
                        case '?': // single-character wildcard
                                if nx < len(name) {
                                        px++
                                        nx++
                                        continue
                                }
                        case '*': // zero-or-more-character wildcard
                                // Try to match at nx.
                                // If that doesn't work out,
                                // restart at nx+1 next.
                                nextPx = px
                                nextNx = nx + 1
                                px++
                                continue
                        }
                }
                // Mismatch. Maybe restart.
                if 0 < nextNx && nextNx <= len(name) {
                        px = nextPx
                        nx = nextNx
                        continue
                }
                return false
        }
        // Matched all of pattern to all of name. Success.
        return true
}

package yqlib

import "fmt"

type Operation struct {
        OperationType *operationType
        Value         interface{}
        StringValue   string
        CandidateNode *CandidateNode // used for Value Path elements
        Preferences   interface{}
        UpdateAssign  bool // used for assign ops, when true it means we evaluate the rhs given the lhs
}

type operationType struct {
        Type                 string
        NumArgs              uint // number of arguments to the op
        Precedence           uint
        Handler              operatorHandler
        CheckForPostTraverse bool
        ToString             func(o *Operation) string
}

var valueToStringFunc = func(p *Operation) string {
        return fmt.Sprintf("%v (%T)", p.Value, p.Value)
}

func createValueOperation(value interface{}, stringValue string) *Operation {
        log.Debug("creating value op for string %v", stringValue)
        var node = createScalarNode(value, stringValue)

        return &Operation{
                OperationType: valueOpType,
                Value:         value,
                StringValue:   stringValue,
                CandidateNode: node,
        }
}

var orOpType = &operationType{Type: "OR", NumArgs: 2, Precedence: 20, Handler: orOperator}
var andOpType = &operationType{Type: "AND", NumArgs: 2, Precedence: 20, Handler: andOperator}
var reduceOpType = &operationType{Type: "REDUCE", NumArgs: 2, Precedence: 35, Handler: reduceOperator}

var blockOpType = &operationType{Type: "BLOCK", Precedence: 10, NumArgs: 2, Handler: emptyOperator}

var unionOpType = &operationType{Type: "UNION", NumArgs: 2, Precedence: 10, Handler: unionOperator}

var pipeOpType = &operationType{Type: "PIPE", NumArgs: 2, Precedence: 30, Handler: pipeOperator}

var assignOpType = &operationType{Type: "ASSIGN", NumArgs: 2, Precedence: 40, Handler: assignUpdateOperator}
var addAssignOpType = &operationType{Type: "ADD_ASSIGN", NumArgs: 2, Precedence: 40, Handler: addAssignOperator}
var subtractAssignOpType = &operationType{Type: "SUBTRACT_ASSIGN", NumArgs: 2, Precedence: 40, Handler: subtractAssignOperator}

var assignAttributesOpType = &operationType{Type: "ASSIGN_ATTRIBUTES", NumArgs: 2, Precedence: 40, Handler: assignAttributesOperator}
var assignStyleOpType = &operationType{Type: "ASSIGN_STYLE", NumArgs: 2, Precedence: 40, Handler: assignStyleOperator}
var assignVariableOpType = &operationType{Type: "ASSIGN_VARIABLE", NumArgs: 2, Precedence: 40, Handler: useWithPipe}
var assignTagOpType = &operationType{Type: "ASSIGN_TAG", NumArgs: 2, Precedence: 40, Handler: assignTagOperator}
var assignCommentOpType = &operationType{Type: "ASSIGN_COMMENT", NumArgs: 2, Precedence: 40, Handler: assignCommentsOperator}
var assignAnchorOpType = &operationType{Type: "ASSIGN_ANCHOR", NumArgs: 2, Precedence: 40, Handler: assignAnchorOperator}
var assignAliasOpType = &operationType{Type: "ASSIGN_ALIAS", NumArgs: 2, Precedence: 40, Handler: assignAliasOperator}

var multiplyOpType = &operationType{Type: "MULTIPLY", NumArgs: 2, Precedence: 42, Handler: multiplyOperator}
var multiplyAssignOpType = &operationType{Type: "MULTIPLY_ASSIGN", NumArgs: 2, Precedence: 42, Handler: multiplyAssignOperator}

var divideOpType = &operationType{Type: "DIVIDE", NumArgs: 2, Precedence: 42, Handler: divideOperator}

var moduloOpType = &operationType{Type: "MODULO", NumArgs: 2, Precedence: 42, Handler: moduloOperator}

var addOpType = &operationType{Type: "ADD", NumArgs: 2, Precedence: 42, Handler: addOperator}
var subtractOpType = &operationType{Type: "SUBTRACT", NumArgs: 2, Precedence: 42, Handler: subtractOperator}
var alternativeOpType = &operationType{Type: "ALTERNATIVE", NumArgs: 2, Precedence: 42, Handler: alternativeOperator}

var equalsOpType = &operationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: equalsOperator}
var notEqualsOpType = &operationType{Type: "NOT_EQUALS", NumArgs: 2, Precedence: 40, Handler: notEqualsOperator}

var compareOpType = &operationType{Type: "COMPARE", NumArgs: 2, Precedence: 40, Handler: compareOperator}
var minOpType = &operationType{Type: "MIN", NumArgs: 0, Precedence: 40, Handler: minOperator}
var maxOpType = &operationType{Type: "MAX", NumArgs: 0, Precedence: 40, Handler: maxOperator}

// createmap needs to be above union, as we use union to build the components of the objects
var createMapOpType = &operationType{Type: "CREATE_MAP", NumArgs: 2, Precedence: 15, Handler: createMapOperator}

var shortPipeOpType = &operationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence: 45, Handler: pipeOperator}

var lengthOpType = &operationType{Type: "LENGTH", NumArgs: 0, Precedence: 50, Handler: lengthOperator}
var lineOpType = &operationType{Type: "LINE", NumArgs: 0, Precedence: 50, Handler: lineOperator}
var columnOpType = &operationType{Type: "LINE", NumArgs: 0, Precedence: 50, Handler: columnOperator}

// Use this expression to create alias/syntactic sugar expressions (in lexer_participle).
var expressionOpType = &operationType{Type: "EXP", NumArgs: 0, Precedence: 50, Handler: expressionOperator}

var collectOpType = &operationType{Type: "COLLECT", NumArgs: 1, Precedence: 50, Handler: collectOperator}
var mapOpType = &operationType{Type: "MAP", NumArgs: 1, Precedence: 52, Handler: mapOperator, CheckForPostTraverse: true}
var filterOpType = &operationType{Type: "FILTER", NumArgs: 1, Precedence: 52, Handler: filterOperator, CheckForPostTraverse: true}
var errorOpType = &operationType{Type: "ERROR", NumArgs: 1, Precedence: 50, Handler: errorOperator}
var pickOpType = &operationType{Type: "PICK", NumArgs: 1, Precedence: 52, Handler: pickOperator, CheckForPostTraverse: true}
var omitOpType = &operationType{Type: "OMIT", NumArgs: 1, Precedence: 52, Handler: omitOperator, CheckForPostTraverse: true}
var evalOpType = &operationType{Type: "EVAL", NumArgs: 1, Precedence: 52, Handler: evalOperator, CheckForPostTraverse: true}
var mapValuesOpType = &operationType{Type: "MAP_VALUES", NumArgs: 1, Precedence: 52, Handler: mapValuesOperator, CheckForPostTraverse: true}

var formatDateTimeOpType = &operationType{Type: "FORMAT_DATE_TIME", NumArgs: 1, Precedence: 50, Handler: formatDateTime}
var withDtFormatOpType = &operationType{Type: "WITH_DATE_TIME_FORMAT", NumArgs: 1, Precedence: 50, Handler: withDateTimeFormat}
var nowOpType = &operationType{Type: "NOW", NumArgs: 0, Precedence: 50, Handler: nowOp}
var tzOpType = &operationType{Type: "TIMEZONE", NumArgs: 1, Precedence: 50, Handler: tzOp}
var fromUnixOpType = &operationType{Type: "FROM_UNIX", NumArgs: 0, Precedence: 50, Handler: fromUnixOp}
var toUnixOpType = &operationType{Type: "TO_UNIX", NumArgs: 0, Precedence: 50, Handler: toUnixOp}

var encodeOpType = &operationType{Type: "ENCODE", NumArgs: 0, Precedence: 50, Handler: encodeOperator}
var decodeOpType = &operationType{Type: "DECODE", NumArgs: 0, Precedence: 50, Handler: decodeOperator}

var anyOpType = &operationType{Type: "ANY", NumArgs: 0, Precedence: 50, Handler: anyOperator}
var allOpType = &operationType{Type: "ALL", NumArgs: 0, Precedence: 50, Handler: allOperator}
var containsOpType = &operationType{Type: "CONTAINS", NumArgs: 1, Precedence: 50, Handler: containsOperator}
var anyConditionOpType = &operationType{Type: "ANY_CONDITION", NumArgs: 1, Precedence: 50, Handler: anyOperator}
var allConditionOpType = &operationType{Type: "ALL_CONDITION", NumArgs: 1, Precedence: 50, Handler: allOperator}

var toEntriesOpType = &operationType{Type: "TO_ENTRIES", NumArgs: 0, Precedence: 52, Handler: toEntriesOperator, CheckForPostTraverse: true}
var fromEntriesOpType = &operationType{Type: "FROM_ENTRIES", NumArgs: 0, Precedence: 50, Handler: fromEntriesOperator}
var withEntriesOpType = &operationType{Type: "WITH_ENTRIES", NumArgs: 1, Precedence: 50, Handler: withEntriesOperator}

var withOpType = &operationType{Type: "WITH", NumArgs: 1, Precedence: 52, Handler: withOperator, CheckForPostTraverse: true}

var splitDocumentOpType = &operationType{Type: "SPLIT_DOC", NumArgs: 0, Precedence: 52, Handler: splitDocumentOperator, CheckForPostTraverse: true}
var getVariableOpType = &operationType{Type: "GET_VARIABLE", NumArgs: 0, Precedence: 55, Handler: getVariableOperator}
var getStyleOpType = &operationType{Type: "GET_STYLE", NumArgs: 0, Precedence: 50, Handler: getStyleOperator}
var getTagOpType = &operationType{Type: "GET_TAG", NumArgs: 0, Precedence: 50, Handler: getTagOperator}
var getKindOpType = &operationType{Type: "GET_KIND", NumArgs: 0, Precedence: 50, Handler: getKindOperator}

var getKeyOpType = &operationType{Type: "GET_KEY", NumArgs: 0, Precedence: 50, Handler: getKeyOperator}
var isKeyOpType = &operationType{Type: "IS_KEY", NumArgs: 0, Precedence: 50, Handler: isKeyOperator}
var getParentOpType = &operationType{Type: "GET_PARENT", NumArgs: 0, Precedence: 50, Handler: getParentOperator}
var getParentsOpType = &operationType{Type: "GET_PARENTS", NumArgs: 0, Precedence: 50, Handler: getParentsOperator}

var getCommentOpType = &operationType{Type: "GET_COMMENT", NumArgs: 0, Precedence: 50, Handler: getCommentsOperator}
var getAnchorOpType = &operationType{Type: "GET_ANCHOR", NumArgs: 0, Precedence: 50, Handler: getAnchorOperator}
var getAliasOpType = &operationType{Type: "GET_ALIAS", NumArgs: 0, Precedence: 50, Handler: getAliasOperator}
var getDocumentIndexOpType = &operationType{Type: "GET_DOCUMENT_INDEX", NumArgs: 0, Precedence: 50, Handler: getDocumentIndexOperator}
var getFilenameOpType = &operationType{Type: "GET_FILENAME", NumArgs: 0, Precedence: 50, Handler: getFilenameOperator}
var getFileIndexOpType = &operationType{Type: "GET_FILE_INDEX", NumArgs: 0, Precedence: 50, Handler: getFileIndexOperator}

var getPathOpType = &operationType{Type: "GET_PATH", NumArgs: 0, Precedence: 52, Handler: getPathOperator, CheckForPostTraverse: true}
var setPathOpType = &operationType{Type: "SET_PATH", NumArgs: 1, Precedence: 50, Handler: setPathOperator}
var delPathsOpType = &operationType{Type: "DEL_PATHS", NumArgs: 1, Precedence: 52, Handler: delPathsOperator, CheckForPostTraverse: true}

var explodeOpType = &operationType{Type: "EXPLODE", NumArgs: 1, Precedence: 52, Handler: explodeOperator, CheckForPostTraverse: true}
var sortByOpType = &operationType{Type: "SORT_BY", NumArgs: 1, Precedence: 52, Handler: sortByOperator, CheckForPostTraverse: true}
var firstOpType = &operationType{Type: "FIRST", NumArgs: 1, Precedence: 52, Handler: firstOperator, CheckForPostTraverse: true}
var reverseOpType = &operationType{Type: "REVERSE", NumArgs: 0, Precedence: 52, Handler: reverseOperator, CheckForPostTraverse: true}
var sortOpType = &operationType{Type: "SORT", NumArgs: 0, Precedence: 52, Handler: sortOperator, CheckForPostTraverse: true}
var shuffleOpType = &operationType{Type: "SHUFFLE", NumArgs: 0, Precedence: 52, Handler: shuffleOperator, CheckForPostTraverse: true}

var sortKeysOpType = &operationType{Type: "SORT_KEYS", NumArgs: 1, Precedence: 52, Handler: sortKeysOperator, CheckForPostTraverse: true}

var joinStringOpType = &operationType{Type: "JOIN", NumArgs: 1, Precedence: 50, Handler: joinStringOperator}
var subStringOpType = &operationType{Type: "SUBSTR", NumArgs: 1, Precedence: 50, Handler: substituteStringOperator}
var matchOpType = &operationType{Type: "MATCH", NumArgs: 1, Precedence: 50, Handler: matchOperator}
var captureOpType = &operationType{Type: "CAPTURE", NumArgs: 1, Precedence: 50, Handler: captureOperator}
var testOpType = &operationType{Type: "TEST", NumArgs: 1, Precedence: 50, Handler: testOperator}
var splitStringOpType = &operationType{Type: "SPLIT", NumArgs: 1, Precedence: 52, Handler: splitStringOperator, CheckForPostTraverse: true}
var changeCaseOpType = &operationType{Type: "CHANGE_CASE", NumArgs: 0, Precedence: 50, Handler: changeCaseOperator}
var trimOpType = &operationType{Type: "TRIM", NumArgs: 0, Precedence: 50, Handler: trimSpaceOperator}
var toStringOpType = &operationType{Type: "TO_STRING", NumArgs: 0, Precedence: 50, Handler: toStringOperator}
var stringInterpolationOpType = &operationType{Type: "STRING_INT", NumArgs: 0, Precedence: 50, Handler: stringInterpolationOperator, ToString: valueToStringFunc}

var loadOpType = &operationType{Type: "LOAD", NumArgs: 1, Precedence: 52, Handler: loadOperator, CheckForPostTraverse: true}
var loadStringOpType = &operationType{Type: "LOAD_STRING", NumArgs: 1, Precedence: 52, Handler: loadStringOperator}

var keysOpType = &operationType{Type: "KEYS", NumArgs: 0, Precedence: 52, Handler: keysOperator, CheckForPostTraverse: true}

var collectObjectOpType = &operationType{Type: "COLLECT_OBJECT", NumArgs: 0, Precedence: 50, Handler: collectObjectOperator}

var traversePathOpType = &operationType{Type: "TRAVERSE_PATH", NumArgs: 0, Precedence: 55, Handler: traversePathOperator,
        ToString: func(p *Operation) string {
                return fmt.Sprintf("%v", p.Value)
        }}

var traverseArrayOpType = &operationType{Type: "TRAVERSE_ARRAY", NumArgs: 2, Precedence: 50, Handler: traverseArrayOperator}

var selfReferenceOpType = &operationType{Type: "SELF", NumArgs: 0, Precedence: 55, Handler: selfOperator}
var valueOpType = &operationType{Type: "VALUE", NumArgs: 0, Precedence: 50, Handler: valueOperator, ToString: valueToStringFunc}
var referenceOpType = &operationType{Type: "REF", NumArgs: 0, Precedence: 50, Handler: referenceOperator}
var envOpType = &operationType{Type: "ENV", NumArgs: 0, Precedence: 52, Handler: envOperator, CheckForPostTraverse: true}
var notOpType = &operationType{Type: "NOT", NumArgs: 0, Precedence: 50, Handler: notOperator}
var toNumberOpType = &operationType{Type: "TO_NUMBER", NumArgs: 0, Precedence: 50, Handler: toNumberOperator}
var emptyOpType = &operationType{Type: "EMPTY", Precedence: 50, Handler: emptyOperator}

var envsubstOpType = &operationType{Type: "ENVSUBST", NumArgs: 0, Precedence: 50, Handler: envsubstOperator}

var recursiveDescentOpType = &operationType{Type: "RECURSIVE_DESCENT", NumArgs: 0, Precedence: 50, Handler: recursiveDescentOperator}

var selectOpType = &operationType{Type: "SELECT", NumArgs: 1, Precedence: 52, Handler: selectOperator, CheckForPostTraverse: true}
var hasOpType = &operationType{Type: "HAS", NumArgs: 1, Precedence: 50, Handler: hasOperator}
var uniqueOpType = &operationType{Type: "UNIQUE", NumArgs: 0, Precedence: 52, Handler: unique, CheckForPostTraverse: true}
var uniqueByOpType = &operationType{Type: "UNIQUE_BY", NumArgs: 1, Precedence: 52, Handler: uniqueBy, CheckForPostTraverse: true}
var groupByOpType = &operationType{Type: "GROUP_BY", NumArgs: 1, Precedence: 52, Handler: groupBy, CheckForPostTraverse: true}
var flattenOpType = &operationType{Type: "FLATTEN_BY", NumArgs: 0, Precedence: 52, Handler: flattenOp, CheckForPostTraverse: true}
var deleteChildOpType = &operationType{Type: "DELETE", NumArgs: 1, Precedence: 40, Handler: deleteChildOperator}

var pivotOpType = &operationType{Type: "PIVOT", NumArgs: 0, Precedence: 52, Handler: pivotOperator, CheckForPostTraverse: true}

// debugging purposes only
func (p *Operation) toString() string {
        if p == nil {
                return "OP IS NIL"
        }
        if p.OperationType.ToString != nil {
                return p.OperationType.ToString(p)
        }
        return fmt.Sprintf("%v", p.OperationType.Type)
}

package yqlib

import (
        "fmt"
        "strconv"
        "strings"
        "time"
)

func createAddOp(lhs *ExpressionNode, rhs *ExpressionNode) *ExpressionNode {
        return &ExpressionNode{Operation: &Operation{OperationType: addOpType},
                LHS: lhs,
                RHS: rhs}
}

func addAssignOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        return compoundAssignFunction(d, context, expressionNode, createAddOp)
}

func toNodes(candidate *CandidateNode, lhs *CandidateNode) []*CandidateNode {
        if candidate.Tag == "!!null" {
                return []*CandidateNode{}
        }

        clone := candidate.Copy()

        switch candidate.Kind {
        case SequenceNode:
                return clone.Content
        default:
                if len(lhs.Content) > 0 {
                        clone.Style = lhs.Content[0].Style
                }
                return []*CandidateNode{clone}
        }

}

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, calcWhenEmpty)
}

func add(_ *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        lhsNode := lhs

        if lhs == nil && rhs == nil {
                return nil, nil
        } else if lhs == nil {
                return rhs.Copy(), nil
        } else if rhs == nil {
                return lhs.Copy(), nil
        } else if lhsNode.Tag == "!!null" {
                return lhs.CopyAsReplacement(rhs), nil
        }

        target := lhs.CopyWithoutContent()

        switch lhsNode.Kind {
        case MappingNode:
                if rhs.Kind != MappingNode {
                        return nil, fmt.Errorf("%v (%v) cannot be added to a %v (%v)", rhs.Tag, rhs.GetNicePath(), lhsNode.Tag, lhs.GetNicePath())
                }
                addMaps(target, lhs, rhs)
        case SequenceNode:
                addSequences(target, lhs, rhs)
        case ScalarNode:
                if rhs.Kind != ScalarNode {
                        return nil, fmt.Errorf("%v (%v) cannot be added to a %v (%v)", rhs.Tag, rhs.GetNicePath(), lhsNode.Tag, lhs.GetNicePath())
                }
                target.Kind = ScalarNode
                target.Style = lhsNode.Style
                if err := addScalars(context, target, lhsNode, rhs); err != nil {
                        return nil, err
                }
        }
        return target, nil
}

func addScalars(context Context, target *CandidateNode, lhs *CandidateNode, rhs *CandidateNode) error {
        lhsTag := lhs.Tag
        rhsTag := rhs.guessTagFromCustomType()
        lhsIsCustom := false
        if !strings.HasPrefix(lhsTag, "!!") {
                // custom tag - we have to have a guess
                lhsTag = lhs.guessTagFromCustomType()
                lhsIsCustom = true
        }

        isDateTime := lhs.Tag == "!!timestamp"

        // if the lhs is a string, it might be a timestamp in a custom format.
        if lhsTag == "!!str" && context.GetDateTimeLayout() != time.RFC3339 {
                _, err := parseDateTime(context.GetDateTimeLayout(), lhs.Value)
                isDateTime = err == nil
        }

        if isDateTime {
                return addDateTimes(context.GetDateTimeLayout(), target, lhs, rhs)

        } else if lhsTag == "!!str" {
                target.Tag = lhs.Tag
                if rhsTag == "!!null" {
                        target.Value = lhs.Value
                } else {
                        target.Value = lhs.Value + rhs.Value
                }

        } else if rhsTag == "!!str" {
                target.Tag = rhs.Tag
                target.Value = lhs.Value + rhs.Value
        } else if lhsTag == "!!int" && rhsTag == "!!int" {
                format, lhsNum, err := parseInt64(lhs.Value)
                if err != nil {
                        return err
                }
                _, rhsNum, err := parseInt64(rhs.Value)
                if err != nil {
                        return err
                }
                sum := lhsNum + rhsNum
                target.Tag = lhs.Tag
                target.Value = fmt.Sprintf(format, sum)
        } else if (lhsTag == "!!int" || lhsTag == "!!float") && (rhsTag == "!!int" || rhsTag == "!!float") {
                lhsNum, err := strconv.ParseFloat(lhs.Value, 64)
                if err != nil {
                        return err
                }
                rhsNum, err := strconv.ParseFloat(rhs.Value, 64)
                if err != nil {
                        return err
                }
                sum := lhsNum + rhsNum
                if lhsIsCustom {
                        target.Tag = lhs.Tag
                } else {
                        target.Tag = "!!float"
                }
                target.Value = fmt.Sprintf("%v", sum)
        } else {
                return fmt.Errorf("%v cannot be added to %v", lhsTag, rhsTag)
        }
        return nil
}

func addDateTimes(layout string, target *CandidateNode, lhs *CandidateNode, rhs *CandidateNode) error {

        duration, err := time.ParseDuration(rhs.Value)
        if err != nil {
                return fmt.Errorf("unable to parse duration [%v]: %w", rhs.Value, err)
        }

        currentTime, err := parseDateTime(layout, lhs.Value)
        if err != nil {
                return err
        }

        newTime := currentTime.Add(duration)
        target.Value = newTime.Format(layout)
        return nil

}

func addSequences(target *CandidateNode, lhs *CandidateNode, rhs *CandidateNode) {
        log.Debugf("adding sequences! target: %v; lhs %v; rhs: %v", NodeToString(target), NodeToString(lhs), NodeToString(rhs))
        target.Kind = SequenceNode
        if len(lhs.Content) == 0 {
                log.Debugf("dont copy lhs style")
                target.Style = 0
        }
        target.Tag = lhs.Tag

        extraNodes := toNodes(rhs, lhs)

        target.AddChildren(lhs.Content)
        target.AddChildren(extraNodes)
}

func addMaps(target *CandidateNode, lhsC *CandidateNode, rhsC *CandidateNode) {
        lhs := lhsC
        rhs := rhsC

        if len(lhs.Content) == 0 {
                log.Debugf("dont copy lhs style")
                target.Style = 0
        }

        target.Content = make([]*CandidateNode, 0)
        target.AddChildren(lhs.Content)

        for index := 0; index < len(rhs.Content); index = index + 2 {
                key := rhs.Content[index]
                value := rhs.Content[index+1]
                log.Debug("finding %v", key.Value)
                indexInLHS := findKeyInMap(target, key)
                log.Debug("indexInLhs %v", indexInLHS)
                if indexInLHS < 0 {
                        // not in there, append it
                        target.AddKeyValueChild(key, value)
                } else {
                        // it's there, replace it
                        oldValue := target.Content[indexInLHS+1]
                        newValueCopy := oldValue.CopyAsReplacement(value)
                        target.Content[indexInLHS+1] = newValueCopy
                }
        }
        target.Kind = MappingNode
        if len(lhs.Content) > 0 {
                target.Style = lhs.Style
        }
        target.Tag = lhs.Tag
}

package yqlib

func alternativeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("alternative")
        prefs := crossFunctionPreferences{
                CalcWhenEmpty: true,
                Calculation:   alternativeFunc,
                LhsResultValue: func(lhs *CandidateNode) (*CandidateNode, error) {
                        if lhs == nil {
                                return nil, nil
                        }
                        truthy := isTruthyNode(lhs)
                        if truthy {
                                return lhs, nil
                        }
                        return nil, nil
                },
        }
        return crossFunctionWithPrefs(d, context, expressionNode, prefs)
}

func alternativeFunc(_ *dataTreeNavigator, _ Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        if lhs == nil {
                return rhs, nil
        }
        if rhs == nil {
                return lhs, nil
        }

        isTrue := isTruthyNode(lhs)
        if isTrue {
                return lhs, nil
        }
        return rhs, nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

var showMergeAnchorToSpecWarning = true

func assignAliasOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("AssignAlias operator!")

        aliasName := ""
        if !expressionNode.Operation.UpdateAssign {
                rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }
                if rhs.MatchingNodes.Front() != nil {
                        aliasName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
                }
        }

        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)

        if err != nil {
                return Context{}, err
        }

        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                log.Debugf("Setting aliasName : %v", candidate.GetKey())

                if expressionNode.Operation.UpdateAssign {
                        rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)
                        if err != nil {
                                return Context{}, err
                        }
                        if rhs.MatchingNodes.Front() != nil {
                                aliasName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
                        }
                }

                if aliasName != "" {
                        candidate.Kind = AliasNode
                        candidate.Value = aliasName
                }
        }
        return context, nil
}

func getAliasOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("GetAlias operator!")
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                result := candidate.CreateReplacement(ScalarNode, "!!str", candidate.Value)
                results.PushBack(result)
        }
        return context.ChildContext(results), nil
}

func assignAnchorOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("AssignAnchor operator!")

        anchorName := ""
        if !expressionNode.Operation.UpdateAssign {
                rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }

                if rhs.MatchingNodes.Front() != nil {
                        anchorName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
                }
        }

        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)

        if err != nil {
                return Context{}, err
        }

        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                log.Debugf("Setting anchorName of : %v", candidate.GetKey())

                if expressionNode.Operation.UpdateAssign {
                        rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)
                        if err != nil {
                                return Context{}, err
                        }

                        if rhs.MatchingNodes.Front() != nil {
                                anchorName = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
                        }
                }

                candidate.Anchor = anchorName
        }
        return context, nil
}

func getAnchorOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("GetAnchor operator!")
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                anchor := candidate.Anchor
                result := candidate.CreateReplacement(ScalarNode, "!!str", anchor)
                results.PushBack(result)
        }
        return context.ChildContext(results), nil
}

func explodeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("ExplodeOperation")

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.RHS)

                if err != nil {
                        return Context{}, err
                }
                for childEl := rhs.MatchingNodes.Front(); childEl != nil; childEl = childEl.Next() {
                        err = explodeNode(childEl.Value.(*CandidateNode), context)
                        if err != nil {
                                return Context{}, err
                        }
                }

        }

        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.Tag != "!!merge" {
                        // always add in plain nodes
                        // explode both the key and value nodes
                        if err := explodeNode(keyNode, Context{}); err != nil {
                                return err
                        }
                        if err := explodeNode(valueNode, Context{}); err != nil {
                                return err
                        }
                        newContent = append(newContent, keyNode, valueNode)
                } else {
                        sequence := valueNode
                        if sequence.Kind == AliasNode {
                                sequence = sequence.Alias
                        }
                        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("can only use merge anchors with maps (!!map) or sequences (!!seq) of maps, but got sequence containing %v", mergeNodeSeq.Tag)
                                }
                                itemsToAdd := mergeNodeSeq.FilterMapContentByKey(func(keyNode *CandidateNode) bool {
                                        return getContentValueByKey(node.Content, keyNode.Value) == nil &&
                                                getContentValueByKey(newContent, keyNode.Value) == nil
                                })

                                for _, item := range itemsToAdd {
                                        // copy to ensure exploding doesn't modify the original node
                                        itemCopy := item.Copy()
                                        if err := explodeNode(itemCopy, Context{}); err != nil {
                                                return err
                                        }
                                        newContent = append(newContent, itemCopy)
                                }
                        }
                }
        }
        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?
        // no it needs to recurse in overrideEntry.

        for index := 0; index < len(node.Content); index = index + 2 {
                keyNode := node.Content[index]
                valueNode := node.Content[index+1]
                log.Debugf("traversing %v", keyNode.Value)
                if keyNode.Value != "<<" {
                        err := overrideEntry(node, keyNode, valueNode, index, context.ChildContext(newContent))
                        if err != nil {
                                return err
                        }
                } else {
                        if valueNode.Kind == SequenceNode {
                                log.Debugf("an alias merge list!")
                                for index := len(valueNode.Content) - 1; index >= 0; index = index - 1 {
                                        aliasNode := valueNode.Content[index]
                                        err := applyAlias(node, aliasNode.Alias, index, context.ChildContext(newContent))
                                        if err != nil {
                                                return err
                                        }
                                }
                        } else {
                                log.Debugf("an alias merge!")
                                err := applyAlias(node, valueNode.Alias, index, context.ChildContext(newContent))
                                if err != nil {
                                        return err
                                }
                        }
                }
        }
        node.Content = make([]*CandidateNode, 0)
        for newEl := newContent.Front(); newEl != nil; newEl = newEl.Next() {
                node.AddChild(newEl.Value.(*CandidateNode))
        }
        return nil
}

func explodeNode(node *CandidateNode, context Context) error {
        log.Debugf("explodeNode -  %v", NodeToString(node))
        node.Anchor = ""
        switch node.Kind {
        case SequenceNode:
                for index, contentNode := range node.Content {
                        log.Debugf("explodeNode -  index %v", index)
                        errorInContent := explodeNode(contentNode, context)
                        if errorInContent != nil {
                                return errorInContent
                        }
                }
                return nil
        case AliasNode:
                log.Debugf("explodeNode - an alias to %v", NodeToString(node.Alias))
                if node.Alias != nil {
                        node.Kind = node.Alias.Kind
                        node.Style = node.Alias.Style
                        node.Tag = node.Alias.Tag
                        node.AddChildren(node.Alias.Content)
                        node.Value = node.Alias.Value
                        node.Alias = nil
                }
                log.Debug("now I'm %v", NodeToString(node))
                return nil
        case MappingNode:
                // //check the map has an alias in it
                hasAlias := false
                for index := 0; index < len(node.Content); index = index + 2 {
                        keyNode := node.Content[index]
                        if keyNode.Value == "<<" {
                                hasAlias = true
                                break
                        }
                }

                if hasAlias {
                        if ConfiguredYamlPreferences.FixMergeAnchorToSpec {
                                return fixedReconstructAliasedMap(node)
                        }
                        if showMergeAnchorToSpecWarning {
                                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.")
                                showMergeAnchorToSpecWarning = false
                        }
                        // this is a slow op, which is why we want to check before running it.
                        return reconstructAliasedMap(node, context)
                }
                // this map has no aliases, but it's kids might
                for index := 0; index < len(node.Content); index = index + 2 {
                        keyNode := node.Content[index]
                        valueNode := node.Content[index+1]
                        err := explodeNode(keyNode, context)
                        if err != nil {
                                return err
                        }
                        err = explodeNode(valueNode, context)
                        if err != nil {
                                return err
                        }
                }
                return nil
        default:
                return nil
        }
}

func applyAlias(node *CandidateNode, alias *CandidateNode, aliasIndex int, newContent Context) error {
        log.Debug("alias is nil ?")
        if alias == nil {
                return nil
        }
        log.Debug("alias: %v", NodeToString(alias))
        if alias.Kind != MappingNode {
                return fmt.Errorf("can only use merge anchors with maps (!!map) or sequences (!!seq) of maps, but got sequence containing %v", alias.Tag)
        }
        for index := 0; index < len(alias.Content); index = index + 2 {
                keyNode := alias.Content[index]
                log.Debugf("applying alias key %v", keyNode.Value)
                valueNode := alias.Content[index+1]
                err := overrideEntry(node, keyNode, valueNode, aliasIndex, newContent)
                if err != nil {
                        return err
                }
        }
        return nil
}

func overrideEntry(node *CandidateNode, key *CandidateNode, value *CandidateNode, startIndex int, newContent Context) error {

        err := explodeNode(value, newContent)

        if err != nil {
                return err
        }

        for newEl := newContent.MatchingNodes.Front(); newEl != nil; newEl = newEl.Next() {
                valueEl := newEl.Next() // move forward twice
                keyNode := newEl.Value.(*CandidateNode)
                log.Debugf("checking new content %v:%v", keyNode.Value, valueEl.Value.(*CandidateNode).Value)
                if keyNode.Value == key.Value && keyNode.Alias == nil && key.Alias == nil {
                        log.Debugf("overridign new content")
                        valueEl.Value = value
                        return nil
                }
                newEl = valueEl // move forward twice
        }

        for index := startIndex + 2; index < len(node.Content); index = index + 2 {
                keyNode := node.Content[index]

                if keyNode.Value == key.Value && keyNode.Alias == nil {
                        log.Debugf("content will be overridden at index %v", index)
                        return nil
                }
        }

        err = explodeNode(key, newContent)
        if err != nil {
                return err
        }
        log.Debugf("adding %v:%v", key.Value, value.Value)
        newContent.MatchingNodes.PushBack(key)
        newContent.MatchingNodes.PushBack(value)
        return nil
}

package yqlib

type assignPreferences struct {
        DontOverWriteAnchor bool
        OnlyWriteNull       bool
        ClobberCustomTags   bool
}

func assignUpdateFunc(prefs assignPreferences) crossFunctionCalculation {
        return func(_ *dataTreeNavigator, _ Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
                if !prefs.OnlyWriteNull || lhs.Tag == "!!null" {
                        lhs.UpdateFrom(rhs, prefs)
                }
                return lhs, nil
        }
}

// they way *= (multipleAssign) is handled, we set the multiplePrefs
// on the node, not assignPrefs. Long story.
func getAssignPreferences(preferences interface{}) assignPreferences {
        prefs := assignPreferences{}

        switch typedPref := preferences.(type) {
        case assignPreferences:
                prefs = typedPref
        case multiplyPreferences:
                prefs = typedPref.AssignPrefs
        }
        return prefs
}

func assignUpdateOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)
        if err != nil {
                return Context{}, err
        }

        prefs := getAssignPreferences(expressionNode.Operation.Preferences)

        log.Debug("assignUpdateOperator prefs: %v", prefs)

        if !expressionNode.Operation.UpdateAssign {
                // this works because we already ran against LHS with an editable context.
                _, err := crossFunction(d, context.ReadOnlyClone(), expressionNode, assignUpdateFunc(prefs), false)
                return context, err
        }

        //traverse backwards through the context -
        // like delete, we need to run against the children first.
        // (e.g. consider when running with expression '.. |= [.]' - we need
        // to wrap the children first
        for el := lhs.MatchingNodes.Back(); el != nil; el = el.Prev() {
                candidate := el.Value.(*CandidateNode)

                rhs, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.RHS)

                if err != nil {
                        return Context{}, err
                }

                // grab the first value
                first := rhs.MatchingNodes.Front()

                if first != nil {
                        rhsCandidate := first.Value.(*CandidateNode)
                        candidate.UpdateFrom(rhsCandidate, prefs)
                }
        }

        return context, nil
}

// does not update content or values
func assignAttributesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debug("getting lhs matching nodes for update")
        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)
        if err != nil {
                return Context{}, err
        }
        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)

                if err != nil {
                        return Context{}, err
                }

                // grab the first value
                first := rhs.MatchingNodes.Front()

                if first != nil {
                        prefs := assignPreferences{}
                        if expressionNode.Operation.Preferences != nil {
                                prefs = expressionNode.Operation.Preferences.(assignPreferences)
                        }
                        if !prefs.OnlyWriteNull || candidate.Tag == "!!null" {
                                candidate.UpdateAttributesFrom(first.Value.(*CandidateNode), prefs)
                        }
                }
        }
        return context, nil
}

package yqlib

import (
        "container/list"
        "fmt"
        "strings"
)

func isTruthyNode(node *CandidateNode) bool {
        if node == nil {
                return false
        }
        if node.Tag == "!!null" {
                return false
        }
        if node.Kind == ScalarNode && node.Tag == "!!bool" {
                // yes/y/true/on
                return (strings.EqualFold(node.Value, "y") ||
                        strings.EqualFold(node.Value, "yes") ||
                        strings.EqualFold(node.Value, "on") ||
                        strings.EqualFold(node.Value, "true"))

        }
        return true
}

func getOwner(lhs *CandidateNode, rhs *CandidateNode) *CandidateNode {
        owner := lhs

        if lhs == nil && rhs == nil {
                owner = &CandidateNode{}
        } else if lhs == nil {
                owner = rhs
        }
        return owner
}

func returnRhsTruthy(_ *dataTreeNavigator, _ Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        owner := getOwner(lhs, rhs)
        rhsBool := isTruthyNode(rhs)

        return createBooleanCandidate(owner, rhsBool), nil
}

func returnLHSWhen(targetBool bool) func(lhs *CandidateNode) (*CandidateNode, error) {
        return func(lhs *CandidateNode) (*CandidateNode, error) {
                var err error
                var lhsBool bool

                if lhsBool = isTruthyNode(lhs); lhsBool != targetBool {
                        return nil, err
                }
                owner := &CandidateNode{}
                if lhs != nil {
                        owner = lhs
                }
                return createBooleanCandidate(owner, targetBool), nil
        }
}

func findBoolean(wantBool bool, d *dataTreeNavigator, context Context, expressionNode *ExpressionNode, sequenceNode *CandidateNode) (bool, error) {
        for _, node := range sequenceNode.Content {

                if expressionNode != nil {
                        //need to evaluate the expression against the node
                        rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(node), expressionNode)
                        if err != nil {
                                return false, err
                        }
                        if rhs.MatchingNodes.Len() > 0 {
                                node = rhs.MatchingNodes.Front().Value.(*CandidateNode)
                        } else {
                                // no results found, ignore this entry
                                continue
                        }
                }

                if isTruthyNode(node) == wantBool {
                        return true, nil
                }
        }
        return false, nil
}

func allOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                if candidate.Kind != SequenceNode {
                        return Context{}, fmt.Errorf("all only supports arrays, was %v", candidate.Tag)
                }
                booleanResult, err := findBoolean(false, d, context, expressionNode.RHS, candidate)
                if err != nil {
                        return Context{}, err
                }
                result := createBooleanCandidate(candidate, !booleanResult)
                results.PushBack(result)
        }
        return context.ChildContext(results), nil
}

func anyOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                if candidate.Kind != SequenceNode {
                        return Context{}, fmt.Errorf("any only supports arrays, was %v", candidate.Tag)
                }
                booleanResult, err := findBoolean(true, d, context, expressionNode.RHS, candidate)
                if err != nil {
                        return Context{}, err
                }
                result := createBooleanCandidate(candidate, booleanResult)
                results.PushBack(result)
        }
        return context.ChildContext(results), nil
}

func orOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        prefs := crossFunctionPreferences{
                CalcWhenEmpty:  true,
                Calculation:    returnRhsTruthy,
                LhsResultValue: returnLHSWhen(true),
        }
        return crossFunctionWithPrefs(d, context.ReadOnlyClone(), expressionNode, prefs)
}

func andOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        prefs := crossFunctionPreferences{
                CalcWhenEmpty:  true,
                Calculation:    returnRhsTruthy,
                LhsResultValue: returnLHSWhen(false),
        }
        return crossFunctionWithPrefs(d, context.ReadOnlyClone(), expressionNode, prefs)
}

func notOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("notOperation")
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                log.Debug("notOperation checking %v", candidate)
                truthy := isTruthyNode(candidate)
                result := createBooleanCandidate(candidate, !truthy)
                results.PushBack(result)
        }
        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
)

func collectTogether(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (*CandidateNode, error) {
        collectedNode := &CandidateNode{Kind: SequenceNode, Tag: "!!seq"}
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                collectExpResults, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode)
                if err != nil {
                        return nil, err
                }
                for result := collectExpResults.MatchingNodes.Front(); result != nil; result = result.Next() {
                        resultC := result.Value.(*CandidateNode)
                        log.Debugf("found this: %v", NodeToString(resultC))
                        collectedNode.AddChild(resultC)
                }
        }
        return collectedNode, nil
}

func collectOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("collectOperation")

        if context.MatchingNodes.Len() == 0 {
                log.Debugf("nothing to collect")
                node := &CandidateNode{Kind: SequenceNode, Tag: "!!seq", Value: "[]"}
                return context.SingleChildContext(node), nil
        }

        var evaluateAllTogether = true
        for matchEl := context.MatchingNodes.Front(); matchEl != nil; matchEl = matchEl.Next() {
                evaluateAllTogether = evaluateAllTogether && matchEl.Value.(*CandidateNode).EvaluateTogether
                if !evaluateAllTogether {
                        break
                }
        }

        if evaluateAllTogether {
                log.Debugf("collect together")
                collectedNode, err := collectTogether(d, context, expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }
                return context.SingleChildContext(collectedNode), nil

        }

        var results = list.New()
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                collectCandidate := candidate.CreateReplacement(SequenceNode, "!!seq", "")

                log.Debugf("collect rhs: %v", expressionNode.RHS.Operation.toString())

                collectExpResults, err := d.GetMatchingNodes(context.SingleChildContext(candidate), expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }

                for result := collectExpResults.MatchingNodes.Front(); result != nil; result = result.Next() {
                        resultC := result.Value.(*CandidateNode)
                        log.Debugf("found this: %v", NodeToString(resultC))
                        collectCandidate.AddChild(resultC)
                }
                log.Debugf("done collect rhs: %v", expressionNode.RHS.Operation.toString())

                results.PushBack(collectCandidate)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

/*
[Mike: cat, Bob: dog]
[Thing: rabbit, peter: sam]

==> cross multiply

{Mike: cat, Thing: rabbit}
{Mike: cat, peter: sam}
...
*/

func collectObjectOperator(d *dataTreeNavigator, originalContext Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("collectObjectOperation")

        context := originalContext.WritableClone()

        if context.MatchingNodes.Len() == 0 {
                candidate := &CandidateNode{Kind: MappingNode, Tag: "!!map", Value: "{}"}
                log.Debugf("collectObjectOperation - starting with empty map")
                return context.SingleChildContext(candidate), nil
        }
        first := context.MatchingNodes.Front().Value.(*CandidateNode)
        var rotated = make([]*list.List, len(first.Content))

        for i := 0; i < len(first.Content); i++ {
                rotated[i] = list.New()
        }

        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]))
                        log.Debugf("children:\n%v", NodeContentToString(candidateNode.Content[i], 0))
                        rotated[i].PushBack(candidateNode.Content[i])
                }
        }
        log.Debugf("collectObjectOperation, length of rotated is %v", len(rotated))

        newObject := list.New()
        for i := 0; i < len(first.Content); i++ {
                additions, err := collect(d, context.ChildContext(list.New()), rotated[i])
                if err != nil {
                        return Context{}, err
                }
                // we should reset the parents and keys of these top level nodes,
                // as they are new
                for el := additions.MatchingNodes.Front(); el != nil; el = el.Next() {
                        addition := el.Value.(*CandidateNode)
                        additionCopy := addition.Copy()

                        additionCopy.SetParent(nil)
                        additionCopy.Key = nil

                        log.Debugf("collectObjectOperation, adding result %v", NodeToString(additionCopy))

                        newObject.PushBack(additionCopy)
                }
        }

        return context.ChildContext(newObject), nil

}

func collect(d *dataTreeNavigator, context Context, remainingMatches *list.List) (Context, error) {
        if remainingMatches.Len() == 0 {
                return context, nil
        }

        candidate := remainingMatches.Remove(remainingMatches.Front()).(*CandidateNode)
        log.Debugf("collectObjectOperation - collect %v", NodeToString(candidate))

        splatted, err := splat(context.SingleChildContext(candidate),
                traversePreferences{DontFollowAlias: true, IncludeMapKeys: false})

        if err != nil {
                return Context{}, err
        }

        if context.MatchingNodes.Len() == 0 {
                log.Debugf("collectObjectOperation - collect context is empty, next")
                return collect(d, splatted, remainingMatches)
        }

        newAgg := list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                aggCandidate := el.Value.(*CandidateNode)
                for splatEl := splatted.MatchingNodes.Front(); splatEl != nil; splatEl = splatEl.Next() {
                        splatCandidate := splatEl.Value.(*CandidateNode)
                        log.Debugf("collectObjectOperation; splatCandidate: %v", NodeToString(splatCandidate))
                        newCandidate := aggCandidate.Copy()
                        log.Debugf("collectObjectOperation; aggCandidate: %v", NodeToString(aggCandidate))

                        newCandidate, err = multiply(multiplyPreferences{AppendArrays: false})(d, context, newCandidate, splatCandidate)

                        if err != nil {
                                return Context{}, err
                        }
                        newAgg.PushBack(newCandidate)
                }
        }
        return collect(d, context.ChildContext(newAgg), remainingMatches)

}

package yqlib

import (
        "container/list"
        "fmt"
)

func columnOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("columnOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                result := candidate.CreateReplacement(ScalarNode, "!!int", fmt.Sprintf("%v", candidate.Column))
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "bufio"
        "bytes"
        "container/list"
        "regexp"
)

type commentOpPreferences struct {
        LineComment bool
        HeadComment bool
        FootComment bool
}

func assignCommentsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("AssignComments operator!")

        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)

        if err != nil {
                return Context{}, err
        }

        preferences := expressionNode.Operation.Preferences.(commentOpPreferences)

        comment := ""
        if !expressionNode.Operation.UpdateAssign {
                rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }

                if rhs.MatchingNodes.Front() != nil {
                        comment = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
                }
        }

        log.Debugf("AssignComments comment is %v", comment)

        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                log.Debugf("AssignComments lhs %v", NodeToString(candidate))

                if expressionNode.Operation.UpdateAssign {
                        rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)
                        if err != nil {
                                return Context{}, err
                        }

                        if rhs.MatchingNodes.Front() != nil {
                                comment = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
                        }
                }

                log.Debugf("Setting comment of : %v", candidate.GetKey())
                if preferences.LineComment {
                        log.Debugf("Setting line comment of : %v to %v", candidate.GetKey(), comment)
                        candidate.LineComment = comment
                }
                if preferences.HeadComment {
                        candidate.HeadComment = comment
                        candidate.LeadingContent = "" // clobber the leading content, if there was any.
                }
                if preferences.FootComment {
                        candidate.FootComment = comment
                }

        }
        return context, nil
}

func getCommentsOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        preferences := expressionNode.Operation.Preferences.(commentOpPreferences)
        var startCommentCharacterRegExp = regexp.MustCompile(`^# `)
        var subsequentCommentCharacterRegExp = regexp.MustCompile(`\n# `)

        log.Debugf("GetComments operator!")
        var results = list.New()

        yamlPrefs := ConfiguredYamlPreferences.Copy()
        yamlPrefs.PrintDocSeparators = false
        yamlPrefs.UnwrapScalar = false
        yamlPrefs.ColorsEnabled = false

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                comment := ""
                if preferences.LineComment {
                        log.Debugf("Reading line comment of : %v to %v", candidate.GetKey(), candidate.LineComment)
                        comment = candidate.LineComment
                } else if preferences.HeadComment && candidate.LeadingContent != "" {
                        var chompRegexp = regexp.MustCompile(`\n$`)
                        var output bytes.Buffer
                        var writer = bufio.NewWriter(&output)
                        var encoder = NewYamlEncoder(yamlPrefs)
                        if err := encoder.PrintLeadingContent(writer, candidate.LeadingContent); err != nil {
                                return Context{}, err
                        }
                        if err := writer.Flush(); err != nil {
                                return Context{}, err
                        }
                        comment = output.String()
                        comment = chompRegexp.ReplaceAllString(comment, "")
                } else if preferences.HeadComment {
                        comment = candidate.HeadComment
                } else if preferences.FootComment {
                        comment = candidate.FootComment
                }
                comment = startCommentCharacterRegExp.ReplaceAllString(comment, "")
                comment = subsequentCommentCharacterRegExp.ReplaceAllString(comment, "\n")

                result := candidate.CreateReplacement(ScalarNode, "!!str", comment)
                if candidate.IsMapKey {
                        result.IsMapKey = false
                        result.Key = candidate
                }
                results.PushBack(result)
        }
        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
        "strconv"
)

type compareTypePref struct {
        OrEqual bool
        Greater bool
}

func compareOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("compareOperator")
        prefs := expressionNode.Operation.Preferences.(compareTypePref)
        return crossFunction(d, context, expressionNode, compare(prefs), true)
}

func compare(prefs compareTypePref) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        return func(_ *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
                log.Debugf("compare cross function")
                if lhs == nil && rhs == nil {
                        owner := &CandidateNode{}
                        return createBooleanCandidate(owner, prefs.OrEqual), nil
                } else if lhs == nil {
                        log.Debugf("lhs nil, but rhs is not")
                        return createBooleanCandidate(rhs, false), nil
                } else if rhs == nil {
                        log.Debugf("rhs nil, but rhs is not")
                        return createBooleanCandidate(lhs, false), nil
                }

                switch lhs.Kind {
                case MappingNode:
                        return nil, fmt.Errorf("maps not yet supported for comparison")
                case SequenceNode:
                        return nil, fmt.Errorf("arrays not yet supported for comparison")
                default:
                        if rhs.Kind != ScalarNode {
                                return nil, fmt.Errorf("%v (%v) cannot be subtracted from %v", rhs.Tag, rhs.GetNicePath(), lhs.Tag)
                        }
                        target := lhs.CopyWithoutContent()
                        boolV, err := compareScalars(context, prefs, lhs, rhs)

                        return createBooleanCandidate(target, boolV), err
                }
        }
}

func compareDateTime(layout string, prefs compareTypePref, lhs *CandidateNode, rhs *CandidateNode) (bool, error) {
        lhsTime, err := parseDateTime(layout, lhs.Value)
        if err != nil {
                return false, err
        }

        rhsTime, err := parseDateTime(layout, rhs.Value)
        if err != nil {
                return false, err
        }

        if prefs.OrEqual && lhsTime.Equal(rhsTime) {
                return true, nil
        }
        if prefs.Greater {
                return lhsTime.After(rhsTime), nil
        }
        return lhsTime.Before(rhsTime), nil

}

func compareScalars(context Context, prefs compareTypePref, lhs *CandidateNode, rhs *CandidateNode) (bool, error) {
        lhsTag := lhs.guessTagFromCustomType()
        rhsTag := rhs.guessTagFromCustomType()

        isDateTime := lhs.Tag == "!!timestamp"
        // if the lhs is a string, it might be a timestamp in a custom format.
        if lhsTag == "!!str" {
                _, err := parseDateTime(context.GetDateTimeLayout(), lhs.Value)
                isDateTime = err == nil
        }
        if isDateTime {
                return compareDateTime(context.GetDateTimeLayout(), prefs, lhs, rhs)
        } else if lhsTag == "!!int" && rhsTag == "!!int" {
                _, lhsNum, err := parseInt64(lhs.Value)
                if err != nil {
                        return false, err
                }
                _, rhsNum, err := parseInt64(rhs.Value)
                if err != nil {
                        return false, err
                }

                if prefs.OrEqual && lhsNum == rhsNum {
                        return true, nil
                }
                if prefs.Greater {
                        return lhsNum > rhsNum, nil
                }
                return lhsNum < rhsNum, nil
        } else if (lhsTag == "!!int" || lhsTag == "!!float") && (rhsTag == "!!int" || rhsTag == "!!float") {
                lhsNum, err := strconv.ParseFloat(lhs.Value, 64)
                if err != nil {
                        return false, err
                }
                rhsNum, err := strconv.ParseFloat(rhs.Value, 64)
                if err != nil {
                        return false, err
                }
                if prefs.OrEqual && lhsNum == rhsNum {
                        return true, nil
                }
                if prefs.Greater {
                        return lhsNum > rhsNum, nil
                }
                return lhsNum < rhsNum, nil
        } else if lhsTag == "!!str" && rhsTag == "!!str" {
                if prefs.OrEqual && lhs.Value == rhs.Value {
                        return true, nil
                }
                if prefs.Greater {
                        return lhs.Value > rhs.Value, nil
                }
                return lhs.Value < rhs.Value, nil
        } else if lhsTag == "!!null" && rhsTag == "!!null" && prefs.OrEqual {
                return true, nil
        } else if lhsTag == "!!null" || rhsTag == "!!null" {
                return false, nil
        }

        return false, fmt.Errorf("%v not yet supported for comparison", lhs.Tag)
}

func superlativeByComparison(d *dataTreeNavigator, context Context, prefs compareTypePref) (Context, error) {
        fn := compare(prefs)

        var results = list.New()

        for seq := context.MatchingNodes.Front(); seq != nil; seq = seq.Next() {
                splatted, err := splat(context.SingleChildContext(seq.Value.(*CandidateNode)), traversePreferences{})
                if err != nil {
                        return Context{}, err
                }
                result := splatted.MatchingNodes.Front()
                if result != nil {
                        for el := result.Next(); el != nil; el = el.Next() {
                                cmp, err := fn(d, context, el.Value.(*CandidateNode), result.Value.(*CandidateNode))
                                if err != nil {
                                        return Context{}, err
                                }
                                if isTruthyNode(cmp) {
                                        result = el
                                }
                        }
                        results.PushBack(result.Value)
                }
        }
        return context.ChildContext(results), nil
}

func minOperator(d *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debug(("Min"))
        return superlativeByComparison(d, context, compareTypePref{Greater: false})
}

func maxOperator(d *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debug(("Max"))
        return superlativeByComparison(d, context, compareTypePref{Greater: true})
}

package yqlib

import (
        "fmt"
        "strings"
)

func containsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        return crossFunction(d, context.ReadOnlyClone(), expressionNode, containsWithNodes, false)
}

func containsArrayElement(array *CandidateNode, item *CandidateNode) (bool, error) {
        for index := 0; index < len(array.Content); index = index + 1 {
                containedInArray, err := contains(array.Content[index], item)
                if err != nil {
                        return false, err
                }
                if containedInArray {
                        return true, nil
                }
        }
        return false, nil
}

func containsArray(lhs *CandidateNode, rhs *CandidateNode) (bool, error) {
        if rhs.Kind != SequenceNode {
                return containsArrayElement(lhs, rhs)
        }
        for index := 0; index < len(rhs.Content); index = index + 1 {
                itemInArray, err := containsArrayElement(lhs, rhs.Content[index])
                if err != nil {
                        return false, err
                }
                if !itemInArray {
                        return false, nil
                }
        }
        return true, nil
}

func containsObject(lhs *CandidateNode, rhs *CandidateNode) (bool, error) {
        if rhs.Kind != MappingNode {
                return false, nil
        }
        for index := 0; index < len(rhs.Content); index = index + 2 {
                rhsKey := rhs.Content[index]
                rhsValue := rhs.Content[index+1]
                log.Debugf("Looking for %v in the lhs", rhsKey.Value)
                lhsKeyIndex := findInArray(lhs, rhsKey)
                log.Debugf("index is %v", lhsKeyIndex)
                if lhsKeyIndex < 0 || lhsKeyIndex%2 != 0 {
                        return false, nil
                }
                lhsValue := lhs.Content[lhsKeyIndex+1]
                log.Debugf("lhsValue is %v", lhsValue.Value)

                itemInArray, err := contains(lhsValue, rhsValue)
                log.Debugf("rhsValue is %v", rhsValue.Value)
                if err != nil {
                        return false, err
                }
                if !itemInArray {
                        return false, nil
                }
        }
        return true, nil
}

func containsScalars(lhs *CandidateNode, rhs *CandidateNode) (bool, error) {
        if lhs.Tag == "!!str" {
                return strings.Contains(lhs.Value, rhs.Value), nil
        }
        return lhs.Value == rhs.Value, nil
}

func contains(lhs *CandidateNode, rhs *CandidateNode) (bool, error) {
        switch lhs.Kind {
        case MappingNode:
                return containsObject(lhs, rhs)
        case SequenceNode:
                return containsArray(lhs, rhs)
        case ScalarNode:
                if rhs.Kind != ScalarNode || lhs.Tag != rhs.Tag {
                        return false, nil
                }
                if lhs.Tag == "!!null" {
                        return rhs.Tag == "!!null", nil
                }
                return containsScalars(lhs, rhs)
        }

        return false, fmt.Errorf("%v not yet supported for contains", lhs.Tag)
}

func containsWithNodes(_ *dataTreeNavigator, _ Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        if lhs.Kind != rhs.Kind {
                return nil, fmt.Errorf("%v cannot check contained in %v", rhs.Tag, lhs.Tag)
        }

        result, err := contains(lhs, rhs)
        if err != nil {
                return nil, err
        }

        return createBooleanCandidate(lhs, result), nil
}

package yqlib

import (
        "container/list"
)

func createMapOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("createMapOperation")

        //each matchingNodes entry should turn into a sequence of keys to create.
        //then collect object should do a cross function of the same index sequence for all matches.

        sequences := list.New()

        if context.MatchingNodes.Len() > 0 {

                for matchingNodeEl := context.MatchingNodes.Front(); matchingNodeEl != nil; matchingNodeEl = matchingNodeEl.Next() {
                        matchingNode := matchingNodeEl.Value.(*CandidateNode)
                        sequenceNode, err := sequenceFor(d, context, matchingNode, expressionNode)
                        if err != nil {
                                return Context{}, err
                        }
                        sequences.PushBack(sequenceNode)
                }
        } else {
                sequenceNode, err := sequenceFor(d, context, nil, expressionNode)
                if err != nil {
                        return Context{}, err
                }
                sequences.PushBack(sequenceNode)
        }

        node := listToNodeSeq(sequences)

        return context.SingleChildContext(node), nil

}

func sequenceFor(d *dataTreeNavigator, context Context, matchingNode *CandidateNode, expressionNode *ExpressionNode) (*CandidateNode, error) {
        var document uint
        var filename string
        var fileIndex int

        var matches = list.New()

        if matchingNode != nil {
                document = matchingNode.GetDocument()
                filename = matchingNode.GetFilename()
                fileIndex = matchingNode.GetFileIndex()
                matches.PushBack(matchingNode)
        }

        log.Debugf("**********sequenceFor %v", NodeToString(matchingNode))

        mapPairs, err := crossFunction(d, context.ChildContext(matches), expressionNode,
                func(_ *dataTreeNavigator, _ Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
                        node := &CandidateNode{Kind: MappingNode, Tag: "!!map"}

                        log.Debugf("**********adding key %v and value %v", NodeToString(lhs), NodeToString(rhs))

                        node.AddKeyValueChild(lhs, rhs)

                        node.document = document
                        node.fileIndex = fileIndex
                        node.filename = filename

                        return node, nil
                }, false)

        if err != nil {
                return nil, err
        }
        innerList := listToNodeSeq(mapPairs.MatchingNodes)
        innerList.Style = FlowStyle
        innerList.document = document
        innerList.fileIndex = fileIndex
        innerList.filename = filename
        return innerList, nil
}

// NOTE: here the document index gets dropped so we
// no longer know where the node originates from.
func listToNodeSeq(list *list.List) *CandidateNode {
        node := CandidateNode{Kind: SequenceNode, Tag: "!!seq"}
        for entry := list.Front(); entry != nil; entry = entry.Next() {
                entryCandidate := entry.Value.(*CandidateNode)
                log.Debugf("Collecting %v into sequence", NodeToString(entryCandidate))
                node.AddChild(entryCandidate)
        }
        return &node
}

package yqlib

import (
        "container/list"
        "errors"
        "fmt"
        "strconv"
        "time"
)

func getStringParameter(parameterName string, d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (string, error) {
        result, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode)

        if err != nil {
                return "", err
        } else if result.MatchingNodes.Len() == 0 {
                return "", fmt.Errorf("could not find %v for format_time", parameterName)
        }

        return result.MatchingNodes.Front().Value.(*CandidateNode).Value, nil
}

func withDateTimeFormat(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        if expressionNode.RHS.Operation.OperationType == blockOpType || expressionNode.RHS.Operation.OperationType == unionOpType {
                layout, err := getStringParameter("layout", d, context, expressionNode.RHS.LHS)
                if err != nil {
                        return Context{}, fmt.Errorf("could not get date time format: %w", err)
                }
                context.SetDateTimeLayout(layout)
                return d.GetMatchingNodes(context, expressionNode.RHS.RHS)

        }
        return Context{}, errors.New(`must provide a date time format string and an expression, e.g. with_dtf("Monday, 02-Jan-06 at 3:04PM MST"; <exp>)`)

}

// for unit tests
var Now = time.Now

func nowOp(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {

        node := &CandidateNode{
                Tag:   "!!timestamp",
                Kind:  ScalarNode,
                Value: Now().Format(time.RFC3339),
        }

        return context.SingleChildContext(node), nil

}

func parseDateTime(layout string, datestring string) (time.Time, error) {

        parsedTime, err := time.Parse(layout, datestring)
        if err != nil && layout == time.RFC3339 {
                // try parsing the date time with only the date
                return time.Parse("2006-01-02", datestring)
        }
        return parsedTime, err

}

func formatDateTime(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        format, err := getStringParameter("format", d, context, expressionNode.RHS)
        layout := context.GetDateTimeLayout()

        if err != nil {
                return Context{}, err
        }
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                parsedTime, err := parseDateTime(layout, candidate.Value)
                if err != nil {
                        return Context{}, fmt.Errorf("could not parse datetime of [%v]: %w", candidate.GetNicePath(), err)
                }
                formattedTimeStr := parsedTime.Format(format)

                node, errorReading := parseSnippet(formattedTimeStr)
                if errorReading != nil {
                        log.Debugf("could not parse %v - lets just leave it as a string: %w", formattedTimeStr, errorReading)
                        node = &CandidateNode{
                                Kind:  ScalarNode,
                                Tag:   "!!str",
                                Value: formattedTimeStr,
                        }
                }
                node.Parent = candidate.Parent
                node.Key = candidate.Key
                results.PushBack(node)
        }

        return context.ChildContext(results), nil
}

func tzOp(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        timezoneStr, err := getStringParameter("timezone", d, context, expressionNode.RHS)
        layout := context.GetDateTimeLayout()

        if err != nil {
                return Context{}, err
        }
        var results = list.New()

        timezone, err := time.LoadLocation(timezoneStr)
        if err != nil {
                return Context{}, fmt.Errorf("could not load tz [%v]: %w", timezoneStr, err)
        }

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                parsedTime, err := parseDateTime(layout, candidate.Value)
                if err != nil {
                        return Context{}, fmt.Errorf("could not parse datetime of [%v] using layout [%v]: %w", candidate.GetNicePath(), layout, err)
                }
                tzTime := parsedTime.In(timezone)

                results.PushBack(candidate.CreateReplacement(ScalarNode, candidate.Tag, tzTime.Format(layout)))
        }

        return context.ChildContext(results), nil
}

func parseUnixTime(unixTime string) (time.Time, error) {
        seconds, err := strconv.ParseFloat(unixTime, 64)

        if err != nil {
                return time.Now(), err
        }

        return time.UnixMilli(int64(seconds * 1000)), nil
}

func fromUnixOp(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                actualTag := candidate.guessTagFromCustomType()

                if actualTag != "!!int" && actualTag != "!!float" {
                        return Context{}, fmt.Errorf("from_unix only works on numbers, found %v instead", candidate.Tag)
                }

                parsedTime, err := parseUnixTime(candidate.Value)
                if err != nil {
                        return Context{}, err
                }

                node := candidate.CreateReplacement(ScalarNode, "!!timestamp", parsedTime.Format(time.RFC3339))

                results.PushBack(node)
        }

        return context.ChildContext(results), nil
}

func toUnixOp(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {

        layout := context.GetDateTimeLayout()

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                parsedTime, err := parseDateTime(layout, candidate.Value)
                if err != nil {
                        return Context{}, fmt.Errorf("could not parse datetime of [%v] using layout [%v]: %w", candidate.GetNicePath(), layout, err)
                }

                results.PushBack(candidate.CreateReplacement(ScalarNode, "!!int", fmt.Sprintf("%v", parsedTime.Unix())))
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func deleteChildOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        nodesToDelete, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)

        if err != nil {
                return Context{}, err
        }
        //need to iterate backwards to ensure correct indices when deleting multiple
        for el := nodesToDelete.MatchingNodes.Back(); el != nil; el = el.Prev() {
                candidate := el.Value.(*CandidateNode)

                if candidate.Parent == nil {
                        // must be a top level thing, delete it
                        return removeFromContext(context, candidate)
                }
                log.Debugf("processing deletion of candidate %v", NodeToString(candidate))

                parentNode := candidate.Parent

                candidatePath := candidate.GetPath()
                childPath := candidatePath[len(candidatePath)-1]

                switch parentNode.Kind {
                case MappingNode:
                        deleteFromMap(candidate.Parent, childPath)
                case SequenceNode:
                        deleteFromArray(candidate.Parent, childPath)
                default:
                        return Context{}, fmt.Errorf("cannot delete nodes from parent of tag %v", parentNode.Tag)
                }
        }
        return context, nil
}

func removeFromContext(context Context, candidate *CandidateNode) (Context, error) {
        newResults := list.New()
        for item := context.MatchingNodes.Front(); item != nil; item = item.Next() {
                nodeInContext := item.Value.(*CandidateNode)
                if nodeInContext != candidate {
                        newResults.PushBack(nodeInContext)
                } else {
                        log.Info("Need to delete this %v", NodeToString(nodeInContext))
                }
        }
        return context.ChildContext(newResults), nil
}

func deleteFromMap(node *CandidateNode, childPath interface{}) {
        log.Debug("deleteFromMap")
        contents := node.Content
        newContents := make([]*CandidateNode, 0)

        for index := 0; index < len(contents); index = index + 2 {
                key := contents[index]
                value := contents[index+1]

                shouldDelete := key.Value == childPath

                log.Debugf("shouldDelete %v? %v == %v = %v", NodeToString(value), key.Value, childPath, shouldDelete)

                if !shouldDelete {
                        newContents = append(newContents, key, value)
                }
        }
        node.Content = newContents
}

func deleteFromArray(node *CandidateNode, childPath interface{}) {
        log.Debug("deleteFromArray")
        contents := node.Content
        newContents := make([]*CandidateNode, 0)

        for index := 0; index < len(contents); index = index + 1 {
                value := contents[index]

                shouldDelete := fmt.Sprintf("%v", index) == fmt.Sprintf("%v", childPath)

                if !shouldDelete {
                        value.Key.Value = fmt.Sprintf("%v", len(newContents))
                        newContents = append(newContents, value)
                }
        }
        node.Content = newContents
}

package yqlib

import (
        "fmt"
        "strconv"
        "strings"
)

func divideOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("Divide operator")

        return crossFunction(d, context.ReadOnlyClone(), expressionNode, divide, false)
}

func divide(_ *dataTreeNavigator, _ Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        if lhs.Tag == "!!null" {
                return nil, fmt.Errorf("%v (%v) cannot be divided by %v (%v)", lhs.Tag, lhs.GetNicePath(), rhs.Tag, rhs.GetNicePath())
        }

        target := lhs.CopyWithoutContent()

        if lhs.Kind == ScalarNode && rhs.Kind == ScalarNode {
                if err := divideScalars(target, lhs, rhs); err != nil {
                        return nil, err
                }
        } else {
                return nil, fmt.Errorf("%v (%v) cannot be divided by %v (%v)", lhs.Tag, lhs.GetNicePath(), rhs.Tag, rhs.GetNicePath())
        }

        return target, nil
}

func divideScalars(target *CandidateNode, lhs *CandidateNode, rhs *CandidateNode) error {
        lhsTag := lhs.Tag
        rhsTag := rhs.guessTagFromCustomType()
        lhsIsCustom := false
        if !strings.HasPrefix(lhsTag, "!!") {
                // custom tag - we have to have a guess
                lhsTag = lhs.guessTagFromCustomType()
                lhsIsCustom = true
        }

        if lhsTag == "!!str" && rhsTag == "!!str" {
                tKind, tTag, res := split(lhs.Value, rhs.Value)
                target.Kind = tKind
                target.Tag = tTag
                target.AddChildren(res)
        } else if (lhsTag == "!!int" || lhsTag == "!!float") && (rhsTag == "!!int" || rhsTag == "!!float") {
                target.Kind = ScalarNode
                target.Style = lhs.Style

                lhsNum, err := strconv.ParseFloat(lhs.Value, 64)
                if err != nil {
                        return err
                }
                rhsNum, err := strconv.ParseFloat(rhs.Value, 64)
                if err != nil {
                        return err
                }
                quotient := lhsNum / rhsNum
                if lhsIsCustom {
                        target.Tag = lhs.Tag
                } else {
                        target.Tag = "!!float"
                }
                target.Value = fmt.Sprintf("%v", quotient)
        } else {
                return fmt.Errorf("%v cannot be divided by %v", lhsTag, rhsTag)
        }
        return nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func getDocumentIndexOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                scalar := candidate.CreateReplacement(ScalarNode, "!!int", fmt.Sprintf("%v", candidate.GetDocument()))
                results.PushBack(scalar)
        }
        return context.ChildContext(results), nil
}

package yqlib

import (
        "bufio"
        "bytes"
        "container/list"
        "errors"
        "regexp"
        "strings"
)

func configureEncoder(format *Format, indent int) Encoder {

        switch format {
        case JSONFormat:
                prefs := ConfiguredJSONPreferences.Copy()
                prefs.Indent = indent
                prefs.ColorsEnabled = false
                prefs.UnwrapScalar = false
                return NewJSONEncoder(prefs)
        case YamlFormat:
                var prefs = ConfiguredYamlPreferences.Copy()
                prefs.Indent = indent
                prefs.ColorsEnabled = false
                return NewYamlEncoder(prefs)
        case XMLFormat:
                var xmlPrefs = ConfiguredXMLPreferences.Copy()
                xmlPrefs.Indent = indent
                return NewXMLEncoder(xmlPrefs)
        }
        return format.EncoderFactory()
}

func encodeToString(candidate *CandidateNode, prefs encoderPreferences) (string, error) {
        var output bytes.Buffer
        log.Debug("printing with indent: %v", prefs.indent)

        encoder := configureEncoder(prefs.format, prefs.indent)
        if encoder == nil {
                return "", errors.New("no support for output format")
        }

        printer := NewPrinter(encoder, NewSinglePrinterWriter(bufio.NewWriter(&output)))
        err := printer.PrintResults(candidate.AsList())
        return output.String(), err
}

type encoderPreferences struct {
        format *Format
        indent int
}

/* encodes object as yaml string */
var chomper = regexp.MustCompile("\n+$")

func encodeOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        preferences := expressionNode.Operation.Preferences.(encoderPreferences)
        var results = list.New()

        hasOnlyOneNewLine := regexp.MustCompile("[^\n].*\n$")
        endWithNewLine := regexp.MustCompile(".*\n$")

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                stringValue, err := encodeToString(candidate, preferences)

                if err != nil {
                        return Context{}, err
                }

                // remove trailing newlines if needed.
                // check if we originally decoded this path, and the original thing had a single line.
                originalList := context.GetVariable("decoded: " + candidate.GetKey())
                if originalList != nil && originalList.Len() > 0 && hasOnlyOneNewLine.MatchString(stringValue) {

                        original := originalList.Front().Value.(*CandidateNode)
                        // original block did not have a newline at the end, get rid of this one too
                        if !endWithNewLine.MatchString(original.Value) {
                                stringValue = chomper.ReplaceAllString(stringValue, "")
                        }
                }

                // dont print a newline when printing json on a single line.
                if (preferences.format == JSONFormat && preferences.indent == 0) ||
                        preferences.format == CSVFormat ||
                        preferences.format == TSVFormat {
                        stringValue = chomper.ReplaceAllString(stringValue, "")
                }

                results.PushBack(candidate.CreateReplacement(ScalarNode, "!!str", stringValue))
        }
        return context.ChildContext(results), nil
}

type decoderPreferences struct {
        format *Format
}

/* takes a string and decodes it back into an object */
func decodeOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        preferences := expressionNode.Operation.Preferences.(decoderPreferences)

        decoder := preferences.format.DecoderFactory()
        if decoder == nil {
                return Context{}, errors.New("no support for input format")
        }

        var results = list.New()
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                context.SetVariable("decoded: "+candidate.GetKey(), candidate.AsList())

                log.Debugf("got: [%v]", candidate.Value)

                err := decoder.Init(strings.NewReader(candidate.Value))
                if err != nil {
                        return Context{}, err
                }

                node, errorReading := decoder.Decode()
                if errorReading != nil {
                        return Context{}, errorReading
                }
                node.Key = candidate.Key
                node.Parent = candidate.Parent

                results.PushBack(node)
        }
        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func entrySeqFor(key *CandidateNode, value *CandidateNode) *CandidateNode {
        var keyKey = &CandidateNode{Kind: ScalarNode, Tag: "!!str", Value: "key"}
        var valueKey = &CandidateNode{Kind: ScalarNode, Tag: "!!str", Value: "value"}
        candidate := &CandidateNode{Kind: MappingNode, Tag: "!!map"}
        candidate.AddKeyValueChild(keyKey, key)
        candidate.AddKeyValueChild(valueKey, value)
        return candidate
}

func toEntriesFromMap(candidateNode *CandidateNode) *CandidateNode {
        var sequence = candidateNode.CreateReplacementWithComments(SequenceNode, "!!seq", 0)

        var contents = candidateNode.Content
        for index := 0; index < len(contents); index = index + 2 {
                key := contents[index]
                value := contents[index+1]

                sequence.AddChild(entrySeqFor(key, value))
        }
        return sequence
}

func toEntriesfromSeq(candidateNode *CandidateNode) *CandidateNode {
        var sequence = candidateNode.CreateReplacementWithComments(SequenceNode, "!!seq", 0)

        var contents = candidateNode.Content
        for index := 0; index < len(contents); index = index + 1 {
                key := &CandidateNode{Kind: ScalarNode, Tag: "!!int", Value: fmt.Sprintf("%v", index)}
                value := contents[index]

                sequence.AddChild(entrySeqFor(key, value))
        }
        return sequence
}

func toEntriesOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        var results = list.New()
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                switch candidate.Kind {
                case MappingNode:
                        results.PushBack(toEntriesFromMap(candidate))

                case SequenceNode:
                        results.PushBack(toEntriesfromSeq(candidate))
                default:
                        if candidate.Tag != "!!null" {
                                return Context{}, fmt.Errorf("%v has no keys", candidate.Tag)
                        }
                }
        }

        return context.ChildContext(results), nil
}

func parseEntry(candidateNode *CandidateNode, position int) (*CandidateNode, *CandidateNode, error) {
        prefs := traversePreferences{DontAutoCreate: true}

        keyResults, err := traverseMap(Context{}, candidateNode, createStringScalarNode("key"), prefs, false)

        if err != nil {
                return nil, nil, err
        } else if keyResults.Len() != 1 {
                return nil, nil, fmt.Errorf("expected to find one 'key' entry but found %v in position %v", keyResults.Len(), position)
        }

        valueResults, err := traverseMap(Context{}, candidateNode, createStringScalarNode("value"), prefs, false)

        if err != nil {
                return nil, nil, err
        } else if valueResults.Len() != 1 {
                return nil, nil, fmt.Errorf("expected to find one 'value' entry but found %v in position %v", valueResults.Len(), position)
        }

        return keyResults.Front().Value.(*CandidateNode), valueResults.Front().Value.(*CandidateNode), nil

}

func fromEntries(candidateNode *CandidateNode) (*CandidateNode, error) {
        var node = candidateNode.CopyWithoutContent()

        var contents = candidateNode.Content

        for index := 0; index < len(contents); index = index + 1 {
                key, value, err := parseEntry(contents[index], index)
                if err != nil {
                        return nil, err
                }

                node.AddKeyValueChild(key, value)
        }
        node.Kind = MappingNode
        node.Tag = "!!map"
        return node, nil
}

func fromEntriesOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        var results = list.New()
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                switch candidate.Kind {
                case SequenceNode:
                        mapResult, err := fromEntries(candidate)
                        if err != nil {
                                return Context{}, err
                        }
                        results.PushBack(mapResult)
                default:
                        return Context{}, fmt.Errorf("from entries only runs against arrays")
                }
        }

        return context.ChildContext(results), nil
}

func withEntriesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        //to_entries on the context
        toEntries, err := toEntriesOperator(d, context, expressionNode)
        if err != nil {
                return Context{}, err
        }

        var results = list.New()

        for el := toEntries.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                //run expression against entries
                // splat toEntries and pipe it into Rhs
                splatted, err := splat(context.SingleChildContext(candidate), traversePreferences{})
                if err != nil {
                        return Context{}, err
                }

                newResults := list.New()

                for itemEl := splatted.MatchingNodes.Front(); itemEl != nil; itemEl = itemEl.Next() {
                        result, err := d.GetMatchingNodes(splatted.SingleChildContext(itemEl.Value.(*CandidateNode)), expressionNode.RHS)
                        if err != nil {
                                return Context{}, err
                        }
                        newResults.PushBackList(result.MatchingNodes)
                }

                selfExpression := &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
                collected, err := collectTogether(d, splatted.ChildContext(newResults), selfExpression)
                if err != nil {
                        return Context{}, err
                }
                log.Debug("candidate %v", NodeToString(candidate))
                log.Debug("candidate leading content: %v", candidate.LeadingContent)
                collected.LeadingContent = candidate.LeadingContent
                log.Debug("candidate FootComment: [%v]", candidate.FootComment)

                collected.HeadComment = candidate.HeadComment
                collected.FootComment = candidate.FootComment

                log.Debugf("collected %v", collected.LeadingContent)

                fromEntries, err := fromEntriesOperator(d, context.SingleChildContext(collected), expressionNode)
                if err != nil {
                        return Context{}, err
                }
                results.PushBackList(fromEntries.MatchingNodes)

        }

        //from_entries on the result
        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
        "os"
        "strings"

        parse "github.com/a8m/envsubst/parse"
)

type envOpPreferences struct {
        StringValue bool
        NoUnset     bool
        NoEmpty     bool
        FailFast    bool
}

func envOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        if ConfiguredSecurityPreferences.DisableEnvOps {
                return Context{}, fmt.Errorf("env operations have been disabled")
        }
        envName := expressionNode.Operation.CandidateNode.Value
        log.Debug("EnvOperator, env name:", envName)

        rawValue := os.Getenv(envName)

        preferences := expressionNode.Operation.Preferences.(envOpPreferences)

        var node *CandidateNode
        if preferences.StringValue {
                node = &CandidateNode{
                        Kind:  ScalarNode,
                        Tag:   "!!str",
                        Value: rawValue,
                }
        } else if rawValue == "" {
                return Context{}, fmt.Errorf("value for env variable '%v' not provided in env()", envName)
        } else {
                decoder := NewYamlDecoder(ConfiguredYamlPreferences)
                if err := decoder.Init(strings.NewReader(rawValue)); err != nil {
                        return Context{}, err
                }
                var err error
                node, err = decoder.Decode()

                if err != nil {
                        return Context{}, err
                }

        }
        log.Debug("ENV tag", node.Tag)
        log.Debug("ENV value", node.Value)
        log.Debug("ENV Kind", node.Kind)

        return context.SingleChildContext(node), nil
}

func envsubstOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        if ConfiguredSecurityPreferences.DisableEnvOps {
                return Context{}, fmt.Errorf("env operations have been disabled")
        }
        var results = list.New()
        preferences := envOpPreferences{}
        if expressionNode.Operation.Preferences != nil {
                preferences = expressionNode.Operation.Preferences.(envOpPreferences)
        }

        parser := parse.New("string", os.Environ(),
                &parse.Restrictions{NoUnset: preferences.NoUnset, NoEmpty: preferences.NoEmpty})

        if preferences.FailFast {
                parser.Mode = parse.Quick
        } else {
                parser.Mode = parse.AllErrors
        }

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)
                if node.Tag != "!!str" {
                        log.Warning("EnvSubstOperator, env name:", node.Tag, node.Value)
                        return Context{}, fmt.Errorf("cannot substitute with %v, can only substitute strings. Hint: Most often you'll want to use '|=' over '=' for this operation", node.Tag)
                }

                value, err := parser.Parse(node.Value)
                if err != nil {
                        return Context{}, err
                }
                result := node.CreateReplacement(ScalarNode, "!!str", value)
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

package yqlib

func equalsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("equalsOperation")
        return crossFunction(d, context, expressionNode, isEquals(false), true)
}

func isEquals(flip bool) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        return func(_ *dataTreeNavigator, _ Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
                value := false
                log.Debugf("isEquals cross function")
                if lhs == nil && rhs == nil {
                        log.Debugf("both are nil")
                        owner := &CandidateNode{}
                        return createBooleanCandidate(owner, !flip), nil
                } else if lhs == nil {
                        log.Debugf("lhs nil, but rhs is not")
                        value := rhs.Tag == "!!null"
                        if flip {
                                value = !value
                        }
                        return createBooleanCandidate(rhs, value), nil
                } else if rhs == nil {
                        log.Debugf("lhs not nil, but rhs is")
                        value := lhs.Tag == "!!null"
                        if flip {
                                value = !value
                        }
                        return createBooleanCandidate(lhs, value), nil
                }

                if lhs.Tag == "!!null" {
                        value = (rhs.Tag == "!!null")
                } else if lhs.Kind == ScalarNode && rhs.Kind == ScalarNode {
                        value = matchKey(lhs.Value, rhs.Value)
                }
                log.Debugf("%v == %v ? %v", NodeToString(lhs), NodeToString(rhs), value)
                if flip {
                        value = !value
                }
                return createBooleanCandidate(lhs, value), nil
        }
}

func notEqualsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("notEqualsOperator")
        return crossFunction(d, context.ReadOnlyClone(), expressionNode, isEquals(true), true)
}

package yqlib

import (
        "errors"
)

func errorOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("errorOperation")

        rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
        if err != nil {
                return Context{}, err
        }
        errorMessage := "aborted"
        if rhs.MatchingNodes.Len() > 0 {
                errorMessage = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
        }
        return Context{}, errors.New(errorMessage)
}

package yqlib

import (
        "container/list"
)

func evalOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("Eval")
        pathExpStrResults, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
        if err != nil {
                return Context{}, err
        }

        expressions := make([]*ExpressionNode, pathExpStrResults.MatchingNodes.Len())
        expIndex := 0
        //parse every expression
        for pathExpStrEntry := pathExpStrResults.MatchingNodes.Front(); pathExpStrEntry != nil; pathExpStrEntry = pathExpStrEntry.Next() {
                expressionStrCandidate := pathExpStrEntry.Value.(*CandidateNode)

                expressions[expIndex], err = ExpressionParser.ParseExpression(expressionStrCandidate.Value)
                if err != nil {
                        return Context{}, err
                }

                expIndex++
        }

        results := list.New()

        for matchEl := context.MatchingNodes.Front(); matchEl != nil; matchEl = matchEl.Next() {
                for expIndex = 0; expIndex < len(expressions); expIndex++ {
                        result, err := d.GetMatchingNodes(context, expressions[expIndex])
                        if err != nil {
                                return Context{}, err
                        }
                        results.PushBackList(result.MatchingNodes)
                }
        }

        return context.ChildContext(results), nil

}

package yqlib

type expressionOpPreferences struct {
        expression string
}

func expressionOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        prefs := expressionNode.Operation.Preferences.(expressionOpPreferences)
        expNode, err := ExpressionParser.ParseExpression(prefs.expression)
        if err != nil {
                return Context{}, err
        }

        return d.GetMatchingNodes(context, expNode)
}

package yqlib

import (
        "container/list"
        "fmt"
)

func getFilenameOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("GetFilename")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                result := candidate.CreateReplacement(ScalarNode, "!!str", candidate.GetFilename())
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

func getFileIndexOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("GetFileIndex")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                result := candidate.CreateReplacement(ScalarNode, "!!int", fmt.Sprintf("%v", candidate.GetFileIndex()))
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
)

func filterOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("filterOperation")
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                children := context.SingleChildContext(candidate)
                splatted, err := splat(children, traversePreferences{})
                if err != nil {
                        return Context{}, err
                }
                filtered, err := selectOperator(d, splatted, expressionNode)
                if err != nil {
                        return Context{}, err
                }

                selfExpression := &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
                collected, err := collectTogether(d, filtered, selfExpression)
                if err != nil {
                        return Context{}, err
                }
                collected.Style = candidate.Style
                results.PushBack(collected)
        }
        return context.ChildContext(results), nil
}

package yqlib

import "container/list"

func firstOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        results := list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                // If no RHS expression is provided, simply return the first entry in candidate.Content
                if expressionNode == nil || expressionNode.RHS == nil {
                        if len(candidate.Content) > 0 {
                                results.PushBack(candidate.Content[0])
                        }
                        continue
                }

                splatted, err := splat(context.SingleChildContext(candidate), traversePreferences{})
                if err != nil {
                        return Context{}, err
                }

                for splatEl := splatted.MatchingNodes.Front(); splatEl != nil; splatEl = splatEl.Next() {
                        splatCandidate := splatEl.Value.(*CandidateNode)
                        // Create a new context for this splatted candidate
                        splatContext := context.SingleChildContext(splatCandidate)
                        // Evaluate the RHS expression against this splatted candidate
                        rhs, err := d.GetMatchingNodes(splatContext, expressionNode.RHS)
                        if err != nil {
                                return Context{}, err
                        }

                        includeResult := false

                        for resultEl := rhs.MatchingNodes.Front(); resultEl != nil; resultEl = resultEl.Next() {
                                result := resultEl.Value.(*CandidateNode)
                                includeResult = isTruthyNode(result)
                                if includeResult {
                                        break
                                }
                        }
                        if includeResult {
                                results.PushBack(splatCandidate)
                                break
                        }
                }

        }
        return context.ChildContext(results), nil
}

package yqlib

import (
        "fmt"
)

type flattenPreferences struct {
        depth int
}

func flatten(node *CandidateNode, depth int) {
        if depth == 0 {
                return
        }
        if node.Kind != SequenceNode {
                return
        }
        content := node.Content
        newSeq := make([]*CandidateNode, 0)

        for i := 0; i < len(content); i++ {
                if content[i].Kind == SequenceNode {
                        flatten(content[i], depth-1)
                        for j := 0; j < len(content[i].Content); j++ {
                                newSeq = append(newSeq, content[i].Content[j])
                        }
                } else {
                        newSeq = append(newSeq, content[i])
                }
        }
        node.Content = make([]*CandidateNode, 0)
        node.AddChildren(newSeq)
}

func flattenOp(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("flatten Operator")
        depth := expressionNode.Operation.Preferences.(flattenPreferences).depth

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                if candidate.Kind != SequenceNode {
                        return Context{}, fmt.Errorf("only arrays are supported for flatten")
                }

                flatten(candidate, depth)

        }

        return context, nil

}

package yqlib

import (
        "container/list"
        "fmt"

        "github.com/elliotchance/orderedmap"
)

func processIntoGroups(d *dataTreeNavigator, context Context, rhsExp *ExpressionNode, node *CandidateNode) (*orderedmap.OrderedMap, error) {
        var newMatches = orderedmap.NewOrderedMap()
        for _, child := range node.Content {
                rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(child), rhsExp)

                if err != nil {
                        return nil, err
                }

                keyValue := "null"

                if rhs.MatchingNodes.Len() > 0 {
                        first := rhs.MatchingNodes.Front()
                        keyCandidate := first.Value.(*CandidateNode)
                        keyValue = keyCandidate.Value
                }

                groupList, exists := newMatches.Get(keyValue)

                if !exists {
                        groupList = list.New()
                        newMatches.Set(keyValue, groupList)
                }
                groupList.(*list.List).PushBack(child)
        }
        return newMatches, nil
}

func groupBy(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("groupBy Operator")
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                if candidate.Kind != SequenceNode {
                        return Context{}, fmt.Errorf("only arrays are supported for group by")
                }

                newMatches, err := processIntoGroups(d, context, expressionNode.RHS, candidate)

                if err != nil {
                        return Context{}, err
                }

                resultNode := candidate.CreateReplacement(SequenceNode, "!!seq", "")
                for groupEl := newMatches.Front(); groupEl != nil; groupEl = groupEl.Next() {
                        groupResultNode := &CandidateNode{Kind: SequenceNode, Tag: "!!seq"}
                        groupList := groupEl.Value.(*list.List)
                        for groupItem := groupList.Front(); groupItem != nil; groupItem = groupItem.Next() {
                                groupResultNode.AddChild(groupItem.Value.(*CandidateNode))
                        }

                        resultNode.AddChild(groupResultNode)
                }

                results.PushBack(resultNode)

        }

        return context.ChildContext(results), nil

}

package yqlib

import (
        "container/list"
        "strconv"
)

func hasOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("hasOperation")
        var results = list.New()

        rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)

        if err != nil {
                return Context{}, err
        }

        wantedKey := "null"
        wanted := &CandidateNode{Tag: "!!null"}
        if rhs.MatchingNodes.Len() != 0 {
                wanted = rhs.MatchingNodes.Front().Value.(*CandidateNode)
                wantedKey = wanted.Value
        }

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                var contents = candidate.Content
                switch candidate.Kind {
                case MappingNode:
                        candidateHasKey := false
                        for index := 0; index < len(contents) && !candidateHasKey; index = index + 2 {
                                key := contents[index]
                                if key.Value == wantedKey {
                                        candidateHasKey = true
                                }
                        }
                        results.PushBack(createBooleanCandidate(candidate, candidateHasKey))
                case SequenceNode:
                        candidateHasKey := false
                        if wanted.Tag == "!!int" {
                                var number, errParsingInt = strconv.ParseInt(wantedKey, 10, 64)
                                if errParsingInt != nil {
                                        return Context{}, errParsingInt
                                }
                                candidateHasKey = int64(len(contents)) > number
                        }
                        results.PushBack(createBooleanCandidate(candidate, candidateHasKey))
                default:
                        results.PushBack(createBooleanCandidate(candidate, false))
                }
        }
        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func isKeyOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("isKeyOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                results.PushBack(createBooleanCandidate(candidate, candidate.IsMapKey))
        }

        return context.ChildContext(results), nil
}

func getKeyOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("getKeyOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                if candidate.Key != nil {
                        results.PushBack(candidate.Key)
                }
        }

        return context.ChildContext(results), nil

}

func keysOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("keysOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                var targetNode *CandidateNode
                switch candidate.Kind {
                case MappingNode:
                        targetNode = getMapKeys(candidate)
                case SequenceNode:
                        targetNode = getIndices(candidate)
                default:
                        return Context{}, fmt.Errorf("cannot get keys of %v, keys only works for maps and arrays", candidate.Tag)
                }

                results.PushBack(targetNode)
        }

        return context.ChildContext(results), nil
}

func getMapKeys(node *CandidateNode) *CandidateNode {
        contents := make([]*CandidateNode, 0)
        for index := 0; index < len(node.Content); index = index + 2 {
                contents = append(contents, node.Content[index])
        }

        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] = createScalarNode(index, fmt.Sprintf("%v", index))
        }

        seq := &CandidateNode{Kind: SequenceNode, Tag: "!!seq"}
        seq.AddChildren(contents)
        return seq
}

package yqlib

import (
        "container/list"
)

func kindToText(kind Kind) string {
        switch kind {
        case MappingNode:
                return "map"
        case SequenceNode:
                return "seq"
        case ScalarNode:
                return "scalar"
        case AliasNode:
                return "alias"
        default:
                return "unknown"
        }
}

func getKindOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("GetKindOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                result := candidate.CreateReplacement(ScalarNode, "!!str", kindToText(candidate.Kind))
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func lengthOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("lengthOperation")
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                var length int
                switch candidate.Kind {
                case ScalarNode:
                        if candidate.Tag == "!!null" {
                                length = 0
                        } else {
                                length = len(candidate.Value)
                        }
                case MappingNode:
                        length = len(candidate.Content) / 2
                case SequenceNode:
                        length = len(candidate.Content)
                default:
                        length = 0
                }

                result := candidate.CreateReplacement(ScalarNode, "!!int", fmt.Sprintf("%v", length))
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func lineOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("lineOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                result := candidate.CreateReplacement(ScalarNode, "!!int", fmt.Sprintf("%v", candidate.Line))
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "bufio"
        "container/list"
        "fmt"
        "os"
)

var LoadYamlPreferences = YamlPreferences{
        LeadingContentPreProcessing: false,
        PrintDocSeparators:          true,
        UnwrapScalar:                true,
        EvaluateTogether:            false,
}

type loadPrefs struct {
        decoder Decoder
}

func loadString(filename string) (*CandidateNode, error) {
        // ignore CWE-22 gosec issue - that's more targeted for http based apps that run in a public directory,
        // and ensuring that it's not possible to give a path to a file outside that directory.

        filebytes, err := os.ReadFile(filename) // #nosec
        if err != nil {
                return nil, err
        }

        return &CandidateNode{Kind: ScalarNode, Tag: "!!str", Value: string(filebytes)}, nil
}

func loadWithDecoder(filename string, decoder Decoder) (*CandidateNode, error) {
        if decoder == nil {
                return nil, fmt.Errorf("could not load %s", filename)
        }

        file, err := os.Open(filename) // #nosec
        if err != nil {
                return nil, err
        }
        reader := bufio.NewReader(file)

        documents, err := readDocuments(reader, filename, 0, decoder)
        if err != nil {
                return nil, err
        }

        if documents.Len() == 0 {
                // return null candidate
                return &CandidateNode{Kind: ScalarNode, Tag: "!!null"}, nil
        } else if documents.Len() == 1 {
                candidate := documents.Front().Value.(*CandidateNode)
                return candidate, nil

        }
        sequenceNode := &CandidateNode{Kind: SequenceNode}
        for doc := documents.Front(); doc != nil; doc = doc.Next() {
                sequenceNode.AddChild(doc.Value.(*CandidateNode))
        }
        return sequenceNode, nil
}

func loadStringOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("loadString")
        if ConfiguredSecurityPreferences.DisableFileOps {
                return Context{}, fmt.Errorf("file operations have been disabled")
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }
                if rhs.MatchingNodes.Front() == nil {
                        return Context{}, fmt.Errorf("filename expression returned nil")
                }
                nameCandidateNode := rhs.MatchingNodes.Front().Value.(*CandidateNode)

                filename := nameCandidateNode.Value

                contentsCandidate, err := loadString(filename)
                if err != nil {
                        return Context{}, fmt.Errorf("failed to load %v: %w", filename, err)
                }

                results.PushBack(contentsCandidate)

        }

        return context.ChildContext(results), nil
}

func loadOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("loadOperator")
        if ConfiguredSecurityPreferences.DisableFileOps {
                return Context{}, fmt.Errorf("file operations have been disabled")
        }

        loadPrefs := expressionNode.Operation.Preferences.(loadPrefs)

        // need to evaluate the 1st parameter against the context
        // and return the data accordingly.

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }
                if rhs.MatchingNodes.Front() == nil {
                        return Context{}, fmt.Errorf("filename expression returned nil")
                }
                nameCandidateNode := rhs.MatchingNodes.Front().Value.(*CandidateNode)

                filename := nameCandidateNode.Value

                contentsCandidate, err := loadWithDecoder(filename, loadPrefs.decoder)
                if err != nil {
                        return Context{}, fmt.Errorf("failed to load %v: %w", filename, err)
                }

                results.PushBack(contentsCandidate)

        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
)

func mapValuesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                //run expression against entries
                // splat toEntries and pipe it into Rhs
                splatted, err := splat(context.SingleChildContext(candidate), traversePreferences{})
                if err != nil {
                        return Context{}, err
                }

                assignUpdateExp := &ExpressionNode{
                        Operation: &Operation{OperationType: assignOpType, UpdateAssign: true},
                        RHS:       expressionNode.RHS,
                }
                _, err = assignUpdateOperator(d, splatted, assignUpdateExp)
                if err != nil {
                        return Context{}, err
                }

        }

        return context, nil
}

func mapOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                //run expression against entries
                // splat toEntries and pipe it into Rhs
                splatted, err := splat(context.SingleChildContext(candidate), traversePreferences{})
                if err != nil {
                        return Context{}, err
                }
                if splatted.MatchingNodes.Len() == 0 {
                        results.PushBack(candidate.Copy())
                        continue
                }

                result, err := d.GetMatchingNodes(splatted, expressionNode.RHS)
                log.Debug("expressionNode.Rhs %v", expressionNode.RHS.Operation.OperationType)
                log.Debug("result %v", result)
                if err != nil {
                        return Context{}, err
                }

                selfExpression := &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
                collected, err := collectTogether(d, result, selfExpression)
                if err != nil {
                        return Context{}, err
                }
                collected.Style = candidate.Style

                results.PushBack(collected)

        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "fmt"
        "math"
        "strconv"
        "strings"
)

func moduloOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("Modulo operator")

        return crossFunction(d, context.ReadOnlyClone(), expressionNode, modulo, false)
}

func modulo(_ *dataTreeNavigator, _ Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        if lhs.Tag == "!!null" {
                return nil, fmt.Errorf("%v (%v) cannot modulo by %v (%v)", lhs.Tag, lhs.GetNicePath(), rhs.Tag, rhs.GetNicePath())
        }

        target := lhs.CopyWithoutContent()

        if lhs.Kind == ScalarNode && rhs.Kind == ScalarNode {
                if err := moduloScalars(target, lhs, rhs); err != nil {
                        return nil, err
                }
        } else {
                return nil, fmt.Errorf("%v (%v) cannot modulo by %v (%v)", lhs.Tag, lhs.GetNicePath(), rhs.Tag, rhs.GetNicePath())
        }

        return target, nil
}

func moduloScalars(target *CandidateNode, lhs *CandidateNode, rhs *CandidateNode) error {
        lhsTag := lhs.Tag
        rhsTag := rhs.guessTagFromCustomType()
        lhsIsCustom := false
        if !strings.HasPrefix(lhsTag, "!!") {
                // custom tag - we have to have a guess
                lhsTag = lhs.guessTagFromCustomType()
                lhsIsCustom = true
        }

        if lhsTag == "!!int" && rhsTag == "!!int" {
                target.Kind = ScalarNode
                target.Style = lhs.Style

                format, lhsNum, err := parseInt64(lhs.Value)
                if err != nil {
                        return err
                }
                _, rhsNum, err := parseInt64(rhs.Value)
                if err != nil {
                        return err
                }
                if rhsNum == 0 {
                        return fmt.Errorf("cannot modulo by 0")
                }
                remainder := lhsNum % rhsNum

                target.Tag = lhs.Tag
                target.Value = fmt.Sprintf(format, remainder)
        } else if (lhsTag == "!!int" || lhsTag == "!!float") && (rhsTag == "!!int" || rhsTag == "!!float") {
                target.Kind = ScalarNode
                target.Style = lhs.Style

                lhsNum, err := strconv.ParseFloat(lhs.Value, 64)
                if err != nil {
                        return err
                }
                rhsNum, err := strconv.ParseFloat(rhs.Value, 64)
                if err != nil {
                        return err
                }
                remainder := math.Mod(lhsNum, rhsNum)
                if lhsIsCustom {
                        target.Tag = lhs.Tag
                } else {
                        target.Tag = "!!float"
                }
                target.Value = fmt.Sprintf("%v", remainder)
        } else {
                return fmt.Errorf("%v cannot modulo by %v", lhsTag, rhsTag)
        }
        return nil
}

package yqlib

import (
        "container/list"
        "fmt"
        "strconv"
        "strings"
)

type multiplyPreferences struct {
        AppendArrays    bool
        DeepMergeArrays bool
        TraversePrefs   traversePreferences
        AssignPrefs     assignPreferences
}

func createMultiplyOp(prefs interface{}) func(lhs *ExpressionNode, rhs *ExpressionNode) *ExpressionNode {
        return func(lhs *ExpressionNode, rhs *ExpressionNode) *ExpressionNode {
                return &ExpressionNode{Operation: &Operation{OperationType: multiplyOpType, Preferences: prefs},
                        LHS: lhs,
                        RHS: rhs}
        }
}

func multiplyAssignOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        var multiplyPrefs = expressionNode.Operation.Preferences

        return compoundAssignFunction(d, context, expressionNode, createMultiplyOp(multiplyPrefs))
}

func multiplyOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("MultiplyOperator")
        return crossFunction(d, context, expressionNode, multiply(expressionNode.Operation.Preferences.(multiplyPreferences)), false)
}

func getComments(lhs *CandidateNode, rhs *CandidateNode) (leadingContent string, headComment string, footComment string) {
        leadingContent = rhs.LeadingContent
        headComment = rhs.HeadComment
        footComment = rhs.FootComment
        if lhs.HeadComment != "" || lhs.LeadingContent != "" {
                headComment = lhs.HeadComment
                leadingContent = lhs.LeadingContent
        }

        if lhs.FootComment != "" {
                footComment = lhs.FootComment
        }

        return leadingContent, headComment, footComment
}

func multiply(preferences multiplyPreferences) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        return func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
                // need to do this before unWrapping the potential document node
                leadingContent, headComment, footComment := getComments(lhs, rhs)
                log.Debugf("Multiplying LHS: %v", NodeToString(lhs))
                log.Debugf("-           RHS: %v", NodeToString(rhs))

                if rhs.Tag == "!!null" {
                        return lhs.Copy(), nil
                }

                if (lhs.Kind == MappingNode && rhs.Kind == MappingNode) ||
                        (lhs.Tag == "!!null" && rhs.Kind == MappingNode) ||
                        (lhs.Kind == SequenceNode && rhs.Kind == SequenceNode) ||
                        (lhs.Tag == "!!null" && rhs.Kind == SequenceNode) {

                        var newBlank = lhs.Copy()

                        newBlank.LeadingContent = leadingContent
                        newBlank.HeadComment = headComment
                        newBlank.FootComment = footComment

                        return mergeObjects(d, context.WritableClone(), newBlank, rhs, preferences)
                }
                return multiplyScalars(lhs, rhs)
        }
}

func multiplyScalars(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        lhsTag := lhs.Tag
        rhsTag := rhs.guessTagFromCustomType()
        lhsIsCustom := false
        if !strings.HasPrefix(lhsTag, "!!") {
                // custom tag - we have to have a guess
                lhsTag = lhs.guessTagFromCustomType()
                lhsIsCustom = true
        }

        if lhsTag == "!!int" && rhsTag == "!!int" {
                return multiplyIntegers(lhs, rhs)
        } else if (lhsTag == "!!int" || lhsTag == "!!float") && (rhsTag == "!!int" || rhsTag == "!!float") {
                return multiplyFloats(lhs, rhs, lhsIsCustom)
        } else if (lhsTag == "!!str" && rhsTag == "!!int") || (lhsTag == "!!int" && rhsTag == "!!str") {
                return repeatString(lhs, rhs)
        }
        return nil, fmt.Errorf("cannot multiply %v with %v", lhs.Tag, rhs.Tag)
}

func multiplyFloats(lhs *CandidateNode, rhs *CandidateNode, lhsIsCustom bool) (*CandidateNode, error) {
        target := lhs.CopyWithoutContent()
        target.Kind = ScalarNode
        target.Style = lhs.Style
        if lhsIsCustom {
                target.Tag = lhs.Tag
        } else {
                target.Tag = "!!float"
        }

        lhsNum, err := strconv.ParseFloat(lhs.Value, 64)
        if err != nil {
                return nil, err
        }
        rhsNum, err := strconv.ParseFloat(rhs.Value, 64)
        if err != nil {
                return nil, err
        }
        target.Value = fmt.Sprintf("%v", lhsNum*rhsNum)
        return target, nil
}

func multiplyIntegers(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        target := lhs.CopyWithoutContent()
        target.Kind = ScalarNode
        target.Style = lhs.Style
        target.Tag = lhs.Tag

        format, lhsNum, err := parseInt64(lhs.Value)
        if err != nil {
                return nil, err
        }
        _, rhsNum, err := parseInt64(rhs.Value)
        if err != nil {
                return nil, err
        }
        target.Value = fmt.Sprintf(format, lhsNum*rhsNum)
        return target, nil
}

func repeatString(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        var stringNode *CandidateNode
        var intNode *CandidateNode
        if lhs.Tag == "!!str" {
                stringNode = lhs
                intNode = rhs
        } else {
                stringNode = rhs
                intNode = lhs
        }
        target := lhs.CopyWithoutContent()
        target.UpdateAttributesFrom(stringNode, assignPreferences{})

        count, err := parseInt(intNode.Value)
        if err != nil {
                return nil, err
        } else if count < 0 {
                return nil, fmt.Errorf("cannot repeat string by a negative number (%v)", count)
        } else if count > 10000000 {
                return nil, fmt.Errorf("cannot repeat string by more than 100 million (%v)", count)
        }
        target.Value = strings.Repeat(stringNode.Value, count)

        return target, nil
}

func mergeObjects(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) (*CandidateNode, error) {
        var results = list.New()

        // only need to recurse the array if we are doing a deep merge
        prefs := recursiveDescentPreferences{RecurseArray: preferences.DeepMergeArrays,
                TraversePreferences: traversePreferences{DontFollowAlias: true, IncludeMapKeys: true}}
        log.Debugf("merge - preferences.DeepMergeArrays %v", preferences.DeepMergeArrays)
        log.Debugf("merge - preferences.AppendArrays %v", preferences.AppendArrays)
        err := recursiveDecent(results, context.SingleChildContext(rhs), prefs)
        if err != nil {
                return nil, err
        }

        var pathIndexToStartFrom int
        if results.Front() != nil {
                pathIndexToStartFrom = len(results.Front().Value.(*CandidateNode).GetPath())
                log.Debugf("pathIndexToStartFrom: %v", pathIndexToStartFrom)
        }

        for el := results.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                log.Debugf("going to applied assignment to LHS: %v with RHS: %v", NodeToString(lhs), NodeToString(candidate))

                if candidate.Tag == "!!merge" {
                        continue
                }

                err := applyAssignment(d, context, pathIndexToStartFrom, lhs, candidate, preferences)
                if err != nil {
                        return nil, err
                }

                log.Debugf("applied assignment to LHS: %v", NodeToString(lhs))
        }
        return lhs, nil
}

func applyAssignment(d *dataTreeNavigator, context Context, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) error {
        shouldAppendArrays := preferences.AppendArrays

        lhsPath := rhs.GetPath()[pathIndexToStartFrom:]
        log.Debugf("merge - lhsPath %v", lhsPath)

        assignmentOp := &Operation{OperationType: assignAttributesOpType, Preferences: preferences.AssignPrefs}
        if shouldAppendArrays && rhs.Kind == SequenceNode {
                assignmentOp.OperationType = addAssignOpType
                log.Debugf("merge - assignmentOp.OperationType = addAssignOpType")
        } else if !preferences.DeepMergeArrays && rhs.Kind == SequenceNode ||
                (rhs.Kind == ScalarNode || rhs.Kind == AliasNode) {
                assignmentOp.OperationType = assignOpType
                assignmentOp.UpdateAssign = false
                log.Debugf("merge - rhs.Kind == SequenceNode: %v", rhs.Kind == SequenceNode)
                log.Debugf("merge - rhs.Kind == ScalarNode: %v", rhs.Kind == ScalarNode)
                log.Debugf("merge - rhs.Kind == AliasNode: %v", rhs.Kind == AliasNode)
                log.Debugf("merge - assignmentOp.OperationType = assignOpType, no updateassign")
        } else {
                log.Debugf("merge - assignmentOp := &Operation{OperationType: assignAttributesOpType}")
        }
        rhsOp := &Operation{OperationType: referenceOpType, CandidateNode: rhs}

        assignmentOpNode := &ExpressionNode{
                Operation: assignmentOp,
                LHS:       createTraversalTree(lhsPath, preferences.TraversePrefs, rhs.IsMapKey),
                RHS:       &ExpressionNode{Operation: rhsOp},
        }

        _, err := d.GetMatchingNodes(context.SingleChildContext(lhs), assignmentOpNode)

        return err
}

package yqlib

import (
        "container/list"
        "strconv"
)

func omitMap(original *CandidateNode, indices *CandidateNode) *CandidateNode {
        filteredContent := make([]*CandidateNode, 0, max(0, len(original.Content)-len(indices.Content)*2))

        for index := 0; index < len(original.Content); index += 2 {
                pos := findInArray(indices, original.Content[index])
                if pos < 0 {
                        clonedKey := original.Content[index].Copy()
                        clonedValue := original.Content[index+1].Copy()
                        filteredContent = append(filteredContent, clonedKey, clonedValue)
                }
        }
        result := original.CopyWithoutContent()
        result.AddChildren(filteredContent)
        return result
}

func omitSequence(original *CandidateNode, indices *CandidateNode) *CandidateNode {
        filteredContent := make([]*CandidateNode, 0, max(0, len(original.Content)-len(indices.Content)))

        for index := 0; index < len(original.Content); index++ {
                pos := findInArray(indices, createScalarNode(index, strconv.Itoa(index)))
                if pos < 0 {
                        filteredContent = append(filteredContent, original.Content[index].Copy())
                }
        }
        result := original.CopyWithoutContent()
        result.AddChildren(filteredContent)
        return result
}

func omitOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("Omit")

        contextIndicesToOmit, err := d.GetMatchingNodes(context, expressionNode.RHS)

        if err != nil {
                return Context{}, err
        }
        indicesToOmit := &CandidateNode{}
        if contextIndicesToOmit.MatchingNodes.Len() > 0 {
                indicesToOmit = contextIndicesToOmit.MatchingNodes.Front().Value.(*CandidateNode)
        }
        if len(indicesToOmit.Content) == 0 {
                log.Debugf("No omit indices specified")
                return context, nil
        }
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)

                var replacement *CandidateNode

                switch node.Kind {
                case MappingNode:
                        replacement = omitMap(node, indicesToOmit)
                case SequenceNode:
                        replacement = omitSequence(node, indicesToOmit)
                default:
                        log.Debugf("Omit from type %v (%v) is noop", node.Tag, node.GetNicePath())
                        return context, nil
                }
                replacement.LeadingContent = node.LeadingContent
                results.PushBack(replacement)
        }
        return context.ChildContext(results), nil
}

package yqlib

import "container/list"

type parentOpPreferences struct {
        Level int
}

func getParentsOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("getParentsOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                parentsList := &CandidateNode{Kind: SequenceNode, Tag: "!!seq"}
                parent := candidate.Parent
                for parent != nil {
                        parentsList.AddChild(parent)
                        parent = parent.Parent
                }
                results.PushBack(parentsList)
        }

        return context.ChildContext(results), nil

}

func getParentOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("getParentOperator")

        var results = list.New()

        prefs := expressionNode.Operation.Preferences.(parentOpPreferences)

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                // Handle negative levels: count total parents first
                levelsToGoUp := prefs.Level
                if prefs.Level < 0 {
                        // Count all parents
                        totalParents := 0
                        temp := candidate.Parent
                        for temp != nil {
                                totalParents++
                                temp = temp.Parent
                        }
                        // Convert negative index to positive
                        // -1 means last parent (root), -2 means second to last, etc.
                        levelsToGoUp = totalParents + prefs.Level + 1
                        if levelsToGoUp < 0 {
                                levelsToGoUp = 0
                        }
                }

                currentLevel := 0
                for currentLevel < levelsToGoUp && candidate != nil {
                        log.Debugf("currentLevel: %v, desired: %v", currentLevel, levelsToGoUp)
                        log.Debugf("candidate: %v", NodeToString(candidate))
                        candidate = candidate.Parent
                        currentLevel++
                }

                log.Debugf("found candidate: %v", NodeToString(candidate))
                if candidate != nil {
                        results.PushBack(candidate)
                }
        }

        return context.ChildContext(results), nil

}

package yqlib

import (
        "container/list"
        "fmt"
)

func createPathNodeFor(pathElement interface{}) *CandidateNode {
        switch pathElement := pathElement.(type) {
        case string:
                return &CandidateNode{Kind: ScalarNode, Value: pathElement, Tag: "!!str"}
        default:
                return &CandidateNode{Kind: ScalarNode, Value: fmt.Sprintf("%v", pathElement), Tag: "!!int"}
        }
}

func getPathArrayFromNode(funcName string, node *CandidateNode) ([]interface{}, error) {
        if node.Kind != SequenceNode {
                return nil, fmt.Errorf("%v: expected path array, but got %v instead", funcName, node.Tag)
        }

        path := make([]interface{}, len(node.Content))

        for i, childNode := range node.Content {
                switch childNode.Tag {
                case "!!str":
                        path[i] = childNode.Value
                case "!!int":
                        number, err := parseInt(childNode.Value)
                        if err != nil {
                                return nil, fmt.Errorf("%v: could not parse %v as an int: %w", funcName, childNode.Value, err)
                        }
                        path[i] = number
                default:
                        return nil, fmt.Errorf("%v: expected either a !!str or !!int in the path, found %v instead", funcName, childNode.Tag)
                }

        }
        return path, nil
}

// SETPATH(pathArray; value)
func setPathOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("SetPath")

        if expressionNode.RHS.Operation.OperationType != blockOpType {
                return Context{}, fmt.Errorf("SETPATH must be given a block (;), got %v instead", expressionNode.RHS.Operation.OperationType.Type)
        }

        lhsPathContext, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS.LHS)

        if err != nil {
                return Context{}, err
        }

        if lhsPathContext.MatchingNodes.Len() != 1 {
                return Context{}, fmt.Errorf("SETPATH: expected single path but found %v results instead", lhsPathContext.MatchingNodes.Len())
        }
        lhsValue := lhsPathContext.MatchingNodes.Front().Value.(*CandidateNode)

        lhsPath, err := getPathArrayFromNode("SETPATH", lhsValue)

        if err != nil {
                return Context{}, err
        }

        lhsTraversalTree := createTraversalTree(lhsPath, traversePreferences{}, false)

        assignmentOp := &Operation{OperationType: assignOpType}

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                targetContextValue, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS.RHS)
                if err != nil {
                        return Context{}, err
                }

                if targetContextValue.MatchingNodes.Len() != 1 {
                        return Context{}, fmt.Errorf("SETPATH: expected single value on RHS but found %v", targetContextValue.MatchingNodes.Len())
                }

                rhsOp := &Operation{OperationType: referenceOpType, CandidateNode: targetContextValue.MatchingNodes.Front().Value.(*CandidateNode)}

                assignmentOpNode := &ExpressionNode{
                        Operation: assignmentOp,
                        LHS:       lhsTraversalTree,
                        RHS:       &ExpressionNode{Operation: rhsOp},
                }

                _, err = d.GetMatchingNodes(context.SingleChildContext(candidate), assignmentOpNode)

                if err != nil {
                        return Context{}, err
                }

        }
        return context, nil
}

func delPathsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("delPaths")
        // single RHS expression that returns an array of paths (array of arrays)

        pathArraysContext, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
        if err != nil {
                return Context{}, err
        }
        if pathArraysContext.MatchingNodes.Len() != 1 {
                return Context{}, fmt.Errorf("DELPATHS: expected single value but found %v", pathArraysContext.MatchingNodes.Len())
        }
        pathArraysNode := pathArraysContext.MatchingNodes.Front().Value.(*CandidateNode)

        if pathArraysNode.Tag != "!!seq" {
                return Context{}, fmt.Errorf("DELPATHS: expected a sequence of sequences, but found %v", pathArraysNode.Tag)
        }

        updatedContext := context

        for i, child := range pathArraysNode.Content {

                if child.Tag != "!!seq" {
                        return Context{}, fmt.Errorf("DELPATHS: expected entry [%v] to be a sequence, but its a %v. Note that delpaths takes an array of path arrays, e.g. [[\"a\", \"b\"]]", i, child.Tag)
                }
                childPath, err := getPathArrayFromNode("DELPATHS", child)

                if err != nil {
                        return Context{}, err
                }

                childTraversalExp := createTraversalTree(childPath, traversePreferences{}, false)
                deleteChildOp := &Operation{OperationType: deleteChildOpType}

                deleteChildOpNode := &ExpressionNode{
                        Operation: deleteChildOp,
                        RHS:       childTraversalExp,
                }

                updatedContext, err = d.GetMatchingNodes(updatedContext, deleteChildOpNode)

                if err != nil {
                        return Context{}, err
                }

        }

        return updatedContext, nil

}

func getPathOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("GetPath")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                node := candidate.CreateReplacement(SequenceNode, "!!seq", "")

                path := candidate.GetPath()

                content := make([]*CandidateNode, len(path))
                for pathIndex := 0; pathIndex < len(path); pathIndex++ {
                        path := path[pathIndex]
                        content[pathIndex] = createPathNodeFor(path)
                }
                node.AddChildren(content)
                results.PushBack(node)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func pickMap(original *CandidateNode, indices *CandidateNode) *CandidateNode {

        filteredContent := make([]*CandidateNode, 0)
        for index := 0; index < len(indices.Content); index = index + 1 {
                keyToFind := indices.Content[index]

                indexInMap := findKeyInMap(original, keyToFind)
                if indexInMap > -1 {
                        clonedKey := original.Content[indexInMap].Copy()
                        clonedValue := original.Content[indexInMap+1].Copy()
                        filteredContent = append(filteredContent, clonedKey, clonedValue)
                }
        }

        newNode := original.CopyWithoutContent()
        newNode.AddChildren(filteredContent)

        return newNode
}

func pickSequence(original *CandidateNode, indices *CandidateNode) (*CandidateNode, error) {

        filteredContent := make([]*CandidateNode, 0)
        for index := 0; index < len(indices.Content); index = index + 1 {
                indexInArray, err := parseInt(indices.Content[index].Value)
                if err != nil {
                        return nil, fmt.Errorf("cannot index array with %v", indices.Content[index].Value)
                }

                if indexInArray > -1 && indexInArray < len(original.Content) {
                        filteredContent = append(filteredContent, original.Content[indexInArray].Copy())
                }
        }

        newNode := original.CopyWithoutContent()
        newNode.AddChildren(filteredContent)

        return newNode, nil
}

func pickOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("Pick")

        contextIndicesToPick, err := d.GetMatchingNodes(context, expressionNode.RHS)

        if err != nil {
                return Context{}, err
        }
        indicesToPick := &CandidateNode{}
        if contextIndicesToPick.MatchingNodes.Len() > 0 {
                indicesToPick = contextIndicesToPick.MatchingNodes.Front().Value.(*CandidateNode)
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)

                var replacement *CandidateNode
                switch node.Kind {
                case MappingNode:
                        replacement = pickMap(node, indicesToPick)
                case SequenceNode:
                        replacement, err = pickSequence(node, indicesToPick)
                        if err != nil {
                                return Context{}, err
                        }

                default:
                        return Context{}, fmt.Errorf("cannot pick indices from type %v (%v)", node.Tag, node.GetNicePath())
                }

                replacement.LeadingContent = node.LeadingContent
                results.PushBack(replacement)
        }

        return context.ChildContext(results), nil
}

package yqlib

func pipeOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        if expressionNode.LHS.Operation.OperationType == assignVariableOpType {
                return variableLoop(d, context, expressionNode)
        }
        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)
        if err != nil {
                return Context{}, err
        }
        rhsContext := context.ChildContext(lhs.MatchingNodes)
        rhs, err := d.GetMatchingNodes(rhsContext, expressionNode.RHS)
        if err != nil {
                return Context{}, err
        }
        return context.ChildContext(rhs.MatchingNodes), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func getUniqueElementTag(seq *CandidateNode) (string, error) {
        switch l := len(seq.Content); l {
        case 0:
                return "", nil
        default:
                result := seq.Content[0].Tag
                for i := 1; i < l; i++ {
                        t := seq.Content[i].Tag
                        if t != result {
                                return "", fmt.Errorf("sequence contains elements of %v and %v types", result, t)
                        }
                }
                return result, nil
        }
}

var nullNodeFactory = func() *CandidateNode { return createScalarNode(nil, "") }

func pad[E any](array []E, length int, factory func() E) []E {
        sz := len(array)
        if sz >= length {
                return array
        }
        pad := make([]E, length-sz)
        for i := 0; i < len(pad); i++ {
                pad[i] = factory()
        }
        return append(array, pad...)
}

func pivotSequences(seq *CandidateNode) *CandidateNode {
        sz := len(seq.Content)
        if sz == 0 {
                return seq
        }
        m := make(map[int][]*CandidateNode)

        for i := 0; i < sz; i++ {
                row := seq.Content[i]
                for j := 0; j < len(row.Content); j++ {
                        e := m[j]
                        if e == nil {
                                e = make([]*CandidateNode, 0, sz)
                        }
                        m[j] = append(pad(e, i, nullNodeFactory), row.Content[j])
                }
        }
        result := CandidateNode{Kind: SequenceNode}

        for i := 0; i < len(m); i++ {
                e := CandidateNode{Kind: SequenceNode}
                e.AddChildren(pad(m[i], sz, nullNodeFactory))
                result.AddChild(&e)
        }
        return &result
}

func pivotMaps(seq *CandidateNode) *CandidateNode {
        sz := len(seq.Content)
        if sz == 0 {
                return &CandidateNode{Kind: MappingNode}
        }
        m := make(map[string][]*CandidateNode)
        keys := make([]string, 0)

        for i := 0; i < sz; i++ {
                row := seq.Content[i]
                for j := 0; j < len(row.Content); j += 2 {
                        k := row.Content[j].Value
                        v := row.Content[j+1]
                        e := m[k]
                        if e == nil {
                                keys = append(keys, k)
                                e = make([]*CandidateNode, 0, sz)
                        }
                        m[k] = append(pad(e, i, nullNodeFactory), v)
                }
        }
        result := CandidateNode{Kind: MappingNode}
        for _, k := range keys {
                pivotRow := CandidateNode{Kind: SequenceNode}
                pivotRow.AddChildren(
                        pad(m[k], sz, nullNodeFactory))
                result.AddKeyValueChild(createScalarNode(k, k), &pivotRow)
        }
        return &result
}

func pivotOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debug("Pivot")
        results := list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                if candidate.Tag != "!!seq" {
                        return Context{}, fmt.Errorf("cannot pivot node of type %v", candidate.Tag)
                }
                tag, err := getUniqueElementTag(candidate)
                if err != nil {
                        return Context{}, err
                }
                var pivot *CandidateNode
                switch tag {
                case "!!seq":
                        pivot = pivotSequences(candidate)
                case "!!map":
                        pivot = pivotMaps(candidate)
                default:
                        return Context{}, fmt.Errorf("can only pivot elements of !!seq or !!map types, received %v", tag)
                }
                results.PushBack(pivot)
        }
        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
)

type recursiveDescentPreferences struct {
        TraversePreferences traversePreferences
        RecurseArray        bool
}

func recursiveDescentOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        var results = list.New()

        preferences := expressionNode.Operation.Preferences.(recursiveDescentPreferences)
        err := recursiveDecent(results, context, preferences)
        if err != nil {
                return Context{}, err
        }

        return context.ChildContext(results), nil
}

func recursiveDecent(results *list.List, context Context, preferences recursiveDescentPreferences) error {
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                log.Debugf("added %v", NodeToString(candidate))
                results.PushBack(candidate)

                if candidate.Kind != AliasNode && len(candidate.Content) > 0 &&
                        (preferences.RecurseArray || candidate.Kind != SequenceNode) {

                        children, err := splat(context.SingleChildContext(candidate), preferences.TraversePreferences)

                        if err != nil {
                                return err
                        }
                        err = recursiveDecent(results, children, preferences)
                        if err != nil {
                                return err
                        }
                }
        }
        return nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func reduceOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("reduceOp")
        //.a as $var reduce (0; . + $var)
        //lhs is the assignment operator
        //rhs is the reduce block
        // '.' refers to the current accumulator, initialised to 0
        // $var references a single element from the .a

        //ensure lhs is actually an assignment
        //and rhs is a block (empty)
        if expressionNode.LHS.Operation.OperationType != assignVariableOpType {
                return Context{}, fmt.Errorf("reduce must be given a variables assignment, got %v instead", expressionNode.LHS.Operation.OperationType.Type)
        } else if expressionNode.RHS.Operation.OperationType != blockOpType {
                return Context{}, fmt.Errorf("reduce must be given a block, got %v instead", expressionNode.RHS.Operation.OperationType.Type)
        }

        arrayExpNode := expressionNode.LHS.LHS
        array, err := d.GetMatchingNodes(context, arrayExpNode)

        if err != nil {
                return Context{}, err
        }

        variableName := expressionNode.LHS.RHS.Operation.StringValue

        initExp := expressionNode.RHS.LHS

        accum, err := d.GetMatchingNodes(context, initExp)
        if err != nil {
                return Context{}, err
        }

        log.Debugf("with variable %v", variableName)

        blockExp := expressionNode.RHS.RHS
        for el := array.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                log.Debugf("REDUCING WITH %v", NodeToString(candidate))
                l := list.New()
                l.PushBack(candidate)
                accum.SetVariable(variableName, l)

                accum, err = d.GetMatchingNodes(accum, blockExp)
                if err != nil {
                        return Context{}, err
                }
        }

        return accum, nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func reverseOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        results := list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                if candidate.Kind != SequenceNode {
                        return context, fmt.Errorf("node at path [%v] is not an array (it's a %v)", candidate.GetNicePath(), candidate.Tag)
                }

                reverseList := candidate.CreateReplacementWithComments(SequenceNode, "!!seq", candidate.Style)
                reverseContent := make([]*CandidateNode, len(candidate.Content))

                for i, originalNode := range candidate.Content {
                        reverseContent[len(candidate.Content)-i-1] = originalNode
                }
                reverseList.AddChildren(reverseContent)
                results.PushBack(reverseList)

        }

        return context.ChildContext(results), nil

}

package yqlib

import (
        "container/list"
)

func selectOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("selectOperation")
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)

                if err != nil {
                        return Context{}, err
                }

                // find any truthy node
                includeResult := false

                for resultEl := rhs.MatchingNodes.Front(); resultEl != nil; resultEl = resultEl.Next() {
                        result := resultEl.Value.(*CandidateNode)
                        includeResult = isTruthyNode(result)
                        if includeResult {
                                break
                        }
                }

                if includeResult {
                        results.PushBack(candidate)
                }
        }
        return context.ChildContext(results), nil
}

package yqlib

func selfOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        return context, nil
}

package yqlib

import (
        "container/list"
        "fmt"
        "math/rand"
)

func shuffleOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {

        // ignore CWE-338 gosec issue of not using crypto/rand
        // this is just to shuffle an array rather generating a
        // secret or something that needs proper rand.
        myRand := rand.New(rand.NewSource(Now().UnixNano())) // #nosec

        results := list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                if candidate.Kind != SequenceNode {
                        return context, fmt.Errorf("node at path [%v] is not an array (it's a %v)", candidate.GetNicePath(), candidate.Tag)
                }

                result := candidate.Copy()

                a := result.Content

                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)
        }
        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func getSliceNumber(d *dataTreeNavigator, context Context, node *CandidateNode, expressionNode *ExpressionNode) (int, error) {
        result, err := d.GetMatchingNodes(context.SingleChildContext(node), expressionNode)
        if err != nil {
                return 0, err
        }
        if result.MatchingNodes.Len() != 1 {
                return 0, fmt.Errorf("expected to find 1 number, got %v instead", result.MatchingNodes.Len())
        }
        return parseInt(result.MatchingNodes.Front().Value.(*CandidateNode).Value)
}

func sliceArrayOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debug("slice array operator!")
        log.Debug("lhs: %v", expressionNode.LHS.Operation.toString())
        log.Debug("rhs: %v", expressionNode.RHS.Operation.toString())

        results := list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                lhsNode := el.Value.(*CandidateNode)

                firstNumber, err := getSliceNumber(d, context, lhsNode, expressionNode.LHS)

                if err != nil {
                        return Context{}, err
                }
                relativeFirstNumber := firstNumber
                if relativeFirstNumber < 0 {
                        relativeFirstNumber = len(lhsNode.Content) + firstNumber
                }

                secondNumber, err := getSliceNumber(d, context, lhsNode, expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }

                relativeSecondNumber := secondNumber
                if relativeSecondNumber < 0 {
                        relativeSecondNumber = len(lhsNode.Content) + secondNumber
                } else if relativeSecondNumber > len(lhsNode.Content) {
                        relativeSecondNumber = len(lhsNode.Content)
                }

                log.Debug("calculateIndicesToTraverse: slice from %v to %v", relativeFirstNumber, relativeSecondNumber)

                var newResults []*CandidateNode
                for i := relativeFirstNumber; i < relativeSecondNumber; i++ {
                        newResults = append(newResults, lhsNode.Content[i])
                }

                sliceArrayNode := lhsNode.CreateReplacement(SequenceNode, lhsNode.Tag, "")
                sliceArrayNode.AddChildren(newResults)
                results.PushBack(sliceArrayNode)

        }

        // result is now the context that has the nodes we need to put back into a sequence.
        //what about multiple arrays in the context? I think we need to create an array for each one
        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
        "sort"
        "strconv"
        "strings"
        "time"
)

func sortOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        selfExpression := &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
        expressionNode.RHS = selfExpression
        return sortByOperator(d, context, expressionNode)
}

// context represents the current matching nodes in the expression pipeline
// expressionNode is your current expression (sort_by)
func sortByOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        results := list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                var sortableArray sortableNodeArray

                if candidate.CanVisitValues() {
                        sortableArray = make(sortableNodeArray, 0)
                        visitor := func(valueNode *CandidateNode) error {
                                compareContext, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(valueNode), expressionNode.RHS)
                                if err != nil {
                                        return err
                                }
                                sortableNode := sortableNode{Node: valueNode, CompareContext: compareContext, dateTimeLayout: context.GetDateTimeLayout()}
                                sortableArray = append(sortableArray, sortableNode)
                                return nil
                        }
                        if err := candidate.VisitValues(visitor); err != nil {
                                return context, err
                        }
                } else {
                        return context, fmt.Errorf("node at path [%v] is not an array or map (it's a %v)", candidate.GetNicePath(), candidate.Tag)
                }

                sort.Stable(sortableArray)

                sortedList := candidate.CopyWithoutContent()
                switch candidate.Kind {
                case MappingNode:
                        for _, sortedNode := range sortableArray {
                                sortedList.AddKeyValueChild(sortedNode.Node.Key, sortedNode.Node)
                        }
                case SequenceNode:
                        for _, sortedNode := range sortableArray {
                                sortedList.AddChild(sortedNode.Node)
                        }
                }

                // convert array of value nodes back to map
                results.PushBack(sortedList)
        }
        return context.ChildContext(results), nil
}

type sortableNode struct {
        Node           *CandidateNode
        CompareContext Context
        dateTimeLayout string
}

type sortableNodeArray []sortableNode

func (a sortableNodeArray) Len() int      { return len(a) }
func (a sortableNodeArray) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

func (a sortableNodeArray) Less(i, j int) bool {
        lhsContext := a[i].CompareContext
        rhsContext := a[j].CompareContext

        rhsEl := rhsContext.MatchingNodes.Front()

        for lhsEl := lhsContext.MatchingNodes.Front(); lhsEl != nil && rhsEl != nil; lhsEl = lhsEl.Next() {
                lhs := lhsEl.Value.(*CandidateNode)
                rhs := rhsEl.Value.(*CandidateNode)

                result := a.compare(lhs, rhs, a[i].dateTimeLayout)

                if result < 0 {
                        return true
                } else if result > 0 {
                        return false
                }

                rhsEl = rhsEl.Next()
        }
        return lhsContext.MatchingNodes.Len() < rhsContext.MatchingNodes.Len()
}

func (a sortableNodeArray) compare(lhs *CandidateNode, rhs *CandidateNode, dateTimeLayout string) int {
        lhsTag := lhs.Tag
        rhsTag := rhs.Tag

        if !strings.HasPrefix(lhsTag, "!!") {
                // custom tag - we have to have a guess
                lhsTag = lhs.guessTagFromCustomType()
        }

        if !strings.HasPrefix(rhsTag, "!!") {
                // custom tag - we have to have a guess
                rhsTag = rhs.guessTagFromCustomType()
        }

        isDateTime := lhsTag == "!!timestamp" && rhsTag == "!!timestamp"
        layout := dateTimeLayout
        // if the lhs is a string, it might be a timestamp in a custom format.
        if lhsTag == "!!str" && layout != time.RFC3339 {
                _, errLhs := parseDateTime(layout, lhs.Value)
                _, errRhs := parseDateTime(layout, rhs.Value)
                isDateTime = errLhs == nil && errRhs == nil
        }

        if lhsTag == "!!null" && rhsTag != "!!null" {
                return -1
        } else if lhsTag != "!!null" && rhsTag == "!!null" {
                return 1
        } else if lhsTag == "!!bool" && rhsTag != "!!bool" {
                return -1
        } else if lhsTag != "!!bool" && rhsTag == "!!bool" {
                return 1
        } else if lhsTag == "!!bool" && rhsTag == "!!bool" {
                lhsTruthy := isTruthyNode(lhs)

                rhsTruthy := isTruthyNode(rhs)
                if lhsTruthy == rhsTruthy {
                        return 0
                } else if lhsTruthy {
                        return 1
                }
                return -1
        } else if isDateTime {
                lhsTime, err := parseDateTime(layout, lhs.Value)
                if err != nil {
                        log.Warningf("Could not parse time %v with layout %v for sort, sorting by string instead: %w", lhs.Value, layout, err)
                        return strings.Compare(lhs.Value, rhs.Value)
                }
                rhsTime, err := parseDateTime(layout, rhs.Value)
                if err != nil {
                        log.Warningf("Could not parse time %v with layout %v for sort, sorting by string instead: %w", rhs.Value, layout, err)
                        return strings.Compare(lhs.Value, rhs.Value)
                }
                if lhsTime.Equal(rhsTime) {
                        return 0
                } else if lhsTime.Before(rhsTime) {
                        return -1
                }

                return 1
        } else if lhsTag == "!!int" && rhsTag == "!!int" {
                _, lhsNum, err := parseInt64(lhs.Value)
                if err != nil {
                        panic(err)
                }
                _, rhsNum, err := parseInt64(rhs.Value)
                if err != nil {
                        panic(err)
                }
                return int(lhsNum - rhsNum)
        } else if (lhsTag == "!!int" || lhsTag == "!!float") && (rhsTag == "!!int" || rhsTag == "!!float") {
                lhsNum, err := strconv.ParseFloat(lhs.Value, 64)
                if err != nil {
                        panic(err)
                }
                rhsNum, err := strconv.ParseFloat(rhs.Value, 64)
                if err != nil {
                        panic(err)
                }
                if lhsNum == rhsNum {
                        return 0
                } else if lhsNum < rhsNum {
                        return -1
                }

                return 1
        }

        return strings.Compare(lhs.Value, rhs.Value)
}

package yqlib

import (
        "sort"
)

func sortKeysOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }

                for childEl := rhs.MatchingNodes.Front(); childEl != nil; childEl = childEl.Next() {
                        node := childEl.Value.(*CandidateNode)
                        if node.Kind == MappingNode {
                                sortKeys(node)
                        }
                        if err != nil {
                                return Context{}, err
                        }
                }

        }
        return context, nil
}

func sortKeys(node *CandidateNode) {
        keys := make([]string, len(node.Content)/2)
        keyBucket := map[string]*CandidateNode{}
        valueBucket := map[string]*CandidateNode{}
        var contents = node.Content
        for index := 0; index < len(contents); index = index + 2 {
                key := contents[index]
                value := contents[index+1]
                keys[index/2] = key.Value
                keyBucket[key.Value] = key
                valueBucket[key.Value] = value
        }
        sort.Strings(keys)
        sortedContent := make([]*CandidateNode, len(node.Content))
        for index := 0; index < len(keys); index = index + 1 {
                keyString := keys[index]
                sortedContent[index*2] = keyBucket[keyString]
                sortedContent[1+(index*2)] = valueBucket[keyString]
        }

        // re-arranging children, no need to update their parent
        // relationship
        node.Content = sortedContent
}

package yqlib

func splitDocumentOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("splitDocumentOperator")

        var index uint
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                candidate.SetDocument(index)
                candidate.SetParent(nil)
                index = index + 1
        }

        return context, nil
}

package yqlib

import (
        "container/list"
        "fmt"
        "regexp"
        "strings"
)

var StringInterpolationEnabled = true

type changeCasePrefs struct {
        ToUpperCase bool
}

func encodeToYamlString(node *CandidateNode) (string, error) {
        encoderPrefs := encoderPreferences{
                format: YamlFormat,
                indent: ConfiguredYamlPreferences.Indent,
        }
        result, err := encodeToString(node, encoderPrefs)

        if err != nil {
                return "", err
        }
        return chomper.ReplaceAllString(result, ""), nil
}

func evaluate(d *dataTreeNavigator, context Context, expStr string) (string, error) {
        exp, err := ExpressionParser.ParseExpression(expStr)
        if err != nil {
                return "", err
        }
        result, err := d.GetMatchingNodes(context, exp)
        if err != nil {
                return "", err
        }
        if result.MatchingNodes.Len() == 0 {
                return "", nil
        }
        node := result.MatchingNodes.Front().Value.(*CandidateNode)
        if node.Kind != ScalarNode {
                return encodeToYamlString(node)
        }
        return node.Value, nil
}

func interpolate(d *dataTreeNavigator, context Context, str string) (string, error) {
        var sb strings.Builder
        var expSb strings.Builder
        inExpression := false
        nestedBracketsCounter := 0
        runes := []rune(str)
        for i := 0; i < len(runes); i++ {
                char := runes[i]
                if !inExpression {
                        if char == '\\' && i < len(runes)-1 {
                                switch runes[i+1] {
                                case '(':
                                        inExpression = true
                                        // skip the lparen
                                        i++
                                        continue
                                case '\\':
                                        // skip the escaped backslash
                                        i++
                                default:
                                        log.Debugf("Ignoring non-escaping backslash @ %v[%d]", str, i)
                                }
                        }
                        sb.WriteRune(char)
                } else { // we are in an expression
                        if char == ')' {
                                if nestedBracketsCounter == 0 {
                                        // finished the expression!
                                        log.Debugf("Expression is :%v", expSb.String())
                                        value, err := evaluate(d, context, expSb.String())
                                        if err != nil {
                                                return "", err
                                        }
                                        inExpression = false
                                        expSb = strings.Builder{} // reset this

                                        sb.WriteString(value)
                                        continue
                                }
                                nestedBracketsCounter--
                        } else if char == '(' {
                                nestedBracketsCounter++
                        } else if char == '\\' && i < len(runes)-1 {
                                switch esc := runes[i+1]; esc {
                                case ')', '\\':
                                        // write escaped character
                                        expSb.WriteRune(esc)
                                        i++
                                        continue
                                default:
                                        log.Debugf("Ignoring non-escaping backslash @ %v[%d]", str, i)
                                }
                        }
                        expSb.WriteRune(char)
                }
        }
        if inExpression {
                log.Warning("unclosed interpolation string, skipping interpolation")
                return str, nil
        }
        return sb.String(), nil
}

func stringInterpolationOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        if !StringInterpolationEnabled {
                return context.SingleChildContext(
                        createScalarNode(expressionNode.Operation.StringValue, expressionNode.Operation.StringValue),
                ), nil
        }
        if context.MatchingNodes.Len() == 0 {
                value, err := interpolate(d, context, expressionNode.Operation.StringValue)
                if err != nil {
                        return Context{}, err
                }
                node := createScalarNode(value, value)
                return context.SingleChildContext(node), nil
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                value, err := interpolate(d, context.SingleChildContext(candidate), expressionNode.Operation.StringValue)
                if err != nil {
                        return Context{}, err
                }
                node := createScalarNode(value, value)
                results.PushBack(node)
        }

        return context.ChildContext(results), nil
}

func trimSpaceOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        results := list.New()
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)

                if node.guessTagFromCustomType() != "!!str" {
                        return Context{}, fmt.Errorf("cannot trim %v, can only operate on strings. ", node.Tag)
                }

                newStringNode := node.CreateReplacement(ScalarNode, node.Tag, strings.TrimSpace(node.Value))
                newStringNode.Style = node.Style
                results.PushBack(newStringNode)

        }

        return context.ChildContext(results), nil
}

func toStringOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        results := list.New()
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)
                var newStringNode *CandidateNode
                if node.Tag == "!!str" {
                        newStringNode = node.CreateReplacement(ScalarNode, "!!str", node.Value)
                } else if node.Kind == ScalarNode {
                        newStringNode = node.CreateReplacement(ScalarNode, "!!str", node.Value)
                        newStringNode.Style = DoubleQuotedStyle
                } else {
                        result, err := encodeToYamlString(node)
                        if err != nil {
                                return Context{}, err
                        }
                        newStringNode = node.CreateReplacement(ScalarNode, "!!str", result)
                        newStringNode.Style = DoubleQuotedStyle
                }
                newStringNode.Tag = "!!str"
                results.PushBack(newStringNode)
        }

        return context.ChildContext(results), nil
}

func changeCaseOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        results := list.New()
        prefs := expressionNode.Operation.Preferences.(changeCasePrefs)

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)

                if node.guessTagFromCustomType() != "!!str" {
                        return Context{}, fmt.Errorf("cannot change case with %v, can only operate on strings. ", node.Tag)
                }

                value := ""
                if prefs.ToUpperCase {
                        value = strings.ToUpper(node.Value)
                } else {
                        value = strings.ToLower(node.Value)
                }
                newStringNode := node.CreateReplacement(ScalarNode, node.Tag, value)
                newStringNode.Style = node.Style
                results.PushBack(newStringNode)

        }

        return context.ChildContext(results), nil

}

func getSubstituteParameters(d *dataTreeNavigator, block *ExpressionNode, context Context) (string, string, error) {
        regEx := ""
        replacementText := ""

        regExNodes, err := d.GetMatchingNodes(context.ReadOnlyClone(), block.LHS)
        if err != nil {
                return "", "", err
        }
        if regExNodes.MatchingNodes.Front() != nil {
                regEx = regExNodes.MatchingNodes.Front().Value.(*CandidateNode).Value
        }

        log.Debug("regEx %v", regEx)

        replacementNodes, err := d.GetMatchingNodes(context, block.RHS)
        if err != nil {
                return "", "", err
        }
        if replacementNodes.MatchingNodes.Front() != nil {
                replacementText = replacementNodes.MatchingNodes.Front().Value.(*CandidateNode).Value
        }

        return regEx, replacementText, nil
}

func substitute(original string, regex *regexp.Regexp, replacement string) (Kind, string, string) {
        replacedString := regex.ReplaceAllString(original, replacement)
        return ScalarNode, "!!str", replacedString
}

func substituteStringOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        //rhs  block operator
        //lhs of block = regex
        //rhs of block = replacement expression
        block := expressionNode.RHS

        regExStr, replacementText, err := getSubstituteParameters(d, block, context)

        if err != nil {
                return Context{}, err
        }

        regEx, err := regexp.Compile(regExStr)
        if err != nil {
                return Context{}, err
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)
                if node.guessTagFromCustomType() != "!!str" {
                        return Context{}, fmt.Errorf("cannot substitute with %v, can only substitute strings. Hint: Most often you'll want to use '|=' over '=' for this operation", node.Tag)
                }

                result := node.CreateReplacement(substitute(node.Value, regEx, replacementText))
                results.PushBack(result)
        }

        return context.ChildContext(results), nil

}

func addMatch(original []*CandidateNode, match string, offset int, name string) []*CandidateNode {

        newContent := append(original,
                createScalarNode("string", "string"))

        if offset < 0 {
                // offset of -1 means there was no match, force a null value like jq
                newContent = append(newContent,
                        createScalarNode(nil, "null"),
                )
        } else {
                newContent = append(newContent,
                        createScalarNode(match, match),
                )
        }

        newContent = append(newContent,
                createScalarNode("offset", "offset"),
                createScalarNode(offset, fmt.Sprintf("%v", offset)),
                createScalarNode("length", "length"),
                createScalarNode(len(match), fmt.Sprintf("%v", len(match))))

        if name != "" {
                newContent = append(newContent,
                        createScalarNode("name", "name"),
                        createScalarNode(name, name),
                )
        }
        return newContent
}

type matchPreferences struct {
        Global bool
}

func getMatches(matchPrefs matchPreferences, regEx *regexp.Regexp, value string) ([][]string, [][]int) {
        var allMatches [][]string
        var allIndices [][]int

        if matchPrefs.Global {
                allMatches = regEx.FindAllStringSubmatch(value, -1)
                allIndices = regEx.FindAllStringSubmatchIndex(value, -1)
        } else {
                allMatches = [][]string{regEx.FindStringSubmatch(value)}
                allIndices = [][]int{regEx.FindStringSubmatchIndex(value)}
        }

        log.Debug("allMatches, %v", allMatches)
        return allMatches, allIndices
}

func match(matchPrefs matchPreferences, regEx *regexp.Regexp, candidate *CandidateNode, value string, results *list.List) {
        subNames := regEx.SubexpNames()
        allMatches, allIndices := getMatches(matchPrefs, regEx, value)

        // if all matches just has an empty array in it,
        // then nothing matched
        if len(allMatches) > 0 && len(allMatches[0]) == 0 {
                return
        }

        for i, matches := range allMatches {
                capturesListNode := &CandidateNode{Kind: SequenceNode}
                match, submatches := matches[0], matches[1:]
                for j, submatch := range submatches {
                        captureNode := &CandidateNode{Kind: MappingNode}
                        captureNode.AddChildren(addMatch(captureNode.Content, submatch, allIndices[i][2+j*2], subNames[j+1]))
                        capturesListNode.AddChild(captureNode)
                }

                node := candidate.CreateReplacement(MappingNode, "!!map", "")
                node.AddChildren(addMatch(node.Content, match, allIndices[i][0], ""))
                node.AddKeyValueChild(createScalarNode("captures", "captures"), capturesListNode)
                results.PushBack(node)

        }

}

func capture(matchPrefs matchPreferences, regEx *regexp.Regexp, candidate *CandidateNode, value string, results *list.List) {
        subNames := regEx.SubexpNames()
        allMatches, allIndices := getMatches(matchPrefs, regEx, value)

        // if all matches just has an empty array in it,
        // then nothing matched
        if len(allMatches) > 0 && len(allMatches[0]) == 0 {
                return
        }

        for i, matches := range allMatches {
                capturesNode := candidate.CreateReplacement(MappingNode, "!!map", "")

                _, submatches := matches[0], matches[1:]
                for j, submatch := range submatches {

                        keyNode := createScalarNode(subNames[j+1], subNames[j+1])
                        var valueNode *CandidateNode

                        offset := allIndices[i][2+j*2]
                        // offset of -1 means there was no match, force a null value like jq
                        if offset < 0 {
                                valueNode = createScalarNode(nil, "null")
                        } else {
                                valueNode = createScalarNode(submatch, submatch)
                        }
                        capturesNode.AddKeyValueChild(keyNode, valueNode)
                }

                results.PushBack(capturesNode)

        }

}

func extractMatchArguments(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (*regexp.Regexp, matchPreferences, error) {
        regExExpNode := expressionNode.RHS

        matchPrefs := matchPreferences{}

        // we got given parameters e.g. match(exp; params)
        if expressionNode.RHS.Operation.OperationType == blockOpType {
                block := expressionNode.RHS
                regExExpNode = block.LHS
                replacementNodes, err := d.GetMatchingNodes(context, block.RHS)
                if err != nil {
                        return nil, matchPrefs, err
                }
                paramText := ""
                if replacementNodes.MatchingNodes.Front() != nil {
                        paramText = replacementNodes.MatchingNodes.Front().Value.(*CandidateNode).Value
                }
                if strings.Contains(paramText, "g") {
                        paramText = strings.ReplaceAll(paramText, "g", "")
                        matchPrefs.Global = true
                }
                if strings.Contains(paramText, "i") {
                        return nil, matchPrefs, fmt.Errorf(`'i' is not a valid option for match. To ignore case, use an expression like match("(?i)cat")`)
                }
                if len(paramText) > 0 {
                        return nil, matchPrefs, fmt.Errorf(`unrecognised match params '%v', please see docs at https://mikefarah.gitbook.io/yq/operators/string-operators`, paramText)
                }
        }

        regExNodes, err := d.GetMatchingNodes(context.ReadOnlyClone(), regExExpNode)
        if err != nil {
                return nil, matchPrefs, err
        }
        log.Debug(NodesToString(regExNodes.MatchingNodes))
        regExStr := ""
        if regExNodes.MatchingNodes.Front() != nil {
                regExStr = regExNodes.MatchingNodes.Front().Value.(*CandidateNode).Value
        }
        log.Debug("regEx %v", regExStr)
        regEx, err := regexp.Compile(regExStr)
        return regEx, matchPrefs, err
}

func matchOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        regEx, matchPrefs, err := extractMatchArguments(d, context, expressionNode)
        if err != nil {
                return Context{}, err
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)
                if node.guessTagFromCustomType() != "!!str" {
                        return Context{}, fmt.Errorf("cannot match with %v, can only match strings. Hint: Most often you'll want to use '|=' over '=' for this operation", node.Tag)
                }

                match(matchPrefs, regEx, node, node.Value, results)
        }

        return context.ChildContext(results), nil
}

func captureOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        regEx, matchPrefs, err := extractMatchArguments(d, context, expressionNode)
        if err != nil {
                return Context{}, err
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)
                if node.guessTagFromCustomType() != "!!str" {
                        return Context{}, fmt.Errorf("cannot match with %v, can only match strings. Hint: Most often you'll want to use '|=' over '=' for this operation", node.Tag)
                }
                capture(matchPrefs, regEx, node, node.Value, results)

        }

        return context.ChildContext(results), nil
}

func testOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        regEx, _, err := extractMatchArguments(d, context, expressionNode)
        if err != nil {
                return Context{}, err
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)
                if node.guessTagFromCustomType() != "!!str" {
                        return Context{}, fmt.Errorf("cannot match with %v, can only match strings. Hint: Most often you'll want to use '|=' over '=' for this operation", node.Tag)
                }
                matches := regEx.FindStringSubmatch(node.Value)
                results.PushBack(createBooleanCandidate(node, len(matches) > 0))

        }

        return context.ChildContext(results), nil
}

func joinStringOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("joinStringOperator")
        joinStr := ""

        rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
        if err != nil {
                return Context{}, err
        }
        if rhs.MatchingNodes.Front() != nil {
                joinStr = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)
                if node.Kind != SequenceNode {
                        return Context{}, fmt.Errorf("cannot join with %v, can only join arrays of scalars", node.Tag)
                }
                result := node.CreateReplacement(join(node.Content, joinStr))
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

func join(content []*CandidateNode, joinStr string) (Kind, string, string) {
        var stringsToJoin []string
        for _, node := range content {
                str := node.Value
                if node.Tag == "!!null" {
                        str = ""
                }
                stringsToJoin = append(stringsToJoin, str)
        }

        return ScalarNode, "!!str", strings.Join(stringsToJoin, joinStr)
}

func splitStringOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("splitStringOperator")
        splitStr := ""

        rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
        if err != nil {
                return Context{}, err
        }
        if rhs.MatchingNodes.Front() != nil {
                splitStr = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)
                if node.Tag == "!!null" {
                        continue
                }

                if node.guessTagFromCustomType() != "!!str" {
                        return Context{}, fmt.Errorf("cannot split %v, can only split strings", node.Tag)
                }
                kind, tag, content := split(node.Value, splitStr)
                result := node.CreateReplacement(kind, tag, "")
                result.AddChildren(content)
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

func split(value string, spltStr string) (Kind, string, []*CandidateNode) {
        var contents []*CandidateNode

        if value != "" {
                log.Debug("going to spltStr[%v]", spltStr)
                var newStrings = strings.Split(value, spltStr)
                contents = make([]*CandidateNode, len(newStrings))

                for index, str := range newStrings {
                        contents[index] = &CandidateNode{Kind: ScalarNode, Tag: "!!str", Value: str}
                }
        }

        return SequenceNode, "!!seq", contents
}

package yqlib

import (
        "container/list"
        "fmt"
)

func parseStyle(customStyle string) (Style, error) {
        if customStyle == "tagged" {
                return TaggedStyle, nil
        } else if customStyle == "double" {
                return DoubleQuotedStyle, nil
        } else if customStyle == "single" {
                return SingleQuotedStyle, nil
        } else if customStyle == "literal" {
                return LiteralStyle, nil
        } else if customStyle == "folded" {
                return FoldedStyle, nil
        } else if customStyle == "flow" {
                return FlowStyle, nil
        } else if customStyle != "" {
                return 0, fmt.Errorf("unknown style %v", customStyle)
        }
        return 0, nil
}

func assignStyleOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("AssignStyleOperator: %v")
        var style Style
        if !expressionNode.Operation.UpdateAssign {
                rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }

                if rhs.MatchingNodes.Front() != nil {
                        style, err = parseStyle(rhs.MatchingNodes.Front().Value.(*CandidateNode).Value)
                        if err != nil {
                                return Context{}, err
                        }
                }
        }

        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)

        if err != nil {
                return Context{}, err
        }

        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                log.Debugf("Setting style of : %v", NodeToString(candidate))
                if expressionNode.Operation.UpdateAssign {
                        rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)
                        if err != nil {
                                return Context{}, err
                        }

                        if rhs.MatchingNodes.Front() != nil {
                                style, err = parseStyle(rhs.MatchingNodes.Front().Value.(*CandidateNode).Value)
                                if err != nil {
                                        return Context{}, err
                                }
                        }
                }

                candidate.Style = style
        }

        return context, nil
}

func getStyleOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("GetStyleOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                var style string
                switch candidate.Style {
                case TaggedStyle:
                        style = "tagged"
                case DoubleQuotedStyle:
                        style = "double"
                case SingleQuotedStyle:
                        style = "single"
                case LiteralStyle:
                        style = "literal"
                case FoldedStyle:
                        style = "folded"
                case FlowStyle:
                        style = "flow"
                case 0:
                        style = ""
                default:
                        style = "<unknown>"
                }
                result := candidate.CreateReplacement(ScalarNode, "!!str", style)
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "fmt"
        "strconv"
        "strings"
        "time"
)

func createSubtractOp(lhs *ExpressionNode, rhs *ExpressionNode) *ExpressionNode {
        return &ExpressionNode{Operation: &Operation{OperationType: subtractOpType},
                LHS: lhs,
                RHS: rhs}
}

func subtractAssignOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        return compoundAssignFunction(d, context, expressionNode, createSubtractOp)
}

func subtractOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("Subtract operator")

        return crossFunction(d, context.ReadOnlyClone(), expressionNode, subtract, false)
}

func subtractArray(lhs *CandidateNode, rhs *CandidateNode) []*CandidateNode {
        newLHSArray := make([]*CandidateNode, 0)

        for lindex := 0; lindex < len(lhs.Content); lindex = lindex + 1 {
                shouldInclude := true
                for rindex := 0; rindex < len(rhs.Content) && shouldInclude; rindex = rindex + 1 {
                        if recursiveNodeEqual(lhs.Content[lindex], rhs.Content[rindex]) {
                                shouldInclude = false
                        }
                }
                if shouldInclude {
                        newLHSArray = append(newLHSArray, lhs.Content[lindex])
                }
        }
        return newLHSArray
}

func subtract(_ *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
        if lhs.Tag == "!!null" {
                return lhs.CopyAsReplacement(rhs), nil
        }

        target := lhs.CopyWithoutContent()

        switch lhs.Kind {
        case MappingNode:
                return nil, fmt.Errorf("maps not yet supported for subtraction")
        case SequenceNode:
                if rhs.Kind != SequenceNode {
                        return nil, fmt.Errorf("%v (%v) cannot be subtracted from %v", rhs.Tag, rhs.GetNicePath(), lhs.Tag)
                }
                target.Content = subtractArray(lhs, rhs)
        case ScalarNode:
                if rhs.Kind != ScalarNode {
                        return nil, fmt.Errorf("%v (%v) cannot be subtracted from %v", rhs.Tag, rhs.GetNicePath(), lhs.Tag)
                }
                target.Kind = ScalarNode
                target.Style = lhs.Style
                if err := subtractScalars(context, target, lhs, rhs); err != nil {
                        return nil, err
                }
        }

        return target, nil
}

func subtractScalars(context Context, target *CandidateNode, lhs *CandidateNode, rhs *CandidateNode) error {
        lhsTag := lhs.Tag
        rhsTag := rhs.Tag
        lhsIsCustom := false
        if !strings.HasPrefix(lhsTag, "!!") {
                // custom tag - we have to have a guess
                lhsTag = lhs.guessTagFromCustomType()
                lhsIsCustom = true
        }

        if !strings.HasPrefix(rhsTag, "!!") {
                // custom tag - we have to have a guess
                rhsTag = rhs.guessTagFromCustomType()
        }

        isDateTime := lhsTag == "!!timestamp"
        // if the lhs is a string, it might be a timestamp in a custom format.
        if lhsTag == "!!str" && context.GetDateTimeLayout() != time.RFC3339 {
                _, err := parseDateTime(context.GetDateTimeLayout(), lhs.Value)
                isDateTime = err == nil
        }

        if isDateTime {
                return subtractDateTime(context.GetDateTimeLayout(), target, lhs, rhs)
        } else if lhsTag == "!!str" {
                return fmt.Errorf("strings cannot be subtracted")
        } else if lhsTag == "!!int" && rhsTag == "!!int" {
                format, lhsNum, err := parseInt64(lhs.Value)
                if err != nil {
                        return err
                }
                _, rhsNum, err := parseInt64(rhs.Value)
                if err != nil {
                        return err
                }
                result := lhsNum - rhsNum
                target.Tag = lhs.Tag
                target.Value = fmt.Sprintf(format, result)
        } else if (lhsTag == "!!int" || lhsTag == "!!float") && (rhsTag == "!!int" || rhsTag == "!!float") {
                lhsNum, err := strconv.ParseFloat(lhs.Value, 64)
                if err != nil {
                        return err
                }
                rhsNum, err := strconv.ParseFloat(rhs.Value, 64)
                if err != nil {
                        return err
                }
                result := lhsNum - rhsNum
                if lhsIsCustom {
                        target.Tag = lhs.Tag
                } else {
                        target.Tag = "!!float"
                }
                target.Value = fmt.Sprintf("%v", result)
        } else {
                return fmt.Errorf("%v cannot be added to %v", lhs.Tag, rhs.Tag)
        }

        return nil
}

func subtractDateTime(layout string, target *CandidateNode, lhs *CandidateNode, rhs *CandidateNode) error {
        var durationStr string
        if strings.HasPrefix(rhs.Value, "-") {
                durationStr = rhs.Value[1:]
        } else {
                durationStr = "-" + rhs.Value
        }
        duration, err := time.ParseDuration(durationStr)

        if err != nil {
                return fmt.Errorf("unable to parse duration [%v]: %w", rhs.Value, err)
        }

        currentTime, err := parseDateTime(layout, lhs.Value)
        if err != nil {
                return err
        }

        newTime := currentTime.Add(duration)
        target.Value = newTime.Format(layout)
        return nil
}

package yqlib

import (
        "container/list"
)

func assignTagOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("AssignTagOperator: %v")
        tag := ""

        if !expressionNode.Operation.UpdateAssign {
                rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)
                if err != nil {
                        return Context{}, err
                }

                if rhs.MatchingNodes.Front() != nil {
                        tag = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
                }
        }

        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)

        if err != nil {
                return Context{}, err
        }

        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                log.Debugf("Setting tag of : %v", candidate.GetKey())
                if expressionNode.Operation.UpdateAssign {
                        rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(candidate), expressionNode.RHS)
                        if err != nil {
                                return Context{}, err
                        }

                        if rhs.MatchingNodes.Front() != nil {
                                tag = rhs.MatchingNodes.Front().Value.(*CandidateNode).Value
                        }
                }
                candidate.Tag = tag
        }

        return context, nil
}

func getTagOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("GetTagOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                result := candidate.CreateReplacement(ScalarNode, "!!str", candidate.Tag)
                results.PushBack(result)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
        "strconv"
)

func tryConvertToNumber(value string) (string, bool) {
        // try an int first
        _, _, err := parseInt64(value)
        if err == nil {
                return "!!int", true
        }
        // try float
        _, floatErr := strconv.ParseFloat(value, 64)

        if floatErr == nil {
                return "!!float", true
        }
        return "", false

}

func toNumberOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        log.Debugf("ToNumberOperator")

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                if candidate.Kind != ScalarNode {
                        return Context{}, fmt.Errorf("cannot convert node at path %v of tag %v to number", candidate.GetNicePath(), candidate.Tag)
                }

                if candidate.Tag == "!!int" || candidate.Tag == "!!float" {
                        // it already is a number!
                        results.PushBack(candidate)
                } else {
                        tag, converted := tryConvertToNumber(candidate.Value)
                        if converted {
                                result := candidate.CreateReplacement(ScalarNode, tag, candidate.Value)
                                results.PushBack(result)
                        } else {
                                return Context{}, fmt.Errorf("cannot convert node value [%v] at path %v of tag %v to number", candidate.Value, candidate.GetNicePath(), candidate.Tag)
                        }

                }
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
        "slices"

        "github.com/elliotchance/orderedmap"
)

type traversePreferences struct {
        DontFollowAlias      bool
        IncludeMapKeys       bool
        DontAutoCreate       bool // by default, we automatically create entries on the fly.
        DontIncludeMapValues bool
        OptionalTraverse     bool // e.g. .adf?
}

func splat(context Context, prefs traversePreferences) (Context, error) {
        return traverseNodesWithArrayIndices(context, make([]*CandidateNode, 0), prefs)
}

func traversePathOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("traversePathOperator")
        var matches = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                newNodes, err := traverse(context, el.Value.(*CandidateNode), expressionNode.Operation)
                if err != nil {
                        return Context{}, err
                }
                matches.PushBackList(newNodes)
        }

        return context.ChildContext(matches), nil
}

func traverse(context Context, matchingNode *CandidateNode, operation *Operation) (*list.List, error) {
        log.Debug("Traversing %v", NodeToString(matchingNode))

        if matchingNode.Tag == "!!null" && operation.Value != "[]" && !context.DontAutoCreate {
                log.Debugf("Guessing kind")
                // we must have added this automatically, lets guess what it should be now
                switch operation.Value.(type) {
                case int, int64:
                        log.Debugf("probably an array")
                        matchingNode.Kind = SequenceNode
                default:
                        log.Debugf("probably a map")
                        matchingNode.Kind = MappingNode
                }
                matchingNode.Tag = ""
        }

        switch matchingNode.Kind {
        case MappingNode:
                log.Debug("its a map with %v entries", len(matchingNode.Content)/2)
                return traverseMap(context, matchingNode, createStringScalarNode(operation.StringValue), operation.Preferences.(traversePreferences), false)

        case SequenceNode:
                log.Debug("its a sequence of %v things!", len(matchingNode.Content))
                return traverseArray(matchingNode, operation, operation.Preferences.(traversePreferences))

        case AliasNode:
                log.Debug("its an alias!")
                matchingNode = matchingNode.Alias
                return traverse(context, matchingNode, operation)
        default:
                return list.New(), nil
        }
}

func traverseArrayOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        //lhs may update the variable context, we should pass that into the RHS
        // BUT we still return the original context back (see jq)
        // https://stedolan.github.io/jq/manual/#Variable/SymbolicBindingOperator:...as$identifier|...

        log.Debugf("--traverseArrayOperator")

        if expressionNode.RHS != nil && expressionNode.RHS.RHS != nil && expressionNode.RHS.RHS.Operation.OperationType == createMapOpType {
                return sliceArrayOperator(d, context, expressionNode.RHS.RHS)
        }

        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)
        if err != nil {
                return Context{}, err
        }

        // rhs is a collect expression that will yield indices to retrieve of the arrays

        rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS)

        if err != nil {
                return Context{}, err
        }
        prefs := traversePreferences{}

        if expressionNode.Operation.Preferences != nil {
                prefs = expressionNode.Operation.Preferences.(traversePreferences)
        }
        var indicesToTraverse = rhs.MatchingNodes.Front().Value.(*CandidateNode).Content

        log.Debugf("indicesToTraverse %v", len(indicesToTraverse))

        //now we traverse the result of the lhs against the indices we found
        result, err := traverseNodesWithArrayIndices(lhs, indicesToTraverse, prefs)
        if err != nil {
                return Context{}, err
        }
        return context.ChildContext(result.MatchingNodes), nil
}

func traverseNodesWithArrayIndices(context Context, indicesToTraverse []*CandidateNode, prefs traversePreferences) (Context, error) {
        var matchingNodeMap = list.New()
        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                newNodes, err := traverseArrayIndices(context, candidate, indicesToTraverse, prefs)
                if err != nil {
                        return Context{}, err
                }
                matchingNodeMap.PushBackList(newNodes)
        }

        return context.ChildContext(matchingNodeMap), nil
}

func traverseArrayIndices(context Context, matchingNode *CandidateNode, indicesToTraverse []*CandidateNode, prefs traversePreferences) (*list.List, error) { // call this if doc / alias like the other traverse
        if matchingNode.Tag == "!!null" {
                log.Debugf("OperatorArrayTraverse got a null - turning it into an empty array")
                // auto vivification
                matchingNode.Tag = ""
                matchingNode.Kind = SequenceNode
                //check that the indices are numeric, if not, then we should create an object
                if len(indicesToTraverse) != 0 && indicesToTraverse[0].Tag != "!!int" {
                        matchingNode.Kind = MappingNode
                }
        }

        switch matchingNode.Kind {
        case AliasNode:
                matchingNode = matchingNode.Alias
                return traverseArrayIndices(context, matchingNode, indicesToTraverse, prefs)
        case SequenceNode:
                return traverseArrayWithIndices(matchingNode, indicesToTraverse, prefs)
        case MappingNode:
                return traverseMapWithIndices(context, matchingNode, indicesToTraverse, prefs)
        }
        log.Debugf("OperatorArrayTraverse skipping %v as its a %v", matchingNode, matchingNode.Tag)
        return list.New(), nil
}

func traverseMapWithIndices(context Context, candidate *CandidateNode, indices []*CandidateNode, prefs traversePreferences) (*list.List, error) {
        if len(indices) == 0 {
                return traverseMap(context, candidate, createStringScalarNode(""), prefs, true)
        }

        var matchingNodeMap = list.New()

        for _, indexNode := range indices {
                log.Debug("traverseMapWithIndices: %v", indexNode.Value)
                newNodes, err := traverseMap(context, candidate, indexNode, prefs, false)
                if err != nil {
                        return nil, err
                }
                matchingNodeMap.PushBackList(newNodes)
        }

        return matchingNodeMap, nil
}

func traverseArrayWithIndices(node *CandidateNode, indices []*CandidateNode, prefs traversePreferences) (*list.List, error) {
        log.Debug("traverseArrayWithIndices")
        var newMatches = list.New()
        if len(indices) == 0 {
                log.Debug("splatting")
                var index int
                for index = 0; index < len(node.Content); index = index + 1 {
                        newMatches.PushBack(node.Content[index])
                }
                return newMatches, nil

        }

        for _, indexNode := range indices {
                log.Debug("traverseArrayWithIndices: '%v'", indexNode.Value)
                index, err := parseInt(indexNode.Value)
                if err != nil && prefs.OptionalTraverse {
                        continue
                }
                if err != nil {
                        return nil, fmt.Errorf("cannot index array with '%v' (%w)", indexNode.Value, err)
                }
                indexToUse := index
                contentLength := len(node.Content)
                for contentLength <= index {
                        if contentLength == 0 {
                                // default to nice yaml formatting
                                node.Style = 0
                        }

                        valueNode := createScalarNode(nil, "null")
                        node.AddChild(valueNode)
                        contentLength = len(node.Content)
                }

                if indexToUse < 0 {
                        indexToUse = contentLength + indexToUse
                }

                if indexToUse < 0 {
                        return nil, fmt.Errorf("index [%v] out of range, array size is %v", index, contentLength)
                }

                newMatches.PushBack(node.Content[indexToUse])
        }
        return newMatches, nil
}

func keyMatches(key *CandidateNode, wantedKey string) bool {
        return matchKey(key.Value, wantedKey)
}

func traverseMap(context Context, matchingNode *CandidateNode, keyNode *CandidateNode, prefs traversePreferences, splat bool) (*list.List, error) {
        var newMatches = orderedmap.NewOrderedMap()
        err := doTraverseMap(newMatches, matchingNode, keyNode.Value, prefs, splat)

        if err != nil {
                return nil, err
        }

        if !splat && !prefs.DontAutoCreate && !context.DontAutoCreate && newMatches.Len() == 0 {
                log.Debugf("no matches, creating one for %v", NodeToString(keyNode))
                //no matches, create one automagically
                valueNode := matchingNode.CreateChild()
                valueNode.Kind = ScalarNode
                valueNode.Tag = "!!null"
                valueNode.Value = "null"

                if len(matchingNode.Content) == 0 {
                        matchingNode.Style = 0
                }

                keyNode, valueNode = matchingNode.AddKeyValueChild(keyNode, valueNode)

                if prefs.IncludeMapKeys {
                        newMatches.Set(keyNode.GetKey(), keyNode)
                }
                if !prefs.DontIncludeMapValues {
                        newMatches.Set(valueNode.GetKey(), valueNode)
                }
        }

        results := list.New()
        i := 0
        for el := newMatches.Front(); el != nil; el = el.Next() {
                results.PushBack(el.Value)
                i++
        }
        return results, nil
}

func doTraverseMap(newMatches *orderedmap.OrderedMap, node *CandidateNode, wantedKey string, prefs traversePreferences, splat bool) error {
        // value.Content is a concatenated array of key, value,
        // so keys are in the even indices, values in odd.
        // merge aliases are defined first, but we only want to traverse them
        // if we don't find a match directly on this node first.

        var contents = node.Content

        if !prefs.DontFollowAlias {
                if ConfiguredYamlPreferences.FixMergeAnchorToSpec {
                        // First evaluate merge keys to make explicit keys take precedence, following spec
                        // We also iterate in reverse to make earlier merge keys take precedence,
                        // although normally there's just one '<<'
                        for index := len(node.Content) - 2; index >= 0; index -= 2 {
                                keyNode := node.Content[index]
                                valueNode := node.Content[index+1]
                                if keyNode.Tag == "!!merge" {
                                        log.Debug("Merge anchor")
                                        err := traverseMergeAnchor(newMatches, valueNode, wantedKey, prefs, splat)
                                        if err != nil {
                                                return err
                                        }
                                }
                        }
                }
        }

        for index := 0; index+1 < len(contents); index = index + 2 {
                key := contents[index]
                value := contents[index+1]

                //skip the 'merge' tag, find a direct match first
                if key.Tag == "!!merge" && !prefs.DontFollowAlias && wantedKey != key.Value {
                        if !ConfiguredYamlPreferences.FixMergeAnchorToSpec {
                                log.Debug("Merge anchor")
                                if showMergeAnchorToSpecWarning {
                                        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. See https://mikefarah.gitbook.io/yq/operators/traverse-read for more details.")
                                        showMergeAnchorToSpecWarning = false
                                }
                                err := traverseMergeAnchor(newMatches, value, wantedKey, prefs, splat)
                                if err != nil {
                                        return err
                                }
                        }
                } else if splat || keyMatches(key, wantedKey) {
                        log.Debug("MATCHED")
                        if prefs.IncludeMapKeys {
                                log.Debug("including key")
                                keyName := key.GetKey()
                                if !newMatches.Set(keyName, key) {
                                        log.Debug("overwriting existing key")
                                }
                        }
                        if !prefs.DontIncludeMapValues {
                                log.Debug("including value")
                                valueName := value.GetKey()
                                if !newMatches.Set(valueName, value) {
                                        log.Debug("overwriting existing value")
                                }
                        }
                }
        }

        return nil
}

func traverseMergeAnchor(newMatches *orderedmap.OrderedMap, merge *CandidateNode, wantedKey string, prefs traversePreferences, splat bool) error {
        if merge.Kind == AliasNode {
                merge = merge.Alias
        }
        switch merge.Kind {
        case MappingNode:
                return doTraverseMap(newMatches, merge, wantedKey, prefs, splat)
        case SequenceNode:
                content := slices.All(merge.Content)
                if ConfiguredYamlPreferences.FixMergeAnchorToSpec {
                        // Reverse to make earlier values take precedence, following spec
                        content = slices.Backward(merge.Content)
                }
                for _, childValue := range content {
                        if childValue.Kind == AliasNode {
                                childValue = childValue.Alias
                        }
                        if childValue.Kind != MappingNode {
                                log.Debugf(
                                        "can only use merge anchors with maps (!!map) or sequences (!!seq) of maps, but got sequence containing %v",
                                        childValue.Tag)
                                return nil
                        }
                        err := doTraverseMap(newMatches, childValue, wantedKey, prefs, splat)
                        if err != nil {
                                return err
                        }
                }
                return nil
        default:
                log.Debugf("can only use merge anchors with maps (!!map) or sequences (!!seq) of maps, but got %v", merge.Tag)
                return nil
        }
}

func traverseArray(candidate *CandidateNode, operation *Operation, prefs traversePreferences) (*list.List, error) {
        log.Debug("operation Value %v", operation.Value)
        indices := []*CandidateNode{{Value: operation.StringValue}}
        return traverseArrayWithIndices(candidate, indices, prefs)
}

package yqlib

import "container/list"

func unionOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debug("unionOperator--")
        log.Debug("unionOperator: context: %v", NodesToString(context.MatchingNodes))
        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)
        if err != nil {
                return Context{}, err
        }
        log.Debug("unionOperator: lhs: %v", NodesToString(lhs.MatchingNodes))
        log.Debug("unionOperator: rhs input: %v", NodesToString(context.MatchingNodes))
        log.Debug("unionOperator: rhs: %v", expressionNode.RHS.Operation.toString())
        rhs, err := d.GetMatchingNodes(context, expressionNode.RHS)

        if err != nil {
                return Context{}, err
        }
        log.Debug("unionOperator: lhs: %v", lhs.ToString())
        log.Debug("unionOperator: rhs: %v", rhs.ToString())

        results := lhs.ChildContext(list.New())
        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                node := el.Value.(*CandidateNode)
                results.MatchingNodes.PushBack(node)
        }

        // this can happen when both expressions modify the context
        // instead of creating their own.
        /// (.foo = "bar"), (.thing = "cat")
        if rhs.MatchingNodes != lhs.MatchingNodes {

                for el := rhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                        node := el.Value.(*CandidateNode)
                        log.Debug("union operator rhs: processing %v", NodeToString(node))

                        results.MatchingNodes.PushBack(node)
                }
        }
        log.Debug("union operator: all together: %v", results.ToString())
        return results, nil
}

package yqlib

import (
        "container/list"
        "fmt"

        "github.com/elliotchance/orderedmap"
)

func unique(d *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        selfExpression := &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
        uniqueByExpression := &ExpressionNode{Operation: &Operation{OperationType: uniqueByOpType}, RHS: selfExpression}
        return uniqueBy(d, context, uniqueByExpression)

}

func uniqueBy(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {

        log.Debugf("uniqueBy Operator")
        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)

                if candidate.Kind != SequenceNode {
                        return Context{}, fmt.Errorf("only arrays are supported for unique")
                }

                var newMatches = orderedmap.NewOrderedMap()
                for _, child := range candidate.Content {
                        rhs, err := d.GetMatchingNodes(context.SingleReadonlyChildContext(child), expressionNode.RHS)

                        if err != nil {
                                return Context{}, err
                        }

                        keyValue, err := getUniqueKeyValue(rhs)
                        if err != nil {
                                return Context{}, err
                        }

                        _, exists := newMatches.Get(keyValue)

                        if !exists {
                                newMatches.Set(keyValue, child)
                        }
                }
                resultNode := candidate.CreateReplacementWithComments(SequenceNode, "!!seq", candidate.Style)
                for el := newMatches.Front(); el != nil; el = el.Next() {
                        resultNode.AddChild(el.Value.(*CandidateNode))
                }

                results.PushBack(resultNode)
        }

        return context.ChildContext(results), nil

}

func getUniqueKeyValue(rhs Context) (string, error) {
        keyValue := "null"
        var err error

        if rhs.MatchingNodes.Len() > 0 {
                first := rhs.MatchingNodes.Front()
                keyCandidate := first.Value.(*CandidateNode)
                keyValue = keyCandidate.Value
                if keyCandidate.Kind != ScalarNode {
                        keyValue, err = encodeToString(keyCandidate, encoderPreferences{YamlFormat, 0})
                }
        }
        return keyValue, err
}

package yqlib

import "container/list"

func referenceOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        return context.SingleChildContext(expressionNode.Operation.CandidateNode), nil
}

func valueOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debug("value = %v", expressionNode.Operation.CandidateNode.Value)
        if context.MatchingNodes.Len() == 0 {
                clone := expressionNode.Operation.CandidateNode.Copy()
                return context.SingleChildContext(clone), nil
        }

        var results = list.New()

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                clone := expressionNode.Operation.CandidateNode.Copy()
                results.PushBack(clone)
        }

        return context.ChildContext(results), nil
}

package yqlib

import (
        "container/list"
        "fmt"
)

func getVariableOperator(_ *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        variableName := expressionNode.Operation.StringValue
        log.Debug("getVariableOperator %v", variableName)
        result := context.GetVariable(variableName)
        if result == nil {
                result = list.New()
        }
        return context.ChildContext(result), nil
}

type assignVarPreferences struct {
        IsReference bool
}

func useWithPipe(_ *dataTreeNavigator, _ Context, _ *ExpressionNode) (Context, error) {
        return Context{}, fmt.Errorf("must use variable with a pipe, e.g. `exp as $x | ...`")
}

// variables are like loops in jq
// https://stedolan.github.io/jq/manual/#Variable
func variableLoop(d *dataTreeNavigator, context Context, originalExp *ExpressionNode) (Context, error) {
        log.Debug("variable loop!")
        results := list.New()
        var evaluateAllTogether = true
        for matchEl := context.MatchingNodes.Front(); matchEl != nil; matchEl = matchEl.Next() {
                evaluateAllTogether = evaluateAllTogether && matchEl.Value.(*CandidateNode).EvaluateTogether
                if !evaluateAllTogether {
                        break
                }
        }
        if evaluateAllTogether {
                return variableLoopSingleChild(d, context, originalExp)
        }

        for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
                result, err := variableLoopSingleChild(d, context.SingleChildContext(el.Value.(*CandidateNode)), originalExp)
                if err != nil {
                        return Context{}, err
                }
                results.PushBackList(result.MatchingNodes)
        }
        return context.ChildContext(results), nil
}

func variableLoopSingleChild(d *dataTreeNavigator, context Context, originalExp *ExpressionNode) (Context, error) {

        variableExp := originalExp.LHS
        lhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), variableExp.LHS)
        if err != nil {
                return Context{}, err
        }
        if variableExp.RHS.Operation.OperationType.Type != "GET_VARIABLE" {
                return Context{}, fmt.Errorf("RHS of 'as' operator must be a variable name e.g. $foo")
        }
        variableName := variableExp.RHS.Operation.StringValue

        prefs := variableExp.Operation.Preferences.(assignVarPreferences)

        results := list.New()

        // now we loop over lhs, set variable to each result and calculate originalExp.Rhs
        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                log.Debug("PROCESSING VARIABLE: ", NodeToString(el.Value.(*CandidateNode)))
                var variableValue = list.New()
                if prefs.IsReference {
                        variableValue.PushBack(el.Value)
                } else {
                        candidateCopy := el.Value.(*CandidateNode).Copy()
                        variableValue.PushBack(candidateCopy)
                }
                newContext := context.ChildContext(context.MatchingNodes)
                newContext.SetVariable(variableName, variableValue)

                rhs, err := d.GetMatchingNodes(newContext, originalExp.RHS)

                if err != nil {
                        return Context{}, err
                }
                log.Debug("PROCESSING VARIABLE DONE, got back: ", rhs.MatchingNodes.Len())
                results.PushBackList(rhs.MatchingNodes)
        }

        // if there is no LHS - then I guess we just calculate originalExp.Rhs
        if lhs.MatchingNodes.Len() == 0 {
                return d.GetMatchingNodes(context, originalExp.RHS)
        }

        return context.ChildContext(results), nil

}

package yqlib

import "fmt"

func withOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
        log.Debugf("withOperator")
        // with(path, exp)

        if expressionNode.RHS.Operation.OperationType != blockOpType {
                return Context{}, fmt.Errorf("with must be given a block (;), got %v instead", expressionNode.RHS.Operation.OperationType.Type)
        }

        pathExp := expressionNode.RHS.LHS

        updateContext, err := d.GetMatchingNodes(context, pathExp)

        if err != nil {
                return Context{}, err
        }

        updateExp := expressionNode.RHS.RHS

        for el := updateContext.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                _, err = d.GetMatchingNodes(updateContext.SingleChildContext(candidate), updateExp)
                if err != nil {
                        return Context{}, err
                }

        }

        return context, nil

}

package yqlib

import (
        "container/list"
        "fmt"

        "github.com/jinzhu/copier"
        logging "gopkg.in/op/go-logging.v1"
)

type operatorHandler func(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error)

type compoundCalculation func(lhs *ExpressionNode, rhs *ExpressionNode) *ExpressionNode

func compoundAssignFunction(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode, calculation compoundCalculation) (Context, error) {
        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)
        if err != nil {
                return Context{}, err
        }

        // tricky logic when we are running *= with flags.
        // we have an op like: .a *=nc .b
        // which should roughly translate to .a =c .a *nc .b
        // note that the 'n' flag only applies to the multiple op, not the assignment
        // but the clobber flag applies to both!

        prefs := assignPreferences{}
        switch typedPref := expressionNode.Operation.Preferences.(type) {
        case assignPreferences:
                prefs = typedPref
        case multiplyPreferences:
                prefs.ClobberCustomTags = typedPref.AssignPrefs.ClobberCustomTags
        }

        assignmentOp := &Operation{OperationType: assignOpType, Preferences: prefs}

        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                candidate := el.Value.(*CandidateNode)
                clone := candidate.Copy()
                valueCopyExp := &ExpressionNode{Operation: &Operation{OperationType: referenceOpType, CandidateNode: clone}}

                valueExpression := &ExpressionNode{Operation: &Operation{OperationType: referenceOpType, CandidateNode: candidate}}

                assignmentOpNode := &ExpressionNode{Operation: assignmentOp, LHS: valueExpression, RHS: calculation(valueCopyExp, expressionNode.RHS)}

                _, err = d.GetMatchingNodes(context, assignmentOpNode)
                if err != nil {
                        return Context{}, err
                }
        }
        return context, nil
}

func emptyOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Context, error) {
        context.MatchingNodes = list.New()
        return context, nil
}

type crossFunctionCalculation func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error)

func resultsForRHS(d *dataTreeNavigator, context Context, lhsCandidate *CandidateNode, prefs crossFunctionPreferences, rhsExp *ExpressionNode, results *list.List) error {

        if prefs.LhsResultValue != nil {
                result, err := prefs.LhsResultValue(lhsCandidate)
                if err != nil {
                        return err
                } else if result != nil {
                        results.PushBack(result)
                        return nil
                }
        }

        rhs, err := d.GetMatchingNodes(context, rhsExp)
        if err != nil {
                return err
        }

        if prefs.CalcWhenEmpty && rhs.MatchingNodes.Len() == 0 {
                resultCandidate, err := prefs.Calculation(d, context, lhsCandidate, nil)
                if err != nil {
                        return err
                }
                if resultCandidate != nil {
                        results.PushBack(resultCandidate)
                }
                return nil
        }

        for rightEl := rhs.MatchingNodes.Front(); rightEl != nil; rightEl = rightEl.Next() {
                rhsCandidate := rightEl.Value.(*CandidateNode)
                if !log.IsEnabledFor(logging.DEBUG) {
                        log.Debugf("Applying lhs: %v, rhsCandidate, %v", NodeToString(lhsCandidate), NodeToString(rhsCandidate))
                }
                resultCandidate, err := prefs.Calculation(d, context, lhsCandidate, rhsCandidate)
                if err != nil {
                        return err
                }
                if resultCandidate != nil {
                        results.PushBack(resultCandidate)
                }
        }
        return nil
}

type crossFunctionPreferences struct {
        CalcWhenEmpty bool
        // if this returns a result node,
        // we wont bother calculating the RHS
        LhsResultValue func(*CandidateNode) (*CandidateNode, error)
        Calculation    crossFunctionCalculation
}

func doCrossFunc(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode, prefs crossFunctionPreferences) (Context, error) {
        var results = list.New()
        lhs, err := d.GetMatchingNodes(context, expressionNode.LHS)
        if err != nil {
                return Context{}, err
        }
        log.Debugf("crossFunction LHS len: %v", lhs.MatchingNodes.Len())

        if prefs.CalcWhenEmpty && context.MatchingNodes.Len() > 0 && lhs.MatchingNodes.Len() == 0 {
                err := resultsForRHS(d, context, nil, prefs, expressionNode.RHS, results)
                if err != nil {
                        return Context{}, err
                }
        }

        for el := lhs.MatchingNodes.Front(); el != nil; el = el.Next() {
                lhsCandidate := el.Value.(*CandidateNode)

                err = resultsForRHS(d, context, lhsCandidate, prefs, expressionNode.RHS, results)
                if err != nil {
                        return Context{}, err
                }

        }
        return context.ChildContext(results), nil
}

func crossFunction(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode, calculation crossFunctionCalculation, calcWhenEmpty bool) (Context, error) {
        prefs := crossFunctionPreferences{CalcWhenEmpty: calcWhenEmpty, Calculation: calculation}
        return crossFunctionWithPrefs(d, context, expressionNode, prefs)
}

func crossFunctionWithPrefs(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode, prefs crossFunctionPreferences) (Context, error) {
        var results = list.New()

        var evaluateAllTogether = true
        for matchEl := context.MatchingNodes.Front(); matchEl != nil; matchEl = matchEl.Next() {
                evaluateAllTogether = evaluateAllTogether && matchEl.Value.(*CandidateNode).EvaluateTogether
                if !evaluateAllTogether {
                        break
                }
        }

        if evaluateAllTogether {
                log.Debug("crossFunction evaluateAllTogether!")
                return doCrossFunc(d, context, expressionNode, prefs)
        }

        log.Debug("crossFunction evaluate apart!")

        for matchEl := context.MatchingNodes.Front(); matchEl != nil; matchEl = matchEl.Next() {
                innerResults, err := doCrossFunc(d, context.SingleChildContext(matchEl.Value.(*CandidateNode)), expressionNode, prefs)
                if err != nil {
                        return Context{}, err
                }
                results.PushBackList(innerResults.MatchingNodes)
        }

        return context.ChildContext(results), nil
}

func createBooleanCandidate(owner *CandidateNode, value bool) *CandidateNode {
        valString := "true"
        if !value {
                valString = "false"
        }
        noob := owner.CreateReplacement(ScalarNode, "!!bool", valString)
        if owner.IsMapKey {
                noob.IsMapKey = false
                noob.Key = owner
        }

        return noob
}

func createTraversalTree(path []interface{}, traversePrefs traversePreferences, targetKey bool) *ExpressionNode {
        if len(path) == 0 {
                return &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
        } else if len(path) == 1 {
                lastPrefs := traversePrefs
                if targetKey {
                        err := copier.Copy(&lastPrefs, traversePrefs)
                        if err != nil {
                                panic(err)
                        }
                        lastPrefs.IncludeMapKeys = true
                        lastPrefs.DontIncludeMapValues = true
                }
                return &ExpressionNode{Operation: &Operation{OperationType: traversePathOpType, Preferences: lastPrefs, Value: path[0], StringValue: fmt.Sprintf("%v", path[0])}}
        }

        return &ExpressionNode{
                Operation: &Operation{OperationType: shortPipeOpType},
                LHS:       createTraversalTree(path[0:1], traversePrefs, false),
                RHS:       createTraversalTree(path[1:], traversePrefs, targetKey),
        }
}

package yqlib

import (
        "bufio"
        "bytes"
        "container/list"
        "fmt"
        "io"
        "regexp"
)

type Printer interface {
        PrintResults(matchingNodes *list.List) error
        PrintedAnything() bool
        //e.g. when given a front-matter doc, like jekyll
        SetAppendix(reader io.Reader)
        SetNulSepOutput(nulSepOutput bool)
}

type resultsPrinter struct {
        encoder           Encoder
        printerWriter     PrinterWriter
        firstTimePrinting bool
        previousDocIndex  uint
        previousFileIndex int
        printedMatches    bool
        treeNavigator     DataTreeNavigator
        appendixReader    io.Reader
        nulSepOutput      bool
}

func NewPrinter(encoder Encoder, printerWriter PrinterWriter) Printer {
        return &resultsPrinter{
                encoder:           encoder,
                printerWriter:     printerWriter,
                firstTimePrinting: true,
                treeNavigator:     NewDataTreeNavigator(),
                nulSepOutput:      false,
        }
}

func (p *resultsPrinter) SetNulSepOutput(nulSepOutput bool) {
        log.Debug("Setting NUL separator output")

        p.nulSepOutput = nulSepOutput
}

func (p *resultsPrinter) SetAppendix(reader io.Reader) {
        p.appendixReader = reader
}

func (p *resultsPrinter) PrintedAnything() bool {
        return p.printedMatches
}

func (p *resultsPrinter) printNode(node *CandidateNode, writer io.Writer) error {
        p.printedMatches = p.printedMatches || (node.Tag != "!!null" &&
                (node.Tag != "!!bool" || node.Value != "false"))
        return p.encoder.Encode(writer, node)
}

func removeLastEOL(b *bytes.Buffer) {
        data := b.Bytes()
        n := len(data)
        if n >= 2 && data[n-2] == '\r' && data[n-1] == '\n' {
                b.Truncate(n - 2)
        } else if n >= 1 && (data[n-1] == '\r' || data[n-1] == '\n') {
                b.Truncate(n - 1)
        }
}

func (p *resultsPrinter) PrintResults(matchingNodes *list.List) error {
        log.Debug("PrintResults for %v matches", matchingNodes.Len())

        if matchingNodes.Len() == 0 {
                log.Debug("no matching results, nothing to print")
                return nil
        }

        if !p.encoder.CanHandleAliases() {
                explodeOp := Operation{OperationType: explodeOpType}
                explodeNode := ExpressionNode{Operation: &explodeOp}
                context, err := p.treeNavigator.GetMatchingNodes(Context{MatchingNodes: matchingNodes}, &explodeNode)
                if err != nil {
                        return err
                }
                matchingNodes = context.MatchingNodes
        }

        if p.firstTimePrinting {
                node := matchingNodes.Front().Value.(*CandidateNode)
                p.previousDocIndex = node.GetDocument()
                p.previousFileIndex = node.GetFileIndex()
                p.firstTimePrinting = false
        }

        for el := matchingNodes.Front(); el != nil; el = el.Next() {

                mappedDoc := el.Value.(*CandidateNode)
                log.Debug("print sep logic: p.firstTimePrinting: %v, previousDocIndex: %v", p.firstTimePrinting, p.previousDocIndex)
                log.Debug("%v", NodeToString(mappedDoc))
                writer, errorWriting := p.printerWriter.GetWriter(mappedDoc)
                if errorWriting != nil {
                        return errorWriting
                }

                commentsStartWithSepExp := regexp.MustCompile(`^\$yqDocSeparator\$`)
                commentStartsWithSeparator := commentsStartWithSepExp.MatchString(mappedDoc.LeadingContent)

                if (p.previousDocIndex != mappedDoc.GetDocument() || p.previousFileIndex != mappedDoc.GetFileIndex()) && !commentStartsWithSeparator {
                        if err := p.encoder.PrintDocumentSeparator(writer); err != nil {
                                return err
                        }
                }

                var destination io.Writer = writer
                tempBuffer := bytes.NewBuffer(nil)
                if p.nulSepOutput {
                        destination = tempBuffer
                }

                if err := p.encoder.PrintLeadingContent(destination, mappedDoc.LeadingContent); err != nil {
                        return err
                }

                if err := p.printNode(mappedDoc, destination); err != nil {
                        return err
                }

                if p.nulSepOutput {
                        removeLastEOL(tempBuffer)
                        tempBufferBytes := tempBuffer.Bytes()
                        if bytes.IndexByte(tempBufferBytes, 0) != -1 {
                                return fmt.Errorf(
                                        "can't serialise value because it contains NUL char and you are using NUL separated output",
                                )
                        }
                        if _, err := writer.Write(tempBufferBytes); err != nil {
                                return err
                        }
                        if _, err := writer.Write([]byte{0}); err != nil {
                                return err
                        }
                }

                p.previousDocIndex = mappedDoc.GetDocument()
                if err := writer.Flush(); err != nil {
                        return err
                }
                log.Debugf("done printing results")
        }

        // what happens if I remove output format check?
        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
}

package yqlib

import (
        "bufio"
        "container/list"
        "io"

        "go.yaml.in/yaml/v4"
)

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
}

package yqlib

import (
        "bufio"
        "fmt"
        "io"
        "os"
        "path/filepath"
        "regexp"
)

type PrinterWriter interface {
        GetWriter(node *CandidateNode) (*bufio.Writer, error)
}

type singlePrinterWriter struct {
        bufferedWriter *bufio.Writer
}

func NewSinglePrinterWriter(writer io.Writer) PrinterWriter {
        return &singlePrinterWriter{
                bufferedWriter: bufio.NewWriter(writer),
        }
}

func (sp *singlePrinterWriter) GetWriter(_ *CandidateNode) (*bufio.Writer, error) {
        return sp.bufferedWriter, nil
}

type multiPrintWriter struct {
        treeNavigator  DataTreeNavigator
        nameExpression *ExpressionNode
        extension      string
        index          int
}

func NewMultiPrinterWriter(expression *ExpressionNode, format *Format) PrinterWriter {
        extension := "yml"

        switch format {
        case JSONFormat:
                extension = "json"
        case PropertiesFormat:
                extension = "properties"
        }

        return &multiPrintWriter{
                nameExpression: expression,
                extension:      extension,
                treeNavigator:  NewDataTreeNavigator(),
                index:          0,
        }
}

func (sp *multiPrintWriter) GetWriter(node *CandidateNode) (*bufio.Writer, error) {
        name := ""

        indexVariableNode := CandidateNode{Kind: ScalarNode, Tag: "!!int", Value: fmt.Sprintf("%v", sp.index)}

        context := Context{MatchingNodes: node.AsList()}
        context.SetVariable("index", indexVariableNode.AsList())
        result, err := sp.treeNavigator.GetMatchingNodes(context, sp.nameExpression)
        if err != nil {
                return nil, err
        }
        if result.MatchingNodes.Len() > 0 {
                name = result.MatchingNodes.Front().Value.(*CandidateNode).Value
        }
        var extensionRegexp = regexp.MustCompile(`\.[a-zA-Z0-9]+$`)
        if !extensionRegexp.MatchString(name) {
                name = fmt.Sprintf("%v.%v", name, sp.extension)
        }

        err = os.MkdirAll(filepath.Dir(name), 0750)
        if err != nil {
                return nil, err
        }
        f, err := os.Create(name)

        if err != nil {
                return nil, err
        }
        sp.index = sp.index + 1

        return bufio.NewWriter(f), nil

}

package yqlib

type PropertiesPreferences struct {
        UnwrapScalar      bool
        KeyValueSeparator string
        UseArrayBrackets  bool
}

func NewDefaultPropertiesPreferences() PropertiesPreferences {
        return PropertiesPreferences{
                UnwrapScalar:      true,
                KeyValueSeparator: " = ",
                UseArrayBrackets:  false,
        }
}

func (p *PropertiesPreferences) Copy() PropertiesPreferences {
        return PropertiesPreferences{
                UnwrapScalar:      p.UnwrapScalar,
                KeyValueSeparator: p.KeyValueSeparator,
                UseArrayBrackets:  p.UseArrayBrackets,
        }
}

var ConfiguredPropertiesPreferences = NewDefaultPropertiesPreferences()

package yqlib

type ShellVariablesPreferences struct {
        KeySeparator string
}

func NewDefaultShellVariablesPreferences() ShellVariablesPreferences {
        return ShellVariablesPreferences{
                KeySeparator: "_",
        }
}

var ConfiguredShellVariablesPreferences = NewDefaultShellVariablesPreferences()

package yqlib

import (
        "container/list"
        "errors"
        "fmt"
        "io"
        "os"
)

// A yaml expression evaluator that runs the expression multiple times for each given yaml document.
// Uses less memory than loading all documents and running the expression once, but this cannot process
// cross document expressions.
type StreamEvaluator interface {
        Evaluate(filename string, reader io.Reader, node *ExpressionNode, printer Printer, decoder Decoder) (uint, error)
        EvaluateFiles(expression string, filenames []string, printer Printer, decoder Decoder) error
        EvaluateNew(expression string, printer Printer) error
}

type streamEvaluator struct {
        treeNavigator DataTreeNavigator
        fileIndex     int
}

func NewStreamEvaluator() StreamEvaluator {
        return &streamEvaluator{treeNavigator: NewDataTreeNavigator()}
}

func (s *streamEvaluator) EvaluateNew(expression string, printer Printer) error {
        node, err := ExpressionParser.ParseExpression(expression)
        if err != nil {
                return err
        }
        candidateNode := createScalarNode(nil, "")
        inputList := list.New()
        inputList.PushBack(candidateNode)

        result, errorParsing := s.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputList}, node)
        if errorParsing != nil {
                return errorParsing
        }
        return printer.PrintResults(result.MatchingNodes)
}

func (s *streamEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer, decoder Decoder) error {
        var totalProcessDocs uint
        node, err := ExpressionParser.ParseExpression(expression)
        if err != nil {
                return err
        }

        for _, filename := range filenames {
                reader, err := readStream(filename)

                if err != nil {
                        return err
                }
                processedDocs, err := s.Evaluate(filename, reader, node, printer, decoder)
                if err != nil {
                        return err
                }
                totalProcessDocs = totalProcessDocs + processedDocs

                switch reader := reader.(type) {
                case *os.File:
                        safelyCloseFile(reader)
                }
        }

        if totalProcessDocs == 0 {
                // problem is I've already slurped the leading content sadface
                return s.EvaluateNew(expression, printer)
        }

        return nil
}

func (s *streamEvaluator) Evaluate(filename string, reader io.Reader, node *ExpressionNode, printer Printer, decoder Decoder) (uint, error) {

        var currentIndex uint
        err := decoder.Init(reader)
        if err != nil {
                return 0, err
        }
        for {
                candidateNode, errorReading := decoder.Decode()

                if errors.Is(errorReading, io.EOF) {
                        s.fileIndex = s.fileIndex + 1
                        return currentIndex, nil
                } else if errorReading != nil {
                        return currentIndex, fmt.Errorf("bad file '%v': %w", filename, errorReading)
                }
                candidateNode.document = currentIndex
                candidateNode.filename = filename
                candidateNode.fileIndex = s.fileIndex

                inputList := list.New()
                inputList.PushBack(candidateNode)

                result, errorParsing := s.treeNavigator.GetMatchingNodes(Context{MatchingNodes: inputList}, node)
                if errorParsing != nil {
                        return currentIndex, errorParsing
                }
                err := printer.PrintResults(result.MatchingNodes)

                if err != nil {
                        return currentIndex, err
                }
                currentIndex = currentIndex + 1
        }
}

package yqlib

import (
        "bufio"
        "bytes"
        "container/list"
        "strings"
)

type StringEvaluator interface {
        Evaluate(expression string, input string, encoder Encoder, decoder Decoder) (string, error)
        EvaluateAll(expression string, input string, encoder Encoder, decoder Decoder) (string, error)
}

type stringEvaluator struct {
        treeNavigator DataTreeNavigator
}

func NewStringEvaluator() StringEvaluator {
        return &stringEvaluator{
                treeNavigator: NewDataTreeNavigator(),
        }
}

func (s *stringEvaluator) EvaluateAll(expression string, input string, encoder Encoder, decoder Decoder) (string, error) {
        reader := bufio.NewReader(strings.NewReader(input))
        var documents *list.List
        var results *list.List
        var err error

        if documents, err = ReadDocuments(reader, decoder); err != nil {
                return "", err
        }

        evaluator := NewAllAtOnceEvaluator()
        if results, err = evaluator.EvaluateCandidateNodes(expression, documents); err != nil {
                return "", err
        }

        out := new(bytes.Buffer)
        printer := NewPrinter(encoder, NewSinglePrinterWriter(out))
        if err := printer.PrintResults(results); err != nil {
                return "", err
        }
        return out.String(), nil
}

func (s *stringEvaluator) Evaluate(expression string, input string, encoder Encoder, decoder Decoder) (string, error) {

        // Use bytes.Buffer for output of string
        out := new(bytes.Buffer)
        printer := NewPrinter(encoder, NewSinglePrinterWriter(out))

        InitExpressionParser()
        node, err := ExpressionParser.ParseExpression(expression)
        if err != nil {
                return "", err
        }

        reader := bufio.NewReader(strings.NewReader(input))
        evaluator := NewStreamEvaluator()
        if _, err := evaluator.Evaluate("", reader, node, printer, decoder); err != nil {
                return "", err
        }
        return out.String(), nil
}

package yqlib

type TomlPreferences struct {
        ColorsEnabled bool
}

func NewDefaultTomlPreferences() TomlPreferences {
        return TomlPreferences{ColorsEnabled: false}
}

func (p *TomlPreferences) Copy() TomlPreferences {
        return TomlPreferences{ColorsEnabled: p.ColorsEnabled}
}

var ConfiguredTomlPreferences = NewDefaultTomlPreferences()

package yqlib

import (
        "bufio"
        "container/list"
        "errors"
        "fmt"
        "io"
        "os"
)

func readStream(filename string) (io.Reader, error) {
        var reader *bufio.Reader
        if filename == "-" {
                reader = bufio.NewReader(os.Stdin)
        } else {
                // ignore CWE-22 gosec issue - that's more targeted for http based apps that run in a public directory,
                // and ensuring that it's not possible to give a path to a file outside that directory.
                file, err := os.Open(filename) // #nosec
                if err != nil {
                        return nil, err
                }
                reader = bufio.NewReader(file)
        }
        return reader, nil

}

func writeString(writer io.Writer, txt string) error {
        _, errorWriting := writer.Write([]byte(txt))
        return errorWriting
}

func ReadDocuments(reader io.Reader, decoder Decoder) (*list.List, error) {
        return readDocuments(reader, "", 0, decoder)
}

func readDocuments(reader io.Reader, filename string, fileIndex int, decoder Decoder) (*list.List, error) {
        err := decoder.Init(reader)
        if err != nil {
                return nil, err
        }
        inputList := list.New()
        var currentIndex uint

        for {
                candidateNode, errorReading := decoder.Decode()

                if errors.Is(errorReading, io.EOF) {
                        switch reader := reader.(type) {
                        case *os.File:
                                safelyCloseFile(reader)
                        }
                        return inputList, nil
                } else if errorReading != nil {
                        return nil, fmt.Errorf("bad file '%v': %w", filename, errorReading)
                }
                candidateNode.document = currentIndex
                candidateNode.filename = filename
                candidateNode.fileIndex = fileIndex
                candidateNode.EvaluateTogether = true

                inputList.PushBack(candidateNode)

                currentIndex = currentIndex + 1
        }
}

package yqlib

import (
        "os"
)

type writeInPlaceHandler interface {
        CreateTempFile() (*os.File, error)
        FinishWriteInPlace(evaluatedSuccessfully bool) error
}

type writeInPlaceHandlerImpl struct {
        inputFilename string
        tempFile      *os.File
}

func NewWriteInPlaceHandler(inputFile string) writeInPlaceHandler {

        return &writeInPlaceHandlerImpl{inputFile, nil}
}

func (w *writeInPlaceHandlerImpl) CreateTempFile() (*os.File, error) {
        file, err := createTempFile()

        if err != nil {
                return nil, err
        }
        info, err := os.Stat(w.inputFilename)
        if err != nil {
                return nil, err
        }
        err = os.Chmod(file.Name(), info.Mode())

        if err != nil {
                return nil, err
        }

        if err = changeOwner(info, file); err != nil {
                return nil, err
        }
        log.Debug("WriteInPlaceHandler: writing to tempfile: %v", file.Name())
        w.tempFile = file
        return file, err
}

func (w *writeInPlaceHandlerImpl) FinishWriteInPlace(evaluatedSuccessfully bool) error {
        log.Debug("Going to write in place, evaluatedSuccessfully=%v, target=%v", evaluatedSuccessfully, w.inputFilename)
        safelyCloseFile(w.tempFile)
        if evaluatedSuccessfully {
                log.Debug("Moving temp file to target")
                return tryRenameFile(w.tempFile.Name(), w.inputFilename)
        }
        tryRemoveTempFile(w.tempFile.Name())

        return nil
}

package yqlib

type XmlPreferences struct {
        Indent          int
        AttributePrefix string
        ContentName     string
        StrictMode      bool
        KeepNamespace   bool
        UseRawToken     bool
        ProcInstPrefix  string
        DirectiveName   string
        SkipProcInst    bool
        SkipDirectives  bool
}

func NewDefaultXmlPreferences() XmlPreferences {
        return XmlPreferences{
                Indent:          2,
                AttributePrefix: "+@",
                ContentName:     "+content",
                StrictMode:      false,
                KeepNamespace:   true,
                UseRawToken:     true,
                ProcInstPrefix:  "+p_",
                DirectiveName:   "+directive",
                SkipProcInst:    false,
                SkipDirectives:  false,
        }
}

func (p *XmlPreferences) Copy() XmlPreferences {
        return XmlPreferences{
                Indent:          p.Indent,
                AttributePrefix: p.AttributePrefix,
                ContentName:     p.ContentName,
                StrictMode:      p.StrictMode,
                KeepNamespace:   p.KeepNamespace,
                UseRawToken:     p.UseRawToken,
                ProcInstPrefix:  p.ProcInstPrefix,
                DirectiveName:   p.DirectiveName,
                SkipProcInst:    p.SkipProcInst,
                SkipDirectives:  p.SkipDirectives,
        }
}

var ConfiguredXMLPreferences = NewDefaultXmlPreferences()

package yqlib

type YamlPreferences struct {
        Indent                      int
        ColorsEnabled               bool
        LeadingContentPreProcessing bool
        PrintDocSeparators          bool
        UnwrapScalar                bool
        EvaluateTogether            bool
        FixMergeAnchorToSpec        bool
}

func NewDefaultYamlPreferences() YamlPreferences {
        return YamlPreferences{
                Indent:                      2,
                ColorsEnabled:               false,
                LeadingContentPreProcessing: true,
                PrintDocSeparators:          true,
                UnwrapScalar:                true,
                EvaluateTogether:            false,
                FixMergeAnchorToSpec:        false,
        }
}

func (p *YamlPreferences) Copy() YamlPreferences {
        return YamlPreferences{
                Indent:                      p.Indent,
                ColorsEnabled:               p.ColorsEnabled,
                LeadingContentPreProcessing: p.LeadingContentPreProcessing,
                PrintDocSeparators:          p.PrintDocSeparators,
                UnwrapScalar:                p.UnwrapScalar,
                EvaluateTogether:            p.EvaluateTogether,
                FixMergeAnchorToSpec:        p.FixMergeAnchorToSpec,
        }
}

var ConfiguredYamlPreferences = NewDefaultYamlPreferences()

package main

import (
        "os"

        command "github.com/mikefarah/yq/v4/cmd"
)

func main() {
        cmd := command.New()

        args := os.Args[1:]

        _, _, err := cmd.Find(args)
        if err != nil && args[0] != "__complete" {
                // default command when nothing matches...
                newArgs := []string{"eval"}
                cmd.SetArgs(append(newArgs, os.Args[1:]...))

        }

        if err := cmd.Execute(); err != nil {
                os.Exit(1)
        }
}