#!/usr/bin/env

 __author__ = "Gustavo Sverzut Barbieri / Artur Duque de Souza"

 __author_email__ = "barbieri@gmail.com / artur.souza@indt.org.br"

 __license__ = "GPL"

 __version__ = "0.3"

 import os

 import stat

 import sys

 import logging

 import urllib

 import gobject

 import imp

 log = logging.getLogger("gms.utils")

 __all__ = ("which", "load_plugins", "PluginSet")

 def which(app):

     """function to implement which(1) unix command"""

     pl = os.environ["PATH"].split(os.pathsep)

     for p in pl:

         path = os.path.join(p, app)

         if os.path.isfile(path):

             st = os.stat(path)

             if st[stat.ST_MODE] & 0111:

                 return path

     return ""

 # which()

 def _load_module(pathlist, name):

     fp, path, desc = imp.find_module(name, pathlist)

     try:

         module = imp.load_module(name, fp, path, desc)

         return module

     finally:

         if fp:

             fp.close()

 # _load_module()

 class PluginSet(object):

     def __init__(self, basetype, *items):

         self.basetype = basetype

         self.map = {}

         self.list = []

         for i in items:

             self._add(i)

         self._sort()

     # __init__()

     def _add(self, item):

         self.map[item.name] = item

         self.list.append(item)

     # _add()

     def add(self, item):

         self._add()

         self._sort()

     # add()

     def __getitem__(self, spec):

         if isinstance(spec, basestring):

             return self.map[spec]

         else:

             return self.list[spec]

     # __getitem__()

     def get(self, name, default=None):

         return self.map.get(name, default)

     # get()

     def __iter__(self):

         return self.list.__iter__()

     # __iter__()

     def __len__(self):

         return len(self.list)

     # __len__()

     def _sort(self):

         self.list.sort(lambda a, b: cmp(a.priority, b.priority))

     # _sort()

     def update(self, pluginset):

         self.map.update(pluginset.map)

         self.list.extend(pluginset.list)

         self._sort()

     # update()

     def load_from_directory(self, directory):

         for i in load_plugins(directory, self.basetype):

             self._add(i)

         self._sort()

     # load_from_directory()

     def __str__(self):

         lst = []

         for o in self.list:

             lst.append('"%s" (%s)' % (o.name, o.__name__))

         return "%s(basetype=%s, items=[%s])" % \

                (self.__class__.__name__,

                 self.basetype.__name__,

                 ", ".join(lst))

     # __str__()

 # PluginSet

 def load_plugins(directory, basetype):

     tn = basetype.__name__

     log.debug("Loading plugins from %s, type=%s" % (directory, tn))

     plugins = []

     for d in os.listdir(directory):

         if not d.endswith(".py"):

             continue

         name = d[0: -3]

         if name == "__init__":

             continue

         directory.replace(os.path.sep, ".")

         mod = _load_module([directory], name)

         for sym in dir(mod):

             cls = getattr(mod, sym)

             if isinstance(cls, type) and issubclass(cls, basetype) and \

                 cls != basetype:

                 plugins.append(cls)

                 log.info("Loaded %s (%s) from %s" % \

                          (cls.__name__, tn, os.path.join(directory, d)))

     return plugins

 # load_plugins()