# states.py - introduce the state concept for mercurial changeset

#

# Copyright 2011 Peter Arrenbrecht <peter.arrenbrecht@gmail.com>

#                Logilab SA        <contact@logilab.fr>

#                Pierre-Yves David <pierre-yves.david@ens-lyon.org>

#

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

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

'''a set of commands to handle changeset mutation'''

from mercurial import cmdutil

from mercurial import scmutil

from mercurial import node

from mercurial import error

from mercurial import extensions

from mercurial import commands

from mercurial import bookmarks

from mercurial import phases

from mercurial import commands

from mercurial import context

from mercurial import copies

from mercurial import util

from mercurial.i18n import _

from mercurial.commands import walkopts, commitopts, commitopts2, logopts

from mercurial import hg

### util function

#############################

def noderange(repo, revsets):

    """The same as revrange but return node"""

    return map(repo.changelog.node,

               scmutil.revrange(repo, revsets))

### changeset rewriting logic

#############################

def rewrite(repo, old, updates, head, newbases, commitopts):

    """Return (nodeid, created) where nodeid is the identifier of the

    changeset generated by the rewrite process, and created is True if

    nodeid was actually created. If created is False, nodeid

    references a changeset existing before the rewrite call.

    """

    if len(old.parents()) > 1: #XXX remove this unecessary limitation.

        raise error.Abort(_('cannot amend merge changesets'))

    base = old.p1()

    updatebookmarks = _bookmarksupdater(repo, old.node())

    wlock = repo.wlock()

    try:

        # commit a new version of the old changeset, including the update

        # collect all files which might be affected

        files = set(old.files())

        for u in updates:

            files.update(u.files())

        # Recompute copies (avoid recording a -> b -> a)

        copied = copies.pathcopies(base, head)

        # prune files which were reverted by the updates

        def samefile(f):

            if f in head.manifest():

                a = head.filectx(f)

                if f in base.manifest():

                    b = base.filectx(f)

                    return (a.data() == b.data()

                            and a.flags() == b.flags())

                else:

                    return False

            else:

                return f not in base.manifest()

        files = [f for f in files if not samefile(f)]

        # commit version of these files as defined by head

        headmf = head.manifest()

        def filectxfn(repo, ctx, path):

            if path in headmf:

                fctx = head[path]

                flags = fctx.flags()

                mctx = context.memfilectx(fctx.path(), fctx.data(),

                                          islink='l' in flags,

                                          isexec='x' in flags,

                                          copied=copied.get(path))

                return mctx

            raise IOError()

        if commitopts.get('message') and commitopts.get('logfile'):

            raise util.Abort(_('options --message and --logfile are mutually'

                               ' exclusive'))

        if commitopts.get('logfile'):

            message= open(commitopts['logfile']).read()

        elif commitopts.get('message'):

            message = commitopts['message']

        else:

            message = old.description()

        user = commitopts.get('user') or old.user()

        date = commitopts.get('date') or None # old.date()

        extra = dict(commitopts.get('extra', {}))

        extra['branch'] = head.branch()

        new = context.memctx(repo,

                             parents=newbases,

                             text=message,

                             files=files,

                             filectxfn=filectxfn,

                             user=user,

                             date=date,

                             extra=extra)

        if commitopts.get('edit'):

            new._text = cmdutil.commitforceeditor(repo, new, [])

        revcount = len(repo)

        newid = repo.commitctx(new)

        new = repo[newid]

        created = len(repo) != revcount

        if created:

            updatebookmarks(newid)

            # add evolution metadata

            markers = [(u, (new,)) for u in updates]

            markers.append((old, (new,)))

            obsolete = extensions.find('obsolete')

            obsolete.createmarkers(repo, markers)

        else:

            # newid is an existing revision. It could make sense to

            # replace revisions with existing ones but probably not by

            # default.

            pass

    finally:

        wlock.release()

    return newid, created

def relocate(repo, orig, dest):

    """rewrite <rev> on dest"""

    try:

        rebase = extensions.find('rebase')

        # dummy state to trick rebase node

        assert orig.p2().rev() == node.nullrev, 'no support yet'

        destbookmarks = repo.nodebookmarks(dest.node())

        cmdutil.duplicatecopies(repo, orig.node(), dest.node())

        nodesrc = orig.node()

        destphase = repo[nodesrc].phase()

        if rebase.rebasenode.func_code.co_argcount == 5:

            # rebasenode collapse argument was introduced by

            # d1afbf03e69a (2.3)

            rebase.rebasenode(repo, orig.node(), dest.node(),

                              {node.nullrev: node.nullrev}, False)

        else:

            rebase.rebasenode(repo, orig.node(), dest.node(),

                              {node.nullrev: node.nullrev})

        try:

            nodenew = rebase.concludenode(repo, orig.node(), dest.node(),

                                          node.nullid)

        except util.Abort:

            repo.ui.write_err(_('/!\\ stabilize failed                          /!\\\n'))

            repo.ui.write_err(_('/!\\ Their is no "hg stabilize --continue"     /!\\\n'))

            repo.ui.write_err(_('/!\\ use "hg up -C . ; hg stabilize --dry-run" /!\\\n'))

            raise

        oldbookmarks = repo.nodebookmarks(nodesrc)

        obsolete = extensions.find('obsolete')

        if nodenew is not None:

            phases.retractboundary(repo, destphase, [nodenew])

            obsolete.createmarkers(repo, [(repo[nodesrc], (repo[nodenew],))])

            for book in oldbookmarks:

                repo._bookmarks[book] = nodenew

        else:

            obsolete.createmarkers(repo, [(repo[nodesrc], ())])

            # Behave like rebase, move bookmarks to dest

            for book in oldbookmarks:

                repo._bookmarks[book] = dest.node()

        for book in destbookmarks: # restore bookmark that rebase move

            repo._bookmarks[book] = dest.node()

        if oldbookmarks or destbookmarks:

            bookmarks.write(repo)

    except util.Abort:

        # Invalidate the previous setparents

        repo.dirstate.invalidate()

        raise

def stabilizableunstable(repo, pctx):

    """Return a changectx for an unstable changeset which can be

    stabilized on top of pctx or one of its descendants. None if none

    can be found.

    """

    def selfanddescendants(repo, pctx):

        yield pctx

        for ctx in pctx.descendants():

            yield ctx

    # Look for an unstable which can be stabilized as a child of

    # node. The unstable must be a child of one of node predecessors.

    for ctx in selfanddescendants(repo, pctx):

        unstables = list(repo.set('unstable() and children(allprecursors(%d))',

                                  ctx.rev()))

        if unstables:

            return unstables[0]

    return None

def _bookmarksupdater(repo, oldid):

    """Return a callable update(newid) updating the current bookmark

    and bookmarks bound to oldid to newid.

    """

    bm = bookmarks.readcurrent(repo)

    def updatebookmarks(newid):

        dirty = False

        if bm:

            repo._bookmarks[bm] = newid

            dirty = True

        oldbookmarks = repo.nodebookmarks(oldid)

        if oldbookmarks:

            for b in oldbookmarks:

                repo._bookmarks[b] = newid

            dirty = True

        if dirty:

            bookmarks.write(repo)

    return updatebookmarks

### new command

#############################

cmdtable = {}

command = cmdutil.command(cmdtable)

@command('^stabilize|evolve|solve',

    [('n', 'dry-run', False, 'do not perform actions, print what to be done'),

    ('A', 'any', False, 'stabilize any unstable changeset'),],

    _('[OPTIONS]...'))

def stabilize(ui, repo, **opts):

    """rebase an unstable changeset to make it stable again

    By default, take the first unstable changeset which could be

    rebased as child of the working directory parent revision or one

    of its descendants and rebase it.

    With --any, stabilize any unstable changeset.

    The working directory is updated to the rebased revision.

    """

    obsolete = extensions.find('obsolete')

    node = None

    if not opts['any']:

        node = stabilizableunstable(repo, repo['.'])

    if node is None:

        unstables = list(repo.set('unstable()'))

        if unstables and not opts['any']:

            ui.write_err(_('nothing to stabilize here\n'))

            ui.status(_('(%i unstable changesets, do you want --any ?)\n')

                      % len(unstables))

            return 2

        elif not unstables:

            ui.write_err(_('no unstable changeset\n'))

            return 1

        node = unstables[0]

    obs = node.parents()[0]

    if not obs.obsolete():

        obs = node.parents()[1]

    assert obs.obsolete()

    newer = obsolete.newerversion(repo, obs.node())

    if len(newer) > 1:

        ui.write_err(_("conflict rewriting. can't choose destination\n"))

        return 2

    targets = newer[0]

    if not targets:

        ui.write_err(_("does not handle kill parent yet\n"))

        return 2

    if len(targets) > 1:

        ui.write_err(_("does not handle splitted parent yet\n"))

        return 2

    target = targets[0]

    displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

    target = repo[target]

    repo.ui.status(_('move:'))

    if not ui.quiet:

        displayer.show(node)

    repo.ui.status(_('atop:'))

    if not ui.quiet:

        displayer.show(target)

    todo= 'hg rebase -Dr %s -d %s\n' % (node, target)

    if opts['dry_run']:

        repo.ui.write(todo)

    else:

        repo.ui.note(todo)

        lock = repo.lock()

        try:

            relocate(repo, node, target)

        finally:

            lock.release()

shorttemplate = '[{rev}] {desc|firstline}\n'

@command('^gdown',

         [],

         '')

def cmdgdown(ui, repo):

    """update to parent an display summary lines"""

    wkctx = repo[None]

    wparents = wkctx.parents()

    if len(wparents) != 1:

        raise util.Abort('merge in progress')

    parents = wparents[0].parents()

    displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

    if len(parents) == 1:

        p = parents[0]

        hg.update(repo, p.rev())

        displayer.show(p)

        return 0

    else:

        for p in parents:

            displayer.show(p)

        ui.warn(_('multiple parents, explicitly update to one\n'))

        return 1

@command('^gup',

         [],

         '')

def cmdup(ui, repo):

    """update to child an display summary lines"""

    wkctx = repo[None]

    wparents = wkctx.parents()

    if len(wparents) != 1:

        raise util.Abort('merge in progress')

    children = [ctx for ctx in wparents[0].children() if not ctx.obsolete()]

    displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

    if not children:

        ui.warn(_('No non-obsolete children\n'))

        return 1

    if len(children) == 1:

        c = children[0]

        hg.update(repo, c.rev())

        displayer.show(c)

        return 0

    else:

        for c in children:

            displayer.show(c)

        ui.warn(_('Multiple non-obsolete children, explicitly update to one\n'))

        return 1

@command('^prune|obsolete|kill',

    [('n', 'new', [], _("successor changeset"))],

    _('[OPTION] REV...'))

def kill(ui, repo, *revs, **opts):

    """mark a changeset as obsolete

    This update the parent directory to a not-killed parent if the current

    working directory parent are killed.

    XXX bookmark support

    XXX handle merge

    XXX check immutable first

    """

    wlock = repo.wlock()

    try:

        lock = repo.lock()

        try:

            new = set(noderange(repo, opts['new']))

            targetnodes = set(noderange(repo, revs))

            if new:

                sucs = tuple(repo[n] for n in new)

            else:

                sucs = ()

            markers = []

            for n in targetnodes:

                markers.append((repo[n], sucs))

            obsolete = extensions.find('obsolete')

            obsolete.createmarkers(repo, markers)