"""Generic metaclass.

XXX This is very much a work in progress.

"""

import types

class MetaMethodWrapper:

    def __init__(self, func, inst):

        self.func = func

        self.inst = inst

        self.__name__ = self.func.__name__

    def __call__(self, *args, **kw):

        return apply(self.func, (self.inst,) + args, kw)

class MetaHelper:

    __methodwrapper__ = MetaMethodWrapper # For derived helpers to override

    def __helperinit__(self, formalclass):

        self.__formalclass__ = formalclass

    def __getattr__(self, name):

        # Invoked for any attr not in the instance's __dict__

        try:

            raw = self.__formalclass__.__getattr__(name)

        except AttributeError:

            try:

                ga = self.__formalclass__.__getattr__('__usergetattr__')

            except (KeyError, AttributeError):

                raise AttributeError, name

            return ga(self, name)

        if type(raw) != types.FunctionType:

            return raw

        return self.__methodwrapper__(raw, self)

class MetaClass:

    """A generic metaclass.

    This can be subclassed to implement various kinds of meta-behavior.

    """

    __helper__ = MetaHelper             # For derived metaclasses to override

    __inited = 0

    def __init__(self, name, bases, dict):

        try:

            ga = dict['__getattr__']

        except KeyError:

            pass

        else:

            dict['__usergetattr__'] = ga

            del dict['__getattr__']

        self.__name__ = name

        self.__bases__ = bases

        self.__realdict__ = dict

        self.__inited = 1

    def __getattr__(self, name):

        try:

            return self.__realdict__[name]

        except KeyError:

            for base in self.__bases__:

                try:

                    return base.__getattr__(name)

                except AttributeError:

                    pass

            raise AttributeError, name

    def __setattr__(self, name, value):

        if not self.__inited:

            self.__dict__[name] = value

        else:

            self.__realdict__[name] = value

    def __call__(self, *args, **kw):

        inst = self.__helper__()

        inst.__helperinit__(self)

        try:

            init = inst.__getattr__('__init__')

        except AttributeError:

            init = lambda: None

        apply(init, args, kw)

        return inst

Meta = MetaClass('Meta', (), {})

def _test():

    class C(Meta):

        def __init__(self, *args):

            print "__init__, args =", args

        def m1(self, x):

            print "m1(x=%r)" % (x,)

    print C

    x = C()

    print x

    x.m1(12)

    class D(C):

        def __getattr__(self, name):

            if name[:2] == '__': raise AttributeError, name

            return "getattr:%s" % name

    x = D()

    print x.foo

    print x._foo

##     print x.__foo

##     print x.__foo__

if __name__ == '__main__':

    _test()