Ignore:
Timestamp:
04/16/06 19:45:21 (9 years ago)
Author:
xi
Message:

Refactor resolver.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pyyaml/trunk/lib/yaml/composer.py

    r136 r137  
    11 
    2 __all__ = ['BaseComposer', 'Composer', 'ComposerError'] 
     2__all__ = ['Composer', 'ComposerError'] 
    33 
    44from error import MarkedYAMLError 
     
    99    pass 
    1010 
    11 class BaseComposer: 
    12  
    13     yaml_resolvers = {} 
     11class Composer: 
    1412 
    1513    def __init__(self): 
    1614        self.all_anchors = {} 
    1715        self.complete_anchors = {} 
    18         self.resolver_tags = [] 
    19         self.resolver_paths = [] 
    2016 
    2117    def check_node(self): 
     
    4339 
    4440        # Compose the root node. 
    45         node = self.compose_node([]) 
     41        node = self.compose_node(None, None) 
    4642 
    4743        # Drop the DOCUMENT-END event. 
     
    5046        self.all_anchors = {} 
    5147        self.complete_anchors = {} 
    52         self.resolver_tags = [] 
    53         self.resolver_paths = [] 
    5448        return node 
    5549 
    56     def increase_resolver_depth(self, path): 
    57         depth = len(path) 
    58         tag = None 
    59         paths = [] 
    60         if not depth: 
    61             for resolver_path in self.yaml_resolvers.keys(): 
    62                 if resolver_path: 
    63                     paths.append(resolver_path) 
    64                 else: 
    65                     tag = self.yaml_resolvers[resolver_path] 
    66         else: 
    67             base, index = path[-1] 
    68             if isinstance(index, ScalarNode)    \ 
    69                     and index.tag == self.DEFAULT_SCALAR_TAG: 
    70                 index = index.value 
    71             elif isinstance(index, Node): 
    72                 index = None 
    73             for resolver_path in self.resolver_paths[-1]: 
    74                 resolver_index = resolver_path[depth-1] 
    75                 if resolver_index is None or resolver_index == index: 
    76                     if len(resolver_index) > depth: 
    77                         paths.append(resolver_path) 
    78                     else: 
    79                         tag = self.yaml_resolvers[resolver_path] 
    80         self.resolver_tags.append(tag) 
    81         self.resolver_paths.append(paths) 
    82  
    83     def decrease_resolver_depth(self): 
    84         del self.resolver_tags[-1] 
    85         del self.resolver_paths[-1] 
    86  
    87     def compose_node(self, path): 
     50    def compose_node(self, parent, index): 
    8851        if self.check_event(AliasEvent): 
    8952            event = self.get_event() 
     
    9962                        event.start_mark) 
    10063            return self.complete_anchors[anchor] 
    101         self.increase_resolver_depth(path) 
    10264        event = self.peek_event() 
    10365        anchor = event.anchor 
     
    10870                        "second occurence", event.start_mark) 
    10971            self.all_anchors[anchor] = event 
     72        self.descend_resolver(parent, index) 
    11073        if self.check_event(ScalarEvent): 
    111             node = self.compose_scalar_node(path) 
     74            node = self.compose_scalar_node() 
    11275        elif self.check_event(SequenceStartEvent): 
    113             node = self.compose_sequence_node(path) 
     76            node = self.compose_sequence_node() 
    11477        elif self.check_event(MappingStartEvent): 
    115             node = self.compose_mapping_node(path) 
     78            node = self.compose_mapping_node() 
    11679        if anchor is not None: 
    11780            self.complete_anchors[anchor] = node 
    118         self.decrease_resolver_depth() 
     81        self.ascend_resolver() 
    11982        return node 
    12083 
    121     def compose_scalar_node(self, path): 
     84    def compose_scalar_node(self): 
    12285        event = self.get_event() 
    123         tag = self.resolve_scalar(path, event.tag, event.implicit, event.value) 
     86        tag = event.tag 
     87        if tag is None or tag == u'!': 
     88            tag = self.resolve(ScalarNode, event.value, event.implicit) 
    12489        return ScalarNode(tag, event.value, 
    12590                event.start_mark, event.end_mark, style=event.style) 
    12691 
    127     def compose_sequence_node(self, path): 
     92    def compose_sequence_node(self): 
    12893        start_event = self.get_event() 
    129         tag = self.resolve_sequence(path, start_event.tag) 
     94        tag = start_event.tag 
     95        if tag is None or tag == u'!': 
     96            tag = self.resolve(SequenceNode, None, start_event.implicit) 
    13097        node = SequenceNode(tag, [], 
    13198                start_event.start_mark, None, 
     
    133100        index = 0 
    134101        while not self.check_event(SequenceEndEvent): 
    135             node.value.append(self.compose_node(path+[(node, index)])) 
     102            node.value.append(self.compose_node(node, index)) 
    136103            index += 1 
    137104        end_event = self.get_event() 
     
    139106        return node 
    140107 
    141     def compose_mapping_node(self, path): 
     108    def compose_mapping_node(self): 
    142109        start_event = self.get_event() 
    143         tag = self.resolve_mapping(path, start_event.tag) 
     110        tag = start_event.tag 
     111        if tag is None or tag == u'!': 
     112            tag = self.resolve(MappingNode, None, start_event.implicit) 
    144113        node = MappingNode(tag, {}, 
    145114                start_event.start_mark, None, 
     
    147116        while not self.check_event(MappingEndEvent): 
    148117            key_event = self.peek_event() 
    149             item_key = self.compose_node(path+[(node, None)]) 
    150             item_value = self.compose_node(path+[(node, item_key)]) 
     118            item_key = self.compose_node(node, None) 
    151119            if item_key in node.value: 
    152120                raise ComposerError("while composing a mapping", start_event.start_mark, 
    153121                        "found duplicate key", key_event.start_mark) 
     122            item_value = self.compose_node(node, item_key) 
    154123            node.value[item_key] = item_value 
    155124        end_event = self.get_event() 
     
    157126        return node 
    158127 
    159     def resolve_scalar(self, path, tag, implicit, value): 
    160         if implicit: 
    161             tag = self.detect(value) 
    162         if tag is None and self.resolver_tags[-1]: 
    163             tag = self.resolver_tags[-1] 
    164         if tag is None or tag == u'!': 
    165             tag = self.DEFAULT_SCALAR_TAG 
    166         return tag 
    167  
    168     def resolve_sequence(self, path, tag): 
    169         if tag is None and self.resolver_tags[-1]: 
    170             tag = self.resolver_tags[-1] 
    171         if tag is None or tag == u'!': 
    172             tag = self.DEFAULT_SEQUENCE_TAG 
    173         return tag 
    174  
    175     def resolve_mapping(self, path, tag): 
    176         if tag is None and self.resolver_tags[-1]: 
    177             tag = self.resolver_tags[-1] 
    178         if tag is None or tag == u'!': 
    179             tag = self.DEFAULT_MAPPING_TAG 
    180         return tag 
    181  
    182     def add_resolver(self, tag, path): 
    183         if not 'yaml_resolvers' in cls.__dict__: 
    184             cls.yaml_resolvers = cls.yaml_resolvers.copy() 
    185         cls.yaml_resolvers[tuple(path)] = tag 
    186     add_resolver = classmethod(add_resolver) 
    187  
    188 class Composer(BaseComposer): 
    189     pass 
    190  
Note: See TracChangeset for help on using the changeset viewer.