.mutt/markdown2html

   1 #!/usr/bin/python3
   2 #
   3 # markdown2html.py — simple Markdown-to-HTML converter for use with Mutt
   4 #
   5 # Mutt recently learnt [how to compose `multipart/alternative`
   6 # emails][1]. This script assumes a message has been composed using Markdown
   7 # (with a lot of pandoc extensions enabled), and translates it to `text/html`
   8 # for Mutt to tie into such a `multipart/alternative` message.
   9 #
  10 # [1]: https://gitlab.com/muttmua/mutt/commit/0e566a03725b4ad789aa6ac1d17cdf7bf4e7e354)
  11 #
  12 # Configuration:
  13 #   muttrc:
  14 #     set send_multipart_alternative=yes
  15 #     set send_multipart_alternative_filter=/path/to/markdown2html.py
  16 #
  17 # Optionally, Custom CSS styles will be read from `~/.mutt/markdown2html.css`,
  18 # if present.
  19 #
  20 # Requirements:
  21 #   - python3
  22 #   - PyPandoc (and pandoc installed, or downloaded)
  23 #   - Pynliner
  24 #
  25 # Optional:
  26 #   - Pygments, if installed, then syntax highlighting is enabled
  27 #
  28 # Latest version:
  29 #   https://git.madduck.net/etc/mutt.git/blob_plain/HEAD:/.mutt/markdown2html
  30 #
  31 # Copyright © 2019 martin f. krafft <madduck@madduck.net>
  32 # Released under the GPL-2+ licence, just like Mutt itself.
  33 #
  34
  35 import pypandoc
  36 import pynliner
  37 import re
  38 import os
  39 import sys
  40
  41 try:
  42     from pygments.formatters import get_formatter_by_name
  43     formatter = get_formatter_by_name('html', style='default')
  44     DEFAULT_CSS = formatter.get_style_defs('.sourceCode')
  45
  46 except ImportError:
  47     DEFAULT_CSS = ""
  48
  49
  50 DEFAULT_CSS += '''
  51 .quote {
  52     padding: 0 0.5em;
  53     margin: 0;
  54     font-style: italic;
  55     border-left: 2px solid #ccc;
  56     color: #999;
  57     font-size: 80%;
  58 }
  59 .quotelead {
  60     font-style: italic;
  61     margin-bottom: -1em;
  62     color: #999;
  63     font-size: 80%;
  64 }
  65 .quotechar { display: none; }
  66 .footnote-ref, .footnote-back { text-decoration: none;}
  67 .signature {
  68     color: #999;
  69     font-family: monospace;
  70     white-space: pre;
  71     margin: 1em 0 0 0;
  72     font-size: 80%;
  73 }
  74 table, th, td {
  75     border-collapse: collapse;
  76     border: 1px solid #999;
  77 }
  78 th, td { padding: 0.5em; }
  79 .header {
  80     background: #eee;
  81 }
  82 .even { background: #eee; }
  83 '''
  84
  85 STYLESHEET = os.path.join(os.path.expanduser('~/.mutt'),
  86                           'markdown2html.css')
  87 if os.path.exists(STYLESHEET):
  88     DEFAULT_CSS += open(STYLESHEET).read()
  89
  90 HTML_DOCUMENT = '''<!DOCTYPE html>
  91 <html><head>
  92 <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
  93 <meta charset="utf-8"/>
  94 <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes"/>
  95 <title>HTML E-Mail</title>
  96 </head><body class="email">
  97 {htmlbody}
  98 </body></html>'''
  99
 100
 101 SIGNATURE_HTML = \
 102         '<div class="signature"><span class="leader">-- </span>{sig}</div>'
 103
 104
 105 def _preprocess_markdown(mdwn):
 106     '''
 107     Preprocess Markdown for handling by the converter.
 108     '''
 109     # convert hard line breaks within paragraphs to 2 trailing spaces, which
 110     # is the markdown way of representing hard line breaks. Note how the
 111     # regexp will not match between paragraphs.
 112     ret = re.sub(r'(\S)\n(\s*\S)', r'\g<1>  \n\g<2>', mdwn, flags=re.MULTILINE)
 113
 114     # Clients like Thunderbird need the leading '>' to be able to properly
 115     # create nested quotes, so we duplicate the symbol, the first instance
 116     # will tell pandoc to create a blockquote, while the second instance will
 117     # be a <span> containing the character, along with a class that causes CSS
 118     # to actually hide it from display. However, this does not work with the
 119     # text-mode HTML2text converters, and so it's left commented for now.
 120     #ret = re.sub(r'\n>', r'  \n>[>]{.quotechar}', ret, flags=re.MULTILINE)
 121
 122     return ret
 123
 124
 125 def _identify_quotes_for_later(mdwn):
 126     '''
 127     Email quoting such as:
 128
 129     ```
 130     On 1970-01-01, you said:
 131     > The Flat Earth Society has members all around the globe.
 132     ```
 133
 134     isn't really properly handled by Markdown, so let's do our best to
 135     identify the individual elements, and mark them, using a syntax similar to
 136     what pandoc uses already in some cases. As pandoc won't actually use these
 137     data (yet?), we call `self._reformat_quotes` later to use these markers
 138     to slap the appropriate classes on the HTML tags.
 139     '''
 140
 141     def generate_lines_with_context(mdwn):
 142         '''
 143         Iterates the input string line-wise, returning a triplet of
 144         previous, current, and next line, the first and last of which
 145         will be None on the first and last line of the input data
 146         respectively.
 147         '''
 148         prev = cur = nxt = None
 149         lines = iter(mdwn.splitlines())
 150         cur = next(lines)
 151         for nxt in lines:
 152             yield prev, cur, nxt
 153             prev = cur
 154             cur = nxt
 155         yield prev, cur, None
 156
 157     ret = []
 158     for prev, cur, nxt in generate_lines_with_context(mdwn):
 159
 160         # The lead-in to a quote is a single line immediately preceding the
 161         # quote, and ending with ':'. Note that there could be multiple of
 162         # these:
 163         if re.match(r'^.+:\s*$', cur) and nxt.startswith('>'):
 164             ret.append(f'{{.quotelead}}{cur.strip()}')
 165             # pandoc needs an empty line before the blockquote, so
 166             # we enter one for the purpose of HTML rendition:
 167             ret.append('')
 168             continue
 169
 170         # The first blockquote after such a lead-in gets marked as the
 171         # "initial" quote:
 172         elif prev and re.match(r'^.+:\s*$', prev) and cur.startswith('>'):
 173             ret.append(re.sub(r'^(\s*>\s*)+(.+)',
 174                               r'\g<1>{.quoteinitial}\g<2>',
 175                               cur, flags=re.MULTILINE))
 176
 177         # All other occurrences of blockquotes get the "subsequent" marker:
 178         elif cur.startswith('>') and prev and not prev.startswith('>'):
 179             ret.append(re.sub(r'^((?:\s*>\s*)+)(.+)',
 180                               r'\g<1>{.quotesubsequent}\g<2>',
 181                               cur, flags=re.MULTILINE))
 182
 183         else: # pass through everything else.
 184             ret.append(cur)
 185
 186     return '\n'.join(ret)
 187
 188
 189 def _reformat_quotes(html):
 190     '''
 191     Earlier in the pipeline, we marked email quoting, using markers, which we
 192     now need to turn into HTML classes, so that we can use CSS to style them.
 193     '''
 194     ret = html.replace('<p>{.quotelead}', '<p class="quotelead">')
 195     ret = re.sub(r'<blockquote>\n((?:<blockquote>\n)*)<p>(?:\{\.quote(\w+)\})',
 196                  r'<blockquote class="quote \g<2>">\n\g<1><p>', ret, flags=re.MULTILINE)
 197     return ret
 198
 199
 200
 201 def _convert_with_pandoc(mdwn, inputfmt='markdown', outputfmt='html5',
 202                          ext_enabled=None, ext_disabled=None,
 203                          standalone=True, title="HTML E-Mail"):
 204     '''
 205     Invoke pandoc to do the actual conversion of Markdown to HTML5.
 206     '''
 207     if not ext_enabled:
 208         ext_enabled = [ 'backtick_code_blocks',
 209                        'line_blocks',
 210                        'fancy_lists',
 211                        'startnum',
 212                        'definition_lists',
 213                        'example_lists',
 214                        'table_captions',
 215                        'simple_tables',
 216                        'multiline_tables',
 217                        'grid_tables',
 218                        'pipe_tables',
 219                        'all_symbols_escapable',
 220                        'intraword_underscores',
 221                        'strikeout',
 222                        'superscript',
 223                        'subscript',
 224                        'fenced_divs',
 225                        'bracketed_spans',
 226                        'footnotes',
 227                        'inline_notes',
 228                        'emoji',
 229                        'tex_math_double_backslash',
 230                       ]
 231     if not ext_disabled:
 232         ext_disabled = [ 'tex_math_single_backslash',
 233                          'tex_math_dollars',
 234                          'smart',
 235                          'raw_html'
 236                        ]
 237
 238     enabled = '+'.join(ext_enabled)
 239     disabled = '-'.join(ext_disabled)
 240     inputfmt = f'{inputfmt}+{enabled}-{disabled}'
 241
 242     args = []
 243     if standalone:
 244         args.append('--standalone')
 245     if title:
 246         args.append(f'--metadata=pagetitle:"{title}"')
 247
 248     return pypandoc.convert_text(mdwn, format=inputfmt, to=outputfmt,
 249                                  extra_args=args)
 250
 251
 252 def _apply_styling(html):
 253     '''
 254     Inline all styles defined and used into the individual HTML tags.
 255     '''
 256     return pynliner.Pynliner().from_string(html).with_cssString(DEFAULT_CSS).run()
 257
 258
 259 def _postprocess_html(html):
 260     '''
 261     Postprocess the generated and styled HTML.
 262     '''
 263     return html
 264
 265
 266 def convert_markdown_to_html(mdwn):
 267     '''
 268     Converts the input Markdown to HTML, handling separately the body, as well
 269     as an optional signature.
 270     '''
 271     parts = re.split(r'^-- $', mdwn, 1, flags=re.MULTILINE)
 272     body = parts[0]
 273     if len(parts) == 2:
 274         sig = parts[1]
 275     else:
 276         sig = None
 277
 278     html=''
 279     if body:
 280         body = _preprocess_markdown(body)
 281         body = _identify_quotes_for_later(body)
 282         html = _convert_with_pandoc(body, standalone=False)
 283         html = _reformat_quotes(html)
 284
 285     if sig:
 286         sig = _preprocess_markdown(sig)
 287         html += SIGNATURE_HTML.format(sig='<br/>'.join(sig.splitlines()))
 288
 289     html = HTML_DOCUMENT.format(htmlbody=html)
 290     html = _apply_styling(html)
 291     html = _postprocess_html(html)
 292
 293     return html
 294
 295
 296 def main():
 297     '''
 298     Convert text on stdin to HTML, and print it to stdout, like mutt would
 299     expect.
 300     '''
 301     html = convert_markdown_to_html(sys.stdin.read())
 302     if html:
 303         # mutt expects the content type in the first line, so:
 304         print(f'text/html\n\n{html}')
 305
 306
 307 if __name__ == '__main__':
 308     main()