lib/yaml/serializer.py

   1
   2 __all__ = ['Serializer', 'SerializerError']
   3
   4 from error import YAMLError
   5 from events import *
   6 from nodes import *
   7
   8 class SerializerError(YAMLError):
   9     pass
  10
  11 class Serializer:
  12
  13     ANCHOR_TEMPLATE = u'id%03d'
  14
  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
  22         self.serialized_nodes = {}
  23         self.anchors = {}
  24         self.last_anchor_id = 0
  25         self.closed = None
  26
  27     def open(self):
  28         if self.closed is None:
  29             self.emit(StreamStartEvent(encoding=self.use_encoding))
  30             self.closed = False
  31         elif self.closed:
  32             raise SerializerError("serializer is closed")
  33         else:
  34             raise SerializerError("serializer is already opened")
  35
  36     def close(self):
  37         if self.closed is None:
  38             raise SerializerError("serializer is not opened")
  39         elif not self.closed:
  40             self.emit(StreamEndEvent())
  41             self.closed = True
  42
  43     #def __del__(self):
  44     #    self.close()
  45
  46     def serialize(self, node):
  47         if self.closed is None:
  48             raise SerializerError("serializer is not opened")
  49         elif self.closed:
  50             raise SerializerError("serializer is closed")
  51         self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
  52             version=self.use_version, tags=self.use_tags))
  53         self.anchor_node(node)
  54         self.serialize_node(node, None, None)
  55         self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
  56         self.serialized_nodes = {}
  57         self.anchors = {}
  58         self.last_alias_id = 0
  59
  60     def anchor_node(self, node):
  61         if node in self.anchors:
  62             if self.anchors[node] is None:
  63                 self.anchors[node] = self.generate_anchor(node)
  64         else:
  65             self.anchors[node] = None
  66             if isinstance(node, SequenceNode):
  67                 for item in node.value:
  68                     self.anchor_node(item)
  69             elif isinstance(node, MappingNode):
  70                 if hasattr(node.value, 'keys'):
  71                     for key in node.value.keys():
  72                         self.anchor_node(key)
  73                         self.anchor_node(node.value[key])
  74                 else:
  75                     for key, value in node.value:
  76                         self.anchor_node(key)
  77                         self.anchor_node(value)
  78
  79     def generate_anchor(self, node):
  80         self.last_anchor_id += 1
  81         return self.ANCHOR_TEMPLATE % self.last_anchor_id
  82
  83     def serialize_node(self, node, parent, index):
  84         alias = self.anchors[node]
  85         if node in self.serialized_nodes:
  86             self.emit(AliasEvent(alias))
  87         else:
  88             self.serialized_nodes[node] = True
  89             self.descend_resolver(parent, index)
  90             if isinstance(node, ScalarNode):
  91                 detected_tag = self.resolve(ScalarNode, node.value, (True, False))
  92                 default_tag = self.resolve(ScalarNode, node.value, (False, True))
  93                 implicit = (node.tag == detected_tag), (node.tag == default_tag)
  94                 self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
  95                     style=node.style))
  96             elif isinstance(node, SequenceNode):
  97                 implicit = (node.tag
  98                             == self.resolve(SequenceNode, node.value, True))
  99                 self.emit(SequenceStartEvent(alias, node.tag, implicit,
 100                     flow_style=node.flow_style))
 101                 index = 0
 102                 for item in node.value:
 103                     self.serialize_node(item, node, index)
 104                     index += 1
 105                 self.emit(SequenceEndEvent())
 106             elif isinstance(node, MappingNode):
 107                 implicit = (node.tag
 108                             == self.resolve(MappingNode, node.value, True))
 109                 self.emit(MappingStartEvent(alias, node.tag, implicit,
 110                     flow_style=node.flow_style))
 111                 if hasattr(node.value, 'keys'):
 112                     for key in node.value.keys():
 113                         self.serialize_node(key, node, None)
 114                         self.serialize_node(node.value[key], node, key)
 115                 else:
 116                     for key, value in node.value:
 117                         self.serialize_node(key, node, None)
 118                         self.serialize_node(value, node, key)
 119                 self.emit(MappingEndEvent())
 120             self.ascend_resolver()
 121