New upstream version 8.1.2.upstream/8.1.2

7 files changed, 172 insertions, 203 deletions

diff --git a/nikola/plugins/compile/markdown/__init__.py b/nikola/plugins/compile/markdown/__init__.py
index c1425a1..74e8c75 100644
--- a/nikola/plugins/compile/markdown/__init__.py
+++ b/nikola/plugins/compile/markdown/__init__.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-# Copyright © 2012-2015 Roberto Alsina and others.
+# Copyright © 2012-2020 Roberto Alsina and others.
 
 # Permission is hereby granted, free of charge, to any
 # person obtaining a copy of this software and associated
@@ -24,59 +24,110 @@
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"""Implementation of compile_html based on markdown."""
-
-from __future__ import unicode_literals
+"""Page compiler plugin for Markdown."""
 
 import io
+import json
 import os
+import threading
+
+from nikola import shortcodes as sc
+from nikola.plugin_categories import PageCompiler
+from nikola.utils import makedirs, req_missing, write_metadata, LocaleBorg, map_metadata
 
 try:
-    from markdown import markdown
+    from markdown import Markdown
 except ImportError:
-    markdown = None  # NOQA
-    nikola_extension = None
-    gist_extension = None
-    podcast_extension = None
+    Markdown = None
 
-from nikola.plugin_categories import PageCompiler
-from nikola.utils import makedirs, req_missing, write_metadata
 
+class ThreadLocalMarkdown(threading.local):
+    """Convert Markdown to HTML using per-thread Markdown objects.
 
-class CompileMarkdown(PageCompiler):
+    See discussion in #2661.
+    """
+
+    def __init__(self, extensions, extension_configs):
+        """Create a Markdown instance."""
+        self.markdown = Markdown(extensions=extensions, extension_configs=extension_configs, output_format="html5")
+
+    def convert(self, data):
+        """Convert data to HTML and reset internal state."""
+        result = self.markdown.convert(data)
+        try:
+            meta = {}
+            for k in self.markdown.Meta:  # This reads everything as lists
+                meta[k.lower()] = ','.join(self.markdown.Meta[k])
+        except Exception:
+            meta = {}
+        self.markdown.reset()
+        return result, meta
 
+
+class CompileMarkdown(PageCompiler):
     """Compile Markdown into HTML."""
 
     name = "markdown"
     friendly_name = "Markdown"
     demote_headers = True
-    extensions = []
     site = None
+    supports_metadata = False
 
     def set_site(self, site):
         """Set Nikola site."""
-        super(CompileMarkdown, self).set_site(site)
+        super().set_site(site)
         self.config_dependencies = []
+        extensions = []
         for plugin_info in self.get_compiler_extensions():
             self.config_dependencies.append(plugin_info.name)
-            self.extensions.append(plugin_info.plugin_object)
+            extensions.append(plugin_info.plugin_object)
             plugin_info.plugin_object.short_help = plugin_info.description
 
-        self.config_dependencies.append(str(sorted(site.config.get("MARKDOWN_EXTENSIONS"))))
-
-    def compile_html(self, source, dest, is_two_file=True):
-        """Compile source file into HTML and save as dest."""
-        if markdown is None:
+        site_extensions = self.site.config.get("MARKDOWN_EXTENSIONS")
+        self.config_dependencies.append(str(sorted(site_extensions)))
+        extensions.extend(site_extensions)
+
+        site_extension_configs = self.site.config.get("MARKDOWN_EXTENSION_CONFIGS")
+        if site_extension_configs:
+            self.config_dependencies.append(json.dumps(site_extension_configs.values, sort_keys=True))
+
+        if Markdown is not None:
+            self.converters = {}
+            for lang in self.site.config['TRANSLATIONS']:
+                lang_extension_configs = site_extension_configs(lang) if site_extension_configs else {}
+                self.converters[lang] = ThreadLocalMarkdown(extensions, lang_extension_configs)
+        self.supports_metadata = 'markdown.extensions.meta' in extensions
+
+    def compile_string(self, data, source_path=None, is_two_file=True, post=None, lang=None):
+        """Compile Markdown into HTML strings."""
+        if lang is None:
+            lang = LocaleBorg().current_lang
+        if Markdown is None:
+            req_missing(['markdown'], 'build this site (compile Markdown)')
+        if not is_two_file:
+            _, data = self.split_metadata(data, post, lang)
+        new_data, shortcodes = sc.extract_shortcodes(data)
+        output, _ = self.converters[lang].convert(new_data)
+        output, shortcode_deps = self.site.apply_shortcodes_uuid(output, shortcodes, filename=source_path, extra_context={'post': post})
+        return output, shortcode_deps
+
+    def compile(self, source, dest, is_two_file=True, post=None, lang=None):
+        """Compile the source file into HTML and save as dest."""
+        if Markdown is None:
             req_missing(['markdown'], 'build this site (compile Markdown)')
         makedirs(os.path.dirname(dest))
-        self.extensions += self.site.config.get("MARKDOWN_EXTENSIONS")
-        with io.open(dest, "w+", encoding="utf8") as out_file:
-            with io.open(source, "r", encoding="utf8") as in_file:
+        with io.open(dest, "w+", encoding="utf-8") as out_file:
+            with io.open(source, "r", encoding="utf-8-sig") as in_file:
                 data = in_file.read()
-            if not is_two_file:
-                _, data = self.split_metadata(data)
-            output = markdown(data, self.extensions)
+            output, shortcode_deps = self.compile_string(data, source, is_two_file, post, lang)
             out_file.write(output)
+        if post is None:
+            if shortcode_deps:
+                self.logger.error(
+                    "Cannot save dependencies for post {0} (post unknown)",
+                    source)
+        else:
+            post._depfile[dest] += shortcode_deps
 
     def create_post(self, path, **kw):
         """Create a new post."""
@@ -91,9 +142,30 @@ class CompileMarkdown(PageCompiler):
         makedirs(os.path.dirname(path))
         if not content.endswith('\n'):
             content += '\n'
-        with io.open(path, "w+", encoding="utf8") as fd:
+        with io.open(path, "w+", encoding="utf-8") as fd:
             if onefile:
-                fd.write('<!-- \n')
-                fd.write(write_metadata(metadata))
-                fd.write('-->\n\n')
+                fd.write(write_metadata(metadata, comment_wrap=True, site=self.site, compiler=self))
             fd.write(content)
+
+    def read_metadata(self, post, lang=None):
+        """Read the metadata from a post, and return a metadata dict."""
+        lang = lang or self.site.config['DEFAULT_LANG']
+        if not self.supports_metadata:
+            return {}
+        if Markdown is None:
+            req_missing(['markdown'], 'build this site (compile Markdown)')
+        if lang is None:
+            lang = LocaleBorg().current_lang
+        source = post.translated_source_path(lang)
+        with io.open(source, 'r', encoding='utf-8-sig') as inf:
+            # Note: markdown meta returns lowercase keys
+            data = inf.read()
+            # If the metadata starts with "---" it's actually YAML and
+            # we should not let markdown parse it, because it will do
+            # bad things like setting empty tags to "''"
+            if data.startswith('---\n'):
+                return {}
+            _, meta = self.converters[lang].convert(data)
+        # Map metadata from other platforms to names Nikola expects (Issue #2817)
+        map_metadata(meta, 'markdown_metadata', self.site.config)
+        return meta
diff --git a/nikola/plugins/compile/markdown/mdx_gist.plugin b/nikola/plugins/compile/markdown/mdx_gist.plugin
index 7fe676c..f962cb7 100644
--- a/nikola/plugins/compile/markdown/mdx_gist.plugin
+++ b/nikola/plugins/compile/markdown/mdx_gist.plugin
@@ -4,11 +4,11 @@ module = mdx_gist
 
 [Nikola]
 compiler = markdown
-plugincategory = CompilerExtension
+PluginCategory = CompilerExtension
 
 [Documentation]
 author = Roberto Alsina
 version = 0.1
-website = http://getnikola.com
+website = https://getnikola.com/
 description = Extension for embedding gists
 
diff --git a/nikola/plugins/compile/markdown/mdx_gist.py b/nikola/plugins/compile/markdown/mdx_gist.py
index f439fa2..f6ce20a 100644
--- a/nikola/plugins/compile/markdown/mdx_gist.py
+++ b/nikola/plugins/compile/markdown/mdx_gist.py
@@ -22,7 +22,7 @@
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 # Warning: URL formats of "raw" gists are undocummented and subject to change.
-# See also:  http://developer.github.com/v3/gists/
+# See also:  https://developer.github.com/v3/gists/
 #
 # Inspired by "[Python] reStructuredText GitHub Gist directive"
 # (https://gist.github.com/brianhsu/1407759), public domain by Brian Hsu
@@ -31,164 +31,54 @@ Extension to Python Markdown for Embedded Gists (gist.github.com).
 
 Basic Example:
 
-    >>> import markdown
-    >>> text = '''
-    ... Text of the gist:
-    ... [:gist: 4747847]
-    ... '''
-    >>> html = markdown.markdown(text, [GistExtension()])
-    >>> print(html)
-    <p>Text of the gist:
-    <div class="gist">
-    <script src="https://gist.github.com/4747847.js"></script>
-    <noscript>
-    <pre>import this</pre>
-    </noscript>
-    </div>
-    </p>
+    Text of the gist:
+    [:gist: 4747847]
 
 Example with filename:
 
-    >>> import markdown
-    >>> text = '''
-    ... Text of the gist:
-    ... [:gist: 4747847 zen.py]
-    ... '''
-    >>> html = markdown.markdown(text, [GistExtension()])
-    >>> print(html)
-    <p>Text of the gist:
-    <div class="gist">
-    <script src="https://gist.github.com/4747847.js?file=zen.py"></script>
-    <noscript>
-    <pre>import this</pre>
-    </noscript>
-    </div>
-    </p>
+    Text of the gist:
+    [:gist: 4747847 zen.py]
 
 Basic Example with hexidecimal id:
 
-    >>> import markdown
-    >>> text = '''
-    ... Text of the gist:
-    ... [:gist: c4a43d6fdce612284ac0]
-    ... '''
-    >>> html = markdown.markdown(text, [GistExtension()])
-    >>> print(html)
-    <p>Text of the gist:
-    <div class="gist">
-    <script src="https://gist.github.com/c4a43d6fdce612284ac0.js"></script>
-    <noscript>
-    <pre>Moo</pre>
-    </noscript>
-    </div>
-    </p>
+    Text of the gist:
+    [:gist: c4a43d6fdce612284ac0]
 
 Example with hexidecimal id filename:
 
-    >>> import markdown
-    >>> text = '''
-    ... Text of the gist:
-    ... [:gist: c4a43d6fdce612284ac0 cow.txt]
-    ... '''
-    >>> html = markdown.markdown(text, [GistExtension()])
-    >>> print(html)
-    <p>Text of the gist:
-    <div class="gist">
-    <script src="https://gist.github.com/c4a43d6fdce612284ac0.js?file=cow.txt"></script>
-    <noscript>
-    <pre>Moo</pre>
-    </noscript>
-    </div>
-    </p>
+    Text of the gist:
+    [:gist: c4a43d6fdce612284ac0 cow.txt]
 
 Example using reStructuredText syntax:
 
-    >>> import markdown
-    >>> text = '''
-    ... Text of the gist:
-    ... .. gist:: 4747847 zen.py
-    ... '''
-    >>> html = markdown.markdown(text, [GistExtension()])
-    >>> print(html)
-    <p>Text of the gist:
-    <div class="gist">
-    <script src="https://gist.github.com/4747847.js?file=zen.py"></script>
-    <noscript>
-    <pre>import this</pre>
-    </noscript>
-    </div>
-    </p>
+    Text of the gist:
+    .. gist:: 4747847 zen.py
 
 Example using hexidecimal ID with reStructuredText syntax:
 
-    >>> import markdown
-    >>> text = '''
-    ... Text of the gist:
-    ... .. gist:: c4a43d6fdce612284ac0
-    ... '''
-    >>> html = markdown.markdown(text, [GistExtension()])
-    >>> print(html)
-    <p>Text of the gist:
-    <div class="gist">
-    <script src="https://gist.github.com/c4a43d6fdce612284ac0.js"></script>
-    <noscript>
-    <pre>Moo</pre>
-    </noscript>
-    </div>
-    </p>
+    Text of the gist:
+    .. gist:: c4a43d6fdce612284ac0
 
 Example using hexidecimal ID and filename with reStructuredText syntax:
 
-    >>> import markdown
-    >>> text = '''
-    ... Text of the gist:
-    ... .. gist:: c4a43d6fdce612284ac0 cow.txt
-    ... '''
-    >>> html = markdown.markdown(text, [GistExtension()])
-    >>> print(html)
-    <p>Text of the gist:
-    <div class="gist">
-    <script src="https://gist.github.com/c4a43d6fdce612284ac0.js?file=cow.txt"></script>
-    <noscript>
-    <pre>Moo</pre>
-    </noscript>
-    </div>
-    </p>
+    Text of the gist:
+    .. gist:: c4a43d6fdce612284ac0 cow.txt
 
 Error Case: non-existent Gist ID:
 
-    >>> import markdown
-    >>> text = '''
-    ... Text of the gist:
-    ... [:gist: 0]
-    ... '''
-    >>> html = markdown.markdown(text, [GistExtension()])
-    >>> print(html)
-    <p>Text of the gist:
-    <div class="gist">
-    <script src="https://gist.github.com/0.js"></script>
-    <noscript><!-- WARNING: Received a 404 response from Gist URL: https://gist.githubusercontent.com/raw/0 --></noscript>
-    </div>
-    </p>
-
-Error Case:  non-existent file:
-
-    >>> import markdown
-    >>> text = '''
-    ... Text of the gist:
-    ... [:gist: 4747847 doesntexist.py]
-    ... '''
-    >>> html = markdown.markdown(text, [GistExtension()])
-    >>> print(html)
-    <p>Text of the gist:
-    <div class="gist">
-    <script src="https://gist.github.com/4747847.js?file=doesntexist.py"></script>
-    <noscript><!-- WARNING: Received a 404 response from Gist URL: https://gist.githubusercontent.com/raw/4747847/doesntexist.py --></noscript>
-    </div>
-    </p>
+    Text of the gist:
+    [:gist: 0]
+
+Error Case: non-existent file:
+
+    Text of the gist:
+    [:gist: 4747847 doesntexist.py]
 """
 
-from __future__ import unicode_literals, print_function
+import requests
+
+from nikola.plugin_categories import MarkdownExtension
+from nikola.utils import get_logger
 
 try:
     from markdown.extensions import Extension
@@ -200,12 +90,8 @@ except ImportError:
     # the markdown compiler will fail first
     Extension = Pattern = object
 
-from nikola.plugin_categories import MarkdownExtension
-from nikola.utils import get_logger, STDERR_HANDLER
-
-import requests
 
-LOGGER = get_logger('compile_markdown.mdx_gist', STDERR_HANDLER)
+LOGGER = get_logger('compile_markdown.mdx_gist')
 
 GIST_JS_URL = "https://gist.github.com/{0}.js"
 GIST_FILE_JS_URL = "https://gist.github.com/{0}.js?file={1}"
@@ -217,7 +103,6 @@ GIST_RST_RE = r'(?m)^\.\.\s*gist::\s*(?P<gist_id>[^\]\s]+)(?:\s*(?P<filename>.+?
 
 
 class GistFetchException(Exception):
-
     """Raised when attempt to fetch content of a Gist from github.com fails."""
 
     def __init__(self, url, status_code):
@@ -228,7 +113,6 @@ class GistFetchException(Exception):
 
 
 class GistPattern(Pattern):
-
     """InlinePattern for footnote markers in a document's body text."""
 
     def __init__(self, pattern, configs):
@@ -282,7 +166,7 @@ class GistPattern(Pattern):
             pre_elem.text = AtomicString(raw_gist)
 
         except GistFetchException as e:
-            LOGGER.warn(e.message)
+            LOGGER.warning(e.message)
             warning_comment = etree.Comment(' WARNING: {0} '.format(e.message))
             noscript_elem.append(warning_comment)
 
@@ -290,7 +174,6 @@ class GistPattern(Pattern):
 
 
 class GistExtension(MarkdownExtension, Extension):
-
     """Gist extension for Markdown."""
 
     def __init__(self, configs={}):
@@ -302,15 +185,15 @@ class GistExtension(MarkdownExtension, Extension):
         for key, value in configs:
             self.setConfig(key, value)
 
-    def extendMarkdown(self, md, md_globals):
+    def extendMarkdown(self, md, md_globals=None):
         """Extend Markdown."""
         gist_md_pattern = GistPattern(GIST_MD_RE, self.getConfigs())
         gist_md_pattern.md = md
-        md.inlinePatterns.add('gist', gist_md_pattern, "<not_strong")
+        md.inlinePatterns.register(gist_md_pattern, 'gist', 175)
 
         gist_rst_pattern = GistPattern(GIST_RST_RE, self.getConfigs())
         gist_rst_pattern.md = md
-        md.inlinePatterns.add('gist-rst', gist_rst_pattern, ">gist")
+        md.inlinePatterns.register(gist_rst_pattern, 'gist-rst', 176)
 
         md.registerExtension(self)
 
@@ -319,6 +202,7 @@ def makeExtension(configs=None):  # pragma: no cover
     """Make Markdown extension."""
     return GistExtension(configs)
 
+
 if __name__ == '__main__':
     import doctest
 
diff --git a/nikola/plugins/compile/markdown/mdx_nikola.plugin b/nikola/plugins/compile/markdown/mdx_nikola.plugin
index 12e4fb6..9751598 100644
--- a/nikola/plugins/compile/markdown/mdx_nikola.plugin
+++ b/nikola/plugins/compile/markdown/mdx_nikola.plugin
@@ -4,11 +4,11 @@ module = mdx_nikola
 
 [Nikola]
 compiler = markdown
-plugincategory = CompilerExtension
+PluginCategory = CompilerExtension
 
 [Documentation]
 author = Roberto Alsina
 version = 0.1
-website = http://getnikola.com
+website = https://getnikola.com/
 description = Nikola-specific Markdown extensions
 
diff --git a/nikola/plugins/compile/markdown/mdx_nikola.py b/nikola/plugins/compile/markdown/mdx_nikola.py
index 54cc18c..06a6d9a 100644
--- a/nikola/plugins/compile/markdown/mdx_nikola.py
+++ b/nikola/plugins/compile/markdown/mdx_nikola.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-# Copyright © 2012-2015 Roberto Alsina and others.
+# Copyright © 2012-2020 Roberto Alsina and others.
 
 # Permission is hereby granted, free of charge, to any
 # person obtaining a copy of this software and associated
@@ -24,25 +24,31 @@
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"""Markdown Extension for Nikola-specific post-processing."""
+"""Markdown Extension for Nikola.
+
+- Specific post-processing.
+- Strikethrough inline patterns.
+"""
 
-from __future__ import unicode_literals
 import re
+
+from nikola.plugin_categories import MarkdownExtension
+
 try:
     from markdown.postprocessors import Postprocessor
+    from markdown.inlinepatterns import SimpleTagPattern
     from markdown.extensions import Extension
 except ImportError:
     # No need to catch this, if you try to use this without Markdown,
     # the markdown compiler will fail first
-    Postprocessor = Extension = object
+    Postprocessor = SimpleTagPattern = Extension = object
 
-from nikola.plugin_categories import MarkdownExtension
 
 CODERE = re.compile('<div class="codehilite"><pre>(.*?)</pre></div>', flags=re.MULTILINE | re.DOTALL)
+STRIKE_RE = r"(~{2})(.+?)(~{2})"  # ~~strike~~
 
 
 class NikolaPostProcessor(Postprocessor):
-
     """Nikola-specific post-processing for Markdown."""
 
     def run(self, text):
@@ -57,13 +63,22 @@ class NikolaPostProcessor(Postprocessor):
 
 
 class NikolaExtension(MarkdownExtension, Extension):
+    """Nikola Markdown extensions."""
 
-    """Extension for injecting the postprocessor."""
-
-    def extendMarkdown(self, md, md_globals):
+    def _add_nikola_post_processor(self, md):
         """Extend Markdown with the postprocessor."""
         pp = NikolaPostProcessor()
-        md.postprocessors.add('nikola_post_processor', pp, '_end')
+        md.postprocessors.register(pp, 'nikola_post_processor', 1)
+
+    def _add_strikethrough_inline_pattern(self, md):
+        """Support PHP-Markdown style strikethrough, for example: ``~~strike~~``."""
+        pattern = SimpleTagPattern(STRIKE_RE, 'del')
+        md.inlinePatterns.register(pattern, 'strikethrough', 175)
+
+    def extendMarkdown(self, md, md_globals=None):
+        """Extend markdown to Nikola flavours."""
+        self._add_nikola_post_processor(md)
+        self._add_strikethrough_inline_pattern(md)
         md.registerExtension(self)
 
 
diff --git a/nikola/plugins/compile/markdown/mdx_podcast.plugin b/nikola/plugins/compile/markdown/mdx_podcast.plugin
index c92a8a0..df5260d 100644
--- a/nikola/plugins/compile/markdown/mdx_podcast.plugin
+++ b/nikola/plugins/compile/markdown/mdx_podcast.plugin
@@ -4,11 +4,11 @@ module = mdx_podcast
 
 [Nikola]
 compiler = markdown
-plugincategory = CompilerExtension
+PluginCategory = CompilerExtension
 
 [Documentation]
 author = Roberto Alsina
 version = 0.1
-website = http://getnikola.com
+website = https://getnikola.com/
 description = Markdown extensions for embedding podcasts and other audio files
 
diff --git a/nikola/plugins/compile/markdown/mdx_podcast.py b/nikola/plugins/compile/markdown/mdx_podcast.py
index 61afdbf..5090407 100644
--- a/nikola/plugins/compile/markdown/mdx_podcast.py
+++ b/nikola/plugins/compile/markdown/mdx_podcast.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright © 2013-2015 Michael Rabbitt, Roberto Alsina and others.
+# Copyright © 2013-2020 Michael Rabbitt, Roberto Alsina and others.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
@@ -30,13 +30,12 @@ Extension to Python Markdown for Embedded Audio.
 Basic Example:
 
 >>> import markdown
->>> text = "[podcast]http://archive.org/download/Rebeldes_Stereotipos/rs20120609_1.mp3[/podcast]"
+>>> text = "[podcast]https://archive.org/download/Rebeldes_Stereotipos/rs20120609_1.mp3[/podcast]"
 >>> html = markdown.markdown(text, [PodcastExtension()])
 >>> print(html)
-<p><audio controls=""><source src="http://archive.org/download/Rebeldes_Stereotipos/rs20120609_1.mp3" type="audio/mpeg"></source></audio></p>
+<p><audio controls=""><source src="https://archive.org/download/Rebeldes_Stereotipos/rs20120609_1.mp3" type="audio/mpeg"></source></audio></p>
 """
 
-from __future__ import print_function, unicode_literals
 from nikola.plugin_categories import MarkdownExtension
 try:
     from markdown.extensions import Extension
@@ -51,7 +50,6 @@ PODCAST_RE = r'\[podcast\](?P<url>.+)\[/podcast\]'
 
 
 class PodcastPattern(Pattern):
-
     """InlinePattern for footnote markers in a document's body text."""
 
     def __init__(self, pattern, configs):
@@ -70,8 +68,7 @@ class PodcastPattern(Pattern):
 
 
 class PodcastExtension(MarkdownExtension, Extension):
-
-    """"Podcast extension for Markdown."""
+    """Podcast extension for Markdown."""
 
     def __init__(self, configs={}):
         """Initialize extension."""
@@ -82,11 +79,11 @@ class PodcastExtension(MarkdownExtension, Extension):
         for key, value in configs:
             self.setConfig(key, value)
 
-    def extendMarkdown(self, md, md_globals):
+    def extendMarkdown(self, md, md_globals=None):
         """Extend Markdown."""
         podcast_md_pattern = PodcastPattern(PODCAST_RE, self.getConfigs())
         podcast_md_pattern.md = md
-        md.inlinePatterns.add('podcast', podcast_md_pattern, "<not_strong")
+        md.inlinePatterns.register(podcast_md_pattern, 'podcast', 175)
         md.registerExtension(self)
 
 
@@ -94,6 +91,7 @@ def makeExtension(configs=None):  # pragma: no cover
     """Make Markdown extension."""
     return PodcastExtension(configs)
 
+
 if __name__ == '__main__':
     import doctest
     doctest.testmod(optionflags=(doctest.NORMALIZE_WHITESPACE +