162 lines
5 KiB
Python
162 lines
5 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Convert Markdown into 80-column DOS-compatible plain text.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import Any, Dict, Iterable, List, Optional, Tuple
|
|
|
|
from conversion_core import parse_frontmatter, read_lines, run_conversion
|
|
from md_types import BlockStyle, FrontMatter
|
|
from markdown_parser import MarkdownParser
|
|
from plugins import (
|
|
available_parsers,
|
|
available_renderers,
|
|
get_parser_factory,
|
|
get_renderer_factory,
|
|
register_parser,
|
|
register_renderer,
|
|
)
|
|
from text_renderer import TextRenderer
|
|
|
|
import micron_renderer # noqa: F401 # register micron renderer plugin
|
|
|
|
|
|
def _split_option(token: str) -> Tuple[str, str]:
|
|
if "=" not in token:
|
|
raise argparse.ArgumentTypeError("Expected KEY=VALUE format.")
|
|
key, value = token.split("=", 1)
|
|
key = key.strip()
|
|
if not key:
|
|
raise argparse.ArgumentTypeError("Option key cannot be empty.")
|
|
return key, value
|
|
|
|
|
|
def _markdown_parser_factory(*, base_style: BlockStyle, **_: Any) -> MarkdownParser:
|
|
return MarkdownParser(base_style)
|
|
|
|
|
|
def _text_renderer_factory(*, frontmatter: FrontMatter, width: int = 80, **_: Any) -> TextRenderer:
|
|
return TextRenderer(width=width, frontmatter=frontmatter)
|
|
|
|
|
|
try:
|
|
register_parser("markdown", _markdown_parser_factory)
|
|
except ValueError:
|
|
pass
|
|
|
|
try:
|
|
register_renderer("text", _text_renderer_factory)
|
|
except ValueError:
|
|
pass
|
|
|
|
|
|
def convert_markdown(
|
|
lines: Iterable[str],
|
|
*,
|
|
width: int,
|
|
frontmatter: FrontMatter,
|
|
base_path: Optional[Path] = None,
|
|
parser_name: str = "markdown",
|
|
renderer_name: str = "text",
|
|
parser_options: Optional[Dict[str, Any]] = None,
|
|
renderer_options: Optional[Dict[str, Any]] = None,
|
|
) -> List[str]:
|
|
parser_factory = get_parser_factory(parser_name)
|
|
renderer_factory = get_renderer_factory(renderer_name)
|
|
effective_renderer_options: Dict[str, Any] = {"width": width}
|
|
if renderer_options:
|
|
effective_renderer_options.update(renderer_options)
|
|
rendered = run_conversion(
|
|
lines,
|
|
frontmatter=frontmatter,
|
|
parser_factory=parser_factory,
|
|
parser_options=parser_options,
|
|
renderer_factory=renderer_factory,
|
|
renderer_options=effective_renderer_options,
|
|
base_path=base_path,
|
|
)
|
|
if isinstance(rendered, list):
|
|
return rendered
|
|
if isinstance(rendered, tuple):
|
|
return list(rendered)
|
|
if isinstance(rendered, str):
|
|
return rendered.splitlines()
|
|
raise TypeError("Renderer plugin returned unsupported output for md2txt CLI.")
|
|
|
|
|
|
def write_output(path: Optional[Path], lines: List[str]) -> None:
|
|
content = "\r\n".join(lines)
|
|
if path is None:
|
|
sys.stdout.write(content + "\r\n")
|
|
return
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(content + "\r\n", encoding="utf-8")
|
|
|
|
|
|
def build_parser() -> argparse.ArgumentParser:
|
|
parser = argparse.ArgumentParser(description="Convert Markdown files to 80-column DOS-compatible text.")
|
|
parser.add_argument("input_path", type=Path, help="Path to the Markdown input file.")
|
|
parser.add_argument("-o", "--output", type=Path, help="Optional path to write the resulting text file.")
|
|
parser.add_argument("--width", type=int, default=80, help="Maximum column width (default: 80).")
|
|
parser.add_argument(
|
|
"--parser",
|
|
default="markdown",
|
|
choices=available_parsers() or ["markdown"],
|
|
help="Name of the parser plugin to use.",
|
|
)
|
|
parser.add_argument(
|
|
"--renderer",
|
|
default="text",
|
|
choices=available_renderers() or ["text"],
|
|
help="Name of the renderer plugin to use.",
|
|
)
|
|
parser.add_argument(
|
|
"--parser-option",
|
|
action="append",
|
|
default=[],
|
|
type=_split_option,
|
|
metavar="KEY=VALUE",
|
|
help="Additional parser option in KEY=VALUE form (may repeat).",
|
|
)
|
|
parser.add_argument(
|
|
"--renderer-option",
|
|
action="append",
|
|
default=[],
|
|
type=_split_option,
|
|
metavar="KEY=VALUE",
|
|
help="Additional renderer option in KEY=VALUE form (may repeat).",
|
|
)
|
|
return parser
|
|
|
|
|
|
def main(argv: Optional[List[str]] = None) -> int:
|
|
parser = build_parser()
|
|
args = parser.parse_args(argv)
|
|
lines = read_lines(args.input_path)
|
|
frontmatter, content = parse_frontmatter(lines)
|
|
parser_options = dict(args.parser_option or [])
|
|
renderer_options = dict(args.renderer_option or [])
|
|
try:
|
|
converted_lines = convert_markdown(
|
|
content,
|
|
width=args.width,
|
|
frontmatter=frontmatter,
|
|
base_path=args.input_path.parent,
|
|
parser_name=args.parser,
|
|
renderer_name=args.renderer,
|
|
parser_options=parser_options or None,
|
|
renderer_options=renderer_options or None,
|
|
)
|
|
except (KeyError, TypeError) as exc:
|
|
sys.stderr.write(f"{exc}\n")
|
|
return 2
|
|
write_output(args.output, converted_lines)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|