| | """ |
| | pygments.formatters.html |
| | ~~~~~~~~~~~~~~~~~~~~~~~~ |
| | |
| | Formatter for HTML output. |
| | |
| | :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS. |
| | :license: BSD, see LICENSE for details. |
| | """ |
| |
|
| | import functools |
| | import os |
| | import sys |
| | import os.path |
| | from io import StringIO |
| |
|
| | from pygments.formatter import Formatter |
| | from pygments.token import Token, Text, STANDARD_TYPES |
| | from pygments.util import get_bool_opt, get_int_opt, get_list_opt |
| |
|
| | try: |
| | import ctags |
| | except ImportError: |
| | ctags = None |
| |
|
| | __all__ = ['HtmlFormatter'] |
| |
|
| |
|
| | _escape_html_table = { |
| | ord('&'): '&', |
| | ord('<'): '<', |
| | ord('>'): '>', |
| | ord('"'): '"', |
| | ord("'"): ''', |
| | } |
| |
|
| |
|
| | def escape_html(text, table=_escape_html_table): |
| | """Escape &, <, > as well as single and double quotes for HTML.""" |
| | return text.translate(table) |
| |
|
| |
|
| | def webify(color): |
| | if color.startswith('calc') or color.startswith('var'): |
| | return color |
| | else: |
| | |
| | color = color.upper() |
| | if (len(color) == 6 and |
| | ( color[0] == color[1] |
| | and color[2] == color[3] |
| | and color[4] == color[5])): |
| | return f'#{color[0]}{color[2]}{color[4]}' |
| | else: |
| | return f'#{color}' |
| |
|
| |
|
| | def _get_ttype_class(ttype): |
| | fname = STANDARD_TYPES.get(ttype) |
| | if fname: |
| | return fname |
| | aname = '' |
| | while fname is None: |
| | aname = '-' + ttype[-1] + aname |
| | ttype = ttype.parent |
| | fname = STANDARD_TYPES.get(ttype) |
| | return fname + aname |
| |
|
| |
|
| | CSSFILE_TEMPLATE = '''\ |
| | /* |
| | generated by Pygments <https://pygments.org/> |
| | Copyright 2006-2025 by the Pygments team. |
| | Licensed under the BSD license, see LICENSE for details. |
| | */ |
| | %(styledefs)s |
| | ''' |
| |
|
| | DOC_HEADER = '''\ |
| | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" |
| | "http://www.w3.org/TR/html4/strict.dtd"> |
| | <!-- |
| | generated by Pygments <https://pygments.org/> |
| | Copyright 2006-2025 by the Pygments team. |
| | Licensed under the BSD license, see LICENSE for details. |
| | --> |
| | <html> |
| | <head> |
| | <title>%(title)s</title> |
| | <meta http-equiv="content-type" content="text/html; charset=%(encoding)s"> |
| | <style type="text/css"> |
| | ''' + CSSFILE_TEMPLATE + ''' |
| | </style> |
| | </head> |
| | <body> |
| | <h2>%(title)s</h2> |
| | |
| | ''' |
| |
|
| | DOC_HEADER_EXTERNALCSS = '''\ |
| | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" |
| | "http://www.w3.org/TR/html4/strict.dtd"> |
| | |
| | <html> |
| | <head> |
| | <title>%(title)s</title> |
| | <meta http-equiv="content-type" content="text/html; charset=%(encoding)s"> |
| | <link rel="stylesheet" href="%(cssfile)s" type="text/css"> |
| | </head> |
| | <body> |
| | <h2>%(title)s</h2> |
| | |
| | ''' |
| |
|
| | DOC_FOOTER = '''\ |
| | </body> |
| | </html> |
| | ''' |
| |
|
| |
|
| | class HtmlFormatter(Formatter): |
| | r""" |
| | Format tokens as HTML 4 ``<span>`` tags. By default, the content is enclosed |
| | in a ``<pre>`` tag, itself wrapped in a ``<div>`` tag (but see the `nowrap` option). |
| | The ``<div>``'s CSS class can be set by the `cssclass` option. |
| | |
| | If the `linenos` option is set to ``"table"``, the ``<pre>`` is |
| | additionally wrapped inside a ``<table>`` which has one row and two |
| | cells: one containing the line numbers and one containing the code. |
| | Example: |
| | |
| | .. sourcecode:: html |
| | |
| | <div class="highlight" > |
| | <table><tr> |
| | <td class="linenos" title="click to toggle" |
| | onclick="with (this.firstChild.style) |
| | { display = (display == '') ? 'none' : '' }"> |
| | <pre>1 |
| | 2</pre> |
| | </td> |
| | <td class="code"> |
| | <pre><span class="Ke">def </span><span class="NaFu">foo</span>(bar): |
| | <span class="Ke">pass</span> |
| | </pre> |
| | </td> |
| | </tr></table></div> |
| | |
| | (whitespace added to improve clarity). |
| | |
| | A list of lines can be specified using the `hl_lines` option to make these |
| | lines highlighted (as of Pygments 0.11). |
| | |
| | With the `full` option, a complete HTML 4 document is output, including |
| | the style definitions inside a ``<style>`` tag, or in a separate file if |
| | the `cssfile` option is given. |
| | |
| | When `tagsfile` is set to the path of a ctags index file, it is used to |
| | generate hyperlinks from names to their definition. You must enable |
| | `lineanchors` and run ctags with the `-n` option for this to work. The |
| | `python-ctags` module from PyPI must be installed to use this feature; |
| | otherwise a `RuntimeError` will be raised. |
| | |
| | The `get_style_defs(arg='')` method of a `HtmlFormatter` returns a string |
| | containing CSS rules for the CSS classes used by the formatter. The |
| | argument `arg` can be used to specify additional CSS selectors that |
| | are prepended to the classes. A call `fmter.get_style_defs('td .code')` |
| | would result in the following CSS classes: |
| | |
| | .. sourcecode:: css |
| | |
| | td .code .kw { font-weight: bold; color: #00FF00 } |
| | td .code .cm { color: #999999 } |
| | ... |
| | |
| | If you have Pygments 0.6 or higher, you can also pass a list or tuple to the |
| | `get_style_defs()` method to request multiple prefixes for the tokens: |
| | |
| | .. sourcecode:: python |
| | |
| | formatter.get_style_defs(['div.syntax pre', 'pre.syntax']) |
| | |
| | The output would then look like this: |
| | |
| | .. sourcecode:: css |
| | |
| | div.syntax pre .kw, |
| | pre.syntax .kw { font-weight: bold; color: #00FF00 } |
| | div.syntax pre .cm, |
| | pre.syntax .cm { color: #999999 } |
| | ... |
| | |
| | Additional options accepted: |
| | |
| | `nowrap` |
| | If set to ``True``, don't add a ``<pre>`` and a ``<div>`` tag |
| | around the tokens. This disables most other options (default: ``False``). |
| | |
| | `full` |
| | Tells the formatter to output a "full" document, i.e. a complete |
| | self-contained document (default: ``False``). |
| | |
| | `title` |
| | If `full` is true, the title that should be used to caption the |
| | document (default: ``''``). |
| | |
| | `style` |
| | The style to use, can be a string or a Style subclass (default: |
| | ``'default'``). This option has no effect if the `cssfile` |
| | and `noclobber_cssfile` option are given and the file specified in |
| | `cssfile` exists. |
| | |
| | `noclasses` |
| | If set to true, token ``<span>`` tags (as well as line number elements) |
| | will not use CSS classes, but inline styles. This is not recommended |
| | for larger pieces of code since it increases output size by quite a bit |
| | (default: ``False``). |
| | |
| | `classprefix` |
| | Since the token types use relatively short class names, they may clash |
| | with some of your own class names. In this case you can use the |
| | `classprefix` option to give a string to prepend to all Pygments-generated |
| | CSS class names for token types. |
| | Note that this option also affects the output of `get_style_defs()`. |
| | |
| | `cssclass` |
| | CSS class for the wrapping ``<div>`` tag (default: ``'highlight'``). |
| | If you set this option, the default selector for `get_style_defs()` |
| | will be this class. |
| | |
| | .. versionadded:: 0.9 |
| | If you select the ``'table'`` line numbers, the wrapping table will |
| | have a CSS class of this string plus ``'table'``, the default is |
| | accordingly ``'highlighttable'``. |
| | |
| | `cssstyles` |
| | Inline CSS styles for the wrapping ``<div>`` tag (default: ``''``). |
| | |
| | `prestyles` |
| | Inline CSS styles for the ``<pre>`` tag (default: ``''``). |
| | |
| | .. versionadded:: 0.11 |
| | |
| | `cssfile` |
| | If the `full` option is true and this option is given, it must be the |
| | name of an external file. If the filename does not include an absolute |
| | path, the file's path will be assumed to be relative to the main output |
| | file's path, if the latter can be found. The stylesheet is then written |
| | to this file instead of the HTML file. |
| | |
| | .. versionadded:: 0.6 |
| | |
| | `noclobber_cssfile` |
| | If `cssfile` is given and the specified file exists, the css file will |
| | not be overwritten. This allows the use of the `full` option in |
| | combination with a user specified css file. Default is ``False``. |
| | |
| | .. versionadded:: 1.1 |
| | |
| | `linenos` |
| | If set to ``'table'``, output line numbers as a table with two cells, |
| | one containing the line numbers, the other the whole code. This is |
| | copy-and-paste-friendly, but may cause alignment problems with some |
| | browsers or fonts. If set to ``'inline'``, the line numbers will be |
| | integrated in the ``<pre>`` tag that contains the code (that setting |
| | is *new in Pygments 0.8*). |
| | |
| | For compatibility with Pygments 0.7 and earlier, every true value |
| | except ``'inline'`` means the same as ``'table'`` (in particular, that |
| | means also ``True``). |
| | |
| | The default value is ``False``, which means no line numbers at all. |
| | |
| | **Note:** with the default ("table") line number mechanism, the line |
| | numbers and code can have different line heights in Internet Explorer |
| | unless you give the enclosing ``<pre>`` tags an explicit ``line-height`` |
| | CSS property (you get the default line spacing with ``line-height: |
| | 125%``). |
| | |
| | `hl_lines` |
| | Specify a list of lines to be highlighted. The line numbers are always |
| | relative to the input (i.e. the first line is line 1) and are |
| | independent of `linenostart`. |
| | |
| | .. versionadded:: 0.11 |
| | |
| | `linenostart` |
| | The line number for the first line (default: ``1``). |
| | |
| | `linenostep` |
| | If set to a number n > 1, only every nth line number is printed. |
| | |
| | `linenospecial` |
| | If set to a number n > 0, every nth line number is given the CSS |
| | class ``"special"`` (default: ``0``). |
| | |
| | `nobackground` |
| | If set to ``True``, the formatter won't output the background color |
| | for the wrapping element (this automatically defaults to ``False`` |
| | when there is no wrapping element [eg: no argument for the |
| | `get_syntax_defs` method given]) (default: ``False``). |
| | |
| | .. versionadded:: 0.6 |
| | |
| | `lineseparator` |
| | This string is output between lines of code. It defaults to ``"\n"``, |
| | which is enough to break a line inside ``<pre>`` tags, but you can |
| | e.g. set it to ``"<br>"`` to get HTML line breaks. |
| | |
| | .. versionadded:: 0.7 |
| | |
| | `lineanchors` |
| | If set to a nonempty string, e.g. ``foo``, the formatter will wrap each |
| | output line in an anchor tag with an ``id`` (and `name`) of ``foo-linenumber``. |
| | This allows easy linking to certain lines. |
| | |
| | .. versionadded:: 0.9 |
| | |
| | `linespans` |
| | If set to a nonempty string, e.g. ``foo``, the formatter will wrap each |
| | output line in a span tag with an ``id`` of ``foo-linenumber``. |
| | This allows easy access to lines via javascript. |
| | |
| | .. versionadded:: 1.6 |
| | |
| | `anchorlinenos` |
| | If set to `True`, will wrap line numbers in <a> tags. Used in |
| | combination with `linenos` and `lineanchors`. |
| | |
| | `tagsfile` |
| | If set to the path of a ctags file, wrap names in anchor tags that |
| | link to their definitions. `lineanchors` should be used, and the |
| | tags file should specify line numbers (see the `-n` option to ctags). |
| | The tags file is assumed to be encoded in UTF-8. |
| | |
| | .. versionadded:: 1.6 |
| | |
| | `tagurlformat` |
| | A string formatting pattern used to generate links to ctags definitions. |
| | Available variables are `%(path)s`, `%(fname)s` and `%(fext)s`. |
| | Defaults to an empty string, resulting in just `#prefix-number` links. |
| | |
| | .. versionadded:: 1.6 |
| | |
| | `filename` |
| | A string used to generate a filename when rendering ``<pre>`` blocks, |
| | for example if displaying source code. If `linenos` is set to |
| | ``'table'`` then the filename will be rendered in an initial row |
| | containing a single `<th>` which spans both columns. |
| | |
| | .. versionadded:: 2.1 |
| | |
| | `wrapcode` |
| | Wrap the code inside ``<pre>`` blocks using ``<code>``, as recommended |
| | by the HTML5 specification. |
| | |
| | .. versionadded:: 2.4 |
| | |
| | `debug_token_types` |
| | Add ``title`` attributes to all token ``<span>`` tags that show the |
| | name of the token. |
| | |
| | .. versionadded:: 2.10 |
| | |
| | |
| | **Subclassing the HTML formatter** |
| | |
| | .. versionadded:: 0.7 |
| | |
| | The HTML formatter is now built in a way that allows easy subclassing, thus |
| | customizing the output HTML code. The `format()` method calls |
| | `self._format_lines()` which returns a generator that yields tuples of ``(1, |
| | line)``, where the ``1`` indicates that the ``line`` is a line of the |
| | formatted source code. |
| | |
| | If the `nowrap` option is set, the generator is the iterated over and the |
| | resulting HTML is output. |
| | |
| | Otherwise, `format()` calls `self.wrap()`, which wraps the generator with |
| | other generators. These may add some HTML code to the one generated by |
| | `_format_lines()`, either by modifying the lines generated by the latter, |
| | then yielding them again with ``(1, line)``, and/or by yielding other HTML |
| | code before or after the lines, with ``(0, html)``. The distinction between |
| | source lines and other code makes it possible to wrap the generator multiple |
| | times. |
| | |
| | The default `wrap()` implementation adds a ``<div>`` and a ``<pre>`` tag. |
| | |
| | A custom `HtmlFormatter` subclass could look like this: |
| | |
| | .. sourcecode:: python |
| | |
| | class CodeHtmlFormatter(HtmlFormatter): |
| | |
| | def wrap(self, source, *, include_div): |
| | return self._wrap_code(source) |
| | |
| | def _wrap_code(self, source): |
| | yield 0, '<code>' |
| | for i, t in source: |
| | if i == 1: |
| | # it's a line of formatted code |
| | t += '<br>' |
| | yield i, t |
| | yield 0, '</code>' |
| | |
| | This results in wrapping the formatted lines with a ``<code>`` tag, where the |
| | source lines are broken using ``<br>`` tags. |
| | |
| | After calling `wrap()`, the `format()` method also adds the "line numbers" |
| | and/or "full document" wrappers if the respective options are set. Then, all |
| | HTML yielded by the wrapped generator is output. |
| | """ |
| |
|
| | name = 'HTML' |
| | aliases = ['html'] |
| | filenames = ['*.html', '*.htm'] |
| |
|
| | def __init__(self, **options): |
| | Formatter.__init__(self, **options) |
| | self.title = self._decodeifneeded(self.title) |
| | self.nowrap = get_bool_opt(options, 'nowrap', False) |
| | self.noclasses = get_bool_opt(options, 'noclasses', False) |
| | self.classprefix = options.get('classprefix', '') |
| | self.cssclass = self._decodeifneeded(options.get('cssclass', 'highlight')) |
| | self.cssstyles = self._decodeifneeded(options.get('cssstyles', '')) |
| | self.prestyles = self._decodeifneeded(options.get('prestyles', '')) |
| | self.cssfile = self._decodeifneeded(options.get('cssfile', '')) |
| | self.noclobber_cssfile = get_bool_opt(options, 'noclobber_cssfile', False) |
| | self.tagsfile = self._decodeifneeded(options.get('tagsfile', '')) |
| | self.tagurlformat = self._decodeifneeded(options.get('tagurlformat', '')) |
| | self.filename = self._decodeifneeded(options.get('filename', '')) |
| | self.wrapcode = get_bool_opt(options, 'wrapcode', False) |
| | self.span_element_openers = {} |
| | self.debug_token_types = get_bool_opt(options, 'debug_token_types', False) |
| |
|
| | if self.tagsfile: |
| | if not ctags: |
| | raise RuntimeError('The "ctags" package must to be installed ' |
| | 'to be able to use the "tagsfile" feature.') |
| | self._ctags = ctags.CTags(self.tagsfile) |
| |
|
| | linenos = options.get('linenos', False) |
| | if linenos == 'inline': |
| | self.linenos = 2 |
| | elif linenos: |
| | |
| | self.linenos = 1 |
| | else: |
| | self.linenos = 0 |
| | self.linenostart = abs(get_int_opt(options, 'linenostart', 1)) |
| | self.linenostep = abs(get_int_opt(options, 'linenostep', 1)) |
| | self.linenospecial = abs(get_int_opt(options, 'linenospecial', 0)) |
| | self.nobackground = get_bool_opt(options, 'nobackground', False) |
| | self.lineseparator = options.get('lineseparator', '\n') |
| | self.lineanchors = options.get('lineanchors', '') |
| | self.linespans = options.get('linespans', '') |
| | self.anchorlinenos = get_bool_opt(options, 'anchorlinenos', False) |
| | self.hl_lines = set() |
| | for lineno in get_list_opt(options, 'hl_lines', []): |
| | try: |
| | self.hl_lines.add(int(lineno)) |
| | except ValueError: |
| | pass |
| |
|
| | self._create_stylesheet() |
| |
|
| | def _get_css_class(self, ttype): |
| | """Return the css class of this token type prefixed with |
| | the classprefix option.""" |
| | ttypeclass = _get_ttype_class(ttype) |
| | if ttypeclass: |
| | return self.classprefix + ttypeclass |
| | return '' |
| |
|
| | def _get_css_classes(self, ttype): |
| | """Return the CSS classes of this token type prefixed with the classprefix option.""" |
| | cls = self._get_css_class(ttype) |
| | while ttype not in STANDARD_TYPES: |
| | ttype = ttype.parent |
| | cls = self._get_css_class(ttype) + ' ' + cls |
| | return cls or '' |
| |
|
| | def _get_css_inline_styles(self, ttype): |
| | """Return the inline CSS styles for this token type.""" |
| | cclass = self.ttype2class.get(ttype) |
| | while cclass is None: |
| | ttype = ttype.parent |
| | cclass = self.ttype2class.get(ttype) |
| | return cclass or '' |
| |
|
| | def _create_stylesheet(self): |
| | t2c = self.ttype2class = {Token: ''} |
| | c2s = self.class2style = {} |
| | for ttype, ndef in self.style: |
| | name = self._get_css_class(ttype) |
| | style = '' |
| | if ndef['color']: |
| | style += 'color: {}; '.format(webify(ndef['color'])) |
| | if ndef['bold']: |
| | style += 'font-weight: bold; ' |
| | if ndef['italic']: |
| | style += 'font-style: italic; ' |
| | if ndef['underline']: |
| | style += 'text-decoration: underline; ' |
| | if ndef['bgcolor']: |
| | style += 'background-color: {}; '.format(webify(ndef['bgcolor'])) |
| | if ndef['border']: |
| | style += 'border: 1px solid {}; '.format(webify(ndef['border'])) |
| | if style: |
| | t2c[ttype] = name |
| | |
| | |
| | c2s[name] = (style[:-2], ttype, len(ttype)) |
| |
|
| | def get_style_defs(self, arg=None): |
| | """ |
| | Return CSS style definitions for the classes produced by the current |
| | highlighting style. ``arg`` can be a string or list of selectors to |
| | insert before the token type classes. |
| | """ |
| | style_lines = [] |
| |
|
| | style_lines.extend(self.get_linenos_style_defs()) |
| | style_lines.extend(self.get_background_style_defs(arg)) |
| | style_lines.extend(self.get_token_style_defs(arg)) |
| |
|
| | return '\n'.join(style_lines) |
| |
|
| | def get_token_style_defs(self, arg=None): |
| | prefix = self.get_css_prefix(arg) |
| |
|
| | styles = [ |
| | (level, ttype, cls, style) |
| | for cls, (style, ttype, level) in self.class2style.items() |
| | if cls and style |
| | ] |
| | styles.sort() |
| |
|
| | lines = [ |
| | f'{prefix(cls)} {{ {style} }} /* {repr(ttype)[6:]} */' |
| | for (level, ttype, cls, style) in styles |
| | ] |
| |
|
| | return lines |
| |
|
| | def get_background_style_defs(self, arg=None): |
| | prefix = self.get_css_prefix(arg) |
| | bg_color = self.style.background_color |
| | hl_color = self.style.highlight_color |
| |
|
| | lines = [] |
| |
|
| | if arg and not self.nobackground and bg_color is not None: |
| | text_style = '' |
| | if Text in self.ttype2class: |
| | text_style = ' ' + self.class2style[self.ttype2class[Text]][0] |
| | lines.insert( |
| | 0, '{}{{ background: {};{} }}'.format( |
| | prefix(''), bg_color, text_style |
| | ) |
| | ) |
| | if hl_color is not None: |
| | lines.insert( |
| | 0, '{} {{ background-color: {} }}'.format(prefix('hll'), hl_color) |
| | ) |
| |
|
| | return lines |
| |
|
| | def get_linenos_style_defs(self): |
| | lines = [ |
| | f'pre {{ {self._pre_style} }}', |
| | f'td.linenos .normal {{ {self._linenos_style} }}', |
| | f'span.linenos {{ {self._linenos_style} }}', |
| | f'td.linenos .special {{ {self._linenos_special_style} }}', |
| | f'span.linenos.special {{ {self._linenos_special_style} }}', |
| | ] |
| |
|
| | return lines |
| |
|
| | def get_css_prefix(self, arg): |
| | if arg is None: |
| | arg = ('cssclass' in self.options and '.'+self.cssclass or '') |
| | if isinstance(arg, str): |
| | args = [arg] |
| | else: |
| | args = list(arg) |
| |
|
| | def prefix(cls): |
| | if cls: |
| | cls = '.' + cls |
| | tmp = [] |
| | for arg in args: |
| | tmp.append((arg and arg + ' ' or '') + cls) |
| | return ', '.join(tmp) |
| |
|
| | return prefix |
| |
|
| | @property |
| | def _pre_style(self): |
| | return 'line-height: 125%;' |
| |
|
| | @property |
| | def _linenos_style(self): |
| | color = self.style.line_number_color |
| | background_color = self.style.line_number_background_color |
| | return f'color: {color}; background-color: {background_color}; padding-left: 5px; padding-right: 5px;' |
| |
|
| | @property |
| | def _linenos_special_style(self): |
| | color = self.style.line_number_special_color |
| | background_color = self.style.line_number_special_background_color |
| | return f'color: {color}; background-color: {background_color}; padding-left: 5px; padding-right: 5px;' |
| |
|
| | def _decodeifneeded(self, value): |
| | if isinstance(value, bytes): |
| | if self.encoding: |
| | return value.decode(self.encoding) |
| | return value.decode() |
| | return value |
| |
|
| | def _wrap_full(self, inner, outfile): |
| | if self.cssfile: |
| | if os.path.isabs(self.cssfile): |
| | |
| | cssfilename = self.cssfile |
| | else: |
| | try: |
| | filename = outfile.name |
| | if not filename or filename[0] == '<': |
| | |
| | raise AttributeError |
| | cssfilename = os.path.join(os.path.dirname(filename), |
| | self.cssfile) |
| | except AttributeError: |
| | print('Note: Cannot determine output file name, ' |
| | 'using current directory as base for the CSS file name', |
| | file=sys.stderr) |
| | cssfilename = self.cssfile |
| | |
| | try: |
| | if not os.path.exists(cssfilename) or not self.noclobber_cssfile: |
| | with open(cssfilename, "w", encoding="utf-8") as cf: |
| | cf.write(CSSFILE_TEMPLATE % |
| | {'styledefs': self.get_style_defs('body')}) |
| | except OSError as err: |
| | err.strerror = 'Error writing CSS file: ' + err.strerror |
| | raise |
| |
|
| | yield 0, (DOC_HEADER_EXTERNALCSS % |
| | dict(title=self.title, |
| | cssfile=self.cssfile, |
| | encoding=self.encoding)) |
| | else: |
| | yield 0, (DOC_HEADER % |
| | dict(title=self.title, |
| | styledefs=self.get_style_defs('body'), |
| | encoding=self.encoding)) |
| |
|
| | yield from inner |
| | yield 0, DOC_FOOTER |
| |
|
| | def _wrap_tablelinenos(self, inner): |
| | dummyoutfile = StringIO() |
| | lncount = 0 |
| | for t, line in inner: |
| | if t: |
| | lncount += 1 |
| | dummyoutfile.write(line) |
| |
|
| | fl = self.linenostart |
| | mw = len(str(lncount + fl - 1)) |
| | sp = self.linenospecial |
| | st = self.linenostep |
| | anchor_name = self.lineanchors or self.linespans |
| | aln = self.anchorlinenos |
| | nocls = self.noclasses |
| |
|
| | lines = [] |
| |
|
| | for i in range(fl, fl+lncount): |
| | print_line = i % st == 0 |
| | special_line = sp and i % sp == 0 |
| |
|
| | if print_line: |
| | line = '%*d' % (mw, i) |
| | if aln: |
| | line = '<a href="#%s-%d">%s</a>' % (anchor_name, i, line) |
| | else: |
| | line = ' ' * mw |
| |
|
| | if nocls: |
| | if special_line: |
| | style = f' style="{self._linenos_special_style}"' |
| | else: |
| | style = f' style="{self._linenos_style}"' |
| | else: |
| | if special_line: |
| | style = ' class="special"' |
| | else: |
| | style = ' class="normal"' |
| |
|
| | if style: |
| | line = f'<span{style}>{line}</span>' |
| |
|
| | lines.append(line) |
| |
|
| | ls = '\n'.join(lines) |
| |
|
| | |
| | |
| | filename_tr = "" |
| | if self.filename: |
| | filename_tr = ( |
| | '<tr><th colspan="2" class="filename">' |
| | '<span class="filename">' + self.filename + '</span>' |
| | '</th></tr>') |
| |
|
| | |
| | |
| | |
| | yield 0, (f'<table class="{self.cssclass}table">' + filename_tr + |
| | '<tr><td class="linenos"><div class="linenodiv"><pre>' + |
| | ls + '</pre></div></td><td class="code">') |
| | yield 0, '<div>' |
| | yield 0, dummyoutfile.getvalue() |
| | yield 0, '</div>' |
| | yield 0, '</td></tr></table>' |
| |
|
| |
|
| | def _wrap_inlinelinenos(self, inner): |
| | |
| | inner_lines = list(inner) |
| | sp = self.linenospecial |
| | st = self.linenostep |
| | num = self.linenostart |
| | mw = len(str(len(inner_lines) + num - 1)) |
| | anchor_name = self.lineanchors or self.linespans |
| | aln = self.anchorlinenos |
| | nocls = self.noclasses |
| |
|
| | for _, inner_line in inner_lines: |
| | print_line = num % st == 0 |
| | special_line = sp and num % sp == 0 |
| |
|
| | if print_line: |
| | line = '%*d' % (mw, num) |
| | else: |
| | line = ' ' * mw |
| |
|
| | if nocls: |
| | if special_line: |
| | style = f' style="{self._linenos_special_style}"' |
| | else: |
| | style = f' style="{self._linenos_style}"' |
| | else: |
| | if special_line: |
| | style = ' class="linenos special"' |
| | else: |
| | style = ' class="linenos"' |
| |
|
| | if style: |
| | linenos = f'<span{style}>{line}</span>' |
| | else: |
| | linenos = line |
| |
|
| | if aln: |
| | yield 1, ('<a href="#%s-%d">%s</a>' % (anchor_name, num, linenos) + |
| | inner_line) |
| | else: |
| | yield 1, linenos + inner_line |
| | num += 1 |
| |
|
| | def _wrap_lineanchors(self, inner): |
| | s = self.lineanchors |
| | |
| | i = self.linenostart - 1 |
| | for t, line in inner: |
| | if t: |
| | i += 1 |
| | href = "" if self.linenos else ' href="#%s-%d"' % (s, i) |
| | yield 1, '<a id="%s-%d" name="%s-%d"%s></a>' % (s, i, s, i, href) + line |
| | else: |
| | yield 0, line |
| |
|
| | def _wrap_linespans(self, inner): |
| | s = self.linespans |
| | i = self.linenostart - 1 |
| | for t, line in inner: |
| | if t: |
| | i += 1 |
| | yield 1, '<span id="%s-%d">%s</span>' % (s, i, line) |
| | else: |
| | yield 0, line |
| |
|
| | def _wrap_div(self, inner): |
| | style = [] |
| | if (self.noclasses and not self.nobackground and |
| | self.style.background_color is not None): |
| | style.append(f'background: {self.style.background_color}') |
| | if self.cssstyles: |
| | style.append(self.cssstyles) |
| | style = '; '.join(style) |
| |
|
| | yield 0, ('<div' + (self.cssclass and f' class="{self.cssclass}"') + |
| | (style and (f' style="{style}"')) + '>') |
| | yield from inner |
| | yield 0, '</div>\n' |
| |
|
| | def _wrap_pre(self, inner): |
| | style = [] |
| | if self.prestyles: |
| | style.append(self.prestyles) |
| | if self.noclasses: |
| | style.append(self._pre_style) |
| | style = '; '.join(style) |
| |
|
| | if self.filename and self.linenos != 1: |
| | yield 0, ('<span class="filename">' + self.filename + '</span>') |
| |
|
| | |
| | |
| | yield 0, ('<pre' + (style and f' style="{style}"') + '><span></span>') |
| | yield from inner |
| | yield 0, '</pre>' |
| |
|
| | def _wrap_code(self, inner): |
| | yield 0, '<code>' |
| | yield from inner |
| | yield 0, '</code>' |
| |
|
| | @functools.lru_cache(maxsize=100) |
| | def _translate_parts(self, value): |
| | """HTML-escape a value and split it by newlines.""" |
| | return value.translate(_escape_html_table).split('\n') |
| |
|
| | def _format_lines(self, tokensource): |
| | """ |
| | Just format the tokens, without any wrapping tags. |
| | Yield individual lines. |
| | """ |
| | nocls = self.noclasses |
| | lsep = self.lineseparator |
| | tagsfile = self.tagsfile |
| |
|
| | lspan = '' |
| | line = [] |
| | for ttype, value in tokensource: |
| | try: |
| | cspan = self.span_element_openers[ttype] |
| | except KeyError: |
| | title = ' title="{}"'.format('.'.join(ttype)) if self.debug_token_types else '' |
| | if nocls: |
| | css_style = self._get_css_inline_styles(ttype) |
| | if css_style: |
| | css_style = self.class2style[css_style][0] |
| | cspan = f'<span style="{css_style}"{title}>' |
| | else: |
| | cspan = '' |
| | else: |
| | css_class = self._get_css_classes(ttype) |
| | if css_class: |
| | cspan = f'<span class="{css_class}"{title}>' |
| | else: |
| | cspan = '' |
| | self.span_element_openers[ttype] = cspan |
| |
|
| | parts = self._translate_parts(value) |
| |
|
| | if tagsfile and ttype in Token.Name: |
| | filename, linenumber = self._lookup_ctag(value) |
| | if linenumber: |
| | base, filename = os.path.split(filename) |
| | if base: |
| | base += '/' |
| | filename, extension = os.path.splitext(filename) |
| | url = self.tagurlformat % {'path': base, 'fname': filename, |
| | 'fext': extension} |
| | parts[0] = "<a href=\"%s#%s-%d\">%s" % \ |
| | (url, self.lineanchors, linenumber, parts[0]) |
| | parts[-1] = parts[-1] + "</a>" |
| |
|
| | |
| | for part in parts[:-1]: |
| | if line: |
| | |
| | |
| | if lspan != cspan and part: |
| | line.extend(((lspan and '</span>'), cspan, part, |
| | (cspan and '</span>'), lsep)) |
| | else: |
| | line.extend((part, (lspan and '</span>'), lsep)) |
| | yield 1, ''.join(line) |
| | line = [] |
| | elif part: |
| | yield 1, ''.join((cspan, part, (cspan and '</span>'), lsep)) |
| | else: |
| | yield 1, lsep |
| | |
| | if line and parts[-1]: |
| | if lspan != cspan: |
| | line.extend(((lspan and '</span>'), cspan, parts[-1])) |
| | lspan = cspan |
| | else: |
| | line.append(parts[-1]) |
| | elif parts[-1]: |
| | line = [cspan, parts[-1]] |
| | lspan = cspan |
| | |
| |
|
| | if line: |
| | line.extend(((lspan and '</span>'), lsep)) |
| | yield 1, ''.join(line) |
| |
|
| | def _lookup_ctag(self, token): |
| | entry = ctags.TagEntry() |
| | if self._ctags.find(entry, token.encode(), 0): |
| | return entry['file'].decode(), entry['lineNumber'] |
| | else: |
| | return None, None |
| |
|
| | def _highlight_lines(self, tokensource): |
| | """ |
| | Highlighted the lines specified in the `hl_lines` option by |
| | post-processing the token stream coming from `_format_lines`. |
| | """ |
| | hls = self.hl_lines |
| |
|
| | for i, (t, value) in enumerate(tokensource): |
| | if t != 1: |
| | yield t, value |
| | if i + 1 in hls: |
| | if self.noclasses: |
| | style = '' |
| | if self.style.highlight_color is not None: |
| | style = (f' style="background-color: {self.style.highlight_color}"') |
| | yield 1, f'<span{style}>{value}</span>' |
| | else: |
| | yield 1, f'<span class="hll">{value}</span>' |
| | else: |
| | yield 1, value |
| |
|
| | def wrap(self, source): |
| | """ |
| | Wrap the ``source``, which is a generator yielding |
| | individual lines, in custom generators. See docstring |
| | for `format`. Can be overridden. |
| | """ |
| |
|
| | output = source |
| | if self.wrapcode: |
| | output = self._wrap_code(output) |
| |
|
| | output = self._wrap_pre(output) |
| |
|
| | return output |
| |
|
| | def format_unencoded(self, tokensource, outfile): |
| | """ |
| | The formatting process uses several nested generators; which of |
| | them are used is determined by the user's options. |
| | |
| | Each generator should take at least one argument, ``inner``, |
| | and wrap the pieces of text generated by this. |
| | |
| | Always yield 2-tuples: (code, text). If "code" is 1, the text |
| | is part of the original tokensource being highlighted, if it's |
| | 0, the text is some piece of wrapping. This makes it possible to |
| | use several different wrappers that process the original source |
| | linewise, e.g. line number generators. |
| | """ |
| | source = self._format_lines(tokensource) |
| |
|
| | |
| | |
| | if not self.nowrap and self.linenos == 2: |
| | source = self._wrap_inlinelinenos(source) |
| |
|
| | if self.hl_lines: |
| | source = self._highlight_lines(source) |
| |
|
| | if not self.nowrap: |
| | if self.lineanchors: |
| | source = self._wrap_lineanchors(source) |
| | if self.linespans: |
| | source = self._wrap_linespans(source) |
| | source = self.wrap(source) |
| | if self.linenos == 1: |
| | source = self._wrap_tablelinenos(source) |
| | source = self._wrap_div(source) |
| | if self.full: |
| | source = self._wrap_full(source, outfile) |
| |
|
| | for t, piece in source: |
| | outfile.write(piece) |
| |
|
