1220 lines
46 KiB
Python
1220 lines
46 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
Convert Markdown into 80-column DOS-compatible plain text.
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import re
|
||
import string
|
||
import sys
|
||
import textwrap
|
||
from dataclasses import dataclass
|
||
from pathlib import Path
|
||
from typing import Callable, Dict, Iterable, List, Optional, Tuple
|
||
|
||
try: # pragma: no cover - optional dependency
|
||
from hyphen import Hyphenator as _Hyphenator # type: ignore
|
||
except ImportError: # pragma: no cover - handled at runtime
|
||
_Hyphenator = None # type: ignore[misc]
|
||
|
||
if _Hyphenator is not None: # pragma: no branch
|
||
Hyphenator = _Hyphenator # type: ignore[assignment]
|
||
else: # pragma: no cover - fallback path
|
||
try:
|
||
import pyphen
|
||
except ImportError: # pragma: no cover - handled at runtime
|
||
Hyphenator = None # type: ignore[misc, assignment]
|
||
else:
|
||
class _PyphenWrapper:
|
||
def __init__(self, lang: str) -> None:
|
||
self._dic = pyphen.Pyphen(lang=lang)
|
||
|
||
def hyphenate_word(self, word: str): # type: ignore[override]
|
||
inserted = self._dic.inserted(word)
|
||
if not inserted:
|
||
return []
|
||
return inserted.split("-")
|
||
|
||
Hyphenator = _PyphenWrapper # type: ignore[assignment]
|
||
|
||
try:
|
||
from pyfiglet import Figlet, FontNotFound
|
||
except ImportError: # pragma: no cover - emit a helpful error at runtime instead
|
||
Figlet = None # type: ignore[assignment]
|
||
FontNotFound = ValueError # type: ignore[assignment]
|
||
|
||
|
||
FRONTMATTER_PATTERN = re.compile(r"^---\s*$")
|
||
HEADING_PATTERN = re.compile(r"^(#{1,6})\s+(.*)$")
|
||
ORDERED_LIST_PATTERN = re.compile(r"^(\s*)(\d+\.)(\s+)(.*)$")
|
||
UNORDERED_LIST_PATTERN = re.compile(r"^(\s*)([*+-])(\s+)(.*)$")
|
||
BLOCKQUOTE_PATTERN = re.compile(r"^\s{0,3}>(.*)$")
|
||
HORIZONTAL_RULE_PATTERN = re.compile(r"^\s*([-*_])(?:\s*\1){2,}\s*$")
|
||
INLINE_PARA_RE = re.compile(r"^\s*<p\b([^>]*)>(.*?)</p>\s*$", re.IGNORECASE)
|
||
PARA_OPEN_RE = re.compile(r"^\s*<p\b([^>]*)>\s*$", re.IGNORECASE)
|
||
PARA_CLOSE_RE = re.compile(r"^\s*</p>\s*$", re.IGNORECASE)
|
||
MMD_ATTR_LINE_RE = re.compile(r"^\{\s*:(.+)\}\s*$")
|
||
MMD_ATTR_TAIL_RE = re.compile(r"(.*?)\s*\{\s*:(.+?)\}\s*$")
|
||
|
||
|
||
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
|
||
|
||
|
||
@dataclass
|
||
class BlockStyle:
|
||
align: str = "left"
|
||
margin_left: int = 0
|
||
margin_right: int = 0
|
||
|
||
|
||
@dataclass
|
||
class StyleSpec:
|
||
align: Optional[str] = None
|
||
margin_left: Optional[int] = None
|
||
margin_right: Optional[int] = None
|
||
|
||
|
||
@dataclass
|
||
class BlockRecord:
|
||
start: int
|
||
length: int
|
||
render: Callable[[BlockStyle], List[str]]
|
||
style: BlockStyle
|
||
|
||
|
||
@dataclass
|
||
class FrontMatter:
|
||
h1_font: str = "standard"
|
||
h2_font: str = "standard"
|
||
h3_font: str = "standard"
|
||
margin_left: int = 0
|
||
margin_right: int = 0
|
||
paragraph_spacing: int = 0
|
||
hyphenate: bool = False
|
||
hyphen_lang: str = "en_US"
|
||
|
||
|
||
class MarkdownToTxtConverter:
|
||
def __init__(self, width: int = 80, frontmatter: Optional[FrontMatter] = None) -> None:
|
||
self.width = width
|
||
self.frontmatter = frontmatter or FrontMatter()
|
||
self.links: List[Tuple[int, str]] = []
|
||
self.link_indices: Dict[str, int] = {}
|
||
self.figlets: Dict[str, Figlet] = {}
|
||
self._base_margin_left = max(0, self.frontmatter.margin_left)
|
||
self._base_margin_right = max(0, self.frontmatter.margin_right)
|
||
self.paragraph_spacing = max(0, self.frontmatter.paragraph_spacing)
|
||
self.hyphenate = self.frontmatter.hyphenate
|
||
self.hyphen_lang = self.frontmatter.hyphen_lang or "en_US"
|
||
self.hyphenator: Optional[Hyphenator]
|
||
if self.hyphenate:
|
||
if Hyphenator is None:
|
||
raise RuntimeError("PyHyphen is required for hyphenation but is not installed.")
|
||
try:
|
||
self.hyphenator = Hyphenator(self.hyphen_lang)
|
||
except Exception as exc: # pragma: no cover - defensive
|
||
raise RuntimeError(f"Failed to initialise hyphenator for language '{self.hyphen_lang}': {exc}") from exc
|
||
else:
|
||
self.hyphenator = None
|
||
self._style_stack: List[BlockStyle] = [self._make_base_style()]
|
||
self._paragraph_style_spec: Optional[StyleSpec] = None
|
||
self._pending_block_style_spec: Optional[StyleSpec] = None
|
||
self._last_stylable_block: Optional[BlockRecord] = None
|
||
|
||
def convert(self, lines: Iterable[str]) -> List[str]:
|
||
output: List[str] = []
|
||
self.links = []
|
||
self.link_indices = {}
|
||
self._style_stack = [self._make_base_style()]
|
||
self._paragraph_style_spec = None
|
||
self._pending_block_style_spec = None
|
||
self._last_stylable_block = None
|
||
|
||
iterator = iter(lines)
|
||
in_code_block = False
|
||
code_lines: List[str] = []
|
||
indented_code_lines: List[str] = []
|
||
current_paragraph: List[str] = []
|
||
|
||
for raw_line in iterator:
|
||
line = raw_line.rstrip("\n")
|
||
|
||
if in_code_block:
|
||
if line.strip().startswith("```"):
|
||
self._emit_block(output, self._flush_code_block(code_lines))
|
||
code_lines = []
|
||
in_code_block = False
|
||
else:
|
||
code_lines.append(line)
|
||
continue
|
||
|
||
if indented_code_lines:
|
||
if line.startswith(" "):
|
||
indented_code_lines.append(line[4:])
|
||
continue
|
||
if not line.strip():
|
||
self._emit_block(output, self._flush_code_block(indented_code_lines))
|
||
indented_code_lines = []
|
||
else:
|
||
self._emit_block(output, self._flush_code_block(indented_code_lines))
|
||
indented_code_lines = []
|
||
|
||
inline_para = INLINE_PARA_RE.match(line.strip())
|
||
if inline_para:
|
||
self._flush_paragraph(current_paragraph, output)
|
||
current_paragraph = []
|
||
spec = self._style_spec_from_html_attributes(inline_para.group(1) or "")
|
||
self._push_style(spec)
|
||
content = inline_para.group(2)
|
||
if content:
|
||
current_paragraph.append(content)
|
||
self._flush_paragraph(current_paragraph, output)
|
||
current_paragraph = []
|
||
self._pop_style()
|
||
continue
|
||
|
||
open_para = PARA_OPEN_RE.match(line)
|
||
if open_para:
|
||
spec = self._style_spec_from_html_attributes(open_para.group(1) or "")
|
||
self._push_style(spec)
|
||
continue
|
||
|
||
close_para = PARA_CLOSE_RE.match(line)
|
||
if close_para:
|
||
self._flush_paragraph(current_paragraph, output)
|
||
current_paragraph = []
|
||
self._paragraph_style_spec = None
|
||
self._pop_style()
|
||
continue
|
||
|
||
stripped = line.strip()
|
||
attr_match = MMD_ATTR_LINE_RE.match(stripped)
|
||
if attr_match:
|
||
spec = self._parse_style_spec_from_tokens(attr_match.group(1))
|
||
if spec:
|
||
if current_paragraph:
|
||
self._paragraph_style_spec = self._merge_specs(self._paragraph_style_spec, spec)
|
||
elif self._last_stylable_block is not None:
|
||
self._apply_style_to_last_block(output, spec)
|
||
else:
|
||
self._pending_block_style_spec = self._merge_specs(self._pending_block_style_spec, spec)
|
||
continue
|
||
|
||
if line.strip().startswith("```"):
|
||
self._flush_paragraph(current_paragraph, output)
|
||
current_paragraph = []
|
||
in_code_block = True
|
||
code_lines = []
|
||
continue
|
||
|
||
if line.startswith(" "):
|
||
self._flush_paragraph(current_paragraph, output)
|
||
current_paragraph = []
|
||
indented_code_lines = [line[4:]]
|
||
continue
|
||
|
||
heading_match = HEADING_PATTERN.match(line)
|
||
if heading_match:
|
||
self._flush_paragraph(current_paragraph, output)
|
||
current_paragraph = []
|
||
level = len(heading_match.group(1))
|
||
heading_text = heading_match.group(2).strip()
|
||
heading_text, inline_spec = self._extract_trailing_attr(heading_text)
|
||
combined_spec = self._merge_specs(self._pending_block_style_spec, inline_spec)
|
||
style = self._combine_styles(self._current_style(), combined_spec)
|
||
render = lambda s: self._render_heading_lines(level, heading_text, s)
|
||
self._emit_block(output, render(style), stylable=True, render_fn=render, style=style)
|
||
self._pending_block_style_spec = None
|
||
continue
|
||
|
||
if HORIZONTAL_RULE_PATTERN.match(line):
|
||
self._flush_paragraph(current_paragraph, output)
|
||
current_paragraph = []
|
||
self._emit_block(output, [self._render_horizontal_rule(self._current_style())])
|
||
continue
|
||
|
||
if BLOCKQUOTE_PATTERN.match(line):
|
||
self._flush_paragraph(current_paragraph, output)
|
||
current_paragraph = []
|
||
self._handle_blockquote(line, output)
|
||
continue
|
||
|
||
if UNORDERED_LIST_PATTERN.match(line) or ORDERED_LIST_PATTERN.match(line):
|
||
self._flush_paragraph(current_paragraph, output)
|
||
current_paragraph = []
|
||
self._handle_list_line(line, output)
|
||
continue
|
||
|
||
if not line.strip():
|
||
self._flush_paragraph(current_paragraph, output)
|
||
if self.paragraph_spacing == 0:
|
||
output.append("")
|
||
current_paragraph = []
|
||
continue
|
||
|
||
current_paragraph.append(line)
|
||
|
||
self._flush_paragraph(current_paragraph, output)
|
||
if in_code_block:
|
||
self._emit_block(output, self._flush_code_block(code_lines))
|
||
if indented_code_lines:
|
||
self._emit_block(output, self._flush_code_block(indented_code_lines))
|
||
|
||
if self.links:
|
||
if output and output[-1] != "":
|
||
output.append("")
|
||
for index, url in self.links:
|
||
entry = f"[{index}] {url}"
|
||
output.extend(
|
||
self._wrap_text(
|
||
entry,
|
||
initial_indent="",
|
||
subsequent_indent="",
|
||
style=self._make_base_style(),
|
||
)
|
||
)
|
||
self._last_stylable_block = None
|
||
|
||
return output
|
||
|
||
def _flush_paragraph(self, paragraph_lines: List[str], output: List[str]) -> None:
|
||
if not paragraph_lines:
|
||
return
|
||
text = " ".join(line.strip() for line in paragraph_lines)
|
||
processed = self._process_inline(text)
|
||
combined_spec = self._merge_specs(self._pending_block_style_spec, self._paragraph_style_spec)
|
||
style = self._combine_styles(self._current_style(), combined_spec)
|
||
|
||
def render(target_style: BlockStyle) -> List[str]:
|
||
return self._wrap_text(processed, style=target_style, hyphenate=self.hyphenate)
|
||
|
||
lines = render(style)
|
||
self._emit_block(output, lines, stylable=True, render_fn=render, style=style)
|
||
if self.paragraph_spacing > 0:
|
||
output.extend([ "" for _ in range(self.paragraph_spacing) ])
|
||
paragraph_lines.clear()
|
||
self._paragraph_style_spec = None
|
||
self._pending_block_style_spec = None
|
||
|
||
def _flush_code_block(self, code_lines: List[str]) -> List[str]:
|
||
if not code_lines:
|
||
return []
|
||
width = max(2, len(str(len(code_lines))))
|
||
formatted: List[str] = []
|
||
for idx, line in enumerate(code_lines, start=1):
|
||
formatted.append(f" {idx:0{width}d} | {line}")
|
||
formatted.append("")
|
||
return formatted
|
||
|
||
def _handle_blockquote(self, line: str, output: List[str]) -> None:
|
||
# Normalize a single blockquote line before wrapping.
|
||
depth = 0
|
||
content = line
|
||
while content.lstrip().startswith(">"):
|
||
depth += 1
|
||
content = content.lstrip()[1:]
|
||
content = content.lstrip()
|
||
processed = self._process_inline(content)
|
||
indent_unit = " | "
|
||
indent = indent_unit * max(1, depth)
|
||
wrapped = self._wrap_text(
|
||
processed,
|
||
initial_indent=indent,
|
||
subsequent_indent=indent,
|
||
style=self._current_style(),
|
||
hyphenate=self.hyphenate,
|
||
)
|
||
self._emit_block(output, wrapped)
|
||
|
||
def _apply_pattern(
|
||
self,
|
||
text: str,
|
||
pattern: re.Pattern[str],
|
||
handler: Callable[[re.Match[str], str], str],
|
||
) -> str:
|
||
result: List[str] = []
|
||
last = 0
|
||
for match in pattern.finditer(text):
|
||
result.append(text[last:match.start()])
|
||
replacement = handler(match, text)
|
||
result.append(replacement)
|
||
last = match.end()
|
||
result.append(text[last:])
|
||
return "".join(result)
|
||
|
||
def _replace_spaced_emphasis(
|
||
self,
|
||
source: str,
|
||
match: re.Match[str],
|
||
*,
|
||
transform: str,
|
||
) -> str:
|
||
stylized = self._stylize_letters(match.group(1), transform=transform)
|
||
if not stylized:
|
||
return stylized
|
||
return self._apply_emphasis_spacing(source, match.start(), match.end(), stylized)
|
||
|
||
def _apply_emphasis_spacing(self, source: str, start: int, end: int, stylized: str) -> str:
|
||
if not stylized:
|
||
return stylized
|
||
prefix = ""
|
||
suffix = ""
|
||
if start > 0:
|
||
before_char = source[start - 1]
|
||
if before_char.isalnum():
|
||
prefix = " "
|
||
if end < len(source):
|
||
after_char = source[end]
|
||
if after_char.isalnum():
|
||
suffix = " "
|
||
return f"{prefix}{stylized}{suffix}"
|
||
|
||
def _handle_list_line(self, line: str, output: List[str]) -> None:
|
||
ordered = ORDERED_LIST_PATTERN.match(line)
|
||
unordered = UNORDERED_LIST_PATTERN.match(line)
|
||
if ordered:
|
||
indent, marker, spacing, rest = ordered.groups()
|
||
elif unordered:
|
||
indent, marker, spacing, rest = unordered.groups()
|
||
else: # fall back to raw line
|
||
self._emit_block(output, [line])
|
||
return
|
||
prefix = f"{indent}{marker}{spacing}"
|
||
processed = self._process_inline(rest)
|
||
wrapped = self._wrap_text(
|
||
processed,
|
||
initial_indent=prefix,
|
||
subsequent_indent=" " * len(prefix),
|
||
style=self._current_style(),
|
||
hyphenate=self.hyphenate,
|
||
)
|
||
self._emit_block(output, wrapped)
|
||
|
||
def _emit_block(
|
||
self,
|
||
output: List[str],
|
||
lines: List[str],
|
||
*,
|
||
stylable: bool = False,
|
||
render_fn: Optional[Callable[[BlockStyle], List[str]]] = None,
|
||
style: Optional[BlockStyle] = None,
|
||
) -> None:
|
||
if not lines:
|
||
return
|
||
start = len(output)
|
||
output.extend(lines)
|
||
if stylable and render_fn is not None and style is not None:
|
||
self._last_stylable_block = BlockRecord(start, len(lines), render_fn, style)
|
||
else:
|
||
self._last_stylable_block = None
|
||
|
||
def _apply_style_to_last_block(self, output: List[str], spec: StyleSpec) -> None:
|
||
if self._last_stylable_block is None:
|
||
return
|
||
new_style = self._combine_styles(self._last_stylable_block.style, spec)
|
||
new_lines = self._last_stylable_block.render(new_style)
|
||
start = self._last_stylable_block.start
|
||
end = start + self._last_stylable_block.length
|
||
output[start:end] = new_lines
|
||
self._last_stylable_block.length = len(new_lines)
|
||
self._last_stylable_block.style = new_style
|
||
|
||
def _make_base_style(self) -> BlockStyle:
|
||
return BlockStyle(
|
||
align="left",
|
||
margin_left=self._base_margin_left,
|
||
margin_right=self._base_margin_right,
|
||
)
|
||
|
||
def _current_style(self) -> BlockStyle:
|
||
return self._style_stack[-1]
|
||
|
||
def _push_style(self, spec: Optional[StyleSpec]) -> None:
|
||
base = self._current_style()
|
||
self._style_stack.append(self._combine_styles(base, spec))
|
||
|
||
def _pop_style(self) -> None:
|
||
if len(self._style_stack) > 1:
|
||
self._style_stack.pop()
|
||
|
||
def _combine_styles(self, base: BlockStyle, spec: Optional[StyleSpec]) -> BlockStyle:
|
||
if spec is None:
|
||
return BlockStyle(align=base.align, margin_left=base.margin_left, margin_right=base.margin_right)
|
||
return BlockStyle(
|
||
align=spec.align or base.align,
|
||
margin_left=spec.margin_left if spec.margin_left is not None else base.margin_left,
|
||
margin_right=spec.margin_right if spec.margin_right is not None else base.margin_right,
|
||
)
|
||
|
||
def _merge_specs(self, first: Optional[StyleSpec], second: Optional[StyleSpec]) -> Optional[StyleSpec]:
|
||
if first is None and second is None:
|
||
return None
|
||
if first is None:
|
||
return second
|
||
if second is None:
|
||
return first
|
||
return StyleSpec(
|
||
align=second.align or first.align,
|
||
margin_left=second.margin_left if second.margin_left is not None else first.margin_left,
|
||
margin_right=second.margin_right if second.margin_right is not None else first.margin_right,
|
||
)
|
||
|
||
def _style_spec_from_html_attributes(self, attributes: str) -> Optional[StyleSpec]:
|
||
if not attributes:
|
||
return None
|
||
attr_pattern = re.compile(r"([\w:-]+)\s*=\s*(\".*?\"|'.*?'|\S+)")
|
||
attr_map: Dict[str, str] = {}
|
||
for name, value in attr_pattern.findall(attributes):
|
||
attr_map[name.lower()] = value.strip().strip("\"'")
|
||
|
||
spec: Optional[StyleSpec] = None
|
||
align_value = attr_map.get("align")
|
||
if align_value:
|
||
normalized = self._normalize_align(align_value)
|
||
if normalized:
|
||
spec = self._merge_specs(spec, StyleSpec(align=normalized))
|
||
|
||
style_value = attr_map.get("style")
|
||
if style_value:
|
||
css_spec = self._style_spec_from_css(style_value)
|
||
spec = self._merge_specs(spec, css_spec)
|
||
|
||
return spec
|
||
|
||
def _style_spec_from_css(self, css: str) -> Optional[StyleSpec]:
|
||
spec = StyleSpec()
|
||
changed = False
|
||
for declaration in css.split(";"):
|
||
if ":" not in declaration:
|
||
continue
|
||
name, value = declaration.split(":", 1)
|
||
name = name.strip().lower()
|
||
value = value.strip()
|
||
if not value:
|
||
continue
|
||
if name == "text-align":
|
||
normalized = self._normalize_align(value)
|
||
if normalized:
|
||
spec.align = normalized
|
||
changed = True
|
||
elif name == "margin":
|
||
left, right, auto_center = self._parse_css_margin_shorthand(value)
|
||
if left is not None:
|
||
spec.margin_left = left
|
||
changed = True
|
||
if right is not None:
|
||
spec.margin_right = right
|
||
changed = True
|
||
if auto_center:
|
||
spec.align = "center"
|
||
changed = True
|
||
elif name == "margin-left":
|
||
parsed = self._parse_space_value(value)
|
||
if parsed is not None:
|
||
spec.margin_left = parsed
|
||
changed = True
|
||
elif value.lower() == "auto":
|
||
spec.align = spec.align or "center"
|
||
changed = True
|
||
elif name == "margin-right":
|
||
parsed = self._parse_space_value(value)
|
||
if parsed is not None:
|
||
spec.margin_right = parsed
|
||
changed = True
|
||
elif value.lower() == "auto":
|
||
spec.align = spec.align or "center"
|
||
changed = True
|
||
return spec if changed else None
|
||
|
||
def _parse_style_spec_from_tokens(self, token_str: str) -> Optional[StyleSpec]:
|
||
tokens = re.split(r"\s+", token_str.strip())
|
||
spec = StyleSpec()
|
||
changed = False
|
||
for token in tokens:
|
||
token = token.strip()
|
||
if not token:
|
||
continue
|
||
if token.startswith("."):
|
||
align = self._class_to_align(token[1:])
|
||
if align:
|
||
spec.align = align
|
||
changed = True
|
||
continue
|
||
if "=" in token:
|
||
key, value = token.split("=", 1)
|
||
key = key.strip().lower().lstrip(".")
|
||
value = value.strip().strip("\"'")
|
||
if key in {"align", "text-align"}:
|
||
normalized = self._normalize_align(value)
|
||
if normalized:
|
||
spec.align = normalized
|
||
changed = True
|
||
elif key in {"margin", "margin-left", "margin-right"}:
|
||
if key == "margin":
|
||
left, right, auto_center = self._parse_css_margin_shorthand(value)
|
||
if left is not None:
|
||
spec.margin_left = left
|
||
changed = True
|
||
if right is not None:
|
||
spec.margin_right = right
|
||
changed = True
|
||
if auto_center:
|
||
spec.align = "center"
|
||
changed = True
|
||
elif key == "margin-left":
|
||
parsed = self._parse_space_value(value)
|
||
if parsed is not None:
|
||
spec.margin_left = parsed
|
||
changed = True
|
||
elif value.lower() == "auto":
|
||
spec.align = spec.align or "center"
|
||
changed = True
|
||
elif key == "margin-right":
|
||
parsed = self._parse_space_value(value)
|
||
if parsed is not None:
|
||
spec.margin_right = parsed
|
||
changed = True
|
||
elif value.lower() == "auto":
|
||
spec.align = spec.align or "center"
|
||
changed = True
|
||
continue
|
||
align = self._normalize_align(token)
|
||
if align:
|
||
spec.align = align
|
||
changed = True
|
||
return spec if changed else None
|
||
|
||
def _parse_css_margin_shorthand(self, value: str) -> Tuple[Optional[int], Optional[int], bool]:
|
||
parts = [part for part in re.split(r"\s+", value.strip()) if part]
|
||
if not parts:
|
||
return None, None, False
|
||
|
||
values: List[Optional[int]] = []
|
||
autos: List[bool] = []
|
||
for part in parts:
|
||
if part.lower() == "auto":
|
||
values.append(None)
|
||
autos.append(True)
|
||
else:
|
||
parsed = self._parse_space_value(part)
|
||
values.append(parsed)
|
||
autos.append(False)
|
||
|
||
left_auto = False
|
||
right_auto = False
|
||
if len(values) == 1:
|
||
left = right = values[0]
|
||
left_auto = right_auto = autos[0]
|
||
elif len(values) == 2:
|
||
left = right = values[1]
|
||
left_auto = right_auto = autos[1]
|
||
elif len(values) == 3:
|
||
left = right = values[1]
|
||
left_auto = right_auto = autos[1]
|
||
else:
|
||
right = values[1]
|
||
left = values[3]
|
||
right_auto = autos[1]
|
||
left_auto = autos[3]
|
||
auto_center = left_auto and right_auto
|
||
return left, right, auto_center
|
||
|
||
def _parse_space_value(self, value: str) -> Optional[int]:
|
||
match = re.match(r"(-?\d+(?:\.\d+)?)", value.strip())
|
||
if not match:
|
||
return None
|
||
number = float(match.group(1))
|
||
return max(0, int(round(number)))
|
||
|
||
def _normalize_align(self, value: str) -> Optional[str]:
|
||
normalized = value.strip().lower()
|
||
mapping = {
|
||
"centre": "center",
|
||
"center": "center",
|
||
"left": "left",
|
||
"right": "right",
|
||
}
|
||
return mapping.get(normalized)
|
||
|
||
def _class_to_align(self, class_name: str) -> Optional[str]:
|
||
name = class_name.strip().lower().lstrip(".")
|
||
if name in {"center", "text-center", "align-center"}:
|
||
return "center"
|
||
if name in {"left", "text-left", "align-left"}:
|
||
return "left"
|
||
if name in {"right", "text-right", "align-right"}:
|
||
return "right"
|
||
return None
|
||
|
||
def _extract_trailing_attr(self, text: str) -> Tuple[str, Optional[StyleSpec]]:
|
||
match = MMD_ATTR_TAIL_RE.match(text)
|
||
if not match:
|
||
return text, None
|
||
clean_text = match.group(1).rstrip()
|
||
spec = self._parse_style_spec_from_tokens(match.group(2))
|
||
return clean_text, spec
|
||
|
||
def _render_heading_lines(self, level: int, text: str, style: BlockStyle) -> List[str]:
|
||
font_name = getattr(self.frontmatter, f"h{level}_font", "standard")
|
||
style_key = font_name.lower()
|
||
if style_key in {"caps", "title"}:
|
||
return self._render_h4_plus(text, style, transform=style_key)
|
||
if level <= 3:
|
||
figlet_lines = self._figlet_render(level, text)
|
||
if figlet_lines:
|
||
max_figlet_width = max((len(line.rstrip()) for line in figlet_lines), default=0)
|
||
if max_figlet_width <= self._effective_width(style):
|
||
styled = self._apply_style_to_lines(figlet_lines, style)
|
||
return styled + [""]
|
||
return self._render_h4_plus(text, style)
|
||
|
||
def _render_horizontal_rule(self, style: BlockStyle) -> str:
|
||
margin_left = min(max(style.margin_left, 0), self.width - 1)
|
||
available_width = max(1, self._effective_width(style))
|
||
return " " * margin_left + "-" * available_width
|
||
|
||
def _apply_style_to_lines(self, lines: List[str], style: BlockStyle) -> List[str]:
|
||
if not lines:
|
||
return []
|
||
margin_left = min(max(style.margin_left, 0), self.width - 1)
|
||
margin_right = max(style.margin_right, 0)
|
||
available_width = max(1, self.width - margin_left - margin_right)
|
||
result: List[str] = []
|
||
block: List[str] = []
|
||
|
||
def flush_block() -> None:
|
||
if not block:
|
||
return
|
||
trimmed = [entry.rstrip("\n").rstrip() for entry in block]
|
||
block_width = max((len(line) for line in trimmed), default=0)
|
||
extra_space = max(0, available_width - block_width)
|
||
if style.align == "center":
|
||
align_offset = extra_space // 2
|
||
elif style.align == "right":
|
||
align_offset = extra_space
|
||
else:
|
||
align_offset = 0
|
||
max_indent = max(0, self.width - block_width)
|
||
indent = min(margin_left + align_offset, max_indent)
|
||
indent_str = " " * indent
|
||
for line in trimmed:
|
||
result.append(indent_str + line)
|
||
block.clear()
|
||
|
||
for line in lines:
|
||
if line.strip():
|
||
block.append(line)
|
||
else:
|
||
flush_block()
|
||
result.append("")
|
||
flush_block()
|
||
return result
|
||
|
||
def _process_inline(self, text: str) -> str:
|
||
code_segments: List[str] = []
|
||
|
||
def stash_code(match: re.Match[str]) -> str:
|
||
code_segments.append(match.group(0))
|
||
return f"\u0000CODE{len(code_segments) - 1}\u0000"
|
||
|
||
text = re.sub(r"`[^`]*`", stash_code, text)
|
||
|
||
text = self._apply_pattern(
|
||
text,
|
||
re.compile(r"~~(.*?)~~"),
|
||
lambda m, src: self._stylize_delimited(m.group(1), "-", transform="preserve"),
|
||
)
|
||
text = self._apply_pattern(
|
||
text,
|
||
re.compile(r"\*\*(.*?)\*\*"),
|
||
lambda m, src: self._replace_spaced_emphasis(src, m, transform="upper"),
|
||
)
|
||
text = self._apply_pattern(
|
||
text,
|
||
re.compile(r"(?<!\*)\*(?!\*)(.*?)(?<!\*)\*(?!\*)"),
|
||
lambda m, src: self._replace_spaced_emphasis(src, m, transform="preserve"),
|
||
)
|
||
|
||
emphasis_segments: List[str] = []
|
||
|
||
def apply_with_placeholder(
|
||
current: str,
|
||
pattern: re.Pattern[str],
|
||
handler: Callable[[re.Match[str]], str],
|
||
) -> str:
|
||
def replacer(match: re.Match[str]) -> str:
|
||
replacement = handler(match)
|
||
placeholder = f"\u0000EMP{len(emphasis_segments)}\u0000"
|
||
emphasis_segments.append(replacement)
|
||
return placeholder
|
||
|
||
return pattern.sub(replacer, current)
|
||
|
||
text = apply_with_placeholder(
|
||
text,
|
||
re.compile(r"__(.*?)__"),
|
||
lambda m: self._apply_emphasis_spacing(
|
||
m.string,
|
||
m.start(),
|
||
m.end(),
|
||
self._stylize_delimited(m.group(1), "_", transform="upper", word_repeat=3),
|
||
),
|
||
)
|
||
text = apply_with_placeholder(
|
||
text,
|
||
re.compile(r"(?<!_)_(?!_)(.*?)(?<!_)_(?!_)"),
|
||
lambda m: self._apply_emphasis_spacing(
|
||
m.string,
|
||
m.start(),
|
||
m.end(),
|
||
self._stylize_delimited(m.group(1), "_", transform="preserve", word_repeat=3),
|
||
),
|
||
)
|
||
|
||
text = re.sub(r"(?<!\!)\[([^\]]+)\]\(([^)]+)\)", self._handle_link, text)
|
||
text = re.sub(r"!\[([^\]]*)\]\(([^)]+)\)", self._handle_image, text)
|
||
|
||
for index, replacement in enumerate(emphasis_segments):
|
||
placeholder = f"\u0000EMP{index}\u0000"
|
||
text = text.replace(placeholder, replacement)
|
||
|
||
for index, code in enumerate(code_segments):
|
||
placeholder = f"\u0000CODE{index}\u0000"
|
||
text = text.replace(placeholder, code)
|
||
|
||
return text
|
||
|
||
def _stylize_letters(self, content: str, transform: str = "preserve") -> str:
|
||
if not content:
|
||
return ""
|
||
result: List[str] = []
|
||
previous_alnum = False
|
||
pending_delimiter: str = ""
|
||
|
||
def apply_transform(char: str) -> str:
|
||
if transform == "upper":
|
||
return char.upper()
|
||
if transform == "lower":
|
||
return char.lower()
|
||
return char
|
||
|
||
for char in content:
|
||
processed = apply_transform(char)
|
||
if processed.isspace():
|
||
if result and result[-1].isalnum():
|
||
pending_delimiter = " "
|
||
previous_alnum = False
|
||
continue
|
||
if processed.isalnum():
|
||
if previous_alnum:
|
||
result.append(" ")
|
||
elif pending_delimiter:
|
||
result.append(pending_delimiter)
|
||
pending_delimiter = ""
|
||
elif result:
|
||
result.append(" ")
|
||
result.append(processed)
|
||
previous_alnum = True
|
||
else:
|
||
if result and result[-1] == " ":
|
||
result.pop()
|
||
if pending_delimiter:
|
||
result.append(pending_delimiter.strip())
|
||
pending_delimiter = ""
|
||
result.append(processed)
|
||
previous_alnum = False
|
||
stylized = "".join(result)
|
||
return stylized.strip()
|
||
|
||
def _stylize_delimited(
|
||
self,
|
||
content: str,
|
||
delimiter: str,
|
||
transform: str = "preserve",
|
||
word_repeat: int = 2,
|
||
) -> str:
|
||
def apply_transform(char: str) -> str:
|
||
if transform == "upper":
|
||
return char.upper()
|
||
if transform == "lower":
|
||
return char.lower()
|
||
return char
|
||
|
||
output: List[str] = []
|
||
open_sequence = False
|
||
pending_gap = False
|
||
|
||
for char in content:
|
||
if char.isspace():
|
||
if open_sequence:
|
||
pending_gap = True
|
||
continue
|
||
|
||
processed = apply_transform(char)
|
||
if not open_sequence:
|
||
output.append(delimiter)
|
||
open_sequence = True
|
||
else:
|
||
repeat = word_repeat if pending_gap else 1
|
||
output.append(delimiter * repeat)
|
||
output.append(processed)
|
||
pending_gap = False
|
||
|
||
if not open_sequence:
|
||
return delimiter * 2
|
||
|
||
output.append(delimiter)
|
||
return "".join(output)
|
||
|
||
def _handle_link(self, match: re.Match[str]) -> str:
|
||
text, target = match.groups()
|
||
url, _title = self._split_link_target(target)
|
||
index = self._register_link(url)
|
||
return f"[{text}]({index})"
|
||
|
||
def _handle_image(self, match: re.Match[str]) -> str:
|
||
alt_text, target = match.groups()
|
||
url, _title = self._split_link_target(target)
|
||
display_text = alt_text or "Image"
|
||
index = self._register_link(url)
|
||
return f"[Image: {display_text}]({index})"
|
||
|
||
def _split_link_target(self, value: str) -> Tuple[str, Optional[str]]:
|
||
value = value.strip()
|
||
if not value:
|
||
return "", None
|
||
if " " not in value:
|
||
return value.strip(), None
|
||
url, remainder = value.split(" ", 1)
|
||
remainder = remainder.strip()
|
||
if remainder.startswith('"') and remainder.endswith('"'):
|
||
return url.strip(), remainder.strip('"')
|
||
return url.strip(), remainder
|
||
|
||
def _register_link(self, url: str) -> int:
|
||
if url in self.link_indices:
|
||
return self.link_indices[url]
|
||
index = len(self.links) + 1
|
||
self.links.append((index, url))
|
||
self.link_indices[url] = index
|
||
return index
|
||
|
||
def _figlet_render(self, level: int, text: str) -> Optional[List[str]]:
|
||
if Figlet is None:
|
||
return None
|
||
font_name = getattr(self.frontmatter, f"h{level}_font", "standard")
|
||
figlet = self.figlets.get(font_name)
|
||
if figlet is None:
|
||
try:
|
||
figlet = Figlet(font=font_name)
|
||
except (FontNotFound, TypeError):
|
||
return None
|
||
self.figlets[font_name] = figlet
|
||
rendered = figlet.renderText(text).rstrip("\n")
|
||
lines = rendered.splitlines()
|
||
trimmed_lines = [line.rstrip("\n") for line in lines]
|
||
if not trimmed_lines or max(len(line.rstrip()) for line in trimmed_lines) > self.width:
|
||
return None
|
||
return [line.rstrip() for line in trimmed_lines]
|
||
|
||
def _render_h4_plus(self, text: str, style: BlockStyle, transform: str = "caps") -> List[str]:
|
||
if transform == "title":
|
||
processed = self._to_title_case(text)
|
||
elif transform == "caps":
|
||
processed = text.upper()
|
||
else:
|
||
processed = text
|
||
wrapped = self._wrap_text(processed, style=style)
|
||
output: List[str] = []
|
||
for line in wrapped:
|
||
line = line.rstrip()
|
||
if not line.strip():
|
||
output.append("")
|
||
continue
|
||
leading = len(line) - len(line.lstrip(" "))
|
||
underline = " " * leading + "-" * len(line.lstrip(" "))
|
||
output.append(line)
|
||
output.append(underline)
|
||
output.append("")
|
||
return output
|
||
|
||
def _to_title_case(self, value: str) -> str:
|
||
return string.capwords(value)
|
||
|
||
def _wrap_text(
|
||
self,
|
||
text: str,
|
||
initial_indent: str = "",
|
||
subsequent_indent: Optional[str] = None,
|
||
style: Optional[BlockStyle] = None,
|
||
hyphenate: bool = False,
|
||
) -> List[str]:
|
||
style = style or BlockStyle()
|
||
margin_left = min(max(style.margin_left, 0), self.width - 1)
|
||
available_width = max(1, self._effective_width(style))
|
||
|
||
subsequent = initial_indent if subsequent_indent is None else subsequent_indent
|
||
|
||
if hyphenate and self.hyphenator is not None:
|
||
return self._wrap_text_hyphenated(
|
||
text,
|
||
initial_indent,
|
||
subsequent,
|
||
style,
|
||
available_width,
|
||
)
|
||
|
||
wrapper = textwrap.TextWrapper(
|
||
width=available_width,
|
||
expand_tabs=False,
|
||
replace_whitespace=False,
|
||
drop_whitespace=False,
|
||
break_on_hyphens=False,
|
||
break_long_words=True,
|
||
initial_indent=initial_indent,
|
||
subsequent_indent=subsequent,
|
||
)
|
||
wrapped = wrapper.wrap(text)
|
||
if not wrapped:
|
||
wrapped = [initial_indent.rstrip()]
|
||
result: List[str] = []
|
||
for line in wrapped:
|
||
line = line.rstrip()
|
||
line_len = len(line)
|
||
extra_space = max(0, available_width - line_len)
|
||
if style.align == "center":
|
||
extra_left = extra_space // 2
|
||
elif style.align == "right":
|
||
extra_left = extra_space
|
||
else:
|
||
extra_left = 0
|
||
max_indent = max(0, self.width - line_len)
|
||
indent = min(margin_left + extra_left, max_indent)
|
||
result.append(" " * indent + line)
|
||
return result
|
||
|
||
def _wrap_text_hyphenated(
|
||
self,
|
||
text: str,
|
||
initial_indent: str,
|
||
subsequent_indent: str,
|
||
style: BlockStyle,
|
||
available_width: int,
|
||
) -> List[str]:
|
||
tokens = re.split(r"(\s+)", text)
|
||
lines: List[str] = []
|
||
current_indent = initial_indent
|
||
current_line = initial_indent
|
||
current_len = len(current_line)
|
||
width = available_width
|
||
for index, token in enumerate(tokens):
|
||
if token == "":
|
||
continue
|
||
if token.isspace():
|
||
if current_len + len(token) > width and current_len > len(current_indent):
|
||
lines.append(current_line.rstrip())
|
||
current_indent = subsequent_indent
|
||
current_line = subsequent_indent
|
||
current_len = len(current_line)
|
||
else:
|
||
current_line += token
|
||
current_len += len(token)
|
||
continue
|
||
segments = self._hyphenate_token(token) or [token]
|
||
while segments:
|
||
remaining = width - current_len
|
||
if remaining <= 1:
|
||
lines.append(current_line.rstrip())
|
||
current_indent = subsequent_indent
|
||
current_line = subsequent_indent
|
||
current_len = len(current_line)
|
||
continue
|
||
|
||
joined_length = sum(len(part) for part in segments)
|
||
if current_len + joined_length <= width:
|
||
current_line += "".join(segments)
|
||
current_len += joined_length
|
||
segments = []
|
||
break
|
||
|
||
split_index = None
|
||
running = 0
|
||
for idx in range(1, len(segments)):
|
||
running += len(segments[idx - 1])
|
||
needed = running + 1 # hyphen
|
||
if current_len + needed <= width:
|
||
split_index = idx
|
||
else:
|
||
break
|
||
|
||
if split_index is None:
|
||
# fallback: break the first segment
|
||
fragment = segments[0]
|
||
force_split = min(len(fragment), remaining - 1)
|
||
if force_split <= 0:
|
||
lines.append(current_line.rstrip())
|
||
current_indent = subsequent_indent
|
||
current_line = subsequent_indent
|
||
current_len = len(current_line)
|
||
continue
|
||
head = fragment[:force_split] + "-"
|
||
tail = fragment[force_split:]
|
||
current_line += head
|
||
lines.append(current_line.rstrip())
|
||
current_indent = subsequent_indent
|
||
current_line = subsequent_indent
|
||
current_len = len(current_line)
|
||
segments[0] = tail
|
||
if not tail:
|
||
segments.pop(0)
|
||
continue
|
||
|
||
consumed_segments = segments[:split_index]
|
||
current_line += "".join(consumed_segments) + "-"
|
||
current_len += sum(len(part) for part in consumed_segments) + 1
|
||
segments = segments[split_index:]
|
||
lines.append(current_line.rstrip())
|
||
current_indent = subsequent_indent
|
||
current_line = subsequent_indent
|
||
current_len = len(current_line)
|
||
if current_line.strip():
|
||
lines.append(current_line.rstrip())
|
||
if not lines:
|
||
lines.append(initial_indent.rstrip())
|
||
|
||
result: List[str] = []
|
||
margin_left = min(max(style.margin_left, 0), self.width - 1)
|
||
width = available_width
|
||
for line in lines:
|
||
stripped = line.rstrip()
|
||
line_len = len(stripped)
|
||
extra_space = max(0, width - line_len)
|
||
if style.align == "center":
|
||
extra_left = extra_space // 2
|
||
elif style.align == "right":
|
||
extra_left = extra_space
|
||
else:
|
||
extra_left = 0
|
||
max_indent = max(0, self.width - line_len)
|
||
indent = min(margin_left + extra_left, max_indent)
|
||
result.append(" " * indent + stripped)
|
||
return result
|
||
|
||
def _hyphenate_token(self, token: str) -> Optional[List[str]]:
|
||
if self.hyphenator is None:
|
||
return None
|
||
match = re.match(r"^([^A-Za-zÀ-ÖØ-öø-ÿ'’]*)([A-Za-zÀ-ÖØ-öø-ÿ'’]+)([^A-Za-zÀ-ÖØ-öø-ÿ'’]*)$", token)
|
||
if not match:
|
||
return None
|
||
leading, word, trailing = match.groups()
|
||
if len(word) <= 4:
|
||
return None
|
||
parts = self.hyphenator.hyphenate_word(word)
|
||
if not parts:
|
||
return None
|
||
if isinstance(parts, str):
|
||
segments = [segment for segment in parts.split("-") if segment]
|
||
else:
|
||
segments = [segment for segment in parts if segment]
|
||
if len(segments) < 2:
|
||
return None
|
||
segments[0] = leading + segments[0]
|
||
segments[-1] = segments[-1] + trailing
|
||
return segments
|
||
|
||
def _effective_width(self, style: BlockStyle) -> int:
|
||
margin_left = min(max(style.margin_left, 0), self.width - 1)
|
||
remaining = self.width - margin_left
|
||
margin_right = min(max(style.margin_right, 0), max(0, remaining - 1))
|
||
return max(1, self.width - margin_left - margin_right)
|
||
|
||
|
||
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")
|
||
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",
|
||
)
|
||
return fm, remaining
|
||
|
||
|
||
def read_lines(path: Path) -> List[str]:
|
||
with path.open("r", encoding="utf-8") as handle:
|
||
return handle.readlines()
|
||
|
||
|
||
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).")
|
||
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)
|
||
converter = MarkdownToTxtConverter(width=args.width, frontmatter=frontmatter)
|
||
converted_lines = converter.convert(content)
|
||
write_output(args.output, converted_lines)
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|