| | from __future__ import annotations |
| |
|
| | import re |
| | from pathlib import PurePath |
| | from typing import NamedTuple |
| |
|
| | from rich.console import Group, RenderableType |
| | from rich.highlighter import ReprHighlighter |
| | from rich.padding import Padding |
| | from rich.panel import Panel |
| | import rich.repr |
| | from rich.syntax import Syntax |
| | from rich.text import Text |
| |
|
| | from ._error_tools import friendly_list |
| | from .._loop import loop_last |
| |
|
| |
|
| | class TokenError(Exception): |
| | """Error raised when the CSS cannot be tokenized (syntax error).""" |
| |
|
| | def __init__( |
| | self, |
| | path: str, |
| | code: str, |
| | start: tuple[int, int], |
| | message: str, |
| | end: tuple[int, int] | None = None, |
| | ) -> None: |
| | """ |
| | Args: |
| | path (str): Path to source or "<object>" if source is parsed from a literal. |
| | code (str): The code being parsed. |
| | start (tuple[int, int]): Line number of the error. |
| | message (str): A message associated with the error. |
| | end (tuple[int, int] | None): End location of token, or None if not known. Defaults to None. |
| | """ |
| |
|
| | self.path = path |
| | self.code = code |
| | self.start = start |
| | self.end = end or start |
| | super().__init__(message) |
| |
|
| | def _get_snippet(self) -> Panel: |
| | """Get a short snippet of code around a given line number. |
| | |
| | Returns: |
| | Panel: A renderable. |
| | """ |
| | line_no = self.start[0] |
| | |
| | syntax = Syntax( |
| | self.code, |
| | lexer="scss", |
| | theme="ansi_light", |
| | line_numbers=True, |
| | indent_guides=True, |
| | line_range=(max(0, line_no - 2), line_no + 2), |
| | highlight_lines={line_no}, |
| | ) |
| | syntax.stylize_range("reverse bold", self.start, self.end) |
| | return Panel(syntax, border_style="red") |
| |
|
| | def __rich__(self) -> RenderableType: |
| | highlighter = ReprHighlighter() |
| | errors: list[RenderableType] = [] |
| |
|
| | message = str(self) |
| | errors.append(Text(" Error in stylesheet:", style="bold red")) |
| |
|
| | line_no, col_no = self.start |
| |
|
| | errors.append(highlighter(f" {self.path or '<unknown>'}:{line_no}:{col_no}")) |
| | errors.append(self._get_snippet()) |
| |
|
| | final_message = "\n".join( |
| | f"• {message_part.strip()}" for message_part in message.split(";") |
| | ) |
| | errors.append( |
| | Padding( |
| | highlighter( |
| | Text(final_message, "red"), |
| | ), |
| | pad=(0, 1), |
| | ) |
| | ) |
| |
|
| | return Group(*errors) |
| |
|
| |
|
| | class EOFError(TokenError): |
| | pass |
| |
|
| |
|
| | class Expect: |
| | def __init__(self, **tokens: str) -> None: |
| | self.names = list(tokens.keys()) |
| | self.regexes = list(tokens.values()) |
| | self._regex = re.compile( |
| | "(" |
| | + "|".join(f"(?P<{name}>{regex})" for name, regex in tokens.items()) |
| | + ")" |
| | ) |
| | self.match = self._regex.match |
| | self.search = self._regex.search |
| | self._expect_eof = False |
| |
|
| | def expect_eof(self, eof: bool) -> Expect: |
| | self._expect_eof = eof |
| | return self |
| |
|
| | def __rich_repr__(self) -> rich.repr.Result: |
| | yield from zip(self.names, self.regexes) |
| |
|
| |
|
| | class ReferencedBy(NamedTuple): |
| | name: str |
| | location: tuple[int, int] |
| | length: int |
| | code: str |
| |
|
| |
|
| | @rich.repr.auto |
| | class Token(NamedTuple): |
| | name: str |
| | value: str |
| | path: str |
| | code: str |
| | location: tuple[int, int] |
| | referenced_by: ReferencedBy | None = None |
| |
|
| | @property |
| | def start(self) -> tuple[int, int]: |
| | """Start line and column (1 indexed).""" |
| | line, offset = self.location |
| | return (line + 1, offset) |
| |
|
| | @property |
| | def end(self) -> tuple[int, int]: |
| | """End line and column (1 indexed).""" |
| | line, offset = self.location |
| | return (line + 1, offset + len(self.value)) |
| |
|
| | def with_reference(self, by: ReferencedBy | None) -> "Token": |
| | """Return a copy of the Token, with reference information attached. |
| | This is used for variable substitution, where a variable reference |
| | can refer to tokens which were defined elsewhere. With the additional |
| | ReferencedBy data attached, we can track where the token we are referring |
| | to is used. |
| | """ |
| | return Token( |
| | name=self.name, |
| | value=self.value, |
| | path=self.path, |
| | code=self.code, |
| | location=self.location, |
| | referenced_by=by, |
| | ) |
| |
|
| | def __str__(self) -> str: |
| | return self.value |
| |
|
| | def __rich_repr__(self) -> rich.repr.Result: |
| | yield "name", self.name |
| | yield "value", self.value |
| | yield "path", self.path |
| | yield "code", self.code if len(self.code) < 40 else self.code[:40] + "..." |
| | yield "location", self.location |
| | yield "referenced_by", self.referenced_by, None |
| |
|
| |
|
| | class Tokenizer: |
| | def __init__(self, text: str, path: str | PurePath = "") -> None: |
| | self.path = str(path) |
| | self.code = text |
| | self.lines = text.splitlines(keepends=True) |
| | self.line_no = 0 |
| | self.col_no = 0 |
| |
|
| | def get_token(self, expect: Expect) -> Token: |
| | line_no = self.line_no |
| | col_no = self.col_no |
| | if line_no >= len(self.lines): |
| | if expect._expect_eof: |
| | return Token( |
| | "eof", |
| | "", |
| | self.path, |
| | self.code, |
| | (line_no + 1, col_no + 1), |
| | None, |
| | ) |
| | else: |
| | raise EOFError( |
| | self.path, |
| | self.code, |
| | (line_no + 1, col_no + 1), |
| | "Unexpected end of file", |
| | ) |
| | line = self.lines[line_no] |
| | match = expect.match(line, col_no) |
| | if match is None: |
| | expected = friendly_list(" ".join(name.split("_")) for name in expect.names) |
| | message = f"Expected one of {expected}.; Did you forget a semicolon at the end of a line?" |
| | raise TokenError( |
| | self.path, |
| | self.code, |
| | (line_no, col_no), |
| | message, |
| | ) |
| | iter_groups = iter(match.groups()) |
| |
|
| | next(iter_groups) |
| |
|
| | for name, value in zip(expect.names, iter_groups): |
| | if value is not None: |
| | break |
| | else: |
| | |
| | raise AssertionError("can't reach here") |
| |
|
| | token = Token( |
| | name, |
| | value, |
| | self.path, |
| | self.code, |
| | (line_no, col_no), |
| | referenced_by=None, |
| | ) |
| | col_no += len(value) |
| | if col_no >= len(line): |
| | line_no += 1 |
| | col_no = 0 |
| | self.line_no = line_no |
| | self.col_no = col_no |
| | return token |
| |
|
| | def skip_to(self, expect: Expect) -> Token: |
| | line_no = self.line_no |
| | col_no = self.col_no |
| |
|
| | while True: |
| | if line_no >= len(self.lines): |
| | raise EOFError( |
| | self.path, self.code, line_no, col_no, "Unexpected end of file" |
| | ) |
| | line = self.lines[line_no] |
| | match = expect.search(line, col_no) |
| |
|
| | if match is None: |
| | line_no += 1 |
| | col_no = 0 |
| | else: |
| | self.line_no = line_no |
| | self.col_no = match.span(0)[0] |
| | return self.get_token(expect) |
| |
|
