|
1 | 1 | import codecs |
2 | 2 | import re |
3 | 3 | from typing import (IO, Iterator, Match, NamedTuple, Optional, Pattern, # noqa |
4 | | - Text, Tuple) |
| 4 | + Sequence, Text) |
5 | 5 |
|
6 | | -_binding = re.compile( |
7 | | - r""" |
8 | | - ( |
9 | | - \s* # leading whitespace |
10 | | - (?:export{0}+)? # export |
| 6 | +from .compat import to_text |
11 | 7 |
|
12 | | - ( '[^']+' # single-quoted key |
13 | | - | [^=\#\s]+ # or unquoted key |
14 | | - )? |
15 | 8 |
|
16 | | - (?: |
17 | | - (?:{0}*={0}*) # equal sign |
| 9 | +def make_regex(string, extra_flags=0): |
| 10 | + # type: (str, int) -> Pattern[Text] |
| 11 | + return re.compile(to_text(string), re.UNICODE | extra_flags) |
18 | 12 |
|
19 | | - ( '(?:\\'|[^'])*' # single-quoted value |
20 | | - | "(?:\\"|[^"])*" # or double-quoted value |
21 | | - | [^\#\r\n]* # or unquoted value |
22 | | - ) |
23 | | - )? |
24 | | -
|
25 | | - \s* # trailing whitespace |
26 | | - (?:\#[^\r\n]*)? # comment |
27 | | - (?:\r|\n|\r\n)? # newline |
28 | | - ) |
29 | | - """.format(r'[^\S\r\n]'), |
30 | | - re.MULTILINE | re.VERBOSE, |
31 | | -) # type: Pattern[Text] |
32 | | - |
33 | | -_escape_sequence = re.compile(r"\\[\\'\"abfnrtv]") # type: Pattern[Text] |
34 | 13 |
|
| 14 | +_whitespace = make_regex(r"\s*", extra_flags=re.MULTILINE) |
| 15 | +_export = make_regex(r"(?:export[^\S\r\n]+)?") |
| 16 | +_single_quoted_key = make_regex(r"'([^']+)'") |
| 17 | +_unquoted_key = make_regex(r"([^=\#\s]+)") |
| 18 | +_equal_sign = make_regex(r"[^\S\r\n]*=[^\S\r\n]*") |
| 19 | +_single_quoted_value = make_regex(r"'((?:\\'|[^'])*)'") |
| 20 | +_double_quoted_value = make_regex(r'"((?:\\"|[^"])*)"') |
| 21 | +_unquoted_value_part = make_regex(r"([^ \r\n]*)") |
| 22 | +_comment = make_regex(r"(?:\s*#[^\r\n]*)?") |
| 23 | +_end_of_line = make_regex(r"[^\S\r\n]*(?:\r\n|\n|\r)?") |
| 24 | +_rest_of_line = make_regex(r"[^\r\n]*(?:\r|\n|\r\n)?") |
| 25 | +_double_quote_escapes = make_regex(r"\\[\\'\"abfnrtv]") |
| 26 | +_single_quote_escapes = make_regex(r"\\[\\']") |
35 | 27 |
|
36 | 28 | Binding = NamedTuple("Binding", [("key", Optional[Text]), |
37 | 29 | ("value", Optional[Text]), |
38 | 30 | ("original", Text)]) |
39 | 31 |
|
40 | 32 |
|
41 | | -def decode_escapes(string): |
42 | | - # type: (Text) -> Text |
| 33 | +class Error(Exception): |
| 34 | + pass |
| 35 | + |
| 36 | + |
| 37 | +class Reader: |
| 38 | + def __init__(self, stream): |
| 39 | + # type: (IO[Text]) -> None |
| 40 | + self.string = stream.read() |
| 41 | + self.position = 0 |
| 42 | + self.mark = 0 |
| 43 | + |
| 44 | + def has_next(self): |
| 45 | + # type: () -> bool |
| 46 | + return self.position < len(self.string) |
| 47 | + |
| 48 | + def set_mark(self): |
| 49 | + # type: () -> None |
| 50 | + self.mark = self.position |
| 51 | + |
| 52 | + def get_marked(self): |
| 53 | + # type: () -> Text |
| 54 | + return self.string[self.mark:self.position] |
| 55 | + |
| 56 | + def peek(self, count): |
| 57 | + # type: (int) -> Text |
| 58 | + return self.string[self.position:self.position + count] |
| 59 | + |
| 60 | + def read(self, count): |
| 61 | + # type: (int) -> Text |
| 62 | + result = self.string[self.position:self.position + count] |
| 63 | + if len(result) < count: |
| 64 | + raise Error("read: End of string") |
| 65 | + self.position += count |
| 66 | + return result |
| 67 | + |
| 68 | + def read_regex(self, regex): |
| 69 | + # type: (Pattern[Text]) -> Sequence[Text] |
| 70 | + match = regex.match(self.string, self.position) |
| 71 | + if match is None: |
| 72 | + raise Error("read_regex: Pattern not found") |
| 73 | + self.position = match.end() |
| 74 | + return match.groups() |
| 75 | + |
| 76 | + |
| 77 | +def decode_escapes(regex, string): |
| 78 | + # type: (Pattern[Text], Text) -> Text |
43 | 79 | def decode_match(match): |
44 | 80 | # type: (Match[Text]) -> Text |
45 | 81 | return codecs.decode(match.group(0), 'unicode-escape') # type: ignore |
46 | 82 |
|
47 | | - return _escape_sequence.sub(decode_match, string) |
| 83 | + return regex.sub(decode_match, string) |
48 | 84 |
|
49 | 85 |
|
50 | | -def is_surrounded_by(string, char): |
51 | | - # type: (Text, Text) -> bool |
52 | | - return ( |
53 | | - len(string) > 1 |
54 | | - and string[0] == string[-1] == char |
55 | | - ) |
56 | | - |
57 | | - |
58 | | -def parse_binding(string, position): |
59 | | - # type: (Text, int) -> Tuple[Binding, int] |
60 | | - match = _binding.match(string, position) |
61 | | - assert match is not None |
62 | | - (matched, key, value) = match.groups() |
63 | | - if key is None or value is None: |
64 | | - key = None |
65 | | - value = None |
| 86 | +def parse_key(reader): |
| 87 | + # type: (Reader) -> Text |
| 88 | + char = reader.peek(1) |
| 89 | + if char == "'": |
| 90 | + (key,) = reader.read_regex(_single_quoted_key) |
| 91 | + else: |
| 92 | + (key,) = reader.read_regex(_unquoted_key) |
| 93 | + return key |
| 94 | + |
| 95 | + |
| 96 | +def parse_unquoted_value(reader): |
| 97 | + # type: (Reader) -> Text |
| 98 | + value = u"" |
| 99 | + while True: |
| 100 | + (part,) = reader.read_regex(_unquoted_value_part) |
| 101 | + value += part |
| 102 | + after = reader.peek(2) |
| 103 | + if len(after) < 2 or after[0] in u"\r\n" or after[1] in u" #\r\n": |
| 104 | + return value |
| 105 | + value += reader.read(2) |
| 106 | + |
| 107 | + |
| 108 | +def parse_value(reader): |
| 109 | + # type: (Reader) -> Text |
| 110 | + char = reader.peek(1) |
| 111 | + if char == u"'": |
| 112 | + (value,) = reader.read_regex(_single_quoted_value) |
| 113 | + return decode_escapes(_single_quote_escapes, value) |
| 114 | + elif char == u'"': |
| 115 | + (value,) = reader.read_regex(_double_quoted_value) |
| 116 | + return decode_escapes(_double_quote_escapes, value) |
| 117 | + elif char in (u"", u"\n", u"\r"): |
| 118 | + return u"" |
66 | 119 | else: |
67 | | - value_quoted = is_surrounded_by(value, "'") or is_surrounded_by(value, '"') |
68 | | - if value_quoted: |
69 | | - value = decode_escapes(value[1:-1]) |
70 | | - else: |
71 | | - value = value.strip() |
72 | | - return (Binding(key=key, value=value, original=matched), match.end()) |
| 120 | + return parse_unquoted_value(reader) |
| 121 | + |
| 122 | + |
| 123 | +def parse_binding(reader): |
| 124 | + # type: (Reader) -> Binding |
| 125 | + reader.set_mark() |
| 126 | + try: |
| 127 | + reader.read_regex(_whitespace) |
| 128 | + reader.read_regex(_export) |
| 129 | + key = parse_key(reader) |
| 130 | + reader.read_regex(_equal_sign) |
| 131 | + value = parse_value(reader) |
| 132 | + reader.read_regex(_comment) |
| 133 | + reader.read_regex(_end_of_line) |
| 134 | + return Binding(key=key, value=value, original=reader.get_marked()) |
| 135 | + except Error: |
| 136 | + reader.read_regex(_rest_of_line) |
| 137 | + return Binding(key=None, value=None, original=reader.get_marked()) |
73 | 138 |
|
74 | 139 |
|
75 | 140 | def parse_stream(stream): |
76 | 141 | # type:(IO[Text]) -> Iterator[Binding] |
77 | | - string = stream.read() |
78 | | - position = 0 |
79 | | - length = len(string) |
80 | | - while position < length: |
81 | | - (binding, position) = parse_binding(string, position) |
82 | | - yield binding |
| 142 | + reader = Reader(stream) |
| 143 | + while reader.has_next(): |
| 144 | + try: |
| 145 | + yield parse_binding(reader) |
| 146 | + except Error: |
| 147 | + return |
0 commit comments