Question

是否有一种简单的方法可以将预处理器/宏处理器与YAML文件一起使用？（即我正在考虑C预处理器的内容）？

我们有很多描述各种数据结构的平面文本文件。它们目前采用我们自己的内部格式，并使用内部解析器进行读取。我想切换到YAML文件，以利用各种预先存在的库进行读写。

然而，我们的文件是分层的，因为我们将主文件“包含”到子文件中，并使用变量替换生成新的数据结构。

作为一个玩具示例，我想要类似的东西：

country_master.yaml

name: $COUNTRY$
file: C:\data\$COUNTRY$

UK_country.yaml

#define $COUNTRY$ UK
#include <country_master.yaml>

USA_country.yaml

#define $COUNTRY$ USA
#include <country_master.yaml>

然后在预处理之后我们得到类似的东西：

name: USA
file: C:\data\USA

C预处理器不能使用YAML注释中使用的＃字符。另外，理想情况下我们希望有预处理器扩展的循环，所以在上面的例子中我们创建了一个带有循环的UK和USA（我不相信你可以用cpp循环）

有什么想法吗？

Answer 1

你正试图在YAML的字符串表示层面上改变一些东西，我认为你不应该这样做。 YAML可以加载对象，这些对象可以通过挂钩到解析器来影响后面加载的元素。这样，您可以用数据替换完整节点，更改标量内的值等等。

我们假设你有这个YAML文件main.yml：

- !YAMLPreProcessor
  verbose: '3'
  escape: ♦
- ♦replace(verbose)
- abcd
- ♦include(xyz.yml)
- xyz

且xyz.yml是：

k: 9
l: 8
m: [7. 6]   # can be either

并且你有♦作为特殊字符（只要特殊的YAMLPreProcessor值匹配action关键字的开头（replace和include），它就可以是任何东西。你想要这个进行往返（加载到内存中的数据然后转储到以下YAML：

- !YAMLPreProcessor
  verbose: '3'
  escape: ♦
- '3'
- abcd
- k: 9
  l: 8
  m: [7. 6] # can be either
- xyz

你可以通过重载为每个标量调用的标量构造函数和适当的YAMLPreProcessor类来实现：

# coding: utf-8

from __future__ import print_function

import ruamel.yaml as yaml

def construct_scalar(loader, node):
    self = getattr(loader, '_yaml_preprocessor', None)
    if self and self.d.get('escape'):
        if node.value and node.value.startswith(self.d['escape']):
            key_word, rest = node.value[1:].split('(', 1)
            args, rest = rest.split(')', 1)
            if key_word == 'replace':
                res = u''
                for arg in args.split(','):
                    res += str(self.d[arg])
                node.value = res + rest
            elif key_word == 'include':
                inc_yml = yaml.load(
                    open(args),
                    Loader=yaml.RoundTripLoader
                )
                # this needs ruamel.yaml>=0.9.6
                return inc_yml
            else:
                print('keyword not found:', key_word)
    ret_val = loader._org_construct_scalar(node)
    # print('ret_val', type(ret_val), ret_val)
    return ret_val

class YAMLPreProcessor:
    def __init__(self, escape=None, verbose=0):
        self.d = dict(escape=escape, verbose=verbose)

    def __repr__(self):
        return "YAMLPreProcessor({escape!r}, {verbose})".format(**self.d)

    @staticmethod
    def __yaml_out__(dumper, self):
        return dumper.represent_mapping('!YAMLPreProcessor', self.d)

    @staticmethod
    def __yaml_in__(loader, data):
        from ruamel.yaml.comments import CommentedMap
        result = YAMLPreProcessor()
        loader._yaml_preprocessor = result
        z = dict()
        loader.construct_mapping(data, z)
        result.d = z
        yield result

    def __delete__(self):
        loader._yaml_preprocessor = None



def construct_yaml_str(self, node):
    value = self.construct_scalar(node)
    if isinstance(value, ScalarString):
        return value
    if PY3:
        return value
    try:
        return value.encode('ascii')
    except AttributeError:
        # in case you replace the node dynamically e.g. with a dict
        return value
    except UnicodeEncodeError:
        return value


loader = yaml.RoundTripLoader

loader.add_constructor('!YAMLPreProcessor', YAMLPreProcessor.__yaml_in__)
loader._org_construct_scalar = loader.construct_scalar
loader.construct_scalar = construct_scalar

data_from_yaml = yaml.load(open('main.yml'), Loader=loader)

#print ('out', data_from_yaml)

dumper = yaml.RoundTripDumper
# need to be able to represent '!YAMLPreProcessor'
# but you can of course also remove the first element
# from data_from_yaml if you don't want the preprocessor in your output
dumper.add_representer(YAMLPreProcessor, YAMLPreProcessor.__yaml_out__)

print(yaml.dump(data_from_yaml, Dumper=dumper, allow_unicode=True))

上面需要最新版本的ruamel.yaml（0.9.6）作为旧版本如果construct_scalar返回非字符串对象，则阻塞。

请注意注释后面的位置 m键是相对于行的开头，在那里的示例中无法补偿插入xyz.yml文件的节点的缩进级别。

Answer 2

# Yamp - YAML Macro-Processor
# https://github.com/birchb1024/yamp

# in master.yaml
defmacro:
  name: country
  args: [$COUNTRY$]
  value:
    name: $COUNTRY$
    file: C:\data\{{$COUNTRY$}}
---
# in some file
- include: [master.yaml]

# Call with wherever needed:
{ country: USA }

YAML预处理器/宏处理器

2 个答案: