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

def warnunstable(orig, ui, repo, *args, **kwargs):

    """display warning is the command resulted in more instable changeset"""

    priorunstables = len(repo.revs('unstable()'))

    #print orig, priorunstables

    #print len(repo.revs('secret() - obsolete()'))

    try:

        return orig(ui, repo, *args, **kwargs)

    finally:

        newunstables = len(repo.revs('unstable()')) - priorunstables

        #print orig, newunstables

        #print len(repo.revs('secret() - obsolete()'))

        if newunstables > 0:

            ui.warn(_('%i new unstables changesets\n') % newunstables)

### extension check

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

### changeset rewriting logic

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

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

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

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

    base = old.p1()

    bm = bookmarks.readcurrent(repo)

    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, [])

        newid = repo.commitctx(new)

        new = repo[newid]

    finally:

        wlock.release()

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

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

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

        repo.addobsolete(nodenew, nodesrc)

        oldbookmarks = repo.nodebookmarks(nodesrc)

        for book in oldbookmarks:

            repo._bookmarks[book] = nodenew

        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

### new command

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

cmdtable = {}

command = cmdutil.command(cmdtable)

@command('^stabilize',

    [

     ('n', 'dry-run', False, 'Do nothing but printing what should be done'),

     ('A', 'any', False, 'Stabilize unstable change on any topological branch'),

    ],

    '')

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

    """move changeset out of the unstable state

    By default only works on changeset that will be rebase on ancestors of the

    current working directory parent (included)"""

    obsolete = extensions.find('obsolete')

    if opts['any']:

        rvstargets = 'unstable()'

    else:

        rvstargets = 'unstable() and ((suspended() and obsancestors(::.))::)'

    unstable = list(repo.set(rvstargets))

    if not unstable:

        unstable = opts['any'] and () or list(repo.set('unstable()'))

        if unstable:

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

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

                      % len(unstable))

            return 2

        else:

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

            return 1

    node = unstable[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',

    [],

    'update to working directory parent and display summary lines')

def cmdgdown(ui, repo):

    """update to working directory 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',

    [],

    'update to working directory children and display summary lines')

def cmdup(ui, repo):

    """update to working directory children 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('^kill',

    [

    ('n', 'new', [], _("New changeset that justify this one to be killed"))

    ],

    '<revs>')

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:

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

        targetnodes = set(noderange(repo, revs))

        if not new:

            new = [node.nullid]

        for n in targetnodes:

            if not repo[n].mutable():

                ui.warn(_("Can't kill immutable changeset %s") % repo[n])

            else:

                for ne in new:

                    repo.addobsolete(ne, n)

        # update to an unkilled parent

        wdp = repo['.']

        newnode = wdp

        while newnode.obsolete():

            newnode = newnode.parents()[0]

        if newnode.node() != wdp.node():

            commands.update(ui, repo, newnode.rev())

            ui.status(_('working directory now at %s\n') % newnode)

    finally:

        wlock.release()

@command('^amend|refresh',

    [('A', 'addremove', None,

     _('mark new/missing files as added/removed before committing')),

    ('n', 'note', '',

     _('use text as commit message for this update')),

    ('c', 'change', '',

     _('specifies the changeset to amend'), _('REV')),

    ('e', 'edit', False,

     _('edit commit message.'), _('')),

    ] + walkopts + commitopts + commitopts2,

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

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