# shelve.py - save/restore working directory state

#

# Copyright 2013 Facebook, Inc.

#

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

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

"""save and restore changes to the working directory

The "hg shelve" command saves changes made to the working directory

and reverts those changes, resetting the working directory to a clean

state.

Later on, the "hg unshelve" command restores the changes saved by "hg

shelve". Changes can be restored even after updating to a different

parent, in which case Mercurial's merge machinery will resolve any

conflicts if necessary.

You can have more than one shelved change outstanding at a time; each

shelved change has a distinct name. For details, see the help for "hg

shelve".

"""

from __future__ import absolute_import

import collections

import errno

import itertools

import stat

from mercurial.i18n import _

from mercurial import (

    bookmarks,

    bundle2,

    bundlerepo,

    changegroup,

    cmdutil,

    discovery,

    error,

    exchange,

    hg,

    lock as lockmod,

    mdiff,

    merge,

    node as nodemod,

    patch,

    phases,

    pycompat,

    registrar,

    repair,

    scmutil,

    templatefilters,

    util,

    vfs as vfsmod,

)

from . import (

    rebase,

)

from mercurial.utils import dateutil

cmdtable = {}

command = registrar.command(cmdtable)

# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for

# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should

# be specifying the version(s) of Mercurial they are tested with, or

# leave the attribute unspecified.

testedwith = 'ships-with-hg-core'

configtable = {}

configitem = registrar.configitem(configtable)

configitem('shelve', 'maxbackups',

    default=10,

)

backupdir = 'shelve-backup'

shelvedir = 'shelved'

shelvefileextensions = ['hg', 'patch', 'oshelve']

# universal extension is present in all types of shelves

patchextension = 'patch'

# we never need the user, so we use a

# generic user for all shelve operations

shelveuser = 'shelve@localhost'

class shelvedfile(object):

    """Helper for the file storing a single shelve

    Handles common functions on shelve files (.hg/.patch) using

    the vfs layer"""

    def __init__(self, repo, name, filetype=None):

        self.repo = repo

        self.name = name

        self.vfs = vfsmod.vfs(repo.vfs.join(shelvedir))

        self.backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))

        self.ui = self.repo.ui

        if filetype:

            self.fname = name + '.' + filetype

        else:

            self.fname = name

    def exists(self):

        return self.vfs.exists(self.fname)

    def filename(self):

        return self.vfs.join(self.fname)

    def backupfilename(self):

        def gennames(base):

            yield base

            base, ext = base.rsplit('.', 1)

            for i in itertools.count(1):

                yield '%s-%d.%s' % (base, i, ext)

        name = self.backupvfs.join(self.fname)

        for n in gennames(name):

            if not self.backupvfs.exists(n):

                return n

    def movetobackup(self):

        if not self.backupvfs.isdir():

            self.backupvfs.makedir()

        util.rename(self.filename(), self.backupfilename())

    def stat(self):

        return self.vfs.stat(self.fname)

    def opener(self, mode='rb'):

        try:

            return self.vfs(self.fname, mode)

        except IOError as err:

            if err.errno != errno.ENOENT:

                raise

            raise error.Abort(_("shelved change '%s' not found") % self.name)

    def applybundle(self):

        fp = self.opener()

        try:

            gen = exchange.readbundle(self.repo.ui, fp, self.fname, self.vfs)

            bundle2.applybundle(self.repo, gen, self.repo.currenttransaction(),

                                source='unshelve',

                                url='bundle:' + self.vfs.join(self.fname),

                                targetphase=phases.secret)

        finally:

            fp.close()

    def bundlerepo(self):

        return bundlerepo.bundlerepository(self.repo.baseui, self.repo.root,

                                           self.vfs.join(self.fname))

    def writebundle(self, bases, node):

        cgversion = changegroup.safeversion(self.repo)

        if cgversion == '01':

            btype = 'HG10BZ'

            compression = None

        else:

            btype = 'HG20'

            compression = 'BZ'

        outgoing = discovery.outgoing(self.repo, missingroots=bases,

                                      missingheads=[node])

        cg = changegroup.makechangegroup(self.repo, outgoing, cgversion,

                                         'shelve')

        bundle2.writebundle(self.ui, cg, self.fname, btype, self.vfs,

                                compression=compression)

    def writeobsshelveinfo(self, info):

        scmutil.simplekeyvaluefile(self.vfs, self.fname).write(info)

    def readobsshelveinfo(self):

        return scmutil.simplekeyvaluefile(self.vfs, self.fname).read()

class shelvedstate(object):

    """Handle persistence during unshelving operations.

    Handles saving and restoring a shelved state. Ensures that different

    versions of a shelved state are possible and handles them appropriately.

    """

    _version = 2

    _filename = 'shelvedstate'

    _keep = 'keep'

    _nokeep = 'nokeep'

    # colon is essential to differentiate from a real bookmark name

    _noactivebook = ':no-active-bookmark'

    @classmethod

    def _verifyandtransform(cls, d):

        """Some basic shelvestate syntactic verification and transformation"""

        try:

            d['originalwctx'] = nodemod.bin(d['originalwctx'])

            d['pendingctx'] = nodemod.bin(d['pendingctx'])

            d['parents'] = [nodemod.bin(h)

                            for h in d['parents'].split(' ')]

            d['nodestoremove'] = [nodemod.bin(h)

                                  for h in d['nodestoremove'].split(' ')]

        except (ValueError, TypeError, KeyError) as err:

            raise error.CorruptedState(pycompat.bytestr(err))

    @classmethod

    def _getversion(cls, repo):

        """Read version information from shelvestate file"""

        fp = repo.vfs(cls._filename)

        try:

            version = int(fp.readline().strip())

        except ValueError as err:

            raise error.CorruptedState(pycompat.bytestr(err))

        finally:

            fp.close()

        return version

    @classmethod

    def _readold(cls, repo):

        """Read the old position-based version of a shelvestate file"""

        # Order is important, because old shelvestate file uses it

        # to detemine values of fields (i.g. name is on the second line,

        # originalwctx is on the third and so forth). Please do not change.

        keys = ['version', 'name', 'originalwctx', 'pendingctx', 'parents',

                'nodestoremove', 'branchtorestore', 'keep', 'activebook']

        # this is executed only seldomly, so it is not a big deal

        # that we open this file twice

        fp = repo.vfs(cls._filename)

        d = {}

        try:

            for key in keys:

                d[key] = fp.readline().strip()

        finally:

            fp.close()

        return d

    @classmethod

    def load(cls, repo):

        version = cls._getversion(repo)

        if version < cls._version:

            d = cls._readold(repo)

        elif version == cls._version:

            d = scmutil.simplekeyvaluefile(repo.vfs, cls._filename)\

                       .read(firstlinenonkeyval=True)

        else:

            raise error.Abort(_('this version of shelve is incompatible '

                                'with the version used in this repo'))

        cls._verifyandtransform(d)

        try:

            obj = cls()

            obj.name = d['name']

            obj.wctx = repo[d['originalwctx']]

            obj.pendingctx = repo[d['pendingctx']]

            obj.parents = d['parents']

            obj.nodestoremove = d['nodestoremove']

            obj.branchtorestore = d.get('branchtorestore', '')

            obj.keep = d.get('keep') == cls._keep

            obj.activebookmark = ''

            if d.get('activebook', '') != cls._noactivebook:

                obj.activebookmark = d.get('activebook', '')

        except (error.RepoLookupError, KeyError) as err:

            raise error.CorruptedState(pycompat.bytestr(err))

        return obj

    @classmethod

    def save(cls, repo, name, originalwctx, pendingctx, nodestoremove,

             branchtorestore, keep=False, activebook=''):

        info = {

            "name": name,

            "originalwctx": nodemod.hex(originalwctx.node()),

            "pendingctx": nodemod.hex(pendingctx.node()),

            "parents": ' '.join([nodemod.hex(p)

                                 for p in repo.dirstate.parents()]),

            "nodestoremove": ' '.join([nodemod.hex(n)

                                      for n in nodestoremove]),

            "branchtorestore": branchtorestore,

            "keep": cls._keep if keep else cls._nokeep,

            "activebook": activebook or cls._noactivebook

        }

        scmutil.simplekeyvaluefile(repo.vfs, cls._filename)\

               .write(info, firstline=("%d" % cls._version))

    @classmethod

    def clear(cls, repo):

        repo.vfs.unlinkpath(cls._filename, ignoremissing=True)

def cleanupoldbackups(repo):

    vfs = vfsmod.vfs(repo.vfs.join(backupdir))

    maxbackups = repo.ui.configint('shelve', 'maxbackups')

    hgfiles = [f for f in vfs.listdir()

               if f.endswith('.' + patchextension)]

    hgfiles = sorted([(vfs.stat(f)[stat.ST_MTIME], f) for f in hgfiles])

    if 0 < maxbackups and maxbackups < len(hgfiles):

        bordermtime = hgfiles[-maxbackups][0]

    else:

        bordermtime = None

    for mtime, f in hgfiles[:len(hgfiles) - maxbackups]:

        if mtime == bordermtime:

            # keep it, because timestamp can't decide exact order of backups

            continue

        base = f[:-(1 + len(patchextension))]

        for ext in shelvefileextensions:

            vfs.tryunlink(base + '.' + ext)

def _backupactivebookmark(repo):

    activebookmark = repo._activebookmark

    if activebookmark:

        bookmarks.deactivate(repo)

    return activebookmark

def _restoreactivebookmark(repo, mark):

    if mark:

        bookmarks.activate(repo, mark)

def _aborttransaction(repo):

    '''Abort current transaction for shelve/unshelve, but keep dirstate

    '''

    tr = repo.currenttransaction()

    backupname = 'dirstate.shelve'

    repo.dirstate.savebackup(tr, backupname)

    tr.abort()

    repo.dirstate.restorebackup(None, backupname)

def createcmd(ui, repo, pats, opts):

    """subcommand that creates a new shelve"""

    with repo.wlock():

        cmdutil.checkunfinished(repo)

        return _docreatecmd(ui, repo, pats, opts)

def getshelvename(repo, parent, opts):

    """Decide on the name this shelve is going to have"""

    def gennames():

        yield label

        for i in itertools.count(1):

            yield '%s-%02d' % (label, i)

    name = opts.get('name')

    label = repo._activebookmark or parent.branch() or 'default'

    # slashes aren't allowed in filenames, therefore we rename it

    label = label.replace('/', '_')

    label = label.replace('\\', '_')

    # filenames must not start with '.' as it should not be hidden

    if label.startswith('.'):

        label = label.replace('.', '_', 1)

    if name:

        if shelvedfile(repo, name, patchextension).exists():

            e = _("a shelved change named '%s' already exists") % name

            raise error.Abort(e)

        # ensure we are not creating a subdirectory or a hidden file

        if '/' in name or '\\' in name:

            raise error.Abort(_('shelved change names can not contain slashes'))

        if name.startswith('.'):

            raise error.Abort(_("shelved change names can not start with '.'"))

    else:

        for n in gennames():

            if not shelvedfile(repo, n, patchextension).exists():

                name = n

                break

    return name

def mutableancestors(ctx):

    """return all mutable ancestors for ctx (included)

    Much faster than the revset ancestors(ctx) & draft()"""

    seen = {nodemod.nullrev}

    visit = collections.deque()

    visit.append(ctx)

    while visit:

        ctx = visit.popleft()

        yield ctx.node()

        for parent in ctx.parents():

            rev = parent.rev()

            if rev not in seen:

                seen.add(rev)

                if parent.mutable():

                    visit.append(parent)