Changeset 20

Timestamp:

08/12/05 16:15:19 (8 years ago)

Author:

xi

Message:

syck.dump() is implemented.

Location:

trunk

Files:

• ext/_syckmodule.c (modified) (4 diffs)
• lib/syck/dumpers.py (modified) (4 diffs)
• sandbox/syck-parser/syck-parser.c (modified) (2 diffs)
• sandbox/syck-parser/test_aliases.yml (added)
• sandbox/syck-parser/test_aliases2.yml (added)
• tests/test_dumper.py (modified) (3 diffs)
• tests/test_loader.py (modified) (2 diffs)
• tests/test_parser.py (modified) (2 diffs)
• tests/test_syck.py (modified) (1 diff)

trunk/ext/_syckmodule.c

@@ -1059 +1059 @@
             if (!object) goto error;
             for (k = 0; k < node->data.list->idx; k++) {
-                index = syck_seq_read(node, k);
+                index = syck_seq_read(node, k)-1;
                 value = PyList_GetItem(self->symbols, index);
                 if (!value) goto error;
@@ -1073 +1073 @@
             for (k = 0; k < node->data.pairs->idx; k++)
             {
-                index = syck_map_read(node, map_key, k);
+                index = syck_map_read(node, map_key, k)-1;
                 key = PyList_GetItem(self->symbols, index);
                 if (!key) goto error;
-                index = syck_map_read(node, map_value, k);
+                index = syck_map_read(node, map_value, k)-1;
                 value = PyList_GetItem(self->symbols, index);
                 if (!value) goto error;
@@ -1098 +1098 @@
         goto error;
 
-    index = PyList_GET_SIZE(self->symbols)-1;
+    index = PyList_GET_SIZE(self->symbols);
     return index;
 
@@ -1268 +1268 @@
 
     self->parsing = 1;
-    index = syck_parse(self->parser);
+    index = syck_parse(self->parser)-1;
     self->parsing = 0;
 

trunk/lib/syck/dumpers.py

@@ -10 +10 @@
     'emit', 'dump', 'emit_documents', 'dump_documents']
 
+INF = 1e300000
+NEGINF = -INF
+NAN = INF/INF
+
+
 class GenericDumper(_syck.Emitter):
 
@@ -16 +21 @@
 
     def _convert(self, object, object_to_node):
-        if id(object) in object_to_node:
+        if id(object) in object_to_node and self.allow_aliases(object):
             return object_to_node[id(object)]
         node = self.represent(object)
@@ -29 +34 @@
                 node.value[self._convert(key, object_to_node)] =    \
                         self._convert(value, object_to_node)
+#        # Workaround against a Syck bug:
+#        if node.kind == 'scalar' and node.style not in ['1quote', '2quote'] \
+#                and node.value and node.value[-1] in [' ', '\t']:
+#            node.style = '2quote'
         return node
 
@@ -39 +48 @@
             return _syck.Scalar(str(object), tag="tag:yaml.org,2002:str")
 
+    def allow_aliases(self, object):
+        return True
+
 class Dumper(GenericDumper):
 
+    def __init__(self, *args, **kwds):
+        super(Dumper, self).__init__(*args, **kwds)
+
     def represent(self, object):
+        for object_type in type(object).__mro__:
+            if object_type.__module__ == '__builtin__':
+                name = object_type.__name__
+            else:
+                name = '%s.%s' % (object_type.__module__, object_type.__name__)
+            method = 'represent_%s' % name.replace('.', '_')
+            if hasattr(self, method):
+                return getattr(self, method)(object)
         return super(Dumper, self).represent(object)
+
+    def represent_object(self, object):
+        return _syck.Scalar(repr(object), tag="tag:yaml.org,2002:str")
+
+    def represent_NoneType(self, object):
+        return _syck.Scalar('~', tag="tag:yaml.org,2002:null")
+
+    def represent_bool(self, object):
+        return _syck.Scalar(repr(object), tag="tag:yaml.org,2002:bool")
+
+    def represent_str(self, object):
+        return _syck.Scalar(str(object), tag="tag:yaml.org,2002:str")
+
+    def represent_list(self, object):
+        return _syck.Seq(object[:], tag="tag:yaml.org,2002:seq")
+
+    def represent_dict(self, object):
+        return _syck.Map(object.copy(), tag="tag:yaml.org,2002:map")
+
+    def represent_int(self, object):
+        return _syck.Scalar(repr(object), tag="tag:yaml.org,2002:int")
+
+    def represent_int(self, object):
+        return _syck.Scalar(repr(object), tag="tag:yaml.org,2002:int")
+
+    def represent_float(self, object):
+        value = repr(object)
+        if value == repr(INF):
+            value = '.inf'
+        elif value == repr(NEGINF):
+            value = '-.inf'
+        elif value == repr(NAN):
+            value = '.nan'
+        return _syck.Scalar(value, tag="tag:yaml.org,2002:float")
+
+    def represent_sets_Set(self, object):
+        return _syck.Seq(list(object), tag="tag:yaml.org,2002:set")
+
+    def represent_datetime_datetime(self, object):
+        return _syck.Scalar(object.isoformat(), tag="tag:yaml.org,2002:timestamp")
+
+    def allow_aliases(self, object):
+        if object is None or type(object) in [int, bool, float]:
+            return False
+        if type(object) is str and (not object or object.isalnum()):
+            return False
+        return True
 
 def emit(node, output=None, **parameters):

trunk/sandbox/syck-parser/syck-parser.c

@@ -123 +123 @@
     switch (n->kind) {
         case syck_str_kind:
-            output(indent, "Node Scalar (%s):", n->type_id);
+            output(indent, "[%d] Node Scalar (%s):", id, n->type_id);
             output(indent+1, "Value: '%s'", n->data.str->ptr);
             break;
         case syck_seq_kind:
-            output(indent, "Node Sequence (%s):", n->type_id);
+            output(indent, "[%d] Node Sequence (%s):", id, n->type_id);
             for (i = 0; i < syck_seq_count(n); i++) {
                 output(indent+1, "Item #%d:", i+1);
@@ -134 +134 @@
             break;
         case syck_map_kind:
-            output(indent, "Node Mapping (%s):", n->type_id);
+            output(indent, "[%d] Node Mapping (%s):", id, n->type_id);
             for (i = 0; i < syck_map_count(n); i++) {
                 output(indent+1, "Key #%d:", i+1);

trunk/tests/test_dumper.py

@@ -2 +2 @@
 import unittest
 import syck
-import StringIO
+import StringIO, datetime, sets
 import test_emitter
 
@@ -15 +15 @@
     'Sammy Sosa',
     'Ken Griffey',
+]
+
+ALIAS_SCALAR = ["foo, bar, and baz"]
+ALIAS_SCALAR.append(ALIAS_SCALAR[0])
+ALIAS_SCALAR.append(ALIAS_SCALAR[0])
+ALIAS_SCALAR.append(ALIAS_SCALAR[0])
+
+ALIAS_SEQ = [['foo', ['bar']]]
+ALIAS_SEQ.append(ALIAS_SEQ[0])
+ALIAS_SEQ.append(ALIAS_SEQ[0])
+
+ALIAS_MAP = [{'foo': 'bar'}]
+ALIAS_MAP.append(ALIAS_MAP[0])
+
+ODD_ALIASES = [
+    [None]*2,
+    [0]*3,
+    [1]*4,
+    [100]*5,
+    ['']*6,
+    ['foo']*7,
+]
+
+INF = 1e300000
+NAN = INF/INF
+
+SCALARS = [
+    None,
+    True, False,
+    0, 123, -4567,
+    123.4e-5, INF, NAN,
+    'foo, bar, baz',
+    datetime.datetime(2001, 12, 15, 2, 59, 43, 100000),
+]
+
+COLLECTIONS = [
+    sets.Set(range(10)),
 ]
 
@@ -73 +110 @@
                 map(test_emitter.strip, nodes))
 
+class TestAliases(unittest.TestCase):
+
+    def testAliases(self):
+        self._testAlias(ALIAS_SCALAR)
+        self._testAlias(ALIAS_SEQ)
+        self._testAlias(ALIAS_MAP)
+
+    def _testAlias(self, objects):
+        objects = syck.load(syck.dump(objects))
+        for object in objects:
+            self.assert_(object is objects[0])
+
+class TestNoOddAliases(unittest.TestCase):
+
+    def testOddAliases(self):
+        document = syck.parse(syck.dump(ODD_ALIASES))
+        for group in document.value:
+            for item in group.value[1:]:
+                self.assert_(item is not group.value[0])
+
+class TestScalarTypes(unittest.TestCase):
+
+    def testScalarTypes(self):
+        scalars = syck.load(syck.dump(SCALARS))
+        for a, b in zip(scalars, SCALARS):
+            self.assertEqual(type(a), type(b))
+            self.assertEqual(a, b)
+
+class TestCollectionTypes(unittest.TestCase):
+
+    def testCollectionTypes(self):
+        collections = syck.load(syck.dump(COLLECTIONS))
+        for a, b in zip(collections, COLLECTIONS):
+            self.assertEqual(type(a), type(b))
+            self.assertEqual(a, b)
+
+

trunk/tests/test_loader.py

@@ -130 +130 @@
     'baseball teams': sets.Set(['Boston Red Sox', 'Detroit Tigers', 'New York Yankees']),
 }
+
+ALIASES = """
+foo: &bar baz
+bar: *bar
+"""
 
 class TestDocuments(test_parser.TestDocuments):
@@ -258 +263 @@
         self.assertEqual(syck.load(SET[0]), SET[1])
 
+class TestAliasesParsingAndLoading(unittest.TestCase):
+
+    def testAliasesParsing(self):
+        node = syck.parse(ALIASES)
+        values = node.value.values()
+        print values
+        print id(values[0])
+        print id(values[1])
+        self.assert_(values[0] is values[1])
+
+    def testAliasesLoading(self):
+        document = syck.load(ALIASES)
+        self.assert_(document['foo'] is document['bar'])
+

trunk/tests/test_parser.py

@@ -169 +169 @@
 """
 
+ALIASES = """
+- &alias foo
+- *alias
+"""
+
 class TestAttributes(unittest.TestCase):
 
@@ -359 +364 @@
         self.assertRaises(TypeError, lambda: parser.parse())
 
+class TestParsingAliases(unittest.TestCase):
+
+    def testAliases(self):
+        parser = _syck.Parser(ALIASES)
+        node = parser.parse()
+        self.assert_(node.value[0] is node.value[1])
+

trunk/tests/test_syck.py

@@ -3 +3 @@
 
 #from test_node import *
-#from test_parser import *
-#from test_loader import *
-#from test_emitter import *
+from test_parser import *
+from test_loader import *
+from test_emitter import *
 from test_dumper import *