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

Timestamp:

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

Author:

xi

Message:

Major refactoring.

File:

• pyyaml/trunk/lib/yaml/representer.py (modified) (5 diffs)

pyyaml/trunk/lib/yaml/representer.py

@@ -21 +21 @@
     pass
 
-class BaseRepresenter(BaseDetector):
-
-    DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str'
-    DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq'
-    DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map'
-
-    def __init__(self, serializer):
-        self.serializer = serializer
+class BaseRepresenter:
+
+    yaml_representers = {}
+
+    def __init__(self):
         self.represented_objects = {}
 
-    def close(self):
-        self.serializer.close()
-
-    def represent(self, native):
-        node = self.represent_object(native)
-        self.serializer.serialize(node)
+    def represent(self, data):
+        node = self.represent_object(data)
+        self.serialize(node)
         self.represented_objects = {}
 
-    def represent_object(self, native):
-        if self.ignore_aliases(native):
+    def represent_object(self, data):
+        if self.ignore_aliases(data):
             alias_key = None
         else:
-            alias_key = id(native)
+            alias_key = id(data)
         if alias_key is not None:
             if alias_key in self.represented_objects:
                 node = self.represented_objects[alias_key]
                 if node is None:
-                    raise RepresenterError("recursive objects are not allowed: %r" % native)
+                    raise RepresenterError("recursive objects are not allowed: %r" % data)
                 return node
             self.represented_objects[alias_key] = None
-        for native_type in type(native).__mro__:
-            if native_type in self.yaml_representers:
-                node = self.yaml_representers[native_type](self, native)
+        for data_type in type(data).__mro__:
+            if data_type in self.yaml_representers:
+                node = self.yaml_representers[data_type](self, data)
                 break
         else:
             if None in self.yaml_representers:
-                node = self.yaml_representers[None](self, native)
+                node = self.yaml_representers[None](self, data)
             else:
-                node = ScalarNode(None, unicode(native))
+                node = ScalarNode(None, unicode(data))
         if alias_key is not None:
             self.represented_objects[alias_key] = node
         return node
 
-    def add_representer(cls, native_type, representer):
+    def add_representer(cls, data_type, representer):
         if not 'yaml_representers' in cls.__dict__:
             cls.yaml_representers = cls.yaml_representers.copy()
-        cls.yaml_representers[native_type] = representer
+        cls.yaml_representers[data_type] = representer
     add_representer = classmethod(add_representer)
 
-    yaml_representers = {}
-
     def represent_scalar(self, tag, value, style=None):
-        detected_tag = self.detect(value)
-        if detected_tag is None:
-            detected_tag = self.DEFAULT_SCALAR_TAG
-        implicit = (tag == detected_tag)
-        if tag == self.DEFAULT_SCALAR_TAG:
-            tag = None
-        return ScalarNode(tag, value, implicit=implicit, style=style)
+        return ScalarNode(tag, value, style=style)
 
     def represent_sequence(self, tag, sequence, flow_style=None):
-        if tag == self.DEFAULT_SEQUENCE_TAG:
-            tag = None
         value = []
         for item in sequence:
@@ -90 +74 @@
 
     def represent_mapping(self, tag, mapping, flow_style=None):
-        if tag == self.DEFAULT_MAPPING_TAG:
-            tag = None
         value = {}
         if hasattr(mapping, 'keys'):
@@ -104 +86 @@
         return MappingNode(tag, value, flow_style=flow_style)
 
-    def ignore_aliases(self, native):
+    def ignore_aliases(self, data):
         return False
 
-class SafeRepresenter(Detector, BaseRepresenter):
-
-    def ignore_aliases(self, native):
-        if native in [None, ()]:
+class SafeRepresenter(BaseRepresenter):
+
+    def ignore_aliases(self, data):
+        if data in [None, ()]:
             return True
-        if isinstance(native, (str, unicode, bool, int, float)):
+        if isinstance(data, (str, unicode, bool, int, float)):
             return True
 
-    def represent_none(self, native):
+    def represent_none(self, data):
         return self.represent_scalar(u'tag:yaml.org,2002:null',
                 u'null')
 
-    def represent_str(self, native):
+    def represent_str(self, data):
         encoding = None
         try:
-            unicode(native, 'ascii')
+            unicode(data, 'ascii')
             encoding = 'ascii'
         except UnicodeDecodeError:
             try:
-                unicode(native, 'utf-8')
+                unicode(data, 'utf-8')
                 encoding = 'utf-8'
             except UnicodeDecodeError:
@@ -132 +114 @@
         if encoding:
             return self.represent_scalar(u'tag:yaml.org,2002:str',
-                    unicode(native, encoding))
+                    unicode(data, encoding))
         else:
             return self.represent_scalar(u'tag:yaml.org,2002:binary',
-                    unicode(native.encode('base64')), style='|')
-
-    def represent_unicode(self, native):
-        return self.represent_scalar(u'tag:yaml.org,2002:str', native)
-
-    def represent_bool(self, native):
-        if native:
+                    unicode(data.encode('base64')), style='|')
+
+    def represent_unicode(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:str', data)
+
+    def represent_bool(self, data):
+        if data:
             value = u'true'
         else:
@@ -147 +129 @@
         return self.represent_scalar(u'tag:yaml.org,2002:bool', value)
 
-    def represent_int(self, native):
-        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(native))
-
-    def represent_long(self, native):
-        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(native))
+    def represent_int(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data))
+
+    def represent_long(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data))
 
     inf_value = 1e300000
     nan_value = inf_value/inf_value
 
-    def represent_float(self, native):
-        if native == self.inf_value:
+    def represent_float(self, data):
+        if data == self.inf_value:
             value = u'.inf'
-        elif native == -self.inf_value:
+        elif data == -self.inf_value:
             value = u'-.inf'
-        elif native == self.nan_value or native != native:
+        elif data == self.nan_value or data != data:
             value = u'.nan'
         else:
-            value = unicode(native)
+            value = unicode(data)
         return self.represent_scalar(u'tag:yaml.org,2002:float', value)
 
-    def represent_list(self, native):
-        pairs = (len(native) > 0)
-        for item in native:
+    def represent_list(self, data):
+        pairs = (len(data) > 0)
+        for item in data:
             if not isinstance(item, tuple) or len(item) != 2:
                 pairs = False
                 break
         if not pairs:
-            return self.represent_sequence(u'tag:yaml.org,2002:seq', native)
+            return self.represent_sequence(u'tag:yaml.org,2002:seq', data)
         value = []
-        for item_key, item_value in native:
+        for item_key, item_value in data:
             value.append(self.represent_mapping(u'tag:yaml.org,2002:map',
                 [(item_key, item_value)]))
         return SequenceNode(u'tag:yaml.org,2002:pairs', value)
 
-    def represent_dict(self, native):
-        return self.represent_mapping(u'tag:yaml.org,2002:map', native)
-
-    def represent_set(self, native):
+    def represent_dict(self, data):
+        return self.represent_mapping(u'tag:yaml.org,2002:map', data)
+
+    def represent_set(self, data):
         value = {}
-        for key in native:
+        for key in data:
             value[key] = None
         return self.represent_mapping(u'tag:yaml.org,2002:set', value)
 
-    def represent_date(self, native):
-        value = u'%04d-%02d-%02d' % (native.year, native.month, native.day)
+    def represent_date(self, data):
+        value = u'%04d-%02d-%02d' % (data.year, data.month, data.day)
         return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value)
 
-    def represent_datetime(self, native):
+    def represent_datetime(self, data):
         value = u'%04d-%02d-%02d %02d:%02d:%02d' \
-                % (native.year, native.month, native.day,
-                    native.hour, native.minute, native.second)
-        if native.microsecond:
-            value += u'.' + unicode(native.microsecond/1000000.0).split(u'.')[1]
-        if native.utcoffset():
-            value += unicode(native.utcoffset())
+                % (data.year, data.month, data.day,
+                    data.hour, data.minute, data.second)
+        if data.microsecond:
+            value += u'.' + unicode(data.microsecond/1000000.0).split(u'.')[1]
+        if data.utcoffset():
+            value += unicode(data.utcoffset())
         return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value)
 
-    def represent_undefined(self, native):
-        raise RepresenterError("cannot represent an object: %s" % native)
+    def represent_yaml_object(self, tag, data, cls, flow_style=None):
+        if hasattr(data, '__getstate__'):
+            state = data.__getstate__()
+        else:
+            state = data.__dict__.copy()
+        mapping = state
+        if hasattr(state, 'keys'):
+            mapping = []
+            keys = state.keys()
+            keys.sort()
+            for key in keys:
+                mapping.append((key.replace('_', '-'), state[key]))
+        return self.represent_mapping(tag, mapping, flow_style=flow_style)
+
+    def represent_undefined(self, data):
+        raise RepresenterError("cannot represent an object: %s" % data)
 
 SafeRepresenter.add_representer(type(None),