Changeset 22


Ignore:
Timestamp:
08/14/05 03:34:58 (9 years ago)
Author:
xi
Message:

Add test cases for customization API.

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib/syck/dumpers.py

    r21 r22  
    205205        return True 
    206206 
    207 def emit(node, output=None, **parameters): 
     207def emit(node, output=None, Dumper=Dumper, **parameters): 
    208208    if output is None: 
    209209        dumper = Dumper(StringIO.StringIO(), **parameters) 
     
    214214        return dumper.output.getvalue() 
    215215 
    216 def dump(object, output=None, **parameters): 
     216def dump(object, output=None, Dumper=Dumper, **parameters): 
    217217    if output is None: 
    218218        dumper = Dumper(StringIO.StringIO(), **parameters) 
     
    223223        return dumper.output.getvalue() 
    224224 
    225 def emit_documents(nodes, output=None, **parameters): 
     225def emit_documents(nodes, output=None, Dumper=Dumper, **parameters): 
    226226    if output is None: 
    227227        dumper = Dumper(StringIO.StringIO(), **parameters) 
     
    233233        return dumper.output.getvalue() 
    234234 
    235 def dump_documents(objects, output=None, **parameters): 
     235def dump_documents(objects, output=None, Dumper=Dumper, **parameters): 
    236236    if output is None: 
    237237        dumper = Dumper(StringIO.StringIO(), **parameters) 
  • trunk/lib/syck/loaders.py

    r21 r22  
    5050                value_object = self._convert(node.value[key_node], 
    5151                        node_to_object) 
    52                 if key_object in value: 
    53                     value = None 
    54                     break 
    5552                try: 
     53                    if key_object in value: 
     54                        value = None 
     55                        break 
    5656                    value[key_object] = value_object 
    5757                except TypeError: 
     
    6161                value = [] 
    6262                for key_node in node.value: 
    63                     key_object = self_convert(key_node, node_to_object) 
     63                    key_object = self._convert(key_node, node_to_object) 
    6464                    value_object = self._convert(node.value[key_node], 
    6565                            node_to_object) 
     
    338338        return object 
    339339 
    340 def parse(source): 
     340def parse(source, Loader=Loader, **parameters): 
    341341    """Parses 'source' and returns the root of the 'Node' graph.""" 
    342     loader = Loader(source) 
     342    loader = Loader(source, **parameters) 
    343343    return loader.parse() 
    344344 
    345 def load(source): 
     345def load(source, Loader=Loader, **parameters): 
    346346    """Parses 'source' and returns the root object.""" 
    347     loader = Loader(source) 
     347    loader = Loader(source, **parameters) 
    348348    return loader.load() 
    349349 
    350 def parse_documents(source): 
     350def parse_documents(source, Loader=Loader, **parameters): 
    351351    """Iterates over 'source' and yields the root node of each document.""" 
    352     loader = Loader(source) 
     352    loader = Loader(source, **parameters) 
    353353    while True: 
    354354        node = loader.parse() 
     
    357357        yield node 
    358358 
    359 def load_documents(source): 
     359def load_documents(source, Loader=Loader, **parameters): 
    360360    """Iterates over 'source' and yields the root object of each document.""" 
    361     loader = Loader(source) 
     361    loader = Loader(source, **parameters) 
    362362    while True: 
    363363        object = loader.load() 
  • trunk/tests/test_loader.py

    r20 r22  
    136136""" 
    137137 
     138MUTABLE_KEY = """ 
     139? [] 
     140: [] 
     141""" 
     142 
    138143class TestDocuments(test_parser.TestDocuments): 
    139144 
     
    181186 
    182187    def _testFileValues(self, (source, structure)): 
    183         filename = os.tempnam('/tmp', '_syck_test_') 
    184         file(filename, 'wb').write(source) 
     188        tempfile = os.tmpfile() 
     189        tempfile.write(source) 
     190        tempfile.seek(0) 
    185191        try: 
    186             self.assertEqualStructure(syck.parse(file(filename)), structure) 
    187             self.assertEqual(syck.load(file(filename)), structure) 
     192            self.assertEqualStructure(syck.parse(tempfile), structure) 
     193            tempfile.seek(0) 
     194            self.assertEqual(syck.load(tempfile), structure) 
     195            tempfile.seek(0) 
    188196        except: 
    189197            os.remove(filename) 
     
    268276        node = syck.parse(ALIASES) 
    269277        values = node.value.values() 
    270         print values 
    271         print id(values[0]) 
    272         print id(values[1]) 
    273278        self.assert_(values[0] is values[1]) 
    274279 
     
    277282        self.assert_(document['foo'] is document['bar']) 
    278283 
     284class TestMutableKey(unittest.TestCase): 
     285 
     286    def testMutableKey(self): 
     287        document = syck.load(MUTABLE_KEY) 
     288        self.assertEqual(type(document), list) 
     289        self.assertEqual(len(document), 1) 
     290        self.assertEqual(type(document[0]), tuple) 
     291        self.assertEqual(len(document[0]), 2) 
     292        self.assertEqual(document[0][0], document[0][1]) 
  • trunk/tests/test_pickle.py

    r21 r22  
     1# coding: utf-8 
    12 
    23import unittest 
     
    252253            self.assertEqual(left, right) 
    253254 
     255class MyPrivateType(AnObject): 
     256    pass 
     257 
     258class MyPublicType(AnObject): 
     259    pass 
     260 
     261class MyMapping(AnObject): 
     262 
     263    def yaml_construct(cls, node): 
     264        return cls(**node.value) 
     265    yaml_construct = classmethod(yaml_construct) 
     266 
     267    def yaml_represent(self, node): 
     268        return syck.Map(self.__dict__.copy(), inline=True) 
     269 
     270EXTENSIONS = """ 
     271- !!MyPrivateType [1, 2, 3] 
     272- !domain.tld,2005/MyPublicType [1, 2, 3] 
     273- !domain.tld,2005/AnotherPublicType [1, 2, 3] 
     274- {foo: 1, bar: 2, baz: 3} 
     275""", [ 
     276    MyPrivateType(1,2,3), 
     277    MyPublicType(1,2,3), 
     278    MyPublicType(1,2,3), 
     279    MyMapping(1,2,3), 
     280] 
     281 
     282class ExLoader(syck.Loader): 
     283 
     284    def find_constructor(self, node): 
     285        if node.kind == 'map': 
     286            return MyMapping.yaml_construct 
     287        return super(ExLoader, self).find_constructor(node) 
     288 
     289    def make_mapping(self, node): 
     290        return MyMapping(**node.value) 
     291 
     292    def construct_private_MyPrivateType(self, node): 
     293        return MyPrivateType(*node.value) 
     294 
     295    def construct_domain_tld_2005(self, node): 
     296        return MyPublicType(*node.value) 
     297 
     298class ExDumper(syck.Dumper): 
     299 
     300    def find_representer(self, object): 
     301        if isinstance(object, MyMapping): 
     302            return object.yaml_represent 
     303        return super(ExDumper, self).find_representer(object) 
     304 
     305    def represent_test_pickle_MyPrivateType(self, object): 
     306        return syck.Seq([object.foo, object.bar, object.baz], 
     307                tag="x-private:MyPrivateType", inline=True) 
     308 
     309    def represent_test_pickle_MyPublicType(self, object): 
     310        return syck.Seq([object.foo, object.bar, object.baz], 
     311                tag="tag:domain.tld,2005:APublicType", inline=True) 
     312 
     313class TestExtensions(unittest.TestCase): 
     314 
     315    def testExtensions(self): 
     316        source = EXTENSIONS[0] 
     317        object = EXTENSIONS[1] 
     318        object2 = syck.load(source, Loader=ExLoader) 
     319        for left, right in zip(object, object2): 
     320            self.assertEqual(left, right) 
     321        source2 = syck.dump(object2, Dumper=ExDumper) 
     322        object3 = syck.load(source2, Loader=ExLoader) 
     323        for left, right in zip(object, object3): 
     324            self.assertEqual(left, right) 
     325 
Note: See TracChangeset for help on using the changeset viewer.