我有以下 YAML：
paths:
patha: /path/to/root/a
pathb: /path/to/root/b
pathc: /path/to/root/c
我如何通过/path/to/root/从三个路径中删除来“规范化”它，并将其作为自己的设置，例如：
paths:
root: /path/to/root/
patha: *root* + a
pathb: *root* + b
pathc: *root* + c
显然这是无效的，我只是编造的。真正的语法是什么？可以做到吗？
我不认为这是可能的。您可以重用“节点”，但不能重用它的一部分。
bill-to: &id001
given : Chris
family : Dumars
ship-to: *id001
这是完全有效的 YAML 和字段given，可以在块family中重用。ship-to您可以以相同的方式重用标量节点，但您无法更改内部的内容并从 YAML 内部添加路径的最后一部分。
如果重复让您非常困扰，我建议让您的应用程序了解root属性并将其添加到每个看起来相对而不是绝对的路径中。
是的，使用自定义标签。Python中的示例，使!join标签连接数组中的字符串：
import yaml
## define custom tag handler
def join(loader, node):
seq = loader.construct_sequence(node)
return ''.join([str(i) for i in seq])
## register the tag handler
yaml.add_constructor('!join', join)
## using your sample data
yaml.load("""
paths:
root: &BASE /path/to/root/
patha: !join [*BASE, a]
pathb: !join [*BASE, b]
pathc: !join [*BASE, c]
""")
结果是：
{
'paths': {
'patha': '/path/to/root/a',
'pathb': '/path/to/root/b',
'pathc': '/path/to/root/c',
'root': '/path/to/root/'
}
}
的参数数组!join可以包含任意数量的任何数据类型的元素，只要它们可以转换为字符串，!join [*a, "/", *b, "/", *c]您所期望的也是如此。
另一种看待这一点的方法是简单地使用另一个字段。
paths:
root_path: &root
val: /path/to/root/
patha: &a
root_path: *root
rel_path: a
pathb: &b
root_path: *root
rel_path: b
pathc: &c
root_path: *root
rel_path: c
我创建了一个库，可在 Packagist 上使用，它执行此功能： https ://packagist.org/packages/grasmash/yaml-expander
示例 YAML 文件：
type: book
book:
title: Dune
author: Frank Herbert
copyright: ${book.author} 1965
protaganist: ${characters.0.name}
media:
- hardcover
characters:
- name: Paul Atreides
occupation: Kwisatz Haderach
aliases:
- Usul
- Muad'Dib
- The Preacher
- name: Duncan Idaho
occupation: Swordmaster
summary: ${book.title} by ${book.author}
product-name: ${${type}.title}
示例逻辑：
// Parse a yaml string directly, expanding internal property references.
$yaml_string = file_get_contents("dune.yml");
$expanded = \Grasmash\YamlExpander\Expander::parse($yaml_string);
print_r($expanded);
结果数组：
array (
'type' => 'book',
'book' =>
array (
'title' => 'Dune',
'author' => 'Frank Herbert',
'copyright' => 'Frank Herbert 1965',
'protaganist' => 'Paul Atreides',
'media' =>
array (
0 => 'hardcover',
),
),
'characters' =>
array (
0 =>
array (
'name' => 'Paul Atreides',
'occupation' => 'Kwisatz Haderach',
'aliases' =>
array (
0 => 'Usul',
1 => 'Muad\'Dib',
2 => 'The Preacher',
),
),
1 =>
array (
'name' => 'Duncan Idaho',
'occupation' => 'Swordmaster',
),
),
'summary' => 'Dune by Frank Herbert',
);
YML 定义：
dir:
default: /home/data/in/
proj1: ${dir.default}p1
proj2: ${dir.default}p2
proj3: ${dir.default}p3
在百里香叶的某个地方
<p th:utext='${@environment.getProperty("dir.default")}' />
<p th:utext='${@environment.getProperty("dir.proj1")}' />
输出： /home/data/in/ /home/data/in/p1
在某些语言中，您可以使用替代库，例如，tampax是 YAML 处理变量的实现：
const tampax = require('tampax');
const yamlString = `
dude:
name: Arthur
weapon:
favorite: Excalibur
useless: knife
sentence: "{{dude.name}} use {{weapon.favorite}}. The goal is {{goal}}."`;
const r = tampax.yamlParseString(yamlString, { goal: 'to kill Mordred' });
console.log(r.sentence);
// output : "Arthur use Excalibur. The goal is to kill Mordred."
编者注：海报也是这个包的作者。
您的示例无效只是因为您选择了一个保留字符来开始您的标量。如果您将 替换为*其他一些非保留字符（我倾向于使用非 ASCII 字符，因为它们很少用作某些规范的一部分），您最终会得到完全合法的 YAML：
paths:
root: /path/to/root/
patha: ♦root♦ + a
pathb: ♦root♦ + b
pathc: ♦root♦ + c
这将加载到解析器使用的语言映射的标准表示中，并且不会神奇地扩展任何内容。
为此，请使用以下 Python 程序中的本地默认对象类型：
# coding: utf-8
from __future__ import print_function
import ruamel.yaml as yaml
class Paths:
def __init__(self):
self.d = {}
def __repr__(self):
return repr(self.d).replace('ordereddict', 'Paths')
@staticmethod
def __yaml_in__(loader, data):
result = Paths()
loader.construct_mapping(data, result.d)
return result
@staticmethod
def __yaml_out__(dumper, self):
return dumper.represent_mapping('!Paths', self.d)
def __getitem__(self, key):
res = self.d[key]
return self.expand(res)
def expand(self, res):
try:
before, rest = res.split(u'♦', 1)
kw, rest = rest.split(u'♦ +', 1)
rest = rest.lstrip() # strip any spaces after "+"
# the lookup will throw the correct keyerror if kw is not found
# recursive call expand() on the tail if there are multiple
# parts to replace
return before + self.d[kw] + self.expand(rest)
except ValueError:
return res
yaml_str = """\
paths: !Paths
root: /path/to/root/
patha: ♦root♦ + a
pathb: ♦root♦ + b
pathc: ♦root♦ + c
"""
loader = yaml.RoundTripLoader
loader.add_constructor('!Paths', Paths.__yaml_in__)
paths = yaml.load(yaml_str, Loader=yaml.RoundTripLoader)['paths']
for k in ['root', 'pathc']:
print(u'{} -> {}'.format(k, paths[k]))
这将打印：
root -> /path/to/root/
pathc -> /path/to/root/c
扩展是即时完成的并处理嵌套定义，但您必须小心不要调用无限递归。
通过指定转储程序，您可以从加载的数据中转储原始 YAML，因为动态扩展：
dumper = yaml.RoundTripDumper
dumper.add_representer(Paths, Paths.__yaml_out__)
print(yaml.dump(paths, Dumper=dumper, allow_unicode=True))
这将改变映射键的顺序。如果这是一个问题，你必须做self.d一个CommentedMap（从 导入ruamel.yaml.comments.py）
使用Yglu，您可以将示例编写为：
paths:
root: /path/to/root/
patha: !? .paths.root + a
pathb: !? .paths.root + b
pathc: !? .paths.root + c
免责声明：我是 Yglu 的作者。
我在 Python 上编写了自己的库，以扩展从目录加载的变量，其层次结构如下：
/root
|
+- /proj1
|
+- config.yaml
|
+- /proj2
|
+- config.yaml
|
... and so on ...
这里的关键区别在于，必须在加载所有文件后才应用扩展config.yaml，其中下一个文件中的变量可以覆盖前一个文件中的变量，因此伪代码应如下所示：
env = YamlEnv()
env.load('/root/proj1/config.yaml')
env.load('/root/proj1/proj2/config.yaml')
...
env.expand()
作为附加选项，xonsh脚本可以将结果变量导出到环境变量中（参见yaml_update_global_vars函数）。
脚本：
https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/python/cmdoplib/cmdoplib.yaml.xsh https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/python /tacklelib/tacklelib.yaml.py
优点：
${MYUNDEFINEDVAR}-> *$/{MYUNDEFINEDVAR})${env:MYVAR})\\为( )/${env:MYVAR:path}缺点：
${MYSCOPE.MYVAR}的东西没有实现）