.config/neomutt/buildmimetree.py

   1 #!/usr/bin/python3
   2 #
   3 # NeoMutt helper script to create multipart/* emails with Markdown → HTML
   4 # alternative conversion, and handling of inline images, using NeoMutt's
   5 # ability to manually craft MIME trees, but automating this process.
   6 #
   7 # Configuration:
   8 #   neomuttrc (needs to be a single line):
   9 #     macro compose B "\
  10 #       <enter-command> source '$my_confdir/buildmimetree.py setup --tempdir $tempdir|'<enter>\
  11 #       <enter-command> sourc e \$my_mdwn_postprocess_cmd_file<enter>\
  12 #     " "Convert message into a modern MIME tree with inline images"
  13 #
  14 #     (Yes, we need to call source twice, as mutt only starts to process output
  15 #     from a source command when the command exits, and since we need to react
  16 #     to the output, we need to be invoked again, using a $my_ variable to pass
  17 #     information)
  18 #
  19 # Requirements:
  20 #   - python3
  21 #   - python3-markdown
  22 # Optional:
  23 #   - pytest
  24 #   - Pynliner
  25 #   - Pygments, if installed, then syntax highlighting is enabled
  26 #
  27 # Latest version:
  28 #   https://git.madduck.net/etc/neomutt.git/blob_plain/HEAD:/.config/neomutt/buildmimetree.py
  29 #
  30 # Copyright © 2023 martin f. krafft <madduck@madduck.net>
  31 # Released under the GPL-2+ licence, just like Mutt itself.
  32 #
  33
  34 import sys
  35 import pathlib
  36 import markdown
  37 import tempfile
  38 import argparse
  39 import re
  40 import mimetypes
  41 from collections import namedtuple, OrderedDict
  42 from markdown.extensions import Extension
  43 from markdown.inlinepatterns import ImageInlineProcessor, IMAGE_LINK_RE
  44 from email.utils import make_msgid
  45 from urllib import request
  46
  47
  48 def parse_cli_args(*args, **kwargs):
  49     parser = argparse.ArgumentParser(
  50         description=(
  51             "NeoMutt helper to turn text/markdown email parts "
  52             "into full-fledged MIME trees"
  53         )
  54     )
  55     parser.epilog = (
  56         "Copyright © 2022 martin f. krafft <madduck@madduck.net>.\n"
  57         "Released under the MIT licence"
  58     )
  59
  60     subp = parser.add_subparsers(help="Sub-command parsers", dest="mode")
  61     parser_setup = subp.add_parser("setup", help="Setup phase")
  62     parser_massage = subp.add_parser("massage", help="Massaging phase")
  63
  64     parser_setup.add_argument(
  65         "--extension",
  66         "-x",
  67         metavar="EXTENSION",
  68         dest="extensions",
  69         nargs="?",
  70         default=[],
  71         action="append",
  72         help="Markdown extension to add to the list of extensions use",
  73     )
  74
  75     parser_setup.add_argument(
  76         "--only-build",
  77         action="store_true",
  78         help="Only build, don't send the message",
  79     )
  80
  81     parser_setup.add_argument(
  82         "--tempdir",
  83         default=None,
  84         help="Specify temporary directory to use for attachments",
  85     )
  86
  87     parser_setup.add_argument(
  88         "--debug-commands",
  89         action="store_true",
  90         help="Turn on debug logging of commands generated to stderr",
  91     )
  92
  93     parser_massage.add_argument(
  94         "--write-commands-to",
  95         metavar="PATH",
  96         dest="cmdpath",
  97         help="Temporary file path to write commands to",
  98     )
  99
 100     parser_massage.add_argument(
 101         "--extensions",
 102         metavar="EXTENSIONS",
 103         type=str,
 104         default="",
 105         help="Markdown extension to use (comma-separated list)",
 106     )
 107
 108     parser_massage.add_argument(
 109         "--only-build",
 110         action="store_true",
 111         help="Only build, don't send the message",
 112     )
 113
 114     parser_massage.add_argument(
 115         "--tempdir",
 116         default=None,
 117         help="Specify temporary directory to use for attachments",
 118     )
 119
 120     parser_massage.add_argument(
 121         "--debug-commands",
 122         action="store_true",
 123         help="Turn on debug logging of commands generated to stderr",
 124     )
 125
 126     parser_massage.add_argument(
 127         "--debug-walk",
 128         action="store_true",
 129         help="Turn on debugging to stderr of the MIME tree walk",
 130     )
 131
 132     parser_massage.add_argument(
 133         "MAILDRAFT",
 134         nargs="?",
 135         help="If provided, the script is invoked as editor on the mail draft",
 136     )
 137
 138     return parser.parse_args(*args, **kwargs)
 139
 140
 141 # [ MARKDOWN WRAPPING ] #######################################################
 142
 143
 144 InlineImageInfo = namedtuple(
 145     "InlineImageInfo", ["cid", "desc"], defaults=[None]
 146 )
 147
 148
 149 class InlineImageExtension(Extension):
 150     class RelatedImageInlineProcessor(ImageInlineProcessor):
 151         def __init__(self, re, md, ext):
 152             super().__init__(re, md)
 153             self._ext = ext
 154
 155         def handleMatch(self, m, data):
 156             el, start, end = super().handleMatch(m, data)
 157             if "src" in el.attrib:
 158                 src = el.attrib["src"]
 159                 if "://" not in src or src.startswith("file://"):
 160                     # We only inline local content
 161                     cid = self._ext.get_cid_for_image(el.attrib)
 162                     el.attrib["src"] = f"cid:{cid}"
 163             return el, start, end
 164
 165     def __init__(self):
 166         super().__init__()
 167         self._images = OrderedDict()
 168
 169     def extendMarkdown(self, md):
 170         md.registerExtension(self)
 171         inline_image_proc = self.RelatedImageInlineProcessor(
 172             IMAGE_LINK_RE, md, self
 173         )
 174         md.inlinePatterns.register(inline_image_proc, "image_link", 150)
 175
 176     def get_cid_for_image(self, attrib):
 177         msgid = make_msgid()[1:-1]
 178         path = attrib["src"]
 179         if path.startswith("/"):
 180             path = f"file://{path}"
 181         self._images[path] = InlineImageInfo(
 182             msgid, attrib.get("title", attrib.get("alt"))
 183         )
 184         return msgid
 185
 186     def get_images(self):
 187         return self._images
 188
 189
 190 def markdown_with_inline_image_support(text, *, extensions=None):
 191     inline_image_handler = InlineImageExtension()
 192     extensions = extensions or []
 193     extensions.append(inline_image_handler)
 194     mdwn = markdown.Markdown(extensions=extensions)
 195     htmltext = mdwn.convert(text)
 196
 197     images = inline_image_handler.get_images()
 198
 199     def replace_image_with_cid(matchobj):
 200         for m in (matchobj.group(1), f"file://{matchobj.group(1)}"):
 201             if m in images:
 202                 return f"(cid:{images[m].cid}"
 203         return matchobj.group(0)
 204
 205     text = re.sub(r"\(([^)\s]+)", replace_image_with_cid, text)
 206     return text, htmltext, images
 207
 208
 209 # [ PARTS GENERATION ] ########################################################
 210
 211
 212 class Part(
 213     namedtuple(
 214         "Part",
 215         ["type", "subtype", "path", "desc", "cid", "orig"],
 216         defaults=[None, None, False],
 217     )
 218 ):
 219     def __str__(self):
 220         ret = f"<{self.type}/{self.subtype}>"
 221         if self.cid:
 222             ret = f"{ret} cid:{self.cid}"
 223         if self.orig:
 224             ret = f"{ret} ORIGINAL"
 225         return ret
 226
 227
 228 class Multipart(
 229     namedtuple("Multipart", ["subtype", "children", "desc"], defaults=[None])
 230 ):
 231     def __str__(self):
 232         return f"<multipart/{self.subtype}> children={len(self.children)}"
 233
 234
 235 def filewriter_fn(path, content, mode="w", **kwargs):
 236     with open(path, mode, **kwargs) as out_f:
 237         out_f.write(content)
 238
 239
 240 def collect_inline_images(
 241     images, *, tempdir=None, filewriter_fn=filewriter_fn
 242 ):
 243     relparts = []
 244     for path, info in images.items():
 245         data = request.urlopen(path)
 246
 247         mimetype = data.headers["Content-Type"]
 248         ext = mimetypes.guess_extension(mimetype)
 249         tempfilename = tempfile.mkstemp(prefix="img", suffix=ext, dir=tempdir)
 250         path = pathlib.Path(tempfilename[1])
 251
 252         filewriter_fn(path, data.read(), "w+b")
 253
 254         relparts.append(
 255             Part(*mimetype.split("/"), path, cid=info.cid, desc=f"Image: {info.desc}")
 256         )
 257
 258     return relparts
 259
 260
 261 def convert_markdown_to_html(
 262     origtext,
 263     draftpath,
 264     *,
 265     filewriter_fn=filewriter_fn,
 266     tempdir=None,
 267     extensions=None,
 268 ):
 269     origtext, htmltext, images = markdown_with_inline_image_support(
 270         origtext, extensions=extensions
 271     )
 272
 273     filewriter_fn(draftpath, origtext, encoding="utf-8")
 274     textpart = Part(
 275         "text", "plain", draftpath, "Plain-text version", orig=True
 276     )
 277
 278     htmlpath = draftpath.with_suffix(".html")
 279     filewriter_fn(
 280         htmlpath, htmltext, encoding="utf-8", errors="xmlcharrefreplace"
 281     )
 282     htmlpart = Part("text", "html", htmlpath, "HTML version")
 283
 284     altpart = Multipart(
 285         "alternative", [textpart, htmlpart], "Group of alternative content"
 286     )
 287
 288     imgparts = collect_inline_images(
 289         images, tempdir=tempdir, filewriter_fn=filewriter_fn
 290     )
 291     if imgparts:
 292         return Multipart(
 293             "relative", [altpart] + imgparts, "Group of related content"
 294         )
 295     else:
 296         return altpart
 297
 298
 299 class MIMETreeDFWalker:
 300     def __init__(self, *, visitor_fn=None, debug=False):
 301         self._visitor_fn = visitor_fn
 302         self._debug = debug
 303
 304     def walk(self, root, *, visitor_fn=None):
 305         """
 306         Recursive function to implement a depth-dirst walk of the MIME-tree
 307         rooted at `root`.
 308         """
 309
 310         if isinstance(root, list):
 311             root = Multipart("mixed", children=root)
 312
 313         self._walk(
 314             root,
 315             stack=[],
 316             visitor_fn=visitor_fn or self._visitor_fn,
 317         )
 318
 319     def _walk(self, node, *, stack, visitor_fn):
 320         # Let's start by enumerating the parts at the current level. At the
 321         # root level, stack will be the empty list, and we expect a multipart/*
 322         # container at this level. Later, e.g. within a mutlipart/alternative
 323         # container, the subtree will just be the alternative parts, while the
 324         # top of the stack will be the multipart/alternative container, which
 325         # we will process after the following loop.
 326
 327         lead = f"{'| '*len(stack)}|-"
 328         if isinstance(node, Multipart):
 329             self.debugprint(
 330                 f"{lead}{node} parents={[s.subtype for s in stack]}"
 331             )
 332
 333             # Depth-first, so push the current container onto the stack,
 334             # then descend …
 335             stack.append(node)
 336             self.debugprint("| " * (len(stack) + 1))
 337             for child in node.children:
 338                 self._walk(
 339                     child,
 340                     stack=stack,
 341                     visitor_fn=visitor_fn,
 342                 )
 343             self.debugprint("| " * len(stack))
 344             assert stack.pop() == node
 345
 346         else:
 347             self.debugprint(f"{lead}{node}")
 348
 349         if visitor_fn:
 350             visitor_fn(node, stack, debugprint=self.debugprint)
 351
 352     def debugprint(self, s, **kwargs):
 353         if self._debug:
 354             print(s, file=sys.stderr, **kwargs)
 355
 356
 357 # [ RUN MODES ] ###############################################################
 358
 359
 360 class MuttCommands:
 361     """
 362     Stupid class to interface writing out Mutt commands. This is quite a hack
 363     to deal with the fact that Mutt runs "push" commands in reverse order, so
 364     all of a sudden, things become very complicated when mixing with "real"
 365     commands.
 366
 367     Hence we keep two sets of commands, and one set of pushes. Commands are
 368     added to the first until a push is added, after which commands are added to
 369     the second set of commands.
 370
 371     On flush(), the first set is printed, followed by the pushes in reverse,
 372     and then the second set is printed. All 3 sets are then cleared.
 373     """
 374
 375     def __init__(self, out_f=sys.stdout, *, debug=False):
 376         self._cmd1, self._push, self._cmd2 = [], [], []
 377         self._out_f = out_f
 378         self._debug = debug
 379
 380     def cmd(self, s):
 381         self.debugprint(s)
 382         if self._push:
 383             self._cmd2.append(s)
 384         else:
 385             self._cmd1.append(s)
 386
 387     def push(self, s):
 388         s = s.replace('"', '"')
 389         s = f'push "{s}"'
 390         self.debugprint(s)
 391         self._push.insert(0, s)
 392
 393     def flush(self):
 394         print(
 395             "\n".join(self._cmd1 + self._push + self._cmd2), file=self._out_f
 396         )
 397         self._cmd1, self._push, self._cmd2 = [], [], []
 398
 399     def debugprint(self, s, **kwargs):
 400         if self._debug:
 401             print(s, file=sys.stderr, **kwargs)
 402
 403
 404 def do_setup(
 405     extensions=None,
 406     *,
 407     out_f=sys.stdout,
 408     only_build=False,
 409     temppath=None,
 410     tempdir=None,
 411     debug_commands=False,
 412 ):
 413     extensions = extensions or []
 414     temppath = temppath or pathlib.Path(
 415         tempfile.mkstemp(prefix="muttmdwn-", dir=tempdir)[1]
 416     )
 417     cmds = MuttCommands(out_f, debug=debug_commands)
 418
 419     editor = f"{sys.argv[0]} massage --write-commands-to {temppath}"
 420     if extensions:
 421         editor = f'{editor} --extensions {",".join(extensions)}'
 422     if only_build:
 423         editor = f'{editor} --only-build'
 424     if tempdir:
 425         editor = f"{editor} --tempdir {tempdir}"
 426     if debug_commands:
 427         editor = f"{editor} --debug-commands"
 428
 429     cmds.cmd('set my_editor="$editor"')
 430     cmds.cmd('set my_edit_headers="$edit_headers"')
 431     cmds.cmd(f'set editor="{editor}"')
 432     cmds.cmd("unset edit_headers")
 433     cmds.cmd(f"set my_mdwn_postprocess_cmd_file={temppath}")
 434     cmds.push("<first-entry><edit-file>")
 435     cmds.flush()
 436
 437
 438 def do_massage(
 439     draft_f,
 440     draftpath,
 441     cmd_f,
 442     *,
 443     extensions=None,
 444     converter=convert_markdown_to_html,
 445     only_build=False,
 446     tempdir=None,
 447     debug_commands=False,
 448     debug_walk=False,
 449 ):
 450     # Here's the big picture: we're being invoked as the editor on the email
 451     # draft, and whatever commands we write to the file given as cmdpath will
 452     # be run by the second source command in the macro definition.
 453
 454     # Let's start by cleaning up what the setup did (see above), i.e. we
 455     # restore the $editor and $edit_headers variables, and also unset the
 456     # variable used to identify the command file we're currently writing
 457     # to.
 458     cmds = MuttCommands(cmd_f, debug=debug_commands)
 459     cmds.cmd('set editor="$my_editor"')
 460     cmds.cmd('set edit_headers="$my_edit_headers"')
 461     cmds.cmd("unset my_editor")
 462     cmds.cmd("unset my_edit_headers")
 463
 464     # let's flush those commands, as there'll be a lot of pushes from now
 465     # on, which need to be run in reverse order
 466     cmds.flush()
 467
 468     extensions = extensions.split(",") if extensions else []
 469     tree = converter(draft_f.read(), draftpath, tempdir=tempdir, extensions=extensions)
 470
 471     mimetree = MIMETreeDFWalker(debug=debug_walk)
 472
 473     def visitor_fn(item, stack, *, debugprint=None):
 474         """
 475         Visitor function called for every node (part) of the MIME tree,
 476         depth-first, and responsible for telling NeoMutt how to assemble
 477         the tree.
 478         """
 479         KILL_LINE=r'\Ca\Ck'
 480
 481         if isinstance(item, Part):
 482             # We've hit a leaf-node, i.e. an alternative or a related part
 483             # with actual content.
 484
 485             # Let's add the part
 486             if item.orig:
 487                 # The original source already exists in the NeoMutt tree, but
 488                 # the underlying file may have been modified, so we need to
 489                 # update the encoding, but that's it:
 490                 cmds.push("<update-encoding>")
 491             else:
 492                 # … whereas all other parts need to be added, and they're all
 493                 # considered to be temporary and inline:
 494                 cmds.push(f"<attach-file>{item.path}<enter>")
 495                 cmds.push("<toggle-unlink><toggle-disposition>")
 496
 497             # If the item (including the original) comes with additional
 498             # information, then we might just as well update the NeoMutt
 499             # tree now:
 500             if item.cid:
 501                 cmds.push(f"<edit-content-id>{KILL_LINE}{item.cid}<enter>")
 502
 503         elif isinstance(item, Multipart):
 504             # This node has children, but we already visited them (see
 505             # above), and so they have been tagged in NeoMutt's compose
 506             # window. Now it's just a matter of telling NeoMutt to do the
 507             # appropriate grouping:
 508             if item.subtype == "alternative":
 509                 cmds.push("<group-alternatives>")
 510             elif item.subtype in ("relative", "related"):
 511                 cmds.push("<group-related>")
 512             elif item.subtype == "multilingual":
 513                 cmds.push("<group-multilingual>")
 514
 515         else:
 516             # We should never get here
 517             assert not "is valid part"
 518
 519         # If the item has a description, we might just as well add it
 520         if item.desc:
 521             cmds.push(f"<edit-description>{KILL_LINE}{item.desc}<enter>")
 522
 523         # Finally, if we're at non-root level, tag the new container,
 524         # as it might itself be part of a container, to be processed
 525         # one level up:
 526         if stack:
 527             cmds.push("<tag-entry>")
 528
 529     # -----------------
 530     # End of visitor_fn
 531
 532     # Let's walk the tree and visit every node with our fancy visitor
 533     # function
 534     mimetree.walk(tree, visitor_fn=visitor_fn)
 535
 536     if not only_build:
 537         cmds.push("<send-message>")
 538
 539     # Finally, cleanup. Since we're responsible for removing the temporary
 540     # file, how's this for a little hack?
 541     try:
 542         filename = cmd_f.name
 543     except AttributeError:
 544         filename = "pytest_internal_file"
 545     cmds.cmd(f"source 'rm -f {filename}|'")
 546     cmds.cmd("unset my_mdwn_postprocess_cmd_file")
 547     cmds.flush()
 548
 549
 550 # [ CLI ENTRY ] ###############################################################
 551
 552 if __name__ == "__main__":
 553     args = parse_cli_args()
 554
 555     if args.mode == "setup":
 556         do_setup(
 557             args.extensions,
 558             only_build=args.only_build,
 559             tempdir=args.tempdir,
 560             debug_commands=args.debug_commands,
 561         )
 562
 563     elif args.mode == "massage":
 564         with open(args.MAILDRAFT, "r") as draft_f, open(
 565             args.cmdpath, "w"
 566         ) as cmd_f:
 567             do_massage(
 568                 draft_f,
 569                 pathlib.Path(args.MAILDRAFT),
 570                 cmd_f,
 571                 extensions=args.extensions,
 572                 only_build=args.only_build,
 573                 tempdir=args.tempdir,
 574                 debug_commands=args.debug_commands,
 575                 debug_walk=args.debug_walk,
 576             )
 577
 578
 579 # [ TESTS ] ###################################################################
 580
 581 try:
 582     import pytest
 583     from io import StringIO
 584
 585     class Tests:
 586         @pytest.fixture
 587         def const1(self):
 588             return "CONSTANT STRING 1"
 589
 590         @pytest.fixture
 591         def const2(self):
 592             return "CONSTANT STRING 2"
 593
 594         # NOTE: tests using the capsys fixture must specify sys.stdout to the
 595         # functions they call, else old stdout is used and not captured
 596
 597         def test_MuttCommands_cmd(self, const1, const2, capsys):
 598             "Assert order of commands"
 599             cmds = MuttCommands(out_f=sys.stdout)
 600             cmds.cmd(const1)
 601             cmds.cmd(const2)
 602             cmds.flush()
 603             captured = capsys.readouterr()
 604             assert captured.out == "\n".join((const1, const2, ""))
 605
 606         def test_MuttCommands_push(self, const1, const2, capsys):
 607             "Assert reverse order of pushes"
 608             cmds = MuttCommands(out_f=sys.stdout)
 609             cmds.push(const1)
 610             cmds.push(const2)
 611             cmds.flush()
 612             captured = capsys.readouterr()
 613             assert (
 614                 captured.out
 615                 == ('"\npush "'.join(("", const2, const1, "")))[2:-6]
 616             )
 617
 618         def test_MuttCommands_cmd_push_mixed(self, const1, const2, capsys):
 619             "Assert reverse order of pushes"
 620             cmds = MuttCommands(out_f=sys.stdout)
 621             lines = ["000", "001", "010", "011", "100", "101", "110", "111"]
 622             for i in range(2):
 623                 cmds.cmd(lines[4 * i + 0])
 624                 cmds.cmd(lines[4 * i + 1])
 625                 cmds.push(lines[4 * i + 2])
 626                 cmds.push(lines[4 * i + 3])
 627             cmds.flush()
 628
 629             captured = capsys.readouterr()
 630             lines_out = captured.out.splitlines()
 631             assert lines[0] in lines_out[0]
 632             assert lines[1] in lines_out[1]
 633             assert lines[7] in lines_out[2]
 634             assert lines[6] in lines_out[3]
 635             assert lines[3] in lines_out[4]
 636             assert lines[2] in lines_out[5]
 637             assert lines[4] in lines_out[6]
 638             assert lines[5] in lines_out[7]
 639
 640         @pytest.fixture
 641         def basic_mime_tree(self):
 642             return Multipart(
 643                 "relative",
 644                 children=[
 645                     Multipart(
 646                         "alternative",
 647                         children=[
 648                             Part(
 649                                 "text",
 650                                 "plain",
 651                                 "part.txt",
 652                                 desc="Plain",
 653                                 orig=True,
 654                             ),
 655                             Part("text", "html", "part.html", desc="HTML"),
 656                         ],
 657                         desc="Alternative",
 658                     ),
 659                     Part(
 660                         "text", "png", "logo.png", cid="logo.png", desc="Logo"
 661                     ),
 662                 ],
 663                 desc="Related",
 664             )
 665
 666         def test_MIMETreeDFWalker_depth_first_walk(self, basic_mime_tree):
 667             mimetree = MIMETreeDFWalker()
 668
 669             items = []
 670
 671             def visitor_fn(item, stack, debugprint):
 672                 items.append((item, len(stack)))
 673
 674             mimetree.walk(basic_mime_tree, visitor_fn=visitor_fn)
 675             assert len(items) == 5
 676             assert items[0][0].subtype == "plain"
 677             assert items[0][1] == 2
 678             assert items[1][0].subtype == "html"
 679             assert items[1][1] == 2
 680             assert items[2][0].subtype == "alternative"
 681             assert items[2][1] == 1
 682             assert items[3][0].subtype == "png"
 683             assert items[3][1] == 1
 684             assert items[4][0].subtype == "relative"
 685             assert items[4][1] == 0
 686
 687         def test_MIMETreeDFWalker_list_to_mixed(self, basic_mime_tree):
 688             mimetree = MIMETreeDFWalker()
 689             items = []
 690
 691             def visitor_fn(item, stack, debugprint):
 692                 items.append(item)
 693
 694             mimetree.walk([basic_mime_tree], visitor_fn=visitor_fn)
 695             assert items[-1].subtype == "mixed"
 696
 697         def test_MIMETreeDFWalker_visitor_in_constructor(
 698             self, basic_mime_tree
 699         ):
 700             items = []
 701
 702             def visitor_fn(item, stack, debugprint):
 703                 items.append(item)
 704
 705             mimetree = MIMETreeDFWalker(visitor_fn=visitor_fn)
 706             mimetree.walk(basic_mime_tree)
 707             assert len(items) == 5
 708
 709         def test_do_setup_no_extensions(self, const1, capsys):
 710             "Assert basics about the setup command output"
 711             do_setup(temppath=const1, out_f=sys.stdout)
 712             captout = capsys.readouterr()
 713             lines = captout.out.splitlines()
 714             assert lines[2].endswith(f'{const1}"')
 715             assert lines[4].endswith(const1)
 716             assert "first-entry" in lines[-1]
 717             assert "edit-file" in lines[-1]
 718
 719         def test_do_setup_extensions(self, const1, const2, capsys):
 720             "Assert that extensions are passed to editor"
 721             do_setup(
 722                 temppath=const1, extensions=[const2, const1], out_f=sys.stdout
 723             )
 724             captout = capsys.readouterr()
 725             lines = captout.out.splitlines()
 726             # assert comma-separated list of extensions passed
 727             assert lines[2].endswith(f'{const2},{const1}"')
 728             assert lines[4].endswith(const1)
 729
 730         @pytest.fixture
 731         def string_io(self, const1, text=None):
 732             return StringIO(text or const1)
 733
 734         def test_do_massage_basic(self, const1, string_io, capsys):
 735             def converter(drafttext, draftpath, extensions, tempdir):
 736                 return Part("text", "plain", draftpath, orig=True)
 737
 738             do_massage(
 739                 draft_f=string_io,
 740                 draftpath=const1,
 741                 cmd_f=sys.stdout,
 742                 converter=converter,
 743             )
 744
 745             captured = capsys.readouterr()
 746             lines = captured.out.splitlines()
 747             assert '="$my_editor"' in lines.pop(0)
 748             assert '="$my_edit_headers"' in lines.pop(0)
 749             assert "unset my_editor" == lines.pop(0)
 750             assert "unset my_edit_headers" == lines.pop(0)
 751             assert "send-message" in lines.pop(0)
 752             assert "update-encoding" in lines.pop(0)
 753             assert "source 'rm -f " in lines.pop(0)
 754             assert "unset my_mdwn_postprocess_cmd_file" == lines.pop(0)
 755
 756         def test_do_massage_fulltree(
 757             self, string_io, const1, basic_mime_tree, capsys
 758         ):
 759             def converter(drafttext, draftpath, extensions, tempdir):
 760                 return basic_mime_tree
 761
 762             do_massage(
 763                 draft_f=string_io,
 764                 draftpath=const1,
 765                 cmd_f=sys.stdout,
 766                 converter=converter,
 767             )
 768
 769             captured = capsys.readouterr()
 770             lines = captured.out.splitlines()[4:]
 771             assert "send-message" in lines.pop(0)
 772             assert "Related" in lines.pop(0)
 773             assert "group-related" in lines.pop(0)
 774             assert "tag-entry" in lines.pop(0)
 775             assert "Logo" in lines.pop(0)
 776             assert "content-id" in lines.pop(0)
 777             assert "toggle-unlink" in lines.pop(0)
 778             assert "logo.png" in lines.pop(0)
 779             assert "tag-entry" in lines.pop(0)
 780             assert "Alternative" in lines.pop(0)
 781             assert "group-alternatives" in lines.pop(0)
 782             assert "tag-entry" in lines.pop(0)
 783             assert "HTML" in lines.pop(0)
 784             assert "toggle-unlink" in lines.pop(0)
 785             assert "part.html" in lines.pop(0)
 786             assert "tag-entry" in lines.pop(0)
 787             assert "Plain" in lines.pop(0)
 788             assert "update-encoding" in lines.pop(0)
 789             assert len(lines) == 2
 790
 791         @pytest.fixture
 792         def fake_filewriter(self):
 793             class FileWriter:
 794                 def __init__(self):
 795                     self._writes = []
 796
 797                 def __call__(self, path, content, mode="w", **kwargs):
 798                     self._writes.append((path, content))
 799
 800                 def pop(self, index=-1):
 801                     return self._writes.pop(index)
 802
 803             return FileWriter()
 804
 805         @pytest.fixture
 806         def markdown_non_converter(self, const1, const2):
 807             return lambda s, text: f"{const1}{text}{const2}"
 808
 809         def test_converter_tree_basic(
 810             self, const1, const2, fake_filewriter, markdown_non_converter
 811         ):
 812             path = pathlib.Path(const2)
 813             tree = convert_markdown_to_html(
 814                 const1, path, filewriter_fn=fake_filewriter
 815             )
 816
 817             assert tree.subtype == "alternative"
 818             assert len(tree.children) == 2
 819             assert tree.children[0].subtype == "plain"
 820             assert tree.children[0].path == path
 821             assert tree.children[0].orig
 822             assert tree.children[1].subtype == "html"
 823             assert tree.children[1].path == path.with_suffix(".html")
 824
 825         def test_converter_writes(
 826             self,
 827             const1,
 828             const2,
 829             fake_filewriter,
 830             monkeypatch,
 831             markdown_non_converter,
 832         ):
 833             path = pathlib.Path(const2)
 834
 835             with monkeypatch.context() as m:
 836                 m.setattr(markdown.Markdown, "convert", markdown_non_converter)
 837                 convert_markdown_to_html(
 838                     const1, path, filewriter_fn=fake_filewriter
 839                 )
 840
 841             assert (path, const1) == fake_filewriter.pop(0)
 842             assert (
 843                 path.with_suffix(".html"),
 844                 markdown_non_converter(None, const1),
 845             ) == fake_filewriter.pop(0)
 846
 847         def test_markdown_inline_image_processor(self):
 848             imgpath1 = "file:/path/to/image.png"
 849             imgpath2 = "file:///path/to/image.png?url=params"
 850             imgpath3 = "/path/to/image.png"
 851             text = f"""![inline local image]({imgpath1})
 852                        ![image inlined
 853                          with newline]({imgpath2})
 854                        ![image local path]({imgpath3})"""
 855             text, html, images = markdown_with_inline_image_support(text)
 856
 857             # local paths have been normalised to URLs:
 858             imgpath3 = f"file://{imgpath3}"
 859
 860             assert 'src="cid:' in html
 861             assert "](cid:" in text
 862             assert len(images) == 3
 863             assert imgpath1 in images
 864             assert imgpath2 in images
 865             assert imgpath3 in images
 866             assert images[imgpath1].cid != images[imgpath2].cid
 867             assert images[imgpath1].cid != images[imgpath3].cid
 868             assert images[imgpath2].cid != images[imgpath3].cid
 869
 870         def test_markdown_inline_image_processor_title_to_desc(self, const1):
 871             imgpath = "file:///path/to/image.png"
 872             text = f'![inline local image]({imgpath} "{const1}")'
 873             text, html, images = markdown_with_inline_image_support(text)
 874             assert images[imgpath].desc == const1
 875
 876         def test_markdown_inline_image_processor_alt_to_desc(self, const1):
 877             imgpath = "file:///path/to/image.png"
 878             text = f"![{const1}]({imgpath})"
 879             text, html, images = markdown_with_inline_image_support(text)
 880             assert images[imgpath].desc == const1
 881
 882         def test_markdown_inline_image_processor_title_over_alt_desc(
 883             self, const1, const2
 884         ):
 885             imgpath = "file:///path/to/image.png"
 886             text = f'![{const1}]({imgpath} "{const2}")'
 887             text, html, images = markdown_with_inline_image_support(text)
 888             assert images[imgpath].desc == const2
 889
 890         def test_markdown_inline_image_not_external(self):
 891             imgpath = "https://path/to/image.png"
 892             text = f"![inline image]({imgpath})"
 893             text, html, images = markdown_with_inline_image_support(text)
 894
 895             assert 'src="cid:' not in html
 896             assert "](cid:" not in text
 897             assert len(images) == 0
 898
 899         def test_markdown_inline_image_local_file(self):
 900             imgpath = "/path/to/image.png"
 901             text = f"![inline image]({imgpath})"
 902             text, html, images = markdown_with_inline_image_support(text)
 903
 904             for k, v in images.items():
 905                 assert k == f"file://{imgpath}"
 906                 break
 907
 908         @pytest.fixture
 909         def test_png(self):
 910             return (
 911                 "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAE"
 912                 "AAAABCAAAAAA6fptVAAAACklEQVQI12P4DwABAQEAG7buVgAA"
 913             )
 914
 915         def test_markdown_inline_image_processor_base64(self, test_png):
 916             text = f"![1px white inlined]({test_png})"
 917             text, html, images = markdown_with_inline_image_support(text)
 918
 919             assert 'src="cid:' in html
 920             assert "](cid:" in text
 921             assert len(images) == 1
 922             assert test_png in images
 923
 924         def test_converter_tree_inline_image_base64(
 925             self, test_png, const1, fake_filewriter
 926         ):
 927             text = f"![inline base64 image]({test_png})"
 928             path = pathlib.Path(const1)
 929             tree = convert_markdown_to_html(
 930                 text, path, filewriter_fn=fake_filewriter
 931             )
 932
 933             assert tree.subtype == "relative"
 934             assert tree.children[1].subtype == "png"
 935             written = fake_filewriter.pop()
 936             assert tree.children[1].path == written[0]
 937             assert written[1] == request.urlopen(test_png).read()
 938
 939         def test_inline_image_collection(
 940             self, test_png, const1, const2, fake_filewriter
 941         ):
 942             test_images = {test_png: InlineImageInfo(cid=const1, desc=const2)}
 943             relparts = collect_inline_images(
 944                 test_images, filewriter_fn=fake_filewriter
 945             )
 946
 947             written = fake_filewriter.pop()
 948             assert b"PNG" in written[1]
 949
 950             assert relparts[0].subtype == "png"
 951             assert relparts[0].path == written[0]
 952             assert relparts[0].cid == const1
 953             assert relparts[0].desc.endswith(const2)
 954
 955 except ImportError:
 956     pass