Example of roundtrip with node and processing (modification)

[marco-m-pix4d]

Hello,
thanks for this library!

If I use yaml.MapSlice I am able to easily perform a roundtrip YAML -> Go -> YAML, modify some elements and write them back in the same order, which is very important for any kind of YAML processing to be validated by a human.

Now I would like to go one step further: my input YAML contains anchors and aliases, so I cannot just use yaml.MapSlice to keep the order, since the YAML anchors are expanded by the decoding, so that if I were to write back the YAML, also without any modification, I would still write back all the anchors expanded, which is not what I want.

So I looked at ast.Node, but I am not sure how to use it; by looking at the API, I could not find a way to go back from node to YAML. I might be missing something obvious ?

Probably related: #285

[marco-m-pix4d]

I found this file to be a good example of ast.Node and yaml.Path:
https://github.com/concourse/concourse/blob/master/integration/internal/ypath/ypath.go

Still missing is how to perform manipulation in presence of anchors.

[masenocturnal]

@marco-m-pix4d I am sorry that I don't have the answer to your question, however you said

"If I use yaml.MapSlice I am able to easily perform a roundtrip YAML -> Go -> YAML, modify some elements and write them back in the same order, which is very important for any kind of YAML processing to be validated by a human."

I have been struggling to do just this for a few days. Would it be at all possible for you to share how you achieved this ?

[marco-m-pix4d]

@masenocturnal I think I was referring to this:

func TestGoccyMapSliceRoundTripKeepsOrder(t *testing.T) {
	const yml = `b: 1
a: 2
`
	buf := bytes.NewBufferString(yml)
	dec := yaml.NewDecoder(buf, yaml.UseOrderedMap())
	var roundTrip bytes.Buffer
	enc := yaml.NewEncoder(&roundTrip)
	m := yaml.MapSlice{}

	assert.NilError(t, dec.Decode(&m))
	assert.NilError(t, enc.Encode(m))

	assert.Equal(t, roundTrip.String(), yml)
}

func TestGoccyMapSliceRoundTripReplaceKeepsOrder(t *testing.T) {
	const input = `b: 1
a: 2
`
	const want = `b: 1
a: 42
`
	buf := bytes.NewBufferString(input)
	dec := yaml.NewDecoder(buf, yaml.UseOrderedMap())
	var roundTrip bytes.Buffer
	enc := yaml.NewEncoder(&roundTrip)
	ms := yaml.MapSlice{}
	assert.NilError(t, dec.Decode(&ms))

	// Traverse the MapSlice and replace the value.
	for i := range ms {
		if ms[i].Key.(string) == "a" {
			ms[i].Value = 42
			break
		}
	}
	assert.NilError(t, enc.Encode(ms))

	assert.Equal(t, roundTrip.String(), want)
}

[masenocturnal]

Thank you so much for the example! This has really helped as I can now see it preserves the order. I was previously using the marshal / unmarshal functions without success.

While the order is correct, I do still see some small (but important) differences in the round trip.

This is a small snippet of the input (left) and output (right). Both the 'image_version' key (modifed using the technique you kindly provided) and the 'serilog__minimumLevel__default' key (not modified) are missing the ""

Do you by any chance happen to know if it's possible to ensure the input values and output values are consistent ? particularly if they have not been modified ?