Changeset 130 for pyyaml/trunk/lib/yaml

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

Add style information to events generated by Parser.

Location:
pyyaml/trunk/lib/yaml
Files:
6 modified

Legend:

Unmodified
Added
Removed

  • 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