म्यूटेशन का उपयोग करके मार्कडाउन में लिखा गया ईमेल भेजें


21

कभी-कभी मुझे Google-समूह इनलाइन पर कोड का एक टुकड़ा भेजने की आवश्यकता होती है। पाठ यहाँ मदद नहीं करता है; मैं इसे मार्कडाउन में टाइप कर सकता हूं, इसे html (pandoc आदि का उपयोग करके) में रूपांतरित कर सकता हूं text/html

यहां एक अच्छा समाधान उपलब्ध है लेकिन यह sendmailईमेल भेजने के लिए बाहरी कार्यक्रम का उपयोग करता है । मैं ऐसे mutt का उपयोग कर रहा हूं जिसमें IMAP पर ईमेल भेजने की क्षमता है।


1
कमांड लाइन मार्कडाउन फॉर्मैटर से सिर्फ पाइप आउटपुट क्यों नहीं sendmail?
Naftuli Kay

हम्म .. साझा कंप्यूटर! बाहरी प्रेषक के लिए पासवर्ड संग्रहीत नहीं करना चाहते।
दिलावर

क्या कोई उदाहरण है जो हम देख सकते हैं कि आपके वर्तमान परिणाम Google-समूहों पर क्या दिखते हैं?
स्लम

इसके अलावा, आप चीजों को मार्कडाउन में टाइप करना चाहते हैं, लेकिन क्या उन्हें आपके ईमेल में संलग्न करने से पहले रेंडर किया गया है, है ना?
स्लम

यह लगता है कि आप क्या पूछ रहे हैं, लेकिन संशोधित करने की आवश्यकता हो सकती है: dgl.cx/2009/03/html-mail-with-mutt-use-markdown । इसके अलावा markdownmail.py आप उपयोग कर सकते हैं की तरह लग रहा था।
स्लम

जवाबों:


28

संदेश भेजने के बाद, लेकिन भेजने से पहले आपके पास बहुत सारे विकल्प उपलब्ध हैं। ?उन्हें देखने के लिए दबाएँ ।

कुछ है कि यहाँ मदद कर सकते हैं:

  • F बाहरी प्रोसेसर के माध्यम से अनुलग्नक को फ़िल्टर करने के लिए
    • pandoc -s -f markdown -t htmlHTML में बदलने के लिए उपयोग करें
  • ^T अनुलग्नक MIME प्रकार को संपादित करने के लिए
    • से बदलें text/plainकरने के लिए text/html

अब एक मैक्रो जो एक चरण में सब कुछ करेगा। इसे अपने में जोड़ें .muttrc:

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

इस मैक्रो का उपयोग करने के बाद, आपने अपना संदेश लिखना समाप्त कर लिया है, लेकिन भेजने से पहले, अपने मार्कट स्वरूपित संदेश को HTML में बदलने के लिए Escफिर दबाएँ 5

आप स्वाभाविक रूप से इस मैक्रो को अनुकूलित कर सकते हैं जैसा कि आप फिट देखते हैं। मठ में पहले से निर्मित कई महत्वपूर्ण बाइंडिंग हैं, इसलिए आप जिस भी महत्वपूर्ण अनुक्रम को बांधना चुनते हैं, यह सुनिश्चित करें कि यह किसी और चीज़ को अधिलेखित नहीं करता (या यह ऐसा कुछ है जिसे आप बिना जी सकते हैं)।


बाहरी आदेशों को चलाने पर विकल्प set wait_key=noMutt के Press any key to continue...संकेत को दबा देता है। अगर wait_keyहै yesकि आप प्रेस करना होगा (जो डिफ़ॉल्ट है) Esc, तो 5फिर किसी भी अन्य प्रमुख जारी रखने के लिए।


1
यह एक बहुत ही सुंदर समाधान है! +1
sinisterstuf

5
यह अच्छा है, लेकिन इसे मुख्य दोष मिला है। यह ईमेल के प्लेनटेक्स्ट भाग को समाप्त कर देता है जो इसे क्लाइंट ... म्यूट;) में पढ़ने के लिए चूसता है। HTML ईमेल में प्लेटेक्स्ट और HTML घटक होना चाहिए। कच्चा मार्कटेशन प्लेनटेक्स्ट होना चाहिए, परिवर्तित HTML होना चाहिए।
मासुकोमी

1
@Masukomi के साथ सहमत, सामान्य रूप से ईमेल क्लाइंट दोनों ईमेल के HTML और पाठ संस्करण भेजते हैं। एक मैक्रो होना अच्छा होगा जो html संस्करण जोड़ता है और मूल को टेक्स्ट / प्लेन के रूप में छोड़ देता है।
काली मिर्च_चिको



1

मेल भेजने के लिए Sendmail अक्सर लचीला Enogh नहीं है।

मैं लचीली SMTP के लिए विशेष खातों पर म्यूट के साथ msmtp का उपयोग करता हूं।

परिवर्तन के साथ इसका उपयोग करने के लिए:

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

तथा

# ~/.msmtprc  
defaults
tls off
logfile ~/.msmtp.log  
account default   
host your.smtp.host  
port 25  
from your-user-name@your-host.com  
auth off  
user username  
password password  

0

मैं यह करने में सक्षम था। मैं अपने समाधान के बारे में पूरी तरह से खुश नहीं हूं लेकिन यह काफी सभ्य है। बेहतर समाधान प्रदान करने के लिए किसी और की प्रतीक्षा कर रहा है।

प्रक्रिया निम्नलिखित है। मार्कडाउन को html में बदलें और इसे संदेश में संलग्न करें। इस आसक्ति को inlineआसक्ति में बदलो। लेकिन अब मेरे पास दो अटैचमेंट हैं, पहला मार्कडाउन में है और दूसरा html है। खाली स्ट्रिंग के साथ मार्कडाउन कंटेंट को बदलें ताकि केवल html भेजा जाए।

मैंने ~/.muttrcफाइल करने के लिए निम्न लाइन जोड़ी ।

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

यहां email-editorप्रश्न में पोस्ट किए गए लिंक से उधार लिया गया है।

#!/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

और मुख्य अजगर फ़ाइल जिसे कहा जाता है, निम्नलिखित है। यह प्रश्न में लिंक से पर्ल स्क्रिप्ट से प्रेरित है।

#!/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)

यह एक और अजगर फ़ाइल पर निर्भर करता है जिसे कहा जाता है formatter.pyजो pandocमेरे मेल को प्रारूपित करने के लिए उपयोग करता है लेकिन अगर pandocयह उपलब्ध नहीं है तो यह python-markdown2पैकेज का उपयोग कर सकता है। यह स्क्रिप्ट निम्नलिखित है।

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

ये फाइलें भी यहां उपलब्ध हैं https://github.com/dilawar/mutt


0

मैं किसी भी प्रारूप का उपयोग करके ईमेल भेज सकता हूं neomutt। मैं सिर्फ Emacs(org- मोड) का उपयोग करता हूं , इसके बजाय vim। हालाँकि, मैं एक vimउपयोगकर्ता भी हूँ । लेकिन, मैं ज्यादातर Emacsबुराई-मोड का उपयोग करता हूं ।

अपने में .muttrcमैंने इसके emacsबजाय संपादक होने की स्थापना की है vim। नया ईमेल लिखते समय, neomuttआग लग जाती emacsहै। फिर मैं "ऑर्ग-मोड" कहता हूं, संदेश लिखता हूं, और जो भी प्रारूप मैं चाहता हूं, उसे निर्यात करें।

मैं PDFप्रारूप में निर्यात कर सकता हूं । फिर मैं इसे सहेजता हूं और PDFफ़ाइल को अपने में संलग्न करता हूं /tmp। उसके बाद मैं जिसे भी भेज सकूँ।

यदि मुझे htmlप्रारूप चाहिए, तो मैं उसी तरह निर्यात करता हूं और ईमेल भेजने से पहले मैं स्वचालित रूप से आउटपुट देख सकता हूं।

इसके अलावा, ऑर्ग-मोड में कई अन्य निर्यात प्रारूप हैं। बस, जो आप चाहते हैं उसे चुनें। अन्य लोगों को कोड भेजने के लिए, आप जो भी भाषा चाहते हैं, उसमें स्रोत कोड जोड़ें। ऑर्ग-विकी में सब कुछ समझाया गया है ।


0

आप ई-मेल भी भेज सकते हैं, multipart/alternativeजिसमें दोनों शामिल हैं text/plainऔर text/html

आवश्यकताएँ: pandoc

मूल रूप से यह मार्कडाउन मैसेज प्लेटेक्स्ट और एचटीएमएल 5 से बनता है। उन हिस्सों से अटैचमेंट बनाता है, उन्हें इनलाइन अटैचमेंट के रूप में चिह्नित करता है, सही माइम प्रकार सेट करता है और उन्हें उत्परिवर्तित संदेश में संयोजित करता है।

कंपोज मेनू में इस मैक्रो को चलाने के बाद किसी अन्य अटैचमेंट को जोड़ा जाना चाहिए। वैकल्पिक रूप से हस्ताक्षर / एन्क्रिप्टिंग संदेश को अंतिम चरण के रूप में किया जाना चाहिए

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" 
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.