# 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".

"""

import collections

import itertools

from mercurial.i18n import _

from mercurial.node import nullid, nullrev, bin, hex

from mercurial import changegroup, cmdutil, scmutil, phases, commands

from mercurial import error, hg, mdiff, merge, patch, repair, util

from mercurial import templatefilters, exchange, bundlerepo, bundle2

from mercurial import lock as lockmod

from hgext import rebase

import errno

cmdtable = {}

command = cmdutil.command(cmdtable)

# Note for extension authors: ONLY specify testedwith = 'internal' 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 = 'internal'

backupdir = 'shelve-backup'

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 = scmutil.vfs(repo.join('shelved'))

        self.backupvfs = scmutil.vfs(repo.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)

            if not isinstance(gen, bundle2.unbundle20):

                gen.apply(self.repo, 'unshelve',

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

                          targetphase=phases.secret)

            if isinstance(gen, bundle2.unbundle20):

                bundle2.applybundle(self.repo, gen,

                                    self.repo.currenttransaction(),

                                    source='unshelve',

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

        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):

        btype = 'HG10BZ'

        cgversion = '01'

        compression = None

        if 'generaldelta' in self.repo.requirements:

            btype = 'HG20'

            cgversion = '02'

            compression = 'BZ'

        cg = changegroup.changegroupsubset(self.repo, bases, [node], 'shelve',

                                           version=cgversion)

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

                                compression=compression)

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 = 1

    _filename = 'shelvedstate'

    @classmethod

    def load(cls, repo):

        fp = repo.vfs(cls._filename)

        try:

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

            if version != cls._version:

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

                                   'with the version used in this repo'))

            name = fp.readline().strip()

            wctx = fp.readline().strip()

            pendingctx = fp.readline().strip()

            parents = [bin(h) for h in fp.readline().split()]

            stripnodes = [bin(h) for h in fp.readline().split()]

        finally:

            fp.close()

        obj = cls()

        obj.name = name

        obj.wctx = repo[bin(wctx)]

        obj.pendingctx = repo[bin(pendingctx)]

        obj.parents = parents

        obj.stripnodes = stripnodes

        return obj

    @classmethod

    def save(cls, repo, name, originalwctx, pendingctx, stripnodes):

        fp = repo.vfs(cls._filename, 'wb')

        fp.write('%i\n' % cls._version)

        fp.write('%s\n' % name)

        fp.write('%s\n' % hex(originalwctx.node()))

        fp.write('%s\n' % hex(pendingctx.node()))

        fp.write('%s\n' % ' '.join([hex(p) for p in repo.dirstate.parents()]))

        fp.write('%s\n' % ' '.join([hex(n) for n in stripnodes]))

        fp.close()

    @classmethod

    def clear(cls, repo):

        util.unlinkpath(repo.join(cls._filename), ignoremissing=True)

def cleanupoldbackups(repo):

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

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

    hgfiles = [f for f in vfs.listdir() if f.endswith('.hg')]

    hgfiles = sorted([(vfs.stat(f).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[:-3]

        for ext in 'hg patch'.split():

            try:

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

            except OSError as err:

                if err.errno != errno.ENOENT:

                    raise

def _aborttransaction(repo):

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

    '''

    backupname = 'dirstate.shelve'

    dirstatebackup = None

    try:

        # create backup of (un)shelved dirstate, because aborting transaction

        # should restore dirstate to one at the beginning of the

        # transaction, which doesn't include the result of (un)shelving

        fp = repo.vfs.open(backupname, "w")

        dirstatebackup = backupname

        # clearing _dirty/_dirtypl of dirstate by _writedirstate below

        # is unintentional. but it doesn't cause problem in this case,

        # because no code path refers them until transaction is aborted.

        repo.dirstate._writedirstate(fp) # write in-memory changes forcibly

        tr = repo.currenttransaction()

        tr.abort()

        # restore to backuped dirstate

        repo.vfs.rename(dirstatebackup, 'dirstate')

        dirstatebackup = None

    finally:

        if dirstatebackup:

            repo.vfs.unlink(dirstatebackup)

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 _docreatecmd(ui, repo, pats, opts):

    def mutableancestors(ctx):

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

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

        seen = set([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)

    wctx = repo[None]

    parents = wctx.parents()

    if len(parents) > 1:

        raise error.Abort(_('cannot shelve while merging'))

    parent = parents[0]

    # we never need the user, so we use a generic user for all shelve operations

    user = 'shelve@localhost'

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

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

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

    def gennames():

        yield label

        for i in xrange(1, 100):

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

    def commitfunc(ui, repo, message, match, opts):

        hasmq = util.safehasattr(repo, 'mq')

        if hasmq:

            saved, repo.mq.checkapplied = repo.mq.checkapplied, False

        backup = repo.ui.backupconfig('phases', 'new-commit')

        try:

            repo.ui. setconfig('phases', 'new-commit', phases.secret)

            editor = cmdutil.getcommiteditor(editform='shelve.shelve', **opts)

            return repo.commit(message, user, opts.get('date'), match,

                               editor=editor)

        finally:

            repo.ui.restoreconfig(backup)

            if hasmq:

                repo.mq.checkapplied = saved

    if parent.node() != nullid:

        desc = "changes to: %s" % parent.description().split('\n', 1)[0]

    else:

        desc = '(changes in empty repository)'

    if not opts['message']:

        opts['message'] = desc

    name = opts['name']

    lock = tr = None

    try:

        lock = repo.lock()

        # use an uncommitted transaction to generate the bundle to avoid

        # pull races. ensure we don't print the abort message to stderr.

        tr = repo.transaction('commit', report=lambda x: None)

        if name:

            if shelvedfile(repo, name, 'hg').exists():

                raise error.Abort(_("a shelved change named '%s' already exists"

                                   ) % name)

        else:

            for n in gennames():

                if not shelvedfile(repo, n, 'hg').exists():

                    name = n

                    break

            else:

                raise error.Abort(_("too many shelved changes named '%s'") %

                                 label)

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

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

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

        if name.startswith('.'):

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

        interactive = opts.get('interactive', False)

        def interactivecommitfunc(ui, repo, *pats, **opts):

            match = scmutil.match(repo['.'], pats, {})

            message = opts['message']

            return commitfunc(ui, repo, message, match, opts)

        if not interactive:

            node = cmdutil.commit(ui, repo, commitfunc, pats, opts)

        else:

            node = cmdutil.dorecord(ui, repo, interactivecommitfunc, None,

                                    False, cmdutil.recordfilter, *pats, **opts)

        if not node:

            stat = repo.status(match=scmutil.match(repo[None], pats, opts))

            if stat.deleted:

                ui.status(_("nothing changed (%d missing files, see "

                            "'hg status')\n") % len(stat.deleted))

            else:

                ui.status(_("nothing changed\n"))

            return 1

        bases = list(mutableancestors(repo[node]))

        shelvedfile(repo, name, 'hg').writebundle(bases, node)

        cmdutil.export(repo, [node],

                       fp=shelvedfile(repo, name, 'patch').opener('wb'),

                       opts=mdiff.diffopts(git=True))

        if ui.formatted():

            desc = util.ellipsis(desc, ui.termwidth())

        ui.status(_('shelved as %s\n') % name)

        hg.update(repo, parent.node())

        _aborttransaction(repo)

    finally:

        lockmod.release(tr, lock)

def cleanupcmd(ui, repo):

    """subcommand that deletes all shelves"""

    with repo.wlock():

        for (name, _type) in repo.vfs.readdir('shelved'):

            suffix = name.rsplit('.', 1)[-1]

            if suffix in ('hg', 'patch'):

                shelvedfile(repo, name).movetobackup()

            cleanupoldbackups(repo)

def deletecmd(ui, repo, pats):

    """subcommand that deletes a specific shelve"""

    if not pats: