"""

* the vregistry handles various types of objects interacting

  together. The vregistry handles registration of dynamically loaded

  objects and provides a convenient api to access those objects

  according to a context

* to interact with the vregistry, objects should inherit from the

  VObject abstract class

* the selection procedure has been generalized by delegating to a

  selector, which is responsible to score the vobject according to the

  current state (req, rset, row, col). At the end of the selection, if

  a vobject class has been found, an instance of this class is

  returned. The selector is instantiated at vobject registration

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

__docformat__ = "restructuredtext en"

import sys

import types

from os import listdir, stat

from os.path import dirname, join, realpath, split, isdir, exists

from logging import getLogger

from warnings import warn

from cubicweb import CW_SOFTWARE_ROOT, set_log_methods

from cubicweb import RegistryNotFound, ObjectNotFound, NoSelectableObject

def _toload_info(path, extrapath, _toload=None):

    """return a dictionary of <modname>: <modpath> and an ordered list of

    (file, module name) to load

    """

    from logilab.common.modutils import modpath_from_file

    if _toload is None:

        assert isinstance(path, list)

        _toload = {}, []

    for fileordir in path:

        if isdir(fileordir) and exists(join(fileordir, '__init__.py')):

            subfiles = [join(fileordir, fname) for fname in listdir(fileordir)]

            _toload_info(subfiles, extrapath, _toload)

        elif fileordir[-3:] == '.py':

            modname = '.'.join(modpath_from_file(fileordir, extrapath))

            _toload[0][modname] = fileordir

            _toload[1].append((fileordir, modname))

    return _toload

class VObject(object):

    """visual object, use to be handled somehow by the visual components

    registry.

    The following attributes should be set on concret vobject subclasses:

    :__registry__:

      name of the registry for this object (string like 'views',

      'templates'...)

    :id:

      object's identifier in the registry (string like 'main',

      'primary', 'folder_box')

    :__select__:

      class'selector

    Moreover, the `__abstract__` attribute may be set to True to indicate

    that a vobject is abstract and should not be registered

    """

    # necessary attributes to interact with the registry

    id = None

    __registry__ = None

    __select__ = None

    @classmethod

    def registered(cls, registry):

        """called by the registry when the vobject has been registered.

        It must return the  object that will be actually registered (this

        may be the right hook to create an instance for example). By

        default the vobject is returned without any transformation.

        """

        cls.build___select__()

        return cls

    @classmethod

    def selected(cls, *args, **kwargs):

        """called by the registry when the vobject has been selected.

        It must return the  object that will be actually returned by the

        .select method (this may be the right hook to create an

        instance for example). By default the selected object is

        returned without any transformation.

        """

        return cls

    @classmethod

    def classid(cls):

        """returns a unique identifier for the vobject"""

        return '%s.%s' % (cls.__module__, cls.__name__)

    # XXX bw compat code

    @classmethod

    def build___select__(cls):

        for klass in cls.mro():

            if klass.__name__ == 'AppRsetObject':

                continue # the bw compat __selector__ is there

            klassdict = klass.__dict__

            if ('__select__' in klassdict and '__selectors__' in klassdict

                and '__selgenerated__' not in klassdict):

                raise TypeError("__select__ and __selectors__ can't be used together on class %s" % cls)

            if '__selectors__' in klassdict and '__selgenerated__' not in klassdict:

                cls.__selgenerated__ = True

                # case where __selectors__ is defined locally (but __select__

                # is in a parent class)

                selectors = klassdict['__selectors__']

                if len(selectors) == 1:

                    # micro optimization: don't bother with AndSelector if there's

                    # only one selector

                    select = _instantiate_selector(selectors[0])

                else:

                    select = AndSelector(*selectors)

                cls.__select__ = select

        """return the registry (dictionary of class objects) associated to

        this name

        """

        try:

        except KeyError:

        """

        result = []

            result += objs

        return result

    # dynamic selection methods ################################################

        raise `ObjectNotFound` if not object with id <oid> in <registry>

        raise `AssertionError` if there is more than one object there

        """

        assert len(objects) == 1, objects

        return objects[0].selected(*args, **kwargs)

        raise `ObjectNotFound` if not object with id <oid> in <registry>

        raise `NoSelectableObject` if not object apply

        """

        """

        try:

        except (NoSelectableObject, ObjectNotFound):

            return None

        context

        """

            try:

                yield self.select_best(vobjects, *args, **kwargs)

            except NoSelectableObject:

                continue

    def select_best(self, vobjects, *args, **kwargs):

        """return an instance of the most specific object according

        to parameters

        raise `NoSelectableObject` if not object apply

        """

        if len(args) > 1:

            warn('only the request param can not be named when calling select',

                 DeprecationWarning, stacklevel=3)

        score, winners = 0, []

        for vobject in vobjects:

            vobjectscore = vobject.__select__(vobject, *args, **kwargs)

            if vobjectscore > score:

                score, winners = vobjectscore, [vobject]

            elif vobjectscore > 0 and vobjectscore == score:

                winners.append(vobject)

        if not winners:

            raise NoSelectableObject('args: %s\nkwargs: %s %s'

                                     % (args, kwargs.keys(),

                                        [repr(v) for v in vobjects]))

        if len(winners) > 1:

            if self.config.mode == 'installed':

                self.error('select ambiguity, args: %s\nkwargs: %s %s',

                           args, kwargs.keys(), [repr(v) for v in winners])

            else:

                raise Exception('select ambiguity, args: %s\nkwargs: %s %s'

                                % (args, kwargs.keys(),

                                   [repr(v) for v in winners]))

        # return the result of the .selected method of the vobject

        return winners[0].selected(*args, **kwargs)

    # methods for explicit (un)registration ###################################

#     def clear(self, key):

#         regname, oid = key.split('.')

#         self[regname].pop(oid, None)

    def register_all(self, objects, modname, butclasses=()):

        for obj in objects:

            try:

                if obj.__module__ != modname or obj in butclasses:

                    continue

                oid = obj.id

            except AttributeError:

                continue

            if oid and not '__abstract__' in obj.__dict__:

                self.register(obj)

    def register(self, obj, registryname=None, oid=None, clear=False):

        """base method to add an object in the registry"""

        assert not '__abstract__' in obj.__dict__

        registryname = registryname or obj.__registry__

        try:

        except AttributeError:

        self.debug('registered vobject %s in registry %s with id %s',

                   vname, registryname, oid)

        # automatic reloading management

        self._loadedmods[obj.__module__]['%s.%s' % (obj.__module__, oid)] = obj

    def unregister(self, obj, registryname=None):

    def register_and_replace(self, obj, replaced, registryname=None):

    def init_registration(self, path, extrapath=None):

        # compute list of all modules that have to be loaded

        self._toloadmods, filemods = _toload_info(path, extrapath)

        self._loadedmods = {}