Add new function RenameYamlKey

Author: stefanhaller

pkg/utils/yaml_utils/yaml_utils.go

@@ -95,3 +95,58 @@ func lookupKey(node *yaml.Node, key string) (*yaml.Node, *yaml.Node) {
 
 return nil, nil
 }
+
+// takes a yaml document in bytes, a path to a key, and a new name for the key.
+// Will rename the key to the new name if it exists, and do nothing otherwise.
+func RenameYamlKey(yamlBytes []byte, path []string, newKey string) ([]byte, error) {
+// Parse the YAML file.
+var node yaml.Node
+err := yaml.Unmarshal(yamlBytes, &node)
+if err != nil {
+return nil, fmt.Errorf("failed to parse YAML: %w", err)
+}
+
+// Empty document: nothing to do.
+if len(node.Content) == 0 {
+return yamlBytes, nil
+}
+
+body := node.Content[0]
+
+if err := renameYamlKey(body, path, newKey); err != nil {
+return yamlBytes, err
+}
+
+// Convert the updated YAML node back to YAML bytes.
+updatedYAMLBytes, err := yaml.Marshal(body)
+if err != nil {
+return nil, fmt.Errorf("failed to convert YAML node to bytes: %w", err)
+}
+
+return updatedYAMLBytes, nil
+}
+
+// Recursive function to rename the YAML key.
+func renameYamlKey(node *yaml.Node, path []string, newKey string) error {
+if node.Kind != yaml.MappingNode {
+return errors.New("yaml node in path is not a dictionary")
+}
+
+keyNode, valueNode := lookupKey(node, path[0])
+if keyNode == nil {
+return nil
+}
+
+// end of path reached: rename key
+if len(path) == 1 {
+// Check that new key doesn't exist yet
+if newKeyNode, _ := lookupKey(node, newKey); newKeyNode != nil {
+return fmt.Errorf("new key `%s' already exists", newKey)
+}
+
+keyNode.Value = newKey
+return nil
+}
+
+return renameYamlKey(valueNode, path[1:], newKey)
+}

pkg/utils/yaml_utils/yaml_utils_test.go

@@ -106,3 +106,83 @@ func TestUpdateYamlValue(t *testing.T) {
 })
 }
 }
+
+func TestRenameYamlKey(t *testing.T) {
+tests := []struct {
+name string
+in string
+path []string
+newKey string
+expectedOut string
+expectedErr string
+}{
+{
+name: "rename key",
+in: "foo: 5\n",
+path: []string{"foo"},
+newKey: "bar",
+expectedOut: "bar: 5\n",
+expectedErr: "",
+},
+{
+name: "rename key, nested",
+in: "foo:\n bar: 5\n",
+path: []string{"foo", "bar"},
+newKey: "baz",
+// indentation is not preserved. See https://github.com/go-yaml/yaml/issues/899
+expectedOut: "foo:\n baz: 5\n",
+expectedErr: "",
+},
+{
+name: "rename non-scalar key",
+in: "foo:\n bar: 5\n",
+path: []string{"foo"},
+newKey: "qux",
+// indentation is not preserved. See https://github.com/go-yaml/yaml/issues/899
+expectedOut: "qux:\n bar: 5\n",
+expectedErr: "",
+},
+
+// Error cases
+{
+name: "existing document is not a dictionary",
+in: "42\n",
+path: []string{"foo"},
+newKey: "bar",
+expectedOut: "42\n",
+expectedErr: "yaml document is not a dictionary",
+},
+{
+name: "not all path elements are dictionaries",
+in: "foo:\n bar: [1, 2, 3]\n",
+path: []string{"foo", "bar", "baz"},
+newKey: "qux",
+expectedOut: "foo:\n bar: [1, 2, 3]\n",
+expectedErr: "yaml node in path is not a dictionary",
+},
+{
+name: "new key exists",
+in: "foo: 5\nbar: 7\n",
+path: []string{"foo"},
+newKey: "bar",
+expectedOut: "foo: 5\nbar: 7\n",
+expectedErr: "new key `bar' already exists",
+},
+}
+
+for _, test := range tests {
+test := test
+t.Run(test.name, func(t *testing.T) {
+out, err := RenameYamlKey([]byte(test.in), test.path, test.newKey)
+if test.expectedErr != "" {
+if err == nil {
+t.Errorf("expected error %q but got none", test.expectedErr)
+}
+} else if err != nil {
+t.Errorf("unexpected error: %v", err)
+} else if string(out) != test.expectedOut {
+t.Errorf("expected %q but got %q", test.expectedOut, string(out))
+}
+})
+}
+}