Preserve original formatting when serializing

[henrikje]

Hi Anton! 👋🙂

In my current use case, I have a user-edited toml file where I sometimes want to update a specific value programmatically. In this scenario, I would want to update the file without losing any comments or custom white space added by the user (except when directly affected by the change).

In the the most general form, TomlValue.from(path).write(path) would be a "no-op". If the TomlValue is modified between reading and writing as little formatting should change as possible. As a more special case, I could imagine a special operation which writes a new value to a single specified key without decoding the full document. But that may not be in line with the current API.

I understand that this may be a fundamental change and simply out of scope, but it doesn't hurt to ask, right? 😁

[valderman]

I think this would be doable for 90% of cases without too much work. The last 10% would be significantly harder. Consider the following examples:

[foo]
bar = 123

foo = {bar = 123}

foo.bar = 123

All of these map to {"foo": {"bar": 123}} in JSON notation. While the two first cases are easy enough to handle - just annotate foo with the type of dictionary it corresponds to - the third one is a problem. Handling cases like this would require replacing the current simple pretty-printing algorithm with some slow and convoluted hackery, and the annotations to support it would be pretty invasive to boot.

Would a best effort solution, which does the right thing as long as you only use the first two forms but converts the third form into the first during a roundtrip, still be useful?

[henrikje]

In my case, I have an end-user editable configuration file which may include custom formatting and comments. The file is read in full and decoded to data classes on startup. In some cases I want to persist changes to the configuration. Typicaly, I have one or a few specific value(s) that I want to change programmatically. The rest of the file should not be changed (i.e. preserving custom white space and comments).

The value (X) I want to change may be at different levels, such as:

a = "X"

[a]
b.c = "X"

[a]
b = [ "X", "y", "z" ]

[a]
b = [ { c = "X", d = "y" }, { e = "z" } ]

As hinted at earlier, if it is simpler, for my use case it would be fine to say something like:

tomlMapper.encodeInline(tomlFilePath, "a.b.c", newValue)

In this case, the full file would not be decoded. Instead, it would be parsed only enough to identify the "bounds" of the existing value for that key in the file, and then replace that part of the file with the new value.