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)