Changeset 136 for pyyaml/trunk/lib/yaml/serializer.py

Timestamp:

04/15/06 19:54:52 (7 years ago)

Author:

xi

Message:

Major refactoring.

File:

• pyyaml/trunk/lib/yaml/serializer.py (modified) (3 diffs)

pyyaml/trunk/lib/yaml/serializer.py

@@ -13 +13 @@
     ANCHOR_TEMPLATE = u'id%03d'
 
-    def __init__(self, emitter, encoding=None, line_break=None, canonical=None,
-            indent=None, width=None, allow_unicode=None):
-        self.emitter = emitter
+    def __init__(self, encoding=None,
+            explicit_start=None, explicit_end=None, version=None, tags=None):
+        self.use_encoding = encoding
+        self.use_explicit_start = explicit_start
+        self.use_explicit_end = explicit_end
+        self.use_version = version
+        self.use_tags = tags
         self.serialized_nodes = {}
         self.anchors = {}
         self.last_anchor_id = 0
         self.closed = None
-        self.open(encoding, line_break, canonical, indent, width, allow_unicode)
 
-    def open(self, encoding=None, line_break=None, canonical=None,
-            indent=None, width=None, allow_unicode=None):
+    def open(self):
         if self.closed is None:
-            self.emitter.emit(StreamStartEvent(encoding=encoding,
-                line_break=line_break, canonical=canonical,
-                indent=indent, width=width, allow_unicode=allow_unicode))
+            self.emit(StreamStartEvent(encoding=self.use_encoding))
             self.closed = False
         elif self.closed:
@@ -38 +38 @@
             raise SerializerError("serializer is not opened")
         elif not self.closed:
-            self.emitter.emit(StreamEndEvent())
+            self.emit(StreamEndEvent())
             self.closed = True
 
-    def __del__(self):
-        self.close()
+    #def __del__(self):
+    #    self.close()
 
-    def serialize(self, node, explicit_start=None, explicit_end=None,
-            version=None, tags=None):
+    def serialize(self, node):
         if self.closed is None:
             raise SerializerError("serializer is not opened")
         elif self.closed:
             raise SerializerError("serializer is closed")
-        self.emitter.emit(DocumentStartEvent(explicit=explicit_start,
-            version=version, tags=tags))
+        self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
+            version=self.use_version, tags=self.use_tags))
         self.anchor_node(node)
         self.serialize_node(node)
-        self.emitter.emit(DocumentEndEvent(explicit=explicit_end))
+        self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
         self.serialized_nodes = {}
         self.anchors = {}
@@ -80 +79 @@
         alias = self.anchors[node]
         if node in self.serialized_nodes:
-            self.emitter.emit(AliasEvent(alias))
+            self.emit(AliasEvent(alias))
         else:
             self.serialized_nodes[node] = True
             if isinstance(node, ScalarNode):
-                self.emitter.emit(ScalarEvent(alias, node.tag, node.value,
-                    implicit=node.implicit, style=node.style))
+                detected_tag = self.detect(node.value)
+                implicit = (node.tag == self.detect(node.value)
+                        or (node.tag == self.DEFAULT_SCALAR_TAG
+                            and detected_tag is None))
+                self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
+                    style=node.style))
             elif isinstance(node, SequenceNode):
-                self.emitter.emit(SequenceStartEvent(alias, node.tag,
+                # TODO:
+                # 1) Check the current path in the Resolver.
+                # 2) Add the implicit flag to the SequenceStartEvent and
+                # MappingStartEvent.
+                tag = node.tag
+                if tag == self.DEFAULT_SEQUENCE_TAG and not self.canonical:
+                    tag = None
+                self.emit(SequenceStartEvent(alias, tag,
                     flow_style=node.flow_style))
                 for item in node.value:
                     self.serialize_node(item)
-                self.emitter.emit(SequenceEndEvent())
+                self.emit(SequenceEndEvent())
             elif isinstance(node, MappingNode):
-                self.emitter.emit(MappingStartEvent(alias, node.tag,
+                tag = node.tag
+                if tag == self.DEFAULT_MAPPING_TAG and not self.canonical:
+                    tag = None
+                self.emit(MappingStartEvent(alias, tag,
                     flow_style=node.flow_style))
-                for key in node.value:
-                    self.serialize_node(key)
-                    self.serialize_node(node.value[key])
-                self.emitter.emit(MappingEndEvent())
+                if hasattr(node.value, 'keys'):
+                    for key in node.value.keys():
+                        self.serialize_node(key)
+                        self.serialize_node(node.value[key])
+                else:
+                    for key, value in node.value:
+                        self.serialize_node(key)
+                        self.serialize_node(value)
+                self.emit(MappingEndEvent())