def setup(self):
render_default = m.Markdown(
TestRenderer(), (
'fenced-code',
'tables',
'footnotes',
'autolink',
'highlight',
'quote',
'strikethrough',
'superscript',
'math'))
# EXT_UNDERLINE Clashes with emphasis.
render_underline = m.Markdown(TestRenderer(), ('underline',))
render_lowlevel = m.Markdown(TestRendererLowlevel())
render_hf = m.Markdown(TestRendererHeaderFooter())
self.md = {
'default': render_default,
'underline': render_underline,
'lowlevel': render_lowlevel,
'hf': render_hf,
}
for name, data in tests:
self._create_test(name, data)
def _parse_meta(self, header, body):
header = m.html(to_unicode(header))
titles = re.findall(r'<h1>(.*)</h1>', header)
if not titles:
logging.error('There is no title')
title = None
else:
title = titles[0]
meta = {'title': title}
items = re.findall(r'<li>(.*?)</li>', header, re.S)
for item in items:
index = item.find(':')
key = item[:index].rstrip()
value = item[index + 1:].lstrip()
meta[key] = value
desc = re.findall(r'<p>(.*?)</p>', header, re.S)
if desc:
meta['description'] = '\n\n'.join(desc)
#: keep body in meta data as source text
meta['source_text'] = body
_toc = m.Markdown(m.HtmlTocRenderer(), 0)
meta['toc'] = _toc.render(body)
return meta
def extract_card(text, config, image_search_path):
""" Extract card data based on the provided texts. """
card = CardData()
parser = CardParser(card, config, image_search_path)
misaka.Markdown(parser, extensions=markdown.ENABLED_EXTENSIONS)(text)
return card
def my_markdown(value, flag):
extensions = (misaka.EXT_NO_INTRA_EMPHASIS | misaka.EXT_FENCED_CODE
| misaka.EXT_AUTOLINK | misaka.EXT_TABLES
| misaka.EXT_STRIKETHROUGH | misaka.EXT_SUPERSCRIPT)
# 根据参数（主题或评论）载入不同Markdown扩展
if flag == 'comment':
renderer = CommentRenderer(flags=misaka.HTML_ESCAPE
| misaka.HTML_HARD_WRAP)
else:
renderer = TopicRenderer(flags=misaka.HTML_ESCAPE
| misaka.HTML_HARD_WRAP)
md = misaka.Markdown(renderer, extensions=extensions)
md = md(value) # force_unicode()
# @人给链接输出
team_name_pattern = re.compile('(?<=@)([0-9a-zA-Z_.]+)', re.UNICODE)
at_name_list = set(re.findall(team_name_pattern, md))
if at_name_list:
for at_name in at_name_list:
try:
at_user = User.objects.get(username=at_name)
if at_user:
md = md.replace(
'@' + at_name, '<a href="%s" class="at_user">@%s</a>' %
(reverse("user:user", args=(at_user.id, )), at_name))
except:
pass
return mark_safe(md)
def extract_codeblocks(md_file):
"""Extract all codeblocks, returning list of [text, lang]."""
md = open(md_file, 'r').read()
ce = CodeExtracter()
msk = misaka.Markdown(ce, extensions=('fenced-code', ))
msk(md)
return (ce.codeblocks)
def index(request):
news_list = NEWS.objects.order_by('-date')[:20]
img_list = []
is_auth = 0
for news in news_list:
md_render = misaka.Markdown(misaka.HtmlRenderer())
html = md_render(news.text)
soup = BeautifulSoup(html, features='html.parser')
img = soup.find('img')
if img != None:
img_list.append(img.get('src'))
else:
img_list.append('')
zipped = zip(news_list, img_list)
zip_list = list(zipped)
if request.user.is_authenticated:
user = get_object_or_404(news_user, id=request.user.id)
is_auth = 1
context = {'news_list': zip_list, 'user': user, 'is_auth': is_auth}
else:
context = {
'news_list': zip_list,
'img_list': img_list,
'is_auth': is_auth
}
return render(request, "index.html", context)
def render(self):
f = open(self.filepath)
logging.debug('read ' + self.relative_filepath)
header = ''
body = ''
recording = True
for line in f:
if recording and line.startswith('---'):
recording = False
elif recording:
header += line
else:
body += line
f.close()
body = to_unicode(body)
meta = self._parse_meta(header)
#: keep body in meta data as source text
meta['source_text'] = body
_toc = m.Markdown(m.HtmlTocRenderer(), 0)
meta['toc'] = _toc.render(body)
content = markdown(body)
return self.post_class(self.filepath, content, meta=meta)
def benchmark_misaka(text):
import misaka as m
# mistune has all these features
extensions = (m.EXT_NO_INTRA_EMPHASIS | m.EXT_FENCED_CODE | m.EXT_AUTOLINK
| m.EXT_TABLES | m.EXT_STRIKETHROUGH)
md = m.Markdown(m.HtmlRenderer(), extensions=extensions)
md.render(text)
def field_to_html(field):
"""Need to extract the math in brackets so that it doesn't get markdowned.
If math is separated with dollar sign it is converted to brackets."""
if CONFIG['math_mode'] == 'dollars':
for (sep, (op, cl)) in [("$$", (r"\\[", r"\\]")),
("$", (r"\\(", r"\\)"))]:
escaped_sep = sep.replace(r"$", r"\$")
# ignore escaped dollar signs when splitting the field
field = re.split(r"(?<!\\){}".format(escaped_sep), field)
# add op(en) and cl(osing) brackets to every second element of the list
field[1::2] = [op + e + cl for e in field[1::2]]
field = "".join(field)
#
# CONFIG['math_mode'] is 'brackets' OR fallback case
#
else:
for bracket in ["(", ")", "[", "]"]:
field = field.replace(r"\{}".format(bracket),
r"\\{}".format(bracket))
# backslashes, man.
if CONFIG['misaka_renderer'] == 'HighlighterRenderer':
renderer = HighlighterRenderer()
#
# CONFIG['misakq_renderer'] is 'HtmlRenderer' OR fallback case
#
else:
renderer = misaka.HtmlRenderer()
return misaka.Markdown(renderer, CONFIG['misaka_extensions'])(field)
def __init__(self):
renderer = MarkdownRenderer()
extensions = (misaka.EXT_FENCED_CODE |
misaka.EXT_NO_INTRA_EMPHASIS |
misaka.EXT_AUTOLINK)
self.renderer = renderer
self.markdown = misaka.Markdown(renderer, extensions=extensions)
def loadmore(request):
type = request.GET.get('type')
if type != None:
List = NEWS.objects.filter(style=type).order_by('-date')
else:
List = NEWS.objects.order_by('-date')
p = 3
limit = 20
img_list = []
for news in List:
md_render = misaka.Markdown(misaka.HtmlRenderer())
html = md_render(news.text)
soup = BeautifulSoup(html, features='html.parser')
img = soup.find('img')
if img != None:
img_list.append(img.get('src'))
else:
img_list.append('')
zipped = zip(List, img_list)
List = L(zipped)
paginor = Paginator(List, limit)
page = request.GET.get('page', p)
item_info = paginor.page(page)
news_list = item_info.object_list
print(news_list)
context = {
'news_list': news_list,
}
template = 'load.html'
return render(request, template, context)
def update_webview(self):
renderer = MathHTMLRenderer()
mi = m.Markdown(renderer)
html = mi(self.entry.toPlainText())
html = '<body><script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.4/latest.js?config=AM_CHTML"></script>' \
+ html + '</body>'
self.browser.setHtml(html)
def build_docs(docs_dir='docs', output_dir='demo/app/assets/views'):
renderer = XMLRenderer()
docs_dir = convert_path(docs_dir)
output_dir = convert_path(output_dir)
md = m.Markdown(renderer, extensions=('fenced-code',))
for root, dirs, files in os.walk(docs_dir):
for name in files:
if name.find('.md') == -1:
continue
doc_path = os.path.join(root, name)
xml_path = replace_dirname(doc_path, docs_dir, output_dir)
xml_path = xml_path[:len(xml_path) - 3] + '.xml'
xml_dir = os.path.dirname(xml_path)
if not os.path.exists(xml_dir):
os.makedirs(xml_dir)
print('build: %s' % xml_path)
if sys.version_info > (3, 0):
md_file = open(doc_path, 'r', encoding='utf8')
xml_file = open(xml_path, 'w+', encoding='utf8')
else:
md_file = open(doc_path, 'r')
xml_file = open(xml_path, 'w+')
xml_content = md(md_file.read())
xml_content = XML_TEMPLATE.format(xml_content)
xml_file.write(xml_content)
xml_file.close()
md_file.close()
def markdown(text, renderer='highlight', inlinestyles=False, linenos=False):
"""Markdown filter for writeup.
:param text: the content to be markdownify
:param highlight: highlight the code block or not
:param inlinestyles: highlight the code with inline styles
:param linenos: show linenos of the highlighted code
"""
if not text:
return u''
flags = m.HTML_ESCAPE
if renderer == 'highlight':
r = HighlightRenderer(flags=flags)
r._inlinestyles = inlinestyles
r._linenos = linenos
elif renderer == 'plain':
r = PlainRenderer(flags=flags)
else:
r = BaseRenderer(flags=flags)
extensions = (
m.EXT_NO_INTRA_EMPHASIS | m.EXT_FENCED_CODE | m.EXT_AUTOLINK |
m.EXT_TABLES | m.EXT_STRIKETHROUGH | m.EXT_SUPERSCRIPT
)
md = m.Markdown(r, extensions=extensions)
return md.render(text)
def _markdown(text):
render_flags = misaka.HTML_SKIP_STYLE
renderer = _HighlighterRenderer(flags=render_flags)
extensions = misaka.EXT_FENCED_CODE | misaka.EXT_NO_INTRA_EMPHASIS | \
misaka.EXT_TABLES | misaka.EXT_AUTOLINK | misaka.EXT_STRIKETHROUGH | \
misaka.EXT_SUPERSCRIPT
md = misaka.Markdown(renderer, extensions=extensions)
# Sundown seems not to properly handle multi-line HTML comments, and instead
# turns the closing part of the tag into –>. To work around this, we
# just strip HTML comments out.
text = re.sub('<!--.*?-->', '', text, 0, re.S)
# Pre-process the markdown to get fenced code block to render like GitHub
# Unfortunately they no longer maintain sundown or redcarpet and have not
# open-sourced their Markdown renderer, so this is a wild-goose chase.
in_block = False
last_line_blank = True
lines = []
for line in text.splitlines():
if re.match('\s*(```|~~~)', line):
if not in_block and not last_line_blank:
line = "\n" + line
in_block = True
else:
in_block = False
lines.append(line)
last_line_blank = re.match('^\s*$', line) != None
return md.render("\n".join(lines))
def markdown_render(content):
renderer = BleepRenderer()
print renderer
misaka_md = misaka.Markdown(renderer,
extensions=misaka.EXT_FENCED_CODE
| misaka.EXT_NO_INTRA_EMPHASIS)
return misaka_md.render(content)
def __init__(self):
"""Initialize the parser, set markdown render handler as
an attribute `markdown` of the parser"""
render = ColorRender() # initialize the color render
extensions = (misaka.EXT_FENCED_CODE | misaka.EXT_NO_INTRA_EMPHASIS
| misaka.EXT_AUTOLINK | misaka.EXT_TABLES)
self.markdown = misaka.Markdown(render, extensions=extensions)
def rich_markdown(text):
if text is None:
return ''
renderer = JuneRenderer(flags=m.HTML_ESCAPE)
ext = (m.EXT_NO_INTRA_EMPHASIS | m.EXT_FENCED_CODE | m.EXT_AUTOLINK
| m.EXT_TABLES | m.EXT_STRIKETHROUGH)
md = m.Markdown(renderer, extensions=ext)
return md.render(text)
def markdown(text):
text = to_unicode(text)
render = AkioRender(flags=m.HTML_USE_XHTML)
md = m.Markdown(
render,
extensions=m.EXT_FENCED_CODE | m.EXT_AUTOLINK,
)
return md.render(text)
def on_change_body(target, value, old_value, initiator):
brief_index = value.find('<!-- more -->')
brief_value = value[:200] if brief_index == -1 else value[:brief_index]
render = HighlighterRenderer()
md = m.Markdown(renderer=render, extensions=('fenced-code', ))
target.body_html = md(value)
target.body_brief = md(brief_value)
def render(self, context):
value = self.nodelist.render(context)
if isinstance(value, SafeText):
# Compatible with Python 3.
value = unicode(value) if six.PY2 else str(value)
renderer = MisakaRenderer(flags=m.HTML_ESCAPE)
md = m.Markdown(renderer,
extensions=m.EXT_FENCED_CODE | m.EXT_NO_INTRA_EMPHASIS)
return md.render(value)
def __init__(self, line_numbers, css_code_class):
super(GithubFlavouredMarkdown, self).__init__()
my_renderer = GithubFlavouredMarkdown.Renderer()
my_renderer.line_numbers = line_numbers
my_renderer.css_code_class = css_code_class
self.renderer = misaka.Markdown(
my_renderer,
extensions=misaka.EXT_FENCED_CODE | misaka.EXT_NO_INTRA_EMPHASIS
)
def setMarkdown(self, md_str):
md_renderer = md.Markdown(self.renderer,
extensions=md.EXT_FENCED_CODE
| md.EXT_NO_INTRA_EMPHASIS)
html = self.render(md_renderer.render(md_str))
QtWebKit.QWebView.setHtml(self,
html,
baseUrl=QtCore.QUrl('file://' +
self.m_mdFile.absPath()))
def new_markdown():
markdown = m.Markdown(
HighlighterRenderer(),
extensions=\
m.EXT_FENCED_CODE |\
m.EXT_TABLES |\
m.EXT_QUOTE
)
return markdown
def _dump_para(text):
md = misaka.Markdown(
# skip-html - 跳过原文中的 HTML 代码
# hard-wrap - 每个 \n 都渲染为 <br>
renderer=ArticleRenderer(flags=('skip-html', 'hard-wrap')),
# space-headers - 只将 # Title 转为 <header>
# #Title 会保持原样
extensions=('disable-indented-code', 'autolink', 'space-headers'))
return {'type': 'text', 'text': text, 'html': md(text)}
def render(markdown: str, highlighting=None) -> str:
"""Renders a markdown string to an embeddable HTML string."""
if highlighting:
html_and_highlight = misaka.Markdown(
HighlightingRenderer(highlighting), extensions=MARKDOWN_EXTENSIONS)
return html_and_highlight(markdown)
return misaka.html(markdown, extensions=MARKDOWN_EXTENSIONS)
def to_html(text, config, search_path):
""" Convert Markdown text to HTML """
processor = misaka.Markdown(HtmlRenderer(config, search_path),
extensions=ENABLED_EXTENSIONS)
text = processor(text)
if not config.get('no_smartquotes'):
text = misaka.smartypants(text)
return flask.Markup(text)
def markdown(text, noclasses=False, lang=None):
if not isinstance(text, (unicode, type(None))):
text = text.decode('utf-8')
render = JuneRender(flags=m.HTML_USE_XHTML)
render.set_pygments_options(noclasses=noclasses, lang=lang)
md = m.Markdown(
render,
extensions=m.EXT_FENCED_CODE | m.EXT_AUTOLINK,
)
return md.render(text)
def markdown(text, noclasses=False):
options = {'noclasses': noclasses}
render = JuneRender(flags=m.HTML_ESCAPE | m.HTML_USE_XHTML)
render.set_pygments_options(options)
md = m.Markdown(
render,
extensions=m.EXT_NO_INTRA_EMPHASIS | m.EXT_FENCED_CODE
| m.EXT_AUTOLINK,
)
return md.render(text)
def markdown(text, renderer=None, **options):
ext, rndr = make_flags(**options)
if renderer:
md = misaka.Markdown(renderer, ext)
result = md(text)
else:
result = misaka.html(text, extensions=ext, render_flags=rndr)
if options.get("smartypants"):
result = misaka.smartypants(result)
return Markup(result)
