eric: comparison ThirdParty/Pygments/pygments/formatters/html.py

-:bf4d19a7cade
+:c2e9bf425554
 pygments.formatters.html
 ~~~~~~~~~~~~~~~~~~~~~~~~
 Formatter for HTML output.
-:copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 from __future__ import print_function
 ord('>'): u'&gt;',
 ord('"'): u'&quot;',
 ord("'"): u'&#39;',
 }
 def escape_html(text, table=_escape_html_table):
 """Escape &, <, > as well as single and double quotes for HTML."""
 return text.translate(table)
-def get_random_id():
-"""Return a random id for javascript fields."""
-from random import random
-from time import time
-try:
-from hashlib import sha1 as sha
-except ImportError:
-import sha
-sha = sha.new
-return sha('%s|%s' % (random(), time())).hexdigest()
 def _get_ttype_class(ttype):
 fname = STANDARD_TYPES.get(ttype)
 if fname:
 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
-`anchorlines` and run ctags with the `-n` option for this to work.  The
+`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
 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.
+.. versionadded:: 2.1
 **Subclassing the HTML formatter**
 .. versionadded:: 0.7
 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', ''))
 if self.tagsfile:
 if not ctags:
 raise RuntimeError('The "ctags" package must to be installed '
 'to be able to use the "tagsfile" feature.')
 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
 def _create_stylesheet(self):
 t2c = self.ttype2class = {Token: ''}
 c2s = self.class2style = {}
 for ttype, ndef in self.style:
 # pseudo files, e.g. name == '<fdopen>'
 raise AttributeError
 cssfilename = os.path.join(os.path.dirname(filename),
 self.cssfile)
 except AttributeError:
-print('Note: Cannot determine output file name, ' \
+print('Note: Cannot determine output file name, '
 'using current directory as base for the CSS file name',
 file=sys.stderr)
 cssfilename = self.cssfile
 # 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()
 except IOError as err:
 err.strerror = 'Error writing CSS file: ' + err.strerror
 raise
 yield 0, (DOC_HEADER_EXTERNALCSS %
-dict(title     = self.title,
+dict(title=self.title,
-cssfile   = self.cssfile,
+cssfile=self.cssfile,
-encoding  = self.encoding))
+encoding=self.encoding))
 else:
 yield 0, (DOC_HEADER %
-dict(title     = self.title,
+dict(title=self.title,
-styledefs = self.get_style_defs('body'),
+styledefs=self.get_style_defs('body'),
-encoding  = self.encoding))
+encoding=self.encoding))
 for t, line in inner:
 yield t, line
 yield 0, DOC_FOOTER
 mw = len(str(len(lines) + num - 1))
 if self.noclasses:
 if sp:
 for t, line in lines:
-if num%sp == 0:
+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
+style, mw, (num % st and ' ' or num)) + line
 num += 1
 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)
+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 % sp == 0 and ' special' or '', mw,
-(num%st and ' ' or num)) + line
+(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
+mw, (num % st and ' ' or num)) + line
 num += 1
 def _wrap_lineanchors(self, inner):
 s = self.lineanchors
-i = self.linenostart - 1 # subtract 1 since we have to increment i
+# subtract 1 since we have to increment i *before* yielding
-# *before* yielding
+i = self.linenostart - 1
 for t, line in inner:
 if t:
 i += 1
 yield 1, '<a name="%s-%d"></a>' % (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('background: %s' % (self.style.background_color,))
 if self.cssstyles:
 style.append(self.cssstyles)
 style = '; '.join(style)
-yield 0, ('<div' + (self.cssclass and ' class="%s"' % self.cssclass)
+yield 0, ('<div' + (self.cssclass and ' class="%s"' % self.cssclass) +
-+ (style and (' style="%s"' % style)) + '>')
+(style and (' style="%s"' % style)) + '>')
 for tup in inner:
 yield tup
 yield 0, '</div>\n'
 def _wrap_pre(self, inner):
 style.append(self.prestyles)
 if self.noclasses:
 style.append('line-height: 125%')
 style = '; '.join(style)
+if self.filename:
+yield 0, ('<span class="filename">' + self.filename + '</span>')
 yield 0, ('<pre' + (style and ' style="%s"' % style) + '>')
 for tup in inner:
 yield tup
 yield 0, '</pre>'
 c2s = self.class2style
 escape_table = _escape_html_table
 tagsfile = self.tagsfile
 lspan = ''
-line = ''
+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_class(ttype)
+cls = self._get_css_classes(ttype)
 cspan = cls and '<span class="%s">' % cls or ''
 parts = value.translate(escape_table).split('\n')
 if tagsfile and ttype in Token.Name:
 # for all but the last line
 for part in parts[:-1]:
 if line:
 if lspan != cspan:
-line += (lspan and '</span>') + cspan + part + \
+line.extend(((lspan and '</span>'), cspan, part,
-(cspan and '</span>') + lsep
+(cspan and '</span>'), lsep))
-else: # both are the same
+else:  # both are the same
-line += part + (lspan and '</span>') + lsep
+line.extend((part, (lspan and '</span>'), lsep))
-yield 1, line
+yield 1, ''.join(line)
-line = ''
+line = []
 elif part:
-yield 1, cspan + part + (cspan and '</span>') + lsep
+yield 1, ''.join((cspan, part, (cspan and '</span>'), lsep))
 else:
 yield 1, lsep
 # for the last line
 if line and parts[-1]:
 if lspan != cspan:
-line += (lspan and '</span>') + cspan + parts[-1]
+line.extend(((lspan and '</span>'), cspan, parts[-1]))
 lspan = cspan
 else:
-line += parts[-1]
+line.append(parts[-1])
 elif parts[-1]:
-line = cspan + parts[-1]
+line = [cspan, parts[-1]]
 lspan = cspan
 # else we neither have to open a new span nor set lspan
 if line:
-yield 1, line + (lspan and '</span>') + lsep
+line.extend(((lspan and '</span>'), lsep))
+yield 1, ''.join(line)
 def _lookup_ctag(self, token):
 entry = ctags.TagEntry()
 if self._ctags.find(entry, token, 0):
 return entry['file'], entry['lineNumber']
 hls = self.hl_lines
 for i, (t, value) in enumerate(tokensource):
 if t != 1:
 yield t, value
-if i + 1 in hls: # i + 1 because Python indexes start at 0
+if i + 1 in hls:  # i + 1 because Python indexes start at 0
 if self.noclasses:
 style = ''
 if self.style.highlight_color is not None:
 style = (' style="background-color: %s"' %
 (self.style.highlight_color,))

Mercurial Repositories > eric / file comparison

comparison: ThirdParty/Pygments/pygments/formatters/html.py

ThirdParty/Pygments/pygments/formatters/html.py