texsmith 0.0.2.dev0__py3-none-any.whl

texsmith/extensions/missing_footnotes.py

@@ -0,0 +1,125 @@
+"""Extension to capture undefined Markdown footnotes."""
+
+from __future__ import annotations
+
+from types import MethodType
+from typing import Any
+import xml.etree.ElementTree as ElementTree
+
+from markdown.extensions import Extension
+from markdown.extensions.footnotes import FootnoteExtension
+
+
+class MissingFootnotesExtension(Extension):
+    """Detect footnote references lacking explicit definitions."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.config = {
+            "element": ["texsmith-missing-footnote", "Tag inserted for missing notes."],
+            "text_template": [
+                "{id}",
+                "Fallback text rendered for missing notes (can reference {id}).",
+            ],
+            "css_class": ["", "CSS class applied to placeholder nodes."],
+            "link_to_list": [
+                False,
+                "When true, link to the generated footnote list despite the absence.",
+            ],
+            "data_attribute": [
+                "data-footnote-id",
+                "Custom attribute storing the missing footnote identifier.",
+            ],
+        }
+        super().__init__(**kwargs)
+        self._footnotes_ext: FootnoteExtension | None = None
+        self._patched_pattern = False
+        self.missing_ids: set[str] = set()
+
+    def reset(self) -> None:
+        """Reset cached state before each Markdown conversion."""
+        self.missing_ids.clear()
+
+    # -- internals ---------------------------------------------------------
+    def _get_footnotes_extension(self, md: Any) -> FootnoteExtension | None:
+        if self._footnotes_ext is not None:
+            return self._footnotes_ext
+
+        for extension in getattr(md, "registeredExtensions", []):
+            if isinstance(extension, FootnoteExtension):
+                self._footnotes_ext = extension
+                break
+        return self._footnotes_ext
+
+    def extendMarkdown(self, md: Any) -> None:  # noqa: N802 - markdown hook
+        """Patch the inline footnote processor to capture missing notes."""
+        md.registerExtension(self)
+        if self._patched_pattern:
+            return
+
+        pattern = self._resolve_footnote_pattern(md)
+        if pattern is None:
+            raise RuntimeError(
+                "MissingFootnotesExtension requires the 'footnotes' extension to be "
+                "registered beforehand."
+            )
+
+        original_handle = pattern.handleMatch
+        extension = self
+
+        def patched_handle(self_pattern: Any, match: Any, data: Any) -> Any:
+            result = original_handle(match, data)
+            if result and result[0] is not None:
+                return result
+
+            footnote_id = match.group(1)
+            extension.missing_ids.add(footnote_id)
+            node = extension.build_placeholder(footnote_id, self_pattern)
+            return node, match.start(0), match.end(0)
+
+        pattern.handleMatch = MethodType(patched_handle, pattern)
+        self._patched_pattern = True
+
+    def _resolve_footnote_pattern(self, md: Any) -> Any:
+        patterns = getattr(md.inlinePatterns, "items", None)
+        if callable(patterns):
+            for name, pattern in md.inlinePatterns.items():
+                if name == "footnote":
+                    return pattern
+        else:
+            try:
+                return md.inlinePatterns["footnote"]
+            except KeyError:
+                return None
+        return None
+
+    def build_placeholder(self, identifier: str, pattern: Any) -> ElementTree.Element:
+        """Construct the XML placeholder inserted for missing footnotes."""
+        element_name = self.getConfig("element")
+        node = ElementTree.Element(element_name)
+
+        css_class = self.getConfig("css_class")
+        if css_class:
+            node.set("class", css_class)
+
+        data_attribute = self.getConfig("data_attribute")
+        if data_attribute:
+            node.set(data_attribute, identifier)
+
+        text = self.getConfig("text_template").format(id=identifier)
+        if self.getConfig("link_to_list"):
+            footnote_extension = self._get_footnotes_extension(pattern.md)
+            separator = footnote_extension.get_separator() if footnote_extension else ":"
+            anchor = ElementTree.SubElement(node, "a")
+            if css_class:
+                anchor.set("class", css_class)
+            anchor.set("href", f"#fn{separator}{identifier}")
+            anchor.text = text
+        else:
+            node.text = text
+
+        return node
+
+
+def makeExtension(**kwargs: Any) -> MissingFootnotesExtension:  # noqa: N802 - markdown hook
+    """Entry point exposed to Python-Markdown."""
+    return MissingFootnotesExtension(**kwargs)

texsmith/extensions/multi_citations.py

@@ -0,0 +1,54 @@
+"""Markdown preprocessor normalising inline citation references."""
+
+from __future__ import annotations
+
+import re
+
+from markdown import Markdown
+from markdown.extensions import Extension
+from markdown.preprocessors import Preprocessor
+
+
+_DOI_PATTERN = r"10\.\d{4,9}/[^\s\]]+"
+_TOKEN_RE = re.compile(rf"^(?:{_DOI_PATTERN}|[0-9A-Za-z_:-]+)$")
+_PATTERN = re.compile(r"\^\[(?P<keys>[^\]]+)\]")
+
+
+def _clean_keys(payload: str) -> list[str]:
+    candidates = [part.strip() for part in payload.split(",")]
+    cleaned = [key for key in candidates if key and _TOKEN_RE.match(key)]
+    return cleaned
+
+
+class _MultiCitationPreprocessor(Preprocessor):
+    """Convert ``^[A,B]`` references into ``[^A,B]`` before footnote processing."""
+
+    def run(self, lines: list[str]) -> list[str]:
+        return [_PATTERN.sub(self._replace_match, line) for line in lines]
+
+    @staticmethod
+    def _replace_match(match: re.Match[str]) -> str:
+        cleaned = _clean_keys(match.group("keys"))
+        if not cleaned:
+            return match.group(0)
+        return f"[^{','.join(cleaned)}]"
+
+
+class MultiCitationExtension(Extension):
+    """Register the multi-citation preprocessor before the footnotes extension."""
+
+    def extendMarkdown(self, md: Markdown) -> None:  # type: ignore[override]  # noqa: N802
+        md.preprocessors.register(
+            _MultiCitationPreprocessor(),
+            "texsmith_multi_citations",
+            priority=5,
+        )
+
+
+def makeExtension(  # noqa: N802
+    **kwargs: object,
+) -> MultiCitationExtension:  # pragma: no cover - API hook
+    return MultiCitationExtension(**kwargs)
+
+
+__all__ = ["MultiCitationExtension", "makeExtension"]

texsmith/extensions/progressbar/__init__.py

@@ -0,0 +1,9 @@
+"""Public entry points for the Markdown progress bar extension."""
+
+from __future__ import annotations
+
+from .markdown import ProgressBarExtension, makeExtension
+from .renderer import register as register_renderer
+
+
+__all__ = ["ProgressBarExtension", "makeExtension", "register_renderer"]

texsmith/extensions/progressbar/markdown.py

@@ -0,0 +1,212 @@
+"""Markdown extension transforming `[=80% "Label"]` blocks into progress bars."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+import re
+import shlex
+from xml.etree import ElementTree
+
+from markdown import Markdown
+from markdown.extensions import Extension
+from markdown.preprocessors import Preprocessor
+
+
+PROGRESS_LINE = re.compile(
+    r"""
+    ^\s*
+    \[=
+    (?P<value>-?\d+(?:\.\d+)?)
+    \s*%
+    \s*
+    (?:
+        "(?P<label>[^"]*)"
+    )?
+    \]
+    (?P<attrs>\{:[^}]+\})?
+    \s*$
+    """,
+    re.VERBOSE,
+)
+ATTR_LINE = re.compile(r"^\s*\{:[^}]+\}\s*$")
+
+
+@dataclass(slots=True)
+class _AttributePayload:
+    classes: list[str]
+    identifier: str | None
+    attributes: dict[str, str]
+
+
+class _ProgressBarPreprocessor(Preprocessor):
+    """Convert the Pymdown-like shorthand into semantic HTML."""
+
+    def run(self, lines: list[str]) -> list[str]:  # type: ignore[override]
+        result: list[str] = []
+        index = 0
+        length = len(lines)
+        in_fence = False
+        fence_char: str | None = None
+        fence_len = 0
+
+        while index < length:
+            line = lines[index]
+            stripped = line.lstrip()
+
+            if not in_fence and self._looks_like_fence_start(stripped):
+                fence_char = stripped[0]
+                fence_len = self._fence_length(stripped)
+                if fence_len >= 3:
+                    in_fence = True
+                result.append(line)
+                index += 1
+                continue
+
+            if in_fence:
+                result.append(line)
+                if self._is_fence_end(stripped, fence_char, fence_len):
+                    in_fence = False
+                index += 1
+                continue
+
+            match = PROGRESS_LINE.match(line)
+            attrs_text = None
+
+            if match:
+                attrs_text = match.group("attrs")
+                if attrs_text is None and index + 1 < length:
+                    next_candidate = lines[index + 1]
+                    if ATTR_LINE.match(next_candidate):
+                        attrs_text = next_candidate.strip()
+                        index += 1
+
+                payload = self._render_progressbar(match, attrs_text)
+                result.append(payload)
+                index += 1
+                continue
+
+            result.append(line)
+            index += 1
+
+        return result
+
+    def _looks_like_fence_start(self, stripped: str) -> bool:
+        if not stripped:
+            return False
+        char = stripped[0]
+        if char not in {"`", "~"}:
+            return False
+        return stripped.startswith(char * 3)
+
+    def _is_fence_end(
+        self,
+        stripped: str,
+        fence_char: str | None,
+        fence_len: int,
+    ) -> bool:
+        if not fence_char or fence_len < 3:
+            return False
+        return stripped.startswith(fence_char * fence_len)
+
+    def _fence_length(self, stripped: str) -> int:
+        if not stripped:
+            return 0
+        char = stripped[0]
+        count = 0
+        for ch in stripped:
+            if ch == char:
+                count += 1
+            else:
+                break
+        return count
+
+    def _render_progressbar(
+        self,
+        match: re.Match[str],
+        attrs_text: str | None,
+    ) -> str:
+        percent = float(match.group("value"))
+        percent = max(0.0, min(100.0, percent))
+        label = match.group("label")
+        if label is None or not label.strip():
+            label = f"{percent:g}%"
+        attrs = self._parse_attributes(attrs_text)
+
+        classes = ["progress", _progress_bucket_class(percent), *attrs.classes]
+        fraction = percent / 100.0
+        fraction_str = _format_decimal(fraction, precision=4)
+
+        container = ElementTree.Element("div")
+        container.set("class", " ".join(filter(None, classes)))
+        container.set("data-progress-percent", _format_decimal(percent, precision=2))
+        container.set("data-progress-fraction", fraction_str)
+        if attrs.identifier:
+            container.set("id", attrs.identifier)
+        for key, value in attrs.attributes.items():
+            container.set(key, value)
+
+        bar = ElementTree.SubElement(container, "div", {"class": "progress-bar"})
+        bar.set("style", f"width:{_format_decimal(percent, precision=2)}%;")
+        bar.set("data-progress-fraction", fraction_str)
+
+        label_node = ElementTree.SubElement(bar, "p", {"class": "progress-label"})
+        label_node.text = label
+
+        return ElementTree.tostring(container, encoding="unicode")
+
+    def _parse_attributes(self, raw: str | None) -> _AttributePayload:
+        if not raw:
+            return _AttributePayload([], None, {})
+        body = raw.strip()
+        if body.startswith("{"):
+            body = body[2:-1].strip()
+
+        classes: list[str] = []
+        attributes: dict[str, str] = {}
+        identifier: str | None = None
+
+        lexer = shlex.shlex(body, posix=True)
+        lexer.whitespace_split = True
+        lexer.commenters = ""
+
+        for token in lexer:
+            if not token:
+                continue
+            if token.startswith("."):
+                classes.append(token[1:])
+            elif token.startswith("#"):
+                identifier = token[1:] or identifier
+            elif "=" in token:
+                key, value = token.split("=", 1)
+                attributes[key] = value
+
+        return _AttributePayload(classes, identifier, attributes)
+
+
+def _progress_bucket_class(percent: float) -> str:
+    bucket = int(math.floor(percent / 5.0) * 5)
+    bucket = max(0, min(100, bucket))
+    return f"progress-{bucket}plus"
+
+
+def _format_decimal(value: float, *, precision: int) -> str:
+    formatted = f"{value:.{precision}f}"
+    return formatted.rstrip("0").rstrip(".") or "0"
+
+
+class ProgressBarExtension(Extension):
+    """Register the preprocessor on the Markdown pipeline."""
+
+    def extendMarkdown(self, md: Markdown) -> None:  # noqa: N802
+        processor = _ProgressBarPreprocessor(md)
+        md.preprocessors.register(processor, "texsmith_progressbar", 27)
+
+
+def makeExtension(  # noqa: N802
+    **kwargs: object,
+) -> ProgressBarExtension:  # pragma: no cover - Markdown hook
+    return ProgressBarExtension(**kwargs)
+
+
+__all__ = ["ProgressBarExtension", "makeExtension"]

texsmith/extensions/progressbar/renderer.py

@@ -0,0 +1,117 @@
+"""Renderer hooks converting HTML progress bars into LaTeX commands."""
+
+from __future__ import annotations
+
+import re
+
+from bs4 import NavigableString, Tag
+
+from texsmith.adapters.handlers._helpers import coerce_attribute, gather_classes, mark_processed
+from texsmith.adapters.latex.utils import escape_latex_chars
+from texsmith.core.context import RenderContext
+from texsmith.core.rules import RenderPhase, renders
+
+
+DEFAULT_HEIGHT = "12pt"
+THIN_HEIGHT = "6pt"
+DEFAULT_OPTIONS = {
+    "width": "9cm",
+    "heighta": DEFAULT_HEIGHT,
+    "roundnessr": "0.1",
+    "borderwidth": "1pt",
+    "linecolor": "black",
+    "filledcolor": "black!60",
+    "emptycolor": "black!10",
+}
+
+
+@renders(
+    "div",
+    phase=RenderPhase.BLOCK,
+    priority=58,
+    name="texsmith_progressbar",
+    nestable=False,
+    auto_mark=False,
+)
+def render_progressbar(element: Tag, context: RenderContext) -> None:
+    r"""Convert ``<div class="progress">`` nodes into ``\progressbar`` calls."""
+    classes = gather_classes(element.get("class"))
+    if "progress" not in classes:
+        return
+
+    bar = element.find("div", class_="progress-bar")
+    if bar is None:
+        return
+
+    percent = _extract_percent(element, bar)
+    fraction = max(0.0, min(1.0, percent / 100.0))
+
+    label_node = bar.find("p", class_="progress-label")
+    label_text = label_node.get_text(strip=True) if label_node else f"{percent:g}%"
+    legacy_accents = getattr(context.config, "legacy_latex_accents", False)
+    escaped_label = escape_latex_chars(label_text, legacy_accents=legacy_accents)
+
+    thin = "thin" in classes or "progress-thin" in classes
+    latex = _compose_latex(fraction, escaped_label, thin=thin)
+
+    node = mark_processed(NavigableString(latex))
+    context.mark_processed(element)
+    context.suppress_children(element)
+    element.replace_with(node)
+
+
+def _extract_percent(element: Tag, bar: Tag) -> float:
+    for attr in ("data-progress-percent", "data-progress", "data-progress-value"):
+        value = coerce_attribute(element.get(attr)) or coerce_attribute(bar.get(attr))
+        if value:
+            try:
+                return float(value)
+            except ValueError:
+                continue
+
+    style = coerce_attribute(bar.get("style")) or ""
+    match = re.search(r"width:\s*([0-9.]+)", style)
+    if match:
+        try:
+            return float(match.group(1))
+        except ValueError:
+            return 0.0
+
+    fraction_attr = coerce_attribute(bar.get("data-progress-fraction"))
+    if fraction_attr:
+        try:
+            return float(fraction_attr) * 100.0
+        except ValueError:
+            return 0.0
+
+    return 0.0
+
+
+def _compose_latex(fraction: float, label: str, *, thin: bool) -> str:
+    value = max(0.0, min(1.0, fraction))
+    height = THIN_HEIGHT if thin else DEFAULT_HEIGHT
+    options = dict(DEFAULT_OPTIONS)
+    options["heighta"] = height
+    options_payload = ",".join(f"{key}={value}" for key, value in options.items())
+    value_payload = _format_fraction(value)
+    return f"{{\\progressbar[{options_payload}]{{{value_payload}}} {label}}}\\par\n"
+
+
+def _format_fraction(value: float) -> str:
+    formatted = f"{value:.4f}"
+    trimmed = formatted.rstrip("0").rstrip(".")
+    return trimmed or "0"
+
+
+def register(renderer: object) -> None:
+    """Register the progress bar handler with the renderer."""
+    register_callable = getattr(renderer, "register", None)
+    if not callable(register_callable):
+        raise TypeError("Renderer does not expose a 'register' method.")
+    if getattr(renderer, "_texsmith_progressbar_registered", False):
+        return
+    register_callable(render_progressbar)
+    renderer._texsmith_progressbar_registered = True  # noqa: SLF001
+
+
+__all__ = ["register", "render_progressbar"]

texsmith/extensions/smallcaps.py

@@ -0,0 +1,48 @@
+"""Markdown extension that maps double underscores to small caps spans."""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ElementTree
+
+from markdown import Markdown
+from markdown.extensions import Extension
+from markdown.inlinepatterns import InlineProcessor
+
+
+_SMALL_CAPS_PATTERN = r"(?<!_)__(?!_)(.+?)__(?!_)"
+
+
+class _SmallCapsInlineProcessor(InlineProcessor):
+    """Inline processor converting ``__text__`` into a span marker."""
+
+    def handleMatch(  # type: ignore[override]  # noqa: N802 - Markdown API requires camelCase
+        self,
+        match,  # type: ignore[override]  # noqa: ANN001
+        data: str,
+    ) -> tuple[ElementTree.Element | None, int | None, int | None]:
+        content = match.group(1)
+        if not content:
+            return None, None, None
+
+        element = ElementTree.Element("span", {"class": "texsmith-smallcaps"})
+        parser = getattr(self, "parser", None)
+        if parser is not None:
+            parser.parseInline(element, content)
+        else:  # pragma: no cover - parser is provided by Markdown
+            element.text = content
+        return element, match.start(0), match.end(0)
+
+
+class SmallCapsExtension(Extension):
+    """Register the ``__text__`` → ``<span class=\"texsmith-smallcaps\">`` processor."""
+
+    def extendMarkdown(self, md: Markdown) -> None:  # type: ignore[override]  # noqa: N802
+        processor = _SmallCapsInlineProcessor(_SMALL_CAPS_PATTERN, md)
+        md.inlinePatterns.register(processor, "texsmith_smallcaps", 185)
+
+
+def makeExtension(**_: object) -> SmallCapsExtension:  # pragma: no cover - API hook  # noqa: N802
+    return SmallCapsExtension()
+
+
+__all__ = ["SmallCapsExtension", "makeExtension"]

texsmith/extensions/texlogos/__init__.py

@@ -0,0 +1,10 @@
+"""TeXSmith extension providing extra TeX logo commands."""
+
+from __future__ import annotations
+
+from .markdown import TexLogosExtension, makeExtension
+from .renderer import register as register_renderer
+from .specs import LogoSpec, iter_specs
+
+
+__all__ = ["LogoSpec", "TexLogosExtension", "iter_specs", "makeExtension", "register_renderer"]