python/rox/mime.py

   1 """This module provides access to the shared MIME database.
   2
   3 types is a dictionary of all known MIME types, indexed by the type name, e.g.
   4 types['application/x-python']
   5
   6 Applications can install information about MIME types by storing an
   7 XML file as <MIME>/packages/<application>.xml and running the
   8 update-mime-database command, which is provided by the freedesktop.org
   9 shared mime database package.
  10
  11 See http://www.freedesktop.org/standards/shared-mime-info-spec/ for
  12 information about the format of these files."""
  13
  14 import os
  15 import stat
  16 import fnmatch
  17
  18 import rox
  19 from rox import i18n
  20
  21 from xml.dom import Node, minidom, XML_NAMESPACE
  22
  23 FREE_NS = 'http://www.freedesktop.org/standards/shared-mime-info'
  24
  25 exts = {}               # Maps extensions to types
  26 globs = []              # List of (glob, type) pairs
  27 literals = {}           # Maps liternal names to types
  28
  29 types = {}              # Maps MIME names to type objects
  30
  31 _home = os.environ.get('HOME', '/')
  32 _xdg_data_home = os.environ.get('XDG_DATA_HOME',
  33                         os.path.join(_home, '.local', 'share'))
  34
  35 _xdg_data_dirs = os.environ.get('XDG_DATA_DIRS', '/usr/local/share:/usr/share')
  36
  37 mimedirs = []
  38
  39 _user_install = os.path.join(_xdg_data_home, 'mime')
  40 if os.access(_user_install, os.R_OK):
  41         mimedirs.append(_user_install)
  42 else:
  43         # See if we have the old directory
  44         _old_user_install = os.path.join(_home, '.mime')
  45         if os.access(_old_user_install, os.R_OK):
  46                 mimedirs.append(_old_user_install)
  47                 rox.info(_("WARNING: %s not found for shared MIME database version %s, "
  48                            "using %s for version %s") %
  49                            (_user_install, '0.11', _old_user_install, '0.10'))
  50         else:
  51                 # Neither old nor new.  Assume new for installing files
  52                 mimedirs.append(_user_install)
  53
  54 for _dir in _xdg_data_dirs.split(':'):
  55         mimedirs.append(os.path.join(_dir, 'mime'))
  56
  57 def _get_node_data(node):
  58         """Get text of XML node"""
  59         return ''.join([n.nodeValue for n in node.childNodes]).strip()
  60
  61 def lookup(media, subtype = None):
  62         "Get the MIMEtype object for this type, creating a new one if needed."
  63         if subtype is None and '/' in media:
  64                 media, subtype = media.split('/', 1)
  65         if (media, subtype) not in types:
  66                 types[(media, subtype)] = MIMEtype(media, subtype)
  67         return types[(media, subtype)]
  68
  69 class MIMEtype:
  70         """Type holding data about a MIME type"""
  71         def __init__(self, media, subtype):
  72                 "Don't use this constructor directly; use mime.lookup() instead."
  73                 assert media and '/' not in media
  74                 assert subtype and '/' not in subtype
  75                 assert (media, subtype) not in types
  76
  77                 self.media = media
  78                 self.subtype = subtype
  79                 self.comment = None
  80
  81         def _load(self):
  82                 "Loads comment for current language. Use get_comment() instead."
  83                 for dir in mimedirs:
  84                         path = os.path.join(dir, self.media, self.subtype + '.xml')
  85                         if not os.path.exists(path):
  86                                 continue
  87
  88                         doc = minidom.parse(path)
  89                         if doc is None:
  90                                 continue
  91                         for comment in doc.documentElement.getElementsByTagNameNS(FREE_NS, 'comment'):
  92                                 lang = comment.getAttributeNS(XML_NAMESPACE, 'lang') or 'en'
  93                                 goodness = 1 + (lang in i18n.langs)
  94                                 if goodness > self.comment[0]:
  95                                         self.comment = (goodness, _get_node_data(comment))
  96                                 if goodness == 2: return
  97
  98         def get_comment(self):
  99                 """Returns comment for current language, loading it if needed."""
 100                 # Should we ever reload?
 101                 if self.comment is None:
 102                         self.comment = (0, str(self))
 103                         self._load()
 104                 return self.comment[1]
 105
 106         def __str__(self):
 107                 return self.media + '/' + self.subtype
 108
 109         def __repr__(self):
 110                 return '[%s: %s]' % (self, self.comment or '(comment not loaded)')
 111
 112 # Some well-known types
 113 text = lookup('text', 'plain')
 114 inode_block = lookup('inode', 'blockdevice')
 115 inode_char = lookup('inode', 'chardevice')
 116 inode_dir = lookup('inode', 'directory')
 117 inode_fifo = lookup('inode', 'fifo')
 118 inode_socket = lookup('inode', 'socket')
 119 inode_symlink = lookup('inode', 'symlink')
 120 inode_door = lookup('inode', 'door')
 121 app_exe = lookup('application', 'executable')
 122
 123 def _import_glob_file(dir):
 124         """Loads name matching information from a MIME directory."""
 125         path = os.path.join(dir, 'globs')
 126         if not os.path.exists(path):
 127                 return
 128
 129         for line in file(path):
 130                 if line.startswith('#'): continue
 131                 line = line[:-1]
 132
 133                 type, pattern = line.split(':', 1)
 134                 mtype = lookup(type)
 135
 136                 if pattern.startswith('*.'):
 137                         rest = pattern[2:]
 138                         if not ('*' in rest or '[' in rest or '?' in rest):
 139                                 exts[rest] = mtype
 140                                 continue
 141                 if '*' in pattern or '[' in pattern or '?' in pattern:
 142                         globs.append((pattern, mtype))
 143                 else:
 144                         literals[pattern] = mtype
 145
 146 for dir in mimedirs:
 147         _import_glob_file(dir)
 148
 149 # Sort globs by length
 150 globs.sort(lambda a, b: cmp(len(b[0]), len(a[0])))
 151
 152 def get_type_by_name(path):
 153         """Returns type of file by its name, or None if not known"""
 154         leaf = os.path.basename(path)
 155         if leaf in literals:
 156                 return literals[leaf]
 157
 158         lleaf = leaf.lower()
 159         if lleaf in literals:
 160                 return literals[lleaf]
 161
 162         ext = leaf
 163         while 1:
 164                 p = ext.find('.')
 165                 if p < 0: break
 166                 ext = ext[p + 1:]
 167                 if ext in exts:
 168                         return exts[ext]
 169         ext = lleaf
 170         while 1:
 171                 p = ext.find('.')
 172                 if p < 0: break
 173                 ext = ext[p+1:]
 174                 if ext in exts:
 175                         return exts[ext]
 176         for (glob, type) in globs:
 177                 if fnmatch.fnmatch(leaf, glob):
 178                         return type
 179                 if fnmatch.fnmatch(lleaf, glob):
 180                         return type
 181         return None
 182
 183 def get_type(path, follow=1, name_pri=100):
 184         """Returns type of file indicated by path.
 185         path     - pathname to check (need not exist)
 186         follow   - when reading file, follow symbolic links
 187         name_pri - Priority to do name matches.  100=override magic"""
 188         # name_pri is not implemented
 189         try:
 190                 if follow:
 191                         st = os.stat(path)
 192                 else:
 193                         st = os.lstat(path)
 194         except:
 195                 t = get_type_by_name(path)
 196                 return t or text
 197
 198         if stat.S_ISREG(st.st_mode):
 199                 t = get_type_by_name(path)
 200                 if t is None:
 201                         if stat.S_IMODE(st.st_mode) & 0111:
 202                                 return app_exe
 203                         else:
 204                                 return text
 205                 return t
 206         elif stat.S_ISDIR(st.st_mode): return inode_dir
 207         elif stat.S_ISCHR(st.st_mode): return inode_char
 208         elif stat.S_ISBLK(st.st_mode): return inode_block
 209         elif stat.S_ISFIFO(st.st_mode): return inode_fifo
 210         elif stat.S_ISLNK(st.st_mode): return inode_symlink
 211         elif stat.S_ISSOCK(st.st_mode): return inode_socket
 212         return inode_door
 213
 214 def install_mime_info(application, package_file = None):
 215         """Copy 'package_file' as ~/.local/share/mime/packages/<application>.xml.
 216         If package_file is None, install <app_dir>/<application>.xml.
 217         If already installed, does nothing. May overwrite an existing
 218         file with the same name (if the contents are different)"""
 219         application += '.xml'
 220         if not package_file:
 221                 package_file = os.path.join(rox.app_dir, application)
 222
 223         new_data = file(package_file).read()
 224
 225         # See if the file is already installed
 226
 227         for x in mimedirs:
 228                 test = os.path.join(x, 'packages', application)
 229                 try:
 230                         old_data = file(test).read()
 231                 except:
 232                         continue
 233                 if old_data == new_data:
 234                         return  # Already installed
 235
 236         # Not already installed; add a new copy
 237         try:
 238                 # Create the directory structure...
 239
 240                 packages = os.path.join(mimedirs[0], 'packages')
 241                 if not os.path.exists(packages): os.makedirs(packages)
 242
 243                 # Write the file...
 244                 new_file = os.path.join(packages, application)
 245                 file(new_file, 'w').write(new_data)
 246
 247                 # Update the database...
 248                 if os.spawnlp(os.P_WAIT, 'update-mime-database', 'update-mime-database', mimedirs[0]):
 249                         os.unlink(new_file)
 250                         raise Exception(_("The 'update-mime-database' command returned an error code!\n" \
 251                                           "Make sure you have the freedesktop.org shared MIME package:\n" \
 252                                           "http://www.freedesktop.org/standards/shared-mime-info.html"))
 253         except:
 254                 rox.report_exception()
 255
 256 def test(name):
 257         """Print results for name.  Test routine"""
 258         t=get_type(name)
 259         print name, t, t.get_comment()
 260
 261 if __name__=='__main__':
 262         import sys
 263         if len(sys.argv)<2:
 264                 test('file.txt')
 265         else:
 266                 for f in sys.argv[1:]:
 267                         test(f)
 268         print globs