Ignore:
Timestamp:
04/15/06 19:54:52 (8 years ago)
Author:
xi
Message:

Major refactoring.

File:
1 edited

Legend:

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

    r135 r136  
    1313    ANCHOR_TEMPLATE = u'id%03d' 
    1414 
    15     def __init__(self, emitter, encoding=None, line_break=None, canonical=None, 
    16             indent=None, width=None, allow_unicode=None): 
    17         self.emitter = emitter 
     15    def __init__(self, encoding=None, 
     16            explicit_start=None, explicit_end=None, version=None, tags=None): 
     17        self.use_encoding = encoding 
     18        self.use_explicit_start = explicit_start 
     19        self.use_explicit_end = explicit_end 
     20        self.use_version = version 
     21        self.use_tags = tags 
    1822        self.serialized_nodes = {} 
    1923        self.anchors = {} 
    2024        self.last_anchor_id = 0 
    2125        self.closed = None 
    22         self.open(encoding, line_break, canonical, indent, width, allow_unicode) 
    2326 
    24     def open(self, encoding=None, line_break=None, canonical=None, 
    25             indent=None, width=None, allow_unicode=None): 
     27    def open(self): 
    2628        if self.closed is None: 
    27             self.emitter.emit(StreamStartEvent(encoding=encoding, 
    28                 line_break=line_break, canonical=canonical, 
    29                 indent=indent, width=width, allow_unicode=allow_unicode)) 
     29            self.emit(StreamStartEvent(encoding=self.use_encoding)) 
    3030            self.closed = False 
    3131        elif self.closed: 
     
    3838            raise SerializerError("serializer is not opened") 
    3939        elif not self.closed: 
    40             self.emitter.emit(StreamEndEvent()) 
     40            self.emit(StreamEndEvent()) 
    4141            self.closed = True 
    4242 
    43     def __del__(self): 
    44         self.close() 
     43    #def __del__(self): 
     44    #    self.close() 
    4545 
    46     def serialize(self, node, explicit_start=None, explicit_end=None, 
    47             version=None, tags=None): 
     46    def serialize(self, node): 
    4847        if self.closed is None: 
    4948            raise SerializerError("serializer is not opened") 
    5049        elif self.closed: 
    5150            raise SerializerError("serializer is closed") 
    52         self.emitter.emit(DocumentStartEvent(explicit=explicit_start, 
    53             version=version, tags=tags)) 
     51        self.emit(DocumentStartEvent(explicit=self.use_explicit_start, 
     52            version=self.use_version, tags=self.use_tags)) 
    5453        self.anchor_node(node) 
    5554        self.serialize_node(node) 
    56         self.emitter.emit(DocumentEndEvent(explicit=explicit_end)) 
     55        self.emit(DocumentEndEvent(explicit=self.use_explicit_end)) 
    5756        self.serialized_nodes = {} 
    5857        self.anchors = {} 
     
    8079        alias = self.anchors[node] 
    8180        if node in self.serialized_nodes: 
    82             self.emitter.emit(AliasEvent(alias)) 
     81            self.emit(AliasEvent(alias)) 
    8382        else: 
    8483            self.serialized_nodes[node] = True 
    8584            if isinstance(node, ScalarNode): 
    86                 self.emitter.emit(ScalarEvent(alias, node.tag, node.value, 
    87                     implicit=node.implicit, style=node.style)) 
     85                detected_tag = self.detect(node.value) 
     86                implicit = (node.tag == self.detect(node.value) 
     87                        or (node.tag == self.DEFAULT_SCALAR_TAG 
     88                            and detected_tag is None)) 
     89                self.emit(ScalarEvent(alias, node.tag, implicit, node.value, 
     90                    style=node.style)) 
    8891            elif isinstance(node, SequenceNode): 
    89                 self.emitter.emit(SequenceStartEvent(alias, node.tag, 
     92                # TODO: 
     93                # 1) Check the current path in the Resolver. 
     94                # 2) Add the implicit flag to the SequenceStartEvent and 
     95                # MappingStartEvent. 
     96                tag = node.tag 
     97                if tag == self.DEFAULT_SEQUENCE_TAG and not self.canonical: 
     98                    tag = None 
     99                self.emit(SequenceStartEvent(alias, tag, 
    90100                    flow_style=node.flow_style)) 
    91101                for item in node.value: 
    92102                    self.serialize_node(item) 
    93                 self.emitter.emit(SequenceEndEvent()) 
     103                self.emit(SequenceEndEvent()) 
    94104            elif isinstance(node, MappingNode): 
    95                 self.emitter.emit(MappingStartEvent(alias, node.tag, 
     105                tag = node.tag 
     106                if tag == self.DEFAULT_MAPPING_TAG and not self.canonical: 
     107                    tag = None 
     108                self.emit(MappingStartEvent(alias, tag, 
    96109                    flow_style=node.flow_style)) 
    97                 for key in node.value: 
    98                     self.serialize_node(key) 
    99                     self.serialize_node(node.value[key]) 
    100                 self.emitter.emit(MappingEndEvent()) 
     110                if hasattr(node.value, 'keys'): 
     111                    for key in node.value.keys(): 
     112                        self.serialize_node(key) 
     113                        self.serialize_node(node.value[key]) 
     114                else: 
     115                    for key, value in node.value: 
     116                        self.serialize_node(key) 
     117                        self.serialize_node(value) 
     118                self.emit(MappingEndEvent()) 
    101119 
Note: See TracChangeset for help on using the changeset viewer.