def block_code(text, lang, inlinestyles=False, linenos=False):
'''
markdown代码高亮
:param text:
:param lang:
:param inlinestyles:
:param linenos:
:return:
'''
if not lang:
text = text.strip()
return u'<pre><code>%s</code></pre>\n' % mistune.escape(text)
try:
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter(
noclasses=inlinestyles, linenos=linenos
)
code = highlight(text, lexer, formatter)
if linenos:
return '<div class="highlight">%s</div>\n' % code
return code
except BaseException:
return '<pre class="%s"><code>%s</code></pre>\n' % (
lang, mistune.escape(text)
)
def block_code(self, code, lang=None):
if lang and lang != 'cmd' and lang != 'yml' and lang != 'conf' and lang != 'sbtshell' and lang != 'commandline' and lang != 'shell script':
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
return highlight(code, lexer, formatter)
return '<pre><code class="language-plaintext">' + mistune.escape(
code) + '</code></pre>'
def block_code(self, code, language=None):
if language:
lexer = get_lexer_by_name(language, stripall=True)
formatter = pygments_html.HtmlFormatter()
highlighted = highlight(code, lexer, formatter)
return highlighted
return '<pre><code>' + mistune.escape(code) + '</code></pre>'
def block_code(self, code, lang):
if not lang:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
return highlight(code, lexer, formatter)
def render_code(code: str, lang: str) -> str:
return highlight(
code=code,
lexer=get_lexer_by_name(lang, stripall=True),
formatter=html.HtmlFormatter(),
)
def block_code(self, code, language=None):
if not language:
return "\n<pre><code>{}</code></pre>\n".format(
mistune.escape(code))
lexer = get_lexer_by_name(language, stripall=True)
formatter = html.HtmlFormatter()
return highlight(code, lexer, formatter)
def block_code(self, code, lang):
if not lang:
return '\n<pre style="background:#d7d9dd;"><code>%s</code></pre>\n' % \
mistune.escape(code)
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter(linenos=True, cssclass="source")
return "<style>" + formatter.get_style_defs() + "</style>" + highlight(
code, lexer, formatter)
def block_code(self, code, lang=None):
if not lang:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
#print("BLOCK_CODE:\nCODE:%s\nLANG: %s\n======" % (code, lang))
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
return highlight(code, lexer, formatter)
def block_code(self, code, lang):
if not lang:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
soup = BS(highlight(code, lexer, formatter), 'html.parser')
soup.pre['class'] = 'highlight'
return str(soup)
def block_code(self, code, lang):
if not lang:
lexer = guess_lexer(code, stripall=True)
else:
try:
lexer = get_lexer_by_name(lang, stripall=True)
except ClassNotFound as e:
lexer = guess_lexer(code, stripall=True)
formatter = html.HtmlFormatter(linenos=True)
return highlight(code, lexer, formatter)
def block_code(self, code, lang):
if lang == 'math':
return '\n%s\n' % mistune.escape(code)
if not lang:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter(linenos='table')
# other option for formatter: http://pygments.org/docs/formatters/
return highlight(code, lexer, formatter)
def block_code(self, code, lang):
if not lang:
lang = 'bash'
try:
lexer = get_lexer_by_name(lang, stripall=True)
except ClassNotFound as e:
print('lang {} not found from lexer'.format(lang))
return '\n<pre><code>%s</code></pre>\n' % mistune.escape(code)
formatter = html.HtmlFormatter(cssclass='codehilite')
return highlight(code, lexer, formatter)
def block_code(self, code, lang):
if not lang:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code.strip())
try:
lexer = get_lexer_by_name(lang, stripall=True)
except ClassNotFound:
return '\n<pre><code>%s\n%s</code></pre>\n' % \
(mistune.escape(lang.strip()), mistune.escape(code.strip()))
formatter = html.HtmlFormatter(classprefix=".highlight ")
return highlight(code, lexer, formatter)
def block_code(self, code, lang_desc):
if not lang_desc:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
lang_split = lang_desc.split(":")
lang = lang_split[0]
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter(linenos=True,
style=current_app.config.get(
"HIGHLIGHT_STYLE", "default"))
return highlight(code, lexer, formatter)
def block_code(self, code, lang=None):
if not lang:
# language type is not specified, use default method.
return super(CodeContentRenderer, self).block_code(code, lang)
try:
# try to get lexer
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter(style='fruity')
return highlight(code, lexer, formatter)
except ClassNotFound:
return super(CodeContentRenderer, self).block_code(code, lang)
def block_code(self, code, lang):
if not lang:
return super().block_code(code, lang)
if lang.lower() == 'math':
return "<p>$$ {} $$</p>".format(mistune.escape(code))
try:
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
return '\n<code>%s</code>\n' % highlight(code, lexer, formatter)
except pygments.util.ClassNotFound as e:
return super().block_code(code, lang)
def block_code(self, code, lang=None):
if lang:
try:
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
return highlight(code, lexer, formatter)
except:
return self.fallback(code, lang)
else:
return self.fallback(code, lang)
def block_code(self,
code: str,
lang=None):
if lang:
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter(linenos=True,
full=True,
style=config.code_style)
return highlight(code, lexer, formatter)
return "<pre><code>" + escape(code) + "</code></pre>"
def process(infile, outfile, fmt):
func = {
'docbook':
process_docbook,
'html':
lambda infile, outfile: process_simple(
infile, outfile,
html.HtmlFormatter(full=True, cssfile="syntax-highlighting.css"))
}.get(fmt)
if not func:
raise KeyError(f"fmt {fmt} for supported")
return func(infile, outfile)
def block_code(self, code, lang):
if not lang:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
try:
lexer = get_lexer_by_name(lang, stripall=True)
except pygments.util.ClassNotFound:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
formatter = html.HtmlFormatter()
return pygments.highlight(code, lexer, formatter)
def block_code(self, code, lang):
if not lang:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
try:
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
text = highlight(code, lexer, formatter)
except Exception as e:
text = '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
return text
def block_code(self, code, lang):
"""
Get the language indicated in each fenced code block. Get the
appropriate Pygments lexer based on this language and parse code
accordingly into HTML format. If not language is detected, use vanilla
<code> blocks.
"""
if not lang:
return "\n<pre>%s</pre>\n" % mistune.escape(code)
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
return highlight(code, lexer, formatter)
def block_code(self, code, language=None):
if language:
lexer = get_lexer_by_name(language, stripall=True)
formatter = pygments_html.HtmlFormatter()
highlighted = highlight(code, lexer, formatter)
highlighted_soup = bs4.BeautifulSoup(highlighted, "html.parser")
for code_soup_element in highlighted_soup.find_all("span"):
if code_soup_element.has_attr("class"):
code_soup_element["class"] = ["pl-" + code_soup_element["class"][0]]
highlighted_soup.find("div")["class"].append("highlight-source-" + language.replace("+", "p"))
return highlighted_soup.__str__()
return '<pre><code>' + mistune.escape(code) + '</code></pre>'
def render_fenced_code(self, element):
code = element.children[0].children
options = CodeHiliteRendererMixin.options.copy()
options.update(_parse_extras(getattr(element, "extra", None)))
if element.lang:
try:
lexer = get_lexer_by_name(element.lang, stripall=True)
except ClassNotFound:
lexer = guess_lexer(code)
else:
lexer = guess_lexer(code)
formatter = html.HtmlFormatter(**options)
return highlight(code, lexer, formatter)
def block_code(self, code, lang=None):
if lang == 'dot':
self.slide_vo.dot = code
return code
else:
self.slide_vo.code = code
self.slide_vo.lang = lang
if not lang:
return '\n<pre><code>%s</code></pre>\n' % \
mistune.escape(code)
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
return highlight(code, lexer, formatter)
def block_code(self, code, lang=None):
def no_highlight():
escaped = mistune.escape(code)
return f"\n<pre><code>{escaped}</code></pre>\n"
if not lang:
return no_highlight()
try:
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
return highlight(code, lexer, formatter)
except ClassNotFound:
return no_highlight()
def block_code(self, code, lang=None):
print("hello")
if not lang:
lang = 'text'
try:
lexer = get_lexer_by_name(lang, stripall=True)
except:
lexer = get_lexer_by_name('text', stripall=True)
formatter = html.HtmlFormatter()
return "{open_block}{formatted}{close_block}".format(
open_block="<div class='code-highlight'>"
if lang != 'text' else '',
formatted=highlight(code, lexer, formatter),
close_block="</div>" if lang != 'text' else '')
def block_code(text, lang, inline_styles=False, linenos=False):
if not lang:
text = text.strip()
return u'<pre><code>%s</code></pre>\n' % escape(text)
try:
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter(noclasses=inline_styles,
linenos=linenos)
code = highlight(text, lexer, formatter)
if linenos:
return '<div class="highlight">%s</div>\n' % code
return code
except:
return '<pre class="%s"><code>%s</code></pre>\n' % (lang, escape(text))
def POST(self):
data = web.input()
code = data.code
language = data.lang
if language == 'python':
from pygments.lexers.python import PythonLexer
lexer = PythonLexer()
elif language == 'php':
from pygments.lexers.php import PhpLexer
lexer = PhpLexer()
elif language == 'java':
from pygments.lexers.jvm import JavaLexer
lexer = JavaLexer()
elif language == 'javascript':
from pygments.lexers.javascript import JavascriptLexer
lexer = JavascriptLexer()
elif language == 'html':
from pygments.lexers.html import HtmlLexer
lexer = HtmlLexer()
elif language == 'cpp':
from pygments.lexers.c_cpp import CppLexer
lexer = CppLexer()
elif language == 'shell':
from pygments.lexers.shell import ShellSessionLexer
lexer = ShellSessionLexer()
elif language == 'matlab':
from pygments.lexers.matlab import MatlabLexer
lexer = MatlabLexer()
elif language == 'ruby':
from pygments.lexers.ruby import RubyLexer
lexer = RubyLexer()
elif language == 'r':
from pygments.lexers.r import RConsoleLexer
lexer = RConsoleLexer()
elif language == 'lisp':
from pygments.lexers.lisp import SchemeLexer
lexer = SchemeLexer()
elif language == 'go':
from pygments.lexers.go import GoLexer
lexer = GoLexer()
formatter = html.HtmlFormatter(linenos=False,
encoding='utf-8',
nowrap=False)
hilighted_snippet = highlight(code, lexer, formatter)
#return hilighted
#return render.submit()
return render.result(hilighted_snippet)
def render_file(request, file, filename):
"""For a given @file path and @filename, pretty print the contents
of the file as an HTML page using pygments"""
mime = guess_type(filename, True)
if mime[0] is None or mime[0].split('/')[0] != 'text':
response = FileResponse(open(file, "rb"))
response['Content-Type'] = str(guess_type(filename, False)[0])
return response
with open(file, mode="r", encoding="utf-8", errors='ignore') as open_file:
content = open_file.read()
lexermime = 'text/x-java' if mime[0] == 'text/x-java-source' else mime[0]
lexer = pygments.lexers.get_lexer_for_mimetype(lexermime)
detail = {
"content": pyghi(content, lexer, pygform.HtmlFormatter(encoding='utf-8',linenos='table')),
"filename": filename
}
return render(request, 'file_viewer/pretty_file.html', detail)
