I'd like to have one yaml object refer to another, like so:
intro: "Hello, dear user."
registration: $intro Thanks for registering!
new_message: $intro You have a new message!
The above syntax is just an example of how it might work (it's also how it seems to work in this cpan module.)
I'm using the standard ruby yaml parser.
Is this possible?
No, standard YAML does not include any kind of "import" or "include" statement. You could create a ! include <filename> handler. @clarkevans sure, but that construct would be "outside" the YAML language.
JSON. YAML 1.2 is a superset of JavaScript Object Notation (JSON) but has some built-in advantages. For example, YAML can self-reference, support complex datatypes, embed block literals, support comments, and more.
With this directive, you can inherit from an existing registered definition item in order to create a new definition item.
Yaml files can be merged using the 'merge' command. Each additional file merged with the first file will set values for any key not existing already or where the key has no value.
Some yaml objects do refer to the others:
irb> require 'yaml'
#=> true
irb> str = "hello"
#=> "hello"
irb> hash = { :a => str, :b => str }
#=> {:a=>"hello", :b=>"hello"}
irb> puts YAML.dump(hash)
---
:a: hello
:b: hello
#=> nil
irb> puts YAML.dump([str,str])
---
- hello
- hello
#=> nil
irb> puts YAML.dump([hash,hash])
---
- &id001
:a: hello
:b: hello
- *id001
#=> nil
Note that it doesn't always reuse objects (the string is just repeated) but it does sometimes (the hash is defined once and reused by reference).
YAML doesn't support string interpolation - which is what you seem to be trying to do - but there's no reason you couldn't encode it a bit more verbosely:
intro: Hello, dear user
registration:
- "%s Thanks for registering!"
- intro
new_message:
- "%s You have a new message!"
- intro
Then you can interpolate it after you load the YAML:
strings = YAML::load(yaml_str)
interpolated = {}
strings.each do |key,val|
if val.kind_of? Array
fmt, *args = *val
val = fmt % args.map { |arg| strings[arg] }
end
interpolated[key] = val
end
And this will yield the following for interpolated
:
{
"intro"=>"Hello, dear user",
"registration"=>"Hello, dear user Thanks for registering!",
"new_message"=>"Hello, dear user You have a new message!"
}
Rather than trying to use implicit references in your yaml, why don't you use substitution strings (like you show above, you need quotes though) and explicitly substitute the contents of them at parse time?
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With