# changelog.py - changelog class for mercurial

#

# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

from .i18n import _

from .node import (

    bin,

    hex,

    nullid,

)

from . import (

    encoding,

    error,

    revlog,

    util,

)

_defaultextra = {'branch': 'default'}

def _string_escape(text):

    """

    >>> d = {'nl': chr(10), 'bs': chr(92), 'cr': chr(13), 'nul': chr(0)}

    >>> s = "ab%(nl)scd%(bs)s%(bs)sn%(nul)sab%(cr)scd%(bs)s%(nl)s" % d

    >>> s

    'ab\\ncd\\\\\\\\n\\x00ab\\rcd\\\\\\n'

    >>> res = _string_escape(s)

    >>> s == res.decode('string_escape')

    True

    """

    # subset of the string_escape codec

    text = text.replace('\\', '\\\\').replace('\n', '\\n').replace('\r', '\\r')

    return text.replace('\0', '\\0')

def decodeextra(text):

    """

    >>> sorted(decodeextra(encodeextra({'foo': 'bar', 'baz': chr(0) + '2'})

    ...                    ).iteritems())

    [('baz', '\\x002'), ('branch', 'default'), ('foo', 'bar')]

    >>> sorted(decodeextra(encodeextra({'foo': 'bar',

    ...                                 'baz': chr(92) + chr(0) + '2'})

    ...                    ).iteritems())

    [('baz', '\\\\\\x002'), ('branch', 'default'), ('foo', 'bar')]

    """

    extra = _defaultextra.copy()

    for l in text.split('\0'):

        if l:

            if '\\0' in l:

                # fix up \0 without getting into trouble with \\0

                l = l.replace('\\\\', '\\\\\n')

                l = l.replace('\\0', '\0')

                l = l.replace('\n', '')

            k, v = l.decode('string_escape').split(':', 1)

            extra[k] = v

    return extra

def encodeextra(d):

    # keys must be sorted to produce a deterministic changelog entry

    items = [_string_escape('%s:%s' % (k, d[k])) for k in sorted(d)]

    return "\0".join(items)

def stripdesc(desc):

    """strip trailing whitespace and leading and trailing empty lines"""

    return '\n'.join([l.rstrip() for l in desc.splitlines()]).strip('\n')

class appender(object):

    '''the changelog index must be updated last on disk, so we use this class

    to delay writes to it'''

    def __init__(self, vfs, name, mode, buf):

        self.data = buf

        fp = vfs(name, mode)

        self.fp = fp

        self.offset = fp.tell()

        self.size = vfs.fstat(fp).st_size

    def end(self):

        return self.size + len("".join(self.data))

    def tell(self):

        return self.offset

    def flush(self):

        pass

    def close(self):

        self.fp.close()

    def seek(self, offset, whence=0):

        '''virtual file offset spans real file and data'''

        if whence == 0:

            self.offset = offset

        elif whence == 1:

            self.offset += offset

        elif whence == 2:

            self.offset = self.end() + offset

        if self.offset < self.size:

            self.fp.seek(self.offset)

    def read(self, count=-1):

        '''only trick here is reads that span real file and data'''

        ret = ""

        if self.offset < self.size:

            s = self.fp.read(count)

            ret = s

            self.offset += len(s)

            if count > 0:

                count -= len(s)

        if count != 0:

            doff = self.offset - self.size

            self.data.insert(0, "".join(self.data))

            del self.data[1:]

            s = self.data[0][doff:doff + count]

            self.offset += len(s)

            ret += s

        return ret

    def write(self, s):

        self.data.append(str(s))

        self.offset += len(s)

def _divertopener(opener, target):

    """build an opener that writes in 'target.a' instead of 'target'"""

    def _divert(name, mode='r'):

        if name != target:

            return opener(name, mode)

        return opener(name + ".a", mode)

    return _divert

def _delayopener(opener, target, buf):

    """build an opener that stores chunks in 'buf' instead of 'target'"""

    def _delay(name, mode='r'):

        if name != target:

            return opener(name, mode)

        return appender(opener, name, mode, buf)

    return _delay

class changelog(revlog.revlog):

    def __init__(self, opener):

        revlog.revlog.__init__(self, opener, "00changelog.i")

        if self._initempty:

            # changelogs don't benefit from generaldelta

            self.version &= ~revlog.REVLOGGENERALDELTA

            self._generaldelta = False

        self._realopener = opener

        self._delayed = False

        self._delaybuf = None

        self._divert = False

        self.filteredrevs = frozenset()

    def tip(self):

        """filtered version of revlog.tip"""

        for i in xrange(len(self) -1, -2, -1):

            if i not in self.filteredrevs:

                return self.node(i)

    def __contains__(self, rev):

        """filtered version of revlog.__contains__"""

        return (0 <= rev < len(self)

                and rev not in self.filteredrevs)

    def __iter__(self):

        """filtered version of revlog.__iter__"""

        if len(self.filteredrevs) == 0:

            return revlog.revlog.__iter__(self)

        def filterediter():

            for i in xrange(len(self)):

                if i not in self.filteredrevs:

                    yield i

        return filterediter()

    def revs(self, start=0, stop=None):

        """filtered version of revlog.revs"""

        for i in super(changelog, self).revs(start, stop):

            if i not in self.filteredrevs:

                yield i

    @util.propertycache

    def nodemap(self):

        # XXX need filtering too

        self.rev(self.node(0))

        return self._nodecache

    def reachableroots(self, minroot, heads, roots, includepath=False):

        return self.index.reachableroots2(minroot, heads, roots, includepath)

    def headrevs(self):

        if self.filteredrevs:

            try:

                return self.index.headrevsfiltered(self.filteredrevs)

            # AttributeError covers non-c-extension environments and

            # old c extensions without filter handling.

            except AttributeError:

                return self._headrevs()

        return super(changelog, self).headrevs()

    def strip(self, *args, **kwargs):

        # XXX make something better than assert

        # We can't expect proper strip behavior if we are filtered.

        assert not self.filteredrevs

        super(changelog, self).strip(*args, **kwargs)

    def rev(self, node):

        """filtered version of revlog.rev"""

        r = super(changelog, self).rev(node)

        if r in self.filteredrevs:

            raise error.FilteredLookupError(hex(node), self.indexfile,

                                            _('filtered node'))

        return r

    def node(self, rev):

        """filtered version of revlog.node"""

        if rev in self.filteredrevs:

            raise error.FilteredIndexError(rev)

        return super(changelog, self).node(rev)

    def linkrev(self, rev):

        """filtered version of revlog.linkrev"""

        if rev in self.filteredrevs:

            raise error.FilteredIndexError(rev)

        return super(changelog, self).linkrev(rev)

    def parentrevs(self, rev):

        """filtered version of revlog.parentrevs"""

        if rev in self.filteredrevs:

            raise error.FilteredIndexError(rev)

        return super(changelog, self).parentrevs(rev)

    def flags(self, rev):

        """filtered version of revlog.flags"""

        if rev in self.filteredrevs:

            raise error.FilteredIndexError(rev)

        return super(changelog, self).flags(rev)

    def delayupdate(self, tr):

        "delay visibility of index updates to other readers"

        if not self._delayed:

            if len(self) == 0:

                self._divert = True

                if self._realopener.exists(self.indexfile + '.a'):

                    self._realopener.unlink(self.indexfile + '.a')

                self.opener = _divertopener(self._realopener, self.indexfile)

            else:

                self._delaybuf = []

                self.opener = _delayopener(self._realopener, self.indexfile,

                                           self._delaybuf)

        self._delayed = True

        tr.addpending('cl-%i' % id(self), self._writepending)

        tr.addfinalize('cl-%i' % id(self), self._finalize)

    def _finalize(self, tr):

        "finalize index updates"

        self._delayed = False

        self.opener = self._realopener

        # move redirected index data back into place

        if self._divert:

            assert not self._delaybuf

            tmpname = self.indexfile + ".a"

            nfile = self.opener.open(tmpname)

            nfile.close()

            self.opener.rename(tmpname, self.indexfile)

        elif self._delaybuf:

            fp = self.opener(self.indexfile, 'a')

            fp.write("".join(self._delaybuf))

            fp.close()

            self._delaybuf = None

        self._divert = False

        # split when we're done

        self.checkinlinesize(tr)

    def readpending(self, file):

        """read index data from a "pending" file

        During a transaction, the actual changeset data is already stored in the

        main file, but not yet finalized in the on-disk index. Instead, a

        "pending" index is written by the transaction logic. If this function

        is running, we are likely in a subprocess invoked in a hook. The

        subprocess is informed that it is within a transaction and needs to

        access its content.

        This function will read all the index data out of the pending file and

        overwrite the main index."""

        if not self.opener.exists(file):

            return # no pending data for changelog

        r = revlog.revlog(self.opener, file)

        self.index = r.index

        self.nodemap = r.nodemap

        self._nodecache = r._nodecache

        self._chunkcache = r._chunkcache

    def _writepending(self, tr):

        "create a file containing the unfinalized state for pretxnchangegroup"

        if self._delaybuf:

            # make a temporary copy of the index

            fp1 = self._realopener(self.indexfile)