Igor20264
532 lines
18 KiB
Python
532 lines
18 KiB
Python
"""Convert md2gost markdown AST → Flat ODF Text (.fodt) body + document."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import os
|
|
import re
|
|
from dataclasses import dataclass, field
|
|
from pathlib import Path
|
|
|
|
from md2gost.extended_markdown import markdown
|
|
from md2gost.diagram_renderer import DIAGRAM_LANGS
|
|
from md2gost.profiles import preprocess_markdown
|
|
|
|
from .escape import escape_text, xml_id
|
|
from .styles import FODT_NS, automatic_styles_xml, styles_xml
|
|
|
|
|
|
@dataclass
|
|
class EmitState:
|
|
body: list[str] = field(default_factory=list)
|
|
pending_caption: tuple[str | None, str | None, bool] | None = None
|
|
biblio: list[tuple[str, str]] = field(default_factory=list)
|
|
work_dir: Path | None = None
|
|
fig_n: int = 0
|
|
tab_n: int = 0
|
|
lst_n: int = 0
|
|
labels: dict[str, str] = field(default_factory=dict) # id -> display number text
|
|
list_style_i: int = 0
|
|
|
|
def w(self, s: str = "") -> None:
|
|
self.body.append(s)
|
|
|
|
|
|
def _inline(children, st: EmitState | None = None) -> str:
|
|
parts: list[str] = []
|
|
for child in children or []:
|
|
t = type(child).__name__
|
|
if t in ("RawText", "Literal"):
|
|
parts.append(escape_text(getattr(child, "children", "") or ""))
|
|
elif t == "CodeSpan":
|
|
parts.append(
|
|
f'<text:span text:style-name="Tcode">{escape_text(child.children)}</text:span>'
|
|
)
|
|
elif t == "Emphasis":
|
|
parts.append(
|
|
f'<text:span text:style-name="Titalic">{_inline(child.children, st)}</text:span>'
|
|
)
|
|
elif t == "StrongEmphasis":
|
|
parts.append(
|
|
f'<text:span text:style-name="Tbold">{_inline(child.children, st)}</text:span>'
|
|
)
|
|
elif t == "Link":
|
|
href = escape_text(child.dest)
|
|
parts.append(
|
|
f'<text:a xlink:type="simple" xlink:href="{href}">'
|
|
f"{_inline(child.children, st)}</text:a>"
|
|
)
|
|
elif t == "Reference":
|
|
full = {
|
|
"рисунок": "Рисунок",
|
|
"таблица": "Таблица",
|
|
"листинг": "Листинг",
|
|
"формула": "формула",
|
|
}.get(child.type.lower(), child.type)
|
|
key = f"{child.type.lower()}:{child.name}"
|
|
num = (st.labels.get(key) if st else None) or "?"
|
|
parts.append(escape_text(f"{full} {num}"))
|
|
elif t == "InlineEquation":
|
|
parts.append(
|
|
f'<text:span text:style-name="Tcode">'
|
|
f"{escape_text(child.latex_equation)}</text:span>"
|
|
)
|
|
elif t == "Image":
|
|
parts.append("")
|
|
elif t == "LineBreak":
|
|
parts.append("<text:line-break/>")
|
|
elif hasattr(child, "children"):
|
|
parts.append(_inline(child.children, st))
|
|
else:
|
|
parts.append(escape_text(str(child)))
|
|
return "".join(parts)
|
|
|
|
|
|
def _plain_inline(children) -> str:
|
|
parts: list[str] = []
|
|
for child in children or []:
|
|
t = type(child).__name__
|
|
if t in ("RawText", "Literal"):
|
|
parts.append(getattr(child, "children", "") or "")
|
|
elif t == "CodeSpan":
|
|
parts.append(child.children or "")
|
|
elif hasattr(child, "children"):
|
|
parts.append(_plain_inline(child.children))
|
|
return "".join(parts)
|
|
|
|
|
|
def _p(style: str, content: str) -> str:
|
|
return f'<text:p text:style-name="{style}">{content}</text:p>'
|
|
|
|
|
|
def _h(level: int, content: str) -> str:
|
|
style = {1: "Heading_20_1", 2: "Heading_20_2", 3: "Heading_20_3"}.get(
|
|
level, "Heading_20_3"
|
|
)
|
|
return f'<text:h text:style-name="{style}" text:outline-level="{level}">{content}</text:h>'
|
|
|
|
|
|
def _emit_heading(st: EmitState, heading) -> None:
|
|
text = _inline(heading.children, st).strip()
|
|
plain = _plain_inline(heading.children).strip()
|
|
upper = plain.upper()
|
|
level = min(int(heading.level), 3)
|
|
|
|
if upper == "СОДЕРЖАНИЕ" or upper.startswith("СОДЕРЖАНИЕ"):
|
|
st.w(_p("Centered", escape_text("СОДЕРЖАНИЕ")))
|
|
st.w(
|
|
'<text:table-of-content text:style-name="Standard" text:protected="false" '
|
|
'text:name="TOC">'
|
|
'<text:table-of-content-source text:outline-level="3">'
|
|
'<text:index-title-template text:style-name="Centered">'
|
|
"Содержание</text:index-title-template>"
|
|
"</text:table-of-content-source>"
|
|
"<text:index-body>"
|
|
+ _p("Standard", escape_text(
|
|
"(Обновите содержание в LibreOffice Writer: ПКМ → Обновить индекс)"
|
|
))
|
|
+ "</text:index-body></text:table-of-content>"
|
|
)
|
|
return
|
|
|
|
st.w(_h(level, text))
|
|
|
|
|
|
def _emit_paragraph(st: EmitState, para) -> None:
|
|
text_probe = ""
|
|
for ch in para.children or []:
|
|
if type(ch).__name__ in ("RawText", "Literal"):
|
|
text_probe += ch.children or ""
|
|
m = re.match(r"^\[([^\]]+)\]:\s*(.+)$", text_probe.strip())
|
|
if m:
|
|
st.biblio.append((m.group(1), m.group(2).strip()))
|
|
return
|
|
|
|
has_image = any(type(c).__name__ == "Image" for c in (para.children or []))
|
|
if has_image:
|
|
for c in para.children:
|
|
if type(c).__name__ == "Image":
|
|
_emit_image(st, c)
|
|
others = [c for c in para.children if type(c).__name__ != "Image"]
|
|
t = _inline(others, st).strip()
|
|
if t:
|
|
st.w(_p("Standard", t))
|
|
return
|
|
|
|
raw = _inline(para.children, st).strip()
|
|
if raw:
|
|
st.w(_p("Standard", raw))
|
|
|
|
|
|
def _mime_for(path: Path) -> str:
|
|
ext = path.suffix.lower()
|
|
return {
|
|
".png": "image/png",
|
|
".jpg": "image/jpeg",
|
|
".jpeg": "image/jpeg",
|
|
".gif": "image/gif",
|
|
".svg": "image/svg+xml",
|
|
".bmp": "image/bmp",
|
|
".webp": "image/webp",
|
|
}.get(ext, "application/octet-stream")
|
|
|
|
|
|
def _emit_image(st: EmitState, img) -> None:
|
|
dest = img.dest
|
|
title = getattr(img, "title", None) or ""
|
|
caption_id = getattr(img, "unique_name", None)
|
|
caption_text = title
|
|
if title.startswith("%"):
|
|
parts = title[1:].split(None, 1)
|
|
caption_id = parts[0]
|
|
caption_text = parts[1] if len(parts) > 1 else ""
|
|
|
|
if st.pending_caption and not caption_text:
|
|
caption_id = caption_id or st.pending_caption[0]
|
|
caption_text = st.pending_caption[1] or ""
|
|
st.pending_caption = None
|
|
|
|
src = dest
|
|
if st.work_dir and not os.path.isabs(src):
|
|
src = str(st.work_dir / dest)
|
|
|
|
st.fig_n += 1
|
|
num = str(st.fig_n)
|
|
if caption_id:
|
|
st.labels[f"рисунок:{caption_id}"] = num
|
|
|
|
frame_inner = ""
|
|
if os.path.isfile(src):
|
|
data = Path(src).read_bytes()
|
|
b64 = base64.b64encode(data).decode("ascii")
|
|
name = Path(dest).name.replace(" ", "_")
|
|
mime = _mime_for(Path(src))
|
|
# width ~ 16cm (page content ≈ 17cm)
|
|
frame_inner = (
|
|
f'<draw:frame draw:style-name="fr1" draw:name="img{st.fig_n}" '
|
|
f'text:anchor-type="as-char" svg:width="16cm" svg:height="9cm" '
|
|
f'draw:z-index="0">'
|
|
f'<draw:image xlink:href="Pictures/{escape_text(name)}" '
|
|
f'xlink:type="simple" xlink:show="embed" xlink:actuate="onLoad" '
|
|
f'draw:mime-type="{mime}">'
|
|
f"<office:binary-data>{b64}</office:binary-data>"
|
|
f"</draw:image></draw:frame>"
|
|
)
|
|
else:
|
|
frame_inner = escape_text(f"[изображение не найдено: {dest}]")
|
|
|
|
st.w(_p("Centered", frame_inner))
|
|
cap = caption_text or "Рисунок"
|
|
label = f"Рисунок {num} — {cap}" if caption_text else f"Рисунок {num}"
|
|
bookmark = ""
|
|
if caption_id:
|
|
bid = xml_id(caption_id, "fig")
|
|
bookmark = f'<text:bookmark text:name="{bid}"/>'
|
|
st.w(_p("Caption", bookmark + escape_text(label)))
|
|
|
|
|
|
def _cell_spans(rows, row: int, col: int) -> tuple[int, int] | None:
|
|
"""Return (rowspan, colspan) or None if cell is covered by a merge."""
|
|
cell = rows[row].children[col]
|
|
if getattr(cell, "merge_v", "none") == "continue":
|
|
return None
|
|
if getattr(cell, "merge_h", "none") == "continue":
|
|
return None
|
|
|
|
rowspan = 1
|
|
if getattr(cell, "merge_v", "none") == "restart":
|
|
r = row + 1
|
|
while r < len(rows) and getattr(rows[r].children[col], "merge_v", "none") == "continue":
|
|
rowspan += 1
|
|
r += 1
|
|
|
|
colspan = 1
|
|
n_cols = len(rows[row].children)
|
|
if getattr(cell, "merge_h", "none") == "restart":
|
|
c = col + 1
|
|
while c < n_cols and getattr(rows[row].children[c], "merge_h", "none") == "continue":
|
|
colspan += 1
|
|
c += 1
|
|
|
|
return rowspan, colspan
|
|
|
|
|
|
def _emit_table(st: EmitState, table, caption_id: str | None, caption_text: str | None) -> None:
|
|
rows = table.children
|
|
if not rows:
|
|
return
|
|
|
|
st.tab_n += 1
|
|
num = str(st.tab_n)
|
|
if caption_id:
|
|
st.labels[f"таблица:{caption_id}"] = num
|
|
|
|
if caption_text or caption_id:
|
|
bookmark = ""
|
|
if caption_id:
|
|
bookmark = f'<text:bookmark text:name="{xml_id(caption_id, "tab")}"/>'
|
|
label = f"Таблица {num}"
|
|
if caption_text:
|
|
label = f"Таблица {num} — {caption_text}"
|
|
st.w(_p("Caption", bookmark + escape_text(label)))
|
|
|
|
n_cols = len(rows[0].children)
|
|
col_w = max(1, 1000 // n_cols)
|
|
covered: set[tuple[int, int]] = set()
|
|
|
|
parts: list[str] = [
|
|
f'<table:table table:name="Table{st.tab_n}" table:style-name="Table1">'
|
|
]
|
|
for _ in range(n_cols):
|
|
parts.append(
|
|
f'<table:table-column table:style-name="Table1.A" '
|
|
f'style:rel-column-width="{col_w}*"/>'
|
|
)
|
|
|
|
# Header row: repeat on page break in Writer
|
|
parts.append("<table:table-header-rows>")
|
|
parts.append(_emit_table_row(rows, 0, n_cols, st, covered))
|
|
parts.append("</table:table-header-rows>")
|
|
|
|
for ri in range(1, len(rows)):
|
|
parts.append(_emit_table_row(rows, ri, n_cols, st, covered))
|
|
|
|
parts.append("</table:table>")
|
|
st.w("".join(parts))
|
|
|
|
|
|
def _emit_table_row(
|
|
rows, ri: int, n_cols: int, st: EmitState, covered: set[tuple[int, int]]
|
|
) -> str:
|
|
cells_xml: list[str] = ["<table:table-row>"]
|
|
row = rows[ri]
|
|
ci = 0
|
|
while ci < n_cols:
|
|
if (ri, ci) in covered:
|
|
cells_xml.append("<table:covered-table-cell/>")
|
|
ci += 1
|
|
continue
|
|
if ci >= len(row.children):
|
|
cells_xml.append(
|
|
'<table:table-cell table:style-name="Table1.1" office:value-type="string">'
|
|
f"{_p('Pcell', '')}</table:table-cell>"
|
|
)
|
|
ci += 1
|
|
continue
|
|
spans = _cell_spans(rows, ri, ci)
|
|
if spans is None:
|
|
cells_xml.append("<table:covered-table-cell/>")
|
|
ci += 1
|
|
continue
|
|
rowspan, colspan = spans
|
|
attrs = ' table:style-name="Table1.1"'
|
|
if rowspan > 1:
|
|
attrs += f' table:number-rows-spanned="{rowspan}"'
|
|
if colspan > 1:
|
|
attrs += f' table:number-columns-spanned="{colspan}"'
|
|
content = _inline(row.children[ci].children, st)
|
|
cells_xml.append(
|
|
f'<table:table-cell{attrs} office:value-type="string">'
|
|
f"{_p('Pcell', content)}"
|
|
f"</table:table-cell>"
|
|
)
|
|
for dr in range(rowspan):
|
|
for dc in range(colspan):
|
|
if dr == 0 and dc == 0:
|
|
continue
|
|
covered.add((ri + dr, ci + dc))
|
|
for dc in range(1, colspan):
|
|
cells_xml.append("<table:covered-table-cell/>")
|
|
covered.discard((ri, ci + dc))
|
|
ci += colspan
|
|
cells_xml.append("</table:table-row>")
|
|
return "".join(cells_xml)
|
|
|
|
|
|
def _emit_code(st: EmitState, block, lang: str) -> None:
|
|
source = block.children[0].children if block.children else ""
|
|
cap_id, cap_text, _with_listing = (None, None, False)
|
|
if st.pending_caption:
|
|
cap_id, cap_text, _with_listing = st.pending_caption
|
|
st.pending_caption = None
|
|
|
|
lang_l = (lang or "").strip().lower()
|
|
if lang_l in DIAGRAM_LANGS:
|
|
pass # v1: source listing only
|
|
|
|
st.lst_n += 1
|
|
num = str(st.lst_n)
|
|
if cap_id:
|
|
st.labels[f"листинг:{cap_id}"] = num
|
|
|
|
if cap_text or cap_id:
|
|
bookmark = ""
|
|
if cap_id:
|
|
bookmark = f'<text:bookmark text:name="{xml_id(cap_id, "lst")}"/>'
|
|
label = f"Листинг {num}"
|
|
if cap_text:
|
|
label = f"Листинг {num} — {cap_text}"
|
|
st.w(_p("Caption", bookmark + escape_text(label)))
|
|
|
|
for line in source.rstrip("\n").split("\n"):
|
|
spaced = escape_text(line)
|
|
|
|
def _spaces(m: re.Match) -> str:
|
|
n = len(m.group(0))
|
|
return "<text:s/>" if n == 1 else f'<text:s text:c="{n}"/>'
|
|
|
|
spaced = re.sub(r" +", _spaces, spaced)
|
|
st.w(_p("Preformatted_20_Text", spaced if spaced else "<text:s/>"))
|
|
|
|
|
|
def _emit_list(st: EmitState, lst) -> None:
|
|
st.list_style_i += 1
|
|
style = "L1"
|
|
attrs = f' text:style-name="{style}"'
|
|
if lst.ordered:
|
|
# use continue numbering via list level number style — simplified
|
|
pass
|
|
st.w(f"<text:list{attrs}>")
|
|
for item in lst.children:
|
|
st.w("<text:list-item>")
|
|
for ch in item.children:
|
|
name = type(ch).__name__
|
|
if name == "Paragraph":
|
|
st.w(_p("Standard", _inline(ch.children, st)))
|
|
elif name == "List":
|
|
_emit_list(st, ch)
|
|
else:
|
|
st.w(_p("Standard", _inline(getattr(ch, "children", []) or [], st)))
|
|
st.w("</text:list-item>")
|
|
st.w("</text:list>")
|
|
|
|
|
|
def _emit_equation(st: EmitState, eq) -> None:
|
|
cap_id = None
|
|
if st.pending_caption:
|
|
cap_id = st.pending_caption[0]
|
|
st.pending_caption = None
|
|
latex = eq.latex_equation.strip()
|
|
bookmark = ""
|
|
if cap_id:
|
|
bookmark = f'<text:bookmark text:name="{xml_id(cap_id, "eq")}"/>'
|
|
st.w(_p("Centered", bookmark + f'<text:span text:style-name="Tcode">{escape_text(latex)}</text:span>'))
|
|
|
|
|
|
def emit_body(md_text: str, *, work_dir: Path, emdash_to_hyphen: bool = False) -> EmitState:
|
|
st = EmitState(work_dir=work_dir)
|
|
pre = preprocess_markdown(md_text, emdash_to_hyphen=emdash_to_hyphen)
|
|
# Two-pass: first collect captions/labels roughly by walking once for numbers,
|
|
# then emit. Simple approach: single pass (refs before definition show "?").
|
|
# Better: first pass assign numbers, second emit.
|
|
doc = markdown.parse(pre)
|
|
|
|
# Pass 1 — assign numbers for captions attached to tables/images/listings
|
|
pending = None
|
|
for el in doc.children:
|
|
name = type(el).__name__
|
|
if name == "Caption":
|
|
pending = (el.unique_name, el.text, getattr(el, "with_listing", False))
|
|
continue
|
|
if name == "Table" and pending:
|
|
st.tab_n += 1
|
|
st.labels[f"таблица:{pending[0]}"] = str(st.tab_n)
|
|
pending = None
|
|
elif name in ("FencedCode", "CodeBlock") and pending:
|
|
st.lst_n += 1
|
|
st.labels[f"листинг:{pending[0]}"] = str(st.lst_n)
|
|
pending = None
|
|
elif name == "Paragraph" and pending:
|
|
if any(type(c).__name__ == "Image" for c in (el.children or [])):
|
|
for c in el.children or []:
|
|
if type(c).__name__ == "Image":
|
|
st.fig_n += 1
|
|
cid = pending[0]
|
|
title = getattr(c, "title", "") or ""
|
|
if title.startswith("%"):
|
|
cid = title[1:].split(None, 1)[0]
|
|
st.labels[f"рисунок:{cid}"] = str(st.fig_n)
|
|
pending = None
|
|
elif name == "Equation" and pending:
|
|
pending = None
|
|
|
|
# reset counters for emit
|
|
st.fig_n = 0
|
|
st.tab_n = 0
|
|
st.lst_n = 0
|
|
st.pending_caption = None
|
|
|
|
for el in doc.children:
|
|
name = type(el).__name__
|
|
if name == "BlankLine":
|
|
continue
|
|
if name == "Caption":
|
|
st.pending_caption = (
|
|
el.unique_name,
|
|
el.text,
|
|
getattr(el, "with_listing", False),
|
|
)
|
|
continue
|
|
if name == "Heading":
|
|
_emit_heading(st, el)
|
|
continue
|
|
if name == "Paragraph":
|
|
_emit_paragraph(st, el)
|
|
continue
|
|
if name == "Table":
|
|
cid = ct = None
|
|
if st.pending_caption:
|
|
cid, ct, _ = st.pending_caption
|
|
st.pending_caption = None
|
|
_emit_table(st, el, cid, ct)
|
|
continue
|
|
if name in ("FencedCode", "CodeBlock"):
|
|
lang = getattr(el, "lang", "") or ""
|
|
_emit_code(st, el, lang)
|
|
continue
|
|
if name == "List":
|
|
_emit_list(st, el)
|
|
continue
|
|
if name == "Equation":
|
|
_emit_equation(st, el)
|
|
continue
|
|
if name == "TOC":
|
|
continue
|
|
if name == "Quote":
|
|
for ch in el.children:
|
|
if type(ch).__name__ == "Paragraph":
|
|
st.w(_p("Standard", _inline(ch.children, st)))
|
|
continue
|
|
if hasattr(el, "children"):
|
|
t = _inline(el.children, st).strip()
|
|
if t:
|
|
st.w(_p("Standard", t))
|
|
|
|
if st.biblio:
|
|
st.w(_h(1, escape_text("СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ")))
|
|
for key, txt in st.biblio:
|
|
st.w(_p("Standard", escape_text(f"[{key}] {txt}")))
|
|
|
|
return st
|
|
|
|
|
|
def emit_fodt(md_text: str, *, work_dir: Path, emdash_to_hyphen: bool = False) -> str:
|
|
st = emit_body(md_text, work_dir=work_dir, emdash_to_hyphen=emdash_to_hyphen)
|
|
body = "\n".join(st.body)
|
|
return (
|
|
'<?xml version="1.0" encoding="UTF-8"?>\n'
|
|
f"<office:document {FODT_NS.strip()}>\n"
|
|
" <office:meta>\n"
|
|
" <dc:title>md2fodt</dc:title>\n"
|
|
" <meta:generator>md2fodt</meta:generator>\n"
|
|
" </office:meta>\n"
|
|
f"{styles_xml()}"
|
|
f"{automatic_styles_xml()}"
|
|
" <office:body>\n"
|
|
" <office:text>\n"
|
|
f"{body}\n"
|
|
" </office:text>\n"
|
|
" </office:body>\n"
|
|
"</office:document>\n"
|
|
)
|