home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / mailcap.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  7.1 KB  |  293 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Mailcap file handling.  See RFC 1524.'''
  5. import os
  6. __all__ = [
  7.     'getcaps',
  8.     'findmatch']
  9.  
  10. def getcaps():
  11.     '''Return a dictionary containing the mailcap database.
  12.  
  13.     The dictionary maps a MIME type (in all lowercase, e.g. \'text/plain\')
  14.     to a list of dictionaries corresponding to mailcap entries.  The list
  15.     collects all the entries for that MIME type from all available mailcap
  16.     files.  Each dictionary contains key-value pairs for that MIME type,
  17.     where the viewing command is stored with the key "view".
  18.  
  19.     '''
  20.     caps = { }
  21.     for mailcap in listmailcapfiles():
  22.         
  23.         try:
  24.             fp = open(mailcap, 'r')
  25.         except IOError:
  26.             continue
  27.  
  28.         morecaps = readmailcapfile(fp)
  29.         fp.close()
  30.         for key, value in morecaps.iteritems():
  31.             if key not in caps:
  32.                 caps[key] = value
  33.                 continue
  34.             caps[key] = caps[key] + value
  35.         
  36.     
  37.     return caps
  38.  
  39.  
  40. def listmailcapfiles():
  41.     '''Return a list of all mailcap files found on the system.'''
  42.     if 'MAILCAPS' in os.environ:
  43.         str = os.environ['MAILCAPS']
  44.         mailcaps = str.split(':')
  45.     elif 'HOME' in os.environ:
  46.         home = os.environ['HOME']
  47.     else:
  48.         home = '.'
  49.     mailcaps = [
  50.         home + '/.mailcap',
  51.         '/etc/mailcap',
  52.         '/usr/etc/mailcap',
  53.         '/usr/local/etc/mailcap']
  54.     return mailcaps
  55.  
  56.  
  57. def readmailcapfile(fp):
  58.     '''Read a mailcap file and return a dictionary keyed by MIME type.
  59.  
  60.     Each MIME type is mapped to an entry consisting of a list of
  61.     dictionaries; the list will contain more than one such dictionary
  62.     if a given MIME type appears more than once in the mailcap file.
  63.     Each dictionary contains key-value pairs for that MIME type, where
  64.     the viewing command is stored with the key "view".
  65.     '''
  66.     caps = { }
  67.     while None:
  68.         line = fp.readline()
  69.         if not line:
  70.             break
  71.         
  72.         if line[0] == '#' or line.strip() == '':
  73.             continue
  74.         
  75.         nextline = line
  76.         while nextline[-2:] == '\\\n':
  77.             nextline = fp.readline()
  78.             if not nextline:
  79.                 nextline = '\n'
  80.             
  81.             line = line[:-2] + nextline
  82.         (key, fields) = parseline(line)
  83.         if not key and fields:
  84.             continue
  85.         
  86.         types = key.split('/')
  87.         for j in range(len(types)):
  88.             types[j] = types[j].strip()
  89.         
  90.         key = '/'.join(types).lower()
  91.         if key in caps:
  92.             caps[key].append(fields)
  93.             continue
  94.         caps[key] = [
  95.             fields]
  96.     return caps
  97.  
  98.  
  99. def parseline(line):
  100.     '''Parse one entry in a mailcap file and return a dictionary.
  101.  
  102.     The viewing command is stored as the value with the key "view",
  103.     and the rest of the fields produce key-value pairs in the dict.
  104.     '''
  105.     fields = []
  106.     i = 0
  107.     n = len(line)
  108.     while i < n:
  109.         (field, i) = parsefield(line, i, n)
  110.         fields.append(field)
  111.         i = i + 1
  112.     if len(fields) < 2:
  113.         return (None, None)
  114.     
  115.     key = fields[0]
  116.     view = fields[1]
  117.     rest = fields[2:]
  118.     fields = {
  119.         'view': view }
  120.     for field in rest:
  121.         i = field.find('=')
  122.         if i < 0:
  123.             fkey = field
  124.             fvalue = ''
  125.         else:
  126.             fkey = field[:i].strip()
  127.             fvalue = field[i + 1:].strip()
  128.         if fkey in fields:
  129.             continue
  130.         fields[fkey] = fvalue
  131.     
  132.     return (key, fields)
  133.  
  134.  
  135. def parsefield(line, i, n):
  136.     '''Separate one key-value pair in a mailcap entry.'''
  137.     start = i
  138.     while i < n:
  139.         c = line[i]
  140.         if c == ';':
  141.             break
  142.             continue
  143.         if c == '\\':
  144.             i = i + 2
  145.             continue
  146.         i = i + 1
  147.     return (line[start:i].strip(), i)
  148.  
  149.  
  150. def findmatch(caps, MIMEtype, key = 'view', filename = '/dev/null', plist = []):
  151.     """Find a match for a mailcap entry.
  152.  
  153.     Return a tuple containing the command line, and the mailcap entry
  154.     used; (None, None) if no match is found.  This may invoke the
  155.     'test' command of several matching entries before deciding which
  156.     entry to use.
  157.  
  158.     """
  159.     entries = lookup(caps, MIMEtype, key)
  160.     for e in entries:
  161.         if 'test' in e:
  162.             test = subst(e['test'], filename, plist)
  163.             if test and os.system(test) != 0:
  164.                 continue
  165.             
  166.         
  167.         command = subst(e[key], MIMEtype, filename, plist)
  168.         return (command, e)
  169.     
  170.     return (None, None)
  171.  
  172.  
  173. def lookup(caps, MIMEtype, key = None):
  174.     entries = []
  175.     if MIMEtype in caps:
  176.         entries = entries + caps[MIMEtype]
  177.     
  178.     MIMEtypes = MIMEtype.split('/')
  179.     MIMEtype = MIMEtypes[0] + '/*'
  180.     if MIMEtype in caps:
  181.         entries = entries + caps[MIMEtype]
  182.     
  183.     if key is not None:
  184.         entries = filter((lambda e, key = key: key in e), entries)
  185.     
  186.     return entries
  187.  
  188.  
  189. def subst(field, MIMEtype, filename, plist = []):
  190.     res = ''
  191.     i = 0
  192.     n = len(field)
  193.     while i < n:
  194.         c = field[i]
  195.         i = i + 1
  196.         if c != '%':
  197.             if c == '\\':
  198.                 c = field[i:i + 1]
  199.                 i = i + 1
  200.             
  201.             res = res + c
  202.             continue
  203.         c = field[i]
  204.         i = i + 1
  205.         if c == '%':
  206.             res = res + c
  207.             continue
  208.         if c == 's':
  209.             res = res + filename
  210.             continue
  211.         if c == 't':
  212.             res = res + MIMEtype
  213.             continue
  214.         if c == '{':
  215.             start = i
  216.             while i < n and field[i] != '}':
  217.                 i = i + 1
  218.             name = field[start:i]
  219.             i = i + 1
  220.             res = res + findparam(name, plist)
  221.             continue
  222.         res = res + '%' + c
  223.     return res
  224.  
  225.  
  226. def findparam(name, plist):
  227.     name = name.lower() + '='
  228.     n = len(name)
  229.     for p in plist:
  230.         if p[:n].lower() == name:
  231.             return p[n:]
  232.             continue
  233.     
  234.     return ''
  235.  
  236.  
  237. def test():
  238.     import sys
  239.     caps = getcaps()
  240.     if not sys.argv[1:]:
  241.         show(caps)
  242.         return None
  243.     
  244.     for i in range(1, len(sys.argv), 2):
  245.         args = sys.argv[i:i + 2]
  246.         if len(args) < 2:
  247.             print 'usage: mailcap [MIMEtype file] ...'
  248.             return None
  249.         
  250.         MIMEtype = args[0]
  251.         file = args[1]
  252.         (command, e) = findmatch(caps, MIMEtype, 'view', file)
  253.         if not command:
  254.             print 'No viewer found for', type
  255.             continue
  256.         print 'Executing:', command
  257.         sts = os.system(command)
  258.         if sts:
  259.             print 'Exit status:', sts
  260.             continue
  261.     
  262.  
  263.  
  264. def show(caps):
  265.     print 'Mailcap files:'
  266.     for fn in listmailcapfiles():
  267.         print '\t' + fn
  268.     
  269.     print 
  270.     if not caps:
  271.         caps = getcaps()
  272.     
  273.     print 'Mailcap entries:'
  274.     print 
  275.     ckeys = caps.keys()
  276.     ckeys.sort()
  277.     for type in ckeys:
  278.         print type
  279.         entries = caps[type]
  280.         for e in entries:
  281.             keys = e.keys()
  282.             keys.sort()
  283.             for k in keys:
  284.                 print '  %-15s' % k, e[k]
  285.             
  286.             print 
  287.         
  288.     
  289.  
  290. if __name__ == '__main__':
  291.     test()
  292.  
  293.