Changeset 46


Ignore:
Timestamp:
02/16/06 17:22:59 (9 years ago)
Author:
xi
Message:

Some renaming.

Location:
branches/pyyaml3000
Files:
1 added
1 deleted
6 edited
2 moved

Legend:

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

    r44 r46  
    4040# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } 
    4141 
    42 from scanner import * 
    43  
    44 class Error(Exception): 
     42from error import YAMLError 
     43from tokens import * 
     44 
     45class ParserError(YAMLError): 
    4546    pass 
    4647 
     
    7778class Parser: 
    7879 
    79     def __init__(self, source, data): 
    80         self.scanner = Scanner(source, data) 
     80    def __init__(self, scanner): 
     81        self.scanner = scanner 
    8182 
    8283    def is_token(self, *choices): 
  • branches/pyyaml3000/lib/yaml/reader.py

    r45 r46  
    88# Parser does not use it for any other purposes. 
    99# 
    10 #   Stream(source, data) 
    11 # Stream determines the encoding of `data` and converts it to unicode. 
    12 # Stream provides the following methods and attributes: 
    13 #   stream.peek(length=1) - return the next `length` characters 
    14 #   stream.forward(length=1) - move the current position to `length` characters. 
    15 #   stream.index - the number of the current character. 
    16 #   stream.line, stream.column - the line and the column of the current character. 
    17  
     10#   Reader(source, data) 
     11# Reader determines the encoding of `data` and converts it to unicode. 
     12# Reader provides the following methods and attributes: 
     13#   reader.peek(length=1) - return the next `length` characters 
     14#   reader.forward(length=1) - move the current position to `length` characters. 
     15#   reader.index - the number of the current character. 
     16#   reader.line, stream.column - the line and the column of the current character. 
     17 
     18__all__ = ['Marker', 'Reader', 'ReaderError'] 
    1819 
    1920from error import YAMLError 
     
    5859class Marker: 
    5960 
    60     def __init__(self, source, line, column, buffer, pointer): 
    61         self.source = source 
     61    def __init__(self, name, line, column, buffer, pointer): 
     62        self.name = name 
    6263        self.line = line 
    6364        self.column = column 
     
    8889                + ' '*(self.pointer-start+len(head)) + '^' + '\n' 
    8990 
    90 class StreamError(YAMLError): 
    91  
    92     def __init__(self, source, encoding, character, position, reason): 
    93         self.source = source 
    94         self.encoding = encoding 
     91class ReaderError(YAMLError): 
     92 
     93    def __init__(self, name, position, character, encoding, reason): 
     94        self.name = name 
    9595        self.character = character 
    9696        self.position = position 
     97        self.encoding = encoding 
    9798        self.reason = reason 
    9899 
     
    100101        if isinstance(self.character, str): 
    101102            return "'%s' codec can't decode byte #x%02x: %s\n"  \ 
    102                     "\tin file '%s', position %d."   \ 
     103                    "\tin '%s', position %d."   \ 
    103104                    % (self.encoding, ord(self.character), self.reason, 
    104                             self.source, self.position) 
     105                            self.name, self.position) 
    105106        else: 
    106107            return "unacceptable character #x%04x: %s\n"    \ 
    107                     "\tin file '%s', position %d."   \ 
     108                    "\tin '%s', position %d."   \ 
    108109                    % (ord(self.character), self.reason, 
    109                             self.source, self.position) 
    110  
    111 class Stream: 
    112     # Stream: 
     110                            self.name, self.position) 
     111 
     112class Reader: 
     113    # Reader: 
    113114    # - determines the data encoding and converts it to unicode, 
    114115    # - checks if characters are in allowed range, 
    115116    # - adds '\0' to the end. 
    116117 
     118    # Reader accepts 
     119    #  - a `str` object, 
     120    #  - a `unicode` object, 
     121    #  - a file-like object with its `read` method returning `str`, 
     122    #  - a file-like object with its `read` method returning `unicode`. 
     123 
    117124    # Yeah, it's ugly and slow. 
    118125 
    119     def __init__(self, source, data): 
    120         self.source = source 
     126    def __init__(self, data): 
     127        self.name = None 
    121128        self.stream = None 
    122129        self.stream_pointer = 0 
     
    125132        self.pointer = 0 
    126133        self.raw_buffer = None 
    127         self.raw_decoder = None 
     134        self.raw_decode = None 
    128135        self.index = 0 
    129136        self.line = 0 
    130137        self.column = 0 
    131138        if isinstance(data, unicode): 
     139            self.name = "<unicode string>" 
    132140            self.check_printable(data) 
    133141            self.buffer = data+u'\0' 
    134142        elif isinstance(data, str): 
     143            self.name = "<string>" 
    135144            self.raw_buffer = data 
    136145            self.determine_encoding() 
    137146        else: 
    138147            self.stream = data 
     148            self.name = getattr(data, 'name', "<file>") 
    139149            self.eof = False 
    140150            self.raw_buffer = '' 
     
    162172    def get_marker(self): 
    163173        if self.stream is None: 
    164             return Marker(self.source, self.line, self.column, 
     174            return Marker(self.name, self.line, self.column, 
    165175                    self.buffer, self.pointer) 
    166176        else: 
    167             return Marker(self.source, self.line, self.column, None, None) 
     177            return Marker(self.name, self.line, self.column, None, None) 
    168178 
    169179    def determine_encoding(self): 
    170180        while not self.eof and len(self.raw_buffer) < 2: 
    171181            self.update_raw() 
    172         if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): 
    173             self.raw_decode = utf_16_le_decode 
    174         elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): 
    175             self.raw_decode = utf_16_be_decode 
    176         else: 
    177             self.raw_decode = utf_8_decode 
     182        if not isinstance(self.raw_buffer, unicode): 
     183            if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): 
     184                self.raw_decode = utf_16_le_decode 
     185            elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): 
     186                self.raw_decode = utf_16_be_decode 
     187            else: 
     188                self.raw_decode = utf_8_decode 
    178189        self.update(1) 
    179190 
     
    184195            character = match.group() 
    185196            position = self.index+(len(self.buffer)-self.pointer)+match.start() 
    186             raise StreamError(self.source, 'unicode', character, position, 
    187                     "control characters are not allowed") 
     197            raise ReaderError(self.name, position, character, 
     198                    'unicode', "special characters are not allowed") 
    188199 
    189200    def update(self, length): 
     
    195206            if not self.eof: 
    196207                self.update_raw() 
    197             try: 
    198                 data, converted = self.raw_decode(self.raw_buffer, 
    199                         'strict', self.eof) 
    200             except UnicodeDecodeError, exc: 
    201                 character = exc.object[exc.start] 
    202                 if self.stream is not None: 
    203                     position = self.stream_pointer-len(self.raw_buffer)+exc.start 
    204                 else: 
    205                     position = exc.start 
    206                 raise StreamError(self.source, exc.encoding, 
    207                         character, position, exc.reason) 
     208            if self.raw_decode is not None: 
     209                try: 
     210                    data, converted = self.raw_decode(self.raw_buffer, 
     211                            'strict', self.eof) 
     212                except UnicodeDecodeError, exc: 
     213                    character = exc.object[exc.start] 
     214                    if self.stream is not None: 
     215                        position = self.stream_pointer-len(self.raw_buffer)+exc.start 
     216                    else: 
     217                        position = exc.start 
     218                    raise ReaderError(self.name, position, character, 
     219                            exc.encoding, exc.reason) 
     220            else: 
     221                data = self.raw_buffer 
     222                converted = len(data) 
    208223            self.check_printable(data) 
    209224            self.buffer += data 
     
    224239#try: 
    225240#    import psyco 
    226 #    psyco.bind(Stream) 
     241#    psyco.bind(Reader) 
    227242#except ImportError: 
    228243#    pass 
  • branches/pyyaml3000/lib/yaml/scanner.py

    r45 r46  
    99# ALIAS(name), ANCHOR(name), TAG(value), SCALAR(value, plain) 
    1010 
    11  
    12 from marker import Marker 
    13 #from error import YAMLError 
    14 from stream import Stream 
    15  
    16 #class ScannerError(YAMLError): 
    17 class ScannerError(Exception): 
     11__all__ = ['Scanner', 'ScannerError'] 
     12 
     13from error import YAMLError 
     14from tokens import * 
     15 
     16class ScannerError(YAMLError): 
     17    # TODO: 
     18    # ScannerError: while reading a quoted string 
     19    #         in '...', line 5, column 10: 
     20    # key: "valu\?e" 
     21    #      ^ 
     22    # got unknown quote character '?' 
     23    #         in '...', line 5, column 15: 
     24    # key: "valu\?e" 
     25    #            ^ 
    1826    pass 
    19  
    20 class Token: 
    21     def __init__(self, start_marker, end_marker): 
    22         self.start_marker = start_marker 
    23         self.end_marker = end_marker 
    24  
    25 class DirectiveToken(Token): 
    26     pass 
    27  
    28 class YAMLDirectiveToken(DirectiveToken): 
    29     def __init__(self, major_version, minor_version, start_marker, end_marker): 
    30         self.major_version = major_version 
    31         self.minor_version = minor_version 
    32         self.start_marker = start_marker 
    33         self.end_marker = end_marker 
    34  
    35 class TagDirectiveToken(DirectiveToken): 
    36     pass 
    37  
    38 class ReservedDirectiveToken(DirectiveToken): 
    39     def __init__(self, name, start_marker, end_marker): 
    40         self.name = name 
    41         self.start_marker = start_marker 
    42         self.end_marker = end_marker 
    43  
    44 class DocumentStartToken(Token): 
    45     pass 
    46  
    47 class DocumentEndToken(Token): 
    48     pass 
    49  
    50 class EndToken(Token): 
    51     pass 
    52  
    53 class BlockSequenceStartToken(Token): 
    54     pass 
    55  
    56 class BlockMappingStartToken(Token): 
    57     pass 
    58  
    59 class BlockEndToken(Token): 
    60     pass 
    61  
    62 class FlowSequenceStartToken(Token): 
    63     pass 
    64  
    65 class FlowMappingStartToken(Token): 
    66     pass 
    67  
    68 class FlowSequenceEndToken(Token): 
    69     pass 
    70  
    71 class FlowMappingEndToken(Token): 
    72     pass 
    73  
    74 class KeyToken(Token): 
    75     pass 
    76  
    77 class ValueToken(Token): 
    78     pass 
    79  
    80 class EntryToken(Token): 
    81     pass 
    82  
    83 class AliasToken(Token): 
    84     def __init__(self, value, start_marker, end_marker): 
    85         self.value = value 
    86         self.start_marker = start_marker 
    87         self.end_marker = end_marker 
    88  
    89 class AnchorToken(Token): 
    90     def __init__(self, value, start_marker, end_marker): 
    91         self.value = value 
    92         self.start_marker = start_marker 
    93         self.end_marker = end_marker 
    94  
    95 class TagToken(Token): 
    96     def __init__(self, value, start_marker, end_marker): 
    97         self.value = value 
    98         self.start_marker = start_marker 
    99         self.end_marker = end_marker 
    100  
    101 class ScalarToken(Token): 
    102     def __init__(self, value, plain, start_marker, end_marker): 
    103         self.value = value 
    104         self.plain = plain 
    105         self.start_marker = start_marker 
    106         self.end_marker = end_marker 
    10727 
    10828class SimpleKey: 
     
    11737class Scanner: 
    11838 
    119     def __init__(self, source, data): 
     39 
     40    def __init__(self, reader): 
    12041        """Initialize the scanner.""" 
    121         # The input stream. The Stream class do the dirty work of checking for 
     42        # The input stream. The Reader class do the dirty work of checking for 
    12243        # BOM and converting the input data to Unicode. It also adds NUL to 
    12344        # the end. 
    12445        # 
    125         # Stream supports the following methods 
    126         #   self.stream.peek(k=1)   # peek the next k characters 
    127         #   self.stream.forward(k=1)   # read the next k characters and move the 
     46        # Reader supports the following methods 
     47        #   self.reader.peek(k=1)   # peek the next k characters 
     48        #   self.reader.forward(k=1)   # read the next k characters and move the 
    12849        #                           # pointer 
    129         self.stream = Stream(source, data) 
     50        self.reader = reader 
    13051 
    13152        # Had we reached the end of the stream? 
     
    218139        # Compare the current indentation and column. It may add some tokens 
    219140        # and decrease the current indentation level. 
    220         self.unwind_indent(self.stream.column) 
     141        self.unwind_indent(self.reader.column) 
    221142 
    222143        #print 
    223         #print self.stream.get_marker().get_snippet() 
     144        #print self.reader.get_marker().get_snippet() 
    224145 
    225146        # Peek the next character. 
    226         ch = self.stream.peek() 
    227  
    228         # Is it the end of stream? 
     147        ch = self.reader.peek() 
     148 
     149        # Is it the end of reader? 
    229150        if ch == u'\0': 
    230151            return self.fetch_end() 
     
    333254        for level in self.possible_simple_keys.keys(): 
    334255            key = self.possible_simple_keys[level] 
    335             if key.line != self.stream.line  \ 
    336                     or self.stream.index-key.index > 1024: 
     256            if key.line != self.reader.line  \ 
     257                    or self.reader.index-key.index > 1024: 
    337258                if key.required: 
    338259                    self.fail("simple key is required") 
     
    345266 
    346267        # Check if a simple key is required at the current position. 
    347         required = not self.flow_level and self.indent == self.stream.column 
     268        required = not self.flow_level and self.indent == self.reader.column 
    348269 
    349270        # The next token might be a simple key. Let's save it's number and 
     
    352273            self.remove_possible_simple_key() 
    353274            token_number = self.tokens_taken+len(self.tokens) 
    354             index = self.stream.index 
    355             line = self.stream.line 
    356             column = self.stream.column 
    357             marker = self.stream.get_marker() 
     275            index = self.reader.index 
     276            line = self.reader.line 
     277            column = self.reader.column 
     278            marker = self.reader.get_marker() 
    358279            key = SimpleKey(token_number, required, 
    359280                    index, line, column, marker) 
     
    381302        # In block context, we may need to issue the BLOCK-END tokens. 
    382303        while self.indent > column: 
    383             marker = self.stream.get_marker() 
     304            marker = self.reader.get_marker() 
    384305            self.indent = self.indents.pop() 
    385306            self.tokens.append(BlockEndToken(marker, marker)) 
     
    405326 
    406327        # Read the token. 
    407         marker = self.stream.get_marker() 
     328        marker = self.reader.get_marker() 
    408329         
    409330        # Add END. 
    410331        self.tokens.append(EndToken(marker, marker)) 
    411332 
    412         # The stream is ended. 
     333        # The reader is ended. 
    413334        self.done = True 
    414335 
     
    442363 
    443364        # Add DOCUMENT-START or DOCUMENT-END. 
    444         start_marker = self.stream.get_marker() 
    445         self.stream.forward(3) 
    446         end_marker = self.stream.get_marker() 
     365        start_marker = self.reader.get_marker() 
     366        self.reader.forward(3) 
     367        end_marker = self.reader.get_marker() 
    447368        self.tokens.append(TokenClass(start_marker, end_marker)) 
    448369 
     
    465386 
    466387        # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. 
    467         start_marker = self.stream.get_marker() 
    468         self.stream.forward() 
    469         end_marker = self.stream.get_marker() 
     388        start_marker = self.reader.get_marker() 
     389        self.reader.forward() 
     390        end_marker = self.reader.get_marker() 
    470391        self.tokens.append(TokenClass(start_marker, end_marker)) 
    471392 
     
    488409 
    489410        # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. 
    490         start_marker = self.stream.get_marker() 
    491         self.stream.forward() 
    492         end_marker = self.stream.get_marker() 
     411        start_marker = self.reader.get_marker() 
     412        self.reader.forward() 
     413        end_marker = self.reader.get_marker() 
    493414        self.tokens.append(TokenClass(start_marker, end_marker)) 
    494415 
     
    503424 
    504425            # We may need to add BLOCK-SEQUENCE-START. 
    505             if self.add_indent(self.stream.column): 
    506                 marker = self.stream.get_marker() 
     426            if self.add_indent(self.reader.column): 
     427                marker = self.reader.get_marker() 
    507428                self.tokens.append(BlockSequenceStartToken(marker, marker)) 
    508429 
     
    514435 
    515436        # Add ENTRY. 
    516         start_marker = self.stream.get_marker() 
    517         self.stream.forward() 
    518         end_marker = self.stream.get_marker() 
     437        start_marker = self.reader.get_marker() 
     438        self.reader.forward() 
     439        end_marker = self.reader.get_marker() 
    519440        self.tokens.append(EntryToken(start_marker, end_marker)) 
    520441 
     
    529450 
    530451            # We may need to add BLOCK-MAPPING-START. 
    531             if self.add_indent(self.stream.column): 
    532                 marker = self.stream.get_marker() 
     452            if self.add_indent(self.reader.column): 
     453                marker = self.reader.get_marker() 
    533454                self.tokens.append(BlockMappingStartToken(marker, marker)) 
    534455 
     
    540461 
    541462        # Add KEY. 
    542         start_marker = self.stream.get_marker() 
    543         self.stream.forward() 
    544         end_marker = self.stream.get_marker() 
     463        start_marker = self.reader.get_marker() 
     464        self.reader.forward() 
     465        end_marker = self.reader.get_marker() 
    545466        self.tokens.append(KeyToken(start_marker, end_marker)) 
    546467 
     
    576497 
    577498        # Add VALUE. 
    578         start_marker = self.stream.get_marker() 
    579         self.stream.forward() 
    580         end_marker = self.stream.get_marker() 
     499        start_marker = self.reader.get_marker() 
     500        self.reader.forward() 
     501        end_marker = self.reader.get_marker() 
    581502        self.tokens.append(ValueToken(start_marker, end_marker)) 
    582503 
     
    667588        # DIRECTIVE:        ^ '%' ... 
    668589        # The '%' indicator is already checked. 
    669         if self.stream.column == 0: 
     590        if self.reader.column == 0: 
    670591            return True 
    671592 
     
    673594 
    674595        # DOCUMENT-START:   ^ '---' (' '|'\n') 
    675         if self.stream.column == 0: 
    676             prefix = self.stream.peek(4) 
     596        if self.reader.column == 0: 
     597            prefix = self.reader.peek(4) 
    677598            if prefix[:3] == u'---' and prefix[3] in u'\0 \t\r\n\x85\u2028\u2029': 
    678599                return True 
     
    681602 
    682603        # DOCUMENT-END:     ^ '...' (' '|'\n') 
    683         if self.stream.column == 0: 
    684             prefix = self.stream.peek(4) 
     604        if self.reader.column == 0: 
     605            prefix = self.reader.peek(4) 
    685606            if prefix[:3] == u'...' and prefix[3] in u'\0 \t\r\n\x85\u2028\u2029': 
    686607                return True 
     
    690611        # ENTRY(flow context):      ',' 
    691612        if self.flow_level: 
    692             return self.stream.peek() == u',' 
     613            return self.reader.peek() == u',' 
    693614 
    694615        # ENTRY(block context):     '-' (' '|'\n') 
    695616        else: 
    696             prefix = self.stream.peek(2) 
     617            prefix = self.reader.peek(2) 
    697618            return prefix[0] == u'-' and prefix[1] in u'\0 \t\r\n\x85\u2028\u2029' 
    698619 
     
    705626        # KEY(block context):   '?' (' '|'\n') 
    706627        else: 
    707             prefix = self.stream.peek(2) 
     628            prefix = self.reader.peek(2) 
    708629            return prefix[1] in u'\0 \t\r\n\x85\u2028\u2029' 
    709630 
     
    716637        # VALUE(block context): ':' (' '|'\n') 
    717638        else: 
    718             prefix = self.stream.peek(2) 
     639            prefix = self.reader.peek(2) 
    719640            return prefix[1] in u'\0 \t\r\n\x85\u2028\u2029' 
    720641 
     
    727648        found = False 
    728649        while not found: 
    729             while self.stream.peek() == u' ': 
    730                 self.stream.forward() 
    731             if self.stream.peek() == u'#': 
    732                 while self.stream.peek() not in u'\r\n': 
    733                     self.stream.forward() 
    734             if self.stream.peek() in u'\r\n': 
    735                 self.stream.forward() 
     650            while self.reader.peek() == u' ': 
     651                self.reader.forward() 
     652            if self.reader.peek() == u'#': 
     653                while self.reader.peek() not in u'\r\n': 
     654                    self.reader.forward() 
     655            if self.reader.peek() in u'\r\n': 
     656                self.reader.forward() 
    736657                if not self.flow_level: 
    737658                    self.allow_simple_key = True 
     
    740661 
    741662    def scan_directive(self): 
    742         marker = self.stream.get_marker() 
    743         if self.stream.peek(5) == u'%YAML ': 
     663        marker = self.reader.get_marker() 
     664        if self.reader.peek(5) == u'%YAML ': 
    744665            self.tokens.append(YAMLDirectiveToken(1, 1, marker, marker)) 
    745         elif self.stream.peek(4) == u'%TAG ': 
     666        elif self.reader.peek(4) == u'%TAG ': 
    746667            self.tokens.append(TagDirectiveToken(marker, marker)) 
    747668        else: 
    748669            self.tokens.append(ReservedDirectiveToken('', marker, marker)) 
    749         while self.stream.peek() not in u'\0\r\n': 
    750             self.stream.forward() 
    751         self.stream.forward() 
     670        while self.reader.peek() not in u'\0\r\n': 
     671            self.reader.forward() 
     672        self.reader.forward() 
    752673 
    753674    def scan_anchor(self, TokenClass): 
    754         start_marker = self.stream.get_marker() 
    755         while self.stream.peek() not in u'\0 \t\r\n,:': 
    756             self.stream.forward() 
    757         end_marker = self.stream.get_marker() 
     675        start_marker = self.reader.get_marker() 
     676        while self.reader.peek() not in u'\0 \t\r\n,:': 
     677            self.reader.forward() 
     678        end_marker = self.reader.get_marker() 
    758679        self.tokens.append(TokenClass('', start_marker, end_marker)) 
    759680 
    760681    def scan_tag(self): 
    761         start_marker = self.stream.get_marker() 
    762         while self.stream.peek() not in u'\0 \t\r\n': 
    763             self.stream.forward() 
    764         end_marker = self.stream.get_marker() 
     682        start_marker = self.reader.get_marker() 
     683        while self.reader.peek() not in u'\0 \t\r\n': 
     684            self.reader.forward() 
     685        end_marker = self.reader.get_marker() 
    765686        self.tokens.append(TagToken('', start_marker, end_marker)) 
    766687 
    767688    def scan_block_scalar(self, folded): 
    768         start_marker = self.stream.get_marker() 
     689        start_marker = self.reader.get_marker() 
    769690        indent = self.indent+1 
    770691        if indent < 1: 
    771692            indent = 1 
    772693        while True: 
    773             while self.stream.peek() and self.stream.peek() and self.stream.peek() not in u'\0\r\n\x85\u2028\u2029': 
    774                 self.stream.forward() 
    775             if self.stream.peek() != u'\0': 
    776                 self.stream.forward() 
     694            while self.reader.peek() and self.reader.peek() and self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
     695                self.reader.forward() 
     696            if self.reader.peek() != u'\0': 
     697                self.reader.forward() 
    777698            count = 0 
    778             while count < indent and self.stream.peek() == u' ': 
    779                 self.stream.forward() 
     699            while count < indent and self.reader.peek() == u' ': 
     700                self.reader.forward() 
    780701                count += 1 
    781             if count < indent and self.stream.peek() not in u'#\r\n\x85\u2028\u2029': 
     702            if count < indent and self.reader.peek() not in u'#\r\n\x85\u2028\u2029': 
    782703                break 
    783704        self.tokens.append(ScalarToken('', False, start_marker, start_marker)) 
    784705 
    785706    def scan_flow_scalar(self, double): 
    786         marker = self.stream.get_marker() 
    787         quote = self.stream.peek() 
    788         self.stream.forward() 
    789         while self.stream.peek() != quote: 
    790             if double and self.stream.peek() == u'\\': 
    791                 self.stream.forward(2) 
    792             elif not double and self.stream.peek(3)[1:] == u'\'\'': 
    793                 self.stream.forward(3) 
     707        marker = self.reader.get_marker() 
     708        quote = self.reader.peek() 
     709        self.reader.forward() 
     710        while self.reader.peek() != quote: 
     711            if double and self.reader.peek() == u'\\': 
     712                self.reader.forward(2) 
     713            elif not double and self.reader.peek(3)[1:] == u'\'\'': 
     714                self.reader.forward(3) 
    794715            else: 
    795                 self.stream.forward(1) 
    796         self.stream.forward(1) 
     716                self.reader.forward(1) 
     717        self.reader.forward(1) 
    797718        self.tokens.append(ScalarToken('', False, marker, marker)) 
    798719 
     
    802723            indent = 1 
    803724        space = False 
    804         marker = self.stream.get_marker() 
     725        marker = self.reader.get_marker() 
    805726        while True: 
    806             while self.stream.peek() == u' ': 
    807                 self.stream.forward() 
     727            while self.reader.peek() == u' ': 
     728                self.reader.forward() 
    808729                space = True 
    809             while self.stream.peek() not in u'\0\r\n?:,[]{}#'   \ 
    810                     or (not space and self.stream.peek() == '#')    \ 
    811                     or (not self.flow_level and self.stream.peek() in '?,[]{}') \ 
    812                     or (not self.flow_level and self.stream.peek() == ':' and self.stream.peek(2)[1] not in u' \0\r\n'): 
    813                 space = self.stream.peek() not in u' \t' 
    814                 self.stream.forward() 
     730            while self.reader.peek() not in u'\0\r\n?:,[]{}#'   \ 
     731                    or (not space and self.reader.peek() == '#')    \ 
     732                    or (not self.flow_level and self.reader.peek() in '?,[]{}') \ 
     733                    or (not self.flow_level and self.reader.peek() == ':' and self.reader.peek(2)[1] not in u' \0\r\n'): 
     734                space = self.reader.peek() not in u' \t' 
     735                self.reader.forward() 
    815736                self.allow_simple_key = False 
    816             if self.stream.peek() not in u'\r\n': 
     737            if self.reader.peek() not in u'\r\n': 
    817738                break 
    818             while self.stream.peek() in u'\r\n': 
    819                 self.stream.forward() 
     739            while self.reader.peek() in u'\r\n': 
     740                self.reader.forward() 
    820741                if not self.flow_level: 
    821742                    self.allow_simple_key = True 
    822743            count = 0 
    823             while self.stream.peek() == u' ' and count < indent: 
    824                 self.stream.forward() 
     744            while self.reader.peek() == u' ' and count < indent: 
     745                self.reader.forward() 
    825746                count += 1 
    826747            if count < indent: 
  • branches/pyyaml3000/tests/test_marker.py

    r45 r46  
    22import test_appliance 
    33 
    4 from yaml.stream import Marker 
     4from yaml.reader import Marker 
    55 
    66class TestMarker(test_appliance.TestAppliance): 
  • branches/pyyaml3000/tests/test_reader.py

    r45 r46  
    11 
    22import test_appliance 
    3 from yaml.stream import Stream, StreamError 
     3from yaml.reader import Reader, ReaderError 
    44 
    5 class TestStreamErrors(test_appliance.TestAppliance): 
     5import codecs 
    66 
    7     def _testStreamUnicodeErrors(self, test_name, stream_filename): 
    8         try: 
    9             data = unicode(file(stream_filename, 'rb').read(), 'utf-8') 
    10         except: 
     7class TestReaderErrors(test_appliance.TestAppliance): 
     8 
     9    def _testReaderUnicodeErrors(self, test_name, stream_filename): 
     10        for encoding in ['utf-8', 'utf-16-le', 'utf-16-be']: 
     11            try: 
     12                data = unicode(file(stream_filename, 'rb').read(), encoding) 
     13                break 
     14            except: 
     15                pass 
     16        else: 
    1117            return 
    12         self.failUnlessRaises(StreamError, lambda: self._load(stream_filename, data)) 
     18        #self._load(data) 
     19        self.failUnlessRaises(ReaderError, 
     20                lambda: self._load(data)) 
     21        #self._load(codecs.open(stream_filename, encoding=encoding)) 
     22        self.failUnlessRaises(ReaderError, 
     23                lambda: self._load(codecs.open(stream_filename, encoding=encoding))) 
    1324 
    14     def _testStreamStringErrors(self, test_name, stream_filename): 
     25    def _testReaderStringErrors(self, test_name, stream_filename): 
    1526        data = file(stream_filename, 'rb').read() 
    16         self.failUnlessRaises(StreamError, lambda: self._load(stream_filename, data)) 
     27        #self._load(data) 
     28        self.failUnlessRaises(ReaderError, lambda: self._load(data)) 
    1729 
    18     def _testStreamFileErrors(self, test_name, stream_filename): 
     30    def _testReaderFileErrors(self, test_name, stream_filename): 
    1931        data = file(stream_filename, 'rb') 
    20         self.failUnlessRaises(StreamError, lambda: self._load(stream_filename, data)) 
     32        #self._load(data) 
     33        self.failUnlessRaises(ReaderError, lambda: self._load(data)) 
    2134 
    22     def _load(self, stream_filename, data): 
    23         stream = Stream(stream_filename, data) 
     35    def _load(self, data): 
     36        stream = Reader(data) 
    2437        while stream.peek() != u'\0': 
    2538            stream.forward() 
    2639 
    27 TestStreamErrors.add_tests('testStreamUnicodeErrors', '.stream-error') 
    28 TestStreamErrors.add_tests('testStreamStringErrors', '.stream-error') 
    29 TestStreamErrors.add_tests('testStreamFileErrors', '.stream-error') 
     40TestReaderErrors.add_tests('testReaderUnicodeErrors', '.stream-error') 
     41TestReaderErrors.add_tests('testReaderStringErrors', '.stream-error') 
     42TestReaderErrors.add_tests('testReaderFileErrors', '.stream-error') 
    3043 
    3144 
  • branches/pyyaml3000/tests/test_structure.py

    r44 r46  
    22import test_appliance 
    33 
     4from yaml.reader import Reader 
     5from yaml.scanner import Scanner 
    46from yaml.parser import * 
    57 
     
    1012        node2 = eval(file(structure_filename, 'rb').read()) 
    1113        try: 
    12             parser = Parser(data_filename, file(data_filename, 'rb').read()) 
     14            parser = Parser(Scanner(Reader(file(data_filename, 'rb')))) 
    1315            node1 = parser.parse() 
    1416            node1 = [self._convert(n) for n in node1] 
     
    5052        documents2 = None 
    5153        try: 
    52             parser = Parser(data_filename, file(data_filename, 'rb').read()) 
     54            parser = Parser(Scanner(Reader(file(data_filename, 'rb')))) 
    5355            documents1 = parser.parse() 
    5456            canonical = test_appliance.CanonicalParser(canonical_filename, file(canonical_filename, 'rb').read()) 
  • branches/pyyaml3000/tests/test_tokens.py

    r44 r46  
    22import test_appliance 
    33 
     4from yaml.reader import * 
     5from yaml.tokens import * 
    46from yaml.scanner import * 
    57 
     
    5153        tokens2 = file(tokens_filename, 'rb').read().split() 
    5254        try: 
    53             scanner = Scanner(data_filename, file(data_filename, 'rb').read()) 
     55            scanner = Scanner(Reader(file(data_filename, 'rb'))) 
    5456            tokens1 = [] 
    5557            while not isinstance(scanner.peek_token(), EndToken): 
     
    7375            tokens = None 
    7476            try: 
    75                 scanner = Scanner(filename, file(filename, 'rb').read()) 
     77                scanner = Scanner(Reader(file(filename, 'rb'))) 
    7678                tokens = [] 
    7779                while not isinstance(scanner.peek_token(), EndToken): 
  • branches/pyyaml3000/tests/test_yaml.py

    r45 r46  
    33 
    44from test_marker import * 
    5 from test_stream import * 
     5from test_reader import * 
    66from test_canonical import * 
    77from test_tokens import * 
Note: See TracChangeset for help on using the changeset viewer.