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

from mercurial import lock as lockmod

from hgext import rebase

import errno

cmdtable = {}

command = cmdutil.command(cmdtable)

testedwith = 'internal'

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.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 unlink(self):

        util.unlink(self.filename())

    def stat(self):

        return self.vfs.stat(self.fname)

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

        try:

            return self.vfs(self.fname, mode)

        except IOError, err:

            if err.errno != errno.ENOENT:

                raise

            raise util.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)

            changegroup.addchangegroup(self.repo, gen, 'unshelve',

                                       '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, cg):

        changegroup.writebundle(self.ui, cg, self.fname, 'HG10UN', self.vfs)

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

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

    def publicancestors(ctx):

        """Compute the public ancestors of a commit.

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

        seen = set([nullrev])

        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 util.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']

    wlock = lock = tr = bms = None

    try:

        wlock = repo.wlock()

        lock = repo.lock()

        bms = repo._bookmarks.copy()

        # 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 util.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 util.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 util.Abort(_('shelved change names may not contain slashes'))

        if name.startswith('.'):

            raise util.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, 'commit',

                                    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(publicancestors(repo[node]))

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

        shelvedfile(repo, name, 'hg').writebundle(cg)

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

    finally:

        if bms:

            # restore old bookmarks

            repo._bookmarks.update(bms)

            repo._bookmarks.write()

        if tr:

            tr.abort()

        lockmod.release(lock, wlock)

def cleanupcmd(ui, repo):

    """subcommand that deletes all shelves"""

    wlock = None

    try:

        wlock = repo.wlock()

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

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

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

                shelvedfile(repo, name).unlink()

    finally:

        lockmod.release(wlock)

def deletecmd(ui, repo, pats):

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

    if not pats:

        raise util.Abort(_('no shelved changes specified!'))

    wlock = repo.wlock()

    try:

        for name in pats:

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

                shelvedfile(repo, name, suffix).unlink()

    except OSError, err:

        if err.errno != errno.ENOENT:

            raise

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

    finally:

        lockmod.release(wlock)

def listshelves(repo):

    """return all shelves in repo as list of (time, filename)"""

    try:

        names = repo.vfs.readdir('shelved')

    except OSError, err:

        if err.errno != errno.ENOENT:

            raise

        return []

    info = []

    for (name, _type) in names:

        pfx, sfx = name.rsplit('.', 1)

        if not pfx or sfx != 'patch':

            continue

        st = shelvedfile(repo, name).stat()

        info.append((st.st_mtime, shelvedfile(repo, pfx).filename()))

    return sorted(info, reverse=True)

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

    """subcommand that displays the list of shelves"""

    pats = set(pats)

    width = 80

    if not ui.plain():

        width = ui.termwidth()

    namelabel = 'shelve.newest'

    for mtime, name in listshelves(repo):

        sname = util.split(name)[1]

        if pats and sname not in pats:

            continue

        ui.write(sname, label=namelabel)

        namelabel = 'shelve.name'

        if ui.quiet:

            ui.write('\n')

            continue

        ui.write(' ' * (16 - len(sname)))

        used = 16

        age = '(%s)' % templatefilters.age(util.makedate(mtime), abbrev=True)

        ui.write(age, label='shelve.age')

        ui.write(' ' * (12 - len(age)))

        used += 12

        fp = open(name + '.patch', 'rb')

        try:

            while True:

                line = fp.readline()

                if not line:

                    break

                if not line.startswith('#'):

                    desc = line.rstrip()

                    if ui.formatted():

                        desc = util.ellipsis(desc, width - used)

                    ui.write(desc)

                    break

            ui.write('\n')

            if not (opts['patch'] or opts['stat']):

                continue

            difflines = fp.readlines()

            if opts['patch']:

                for chunk, label in patch.difflabel(iter, difflines):

                    ui.write(chunk, label=label)

            if opts['stat']:

                for chunk, label in patch.diffstatui(difflines, width=width,

                                                     git=True):

                    ui.write(chunk, label=label)

        finally:

            fp.close()

def singlepatchcmds(ui, repo, pats, opts, subcommand):

    """subcommand that displays a single shelf"""

    if len(pats) != 1:

        raise util.Abort(_("--%s expects a single shelf") % subcommand)