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.
82 lines
2.2 KiB
Python
82 lines
2.2 KiB
Python
import re
|
|
from typing import TYPE_CHECKING, Match, Optional
|
|
|
|
from ._base import BaseDirective, DirectiveParser
|
|
|
|
if TYPE_CHECKING:
|
|
from ..block_parser import BlockParser
|
|
from ..core import BlockState
|
|
from ..markdown import Markdown
|
|
|
|
__all__ = ["RSTDirective"]
|
|
|
|
|
|
_directive_re = re.compile(
|
|
r"\.\.( +)(?P<type>[a-zA-Z0-9_-]+)\:\: *(?P<title>[^\n]*)(?:\n|$)"
|
|
r"(?P<options>(?: \1 {0,3}\:[a-zA-Z0-9_-]+\: *[^\n]*\n+)*)"
|
|
r"\n*(?P<text>(?: \1 {0,3}[^\n]*\n+)*)"
|
|
)
|
|
|
|
|
|
class RSTParser(DirectiveParser):
|
|
name = "rst_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:
|
|
full_content = m.group(0)
|
|
text = m.group("text")
|
|
pretext = full_content[: -len(text)]
|
|
leading = len(m.group(1)) + 2
|
|
return "\n".join(line[leading:] for line in text.splitlines()) + "\n"
|
|
|
|
|
|
class RSTDirective(BaseDirective):
|
|
"""A RST style of directive syntax is inspired by reStructuredText.
|
|
The syntax is very powerful that you can define a lot of custom
|
|
features on your own. The syntax looks like:
|
|
|
|
.. code-block:: text
|
|
|
|
.. directive-type:: directive value
|
|
:option-key: option value
|
|
:option-key: option value
|
|
|
|
content text here
|
|
|
|
To use ``RSTDirective``, developers can add it into plugin list in
|
|
the :class:`Markdown` instance:
|
|
|
|
.. code-block:: python
|
|
|
|
import mistune
|
|
from mistune.directives import RSTDirective, Admonition
|
|
|
|
md = mistune.create_markdown(plugins=[
|
|
# ...
|
|
RSTDirective([Admonition()]),
|
|
])
|
|
"""
|
|
|
|
parser = RSTParser
|
|
directive_pattern = r"^\.\. +[a-zA-Z0-9_-]+\:\:"
|
|
|
|
def parse_directive(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
|
|
m2 = _directive_re.match(state.src, state.cursor)
|
|
if not m2:
|
|
return None
|
|
|
|
self.parse_method(block, m2, state)
|
|
return m2.end()
|
|
|
|
def __call__(self, markdown: "Markdown") -> None:
|
|
super(RSTDirective, self).__call__(markdown)
|
|
self.register_block_parser(markdown)
|