libs: new markdown rendereres for python3

rhodecode/lib/markdown_ext.py

@@ -1,175 +1,132 b''
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import re
 import markdown
 import xml.etree.ElementTree as etree
 
 from markdown.extensions import Extension
 from markdown.extensions.fenced_code import FencedCodeExtension
 from markdown.extensions.tables import TableExtension
+from markdown.extensions.nl2br import Nl2BrExtension as _Nl2BrExtension
+from markdown.extensions.wikilinks import WikiLinkExtension
 from markdown.inlinepatterns import Pattern
 
 import gfm
 
 
 class InlineProcessor(Pattern):
     """
     Base class that inline patterns subclass.
     This is the newer style inline processor that uses a more
     efficient and flexible search approach.
     """
 
     def __init__(self, pattern, md=None):
         """
         Create an instant of an inline pattern.
         Keyword arguments:
         * pattern: A regular expression that matches a pattern
         """
         self.pattern = pattern
         self.compiled_re = re.compile(pattern, re.DOTALL | re.UNICODE)
 
         # Api for Markdown to pass safe_mode into instance
         self.safe_mode = False
         self.md = md
 
     def handleMatch(self, m, data):
         """Return a ElementTree element from the given match and the
         start and end index of the matched text.
         If `start` and/or `end` are returned as `None`, it will be
         assumed that the processor did not find a valid region of text.
         Subclasses should override this method.
         Keyword arguments:
         * m: A re match object containing a match of the pattern.
         * data: The buffer current under analysis
         Returns:
         * el: The ElementTree element, text or None.
         * start: The start of the region that has been matched or None.
         * end: The end of the region that has been matched or None.
         """
         pass  # pragma: no cover
 
 
 class SimpleTagInlineProcessor(InlineProcessor):
     """
     Return element of type `tag` with a text attribute of group(2)
     of a Pattern.
     """
     def __init__(self, pattern, tag):
         InlineProcessor.__init__(self, pattern)
         self.tag = tag
 
     def handleMatch(self, m, data):  # pragma: no cover
         el = etree.Element(self.tag)
         el.text = m.group(2)
         return el, m.start(0), m.end(0)
 
 
 class SubstituteTagInlineProcessor(SimpleTagInlineProcessor):
     """ Return an element of type `tag` with no children. """
     def handleMatch(self, m, data):
         return etree.Element(self.tag), m.start(0), m.end(0)
 
 
-class Nl2BrExtension(Extension):
-    BR_RE = r'\n'
-
-    def extendMarkdown(self, md, md_globals):
-        br_tag = SubstituteTagInlineProcessor(self.BR_RE, 'br')
-        md.inlinePatterns.add('nl', br_tag, '_end')
-
-
-class GithubFlavoredMarkdownExtension(Extension):
-    """
-    An extension that is as compatible as possible with GitHub-flavored
-    Markdown (GFM).
-
-    This extension aims to be compatible with the variant of GFM that GitHub
-    uses for Markdown-formatted gists and files (including READMEs). This
-    variant seems to have all the extensions described in the `GFM
-    documentation`_, except:
-
-    - Newlines in paragraphs are not transformed into ``br`` tags.
-    - Intra-GitHub links to commits, repositories, and issues are not
-      supported.
-
-    If you need support for features specific to GitHub comments and issues,
-    please use :class:`mdx_gfm.GithubFlavoredMarkdownExtension`.
-
-    .. _GFM documentation: https://guides.github.com/features/mastering-markdown/
-    """
-
-    def extendMarkdown(self, md, md_globals):
-        # Built-in extensions
-        Nl2BrExtension().extendMarkdown(md, md_globals)
-        FencedCodeExtension().extendMarkdown(md, md_globals)
-        TableExtension().extendMarkdown(md, md_globals)
-
-        # Custom extensions
-        gfm.AutolinkExtension().extendMarkdown(md, md_globals)
-        gfm.AutomailExtension().extendMarkdown(md, md_globals)
-        gfm.HiddenHiliteExtension([
-            ('guess_lang', 'False'),
-            ('css_class', 'highlight')
-        ]).extendMarkdown(md, md_globals)
-        gfm.SemiSaneListExtension().extendMarkdown(md, md_globals)
-        gfm.SpacedLinkExtension().extendMarkdown(md, md_globals)
-        gfm.StrikethroughExtension().extendMarkdown(md, md_globals)
-        gfm.TaskListExtension([
-            ('list_attrs', {'class': 'checkbox'})
-        ]).extendMarkdown(md, md_globals)
+class Nl2BrExtension(_Nl2BrExtension):
+    pass
 
 
 # Global Vars
 URLIZE_RE = '(%s)' % '|'.join([
     r'<(?:f|ht)tps?://[^>]*>',
     r'\b(?:f|ht)tps?://[^)<>\s]+[^.,)<>\s]',
     r'\bwww\.[^)<>\s]+[^.,)<>\s]',
     r'[^(<\s]+\.(?:com|net|org)\b',
 ])
 
 
 class UrlizePattern(markdown.inlinepatterns.Pattern):
     """ Return a link Element given an autolink (`http://example/com`). """
     def handleMatch(self, m):
         url = m.group(2)
 
         if url.startswith('<'):
             url = url[1:-1]
 
         text = url
 
         if not url.split('://')[0] in ('http','https','ftp'):
             if '@' in url and not '/' in url:
                 url = 'mailto:' + url
             else:
                 url = 'http://' + url
 
         el = markdown.util.etree.Element("a")
         el.set('href', url)
         el.text = markdown.util.AtomicString(text)
         return el
 
 
-class UrlizeExtension(markdown.Extension):
+class UrlizeExtension(Extension):
     """ Urlize Extension for Python-Markdown. """
 
-    def extendMarkdown(self, md, md_globals):
+    def extendMarkdown(self, md):
         """ Replace autolink with UrlizePattern """
         md.inlinePatterns['autolink'] = UrlizePattern(URLIZE_RE, md)

rhodecode/lib/markup_renderer.py

@@ -1,580 +1,547 b''
 
 
 # Copyright (C) 2011-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 """
 Renderer for markup languages with ability to parse using rst or markdown
 """
 
 import re
 import os
 import lxml
 import logging
 import urllib.parse
 import bleach
+import pycmarkgfm
 
 from mako.lookup import TemplateLookup
 from mako.template import Template as MakoTemplate
 
 from docutils.core import publish_parts
 from docutils.parsers.rst import directives
 from docutils import writers
 from docutils.writers import html4css1
 import markdown
 
-from rhodecode.lib.markdown_ext import GithubFlavoredMarkdownExtension
-from rhodecode.lib.utils2 import (safe_unicode, md5_safe, MENTIONS_REGEX)
+from rhodecode.lib.utils2 import safe_str, md5_safe, MENTIONS_REGEX
 
 log = logging.getLogger(__name__)
 
 # default renderer used to generate automated comments
 DEFAULT_COMMENTS_RENDERER = 'rst'
 
 try:
     from lxml.html import fromstring
     from lxml.html import tostring
 except ImportError:
     log.exception('Failed to import lxml')
     fromstring = None
     tostring = None
 
 
 class CustomHTMLTranslator(writers.html4css1.HTMLTranslator):
     """
     Custom HTML Translator used for sandboxing potential
     JS injections in ref links
     """
     def visit_literal_block(self, node):
         self.body.append(self.starttag(node, 'pre', CLASS='codehilite literal-block'))
 
     def visit_reference(self, node):
         if 'refuri' in node.attributes:
             refuri = node['refuri']
             if ':' in refuri:
                 prefix, link = refuri.lstrip().split(':', 1)
                 prefix = prefix or ''
 
                 if prefix.lower() == 'javascript':
                     # we don't allow javascript type of refs...
                     node['refuri'] = 'javascript:alert("SandBoxedJavascript")'
 
         # old style class requires this...
         return html4css1.HTMLTranslator.visit_reference(self, node)
 
 
 class RhodeCodeWriter(writers.html4css1.Writer):
     def __init__(self):
-        writers.Writer.__init__(self)
+        super(RhodeCodeWriter, self).__init__()
         self.translator_class = CustomHTMLTranslator
 
 
 def relative_links(html_source, server_paths):
     if not html_source:
         return html_source
 
     if not fromstring and tostring:
         return html_source
 
     try:
         doc = lxml.html.fromstring(html_source)
     except Exception:
         return html_source
 
     for el in doc.cssselect('img, video'):
         src = el.attrib.get('src')
         if src:
             el.attrib['src'] = relative_path(src, server_paths['raw'])
 
     for el in doc.cssselect('a:not(.gfm)'):
         src = el.attrib.get('href')
         if src:
             raw_mode = el.attrib['href'].endswith('?raw=1')
             if raw_mode:
                 el.attrib['href'] = relative_path(src, server_paths['raw'])
             else:
                 el.attrib['href'] = relative_path(src, server_paths['standard'])
 
-    return lxml.html.tostring(doc)
+    return lxml.html.tostring(doc, encoding='unicode')
 
 
 def relative_path(path, request_path, is_repo_file=None):
     """
     relative link support, path is a rel path, and request_path is current
     server path (not absolute)
 
     e.g.
 
     path = '../logo.png'
     request_path= '/repo/files/path/file.md'
     produces: '/repo/files/logo.png'
     """
     # TODO(marcink): unicode/str support ?
-    # maybe=> safe_unicode(urllib.quote(safe_str(final_path), '/:'))
+    # maybe=> safe_str(urllib.quote(safe_str(final_path), '/:'))
 
     def dummy_check(p):
         return True  # assume default is a valid file path
 
     is_repo_file = is_repo_file or dummy_check
     if not path:
         return request_path
 
-    path = safe_unicode(path)
-    request_path = safe_unicode(request_path)
+    path = safe_str(path)
+    request_path = safe_str(request_path)
 
     if path.startswith(('data:', 'javascript:', '#', ':')):
         # skip data, anchor, invalid links
         return path
 
     is_absolute = bool(urllib.parse.urlparse(path).netloc)
     if is_absolute:
         return path
 
     if not request_path:
         return path
 
     if path.startswith('/'):
         path = path[1:]
 
     if path.startswith('./'):
         path = path[2:]
 
     parts = request_path.split('/')
     # compute how deep we need to traverse the request_path
     depth = 0
 
     if is_repo_file(request_path):
         # if request path is a VALID file, we use a relative path with
         # one level up
         depth += 1
 
     while path.startswith('../'):
         depth += 1
         path = path[3:]
 
     if depth > 0:
         parts = parts[:-depth]
 
     parts.append(path)
     final_path = '/'.join(parts).lstrip('/')
 
     return '/' + final_path
 
 
 _cached_markdown_renderer = None
 
 
 def get_markdown_renderer(extensions, output_format):
     global _cached_markdown_renderer
 
     if _cached_markdown_renderer is None:
         _cached_markdown_renderer = markdown.Markdown(
-            extensions=extensions,
-            enable_attributes=False, output_format=output_format)
+            extensions=extensions + ['legacy_attrs'],
+            output_format=output_format)
     return _cached_markdown_renderer
 
 
-_cached_markdown_renderer_flavored = None
-
+def get_markdown_renderer_flavored(extensions, output_format):
+    """
+    Dummy wrapper to mimic markdown API and render github HTML rendered
 
-def get_markdown_renderer_flavored(extensions, output_format):
-    global _cached_markdown_renderer_flavored
+    """
+    md = get_markdown_renderer(extensions, output_format)
 
-    if _cached_markdown_renderer_flavored is None:
-        _cached_markdown_renderer_flavored = markdown.Markdown(
-            extensions=extensions + [GithubFlavoredMarkdownExtension()],
-            enable_attributes=False, output_format=output_format)
-    return _cached_markdown_renderer_flavored
+    class GFM(object):
+        def convert(self, source):
+            with pycmarkgfm.parse_gfm(source) as document:
+                parsed_md = document.to_commonmark()
+                return md.convert(parsed_md)
+
+    return GFM()
 
 
 class MarkupRenderer(object):
     RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES = ['include', 'meta', 'raw']
 
     MARKDOWN_PAT = re.compile(r'\.(md|mkdn?|mdown|markdown)$', re.IGNORECASE)
     RST_PAT = re.compile(r'\.re?st$', re.IGNORECASE)
     JUPYTER_PAT = re.compile(r'\.(ipynb)$', re.IGNORECASE)
     PLAIN_PAT = re.compile(r'^readme$', re.IGNORECASE)
 
     URL_PAT = re.compile(r'(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]'
                          r'|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)')
 
     MENTION_PAT = re.compile(MENTIONS_REGEX)
 
     extensions = ['markdown.extensions.codehilite', 'markdown.extensions.extra',
                   'markdown.extensions.def_list', 'markdown.extensions.sane_lists']
 
     output_format = 'html4'
 
     # extension together with weights. Lower is first means we control how
     # extensions are attached to readme names with those.
     PLAIN_EXTS = [
         # prefer no extension
         ('', 0),  # special case that renders READMES names without extension
         ('.text', 2), ('.TEXT', 2),
         ('.txt', 3), ('.TXT', 3)
     ]
 
     RST_EXTS = [
         ('.rst', 1), ('.rest', 1),
         ('.RST', 2), ('.REST', 2)
     ]
 
     MARKDOWN_EXTS = [
         ('.md', 1), ('.MD', 1),
         ('.mkdn', 2), ('.MKDN', 2),
         ('.mdown', 3), ('.MDOWN', 3),
         ('.markdown', 4), ('.MARKDOWN', 4)
     ]
 
     def _detect_renderer(self, source, filename=None):
         """
         runs detection of what renderer should be used for generating html
         from a markup language
 
         filename can be also explicitly a renderer name
 
         :param source:
         :param filename:
         """
 
         if MarkupRenderer.MARKDOWN_PAT.findall(filename):
             detected_renderer = 'markdown'
         elif MarkupRenderer.RST_PAT.findall(filename):
             detected_renderer = 'rst'
         elif MarkupRenderer.JUPYTER_PAT.findall(filename):
             detected_renderer = 'jupyter'
         elif MarkupRenderer.PLAIN_PAT.findall(filename):
             detected_renderer = 'plain'
         else:
             detected_renderer = 'plain'
 
         return getattr(MarkupRenderer, detected_renderer)
 
     @classmethod
-    def bleach_clean(cls, text):
+    def sanitize_html(cls, text):
+        # TODO: replace this with https://nh3.readthedocs.io/en/latest
+        # bleach is abandoned and deprecated :/
+
         from .bleach_whitelist import markdown_attrs, markdown_tags
         allowed_tags = markdown_tags
         allowed_attrs = markdown_attrs
 
         try:
             return bleach.clean(text, tags=allowed_tags, attributes=allowed_attrs)
         except Exception:
-            return 'UNPARSEABLE TEXT'
+            return 'TEXT CANNOT BE PARSED USING SANITIZE'
 
     @classmethod
     def renderer_from_filename(cls, filename, exclude):
         """
         Detect renderer markdown/rst from filename and optionally use exclude
         list to remove some options. This is mostly used in helpers.
         Returns None when no renderer can be detected.
         """
         def _filter(elements):
             if isinstance(exclude, (list, tuple)):
                 return [x for x in elements if x not in exclude]
             return elements
 
         if filename.endswith(
                 tuple(_filter([x[0] for x in cls.MARKDOWN_EXTS if x[0]]))):
             return 'markdown'
         if filename.endswith(tuple(_filter([x[0] for x in cls.RST_EXTS if x[0]]))):
             return 'rst'
 
         return None
 
     def render(self, source, filename=None):
         """
         Renders a given filename using detected renderer
         it detects renderers based on file extension or mimetype.
         At last it will just do a simple html replacing new lines with <br/>
-
-        :param file_name:
-        :param source:
         """
 
         renderer = self._detect_renderer(source, filename)
         readme_data = renderer(source)
         return readme_data
 
     @classmethod
-    def _flavored_markdown(cls, text):
-        """
-        Github style flavored markdown
-
-        :param text:
-        """
-
-        # Extract pre blocks.
-        extractions = {}
-
-        def pre_extraction_callback(matchobj):
-            digest = md5_safe(matchobj.group(0))
-            extractions[digest] = matchobj.group(0)
-            return "{gfm-extraction-%s}" % digest
-        pattern = re.compile(r'<pre>.*?</pre>', re.MULTILINE | re.DOTALL)
-        text = re.sub(pattern, pre_extraction_callback, text)
-
-        # Prevent foo_bar_baz from ending up with an italic word in the middle.
-        def italic_callback(matchobj):
-            s = matchobj.group(0)
-            if list(s).count('_') >= 2:
-                return s.replace('_', r'\_')
-            return s
-        text = re.sub(r'^(?! {4}|\t)\w+_\w+_\w[\w_]*', italic_callback, text)
-
-        # Insert pre block extractions.
-        def pre_insert_callback(matchobj):
-            return '\n\n' + extractions[matchobj.group(1)]
-        text = re.sub(r'\{gfm-extraction-([0-9a-f]{32})\}',
-                      pre_insert_callback, text)
-
-        return text
-
-    @classmethod
     def urlify_text(cls, text):
         def url_func(match_obj):
             url_full = match_obj.groups()[0]
-            return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})
+            return f'<a href="{url_full}">{url_full}</a>'
 
         return cls.URL_PAT.sub(url_func, text)
 
     @classmethod
     def convert_mentions(cls, text, mode):
         mention_pat = cls.MENTION_PAT
 
         def wrapp(match_obj):
             uname = match_obj.groups()[0]
             hovercard_url = "pyroutes.url('hovercard_username', {'username': '%s'});" % uname
 
             if mode == 'markdown':
                 tmpl = '<strong class="tooltip-hovercard" data-hovercard-alt="{uname}" data-hovercard-url="{hovercard_url}">@{uname}</strong>'
             elif mode == 'rst':
                 tmpl = ' **@{uname}** '
             else:
                 raise ValueError('mode must be rst or markdown')
 
             return tmpl.format(**{'uname': uname,
                                   'hovercard_url': hovercard_url})
 
         return mention_pat.sub(wrapp, text).strip()
 
     @classmethod
     def plain(cls, source, universal_newline=True, leading_newline=True):
-        source = safe_unicode(source)
+        source = safe_str(source)
         if universal_newline:
             newline = '\n'
             source = newline.join(source.splitlines())
 
         rendered_source = cls.urlify_text(source)
         source = ''
         if leading_newline:
             source += '<br />'
         source += rendered_source.replace("\n", '<br />')
 
-        rendered = cls.bleach_clean(source)
+        rendered = cls.sanitize_html(source)
         return rendered
 
     @classmethod
     def markdown(cls, source, safe=True, flavored=True, mentions=False,
                  clean_html=True):
         """
         returns markdown rendered code cleaned by the bleach library
         """
 
         if flavored:
             markdown_renderer = get_markdown_renderer_flavored(
                 cls.extensions, cls.output_format)
         else:
             markdown_renderer = get_markdown_renderer(
                 cls.extensions, cls.output_format)
 
         if mentions:
             mention_hl = cls.convert_mentions(source, mode='markdown')
             # we extracted mentions render with this using Mentions false
             return cls.markdown(mention_hl, safe=safe, flavored=flavored,
                                 mentions=False)
 
-        source = safe_unicode(source)
+        try:
+            rendered = markdown_renderer.convert(source)
 
-        try:
-            if flavored:
-                source = cls._flavored_markdown(source)
-            rendered = markdown_renderer.convert(source)
         except Exception:
             log.exception('Error when rendering Markdown')
             if safe:
                 log.debug('Fallback to render in plain mode')
                 rendered = cls.plain(source)
             else:
                 raise
 
         if clean_html:
-            rendered = cls.bleach_clean(rendered)
+            rendered = cls.sanitize_html(rendered)
         return rendered
 
     @classmethod
     def rst(cls, source, safe=True, mentions=False, clean_html=False):
+
         if mentions:
             mention_hl = cls.convert_mentions(source, mode='rst')
             # we extracted mentions render with this using Mentions false
             return cls.rst(mention_hl, safe=safe, mentions=False)
 
-        source = safe_unicode(source)
+        source = safe_str(source)
         try:
             docutils_settings = dict(
                 [(alias, None) for alias in
                  cls.RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES])
 
             docutils_settings.update({
                 'input_encoding': 'unicode',
                 'report_level': 4,
                 'syntax_highlight': 'short',
             })
 
-            for k, v in docutils_settings.items():
+            for k, v in list(docutils_settings.items()):
                 directives.register_directive(k, v)
 
             parts = publish_parts(source=source,
                                   writer=RhodeCodeWriter(),
                                   settings_overrides=docutils_settings)
             rendered = parts["fragment"]
             if clean_html:
-                rendered = cls.bleach_clean(rendered)
+                rendered = cls.sanitize_html(rendered)
             return parts['html_title'] + rendered
         except Exception:
             log.exception('Error when rendering RST')
             if safe:
                 log.debug('Fallback to render in plain mode')
                 return cls.plain(source)
             else:
                 raise
 
     @classmethod
     def jupyter(cls, source, safe=True):
         from rhodecode.lib import helpers
 
         from traitlets.config import Config
         import nbformat
         from nbconvert import HTMLExporter
         from nbconvert.preprocessors import Preprocessor
 
         class CustomHTMLExporter(HTMLExporter):
             def _template_file_default(self):
                 return 'basic'
 
         class Sandbox(Preprocessor):
 
             def preprocess(self, nb, resources):
                 sandbox_text = 'SandBoxed(IPython.core.display.Javascript object)'
                 for cell in nb['cells']:
                     if not safe:
                         continue
 
                     if 'outputs' in cell:
                         for cell_output in cell['outputs']:
                             if 'data' in cell_output:
                                 if 'application/javascript' in cell_output['data']:
                                     cell_output['data']['text/plain'] = sandbox_text
                                     cell_output['data'].pop('application/javascript', None)
 
                     if 'source' in cell and cell['cell_type'] == 'markdown':
                         # sanitize similar like in markdown
-                        cell['source'] = cls.bleach_clean(cell['source'])
+                        cell['source'] = cls.sanitize_html(cell['source'])
 
                 return nb, resources
 
         def _sanitize_resources(input_resources):
             """
             Skip/sanitize some of the CSS generated and included in jupyter
             so it doesn't messes up UI so much
             """
 
             # TODO(marcink): probably we should replace this with whole custom
             # CSS set that doesn't screw up, but jupyter generated html has some
             # special markers, so it requires Custom HTML exporter template with
             # _default_template_path_default, to achieve that
 
             # strip the reset CSS
             input_resources[0] = input_resources[0][input_resources[0].find('/*! Source'):]
             return input_resources
 
         def as_html(notebook):
             conf = Config()
             conf.CustomHTMLExporter.preprocessors = [Sandbox]
             html_exporter = CustomHTMLExporter(config=conf)
 
             (body, resources) = html_exporter.from_notebook_node(notebook)
             header = '<!-- ## IPYTHON NOTEBOOK RENDERING ## -->'
             js = MakoTemplate(r'''
             <!-- MathJax configuration -->
             <script type="text/x-mathjax-config">
             MathJax.Hub.Config({
                 jax: ["input/TeX","output/HTML-CSS", "output/PreviewHTML"],
                 extensions: ["tex2jax.js","MathMenu.js","MathZoom.js", "fast-preview.js", "AssistiveMML.js", "[Contrib]/a11y/accessibility-menu.js"],
                 TeX: {
                     extensions: ["AMSmath.js","AMSsymbols.js","noErrors.js","noUndefined.js"]
                 },
                 tex2jax: {
                     inlineMath: [ ['$','$'], ["\\(","\\)"] ],
                     displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
                     processEscapes: true,
                     processEnvironments: true
                 },
                 // Center justify equations in code and markdown cells. Elsewhere
                 // we use CSS to left justify single line equations in code cells.
                 displayAlign: 'center',
                 "HTML-CSS": {
                     styles: {'.MathJax_Display': {"margin": 0}},
                     linebreaks: { automatic: true },
                     availableFonts: ["STIX", "TeX"]
                 },
                 showMathMenu: false
             });
             </script>
             <!-- End of MathJax configuration -->
             <script src="${h.asset('js/src/math_jax/MathJax.js')}"></script>
             ''').render(h=helpers)
 
             css = MakoTemplate(r'''
             <link rel="stylesheet" type="text/css" href="${h.asset('css/style-ipython.css', ver=ver)}" media="screen"/>
             ''').render(h=helpers, ver='ver1')
 
             body = '\n'.join([header, css, js, body])
             return body, resources
 
         notebook = nbformat.reads(source, as_version=4)
         (body, resources) = as_html(notebook)
         return body
 
 
 class RstTemplateRenderer(object):
 
     def __init__(self):
         base = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
         rst_template_dirs = [os.path.join(base, 'templates', 'rst_templates')]
         self.template_store = TemplateLookup(
             directories=rst_template_dirs,
             input_encoding='utf-8',
             imports=['from rhodecode.lib import helpers as h'])
 
     def _get_template(self, templatename):
         return self.template_store.get_template(templatename)
 
     def render(self, template_name, **kwargs):
         template = self._get_template(template_name)
         return template.render(**kwargs)