source: pyyaml/trunk/lib3/yaml/resolver.py @ 328

Revision 328, 8.6 KB checked in by xi, 5 years ago (diff)

Added basic support for Python 3 (Thanks idadesub(at)users(dot)sourceforge(dot)net).

RevLine 
[133]1
[137]2__all__ = ['BaseResolver', 'Resolver']
[133]3
[328]4from .error import *
5from .nodes import *
[137]6
[133]7import re
8
[137]9class ResolverError(YAMLError):
10    pass
[133]11
[328]12class BaseResolver:
[137]13
[328]14    DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
15    DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'
16    DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
[136]17
[137]18    yaml_implicit_resolvers = {}
19    yaml_path_resolvers = {}
[133]20
[136]21    def __init__(self):
[137]22        self.resolver_exact_paths = []
23        self.resolver_prefix_paths = []
[136]24
[328]25    @classmethod
[137]26    def add_implicit_resolver(cls, tag, regexp, first):
27        if not 'yaml_implicit_resolvers' in cls.__dict__:
28            cls.yaml_implicit_resolvers = cls.yaml_implicit_resolvers.copy()
[155]29        if first is None:
30            first = [None]
[133]31        for ch in first:
[137]32            cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp))
[133]33
[328]34    @classmethod
[137]35    def add_path_resolver(cls, tag, path, kind=None):
[246]36        # Note: `add_path_resolver` is experimental.  The API could be changed.
37        # `new_path` is a pattern that is matched against the path from the
38        # root to the node that is being considered.  `node_path` elements are
39        # tuples `(node_check, index_check)`.  `node_check` is a node class:
40        # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`.  `None`
41        # matches any kind of a node.  `index_check` could be `None`, a boolean
42        # value, a string value, or a number.  `None` and `False` match against
43        # any _value_ of sequence and mapping nodes.  `True` matches against
44        # any _key_ of a mapping node.  A string `index_check` matches against
45        # a mapping value that corresponds to a scalar key which content is
46        # equal to the `index_check` value.  An integer `index_check` matches
47        # against a sequence value with the index equal to `index_check`.
[137]48        if not 'yaml_path_resolvers' in cls.__dict__:
49            cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy()
50        new_path = []
51        for element in path:
52            if isinstance(element, (list, tuple)):
53                if len(element) == 2:
54                    node_check, index_check = element
55                elif len(element) == 1:
56                    node_check = element[0]
57                    index_check = True
58                else:
59                    raise ResolverError("Invalid path element: %s" % element)
60            else:
61                node_check = None
62                index_check = element
63            if node_check is str:
64                node_check = ScalarNode
65            elif node_check is list:
66                node_check = SequenceNode
[158]67            elif node_check is dict:
[137]68                node_check = MappingNode
69            elif node_check not in [ScalarNode, SequenceNode, MappingNode]  \
[328]70                    and not isinstance(node_check, str) \
[137]71                    and node_check is not None:
72                raise ResolverError("Invalid node checker: %s" % node_check)
[328]73            if not isinstance(index_check, (str, int))  \
[137]74                    and index_check is not None:
75                raise ResolverError("Invalid index checker: %s" % index_check)
76            new_path.append((node_check, index_check))
77        if kind is str:
78            kind = ScalarNode
79        elif kind is list:
80            kind = SequenceNode
[158]81        elif kind is dict:
[137]82            kind = MappingNode
83        elif kind not in [ScalarNode, SequenceNode, MappingNode]    \
84                and kind is not None:
85            raise ResolverError("Invalid node kind: %s" % kind)
86        cls.yaml_path_resolvers[tuple(new_path), kind] = tag
87
88    def descend_resolver(self, current_node, current_index):
[223]89        if not self.yaml_path_resolvers:
90            return
[137]91        exact_paths = {}
92        prefix_paths = []
93        if current_node:
94            depth = len(self.resolver_prefix_paths)
95            for path, kind in self.resolver_prefix_paths[-1]:
96                if self.check_resolver_prefix(depth, path, kind,
97                        current_node, current_index):
98                    if len(path) > depth:
99                        prefix_paths.append((path, kind))
100                    else:
101                        exact_paths[kind] = self.yaml_path_resolvers[path, kind]
[133]102        else:
[137]103            for path, kind in self.yaml_path_resolvers:
104                if not path:
105                    exact_paths[kind] = self.yaml_path_resolvers[path, kind]
106                else:
107                    prefix_paths.append((path, kind))
108        self.resolver_exact_paths.append(exact_paths)
109        self.resolver_prefix_paths.append(prefix_paths)
[133]110
[137]111    def ascend_resolver(self):
[223]112        if not self.yaml_path_resolvers:
113            return
[137]114        self.resolver_exact_paths.pop()
115        self.resolver_prefix_paths.pop()
116
117    def check_resolver_prefix(self, depth, path, kind,
118            current_node, current_index):
119        node_check, index_check = path[depth-1]
[328]120        if isinstance(node_check, str):
[137]121            if current_node.tag != node_check:
122                return
123        elif node_check is not None:
124            if not isinstance(current_node, node_check):
125                return
126        if index_check is True and current_index is not None:
127            return
[246]128        if (index_check is False or index_check is None)    \
129                and current_index is None:
[137]130            return
[328]131        if isinstance(index_check, str):
[137]132            if not (isinstance(current_index, ScalarNode)
133                    and index_check == current_index.value):
134                return
[246]135        elif isinstance(index_check, int) and not isinstance(index_check, bool):
[137]136            if index_check != current_index:
137                return
138        return True
139
140    def resolve(self, kind, value, implicit):
141        if kind is ScalarNode and implicit[0]:
[328]142            if value == '':
143                resolvers = self.yaml_implicit_resolvers.get('', [])
[137]144            else:
145                resolvers = self.yaml_implicit_resolvers.get(value[0], [])
146            resolvers += self.yaml_implicit_resolvers.get(None, [])
147            for tag, regexp in resolvers:
148                if regexp.match(value):
149                    return tag
150            implicit = implicit[1]
[223]151        if self.yaml_path_resolvers:
152            exact_paths = self.resolver_exact_paths[-1]
153            if kind in exact_paths:
154                return exact_paths[kind]
155            if None in exact_paths:
156                return exact_paths[None]
[137]157        if kind is ScalarNode:
158            return self.DEFAULT_SCALAR_TAG
159        elif kind is SequenceNode:
160            return self.DEFAULT_SEQUENCE_TAG
161        elif kind is MappingNode:
162            return self.DEFAULT_MAPPING_TAG
163
164class Resolver(BaseResolver):
[133]165    pass
166
[137]167Resolver.add_implicit_resolver(
[328]168        'tag:yaml.org,2002:bool',
169        re.compile(r'''^(?:yes|Yes|YES|no|No|NO
[133]170                    |true|True|TRUE|false|False|FALSE
171                    |on|On|ON|off|Off|OFF)$''', re.X),
[328]172        list('yYnNtTfFoO'))
[133]173
[137]174Resolver.add_implicit_resolver(
[328]175        'tag:yaml.org,2002:float',
176        re.compile(r'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?
[260]177                    |\.[0-9_]+(?:[eE][-+][0-9]+)?
[133]178                    |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
179                    |[-+]?\.(?:inf|Inf|INF)
180                    |\.(?:nan|NaN|NAN))$''', re.X),
[328]181        list('-+0123456789.'))
[133]182
[137]183Resolver.add_implicit_resolver(
[328]184        'tag:yaml.org,2002:int',
185        re.compile(r'''^(?:[-+]?0b[0-1_]+
[133]186                    |[-+]?0[0-7_]+
187                    |[-+]?(?:0|[1-9][0-9_]*)
188                    |[-+]?0x[0-9a-fA-F_]+
189                    |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X),
[328]190        list('-+0123456789'))
[133]191
[137]192Resolver.add_implicit_resolver(
[328]193        'tag:yaml.org,2002:merge',
194        re.compile(r'^(?:<<)$'),
[133]195        ['<'])
196
[137]197Resolver.add_implicit_resolver(
[328]198        'tag:yaml.org,2002:null',
199        re.compile(r'''^(?: ~
[133]200                    |null|Null|NULL
201                    | )$''', re.X),
[328]202        ['~', 'n', 'N', ''])
[133]203
[137]204Resolver.add_implicit_resolver(
[328]205        'tag:yaml.org,2002:timestamp',
206        re.compile(r'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]
[133]207                    |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]?
208                     (?:[Tt]|[ \t]+)[0-9][0-9]?
209                     :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)?
210                     (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X),
[328]211        list('0123456789'))
[133]212
[137]213Resolver.add_implicit_resolver(
[328]214        'tag:yaml.org,2002:value',
215        re.compile(r'^(?:=)$'),
[133]216        ['='])
217
[137]218# The following resolver is only for documentation purposes. It cannot work
[133]219# because plain scalars cannot start with '!', '&', or '*'.
[137]220Resolver.add_implicit_resolver(
[328]221        'tag:yaml.org,2002:yaml',
222        re.compile(r'^(?:!|&|\*)$'),
223        list('!&*'))
[133]224
Note: See TracBrowser for help on using the repository browser.