Wyślij e-mail napisany w przecenie za pomocą mutta

21

Czasami muszę wysłać fragment kodu na stronie Google-Group. Tekst tu nie pomaga; Mogę wpisać to w Markdown, przekonwertować na HTML (używając pandoc itp.), Dołączyć do mutt as text/htmli wysłać.

Jest tutaj jedno dobre rozwiązanie , ale używa zewnętrznego sendmailprogramu do wysyłania wiadomości e-mail. Korzystam z mutta, który sam ma możliwości wysyłania wiadomości e-mail ~~przez IMAP~~ .

scripting mutt Dilawar
źródło

1

Dlaczego nie tylko potokować danych wyjściowych z formatera Markdown z wiersza poleceń sendmail?

Naftuli Kay

Hmm .. wspólny komputer! Nie chcę przechowywać hasła do zewnętrznego sendmaila.

Dilawar

Czy istnieją przykłady, które możemy zobaczyć, jak wyglądają Twoje obecne wyniki w grupach google?

slm

Chcesz też wpisywać rzeczy w przecenach, ale czy mają być renderowane przed dołączeniem ich do wiadomości e-mail, prawda?

slm

To brzmi jak to, o co prosisz, ale może wymagać modyfikacji: dgl.cx/2009/03/html-mail-with-mutt-using-markdown . Markdownmail.py również brzmiał jak coś, czego można użyć.

slm

28

Po redagowaniu wiadomości, ale przed wysłaniem masz do dyspozycji wiele opcji. Naciśnij, ?aby je wyświetlić.

Niektóre, które mogą pomóc tutaj:

F aby przefiltrować załącznik przez zewnętrzny procesor
- Służy pandoc -s -f markdown -t htmldo konwersji na HTML
^T aby edytować typ MIME załącznika
- Zmień z text/plainna text/html.

Teraz makro, które zrobi wszystko w jednym kroku. Dodaj to do .muttrc:

macro compose \e5 "F pandoc -s -f markdown -t html \ny^T^Utext/html; charset=us-ascii\n"
set wait_key=no

Aby użyć tego makra, po zakończeniu redagowania wiadomości, ale przed wysłaniem, naciśnij, Esca następnie, 5aby przekonwertować wiadomość sformatowaną za pomocą znaczników na HTML.

Możesz oczywiście dostosować to makro według własnego uznania. Mutt ma już wbudowane wiele powiązań klawiszy, więc niezależnie od sekwencji klawiszy, z którymi chcesz się powiązać, upewnij się, że nie zastąpi on niczego innego (lub jest to coś, bez czego możesz żyć).

Ta opcja set wait_key=nopomija Press any key to continue...monit Mutt, gdy uruchamiane są polecenia zewnętrzne. Jeśli wait_keyjest yes(co jest ustawieniem domyślnym), będziesz musiał nacisnąć Esc, a 5następnie dowolny inny klawisz, aby kontynuować.

bahamat
źródło

1

To naprawdę eleganckie rozwiązanie! +1

sinisterstuf,

5

to miłe, ale ma wadę podstawową. eliminuje część zwykłego tekstu wiadomości e-mail, co powoduje, że czytanie w klientach takich jak ... mutt jest do kitu;) Wiadomości e-mail w formacie HTML powinny zawierać komponent tekstowy i HTML. surowe oznaczanie powinno być zwykłym tekstem, a przekonwertowany powinien być HTML.

masukomi

1

Zgadzam się z @masukomi, klienci poczty e-mail wysyłają wiadomości e-mail w wersji HTML i tekstowej. Byłoby miło mieć makro, które dodaje wersję HTML i pozostawia oryginał jako tekst / zwykły.

pepper_chico

2

W końcu zbudowałem własną konfigurację dla tego nosubstance.me/post/mutt-secret-sauce

pepper_chico

1

@Rastapopoulos tak: github.com/oblitum/dotfiles/issues/3#issuecomment-437954693

pepper_chico

1

Sendmail często nie jest elastycznym narzędziem do wysyłania wiadomości e-mail.

Używam msmtp razem z mutt na poszczególnych kontach dla elastycznego SMTP.

Aby użyć go ze zmianą mutt:

# ~/.muttrc  
set sendmail="/usr/bin/msmtp -a default"

i

# ~/.msmtprc  
defaults
tls off
logfile ~/.msmtp.log  
account default   
host your.smtp.host  
port 25  
from [email protected]  
auth off  
user username  
password password

źródło

0

Byłem w stanie to zrobić. Nie jestem do końca zadowolony z mojego rozwiązania, ale jest wystarczająco przyzwoite. Czekam, aż ktoś inny zaproponuje lepsze rozwiązanie.

Proces jest następujący. Konwertuj znaczniki na HTML i dołącz je do wiadomości. Zamień ten załącznik na inlinezałącznik. Ale teraz mam dwa załączniki, pierwszy jest w przecenie, a drugi to html. Zamień treść przeceny na pusty ciąg, aby wysyłany był tylko HTML.

Dodałem następujący wiersz do ~/.muttrcpliku.

macro compose B ":set editor=text2mime-markdown.py<enter>E:set editor=email-editor<enter>Da/tmp/html-markdown-alternative.html<enter>^Du"

Oto, email-editorco zapożyczono z zamieszczonego linku.

#!/bin/sh
if grep -q In-Reply-To $1; then
  # Jump to first line of message
  exec vim -c 'norm }j' $1
else
  # Enter insert mode on the To: line
  exec vim  $1
fi

Główny plik Pythona, który się nazywa, jest następujący. Jest to inspirowane skryptem Perla z odnośnego linku.

#!/usr/bin/env python
import os
import sys
from formatter import *
version = "0.1"

file = sys.argv[1]
new_file = "/tmp/html-markdown-alternative.html"
with open(file, "r") as f:
    text = f.read()

lines = text.split('\n')
header = []
body = []
headerStart = True
for l in lines:
    if headerStart:
        m = re.search(r'^[\w\-]+\:', l)
        if m:
            header.append(l)
        else:
            headerStart = False
            body.append(l)
    else:
        body.append(l)

header = '\n'.join(header)
body = '\n'.join(body)

htmlBody = markdownToHtml(body);

html = []
html.append('<html>')
html.append('<head>')
html.append('<meta name=\"generator\" content=\"text2mime-markdown{}\">'.format(version))
html.append('<style>')
html.append("code { font-family: 'Andale Mono', 'Lucida Console', \
        'Bitstream Vera Sans Mono', 'Courier New', monospace; }")
html.append('pre { border-left: 20px solid #ddd; margin-left: 10px; \
        padding-left: 5px; }')
html.append('</style>')
html.append('</head>')
html.append('<body>')
html.append('{0}'.format(body))
html.append('</body>')
html.append('</html>')
html = '\n'.join(html)

with open(new_file, "w") as newF:
    newF.write(html)

with open(file, 'w') as f:
    f.write(header)

Zależy to od jeszcze jednego wywołanego pliku Pythona, formatter.pyktóry używa pandocdo formatowania mojej poczty, ale jeśli pandocnie jest dostępny, może użyć python-markdown2pakietu. Ten skrypt jest następujący.

import subprocess
import re
import os 
import sys
import html2text 
import collections

# check if pandoc exists
panDoc = True
try:
    subprocess.call(["pandoc", '--version']
            , stdout=subprocess.PIPE
            , stdin=subprocess.PIPE
            )
except OSError:
    panDoc = False

if not panDoc:
    import text.html2text as html2text
    import markdown 

def decodeText(text):
    return text.decode('utf-8')

def markdownToHtml(content, convertor='pandoc'):
    global panDoc
    if panDoc:
        cmd = ["pandoc", "-f", "markdown", "-t", "html"]
        p = subprocess.Popen(cmd
                , stdin = subprocess.PIPE
                , stdout = subprocess.PIPE
                )
        p.stdin.write(content)
        content = p.communicate()[0]
        return decodeText(content)
    else:
        return markdown.markdown(decodeText(content))


def htmlToMarkdown(content, convertor='pandoc'):
    global panDoc
    if panDoc and convertor == 'pandoc':
        cmd = ["pandoc", "-t", "markdown", "-f", "html"]
        p = subprocess.Popen(cmd
                , stdin = subprocess.PIPE
                , stdout = subprocess.PIPE
                )
        p.stdin.write(content)
        content = p.communicate()[0]
        return decodeText(content)
    # Use markdown package to convert markdown to html
    else:
        h = html2text.HTML2Text()
        content = h.handle(decodeText(content))
        return content

def titleToBlogDir(title):
    if title is None:
        return ''
    if len(title.strip()) == 0:
        return ''
    blogDir = title.replace(" ","_").replace(':', '-').replace('(', '')
    blogDir = blogDir.replace('/', '').replace('\\', '').replace('`', '')
    blogDir = blogDir.replace(')', '').replace("'", '').replace('"', '')
    return blogDir

def titleToFilePath(title, blogDir):
    if len(blogDir.strip()) == 0:
        return ''
    fileName = os.path.join(blogDir, titleToBlogDir(title))
    return fileName


def htmlToHtml(html):
    return decodeText(html)

def metadataDict(txt):
    mdict = collections.defaultdict(list)
    md = getMetadata(txt)
    for c in ["title", 'type', "layout", "status", "id", "published", "category", "tag"]:
        pat = re.compile(r'{0}\:\s*(?P<name>.+)'.format(c), re.IGNORECASE)
        m = pat.findall(txt)
        for i in m:
            mdict[c].append(i)
    return mdict

def getMetadata(txt):
   """
   Get metadata out of a txt
   """
   if not "---" in txt:
       print txt
       sys.exit(1)

   pat = re.compile(r'\-\-\-+(?P<metadata>.+?)\-\-\-+', re.DOTALL)
   m = pat.search(txt)
   if m:
       return m.group('metadata')
   else:
       sys.exit(0)

def getContent(txt):
    """ 
    Return only text of the post.
    """
    pat = re.compile(r'\-\-\-+(?P<metadata>.+?)\-\-\-+', re.DOTALL)
    return re.sub(pat, "", txt)

def readInputFile(fileName):
    """
    read file and return its format. html or markdown
    """
    assert fileName
    if not os.path.exists(fileName):
        raise IOError, "File %s does not exists" % fileName

    # Check the fmt of file.
    fmt = os.path.splitext(fileName)[1].lower()
    if fmt in ["htm", "html", "xhtml"]:
        fmt = "html"
    elif fmt in ["md", "markdown"]:
        fmt = "markdown"
    else:
        fmt = "markdown"
    txt = open(fileName, 'r').read()   
    return (fmt, txt)

def formatContent(txt, fmt):
    """
    Format the content as per fmt.
    """
    content = getContent(txt)
    if fmt == "html":
        content = htmlToHtml(content)
    elif fmt == "markdown":
        content = markdownToHtml(content)
    else:
        content = markdownToHtml(content)
    return content

Te pliki są również dostępne tutaj https://github.com/dilawar/mutt

Dilawar
źródło

0

Mogę wysyłać wiadomości e-mail w dowolnym formacie za pomocą neomutt. Po prostu używam Emacs(org-mode) zamiast vim. Chociaż jestem także vimużytkownikiem. Ale najczęściej używam Emacsw trybie zła.

W moim .muttrcustawiłem edytor emacszamiast vim. Pisząc nowy e-mail, neomutturuchamia emacssię. Następnie wywołuję „tryb org”, piszę wiadomość i eksportuję do dowolnego formatu, jaki chcę.

Mogę eksportować do PDFformatu. Następnie zapisuję go i dołączam PDFplik do swojego /tmp. Następnie mogę wysłać komukolwiek.

Jeśli chcę htmlformat, eksportuję go w ten sam sposób i automatycznie widzę wynik przed wysłaniem wiadomości e-mail.

Oprócz tego istnieje wiele innych formatów eksportu w trybie org. Po prostu wybierz, co chcesz. Aby wysłać kod innym osobom, po prostu dodaj kod źródłowy do dowolnego języka. Wszystko zostało wyjaśnione na org-wiki .

Achylles
źródło

0

Możesz wysyłać wiadomości e-mail również jako multipart/alternativezawierające je text/plaini text/html.

Wymagania: pandoc

Zasadniczo tworzy z tekstu wiadomości tekstowej i html5. Tworzy załączniki z tych części, oznacza je jako załączniki śródliniowe, ustaw prawidłowy typ MIME i połącz je w wiadomość mutlipart.

Wszelkie inne załączniki powinny zostać dodane po uruchomieniu tego makra w menu tworzenia. Opcjonalnie podpisywanie / szyfrowanie wiadomości powinno być wykonane jako ostatni krok

macro compose ,m \
"<enter-command>set pipe_decode<enter>\
<pipe-message>pandoc -f gfm -t plain -o /tmp/msg.txt<enter>\
<pipe-message>pandoc -s -f gfm -t html5 -o /tmp/msg.html<enter>\
<enter-command>unset pipe_decode<enter>a^U/tmp/msg.txt\n^Da^U/tmp/msg.html\n^D^T^Utext/html; charset=utf-8\n=DTT&d^U\n" \
"Convert markdown gfm to HTML and plain"

Jakub Jindra
źródło

Wyślij e-mail napisany w przecenie za pomocą mutta

Odpowiedzi: