pygments.rb 1.1.0 → 2.0.0.rc2

data/vendor/pygments-main/pygments/formatter.py

@@ -5,25 +5,25 @@
 
     Base formatter class.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import codecs
 
-from pygments.util import get_bool_opt, string_types
+from pygments.util import get_bool_opt
 from pygments.styles import get_style_by_name
 
 __all__ = ['Formatter']
 
 
 def _lookup_style(style):
-    if isinstance(style, string_types):
+    if isinstance(style, str):
         return get_style_by_name(style)
     return style
 
 
-class Formatter(object):
+class Formatter:
     """
     Converts a token stream to text.
 

data/vendor/pygments-main/pygments/formatters/__init__.py

@@ -5,7 +5,7 @@
 
     Pygments formatters.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -17,10 +17,10 @@ from os.path import basename
 
 from pygments.formatters._mapping import FORMATTERS
 from pygments.plugin import find_plugin_formatters
-from pygments.util import ClassNotFound, itervalues
+from pygments.util import ClassNotFound
 
 __all__ = ['get_formatter_by_name', 'get_formatter_for_filename',
-           'get_all_formatters'] + list(FORMATTERS)
+           'get_all_formatters', 'load_formatter_from_file'] + list(FORMATTERS)
 
 _formatter_cache = {}  # classes by name
 _pattern_cache = {}
@@ -45,7 +45,7 @@ def _load_formatters(module_name):
 def get_all_formatters():
     """Return a generator for all formatter classes."""
     # NB: this returns formatter classes, not info like get_all_lexers().
-    for info in itervalues(FORMATTERS):
+    for info in FORMATTERS.values():
         if info[1] not in _formatter_cache:
             _load_formatters(info[0])
         yield _formatter_cache[info[1]]
@@ -58,7 +58,7 @@ def find_formatter_class(alias):
 
     Returns None if not found.
     """
-    for module_name, name, aliases, _, _ in itervalues(FORMATTERS):
+    for module_name, name, aliases, _, _ in FORMATTERS.values():
         if alias in aliases:
             if name not in _formatter_cache:
                 _load_formatters(module_name)
@@ -79,13 +79,49 @@ def get_formatter_by_name(_alias, **options):
     return cls(**options)
 
 
+def load_formatter_from_file(filename, formattername="CustomFormatter",
+                             **options):
+    """Load a formatter from a file.
+
+    This method expects a file located relative to the current working
+    directory, which contains a class named CustomFormatter. By default,
+    it expects the Formatter to be named CustomFormatter; you can specify
+    your own class name as the second argument to this function.
+
+    Users should be very careful with the input, because this method
+    is equivalent to running eval on the input file.
+
+    Raises ClassNotFound if there are any problems importing the Formatter.
+
+    .. versionadded:: 2.2
+    """
+    try:
+        # This empty dict will contain the namespace for the exec'd file
+        custom_namespace = {}
+        with open(filename, 'rb') as f:
+            exec(f.read(), custom_namespace)
+        # Retrieve the class `formattername` from that namespace
+        if formattername not in custom_namespace:
+            raise ClassNotFound('no valid %s class found in %s' %
+                                (formattername, filename))
+        formatter_class = custom_namespace[formattername]
+        # And finally instantiate it with the options
+        return formatter_class(**options)
+    except IOError as err:
+        raise ClassNotFound('cannot read %s: %s' % (filename, err))
+    except ClassNotFound:
+        raise
+    except Exception as err:
+        raise ClassNotFound('error when loading custom formatter: %s' % err)
+
+
 def get_formatter_for_filename(fn, **options):
     """Lookup and instantiate a formatter by filename pattern.
 
     Raises ClassNotFound if not found.
     """
     fn = basename(fn)
-    for modname, name, _, filenames, _ in itervalues(FORMATTERS):
+    for modname, name, _, filenames, _ in FORMATTERS.values():
         for filename in filenames:
             if _fn_matches(fn, filename):
                 if name not in _formatter_cache:

data/vendor/pygments-main/pygments/formatters/_mapping.py

@@ -9,12 +9,10 @@
 
     Do not alter the FORMATTERS dictionary by hand.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-from __future__ import print_function
-
 FORMATTERS = {
     'BBCodeFormatter': ('pygments.formatters.bbcode', 'BBCode', ('bbcode', 'bb'), (), 'Format tokens with BBcodes. These formatting codes are used by many bulletin boards, so you can highlight your sourcecode with pygments before posting it there.'),
     'BmpImageFormatter': ('pygments.formatters.img', 'img_bmp', ('bmp', 'bitmap'), ('*.bmp',), 'Create a bitmap image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),

data/vendor/pygments-main/pygments/formatters/bbcode.py

@@ -5,7 +5,7 @@
 
     BBcode formatter.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

data/vendor/pygments-main/pygments/formatters/html.py

@@ -5,20 +5,19 @@
 
     Formatter for HTML output.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-from __future__ import print_function
-
+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, \
-    StringIO, string_types, iteritems
+from pygments.util import get_bool_opt, get_int_opt, get_list_opt
 
 try:
     import ctags
@@ -29,11 +28,11 @@ __all__ = ['HtmlFormatter']
 
 
 _escape_html_table = {
-    ord('&'): u'&',
-    ord('<'): u'&lt;',
-    ord('>'): u'&gt;',
-    ord('"'): u'&quot;',
-    ord("'"): u'&#39;',
+    ord('&'): '&amp;',
+    ord('<'): '&lt;',
+    ord('>'): '&gt;',
+    ord('"'): '&quot;',
+    ord("'"): '&#39;',
 }
 
 
@@ -42,6 +41,13 @@ def escape_html(text, table=_escape_html_table):
     return text.translate(table)
 
 
+def webify(color):
+    if color.startswith('calc') or color.startswith('var'):
+        return color
+    else:
+        return '#' + color
+
+
 def _get_ttype_class(ttype):
     fname = STANDARD_TYPES.get(ttype)
     if fname:
@@ -55,16 +61,22 @@ def _get_ttype_class(ttype):
 
 
 CSSFILE_TEMPLATE = '''\
-td.linenos { background-color: #f0f0f0; padding-right: 10px; }
-span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }
-pre { line-height: 125%%; }
+/*
+generated by Pygments <https://pygments.org/>
+Copyright 2006-2020 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-2020 by the Pygments team.
+Licensed under the BSD license, see LICENSE for details.
+-->
 <html>
 <head>
   <title>%(title)s</title>
@@ -194,9 +206,10 @@ class HtmlFormatter(Formatter):
         `cssfile` exists.
 
     `noclasses`
-        If set to true, token ``<span>`` tags 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``).
+        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
@@ -322,11 +335,17 @@ class HtmlFormatter(Formatter):
         .. versionadded:: 1.6
 
     `filename`
-        A string used to generate a filename when rendering <pre> blocks,
+        A string used to generate a filename when rendering ``<pre>`` blocks,
         for example if displaying source code.
 
         .. versionadded:: 2.1
 
+    `wrapcode`
+        Wrap the code inside ``<pre>`` blocks using ``<code>``, as recommended
+        by the HTML5 specification.
+
+        .. versionadded:: 2.4
+
 
     **Subclassing the HTML formatter**
 
@@ -395,6 +414,8 @@ class HtmlFormatter(Formatter):
         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 = {}
 
         if self.tagsfile:
             if not ctags:
@@ -417,7 +438,7 @@ class HtmlFormatter(Formatter):
         self.lineseparator = options.get('lineseparator', '\n')
         self.lineanchors = options.get('lineanchors', '')
         self.linespans = options.get('linespans', '')
-        self.anchorlinenos = options.get('anchorlinenos', False)
+        self.anchorlinenos = get_bool_opt(options, 'anchorlinenos', False)
         self.hl_lines = set()
         for lineno in get_list_opt(options, 'hl_lines', []):
             try:
@@ -436,13 +457,20 @@ class HtmlFormatter(Formatter):
         return ''
 
     def _get_css_classes(self, ttype):
-        """Return the css classes of this token type prefixed with
-        the classprefix option."""
+        """Generate the opening <span> tag for a given token type using CSS classes."""
         cls = self._get_css_class(ttype)
         while ttype not in STANDARD_TYPES:
             ttype = ttype.parent
             cls = self._get_css_class(ttype) + ' ' + cls
-        return cls
+        return cls and '<span class="%s">' % cls or ''
+
+    def _get_css_inline_styles(self, ttype):
+        """Generate the opening <span> tag for a given token type using inline CSS styles."""
+        cclass = self.ttype2class.get(ttype)
+        while cclass is None:
+            ttype = ttype.parent
+            cclass = self.ttype2class.get(ttype)
+        return cclass and '<span style="%s">' % self.class2style[cclass][0] or ''
 
     def _create_stylesheet(self):
         t2c = self.ttype2class = {Token: ''}
@@ -451,7 +479,7 @@ class HtmlFormatter(Formatter):
             name = self._get_css_class(ttype)
             style = ''
             if ndef['color']:
-                style += 'color: #%s; ' % ndef['color']
+                style += 'color: %s; ' % webify(ndef['color'])
             if ndef['bold']:
                 style += 'font-weight: bold; '
             if ndef['italic']:
@@ -459,9 +487,9 @@ class HtmlFormatter(Formatter):
             if ndef['underline']:
                 style += 'text-decoration: underline; '
             if ndef['bgcolor']:
-                style += 'background-color: #%s; ' % ndef['bgcolor']
+                style += 'background-color: %s; ' % webify(ndef['bgcolor'])
             if ndef['border']:
-                style += 'border: 1px solid #%s; ' % ndef['border']
+                style += 'border: 1px solid %s; ' % webify(ndef['border'])
             if style:
                 t2c[ttype] = name
                 # save len(ttype) to enable ordering the styles by
@@ -474,9 +502,69 @@ class HtmlFormatter(Formatter):
         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 = [
+            '%s { %s } /* %s */' % (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, '%s{ background: %s;%s }' % (
+                    prefix(''), bg_color, text_style
+                )
+            )
+        if hl_color is not None:
+            lines.insert(
+                0, '%s { background-color: %s }' % (prefix('hll'), hl_color)
+            )
+
+        return lines
+
+    def get_linenos_style_defs(self):
+        lines = [
+            'pre { %s }' % self._pre_style,
+            'td.linenos pre { %s }' % self._linenos_style,
+            'span.linenos { %s }' % self._linenos_style,
+            'td.linenos pre.special { %s }' % self._linenos_special_style,
+            'span.linenos.special { %s }' % 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, string_types):
+        if isinstance(arg, str):
             args = [arg]
         else:
             args = list(arg)
@@ -489,23 +577,25 @@ class HtmlFormatter(Formatter):
                 tmp.append((arg and arg + ' ' or '') + cls)
             return ', '.join(tmp)
 
-        styles = [(level, ttype, cls, style)
-                  for cls, (style, ttype, level) in iteritems(self.class2style)
-                  if cls and style]
-        styles.sort()
-        lines = ['%s { %s } /* %s */' % (prefix(cls), style, repr(ttype)[6:])
-                 for (level, ttype, cls, style) in styles]
-        if arg and not self.nobackground and \
-           self.style.background_color is not None:
-            text_style = ''
-            if Text in self.ttype2class:
-                text_style = ' ' + self.class2style[self.ttype2class[Text]][0]
-            lines.insert(0, '%s { background: %s;%s }' %
-                         (prefix(''), self.style.background_color, text_style))
-        if self.style.highlight_color is not None:
-            lines.insert(0, '%s.hll { background-color: %s }' %
-                         (prefix(''), self.style.highlight_color))
-        return '\n'.join(lines)
+        return prefix
+
+    @property
+    def _pre_style(self):
+        return 'line-height: 125%;'
+
+    @property
+    def _linenos_style(self):
+        return 'color: %s; background-color: %s; padding-left: 5px; padding-right: 5px;' % (
+            self.style.line_number_color,
+            self.style.line_number_background_color
+        )
+
+    @property
+    def _linenos_special_style(self):
+        return 'color: %s; background-color: %s; padding-left: 5px; padding-right: 5px;' % (
+            self.style.line_number_special_color,
+            self.style.line_number_special_background_color
+        )
 
     def _decodeifneeded(self, value):
         if isinstance(value, bytes):
@@ -535,10 +625,9 @@ class HtmlFormatter(Formatter):
             # write CSS file only if noclobber_cssfile isn't given as an option.
             try:
                 if not os.path.exists(cssfilename) or not self.noclobber_cssfile:
-                    cf = open(cssfilename, "w")
-                    cf.write(CSSFILE_TEMPLATE %
-                             {'styledefs': self.get_style_defs('body')})
-                    cf.close()
+                    with open(cssfilename, "w") as cf:
+                        cf.write(CSSFILE_TEMPLATE %
+                                 {'styledefs': self.get_style_defs('body')})
             except IOError as err:
                 err.strerror = 'Error writing CSS file: ' + err.strerror
                 raise
@@ -553,8 +642,7 @@ class HtmlFormatter(Formatter):
                            styledefs=self.get_style_defs('body'),
                            encoding=self.encoding))
 
-        for t, line in inner:
-            yield t, line
+        yield from inner
         yield 0, DOC_FOOTER
 
     def _wrap_tablelinenos(self, inner):
@@ -572,88 +660,83 @@ class HtmlFormatter(Formatter):
         la = self.lineanchors
         aln = self.anchorlinenos
         nocls = self.noclasses
-        if sp:
-            lines = []
-
-            for i in range(fl, fl+lncount):
-                if i % st == 0:
-                    if i % sp == 0:
-                        if aln:
-                            lines.append('<a href="#%s-%d" class="special">%*d</a>' %
-                                         (la, i, mw, i))
-                        else:
-                            lines.append('<span class="special">%*d</span>' % (mw, i))
-                    else:
-                        if aln:
-                            lines.append('<a href="#%s-%d">%*d</a>' % (la, i, mw, i))
-                        else:
-                            lines.append('%*d' % (mw, i))
+
+        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>' % (la, i, line)
+            else:
+                line = ' ' * mw
+
+            if nocls:
+                if special_line:
+                    style = ' style="%s"' % self._linenos_special_style
                 else:
-                    lines.append('')
-            ls = '\n'.join(lines)
-        else:
-            lines = []
-            for i in range(fl, fl+lncount):
-                if i % st == 0:
-                    if aln:
-                        lines.append('<a href="#%s-%d">%*d</a>' % (la, i, mw, i))
-                    else:
-                        lines.append('%*d' % (mw, i))
+                    style = ' style="%s"' % self._linenos_style
+            else:
+                if special_line:
+                    style = ' class="special"'
                 else:
-                    lines.append('')
-            ls = '\n'.join(lines)
+                    style = ''
+
+            if style:
+                line = '<span%s>%s</span>' % (style, line)
+
+            lines.append(line)
+
+        ls = '\n'.join(lines)
 
         # in case you wonder about the seemingly redundant <div> here: since the
         # content in the other cell also is wrapped in a div, some browsers in
         # some configurations seem to mess up the formatting...
-        if nocls:
-            yield 0, ('<table class="%stable">' % self.cssclass +
-                      '<tr><td><div class="linenodiv" '
-                      'style="background-color: #f0f0f0; padding-right: 10px">'
-                      '<pre style="line-height: 125%">' +
-                      ls + '</pre></div></td><td class="code">')
-        else:
-            yield 0, ('<table class="%stable">' % self.cssclass +
-                      '<tr><td class="linenos"><div class="linenodiv"><pre>' +
-                      ls + '</pre></div></td><td class="code">')
+        yield 0, (
+            '<table class="%stable">' % self.cssclass +
+            '<tr><td class="linenos"><div class="linenodiv"><pre>' +
+            ls + '</pre></div></td><td class="code">'
+        )
         yield 0, dummyoutfile.getvalue()
         yield 0, '</td></tr></table>'
 
     def _wrap_inlinelinenos(self, inner):
         # need a list of lines since we need the width of a single number :(
-        lines = list(inner)
+        inner_lines = list(inner)
         sp = self.linenospecial
         st = self.linenostep
         num = self.linenostart
-        mw = len(str(len(lines) + num - 1))
+        mw = len(str(len(inner_lines) + num - 1))
+        nocls = self.noclasses
 
-        if self.noclasses:
-            if sp:
-                for t, line in lines:
-                    if num % sp == 0:
-                        style = 'background-color: #ffffc0; padding: 0 5px 0 5px'
-                    else:
-                        style = 'background-color: #f0f0f0; padding: 0 5px 0 5px'
-                    yield 1, '<span style="%s">%*s </span>' % (
-                        style, mw, (num % st and ' ' or num)) + line
-                    num += 1
+        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:
-                for t, line in lines:
-                    yield 1, ('<span style="background-color: #f0f0f0; '
-                              'padding: 0 5px 0 5px">%*s </span>' % (
-                                  mw, (num % st and ' ' or num)) + line)
-                    num += 1
-        elif sp:
-            for t, line in lines:
-                yield 1, '<span class="lineno%s">%*s </span>' % (
-                    num % sp == 0 and ' special' or '', mw,
-                    (num % st and ' ' or num)) + line
-                num += 1
-        else:
-            for t, line in lines:
-                yield 1, '<span class="lineno">%*s </span>' % (
-                    mw, (num % st and ' ' or num)) + line
-                num += 1
+                line = ' ' * mw
+
+            if nocls:
+                if special_line:
+                    style = ' style="%s"' % self._linenos_special_style
+                else:
+                    style = ' style="%s"' % self._linenos_style
+            else:
+                if special_line:
+                    style = ' class="linenos special"'
+                else:
+                    style = ' class="linenos"'
+
+            if style:
+                yield 1, '<span%s>%s</span>' % (style, line) + inner_line
+            else:
+                yield 1, line +  inner_line
+            num += 1
 
     def _wrap_lineanchors(self, inner):
         s = self.lineanchors
@@ -687,8 +770,7 @@ class HtmlFormatter(Formatter):
 
         yield 0, ('<div' + (self.cssclass and ' class="%s"' % self.cssclass) +
                   (style and (' style="%s"' % style)) + '>')
-        for tup in inner:
-            yield tup
+        yield from inner
         yield 0, '</div>\n'
 
     def _wrap_pre(self, inner):
@@ -696,7 +778,7 @@ class HtmlFormatter(Formatter):
         if self.prestyles:
             style.append(self.prestyles)
         if self.noclasses:
-            style.append('line-height: 125%')
+            style.append(self._pre_style)
         style = '; '.join(style)
 
         if self.filename:
@@ -705,10 +787,19 @@ class HtmlFormatter(Formatter):
         # the empty span here is to keep leading empty lines from being
         # ignored by HTML parsers
         yield 0, ('<pre' + (style and ' style="%s"' % style) + '><span></span>')
-        for tup in inner:
-            yield tup
+        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.
@@ -716,26 +807,20 @@ class HtmlFormatter(Formatter):
         """
         nocls = self.noclasses
         lsep = self.lineseparator
-        # for <span style=""> lookup only
-        getcls = self.ttype2class.get
-        c2s = self.class2style
-        escape_table = _escape_html_table
         tagsfile = self.tagsfile
 
         lspan = ''
         line = []
         for ttype, value in tokensource:
-            if nocls:
-                cclass = getcls(ttype)
-                while cclass is None:
-                    ttype = ttype.parent
-                    cclass = getcls(ttype)
-                cspan = cclass and '<span style="%s">' % c2s[cclass][0] or ''
-            else:
-                cls = self._get_css_classes(ttype)
-                cspan = cls and '<span class="%s">' % cls or ''
+            try:
+                cspan = self.span_element_openers[ttype]
+            except KeyError:
+                if nocls:
+                    cspan = self.span_element_openers[ttype] = self._get_css_inline_styles(ttype)
+                else:
+                    cspan = self.span_element_openers[ttype] = self._get_css_classes(ttype)
 
-            parts = value.translate(escape_table).split('\n')
+            parts = self._translate_parts(value)
 
             if tagsfile and ttype in Token.Name:
                 filename, linenumber = self._lookup_ctag(value)
@@ -815,7 +900,10 @@ class HtmlFormatter(Formatter):
         individual lines, in custom generators. See docstring
         for `format`. Can be overridden.
         """
-        return self._wrap_div(self._wrap_pre(source))
+        if self.wrapcode:
+            return self._wrap_div(self._wrap_pre(self._wrap_code(source)))
+        else:
+            return self._wrap_div(self._wrap_pre(source))
 
     def format_unencoded(self, tokensource, outfile):
         """