yq/cmd/merge.go

package cmd

import (
	"github.com/mikefarah/yq/v3/pkg/yqlib"
	errors "github.com/pkg/errors"
	"github.com/spf13/cobra"
	yaml "gopkg.in/yaml.v3"
)

func createMergeCmd() *cobra.Command {
	var cmdMerge = &cobra.Command{
		Use:     "merge [initial_yaml_file] [additional_yaml_file]...",
		Aliases: []string{"m"},
		Short:   "yq m [--inplace/-i] [--doc/-d index] [--overwrite/-x] [--arrayMerge/-a strategy] sample.yaml sample2.yaml",
		Example: `
yq merge things.yaml other.yaml
yq merge --inplace things.yaml other.yaml
yq m -i things.yaml other.yaml
yq m --overwrite things.yaml other.yaml
yq m -i -x things.yaml other.yaml
yq m -i -a=append things.yaml other.yaml
yq m -i --autocreate=false things.yaml other.yaml
      `,
		Long: `Updates the yaml file by adding/updating the path(s) and value(s) from additional yaml file(s).
Outputs to STDOUT unless the inplace flag is used, in which case the file is updated instead.

If overwrite flag is set then existing values will be overwritten using the values from each additional yaml file.
If append flag is set then existing arrays will be merged with the arrays from each additional yaml file.
`,
		RunE: mergeProperties,
	}
	cmdMerge.PersistentFlags().BoolVarP(&writeInplace, "inplace", "i", false, "update the yaml file inplace")
	cmdMerge.PersistentFlags().BoolVarP(&overwriteFlag, "overwrite", "x", false, "update the yaml file by overwriting existing values")
	cmdMerge.PersistentFlags().BoolVarP(&autoCreateFlag, "autocreate", "c", true, "automatically create any missing entries")
	cmdMerge.PersistentFlags().StringVarP(&arrayMergeStrategyFlag, "arrays", "a", "update", `array merge strategy (update/append/overwrite)
update: recursively update arrays by their index
append: concatenate arrays together
overwrite: replace arrays
`)
	cmdMerge.PersistentFlags().StringVarP(&commentsMergeStrategyFlag, "comments", "", "setWhenBlank", `comments merge strategy (setWhenBlank/ignore/append/overwrite)
setWhenBlank: set comment if the original document has no comment at that node
ignore: leave comments as-is in the original
append: append comments together
overwrite: overwrite comments completely
`)
	cmdMerge.PersistentFlags().StringVarP(&docIndex, "doc", "d", "0", "process document index number (0 based, * for all documents)")
	return cmdMerge
}

/*
* We don't deeply traverse arrays when appending a merge, instead we want to
* append the entire array element.
 */
func createReadFunctionForMerge(arrayMergeStrategy yqlib.ArrayMergeStrategy) func(*yaml.Node) ([]*yqlib.NodeContext, error) {
	return func(dataBucket *yaml.Node) ([]*yqlib.NodeContext, error) {
		return lib.GetForMerge(dataBucket, "**", arrayMergeStrategy)
	}
}

func mergeProperties(cmd *cobra.Command, args []string) error {
	var updateCommands []yqlib.UpdateCommand = make([]yqlib.UpdateCommand, 0)

	if len(args) < 1 {
		return errors.New("Must provide at least 1 yaml file")
	}
	var arrayMergeStrategy yqlib.ArrayMergeStrategy

	switch arrayMergeStrategyFlag {
	case "update":
		arrayMergeStrategy = yqlib.UpdateArrayMergeStrategy
	case "append":
		arrayMergeStrategy = yqlib.AppendArrayMergeStrategy
	case "overwrite":
		arrayMergeStrategy = yqlib.OverwriteArrayMergeStrategy
	default:
		return errors.New("Array merge strategy must be one of: update/append/overwrite")
	}

	var commentsMergeStrategy yqlib.CommentsMergeStrategy

	switch commentsMergeStrategyFlag {
	case "setWhenBlank":
		commentsMergeStrategy = yqlib.SetWhenBlankCommentsMergeStrategy
	case "ignore":
		commentsMergeStrategy = yqlib.IgnoreCommentsMergeStrategy
	case "append":
		commentsMergeStrategy = yqlib.AppendCommentsMergeStrategy
	case "overwrite":
		commentsMergeStrategy = yqlib.OverwriteCommentsMergeStrategy
	default:
		return errors.New("Comments merge strategy must be one of: setWhenBlank/ignore/append/overwrite")
	}

	if len(args) > 1 {
		// first generate update commands from the file
		var filesToMerge = args[1:]

		for _, fileToMerge := range filesToMerge {
			matchingNodes, errorProcessingFile := doReadYamlFile(fileToMerge, createReadFunctionForMerge(arrayMergeStrategy), false, 0)
			if errorProcessingFile != nil {
				return errorProcessingFile
			}
			log.Debugf("finished reading for merge!")
			for _, matchingNode := range matchingNodes {
				log.Debugf("matched node %v", lib.PathStackToString(matchingNode.PathStack))
				yqlib.DebugNode(matchingNode.Node)
			}
			for _, matchingNode := range matchingNodes {
				mergePath := lib.MergePathStackToString(matchingNode.PathStack, arrayMergeStrategy)
				updateCommands = append(updateCommands, yqlib.UpdateCommand{
					Command:               "merge",
					Path:                  mergePath,
					Value:                 matchingNode.Node,
					Overwrite:             overwriteFlag,
					CommentsMergeStrategy: commentsMergeStrategy,
					// dont update the content for nodes midway, only leaf nodes
					DontUpdateNodeContent: matchingNode.IsMiddleNode && (arrayMergeStrategy != yqlib.OverwriteArrayMergeStrategy || matchingNode.Node.Kind != yaml.SequenceNode),
				})
			}
		}
	}

	return updateDoc(args[0], updateCommands, cmd.OutOrStdout())
}