markdown-exec 1.9.0__tar.gz → 1.9.2__tar.gz

{markdown_exec-1.9.0 → markdown_exec-1.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: markdown-exec
-Version: 1.9.0
+Version: 1.9.2
 Summary: Utilities to execute code blocks in Markdown files.
 Keywords: markdown,python,exec,shell,bash,mkdocs
 Author-Email: =?utf-8?q?Timoth=C3=A9e_Mazzucotelli?= <dev@pawamoy.fr>

{markdown_exec-1.9.0 → markdown_exec-1.9.2}/pyproject.toml

@@ -41,7 +41,7 @@ classifiers = [
 dependencies = [
     "pymdown-extensions>=9",
 ]
-version = "1.9.0"
+version = "1.9.2"
 
 [project.license]
 text = "ISC"
@@ -72,6 +72,7 @@ package-dir = "src"
 editable-backend = "editables"
 source-includes = [
     "share",
+    "tests",
 ]
 
 [tool.pdm.build.wheel-data]

{markdown_exec-1.9.0 → markdown_exec-1.9.2}/src/markdown_exec/formatters/base.py

@@ -152,7 +152,7 @@ def base_format(
         logger.warning(log_message)
         return markdown.convert(str(error))
 
-    if not output:
+    if not output and not source:
         return Markup()
 
     if html:

markdown_exec-1.9.2/tests/__init__.py

@@ -0,0 +1,7 @@
+"""Tests suite for `markdown_exec`."""
+
+from pathlib import Path
+
+TESTS_DIR = Path(__file__).parent
+TMP_DIR = TESTS_DIR / "tmp"
+FIXTURES_DIR = TESTS_DIR / "fixtures"

markdown_exec-1.9.2/tests/conftest.py

@@ -0,0 +1,28 @@
+"""Configuration for the pytest test suite."""
+
+import pytest
+from markdown import Markdown
+
+from markdown_exec import formatter, formatters, validator
+
+
+@pytest.fixture()
+def md() -> Markdown:
+    """Return a Markdown instance.
+
+    Returns:
+        Markdown instance.
+    """
+    fences = [
+        {
+            "name": language,
+            "class": language,
+            "validator": validator,
+            "format": formatter,
+        }
+        for language in formatters
+    ]
+    return Markdown(
+        extensions=["pymdownx.superfences", "pymdownx.tabbed"],
+        extension_configs={"pymdownx.superfences": {"custom_fences": fences}},
+    )

markdown_exec-1.9.2/tests/test_base_formatter.py

@@ -0,0 +1,126 @@
+"""Tests for the base formatter."""
+
+import subprocess
+
+import pytest
+from markdown import Markdown
+
+from markdown_exec.formatters.base import base_format
+
+
+def test_no_p_around_html(md: Markdown) -> None:
+    """Assert HTML isn't wrapped in a `p` tag.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    code = "<pre><code>hello</code></pre>"
+    html = base_format(
+        language="whatever",
+        run=lambda code, **_: code,
+        code=code,
+        md=md,
+        html=True,
+    )
+    assert html == code
+
+
+@pytest.mark.parametrize("html", [True, False])
+def test_render_source(md: Markdown, html: bool) -> None:
+    """Assert source is rendered.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+        html: Whether output is HTML or not.
+    """
+    markup = base_format(
+        language="python",
+        run=lambda code, **_: code,
+        code="hello",
+        md=md,
+        html=html,
+        source="tabbed-left",
+    )
+    assert "Source" in markup
+
+
+def test_render_console_plus_ansi_result(md: Markdown) -> None:
+    """Assert we can render source as console style with `ansi` highlight.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    markup = base_format(
+        language="bash",
+        run=lambda code, **_: code,
+        code="echo -e '\033[31mhello'",
+        md=md,
+        html=False,
+        source="console",
+        result="ansi",
+    )
+    assert "<code>ansi" in markup
+
+
+def test_dont_render_anything_if_output_is_empty(md: Markdown) -> None:
+    """Assert nothing is rendered if output is empty.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    markup = base_format(
+        language="bash",
+        run=lambda code, **_: "",
+        code="whatever",
+        md=md,
+    )
+    assert not markup
+
+
+def test_render_source_even_if_output_is_empty(md: Markdown) -> None:
+    """Assert source is rendered even if output is empty.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    markup = base_format(
+        language="bash",
+        run=lambda code, **_: "",
+        code="whatever",
+        md=md,
+        source="tabbed-left",
+    )
+    assert "Source" in markup
+
+
+def test_changing_working_directory(md: Markdown) -> None:
+    """Assert we can change the working directory with `workdir`.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    markup = base_format(
+        language="python",
+        run=lambda code, **_: subprocess.check_output(code, shell=True, text=True),  # noqa: S602
+        code="pwd",
+        md=md,
+        workdir="/",
+    )
+    assert markup == "<p>/</p>"
+
+
+def test_console_width(md: Markdown) -> None:
+    """Assert we can change the console width with `width`.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    for width in (10, 1000):
+        markup = base_format(
+            language="bash",
+            run=lambda code, **_: subprocess.check_output(code, shell=True, text=True),  # noqa: S602,
+            code="echo width: $COLUMNS",
+            md=md,
+            width=width,
+        )
+        assert f"width: {width}" in markup

markdown_exec-1.9.2/tests/test_converter.py

@@ -0,0 +1,76 @@
+"""Tests for the Markdown converter."""
+
+from __future__ import annotations
+
+import re
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+import pytest
+from markdown.extensions.toc import TocExtension
+
+from markdown_exec.rendering import MarkdownConfig, markdown_config
+
+if TYPE_CHECKING:
+    from markdown import Markdown
+
+
+def test_rendering_nested_blocks(md: Markdown) -> None:
+    """Assert nested blocks are properly handled.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ````md exec="1"
+            ```python exec="1"
+            print("**Bold!**")
+            ```
+            ````
+            """,
+        ),
+    )
+    assert html == "<p><strong>Bold!</strong></p>"
+
+
+def test_instantiating_config_singleton() -> None:
+    """Assert that the Markdown config instances act as a singleton."""
+    assert MarkdownConfig() is markdown_config
+    markdown_config.save([], {})
+    markdown_config.reset()
+
+
+@pytest.mark.parametrize(
+    ("id", "id_prefix", "expected"),
+    [
+        ("", None, 'id="exec-\\d+--heading"'),
+        ("", "", 'id="heading"'),
+        ("", "some-prefix-", 'id="some-prefix-heading"'),
+        ("some-id", None, 'id="some-id-heading"'),
+        ("some-id", "", 'id="heading"'),
+        ("some-id", "some-prefix-", 'id="some-prefix-heading"'),
+    ],
+)
+def test_prefixing_headings(md: Markdown, id: str, id_prefix: str | None, expected: str) -> None:  # noqa: A002
+    """Assert that we prefix headings as specified.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+        id: The code block id.
+        id_prefix: The code block id prefix.
+        expected: The id we expect to find in the HTML.
+    """
+    TocExtension().extendMarkdown(md)
+    prefix = f'idprefix="{id_prefix}"' if id_prefix is not None else ""
+    html = md.convert(
+        dedent(
+            f"""
+            ```python exec="1" id="{id}" {prefix}
+            print("# HEADING")
+            ```
+            """,
+        ),
+    )
+    assert re.search(expected, html)

markdown_exec-1.9.2/tests/test_headings.py

@@ -0,0 +1,30 @@
+"""Tests for headings."""
+
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from markdown import Markdown
+
+
+def test_headings_removal(md: Markdown) -> None:
+    """Headings should leave no trace behind.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            === "File layout"
+
+                ```tree
+                ./
+                    hello.md
+                ```
+            """,
+        ),
+    )
+    assert 'class="markdown-exec"' not in html

markdown_exec-1.9.2/tests/test_python.py

@@ -0,0 +1,231 @@
+"""Tests for the Python formatters."""
+
+from __future__ import annotations
+
+import re
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import pytest
+    from markdown import Markdown
+
+
+def test_output_markdown(md: Markdown) -> None:
+    """Assert Markdown is converted to HTML.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="yes"
+            print("**Bold!**")
+            ```
+            """,
+        ),
+    )
+    assert html == "<p><strong>Bold!</strong></p>"
+
+
+def test_output_html(md: Markdown) -> None:
+    """Assert HTML is injected as is.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="yes" html="yes"
+            print("**Bold!**")
+            ```
+            """,
+        ),
+    )
+    assert html == "<p>**Bold!**\n</p>"
+
+
+def test_error_raised(md: Markdown, caplog: pytest.LogCaptureFixture) -> None:
+    """Assert errors properly log a warning and return a formatted traceback.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+        caplog: Pytest fixture to capture logs.
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="yes"
+            raise ValueError("oh no!")
+            ```
+            """,
+        ),
+    )
+    assert "Traceback" in html
+    assert "ValueError" in html
+    assert "oh no!" in html
+    assert "Execution of python code block exited with errors" in caplog.text
+
+
+def test_can_print_non_string_objects(md: Markdown) -> None:
+    """Assert we can print non-string objects.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="yes"
+            class NonString:
+                def __str__(self):
+                    return "string"
+
+            nonstring = NonString()
+            print(nonstring, nonstring)
+            ```
+            """,
+        ),
+    )
+    assert "Traceback" not in html
+
+
+def test_sessions(md: Markdown) -> None:
+    """Assert sessions can be reused.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="1" session="a"
+            a = 1
+            ```
+
+            ```pycon exec="1" session="b"
+            >>> b = 2
+            ```
+
+            ```pycon exec="1" session="a"
+            >>> print(f"a = {a}")
+            >>> try:
+            ...     print(b)
+            ... except NameError:
+            ...     print("ok")
+            ... else:
+            ...     print("ko")
+            ```
+
+            ```python exec="1" session="b"
+            print(f"b = {b}")
+            try:
+                print(a)
+            except NameError:
+                print("ok")
+            else:
+                print("ko")
+            ```
+            """,
+        ),
+    )
+    assert "a = 1" in html
+    assert "b = 2" in html
+    assert "ok" in html
+    assert "ko" not in html
+
+
+def test_reporting_errors_in_sessions(md: Markdown, caplog: pytest.LogCaptureFixture) -> None:
+    """Assert errors and source lines are correctly reported across sessions.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+        caplog: Pytest fixture to capture logs.
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="1" session="a"
+            def fraise():
+                raise RuntimeError("strawberry")
+            ```
+
+            ```python exec="1" session="a"
+            print("hello")
+            fraise()
+            ```
+            """,
+        ),
+    )
+    assert "Traceback" in html
+    assert "strawberry" in html
+    assert "fraise()" in caplog.text
+    assert 'raise RuntimeError("strawberry")' in caplog.text
+
+
+def test_removing_output_from_pycon_code(md: Markdown) -> None:
+    """Assert output lines are removed from pycon snippets.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```pycon exec="1" source="console"
+            >>> print("ok")
+            ko
+            ```
+            """,
+        ),
+    )
+    assert "ok" in html
+    assert "ko" not in html
+
+
+def test_functions_have_a_module_attribute(md: Markdown) -> None:
+    """Assert functions have a `__module__` attribute.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="1"
+            def func():
+                pass
+
+            print(f"`{func.__module__}`")
+            ```
+            """,
+        ),
+    )
+    assert "_code_block_n" in html
+
+
+def test_future_annotations_do_not_leak_into_user_code(md: Markdown) -> None:
+    """Assert future annotations do not leak into user code.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="1"
+            class Int:
+                ...
+
+            def f(x: Int) -> None:
+                return x + 1.0
+
+            print(f"`{f.__annotations__['x']}`")
+            ```
+            """,
+        ),
+    )
+    assert "<code>Int</code>" not in html
+    assert re.search(r"class '_code_block_n\d+_\.Int'", html)

markdown_exec-1.9.2/tests/test_shell.py

@@ -0,0 +1,87 @@
+"""Tests for the shell formatters."""
+
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import pytest
+    from markdown import Markdown
+
+
+def test_output_markdown(md: Markdown) -> None:
+    """Assert Markdown is converted to HTML.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```sh exec="yes"
+            echo "**Bold!**"
+            ```
+            """,
+        ),
+    )
+    assert html == "<p><strong>Bold!</strong></p>"
+
+
+def test_output_html(md: Markdown) -> None:
+    """Assert HTML is injected as is.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```sh exec="yes" html="yes"
+            echo "**Bold!**"
+            ```
+            """,
+        ),
+    )
+    assert html == "<p>**Bold!**\n</p>"
+
+
+def test_error_raised(md: Markdown, caplog: pytest.LogCaptureFixture) -> None:
+    """Assert errors properly log a warning and return a formatted traceback.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+        caplog: Pytest fixture to capture logs.
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```sh exec="yes"
+            echo("wrong syntax")
+            ```
+            """,
+        ),
+    )
+    assert "error" in html
+    assert "Execution of sh code block exited with unexpected code 2" in caplog.text
+
+
+def test_return_code(md: Markdown, caplog: pytest.LogCaptureFixture) -> None:
+    """Assert return code is used correctly.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+        caplog: Pytest fixture to capture logs.
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```sh exec="yes" returncode="1"
+            echo Not in the mood
+            exit 1
+            ```
+            """,
+        ),
+    )
+    assert "Not in the mood" in html
+    assert "exited with" not in caplog.text

markdown_exec-1.9.2/tests/test_toc.py

@@ -0,0 +1,89 @@
+"""Tests for the logic updating the table of contents."""
+
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+from markdown.extensions.toc import TocExtension
+
+if TYPE_CHECKING:
+    from markdown import Markdown
+
+
+def test_updating_toc(md: Markdown) -> None:
+    """Assert ToC is updated with generated headings.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    TocExtension().extendMarkdown(md)
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="yes"
+            print("# big heading")
+            ```
+            """,
+        ),
+    )
+    assert "<h1" in html
+    assert "big-heading" in md.toc  # type: ignore[attr-defined]
+
+
+def test_not_updating_toc(md: Markdown) -> None:
+    """Assert ToC is not updated with generated headings.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    TocExtension().extendMarkdown(md)
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="yes" updatetoc="no"
+            print("# big heading")
+            ```
+            """,
+        ),
+    )
+    assert "<h1" in html
+    assert "big-heading" not in md.toc  # type: ignore[attr-defined]
+
+
+def test_both_updating_and_not_updating_toc(md: Markdown) -> None:
+    """Assert ToC is not updated with generated headings.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    TocExtension().extendMarkdown(md)
+    html = md.convert(
+        dedent(
+            """
+            ```python exec="yes" updatetoc="no"
+            print("# big heading")
+            ```
+
+            ```python exec="yes" updatetoc="yes"
+            print("## medium heading")
+            ```
+
+            ```python exec="yes" updatetoc="no"
+            print("### small heading")
+            ```
+
+            ```python exec="yes" updatetoc="yes"
+            print("#### tiny heading")
+            ```
+            """,
+        ),
+    )
+    assert "<h1" in html
+    assert "<h2" in html
+    assert "<h3" in html
+    assert "<h4" in html
+    assert "big-heading" not in md.toc  # type: ignore[attr-defined]
+    assert "medium-heading" in md.toc  # type: ignore[attr-defined]
+    assert "small-heading" not in md.toc  # type: ignore[attr-defined]
+    assert "tiny-heading" in md.toc  # type: ignore[attr-defined]

markdown_exec-1.9.2/tests/test_tree.py

@@ -0,0 +1,25 @@
+"""Tests for the shell formatters."""
+
+from textwrap import dedent
+
+from markdown import Markdown
+
+
+def test_output_markdown(md: Markdown) -> None:
+    """Assert we can highlight lines in the output.
+
+    Parameters:
+        md: A Markdown instance (fixture).
+    """
+    html = md.convert(
+        dedent(
+            """
+            ```tree hl_lines="2"
+            1
+            2
+            3
+            ```
+            """,
+        ),
+    )
+    assert '<span class="hll">' in html

markdown_exec-1.9.2/tests/test_validator.py

@@ -0,0 +1,38 @@
+"""Tests for the `validator` function."""
+
+import pytest
+from markdown.core import Markdown
+
+from markdown_exec import validator
+
+
+@pytest.mark.parametrize(
+    ("exec_value", "expected"),
+    [
+        ("yes", True),
+        ("YES", True),
+        ("on", True),
+        ("ON", True),
+        ("whynot", True),
+        ("true", True),
+        ("TRUE", True),
+        ("1", True),
+        ("-1", True),
+        ("0", False),
+        ("no", False),
+        ("NO", False),
+        ("off", False),
+        ("OFF", False),
+        ("false", False),
+        ("FALSE", False),
+    ],
+)
+def test_validate(md: Markdown, exec_value: str, expected: bool) -> None:
+    """Assert the validator returns True or False given inputs.
+
+    Parameters:
+        md: A Markdown instance.
+        exec_value: The exec option value, passed from the code block.
+        expected: Expected validation result.
+    """
+    assert validator("whatever", inputs={"exec": exec_value}, options={}, attrs={}, md=md) is expected