plugin system
This commit is contained in:
randogoth
parent
1c69a01aa6
commit
03cab97dac
7 changed files with 599 additions and 251 deletions
306
conversion_core.py
Normal file
306
conversion_core.py
Normal file
|
|
@ -0,0 +1,306 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, Iterator, List, Optional, Protocol, Set, Tuple, TypeVar
|
||||
|
||||
from md_types import BlockEvent, BlockStyle, FrontMatter, StyleUpdateEvent
|
||||
|
||||
|
||||
FRONTMATTER_PATTERN = re.compile(r"^---\s*$")
|
||||
INCLUDE_WIKILINK_PATTERN = re.compile(r"^\s*!\[\[(.+?)\]\]\s*$")
|
||||
INCLUDE_DIRECTIVE_PATTERN = re.compile(r"^\s*\{\s*\.include\s+(.+?)\s*\}\s*$")
|
||||
ASCII_BLOCK_PATTERN = re.compile(
|
||||
r"^\s*#\[(?P<label>[^\]]+)\]\((?P<target>[^)]+)\)\s*(?P<attr>\{\s*:[^}]+\s*\})?\s*$"
|
||||
)
|
||||
ASCII_INLINE_PATTERN = re.compile(r"#\[(?P<label>[^\]]+)\]\((?P<target>[^)]+)\)")
|
||||
MMD_ATTR_TAIL_RE = re.compile(r"(.*?)\s*\{\s*:(.+?)\}\s*$")
|
||||
ASCII_SENTINEL_PREFIX = "\u0000ASCII:"
|
||||
|
||||
Event = BlockEvent | StyleUpdateEvent
|
||||
RendererOutput = TypeVar("RendererOutput")
|
||||
|
||||
|
||||
class Parser(Protocol):
|
||||
def parse(self, lines: Iterable[str]) -> Iterator[Event]:
|
||||
...
|
||||
|
||||
|
||||
class Renderer(Protocol[RendererOutput]):
|
||||
def handle_event(self, event: Event) -> None:
|
||||
...
|
||||
|
||||
def finalize(self) -> RendererOutput:
|
||||
...
|
||||
|
||||
|
||||
class ParserFactory(Protocol):
|
||||
def __call__(self, *, base_style: BlockStyle, **kwargs: Any) -> Parser:
|
||||
...
|
||||
|
||||
|
||||
class RendererFactory(Protocol[RendererOutput]):
|
||||
def __call__(self, *, frontmatter: FrontMatter, **kwargs: Any) -> Renderer[RendererOutput]:
|
||||
...
|
||||
|
||||
|
||||
def _parse_int(value: Optional[str], default: int = 0) -> int:
|
||||
if value is None:
|
||||
return default
|
||||
match = re.search(r"-?\d+", value)
|
||||
if not match:
|
||||
return default
|
||||
try:
|
||||
return int(match.group())
|
||||
except ValueError:
|
||||
return default
|
||||
|
||||
|
||||
def _parse_bool(value: Optional[str], default: bool = False) -> bool:
|
||||
if value is None:
|
||||
return default
|
||||
lowered = value.strip().lower()
|
||||
if lowered in {"true", "yes", "1", "on"}:
|
||||
return True
|
||||
if lowered in {"false", "no", "0", "off"}:
|
||||
return False
|
||||
return default
|
||||
|
||||
|
||||
def parse_frontmatter(lines: List[str]) -> Tuple[FrontMatter, List[str]]:
|
||||
if not lines or not FRONTMATTER_PATTERN.match(lines[0]):
|
||||
return FrontMatter(), lines
|
||||
frontmatter: Dict[str, str] = {}
|
||||
idx = 1
|
||||
while idx < len(lines):
|
||||
if FRONTMATTER_PATTERN.match(lines[idx]):
|
||||
break
|
||||
if ":" in lines[idx]:
|
||||
key, value = lines[idx].split(":", 1)
|
||||
frontmatter[key.strip()] = value.strip()
|
||||
idx += 1
|
||||
if idx >= len(lines):
|
||||
return FrontMatter(), lines
|
||||
remaining = lines[idx + 1 :] if idx + 1 < len(lines) else []
|
||||
paragraph_spacing_value = frontmatter.get("paragraph_spacing")
|
||||
if paragraph_spacing_value is None:
|
||||
paragraph_spacing_value = frontmatter.get("lines_between_paragraphs")
|
||||
if paragraph_spacing_value is None:
|
||||
paragraph_spacing_value = frontmatter.get("paragraph_lines")
|
||||
default_wrap_indent = 2
|
||||
wrap_code_blocks = _parse_bool(frontmatter.get("wrap_code_blocks"), False)
|
||||
code_block_wrap_indent = default_wrap_indent if wrap_code_blocks else 0
|
||||
code_block_wrap_value = frontmatter.get("code_block_wrap")
|
||||
if code_block_wrap_value is not None:
|
||||
normalized_wrap = code_block_wrap_value.strip()
|
||||
if normalized_wrap:
|
||||
if re.fullmatch(r"-?\d+", normalized_wrap):
|
||||
wrap_code_blocks = True
|
||||
code_block_wrap_indent = max(0, _parse_int(normalized_wrap, default_wrap_indent))
|
||||
else:
|
||||
wrap_flag = _parse_bool(normalized_wrap, wrap_code_blocks)
|
||||
wrap_code_blocks = wrap_flag
|
||||
code_block_wrap_indent = default_wrap_indent if wrap_flag else 0
|
||||
code_block_line_numbers = _parse_bool(frontmatter.get("code_block_line_numbers"), True)
|
||||
blockquote_bars = _parse_bool(frontmatter.get("blockquote_bars"), True)
|
||||
list_marker_indent = max(0, _parse_int(frontmatter.get("list_marker_indent"), 0))
|
||||
list_text_spacing = max(0, _parse_int(frontmatter.get("list_text_spacing"), 1))
|
||||
fm = FrontMatter(
|
||||
h1_font=frontmatter.get("h1_font", "standard").strip() or "standard",
|
||||
h2_font=frontmatter.get("h2_font", "standard").strip() or "standard",
|
||||
h3_font=frontmatter.get("h3_font", "standard").strip() or "standard",
|
||||
margin_left=_parse_int(frontmatter.get("margin_left"), 0),
|
||||
margin_right=_parse_int(frontmatter.get("margin_right"), 0),
|
||||
paragraph_spacing=max(0, _parse_int(paragraph_spacing_value, 0)),
|
||||
hyphenate=_parse_bool(frontmatter.get("hyphenate"), False),
|
||||
hyphen_lang=(frontmatter.get("hyphen_lang") or "en_US").strip() or "en_US",
|
||||
figlet_fallback=_parse_bool(frontmatter.get("figlet_fallback"), False),
|
||||
header_spacing=max(0, _parse_int(frontmatter.get("header_spacing"), 2)),
|
||||
wrap_code_blocks=wrap_code_blocks,
|
||||
code_block_wrap_indent=code_block_wrap_indent,
|
||||
code_block_line_numbers=code_block_line_numbers,
|
||||
blockquote_bars=blockquote_bars,
|
||||
list_marker_indent=list_marker_indent,
|
||||
list_text_spacing=list_text_spacing,
|
||||
)
|
||||
return fm, remaining
|
||||
|
||||
|
||||
def read_lines(path: Path) -> List[str]:
|
||||
with path.open("r", encoding="utf-8") as handle:
|
||||
return handle.readlines()
|
||||
|
||||
|
||||
def expand_includes(
|
||||
lines: List[str],
|
||||
base_dir: Path,
|
||||
include_stack: Set[Path],
|
||||
) -> List[str]:
|
||||
expanded: List[str] = []
|
||||
for line in lines:
|
||||
ascii_segments = _extract_ascii_segments(line, base_dir)
|
||||
if ascii_segments is not None:
|
||||
for sentinel_line, attr_line in ascii_segments:
|
||||
expanded.append(sentinel_line)
|
||||
if attr_line is not None:
|
||||
expanded.append(attr_line)
|
||||
continue
|
||||
target = _extract_include_target(line)
|
||||
if target is None:
|
||||
expanded.append(line)
|
||||
continue
|
||||
target_path = (base_dir / target).resolve()
|
||||
if target_path in include_stack:
|
||||
raise RuntimeError(f"Circular include detected for '{target_path}'.")
|
||||
if not target_path.exists():
|
||||
raise FileNotFoundError(f"Included file '{target_path}' was not found.")
|
||||
include_stack.add(target_path)
|
||||
included_lines = read_lines(target_path)
|
||||
_, include_body = parse_frontmatter(included_lines)
|
||||
included_content = expand_includes(include_body, target_path.parent, include_stack)
|
||||
expanded.extend(included_content)
|
||||
include_stack.remove(target_path)
|
||||
return expanded
|
||||
|
||||
|
||||
def _extract_include_target(line: str) -> Optional[str]:
|
||||
stripped = line.rstrip("\n")
|
||||
match = INCLUDE_WIKILINK_PATTERN.match(stripped)
|
||||
if match:
|
||||
return _normalize_include_target(match.group(1))
|
||||
match = INCLUDE_DIRECTIVE_PATTERN.match(stripped)
|
||||
if match:
|
||||
return _normalize_include_target(match.group(1))
|
||||
return None
|
||||
|
||||
|
||||
def _normalize_include_target(value: str) -> str:
|
||||
trimmed = value.strip()
|
||||
if len(trimmed) >= 2 and ((trimmed[0] == trimmed[-1]) and trimmed[0] in {"'", '"'}):
|
||||
trimmed = trimmed[1:-1].strip()
|
||||
return trimmed
|
||||
|
||||
|
||||
def _extract_ascii_segments(line: str, base_dir: Path) -> Optional[List[Tuple[str, Optional[str]]]]:
|
||||
stripped_line = line.rstrip("\n")
|
||||
block_match = ASCII_BLOCK_PATTERN.match(stripped_line)
|
||||
if block_match:
|
||||
label = block_match.group("label")
|
||||
target = block_match.group("target")
|
||||
attr_text = block_match.group("attr")
|
||||
sentinel = _make_ascii_sentinel(label, target, base_dir)
|
||||
attr_line = f"{attr_text}\n" if attr_text else None
|
||||
return [(sentinel, attr_line)]
|
||||
|
||||
matches = list(ASCII_INLINE_PATTERN.finditer(stripped_line))
|
||||
if not matches:
|
||||
return None
|
||||
|
||||
pieces: List[Dict[str, Optional[str]]] = []
|
||||
last_end = 0
|
||||
for match in matches:
|
||||
prefix = stripped_line[last_end : match.start()]
|
||||
if prefix.strip():
|
||||
return None
|
||||
label = match.group("label")
|
||||
target = match.group("target")
|
||||
block_type, block_name, align = _parse_ascii_label(label)
|
||||
normalized_target = _normalize_include_target(target)
|
||||
target_path = (base_dir / normalized_target).resolve()
|
||||
if not target_path.exists():
|
||||
raise FileNotFoundError(f"ASCII art file '{target_path}' was not found.")
|
||||
pieces.append(
|
||||
{
|
||||
"type": block_type,
|
||||
"name": block_name,
|
||||
"path": str(target_path),
|
||||
"align": align,
|
||||
}
|
||||
)
|
||||
last_end = match.end()
|
||||
|
||||
suffix = stripped_line[last_end:]
|
||||
if suffix.strip():
|
||||
return None
|
||||
|
||||
if not pieces:
|
||||
return None
|
||||
|
||||
sentinel = f"{ASCII_SENTINEL_PREFIX}{json.dumps({'pieces': pieces})}\n"
|
||||
return [(sentinel, None)]
|
||||
|
||||
|
||||
def _make_ascii_sentinel(label: str, target: str, base_dir: Path) -> str:
|
||||
block_type, block_name, align = _parse_ascii_label(label)
|
||||
normalized_target = _normalize_include_target(target)
|
||||
target_path = (base_dir / normalized_target).resolve()
|
||||
if not target_path.exists():
|
||||
raise FileNotFoundError(f"ASCII art file '{target_path}' was not found.")
|
||||
payload = {
|
||||
"pieces": [
|
||||
{
|
||||
"type": block_type,
|
||||
"name": block_name,
|
||||
"path": str(target_path),
|
||||
"align": align,
|
||||
}
|
||||
]
|
||||
}
|
||||
return f"{ASCII_SENTINEL_PREFIX}{json.dumps(payload)}\n"
|
||||
|
||||
|
||||
def _parse_ascii_label(label: str) -> Tuple[str, str, Optional[str]]:
|
||||
tokens = label.strip().split()
|
||||
non_colon: List[str] = []
|
||||
align: Optional[str] = None
|
||||
for token in tokens:
|
||||
if token.startswith(":"):
|
||||
tag = token[1:].strip().lower()
|
||||
if tag in {"left", "right", "center", "centre"}:
|
||||
align = "center" if tag in {"center", "centre"} else tag
|
||||
else:
|
||||
non_colon.append(token)
|
||||
|
||||
block_type = non_colon[0] if non_colon else "custom"
|
||||
block_name = " ".join(non_colon[1:]) if len(non_colon) > 1 else ""
|
||||
return block_type, block_name, align
|
||||
|
||||
|
||||
def run_pipeline(
|
||||
lines: Iterable[str],
|
||||
*,
|
||||
parser: Parser,
|
||||
renderer: Renderer[RendererOutput],
|
||||
base_path: Optional[Path] = None,
|
||||
) -> RendererOutput:
|
||||
base_dir = (base_path or Path.cwd()).resolve()
|
||||
expanded_lines = expand_includes(list(lines), base_dir, set())
|
||||
for event in parser.parse(expanded_lines):
|
||||
renderer.handle_event(event)
|
||||
return renderer.finalize()
|
||||
|
||||
|
||||
def run_conversion(
|
||||
lines: Iterable[str],
|
||||
*,
|
||||
frontmatter: FrontMatter,
|
||||
parser_factory: ParserFactory,
|
||||
renderer_factory: RendererFactory[RendererOutput],
|
||||
parser_options: Optional[Dict[str, Any]] = None,
|
||||
renderer_options: Optional[Dict[str, Any]] = None,
|
||||
base_path: Optional[Path] = None,
|
||||
) -> RendererOutput:
|
||||
parser = parser_factory(
|
||||
base_style=BlockStyle(
|
||||
align="left",
|
||||
margin_left=max(0, frontmatter.margin_left),
|
||||
margin_right=max(0, frontmatter.margin_right),
|
||||
),
|
||||
**(parser_options or {}),
|
||||
)
|
||||
renderer = renderer_factory(
|
||||
frontmatter=frontmatter,
|
||||
**(renderer_options or {}),
|
||||
)
|
||||
return run_pipeline(lines, parser=parser, renderer=renderer, base_path=base_path)
|
||||
Loading…
Add table
Add a link
Reference in a new issue