Closed theamarin closed 2 years ago
There are two issues here:
The first is the problem of referencing anchors in ignored structure. This is a non-trivial problem due to the way NimYAML deserializes data currently. There are some interesting nuances:
anchors:
- &a
id: &b anchor
items:
- id: *b
- *a
If NimYAML was to say „well I'll remember the anchored events for later“ then in this instance, it'd remember both the &a
and the &b
anchored events, where the second is within the first. Then at *b
, we can create a string from anchor
. At *a
, we will now have the situation where we need to generate a value but parts of the value have already been constructed. Not only will the construction of *a
need to construct a value seen earlier, it also needs to inject that value into the stored events of &a
to make this fully correct.
The second issue is that you want to deserialize an alias node into a non-ref type. This would currently fail even without the ignored part, e.g.
items:
- &a
id: droggeljug
- *a
You'd get
Error: unhandled exception: Anchor on non-ref type [YamlConstructionError]
Should NimYAML support that in this special case? I don't think so; the rule
you can only have anchors on ref types
is simple while
you can have anchors on ref types and in ignored sections as long as they are referred to at most once
makes the API rather confusing.
When we take the second issue out of the equation by making Item
a ref object
, I think NimYAML should be able to properly load this. This will not be trivial to implement and may take a while, but I'll try to do it.
Thank you again for your quick reply and thorough analysis!
I am absolutely happy to make Item
a ref object
to simplify things. It absolutely makes sense to allow anchors only on ref types, I should have spotted this one.
Workaround:
var node: YamlNode
load(input, node)
var stream = represent(node, tsNone, asNone)
discard stream.next() # skip stream start event
var main: Main
construct(stream, main)
This loads the YAML into a node graph, then generates a stream from those with asNone
which will duplicate a node each time an alias would be produced. That stream can then be loaded into the given type. I would suggest using this approach for situations where YAML anchors are used like variables, however I seriously need to fix the problem of this going in an endless loop when there's a loop in the node graph.
This use-case has now been implemented via
import yaml / [serialization, dom]
let input = """
anchors:
- &myAnchor
id: anchor
items:
- *myAnchor
"""
type
Main {.ignore: ["anchors"].} = object
items: seq[Item]
Item = object
id: string
var main: Main
loadFlattened(input, main)
echo $main
loadFlattened
replaces aliases with resolved content before loading and basically implements the workaround I've shown. It is available from the dom
API since it uses the DOM as shown.
Error messages have been updated appropriately.
I am using the workaround you proposed above in my code quite a lot by now, as it leverages the need to use ref object
s whenever anchors are used.
Just as a reference for others who might want to use this, here is how it looks like with nim-yaml v2:
var s: FileStream = newFileStream(filePath)
var node: YamlNode
load(s, node)
s.close()
# Inline anchors
var stream = represent(node, SerializationOptions(anchorStyle: asNone))
discard stream.next() # skip stream start event
var main: Main
construct(stream, main)
Hi @flyx,
thank you so much for your unflinching support!
If I define an anchor in a scope that is ignored by NimYAML, it won't be recognized.
Non-working example:
With the following output:
Please note that in yaml/serialization.nim:1211,
e.aliasTarget
is notinc.refs
, soval.tag
is empty.I am not sure if this should be fixed or if just the error handling should be adapted, e.g., as follows:
If you want to fix this, you would probably need to construct the data (and add it to the context refs) when the yamlAlias is reached, as otherwise its data type is unknown.
Any feedback is appreciated.
Thank you!