Application: gvSIG desktop » gvSIG scripting

#!/usr/bin/env python

"""cssutils ErrorHandler

ErrorHandler

    used as log with usual levels (debug, info, warn, error)

    if instanciated with ``raiseExceptions=True`` raises exeptions instead

    of logging

log

    defaults to instance of ErrorHandler for any kind of log message from

    lexerm, parser etc.

    - raiseExceptions = [False, True]

    - setloglevel(loglevel)

"""

__all__ = ['ErrorHandler']

__docformat__ = 'restructuredtext'

__version__ = '$Id$'

import logging

import urllib2

import xml.dom

class _ErrorHandler(object):

    """

    handles all errors and log messages

    """

    def __init__(self, log, defaultloglevel=logging.INFO, 

                 raiseExceptions=True):

        """

        inits log if none given

        log

            for parse messages, default logs to sys.stderr

        defaultloglevel

            if none give this is logging.DEBUG

        raiseExceptions

            - True: Errors will be raised e.g. during building

            - False: Errors will be written to the log, this is the

              default behaviour when parsing

        """

        # may be disabled during setting of known valid items

        self.enabled = True

        if log:

            self._log = log

        else:

            import sys

            self._log = logging.getLogger('CSSUTILS')

            hdlr = logging.StreamHandler(sys.stderr)

            formatter = logging.Formatter('%(levelname)s\t%(message)s')

            hdlr.setFormatter(formatter)

            self._log.addHandler(hdlr)

            self._log.setLevel(defaultloglevel)

        self.raiseExceptions = raiseExceptions

    def __getattr__(self, name):

        "use self._log items"

        calls = ('debug', 'info', 'warn', 'error', 'critical', 'fatal')

        other = ('setLevel', 'getEffectiveLevel', 'addHandler', 'removeHandler')

        if name in calls:

            self._logcall = getattr(self._log, name)

            return self.__handle

        elif name in other:

            return getattr(self._log, name)

        else:

            raise AttributeError(

                '(errorhandler) No Attribute %r found' % name)

    def __handle(self, msg=u'', token=None, error=xml.dom.SyntaxErr,

                 neverraise=False, args=None):

        """

        handles all calls

        logs or raises exception

        """

        if self.enabled:

            if error is None:

                error = xml.dom.SyntaxErr

            line, col = None, None

            if token:

                if isinstance(token, tuple):

                    value, line, col = token[1], token[2], token[3]

                else:

                    value, line, col = token.value, token.line, token.col

                msg = u'%s [%s:%s: %s]' % (

                    msg, line, col, value)

            if error and self.raiseExceptions and not neverraise:

                if isinstance(error, urllib2.HTTPError) or isinstance(error, urllib2.URLError):

                    raise

                elif issubclass(error, xml.dom.DOMException): 

                    error.line = line

                    error.col = col

                raise error(msg)

            else:

                self._logcall(msg)

    def setLog(self, log):

        """set log of errorhandler's log"""

        self._log = log

class ErrorHandler(_ErrorHandler):

    "Singleton, see _ErrorHandler"

    instance = None

    def __init__(self,

            log=None, defaultloglevel=logging.INFO, raiseExceptions=True):

        if ErrorHandler.instance is None:

            ErrorHandler.instance = _ErrorHandler(log=log,

                                        defaultloglevel=defaultloglevel,

                                        raiseExceptions=raiseExceptions)

        self.__dict__ = ErrorHandler.instance.__dict__