def view(uid):
"""
View snippet.
"""
if not UID_RE.match(uid):
abort(404) # uid is bad
filename = snippet_file(uid)
if not os.path.isfile(filename):
app.logger.warning("File not found: '%s'" % filename)
abort(404) # file is not found
snippet = read_snippet(filename)
if snippet is None:
app.logger.error("Can't read file: '%s'" % filename)
abort(404) # file is bad (can't read it)
code = snippet.get('code', '')
snippet['uid'] = uid
user_id = request.cookies.get('user_id')
if user_id is not None and UID_RE.match(user_id):
if snippet.get('user_id') == hashlib.md5(user_id).hexdigest():
snippet['editable'] = True # user can edit snippet
if request.path.endswith('/raw/'): # this is raw snippet view
return Response(code, content_type='text/plain; charset=utf-8')
if request.path.endswith('/edit/'): # this is 'edit snippet' page
return render_template('edit.html', lexers=get_lexers(), **snippet)
# get lexer
lang = snippet.get('lang')
try:
if lang == '*auto*':
if code:
lexer = lexers.guess_lexer(code)
else:
lexer = lexers.TextLexer()
elif lang:
lexer = lexers.get_lexer_by_name(lang, stripall=True)
else:
lexer = lexers.TextLexer()
except lexers.ClassNotFound:
lexer = lexers.TextLexer()
snippet['lexer'] = lexer.name
# format code with lexer
formatter = HtmlFormatter(linenos=True)
snippet['html'] = highlight(code, lexer, formatter)
# this is 'view snippet' page
return render_template('view.html', **snippet)
def _get_lexer(codesyntax):
if codesyntax in ("cpp", "javascript"):
return lexers.JavascriptLexer()
elif codesyntax == "python":
return lexers.PythonLexer()
elif codesyntax == "json":
return lexers.JsonLexer()
elif codesyntax == "xml" or codesyntax == "html":
return lexers.HtmlLexer()
elif codesyntax == "yml" or codesyntax == "yaml":
return lexers.YamlLexer()
elif codesyntax == "css":
return lexers.CssLexer()
elif codesyntax == "sql":
return lexers.SqlLexer()
elif codesyntax == "bash" or codesyntax == "sh":
return lexers.BashLexer()
elif codesyntax == "go":
return lexers.GoLexer()
elif codesyntax == "diff":
return lexers.DiffLexer()
elif codesyntax == "emacslisp":
return lexers.EmacsLispLexer()
elif codesyntax == "lisp":
return lexers.CommonLispLexer()
elif codesyntax == "rust":
return lexers.RustLexer()
elif codesyntax == "jsx":
return BabylonLexer()
elif codesyntax:
raise NotImplementedError(codesyntax)
else:
return lexers.TextLexer()
def repl(m):
try:
lexer = lexers.get_lexer_by_name(m.group(1))
except ValueError:
lexer = lexers.TextLexer()
code = highlight(m.group(2), lexer, self.formatter)
return '\n\n<div class="code">%s</div>\n\n' % code
def entry_view(context, request):
paste = context.paste or u''
try:
if context.language:
l = lexers.get_lexer_by_name(context.language)
else:
l = lexers.guess_lexer(context.paste)
l.aliases[0]
except util.ClassNotFound:
# couldn't guess lexer
l = lexers.TextLexer()
formatted_paste = pygments.highlight(paste, l, formatter)
pastes = get_pastes(context, request, 10)
return dict(
author=context.author_name,
date=context.date.strftime('%x at %X'),
style_defs=style_defs,
lexer_name=l.name,
paste=formatted_paste,
pastes=pastes,
version=app_version,
message=None,
application_url=request.application_url,
)
def pygments_directive(self,
name,
arguments,
options,
content,
lineno,
content_offset,
block_text,
state,
state_machine,
pygments_formatter=None):
import pygments
from pygments import formatters, lexers
from docutils import nodes
if not pygments_formatter:
pygments_formatter = formatters.HtmlFormatter
try:
lexer = lexers.get_lexer_by_name(arguments[0])
except ValueError:
lexer = lexers.TextLexer()
parsed = pygments.highlight('\n'.join(content), lexer,
pygments_formatter())
return [nodes.raw('', parsed, format='html')]
def _format(self, file):
if self.attributes['arguments'] is None:
self.attributes['arguments'] = {}
linenos = False
if ('numbers' in self.attributes['arguments']
or 'numbers' in document.userdata['listings']):
linenos = 'inline'
# If this listing includes a label, inform plasTeX.
if 'label' in list(self.attributes['arguments'].keys()):
if hasattr(self.attributes['arguments']['label'], 'textContent'):
self.ownerDocument.context.label(
self.attributes['arguments']['label'].textContent)
else:
self.ownerDocument.context.label(
self.attributes['arguments']['label'])
# Check the textual LaTeX arguments and convert them to Python
# attributes.
if 'firstline' in list(self.attributes['arguments'].keys()):
first_line_number = int(self.attributes['arguments']['firstline'])
else:
first_line_number = 0
if 'lastline' in list(self.attributes['arguments'].keys()):
last_line_number = int(self.attributes['arguments']['lastline'])
else:
last_line_number = sys.maxsize
# Read the file, all the while respecting the "firstline" and
# "lastline" arguments given in the document.
self.plain_listing = ''
for current_line_number, line in enumerate(file):
current_line_number += 1
if (current_line_number >= first_line_number) and \
(current_line_number <= last_line_number):
# Remove single-line "listings" comments. Only
# comments started by "/*@" and ended by "@*/" are
# supported.
line = re.sub(r'/\*@[^@]*@\*/', '', line)
# Add the just-read line to the listing.
if hasattr(file, 'read'):
self.plain_listing += line
else:
self.plain_listing += '\n' + line
# Create a syntax highlighted XHTML version of the file using Pygments
if pygments is not None:
from pygments import lexers, formatters
try:
lexer = lexers.get_lexer_by_name(
self.ownerDocument.context.current_language.lower())
except Exception as msg:
lexer = lexers.TextLexer()
self.xhtml_listing = pygments.highlight(
self.plain_listing, lexer,
formatters.HtmlFormatter(linenos=linenos))
def _get_lexer(codesyntax):
if codesyntax == 'python':
return lexers.PythonLexer()
elif codesyntax == 'go':
return lexers.GoLexer()
elif codesyntax:
raise NotImplementedError(codesyntax)
else:
return lexers.TextLexer()
def blockcode(self, code, lang=''):
try:
if lang:
lexer = lexers.get_lexer_by_name(lang)
else:
lexer = lexers.guess_lexer(code)
except ClassNotFound:
lexer = lexers.TextLexer()
formatter = HighlightFormatter()
return pygments.highlight(code, lexer, formatter)
def get_lexer_for_file(filename):
ext = os.path.splitext(filename)[1]
try:
lexer = lexers.get_lexer_for_filename(filename)
except lexers.ClassNotFound:
if ext == '.kv':
lexer = KivyLexer()
else:
lexer = lexers.TextLexer()
# print('found {} for {}'.format(lexer, filename))
return lexer
def lexer(self):
"""
Returns pygment's lexer class. Would try to guess lexer taking file's
content, name and mimetype.
"""
try:
lexer = lexers.guess_lexer_for_filename(self.name, self.content)
except lexers.ClassNotFound:
lexer = lexers.TextLexer()
# returns first alias
return lexer
def _getLexerInstance(filename):
"""Get the lexer instance from the filename"""
if filename is None:
return lexers.TextLexer(stripnl=False, stripall=False)
# Fast lookup first
ext = os.path.splitext(filename)[1]
cls = EXTENSION_TO_LEXER.get(ext)
if cls is not None:
return cls(stripnl=False, stripall=False)
# Slow lookup for less common cases
try:
lexer = lexers.get_lexer_for_filename(filename,
stripnl=False,
stripall=False)
except util.ClassNotFound:
lexer = lexers.TextLexer(stripnl=False, stripall=False)
return lexer
def change_lexer(self, mimetype=None):
"""Change the lexer of this :py:class:`.Editor`.
The lexer is what takes care of recognizing the keywords, variable names, etc.
:param mimetype: The mimetype for which a lexer should be found. The lexer is \
changed to that found with this mimetype.
"""
if mimetype is not None:
try:
# If the mimetype is 'text/plain' and the extension
# of the file is '.kv', then a kivylexer should be used.
if mimetype == 'text/plain' and os.path.splitext(
self._name)[1] == '.kv':
self.lexer = KivyLexer()
else:
self.lexer = get_lexer_for_mimetype(mimetype)
except ClassNotFound as err:
print(err, 'Unsopported type {}'.format(mimetype), sep='\n')
self.lexer = lexers.TextLexer()
finally:
return self.lexer.name
elif self._name is not None:
# If the mimetype is 'text/plain' and the extension
# of the file is '.kv', then a kivylexer should be used.
if os.path.splitext(self._name)[1] == '.kv':
self.lexer = KivyLexer()
else:
self.lexer = lexers.TextLexer()
else:
self.lexer = lexers.TextLexer()
return self.lexer.name
def lexer(self):
"""
Returns pygment's lexer class. Would try to guess lexer taking file's
content, name and mimetype.
"""
from pygments import lexers
try:
lexer = lexers.guess_lexer_for_filename(self.name,
safe_str(self.content),
stripnl=False)
except lexers.ClassNotFound:
lexer = lexers.TextLexer(stripnl=False)
# returns first alias
return lexer
def get_lexer(self, code_string, lexer_prefix='#!'):
"""
Resolves the lexer name out of a code block.
"""
from pygments import lexers
from pygments.util import ClassNotFound
lexer_line = code_string.splitlines()[0]
if lexer_line.startswith(lexer_prefix):
lexer_name = lexer_line[len(lexer_prefix):].strip(' ')
code_string = '\n'.join(code_string.splitlines()[1:])
try:
lexer = lexers.get_lexer_by_name(lexer_name)
except ClassNotFound:
try:
lexer = lexers.guess_lexer(code_string)
except ClassNotFound:
lexer = lexers.TextLexer()
else:
try:
lexer = lexers.guess_lexer(code_string)
except ClassNotFound:
lexer = lexers.TextLexer()
return (code_string, lexer)
def repl(m):
language = m.group(1)
content = m.group(2)
if self.config.highlighter == 'pygments':
try:
lexer = lexers.get_lexer_by_name(language)
except ValueError:
lexer = lexers.TextLexer()
code = highlight(content, lexer, self.formatter)
return '\n\n<div class="%s">%s</div>\n\n' % (class_name, code)
elif self.config.highlighter == 'plain':
return '\n\n<pre><code class="%s">%s</code></pre>\n\n' \
% (language, content)
text = '{} is an invalid highlighter. Valid choices are: pygments, plain.'
raise ValueError(text.format(self.config.highlighter))
def repl(m):
language = m.group(1)
language = language[1:] if language[0] == ':' else language
if language in ['', 'none']:
language = 'text'
content = m.group(2)
if self.config.highlighter == 'pygments':
try:
lexer = lexers.get_lexer_by_name(language)
except ValueError:
# pylint: disable=no-member
lexer = lexers.TextLexer()
code = highlight(content, lexer, self.formatter)
return '\n\n<div class="%s">%s</div>\n\n' % (class_name, code)
elif self.config.highlighter == 'plain':
return '\n\n<pre><code class="%s">%s</code></pre>\n\n' \
% (language, content)
text = '{} is an invalid highlighter. Valid choices are: pygments, plain.'
raise ValueError(text.format(self.config.highlighter))
def colorize_blob(fname, s):
try:
lexer = lexers.guess_lexer_for_filename(fname, s, encoding='utf-8')
except lexers.ClassNotFound:
# Only try to guess lexers if the file starts with a shebang,
# otherwise it's likely a text file and guess_lexer() is prone to
# make mistakes with those.
lexer = lexers.TextLexer(encoding='utf-8')
if s.startswith('#!'):
try:
lexer = lexers.guess_lexer(s[:80], encoding='utf-8')
except lexers.ClassNotFound:
pass
formatter = HtmlFormatter(encoding='utf-8',
cssclass='source_code',
linenos='table',
anchorlinenos=True,
lineanchors='line')
return highlight(s, lexer, formatter)
def repl(m):
language = m.group('lang')
if language in ['', 'none']:
language = 'text'
hl_lines = m.group('lines')
content = m.group('content')
if self.config.highlighter == 'pygments':
formatter = self.formatter
if hl_lines:
formatter = self.get_formatter(hl_lines=hl_lines)
try:
lexer = lexers.get_lexer_by_name(language)
except ValueError:
# pylint: disable=no-member
lexer = lexers.TextLexer()
return u'\n{}\n'.format(highlight(content, lexer, formatter))
elif self.config.highlighter == 'plain':
text = u'\n\n<div class="{}"><pre><code class="{}">{}</code></pre></div>\n\n'
return text.format(self.config.class_name, language, content)
text = '{} is an invalid highlighter. Valid choices are: pygments, plain.'
raise ValueError(text.format(self.config.highlighter))
def pygments_lexer(self):
language = self.data.get('pygments_language')
lexer = None
if language is not None:
try:
lexer = lexers.get_lexer_by_name(language)
except ClassNotFound:
lexer = None
if lexer is None and self.gist_file_name is not None:
try:
lexer = lexers.find_lexer_class_for_filename(
self.gist_file_name, )
except ClassNotFound:
lexer = None
else:
lexer = lexer()
if lexer is None:
lexer = lexers.TextLexer()
return lexer