view hgext/qsync.py @ 751:a5474648a9d2

gdown/gup: add next/previous alias

Up and down refer to the customary order in log output rather than
concepts; as such, it may be confusing to the user. I for one found
them suprising -- they just didn't fit with my mental model.

Previous and next, however, imply a clear parent/child relationship.

We attroduce the new name as aliases for now.

# Copyright 2011 Logilab SA <[e-mail]>
"""synchronize patches queues and evolving changesets"""

import re
from cStringIO import StringIO
import json

from mercurial.i18n import _
from mercurial import commands
from mercurial import patch
from mercurial import util
from mercurial.node import nullid, hex, short, bin
from mercurial import cmdutil
from mercurial import hg
from mercurial import scmutil
from mercurial import error
from mercurial import extensions
from mercurial import phases
from mercurial import obsolete

### old compat code
#############################

BRANCHNAME="qsubmit2"

### new command
#############################
cmdtable = {}
command = cmdutil.command(cmdtable)

@command('^qsync|sync',
    [
     ('a', 'review-all', False, _('mark all touched patches ready for review (no editor)')),
    ],
    '')
def cmdsync(ui, repo, **opts):
    '''Export draft changeset as mq patch in a mq patches repository commit.

    This command get all changesets in draft phase and create an mq changeset:

        * on a "qsubmit2" branch (based on the last changeset)

        * one patch per draft changeset

        * a series files listing all generated patch

        * qsubmitdata holding useful information

    It does use obsolete relation to update patches that already existing in the qsubmit2 branch.

    Already existing patch which became public, draft or got killed are remove from the mq repo.

    Patch name are generated using the summary line for changeset description.

    .. warning:: Series files is ordered topologically. So two series with
                 interleaved changeset will appear interleaved.
    '''

    review = 'edit'
    if opts['review_all']:
        review = 'all'
    mqrepo = repo.mq.qrepo()
    if mqrepo is None:
        raise util.Abort('No patches repository')

    try:
        parent = mqrepo[BRANCHNAME]
    except error.RepoLookupError:
        parent = initqsubmit(mqrepo)
    store, data, touched = fillstore(repo, parent)
    try:
        if not touched:
            raise util.Abort('Nothing changed')
        files = ['qsubmitdata', 'series'] + touched
        # mark some as ready for review
        message = 'qsubmit commit\n\n'
        review_list = []
        applied_list = []
        if review:
            olddata = get_old_data(parent)
            oldfiles = dict([(name, bin(ctxhex)) for ctxhex, name in olddata])

            for patch_name in touched:
                try:
                    store.getfile(patch_name)
                    review_list.append(patch_name)
                except IOError:
                    oldnode = oldfiles[patch_name]
                    newnodes = obsolete.successorssets(repo, oldnode)
                    if newnodes:
                        newnodes = [n for n in newnodes if n and n[0] in repo] # remove killing
                    if not newnodes:
                        # changeset has been killed (eg. reject)
                        pass
                    else:
                        assert len(newnodes) == 1 # conflict!!!
                        newnode = newnodes[0]
                        assert len(newnode) == 1 # split unsupported for now
                        newnode = list(newnode)[0]
                        # XXX unmanaged case where a cs is obsoleted by an unavailable one
                        #if newnode.node() not in repo.changelog.nodemap:
                        #    raise util.Abort('%s is obsoleted by an unknown node %s'% (oldnode, newnode))
                        ctx = repo[newnode]
                        if ctx.phase() == phases.public:
                            # applied
                            applied_list.append(patch_name)
                        elif ctx.phase() == phases.secret:
                            # already exported changeset is now secret
                            repo.ui.warn("An already exported changeset is now secret!!!")
                        else:
                            # draft
                            assert False, "Should be exported"

        if review:
            if applied_list:
                message += '\n'.join('* applied %s' % x for x in applied_list) + '\n'
            if review_list:
                message += '\n'.join('* %s ready for review' % x for x in review_list) + '\n'
        memctx = patch.makememctx(mqrepo, (parent.node(), nullid),
                                  message,
                                  None,
                                  None,
                                  parent.branch(), files, store,
                                  editor=None)
        if review == 'edit':
            memctx._text = cmdutil.commitforceeditor(mqrepo, memctx, [])
        mqrepo.savecommitmessage(memctx.description())
        n = memctx.commit()
    finally:
        store.close()
    return 0


def makename(ctx):
    """create a patch name form a changeset"""
    descsummary = ctx.description().splitlines()[0]
    descsummary = re.sub(r'\s+', '_', descsummary)
    descsummary = re.sub(r'\W+', '', descsummary)
    if len(descsummary) > 45:
        descsummary = descsummary[:42] + '.'
    return '%s-%s.diff' % (ctx.branch().upper(), descsummary)


def get_old_data(mqctx):
    """read qsubmit data to fetch previous export data

    get old data from the content of an mq commit"""
    try:
        old_data = mqctx['qsubmitdata']
        return json.loads(old_data.data())
    except error.LookupError:
        return []

def get_current_data(repo):
    """Return what would be exported if no previous data exists"""
    data = []
    for ctx in repo.set('draft() - (obsolete() + merge())'):
        name = makename(ctx)
        data.append([ctx.hex(), makename(ctx)])
    merges = repo.revs('draft() and merge()')
    if merges:
        repo.ui.warn('ignoring %i merge\n' % len(merges))
    return data


def patchmq(repo, store, olddata, newdata):
    """export the mq patches and return all useful data to be exported"""
    finaldata = []
    touched = set()
    currentdrafts = set(d[0] for d in newdata)
    usednew = set()
    usedold = set()
    evolve = extensions.find('evolve')
    for oldhex, oldname in olddata:
        if oldhex in usedold:
            continue # no duplicate
        usedold.add(oldhex)
        oldname = str(oldname)
        oldnode = bin(oldhex)
        newnodes = obsolete.successorssets(repo, oldnode)
        if newnodes:
            newnodes = [n for n in newnodes if n and n[0] in repo] # remove killing
            if len(newnodes) > 1:
                newnodes = [short(nodes[0]) for nodes in newnodes]
                raise util.Abort('%s have more than one newer version: %s'% (oldname, newnodes))
            if newnodes:
                # else, changeset have been killed
                newnode = list(newnodes)[0][0]
                ctx = repo[newnode]
                if ctx.hex() != oldhex and ctx.phase():
                    fp = StringIO()
                    cmdutil.export(repo, [ctx.rev()], fp=fp)
                    data = fp.getvalue()
                    store.setfile(oldname, data, (None, None))
                    finaldata.append([ctx.hex(), oldname])
                    usednew.add(ctx.hex())
                    touched.add(oldname)
                    continue
        if oldhex in currentdrafts:
            # else changeset is now public or secret
            finaldata.append([oldhex, oldname])
            usednew.add(ctx.hex())
            continue
        touched.add(oldname)

    for newhex, newname in newdata:
        if newhex in usednew:
            continue
        newnode = bin(newhex)
        ctx = repo[newnode]
        fp = StringIO()
        cmdutil.export(repo, [ctx.rev()], fp=fp)
        data = fp.getvalue()
        store.setfile(newname, data, (None, None))
        finaldata.append([ctx.hex(), newname])
        touched.add(newname)
    # sort by branchrev number
    finaldata.sort(key=lambda x: sort_key(repo[x[0]]))
    # sort touched too (ease review list)
    stouched = [f[1] for f in finaldata if f[1] in touched]
    stouched += [x for x in touched if x not in stouched]
    return finaldata, stouched

def sort_key(ctx):
    """ctx sort key: (branch, rev)"""
    return (ctx.branch(), ctx.rev())


def fillstore(repo, basemqctx):
    """fill store with patch data"""
    olddata = get_old_data(basemqctx)
    newdata = get_current_data(repo)
    store = patch.filestore()
    try:
        data, touched = patchmq(repo, store, olddata, newdata)
        # put all name in the series
        series ='\n'.join(d[1] for d in data) + '\n'
        store.setfile('series', series, (False, False))

        # export data to ease futur work
        store.setfile('qsubmitdata', json.dumps(data, indent=True),
                      (False, False))
    except:
        store.close()
	raise
    return store, data, touched


def initqsubmit(mqrepo):
    """create initial qsubmit branch"""
    store = patch.filestore()
    try:
        files = set()
        store.setfile('DO-NOT-EDIT-THIS-WORKING-COPY-BY-HAND', 'WE WARNED YOU!', (False, False))
        store.setfile('.hgignore', '^status$\n', (False, False))
        memctx = patch.makememctx(mqrepo, (nullid, nullid),
                              'qsubmit init',
                              None,
                              None,
                              BRANCHNAME, ('.hgignore',), store,
                              editor=None)
        mqrepo.savecommitmessage(memctx.description())
        n = memctx.commit()
    finally:
        store.close()
    return mqrepo[n]