You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
152 lines
4.7 KiB
Python
152 lines
4.7 KiB
Python
import re
|
|
from typing import TYPE_CHECKING, List, Match, Optional
|
|
|
|
from ._base import BaseDirective, DirectiveParser, DirectivePlugin
|
|
|
|
if TYPE_CHECKING:
|
|
from ..block_parser import BlockParser
|
|
from ..core import BlockState
|
|
from ..markdown import Markdown
|
|
|
|
|
|
__all__ = ["FencedDirective"]
|
|
|
|
|
|
_type_re = re.compile(r"^ *\{[a-zA-Z0-9_-]+\}")
|
|
_directive_re = re.compile(
|
|
r"\{(?P<type>[a-zA-Z0-9_-]+)\} *(?P<title>[^\n]*)(?:\n|$)"
|
|
r"(?P<options>(?:\:[a-zA-Z0-9_-]+\: *[^\n]*\n+)*)"
|
|
r"\n*(?P<text>(?:[^\n]*\n+)*)"
|
|
)
|
|
|
|
|
|
class FencedParser(DirectiveParser):
|
|
name = "fenced_directive"
|
|
|
|
@staticmethod
|
|
def parse_type(m: Match[str]) -> str:
|
|
return m.group("type")
|
|
|
|
@staticmethod
|
|
def parse_title(m: Match[str]) -> str:
|
|
return m.group("title")
|
|
|
|
@staticmethod
|
|
def parse_content(m: Match[str]) -> str:
|
|
return m.group("text")
|
|
|
|
|
|
class FencedDirective(BaseDirective):
|
|
"""A **fenced** style of directive looks like a fenced code block, it is
|
|
inspired by markdown-it-docutils. The syntax looks like:
|
|
|
|
.. code-block:: text
|
|
|
|
```{directive-type} title
|
|
:option-key: option value
|
|
:option-key: option value
|
|
|
|
content text here
|
|
```
|
|
|
|
To use ``FencedDirective``, developers can add it into plugin list in
|
|
the :class:`Markdown` instance:
|
|
|
|
.. code-block:: python
|
|
|
|
import mistune
|
|
from mistune.directives import FencedDirective, Admonition
|
|
|
|
md = mistune.create_markdown(plugins=[
|
|
# ...
|
|
FencedDirective([Admonition()]),
|
|
])
|
|
|
|
FencedDirective is using >= 3 backticks or curly-brackets for the fenced
|
|
syntax. Developers can change it to other characters, e.g. colon:
|
|
|
|
.. code-block:: python
|
|
|
|
directive = FencedDirective([Admonition()], ':')
|
|
|
|
And then the directive syntax would look like:
|
|
|
|
.. code-block:: text
|
|
|
|
::::{note} Nesting directives
|
|
You can nest directives by ensuring the start and end fence matching
|
|
the length. For instance, in this example, the admonition is started
|
|
with 4 colons, then it should end with 4 colons.
|
|
|
|
You can nest another admonition with other length of colons except 4.
|
|
|
|
:::{tip} Longer outermost fence
|
|
It would be better that you put longer markers for the outer fence,
|
|
and shorter markers for the inner fence. In this example, we put 4
|
|
colons outsie, and 3 colons inside.
|
|
:::
|
|
::::
|
|
|
|
:param plugins: list of directive plugins
|
|
:param markers: characters to determine the fence, default is backtick
|
|
and curly-bracket
|
|
"""
|
|
|
|
parser = FencedParser
|
|
|
|
def __init__(self, plugins: List[DirectivePlugin], markers: str = "`~") -> None:
|
|
super(FencedDirective, self).__init__(plugins)
|
|
self.markers = markers
|
|
_marker_pattern = "|".join(re.escape(c) for c in markers)
|
|
self.directive_pattern = (
|
|
r"^(?P<fenced_directive_mark>(?:" + _marker_pattern + r"){3,})"
|
|
r"\{[a-zA-Z0-9_-]+\}"
|
|
)
|
|
|
|
def _process_directive(self, block: "BlockParser", marker: str, start: int, state: "BlockState") -> Optional[int]:
|
|
mlen = len(marker)
|
|
cursor_start = start + len(marker)
|
|
|
|
_end_pattern = (
|
|
r"^ {0,3}" + marker[0] + "{" + str(mlen) + r",}"
|
|
r"[ \t]*(?:\n|$)"
|
|
)
|
|
_end_re = re.compile(_end_pattern, re.M)
|
|
|
|
_end_m = _end_re.search(state.src, cursor_start)
|
|
if _end_m:
|
|
text = state.src[cursor_start : _end_m.start()]
|
|
end_pos = _end_m.end()
|
|
else:
|
|
text = state.src[cursor_start:]
|
|
end_pos = state.cursor_max
|
|
|
|
m = _directive_re.match(text)
|
|
if not m:
|
|
return None
|
|
|
|
self.parse_method(block, m, state)
|
|
return end_pos
|
|
|
|
def parse_directive(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
|
|
marker = m.group("fenced_directive_mark")
|
|
return self._process_directive(block, marker, m.start(), state)
|
|
|
|
def parse_fenced_code(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
|
|
info = m.group("fenced_3")
|
|
if not info or not _type_re.match(info):
|
|
return block.parse_fenced_code(m, state)
|
|
|
|
if state.depth() >= block.max_nested_level:
|
|
return block.parse_fenced_code(m, state)
|
|
|
|
marker = m.group("fenced_2")
|
|
return self._process_directive(block, marker, m.start(), state)
|
|
|
|
def __call__(self, md: "Markdown") -> None:
|
|
super(FencedDirective, self).__call__(md)
|
|
if self.markers == "`~":
|
|
md.block.register("fenced_code", None, self.parse_fenced_code)
|
|
else:
|
|
self.register_block_parser(md, "fenced_code")
|