pax_global_header00006660000000000000000000000064141523477450014526gustar00rootroot0000000000000052 comment=aba72e6347e0c7ae8df9111a7d69cf0ab4bbf961 mdit-py-plugins-0.3.0/000077500000000000000000000000001415234774500145705ustar00rootroot00000000000000mdit-py-plugins-0.3.0/.github/000077500000000000000000000000001415234774500161305ustar00rootroot00000000000000mdit-py-plugins-0.3.0/.github/workflows/000077500000000000000000000000001415234774500201655ustar00rootroot00000000000000mdit-py-plugins-0.3.0/.github/workflows/tests.yml000066400000000000000000000035701415234774500220570ustar00rootroot00000000000000# This workflow will install Python dependencies, run tests and lint with a variety of Python versions # For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions name: continuous-integration on: push: branches: [master] tags: - 'v*' pull_request: jobs: pre-commit: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python 3.8 uses: actions/setup-python@v2 with: python-version: 3.8 - uses: pre-commit/action@v2.0.0 tests: runs-on: ubuntu-latest strategy: matrix: python-version: [pypy3, 3.6, 3.7, 3.8, 3.9] steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip pip install -e .[testing] - name: Run pytest run: | pytest --cov=mdit_py_plugins --cov-report=xml --cov-report=term-missing - name: Upload to Codecov uses: codecov/codecov-action@v1 with: name: mdit-py-plugins-pytests flags: pytests file: ./coverage.xml fail_ci_if_error: true publish: name: Publish to PyPi needs: [pre-commit, tests] if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags') runs-on: ubuntu-latest steps: - name: Checkout source uses: actions/checkout@v2 - name: Set up Python uses: actions/setup-python@v2 with: python-version: 3.8 - name: Build package run: | pip install build python -m build - name: Publish uses: pypa/gh-action-pypi-publish@v1.1.0 with: user: __token__ password: ${{ secrets.PYPI_KEY }} mdit-py-plugins-0.3.0/.gitignore000066400000000000000000000036121415234774500165620ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ pip-wheel-metadata/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # PEP 582; used by e.g. github.com/David-OConnor/pyflow __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ benchmark/extra/ node_modules/ coverage/ demo/ apidoc/ *.log __pycache__/ .ropeproject/ *.egg-info/ .vscode/ .DS_Store docs/api/ mdit-py-plugins-0.3.0/.pre-commit-config.yaml000066400000000000000000000023331415234774500210520ustar00rootroot00000000000000# Install pre-commit hooks via # pre-commit install exclude: > (?x)^( \.vscode/settings\.json| test.*\.md| test.*\.txt| test.*\.html| )$ repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v3.3.0 hooks: - id: check-json - id: check-yaml - id: end-of-file-fixer - id: trailing-whitespace - repo: https://github.com/mgedmin/check-manifest rev: "0.46" hooks: - id: check-manifest args: [--no-build-isolation] additional_dependencies: [setuptools>=46.4.0] # this is not used for now, # since it converts mdit-py-plugins to mdit_py_plugins and removes comments # - repo: https://github.com/asottile/setup-cfg-fmt # rev: v1.17.0 # hooks: # - id: setup-cfg-fmt - repo: https://github.com/timothycrosley/isort rev: 5.8.0 hooks: - id: isort - repo: https://github.com/psf/black rev: 20.8b1 hooks: - id: black - repo: https://gitlab.com/pycqa/flake8 rev: 3.9.1 hooks: - id: flake8 additional_dependencies: [flake8-bugbear==21.3.1] - repo: https://github.com/pre-commit/mirrors-mypy rev: v0.812 hooks: - id: mypy additional_dependencies: [markdown-it-py~=1.0] mdit-py-plugins-0.3.0/.readthedocs.yml000066400000000000000000000002271415234774500176570ustar00rootroot00000000000000version: 2 python: version: 3 install: - method: pip path: . extra_requirements: [rtd] sphinx: builder: html fail_on_warning: true mdit-py-plugins-0.3.0/CHANGELOG.md000066400000000000000000000030751415234774500164060ustar00rootroot00000000000000# Change Log ## 0.3.0 - 2021-12-03 - ⬆️ UPGRADE: Compatible with markdown-it-py `v2`. - ✨ NEW: Add field list plugin, Based on the [restructuredtext syntax](https://docutils.sourceforge.io/docs/ref/rst/restructuredtext.html#field-lists) - ♻️ REFACTOR: dollarmath plugin, `math_block_eqno` -> `math_block_label` token - ♻️ REFACTOR: Remove AttrDict usage from texmath - 👌 IMPROVE: Default HTML rendering for dollarmath and amsmath plugins - 👌 IMPROVE: Add render options for dollarmath and amsmath plugins - 👌 IMPROVE: MyST parsing of target blocks (allow whitespace) and roles (allow for new lines) ## 0.2.8 - 2021-05-03 🐛 FIX: `wordcount` update of minutes ## 0.2.7 - 2021-05-03 - ⬆️ UPDATE: markdown-it-py~=1.0 - ✨ NEW: Add `wordcount_plugin` - 👌 IMPROVE: `dollarmath`: Allow inline double-dollar - 👌 IMPROVE: `myst_blocks`: Parse multiline comments - 👌 IMPROVE: Replace use of `env` as an `AttrDict` - 🐛 FIX: `front_matter`: don't duplicate content storage in `Token.meta` ## 0.2.6 - 2021-03-17 👌 IMPROVE: Remove direct use of `Token.attrs` ## 0.2.5 - 2021-02-06 🐛 FIX: front-matter: `IndexError` if first line is single dash ## 0.2.2 - 2020-12-16 ✨ NEW: Add substitution_plugin (improvements in 0.2.3 and 0.2.4) ## 0.2.0 - 2020-12-14 Add mypy type-checking, code taken from: https://github.com/executablebooks/markdown-it-py/commit/2eb1fe6b47cc0ad4ebe954cabd91fb8e52a2f03d ## 0.1.0 - 2020-12-14 First release, code taken from: https://github.com/executablebooks/markdown-it-py/commit/3a5bdcc98e67de9df26ebb8bc7cd0221a0d6b51b mdit-py-plugins-0.3.0/LICENSE000066400000000000000000000020661415234774500156010ustar00rootroot00000000000000MIT License Copyright (c) 2020 ExecutableBookProject Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. mdit-py-plugins-0.3.0/MANIFEST.in000066400000000000000000000005241415234774500163270ustar00rootroot00000000000000exclude docs recursive-exclude docs * exclude tests recursive-exclude tests * exclude .pre-commit-config.yaml exclude .readthedocs.yml exclude tox.ini exclude .flake8 exclude codecov.yml exclude .mypy.ini include LICENSE include CHANGELOG.md include mdit_py_plugins/py.typed recursive-include mdit_py_plugins port.yaml LICENSE README.md mdit-py-plugins-0.3.0/README.md000066400000000000000000000022621415234774500160510ustar00rootroot00000000000000# mdit-py-plugins [![Github-CI][github-ci]][github-link] [![Coverage Status][codecov-badge]][codecov-link] [![PyPI][pypi-badge]][pypi-link] [![Conda][conda-badge]][conda-link] [![Code style: black][black-badge]][black-link] Collection of core plugins for [markdown-it-py](https://github.com/executablebooks/markdown-it-py). [github-ci]: https://github.com/executablebooks/mdit-py-plugins/workflows/continuous-integration/badge.svg [github-link]: https://github.com/executablebooks/mdit-py-plugins [pypi-badge]: https://img.shields.io/pypi/v/mdit-py-plugins.svg [pypi-link]: https://pypi.org/project/mdit-py-plugins [conda-badge]: https://anaconda.org/conda-forge/mdit-py-plugins/badges/version.svg [conda-link]: https://anaconda.org/conda-forge/mdit-py-plugins [codecov-badge]: https://codecov.io/gh/executablebooks/mdit-py-plugins/branch/master/graph/badge.svg [codecov-link]: https://codecov.io/gh/executablebooks/mdit-py-plugins [black-badge]: https://img.shields.io/badge/code%20style-black-000000.svg [black-link]: https://github.com/ambv/black [install-badge]: https://img.shields.io/pypi/dw/mdit-py-plugins?label=pypi%20installs [install-link]: https://pypistats.org/packages/mdit-py-plugins mdit-py-plugins-0.3.0/codecov.yml000066400000000000000000000002421415234774500167330ustar00rootroot00000000000000coverage: status: project: default: target: 93% threshold: 0.2% patch: default: target: 80% threshold: 0.2% mdit-py-plugins-0.3.0/docs/000077500000000000000000000000001415234774500155205ustar00rootroot00000000000000mdit-py-plugins-0.3.0/docs/conf.py000066400000000000000000000013601415234774500170170ustar00rootroot00000000000000project = "mdit-py-plugins" copyright = "2020, Executable Book Project" author = "Executable Book Project" master_doc = "index" extensions = [ "sphinx.ext.autodoc", "sphinx.ext.viewcode", "sphinx.ext.intersphinx", "myst_parser", ] exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] intersphinx_mapping = { "python": ("https://docs.python.org/3.8", None), "markdown_it": ("https://markdown-it-py.readthedocs.io/en/latest", None), } html_title = "mdit-py-plugins" html_theme = "sphinx_book_theme" html_theme_options = { "single_page": True, "use_edit_page_button": True, "repository_url": "https://github.com/executablebooks/mdit-py-plugins", "repository_branch": "master", "path_to_docs": "docs", } mdit-py-plugins-0.3.0/docs/index.md000066400000000000000000000057111415234774500171550ustar00rootroot00000000000000# Markdown-It-Py Plugin Extensions ## Built-in The following plugins are embedded within the core package: - [tables](https://help.github.com/articles/organizing-information-with-tables/) (GFM) - [strikethrough](https://help.github.com/articles/basic-writing-and-formatting-syntax/#styling-text) (GFM) These can be enabled individually: ```python from markdown_it import MarkdownIt md = MarkdownIt("commonmark").enable('table') ``` or as part of a configuration: ```python from markdown_it import MarkdownIt md = MarkdownIt("gfm-like") ``` ```{seealso} See [](markdown_it:using) ``` ## mdit-py-plugins package The [`mdit_py_plugins`](https://github.com/executablebooks/mdit-py-plugins), contains a number of common plugins. They can be chained and loaded *via*: ```python from markdown_it import MarkdownIt from mdit_py_plugins import plugin1, plugin2 md = MarkdownIt().use(plugin1, keyword=value).use(plugin2, keyword=value) html_string = md.render("some *Markdown*") ``` ## Front-Matter ```{eval-rst} .. autofunction:: mdit_py_plugins.front_matter.front_matter_plugin ``` ## Footnotes ```{eval-rst} .. autofunction:: mdit_py_plugins.footnote.footnote_plugin ``` ## Definition Lists ```{eval-rst} .. autofunction:: mdit_py_plugins.deflist.deflist_plugin ``` ## Task lists ```{eval-rst} .. autofunction:: mdit_py_plugins.tasklists.tasklists_plugin ``` ## Field Lists ```{eval-rst} .. autofunction:: mdit_py_plugins.field_list.fieldlist_plugin ``` ## Heading Anchors ```{eval-rst} .. autofunction:: mdit_py_plugins.anchors.anchors_plugin ``` ## Word Count ```{eval-rst} .. autofunction:: mdit_py_plugins.wordcount.wordcount_plugin ``` ## Containers ```{eval-rst} .. autofunction:: mdit_py_plugins.container.container_plugin ``` ## Math ```{eval-rst} .. autofunction:: mdit_py_plugins.texmath.texmath_plugin ``` ```{eval-rst} .. autofunction:: mdit_py_plugins.dollarmath.dollarmath_plugin ``` ```{eval-rst} .. autofunction:: mdit_py_plugins.amsmath.amsmath_plugin ``` ## MyST plugins `myst_blocks` and `myst_role` plugins are also available, for utilisation by the [MyST renderer](https://myst-parser.readthedocs.io/en/latest/using/syntax.html) ```{eval-rst} .. autofunction:: mdit_py_plugins.myst_role.myst_role_plugin .. autofunction:: mdit_py_plugins.myst_blocks.myst_block_plugin ``` ## Write your own Use the `mdit_py_plugins` as a guide to write your own, following the [markdown-it design principles](markdown_it:architecture). There are many other plugins which could easily be ported from the JS versions (and hopefully will): - [subscript](https://github.com/markdown-it/markdown-it-sub) - [superscript](https://github.com/markdown-it/markdown-it-sup) - [abbreviation](https://github.com/markdown-it/markdown-it-abbr) - [emoji](https://github.com/markdown-it/markdown-it-emoji) - [insert](https://github.com/markdown-it/markdown-it-ins) - [mark](https://github.com/markdown-it/markdown-it-mark) - ... and [others](https://www.npmjs.org/browse/keyword/markdown-it-plugin) mdit-py-plugins-0.3.0/mdit_py_plugins/000077500000000000000000000000001415234774500177765ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/__init__.py000066400000000000000000000000261415234774500221050ustar00rootroot00000000000000__version__ = "0.3.0" mdit-py-plugins-0.3.0/mdit_py_plugins/amsmath/000077500000000000000000000000001415234774500214305ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/amsmath/__init__.py000066400000000000000000000102321415234774500235370ustar00rootroot00000000000000"""An extension to capture amsmath latex environments.""" import re from typing import Callable, Optional from markdown_it import MarkdownIt from markdown_it.common.utils import escapeHtml from markdown_it.rules_block import StateBlock # Taken from amsmath version 2.1 # http://anorien.csc.warwick.ac.uk/mirrors/CTAN/macros/latex/required/amsmath/amsldoc.pdf ENVIRONMENTS = [ # 3.2 single equation with an automatically gen-erated number "equation", # 3.3 variation equation, used for equations that don’t fit on a single line "multline", # 3.5 a group of consecutive equations when there is no alignment desired among them "gather", # 3.6 Used for two or more equations when vertical alignment is desired "align", # allows the horizontal space between equationsto be explicitly specified. "alignat", # stretches the space betweenthe equation columns to the maximum possible width "flalign", # 4.1 The pmatrix, bmatrix, Bmatrix, vmatrix and Vmatrix have (respectively) # (),[],{},||,and ‖‖ delimiters built in. "matrix", "pmatrix", "bmatrix", "Bmatrix", "vmatrix", "Vmatrix", # eqnarray is another math environment, it is not part of amsmath, # and note that it is better to use align or equation+split instead "eqnarray", ] # other "non-top-level" environments: # 3.4 the split environment is for single equations that are too long to fit on one line # and hence must be split into multiple lines, # it is intended for use only inside some other displayed equation structure, # usually an equation, align, or gather environment # 3.7 variants gathered, aligned,and alignedat are provided # whose total width is the actual width of the contents; # thus they can be used as a component in a containing expression RE_OPEN = re.compile(r"\\begin\{(" + "|".join(ENVIRONMENTS) + r")([\*]?)\}") def amsmath_plugin(md: MarkdownIt, *, renderer: Optional[Callable[[str], str]] = None): """Parses TeX math equations, without any surrounding delimiters, only for top-level `amsmath `__ environments: .. code-block:: latex \\begin{gather*} a_1=b_1+c_1\\\\ a_2=b_2+c_2-d_2+e_2 \\end{gather*} :param renderer: Function to render content, by default escapes HTML """ md.block.ruler.before( "blockquote", "amsmath", amsmath_block, {"alt": ["paragraph", "reference", "blockquote", "list", "footnote_def"]}, ) if renderer is None: _renderer = lambda content: escapeHtml(content) else: _renderer = renderer def render_amsmath_block(self, tokens, idx, options, env): content = _renderer(str(tokens[idx].content)) return f'
\n{content}\n
\n' md.add_render_rule("amsmath", render_amsmath_block) def match_environment(string): match_open = RE_OPEN.match(string) if not match_open: return None environment = match_open.group(1) numbered = match_open.group(2) match_close = re.search( r"\\end\{" + environment + numbered.replace("*", r"\*") + "\\}", string ) if not match_close: return None return (environment, numbered, match_close.end()) def amsmath_block(state: StateBlock, startLine: int, endLine: int, silent: bool): # if it's indented more than 3 spaces, it should be a code block if state.sCount[startLine] - state.blkIndent >= 4: return False begin = state.bMarks[startLine] + state.tShift[startLine] outcome = match_environment(state.src[begin:]) if not outcome: return False environment, numbered, endpos = outcome endpos += begin line = startLine while line < endLine: if endpos >= state.bMarks[line] and endpos <= state.eMarks[line]: # line for end of block math found ... state.line = line + 1 break line += 1 if not silent: token = state.push("amsmath", "math", 0) token.block = True token.content = state.src[begin:endpos] token.meta = {"environment": environment, "numbered": numbered} token.map = [startLine, line] return True mdit-py-plugins-0.3.0/mdit_py_plugins/anchors/000077500000000000000000000000001415234774500214335ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/anchors/__init__.py000066400000000000000000000000571415234774500235460ustar00rootroot00000000000000from .index import anchors_plugin # noqa F401 mdit-py-plugins-0.3.0/mdit_py_plugins/anchors/index.py000066400000000000000000000077171415234774500231300ustar00rootroot00000000000000import re from typing import Callable, List, Optional, Set from markdown_it import MarkdownIt from markdown_it.rules_core import StateCore from markdown_it.token import Token def anchors_plugin( md: MarkdownIt, min_level: int = 1, max_level: int = 2, slug_func: Optional[Callable[[str], str]] = None, permalink: bool = False, permalinkSymbol: str = "¶", permalinkBefore: bool = False, permalinkSpace: bool = True, ): """Plugin for adding header anchors, based on `markdown-it-anchor `__ .. code-block:: md # Title String renders as: .. code-block:: html

Title String

:param min_level: minimum header level to apply anchors :param max_level: maximum header level to apply anchors :param slug_func: function to convert title text to id slug. :param permalink: Add a permalink next to the title :param permalinkSymbol: the symbol to show :param permalinkBefore: Add the permalink before the title, otherwise after :param permalinkSpace: Add a space between the permalink and the title Note, the default slug function aims to mimic the GitHub Markdown format, see: - https://github.com/jch/html-pipeline/blob/master/lib/html/pipeline/toc_filter.rb - https://gist.github.com/asabaylus/3071099 """ selected_levels = list(range(min_level, max_level + 1)) md.core.ruler.push( "anchor", _make_anchors_func( selected_levels, slug_func or slugify, permalink, permalinkSymbol, permalinkBefore, permalinkSpace, ), ) def _make_anchors_func( selected_levels: List[int], slug_func: Callable[[str], str], permalink: bool, permalinkSymbol: str, permalinkBefore: bool, permalinkSpace: bool, ): slugs: Set[str] = set() def _anchor_func(state: StateCore): for (idx, token) in enumerate(state.tokens): if token.type != "heading_open": continue level = int(token.tag[1]) if level not in selected_levels: continue inline_token = state.tokens[idx + 1] assert inline_token.children is not None title = "".join( child.content for child in inline_token.children if child.type in ["text", "code_inline"] ) slug = unique_slug(slug_func(title), slugs) token.attrSet("id", slug) if permalink: link_open = Token( "link_open", "a", 1, ) link_open.attrSet("class", "header-anchor") link_open.attrSet("href", f"#{slug}") link_tokens = [ link_open, Token("html_block", "", 0, content=permalinkSymbol), Token("link_close", "a", -1), ] if permalinkBefore: inline_token.children = ( link_tokens + ( [Token("text", "", 0, content=" ")] if permalinkSpace else [] ) + inline_token.children ) else: inline_token.children.extend( ([Token("text", "", 0, content=" ")] if permalinkSpace else []) + link_tokens ) return _anchor_func def slugify(title: str): return re.sub(r"[^\w\u4e00-\u9fff\- ]", "", title.strip().lower().replace(" ", "-")) def unique_slug(slug: str, slugs: set): uniq = slug i = 1 while uniq in slugs: uniq = f"{slug}-{i}" i += 1 slugs.add(uniq) return uniq mdit-py-plugins-0.3.0/mdit_py_plugins/colon_fence.py000066400000000000000000000064221415234774500226260ustar00rootroot00000000000000from markdown_it import MarkdownIt from markdown_it.common.utils import escapeHtml, unescapeAll from markdown_it.rules_block import StateBlock def colon_fence_plugin(md: MarkdownIt): """This plugin directly mimics regular fences, but with `:` colons. Example:: :::name contained text ::: """ md.block.ruler.before( "fence", "colon_fence", _rule, {"alt": ["paragraph", "reference", "blockquote", "list", "footnote_def"]}, ) md.add_render_rule("colon_fence", _render) def _rule(state: StateBlock, startLine: int, endLine: int, silent: bool): haveEndMarker = False pos = state.bMarks[startLine] + state.tShift[startLine] maximum = state.eMarks[startLine] # if it's indented more than 3 spaces, it should be a code block if state.sCount[startLine] - state.blkIndent >= 4: return False if pos + 3 > maximum: return False marker = state.srcCharCode[pos] # /* : */ if marker != 0x3A: return False # scan marker length mem = pos pos = state.skipChars(pos, marker) length = pos - mem if length < 3: return False markup = state.src[mem:pos] params = state.src[pos:maximum] # Since start is found, we can report success here in validation mode if silent: return True # search end of block nextLine = startLine while True: nextLine += 1 if nextLine >= endLine: # unclosed block should be autoclosed by end of document. # also block seems to be autoclosed by end of parent break pos = mem = state.bMarks[nextLine] + state.tShift[nextLine] maximum = state.eMarks[nextLine] if pos < maximum and state.sCount[nextLine] < state.blkIndent: # non-empty line with negative indent should stop the list: # - ``` # test break if state.srcCharCode[pos] != marker: continue if state.sCount[nextLine] - state.blkIndent >= 4: # closing fence should be indented less than 4 spaces continue pos = state.skipChars(pos, marker) # closing code fence must be at least as long as the opening one if pos - mem < length: continue # make sure tail has spaces only pos = state.skipSpaces(pos) if pos < maximum: continue haveEndMarker = True # found! break # If a fence has heading spaces, they should be removed from its inner block length = state.sCount[startLine] state.line = nextLine + (1 if haveEndMarker else 0) token = state.push("colon_fence", "code", 0) token.info = params token.content = state.getLines(startLine + 1, nextLine, length, True) token.markup = markup token.map = [startLine, state.line] return True def _render(self, tokens, idx, options, env): token = tokens[idx] info = unescapeAll(token.info).strip() if token.info else "" content = escapeHtml(token.content) block_name = "" if info: block_name = info.split()[0] return ( "
"
        + content
        + "
\n" ) mdit-py-plugins-0.3.0/mdit_py_plugins/container/000077500000000000000000000000001415234774500217605ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/container/LICENSE000066400000000000000000000020611415234774500227640ustar00rootroot00000000000000Copyright (c) 2015 Vitaly Puzrin, Alex Kocharin. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. mdit-py-plugins-0.3.0/mdit_py_plugins/container/README.md000066400000000000000000000047451415234774500232510ustar00rootroot00000000000000# markdown-it-container [![Build Status](https://img.shields.io/travis/markdown-it/markdown-it-container/master.svg?style=flat)](https://travis-ci.org/markdown-it/markdown-it-container) [![NPM version](https://img.shields.io/npm/v/markdown-it-container.svg?style=flat)](https://www.npmjs.org/package/markdown-it-container) [![Coverage Status](https://img.shields.io/coveralls/markdown-it/markdown-it-container/master.svg?style=flat)](https://coveralls.io/r/markdown-it/markdown-it-container?branch=master) > Plugin for creating block-level custom containers for [markdown-it](https://github.com/markdown-it/markdown-it) markdown parser. __v2.+ requires `markdown-it` v5.+, see changelog.__ With this plugin you can create block containers like: ``` ::: warning *here be dragons* ::: ``` .... and specify how they should be rendered. If no renderer defined, `
` with container name class will be created: ```html
here be dragons
``` Markup is the same as for [fenced code blocks](http://spec.commonmark.org/0.18/#fenced-code-blocks). Difference is, that marker use another character and content is rendered as markdown markup. ## Installation node.js, browser: ```bash $ npm install markdown-it-container --save $ bower install markdown-it-container --save ``` ## API ```js var md = require('markdown-it')() .use(require('markdown-it-container'), name [, options]); ``` Params: - __name__ - container name (mandatory) - __options:__ - __validate__ - optional, function to validate tail after opening marker, should return `true` on success. - __render__ - optional, renderer function for opening/closing tokens. - __marker__ - optional (`:`), character to use in delimiter. ## Example ```js var md = require('markdown-it')(); md.use(require('markdown-it-container'), 'spoiler', { validate: function(params) { return params.trim().match(/^spoiler\s+(.*)$/); }, render: function (tokens, idx) { var m = tokens[idx].info.trim().match(/^spoiler\s+(.*)$/); if (tokens[idx].nesting === 1) { // opening tag return '
' + md.utils.escapeHtml(m[1]) + '\n'; } else { // closing tag return '
\n'; } } }); console.log(md.render('::: spoiler click me\n*content*\n:::\n')); // Output: // //
click me //

content

//
``` ## License [MIT](https://github.com/markdown-it/markdown-it-container/blob/master/LICENSE) mdit-py-plugins-0.3.0/mdit_py_plugins/container/__init__.py000066400000000000000000000000611415234774500240660ustar00rootroot00000000000000from .index import container_plugin # noqa F401 mdit-py-plugins-0.3.0/mdit_py_plugins/container/index.py000066400000000000000000000123571415234774500234510ustar00rootroot00000000000000"""Process block-level custom containers.""" from math import floor from typing import Callable, Optional from markdown_it import MarkdownIt from markdown_it.common.utils import charCodeAt from markdown_it.rules_block import StateBlock def container_plugin( md: MarkdownIt, name: str, marker: str = ":", validate: Optional[Callable[[str, str], bool]] = None, render=None, ): """Plugin ported from `markdown-it-container `__. It is a plugin for creating block-level custom containers: .. code-block:: md :::: name ::: name *markdown* ::: :::: :param name: the name of the container to parse :param marker: the marker character to use :param validate: func(marker, param) -> bool, default matches against the name :param render: render func """ def validateDefault(params: str, *args): return params.strip().split(" ", 2)[0] == name def renderDefault(self, tokens, idx, _options, env): # add a class to the opening tag if tokens[idx].nesting == 1: tokens[idx].attrJoin("class", name) return self.renderToken(tokens, idx, _options, env) min_markers = 3 marker_str = marker marker_char = charCodeAt(marker_str, 0) marker_len = len(marker_str) validate = validate or validateDefault render = render or renderDefault def container_func(state: StateBlock, startLine: int, endLine: int, silent: bool): auto_closed = False start = state.bMarks[startLine] + state.tShift[startLine] maximum = state.eMarks[startLine] # Check out the first character quickly, # this should filter out most of non-containers if marker_char != state.srcCharCode[start]: return False # Check out the rest of the marker string pos = start + 1 while pos <= maximum: try: character = state.src[pos] except IndexError: break if marker_str[(pos - start) % marker_len] != character: break pos += 1 marker_count = floor((pos - start) / marker_len) if marker_count < min_markers: return False pos -= (pos - start) % marker_len markup = state.src[start:pos] params = state.src[pos:maximum] assert validate is not None if not validate(params, markup): return False # Since start is found, we can report success here in validation mode if silent: return True # Search for the end of the block nextLine = startLine while True: nextLine += 1 if nextLine >= endLine: # unclosed block should be autoclosed by end of document. # also block seems to be autoclosed by end of parent break start = state.bMarks[nextLine] + state.tShift[nextLine] maximum = state.eMarks[nextLine] if start < maximum and state.sCount[nextLine] < state.blkIndent: # non-empty line with negative indent should stop the list: # - ``` # test break if marker_char != state.srcCharCode[start]: continue if state.sCount[nextLine] - state.blkIndent >= 4: # closing fence should be indented less than 4 spaces continue pos = start + 1 while pos <= maximum: try: character = state.src[pos] except IndexError: break if marker_str[(pos - start) % marker_len] != character: break pos += 1 # closing code fence must be at least as long as the opening one if floor((pos - start) / marker_len) < marker_count: continue # make sure tail has spaces only pos -= (pos - start) % marker_len pos = state.skipSpaces(pos) if pos < maximum: continue # found! auto_closed = True break old_parent = state.parentType old_line_max = state.lineMax state.parentType = "container" # this will prevent lazy continuations from ever going past our end marker state.lineMax = nextLine token = state.push(f"container_{name}_open", "div", 1) token.markup = markup token.block = True token.info = params token.map = [startLine, nextLine] state.md.block.tokenize(state, startLine + 1, nextLine) token = state.push(f"container_{name}_close", "div", -1) token.markup = state.src[start:pos] token.block = True state.parentType = old_parent state.lineMax = old_line_max state.line = nextLine + (1 if auto_closed else 0) return True md.block.ruler.before( "fence", "container_" + name, container_func, {"alt": ["paragraph", "reference", "blockquote", "list"]}, ) md.add_render_rule(f"container_{name}_open", render) md.add_render_rule(f"container_{name}_close", render) mdit-py-plugins-0.3.0/mdit_py_plugins/container/port.yaml000066400000000000000000000002041415234774500236240ustar00rootroot00000000000000- package: markdown-it-container commit: adb3defde3a1c56015895b47ce4c6591b8b1e3a2 date: Jun 2, 2020 version: 3.0.0 changes: mdit-py-plugins-0.3.0/mdit_py_plugins/deflist/000077500000000000000000000000001415234774500214305ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/deflist/LICENSE000066400000000000000000000020661415234774500224410ustar00rootroot00000000000000Copyright (c) 2014-2015 Vitaly Puzrin, Alex Kocharin. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. mdit-py-plugins-0.3.0/mdit_py_plugins/deflist/README.md000066400000000000000000000023711415234774500227120ustar00rootroot00000000000000# markdown-it-deflist [![Build Status](https://img.shields.io/travis/markdown-it/markdown-it-deflist/master.svg?style=flat)](https://travis-ci.org/markdown-it/markdown-it-deflist) [![NPM version](https://img.shields.io/npm/v/markdown-it-deflist.svg?style=flat)](https://www.npmjs.org/package/markdown-it-deflist) [![Coverage Status](https://img.shields.io/coveralls/markdown-it/markdown-it-deflist/master.svg?style=flat)](https://coveralls.io/r/markdown-it/markdown-it-deflist?branch=master) > Definition list (`
`) tag plugin for [markdown-it](https://github.com/markdown-it/markdown-it) markdown parser. __v2.+ requires `markdown-it` v5.+, see changelog.__ Syntax is based on [pandoc definition lists](http://johnmacfarlane.net/pandoc/README.html#definition-lists). ## Install node.js, browser: ```bash npm install markdown-it-deflist --save bower install markdown-it-deflist --save ``` ## Use ```js var md = require('markdown-it')() .use(require('markdown-it-deflist')); md.render(/*...*/); ``` _Differences in browser._ If you load script directly into the page, without package system, module will add itself globally as `window.markdownitDeflist`. ## License [MIT](https://github.com/markdown-it/markdown-it-deflist/blob/master/LICENSE) mdit-py-plugins-0.3.0/mdit_py_plugins/deflist/__init__.py000066400000000000000000000000571415234774500235430ustar00rootroot00000000000000from .index import deflist_plugin # noqa F401 mdit-py-plugins-0.3.0/mdit_py_plugins/deflist/index.py000066400000000000000000000164031415234774500231150ustar00rootroot00000000000000"""Process definition lists.""" from markdown_it import MarkdownIt from markdown_it.rules_block import StateBlock def deflist_plugin(md: MarkdownIt): """Plugin ported from `markdown-it-deflist `__. The syntax is based on `pandoc definition lists `__: .. code-block:: md Term 1 : Definition 1 long form second paragraph Term 2 with *inline markup* ~ Definition 2a compact style ~ Definition 2b """ isSpace = md.utils.isSpace # type: ignore def skipMarker(state: StateBlock, line: int): """Search `[:~][\n ]`, returns next pos after marker on success or -1 on fail.""" start = state.bMarks[line] + state.tShift[line] maximum = state.eMarks[line] if start >= maximum: return -1 # Check bullet marker = state.srcCharCode[start] start += 1 if marker != 0x7E and marker != 0x3A: # ~ : return -1 pos = state.skipSpaces(start) # require space after ":" if start == pos: return -1 # no empty definitions, e.g. " : " if pos >= maximum: return -1 return start def markTightParagraphs(state: StateBlock, idx: int): level = state.level + 2 i = idx + 2 l2 = len(state.tokens) - 2 while i < l2: if ( state.tokens[i].level == level and state.tokens[i].type == "paragraph_open" ): state.tokens[i + 2].hidden = True state.tokens[i].hidden = True i += 2 i += 1 def deflist(state: StateBlock, startLine: int, endLine: int, silent: bool): if silent: # quirk: validation mode validates a dd block only, not a whole deflist if state.ddIndent < 0: return False return skipMarker(state, startLine) >= 0 nextLine = startLine + 1 if nextLine >= endLine: return False if state.isEmpty(nextLine): nextLine += 1 if nextLine >= endLine: return False if state.sCount[nextLine] < state.blkIndent: return False contentStart = skipMarker(state, nextLine) if contentStart < 0: return False # Start list listTokIdx = len(state.tokens) tight = True token = state.push("dl_open", "dl", 1) token.map = listLines = [startLine, 0] # Iterate list items dtLine = startLine ddLine = nextLine # One definition list can contain multiple DTs, # and one DT can be followed by multiple DDs. # # Thus, there is two loops here, and label is # needed to break out of the second one # break_outer = False while True: prevEmptyEnd = False token = state.push("dt_open", "dt", 1) token.map = [dtLine, dtLine] token = state.push("inline", "", 0) token.map = [dtLine, dtLine] token.content = state.getLines( dtLine, dtLine + 1, state.blkIndent, False ).strip() token.children = [] token = state.push("dt_close", "dt", -1) while True: token = state.push("dd_open", "dd", 1) token.map = itemLines = [nextLine, 0] pos = contentStart maximum = state.eMarks[ddLine] offset = ( state.sCount[ddLine] + contentStart - (state.bMarks[ddLine] + state.tShift[ddLine]) ) while pos < maximum: ch = state.srcCharCode[pos] if isSpace(ch): if ch == 0x09: offset += 4 - offset % 4 else: offset += 1 else: break pos += 1 contentStart = pos oldTight = state.tight oldDDIndent = state.ddIndent oldIndent = state.blkIndent oldTShift = state.tShift[ddLine] oldSCount = state.sCount[ddLine] oldParentType = state.parentType state.blkIndent = state.ddIndent = state.sCount[ddLine] + 2 state.tShift[ddLine] = contentStart - state.bMarks[ddLine] state.sCount[ddLine] = offset state.tight = True state.parentType = "deflist" state.md.block.tokenize(state, ddLine, endLine, True) # If any of list item is tight, mark list as tight if not state.tight or prevEmptyEnd: tight = False # Item become loose if finish with empty line, # but we should filter last element, because it means list finish prevEmptyEnd = (state.line - ddLine) > 1 and state.isEmpty( state.line - 1 ) state.tShift[ddLine] = oldTShift state.sCount[ddLine] = oldSCount state.tight = oldTight state.parentType = oldParentType state.blkIndent = oldIndent state.ddIndent = oldDDIndent token = state.push("dd_close", "dd", -1) itemLines[1] = nextLine = state.line if nextLine >= endLine: break_outer = True break if state.sCount[nextLine] < state.blkIndent: break_outer = True break contentStart = skipMarker(state, nextLine) if contentStart < 0: break ddLine = nextLine # go to the next loop iteration: # insert DD tag and repeat checking if break_outer: break_outer = False break if nextLine >= endLine: break dtLine = nextLine if state.isEmpty(dtLine): break if state.sCount[dtLine] < state.blkIndent: break ddLine = dtLine + 1 if ddLine >= endLine: break if state.isEmpty(ddLine): ddLine += 1 if ddLine >= endLine: break if state.sCount[ddLine] < state.blkIndent: break contentStart = skipMarker(state, ddLine) if contentStart < 0: break # go to the next loop iteration: # insert DT and DD tags and repeat checking # Finalise list token = state.push("dl_close", "dl", -1) listLines[1] = nextLine state.line = nextLine # mark paragraphs tight if needed if tight: markTightParagraphs(state, listTokIdx) return True md.block.ruler.before( "paragraph", "deflist", deflist, {"alt": ["paragraph", "reference", "blockquote"]}, ) mdit-py-plugins-0.3.0/mdit_py_plugins/deflist/port.yaml000066400000000000000000000002041415234774500232740ustar00rootroot00000000000000- package: markdown-it-deflist commit: 20db400948520308291da029a23b0751cb30f3a0 date: July 12, 2017 version: 2.0.3 changes: mdit-py-plugins-0.3.0/mdit_py_plugins/dollarmath/000077500000000000000000000000001415234774500221255ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/dollarmath/__init__.py000066400000000000000000000000621415234774500242340ustar00rootroot00000000000000from .index import dollarmath_plugin # noqa F401 mdit-py-plugins-0.3.0/mdit_py_plugins/dollarmath/index.py000066400000000000000000000263041415234774500236130ustar00rootroot00000000000000import re from typing import Any, Callable, Dict, Optional from markdown_it import MarkdownIt from markdown_it.common.utils import escapeHtml, isWhiteSpace from markdown_it.rules_block import StateBlock from markdown_it.rules_inline import StateInline def dollarmath_plugin( md: MarkdownIt, *, allow_labels: bool = True, allow_space: bool = True, allow_digits: bool = True, double_inline: bool = False, label_normalizer: Optional[Callable[[str], str]] = None, renderer: Optional[Callable[[str, Dict[str, Any]], str]] = None, label_renderer: Optional[Callable[[str], str]] = None, ) -> None: """Plugin for parsing dollar enclosed math, e.g. inline: ``$a=1$``, block: ``$$b=2$$`` This is an improved version of ``texmath``; it is more performant, and handles ``\\`` escaping properly and allows for more configuration. :param allow_labels: Capture math blocks with label suffix, e.g. ``$$a=1$$ (eq1)`` :param allow_space: Parse inline math when there is space after/before the opening/closing ``$``, e.g. ``$ a $`` :param allow_digits: Parse inline math when there is a digit before/after the opening/closing ``$``, e.g. ``1$`` or ``$2``. This is useful when also using currency. :param double_inline: Search for double-dollar math within inline contexts :param label_normalizer: Function to normalize the label, by default replaces whitespace with `-` :param renderer: Function to render content: `(str, {"display_mode": bool}) -> str`, by default escapes HTML :param label_renderer: Function to render labels, by default creates anchor """ if label_normalizer is None: label_normalizer = lambda label: re.sub(r"\s+", "-", label) md.inline.ruler.before( "escape", "math_inline", math_inline_dollar(allow_space, allow_digits, double_inline), ) md.block.ruler.before( "fence", "math_block", math_block_dollar(allow_labels, label_normalizer) ) # TODO the current render rules are really just for testing # would be good to allow "proper" math rendering, # e.g. https://github.com/roniemartinez/latex2mathml if renderer is None: _renderer = lambda content, _: escapeHtml(content) else: _renderer = renderer if label_renderer is None: _label_renderer = ( lambda label: f'' # noqa: E501 ) else: _label_renderer = label_renderer def render_math_inline(self, tokens, idx, options, env) -> str: content = _renderer(str(tokens[idx].content).strip(), {"display_mode": False}) return f'{content}' def render_math_inline_double(self, tokens, idx, options, env) -> str: content = _renderer(str(tokens[idx].content).strip(), {"display_mode": True}) return f'
{content}
' def render_math_block(self, tokens, idx, options, env) -> str: content = _renderer(str(tokens[idx].content).strip(), {"display_mode": True}) return f'
\n{content}\n
\n' def render_math_block_label(self, tokens, idx, options, env) -> str: content = _renderer(str(tokens[idx].content).strip(), {"display_mode": True}) _id = tokens[idx].info label = _label_renderer(tokens[idx].info) return f'
\n{label}\n{content}\n
\n' md.add_render_rule("math_inline", render_math_inline) md.add_render_rule("math_inline_double", render_math_inline_double) md.add_render_rule("math_block", render_math_block) md.add_render_rule("math_block_label", render_math_block_label) def is_escaped(state: StateInline, back_pos: int, mod: int = 0) -> bool: """Test if dollar is escaped.""" # count how many \ are before the current position backslashes = 0 while back_pos >= 0: back_pos = back_pos - 1 if state.srcCharCode[back_pos] == 0x5C: # /* \ */ backslashes += 1 else: break if not backslashes: return False # if an odd number of \ then ignore if (backslashes % 2) != mod: return True return False def math_inline_dollar( allow_space: bool = True, allow_digits: bool = True, allow_double: bool = False ) -> Callable[[StateInline, bool], bool]: """Generate inline dollar rule. :param allow_space: Parse inline math when there is space after/before the opening/closing ``$``, e.g. ``$ a $`` :param allow_digits: Parse inline math when there is a digit before/after the opening/closing ``$``, e.g. ``1$`` or ``$2``. This is useful when also using currency. :param allow_double: Search for double-dollar math within inline contexts """ def _math_inline_dollar(state: StateInline, silent: bool) -> bool: """Inline dollar rule. - Initial check: - check if first character is a $ - check if the first character is escaped - check if the next character is a space (if not allow_space) - check if the next character is a digit (if not allow_digits) - Advance one, if allow_double - Find closing (advance one, if allow_double) - Check closing: - check if the previous character is a space (if not allow_space) - check if the next character is a digit (if not allow_digits) - Check empty content """ # TODO options: # even/odd backslash escaping if state.srcCharCode[state.pos] != 0x24: # /* $ */ return False if not allow_space: # whitespace not allowed straight after opening $ try: if isWhiteSpace(state.srcCharCode[state.pos + 1]): return False except IndexError: return False if not allow_digits: # digit not allowed straight before opening $ try: if state.src[state.pos - 1].isdigit(): return False except IndexError: pass if is_escaped(state, state.pos): return False try: is_double = allow_double and state.srcCharCode[state.pos + 1] == 0x24 except IndexError: return False # find closing $ pos = state.pos + 1 + (1 if is_double else 0) found_closing = False while not found_closing: try: end = state.srcCharCode.index(0x24, pos) except ValueError: return False if is_escaped(state, end): pos = end + 1 continue try: if is_double and not state.srcCharCode[end + 1] == 0x24: pos = end + 1 continue except IndexError: return False if is_double: end += 1 found_closing = True if not found_closing: return False if not allow_space: # whitespace not allowed straight before closing $ try: if isWhiteSpace(state.srcCharCode[end - 1]): return False except IndexError: return False if not allow_digits: # digit not allowed straight after closing $ try: if state.src[end + 1].isdigit(): return False except IndexError: pass text = ( state.src[state.pos + 2 : end - 1] if is_double else state.src[state.pos + 1 : end] ) # ignore empty if not text: return False if not silent: token = state.push( "math_inline_double" if is_double else "math_inline", "math", 0 ) token.content = text token.markup = "$$" if is_double else "$" state.pos = end + 1 return True return _math_inline_dollar # reversed end of block dollar equation, with equation label DOLLAR_EQNO_REV = re.compile(r"^\s*\)([^)$\r\n]+?)\(\s*\${2}") def math_block_dollar( allow_labels: bool = True, label_normalizer: Optional[Callable[[str], str]] = None, ) -> Callable[[StateBlock, int, int, bool], bool]: """Generate block dollar rule.""" def _math_block_dollar( state: StateBlock, startLine: int, endLine: int, silent: bool ) -> bool: # TODO internal backslash escaping haveEndMarker = False startPos = state.bMarks[startLine] + state.tShift[startLine] end = state.eMarks[startLine] # if it's indented more than 3 spaces, it should be a code block if state.sCount[startLine] - state.blkIndent >= 4: return False if startPos + 2 > end: return False if ( state.srcCharCode[startPos] != 0x24 or state.srcCharCode[startPos + 1] != 0x24 ): # /* $ */ return False # search for end of block nextLine = startLine label = None # search for end of block on same line lineText = state.src[startPos:end] if len(lineText.strip()) > 3: if lineText.strip().endswith("$$"): haveEndMarker = True end = end - 2 - (len(lineText) - len(lineText.strip())) elif allow_labels: # reverse the line and match eqnoMatch = DOLLAR_EQNO_REV.match(lineText[::-1]) if eqnoMatch: haveEndMarker = True label = eqnoMatch.group(1)[::-1] end = end - eqnoMatch.end() # search for end of block on subsequent line if not haveEndMarker: while True: nextLine += 1 if nextLine >= endLine: break start = state.bMarks[nextLine] + state.tShift[nextLine] end = state.eMarks[nextLine] if end - start < 2: continue lineText = state.src[start:end] if lineText.strip().endswith("$$"): haveEndMarker = True end = end - 2 - (len(lineText) - len(lineText.strip())) break # reverse the line and match if allow_labels: eqnoMatch = DOLLAR_EQNO_REV.match(lineText[::-1]) if eqnoMatch: haveEndMarker = True label = eqnoMatch.group(1)[::-1] end = end - eqnoMatch.end() break if not haveEndMarker: return False state.line = nextLine + (1 if haveEndMarker else 0) token = state.push("math_block_label" if label else "math_block", "math", 0) token.block = True token.content = state.src[startPos + 2 : end] token.markup = "$$" token.map = [startLine, state.line] if label: token.info = label if label_normalizer is None else label_normalizer(label) return True return _math_block_dollar mdit-py-plugins-0.3.0/mdit_py_plugins/field_list/000077500000000000000000000000001415234774500221145ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/field_list/__init__.py000066400000000000000000000141121415234774500242240ustar00rootroot00000000000000"""Field list plugin""" from contextlib import contextmanager from typing import Tuple from markdown_it import MarkdownIt from markdown_it.rules_block import StateBlock def fieldlist_plugin(md: MarkdownIt): """Field lists are mappings from field names to field bodies, based on the `reStructureText syntax `_. .. code-block:: md :name *markup*: :name1: body content :name2: paragraph 1 paragraph 2 :name3: paragraph 1 paragraph 2 A field name may consist of any characters except colons (":"). Inline markup is parsed in field names. The field name is followed by whitespace and the field body. The field body may be empty or contain multiple body elements. The field body is aligned either by the start of the body on the first line or, if no body content is on the first line, by 2 spaces. """ md.block.ruler.before( "paragraph", "fieldlist", _fieldlist_rule, {"alt": ["paragraph", "reference", "blockquote"]}, ) def parseNameMarker(state: StateBlock, startLine: int) -> Tuple[int, str]: """Parse field name: `:name:` :returns: position after name marker, name text """ start = state.bMarks[startLine] + state.tShift[startLine] pos = start maximum = state.eMarks[startLine] # marker should have at least 3 chars (colon + character + colon) if pos + 2 >= maximum: return -1, "" # first character should be ':' if state.src[pos] != ":": return -1, "" # scan name length name_length = 1 found_close = False for ch in state.src[pos + 1 :]: if ch == "\n": break if ch == ":": # TODO backslash escapes found_close = True break name_length += 1 if not found_close: return -1, "" # get name name_text = state.src[pos + 1 : pos + name_length] # name should contain at least one character if not name_text.strip(): return -1, "" return pos + name_length + 1, name_text @contextmanager def set_parent_type(state: StateBlock, name: str): """Temporarily set parent type to `name`""" oldParentType = state.parentType state.parentType = name yield state.parentType = oldParentType def _fieldlist_rule(state: StateBlock, startLine: int, endLine: int, silent: bool): # adapted from markdown_it/rules_block/list.py::list_block # if it's indented more than 3 spaces, it should be a code block if state.sCount[startLine] - state.blkIndent >= 4: return False posAfterName, name_text = parseNameMarker(state, startLine) if posAfterName < 0: return False # For validation mode we can terminate immediately if silent: return True # start field list token = state.push("field_list_open", "dl", 1) token.attrSet("class", "field-list") token.map = listLines = [startLine, 0] # iterate list items nextLine = startLine with set_parent_type(state, "fieldlist"): while nextLine < endLine: # create name tokens token = state.push("fieldlist_name_open", "dt", 1) token.map = [startLine, startLine] token = state.push("inline", "", 0) token.map = [startLine, startLine] token.content = name_text token.children = [] token = state.push("fieldlist_name_close", "dt", -1) # set indent positions pos = posAfterName maximum = state.eMarks[nextLine] offset = ( state.sCount[nextLine] + posAfterName - (state.bMarks[startLine] + state.tShift[startLine]) ) # find indent to start of body on first line while pos < maximum: ch = state.srcCharCode[pos] if ch == 0x09: # \t offset += 4 - (offset + state.bsCount[nextLine]) % 4 elif ch == 0x20: # \s offset += 1 else: break pos += 1 contentStart = pos # set indent for body text if contentStart >= maximum: # no body on first line, so use constant indentation # TODO adapt to indentation of subsequent lines? indent = 2 else: indent = offset # Run subparser on the field body token = state.push("fieldlist_body_open", "dd", 1) token.map = itemLines = [startLine, 0] # change current state, then restore it after parser subcall oldTShift = state.tShift[startLine] oldSCount = state.sCount[startLine] oldBlkIndent = state.blkIndent state.tShift[startLine] = contentStart - state.bMarks[startLine] state.sCount[startLine] = offset state.blkIndent = indent state.md.block.tokenize(state, startLine, endLine) state.blkIndent = oldBlkIndent state.tShift[startLine] = oldTShift state.sCount[startLine] = oldSCount token = state.push("fieldlist_body_close", "dd", -1) nextLine = startLine = state.line itemLines[1] = nextLine if nextLine >= endLine: break contentStart = state.bMarks[startLine] # Try to check if list is terminated or continued. if state.sCount[nextLine] < state.blkIndent: break # if it's indented more than 3 spaces, it should be a code block if state.sCount[startLine] - state.blkIndent >= 4: break # get next field item posAfterName, name_text = parseNameMarker(state, startLine) if posAfterName < 0: break # Finalize list token = state.push("field_list_close", "dl", -1) listLines[1] = nextLine state.line = nextLine return True mdit-py-plugins-0.3.0/mdit_py_plugins/footnote/000077500000000000000000000000001415234774500216335ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/footnote/LICENSE000066400000000000000000000020661415234774500226440ustar00rootroot00000000000000Copyright (c) 2014-2015 Vitaly Puzrin, Alex Kocharin. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. mdit-py-plugins-0.3.0/mdit_py_plugins/footnote/__init__.py000066400000000000000000000000611415234774500237410ustar00rootroot00000000000000from .index import footnote_plugin # noqa: F401 mdit-py-plugins-0.3.0/mdit_py_plugins/footnote/index.py000066400000000000000000000304671415234774500233260ustar00rootroot00000000000000# Process footnotes # from typing import List, Optional from markdown_it import MarkdownIt from markdown_it.common.utils import isSpace from markdown_it.helpers import parseLinkLabel from markdown_it.rules_block import StateBlock from markdown_it.rules_inline import StateInline from markdown_it.token import Token def footnote_plugin(md: MarkdownIt): """Plugin ported from `markdown-it-footnote `__. It is based on the `pandoc definition `__: .. code-block:: md Normal footnote: Here is a footnote reference,[^1] and another.[^longnote] [^1]: Here is the footnote. [^longnote]: Here's one with multiple blocks. Subsequent paragraphs are indented to show that they belong to the previous footnote. """ md.block.ruler.before( "reference", "footnote_def", footnote_def, {"alt": ["paragraph", "reference"]} ) md.inline.ruler.after("image", "footnote_inline", footnote_inline) md.inline.ruler.after("footnote_inline", "footnote_ref", footnote_ref) md.core.ruler.after("inline", "footnote_tail", footnote_tail) md.add_render_rule("footnote_ref", render_footnote_ref) md.add_render_rule("footnote_block_open", render_footnote_block_open) md.add_render_rule("footnote_block_close", render_footnote_block_close) md.add_render_rule("footnote_open", render_footnote_open) md.add_render_rule("footnote_close", render_footnote_close) md.add_render_rule("footnote_anchor", render_footnote_anchor) # helpers (only used in other rules, no tokens are attached to those) md.add_render_rule("footnote_caption", render_footnote_caption) md.add_render_rule("footnote_anchor_name", render_footnote_anchor_name) # ## RULES ## def footnote_def(state: StateBlock, startLine: int, endLine: int, silent: bool): """Process footnote block definition""" start = state.bMarks[startLine] + state.tShift[startLine] maximum = state.eMarks[startLine] # line should be at least 5 chars - "[^x]:" if start + 4 > maximum: return False if state.srcCharCode[start] != 0x5B: # /* [ */ return False if state.srcCharCode[start + 1] != 0x5E: # /* ^ */ return False pos = start + 2 while pos < maximum: if state.srcCharCode[pos] == 0x20: return False if state.srcCharCode[pos] == 0x5D: # /* ] */ break pos += 1 if pos == start + 2: # no empty footnote labels return False pos += 1 if pos + 1 >= maximum or state.srcCharCode[pos] != 0x3A: # /* : */ return False if silent: return True pos += 1 label = state.src[start + 2 : pos - 2] state.env.setdefault("footnotes", {}).setdefault("refs", {})[":" + label] = -1 open_token = Token("footnote_reference_open", "", 1) open_token.meta = {"label": label} open_token.level = state.level state.level += 1 state.tokens.append(open_token) oldBMark = state.bMarks[startLine] oldTShift = state.tShift[startLine] oldSCount = state.sCount[startLine] oldParentType = state.parentType posAfterColon = pos initial = offset = ( state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine]) ) while pos < maximum: ch = state.srcCharCode[pos] if isSpace(ch): if ch == 0x09: offset += 4 - offset % 4 else: offset += 1 else: break pos += 1 state.tShift[startLine] = pos - posAfterColon state.sCount[startLine] = offset - initial state.bMarks[startLine] = posAfterColon state.blkIndent += 4 state.parentType = "footnote" if state.sCount[startLine] < state.blkIndent: state.sCount[startLine] += state.blkIndent state.md.block.tokenize(state, startLine, endLine, True) state.parentType = oldParentType state.blkIndent -= 4 state.tShift[startLine] = oldTShift state.sCount[startLine] = oldSCount state.bMarks[startLine] = oldBMark open_token.map = [startLine, state.line] token = Token("footnote_reference_close", "", -1) state.level -= 1 token.level = state.level state.tokens.append(token) return True def footnote_inline(state: StateInline, silent: bool): """Process inline footnotes (^[...])""" maximum = state.posMax start = state.pos if start + 2 >= maximum: return False if state.srcCharCode[start] != 0x5E: # /* ^ */ return False if state.srcCharCode[start + 1] != 0x5B: # /* [ */ return False labelStart = start + 2 labelEnd = parseLinkLabel(state, start + 1) # parser failed to find ']', so it's not a valid note if labelEnd < 0: return False # We found the end of the link, and know for a fact it's a valid link # so all that's left to do is to call tokenizer. # if not silent: refs = state.env.setdefault("footnotes", {}).setdefault("list", {}) footnoteId = len(refs) tokens: List[Token] = [] state.md.inline.parse( state.src[labelStart:labelEnd], state.md, state.env, tokens ) token = state.push("footnote_ref", "", 0) token.meta = {"id": footnoteId} refs[footnoteId] = {"content": state.src[labelStart:labelEnd], "tokens": tokens} state.pos = labelEnd + 1 state.posMax = maximum return True def footnote_ref(state: StateInline, silent: bool): """Process footnote references ([^...])""" maximum = state.posMax start = state.pos # should be at least 4 chars - "[^x]" if start + 3 > maximum: return False if "footnotes" not in state.env or "refs" not in state.env["footnotes"]: return False if state.srcCharCode[start] != 0x5B: # /* [ */ return False if state.srcCharCode[start + 1] != 0x5E: # /* ^ */ return False pos = start + 2 while pos < maximum: if state.srcCharCode[pos] == 0x20: return False if state.srcCharCode[pos] == 0x0A: return False if state.srcCharCode[pos] == 0x5D: # /* ] */ break pos += 1 if pos == start + 2: # no empty footnote labels return False if pos >= maximum: return False pos += 1 label = state.src[start + 2 : pos - 1] if (":" + label) not in state.env["footnotes"]["refs"]: return False if not silent: if "list" not in state.env["footnotes"]: state.env["footnotes"]["list"] = {} if state.env["footnotes"]["refs"][":" + label] < 0: footnoteId = len(state.env["footnotes"]["list"]) state.env["footnotes"]["list"][footnoteId] = {"label": label, "count": 0} state.env["footnotes"]["refs"][":" + label] = footnoteId else: footnoteId = state.env["footnotes"]["refs"][":" + label] footnoteSubId = state.env["footnotes"]["list"][footnoteId]["count"] state.env["footnotes"]["list"][footnoteId]["count"] += 1 token = state.push("footnote_ref", "", 0) token.meta = {"id": footnoteId, "subId": footnoteSubId, "label": label} state.pos = pos state.posMax = maximum return True def footnote_tail(state: StateBlock, *args, **kwargs): """Post-processing step, to move footnote tokens to end of the token stream. Also removes un-referenced tokens. """ insideRef = False refTokens = {} if "footnotes" not in state.env: return current: List[Token] = [] tok_filter = [] for tok in state.tokens: if tok.type == "footnote_reference_open": insideRef = True current = [] currentLabel = tok.meta["label"] tok_filter.append(False) continue if tok.type == "footnote_reference_close": insideRef = False # prepend ':' to avoid conflict with Object.prototype members refTokens[":" + currentLabel] = current tok_filter.append(False) continue if insideRef: current.append(tok) tok_filter.append((not insideRef)) state.tokens = [t for t, f in zip(state.tokens, tok_filter) if f] if "list" not in state.env.get("footnotes", {}): return foot_list = state.env["footnotes"]["list"] token = Token("footnote_block_open", "", 1) state.tokens.append(token) for i, foot_note in foot_list.items(): token = Token("footnote_open", "", 1) token.meta = {"id": i, "label": foot_note.get("label", None)} # TODO propagate line positions of original foot note # (but don't store in token.map, because this is used for scroll syncing) state.tokens.append(token) if "tokens" in foot_note: tokens = [] token = Token("paragraph_open", "p", 1) token.block = True tokens.append(token) token = Token("inline", "", 0) token.children = foot_note["tokens"] token.content = foot_note["content"] tokens.append(token) token = Token("paragraph_close", "p", -1) token.block = True tokens.append(token) elif "label" in foot_note: tokens = refTokens[":" + foot_note["label"]] state.tokens.extend(tokens) if state.tokens[len(state.tokens) - 1].type == "paragraph_close": lastParagraph: Optional[Token] = state.tokens.pop() else: lastParagraph = None t = ( foot_note["count"] if (("count" in foot_note) and (foot_note["count"] > 0)) else 1 ) j = 0 while j < t: token = Token("footnote_anchor", "", 0) token.meta = {"id": i, "subId": j, "label": foot_note.get("label", None)} state.tokens.append(token) j += 1 if lastParagraph: state.tokens.append(lastParagraph) token = Token("footnote_close", "", -1) state.tokens.append(token) token = Token("footnote_block_close", "", -1) state.tokens.append(token) ######################################## # Renderer partials def render_footnote_anchor_name(self, tokens, idx, options, env): n = str(tokens[idx].meta["id"] + 1) prefix = "" doc_id = env.get("docId", None) if isinstance(doc_id, str): prefix = f"-{doc_id}-" return prefix + n def render_footnote_caption(self, tokens, idx, options, env): n = str(tokens[idx].meta["id"] + 1) if tokens[idx].meta.get("subId", -1) > 0: n += ":" + str(tokens[idx].meta["subId"]) return "[" + n + "]" def render_footnote_ref(self, tokens, idx, options, env): ident = self.rules["footnote_anchor_name"](tokens, idx, options, env) caption = self.rules["footnote_caption"](tokens, idx, options, env) refid = ident if tokens[idx].meta.get("subId", -1) > 0: refid += ":" + str(tokens[idx].meta["subId"]) return ( '' + caption + "" ) def render_footnote_block_open(self, tokens, idx, options, env): return ( ( '
\n' if options.xhtmlOut else '
\n' ) + '
\n' + '
    \n' ) def render_footnote_block_close(self, tokens, idx, options, env): return "
\n
\n" def render_footnote_open(self, tokens, idx, options, env): ident = self.rules["footnote_anchor_name"](tokens, idx, options, env) if tokens[idx].meta.get("subId", -1) > 0: ident += ":" + tokens[idx].meta["subId"] return '
  • ' def render_footnote_close(self, tokens, idx, options, env): return "
  • \n" def render_footnote_anchor(self, tokens, idx, options, env): ident = self.rules["footnote_anchor_name"](tokens, idx, options, env) if tokens[idx].meta["subId"] > 0: ident += ":" + str(tokens[idx].meta["subId"]) # ↩ with escape code to prevent display as Apple Emoji on iOS return ' \u21a9\uFE0E' mdit-py-plugins-0.3.0/mdit_py_plugins/footnote/port.yaml000066400000000000000000000001701415234774500235010ustar00rootroot00000000000000- package: markdown-it-footnote commit: cab6665ba39c6eb517cbbae3baeb549004bf740c date: Jul 9, 2019 version: 3.0.2 mdit-py-plugins-0.3.0/mdit_py_plugins/front_matter/000077500000000000000000000000001415234774500225025ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/front_matter/LICENSE000066400000000000000000000020401415234774500235030ustar00rootroot00000000000000Copyright (c) 2016-2020 ParkSB. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. mdit-py-plugins-0.3.0/mdit_py_plugins/front_matter/__init__.py000066400000000000000000000000651415234774500246140ustar00rootroot00000000000000from .index import front_matter_plugin # noqa: F401 mdit-py-plugins-0.3.0/mdit_py_plugins/front_matter/index.py000066400000000000000000000100421415234774500241600ustar00rootroot00000000000000# Process front matter and pass to cb from math import floor from markdown_it import MarkdownIt from markdown_it.common.utils import charCodeAt from markdown_it.rules_block import StateBlock def front_matter_plugin(md: MarkdownIt): """Plugin ported from `markdown-it-front-matter `__. It parses initial metadata, stored between opening/closing dashes: .. code-block:: md --- valid-front-matter: true --- """ frontMatter = make_front_matter_rule() md.block.ruler.before( "table", "front_matter", frontMatter, {"alt": ["paragraph", "reference", "blockquote", "list"]}, ) def make_front_matter_rule(): min_markers = 3 marker_str = "-" marker_char = charCodeAt(marker_str, 0) marker_len = len(marker_str) def frontMatter(state: StateBlock, startLine: int, endLine: int, silent: bool): auto_closed = False start = state.bMarks[startLine] + state.tShift[startLine] maximum = state.eMarks[startLine] src_len = len(state.src) # Check out the first character of the first line quickly, # this should filter out non-front matter if startLine != 0 or marker_char != state.srcCharCode[0]: return False # Check out the rest of the marker string # while pos <= 3 pos = start + 1 while pos <= maximum and pos < src_len: if marker_str[(pos - start) % marker_len] != state.src[pos]: break pos += 1 marker_count = floor((pos - start) / marker_len) if marker_count < min_markers: return False pos -= (pos - start) % marker_len # Since start is found, we can report success here in validation mode if silent: return True # Search for the end of the block nextLine = startLine while True: nextLine += 1 if nextLine >= endLine: # unclosed block should be autoclosed by end of document. return False if state.src[start:maximum] == "...": break start = state.bMarks[nextLine] + state.tShift[nextLine] maximum = state.eMarks[nextLine] if start < maximum and state.sCount[nextLine] < state.blkIndent: # non-empty line with negative indent should stop the list: # - ``` # test break if marker_char != state.srcCharCode[start]: continue if state.sCount[nextLine] - state.blkIndent >= 4: # closing fence should be indented less than 4 spaces continue pos = start + 1 while pos < maximum: if marker_str[(pos - start) % marker_len] != state.src[pos]: break pos += 1 # closing code fence must be at least as long as the opening one if floor((pos - start) / marker_len) < marker_count: continue # make sure tail has spaces only pos -= (pos - start) % marker_len pos = state.skipSpaces(pos) if pos < maximum: continue # found! auto_closed = True break old_parent = state.parentType old_line_max = state.lineMax state.parentType = "container" # this will prevent lazy continuations from ever going past our end marker state.lineMax = nextLine token = state.push("front_matter", "", 0) token.hidden = True token.markup = marker_str * min_markers token.content = state.src[ state.bMarks[startLine + 1] : state.eMarks[nextLine - 1] ] token.block = True state.parentType = old_parent state.lineMax = old_line_max state.line = nextLine + (1 if auto_closed else 0) token.map = [startLine, state.line] return True return frontMatter mdit-py-plugins-0.3.0/mdit_py_plugins/front_matter/port.yaml000066400000000000000000000001741415234774500243540ustar00rootroot00000000000000- package: markdown-it-front-matter commit: b404f5d8fd536e7e9ddb276267ae0b6f76e9cf9d date: Feb 7, 2020 version: 0.2.1 mdit-py-plugins-0.3.0/mdit_py_plugins/myst_blocks/000077500000000000000000000000001415234774500223275ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/myst_blocks/__init__.py000066400000000000000000000000631415234774500244370ustar00rootroot00000000000000from .index import myst_block_plugin # noqa: F401 mdit-py-plugins-0.3.0/mdit_py_plugins/myst_blocks/index.py000066400000000000000000000103701415234774500240110ustar00rootroot00000000000000import itertools from markdown_it import MarkdownIt from markdown_it.common.utils import escapeHtml, isSpace from markdown_it.rules_block import StateBlock def myst_block_plugin(md: MarkdownIt): """Parse MyST targets (``(name)=``), blockquotes (``% comment``) and block breaks (``+++``).""" md.block.ruler.before( "blockquote", "myst_line_comment", line_comment, {"alt": ["paragraph", "reference", "blockquote", "list", "footnote_def"]}, ) md.block.ruler.before( "hr", "myst_block_break", block_break, {"alt": ["paragraph", "reference", "blockquote", "list", "footnote_def"]}, ) md.block.ruler.before( "hr", "myst_target", target, {"alt": ["paragraph", "reference", "blockquote", "list", "footnote_def"]}, ) md.add_render_rule("myst_target", render_myst_target) md.add_render_rule("myst_line_comment", render_myst_line_comment) def line_comment(state: StateBlock, startLine: int, endLine: int, silent: bool): pos = state.bMarks[startLine] + state.tShift[startLine] maximum = state.eMarks[startLine] # if it's indented more than 3 spaces, it should be a code block if state.sCount[startLine] - state.blkIndent >= 4: return False if state.src[pos] != "%": return False if silent: return True token = state.push("myst_line_comment", "", 0) token.attrSet("class", "myst-line-comment") token.content = state.src[pos + 1 : maximum].rstrip() token.markup = "%" # search end of block while appending lines to `token.content` for nextLine in itertools.count(startLine + 1): if nextLine >= endLine: break pos = state.bMarks[nextLine] + state.tShift[nextLine] maximum = state.eMarks[nextLine] if state.src[pos] != "%": break token.content += "\n" + state.src[pos + 1 : maximum].rstrip() state.line = nextLine token.map = [startLine, nextLine] return True def block_break(state: StateBlock, startLine: int, endLine: int, silent: bool): pos = state.bMarks[startLine] + state.tShift[startLine] maximum = state.eMarks[startLine] # if it's indented more than 3 spaces, it should be a code block if state.sCount[startLine] - state.blkIndent >= 4: return False marker = state.srcCharCode[pos] pos += 1 # Check block marker /* + */ if marker != 0x2B: return False # markers can be mixed with spaces, but there should be at least 3 of them cnt = 1 while pos < maximum: ch = state.srcCharCode[pos] if ch != marker and not isSpace(ch): break if ch == marker: cnt += 1 pos += 1 if cnt < 3: return False if silent: return True state.line = startLine + 1 token = state.push("myst_block_break", "hr", 0) token.attrSet("class", "myst-block") token.content = state.src[pos:maximum].strip() token.map = [startLine, state.line] token.markup = chr(marker) * cnt return True def target(state: StateBlock, startLine: int, endLine: int, silent: bool): pos = state.bMarks[startLine] + state.tShift[startLine] maximum = state.eMarks[startLine] # if it's indented more than 3 spaces, it should be a code block if state.sCount[startLine] - state.blkIndent >= 4: return False text = state.src[pos:maximum].strip() if not text.startswith("("): return False if not text.endswith(")="): return False if not text[1:-2]: return False if silent: return True state.line = startLine + 1 token = state.push("myst_target", "", 0) token.attrSet("class", "myst-target") token.content = text[1:-2] token.map = [startLine, state.line] return True def render_myst_target(self, tokens, idx, options, env): label = tokens[idx].content class_name = "myst-target" target = f'({label})=' return f'
    {target}
    ' def render_myst_line_comment(self, tokens, idx, options, env): # Strip leading whitespace from all lines content = "\n".join(line.lstrip() for line in tokens[idx].content.split("\n")) return f"" mdit-py-plugins-0.3.0/mdit_py_plugins/myst_role/000077500000000000000000000000001415234774500220135ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/myst_role/__init__.py000066400000000000000000000000621415234774500241220ustar00rootroot00000000000000from .index import myst_role_plugin # noqa: F401 mdit-py-plugins-0.3.0/mdit_py_plugins/myst_role/index.py000066400000000000000000000033261415234774500235000ustar00rootroot00000000000000import re from markdown_it import MarkdownIt from markdown_it.common.utils import escapeHtml from markdown_it.rules_inline import StateInline VALID_NAME_PATTERN = re.compile(r"^\{([a-zA-Z0-9\_\-\+\:]+)\}") def myst_role_plugin(md: MarkdownIt): """Parse ``{role-name}`content```""" md.inline.ruler.before("backticks", "myst_role", myst_role) md.add_render_rule("myst_role", render_myst_role) def myst_role(state: StateInline, silent: bool): # check name match = VALID_NAME_PATTERN.match(state.src[state.pos :]) if not match: return False name = match.group(1) # check for starting backslash escape try: if state.srcCharCode[state.pos - 1] == 0x5C: # /* \ */ # escaped (this could be improved in the case of edge case '\\{') return False except IndexError: pass # scan opening tick length start = pos = state.pos + match.end() try: while state.src[pos] == "`": pos += 1 except IndexError: return False tick_length = pos - start if not tick_length: return False # search for closing ticks match = re.search("`" * tick_length, state.src[pos + 1 :]) if not match: return False content = state.src[pos : pos + match.start() + 1].replace("\n", " ") if not silent: token = state.push("myst_role", "", 0) token.meta = {"name": name} token.content = content state.pos = pos + match.end() + 1 return True def render_myst_role(self, tokens, idx, options, env): token = tokens[idx] name = token.meta.get("name", "unknown") return ( '' f"{{{name}}}[{escapeHtml(token.content)}]" "" ) mdit-py-plugins-0.3.0/mdit_py_plugins/py.typed000066400000000000000000000000321415234774500214700ustar00rootroot00000000000000# Marker file for PEP 561 mdit-py-plugins-0.3.0/mdit_py_plugins/substitution.py000066400000000000000000000062261415234774500231320ustar00rootroot00000000000000from markdown_it import MarkdownIt from markdown_it.rules_block import StateBlock from markdown_it.rules_inline import StateInline def substitution_plugin( md: MarkdownIt, start_delimiter: str = "{", end_delimiter: str = "}" ): """A plugin to create substitution tokens. These, token should be handled by the renderer. Example:: {{ block }} a {{ inline }} b """ start_char = ord(start_delimiter) end_char = ord(end_delimiter) def _substitution_inline(state: StateInline, silent: bool): try: if ( state.srcCharCode[state.pos] != start_char or state.srcCharCode[state.pos + 1] != start_char ): return False except IndexError: return False pos = state.pos + 2 found_closing = False while True: try: end = state.srcCharCode.index(end_char, pos) except ValueError: return False try: if state.srcCharCode[end + 1] == end_char: found_closing = True break except IndexError: return False pos = end + 2 if not found_closing: return False text = state.src[state.pos + 2 : end].strip() state.pos = end + 2 if silent: return True token = state.push("substitution_inline", "span", 0) token.block = False token.content = text token.attrSet("class", "substitution") token.attrSet("text", text) token.markup = f"{start_delimiter}{end_delimiter}" return True def _substitution_block( state: StateBlock, startLine: int, endLine: int, silent: bool ): startPos = state.bMarks[startLine] + state.tShift[startLine] end = state.eMarks[startLine] # if it's indented more than 3 spaces, it should be a code block if state.sCount[startLine] - state.blkIndent >= 4: return False lineText = state.src[startPos:end].strip() try: if ( lineText[0] != start_delimiter or lineText[1] != start_delimiter or lineText[-1] != end_delimiter or lineText[-2] != end_delimiter or len(lineText) < 5 ): return False except IndexError: return False text = lineText[2:-2].strip() # special case if multiple on same line, e.g. {{a}}{{b}} if (end_delimiter * 2) in text: return False state.line = startLine + 1 if silent: return True token = state.push("substitution_block", "div", 0) token.block = True token.content = text token.attrSet("class", "substitution") token.attrSet("text", text) token.markup = f"{start_delimiter}{end_delimiter}" token.map = [startLine, state.line] return True md.block.ruler.before("fence", "substitution_block", _substitution_block) md.inline.ruler.before("escape", "substitution_inline", _substitution_inline) mdit-py-plugins-0.3.0/mdit_py_plugins/tasklists/000077500000000000000000000000001415234774500220175ustar00rootroot00000000000000mdit-py-plugins-0.3.0/mdit_py_plugins/tasklists/__init__.py000066400000000000000000000130551415234774500241340ustar00rootroot00000000000000"""Builds task/todo lists out of markdown lists with items starting with [ ] or [x]""" # Ported by Wolmar Nyberg Åkerström from https://github.com/revin/markdown-it-task-lists # ISC License # Copyright (c) 2016, Revin Guillen # # Permission to use, copy, modify, and/or distribute this software for any # purpose with or without fee is hereby granted, provided that the above # copyright notice and this permission notice appear in all copies. # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. from typing import List from uuid import uuid4 from markdown_it import MarkdownIt from markdown_it.token import Token def tasklists_plugin( md: MarkdownIt, enabled: bool = False, label: bool = False, label_after: bool = False, ): """Plugin for building task/todo lists out of markdown lists with items starting with [ ] or [x] .. Nothing else For example:: - [ ] An item that needs doing - [x] An item that is complete The rendered HTML checkboxes are disabled; to change this, pass a truthy value into the enabled property of the plugin options. :param enabled: True enables the rendered checkboxes :param label: True wraps the rendered list items in a
    .mdit-py-plugins-0.3.0/tests/fixtures/anchors.md000066400000000000000000000011451415234774500215630ustar00rootroot00000000000000basic (max level 2): . # H1 ## H2 ### H3 .

    H1

    H2

    H3

    . space: . # a b c .

    a b c

    . characters: . # a,b\cβÊ .

    a,b\cβÊ

    . emoji: . # 🚀a .

    🚀a

    . html entity: . # foo&bar .

    foo&bar

    . uniqueness: . # a # a ## a .

    a

    a

    a

    . standard (permalink after): . # a .

    a

    . standard (permalink before): . # a .

    a

    . mdit-py-plugins-0.3.0/tests/fixtures/colon_fence.md000066400000000000000000000077051415234774500224100ustar00rootroot00000000000000# The initial tests are adapted from the test for normal code fences in tests/test_port/fixtures/commonmark_spec.md src line: 1638 . ::: < > ::: .
    <
     >
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1665 . :: foo :: .

    :: foo ::

    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1676 . ::: aaa ~~~ ::: .
    aaa
    ~~~
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1688 . ::: aaa ``` ::: .
    aaa
    ```
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1702 . :::: aaa ::: :::::: .
    aaa
    :::
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1729 . ::: .
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1736 . ::::: ::: aaa .
    
    :::
    aaa
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1749 . > ::: > aaa bbb .
    aaa
    

    bbb

    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1765 . ::: ::: .
    
      
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1779 . ::: ::: .
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1791 . ::: aaa aaa ::: .
    aaa
    aaa
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1803 . ::: aaa aaa aaa ::: .
    aaa
    aaa
    aaa
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1817 . ::: aaa aaa aaa ::: .
    aaa
     aaa
    aaa
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1833 . ::: aaa ::: .
    :::
    aaa
    :::
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1848 . ::: aaa ::: .
    aaa
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1858 . ::: aaa ::: .
    aaa
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1870 . ::: aaa ::: .
    aaa
        :::
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1884 . ::: ::: aaa .
    aaa
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1907 . foo ::: bar ::: baz .

    foo

    bar
    

    baz

    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1946 . :::ruby def foo(x) return 3 end ::: .
    def foo(x)
      return 3
    end
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1974 . ::::; :::: .
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 1984 . ::: aa ::: foo .
    foo
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 2007 . ::: ::: aaa ::: .
    ::: aaa
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ src line: 2007 . ::: ::: aaa ::: .
    ::: aaa
    
    . ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Ending marker could be longer . ::::: name ::::: hello world :::::::::::::::: .
      hello world
    
    . Nested blocks . ::::: name :::: name xxx :::: ::::: .
    :::: name
    xxx
    ::::
    
    . Name could be adjacent to marker . :::name xxx ::: .
    xxx
    
    . They should terminate paragraphs . blah blah ::: name content ::: .

    blah blah

    content
    
    . They could be nested in lists . - ::: name - xxx ::: . . Or in blockquotes . > ::: name > xxx >> yyy > zzz > ::: .
    xxx
    > yyy
    zzz
    
    . List indentation quirks . - ::: name xxx yyy ::: - ::: name xxx yyy ::: .
    
    -  ::: name
     xxx
    yyy
    
    . mdit-py-plugins-0.3.0/tests/fixtures/container.md000066400000000000000000000047251415234774500221170ustar00rootroot00000000000000 Simple container . ::: name *content* ::: .

    content

    . Delimiters too short . :: name *content* :: .

    :: name content ::

    . Could contain block elements too . ::: name ### heading ----------- ::: .

    heading


    . Ending marker could be longer . ::::: name ::::: hello world :::::::::::::::: .

    hello world

    . Nested blocks . ::::: name :::: name xxx :::: ::::: .

    xxx

    . Incorrectly nested blocks . :::: name this block is closed with 5 markers below ::::: name auto-closed block ::::: :::: .

    this block is closed with 5 markers below

    auto-closed block

    ::::

    . Marker could be indented up to 3 spaces . ::: name content ::: ::: .

    content :::

    . But that's a code block . ::: name content ::: .
    ::: name
    content
    :::
    
    . Some more indent checks . ::: name not a code block code block ::: .

    not a code block

    code block
    
    . Name could be adjacent to marker . :::name xxx ::: .

    xxx

    . Or several spaces apart . ::: name xxx ::: .

    xxx

    . It could contain params . ::: name arg=123 foo=456 xxx ::: .

    xxx

    . But closing marker can't . ::: name xxx ::: arg=123 .

    xxx ::: arg=123

    . This however isn't a valid one . ::: namename xxx ::: .

    ::: namename xxx :::

    . Containers self-close at the end of the document . ::: name xxx .

    xxx

    . They should terminate paragraphs . blah blah ::: name content ::: .

    blah blah

    content

    . They could be nested in lists . - ::: name - xxx ::: . . Or in blockquotes . > ::: name > xxx >> yyy > zzz > ::: .

    xxx

    yyy zzz

    . List indentation quirks . - ::: name xxx yyy ::: - ::: name xxx yyy ::: .

    :::

    yyy :::

    . mdit-py-plugins-0.3.0/tests/fixtures/deflist.md000066400000000000000000000046471415234774500215720ustar00rootroot00000000000000 Pandoc (with slightly changed indents): . Term 1 : Definition 1 Term 2 with *inline markup* : Definition 2 { some code, part of Definition 2 } Third paragraph of definition 2. .
    Term 1

    Definition 1

    Term 2 with inline markup

    Definition 2

    { some code, part of Definition 2 }
    

    Third paragraph of definition 2.

    . Pandoc again: . Term 1 : Definition with lazy continuation. Second paragraph of the definition. .
    Term 1

    Definition with lazy continuation.

    Second paragraph of the definition.

    . Well, I might just copy-paste the third one while I'm at it: . Term 1 ~ Definition 1 Term 2 ~ Definition 2a ~ Definition 2b .
    Term 1
    Definition 1
    Term 2
    Definition 2a
    Definition 2b
    . Now, with our custom ones. Spaces after a colon: . Term 1 : paragraph Term 2 : code block .
    Term 1
    paragraph
    Term 2
    code block
    
    . There should be something after a colon by the way: . Non-term 1 : Non-term 2 : .

    Non-term 1 :

    Non-term 2 :

    . List is tight iff all dts are tight: . Term 1 : foo : bar Term 2 : foo : bar .
    Term 1

    foo

    bar

    Term 2

    foo

    bar

    . Regression test (first paragraphs shouldn't be tight): . Term 1 : foo bar Term 2 : foo .
    Term 1

    foo

    bar Term 2

    foo

    . Definition lists should be second last in the queue. Exemplī grātiā, this isn't a valid one: . # test : just a paragraph with a colon .

    test

    : just a paragraph with a colon

    . Nested definition lists: . test : foo : bar : baz : bar : foo .
    test
    foo
    bar
    baz
    bar
    foo
    . Regression test, tabs . Term 1 : code block .
    Term 1
    code block
    
    . Regression test (blockquote inside deflist) . foo : > bar : baz .
    foo

    bar

    baz
    . Coverage, 1 blank line . test .

    test

    . Coverage, 2 blank lines . test .

    test

    . mdit-py-plugins-0.3.0/tests/fixtures/dollar_math.md000066400000000000000000000214001415234774500224100ustar00rootroot00000000000000single dollar . $ .

    $

    . double-dollar . $$ .

    $$

    . single character inline equation. (valid=True) . $a$ .

    a

    . inline equation with single greek character (valid=True) . $\\varphi$ .

    \\varphi

    . simple equation starting and ending with numbers. (valid=True) . $1+1=2$ .

    1+1=2

    . simple equation including special html character. (valid=True) . $1+1<3$ .

    1+1<3

    . equation including backslashes. (valid=True) . $a \\backslash$ .

    a \\backslash

    . use of currency symbol, i.e. digits before/after opening/closing (valid=True) . 3$1+2$ $1+2$3 .

    3$1+2$ $1+2$3

    . use of currency symbol (valid=True) . If you solve $1+2$ you get $3 .

    If you solve 1+2 you get $3

    . inline fraction (valid=True) . $\\frac{1}{2}$ .

    \\frac{1}{2}

    . inline column vector (valid=True) . $\\begin{pmatrix}x\\\\y\\end{pmatrix}$ .

    \\begin{pmatrix}x\\\\y\\end{pmatrix}

    . inline bold vector notation (valid=True) . ${\\tilde\\bold e}_\\alpha$ .

    {\\tilde\\bold e}_\\alpha

    . exponentiation (valid=True) . $a^{b}$ .

    a^{b}

    . conjugate complex (valid=True) . $a^\*b$ with $a^\*$ .

    a^\*b with a^\*

    . Inline multi-line (valid=True) . a $a \not=1$ b .

    a a \not=1 b

    . Inline multi-line with newline (valid=False) . a $a \not=1$ b .

    a $a

    \not=1$ b

    . single block equation, greek index (valid=True) . $$e_\\alpha$$ .
    e_\\alpha
    . display equation on its own single line. (valid=True) . $$1+1=2$$ .
    1+1=2
    . display equation with number on its own single line. (valid=True) . $$1+1=2$$ (2) .
    1+1=2
    . inline equation followed by block equation. (valid=True) . ${e}_x$ $$e_\\alpha$$ .

    {e}_x

    e_\\alpha
    . underline tests (valid=True) . $$c{\\bold e}_x = a{\\bold e}_\\alpha - b\\tilde{\\bold e}_\\alpha$$ .
    c{\\bold e}_x = a{\\bold e}_\\alpha - b\\tilde{\\bold e}_\\alpha
    . non-numeric character before opening $ or after closing $ or both is allowed. (valid=True) . a$1+1=2$ $1+1=2$b c$x$d .

    a1+1=2 1+1=2b cxd

    . following dollar character '$' is allowed. (valid=True) . $x$ $ .

    x $

    . consecutive inline equations. (valid=True) . $x$ $y$ .

    x y

    . inline equation after '-' sign in text. (valid=True) . so-what is $x$ .

    so-what is x

    . display equation with line breaks. (valid=True) . $$ 1+1=2 $$ .
    1+1=2
    . multiple equations (valid=True) . $$ a = 1 $$ $$ b = 2 $$ .
    a = 1
    b = 2
    . equation followed by a labelled equation (valid=True) . $$ a = 1 $$ $$ b = 2 $$ (1) .
    a = 1
    b = 2
    . multiline equation. (valid=True) . $$\\begin{matrix} f & = & 2 + x + 3 \\ & = & 5 + x \\end{matrix}$$ .
    \\begin{matrix} f & = & 2 + x + 3 \\ & = & 5 + x \\end{matrix}
    . vector equation. (valid=True) . $$\\begin{pmatrix}x_2 \\\\ y_2 \\end{pmatrix} = \\begin{pmatrix} A & B \\\\ C & D \\end{pmatrix}\\cdot \\begin{pmatrix} x_1 \\\\ y_1 \\end{pmatrix}$$ .
    \\begin{pmatrix}x_2 \\\\ y_2 \\end{pmatrix} = \\begin{pmatrix} A & B \\\\ C & D \\end{pmatrix}\\cdot \\begin{pmatrix} x_1 \\\\ y_1 \\end{pmatrix}
    . display equation with equation number. (valid=True) . $$f(x) = x^2 - 1$$ (1) .
    f(x) = x^2 - 1
    . inline equation following code section. (valid=True) . `code`$a-b$ .

    codea-b

    . equation following code block. (valid=True) . ``` code ``` $$a+b$$ .
    code
    
    a+b
    . numbered equation following code block. (valid=True) . ``` code ``` $$a+b$$(1) .
    code
    
    a+b
    . Equations in list. (valid=True) . 1. $1+2$ 2. $2+3$ 1. $3+4$ .
    1. 1+2
    2. 2+3
      1. 3+4
    . Inline sum. (valid=True) . $\\sum\_{i=1}^n$ .

    \\sum\_{i=1}^n

    . Sum without equation number. (valid=True) . $$\\sum\_{i=1}^n$$ .
    \\sum\_{i=1}^n
    . Sum with equation number. (valid=True) . $$\\sum\_{i=1}\^n$$ (2) .
    \\sum\_{i=1}\^n
    . equation number always vertically aligned. (valid=True) . $${\\bold e}(\\varphi) = \\begin{pmatrix} \\cos\\varphi\\\\\\sin\\varphi \\end{pmatrix}$$ (3) .
    {\\bold e}(\\varphi) = \\begin{pmatrix} \\cos\\varphi\\\\\\sin\\varphi \\end{pmatrix}
    . inline equations in blockquote. (valid=True) . > see $a = b + c$ > $c^2=a^2+b^2$ (2) > $c^2=a^2+b^2$ .

    see a = b + c c^2=a^2+b^2 (2) c^2=a^2+b^2

    . display equation in blockquote. (valid=True) . > formula > > $$ a+b=c$$ (2) > > in blockquote. .

    formula

    a+b=c

    in blockquote.

    . mixed syntax: . $$ a=1 \\ b=2 $$ (abc) - ab $c=1$ d .
    a=1 \\ b=2
    . escaped dollars '\\$' are interpreted as dollar '$' characters. (valid=True) . \\$1+1=2$ $1+1=2\\$ .

    \1+1=2 1+1=2\\

    . empty line between text and display formula is required. (valid=False) . some text \$\\$a+b=c\$\$ .

    some text $\$a+b=c$$

    . whitespace character after opening $ or before closing $ is not allowed. (valid=False) . $ $ $ x$ $x $ .

    $ $ $ x$ $x $

    . new line in blockquote block (valid=False): . > \$\$ a+b\n=c\$\$ .

    $$ a+b\n=c$$

    . math-escaping: escaped start $: . \$p_2 = $a .

    $p_2 = $a

    . math-escaping: escaped end $: . $p_2 = \$a .

    $p_2 = $a

    . math-escaping: internal escaped $: . $p_2 = \$1$ .

    p_2 = \$1

    . math-escaping: double-escaped start $: . \\$p_2 = 1$ .

    \p_2 = 1

    . math-escaping: double-escaped end $: . $p_2 = \\$a .

    p_2 = \\a

    . Inline double-dollar start: . $$a=1$$ b .

    a=1
    b

    . Inline double-dollar end: . a $$a=1$$ .

    a

    a=1

    . Inline double-dollar enclosed: . a $$a=1$$ (1) b .

    a

    a=1
    (1) b

    . Inline double-dollar, escaped: . a \$$a=1$$ b .

    a $a=1$ b

    . Inline mixed single/double dollars: . Hence, for $\alpha \in (0, 1)$, $$ \mathbb P (\alpha \bar{X} \ge \mu) \le \alpha; $$ i.e., $[\alpha \bar{X}, \infty)$ is a lower 1-sided $1-\alpha$ confidence bound for $\mu$. .

    Hence, for \alpha \in (0, 1),

    \mathbb P (\alpha \bar{X} \ge \mu) \le \alpha;
    i.e., [\alpha \bar{X}, \infty) is a lower 1-sided 1-\alpha confidence bound for \mu.

    . display equation with label containing whitespace. (valid=True) . $$1+1=2$$ (a b) .
    1+1=2
    . mdit-py-plugins-0.3.0/tests/fixtures/field_list.md000066400000000000000000000050741415234774500222510ustar00rootroot00000000000000Body alignment: . :no body: :single line: content :paragraph: content running onto new line :body inline: paragraph 1 paragraph 2 paragraph 3 :body on 2nd line: paragraph 1 paragraph 2 :body on 3rd line: paragraph 1 paragraph 2 .
    no body
    single line

    content

    paragraph

    content running onto new line

    body inline

    paragraph 1

    paragraph 2

    paragraph 3

    body on 2nd line

    paragraph 1

    paragraph 2

    body on 3rd line

    paragraph 1

    paragraph 2

    . Empty name: . :: .

    ::

    . Whitespace only name: . : : .

    : :

    . Name markup: . :inline *markup*: .
    inline markup
    . Content paragraph markup: . :name: body *markup* .
    name

    body markup

    . Body list: . :name: - item 1 - item 2 :name: - item 1 - item 2 .
    name
    • item 1
    • item 2
    name
    • item 1
    • item 2
    . Body code block . :name: code :name: body code .
    name
    code
    
    name

    body

    code
    
    . Body blockquote: . :name: > item 1 > item 2 :name: > item 1 > item 2 .
    name

    item 1 item 2

    name

    item 1 item 2

    . Body fence: . :name: ```python code ``` .
    name
    code
    
    . Following blocks: . :name: body - item 1 :name: body > block quote :name: body ```python code ``` .
    name

    body

    name

    body

    block quote

    name

    body

    code
    
    . In list: . - :name: body - item 2 . . In blockquote: . > :name: body .
    name

    body

    . mdit-py-plugins-0.3.0/tests/fixtures/footnote.md000066400000000000000000000165741415234774500217770ustar00rootroot00000000000000 Pandoc example: . Here is a footnote reference,[^1] and another.[^longnote] [^1]: Here is the footnote. [^longnote]: Here's one with multiple blocks. Subsequent paragraphs are indented to show that they belong to the previous footnote. { some.code } The whole paragraph can be indented, or just the first line. In this way, multi-paragraph footnotes work like multi-paragraph list items. This paragraph won't be part of the note, because it isn't indented. .

    Here is a footnote reference,[1] and another.[2]

    This paragraph won't be part of the note, because it isn't indented.


    1. Here is the footnote. ↩︎

    2. Here's one with multiple blocks.

      Subsequent paragraphs are indented to show that they belong to the previous footnote.

      { some.code }
      

      The whole paragraph can be indented, or just the first line. In this way, multi-paragraph footnotes work like multi-paragraph list items. ↩︎

    . They could terminate each other: . [^1][^2][^3] [^1]: foo [^2]: bar [^3]: baz .

    [1][2][3]


    1. foo ↩︎

    2. bar ↩︎

    3. baz ↩︎

    . They could be inside blockquotes, and are lazy: . [^foo] > [^foo]: bar baz .

    [1]


    1. bar baz ↩︎

    . Their labels could not contain spaces or newlines: . [^ foo]: bar baz [^foo ]: bar baz .

    [^ foo]: bar baz

    [^foo ]: bar baz

    . We support inline notes too (pandoc example): . Here is an inline note.^[Inlines notes are easier to write, since you don't have to pick an identifier and move down to type the note.] .

    Here is an inline note.[1]


    1. Inlines notes are easier to write, since you don't have to pick an identifier and move down to type the note. ↩︎

    . They could have arbitrary markup: . foo^[ *bar* ] .

    foo[1]


    1. bar ↩︎

    . Duplicate footnotes: . [^xxxxx] [^xxxxx] [^xxxxx]: foo .

    [1] [1:1]


    1. foo ↩︎ ↩︎

    . Indents: . [^xxxxx] [^yyyyy] [^xxxxx]: foo --- [^yyyyy]: foo --- .

    [1] [2]



    1. foo

      ↩︎
    2. foo ↩︎

    . Indents for the first line: . [^xxxxx] [^yyyyy] [^xxxxx]: foo [^yyyyy]: foo .

    [1] [2]


    1. foo ↩︎

    2. foo
      
    . Indents for the first line (tabs): . [^xxxxx] [^xxxxx]: foo .

    [1]


    1. foo ↩︎

    . Security 1 . [^__proto__] [^__proto__]: blah .

    [1]


    1. blah ↩︎

    . Security 2 . [^hasOwnProperty] [^hasOwnProperty]: blah .

    [1]


    1. blah ↩︎

    . Should allow links in inline footnotes . Example^[this is another example https://github.com] .

    Example[1]


    1. this is another example https://github.com ↩︎

    . Nested blocks: . [^a] [^a]: abc def hij - list > block terminates here .

    [1]

    terminates here


    1. abc

      def hij

      • list

      block

      ↩︎
    . Empty lines after blockquote+footnote (markdown-it-py#133) . > b [^1] Some text > c [^1]: d .

    b [1]

    Some text

    c


    1. d ↩︎

    . mdit-py-plugins-0.3.0/tests/fixtures/front_matter.md000066400000000000000000000015511415234774500226330ustar00rootroot00000000000000 should parse empty front matter: . --- --- # Head .

    Head

    . should parse basic front matter: . --- x: 1 --- # Head .

    Head

    . should parse until triple dots: . --- x: 1 ... # Head .

    Head

    . should parse front matter with indentation: . --- title: Associative arrays people: name: John Smith age: 33 morePeople: { name: Grace Jones, age: 21 } --- # Head .

    Head

    . should ignore spaces after front matter delimiters: . --- title: Associative arrays people: name: John Smith age: 33 morePeople: { name: Grace Jones, age: 21 } --- # Head .

    Head

    . should ignore front matter with less than 3 opening dashes: . -- x: 1 -- # Head .

    -- x: 1

    Head

    . should require front matter have matching number of opening and closing dashes: . ---- x: 1 --- # Head .

    x: 1

    Head

    . mdit-py-plugins-0.3.0/tests/fixtures/myst_block.md000066400000000000000000000026501415234774500222760ustar00rootroot00000000000000 Block Break: . +++ .
    . Block Break Split Markers: . + + + + xfsdfsdf .
    . Block Break Too Few Markers: . ++ .

    ++

    . Block Break terminates other blocks: . a +++ - b +++ > c +++ .

    a



    c


    . Target: . (a)= . . Target characters: . (a bc |@<>*./_-+:)= . . Empty target: . ()= .

    ()=

    . Escaped target: . \(a)= .

    (a)=

    . Indented target: . (a)= . . Target terminates other blocks: . a (a-b)= - b (a b)= > c (a)= .

    a

    c

    . Comment: . % abc . . Comment terminates other blocks: . a % abc - b % abc > c % abc .

    a

    c

    . Multiline comment: . a % abc % def - b % abc %def > c %abc % %def .

    a

    c

    . mdit-py-plugins-0.3.0/tests/fixtures/myst_role.md000066400000000000000000000022361415234774500221450ustar00rootroot00000000000000 Basic: . {abc}`xyz` .

    {abc}[xyz]

    . Multiple: . {abc}`xyz`{def}`uvw` .

    {abc}[xyz]{def}[uvw]

    . Surrounding Text: . a {abc}`xyz` b .

    a {abc}[xyz] b

    . New lines: . {abc}`xy z` `d e` .

    {abc}[xy z] d e

    . In Code: . `` {abc}`xyz` `` .

    {abc}`xyz`

    . Empty content: . {name}`` a .

    {name}`` a

    . Surrounding Code: . `a` {abc}`xyz` `b` .

    a {abc}[xyz] b

    . In list: . - {abc}`xyz` . . In Quote: . > {abc}`xyz` b .

    {abc}[xyz] b

    . Multiple ticks: . {abc}``xyz`` .

    {abc}[xyz]

    . Inner tick: . {abc}``x`yz`` .

    {abc}[x`yz]

    . Unbalanced ticks: . {abc}``xyz` .

    {abc}``xyz`

    . Space in name: . {ab c}`xyz` .

    {ab c}xyz

    . Escaped: . \{abc}`xyz` .

    {abc}xyz

    . mdit-py-plugins-0.3.0/tests/fixtures/substitution.md000066400000000000000000000026251415234774500227060ustar00rootroot00000000000000Basic (space): . {{ block }} a {{ inline }} b .

    a b

    . Basic (no space): . {{block}} a {{inline}} b .

    a b

    . Same line: . {{a}}{{b}} .

    . No closing: . {{ a {{b} {{c} } .

    {{ a

    {{b}

    {{c} }

    . Inside code . `{{ a }}` ```python {{b}} ``` .

    {{ a }}

    {{b}}
    
    . New line: . {{a}} {{b}} .
    . Blocks: . - {{a}} > {{b}} 1. {{c}} .
    . Inline: . - {{a}} x > {{b}} y 1. {{c}} z .
    • x

    y

    1. z
    . Tables: . | | | |-|-| |{{a}}|{{b}} c| .
    c
    . mdit-py-plugins-0.3.0/tests/fixtures/tasklists.md000066400000000000000000000064731415234774500221600ustar00rootroot00000000000000 bullet.md: . - [ ] unchecked item 1 - [ ] unchecked item 2 - [ ] unchecked item 3 - [x] checked item 4 .
    • unchecked item 1
    • unchecked item 2
    • unchecked item 3
    • checked item 4
    . dirty.md: . - [ ] unchecked todo item 1 - [ ] - [ ] not a todo item 2 - [ x] not a todo item 3 - [x ] not a todo item 4 - [ x ] not a todo item 5 - [x] todo item 6 .
    • unchecked todo item 1
    • [ ]
    • [ ] not a todo item 2
    • [ x] not a todo item 3
    • [x ] not a todo item 4
    • [ x ] not a todo item 5
    • todo item 6
    . mixed-nested.md: . # Test 1 1. foo * [ ] nested unchecked item 1 * not a todo item 2 * not a todo item 3 * [x] nested checked item 4 2. bar 3. spam # Test 2 - foo - [ ] nested unchecked item 1 - [ ] nested unchecked item 2 - [x] nested checked item 3 - [X] nested checked item 4 .

    Test 1

    1. foo
      • nested unchecked item 1
      • not a todo item 2
      • not a todo item 3
      • nested checked item 4
    2. bar
    3. spam

    Test 2

    • foo
      • nested unchecked item 1
      • nested unchecked item 2
      • nested checked item 3
      • nested checked item 4
    . oedered.md: . 1. [x] checked ordered 1 2. [ ] unchecked ordered 2 3. [x] checked ordered 3 4. [ ] unchecked ordered 4 .
    1. checked ordered 1
    2. unchecked ordered 2
    3. checked ordered 3
    4. unchecked ordered 4
    . mdit-py-plugins-0.3.0/tests/fixtures/texmath_bracket.md000066400000000000000000000120471415234774500232760ustar00rootroot00000000000000single character inline equation. (valid=True) . \(a\) .

    a

    . inline equation with single greek character (valid=True) . \(\\varphi\) .

    \\varphi

    . simple equation starting and ending with numbers. (valid=True) . \(1+1=2\) .

    1+1=2

    . simple equation including special html character. (valid=True) . \(1+1<3\) .

    1+1<3

    . equation including backslashes. (valid=True) . \(a \\backslash\) .

    a \\backslash

    . use of currency symbol (valid=True) . You get 3$ if you solve \(1+2\) .

    You get 3$ if you solve 1+2

    . use of currency symbol (valid=True) . If you solve \(1+2\) you get $3 .

    If you solve 1+2 you get $3

    . inline fraction (valid=True) . \(\\frac{1}{2}\) .

    \\frac{1}{2}

    . inline column vector (valid=True) . \(\\begin{pmatrix}x\\\\y\\end{pmatrix}\) .

    \\begin{pmatrix}x\\\\y\\end{pmatrix}

    . inline bold vector notation (valid=True) . \({\\tilde\\bold e}_\\alpha\) .

    {\\tilde\\bold e}_\\alpha

    . exponentiation (valid=True) . \(a^{b}\) .

    a^{b}

    . conjugate complex (valid=True) . \(a^\*b\) with \(a^\*\) .

    a^\*b with a^\*

    . Inline multi-line (valid=True) . a \(a \not=1\) b .

    a a \not=1 b

    . Inline multi-line with newline (valid=False) . a \(a \not=1\) b .

    a (a

    \not=1) b

    . single block equation, greek index (valid=True) . \[e_\\alpha\] .
    e_\\alpha
    . display equation on its own single line. (valid=True) . \[1+1=2\] .
    1+1=2
    . inline equation followed by block equation. (valid=True) . \({e}_x\) \[e_\\alpha\] .

    {e}_x

    e_\\alpha
    . underline tests (valid=True) . \[c{\\bold e}_x = a{\\bold e}_\\alpha - b\\tilde{\\bold e}_\\alpha\] .
    c{\\bold e}_x = a{\\bold e}_\\alpha - b\\tilde{\\bold e}_\\alpha
    . non-numeric character before opening $ or after closing $ or both is allowed. (valid=True) . a\(1+1=2\) \(1+1=2\)b c\(x\)d .

    a1+1=2 1+1=2b cxd

    . following dollar character '$' is allowed. (valid=True) . \(x\) $ .

    x $

    . consecutive inline equations. (valid=True) . \(x\) \(y\) .

    x y

    . inline equation after '-' sign in text. (valid=True) . so-what is \(x\) .

    so-what is x

    . display equation with line breaks. (valid=True) . \[ 1+1=2 \] .
    1+1=2
    . multiple equations (valid=True) . \[ a = 1 \] \[ b = 2 \] .
    a = 1
    b = 2
    . equation followed by a labelled equation (valid=True) . \[ a = 1 \] \[ b = 2 \] (1) .
    a = 1
    b = 2
    . multiline equation. (valid=True) . \[\\begin{matrix} f & = & 2 + x + 3 \\ & = & 5 + x \\end{matrix}\] .
    \\begin{matrix} f & = & 2 + x + 3 \\ & = & 5 + x \\end{matrix}
    . vector equation. (valid=True) . \[\\begin{pmatrix}x_2 \\\\ y_2 \\end{pmatrix} = \\begin{pmatrix} A & B \\\\ C & D \\end{pmatrix}\\cdot \\begin{pmatrix} x_1 \\\\ y_1 \\end{pmatrix}\] .
    \\begin{pmatrix}x_2 \\\\ y_2 \\end{pmatrix} = \\begin{pmatrix} A & B \\\\ C & D \\end{pmatrix}\\cdot \\begin{pmatrix} x_1 \\\\ y_1 \\end{pmatrix}
    . display equation with equation number. (valid=True) . \[f(x) = x^2 - 1\] (1) .
    f(x) = x^2 - 1
    . inline equation following code section. (valid=True) . `code`\(a-b\) .

    codea-b

    . equation following code block. (valid=True) . ``` code ``` \[a+b\] .
    code
    
    a+b
    . numbered equation following code block. (valid=True) . ``` code ``` \[a+b\](1) .
    code
    
    a+b
    . Equations in list. (valid=True) . 1. \(1+2\) 2. \(2+3\) 1. \(3+4\) .
    1. 1+2
    2. 2+3
      1. 3+4
    . Inline sum. (valid=True) . \(\\sum\_{i=1}^n\) .

    \\sum\_{i=1}^n

    . Sum without equation number. (valid=True) . \[\\sum\_{i=1}^n\] .
    \\sum\_{i=1}^n
    . Sum with equation number. (valid=True) . \[\\sum\_{i=1}\^n\] \(2\) .
    \\sum\_{i=1}\^n
    . equation number always vertically aligned. (valid=True) . \[{\\bold e}(\\varphi) = \\begin{pmatrix} \\cos\\varphi\\\\\\sin\\varphi \\end{pmatrix}\] (3) .
    {\\bold e}(\\varphi) = \\begin{pmatrix} \\cos\\varphi\\\\\\sin\\varphi \\end{pmatrix}
    . inline equations in blockquote. (valid=True) . > see \(a = b + c\) > \(c^2=a^2+b^2\) (2) > \(c^2=a^2+b^2\) .

    see a = b + c c^2=a^2+b^2 (2) c^2=a^2+b^2

    . display equation in blockquote. (valid=True) . > formula > > \[ a+b=c\] (2) > > in blockquote. .

    formula

    a+b=c

    in blockquote.

    . mdit-py-plugins-0.3.0/tests/fixtures/texmath_dollar.md000066400000000000000000000127751415234774500231500ustar00rootroot00000000000000single character inline equation. (valid=True) . $a$ .

    a

    . inline equation with single greek character (valid=True) . $\\varphi$ .

    \\varphi

    . simple equation starting and ending with numbers. (valid=True) . $1+1=2$ .

    1+1=2

    . simple equation including special html character. (valid=True) . $1+1<3$ .

    1+1<3

    . equation including backslashes. (valid=True) . $a \\backslash$ .

    a \\backslash

    . use of currency symbol (valid=True) . You get 3$ if you solve $1+2$ .

    You get 3$ if you solve 1+2

    . use of currency symbol (valid=True) . If you solve $1+2$ you get $3 .

    If you solve 1+2 you get $3

    . inline fraction (valid=True) . $\\frac{1}{2}$ .

    \\frac{1}{2}

    . inline column vector (valid=True) . $\\begin{pmatrix}x\\\\y\\end{pmatrix}$ .

    \\begin{pmatrix}x\\\\y\\end{pmatrix}

    . inline bold vector notation (valid=True) . ${\\tilde\\bold e}_\\alpha$ .

    {\\tilde\\bold e}_\\alpha

    . exponentiation (valid=True) . $a^{b}$ .

    a^{b}

    . conjugate complex (valid=True) . $a^\*b$ with $a^\*$ .

    a^\*b with a^\*

    . Inline multi-line (valid=True) . a $a \not=1$ b .

    a a \not=1 b

    . Inline multi-line with newline (valid=False) . a $a \not=1$ b .

    a $a

    \not=1$ b

    . single block equation, greek index (valid=True) . $$e_\\alpha$$ .
    e_\\alpha
    . display equation on its own single line. (valid=True) . $$1+1=2$$ .
    1+1=2
    . inline equation followed by block equation. (valid=True) . ${e}_x$ $$e_\\alpha$$ .

    {e}_x

    e_\\alpha
    . underline tests (valid=True) . $$c{\\bold e}_x = a{\\bold e}_\\alpha - b\\tilde{\\bold e}_\\alpha$$ .
    c{\\bold e}_x = a{\\bold e}_\\alpha - b\\tilde{\\bold e}_\\alpha
    . non-numeric character before opening $ or after closing $ or both is allowed. (valid=True) . a$1+1=2$ $1+1=2$b c$x$d .

    a1+1=2 1+1=2b cxd

    . following dollar character '$' is allowed. (valid=True) . $x$ $ .

    x $

    . consecutive inline equations. (valid=True) . $x$ $y$ .

    x y

    . inline equation after '-' sign in text. (valid=True) . so-what is $x$ .

    so-what is x

    . display equation with line breaks. (valid=True) . $$ 1+1=2 $$ .
    1+1=2
    . multiple equations (valid=True) . $$ a = 1 $$ $$ b = 2 $$ .
    a = 1
    b = 2
    . equation followed by a labelled equation (valid=True) . $$ a = 1 $$ $$ b = 2 $$ (1) .
    a = 1
    b = 2
    . multiline equation. (valid=True) . $$\\begin{matrix} f & = & 2 + x + 3 \\ & = & 5 + x \\end{matrix}$$ .
    \\begin{matrix} f & = & 2 + x + 3 \\ & = & 5 + x \\end{matrix}
    . vector equation. (valid=True) . $$\\begin{pmatrix}x_2 \\\\ y_2 \\end{pmatrix} = \\begin{pmatrix} A & B \\\\ C & D \\end{pmatrix}\\cdot \\begin{pmatrix} x_1 \\\\ y_1 \\end{pmatrix}$$ .
    \\begin{pmatrix}x_2 \\\\ y_2 \\end{pmatrix} = \\begin{pmatrix} A & B \\\\ C & D \\end{pmatrix}\\cdot \\begin{pmatrix} x_1 \\\\ y_1 \\end{pmatrix}
    . display equation with equation number. (valid=True) . $$f(x) = x^2 - 1$$ (1) .
    f(x) = x^2 - 1
    . inline equation following code section. (valid=True) . `code`$a-b$ .

    codea-b

    . equation following code block. (valid=True) . ``` code ``` $$a+b$$ .
    code
    
    a+b
    . numbered equation following code block. (valid=True) . ``` code ``` $$a+b$$(1) .
    code
    
    a+b
    . Equations in list. (valid=True) . 1. $1+2$ 2. $2+3$ 1. $3+4$ .
    1. 1+2
    2. 2+3
      1. 3+4
    . Inline sum. (valid=True) . $\\sum\_{i=1}^n$ .

    \\sum\_{i=1}^n

    . Sum without equation number. (valid=True) . $$\\sum\_{i=1}^n$$ .
    \\sum\_{i=1}^n
    . Sum with equation number. (valid=True) . $$\\sum\_{i=1}\^n$$ \(2\) .
    \\sum\_{i=1}\^n
    . equation number always vertically aligned. (valid=True) . $${\\bold e}(\\varphi) = \\begin{pmatrix} \\cos\\varphi\\\\\\sin\\varphi \\end{pmatrix}$$ (3) .
    {\\bold e}(\\varphi) = \\begin{pmatrix} \\cos\\varphi\\\\\\sin\\varphi \\end{pmatrix}
    . inline equations in blockquote. (valid=True) . > see $a = b + c$ > $c^2=a^2+b^2$ (2) > $c^2=a^2+b^2$ .

    see a = b + c c^2=a^2+b^2 (2) c^2=a^2+b^2

    . display equation in blockquote. (valid=True) . > formula > > $$ a+b=c$$ (2) > > in blockquote. .

    formula

    a+b=c

    in blockquote.

    . mixed syntax: . $$ a=1 \\ b=2 $$ (abc) - ab $c=1$ d .
    a=1 \\ b=2
    • ab c=1 d
    . escaped dollars '\\$' are interpreted as dollar '$' characters. (valid=True) . \\$1+1=2$ $1+1=2\\$ .

    \$1+1=2$ $1+1=2\$

    . empty line between text and display formula is required. (valid=False) . some text \$\\$a+b=c\$\$ .

    some text $\$a+b=c$$

    . whitespace character after opening $ or before closing $ is not allowed. (valid=False) . $ $ $ x$ $x $ .

    $ $ $ x$ $x $

    . mdit-py-plugins-0.3.0/tests/fixtures/wordcount.md000066400000000000000000000065621415234774500221620ustar00rootroot00000000000000syntax (text) . one two three four - five six > seven eight [nine ten](link) . { "minutes": 0, "text": [ "one two", "three four", "five six", "seven eight", "nine ten" ], "words": 10 } . non-words . Geeksforgeeks, is best @# Computer Science Portal.!!! . { "minutes": 0, "words": 6 } . lore ipsum . Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent imperdiet hendrerit dictum. Etiam diam turpis, cursus in varius dignissim, imperdiet nec nibh. Nulla nec finibus dui. Phasellus fermentum venenatis placerat. Donec ut dui in sem rhoncus molestie. Sed auctor sem dapibus augue varius facilisis. Maecenas at suscipit dolor. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Vestibulum ornare dui ac tristique ultricies. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Quisque arcu erat, ultricies ac lorem at, semper ornare nisl. Donec massa magna, commodo et ultrices ac, rutrum non nulla. Nunc fermentum fringilla ultrices. Morbi ante nibh, accumsan ac viverra quis, gravida rutrum mi. Integer lobortis, purus id laoreet ornare, sapien odio placerat massa, vel vestibulum dolor ante id mi. Donec ex leo, ultricies non ante eget, pharetra dictum orci. Interdum et malesuada fames ac ante ipsum primis in faucibus. Maecenas vitae tortor ut nisi cursus egestas. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Morbi et nunc posuere, pharetra est aliquet, iaculis libero. Aliquam leo nibh, posuere eget eros a, convallis bibendum nibh. Phasellus vulputate bibendum lacus sit amet varius. Integer ut rutrum dolor, ac finibus neque. Maecenas ultrices pretium augue vitae mollis. Fusce semper lorem eu mauris iaculis pulvinar. Morbi ac pretium nunc, ac faucibus enim. Duis consequat nibh metus, at sodales sem luctus nec. Donec id finibus ante. Duis tincidunt vulputate efficitur. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Aenean porttitor augue consectetur, feugiat odio in, rutrum velit. Aliquam et mi lacinia, efficitur nisl nec, rutrum mauris. Mauris efficitur eros in maximus tempor. Suspendisse potenti. Quisque cursus non libero in faucibus. Etiam dignissim urna vel nibh feugiat, at vehicula dui vulputate. Praesent malesuada arcu quis neque condimentum vestibulum. Aliquam pretium eleifend neque, eget vulputate erat faucibus at. Quisque egestas nunc ac hendrerit fringilla. Vestibulum at tristique lacus, eget placerat risus. Aenean a metus ullamcorper, eleifend ante ut, feugiat lacus. Proin eget semper purus, ac vehicula nisl. Suspendisse eu mi enim. Nullam aliquam purus eu orci iaculis suscipit. Mauris dapibus non neque eu hendrerit. Sed eros purus, finibus ut ex ac, ultricies luctus enim. Quisque non lacus arcu. Ut dictum mauris ac tristique pulvinar. Aenean ut nisl massa. Donec nec dui scelerisque, egestas arcu sit amet, tempor eros. Donec sit amet faucibus tellus. Cras auctor mi id quam rhoncus, eget porttitor magna ultrices. Sed tristique ut augue in facilisis. Duis in finibus diam. In hac habitasse platea dictumst. Vestibulum in pulvinar orci. Sed a justo cursus enim ultrices egestas sed sit amet leo. Donec sed auctor urna. Praesent vitae dapibus ipsum. Nulla facilisi. Pellentesque non nisi sem. Sed ac mi rutrum, blandit purus ut, facilisis ipsum. . { "minutes": 2, "words": 458 } . mdit-py-plugins-0.3.0/tests/test_amsmath.py000066400000000000000000000015771415234774500210070ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.utils import read_fixture_file from mdit_py_plugins.amsmath import amsmath_plugin FIXTURE_PATH = Path(__file__).parent def test_plugin_parse(data_regression): md = MarkdownIt().use(amsmath_plugin) tokens = md.parse( dedent( """\ a \\begin{equation} b=1 c=2 \\end{equation} d """ ) ) data_regression.check([t.as_dict() for t in tokens]) @pytest.mark.parametrize( "line,title,input,expected", read_fixture_file(FIXTURE_PATH.joinpath("fixtures", "amsmath.md")), ) def test_fixtures(line, title, input, expected): md = MarkdownIt("commonmark").use(amsmath_plugin) md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() mdit-py-plugins-0.3.0/tests/test_amsmath/000077500000000000000000000000001415234774500204235ustar00rootroot00000000000000mdit-py-plugins-0.3.0/tests/test_amsmath/test_plugin_parse.yml000066400000000000000000000033131415234774500246750ustar00rootroot00000000000000- attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: - 0 - 1 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: a hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: a hidden: false info: '' level: 1 map: - 0 - 1 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '\begin{equation} b=1 c=2 \end{equation}' hidden: false info: '' level: 0 map: - 1 - 4 markup: '' meta: environment: equation numbered: '' nesting: 0 tag: math type: amsmath - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: - 5 - 6 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: d hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: d hidden: false info: '' level: 1 map: - 5 - 6 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close mdit-py-plugins-0.3.0/tests/test_anchors.py000066400000000000000000000011611415234774500207770ustar00rootroot00000000000000from pathlib import Path import pytest from markdown_it import MarkdownIt from markdown_it.utils import read_fixture_file from mdit_py_plugins.anchors import anchors_plugin FIXTURE_PATH = Path(__file__).parent @pytest.mark.parametrize( "line,title,input,expected", read_fixture_file(FIXTURE_PATH.joinpath("fixtures", "anchors.md")), ) def test_fixtures(line, title, input, expected): md = MarkdownIt("commonmark").use( anchors_plugin, permalink="(permalink" in title, permalinkBefore="before)" in title, ) text = md.render(input) assert text.rstrip() == expected.rstrip() mdit-py-plugins-0.3.0/tests/test_colon_fence.py000066400000000000000000000016371415234774500216240ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.utils import read_fixture_file from mdit_py_plugins.colon_fence import colon_fence_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "colon_fence.md") @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_fixtures(line, title, input, expected): md = MarkdownIt("commonmark").use(colon_fence_plugin) md.options["xhtmlOut"] = False text = md.render(input) try: assert text.rstrip() == expected.rstrip() except AssertionError: print(text) raise def test_plugin_parse(data_regression): md = MarkdownIt().use(colon_fence_plugin) tokens = md.parse( dedent( """\ ::: name *content* ::: """ ) ) data_regression.check([t.as_dict() for t in tokens]) mdit-py-plugins-0.3.0/tests/test_colon_fence/000077500000000000000000000000001415234774500212435ustar00rootroot00000000000000mdit-py-plugins-0.3.0/tests/test_colon_fence/test_plugin_parse.yml000066400000000000000000000003201415234774500255100ustar00rootroot00000000000000- attrs: null block: true children: null content: '*content* ' hidden: false info: ' name' level: 0 map: - 0 - 3 markup: ':::' meta: {} nesting: 0 tag: code type: colon_fence mdit-py-plugins-0.3.0/tests/test_container.py000066400000000000000000000022561415234774500213320ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.utils import read_fixture_file from mdit_py_plugins.container import container_plugin def test_plugin_parse(data_regression): md = MarkdownIt().use(container_plugin, "name") tokens = md.parse( dedent( """\ ::: name *content* ::: """ ) ) data_regression.check([t.as_dict() for t in tokens]) def test_no_new_line_issue(data_regression): """Fixed an IndexError when no newline on final line.""" md = MarkdownIt().use(container_plugin, "name") tokens = md.parse( dedent( """\ ::: name *content* :::""" ) ) data_regression.check([t.as_dict() for t in tokens]) FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "container.md") @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_all(line, title, input, expected): md = MarkdownIt("commonmark").use(container_plugin, "name") md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() mdit-py-plugins-0.3.0/tests/test_container/000077500000000000000000000000001415234774500207535ustar00rootroot00000000000000mdit-py-plugins-0.3.0/tests/test_container/test_no_new_line_issue.yml000066400000000000000000000030041415234774500262360ustar00rootroot00000000000000- attrs: null block: true children: null content: '' hidden: false info: ' name' level: 0 map: - 0 - 2 markup: ':::' meta: {} nesting: 1 tag: div type: container_name_open - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 1 - 2 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: '' hidden: false info: '' level: 0 map: null markup: '*' meta: {} nesting: 1 tag: em type: em_open - attrs: null block: false children: null content: content hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: 0 tag: '' type: text - attrs: null block: false children: null content: '' hidden: false info: '' level: 0 map: null markup: '*' meta: {} nesting: -1 tag: em type: em_close content: '*content*' hidden: false info: '' level: 2 map: - 1 - 2 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: ':::' meta: {} nesting: -1 tag: div type: container_name_close mdit-py-plugins-0.3.0/tests/test_container/test_plugin_parse.yml000066400000000000000000000030041415234774500252220ustar00rootroot00000000000000- attrs: null block: true children: null content: '' hidden: false info: ' name' level: 0 map: - 0 - 2 markup: ':::' meta: {} nesting: 1 tag: div type: container_name_open - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 1 - 2 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: '' hidden: false info: '' level: 0 map: null markup: '*' meta: {} nesting: 1 tag: em type: em_open - attrs: null block: false children: null content: content hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: 0 tag: '' type: text - attrs: null block: false children: null content: '' hidden: false info: '' level: 0 map: null markup: '*' meta: {} nesting: -1 tag: em type: em_close content: '*content*' hidden: false info: '' level: 2 map: - 1 - 2 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: ':::' meta: {} nesting: -1 tag: div type: container_name_close mdit-py-plugins-0.3.0/tests/test_deflist.py000066400000000000000000000016001415234774500207720ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.utils import read_fixture_file from mdit_py_plugins.deflist import deflist_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "deflist.md") def test_plugin_parse(data_regression): md = MarkdownIt().use(deflist_plugin) tokens = md.parse( dedent( """\ Term 1 : Definition 1 Term 2 ~ Definition 2a ~ Definition 2b """ ) ) data_regression.check([t.as_dict() for t in tokens]) @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_all(line, title, input, expected): md = MarkdownIt("commonmark").use(deflist_plugin) md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() mdit-py-plugins-0.3.0/tests/test_deflist/000077500000000000000000000000001415234774500204235ustar00rootroot00000000000000mdit-py-plugins-0.3.0/tests/test_deflist/test_plugin_parse.yml000066400000000000000000000120141415234774500246730ustar00rootroot00000000000000- attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: - 0 - 7 markup: '' meta: {} nesting: 1 tag: dl type: dl_open - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 0 - 0 markup: '' meta: {} nesting: 1 tag: dt type: dt_open - attrs: null block: true children: - attrs: null block: false children: null content: Term 1 hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: Term 1 hidden: false info: '' level: 2 map: - 0 - 0 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: dt type: dt_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 2 - 4 markup: '' meta: {} nesting: 1 tag: dd type: dd_open - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: - 2 - 3 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: Definition 1 hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: Definition 1 hidden: false info: '' level: 3 map: - 2 - 3 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: dd type: dd_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 4 - 4 markup: '' meta: {} nesting: 1 tag: dt type: dt_open - attrs: null block: true children: - attrs: null block: false children: null content: Term 2 hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: Term 2 hidden: false info: '' level: 2 map: - 4 - 4 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: dt type: dt_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 4 - 6 markup: '' meta: {} nesting: 1 tag: dd type: dd_open - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: - 5 - 6 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: Definition 2a hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: Definition 2a hidden: false info: '' level: 3 map: - 5 - 6 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: dd type: dd_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 6 - 7 markup: '' meta: {} nesting: 1 tag: dd type: dd_open - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: - 6 - 7 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: Definition 2b hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: Definition 2b hidden: false info: '' level: 3 map: - 6 - 7 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: dd type: dd_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: -1 tag: dl type: dl_close mdit-py-plugins-0.3.0/tests/test_dollarmath.py000066400000000000000000000044471415234774500215030ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.rules_block import StateBlock from markdown_it.rules_inline import StateInline from markdown_it.utils import read_fixture_file from mdit_py_plugins.dollarmath import dollarmath_plugin from mdit_py_plugins.dollarmath import index as main FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures") def test_inline_func(): inline_func = main.math_inline_dollar() md = MarkdownIt() src = r"$a=1$ $b=2$" tokens = [] state = StateInline(src, md, {}, tokens) inline_func(state, False) assert tokens[0].as_dict() == { "type": "math_inline", "tag": "math", "nesting": 0, "attrs": None, "map": None, "level": 0, "children": None, "content": "a=1", "markup": "$", "info": "", "meta": {}, "block": False, "hidden": False, } assert state.pos == 5 def test_block_func(): block_func = main.math_block_dollar() md = MarkdownIt() src = r"$$\na=1\n\nc\nb=2$$ (abc)" tokens = [] state = StateBlock(src, md, {}, tokens) block_func(state, 0, 10, False) print(tokens[0].as_dict()) assert tokens[0].as_dict() == { "type": "math_block_label", "tag": "math", "nesting": 0, "attrs": None, "map": [0, 1], "level": 0, "children": None, "content": "\\na=1\\n\\nc\\nb=2", "markup": "$$", "info": "abc", "meta": {}, "block": True, "hidden": False, } def test_plugin_parse(data_regression): md = MarkdownIt().use(dollarmath_plugin) tokens = md.parse( dedent( """\ $$ a=1 b=2 $$ (abc) - ab $c=1$ d """ ) ) data_regression.check([t.as_dict() for t in tokens]) @pytest.mark.parametrize( "line,title,input,expected", read_fixture_file(FIXTURE_PATH.joinpath("dollar_math.md")), ) def test_dollarmath_fixtures(line, title, input, expected): md = MarkdownIt("commonmark").use( dollarmath_plugin, allow_space=False, allow_digits=False, double_inline=True ) md.options.xhtmlOut = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() mdit-py-plugins-0.3.0/tests/test_dollarmath/000077500000000000000000000000001415234774500211205ustar00rootroot00000000000000mdit-py-plugins-0.3.0/tests/test_dollarmath/test_plugin_parse.yml000066400000000000000000000040671415234774500254010ustar00rootroot00000000000000- attrs: null block: true children: null content: ' a=1 b=2 ' hidden: false info: abc level: 0 map: - 0 - 4 markup: $$ meta: {} nesting: 0 tag: math type: math_block_label - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: - 5 - 6 markup: '-' meta: {} nesting: 1 tag: ul type: bullet_list_open - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 5 - 6 markup: '-' meta: {} nesting: 1 tag: li type: list_item_open - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: - 5 - 6 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: 'ab ' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text - attrs: null block: false children: null content: c=1 hidden: false info: '' level: 0 map: null markup: $ meta: {} nesting: 0 tag: math type: math_inline - attrs: null block: false children: null content: ' d' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: ab $c=1$ d hidden: false info: '' level: 3 map: - 5 - 6 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '-' meta: {} nesting: -1 tag: li type: list_item_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: '-' meta: {} nesting: -1 tag: ul type: bullet_list_close mdit-py-plugins-0.3.0/tests/test_field_list.py000066400000000000000000000015311415234774500214610ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.utils import read_fixture_file from mdit_py_plugins.field_list import fieldlist_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "field_list.md") def test_plugin_parse(data_regression): md = MarkdownIt().use(fieldlist_plugin) tokens = md.parse( dedent( """\ :abc: Content :def: Content """ ) ) data_regression.check([t.as_dict() for t in tokens]) @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_all(line, title, input, expected): md = MarkdownIt("commonmark").use(fieldlist_plugin) md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() mdit-py-plugins-0.3.0/tests/test_field_list/000077500000000000000000000000001415234774500211075ustar00rootroot00000000000000mdit-py-plugins-0.3.0/tests/test_field_list/test_plugin_parse.yml000066400000000000000000000100431415234774500253570ustar00rootroot00000000000000- attrs: - - class - field-list block: true children: null content: '' hidden: false info: '' level: 0 map: - 0 - 2 markup: '' meta: {} nesting: 1 tag: dl type: field_list_open - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 0 - 0 markup: '' meta: {} nesting: 1 tag: dt type: fieldlist_name_open - attrs: null block: true children: - attrs: null block: false children: null content: abc hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: abc hidden: false info: '' level: 2 map: - 0 - 0 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: dt type: fieldlist_name_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 0 - 1 markup: '' meta: {} nesting: 1 tag: dd type: fieldlist_body_open - attrs: null block: true children: null content: '' hidden: false info: '' level: 2 map: - 0 - 1 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: Content hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: Content hidden: false info: '' level: 3 map: - 0 - 1 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 2 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: dd type: fieldlist_body_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 1 - 1 markup: '' meta: {} nesting: 1 tag: dt type: fieldlist_name_open - attrs: null block: true children: - attrs: null block: false children: null content: def hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: def hidden: false info: '' level: 2 map: - 1 - 1 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: dt type: fieldlist_name_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 1 - 2 markup: '' meta: {} nesting: 1 tag: dd type: fieldlist_body_open - attrs: null block: true children: null content: '' hidden: false info: '' level: 2 map: - 1 - 2 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: Content hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: Content hidden: false info: '' level: 3 map: - 1 - 2 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 2 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '' meta: {} nesting: -1 tag: dd type: fieldlist_body_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: -1 tag: dl type: field_list_close mdit-py-plugins-0.3.0/tests/test_footnote.py000066400000000000000000000276621415234774500212150ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.rules_block import StateBlock from markdown_it.rules_inline import StateInline from markdown_it.token import Token from markdown_it.utils import read_fixture_file from mdit_py_plugins.footnote import footnote_plugin, index FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "footnote.md") def test_footnote_def(): md = MarkdownIt() src = r"[^a]: xyz" tokens = [] state = StateBlock(src, md, {}, tokens) index.footnote_def(state, 0, 1, False) assert [t.as_dict() for t in tokens] == [ { "type": "footnote_reference_open", "tag": "", "nesting": 1, "attrs": None, "map": [0, 1], "level": 0, "children": None, "content": "", "markup": "", "info": "", "meta": {"label": "a"}, "block": False, "hidden": False, }, { "type": "paragraph_open", "tag": "p", "nesting": 1, "attrs": None, "map": [0, 1], "level": 1, "children": None, "content": "", "markup": "", "info": "", "meta": {}, "block": True, "hidden": False, }, { "type": "inline", "tag": "", "nesting": 0, "attrs": None, "map": [0, 1], "level": 2, "children": [], "content": "xyz", "markup": "", "info": "", "meta": {}, "block": True, "hidden": False, }, { "type": "paragraph_close", "tag": "p", "nesting": -1, "attrs": None, "map": None, "level": 1, "children": None, "content": "", "markup": "", "info": "", "meta": {}, "block": True, "hidden": False, }, { "type": "footnote_reference_close", "tag": "", "nesting": -1, "attrs": None, "map": None, "level": 0, "children": None, "content": "", "markup": "", "info": "", "meta": {}, "block": False, "hidden": False, }, ] assert state.env == {"footnotes": {"refs": {":a": -1}}} def test_footnote_ref(): md = MarkdownIt() src = r"[^a]" tokens = [] state = StateInline(src, md, {}, tokens) state.env = {"footnotes": {"refs": {":a": -1}}} index.footnote_ref(state, False) # print([t.as_dict() for t in tokens]) assert [t.as_dict() for t in tokens] == [ { "type": "footnote_ref", "tag": "", "nesting": 0, "attrs": None, "map": None, "level": 0, "children": None, "content": "", "markup": "", "info": "", "meta": {"id": 0, "subId": 0, "label": "a"}, "block": False, "hidden": False, } ] assert state.env == { "footnotes": {"refs": {":a": 0}, "list": {0: {"label": "a", "count": 1}}} } def test_footnote_inline(): md = MarkdownIt().use(footnote_plugin) src = r"^[a]" tokens = [] state = StateInline(src, md, {}, tokens) state.env = {"footnotes": {"refs": {":a": -1}}} index.footnote_inline(state, False) # print([t.as_dict() for t in tokens]) assert [t.as_dict() for t in tokens] == [ { "type": "footnote_ref", "tag": "", "nesting": 0, "attrs": None, "map": None, "level": 0, "children": None, "content": "", "markup": "", "info": "", "meta": {"id": 0}, "block": False, "hidden": False, } ] assert state.env == { "footnotes": { "refs": {":a": -1}, "list": { 0: { "content": "a", "tokens": [ Token( type="text", tag="", nesting=0, attrs=None, map=None, level=0, children=None, content="a", markup="", info="", meta={}, block=False, hidden=False, ) ], } }, } } def test_footnote_tail(): md = MarkdownIt() tokens = [ Token( **{ "type": "footnote_reference_open", "tag": "", "nesting": 1, "attrs": None, "map": None, "level": 0, "children": None, "content": "", "markup": "", "info": "", "meta": {"label": "a"}, "block": False, "hidden": False, } ), Token( **{ "type": "paragraph_open", "tag": "p", "nesting": 1, "attrs": None, "map": [0, 1], "level": 1, "children": None, "content": "", "markup": "", "info": "", "meta": {}, "block": True, "hidden": False, } ), Token( **{ "type": "inline", "tag": "", "nesting": 0, "attrs": None, "map": [0, 1], "level": 2, "children": [], "content": "xyz", "markup": "", "info": "", "meta": {}, "block": True, "hidden": False, } ), Token( **{ "type": "paragraph_close", "tag": "p", "nesting": -1, "attrs": None, "map": None, "level": 1, "children": None, "content": "", "markup": "", "info": "", "meta": {}, "block": True, "hidden": False, } ), Token( **{ "type": "footnote_reference_close", "tag": "", "nesting": -1, "attrs": None, "map": None, "level": 0, "children": None, "content": "", "markup": "", "info": "", "meta": {}, "block": False, "hidden": False, } ), Token("other", "", 0), ] env = {"footnotes": {"refs": {":a": 0}, "list": {0: {"label": "a", "count": 1}}}} state = StateBlock("", md, env, tokens) index.footnote_tail(state) assert state.tokens == [ Token( type="other", tag="", nesting=0, attrs=None, map=None, level=0, children=None, content="", markup="", info="", meta={}, block=False, hidden=False, ), Token( type="footnote_block_open", tag="", nesting=1, attrs=None, map=None, level=0, children=None, content="", markup="", info="", meta={}, block=False, hidden=False, ), Token( type="footnote_open", tag="", nesting=1, attrs=None, map=None, level=0, children=None, content="", markup="", info="", meta={"id": 0, "label": "a"}, block=False, hidden=False, ), Token( type="paragraph_open", tag="p", nesting=1, attrs=None, map=[0, 1], level=1, children=None, content="", markup="", info="", meta={}, block=True, hidden=False, ), Token( type="inline", tag="", nesting=0, attrs=None, map=[0, 1], level=2, children=[], content="xyz", markup="", info="", meta={}, block=True, hidden=False, ), Token( type="footnote_anchor", tag="", nesting=0, attrs=None, map=None, level=0, children=None, content="", markup="", info="", meta={"id": 0, "subId": 0, "label": "a"}, block=False, hidden=False, ), Token( type="paragraph_close", tag="p", nesting=-1, attrs=None, map=None, level=1, children=None, content="", markup="", info="", meta={}, block=True, hidden=False, ), Token( type="footnote_close", tag="", nesting=-1, attrs=None, map=None, level=0, children=None, content="", markup="", info="", meta={}, block=False, hidden=False, ), Token( type="footnote_block_close", tag="", nesting=-1, attrs=None, map=None, level=0, children=None, content="", markup="", info="", meta={}, block=False, hidden=False, ), ] def test_plugin_render(): md = MarkdownIt().use(footnote_plugin) text = md.render( dedent( """\ [^1] ^[a] [^a] [^a] [^1]: abc [^a]: xyz """ ) ) assert text == ( dedent( """\

    [1] [2] [3] [3:1]


    1. abc ↩︎

    2. a ↩︎

    3. xyz ↩︎ ↩︎

    """ # noqa: E501 ) ) @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_all(line, title, input, expected): md = MarkdownIt("commonmark").use(footnote_plugin) md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip().replace("↩︎", "<-").replace( "↩", "<-" ) == expected.rstrip().replace("↩︎", "<-").replace("↩", "<-") mdit-py-plugins-0.3.0/tests/test_front_matter.py000066400000000000000000000024051415234774500220500ustar00rootroot00000000000000from pathlib import Path import pytest from markdown_it import MarkdownIt from markdown_it.token import Token from markdown_it.utils import read_fixture_file from mdit_py_plugins.front_matter import front_matter_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "front_matter.md") @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_all(line, title, input, expected): md = MarkdownIt("commonmark").use(front_matter_plugin) md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() def test_token(): md = MarkdownIt("commonmark").use(front_matter_plugin) tokens = md.parse("---\na: 1\n---") # print(tokens) assert tokens == [ Token( type="front_matter", tag="", nesting=0, attrs=None, map=[0, 3], level=0, children=None, content="a: 1", markup="---", info="", meta={}, block=True, hidden=True, ) ] def test_short_source(): md = MarkdownIt("commonmark").use(front_matter_plugin) # The code should not raise an IndexError. assert md.parse("-") mdit-py-plugins-0.3.0/tests/test_myst_block.py000066400000000000000000000037341415234774500215200ustar00rootroot00000000000000from pathlib import Path import pytest from markdown_it import MarkdownIt from markdown_it.token import Token from markdown_it.utils import read_fixture_file from mdit_py_plugins.myst_blocks import myst_block_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "myst_block.md") @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_all(line, title, input, expected): md = MarkdownIt("commonmark").use(myst_block_plugin) md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() def test_block_token(): md = MarkdownIt("commonmark").use(myst_block_plugin) tokens = md.parse("+++") expected_token = Token( type="myst_block_break", tag="hr", nesting=0, map=[0, 1], level=0, children=None, content="", markup="+++", info="", meta={}, block=True, hidden=False, ) expected_token.attrSet("class", "myst-block") assert tokens == [expected_token] tokens = md.parse("\n+ + + abc") expected_token = Token( type="myst_block_break", tag="hr", nesting=0, map=[1, 2], level=0, children=None, content="abc", markup="+++", info="", meta={}, block=True, hidden=False, ) expected_token.attrSet("class", "myst-block") assert tokens == [expected_token] def test_comment_token(): md = MarkdownIt("commonmark").use(myst_block_plugin) tokens = md.parse("\n\n% abc \n%def") expected_token = Token( type="myst_line_comment", tag="", nesting=0, map=[2, 4], level=0, children=None, content=" abc\ndef", markup="%", info="", meta={}, block=True, hidden=False, ) expected_token.attrSet("class", "myst-line-comment") assert tokens == [expected_token] mdit-py-plugins-0.3.0/tests/test_myst_role.py000066400000000000000000000043411415234774500213620ustar00rootroot00000000000000from pathlib import Path import pytest from markdown_it import MarkdownIt from markdown_it.token import Token from markdown_it.utils import read_fixture_file from mdit_py_plugins.myst_role import myst_role_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "myst_role.md") def test_basic(): md = MarkdownIt().use(myst_role_plugin) src = "{abc}``` a ```" tokens = md.parse(src) print(tokens) assert tokens == [ Token( type="paragraph_open", tag="p", nesting=1, attrs=None, map=[0, 1], level=0, children=None, content="", markup="", info="", meta={}, block=True, hidden=False, ), Token( type="inline", tag="", nesting=0, attrs=None, map=[0, 1], level=1, children=[ Token( type="myst_role", tag="", nesting=0, attrs=None, map=None, level=0, children=None, content=" a ", markup="", info="", meta={"name": "abc"}, block=False, hidden=False, ) ], content="{abc}``` a ```", markup="", info="", meta={}, block=True, hidden=False, ), Token( type="paragraph_close", tag="p", nesting=-1, attrs=None, map=None, level=0, children=None, content="", markup="", info="", meta={}, block=True, hidden=False, ), ] @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_all(line, title, input, expected): md = MarkdownIt("commonmark").use(myst_role_plugin) md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() mdit-py-plugins-0.3.0/tests/test_substitution.py000066400000000000000000000015721415234774500221240ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.utils import read_fixture_file # from markdown_it.token import Token from mdit_py_plugins.substitution import substitution_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "substitution.md") @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_fixtures(line, title, input, expected): md = MarkdownIt("commonmark").enable("table").use(substitution_plugin) text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() def test_tokens(data_regression): md = MarkdownIt().use(substitution_plugin) tokens = md.parse( dedent( """\ {{ block }} a {{ inline }} b """ ) ) data_regression.check([t.as_dict() for t in tokens]) mdit-py-plugins-0.3.0/tests/test_substitution/000077500000000000000000000000001415234774500215455ustar00rootroot00000000000000mdit-py-plugins-0.3.0/tests/test_substitution/test_tokens.yml000066400000000000000000000026761415234774500246450ustar00rootroot00000000000000- attrs: - - class - substitution - - text - block block: true children: null content: block hidden: false info: '' level: 0 map: - 0 - 1 markup: '{}' meta: {} nesting: 0 tag: div type: substitution_block - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: - 2 - 3 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: 'a ' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text - attrs: - - class - substitution - - text - inline block: false children: null content: inline hidden: false info: '' level: 0 map: null markup: '{}' meta: {} nesting: 0 tag: span type: substitution_inline - attrs: null block: false children: null content: ' b' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: a {{ inline }} b hidden: false info: '' level: 1 map: - 2 - 3 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close mdit-py-plugins-0.3.0/tests/test_tasklists.py000066400000000000000000000016551415234774500213730ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.utils import read_fixture_file from mdit_py_plugins.tasklists import tasklists_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "tasklists.md") def test_plugin_parse(data_regression): md = MarkdownIt().use(tasklists_plugin) tokens = md.parse( dedent( """\ * [ ] Task incomplete * [x] Task complete * [ ] Indented task incomplete * [x] Indented task complete """ ) ) data_regression.check([t.as_dict() for t in tokens]) @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_all(line, title, input, expected): md = MarkdownIt("commonmark").use(tasklists_plugin) md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() mdit-py-plugins-0.3.0/tests/test_tasklists/000077500000000000000000000000001415234774500210125ustar00rootroot00000000000000mdit-py-plugins-0.3.0/tests/test_tasklists/test_plugin_parse.yml000066400000000000000000000147521415234774500252750ustar00rootroot00000000000000- attrs: - - class - contains-task-list block: true children: null content: '' hidden: false info: '' level: 0 map: - 0 - 4 markup: '*' meta: {} nesting: 1 tag: ul type: bullet_list_open - attrs: - - class - task-list-item block: true children: null content: '' hidden: false info: '' level: 1 map: - 0 - 1 markup: '*' meta: {} nesting: 1 tag: li type: list_item_open - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: - 0 - 1 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: html_inline - attrs: null block: false children: null content: ' Task incomplete' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: ' Task incomplete' hidden: false info: '' level: 3 map: - 0 - 1 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '*' meta: {} nesting: -1 tag: li type: list_item_close - attrs: - - class - task-list-item block: true children: null content: '' hidden: false info: '' level: 1 map: - 1 - 4 markup: '*' meta: {} nesting: 1 tag: li type: list_item_open - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: - 1 - 2 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: html_inline - attrs: null block: false children: null content: ' Task complete' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: ' Task complete' hidden: false info: '' level: 3 map: - 1 - 2 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: - - class - contains-task-list block: true children: null content: '' hidden: false info: '' level: 2 map: - 2 - 4 markup: '*' meta: {} nesting: 1 tag: ul type: bullet_list_open - attrs: - - class - task-list-item block: true children: null content: '' hidden: false info: '' level: 3 map: - 2 - 3 markup: '*' meta: {} nesting: 1 tag: li type: list_item_open - attrs: null block: true children: null content: '' hidden: true info: '' level: 4 map: - 2 - 3 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: html_inline - attrs: null block: false children: null content: ' Indented task incomplete' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: ' Indented task incomplete' hidden: false info: '' level: 5 map: - 2 - 3 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: true info: '' level: 4 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 3 map: null markup: '*' meta: {} nesting: -1 tag: li type: list_item_close - attrs: - - class - task-list-item block: true children: null content: '' hidden: false info: '' level: 3 map: - 3 - 4 markup: '*' meta: {} nesting: 1 tag: li type: list_item_open - attrs: null block: true children: null content: '' hidden: true info: '' level: 4 map: - 3 - 4 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: html_inline - attrs: null block: false children: null content: ' Indented task complete' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: ' Indented task complete' hidden: false info: '' level: 5 map: - 3 - 4 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: true info: '' level: 4 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 3 map: null markup: '*' meta: {} nesting: -1 tag: li type: list_item_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 2 map: null markup: '*' meta: {} nesting: -1 tag: ul type: bullet_list_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '*' meta: {} nesting: -1 tag: li type: list_item_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: '*' meta: {} nesting: -1 tag: ul type: bullet_list_close mdit-py-plugins-0.3.0/tests/test_texmath.py000066400000000000000000000051641415234774500210230ustar00rootroot00000000000000from pathlib import Path from textwrap import dedent import pytest from markdown_it import MarkdownIt from markdown_it.rules_block import StateBlock from markdown_it.rules_inline import StateInline from markdown_it.utils import read_fixture_file from mdit_py_plugins.texmath import index as main from mdit_py_plugins.texmath import texmath_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures") def test_inline_func(): inline_func = main.make_inline_func(main.rules["dollars"]["inline"][0]) md = MarkdownIt() src = r"$a=1$ $b=2$" tokens = [] state = StateInline(src, md, {}, tokens) inline_func(state, False) assert tokens[0].as_dict() == { "type": "math_inline", "tag": "math", "nesting": 0, "attrs": None, "map": None, "level": 0, "children": None, "content": "a=1", "markup": "$", "info": "", "meta": {}, "block": False, "hidden": False, } assert state.pos == 5 def test_block_func(): block_func = main.make_block_func(main.rules["dollars"]["block"][0]) md = MarkdownIt() src = r"$$\na=1\n\nc\nb=2$$ (abc)" tokens = [] state = StateBlock(src, md, {}, tokens) block_func(state, 0, 10, False) assert tokens[0].as_dict() == { "type": "math_block_eqno", "tag": "math", "nesting": 0, "attrs": None, "map": None, "level": 0, "children": None, "content": "\\na=1\\n\\nc\\nb=2", "markup": "$$", "info": "abc", "meta": {}, "block": True, "hidden": False, } def test_plugin_parse(data_regression): md = MarkdownIt().use(texmath_plugin) tokens = md.parse( dedent( """\ $$ a=1 b=2 $$ (abc) - ab $c=1$ d """ ) ) data_regression.check([t.as_dict() for t in tokens]) @pytest.mark.parametrize( "line,title,input,expected", read_fixture_file(FIXTURE_PATH.joinpath("texmath_dollar.md")), ) def test_dollar_fixtures(line, title, input, expected): md = MarkdownIt("commonmark").use(texmath_plugin) md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() @pytest.mark.parametrize( "line,title,input,expected", read_fixture_file(FIXTURE_PATH.joinpath("texmath_bracket.md")), ) def test_bracket_fixtures(line, title, input, expected): md = MarkdownIt("commonmark").use(texmath_plugin, delimiters="brackets") md.options["xhtmlOut"] = False text = md.render(input) print(text) assert text.rstrip() == expected.rstrip() mdit-py-plugins-0.3.0/tests/test_texmath/000077500000000000000000000000001415234774500204435ustar00rootroot00000000000000mdit-py-plugins-0.3.0/tests/test_texmath/test_plugin_parse.yml000066400000000000000000000040571415234774500247230ustar00rootroot00000000000000- attrs: null block: true children: null content: ' a=1 b=2 ' hidden: false info: abc level: 0 map: null markup: $$ meta: {} nesting: 0 tag: math type: math_block_eqno - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: - 5 - 6 markup: '-' meta: {} nesting: 1 tag: ul type: bullet_list_open - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: - 5 - 6 markup: '-' meta: {} nesting: 1 tag: li type: list_item_open - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: - 5 - 6 markup: '' meta: {} nesting: 1 tag: p type: paragraph_open - attrs: null block: true children: - attrs: null block: false children: null content: 'ab ' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text - attrs: null block: false children: null content: c=1 hidden: false info: '' level: 0 map: null markup: $ meta: {} nesting: 0 tag: math type: math_inline - attrs: null block: false children: null content: ' d' hidden: false info: '' level: 0 map: null markup: '' meta: {} nesting: 0 tag: '' type: text content: ab $c=1$ d hidden: false info: '' level: 3 map: - 5 - 6 markup: '' meta: {} nesting: 0 tag: '' type: inline - attrs: null block: true children: null content: '' hidden: true info: '' level: 2 map: null markup: '' meta: {} nesting: -1 tag: p type: paragraph_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 1 map: null markup: '-' meta: {} nesting: -1 tag: li type: list_item_close - attrs: null block: true children: null content: '' hidden: false info: '' level: 0 map: null markup: '-' meta: {} nesting: -1 tag: ul type: bullet_list_close mdit-py-plugins-0.3.0/tests/test_wordcount.py000066400000000000000000000013041415234774500213650ustar00rootroot00000000000000import json from pathlib import Path import pytest from markdown_it import MarkdownIt from markdown_it.utils import read_fixture_file from mdit_py_plugins.wordcount import wordcount_plugin FIXTURE_PATH = Path(__file__).parent.joinpath("fixtures", "wordcount.md") @pytest.mark.parametrize("line,title,input,expected", read_fixture_file(FIXTURE_PATH)) def test_all(line, title, input, expected): md = MarkdownIt("commonmark").use(wordcount_plugin, store_text="(text)" in title) env = {} md.render(input, env) data = json.dumps(env["wordcount"], indent=2, sort_keys=True) try: assert data.strip() == expected.strip() except AssertionError: print(data) raise mdit-py-plugins-0.3.0/tox.ini000066400000000000000000000010231415234774500160770ustar00rootroot00000000000000# To use tox, see https://tox.readthedocs.io # Simply pip or conda install tox # If you use conda, you may also want to install tox-conda # then run `tox` or `tox -- {pytest args}` # run in parallel using `tox -p` [tox] envlist = py37 [testenv] usedevelop = true [testenv:py{36,37,38,39}] extras = testing commands = pytest {posargs} [testenv:docs-{update,clean}] extras = rtd whitelist_externals = rm commands = clean: rm -rf docs/_build sphinx-build -nW --keep-going -b {posargs:html} docs/ docs/_build/{posargs:html}