.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 .block {
  52     padding: 0 0.5em;
  53     margin: 0;
  54     border-left: 2px solid #eee;
  55 }
  56 .quote, blockquote {
  57     padding: 0 0.5em;
  58     margin: 0;
  59     font-style: italic;
  60     border-left: 2px solid #666;
  61     color: #666;
  62     font-size: 80%;
  63 }
  64 .quotelead {
  65     margin-bottom: -1em;
  66     font-size: 80%;
  67 }
  68 .quotechar { display: none; }
  69 .footnote-ref, .footnote-back { text-decoration: none;}
  70 .signature {
  71     color: #999;
  72     font-family: monospace;
  73     white-space: pre;
  74     margin: 1em 0 0 0;
  75     font-size: 80%;
  76 }
  77 table, th, td {
  78     border-collapse: collapse;
  79     border: 1px solid #999;
  80 }
  81 th, td { padding: 0.5em; }
  82 .header {
  83     background: #eee;
  84 }
  85 .even { background: #eee; }
  86 h1, h2, h3, h4, h5, h6 {
  87     color: #666;
  88     background-color: #eee;
  89     padding-left: 0.5em
  90 }
  91 h1 { font-size: 130%; }
  92 h2 { font-size: 120%; }
  93 h3 { font-size: 110%; }
  94 h4 { font-size: 107%; }
  95 h5 { font-size: 103%; }
  96 h6 { font-size: 100%; }
  97 p { padding: 0 0.5em; }
  98 '''
  99
 100 STYLESHEET = os.path.join(os.path.expanduser('~/.mutt'),
 101                           'markdown2html.css')
 102 if os.path.exists(STYLESHEET):
 103     DEFAULT_CSS += open(STYLESHEET).read()
 104
 105 HTML_DOCUMENT = '''<!DOCTYPE html>
 106 <html><head>
 107 <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
 108 <meta charset="utf-8"/>
 109 <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes"/>
 110 </head><body class="email">
 111 {htmlbody}
 112 </body></html>'''
 113
 114
 115 SIGNATURE_HTML = \
 116         '<div class="signature"><span class="leader">-- </span>{sig}</div>'
 117
 118
 119 def _preprocess_signature(sig):
 120     '''
 121     Preprocess the signature before markdown processing.
 122     '''
 123     return sig
 124
 125 def _preprocess_markdown(mdwn):
 126     '''
 127     Preprocess Markdown for handling by the converter.
 128     '''
 129     # convert hard line breaks within paragraphs to 2 trailing spaces, which
 130     # is the markdown way of representing hard line breaks. Note how the
 131     # regexp will not match between paragraphs.
 132     ret = re.sub(r'(\S)\n(\s*\S)', r'\g<1>  \n\g<2>', mdwn, flags=re.MULTILINE)
 133
 134     # Clients like Thunderbird need the leading '>' to be able to properly
 135     # create nested quotes, so we duplicate the symbol, the first instance
 136     # will tell pandoc to create a blockquote, while the second instance will
 137     # be a <span> containing the character, along with a class that causes CSS
 138     # to actually hide it from display. However, this does not work with the
 139     # text-mode HTML2text converters, and so it's left commented for now.
 140     #ret = re.sub(r'\n>', r'  \n>[>]{.quotechar}', ret, flags=re.MULTILINE)
 141
 142     # With the autolink_bare_uris extension, we do not need to put links into
 143     # angle brackets to have them converted, so let's conserve the brackets
 144     # when used around email addresses. Note that this needs a postprocessing
 145     # hack because the pandoc autolink converted includes the ambersand
 146     # (https://github.com/jgm/pandoc/issues/7398).
 147     ret = re.sub(r'<([^@]+@.+\.[^>]+)>', r'&lt;\g<1> -PANDOC_BUG_7398-&gt;', ret)
 148
 149     return ret
 150
 151
 152 def _identify_quotes_for_later(mdwn):
 153     '''
 154     Email quoting such as:
 155
 156     ```
 157     On 1970-01-01, you said:
 158     > The Flat Earth Society has members all around the globe.
 159     ```
 160
 161     isn't really properly handled by Markdown, so let's do our best to
 162     identify the individual elements, and mark them, using a syntax similar to
 163     what pandoc uses already in some cases. As pandoc won't actually use these
 164     data (yet?), we call `self._reformat_quotes` later to use these markers
 165     to slap the appropriate classes on the HTML tags.
 166     '''
 167
 168     def generate_lines_with_context(mdwn):
 169         '''
 170         Iterates the input string line-wise, returning a triplet of
 171         previous, current, and next line, the first and last of which
 172         will be None on the first and last line of the input data
 173         respectively.
 174         '''
 175         prev = cur = nxt = None
 176         lines = iter(mdwn.splitlines())
 177         cur = next(lines)
 178         for nxt in lines:
 179             yield prev, cur, nxt
 180             prev = cur
 181             cur = nxt
 182         yield prev, cur, None
 183
 184     ret = []
 185     for prev, cur, nxt in generate_lines_with_context(mdwn):
 186
 187         # The lead-in to a quote is a single line immediately preceding the
 188         # quote, and ending with ':'. Note that there could be multiple of
 189         # these:
 190         if re.match(r'^.+:\s*$', cur) and nxt.startswith('>'):
 191             ret.append(f'{{.quotelead}}{cur.strip()}')
 192             # pandoc needs an empty line before the blockquote, so
 193             # we enter one for the purpose of HTML rendition:
 194             ret.append('')
 195             continue
 196
 197         # The first blockquote after such a lead-in gets marked as the
 198         # "initial" quote:
 199         elif prev and re.match(r'^.+:\s*$', prev) and cur.startswith('>'):
 200             ret.append(re.sub(r'^(\s*>\s*)+(.+)',
 201                               r'\g<1>{.quoteinitial}\g<2>',
 202                               cur, flags=re.MULTILINE))
 203
 204         # All other occurrences of blockquotes get the "subsequent" marker:
 205         elif cur.startswith('>') and prev and not prev.startswith('>'):
 206             ret.append(re.sub(r'^((?:\s*>\s*)+)(.+)',
 207                               r'\g<1>{.quotesubsequent}\g<2>',
 208                               cur, flags=re.MULTILINE))
 209
 210         else: # pass through everything else.
 211             ret.append(cur)
 212
 213     return '\n'.join(ret)
 214
 215
 216 def _reformat_quotes(html):
 217     '''
 218     Earlier in the pipeline, we marked email quoting, using markers, which we
 219     now need to turn into HTML classes, so that we can use CSS to style them.
 220     '''
 221     ret = html.replace('<p>{.quotelead}', '<p class="quotelead">')
 222     ret = re.sub(r'<blockquote>\n((?:<blockquote>\n)*)<p>(?:\{\.quote(\w+)\})',
 223                  r'<blockquote class="quote \g<2>">\n\g<1><p>', ret, flags=re.MULTILINE)
 224     return ret
 225
 226
 227
 228 def _convert_with_pandoc(mdwn, inputfmt='markdown', outputfmt='html5',
 229                          ext_enabled=None, ext_disabled=None,
 230                          standalone=True, selfcontained=True, title=None):
 231     '''
 232     Invoke pandoc to do the actual conversion of Markdown to HTML5.
 233     '''
 234     if not ext_enabled:
 235         ext_enabled = [ 'backtick_code_blocks',
 236                        'line_blocks',
 237                        'fancy_lists',
 238                        'startnum',
 239                        'definition_lists',
 240                        'example_lists',
 241                        'table_captions',
 242                        'simple_tables',
 243                        'multiline_tables',
 244                        'grid_tables',
 245                        'pipe_tables',
 246                        'all_symbols_escapable',
 247                        'intraword_underscores',
 248                        'strikeout',
 249                        'superscript',
 250                        'subscript',
 251                        'fenced_divs',
 252                        'bracketed_spans',
 253                        'footnotes',
 254                        'inline_notes',
 255                        'emoji',
 256                        'tex_math_double_backslash',
 257                        'autolink_bare_uris'
 258                       ]
 259     if not ext_disabled:
 260         ext_disabled = [ 'tex_math_single_backslash',
 261                          'tex_math_dollars',
 262                          'smart',
 263                          'raw_html'
 264                        ]
 265
 266     enabled = '+'.join(ext_enabled)
 267     disabled = '-'.join(ext_disabled)
 268     inputfmt = f'{inputfmt}+{enabled}-{disabled}'
 269
 270     args = []
 271     if standalone:
 272         args.append('--standalone')
 273     if selfcontained:
 274         args.append('--self-contained')
 275     if title:
 276         args.append(f'--metadata=pagetitle:"{title}"')
 277
 278     return pypandoc.convert_text(mdwn, format=inputfmt, to=outputfmt,
 279                                  extra_args=args)
 280
 281
 282 def _apply_styling(html):
 283     '''
 284     Inline all styles defined and used into the individual HTML tags.
 285     '''
 286     return pynliner.Pynliner().from_string(html).with_cssString(DEFAULT_CSS).run()
 287
 288
 289 def _postprocess_html(html):
 290     '''
 291     Postprocess the generated and styled HTML.
 292     '''
 293
 294     # Preprocessing leaves a sentinel to work around
 295     # https://github.com/jgm/pandoc/issues/7398, and so we need to remove it:
 296     html = html.replace('</a> -PANDOC_BUG_7398-&gt;', '</a>&gt;')
 297     return html
 298
 299
 300 def convert_markdown_to_html(mdwn):
 301     '''
 302     Converts the input Markdown to HTML, handling separately the body, as well
 303     as an optional signature.
 304     '''
 305     parts = re.split(r'^-- $', mdwn, 1, flags=re.MULTILINE)
 306     body = parts[0]
 307     if len(parts) == 2:
 308         sig = parts[1]
 309     else:
 310         sig = None
 311
 312     html=''
 313     if body:
 314         body = _preprocess_markdown(body)
 315         body = _identify_quotes_for_later(body)
 316         html = _convert_with_pandoc(body, standalone=True, selfcontained=True)
 317         html = _reformat_quotes(html)
 318
 319     if sig:
 320         sig = _preprocess_signature(sig)
 321         sig = _preprocess_markdown(sig)
 322         sig = _convert_with_pandoc(sig, standalone=False, selfcontained=False)
 323         sig = SIGNATURE_HTML.format(sig='<br/>'.join(sig.splitlines()))
 324         eob = html.find('</body>')
 325         html = f'{html[:eob]}{sig}\n{html[eob:]}'
 326
 327     html = HTML_DOCUMENT.format(htmlbody=html)
 328     html = _apply_styling(html)
 329     html = _postprocess_html(html)
 330
 331     return html
 332
 333
 334 def main():
 335     '''
 336     Convert text on stdin to HTML, and print it to stdout, like mutt would
 337     expect.
 338     '''
 339     html = convert_markdown_to_html(sys.stdin.read())
 340     if html:
 341         # mutt expects the content type in the first line, so:
 342         print(f'text/html\n\n{html}')
 343
 344
 345 if __name__ == '__main__':
 346     main()