v-scroll class for long code

[etc/neomutt.git] / .config / neomutt / buildmimetree.py

diff --git a/.config/neomutt/buildmimetree.py b/.config/neomutt/buildmimetree.py
index fbc8040061877b74cc0e9fbc4a8e605d21a8a33c..1ff0cb0e9284e8fc7378ac6258aae2e5973a1bc2 100755 (executable)
--- a/.config/neomutt/buildmimetree.py
+++ b/.config/neomutt/buildmimetree.py
@@ -28,6 +28,9 @@
 #   - Pynliner, provides --css-file and thus inline styling of HTML output
 #   - Pygments, then syntax highlighting for fenced code is enabled
 #
 #   - Pynliner, provides --css-file and thus inline styling of HTML output
 #   - Pygments, then syntax highlighting for fenced code is enabled
 #

+# Running tests:
+#   pytest -x buildmimetree.py
+#

 # Latest version:
 #   https://git.madduck.net/etc/neomutt.git/blob_plain/HEAD:/.config/neomutt/buildmimetree.py
 #
 # Latest version:
 #   https://git.madduck.net/etc/neomutt.git/blob_plain/HEAD:/.config/neomutt/buildmimetree.py
 #


@@ -36,7 +39,6 @@
 #
 
 import sys
 #
 
 import sys

-import os

 import os.path
 import pathlib
 import markdown
 import os.path
 import pathlib
 import markdown


@@ -45,8 +47,13 @@ import argparse
 import re
 import mimetypes
 import bs4
 import re
 import mimetypes
 import bs4

+import xml.etree.ElementTree as etree
+import io
+import enum
+from contextlib import contextmanager

 from collections import namedtuple, OrderedDict
 from markdown.extensions import Extension
 from collections import namedtuple, OrderedDict
 from markdown.extensions import Extension

+from markdown.blockprocessors import BlockProcessor

 from markdown.inlinepatterns import ImageInlineProcessor, IMAGE_LINK_RE
 from email.utils import make_msgid
 from urllib import request
 from markdown.inlinepatterns import ImageInlineProcessor, IMAGE_LINK_RE
 from email.utils import make_msgid
 from urllib import request


@@ -133,6 +140,13 @@ def parse_cli_args(*args, **kwargs):
         help="Turn on debugging to stderr of the MIME tree walk",
     )
 
         help="Turn on debugging to stderr of the MIME tree walk",
     )
 

+    parser.add_argument(
+        "--dump-html",
+        metavar="FILE",
+        type=pathlib.Path,
+        help="Write the generated HTML to the file",
+    )
+

     subp = parser.add_subparsers(help="Sub-command parsers", dest="mode")
     massage_p = subp.add_parser(
         "massage", help="Massaging phase (internal use)"
     subp = parser.add_subparsers(help="Sub-command parsers", dest="mode")
     massage_p = subp.add_parser(
         "massage", help="Massaging phase (internal use)"


@@ -158,6 +172,172 @@ def parse_cli_args(*args, **kwargs):
     return parser.parse_args(*args, **kwargs)
 
 
     return parser.parse_args(*args, **kwargs)
 
 

+# [ FILE I/O HANDLING ] #######################################################
+
+
+class File:
+
+    class Op(enum.Enum):
+        R = enum.auto()
+        W = enum.auto()
+
+    def __init__(self, path=None, mode="r", content=None, **kwargs):
+        if path:
+            if content:
+                raise RuntimeError("Cannot specify path and content for File")
+
+            self._path = (
+                path if isinstance(path, pathlib.Path) else pathlib.Path(path)
+            )
+        else:
+            self._path = None
+
+        if content and not re.search(r"[r+]", mode):
+            raise RuntimeError("Cannot specify content without read mode")
+
+        self._cache = {
+            File.Op.R: [content] if content else [],
+            File.Op.W: []
+        }
+        self._lastop = None
+        self._mode = mode
+        self._kwargs = kwargs
+        self._file = None
+
+    def open(self):
+        if self._path:
+            self._file = open(self._path, self._mode, **self._kwargs)
+        elif "b" in self._mode:
+            self._file = io.BytesIO()
+        else:
+            self._file = io.StringIO()
+
+    def __enter__(self):
+        self.open()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        self._file.close()
+        self._file = None
+        self._cache[File.Op.R] = self._cache[File.Op.W]
+        self._lastop = None
+
+    def _get_cache(self, op):
+        return (b"" if "b" in self._mode else "").join(self._cache[op])
+
+    def _add_to_cache(self, op, s):
+        self._cache[op].append(s)
+
+    def read(self, *, cache=True):
+        if cache and self._cache[File.Op.R]:
+            return self._get_cache(File.Op.R)
+
+        if self._lastop == File.Op.W:
+            try:
+                self._file.seek(0)
+            except io.UnsupportedOperation:
+                pass
+
+        self._lastop = File.Op.R
+
+        if cache:
+            self._add_to_cache(File.Op.R, self._file.read())
+            return self._get_cache(File.Op.R)
+        else:
+            return self._file.read()
+
+    def write(self, s, *, cache=True):
+
+        if self._lastop == File.Op.R:
+            try:
+                self._file.seek(0)
+            except io.UnsupportedOperation:
+                pass
+
+        if cache:
+            self._add_to_cache(File.Op.W, s)
+
+        self._cache[File.Op.R] = self._cache[File.Op.W]
+
+        written = self._file.write(s)
+        self._file.flush()
+        self._lastop = File.Op.W
+        return written
+
+    path = property(lambda s: s._path)
+
+    def __repr__(self):
+        return (
+            f'<File path={self._path or "(buffered)"} open={bool(self._file)} '
+            f"rcache={sum(len(c) for c in self._rcache) if self._rcache is not None else False} "
+            f"wcache={sum(len(c) for c in self._wcache) if self._wcache is not None else False}>"
+        )
+
+
+class FileFactory:
+    def __init__(self):
+        self._files = []
+
+    def __call__(self, path=None, mode="r", content=None, **kwargs):
+        f = File(path, mode, content, **kwargs)
+        self._files.append(f)
+        return f
+
+    def __len__(self):
+        return self._files.__len__()
+
+    def pop(self, idx=-1):
+        return self._files.pop(idx)
+
+    def __getitem__(self, idx):
+        return self._files.__getitem__(idx)
+
+    def __contains__(self, f):
+        return self._files.__contains__(f)
+
+
+class FakeFileFactory(FileFactory):
+    def __init__(self):
+        super().__init__()
+        self._paths2files = OrderedDict()
+
+    def __call__(self, path=None, mode="r", content=None, **kwargs):
+        if path in self._paths2files:
+            return self._paths2files[path]
+
+        f = super().__call__(None, mode, content, **kwargs)
+        self._paths2files[path] = f
+
+        mypath = path
+
+        class FakeFile(File):
+            path = mypath
+
+        # this is quality Python! We do this so that the fake file, which has
+        # no path, fake-pretends to have a path for testing purposes.
+
+        f.__class__ = FakeFile
+        return f
+
+    def __getitem__(self, path):
+        return self._paths2files.__getitem__(path)
+
+    def get(self, path, default):
+        return self._paths2files.get(path, default)
+
+    def pop(self, last=True):
+        return self._paths2files.popitem(last)
+
+    def __repr__(self):
+        return (
+            f"<FakeFileFactory nfiles={len(self._files)} "
+            f"paths={len(self._paths2files)}>"
+        )
+
+

 # [ IMAGE HANDLING ] ##########################################################
 
 
 # [ IMAGE HANDLING ] ##########################################################
 
 


@@ -171,6 +351,7 @@ class ImageRegistry:
         self._images = OrderedDict()
 
     def register(self, path, description=None):
         self._images = OrderedDict()
 
     def register(self, path, description=None):

+        # path = str(pathlib.Path(path).expanduser())

         path = os.path.expanduser(path)
         if path.startswith("/"):
             path = f"file://{path}"
         path = os.path.expanduser(path)
         if path.startswith("/"):
             path = f"file://{path}"


@@ -295,6 +476,79 @@ def apply_styling(html, css):
     )
 
 
     )
 
 

+# [ QUOTE HANDLING ] ##########################################################
+
+
+class QuoteToAdmonitionExtension(Extension):
+    class EmailQuoteBlockProcessor(BlockProcessor):
+        RE = re.compile(r"(?:^|\n)>\s*(.*)")
+
+        def __init__(self, parser):
+            super().__init__(parser)
+            self._title = None
+            self._disable = False
+
+        def test(self, parent, blocks):
+            if self._disable:
+                return False
+
+            if markdown.util.nearing_recursion_limit():
+                return False
+
+            lines = blocks.splitlines()
+            if len(lines) < 2:
+                if not self._title:
+                    return False
+
+                elif not self.RE.search(lines[0]):
+                    return False
+
+                return len(lines) > 0
+
+            elif not self.RE.search(lines[0]) and self.RE.search(lines[1]):
+                return True
+
+            elif self._title and self.RE.search(lines[1]):
+                return True
+
+            return False
+
+        def run(self, parent, blocks):
+            quotelines = blocks.pop(0).splitlines()
+
+            cont = bool(self._title)
+            if not self.RE.search(quotelines[0]):
+                self._title = quotelines.pop(0)
+
+            admonition = etree.SubElement(parent, "div")
+            admonition.set(
+                "class", f"admonition quote{' continued' if cont else ''}"
+            )
+            self.parser.parseChunk(admonition, self._title)
+
+            admonition[0].set("class", "admonition-title")
+            with self.disable():
+                self.parser.parseChunk(
+                    admonition, "\n".join(quotelines)
+                )
+
+        @contextmanager
+        def disable(self):
+            self._disable = True
+            yield True
+            self._disable = False
+
+        @classmethod
+        def clean(klass, line):
+            m = klass.RE.match(line)
+            return m.group(1) if m else line
+
+    def extendMarkdown(self, md):
+        md.registerExtension(self)
+        email_quote_proc = self.EmailQuoteBlockProcessor(md.parser)
+        md.parser.blockprocessors.register(email_quote_proc, "emailquote", 25)
+
+

 # [ PARTS GENERATION ] ########################################################
 
 
 # [ PARTS GENERATION ] ########################################################
 
 


@@ -324,18 +578,8 @@ class Multipart(
         return hash(str(self.subtype) + "".join(str(self.children)))
 
 
         return hash(str(self.subtype) + "".join(str(self.children)))
 
 

-def filereader_fn(path, mode="r", **kwargs):
-    with open(path, mode, **kwargs) as in_f:
-        return in_f.read()
-
-
-def filewriter_fn(path, content, mode="w", **kwargs):
-    with open(path, mode, **kwargs) as out_f:
-        out_f.write(content)
-
-

 def collect_inline_images(
 def collect_inline_images(

-    image_registry, *, tempdir=None, filewriter_fn=filewriter_fn
+    image_registry, *, tempdir=None, filefactory=FileFactory()

 ):
     relparts = []
     for path, info in image_registry.items():
 ):
     relparts = []
     for path, info in image_registry.items():


@@ -349,7 +593,10 @@ def collect_inline_images(
         tempfilename = tempfile.mkstemp(prefix="img", suffix=ext, dir=tempdir)
         path = pathlib.Path(tempfilename[1])
 
         tempfilename = tempfile.mkstemp(prefix="img", suffix=ext, dir=tempdir)
         path = pathlib.Path(tempfilename[1])
 

-        filewriter_fn(path, data.read(), "w+b")
+        with filefactory(path, "w+b") as out_f:
+            out_f.write(data.read())
+
+        # filewriter_fn(path, data.read(), "w+b")

 
         desc = (
             f'Inline image: "{info.desc}"'
 
         desc = (
             f'Inline image: "{info.desc}"'


@@ -394,7 +641,7 @@ def make_text_mail(text, sig=None):
     return EMAIL_SIG_SEP.join((text, sig)) if sig else text
 
 
     return EMAIL_SIG_SEP.join((text, sig)) if sig else text
 
 

-def extract_signature(text, *, filereader_fn=filereader_fn):
+def extract_signature(text, *, filefactory=FileFactory()):

     parts = text.split(EMAIL_SIG_SEP, 1)
     if len(parts) == 1:
         return text, None, None
     parts = text.split(EMAIL_SIG_SEP, 1)
     if len(parts) == 1:
         return text, None, None


@@ -404,7 +651,9 @@ def extract_signature(text, *, filereader_fn=filereader_fn):
         path = pathlib.Path(re.split(r" +", lines.pop(0), maxsplit=1)[1])
         textsig = "\n".join(lines)
 
         path = pathlib.Path(re.split(r" +", lines.pop(0), maxsplit=1)[1])
         textsig = "\n".join(lines)
 

-        sig_input = filereader_fn(path.expanduser())
+        with filefactory(path.expanduser()) as sig_f:
+            sig_input = sig_f.read()
+

         soup = bs4.BeautifulSoup(sig_input, "html.parser")
 
         style = str(soup.style.extract()) if soup.style else ""
         soup = bs4.BeautifulSoup(sig_input, "html.parser")
 
         style = str(soup.style.extract()) if soup.style else ""


@@ -434,24 +683,28 @@ def extract_signature(text, *, filereader_fn=filereader_fn):
 
 
 def convert_markdown_to_html(
 
 
 def convert_markdown_to_html(

-    origtext,
-    draftpath,
+    draft_f,

     *,
     related_to_html_only=False,
     *,
     related_to_html_only=False,

-    css=None,
-    filewriter_fn=filewriter_fn,
-    filereader_fn=filereader_fn,
+    css_f=None,
+    htmldump_f=None,
+    filefactory=FileFactory(),

     tempdir=None,
     extensions=None,
     extension_configs=None,
 ):
     # TODO extension_configs need to be handled differently
     extension_configs = extension_configs or {}
     tempdir=None,
     extensions=None,
     extension_configs=None,
 ):
     # TODO extension_configs need to be handled differently
     extension_configs = extension_configs or {}

-    extension_configs.setdefault("pymdownx.highlight", {})
-    extension_configs["pymdownx.highlight"]["css_class"] = _CODEHILITE_CLASS
+    extension_configs.setdefault("pymdownx.highlight", {})[
+        "css_class"
+    ] = _CODEHILITE_CLASS
+
+    extensions = extensions or []
+    extensions.append(QuoteToAdmonitionExtension())

 
 

+    draft = draft_f.read()

     origtext, textsig, htmlsig = extract_signature(
     origtext, textsig, htmlsig = extract_signature(

-        origtext, filereader_fn=filereader_fn
+        draft, filefactory=filefactory

     )
 
     (
     )
 
     (


@@ -492,23 +745,31 @@ def convert_markdown_to_html(
         )
 
     origtext = make_text_mail(origtext, textsig)
         )
 
     origtext = make_text_mail(origtext, textsig)

-
-    filewriter_fn(draftpath, origtext, encoding="utf-8")
+    draft_f.write(origtext)

     textpart = Part(
     textpart = Part(

-        "text", "plain", draftpath, "Plain-text version", orig=True
+        "text", "plain", draft_f.path, "Plain-text version", orig=True

     )
 
     htmltext = make_html_doc(htmltext, htmlsig)
     )
 
     htmltext = make_html_doc(htmltext, htmlsig)

-    htmltext = apply_styling(htmltext, css)
+    htmltext = apply_styling(htmltext, css_f.read() if css_f else None)

 
 

-    htmlpath = draftpath.with_suffix(".html")
-    filewriter_fn(
-        htmlpath, htmltext, encoding="utf-8", errors="xmlcharrefreplace"
-    )
+    if draft_f.path:
+        htmlpath = draft_f.path.with_suffix(".html")
+    else:
+        htmlpath = pathlib.Path(
+            tempfile.mkstemp(suffix=".html", dir=tempdir)[1]
+        )
+    with filefactory(
+        htmlpath, "w", encoding="utf-8", errors="xmlcharrefreplace"
+    ) as out_f:
+        out_f.write(htmltext)

     htmlpart = Part("text", "html", htmlpath, "HTML version")
 
     htmlpart = Part("text", "html", htmlpath, "HTML version")
 

+    if htmldump_f:
+        htmldump_f.write(htmltext)
+

     imgparts = collect_inline_images(
     imgparts = collect_inline_images(

-        image_registry, tempdir=tempdir, filewriter_fn=filewriter_fn
+        image_registry, tempdir=tempdir, filefactory=filefactory

     )
 
     if related_to_html_only:
     )
 
     if related_to_html_only:


@@ -684,11 +945,11 @@ def do_setup(
 
 def do_massage(
     draft_f,
 
 def do_massage(
     draft_f,

-    draftpath,

     cmd_f,
     *,
     extensions=None,
     css_f=None,
     cmd_f,
     *,
     extensions=None,
     css_f=None,

+    htmldump_f=None,

     converter=convert_markdown_to_html,
     related_to_html_only=True,
     only_build=False,
     converter=convert_markdown_to_html,
     related_to_html_only=True,
     only_build=False,


@@ -706,20 +967,12 @@ def do_massage(
     # variable used to identify the command file we're currently writing
     # to.
     cmds = MuttCommands(cmd_f, debug=debug_commands)
     # variable used to identify the command file we're currently writing
     # to.
     cmds = MuttCommands(cmd_f, debug=debug_commands)

-    cmds.cmd('set editor="$my_editor"')
-    cmds.cmd('set edit_headers="$my_edit_headers"')
-    cmds.cmd("unset my_editor")
-    cmds.cmd("unset my_edit_headers")
-
-    # let's flush those commands, as there'll be a lot of pushes from now
-    # on, which need to be run in reverse order
-    cmds.flush()

 
     extensions = extensions.split(",") if extensions else []
     tree = converter(
 
     extensions = extensions.split(",") if extensions else []
     tree = converter(

-        draft_f.read(),
-        draftpath,
-        css=css_f.read() if css_f else None,
+        draft_f,
+        css_f=css_f,
+        htmldump_f=htmldump_f,

         related_to_html_only=related_to_html_only,
         tempdir=tempdir,
         extensions=extensions,
         related_to_html_only=related_to_html_only,
         tempdir=tempdir,
         extensions=extensions,


@@ -859,6 +1112,10 @@ def do_massage(
     except AttributeError:
         filename = "pytest_internal_file"
     cmds.cmd(f"source 'rm -f {filename}|'")
     except AttributeError:
         filename = "pytest_internal_file"
     cmds.cmd(f"source 'rm -f {filename}|'")

+    cmds.cmd('set editor="$my_editor"')
+    cmds.cmd('set edit_headers="$my_edit_headers"')
+    cmds.cmd("unset my_editor")
+    cmds.cmd("unset my_edit_headers")

     cmds.cmd("unset my_mdwn_postprocess_cmd_file")
     cmds.flush()
 
     cmds.cmd("unset my_mdwn_postprocess_cmd_file")
     cmds.flush()
 


@@ -875,15 +1132,18 @@ if __name__ == "__main__":
         )
 
     elif args.mode == "massage":
         )
 
     elif args.mode == "massage":

-        with open(args.MAILDRAFT, "r") as draft_f, open(
-            args.cmdpath, "w"
-        ) as cmd_f, open(args.css_file, "r") as css_f:
+        with (
+            File(args.MAILDRAFT, "r+") as draft_f,
+            File(args.cmdpath, "w") as cmd_f,
+            File(args.css_file, "r") as css_f,
+            File(args.dump_html, "w") as htmldump_f,
+        ):

             do_massage(
                 draft_f,
             do_massage(
                 draft_f,

-                args.MAILDRAFT,

                 cmd_f,
                 extensions=args.extensions,
                 css_f=css_f,
                 cmd_f,
                 extensions=args.extensions,
                 css_f=css_f,

+                htmldump_f=htmldump_f,

                 related_to_html_only=args.related_to_html_only,
                 max_other_attachments=args.max_number_other_attachments,
                 only_build=args.only_build,
                 related_to_html_only=args.related_to_html_only,
                 max_other_attachments=args.max_number_other_attachments,
                 only_build=args.only_build,


@@ -897,16 +1157,23 @@ if __name__ == "__main__":
 
 try:
     import pytest
 
 try:
     import pytest

-    from io import StringIO

 
     class Tests:
         @pytest.fixture
         def const1(self):
 
     class Tests:
         @pytest.fixture
         def const1(self):

-            return "CONSTANT STRING 1"
+            return "Curvature Vest Usher Dividing+T#iceps Senior"

 
         @pytest.fixture
         def const2(self):
 
         @pytest.fixture
         def const2(self):

-            return "CONSTANT STRING 2"
+            return "Habitant Celestial 2litzy Resurf/ce Headpiece Harmonics"
+
+        @pytest.fixture
+        def fakepath(self):
+            return pathlib.Path("/does/not/exist")
+
+        @pytest.fixture
+        def fakepath2(self):
+            return pathlib.Path("/does/not/exist/either")

 
         # NOTE: tests using the capsys fixture must specify sys.stdout to the
         # functions they call, else old stdout is used and not captured
 
         # NOTE: tests using the capsys fixture must specify sys.stdout to the
         # functions they call, else old stdout is used and not captured


@@ -1021,6 +1288,53 @@ try:
                 desc="Alternative",
             )
 
                 desc="Alternative",
             )
 

+        @pytest.fixture
+        def mime_tree_nested(self):
+            return Multipart(
+                "relative",
+                children=[
+                    Multipart(
+                        "alternative",
+                        children=[
+                            Part(
+                                "text",
+                                "plain",
+                                "part.txt",
+                                desc="Plain",
+                                orig=True,
+                            ),
+                            Multipart(
+                                "alternative",
+                                children=[
+                                    Part(
+                                        "text",
+                                        "plain",
+                                        "part.txt",
+                                        desc="Nested plain",
+                                    ),
+                                    Part(
+                                        "text",
+                                        "html",
+                                        "part.html",
+                                        desc="Nested HTML",
+                                    ),
+                                ],
+                                desc="Nested alternative",
+                            ),
+                        ],
+                        desc="Alternative",
+                    ),
+                    Part(
+                        "text",
+                        "png",
+                        "logo.png",
+                        cid="logo.png",
+                        desc="Logo",
+                    ),
+                ],
+                desc="Related",
+            )
+

         @pytest.mark.treewalk
         def test_MIMETreeDFWalker_depth_first_walk(
             self, mime_tree_related_to_alternative
         @pytest.mark.treewalk
         def test_MIMETreeDFWalker_depth_first_walk(
             self, mime_tree_related_to_alternative


@@ -1084,61 +1398,44 @@ try:
             return StringIO(text or const1)
 
         @pytest.mark.massage
             return StringIO(text or const1)
 
         @pytest.mark.massage

-        def test_do_massage_basic(self, const1, string_io, capsys):
-            def converter(
-                drafttext,
-                draftpath,
-                css,
-                related_to_html_only,
-                extensions,
-                tempdir,
-            ):
-                return Part("text", "plain", draftpath, orig=True)
+        def test_do_massage_basic(self):
+            def converter(draft_f, **kwargs):
+                return Part("text", "plain", draft_f.path, orig=True)

 
 

-            do_massage(
-                draft_f=string_io,
-                draftpath=const1,
-                cmd_f=sys.stdout,
-                converter=converter,
-            )
+            with File() as draft_f, File() as cmd_f:
+                do_massage(
+                    draft_f=draft_f,
+                    cmd_f=cmd_f,
+                    converter=converter,
+                )
+                lines = cmd_f.read().splitlines()

 
 

-            captured = capsys.readouterr()
-            lines = captured.out.splitlines()
-            assert '="$my_editor"' in lines.pop(0)
-            assert '="$my_edit_headers"' in lines.pop(0)
-            assert "unset my_editor" == lines.pop(0)
-            assert "unset my_edit_headers" == lines.pop(0)

             assert "send-message" in lines.pop(0)
             assert "update-encoding" in lines.pop(0)
             assert "first-entry" in lines.pop(0)
             assert "source 'rm -f " in lines.pop(0)
             assert "send-message" in lines.pop(0)
             assert "update-encoding" in lines.pop(0)
             assert "first-entry" in lines.pop(0)
             assert "source 'rm -f " in lines.pop(0)

+            assert '="$my_editor"' in lines.pop(0)
+            assert '="$my_edit_headers"' in lines.pop(0)
+            assert "unset my_editor" == lines.pop(0)
+            assert "unset my_edit_headers" == lines.pop(0)

             assert "unset my_mdwn_postprocess_cmd_file" == lines.pop(0)
 
         @pytest.mark.massage
             assert "unset my_mdwn_postprocess_cmd_file" == lines.pop(0)
 
         @pytest.mark.massage

-        def test_do_massage_fulltree(
-            self, string_io, const1, mime_tree_related_to_alternative, capsys
-        ):
-            def converter(
-                drafttext,
-                draftpath,
-                css,
-                related_to_html_only,
-                extensions,
-                tempdir,
-            ):
+        def test_do_massage_fulltree(self, mime_tree_related_to_alternative):
+            def converter(draft_f, **kwargs):

                 return mime_tree_related_to_alternative
 
             max_attachments = 5
                 return mime_tree_related_to_alternative
 
             max_attachments = 5

-            do_massage(
-                draft_f=string_io,
-                draftpath=const1,
-                cmd_f=sys.stdout,
-                max_other_attachments=max_attachments,
-                converter=converter,
-            )

 
 

-            captured = capsys.readouterr()
-            lines = captured.out.splitlines()[4:-2]
+            with File() as draft_f, File() as cmd_f:
+                do_massage(
+                    draft_f=draft_f,
+                    cmd_f=cmd_f,
+                    max_other_attachments=max_attachments,
+                    converter=converter,
+                )
+                lines = cmd_f.read().splitlines()[:-6]
+

             assert "first-entry" in lines.pop()
             assert "update-encoding" in lines.pop()
             assert "Plain" in lines.pop()
             assert "first-entry" in lines.pop()
             assert "update-encoding" in lines.pop()
             assert "Plain" in lines.pop()


@@ -1166,59 +1463,115 @@ try:
             assert "send-message" in lines.pop()
             assert len(lines) == 0
 
             assert "send-message" in lines.pop()
             assert len(lines) == 0
 

-        @pytest.fixture
-        def fake_filewriter(self):
-            class FileWriter:
-                def __init__(self):
-                    self._writes = []
+        @pytest.mark.massage
+        def test_mime_tree_relative_within_alternative(
+            self, mime_tree_related_to_html
+        ):
+            def converter(draft_f, **kwargs):
+                return mime_tree_related_to_html

 
 

-                def __call__(self, path, content, mode="w", **kwargs):
-                    self._writes.append((path, content))
+            with File() as draft_f, File() as cmd_f:
+                do_massage(
+                    draft_f=draft_f,
+                    cmd_f=cmd_f,
+                    converter=converter,
+                )
+                lines = cmd_f.read().splitlines()[:-6]

 
 

-                def pop(self, index=-1):
-                    return self._writes.pop(index)
+            assert "first-entry" in lines.pop()
+            assert "update-encoding" in lines.pop()
+            assert "Plain" in lines.pop()
+            assert "part.html" in lines.pop()
+            assert "toggle-unlink" in lines.pop()
+            assert "move-up" in lines.pop()
+            while True:
+                top = lines.pop()
+                if "move-up" not in top:
+                    break
+            assert "move-down" in top
+            assert "HTML" in lines.pop()
+            assert "logo.png" in lines.pop()
+            assert "toggle-unlink" in lines.pop()
+            assert "content-id" in lines.pop()
+            assert "move-up" in lines.pop()
+            while True:
+                top = lines.pop()
+                if "move-up" not in top:
+                    break
+            assert "move-down" in top
+            assert "move-down" in lines.pop()
+            assert "Logo" in lines.pop()
+            assert "jump>2" in lines.pop()
+            assert "jump>3" in lines.pop()
+            assert "group-related" in lines.pop()
+            assert "Related" in lines.pop()
+            assert "jump>1" in lines.pop()
+            assert "jump>2" in lines.pop()
+            assert "group-alternative" in lines.pop()
+            assert "Alternative" in lines.pop()
+            assert "send-message" in lines.pop()
+            assert len(lines) == 0

 
 

-            return FileWriter()
+        @pytest.mark.massage
+        def test_mime_tree_nested_trees_does_not_break_positioning(
+            self, mime_tree_nested
+        ):
+            def converter(draft_f, **kwargs):
+                return mime_tree_nested

 
 

-        @pytest.fixture
-        def markdown_non_converter(self, const1, const2):
-            return lambda s, text: f"{const1}{text}{const2}"
+            with File() as draft_f, File() as cmd_f:
+                do_massage(
+                    draft_f=draft_f,
+                    cmd_f=cmd_f,
+                    converter=converter,
+                )
+                lines = cmd_f.read().splitlines()
+
+            while "logo.png" not in lines.pop():
+                pass
+            lines.pop()
+            assert "content-id" in lines.pop()
+            assert "move-up" in lines.pop()
+            while True:
+                top = lines.pop()
+                if "move-up" not in top:
+                    break
+            assert "move-down" in top
+            # Due to the nested trees, the number of descendents of the sibling
+            # actually needs to be considered, not just the nieces. So to move
+            # from position 1 to position 6, it only needs one <move-down>
+            # because that jumps over the entire sibling tree. Thus what
+            # follows next must not be another <move-down>
+            assert "Logo" in lines.pop()

 
         @pytest.mark.converter
 
         @pytest.mark.converter

-        def test_converter_tree_basic(self, const1, const2, fake_filewriter):
-            path = pathlib.Path(const2)
-            tree = convert_markdown_to_html(
-                const1, path, filewriter_fn=fake_filewriter
-            )
+        def test_converter_tree_basic(self, fakepath, const1, fakefilefactory):
+            with fakefilefactory(fakepath, content=const1) as draft_f:
+                tree = convert_markdown_to_html(
+                    draft_f, filefactory=fakefilefactory
+                )

 
             assert tree.subtype == "alternative"
             assert len(tree.children) == 2
             assert tree.children[0].subtype == "plain"
 
             assert tree.subtype == "alternative"
             assert len(tree.children) == 2
             assert tree.children[0].subtype == "plain"

-            assert tree.children[0].path == path
+            assert tree.children[0].path == draft_f.path

             assert tree.children[0].orig
             assert tree.children[1].subtype == "html"
             assert tree.children[0].orig
             assert tree.children[1].subtype == "html"

-            assert tree.children[1].path == path.with_suffix(".html")
+            assert tree.children[1].path == fakepath.with_suffix(".html")

 
 

+        @pytest.mark.converter

         def test_converter_writes(
         def test_converter_writes(

-            self,
-            const1,
-            const2,
-            fake_filewriter,
-            monkeypatch,
-            markdown_non_converter,
+            self, fakepath, fakefilefactory, const1, monkeypatch

         ):
         ):

-            path = pathlib.Path(const2)
-
-            with monkeypatch.context() as m:
-                m.setattr(markdown.Markdown, "convert", markdown_non_converter)
-                convert_markdown_to_html(
-                    const1, path, filewriter_fn=fake_filewriter
-                )
+            with fakefilefactory(fakepath, content=const1) as draft_f:
+                convert_markdown_to_html(draft_f, filefactory=fakefilefactory)

 
 

-            assert (path, const1) == fake_filewriter.pop(0)
-            written = fake_filewriter.pop(0)
-            assert path.with_suffix(".html") == written[0]
-            assert const1 in written[1]
+            html = fakefilefactory.pop()
+            assert fakepath.with_suffix(".html") == html[0]
+            assert const1 in html[1].read()
+            text = fakefilefactory.pop()
+            assert fakepath == text[0]
+            assert const1 == text[1].read()

 
         @pytest.mark.imgproc
         def test_markdown_inline_image_processor(self):
 
         @pytest.mark.imgproc
         def test_markdown_inline_image_processor(self):


@@ -1316,76 +1669,77 @@ try:
 
         @pytest.mark.converter
         def test_converter_tree_inline_image_base64(
 
         @pytest.mark.converter
         def test_converter_tree_inline_image_base64(

-            self, test_png, const1, fake_filewriter
+            self, test_png, fakefilefactory

         ):
             text = f"![inline base64 image]({test_png})"
         ):
             text = f"![inline base64 image]({test_png})"

-            path = pathlib.Path(const1)
-            tree = convert_markdown_to_html(
-                text,
-                path,
-                filewriter_fn=fake_filewriter,
-                related_to_html_only=False,
-            )
+            with fakefilefactory(content=text) as draft_f:
+                tree = convert_markdown_to_html(
+                    draft_f,
+                    filefactory=fakefilefactory,
+                    related_to_html_only=False,
+                )

             assert tree.subtype == "relative"
             assert tree.children[0].subtype == "alternative"
             assert tree.children[1].subtype == "png"
             assert tree.subtype == "relative"
             assert tree.children[0].subtype == "alternative"
             assert tree.children[1].subtype == "png"

-            written = fake_filewriter.pop()
+            written = fakefilefactory.pop()

             assert tree.children[1].path == written[0]
             assert tree.children[1].path == written[0]

-            assert written[1] == request.urlopen(test_png).read()
+            assert b"PNG" in written[1].read()

 
         @pytest.mark.converter
         def test_converter_tree_inline_image_base64_related_to_html(
 
         @pytest.mark.converter
         def test_converter_tree_inline_image_base64_related_to_html(

-            self, test_png, const1, fake_filewriter
+            self, test_png, fakefilefactory

         ):
             text = f"![inline base64 image]({test_png})"
         ):
             text = f"![inline base64 image]({test_png})"

-            path = pathlib.Path(const1)
-            tree = convert_markdown_to_html(
-                text,
-                path,
-                filewriter_fn=fake_filewriter,
-                related_to_html_only=True,
-            )
+            with fakefilefactory(content=text) as draft_f:
+                tree = convert_markdown_to_html(
+                    draft_f,
+                    filefactory=fakefilefactory,
+                    related_to_html_only=True,
+                )

             assert tree.subtype == "alternative"
             assert tree.children[1].subtype == "relative"
             assert tree.children[1].children[1].subtype == "png"
             assert tree.subtype == "alternative"
             assert tree.children[1].subtype == "relative"
             assert tree.children[1].children[1].subtype == "png"

-            written = fake_filewriter.pop()
+            written = fakefilefactory.pop()

             assert tree.children[1].children[1].path == written[0]
             assert tree.children[1].children[1].path == written[0]

-            assert written[1] == request.urlopen(test_png).read()
+            assert b"PNG" in written[1].read()

 
         @pytest.mark.converter
         def test_converter_tree_inline_image_cid(
 
         @pytest.mark.converter
         def test_converter_tree_inline_image_cid(

-            self, const1, fake_filewriter
+            self, const1, fakefilefactory

         ):
             text = f"![inline base64 image](cid:{const1})"
         ):
             text = f"![inline base64 image](cid:{const1})"

-            path = pathlib.Path(const1)
-            tree = convert_markdown_to_html(
-                text,
-                path,
-                filewriter_fn=fake_filewriter,
-                related_to_html_only=False,
-            )
+            with fakefilefactory(content=text) as draft_f:
+                tree = convert_markdown_to_html(
+                    draft_f,
+                    filefactory=fakefilefactory,
+                    related_to_html_only=False,
+                )

             assert len(tree.children) == 2
             assert tree.children[0].cid != const1
             assert tree.children[0].type != "image"
             assert tree.children[1].cid != const1
             assert tree.children[1].type != "image"
 
             assert len(tree.children) == 2
             assert tree.children[0].cid != const1
             assert tree.children[0].type != "image"
             assert tree.children[1].cid != const1
             assert tree.children[1].type != "image"
 

+        @pytest.fixture
+        def fakefilefactory(self):
+            return FakeFileFactory()
+

         @pytest.mark.imgcoll
         def test_inline_image_collection(
         @pytest.mark.imgcoll
         def test_inline_image_collection(

-            self, test_png, const1, const2, fake_filewriter
+            self, test_png, const1, const2, fakefilefactory

         ):
             test_images = {test_png: InlineImageInfo(cid=const1, desc=const2)}
             relparts = collect_inline_images(
         ):
             test_images = {test_png: InlineImageInfo(cid=const1, desc=const2)}
             relparts = collect_inline_images(

-                test_images, filewriter_fn=fake_filewriter
+                test_images, filefactory=fakefilefactory

             )
 
             )
 

-            written = fake_filewriter.pop()
-            assert b"PNG" in written[1]
+            written = fakefilefactory.pop()
+            assert b"PNG" in written[1].read()

 
             assert relparts[0].subtype == "png"
             assert relparts[0].path == written[0]
             assert relparts[0].cid == const1
 
             assert relparts[0].subtype == "png"
             assert relparts[0].path == written[0]
             assert relparts[0].cid == const1

-            assert relparts[0].desc.endswith(const2)
+            assert const2 in relparts[0].desc

 
         if _PYNLINER:
 
 
         if _PYNLINER:
 


@@ -1397,49 +1751,56 @@ try:
                 assert 'p style="color' in out
 
             @pytest.mark.styling
                 assert 'p style="color' in out
 
             @pytest.mark.styling

-            def test_massage_styling_to_converter(self, string_io, const1):
+            def test_apply_no_stylesheet(self, const1):
+                out = apply_styling(const1, None)
+
+            @pytest.mark.massage
+            @pytest.mark.styling
+            def test_massage_styling_to_converter(self):

                 css = "p { color:red }"
                 css = "p { color:red }"

-                css_f = StringIO(css)
-                out_f = StringIO()

                 css_applied = []
 
                 css_applied = []
 

-                def converter(
-                    drafttext,
-                    draftpath,
-                    css,
-                    related_to_html_only,
-                    extensions,
-                    tempdir,
-                ):
+                def converter(draft_f, css_f, **kwargs):
+                    css = css_f.read()

                     css_applied.append(css)
                     css_applied.append(css)

-                    return Part("text", "plain", draftpath, orig=True)
+                    return Part("text", "plain", draft_f.path, orig=True)

 
 

-                do_massage(
-                    draft_f=string_io,
-                    draftpath=const1,
-                    cmd_f=out_f,
-                    css_f=css_f,
-                    converter=converter,
-                )
+                with (
+                    File() as draft_f,
+                    File(mode="w") as cmd_f,
+                    File(content=css) as css_f
+                ):
+                    do_massage(
+                        draft_f=draft_f,
+                        cmd_f=cmd_f,
+                        css_f=css_f,
+                        converter=converter,
+                    )

                 assert css_applied[0] == css
 
             @pytest.mark.converter
                 assert css_applied[0] == css
 
             @pytest.mark.converter

+            @pytest.mark.styling

             def test_converter_apply_styles(
             def test_converter_apply_styles(

-                self, const1, fake_filewriter, monkeypatch
+                self, const1, monkeypatch, fakepath, fakefilefactory

             ):
             ):

-                path = pathlib.Path(const1)
-                text = "Hello, world!"

                 css = "p { color:red }"
                 css = "p { color:red }"

-                with monkeypatch.context() as m:
+                with (
+                    monkeypatch.context() as m,
+                    fakefilefactory(fakepath, content=const1) as draft_f,
+                    fakefilefactory(content=css) as css_f,
+                ):

                     m.setattr(
                         markdown.Markdown,
                         "convert",
                         lambda s, t: f"<p>{t}</p>",
                     )
                     convert_markdown_to_html(
                     m.setattr(
                         markdown.Markdown,
                         "convert",
                         lambda s, t: f"<p>{t}</p>",
                     )
                     convert_markdown_to_html(

-                        text, path, css=css, filewriter_fn=fake_filewriter
+                        draft_f, css_f=css_f, filefactory=fakefilefactory

                     )
                     )

-                assert "color: red" in fake_filewriter.pop()[1]
+                assert re.search(
+                    r"color:.*red",
+                    fakefilefactory[fakepath.with_suffix(".html")].read(),
+                )

 
         if _PYGMENTS_CSS:
 
 
         if _PYGMENTS_CSS:
 


@@ -1452,146 +1813,6 @@ try:
                 out = apply_styling(html, _PYGMENTS_CSS)
                 assert f'{_CODEHILITE_CLASS}" style="' in out
 
                 out = apply_styling(html, _PYGMENTS_CSS)
                 assert f'{_CODEHILITE_CLASS}" style="' in out
 

-        @pytest.mark.massage
-        def test_mime_tree_relative_within_alternative(
-            self, string_io, const1, capsys, mime_tree_related_to_html
-        ):
-            def converter(
-                drafttext,
-                draftpath,
-                css,
-                related_to_html_only,
-                extensions,
-                tempdir,
-            ):
-                return mime_tree_related_to_html
-
-            do_massage(
-                draft_f=string_io,
-                draftpath=const1,
-                cmd_f=sys.stdout,
-                converter=converter,
-            )
-
-            captured = capsys.readouterr()
-            lines = captured.out.splitlines()[4:-2]
-            assert "first-entry" in lines.pop()
-            assert "update-encoding" in lines.pop()
-            assert "Plain" in lines.pop()
-            assert "part.html" in lines.pop()
-            assert "toggle-unlink" in lines.pop()
-            assert "move-up" in lines.pop()
-            while True:
-                top = lines.pop()
-                if "move-up" not in top:
-                    break
-            assert "move-down" in top
-            assert "HTML" in lines.pop()
-            assert "logo.png" in lines.pop()
-            assert "toggle-unlink" in lines.pop()
-            assert "content-id" in lines.pop()
-            assert "move-up" in lines.pop()
-            while True:
-                top = lines.pop()
-                if "move-up" not in top:
-                    break
-            assert "move-down" in top
-            assert "move-down" in lines.pop()
-            assert "Logo" in lines.pop()
-            assert "jump>2" in lines.pop()
-            assert "jump>3" in lines.pop()
-            assert "group-related" in lines.pop()
-            assert "Related" in lines.pop()
-            assert "jump>1" in lines.pop()
-            assert "jump>2" in lines.pop()
-            assert "group-alternative" in lines.pop()
-            assert "Alternative" in lines.pop()
-            assert "send-message" in lines.pop()
-            assert len(lines) == 0
-
-        @pytest.mark.massage
-        def test_mime_tree_nested_trees_does_not_break_positioning(
-            self, string_io, const1, capsys
-        ):
-            def converter(
-                drafttext,
-                draftpath,
-                css,
-                related_to_html_only,
-                extensions,
-                tempdir,
-            ):
-                return Multipart(
-                    "relative",
-                    children=[
-                        Multipart(
-                            "alternative",
-                            children=[
-                                Part(
-                                    "text",
-                                    "plain",
-                                    "part.txt",
-                                    desc="Plain",
-                                    orig=True,
-                                ),
-                                Multipart(
-                                    "alternative",
-                                    children=[
-                                        Part(
-                                            "text",
-                                            "plain",
-                                            "part.txt",
-                                            desc="Nested plain",
-                                        ),
-                                        Part(
-                                            "text",
-                                            "html",
-                                            "part.html",
-                                            desc="Nested HTML",
-                                        ),
-                                    ],
-                                    desc="Nested alternative",
-                                ),
-                            ],
-                            desc="Alternative",
-                        ),
-                        Part(
-                            "text",
-                            "png",
-                            "logo.png",
-                            cid="logo.png",
-                            desc="Logo",
-                        ),
-                    ],
-                    desc="Related",
-                )
-
-            do_massage(
-                draft_f=string_io,
-                draftpath=const1,
-                cmd_f=sys.stdout,
-                converter=converter,
-            )
-
-            captured = capsys.readouterr()
-            lines = captured.out.splitlines()
-            while "logo.png" not in lines.pop():
-                pass
-            lines.pop()
-            assert "content-id" in lines.pop()
-            assert "move-up" in lines.pop()
-            while True:
-                top = lines.pop()
-                if "move-up" not in top:
-                    break
-            assert "move-down" in top
-            # Due to the nested trees, the number of descendents of the sibling
-            # actually needs to be considered, not just the nieces. So to move
-            # from position 1 to position 6, it only needs one <move-down>
-            # because that jumps over the entire sibling tree. Thus what
-            # follows next must not be another <move-down>
-            assert "Logo" in lines.pop()
-

         @pytest.mark.sig
         def test_signature_extraction_no_signature(self, const1):
             assert (const1, None, None) == extract_signature(const1)
         @pytest.mark.sig
         def test_signature_extraction_no_signature(self, const1):
             assert (const1, None, None) == extract_signature(const1)


@@ -1606,29 +1827,27 @@ try:
             assert htmlsig is None
 
         @pytest.mark.sig
             assert htmlsig is None
 
         @pytest.mark.sig

-        def test_signature_extraction_html(self, const1, const2):
-            path = pathlib.Path("somepath")
+        def test_signature_extraction_html(
+            self, fakepath, fakefilefactory, const1, const2
+        ):

             sigconst = "HTML signature from {path} but as a string"
             sigconst = "HTML signature from {path} but as a string"

+            sig = f'<div id="signature">{sigconst.format(path=fakepath)}</div>'

 
 

-            def filereader_fn(path):
-                return (
-                    f'<div id="signature">{sigconst.format(path=path)}</div>'
-                )
+            sig_f = fakefilefactory(fakepath, content=sig)

 
             origtext, textsig, htmlsig = extract_signature(
 
             origtext, textsig, htmlsig = extract_signature(

-                f"{const1}{EMAIL_SIG_SEP}{HTML_SIG_MARKER} {path}\n{const2}",
-                filereader_fn=filereader_fn,
+                f"{const1}{EMAIL_SIG_SEP}{HTML_SIG_MARKER} {fakepath}\n{const2}",
+                filefactory=fakefilefactory,

             )
             assert origtext == const1
             assert textsig == const2
             )
             assert origtext == const1
             assert textsig == const2

-            assert htmlsig == sigconst.format(path=path)
+            assert htmlsig == sigconst.format(path=fakepath)

 
         @pytest.mark.sig
 
         @pytest.mark.sig

-        def test_signature_extraction_file_not_found(self, const1):
-            path = pathlib.Path("/does/not/exist")
+        def test_signature_extraction_file_not_found(self, fakepath, const1):

             with pytest.raises(FileNotFoundError):
                 origtext, textsig, htmlsig = extract_signature(
             with pytest.raises(FileNotFoundError):
                 origtext, textsig, htmlsig = extract_signature(

-                    f"{const1}{EMAIL_SIG_SEP}{HTML_SIG_MARKER}{path}\n{const1}"
+                    f"{const1}{EMAIL_SIG_SEP}{HTML_SIG_MARKER}{fakepath}\n{const1}"

                 )
 
         @pytest.mark.imgproc
                 )
 
         @pytest.mark.imgproc


@@ -1651,29 +1870,27 @@ try:
         @pytest.mark.converter
         @pytest.mark.sig
         def test_converter_signature_handling(
         @pytest.mark.converter
         @pytest.mark.sig
         def test_converter_signature_handling(

-            self, const1, fake_filewriter, monkeypatch
+            self, fakepath, fakefilefactory, monkeypatch

         ):
         ):

-            path = pathlib.Path(const1)
-

             mailparts = (
                 "This is the mail body\n",
                 f"{EMAIL_SIG_SEP}",
                 "This is a plain-text signature only",
             )
 
             mailparts = (
                 "This is the mail body\n",
                 f"{EMAIL_SIG_SEP}",
                 "This is a plain-text signature only",
             )
 

-            def filereader_fn(path):
-                return ""
-
-            with monkeypatch.context() as m:
+            with (
+                fakefilefactory(
+                    fakepath, content="".join(mailparts)
+                ) as draft_f,
+                monkeypatch.context() as m,
+            ):

                 m.setattr(markdown.Markdown, "convert", lambda s, t: t)
                 m.setattr(markdown.Markdown, "convert", lambda s, t: t)

-                convert_markdown_to_html(
-                    "".join(mailparts),
-                    path,
-                    filewriter_fn=fake_filewriter,
-                    filereader_fn=filereader_fn,
-                )
+                convert_markdown_to_html(draft_f, filefactory=fakefilefactory)

 
 

-            soup = bs4.BeautifulSoup(fake_filewriter.pop()[1], "html.parser")
+            soup = bs4.BeautifulSoup(
+                fakefilefactory[fakepath.with_suffix(".html")].read(),
+                "html.parser",
+            )

             body = soup.body.contents
 
             assert mailparts[0] in body.pop(0)
             body = soup.body.contents
 
             assert mailparts[0] in body.pop(0)


@@ -1690,114 +1907,312 @@ try:
         @pytest.mark.converter
         @pytest.mark.sig
         def test_converter_signature_handling_htmlsig(
         @pytest.mark.converter
         @pytest.mark.sig
         def test_converter_signature_handling_htmlsig(

-            self, const1, fake_filewriter, monkeypatch
+            self, fakepath, fakepath2, fakefilefactory, monkeypatch

         ):
         ):

-            path = pathlib.Path(const1)
-

             mailparts = (
                 "This is the mail body",
                 f"{EMAIL_SIG_SEP}",
             mailparts = (
                 "This is the mail body",
                 f"{EMAIL_SIG_SEP}",

-                f"{HTML_SIG_MARKER}{path}\n",
+                f"{HTML_SIG_MARKER}{fakepath2}\n",

                 "This is the plain-text version",
             )
                 "This is the plain-text version",
             )

+            htmlsig = "HTML Signature from {path} but as a string"
+            html = (
+                f'<div id="signature"><p>{htmlsig.format(path=fakepath2)}</p></div>'
+            )

 
 

-            htmlsig = "HTML Signature from {path}"
-
-            def filereader_fn(path):
-                return f'<div id="signature">{htmlsig.format(path=path)}</div>'
+            sig_f = fakefilefactory(fakepath2, content=html)

 
             def mdwn_fn(t):
                 return t.upper()
 
 
             def mdwn_fn(t):
                 return t.upper()
 

-            with monkeypatch.context() as m:
+            with (
+                fakefilefactory(
+                    fakepath, content="".join(mailparts)
+                ) as draft_f,
+                monkeypatch.context() as m,
+            ):

                 m.setattr(
                     markdown.Markdown, "convert", lambda s, t: mdwn_fn(t)
                 )
                 m.setattr(
                     markdown.Markdown, "convert", lambda s, t: mdwn_fn(t)
                 )

-                convert_markdown_to_html(
-                    "".join(mailparts),
-                    path,
-                    filewriter_fn=fake_filewriter,
-                    filereader_fn=filereader_fn,
-                )
+                convert_markdown_to_html(draft_f, filefactory=fakefilefactory)

 
 

-            soup = bs4.BeautifulSoup(fake_filewriter.pop()[1], "html.parser")
+            soup = bs4.BeautifulSoup(
+                fakefilefactory[fakepath.with_suffix(".html")].read(),
+                "html.parser",
+            )

             sig = soup.select_one("#signature")
             sig.span.extract()
 
             assert HTML_SIG_MARKER not in sig.text
             sig = soup.select_one("#signature")
             sig.span.extract()
 
             assert HTML_SIG_MARKER not in sig.text

-            assert htmlsig.format(path=path) == sig.text.strip()
+            assert htmlsig.format(path=fakepath2) == sig.text.strip()

 
 

-            plaintext = fake_filewriter.pop()[1]
+            plaintext = fakefilefactory[fakepath].read()

             assert plaintext.endswith(EMAIL_SIG_SEP + mailparts[-1])
 
         @pytest.mark.converter
         @pytest.mark.sig
         def test_converter_signature_handling_htmlsig_with_image(
             assert plaintext.endswith(EMAIL_SIG_SEP + mailparts[-1])
 
         @pytest.mark.converter
         @pytest.mark.sig
         def test_converter_signature_handling_htmlsig_with_image(

-            self, const1, fake_filewriter, monkeypatch, test_png
+            self, fakepath, fakepath2, fakefilefactory, monkeypatch, test_png

         ):
         ):

-            path = pathlib.Path(const1)
-

             mailparts = (
                 "This is the mail body",
                 f"{EMAIL_SIG_SEP}",
             mailparts = (
                 "This is the mail body",
                 f"{EMAIL_SIG_SEP}",

-                f"{HTML_SIG_MARKER}{path}\n",
+                f"{HTML_SIG_MARKER}{fakepath2}\n",

                 "This is the plain-text version",
             )
                 "This is the plain-text version",
             )

-

             htmlsig = (
                 "HTML Signature from {path} with image\n"
                 f'<img src="{test_png}">\n'
             )
             htmlsig = (
                 "HTML Signature from {path} with image\n"
                 f'<img src="{test_png}">\n'
             )

+            html = (
+                f'<div id="signature">{htmlsig.format(path=fakepath2)}</div>'
+            )

 
 

-            def filereader_fn(path):
-                return f'<div id="signature">{htmlsig.format(path=path)}</div>'
+            sig_f = fakefilefactory(fakepath2, content=html)

 
             def mdwn_fn(t):
                 return t.upper()
 
 
             def mdwn_fn(t):
                 return t.upper()
 

-            with monkeypatch.context() as m:
+            with (
+                fakefilefactory(
+                    fakepath, content="".join(mailparts)
+                ) as draft_f,
+                monkeypatch.context() as m,
+            ):

                 m.setattr(
                     markdown.Markdown, "convert", lambda s, t: mdwn_fn(t)
                 )
                 m.setattr(
                     markdown.Markdown, "convert", lambda s, t: mdwn_fn(t)
                 )

-                convert_markdown_to_html(
-                    "".join(mailparts),
-                    path,
-                    filewriter_fn=fake_filewriter,
-                    filereader_fn=filereader_fn,
-                )
+                convert_markdown_to_html(draft_f, filefactory=fakefilefactory)

 
 

-            assert fake_filewriter.pop()[0].suffix == ".png"
+            assert fakefilefactory.pop()[0].suffix == ".png"

 
 

-            soup = bs4.BeautifulSoup(fake_filewriter.pop()[1], "html.parser")
+            soup = bs4.BeautifulSoup(
+                fakefilefactory[fakepath.with_suffix(".html")].read(),
+                "html.parser",
+            )

             assert soup.img.attrs["src"].startswith("cid:")
 
         @pytest.mark.converter
         @pytest.mark.sig
         def test_converter_signature_handling_textsig_with_image(
             assert soup.img.attrs["src"].startswith("cid:")
 
         @pytest.mark.converter
         @pytest.mark.sig
         def test_converter_signature_handling_textsig_with_image(

-            self, const1, fake_filewriter, test_png
+            self, fakepath, fakefilefactory, test_png

         ):
             mailparts = (
                 "This is the mail body",
                 f"{EMAIL_SIG_SEP}",
                 "This is the plain-text version with image\n",
                 f"![Inline]({test_png})",
         ):
             mailparts = (
                 "This is the mail body",
                 f"{EMAIL_SIG_SEP}",
                 "This is the plain-text version with image\n",
                 f"![Inline]({test_png})",

-
-            )
-            tree = convert_markdown_to_html
-                "".join(mailparts),
-                pathlib.Path(const1),
-                filewriter_fn=fake_filewriter,

             )
             )

+            with (
+                fakefilefactory(
+                    fakepath, content="".join(mailparts)
+                ) as draft_f,
+            ):
+                tree = convert_markdown_to_html(
+                    draft_f, filefactory=fakefilefactory
+                )

 
             assert tree.subtype == "relative"
             assert tree.children[0].subtype == "alternative"
             assert tree.children[1].subtype == "png"
 
             assert tree.subtype == "relative"
             assert tree.children[0].subtype == "alternative"
             assert tree.children[1].subtype == "png"

-            written = fake_filewriter.pop()
+            written = fakefilefactory.pop()

             assert tree.children[1].path == written[0]
             assert tree.children[1].path == written[0]

-            assert written[1] == request.urlopen(test_png).read()
+            assert written[1].read() == request.urlopen(test_png).read()
+
+        @pytest.mark.converter
+        def test_converter_attribution_to_admonition(
+            self, fakepath, fakefilefactory
+        ):
+            mailparts = (
+                "Regarding whatever",
+                "> blockquote line1",
+                "> blockquote line2",
+                "> ",
+                "> new para with **bold** text",
+            )
+            with fakefilefactory(
+                fakepath, content="\n".join(mailparts)
+            ) as draft_f:
+                convert_markdown_to_html(draft_f, filefactory=fakefilefactory)
+
+            soup = bs4.BeautifulSoup(
+                fakefilefactory[fakepath.with_suffix(".html")].read(),
+                "html.parser",
+            )
+            quote = soup.select_one("div.admonition.quote")
+            assert quote
+            assert (
+                soup.select_one("p.admonition-title").extract().text.strip()
+                == mailparts[0]
+            )

 
 

-        def test_converter_attribution_to_admonition(self, fake_filewriter):
+            p = quote.p.extract()
+            assert p.text.strip() == "\n".join(p[2:] for p in mailparts[1:3])

 
 

+            p = quote.p.extract()
+            assert p.contents[1].name == "strong"
+
+        @pytest.mark.converter
+        def test_converter_attribution_to_admonition_with_blockquote(
+            self, fakepath, fakefilefactory
+        ):
+            mailparts = (
+                "Regarding whatever",
+                "> blockquote line1",
+                "> blockquote line2",
+                "> ",
+                "> new para with **bold** text",
+            )
+            with fakefilefactory(
+                fakepath, content="\n".join(mailparts)
+            ) as draft_f:
+                convert_markdown_to_html(draft_f, filefactory=fakefilefactory)
+
+            soup = bs4.BeautifulSoup(
+                fakefilefactory[fakepath.with_suffix(".html")].read(),
+                "html.parser",
+            )
+            quote = soup.select_one("div.admonition.quote")
+            assert quote.blockquote
+
+        @pytest.mark.converter
+        def test_converter_attribution_to_admonition_multiple(
+            self, fakepath, fakefilefactory
+        ):
+            mailparts = (
+                "Regarding whatever",
+                "> blockquote line1",
+                "> blockquote line2",
+                "",
+                "Normal text",
+                "",
+                "> continued emailquote",
+                "",
+                "Another email-quote",
+                "> something",
+            )
+            with fakefilefactory(
+                fakepath, content="\n".join(mailparts)
+            ) as draft_f:
+                convert_markdown_to_html(draft_f, filefactory=fakefilefactory)
+
+            soup = bs4.BeautifulSoup(
+                fakefilefactory[fakepath.with_suffix(".html")].read(),
+                "html.parser",
+            )
+            quote = soup.select_one("div.admonition.quote.continued").extract()
+            assert quote
+            assert (
+                quote.select_one("p.admonition-title").extract().text.strip()
+                == mailparts[0]
+            )
+
+            p = quote.p.extract()
+            assert p
+
+            quote = soup.select_one("div.admonition.quote.continued").extract()
+            assert quote
+            assert (
+                quote.select_one("p.admonition-title").extract().text.strip()
+                == mailparts[-2]
+            )
+
+        @pytest.mark.fileio
+        def test_file_class_contextmanager(self, const1, monkeypatch):
+            state = dict(o=False, c=False)
+
+            def fn(t):
+                state[t] = True
+
+            with monkeypatch.context() as m:
+                m.setattr(File, "open", lambda s: fn("o"))
+                m.setattr(File, "close", lambda s: fn("c"))
+                with File() as f:
+                    assert state["o"]
+                    assert not state["c"]
+            assert state["c"]
+
+        @pytest.mark.fileio
+        def test_file_class_no_path(self, const1):
+            with File(mode="w+") as f:
+                f.write(const1, cache=False)
+                assert f.read(cache=False) == const1
+
+        @pytest.mark.fileio
+        def test_file_class_path(self, const1, tmp_path):
+            with File(tmp_path / "file", mode="w+") as f:
+                f.write(const1, cache=False)
+                assert f.read(cache=False) == const1
+
+        @pytest.mark.fileio
+        def test_file_class_path_no_exists(self, fakepath):
+            with pytest.raises(FileNotFoundError):
+                File(fakepath, mode="r").open()
+
+        @pytest.mark.fileio
+        def test_file_class_cache(self, tmp_path, const1, const2):
+            path = tmp_path / "file"
+            file = File(path, mode="w+")
+            with file as f:
+                f.write(const1, cache=True)
+            with open(path, mode="w") as f:
+                f.write(const2)
+            with file as f:
+                assert f.read(cache=True) == const1
+
+        @pytest.mark.fileio
+        def test_file_class_cache_init(self, const1):
+            file = File(path=None, mode="r", content=const1)
+            with file as f:
+                assert f.read() == const1
+
+        @pytest.mark.fileio
+        def test_file_class_content_or_path(self, fakepath, const1):
+            with pytest.raises(RuntimeError):
+                file = File(path=fakepath, content=const1)
+
+        @pytest.mark.fileio
+        def test_file_class_content_needs_read(self, const1):
+            with pytest.raises(RuntimeError):
+                file = File(mode="w", content=const1)
+
+        @pytest.mark.fileio
+        def test_file_class_write_persists_close(self, const1):
+            f = File(mode="w+")
+            with f:
+                f.write(const1)
+            with f:
+                assert f.read() == const1
+
+        @pytest.mark.fileio
+        def test_file_class_write_resets_read_cache(self, const1, const2):
+            with File(mode="w+", content=const1) as f:
+                assert f.read() == const1
+                f.write(const2)
+                assert f.read() == const2
+
+        @pytest.mark.fileio
+        def test_file_factory(self):
+            fact = FileFactory()
+            f = fact()
+            assert isinstance(f, File)
+            assert len(fact) == 1
+            assert f in fact
+            assert f == fact[0]
+
+        @pytest.mark.fileio
+        def test_fake_file_factory(self, fakepath, fakefilefactory):
+            fact = FakeFileFactory()
+            f = fakefilefactory(fakepath)
+            assert f.path == fakepath
+            assert f == fakefilefactory[fakepath]
+
+        @pytest.mark.fileio
+        def test_fake_file_factory_path_persistence(
+            self, fakepath, fakefilefactory
+        ):
+            f1 = fakefilefactory(fakepath)
+            assert f1 == fakefilefactory(fakepath)

 
 except ImportError:
     pass
 
 except ImportError:
     pass