Changeset 130


Ignore:
Timestamp:
04/03/06 14:20:25 (7 years ago)
Author:
xi
Message:

Add style information to events generated by Parser.

Location:
pyyaml/trunk
Files:
13 edited
6 copied

Legend:

Unmodified
Added
Removed

  • pyyaml/trunk/examples/yaml-hl/yaml_hl_ascii.cfg

    r119 r130  
    2828    document-start: 
    2929    document-end: 
    30     sequence: 
    31     mapping: 
    32     collection-end: 
     30    sequence-start: 
     31    sequence-end: 
     32    mapping-start: 
     33    mapping-end: 
    3334    scalar: 
    3435 

  • pyyaml/trunk/examples/yaml-hl/yaml_hl_html.cfg

    r119 r130  
    2727    document-start: { start: <span class="document"> } 
    2828    document-end:   { end: </span> } 
    29     sequence:       { start: <span class="sequence"> } 
    30     mapping:        { start: <span class="mapping"> } 
    31     collection-end: { end: </span> } 
     29    sequence-start: { start: <span class="sequence"> } 
     30    sequence-end:   { end: </span> } 
     31    mapping-start:  { start: <span class="mapping"> } 
     32    mapping-end:    { end: </span> } 
    3233    scalar:         { start: <span class="scalar">, end: </span> } 
    3334 

  • pyyaml/trunk/lib/yaml/composer.py

    r118 r130  
    7272        if self.parser.check(ScalarEvent): 
    7373            node = self.compose_scalar_node() 
    74         elif self.parser.check(SequenceEvent): 
     74        elif self.parser.check(SequenceStartEvent): 
    7575            node = self.compose_sequence_node() 
    76         elif self.parser.check(MappingEvent): 
     76        elif self.parser.check(MappingStartEvent): 
    7777            node = self.compose_mapping_node() 
    7878        if anchor is not None: 
    … …  
    8888        start_event = self.parser.get() 
    8989        value = [] 
    90         while not self.parser.check(CollectionEndEvent): 
     90        while not self.parser.check(SequenceEndEvent): 
    9191            value.append(self.compose_node()) 
    9292        end_event = self.parser.get() 
    … …  
    9797        start_event = self.parser.get() 
    9898        value = {} 
    99         while not self.parser.check(CollectionEndEvent): 
     99        while not self.parser.check(MappingEndEvent): 
    100100            key_event = self.parser.peek() 
    101101            item_key = self.compose_node() 

  • pyyaml/trunk/lib/yaml/events.py

    r118 r130  
     1 
     2# Abstract classes. 
    13 
    24class Event: 
    3     def __init__(self, start_mark, end_mark): 
     5    def __init__(self, start_mark=None, end_mark=None): 
    46        self.start_mark = start_mark 
    57        self.end_mark = end_mark 
    68    def __repr__(self): 
    7         attributes = [key for key in self.__dict__ 
    8                 if not key.endswith('_mark')] 
    9         attributes.sort() 
     9        attributes = [key for key in ['anchor', 'tag', 'value'] 
     10                if hasattr(self, key)] 
    1011        arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) 
    1112                for key in attributes]) 
    … …  
    1314 
    1415class NodeEvent(Event): 
    15     def __init__(self, anchor, start_mark, end_mark): 
     16    def __init__(self, anchor, start_mark=None, end_mark=None): 
    1617        self.anchor = anchor 
    1718        self.start_mark = start_mark 
    1819        self.end_mark = end_mark 
     20 
     21class CollectionStartEvent(NodeEvent): 
     22    def __init__(self, anchor, tag, start_mark=None, end_mark=None, 
     23            flow_style=None): 
     24        self.anchor = anchor 
     25        self.tag = tag 
     26        self.start_mark = start_mark 
     27        self.end_mark = end_mark 
     28        self.flow_style = flow_style 
     29 
     30class CollectionEndEvent(Event): 
     31    pass 
     32 
     33# Implementations. 
     34 
     35class StreamStartEvent(Event): 
     36    def __init__(self, start_mark=None, end_mark=None, 
     37            encoding=None, canonical=None, indent=None, width=None): 
     38        self.start_mark = start_mark 
     39        self.end_mark = end_mark 
     40        self.encoding = encoding 
     41        self.canonical = canonical 
     42        self.indent = indent 
     43        self.width = width 
     44 
     45class StreamEndEvent(Event): 
     46    pass 
     47 
     48class DocumentStartEvent(Event): 
     49    def __init__(self, start_mark=None, end_mark=None, 
     50            implicit=None, version=None, tags=None): 
     51        self.start_mark = start_mark 
     52        self.end_mark = end_mark 
     53        self.implicit = implicit 
     54        self.version = version 
     55        self.tags = tags 
     56 
     57class DocumentEndEvent(Event): 
     58    def __init__(self, start_mark=None, end_mark=None, 
     59            implicit=None): 
     60        self.start_mark = start_mark 
     61        self.end_mark = end_mark 
     62        self.implicit = implicit 
    1963 
    2064class AliasEvent(NodeEvent): 
    … …  
    2266 
    2367class ScalarEvent(NodeEvent): 
    24     def __init__(self, anchor, tag, value, start_mark, end_mark): 
     68    def __init__(self, anchor, tag, value, start_mark=None, end_mark=None, 
     69            implicit=None, style=None): 
    2570        self.anchor = anchor 
    2671        self.tag = tag 
    … …  
    2873        self.start_mark = start_mark 
    2974        self.end_mark = end_mark 
     75        self.implicit = implicit 
     76        self.style = style 
    3077 
    31 class CollectionEvent(NodeEvent): 
    32     def __init__(self, anchor, tag, start_mark, end_mark): 
    33         self.anchor = anchor 
    34         self.tag = tag 
    35         self.start_mark = start_mark 
    36         self.end_mark = end_mark 
    37  
    38 class SequenceEvent(CollectionEvent): 
     78class SequenceStartEvent(CollectionStartEvent): 
    3979    pass 
    4080 
    41 class MappingEvent(CollectionEvent): 
     81class SequenceEndEvent(CollectionEndEvent): 
    4282    pass 
    4383 
    44 class CollectionEndEvent(Event): 
     84class MappingStartEvent(CollectionStartEvent): 
    4585    pass 
    4686 
    47 class DocumentStartEvent(Event): 
     87class MappingEndEvent(CollectionEndEvent): 
    4888    pass 
    4989 
    50 class DocumentEndEvent(Event): 
    51     pass 
    52  
    53 class StreamStartEvent(Event): 
    54     pass 
    55  
    56 class StreamEndEvent(Event): 
    57     pass 
    58  

  • pyyaml/trunk/lib/yaml/parser.py

    r118 r130  
    131131        # Parse start of stream. 
    132132        token = self.scanner.get() 
    133         yield StreamStartEvent(token.start_mark, token.end_mark) 
     133        yield StreamStartEvent(token.start_mark, token.end_mark, 
     134                encoding=token.encoding) 
    134135 
    135136        # Parse implicit document. 
    … …  
    139140            token = self.scanner.peek() 
    140141            start_mark = end_mark = token.start_mark 
    141             yield DocumentStartEvent(start_mark, end_mark) 
     142            yield DocumentStartEvent(start_mark, end_mark, 
     143                    implicit=True) 
    142144            for event in self.parse_block_node(): 
    143145                yield event 
    144146            token = self.scanner.peek() 
    145147            start_mark = end_mark = token.start_mark 
     148            implicit = True 
    146149            while self.scanner.check(DocumentEndToken): 
    147150                token = self.scanner.get() 
    148151                end_mark = token.end_mark 
    149             yield DocumentEndEvent(start_mark, end_mark) 
     152                implicit = True 
     153            yield DocumentEndEvent(start_mark, end_mark, 
     154                    implicit=implicit) 
    150155 
    151156        # Parse explicit documents. 
    … …  
    153158            token = self.scanner.peek() 
    154159            start_mark = token.start_mark 
    155             self.process_directives() 
     160            version, tags = self.process_directives() 
    156161            if not self.scanner.check(DocumentStartToken): 
    157162                raise ParserError(None, None, 
    … …  
    161166            token = self.scanner.get() 
    162167            end_mark = token.end_mark 
    163             yield DocumentStartEvent(start_mark, end_mark) 
     168            yield DocumentStartEvent(start_mark, end_mark, 
     169                    implicit=False, version=version, tags=tags) 
    164170            if self.scanner.check(DirectiveToken, 
    165171                    DocumentStartToken, DocumentEndToken, StreamEndToken): 
    … …  
    170176            token = self.scanner.peek() 
    171177            start_mark = end_mark = token.start_mark 
     178            implicit=True 
    172179            while self.scanner.check(DocumentEndToken): 
    173180                token = self.scanner.get() 
    174181                end_mark = token.end_mark 
    175             yield DocumentEndEvent(start_mark, end_mark) 
     182                implicit=False 
     183            yield DocumentEndEvent(start_mark, end_mark, 
     184                    implicit=implicit) 
    176185 
    177186        # Parse end of stream. 
    … …  
    202211                            token.start_mark) 
    203212                self.tag_handles[handle] = prefix 
     213        if self.tag_handles: 
     214            value = self.yaml_version, self.tag_handles.copy() 
     215        else: 
     216            value = self.yaml_version, None 
    204217        for key in self.DEFAULT_TAGS: 
    205218            if key not in self.tag_handles: 
    206219                self.tag_handles[key] = self.DEFAULT_TAGS[key] 
     220        return value 
    207221 
    208222    def parse_block_node(self): 
    … …  
    233247            if self.scanner.check(AnchorToken): 
    234248                token = self.scanner.get() 
    235                 start_mark = end_mark = token.start_mark 
     249                start_mark = token.start_mark 
     250                end_mark = token.end_mark 
    236251                anchor = token.value 
    237252                if self.scanner.check(TagToken): 
    238253                    token = self.scanner.get() 
    239                     end_mark = tag_mark = token.start_mark 
     254                    tag_mark = token.start_mark 
     255                    end_mark = token.end_mark 
    240256                    tag = token.value 
    241257            elif self.scanner.check(TagToken): 
    242258                token = self.scanner.get() 
    243                 start_mark = end_mark = tag_mark = token.start_mark 
     259                start_mark = tag_mark = token.start_mark 
     260                end_mark = token.end_mark 
    244261                tag = token.value 
    245262                if self.scanner.check(AnchorToken): 
    246263                    token = self.scanner.get() 
    247                     end_mark = token.start_mark 
     264                    end_mark = token.end_mark 
    248265                    anchor = token.value 
    249266            if tag is not None: 
    … …  
    259276            if tag is None: 
    260277                if not (self.scanner.check(ScalarToken) and 
    261                         self.scanner.peek().plain): 
     278                        self.scanner.peek().implicit): 
    262279                    tag = u'!' 
    263280            if start_mark is None: 
    264                 start_mark = self.scanner.peek().start_mark 
     281                start_mark = end_mark = self.scanner.peek().start_mark 
    265282            event = None 
    266283            collection_events = None 
    267284            if indentless_sequence and self.scanner.check(BlockEntryToken): 
    268285                end_mark = self.scanner.peek().end_mark 
    269                 event = SequenceEvent(anchor, tag, start_mark, end_mark) 
     286                event = SequenceStartEvent(anchor, tag, start_mark, end_mark) 
    270287                collection_events = self.parse_indentless_sequence() 
    271288            else: 
    … …  
    274291                    end_mark = token.end_mark 
    275292                    event = ScalarEvent(anchor, tag, token.value, 
    276                             start_mark, end_mark) 
     293                            start_mark, end_mark, 
     294                            implicit=token.implicit, style=token.style) 
    277295                elif self.scanner.check(FlowSequenceStartToken): 
    278296                    end_mark = self.scanner.peek().end_mark 
    279                     event = SequenceEvent(anchor, tag, start_mark, end_mark) 
     297                    event = SequenceStartEvent(anchor, tag, start_mark, end_mark, 
     298                            flow_style=True) 
    280299                    collection_events = self.parse_flow_sequence() 
    281300                elif self.scanner.check(FlowMappingStartToken): 
    282301                    end_mark = self.scanner.peek().end_mark 
    283                     event = MappingEvent(anchor, tag, start_mark, end_mark) 
     302                    event = MappingStartEvent(anchor, tag, start_mark, end_mark, 
     303                            flow_style=True) 
    284304                    collection_events = self.parse_flow_mapping() 
    285305                elif block and self.scanner.check(BlockSequenceStartToken): 
    286306                    end_mark = self.scanner.peek().start_mark 
    287                     event = SequenceEvent(anchor, tag, start_mark, end_mark) 
     307                    event = SequenceStartEvent(anchor, tag, start_mark, end_mark, 
     308                            flow_style=False) 
    288309                    collection_events = self.parse_block_sequence() 
    289310                elif block and self.scanner.check(BlockMappingStartToken): 
    290311                    end_mark = self.scanner.peek().start_mark 
    291                     event = MappingEvent(anchor, tag, start_mark, end_mark) 
     312                    event = MappingStartEvent(anchor, tag, start_mark, end_mark, 
     313                            flow_style=False) 
    292314                    collection_events = self.parse_block_mapping() 
     315                elif anchor is not None or tag is not None: 
     316                    # Empty scalars are allowed even if a tag or an anchor is 
     317                    # specified. 
     318                    event = ScalarEvent(anchor, tag, u'', start_mark, end_mark, 
     319                            implicit=True) 
    293320                else: 
    294321                    if block: 
    … …  
    321348                    "expected <block end>, but found %r" % token.id, token.start_mark) 
    322349        token = self.scanner.get() 
    323         yield CollectionEndEvent(token.start_mark, token.end_mark) 
     350        yield SequenceEndEvent(token.start_mark, token.end_mark) 
    324351 
    325352    def parse_indentless_sequence(self): 
    … …  
    334361                yield self.process_empty_scalar(token.end_mark) 
    335362        token = self.scanner.peek() 
    336         yield CollectionEndEvent(token.start_mark, token.start_mark) 
     363        yield SequenceEndEvent(token.start_mark, token.start_mark) 
    337364 
    338365    def parse_block_mapping(self): 
    … …  
    366393                    "expected <block end>, but found %r" % token.id, token.start_mark) 
    367394        token = self.scanner.get() 
    368         yield CollectionEndEvent(token.start_mark, token.end_mark) 
     395        yield MappingEndEvent(token.start_mark, token.end_mark) 
    369396 
    370397    def parse_flow_sequence(self): 
    … …  
    384411            if self.scanner.check(KeyToken): 
    385412                token = self.scanner.get() 
    386                 yield MappingEvent(None, u'!', 
    387                         token.start_mark, token.end_mark) 
     413                yield MappingStartEvent(None, u'!', 
     414                        token.start_mark, token.end_mark, 
     415                        flow_style=True) 
    388416                if not self.scanner.check(ValueToken, 
    389417                        FlowEntryToken, FlowSequenceEndToken): 
    … …  
    403431                    yield self.process_empty_scalar(token.start_mark) 
    404432                token = self.scanner.peek() 
    405                 yield CollectionEndEvent(token.start_mark, token.start_mark) 
     433                yield MappingEndEvent(token.start_mark, token.start_mark) 
    406434            else: 
    407435                for event in self.parse_flow_node(): 
    … …  
    414442                self.scanner.get() 
    415443        token = self.scanner.get() 
    416         yield CollectionEndEvent(token.start_mark, token.end_mark) 
     444        yield SequenceEndEvent(token.start_mark, token.end_mark) 
    417445 
    418446    def parse_flow_mapping(self): 
    … …  
    458486                    "expected '}', but found %r" % token.id, token.start_mark) 
    459487        token = self.scanner.get() 
    460         yield CollectionEndEvent(token.start_mark, token.end_mark) 
     488        yield MappingEndEvent(token.start_mark, token.end_mark) 
    461489 
    462490    def process_empty_scalar(self, mark): 
    463         return ScalarEvent(None, None, u'', mark, mark) 
    464  
     491        return ScalarEvent(None, None, u'', mark, mark, 
     492                implicit=True) 
     493 

  • pyyaml/trunk/lib/yaml/reader.py

    r119 r130  
    101101        self.raw_buffer = None 
    102102        self.raw_decode = None 
     103        self.encoding = None 
    103104        self.index = 0 
    104105        self.line = 0 
    … …  
    157158            if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): 
    158159                self.raw_decode = utf_16_le_decode 
     160                self.encoding = 'utf-16-le' 
    159161            elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): 
    160162                self.raw_decode = utf_16_be_decode 
     163                self.encoding = 'utf-16-be' 
    161164            else: 
    162165                self.raw_decode = utf_8_decode 
     166                self.encoding = 'utf-8' 
    163167        self.update(1) 
    164168 

  • pyyaml/trunk/lib/yaml/scanner.py

    r118 r130  
    380380        mark = self.reader.get_mark() 
    381381         
    382         # Add STREAM-END. 
    383         self.tokens.append(StreamStartToken(mark, mark)) 
     382        # Add STREAM-START. 
     383        self.tokens.append(StreamStartToken(mark, mark, 
     384            encoding=self.reader.encoding)) 
    384385         
    385386 
    … …  
    639640 
    640641    def fetch_literal(self): 
    641         self.fetch_block_scalar(folded=False) 
     642        self.fetch_block_scalar(style='|') 
    642643 
    643644    def fetch_folded(self): 
    644         self.fetch_block_scalar(folded=True) 
    645  
    646     def fetch_block_scalar(self, folded): 
     645        self.fetch_block_scalar(style='>') 
     646 
     647    def fetch_block_scalar(self, style): 
    647648 
    648649        # A simple key may follow a block scalar. 
    … …  
    653654 
    654655        # Scan and add SCALAR. 
    655         self.tokens.append(self.scan_block_scalar(folded)) 
     656        self.tokens.append(self.scan_block_scalar(style)) 
    656657 
    657658    def fetch_single(self): 
    658         self.fetch_flow_scalar(double=False) 
     659        self.fetch_flow_scalar(style='\'') 
    659660 
    660661    def fetch_double(self): 
    661         self.fetch_flow_scalar(double=True) 
    662  
    663     def fetch_flow_scalar(self, double): 
     662        self.fetch_flow_scalar(style='"') 
     663 
     664    def fetch_flow_scalar(self, style): 
    664665 
    665666        # A flow scalar could be a simple key. 
    … …  
    670671 
    671672        # Scan and add SCALAR. 
    672         self.tokens.append(self.scan_flow_scalar(double)) 
     673        self.tokens.append(self.scan_flow_scalar(style)) 
    673674 
    674675    def fetch_plain(self): 
    … …  
    987988        return TagToken(value, start_mark, end_mark) 
    988989 
    989     def scan_block_scalar(self, folded): 
    990         # See the specification for details. 
     990    def scan_block_scalar(self, style): 
     991        # See the specification for details. 
     992 
     993        if style == '>': 
     994            folded = True 
     995        else: 
     996            folded = False 
    991997 
    992998        chunks = [] 
    … …  
    10221028            breaks, end_mark = self.scan_block_scalar_breaks(indent) 
    10231029            if self.reader.column == indent and self.reader.peek() != u'\0': 
     1030 
    10241031                # Unfortunately, folding rules are ambiguous. 
    10251032                # 
    … …  
    10541061 
    10551062        # We are done. 
    1056         return ScalarToken(u''.join(chunks), False, start_mark, end_mark) 
     1063        return ScalarToken(u''.join(chunks), False, start_mark, end_mark, 
     1064                style) 
    10571065 
    10581066    def scan_block_scalar_indicators(self, start_mark): 
    … …  
    11381146        return chunks, end_mark 
    11391147 
    1140     def scan_flow_scalar(self, double): 
     1148    def scan_flow_scalar(self, style): 
    11411149        # See the specification for details. 
    11421150        # Note that we loose indentation rules for quoted scalars. Quoted 
    … …  
    11451153        # restrictive then the specification requires. We only need to check 
    11461154        # that document separators are not included in scalars. 
     1155        if style == '"': 
     1156            double = True 
     1157        else: 
     1158            double = False 
    11471159        chunks = [] 
    11481160        start_mark = self.reader.get_mark() 
    … …  
    11551167        self.reader.forward() 
    11561168        end_mark = self.reader.get_mark() 
    1157         return ScalarToken(u''.join(chunks), False, start_mark, end_mark) 
     1169        return ScalarToken(u''.join(chunks), False, start_mark, end_mark, 
     1170                style) 
    11581171 
    11591172    ESCAPE_REPLACEMENTS = { 

  • pyyaml/trunk/lib/yaml/tokens.py

    r118 r130  
    3131class StreamStartToken(Token): 
    3232    id = '<stream start>' 
     33    def __init__(self, start_mark=None, end_mark=None, 
     34            encoding=None): 
     35        self.start_mark = start_mark 
     36        self.end_mark = end_mark 
     37        self.encoding = encoding 
    3338 
    3439class StreamEndToken(Token): 
    … …  
    9196class ScalarToken(Token): 
    9297    id = '<scalar>' 
    93     def __init__(self, value, plain, start_mark, end_mark): 
     98    def __init__(self, value, implicit, start_mark, end_mark, style=None): 
    9499        self.value = value 
    95         self.plain = plain 
     100        self.implicit = implicit 
    96101        self.start_mark = start_mark 
    97102        self.end_mark = end_mark 
     103        self.style = style 
    98104 

  • pyyaml/trunk/tests/data/aliases.events

    r129 r130  
    11- !StreamStart 
    22- !DocumentStart 
    3 - !Sequence 
     3- !SequenceStart 
    44- !Scalar { anchor: 'myanchor', tag: '!mytag', value: 'data' } 
    55- !Alias { anchor: 'myanchor' } 
    6 - !CollectionEnd 
     6- !SequenceEnd 
    77- !DocumentEnd 
    88- !StreamEnd 

  • pyyaml/trunk/tests/data/mappings.events

    r129 r130  
    22 
    33- !DocumentStart 
    4 - !Mapping 
     4- !MappingStart 
    55- !Scalar { implicit: true, value: 'key' } 
    66- !Scalar { implicit: true, value: 'value' } 
    77- !Scalar { implicit: true, value: 'empty mapping' } 
    8 - !Mapping 
    9 - !CollectionEnd 
     8- !MappingStart 
     9- !MappingEnd 
    1010- !Scalar { implicit: true, value: 'empty mapping with tag' } 
    11 - !Mapping { tag: '!mytag' } 
    12 - !CollectionEnd 
     11- !MappingStart { tag: '!mytag' } 
     12- !MappingEnd 
    1313- !Scalar { implicit: true, value: 'block mapping' } 
    14 - !Mapping 
    15 - !Mapping 
     14- !MappingStart 
     15- !MappingStart 
    1616- !Scalar { implicit: true, value: 'complex' } 
    1717- !Scalar { implicit: true, value: 'key' } 
    1818- !Scalar { implicit: true, value: 'complex' } 
    1919- !Scalar { implicit: true, value: 'key' } 
    20 - !CollectionEnd 
    21 - !Mapping 
     20- !MappingEnd 
     21- !MappingStart 
    2222- !Scalar { implicit: true, value: 'complex' } 
    2323- !Scalar { implicit: true, value: 'key' } 
    24 - !CollectionEnd 
    25 - !CollectionEnd 
     24- !MappingEnd 
     25- !MappingEnd 
    2626- !Scalar { implicit: true, value: 'flow mapping' } 
    27 - !Mapping { flow: true } 
     27- !MappingStart { flow: true } 
    2828- !Scalar { implicit: true, value: 'key' } 
    2929- !Scalar { implicit: true, value: 'value' } 
    30 - !Mapping 
     30- !MappingStart 
    3131- !Scalar { implicit: true, value: 'complex' } 
    3232- !Scalar { implicit: true, value: 'key' } 
    3333- !Scalar { implicit: true, value: 'complex' } 
    3434- !Scalar { implicit: true, value: 'key' } 
    35 - !CollectionEnd 
    36 - !Mapping 
     35- !MappingEnd 
     36- !MappingStart 
    3737- !Scalar { implicit: true, value: 'complex' } 
    3838- !Scalar { implicit: true, value: 'key' } 
    39 - !CollectionEnd 
    40 - !CollectionEnd 
    41 - !CollectionEnd 
     39- !MappingEnd 
     40- !MappingEnd 
     41- !MappingEnd 
    4242- !DocumentEnd 
    4343 

  • pyyaml/trunk/tests/data/scalars.events

    r129 r130  
    22 
    33- !DocumentStart 
    4 - !Mapping 
     4- !MappingStart 
    55- !Scalar { implicit: true, value: 'empty scalar' } 
    66- !Scalar { implicit: true, value: '' } 
    … …  
    1919- !Scalar { implicit: true, value: 'block scalar with tag' } 
    2020- !Scalar { value: 'data', style: '|', tag: '!mytag' } 
    21 - !CollectionEnd 
     21- !MappingEnd 
    2222- !DocumentEnd 
    2323 

  • pyyaml/trunk/tests/data/sequences.events

    r129 r130  
    22 
    33- !DocumentStart 
    4 - !Sequence 
    5 - !CollectionEnd 
     4- !SequenceStart 
     5- !SequenceEnd 
    66- !DocumentEnd 
    77 
    88- !DocumentStart 
    9 - !Sequence { tag: '!mytag' } 
    10 - !CollectionEnd 
     9- !SequenceStart { tag: '!mytag' } 
     10- !SequenceEnd 
    1111- !DocumentEnd 
    1212 
    1313- !DocumentStart 
    14 - !Sequence 
    15 - !Sequence 
    16 - !CollectionEnd 
    17 - !Sequence { tag: '!mytag' } 
    18 - !CollectionEnd 
    19 - !Sequence 
     14- !SequenceStart 
     15- !SequenceStart 
     16- !SequenceEnd 
     17- !SequenceStart { tag: '!mytag' } 
     18- !SequenceEnd 
     19- !SequenceStart 
    2020- !Scalar 
    2121- !Scalar { value: 'data' } 
    2222- !Scalar { tag: '!mytag', value: 'data' } 
    23 - !CollectionEnd 
    24 - !Sequence 
    25 - !Sequence 
    26 - !Sequence 
     23- !SequenceEnd 
     24- !SequenceStart 
     25- !SequenceStart 
     26- !SequenceStart 
    2727- !Scalar 
    28 - !CollectionEnd 
    29 - !CollectionEnd 
    30 - !CollectionEnd 
    31 - !Sequence 
    32 - !Sequence { tag: '!mytag' } 
    33 - !Sequence 
     28- !SequenceEnd 
     29- !SequenceEnd 
     30- !SequenceEnd 
     31- !SequenceStart 
     32- !SequenceStart { tag: '!mytag' } 
     33- !SequenceStart 
    3434- !Scalar { value: 'data' } 
    35 - !CollectionEnd 
    36 - !CollectionEnd 
    37 - !CollectionEnd 
    38 - !CollectionEnd 
     35- !SequenceEnd 
     36- !SequenceEnd 
     37- !SequenceEnd 
     38- !SequenceEnd 
    3939- !DocumentEnd 
    4040 
    4141- !DocumentStart 
    42 - !Sequence 
    43 - !Mapping 
     42- !SequenceStart 
     43- !MappingStart 
    4444- !Scalar { value: 'key1' } 
    45 - !Sequence 
     45- !SequenceStart 
    4646- !Scalar { value: 'data1' } 
    4747- !Scalar { value: 'data2' } 
    48 - !CollectionEnd 
     48- !SequenceEnd 
    4949- !Scalar { value: 'key2' } 
    50 - !Sequence { tag: '!mytag1' } 
     50- !SequenceStart { tag: '!mytag1' } 
    5151- !Scalar { value: 'data3' } 
    52 - !Sequence 
     52- !SequenceStart 
    5353- !Scalar { value: 'data4' } 
    5454- !Scalar { value: 'data5' } 
    55 - !CollectionEnd 
    56 - !Sequence { tag: '!mytag2' } 
     55- !SequenceEnd 
     56- !SequenceStart { tag: '!mytag2' } 
    5757- !Scalar { value: 'data6' } 
    5858- !Scalar { value: 'data7' } 
    59 - !CollectionEnd 
    60 - !CollectionEnd 
    61 - !CollectionEnd 
    62 - !CollectionEnd 
     59- !SequenceEnd 
     60- !SequenceEnd 
     61- !MappingEnd 
     62- !SequenceEnd 
    6363- !DocumentEnd 
    6464 
    6565- !DocumentStart 
    66 - !Sequence 
    67 - !Sequence { flow: true } 
    68 - !Sequence 
    69 - !CollectionEnd 
     66- !SequenceStart 
     67- !SequenceStart { flow: true } 
     68- !SequenceStart 
     69- !SequenceEnd 
    7070- !Scalar 
    7171- !Scalar { value: 'data' } 
    7272- !Scalar { tag: '!mytag', value: 'data' } 
    73 - !Sequence { tag: '!mytag' } 
     73- !SequenceStart { tag: '!mytag' } 
    7474- !Scalar { value: 'data' } 
    7575- !Scalar { value: 'data' } 
    76 - !CollectionEnd 
    77 - !CollectionEnd 
    78 - !CollectionEnd 
     76- !SequenceEnd 
     77- !SequenceEnd 
     78- !SequenceEnd 
    7979- !DocumentEnd 
    8080 

  • pyyaml/trunk/tests/data/spec-08-12.canonical

    r38 r130  
    77  *A, 
    88  !!str "", 
     9  !!str "", 
    910] 

  • pyyaml/trunk/tests/data/spec-08-12.data

    r44 r130  
    44  !!str 'Tagged', 
    55  *anchor, # Alias node 
    6 #  !!str,   # Empty plain scalar 
     6  !!str ,  # Empty plain scalar 
    77  '',   # Empty plain scalar 
    88] 

  • pyyaml/trunk/tests/test_appliance.py

    r118 r130  
    244244                self.events.append(ScalarEvent(anchor, tag, self.get_value(), None, None)) 
    245245            elif self.test_token(FlowSequenceStartToken): 
    246                 self.events.append(SequenceEvent(anchor, tag, None, None)) 
     246                self.events.append(SequenceStartEvent(anchor, tag, None, None)) 
    247247                self.parse_sequence() 
    248248            elif self.test_token(FlowMappingStartToken): 
    249                 self.events.append(MappingEvent(anchor, tag, None, None)) 
     249                self.events.append(MappingStartEvent(anchor, tag, None, None)) 
    250250                self.parse_mapping() 
    251251            else: 
    … …  
    262262                    self.parse_node() 
    263263        self.consume_token(FlowSequenceEndToken) 
    264         self.events.append(CollectionEndEvent(None, None)) 
     264        self.events.append(SequenceEndEvent(None, None)) 
    265265 
    266266    # mapping: MAPPING-START (map_entry (ENTRY map_entry)*)? ENTRY? MAPPING-END 
    … …  
    274274                    self.parse_map_entry() 
    275275        self.consume_token(FlowMappingEndToken) 
    276         self.events.append(CollectionEndEvent(None, None)) 
     276        self.events.append(MappingEndEvent(None, None)) 
    277277 
    278278    # map_entry: KEY node VALUE node 

  • pyyaml/trunk/tests/test_emitter.py

    r129 r130  
    3333            mapping = self.construct_mapping(node) 
    3434        class_name = str(node.tag[1:])+'Event' 
    35         if class_name in ['AliasEvent', 'ScalarEvent', 'SequenceEvent', 'MappingEvent']: 
     35        if class_name in ['AliasEvent', 'ScalarEvent', 'SequenceStartEvent', 'MappingStartEvent']: 
    3636            mapping.setdefault('anchor', None) 
    37         if class_name in ['ScalarEvent', 'SequenceEvent', 'MappingEvent']: 
     37        if class_name in ['ScalarEvent', 'SequenceStartEvent', 'MappingStartEvent']: 
    3838            mapping.setdefault('tag', None) 
    3939        if class_name == 'ScalarEvent': 

  • pyyaml/trunk/tests/test_structure.py

    r118 r130  
    3636            else: 
    3737                return None 
    38         elif parser.check(SequenceEvent): 
     38        elif parser.check(SequenceStartEvent): 
    3939            parser.get() 
    4040            sequence = [] 
    41             while not parser.check(CollectionEndEvent): 
     41            while not parser.check(SequenceEndEvent): 
    4242                sequence.append(self._convert(parser)) 
    4343            parser.get() 
    4444            return sequence 
    45         elif parser.check(MappingEvent): 
     45        elif parser.check(MappingStartEvent): 
    4646            parser.get() 
    4747            mapping = [] 
    48             while not parser.check(CollectionEndEvent): 
     48            while not parser.check(MappingEndEvent): 
    4949                key = self._convert(parser) 
    5050                value = self._convert(parser) 
    … …  
    9393                #self.failUnlessEqual(event1.tag, event2.tag) 
    9494                self.failUnlessEqual(event1.value, event2.value) 
    95             if isinstance(event1, CollectionEvent): 
     95            if isinstance(event1, CollectionStartEvent): 
    9696                #self.failUnlessEqual(event1.anchor, event2.anchor) 
    9797                #self.failUnlessEqual(event1.tag, event2.tag) 
    … …  
    214214                self.failUnlessEqual(event1.tag, event2.tag) 
    215215                self.failUnlessEqual(event1.value, event2.value) 
    216             if isinstance(event1, CollectionEvent): 
     216            if isinstance(event1, CollectionStartEvent): 
    217217                self.failUnlessEqual(event1.anchor, event2.anchor) 
    218218                self.failUnlessEqual(event1.tag, event2.tag) 

  • pyyaml/trunk/tests/test_yaml.py

    r116 r130  
    1010from test_detector import * 
    1111from test_constructor import * 
     12#from test_emitter import * 
    1213from test_syck import * 
    1314 
Note: See TracChangeset for help on using the changeset viewer.