Changeset 7


Ignore:
Timestamp:
07/18/05 13:13:22 (8 years ago)
Author:
xi
Message:

Implement syck.parse() and syck.load() (closes #8).
Add basic scalar types to the resolver (partially closes #9).

Location:
trunk
Files:
5 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/ext/_syckmodule.c

    r6 r7  
    244244 
    245245static char PySyckParser_doc[] = 
    246     "_syck.Parser(yaml_string_or_file, implicit_typing=True, taguri_expansion=True) -> Parser object\n" 
     246    "_syck.Parser(yaml_string_or_file, resolver=None, implicit_typing=True, taguri_expansion=True) -> Parser object\n" 
    247247    "\n" 
    248248    "Methods of the Parser object:\n\n" 
    249249    "parse() -- Parses the next document in the YAML stream, return the root Node object or None on EOF.\n" 
    250     "parse_documents() -- Parses the entire YAML stream and returns list of documents.\n" 
    251     "close() -- Closes the parser and frees memory.\n"; 
     250    "eof() -- Checks if the parser is stopped.\n"; 
    252251 
    253252static PyTypeObject PySyckParser_Type = { 

  • trunk/lib/syck/__init__.py

    r3 r7  
     1 
     2from parsers import * 
     3 
     4generic_parser = GenericParser() 
     5parse = generic_parser.load 
     6parse_documents = generic_parser.load_documents 
     7 
     8parser = Parser() 
     9load = parser.load 
     10load_documents = parser.load_documents 
     11add_type = parser.add_type 
     12add_domain_type = parser.add_domain_type 
     13add_builtin_type = parser.add_builtin_type 
     14add_python_type = parser.add_python_type 
     15add_private_type = parser.add_private_type 
     16 

  • trunk/tests/test_syck.py

    r6 r7  
    11 
    22import unittest 
    3 import _syck, syck 
    4 import StringIO 
    53 
    6 EXAMPLE = """ 
    7 - 
    8   avg: 0.278 
    9   hr: 65 
    10   name: Mark McGwire 
    11 - 
    12   avg: 0.288 
    13   hr: 63 
    14   name: Sammy Sosa 
    15 """ 
    16  
    17 INVALID = """ 
    18  - invalid 
    19 - document 
    20 """, 2, 0 
    21  
    22 COMPARE1 = """ 
    23 one: foo 
    24 two: bar 
    25 three: baz 
    26 """, { 
    27     'one': 'foo', 
    28     'two': 'bar', 
    29     'three': 'baz', 
    30 } 
    31  
    32 COMPARE2 = """ 
    33 - Mark McGwire 
    34 - Sammy Sosa 
    35 - Ken Griffey 
    36 """, [ 
    37     'Mark McGwire', 
    38     'Sammy Sosa', 
    39     'Ken Griffey', 
    40 ] 
    41  
    42 COMPARE3 = """ 
    43 american: 
    44   - Boston Red Sox 
    45   - Detroit Tigers 
    46   - New York Yankees 
    47 national: 
    48   - New York Mets 
    49   - Chicago Cubs 
    50   - Atlanta Braves 
    51 """, { 
    52     'american': [ 
    53         'Boston Red Sox', 
    54         'Detroit Tigers', 
    55         'New York Yankees', 
    56     ], 
    57     'national': [ 
    58         'New York Mets', 
    59         'Chicago Cubs', 
    60         'Atlanta Braves', 
    61     ], 
    62 } 
    63  
    64 DOCUMENTS0 = "" 
    65  
    66 DOCUMENTS1 = """ 
    67 --- 
    68 Time: 2001-11-23 15:01:42 -05:00 
    69 User: ed 
    70 Warning: > 
    71   This is an error message 
    72   for the log file 
    73 """ 
    74  
    75 DOCUMENTS2 = """ 
    76 --- 
    77 Time: 2001-11-23 15:01:42 -05:00 
    78 User: ed 
    79 Warning: > 
    80   This is an error message 
    81   for the log file 
    82 --- 
    83 Time: 2001-11-23 15:02:31 -05:00 
    84 User: ed 
    85 Warning: > 
    86   A slightly different error 
    87   message. 
    88 """ 
    89  
    90 DOCUMENTS3 = """ 
    91 --- 
    92 Time: 2001-11-23 15:01:42 -05:00 
    93 User: ed 
    94 Warning: > 
    95   This is an error message 
    96   for the log file 
    97 --- 
    98 Time: 2001-11-23 15:02:31 -05:00 
    99 User: ed 
    100 Warning: > 
    101   A slightly different error 
    102   message. 
    103 --- 
    104 Date: 2001-11-23 15:03:17 -05:00 
    105 User: ed 
    106 Fatal: > 
    107   Unknown variable "bar" 
    108 Stack: 
    109   - file: TopClass.py 
    110     line: 23 
    111     code: | 
    112       x = MoreObject("345\\n") 
    113   - file: MoreClass.py 
    114     line: 58 
    115     code: |- 
    116       foo = bar 
    117 """ 
    118  
    119 IMPLICIT_TYPING = """ 
    120 - 'foo' 
    121 - >- 
    122   bar 
    123 - baz 
    124 - 123 
    125 - 3.14 
    126 - true 
    127 - false 
    128 - [] 
    129 - {} 
    130 """, [ 
    131     ('str', True), 
    132     ('str', True), 
    133     ('str', False), 
    134     ('int', False), 
    135     ('float#fix', False), 
    136     ('bool#yes', False), 
    137     ('bool#no', False), 
    138     (None, False), 
    139     (None, False), 
    140 ] 
    141  
    142 EXPLICIT_TYPING = """ 
    143 - !int '123' 
    144 - !yamltype 'foo' 
    145 - !python/type 'bar' 
    146 - !domain.tld,2002/type 'baz' 
    147 - !!private 'private' 
    148 - !map {} 
    149 - !seq [] 
    150 """, [ 
    151     'tag:yaml.org,2002:int', 
    152     'tag:yaml.org,2002:yamltype', 
    153     'tag:python.yaml.org,2002:type', 
    154     'tag:domain.tld,2002:type', 
    155     'x-private:private', 
    156     'tag:yaml.org,2002:map', 
    157     'tag:yaml.org,2002:seq', 
    158 ] 
    159  
    160 class TestTypes(unittest.TestCase): 
    161  
    162     def testParserType(self): 
    163         parser = _syck.Parser(EXAMPLE) 
    164         self.assertEqual(type(parser), _syck.ParserType) 
    165  
    166     def testNodeType(self): 
    167         parser = _syck.Parser(EXAMPLE) 
    168         document = parser.parse() 
    169         self.assertEqual(type(document), _syck.NodeType) 
    170  
    171     def testNodeType2(self): 
    172         self.assertRaises(TypeError, (lambda: _syck.Node())) 
    173  
    174 class TestErrors(unittest.TestCase): 
    175  
    176     def testError(self): 
    177         parser = _syck.Parser(INVALID[0]) 
    178         self.assertRaises(_syck.error, (lambda: parser.parse())) 
    179  
    180     def testErrorLocation(self): 
    181         source, line, column = INVALID 
    182         parser = _syck.Parser(source) 
    183         try: 
    184             parser.parse() 
    185             raise Exception 
    186         except _syck.error, e: 
    187             self.assertEqual(e.args[1], line) 
    188             self.assertEqual(e.args[2], column) 
    189  
    190 class EqualStructure: 
    191  
    192     def assertEqualStructure(self, node, structure): 
    193         if node.kind == 'scalar': 
    194             self.assertEqual(type(structure), str) 
    195             self.assertEqual(node.value, structure) 
    196         elif node.kind == 'seq': 
    197             self.assertEqual(type(structure), list) 
    198             self.assertEqual(len(node.value), len(structure)) 
    199             for i, item in enumerate(node.value): 
    200                 self.assertEqualStructure(item, structure[i]) 
    201         elif node.kind == 'map': 
    202             self.assertEqual(type(structure), dict) 
    203             self.assertEqual(len(node.value), len(structure)) 
    204             for key in node.value: 
    205                 self.assert_(key.value in structure) 
    206                 self.assertEqualStructure(node.value[key], structure[key.value]) 
    207  
    208 class TestValuesAndSources(unittest.TestCase, EqualStructure): 
    209  
    210     def testValues1(self): 
    211         self._testValues(COMPARE1) 
    212  
    213     def testValues2(self): 
    214         self._testValues(COMPARE2) 
    215  
    216     def testValues3(self): 
    217         self._testValues(COMPARE3) 
    218  
    219     def testFileValues1(self): 
    220         self._testFileValues(COMPARE1) 
    221  
    222     def testFileValues2(self): 
    223         self._testFileValues(COMPARE2) 
    224  
    225     def testFileValues3(self): 
    226         self._testFileValues(COMPARE3) 
    227  
    228     def testNonsense(self): 
    229         parser = _syck.Parser(None) 
    230         self.assertRaises(AttributeError, (lambda: parser.parse())) 
    231  
    232     def _testValues(self, (source, structure)): 
    233         parser = _syck.Parser(source) 
    234         document = parser.parse() 
    235         self.assertEqualStructure(document, structure) 
    236  
    237     def _testFileValues(self, (source, structure)): 
    238         parser = _syck.Parser(StringIO.StringIO(source)) 
    239         document = parser.parse() 
    240         self.assertEqualStructure(document, structure) 
    241  
    242 class TestResolver(unittest.TestCase, EqualStructure): 
    243  
    244     object = 12345 
    245  
    246     def object_resolver(self, node): 
    247         return self.object 
    248  
    249     def simple_resolver(self, node): 
    250         return node.value 
    251  
    252     def default_resolver(self, node): 
    253         return node 
    254  
    255     def call_me_not_resolver(self, node): 
    256         self.call_me_not_parser.parse() 
    257         return node 
    258  
    259     def testResolver1(self): 
    260         self._testResolver(COMPARE1) 
    261  
    262     def testResolver2(self): 
    263         self._testResolver(COMPARE2) 
    264  
    265     def testResolver3(self): 
    266         self._testResolver(COMPARE3) 
    267  
    268     def testCallMeNot(self): 
    269         self.call_me_not_parser = _syck.Parser(EXAMPLE, self.call_me_not_resolver) 
    270         self.assertRaises(RuntimeError, (lambda: self.call_me_not_parser.parse())) 
    271         del self.call_me_not_parser 
    272  
    273     def _testResolver(self, compare): 
    274         self._testObject(compare) 
    275         self._testSimple(compare) 
    276         self._testDefault(compare) 
    277         self._testNone(compare) 
    278  
    279     def _testObject(self, (source, structure)): 
    280         parser = _syck.Parser(source, self.object_resolver) 
    281         document = parser.parse() 
    282         self.assert_(document is self.object) 
    283  
    284     def _testSimple(self, (source, structure)): 
    285         parser = _syck.Parser(source, self.simple_resolver) 
    286         document = parser.parse() 
    287         self.assert_(document, structure) 
    288  
    289     def _testDefault(self, (source, structure)): 
    290         parser = _syck.Parser(source, resolver=self.default_resolver) 
    291         document = parser.parse() 
    292         self.assertEqualStructure(document, structure) 
    293  
    294     def _testNone(self, (source, structure)): 
    295         parser = _syck.Parser(source, resolver=None) 
    296         document = parser.parse() 
    297         self.assertEqualStructure(document, structure) 
    298  
    299 class TestDocuments(unittest.TestCase): 
    300  
    301     def testDocuments0(self): 
    302         self._testDocuments(DOCUMENTS0, 0) 
    303  
    304     def testDocuments1(self): 
    305         self._testDocuments(DOCUMENTS1, 1) 
    306  
    307     def testDocuments2(self): 
    308         self._testDocuments(DOCUMENTS2, 2) 
    309  
    310     def testDocuments3(self): 
    311         self._testDocuments(DOCUMENTS3, 3) 
    312  
    313     def _testDocuments(self, source, length): 
    314         parser = _syck.Parser(source) 
    315         actual_length = 0 
    316         while True: 
    317             document = parser.parse() 
    318             if parser.eof(): 
    319                 self.assertEqual(document, None) 
    320                 break 
    321             actual_length += 1 
    322         self.assertEqual(actual_length, length) 
    323         self.assertEqual(parser.parse(), None) 
    324         self.assert_(parser.eof()) 
    325         self.assertEqual(parser.parse(), None) 
    326         self.assert_(parser.eof()) 
    327  
    328 class TestImplicitTyping(unittest.TestCase): 
    329  
    330     def testImplicitAndExpansionTyping(self): 
    331         self._testTyping(True, True) 
    332  
    333     def testImplicitTyping(self): 
    334         self._testTyping(True, False) 
    335  
    336     def testExpansionTyping(self): 
    337         self._testTyping(False, True) 
    338  
    339     def testNoTyping(self): 
    340         self._testTyping(False, False) 
    341  
    342     def _testTyping(self, implicit_typing, taguri_expansion): 
    343         parser = _syck.Parser(IMPLICIT_TYPING[0], None, implicit_typing, taguri_expansion) 
    344         for node, (type_id, explicit) in zip(parser.parse().value, IMPLICIT_TYPING[1]): 
    345             if type_id is not None and taguri_expansion: 
    346                 type_id = 'tag:yaml.org,2002:%s' % type_id 
    347             if implicit_typing or explicit: 
    348                 self.assertEqual(node.type_id, type_id) 
    349             else: 
    350                 self.assertEqual(node.type_id, None) 
    351  
    352 class TestExplicitTyping(unittest.TestCase): 
    353  
    354     def testExplicitTyping(self): 
    355         parser = _syck.Parser(EXPLICIT_TYPING[0]) 
    356         for node, type_id in zip(parser.parse().value, EXPLICIT_TYPING[1]): 
    357             self.assertEqual(node.type_id, type_id) 
     4#from test_low_parser import * 
     5from test_high_parser import * 
    3586 
    3597def main(module='__main__'): 
Note: See TracChangeset for help on using the changeset viewer.