import py

import sys, os.path

builtin_repr = repr

reprlib = py.builtin._tryimport('repr', 'reprlib')

class Code(object):

    """ wrapper around Python code objects """

    def __init__(self, rawcode):

        rawcode = py.code.getrawcode(rawcode)

        self.raw = rawcode

        try:

            self.filename = rawcode.co_filename

            self.firstlineno = rawcode.co_firstlineno - 1

            self.name = rawcode.co_name

        except AttributeError:

            raise TypeError("not a code object: %r" %(rawcode,))

    def __eq__(self, other):

        return self.raw == other.raw

    def __ne__(self, other):

        return not self == other

    def path(self):

        """ return a path object pointing to source code"""

        p = py.path.local(self.raw.co_filename)

        if not p.check():

            # XXX maybe try harder like the weird logic

            # in the standard lib [linecache.updatecache] does?

            p = self.raw.co_filename

        return p

    path = property(path, None, None, "path of this code object")

    def fullsource(self):

        """ return a py.code.Source object for the full source file of the code

        """

        from py._code import source

        full, _ = source.findsource(self.raw)

        return full

    fullsource = property(fullsource, None, None,

                          "full source containing this code object")

    def source(self):

        """ return a py.code.Source object for the code object's source only

        """

        # return source only for that part of code

        return py.code.Source(self.raw)

    def getargs(self):

        """ return a tuple with the argument names for the code object

        """

        # handfull shortcut for getting args

        raw = self.raw

        return raw.co_varnames[:raw.co_argcount]

class Frame(object):

    """Wrapper around a Python frame holding f_locals and f_globals

    in which expressions can be evaluated."""

    def __init__(self, frame):

        self.code = py.code.Code(frame.f_code)

        self.lineno = frame.f_lineno - 1

        self.f_globals = frame.f_globals

        self.f_locals = frame.f_locals

        self.raw = frame

    def statement(self):

        if self.code.fullsource is None:

            return py.code.Source("")

        return self.code.fullsource.getstatement(self.lineno)

    statement = property(statement, None, None,

                         "statement this frame is at")

    def eval(self, code, **vars):

        """ evaluate 'code' in the frame

            'vars' are optional additional local variables

            returns the result of the evaluation

        """

        f_locals = self.f_locals.copy()

        f_locals.update(vars)

        return eval(code, self.f_globals, f_locals)

    def exec_(self, code, **vars):

        """ exec 'code' in the frame

            'vars' are optiona; additional local variables

        """

        f_locals = self.f_locals.copy()

        f_locals.update(vars)

        py.builtin.exec_(code, self.f_globals, f_locals )

    def repr(self, object):

        """ return a 'safe' (non-recursive, one-line) string repr for 'object'

        """

        return py.io.saferepr(object)

    def is_true(self, object):

        return object

    def getargs(self):

        """ return a list of tuples (name, value) for all arguments

        """

        retval = []

        for arg in self.code.getargs():

            try:

                retval.append((arg, self.f_locals[arg]))

            except KeyError:

                pass     # this can occur when using Psyco

        return retval

class TracebackEntry(object):

    """ a single entry in a traceback """

    exprinfo = None

    def __init__(self, rawentry):

        self._rawentry = rawentry

        self.frame = py.code.Frame(rawentry.tb_frame)

        # Ugh. 2.4 and 2.5 differs here when encountering

        # multi-line statements. Not sure about the solution, but

        # should be portable

        self.lineno = rawentry.tb_lineno - 1

        self.relline = self.lineno - self.frame.code.firstlineno

    def __repr__(self):

        return "<TracebackEntry %s:%d>" %(self.frame.code.path, self.lineno+1)

    def statement(self):

        """ return a py.code.Source object for the current statement """

        source = self.frame.code.fullsource

        return source.getstatement(self.lineno)

    statement = property(statement, None, None,

                         "statement of this traceback entry.")

    def path(self):

        return self.frame.code.path

    path = property(path, None, None, "path to the full source code")

    def getlocals(self):

        return self.frame.f_locals

    locals = property(getlocals, None, None, "locals of underlaying frame")

    def reinterpret(self):

        """Reinterpret the failing statement and returns a detailed information

           about what operations are performed."""

        if self.exprinfo is None:

            source = str(self.statement).strip()

            x = py.code._reinterpret(source, self.frame, should_fail=True)

            if not isinstance(x, str):

                raise TypeError("interpret returned non-string %r" % (x,))

            self.exprinfo = x

        return self.exprinfo

    def getfirstlinesource(self):

        # on Jython this firstlineno can be -1 apparently

        return max(self.frame.code.firstlineno, 0)

    def getsource(self):

        """ return failing source code. """

        source = self.frame.code.fullsource

        if source is None:

            return None

        start = self.getfirstlinesource()

        end = self.lineno

        try:

            _, end = source.getstatementrange(end)

        except IndexError:

            end = self.lineno + 1

        # heuristic to stop displaying source on e.g.

        #   if something:  # assume this causes a NameError

        #      # _this_ lines and the one

               #        below we don't want from entry.getsource()

        for i in range(self.lineno, end):

            if source[i].rstrip().endswith(':'):

                end = i + 1

                break

        return source[start:end]

    source = property(getsource)

    def ishidden(self):

        """ return True if the current frame has a var __tracebackhide__

            resolving to True

            mostly for internal use

        """

        try:

            return self.frame.eval("__tracebackhide__")

        except py.builtin._sysex:

            raise

        except:

            return False

    def __str__(self):

        try:

            fn = str(self.path)

        except py.error.Error:

            fn = '???'

        name = self.frame.code.name

        try:

            line = str(self.statement).lstrip()

        except KeyboardInterrupt:

            raise

        except:

            line = "???"

        return "  File %r:%d in %s\n  %s\n" %(fn, self.lineno+1, name, line)

    def name(self):

        return self.frame.code.raw.co_name

    name = property(name, None, None, "co_name of underlaying code")

class Traceback(list):

    """ Traceback objects encapsulate and offer higher level

        access to Traceback entries.

    """

    Entry = TracebackEntry

    def __init__(self, tb):

        """ initialize from given python traceback object. """

        if hasattr(tb, 'tb_next'):

            def f(cur):

                while cur is not None:

                    yield self.Entry(cur)

                    cur = cur.tb_next

            list.__init__(self, f(tb))

        else:

            list.__init__(self, tb)

    def cut(self, path=None, lineno=None, firstlineno=None, excludepath=None):

        """ return a Traceback instance wrapping part of this Traceback

            by provding any combination of path, lineno and firstlineno, the

            first frame to start the to-be-returned traceback is determined

            this allows cutting the first part of a Traceback instance e.g.

            for formatting reasons (removing some uninteresting bits that deal

            with handling of the exception/traceback)

        """

        for x in self:

            code = x.frame.code

            codepath = code.path

            if ((path is None or codepath == path) and

                (excludepath is None or not hasattr(codepath, 'relto') or

                 not codepath.relto(excludepath)) and

                (lineno is None or x.lineno == lineno) and

                (firstlineno is None or x.frame.code.firstlineno == firstlineno)):

                return Traceback(x._rawentry)

        return self

    def __getitem__(self, key):

        val = super(Traceback, self).__getitem__(key)

        if isinstance(key, type(slice(0))):

            val = self.__class__(val)

        return val

    def filter(self, fn=lambda x: not x.ishidden()):

        """ return a Traceback instance with certain items removed

            fn is a function that gets a single argument, a TracebackItem

            instance, and should return True when the item should be added

            to the Traceback, False when not

            by default this removes all the TracebackItems which are hidden

            (see ishidden() above)

        """

        return Traceback(filter(fn, self))

    def getcrashentry(self):

        """ return last non-hidden traceback entry that lead

        to the exception of a traceback.

        """

        tb = self.filter()

        if not tb:

            tb = self

        return tb[-1]

    def recursionindex(self):

        """ return the index of the frame/TracebackItem where recursion

            originates if appropriate, None if no recursion occurred

        """

        cache = {}

        for i, entry in enumerate(self):

            key = entry.frame.code.path, entry.lineno

            #print "checking for recursion at", key

            l = cache.setdefault(key, [])

            if l:

                f = entry.frame

                loc = f.f_locals

                for otherloc in l:

                    if f.is_true(f.eval(co_equal,

                        __recursioncache_locals_1=loc,

                        __recursioncache_locals_2=otherloc)):

                        return i

            l.append(entry.frame.f_locals)

        return None

co_equal = compile('__recursioncache_locals_1 == __recursioncache_locals_2',

                   '?', 'eval')

class ExceptionInfo(object):

    """ wraps sys.exc_info() objects and offers

        help for navigating the traceback.

    """

    _striptext = ''

    def __init__(self, tup=None, exprinfo=None):

        # NB. all attributes are private!  Subclasses or other

        #     ExceptionInfo-like classes may have different attributes.

        if tup is None:

            tup = sys.exc_info()

            if exprinfo is None and isinstance(tup[1], py.code._AssertionError):

                exprinfo = getattr(tup[1], 'msg', None)

                if exprinfo is None:

                    exprinfo = str(tup[1])

                if exprinfo and exprinfo.startswith('assert '):

                    self._striptext = 'AssertionError: '

        self._excinfo = tup

        self.type, self.value, tb = self._excinfo

        self.typename = self.type.__name__

        self.traceback = py.code.Traceback(tb)

    def __repr__(self):

        return "<ExceptionInfo %s tblen=%d>" % (self.typename, len(self.traceback))

    def exconly(self, tryshort=False):

        """ return the exception as a string

            when 'tryshort' resolves to True, and the exception is a

            py.code._AssertionError, only the actual exception part of

            the exception representation is returned (so 'AssertionError: ' is

            removed from the beginning)

        """

        lines = py.std.traceback.format_exception_only(self.type, self.value)

        text = ''.join(lines)

        text = text.rstrip()

        if tryshort:

            if text.startswith(self._striptext):

                text = text[len(self._striptext):]

        return text

    def errisinstance(self, exc):

        """ return True if the exception is an instance of exc """

        return isinstance(self.value, exc)

    def _getreprcrash(self):

        exconly = self.exconly(tryshort=True)

        entry = self.traceback.getcrashentry()

        path, lineno = entry.path, entry.lineno

        reprcrash = ReprFileLocation(path, lineno+1, exconly)

        return reprcrash

    def getrepr(self, showlocals=False, style="long",

            abspath=False, tbfilter=True, funcargs=False):

        """ return str()able representation of this exception info.

            showlocals: show locals per traceback entry

            style: long|short|no|native traceback style

            tbfilter: hide entries (where __tracebackhide__ is true)

        """

        if style == 'native':

            import traceback

            return ''.join(traceback.format_exception(

                self.type,

                self.value,

                self.traceback[0]._rawentry,

                ))

        fmt = FormattedExcinfo(showlocals=showlocals, style=style,

            abspath=abspath, tbfilter=tbfilter, funcargs=funcargs)

        return fmt.repr_excinfo(self)

    def __str__(self):

        entry = self.traceback[-1]

        loc = ReprFileLocation(entry.path, entry.lineno + 1, self.exconly())

        return str(loc)

    def __unicode__(self):

        entry = self.traceback[-1]

        loc = ReprFileLocation(entry.path, entry.lineno + 1, self.exconly())

        return unicode(loc)

class FormattedExcinfo(object):

    """ presenting information about failing Functions and Generators. """

    # for traceback entries

    flow_marker = ">"

    fail_marker = "E"

    def __init__(self, showlocals=False, style="long", abspath=True, tbfilter=True, funcargs=False):

        self.showlocals = showlocals

        self.style = style

        self.tbfilter = tbfilter

        self.funcargs = funcargs

        self.abspath = abspath

    def _getindent(self, source):

        # figure out indent for given source

        try:

            s = str(source.getstatement(len(source)-1))

        except KeyboardInterrupt:

            raise

        except:

            try:

                s = str(source[-1])

            except KeyboardInterrupt:

                raise

            except:

                return 0

        return 4 + (len(s) - len(s.lstrip()))

    def _getentrysource(self, entry):

        source = entry.getsource()

        if source is not None:

            source = source.deindent()

        return source

    def _saferepr(self, obj):

        return py.io.saferepr(obj)

    def repr_args(self, entry):

        if self.funcargs:

            args = []

            for argname, argvalue in entry.frame.getargs():

                args.append((argname, self._saferepr(argvalue)))

            return ReprFuncArgs(args)

    def get_source(self, source, line_index=-1, excinfo=None, short=False):

        """ return formatted and marked up source lines. """

        lines = []

        if source is None:

            source = py.code.Source("???")

            line_index = 0

        if line_index < 0:

            line_index += len(source)

        for i in range(len(source)):

            if i == line_index:

                prefix = self.flow_marker + "   "

            else:

                if short:

                    continue

                prefix = "    "

            line = prefix + source[i]

            lines.append(line)

        if excinfo is not None:

            indent = self._getindent(source)

            lines.extend(self.get_exconly(excinfo, indent=indent, markall=True))

        return lines

    def get_exconly(self, excinfo, indent=4, markall=False):

        lines = []

        indent = " " * indent

        # get the real exception information out

        exlines = excinfo.exconly(tryshort=True).split('\n')

        failindent = self.fail_marker + indent[1:]

        for line in exlines:

            lines.append(failindent + line)

            if not markall:

                failindent = indent

        return lines

    def repr_locals(self, locals):

        if self.showlocals:

            lines = []

            keys = list(locals)

            keys.sort()

            for name in keys:

                value = locals[name]

                if name == '__builtins__':

                    lines.append("__builtins__ = <builtins>")

                else:

                    # This formatting could all be handled by the

                    # _repr() function, which is only reprlib.Repr in

                    # disguise, so is very configurable.

                    str_repr = self._saferepr(value)

                    #if len(str_repr) < 70 or not isinstance(value,

                    #                            (list, tuple, dict)):

                    lines.append("%-10s = %s" %(name, str_repr))

                    #else:

                    #    self._line("%-10s =\\" % (name,))

                    #    # XXX

                    #    py.std.pprint.pprint(value, stream=self.excinfowriter)

            return ReprLocals(lines)

    def repr_traceback_entry(self, entry, excinfo=None):

        # excinfo is not None if this is the last tb entry

        source = self._getentrysource(entry)

        if source is None:

            source = py.code.Source("???")

            line_index = 0

        else:

            # entry.getfirstlinesource() can be -1, should be 0 on jython

            line_index = entry.lineno - max(entry.getfirstlinesource(), 0)

        lines = []

        if self.style in ("short", "long"):

            short = self.style == "short"

            reprargs = None

            if not short:

                reprargs = self.repr_args(entry)

            s = self.get_source(source, line_index, excinfo, short=short)

            lines.extend(s)

            if short:

                message = "in %s" %(entry.name)

            else:

                message = excinfo and excinfo.typename or ""

            path = self._makepath(entry.path)

            filelocrepr = ReprFileLocation(path, entry.lineno+1, message)

            localsrepr = None

            if not short:

                localsrepr =  self.repr_locals(entry.locals)

            return ReprEntry(lines, reprargs, localsrepr, filelocrepr, short)

        if excinfo:

            lines.extend(self.get_exconly(excinfo, indent=4))

        return ReprEntry(lines, None, None, None, False)

    def _makepath(self, path):

        if not self.abspath:

            np = py.path.local().bestrelpath(path)

            if len(np) < len(str(path)):

                path = np

        return path

    def repr_traceback(self, excinfo):

        traceback = excinfo.traceback

        if self.tbfilter:

            traceback = traceback.filter()

        recursionindex = None

        if excinfo.errisinstance(RuntimeError):