Changeset 44


Ignore:
Timestamp:
02/15/06 08:35:29 (9 years ago)
Author:
xi
Message:

All tests passed! Scanner and Parser seem to be correct.

Location:
branches/pyyaml3000
Files:
29 added
28 edited

Legend:

Unmodified
Added
Removed
  • branches/pyyaml3000/lib/yaml/parser.py

    r43 r44  
    4040# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } 
    4141 
     42from scanner import * 
     43 
     44class Error(Exception): 
     45    pass 
     46 
     47class Node: 
     48    def __repr__(self): 
     49        args = [] 
     50        for attribute in ['anchor', 'tag', 'value']: 
     51            if hasattr(self, attribute): 
     52                args.append(repr(getattr(self, attribute))) 
     53        return "%s(%s)" % (self.__class__.__name__, ', '.join(args)) 
     54 
     55class AliasNode(Node): 
     56    def __init__(self, anchor): 
     57        self.anchor = anchor 
     58 
     59class ScalarNode(Node): 
     60    def __init__(self, anchor, tag, value): 
     61        self.anchor = anchor 
     62        self.tag = tag 
     63        self.value = value 
     64 
     65class SequenceNode(Node): 
     66    def __init__(self, anchor, tag, value): 
     67        self.anchor = anchor 
     68        self.tag = tag 
     69        self.value = value 
     70 
     71class MappingNode(Node): 
     72    def __init__(self, anchor, tag, value): 
     73        self.anchor = anchor 
     74        self.tag = tag 
     75        self.value = value 
     76 
    4277class Parser: 
    4378 
    44     def parse(self, source, data): 
    45         scanner = Scanner() 
    46         self.tokens = scanner.scan(source, data) 
    47         self.tokens.append('END') 
    48         documents = self.parse_stream() 
    49         if len(documents) == 1: 
    50             return documents[0] 
    51         return documents 
     79    def __init__(self, source, data): 
     80        self.scanner = Scanner(source, data) 
     81 
     82    def is_token(self, *choices): 
     83        token = self.scanner.peek_token() 
     84        for choice in choices: 
     85            if isinstance(token, choices): 
     86                return True 
     87        return False 
     88 
     89    def get_token(self): 
     90        return self.scanner.get_token() 
     91 
     92    def parse(self): 
     93        return self.parse_stream() 
    5294 
    5395    def parse_stream(self): 
    5496        documents = [] 
    55         if self.tokens[0] not in ['DIRECTIVE', 'DOCUMENT_START', 'END']: 
     97        if not self.is_token(DirectiveToken, DocumentStartToken, EndToken): 
    5698            documents.append(self.parse_block_node()) 
    57         while self.tokens[0] != 'END': 
    58             while self.tokens[0] == 'DIRECTIVE': 
    59                 self.tokens.pop(0) 
    60             if self.tokens[0] != 'DOCUMENT_START': 
    61                 self.error('DOCUMENT_START is expected') 
    62             self.tokens.pop(0) 
    63             if self.tokens[0] in ['DIRECTIVE', 'DOCUMENT_START', 'DOCUMENT_END', 'END']: 
     99        while not self.is_token(EndToken): 
     100            while self.is_token(DirectiveToken): 
     101                self.get_token() 
     102            if not self.is_token(DocumentStartToken): 
     103                self.fail('DOCUMENT-START is expected') 
     104            self.get_token() 
     105            if self.is_token(DirectiveToken, 
     106                    DocumentStartToken, DocumentEndToken, EndToken): 
    64107                documents.append(None) 
    65108            else: 
    66109                documents.append(self.parse_block_node()) 
    67             while self.tokens[0] == 'DOCUMENT_END': 
    68                 self.tokens.pop(0) 
    69         if self.tokens[0] != 'END': 
    70             self.error("END is expected") 
    71         return tuple(documents) 
     110            while self.is_token(DocumentEndToken): 
     111                self.get_token() 
     112        if not self.is_token(EndToken): 
     113            self.fail("END is expected") 
     114        return documents 
    72115 
    73116    def parse_block_node(self): 
    74         if self.tokens[0] == 'ALIAS': 
    75             self.tokens.pop(0) 
    76             return '*' 
    77         if self.tokens[0] == 'TAG': 
    78             self.tokens.pop(0) 
    79             if self.tokens[0] == 'ANCHOR': 
    80                 self.tokens.pop(0) 
    81         elif self.tokens[0] == 'ANCHOR': 
    82             self.tokens.pop(0) 
    83             if self.tokens[0] == 'TAG': 
    84                 self.tokens.pop(0) 
    85         return self.parse_block_content() 
     117        return self.parse_node(block=True) 
    86118 
    87119    def parse_flow_node(self): 
    88         if self.tokens[0] == 'ALIAS': 
    89             self.tokens.pop(0) 
    90             return '*' 
    91         if self.tokens[0] == 'TAG': 
    92             self.tokens.pop(0) 
    93             if self.tokens[0] == 'ANCHOR': 
    94                 self.tokens.pop(0) 
    95         elif self.tokens[0] == 'ANCHOR': 
    96             self.tokens.pop(0) 
    97             if self.tokens[0] == 'TAG': 
    98                 self.tokens.pop(0) 
    99         return self.parse_flow_content() 
     120        return self.parse_node() 
    100121 
    101122    def parse_block_node_or_indentless_sequence(self): 
    102         if self.tokens[0] == 'ALIAS': 
    103             self.tokens.pop(0) 
    104             return '*' 
    105         if self.tokens[0] == 'TAG': 
    106             self.tokens.pop(0) 
    107             if self.tokens[0] == 'ANCHOR': 
    108                 self.tokens.pop(0) 
    109         elif self.tokens[0] == 'ANCHOR': 
    110             self.tokens.pop(0) 
    111             if self.tokens[0] == 'TAG': 
    112                 self.tokens.pop(0) 
    113         if self.tokens[0] == 'ENTRY': 
    114             return self.parse_indentless_sequence(self) 
    115         return self.parse_block_content() 
     123        return self.parse_node(block=True, indentless_sequence=True) 
     124 
     125    def parse_node(self, block=False, indentless_sequence=False): 
     126        if self.is_token(AliasToken): 
     127            token = self.get_token() 
     128            return AliasNode(token.value) 
     129        anchor = None 
     130        tag = None 
     131        if self.is_token(AnchorToken): 
     132            anchor = self.get_token().value 
     133            if self.is_token(TagToken): 
     134                tag = self.get_token().value 
     135        elif self.is_token(TagToken): 
     136            tag = self.get_token().value 
     137            if self.is_token(AnchorToken): 
     138                anchor = self.get_token().value 
     139        if indentless_sequence and self.is_token(EntryToken): 
     140            NodeClass = SequenceNode 
     141            value = self.parse_indentless_sequence() 
     142        else: 
     143            if self.is_token(ScalarToken): 
     144                NodeClass = ScalarNode 
     145            elif self.is_token(BlockSequenceStartToken, FlowSequenceStartToken): 
     146                NodeClass = SequenceNode 
     147            elif self.is_token(BlockMappingStartToken, FlowMappingStartToken): 
     148                NodeClass = MappingNode 
     149            if block: 
     150                value = self.parse_block_content() 
     151            else: 
     152                value = self.parse_flow_content() 
     153        return NodeClass(anchor, tag, value) 
    116154 
    117155    def parse_block_content(self): 
    118         if self.tokens[0] == 'SCALAR': 
    119             self.tokens.pop(0) 
    120             return True 
    121         elif self.tokens[0] == 'BLOCK_SEQ_START': 
     156        if self.is_token(ScalarToken): 
     157            return self.get_token().value 
     158        elif self.is_token(BlockSequenceStartToken): 
    122159            return self.parse_block_sequence() 
    123         elif self.tokens[0] == 'BLOCK_MAP_START': 
     160        elif self.is_token(BlockMappingStartToken): 
    124161            return self.parse_block_mapping() 
    125         elif self.tokens[0] == 'FLOW_SEQ_START': 
     162        elif self.is_token(FlowSequenceStartToken): 
    126163            return self.parse_flow_sequence() 
    127         elif self.tokens[0] == 'FLOW_MAP_START': 
     164        elif self.is_token(FlowMappingStartToken): 
    128165            return self.parse_flow_mapping() 
    129166        else: 
    130             self.error('block content is expected') 
     167            self.fail('block content is expected') 
    131168 
    132169    def parse_flow_content(self): 
    133         if self.tokens[0] == 'SCALAR': 
    134             self.tokens.pop(0) 
    135             return True 
    136         elif self.tokens[0] == 'FLOW_SEQ_START': 
     170        if self.is_token(ScalarToken): 
     171            return self.get_token().value 
     172        elif self.is_token(FlowSequenceStartToken): 
    137173            return self.parse_flow_sequence() 
    138         elif self.tokens[0] == 'FLOW_MAP_START': 
     174        elif self.is_token(FlowMappingStartToken): 
    139175            return self.parse_flow_mapping() 
    140176        else: 
    141             self.error('flow content is expected') 
     177            self.fail('flow content is expected') 
    142178 
    143179    def parse_block_sequence(self): 
    144180        sequence = [] 
    145         if self.tokens[0] != 'BLOCK_SEQ_START': 
    146             self.error('BLOCK_SEQ_START is expected') 
    147         self.tokens.pop(0) 
    148         while self.tokens[0] == 'ENTRY': 
    149             self.tokens.pop(0) 
    150             if self.tokens[0] not in ['ENTRY', 'BLOCK_END']: 
     181        if not self.is_token(BlockSequenceStartToken): 
     182            self.fail('BLOCK-SEQUENCE-START is expected') 
     183        self.get_token() 
     184        while self.is_token(EntryToken): 
     185            self.get_token() 
     186            if not self.is_token(EntryToken, BlockEndToken): 
    151187                sequence.append(self.parse_block_node()) 
    152188            else: 
    153189                sequence.append(None) 
    154         if self.tokens[0] != 'BLOCK_END': 
    155             self.error('BLOCK_END is expected') 
    156         self.tokens.pop(0) 
     190        if not self.is_token(BlockEndToken): 
     191            self.fail('BLOCK-END is expected') 
     192        self.get_token() 
    157193        return sequence 
    158194 
    159195    def parse_indentless_sequence(self): 
    160196        sequence = [] 
    161         while self.tokens[0] == 'ENTRY': 
    162             self.tokens.pop(0) 
    163             if self.tokens[0] not in ['ENTRY']: 
     197        while self.is_token(EntryToken): 
     198            self.get_token() 
     199            if not self.is_token(EntryToken): 
    164200                sequence.append(self.parse_block_node()) 
    165201            else: 
     
    169205    def parse_block_mapping(self): 
    170206        mapping = [] 
    171         if self.tokens[0] != 'BLOCK_MAP_START': 
    172             self.error('BLOCK_MAP_START is expected') 
    173         self.tokens.pop(0) 
    174         while self.tokens[0] in ['KEY', 'VALUE']: 
     207        if not self.is_token(BlockMappingStartToken): 
     208            self.fail('BLOCK-MAPPING-START is expected') 
     209        self.get_token() 
     210        while self.is_token(KeyToken, ValueToken): 
    175211            key = None 
    176212            value = None 
    177             if self.tokens[0] == 'KEY': 
    178                 self.tokens.pop(0) 
    179                 if self.tokens[0] not in ['KEY', 'VALUE', 'BLOCK_END']: 
     213            if self.is_token(KeyToken): 
     214                self.get_token() 
     215                if not self.is_token(KeyToken, ValueToken, BlockEndToken): 
    180216                    key = self.parse_block_node_or_indentless_sequence() 
    181             if self.tokens[0] == 'VALUE': 
    182                 self.tokens.pop(0) 
    183                 if self.tokens[0] not in ['KEY', 'VALUE', 'BLOCK_END']: 
     217            if self.is_token(ValueToken): 
     218                self.get_token() 
     219                if not self.is_token(KeyToken, ValueToken, BlockEndToken): 
    184220                    value = self.parse_block_node_or_indentless_sequence() 
    185221            mapping.append((key, value)) 
    186         if self.tokens[0] != 'BLOCK_END': 
    187             self.error('BLOCK_END is expected') 
    188         self.tokens.pop(0) 
     222        if not self.is_token(BlockEndToken): 
     223            self.fail('BLOCK-END is expected') 
     224        self.get_token() 
    189225        return mapping 
    190226 
    191227    def parse_flow_sequence(self): 
    192228        sequence = [] 
    193         if self.tokens[0] != 'FLOW_SEQ_START': 
    194             self.error('FLOW_SEQ_START is expected') 
    195         self.tokens.pop(0) 
    196         while self.tokens[0] != 'FLOW_SEQ_END': 
    197             if self.tokens[0] == 'KEY': 
    198                 self.tokens.pop(0) 
     229        if not self.is_token(FlowSequenceStartToken): 
     230            self.fail('FLOW-SEQUENCE-START is expected') 
     231        self.get_token() 
     232        while not self.is_token(FlowSequenceEndToken): 
     233            if self.is_token(KeyToken): 
     234                self.get_token() 
    199235                key = None 
    200236                value = None 
    201                 if self.tokens[0] != 'VALUE': 
     237                if not self.is_token(ValueToken): 
    202238                    key = self.parse_flow_node() 
    203                 if self.tokens[0] == 'VALUE': 
    204                     self.tokens.pop(0) 
    205                     if self.tokens[0] not in ['ENTRY', 'FLOW_SEQ_END']: 
     239                if self.is_token(ValueToken): 
     240                    self.get_token() 
     241                    if not self.is_token(EntryToken, FlowSequenceEndToken): 
    206242                        value = self.parse_flow_node() 
    207                 sequence.append([(key, value)]) 
     243                node = MappingNode(None, None, [(key, value)]) 
     244                sequence.append(node) 
    208245            else: 
    209246                sequence.append(self.parse_flow_node()) 
    210             if self.tokens[0] not in ['ENTRY', 'FLOW_SEQ_END']: 
    211                 self.error("ENTRY or FLOW_SEQ_END is expected") 
    212             if self.tokens[0] == 'ENTRY': 
    213                 self.tokens.pop(0) 
    214         if self.tokens[0] != 'FLOW_SEQ_END': 
    215             self.error('FLOW_SEQ_END is expected') 
    216         self.tokens.pop(0) 
     247            if not self.is_token(EntryToken, FlowSequenceEndToken): 
     248                self.fail("ENTRY or FLOW-SEQUENCE-END are expected") 
     249            if self.is_token(EntryToken): 
     250                self.get_token() 
     251        if not self.is_token(FlowSequenceEndToken): 
     252            self.fail('FLOW-SEQUENCE-END is expected') 
     253        self.get_token() 
    217254        return sequence 
    218255 
    219256    def parse_flow_mapping(self): 
    220257        mapping = [] 
    221         if self.tokens[0] != 'FLOW_MAP_START': 
    222             self.error('FLOW_MAP_START is expected') 
    223         self.tokens.pop(0) 
    224         while self.tokens[0] != 'FLOW_MAP_END': 
    225             if self.tokens[0] == 'KEY': 
    226                 self.tokens.pop(0) 
     258        if not self.is_token(FlowMappingStartToken): 
     259            self.fail('FLOW-MAPPING-START is expected') 
     260        self.get_token() 
     261        while not self.is_token(FlowMappingEndToken): 
     262            if self.is_token(KeyToken): 
     263                self.get_token() 
    227264                key = None 
    228265                value = None 
    229                 if self.tokens[0] != 'VALUE': 
     266                if not self.is_token(ValueToken): 
    230267                    key = self.parse_flow_node() 
    231                 if self.tokens[0] == 'VALUE': 
    232                     self.tokens.pop(0) 
    233                     if self.tokens[0] not in ['ENTRY', 'FLOW_MAP_END']: 
     268                if self.is_token(ValueToken): 
     269                    self.get_token() 
     270                    if not self.is_token(EntryToken, FlowMappingEndToken): 
    234271                        value = self.parse_flow_node() 
    235272                mapping.append((key, value)) 
    236273            else: 
    237274                mapping.append((self.parse_flow_node(), None)) 
    238             if self.tokens[0] not in ['ENTRY', 'FLOW_MAP_END']: 
    239                 self.error("ENTRY or FLOW_MAP_END is expected") 
    240             if self.tokens[0] == 'ENTRY': 
    241                 self.tokens.pop(0) 
    242         if self.tokens[0] != 'FLOW_MAP_END': 
    243             self.error('FLOW_MAP_END is expected') 
    244         self.tokens.pop(0) 
     275            if not self.is_token(EntryToken, FlowMappingEndToken): 
     276                self.fail("ENTRY or FLOW-MAPPING-END are expected") 
     277            if self.is_token(EntryToken): 
     278                self.get_token() 
     279        if not self.is_token(FlowMappingEndToken): 
     280            self.fail('FLOW-MAPPING-END is expected') 
     281        self.get_token() 
    245282        return mapping 
    246283 
    247     def error(self, message): 
    248         raise Error(message+': '+str(self.tokens)) 
    249  
    250  
     284    def fail(self, message): 
     285        marker = self.scanner.peek_token().start_marker 
     286        raise Error(message+':\n'+marker.get_snippet()) 
     287 
  • branches/pyyaml3000/lib/yaml/scanner.py

    r43 r44  
    2323        self.end_marker = end_marker 
    2424 
    25 class YAMLDirective(Token): 
     25class DirectiveToken(Token): 
     26    pass 
     27 
     28class YAMLDirectiveToken(DirectiveToken): 
    2629    def __init__(self, major_version, minor_version, start_marker, end_marker): 
    2730        self.major_version = major_version 
     
    3033        self.end_marker = end_marker 
    3134 
    32 class TagDirective(Token): 
    33     pass 
    34  
    35 class ReservedDirective(Token): 
     35class TagDirectiveToken(DirectiveToken): 
     36    pass 
     37 
     38class ReservedDirectiveToken(DirectiveToken): 
    3639    def __init__(self, name, start_marker, end_marker): 
    3740        self.name = name 
     
    3942        self.end_marker = end_marker 
    4043 
    41 class DocumentStart(Token): 
    42     pass 
    43  
    44 class DocumentEnd(Token): 
    45     pass 
    46  
    47 class End(Token): 
    48     pass 
    49  
    50 class BlockSequenceStart(Token): 
    51     pass 
    52  
    53 class BlockMappingStart(Token): 
    54     pass 
    55  
    56 class BlockEnd(Token): 
    57     pass 
    58  
    59 class FlowSequenceStart(Token): 
    60     pass 
    61  
    62 class FlowMappingStart(Token): 
    63     pass 
    64  
    65 class FlowSequenceEnd(Token): 
    66     pass 
    67  
    68 class FlowMappingEnd(Token): 
    69     pass 
    70  
    71 class Key(Token): 
    72     pass 
    73  
    74 class Value(Token): 
    75     pass 
    76  
    77 class Entry(Token): 
    78     pass 
    79  
    80 class Alias(Token): 
     44class DocumentStartToken(Token): 
     45    pass 
     46 
     47class DocumentEndToken(Token): 
     48    pass 
     49 
     50class EndToken(Token): 
     51    pass 
     52 
     53class BlockSequenceStartToken(Token): 
     54    pass 
     55 
     56class BlockMappingStartToken(Token): 
     57    pass 
     58 
     59class BlockEndToken(Token): 
     60    pass 
     61 
     62class FlowSequenceStartToken(Token): 
     63    pass 
     64 
     65class FlowMappingStartToken(Token): 
     66    pass 
     67 
     68class FlowSequenceEndToken(Token): 
     69    pass 
     70 
     71class FlowMappingEndToken(Token): 
     72    pass 
     73 
     74class KeyToken(Token): 
     75    pass 
     76 
     77class ValueToken(Token): 
     78    pass 
     79 
     80class EntryToken(Token): 
     81    pass 
     82 
     83class AliasToken(Token): 
    8184    def __init__(self, value, start_marker, end_marker): 
    8285        self.value = value 
     
    8487        self.end_marker = end_marker 
    8588 
    86 class Anchor(Token): 
     89class AnchorToken(Token): 
    8790    def __init__(self, value, start_marker, end_marker): 
    8891        self.value = value 
     
    9093        self.end_marker = end_marker 
    9194 
    92 class Tag(Token): 
     95class TagToken(Token): 
    9396    def __init__(self, value, start_marker, end_marker): 
    9497        self.value = value 
     
    9699        self.end_marker = end_marker 
    97100 
    98 class Scalar(Token): 
     101class ScalarToken(Token): 
    99102    def __init__(self, value, plain, start_marker, end_marker): 
    100103        self.value = value 
     
    380383            marker = self.stream.get_marker() 
    381384            self.indent = self.indents.pop() 
    382             self.tokens.append(BlockEnd(marker, marker)) 
     385            self.tokens.append(BlockEndToken(marker, marker)) 
    383386 
    384387    def add_indent(self, column): 
     
    405408         
    406409        # Add END. 
    407         self.tokens.append(End(marker, marker)) 
     410        self.tokens.append(EndToken(marker, marker)) 
    408411 
    409412        # The stream is ended. 
     
    423426 
    424427    def fetch_document_start(self): 
    425         self.fetch_document_indicator(DocumentStart) 
     428        self.fetch_document_indicator(DocumentStartToken) 
    426429 
    427430    def fetch_document_end(self): 
    428         self.fetch_document_indicator(DocumentEnd) 
     431        self.fetch_document_indicator(DocumentEndToken) 
    429432 
    430433    def fetch_document_indicator(self, TokenClass): 
     
    445448 
    446449    def fetch_flow_sequence_start(self): 
    447         self.fetch_flow_collection_start(FlowSequenceStart) 
     450        self.fetch_flow_collection_start(FlowSequenceStartToken) 
    448451 
    449452    def fetch_flow_mapping_start(self): 
    450         self.fetch_flow_collection_start(FlowMappingStart) 
     453        self.fetch_flow_collection_start(FlowMappingStartToken) 
    451454 
    452455    def fetch_flow_collection_start(self, TokenClass): 
     456 
     457        # '[' and '{' may start a simple key. 
     458        self.save_possible_simple_key() 
    453459 
    454460        # Increase the flow level. 
    455461        self.flow_level += 1 
    456  
    457         # '[' and '{' may start a simple key. 
    458         self.save_possible_simple_key() 
    459462 
    460463        # Simple keys are allowed after '[' and '{'. 
     
    468471 
    469472    def fetch_flow_sequence_end(self): 
    470         self.fetch_flow_collection_end(FlowSequenceEnd) 
     473        self.fetch_flow_collection_end(FlowSequenceEndToken) 
    471474 
    472475    def fetch_flow_mapping_end(self): 
    473         self.fetch_flow_collection_end(FlowMappingEnd) 
     476        self.fetch_flow_collection_end(FlowMappingEndToken) 
    474477 
    475478    def fetch_flow_collection_end(self, TokenClass): 
     
    502505            if self.add_indent(self.stream.column): 
    503506                marker = self.stream.get_marker() 
    504                 self.tokens.append(BlockSequenceStart(marker, marker)) 
     507                self.tokens.append(BlockSequenceStartToken(marker, marker)) 
    505508 
    506509        # Simple keys are allowed after '-' and ','. 
     
    514517        self.stream.read() 
    515518        end_marker = self.stream.get_marker() 
    516         self.tokens.append(Entry(start_marker, end_marker)) 
     519        self.tokens.append(EntryToken(start_marker, end_marker)) 
    517520 
    518521    def fetch_key(self): 
     
    528531            if self.add_indent(self.stream.column): 
    529532                marker = self.stream.get_marker() 
    530                 self.tokens.append(BlockMappingStart(marker, marker)) 
     533                self.tokens.append(BlockMappingStartToken(marker, marker)) 
    531534 
    532535        # Simple keys are allowed after '?' in the block context. 
     
    540543        self.stream.read() 
    541544        end_marker = self.stream.get_marker() 
    542         self.tokens.append(Key(start_marker, end_marker)) 
     545        self.tokens.append(KeyToken(start_marker, end_marker)) 
    543546 
    544547    def fetch_value(self): 
     
    551554            del self.possible_simple_keys[self.flow_level] 
    552555            self.tokens.insert(key.token_number-self.tokens_taken, 
    553                     Key(key.marker, key.marker)) 
     556                    KeyToken(key.marker, key.marker)) 
    554557 
    555558            # If this key starts a new block mapping, we need to add 
     
    558561                if self.add_indent(key.column): 
    559562                    self.tokens.insert(key.token_number-self.tokens_taken, 
    560                             BlockMappingStart(key.marker, key.marker)) 
     563                            BlockMappingStartToken(key.marker, key.marker)) 
    561564 
    562565            # There cannot be two simple keys one after another. 
     
    576579        self.stream.read() 
    577580        end_marker = self.stream.get_marker() 
    578         self.tokens.append(Value(start_marker, end_marker)) 
     581        self.tokens.append(ValueToken(start_marker, end_marker)) 
    579582 
    580583    def fetch_alias(self): 
     
    587590 
    588591        # Scan and add ALIAS. 
    589         self.scan_anchor(Alias) 
     592        self.scan_anchor(AliasToken) 
    590593 
    591594    def fetch_anchor(self): 
     
    598601 
    599602        # Scan and add ANCHOR. 
    600         self.scan_anchor(Anchor) 
     603        self.scan_anchor(AnchorToken) 
    601604 
    602605    def fetch_tag(self): 
     
    739742        marker = self.stream.get_marker() 
    740743        if self.stream.peek(5) == u'%YAML ': 
    741             self.tokens.append(YAMLDirective(1, 1, marker, marker)) 
     744            self.tokens.append(YAMLDirectiveToken(1, 1, marker, marker)) 
    742745        elif self.stream.peek(4) == u'%TAG ': 
    743             self.tokens.append(TagDirective(marker, marker)) 
     746            self.tokens.append(TagDirectiveToken(marker, marker)) 
    744747        else: 
    745             self.tokens.append(ReservedDirective('', marker, marker)) 
     748            self.tokens.append(ReservedDirectiveToken('', marker, marker)) 
    746749        while self.stream.peek() not in u'\0\r\n': 
    747750            self.stream.read() 
     
    760763            self.stream.read() 
    761764        end_marker = self.stream.get_marker() 
    762         self.tokens.append(Tag('', start_marker, end_marker)) 
     765        self.tokens.append(TagToken('', start_marker, end_marker)) 
    763766 
    764767    def scan_block_scalar(self, folded): 
     
    768771            indent = 1 
    769772        while True: 
    770             while self.stream.peek() and self.stream.peek() and self.stream.peek() not in u'\0\r\n': 
     773            while self.stream.peek() and self.stream.peek() and self.stream.peek() not in u'\0\r\n\x85\u2028\u2029': 
    771774                self.stream.read() 
    772775            if self.stream.peek() != u'\0': 
     
    776779                self.stream.read() 
    777780                count += 1 
    778             if count < indent and self.stream.peek() not in u'#\r\n': 
     781            if count < indent and self.stream.peek() not in u'#\r\n\x85\u2028\u2029': 
    779782                break 
    780         self.tokens.append(Scalar('', False, start_marker, start_marker)) 
     783        self.tokens.append(ScalarToken('', False, start_marker, start_marker)) 
    781784 
    782785    def scan_flow_scalar(self, double): 
     
    791794                self.stream.read(1) 
    792795        self.stream.read(1) 
    793         self.tokens.append(Scalar('', False, marker, marker)) 
     796        self.tokens.append(ScalarToken('', False, marker, marker)) 
    794797 
    795798    def scan_plain(self): 
     
    823826                break 
    824827            space = True 
    825         self.tokens.append(Scalar('', True, marker, marker)) 
     828        self.tokens.append(ScalarToken('', True, marker, marker)) 
    826829 
    827830    def invalid_token(self): 
  • branches/pyyaml3000/lib/yaml/stream.py

    r43 r44  
    1919            if self.index >= len(self.data): 
    2020                break 
    21             if self.data[self.index] in u'\r\n': 
     21            if self.data[self.index] in u'\r\n\x85\u2028\u2029': 
    2222                self.line += 1 
    2323                self.column = 0 
  • branches/pyyaml3000/tests/data/spec-05-03.canonical

    r38 r44  
    99  : !!map { 
    1010    ? !!str "sky" : !!str "blue", 
    11     ? !!str "sea" : !!str "green", 
     11#    ? !!str "sea" : !!str "green", 
     12    ? !!map { ? !!str "sea" : !!str "green" } : !!null "", 
    1213  } 
    1314} 
  • branches/pyyaml3000/tests/data/spec-07-10.canonical

    r38 r44  
    1212} 
    1313--- 
    14 !!str "" 
     14#!!str "" 
     15!!null "" 
  • branches/pyyaml3000/tests/data/spec-08-01.data

    r38 r44  
    1 !!str 
    2  &a1 
    3   "foo" : !!str bar 
     1!!str &a1 "foo" : !!str bar 
    42&a2 baz : *a1 
  • branches/pyyaml3000/tests/data/spec-08-12.data

    r38 r44  
    44  !!str 'Tagged', 
    55  *anchor, # Alias node 
    6   !!str,   # Empty plain scalar 
     6#  !!str,   # Empty plain scalar 
     7  '',   # Empty plain scalar 
    78] 
  • branches/pyyaml3000/tests/data/spec-08-13.canonical

    r42 r44  
    33!!map { 
    44  ? !!str "foo" 
    5   : !!str "", 
    6   ? !!str "" 
     5#  : !!str "", 
     6#  ? !!str "" 
     7  : !!null "", 
     8  ? !!null "" 
    79  : !!str "bar", 
    810} 
  • branches/pyyaml3000/tests/data/spec-08-15.canonical

    r42 r44  
    22--- 
    33!!seq [ 
    4   !!str "", 
     4  !!null "", 
    55  !!map { 
    66    ? !!str "foo" 
    7     : !!str "", 
    8     ? !!str "" 
     7    : !!null "", 
     8    ? !!null "" 
    99    : !!str "bar", 
    1010  } 
  • branches/pyyaml3000/tests/data/spec-08-15.data

    r38 r44  
    1 seq: 
    21- # Empty plain scalar 
    32- ? foo 
    43  : 
    54  ? 
    6   : bar, 
     5  : bar 
  • branches/pyyaml3000/tests/data/spec-09-12.data

    r38 r44  
    44- -123 
    55# Inside flow collection: 
    6 - [ ::std::vector, 
     6- [ '::std::vector', 
    77  "Up, up and away!", 
    88  -123 ] 
  • branches/pyyaml3000/tests/data/spec-09-25.canonical

    r38 r44  
    11%YAML 1.1 
    22--- 
    3 !!seq [ 
    4   !!str "literal\n\ 
    5         \ttext\n" 
    6 ] 
     3!!str "literal\n\ 
     4      \ttext\n" 
  • branches/pyyaml3000/tests/data/spec-09-29.canonical

    r38 r44  
    11%YAML 1.1 
    22--- 
    3 !!seq [ 
    4   !!str "folded text\n\ 
    5         \tlines\n" 
    6 ] 
     3!!str "folded text\n\ 
     4      \tlines\n" 
  • branches/pyyaml3000/tests/data/spec-09-30.canonical

    r38 r44  
    11%YAML 1.1 
    22--- 
    3 !!seq [ 
    4   !!str "folded line\n\ 
    5         next line\n\ 
    6         \  * bullet\n\ 
    7         \  * list\n\ 
    8         last line\n" 
    9 ] 
     3!!str "folded line\n\ 
     4      next line\n\ 
     5      \  * bullet\n\ 
     6      \  * list\n\ 
     7      last line\n" 
  • branches/pyyaml3000/tests/data/spec-09-31.canonical

    r38 r44  
    11%YAML 1.1 
    22--- 
    3 !!seq [ 
    4   !!str "folded line\n\ 
    5         next line\n\ 
    6         \  * bullet\n\ 
    7         \  * list\n\ 
    8         last line\n" 
    9 ] 
     3!!str "folded line\n\ 
     4      next line\n\ 
     5      \  * bullet\n\ 
     6      \  * list\n\ 
     7      last line\n" 
  • branches/pyyaml3000/tests/data/spec-09-32.canonical

    r38 r44  
    11%YAML 1.1 
    22--- 
    3 !!seq [ 
    4   !!str "folded line\n\ 
    5         next line\n\ 
    6         \  * bullet\n\ 
    7         \  * list\n\ 
    8         last line\n" 
    9 ] 
     3!!str "folded line\n\ 
     4      next line\n\ 
     5      \  * bullet\n\ 
     6      \  * list\n\ 
     7      last line\n" 
  • branches/pyyaml3000/tests/data/spec-09-33.canonical

    r38 r44  
    11%YAML 1.1 
    22--- 
    3 !!seq [ 
    4   !!str "folded line\n\ 
    5         next line\n\ 
    6         \  * bullet\n\ 
    7         \  * list\n\ 
    8         last line\n" 
    9 ] 
     3!!str "folded line\n\ 
     4      next line\n\ 
     5      \  * bullet\n\ 
     6      \  * list\n\ 
     7      last line\n" 
  • branches/pyyaml3000/tests/data/spec-10-05.canonical

    r42 r44  
    22--- 
    33!!seq [ 
    4   !!str "", 
     4  !!null "", 
    55  !!str "block node\n", 
    66  !!seq [ 
  • branches/pyyaml3000/tests/data/spec-10-07.canonical

    r38 r44  
    22--- 
    33!!map { 
    4   ? !!str "" 
     4  ? !!null "" 
    55  : !!str "value", 
    66  ? !!str "explicit key" 
  • branches/pyyaml3000/tests/data/spec-10-07.data

    r38 r44  
    11{ 
    2 ? : value # Empty key 
     2#? : value # Empty key 
     3? ~ : value, # Empty key 
    34? explicit 
    45 key: value, 
    5 simple key : value 
     6simple key : value, 
    67[ collection, simple, key ]: value 
    78} 
  • branches/pyyaml3000/tests/data/spec-10-09.canonical

    r38 r44  
    55  : !!str "value", 
    66  ? !!str "empty" 
    7   : !!str "", 
     7  : !!null "", 
    88} 
  • branches/pyyaml3000/tests/data/spec-10-10.canonical

    r38 r44  
    55  : !!str "explicit value", 
    66  ? !!str "explicit key2" 
    7   : !!str "", 
     7  : !!null "", 
    88  ? !!str "explicit key3" 
    9   : !!str "", 
     9  : !!null "", 
    1010  ? !!str "simple key1" 
    1111  : !!str "explicit value", 
    1212  ? !!str "simple key2" 
    13   : !!str "", 
     13  : !!null "", 
    1414  ? !!str "simple key3" 
    15   : !!str "", 
     15  : !!null "", 
    1616} 
  • branches/pyyaml3000/tests/data/spec-10-11.canonical

    r38 r44  
    88  !!map { 
    99    ? !!str "explicit key2" 
    10     : !!str "", 
     10    : !!null "", 
    1111  }, 
    1212  !!map { 
    1313    ? !!str "explicit key3" 
    14     : !!str "", 
     14    : !!null "", 
    1515  }, 
    1616  !!map { 
     
    2020  !!map { 
    2121    ? !!str "simple key2" 
    22     : !!str "", 
     22    : !!null "", 
    2323  }, 
    2424] 
  • branches/pyyaml3000/tests/data/spec-10-13.canonical

    r38 r44  
    33!!map { 
    44  ? !!str "explicit key" 
    5   : !!str "", 
     5  : !!null "", 
    66  ? !!str "block key\n" 
    77  : !!seq [ 
  • branches/pyyaml3000/tests/data/spec-10-14.canonical

    r38 r44  
    33!!map { 
    44  ? !!str "plain key" 
    5   : !!str "", 
     5  : !!null "", 
    66  ? !!str "quoted key\n" 
    77  : !!seq [ 
  • branches/pyyaml3000/tests/test_appliance.py

    r43 r44  
    3333            if hasattr(self, attribute): 
    3434                args.append(repr(getattr(self, attribute))) 
    35         return "%s(%s)" % (self.__class__.__name__, ''.join(args)) 
     35        return "%s(%s)" % (self.__class__.__name__, ', '.join(args)) 
    3636 
    3737class AliasNode(Node): 
  • branches/pyyaml3000/tests/test_tokens.py

    r43 r44  
    2626 
    2727    replaces = { 
    28         YAMLDirective: '%', 
    29         TagDirective: '%', 
    30         ReservedDirective: '%', 
    31         DocumentStart: '---', 
    32         DocumentEnd: '...', 
    33         Alias: '*', 
    34         Anchor: '&', 
    35         Tag: '!', 
    36         Scalar: '_', 
    37         BlockSequenceStart: '[[', 
    38         BlockMappingStart: '{{', 
    39         BlockEnd: ']}', 
    40         FlowSequenceStart: '[', 
    41         FlowSequenceEnd: ']', 
    42         FlowMappingStart: '{', 
    43         FlowMappingEnd: '}', 
    44         Entry: ',', 
    45         Key: '?', 
    46         Value: ':', 
     28        YAMLDirectiveToken: '%', 
     29        TagDirectiveToken: '%', 
     30        ReservedDirectiveToken: '%', 
     31        DocumentStartToken: '---', 
     32        DocumentEndToken: '...', 
     33        AliasToken: '*', 
     34        AnchorToken: '&', 
     35        TagToken: '!', 
     36        ScalarToken: '_', 
     37        BlockSequenceStartToken: '[[', 
     38        BlockMappingStartToken: '{{', 
     39        BlockEndToken: ']}', 
     40        FlowSequenceStartToken: '[', 
     41        FlowSequenceEndToken: ']', 
     42        FlowMappingStartToken: '{', 
     43        FlowMappingEndToken: '}', 
     44        EntryToken: ',', 
     45        KeyToken: '?', 
     46        ValueToken: ':', 
    4747    } 
    4848 
     
    5353            scanner = Scanner(data_filename, file(data_filename, 'rb').read()) 
    5454            tokens1 = [] 
    55             while not isinstance(scanner.peek_token(), End): 
     55            while not isinstance(scanner.peek_token(), EndToken): 
    5656                tokens1.append(scanner.get_token()) 
    5757            tokens1 = [self.replaces[t.__class__] for t in tokens1] 
     
    7575                scanner = Scanner(filename, file(filename, 'rb').read()) 
    7676                tokens = [] 
    77                 while not isinstance(scanner.peek_token(), End): 
     77                while not isinstance(scanner.peek_token(), EndToken): 
    7878                    tokens.append(scanner.get_token().__class__.__name__) 
    7979            except: 
  • branches/pyyaml3000/tests/test_yaml.py

    r43 r44  
    55from test_canonical import * 
    66from test_tokens import * 
     7from test_structure import * 
    78 
    89def main(module='__main__'): 
Note: See TracChangeset for help on using the changeset viewer.