mirror of https://github.com/morpheus65535/bazarr
946 lines
34 KiB
Python
946 lines
34 KiB
Python
import os.path
|
|
import platform
|
|
import re
|
|
import sys
|
|
import textwrap
|
|
from abc import ABC, abstractmethod
|
|
from typing import (
|
|
Any,
|
|
Dict,
|
|
Iterable,
|
|
List,
|
|
NamedTuple,
|
|
Optional,
|
|
Sequence,
|
|
Set,
|
|
Tuple,
|
|
Type,
|
|
Union,
|
|
)
|
|
|
|
from pygments.lexer import Lexer
|
|
from pygments.lexers import get_lexer_by_name, guess_lexer_for_filename
|
|
from pygments.style import Style as PygmentsStyle
|
|
from pygments.styles import get_style_by_name
|
|
from pygments.token import (
|
|
Comment,
|
|
Error,
|
|
Generic,
|
|
Keyword,
|
|
Name,
|
|
Number,
|
|
Operator,
|
|
String,
|
|
Token,
|
|
Whitespace,
|
|
)
|
|
from pygments.util import ClassNotFound
|
|
|
|
from rich.containers import Lines
|
|
from rich.padding import Padding, PaddingDimensions
|
|
|
|
from ._loop import loop_first
|
|
from .cells import cell_len
|
|
from .color import Color, blend_rgb
|
|
from .console import Console, ConsoleOptions, JustifyMethod, RenderResult
|
|
from .jupyter import JupyterMixin
|
|
from .measure import Measurement
|
|
from .segment import Segment, Segments
|
|
from .style import Style, StyleType
|
|
from .text import Text
|
|
|
|
TokenType = Tuple[str, ...]
|
|
|
|
WINDOWS = platform.system() == "Windows"
|
|
DEFAULT_THEME = "monokai"
|
|
|
|
# The following styles are based on https://github.com/pygments/pygments/blob/master/pygments/formatters/terminal.py
|
|
# A few modifications were made
|
|
|
|
ANSI_LIGHT: Dict[TokenType, Style] = {
|
|
Token: Style(),
|
|
Whitespace: Style(color="white"),
|
|
Comment: Style(dim=True),
|
|
Comment.Preproc: Style(color="cyan"),
|
|
Keyword: Style(color="blue"),
|
|
Keyword.Type: Style(color="cyan"),
|
|
Operator.Word: Style(color="magenta"),
|
|
Name.Builtin: Style(color="cyan"),
|
|
Name.Function: Style(color="green"),
|
|
Name.Namespace: Style(color="cyan", underline=True),
|
|
Name.Class: Style(color="green", underline=True),
|
|
Name.Exception: Style(color="cyan"),
|
|
Name.Decorator: Style(color="magenta", bold=True),
|
|
Name.Variable: Style(color="red"),
|
|
Name.Constant: Style(color="red"),
|
|
Name.Attribute: Style(color="cyan"),
|
|
Name.Tag: Style(color="bright_blue"),
|
|
String: Style(color="yellow"),
|
|
Number: Style(color="blue"),
|
|
Generic.Deleted: Style(color="bright_red"),
|
|
Generic.Inserted: Style(color="green"),
|
|
Generic.Heading: Style(bold=True),
|
|
Generic.Subheading: Style(color="magenta", bold=True),
|
|
Generic.Prompt: Style(bold=True),
|
|
Generic.Error: Style(color="bright_red"),
|
|
Error: Style(color="red", underline=True),
|
|
}
|
|
|
|
ANSI_DARK: Dict[TokenType, Style] = {
|
|
Token: Style(),
|
|
Whitespace: Style(color="bright_black"),
|
|
Comment: Style(dim=True),
|
|
Comment.Preproc: Style(color="bright_cyan"),
|
|
Keyword: Style(color="bright_blue"),
|
|
Keyword.Type: Style(color="bright_cyan"),
|
|
Operator.Word: Style(color="bright_magenta"),
|
|
Name.Builtin: Style(color="bright_cyan"),
|
|
Name.Function: Style(color="bright_green"),
|
|
Name.Namespace: Style(color="bright_cyan", underline=True),
|
|
Name.Class: Style(color="bright_green", underline=True),
|
|
Name.Exception: Style(color="bright_cyan"),
|
|
Name.Decorator: Style(color="bright_magenta", bold=True),
|
|
Name.Variable: Style(color="bright_red"),
|
|
Name.Constant: Style(color="bright_red"),
|
|
Name.Attribute: Style(color="bright_cyan"),
|
|
Name.Tag: Style(color="bright_blue"),
|
|
String: Style(color="yellow"),
|
|
Number: Style(color="bright_blue"),
|
|
Generic.Deleted: Style(color="bright_red"),
|
|
Generic.Inserted: Style(color="bright_green"),
|
|
Generic.Heading: Style(bold=True),
|
|
Generic.Subheading: Style(color="bright_magenta", bold=True),
|
|
Generic.Prompt: Style(bold=True),
|
|
Generic.Error: Style(color="bright_red"),
|
|
Error: Style(color="red", underline=True),
|
|
}
|
|
|
|
RICH_SYNTAX_THEMES = {"ansi_light": ANSI_LIGHT, "ansi_dark": ANSI_DARK}
|
|
NUMBERS_COLUMN_DEFAULT_PADDING = 2
|
|
|
|
|
|
class SyntaxTheme(ABC):
|
|
"""Base class for a syntax theme."""
|
|
|
|
@abstractmethod
|
|
def get_style_for_token(self, token_type: TokenType) -> Style:
|
|
"""Get a style for a given Pygments token."""
|
|
raise NotImplementedError # pragma: no cover
|
|
|
|
@abstractmethod
|
|
def get_background_style(self) -> Style:
|
|
"""Get the background color."""
|
|
raise NotImplementedError # pragma: no cover
|
|
|
|
|
|
class PygmentsSyntaxTheme(SyntaxTheme):
|
|
"""Syntax theme that delegates to Pygments theme."""
|
|
|
|
def __init__(self, theme: Union[str, Type[PygmentsStyle]]) -> None:
|
|
self._style_cache: Dict[TokenType, Style] = {}
|
|
if isinstance(theme, str):
|
|
try:
|
|
self._pygments_style_class = get_style_by_name(theme)
|
|
except ClassNotFound:
|
|
self._pygments_style_class = get_style_by_name("default")
|
|
else:
|
|
self._pygments_style_class = theme
|
|
|
|
self._background_color = self._pygments_style_class.background_color
|
|
self._background_style = Style(bgcolor=self._background_color)
|
|
|
|
def get_style_for_token(self, token_type: TokenType) -> Style:
|
|
"""Get a style from a Pygments class."""
|
|
try:
|
|
return self._style_cache[token_type]
|
|
except KeyError:
|
|
try:
|
|
pygments_style = self._pygments_style_class.style_for_token(token_type)
|
|
except KeyError:
|
|
style = Style.null()
|
|
else:
|
|
color = pygments_style["color"]
|
|
bgcolor = pygments_style["bgcolor"]
|
|
style = Style(
|
|
color="#" + color if color else "#000000",
|
|
bgcolor="#" + bgcolor if bgcolor else self._background_color,
|
|
bold=pygments_style["bold"],
|
|
italic=pygments_style["italic"],
|
|
underline=pygments_style["underline"],
|
|
)
|
|
self._style_cache[token_type] = style
|
|
return style
|
|
|
|
def get_background_style(self) -> Style:
|
|
return self._background_style
|
|
|
|
|
|
class ANSISyntaxTheme(SyntaxTheme):
|
|
"""Syntax theme to use standard colors."""
|
|
|
|
def __init__(self, style_map: Dict[TokenType, Style]) -> None:
|
|
self.style_map = style_map
|
|
self._missing_style = Style.null()
|
|
self._background_style = Style.null()
|
|
self._style_cache: Dict[TokenType, Style] = {}
|
|
|
|
def get_style_for_token(self, token_type: TokenType) -> Style:
|
|
"""Look up style in the style map."""
|
|
try:
|
|
return self._style_cache[token_type]
|
|
except KeyError:
|
|
# Styles form a hierarchy
|
|
# We need to go from most to least specific
|
|
# e.g. ("foo", "bar", "baz") to ("foo", "bar") to ("foo",)
|
|
get_style = self.style_map.get
|
|
token = tuple(token_type)
|
|
style = self._missing_style
|
|
while token:
|
|
_style = get_style(token)
|
|
if _style is not None:
|
|
style = _style
|
|
break
|
|
token = token[:-1]
|
|
self._style_cache[token_type] = style
|
|
return style
|
|
|
|
def get_background_style(self) -> Style:
|
|
return self._background_style
|
|
|
|
|
|
SyntaxPosition = Tuple[int, int]
|
|
|
|
|
|
class _SyntaxHighlightRange(NamedTuple):
|
|
"""
|
|
A range to highlight in a Syntax object.
|
|
`start` and `end` are 2-integers tuples, where the first integer is the line number
|
|
(starting from 1) and the second integer is the column index (starting from 0).
|
|
"""
|
|
|
|
style: StyleType
|
|
start: SyntaxPosition
|
|
end: SyntaxPosition
|
|
|
|
|
|
class Syntax(JupyterMixin):
|
|
"""Construct a Syntax object to render syntax highlighted code.
|
|
|
|
Args:
|
|
code (str): Code to highlight.
|
|
lexer (Lexer | str): Lexer to use (see https://pygments.org/docs/lexers/)
|
|
theme (str, optional): Color theme, aka Pygments style (see https://pygments.org/docs/styles/#getting-a-list-of-available-styles). Defaults to "monokai".
|
|
dedent (bool, optional): Enable stripping of initial whitespace. Defaults to False.
|
|
line_numbers (bool, optional): Enable rendering of line numbers. Defaults to False.
|
|
start_line (int, optional): Starting number for line numbers. Defaults to 1.
|
|
line_range (Tuple[int | None, int | None], optional): If given should be a tuple of the start and end line to render.
|
|
A value of None in the tuple indicates the range is open in that direction.
|
|
highlight_lines (Set[int]): A set of line numbers to highlight.
|
|
code_width: Width of code to render (not including line numbers), or ``None`` to use all available width.
|
|
tab_size (int, optional): Size of tabs. Defaults to 4.
|
|
word_wrap (bool, optional): Enable word wrapping.
|
|
background_color (str, optional): Optional background color, or None to use theme color. Defaults to None.
|
|
indent_guides (bool, optional): Show indent guides. Defaults to False.
|
|
padding (PaddingDimensions): Padding to apply around the syntax. Defaults to 0 (no padding).
|
|
"""
|
|
|
|
_pygments_style_class: Type[PygmentsStyle]
|
|
_theme: SyntaxTheme
|
|
|
|
@classmethod
|
|
def get_theme(cls, name: Union[str, SyntaxTheme]) -> SyntaxTheme:
|
|
"""Get a syntax theme instance."""
|
|
if isinstance(name, SyntaxTheme):
|
|
return name
|
|
theme: SyntaxTheme
|
|
if name in RICH_SYNTAX_THEMES:
|
|
theme = ANSISyntaxTheme(RICH_SYNTAX_THEMES[name])
|
|
else:
|
|
theme = PygmentsSyntaxTheme(name)
|
|
return theme
|
|
|
|
def __init__(
|
|
self,
|
|
code: str,
|
|
lexer: Union[Lexer, str],
|
|
*,
|
|
theme: Union[str, SyntaxTheme] = DEFAULT_THEME,
|
|
dedent: bool = False,
|
|
line_numbers: bool = False,
|
|
start_line: int = 1,
|
|
line_range: Optional[Tuple[Optional[int], Optional[int]]] = None,
|
|
highlight_lines: Optional[Set[int]] = None,
|
|
code_width: Optional[int] = None,
|
|
tab_size: int = 4,
|
|
word_wrap: bool = False,
|
|
background_color: Optional[str] = None,
|
|
indent_guides: bool = False,
|
|
padding: PaddingDimensions = 0,
|
|
) -> None:
|
|
self.code = code
|
|
self._lexer = lexer
|
|
self.dedent = dedent
|
|
self.line_numbers = line_numbers
|
|
self.start_line = start_line
|
|
self.line_range = line_range
|
|
self.highlight_lines = highlight_lines or set()
|
|
self.code_width = code_width
|
|
self.tab_size = tab_size
|
|
self.word_wrap = word_wrap
|
|
self.background_color = background_color
|
|
self.background_style = (
|
|
Style(bgcolor=background_color) if background_color else Style()
|
|
)
|
|
self.indent_guides = indent_guides
|
|
self.padding = padding
|
|
|
|
self._theme = self.get_theme(theme)
|
|
self._stylized_ranges: List[_SyntaxHighlightRange] = []
|
|
|
|
@classmethod
|
|
def from_path(
|
|
cls,
|
|
path: str,
|
|
encoding: str = "utf-8",
|
|
lexer: Optional[Union[Lexer, str]] = None,
|
|
theme: Union[str, SyntaxTheme] = DEFAULT_THEME,
|
|
dedent: bool = False,
|
|
line_numbers: bool = False,
|
|
line_range: Optional[Tuple[int, int]] = None,
|
|
start_line: int = 1,
|
|
highlight_lines: Optional[Set[int]] = None,
|
|
code_width: Optional[int] = None,
|
|
tab_size: int = 4,
|
|
word_wrap: bool = False,
|
|
background_color: Optional[str] = None,
|
|
indent_guides: bool = False,
|
|
padding: PaddingDimensions = 0,
|
|
) -> "Syntax":
|
|
"""Construct a Syntax object from a file.
|
|
|
|
Args:
|
|
path (str): Path to file to highlight.
|
|
encoding (str): Encoding of file.
|
|
lexer (str | Lexer, optional): Lexer to use. If None, lexer will be auto-detected from path/file content.
|
|
theme (str, optional): Color theme, aka Pygments style (see https://pygments.org/docs/styles/#getting-a-list-of-available-styles). Defaults to "emacs".
|
|
dedent (bool, optional): Enable stripping of initial whitespace. Defaults to True.
|
|
line_numbers (bool, optional): Enable rendering of line numbers. Defaults to False.
|
|
start_line (int, optional): Starting number for line numbers. Defaults to 1.
|
|
line_range (Tuple[int, int], optional): If given should be a tuple of the start and end line to render.
|
|
highlight_lines (Set[int]): A set of line numbers to highlight.
|
|
code_width: Width of code to render (not including line numbers), or ``None`` to use all available width.
|
|
tab_size (int, optional): Size of tabs. Defaults to 4.
|
|
word_wrap (bool, optional): Enable word wrapping of code.
|
|
background_color (str, optional): Optional background color, or None to use theme color. Defaults to None.
|
|
indent_guides (bool, optional): Show indent guides. Defaults to False.
|
|
padding (PaddingDimensions): Padding to apply around the syntax. Defaults to 0 (no padding).
|
|
|
|
Returns:
|
|
[Syntax]: A Syntax object that may be printed to the console
|
|
"""
|
|
with open(path, "rt", encoding=encoding) as code_file:
|
|
code = code_file.read()
|
|
|
|
if not lexer:
|
|
lexer = cls.guess_lexer(path, code=code)
|
|
|
|
return cls(
|
|
code,
|
|
lexer,
|
|
theme=theme,
|
|
dedent=dedent,
|
|
line_numbers=line_numbers,
|
|
line_range=line_range,
|
|
start_line=start_line,
|
|
highlight_lines=highlight_lines,
|
|
code_width=code_width,
|
|
tab_size=tab_size,
|
|
word_wrap=word_wrap,
|
|
background_color=background_color,
|
|
indent_guides=indent_guides,
|
|
padding=padding,
|
|
)
|
|
|
|
@classmethod
|
|
def guess_lexer(cls, path: str, code: Optional[str] = None) -> str:
|
|
"""Guess the alias of the Pygments lexer to use based on a path and an optional string of code.
|
|
If code is supplied, it will use a combination of the code and the filename to determine the
|
|
best lexer to use. For example, if the file is ``index.html`` and the file contains Django
|
|
templating syntax, then "html+django" will be returned. If the file is ``index.html``, and no
|
|
templating language is used, the "html" lexer will be used. If no string of code
|
|
is supplied, the lexer will be chosen based on the file extension..
|
|
|
|
Args:
|
|
path (AnyStr): The path to the file containing the code you wish to know the lexer for.
|
|
code (str, optional): Optional string of code that will be used as a fallback if no lexer
|
|
is found for the supplied path.
|
|
|
|
Returns:
|
|
str: The name of the Pygments lexer that best matches the supplied path/code.
|
|
"""
|
|
lexer: Optional[Lexer] = None
|
|
lexer_name = "default"
|
|
if code:
|
|
try:
|
|
lexer = guess_lexer_for_filename(path, code)
|
|
except ClassNotFound:
|
|
pass
|
|
|
|
if not lexer:
|
|
try:
|
|
_, ext = os.path.splitext(path)
|
|
if ext:
|
|
extension = ext.lstrip(".").lower()
|
|
lexer = get_lexer_by_name(extension)
|
|
except ClassNotFound:
|
|
pass
|
|
|
|
if lexer:
|
|
if lexer.aliases:
|
|
lexer_name = lexer.aliases[0]
|
|
else:
|
|
lexer_name = lexer.name
|
|
|
|
return lexer_name
|
|
|
|
def _get_base_style(self) -> Style:
|
|
"""Get the base style."""
|
|
default_style = self._theme.get_background_style() + self.background_style
|
|
return default_style
|
|
|
|
def _get_token_color(self, token_type: TokenType) -> Optional[Color]:
|
|
"""Get a color (if any) for the given token.
|
|
|
|
Args:
|
|
token_type (TokenType): A token type tuple from Pygments.
|
|
|
|
Returns:
|
|
Optional[Color]: Color from theme, or None for no color.
|
|
"""
|
|
style = self._theme.get_style_for_token(token_type)
|
|
return style.color
|
|
|
|
@property
|
|
def lexer(self) -> Optional[Lexer]:
|
|
"""The lexer for this syntax, or None if no lexer was found.
|
|
|
|
Tries to find the lexer by name if a string was passed to the constructor.
|
|
"""
|
|
|
|
if isinstance(self._lexer, Lexer):
|
|
return self._lexer
|
|
try:
|
|
return get_lexer_by_name(
|
|
self._lexer,
|
|
stripnl=False,
|
|
ensurenl=True,
|
|
tabsize=self.tab_size,
|
|
)
|
|
except ClassNotFound:
|
|
return None
|
|
|
|
def highlight(
|
|
self,
|
|
code: str,
|
|
line_range: Optional[Tuple[Optional[int], Optional[int]]] = None,
|
|
) -> Text:
|
|
"""Highlight code and return a Text instance.
|
|
|
|
Args:
|
|
code (str): Code to highlight.
|
|
line_range(Tuple[int, int], optional): Optional line range to highlight.
|
|
|
|
Returns:
|
|
Text: A text instance containing highlighted syntax.
|
|
"""
|
|
|
|
base_style = self._get_base_style()
|
|
justify: JustifyMethod = (
|
|
"default" if base_style.transparent_background else "left"
|
|
)
|
|
|
|
text = Text(
|
|
justify=justify,
|
|
style=base_style,
|
|
tab_size=self.tab_size,
|
|
no_wrap=not self.word_wrap,
|
|
)
|
|
_get_theme_style = self._theme.get_style_for_token
|
|
|
|
lexer = self.lexer
|
|
|
|
if lexer is None:
|
|
text.append(code)
|
|
else:
|
|
if line_range:
|
|
# More complicated path to only stylize a portion of the code
|
|
# This speeds up further operations as there are less spans to process
|
|
line_start, line_end = line_range
|
|
|
|
def line_tokenize() -> Iterable[Tuple[Any, str]]:
|
|
"""Split tokens to one per line."""
|
|
assert lexer # required to make MyPy happy - we know lexer is not None at this point
|
|
|
|
for token_type, token in lexer.get_tokens(code):
|
|
while token:
|
|
line_token, new_line, token = token.partition("\n")
|
|
yield token_type, line_token + new_line
|
|
|
|
def tokens_to_spans() -> Iterable[Tuple[str, Optional[Style]]]:
|
|
"""Convert tokens to spans."""
|
|
tokens = iter(line_tokenize())
|
|
line_no = 0
|
|
_line_start = line_start - 1 if line_start else 0
|
|
|
|
# Skip over tokens until line start
|
|
while line_no < _line_start:
|
|
_token_type, token = next(tokens)
|
|
yield (token, None)
|
|
if token.endswith("\n"):
|
|
line_no += 1
|
|
# Generate spans until line end
|
|
for token_type, token in tokens:
|
|
yield (token, _get_theme_style(token_type))
|
|
if token.endswith("\n"):
|
|
line_no += 1
|
|
if line_end and line_no >= line_end:
|
|
break
|
|
|
|
text.append_tokens(tokens_to_spans())
|
|
|
|
else:
|
|
text.append_tokens(
|
|
(token, _get_theme_style(token_type))
|
|
for token_type, token in lexer.get_tokens(code)
|
|
)
|
|
if self.background_color is not None:
|
|
text.stylize(f"on {self.background_color}")
|
|
|
|
if self._stylized_ranges:
|
|
self._apply_stylized_ranges(text)
|
|
|
|
return text
|
|
|
|
def stylize_range(
|
|
self, style: StyleType, start: SyntaxPosition, end: SyntaxPosition
|
|
) -> None:
|
|
"""
|
|
Adds a custom style on a part of the code, that will be applied to the syntax display when it's rendered.
|
|
Line numbers are 1-based, while column indexes are 0-based.
|
|
|
|
Args:
|
|
style (StyleType): The style to apply.
|
|
start (Tuple[int, int]): The start of the range, in the form `[line number, column index]`.
|
|
end (Tuple[int, int]): The end of the range, in the form `[line number, column index]`.
|
|
"""
|
|
self._stylized_ranges.append(_SyntaxHighlightRange(style, start, end))
|
|
|
|
def _get_line_numbers_color(self, blend: float = 0.3) -> Color:
|
|
background_style = self._theme.get_background_style() + self.background_style
|
|
background_color = background_style.bgcolor
|
|
if background_color is None or background_color.is_system_defined:
|
|
return Color.default()
|
|
foreground_color = self._get_token_color(Token.Text)
|
|
if foreground_color is None or foreground_color.is_system_defined:
|
|
return foreground_color or Color.default()
|
|
new_color = blend_rgb(
|
|
background_color.get_truecolor(),
|
|
foreground_color.get_truecolor(),
|
|
cross_fade=blend,
|
|
)
|
|
return Color.from_triplet(new_color)
|
|
|
|
@property
|
|
def _numbers_column_width(self) -> int:
|
|
"""Get the number of characters used to render the numbers column."""
|
|
column_width = 0
|
|
if self.line_numbers:
|
|
column_width = (
|
|
len(str(self.start_line + self.code.count("\n")))
|
|
+ NUMBERS_COLUMN_DEFAULT_PADDING
|
|
)
|
|
return column_width
|
|
|
|
def _get_number_styles(self, console: Console) -> Tuple[Style, Style, Style]:
|
|
"""Get background, number, and highlight styles for line numbers."""
|
|
background_style = self._get_base_style()
|
|
if background_style.transparent_background:
|
|
return Style.null(), Style(dim=True), Style.null()
|
|
if console.color_system in ("256", "truecolor"):
|
|
number_style = Style.chain(
|
|
background_style,
|
|
self._theme.get_style_for_token(Token.Text),
|
|
Style(color=self._get_line_numbers_color()),
|
|
self.background_style,
|
|
)
|
|
highlight_number_style = Style.chain(
|
|
background_style,
|
|
self._theme.get_style_for_token(Token.Text),
|
|
Style(bold=True, color=self._get_line_numbers_color(0.9)),
|
|
self.background_style,
|
|
)
|
|
else:
|
|
number_style = background_style + Style(dim=True)
|
|
highlight_number_style = background_style + Style(dim=False)
|
|
return background_style, number_style, highlight_number_style
|
|
|
|
def __rich_measure__(
|
|
self, console: "Console", options: "ConsoleOptions"
|
|
) -> "Measurement":
|
|
|
|
_, right, _, left = Padding.unpack(self.padding)
|
|
padding = left + right
|
|
if self.code_width is not None:
|
|
width = self.code_width + self._numbers_column_width + padding + 1
|
|
return Measurement(self._numbers_column_width, width)
|
|
lines = self.code.splitlines()
|
|
width = (
|
|
self._numbers_column_width
|
|
+ padding
|
|
+ (max(cell_len(line) for line in lines) if lines else 0)
|
|
)
|
|
if self.line_numbers:
|
|
width += 1
|
|
return Measurement(self._numbers_column_width, width)
|
|
|
|
def __rich_console__(
|
|
self, console: Console, options: ConsoleOptions
|
|
) -> RenderResult:
|
|
segments = Segments(self._get_syntax(console, options))
|
|
if self.padding:
|
|
yield Padding(
|
|
segments, style=self._theme.get_background_style(), pad=self.padding
|
|
)
|
|
else:
|
|
yield segments
|
|
|
|
def _get_syntax(
|
|
self,
|
|
console: Console,
|
|
options: ConsoleOptions,
|
|
) -> Iterable[Segment]:
|
|
"""
|
|
Get the Segments for the Syntax object, excluding any vertical/horizontal padding
|
|
"""
|
|
transparent_background = self._get_base_style().transparent_background
|
|
code_width = (
|
|
(
|
|
(options.max_width - self._numbers_column_width - 1)
|
|
if self.line_numbers
|
|
else options.max_width
|
|
)
|
|
if self.code_width is None
|
|
else self.code_width
|
|
)
|
|
|
|
ends_on_nl, processed_code = self._process_code(self.code)
|
|
text = self.highlight(processed_code, self.line_range)
|
|
|
|
if not self.line_numbers and not self.word_wrap and not self.line_range:
|
|
if not ends_on_nl:
|
|
text.remove_suffix("\n")
|
|
# Simple case of just rendering text
|
|
style = (
|
|
self._get_base_style()
|
|
+ self._theme.get_style_for_token(Comment)
|
|
+ Style(dim=True)
|
|
+ self.background_style
|
|
)
|
|
if self.indent_guides and not options.ascii_only:
|
|
text = text.with_indent_guides(self.tab_size, style=style)
|
|
text.overflow = "crop"
|
|
if style.transparent_background:
|
|
yield from console.render(
|
|
text, options=options.update(width=code_width)
|
|
)
|
|
else:
|
|
syntax_lines = console.render_lines(
|
|
text,
|
|
options.update(width=code_width, height=None, justify="left"),
|
|
style=self.background_style,
|
|
pad=True,
|
|
new_lines=True,
|
|
)
|
|
for syntax_line in syntax_lines:
|
|
yield from syntax_line
|
|
return
|
|
|
|
start_line, end_line = self.line_range or (None, None)
|
|
line_offset = 0
|
|
if start_line:
|
|
line_offset = max(0, start_line - 1)
|
|
lines: Union[List[Text], Lines] = text.split("\n", allow_blank=ends_on_nl)
|
|
if self.line_range:
|
|
lines = lines[line_offset:end_line]
|
|
|
|
if self.indent_guides and not options.ascii_only:
|
|
style = (
|
|
self._get_base_style()
|
|
+ self._theme.get_style_for_token(Comment)
|
|
+ Style(dim=True)
|
|
+ self.background_style
|
|
)
|
|
lines = (
|
|
Text("\n")
|
|
.join(lines)
|
|
.with_indent_guides(self.tab_size, style=style)
|
|
.split("\n", allow_blank=True)
|
|
)
|
|
|
|
numbers_column_width = self._numbers_column_width
|
|
render_options = options.update(width=code_width)
|
|
|
|
highlight_line = self.highlight_lines.__contains__
|
|
_Segment = Segment
|
|
new_line = _Segment("\n")
|
|
|
|
line_pointer = "> " if options.legacy_windows else "❱ "
|
|
|
|
(
|
|
background_style,
|
|
number_style,
|
|
highlight_number_style,
|
|
) = self._get_number_styles(console)
|
|
|
|
for line_no, line in enumerate(lines, self.start_line + line_offset):
|
|
if self.word_wrap:
|
|
wrapped_lines = console.render_lines(
|
|
line,
|
|
render_options.update(height=None, justify="left"),
|
|
style=background_style,
|
|
pad=not transparent_background,
|
|
)
|
|
else:
|
|
segments = list(line.render(console, end=""))
|
|
if options.no_wrap:
|
|
wrapped_lines = [segments]
|
|
else:
|
|
wrapped_lines = [
|
|
_Segment.adjust_line_length(
|
|
segments,
|
|
render_options.max_width,
|
|
style=background_style,
|
|
pad=not transparent_background,
|
|
)
|
|
]
|
|
|
|
if self.line_numbers:
|
|
wrapped_line_left_pad = _Segment(
|
|
" " * numbers_column_width + " ", background_style
|
|
)
|
|
for first, wrapped_line in loop_first(wrapped_lines):
|
|
if first:
|
|
line_column = str(line_no).rjust(numbers_column_width - 2) + " "
|
|
if highlight_line(line_no):
|
|
yield _Segment(line_pointer, Style(color="red"))
|
|
yield _Segment(line_column, highlight_number_style)
|
|
else:
|
|
yield _Segment(" ", highlight_number_style)
|
|
yield _Segment(line_column, number_style)
|
|
else:
|
|
yield wrapped_line_left_pad
|
|
yield from wrapped_line
|
|
yield new_line
|
|
else:
|
|
for wrapped_line in wrapped_lines:
|
|
yield from wrapped_line
|
|
yield new_line
|
|
|
|
def _apply_stylized_ranges(self, text: Text) -> None:
|
|
"""
|
|
Apply stylized ranges to a text instance,
|
|
using the given code to determine the right portion to apply the style to.
|
|
|
|
Args:
|
|
text (Text): Text instance to apply the style to.
|
|
"""
|
|
code = text.plain
|
|
newlines_offsets = [
|
|
# Let's add outer boundaries at each side of the list:
|
|
0,
|
|
# N.B. using "\n" here is much faster than using metacharacters such as "^" or "\Z":
|
|
*[
|
|
match.start() + 1
|
|
for match in re.finditer("\n", code, flags=re.MULTILINE)
|
|
],
|
|
len(code) + 1,
|
|
]
|
|
|
|
for stylized_range in self._stylized_ranges:
|
|
start = _get_code_index_for_syntax_position(
|
|
newlines_offsets, stylized_range.start
|
|
)
|
|
end = _get_code_index_for_syntax_position(
|
|
newlines_offsets, stylized_range.end
|
|
)
|
|
if start is not None and end is not None:
|
|
text.stylize(stylized_range.style, start, end)
|
|
|
|
def _process_code(self, code: str) -> Tuple[bool, str]:
|
|
"""
|
|
Applies various processing to a raw code string
|
|
(normalises it so it always ends with a line return, dedents it if necessary, etc.)
|
|
|
|
Args:
|
|
code (str): The raw code string to process
|
|
|
|
Returns:
|
|
Tuple[bool, str]: the boolean indicates whether the raw code ends with a line return,
|
|
while the string is the processed code.
|
|
"""
|
|
ends_on_nl = code.endswith("\n")
|
|
processed_code = code if ends_on_nl else code + "\n"
|
|
processed_code = (
|
|
textwrap.dedent(processed_code) if self.dedent else processed_code
|
|
)
|
|
processed_code = processed_code.expandtabs(self.tab_size)
|
|
return ends_on_nl, processed_code
|
|
|
|
|
|
def _get_code_index_for_syntax_position(
|
|
newlines_offsets: Sequence[int], position: SyntaxPosition
|
|
) -> Optional[int]:
|
|
"""
|
|
Returns the index of the code string for the given positions.
|
|
|
|
Args:
|
|
newlines_offsets (Sequence[int]): The offset of each newline character found in the code snippet.
|
|
position (SyntaxPosition): The position to search for.
|
|
|
|
Returns:
|
|
Optional[int]: The index of the code string for this position, or `None`
|
|
if the given position's line number is out of range (if it's the column that is out of range
|
|
we silently clamp its value so that it reaches the end of the line)
|
|
"""
|
|
lines_count = len(newlines_offsets)
|
|
|
|
line_number, column_index = position
|
|
if line_number > lines_count or len(newlines_offsets) < (line_number + 1):
|
|
return None # `line_number` is out of range
|
|
line_index = line_number - 1
|
|
line_length = newlines_offsets[line_index + 1] - newlines_offsets[line_index] - 1
|
|
# If `column_index` is out of range: let's silently clamp it:
|
|
column_index = min(line_length, column_index)
|
|
return newlines_offsets[line_index] + column_index
|
|
|
|
|
|
if __name__ == "__main__": # pragma: no cover
|
|
|
|
import argparse
|
|
import sys
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description="Render syntax to the console with Rich"
|
|
)
|
|
parser.add_argument(
|
|
"path",
|
|
metavar="PATH",
|
|
help="path to file, or - for stdin",
|
|
)
|
|
parser.add_argument(
|
|
"-c",
|
|
"--force-color",
|
|
dest="force_color",
|
|
action="store_true",
|
|
default=None,
|
|
help="force color for non-terminals",
|
|
)
|
|
parser.add_argument(
|
|
"-i",
|
|
"--indent-guides",
|
|
dest="indent_guides",
|
|
action="store_true",
|
|
default=False,
|
|
help="display indent guides",
|
|
)
|
|
parser.add_argument(
|
|
"-l",
|
|
"--line-numbers",
|
|
dest="line_numbers",
|
|
action="store_true",
|
|
help="render line numbers",
|
|
)
|
|
parser.add_argument(
|
|
"-w",
|
|
"--width",
|
|
type=int,
|
|
dest="width",
|
|
default=None,
|
|
help="width of output (default will auto-detect)",
|
|
)
|
|
parser.add_argument(
|
|
"-r",
|
|
"--wrap",
|
|
dest="word_wrap",
|
|
action="store_true",
|
|
default=False,
|
|
help="word wrap long lines",
|
|
)
|
|
parser.add_argument(
|
|
"-s",
|
|
"--soft-wrap",
|
|
action="store_true",
|
|
dest="soft_wrap",
|
|
default=False,
|
|
help="enable soft wrapping mode",
|
|
)
|
|
parser.add_argument(
|
|
"-t", "--theme", dest="theme", default="monokai", help="pygments theme"
|
|
)
|
|
parser.add_argument(
|
|
"-b",
|
|
"--background-color",
|
|
dest="background_color",
|
|
default=None,
|
|
help="Override background color",
|
|
)
|
|
parser.add_argument(
|
|
"-x",
|
|
"--lexer",
|
|
default=None,
|
|
dest="lexer_name",
|
|
help="Lexer name",
|
|
)
|
|
parser.add_argument(
|
|
"-p", "--padding", type=int, default=0, dest="padding", help="Padding"
|
|
)
|
|
parser.add_argument(
|
|
"--highlight-line",
|
|
type=int,
|
|
default=None,
|
|
dest="highlight_line",
|
|
help="The line number (not index!) to highlight",
|
|
)
|
|
args = parser.parse_args()
|
|
|
|
from rich.console import Console
|
|
|
|
console = Console(force_terminal=args.force_color, width=args.width)
|
|
|
|
if args.path == "-":
|
|
code = sys.stdin.read()
|
|
syntax = Syntax(
|
|
code=code,
|
|
lexer=args.lexer_name,
|
|
line_numbers=args.line_numbers,
|
|
word_wrap=args.word_wrap,
|
|
theme=args.theme,
|
|
background_color=args.background_color,
|
|
indent_guides=args.indent_guides,
|
|
padding=args.padding,
|
|
highlight_lines={args.highlight_line},
|
|
)
|
|
else:
|
|
syntax = Syntax.from_path(
|
|
args.path,
|
|
lexer=args.lexer_name,
|
|
line_numbers=args.line_numbers,
|
|
word_wrap=args.word_wrap,
|
|
theme=args.theme,
|
|
background_color=args.background_color,
|
|
indent_guides=args.indent_guides,
|
|
padding=args.padding,
|
|
highlight_lines={args.highlight_line},
|
|
)
|
|
console.print(syntax, soft_wrap=args.soft_wrap)
|