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