← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python3.4/trusty-proposed

« back to all changes in this revision

Viewing changes to Lib/mailcap.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-11-25 09:44:27 UTC
  • Revision ID: package-import@ubuntu.com-20131125094427-lzxj8ap5w01lmo7f
Tags: upstream-3.4~b1
Import upstream version 3.4~b1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/mailcap.py
 
1
"""Mailcap file handling.  See RFC 1524."""
 
2
 
 
3
import os
 
4
 
 
5
__all__ = ["getcaps","findmatch"]
 
6
 
 
7
# Part 1: top-level interface.
 
8
 
 
9
def getcaps():
 
10
    """Return a dictionary containing the mailcap database.
 
11
 
 
12
    The dictionary maps a MIME type (in all lowercase, e.g. 'text/plain')
 
13
    to a list of dictionaries corresponding to mailcap entries.  The list
 
14
    collects all the entries for that MIME type from all available mailcap
 
15
    files.  Each dictionary contains key-value pairs for that MIME type,
 
16
    where the viewing command is stored with the key "view".
 
17
 
 
18
    """
 
19
    caps = {}
 
20
    for mailcap in listmailcapfiles():
 
21
        try:
 
22
            fp = open(mailcap, 'r')
 
23
        except OSError:
 
24
            continue
 
25
        morecaps = readmailcapfile(fp)
 
26
        fp.close()
 
27
        for key, value in morecaps.items():
 
28
            if not key in caps:
 
29
                caps[key] = value
 
30
            else:
 
31
                caps[key] = caps[key] + value
 
32
    return caps
 
33
 
 
34
def listmailcapfiles():
 
35
    """Return a list of all mailcap files found on the system."""
 
36
    # This is mostly a Unix thing, but we use the OS path separator anyway
 
37
    if 'MAILCAPS' in os.environ:
 
38
        pathstr = os.environ['MAILCAPS']
 
39
        mailcaps = pathstr.split(os.pathsep)
 
40
    else:
 
41
        if 'HOME' in os.environ:
 
42
            home = os.environ['HOME']
 
43
        else:
 
44
            # Don't bother with getpwuid()
 
45
            home = '.' # Last resort
 
46
        mailcaps = [home + '/.mailcap', '/etc/mailcap',
 
47
                '/usr/etc/mailcap', '/usr/local/etc/mailcap']
 
48
    return mailcaps
 
49
 
 
50
 
 
51
# Part 2: the parser.
 
52
 
 
53
def readmailcapfile(fp):
 
54
    """Read a mailcap file and return a dictionary keyed by MIME type.
 
55
 
 
56
    Each MIME type is mapped to an entry consisting of a list of
 
57
    dictionaries; the list will contain more than one such dictionary
 
58
    if a given MIME type appears more than once in the mailcap file.
 
59
    Each dictionary contains key-value pairs for that MIME type, where
 
60
    the viewing command is stored with the key "view".
 
61
    """
 
62
    caps = {}
 
63
    while 1:
 
64
        line = fp.readline()
 
65
        if not line: break
 
66
        # Ignore comments and blank lines
 
67
        if line[0] == '#' or line.strip() == '':
 
68
            continue
 
69
        nextline = line
 
70
        # Join continuation lines
 
71
        while nextline[-2:] == '\\\n':
 
72
            nextline = fp.readline()
 
73
            if not nextline: nextline = '\n'
 
74
            line = line[:-2] + nextline
 
75
        # Parse the line
 
76
        key, fields = parseline(line)
 
77
        if not (key and fields):
 
78
            continue
 
79
        # Normalize the key
 
80
        types = key.split('/')
 
81
        for j in range(len(types)):
 
82
            types[j] = types[j].strip()
 
83
        key = '/'.join(types).lower()
 
84
        # Update the database
 
85
        if key in caps:
 
86
            caps[key].append(fields)
 
87
        else:
 
88
            caps[key] = [fields]
 
89
    return caps
 
90
 
 
91
def parseline(line):
 
92
    """Parse one entry in a mailcap file and return a dictionary.
 
93
 
 
94
    The viewing command is stored as the value with the key "view",
 
95
    and the rest of the fields produce key-value pairs in the dict.
 
96
    """
 
97
    fields = []
 
98
    i, n = 0, len(line)
 
99
    while i < n:
 
100
        field, i = parsefield(line, i, n)
 
101
        fields.append(field)
 
102
        i = i+1 # Skip semicolon
 
103
    if len(fields) < 2:
 
104
        return None, None
 
105
    key, view, rest = fields[0], fields[1], fields[2:]
 
106
    fields = {'view': view}
 
107
    for field in rest:
 
108
        i = field.find('=')
 
109
        if i < 0:
 
110
            fkey = field
 
111
            fvalue = ""
 
112
        else:
 
113
            fkey = field[:i].strip()
 
114
            fvalue = field[i+1:].strip()
 
115
        if fkey in fields:
 
116
            # Ignore it
 
117
            pass
 
118
        else:
 
119
            fields[fkey] = fvalue
 
120
    return key, fields
 
121
 
 
122
def parsefield(line, i, n):
 
123
    """Separate one key-value pair in a mailcap entry."""
 
124
    start = i
 
125
    while i < n:
 
126
        c = line[i]
 
127
        if c == ';':
 
128
            break
 
129
        elif c == '\\':
 
130
            i = i+2
 
131
        else:
 
132
            i = i+1
 
133
    return line[start:i].strip(), i
 
134
 
 
135
 
 
136
# Part 3: using the database.
 
137
 
 
138
def findmatch(caps, MIMEtype, key='view', filename="/dev/null", plist=[]):
 
139
    """Find a match for a mailcap entry.
 
140
 
 
141
    Return a tuple containing the command line, and the mailcap entry
 
142
    used; (None, None) if no match is found.  This may invoke the
 
143
    'test' command of several matching entries before deciding which
 
144
    entry to use.
 
145
 
 
146
    """
 
147
    entries = lookup(caps, MIMEtype, key)
 
148
    # XXX This code should somehow check for the needsterminal flag.
 
149
    for e in entries:
 
150
        if 'test' in e:
 
151
            test = subst(e['test'], filename, plist)
 
152
            if test and os.system(test) != 0:
 
153
                continue
 
154
        command = subst(e[key], MIMEtype, filename, plist)
 
155
        return command, e
 
156
    return None, None
 
157
 
 
158
def lookup(caps, MIMEtype, key=None):
 
159
    entries = []
 
160
    if MIMEtype in caps:
 
161
        entries = entries + caps[MIMEtype]
 
162
    MIMEtypes = MIMEtype.split('/')
 
163
    MIMEtype = MIMEtypes[0] + '/*'
 
164
    if MIMEtype in caps:
 
165
        entries = entries + caps[MIMEtype]
 
166
    if key is not None:
 
167
        entries = [e for e in entries if key in e]
 
168
    return entries
 
169
 
 
170
def subst(field, MIMEtype, filename, plist=[]):
 
171
    # XXX Actually, this is Unix-specific
 
172
    res = ''
 
173
    i, n = 0, len(field)
 
174
    while i < n:
 
175
        c = field[i]; i = i+1
 
176
        if c != '%':
 
177
            if c == '\\':
 
178
                c = field[i:i+1]; i = i+1
 
179
            res = res + c
 
180
        else:
 
181
            c = field[i]; i = i+1
 
182
            if c == '%':
 
183
                res = res + c
 
184
            elif c == 's':
 
185
                res = res + filename
 
186
            elif c == 't':
 
187
                res = res + MIMEtype
 
188
            elif c == '{':
 
189
                start = i
 
190
                while i < n and field[i] != '}':
 
191
                    i = i+1
 
192
                name = field[start:i]
 
193
                i = i+1
 
194
                res = res + findparam(name, plist)
 
195
            # XXX To do:
 
196
            # %n == number of parts if type is multipart/*
 
197
            # %F == list of alternating type and filename for parts
 
198
            else:
 
199
                res = res + '%' + c
 
200
    return res
 
201
 
 
202
def findparam(name, plist):
 
203
    name = name.lower() + '='
 
204
    n = len(name)
 
205
    for p in plist:
 
206
        if p[:n].lower() == name:
 
207
            return p[n:]
 
208
    return ''
 
209
 
 
210
 
 
211
# Part 4: test program.
 
212
 
 
213
def test():
 
214
    import sys
 
215
    caps = getcaps()
 
216
    if not sys.argv[1:]:
 
217
        show(caps)
 
218
        return
 
219
    for i in range(1, len(sys.argv), 2):
 
220
        args = sys.argv[i:i+2]
 
221
        if len(args) < 2:
 
222
            print("usage: mailcap [MIMEtype file] ...")
 
223
            return
 
224
        MIMEtype = args[0]
 
225
        file = args[1]
 
226
        command, e = findmatch(caps, MIMEtype, 'view', file)
 
227
        if not command:
 
228
            print("No viewer found for", type)
 
229
        else:
 
230
            print("Executing:", command)
 
231
            sts = os.system(command)
 
232
            if sts:
 
233
                print("Exit status:", sts)
 
234
 
 
235
def show(caps):
 
236
    print("Mailcap files:")
 
237
    for fn in listmailcapfiles(): print("\t" + fn)
 
238
    print()
 
239
    if not caps: caps = getcaps()
 
240
    print("Mailcap entries:")
 
241
    print()
 
242
    ckeys = sorted(caps)
 
243
    for type in ckeys:
 
244
        print(type)
 
245
        entries = caps[type]
 
246
        for e in entries:
 
247
            keys = sorted(e)
 
248
            for k in keys:
 
249
                print("  %-15s" % k, e[k])
 
250
            print()
 
251
 
 
252
if __name__ == '__main__':
 
253
    test()