rdocx: markup the library writes breaks the schema or differs from Word (equations, notes, hyperlinks, cells, numbering, TOC, replace) #432

"""A square root written by add_equation has no m:deg (ECMA-376 Part 1, 22.1.2.88, CT_Rad: radPr?, deg, e)."""
import re
import sys
import rdocx

doc = rdocx.Document()
cases = [("latex \\sqrt{x}", r"\sqrt{x}", "latex"),
         ("latex \\sqrt[3]{x}", r"\sqrt[3]{x}", "latex"),
         ("mathml <msqrt>", '<math xmlns="http://www.w3.org/1998/Math/MathML"><msqrt><mi>x</mi></msqrt></math>',
          "mathml")]
for _, src, fmt in cases:
    doc.add_paragraph("").add_equation(src, format=fmt)
xml = doc.part_xml("word/document.xml")
failed = False
for (label, _, _), m in zip(cases, re.finditer(r"<m:rad>.*?</m:rad>", xml, re.S)):
    rad = re.sub(r">\s+<", "><", m.group(0))
    if re.search(r"(?:</m:radPr>|<m:rad>)<m:deg[ />]", rad):
        print(f"PASS {label}: m:rad holds m:deg after m:radPr")
    else:
        failed = True
        print(f"FAIL {label}: got {rad}, expected an m:deg after m:radPr")
sys.exit(1 if failed else 0)

"""add_footnote / add_endnote write w:rPr after w:footnoteRef / w:endnoteRef (CT_R wants w:rPr first),
no separator notes, and no space between the number and the note text."""
import re
import sys
import rdocx

doc = rdocx.Document()
p = doc.add_paragraph("Body text")
doc.add_footnote(p, "Source note")
doc.add_endnote(p, "End note")
failed = False


def check(ok, what, got, expected):
    global failed
    failed |= not ok
    print(f"PASS {what}" if ok else f"FAIL {what}: got {got}, expected {expected}")


for part, tag in (("word/footnotes.xml", "footnote"), ("word/endnotes.xml", "endnote")):
    xml = doc.part_xml(part)
    run = re.sub(r">\s+<", "><", re.search(rf"<w:r>(?:(?!</w:r>).)*<w:{tag}Ref/>.*?</w:r>", xml, re.S).group(0))
    check("<w:rPr>" in run and run.index("<w:rPr>") < run.index(f"<w:{tag}Ref/>"), f"{part} number run has w:rPr first",
          run, f"<w:r><w:rPr>...</w:rPr><w:{tag}Ref/></w:r>")
    seps = len(re.findall(r'w:type="(?:separator|continuationSeparator)"', xml))
    check(seps == 2, f"{part} holds the separator and continuation separator notes", seps, 2)
    text = "".join(re.findall(r"<w:t(?: [^>]*)?>([^<]*)</w:t>", xml))
    check(text.startswith(" "), f"{part} note text follows the number after a space", repr(text), "a leading space")
sys.exit(1 if failed else 0)

"""Hyperlinks written by rdocx carry no run formatting: no Hyperlink character style, colour or underline."""
import re
import sys
import rdocx


def with_hyperlink_style():
    doc = rdocx.Document()
    doc.add_style("Hyperlink", style_type="character", color="0563C1", underline=True)
    return doc


def link_xml(doc):
    found = re.search(r"<w:hyperlink\b.*?</w:hyperlink>", doc.part_xml("word/document.xml"), re.S)
    return re.sub(r">\s+<", "><", found.group(0))


cases = {}
doc = with_hyperlink_style()
doc.add_paragraph("See ").add_hyperlink("the site", "https://example.com")
cases["Paragraph.add_hyperlink"] = doc
doc = with_hyperlink_style()
doc.add_heading("Target", 1)
doc.add_paragraph("See ")
doc.add_heading_hyperlink(doc.paragraphs[1], doc.paragraphs[0], "Target")
cases["Document.add_heading_hyperlink"] = doc
cases["Document.from_markdown(template=...)"] = rdocx.Document.from_markdown(
    "See [the site](https://example.com).", template=with_hyperlink_style())[0]
cases["Document.from_html"] = rdocx.Document.from_html('<p>See <a href="https://example.com">the site</a>.</p>')[0]

failed = False
for name, doc in cases.items():
    xml = link_xml(doc)
    if re.search(r'<w:rStyle w:val="Hyperlink"/>|<w:color |<w:u ', xml):
        print(f"PASS {name}: link run is formatted")
    else:
        failed = True
        print(f'FAIL {name}: got {xml}, expected a run with <w:rStyle w:val="Hyperlink"/> (or a colour and underline)')
sys.exit(1 if failed else 0)

"""Cell.merge keeps the lone empty paragraph of an empty cell it absorbs."""
import sys
import rdocx


cases = [  # (label, shape, first cell text, second cell text, expected)
    ("horizontal, second cell empty", (1, 2), "Total", None, ["Total"]),
    ("horizontal, first cell empty", (1, 2), None, "Sum", ["Sum"]),
    ("horizontal, both with text", (1, 2), "Total", "Sum", ["Total", "Sum"]),
    ("vertical, second cell empty", (2, 1), "Total", None, ["Total"]),
]
failed = False
for label, (rows, cols), a, b, expected in cases:
    doc = rdocx.Document()
    t = doc.add_table(rows, cols)
    second = (0, 1) if cols == 2 else (1, 0)
    if a:
        t.cell(0, 0).text = a
    if b:
        t.cell(*second).text = b
    doc.tables[0].cell(0, 0).merge(doc.tables[0].cell(*second))
    got = [p.text for p in doc.tables[0].cell(0, 0).paragraphs]
    if got == expected:
        print(f"PASS {label}: merged cell paragraphs {got}")
    else:
        failed = True
        print(f"FAIL {label}: got paragraphs {got}, expected {expected}")
sys.exit(1 if failed else 0)

"""Table.insert_column and Table.add_row copy the source cell's shading but not its paragraph formatting
or the run properties of its paragraph mark."""
import re
import sys
import rdocx
from rdocx.enum.text import WD_ALIGN_PARAGRAPH

doc = rdocx.Document()
doc.add_table(2, 2)
for r in range(2):
    for c in range(2):
        cell = doc.tables[0].cell(r, c)
        cell.text = f"r{r}c{c}"
        cell.shading = "D9E2F3"
        cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
        cell.paragraphs[0].runs[0].font.bold = True
doc.tables[0].insert_column(1, before=False)
doc.tables[0].add_row()
failed = False
for label, r, c in (("insert_column(1, before=False) cell (0, 2)", 0, 2), ("add_row() cell (2, 1)", 2, 1)):
    xml = doc.tables[0].cell(r, c).xml
    m = re.search(r"<w:pPr>.*?</w:pPr>", xml, re.S)
    ppr = re.sub(r">\s+<", "><", m.group(0)) if m else None
    for what, ok in (('w:jc w:val="center"', ppr is not None and '<w:jc w:val="center"/>' in ppr),
                     ("w:b on the paragraph mark (w:pPr/w:rPr)",
                      ppr is not None and re.search(r"<w:rPr>(?:(?!</w:rPr>).)*<w:b/>", ppr) is not None)):
        if ok:
            print(f"PASS {label} keeps {what}")
        else:
            failed = True
            print(f"FAIL {label} keeps {what}: got pPr {ppr}, expected {what} as in the source cell")
sys.exit(1 if failed else 0)

"""The id add_numbering_definition returns goes stale after an edit such as add_footnote or add_picture:
add_numbering_instance(bullets) then makes an instance of the numbered definition."""
import re
import struct
import sys
import zlib
import rdocx


def png_1x1():
    chunk = lambda kind, data: struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data))
    return (b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", struct.pack(">IIBBBBB", 1, 1, 8, 2, 0, 0, 0))
            + chunk(b"IDAT", zlib.compress(b"\x00\xff\xff\xff")) + chunk(b"IEND", b""))


def comment(doc):
    doc.add_paragraph("text")
    doc.add_comment_on_text("text", author="A", text="a comment")


EDITS = {
    "no other edit": lambda d: None,
    "add_footnote": lambda d: d.add_footnote(d.add_paragraph("text"), "a note"),
    "add_picture": lambda d: d.add_picture(png_1x1(), "dot.png", width=rdocx.Inches(1), height=rdocx.Inches(1)),
    "add_comment_on_text": comment,
}
failed = False
for label, edit in EDITS.items():
    doc = rdocx.Document()
    bullets = doc.add_numbering_definition([rdocx.ListLevel(format="bullet", text="o")])
    numbers = doc.add_numbering_definition([rdocx.ListLevel(format="decimal", text="%1.")])
    n1 = doc.add_numbering_instance(numbers)
    doc.add_paragraph("numbered item", style="List Paragraph").numbering = (n1, 0)
    b1 = doc.add_numbering_instance(bullets)
    doc.add_paragraph("bullet item", style="List Paragraph").numbering = (b1, 0)
    edit(doc)
    b2 = doc.add_numbering_instance(bullets)
    xml = doc.part_xml("word/numbering.xml")
    fmt = dict(re.findall(r'<w:abstractNum w:abstractNumId="(\d+)".*?<w:numFmt w:val="(\w+)"', xml, re.S))
    num = dict(re.findall(r'<w:num w:numId="(\d+)"><w:abstractNumId w:val="(\d+)"/>', xml))
    got = fmt[num[str(b2)]]
    if got == "bullet":
        print(f"PASS {label}: add_numbering_instance(bullets) -> abstractNum {num[str(b2)]} (bullet)")
    else:
        failed = True
        print(f"FAIL {label}: add_numbering_instance(bullets) got abstractNum {num[str(b2)]} ({got}), expected bullet")
sys.exit(1 if failed else 0)

"""rebuild_toc() refuses a table of contents that insert_toc() wrote before the document had headings."""
import re
import sys
import rdocx


def report(toc_first):
    doc = rdocx.Document()
    doc.add_paragraph("Contents")
    if toc_first:
        doc.insert_toc(1, max_level=3)
    doc.add_heading("Introduction", 1)
    doc.add_paragraph("Body text.")
    doc.add_heading("Methods", 1)
    if not toc_first:
        doc.insert_toc(1, max_level=3)
    return doc


failed = False
expected = ["Introduction", "Methods"]
for label, toc_first in (("insert_toc after the headings", False), ("insert_toc before the headings", True)):
    doc = report(toc_first)
    try:
        doc.rebuild_toc()
        got = re.findall(r'<w:hyperlink w:anchor="_Toc\w*"[^>]*><w:r><w:t>([^<]*)', doc.part_xml("word/document.xml"))
    except Exception as e:
        got = f"{type(e).__name__}: {e}"
    if got == expected:
        print(f"PASS {label}: rebuild_toc() entries {got}")
    else:
        failed = True
        print(f"FAIL {label}: rebuild_toc() got {got}, expected entries {expected}")
sys.exit(1 if failed else 0)

"""`rdocx replace` and Document.try_replace_text also rewrite the cached labels of Word charts, which
`rdocx text` does not show, and leave the chart's embedded workbook with the old label."""
import io
import re
import subprocess
import sys
import zipfile
import rdocx

doc = rdocx.Document()
doc.add_paragraph("Sales in the North region rose.")
data = rdocx.CategoryChartData()
data.categories = ["North", "South"]
data.add_series("Sales", [3, 4])
doc.add_chart(rdocx.XL_CHART_TYPE.COLUMN_CLUSTERED, data, rdocx.Inches(4), rdocx.Inches(3))
doc.save("chart.docx")
failed = False


def check(ok, what, got, expected):
    global failed
    failed |= not ok
    print(f"PASS {what}" if ok else f"FAIL {what}: got {got}, expected {expected}")


shown = subprocess.run(["rdocx", "text", "chart.docx"], capture_output=True, text=True).stdout.count("North")
r = subprocess.run(["rdocx", "replace", "chart.docx", "-p", "North", "-v", "NORTH", "--expect", str(shown),
                    "-o", "out.docx"], capture_output=True, text=True)
check(r.returncode == 0, f"rdocx replace --expect {shown} (the count `rdocx text` shows)",
      f"exit {r.returncode} {r.stderr.strip()}", "exit 0")
python_doc = rdocx.Document("chart.docx")
count = python_doc.try_replace_text("North", "NORTH")
check(count == shown, "try_replace_text count matches `rdocx text`", count, shown)
z = zipfile.ZipFile(io.BytesIO(python_doc.to_bytes()))
chart = next(n for n in z.namelist() if re.fullmatch(r"word/charts/chart\d+\.xml", n))
cache = re.findall(r"<c:pt idx=\"\d\"><c:v>([A-Za-z]+)</c:v>", z.read(chart).decode())
book = zipfile.ZipFile(io.BytesIO(z.read(next(n for n in z.namelist() if n.startswith("word/embeddings/")))))
in_book = "North" in "".join(book.read(n).decode() for n in book.namelist()
                             if n == "xl/sharedStrings.xml" or n.startswith("xl/worksheets/"))
check(("North" in cache) == in_book, "chart cache and embedded workbook agree after the replacement",
      f"cache {cache}, workbook holds 'North': {in_book}", "the same labels in both")
sys.exit(1 if failed else 0)