evolve: comparison hgext/evolve.py

equal deleted inserted replaced

-:91b6a30424a3
+:bca3fce56b2c
 this feature,
 - improves some aspect of the early implementation in Mercurial core
 '''
 __version__ = '5.2.0'
-testedwith = '3.3.3 3.4.1'
+testedwith = '3.4.3 3.5.2 3.6'
 buglink = 'http://bz.selenic.com/'
 evolutionhelptext = """
 Obsolescence markers make it possible to mark changesets that have been
 import errno
 sha1re = re.compile(r'\b[0-9a-f]{6,40}\b')
 import mercurial
 from mercurial import util
+from mercurial import repair
 try:
 from mercurial import obsolete
 if not obsolete._enabled:
 obsolete._enabled = True
 """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.
+wlock = lock = tr = None
-raise error.Abort(_('cannot amend merge changesets'))
+try:
-base = old.p1()
+wlock = repo.wlock()
-updatebookmarks = _bookmarksupdater(repo, old.node())
+lock = repo.lock()
+tr = repo.transaction('rewrite')
-# commit a new version of the old changeset, including the update
+if len(old.parents()) > 1: #XXX remove this unecessary limitation.
-# collect all files which might be affected
+raise error.Abort(_('cannot amend merge changesets'))
-files = set(old.files())
+base = old.p1()
-for u in updates:
+updatebookmarks = _bookmarksupdater(repo, old.node(), tr)
-files.update(u.files())
+# commit a new version of the old changeset, including the update
-# Recompute copies (avoid recording a -> b -> a)
+# collect all files which might be affected
-copied = copies.pathcopies(base, head)
+files = set(old.files())
+for u in updates:
+files.update(u.files())
-# prune files which were reverted by the updates
-def samefile(f):
+# Recompute copies (avoid recording a -> b -> a)
-if f in head.manifest():
+copied = copies.pathcopies(base, head)
-a = head.filectx(f)
-if f in base.manifest():
-b = base.filectx(f)
+# prune files which were reverted by the updates
-return (a.data() == b.data()
+def samefile(f):
-and a.flags() == b.flags())
+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 False
+return f not in base.manifest()
-else:
+files = [f for f in files if not samefile(f)]
-return f not in base.manifest()
+# commit version of these files as defined by head
-files = [f for f in files if not samefile(f)]
+headmf = head.manifest()
-# commit version of these files as defined by head
+def filectxfn(repo, ctx, path):
-headmf = head.manifest()
+if path in headmf:
-def filectxfn(repo, ctx, path):
+fctx = head[path]
-if path in headmf:
+flags = fctx.flags()
-fctx = head[path]
+mctx = memfilectx(repo, fctx.path(), fctx.data(),
-flags = fctx.flags()
+islink='l' in flags,
-mctx = memfilectx(repo, fctx.path(), fctx.data(),
+isexec='x' in flags,
-islink='l' in flags,
+copied=copied.get(path))
-isexec='x' in flags,
+return mctx
-copied=copied.get(path))
+return None
-return mctx
-return None
+message = cmdutil.logmessage(repo.ui, commitopts)
+if not message:
-message = cmdutil.logmessage(repo.ui, commitopts)
+message = old.description()
-if not message:
-message = old.description()
+user = commitopts.get('user') or old.user()
+date = commitopts.get('date') or None # old.date()
-user = commitopts.get('user') or old.user()
+extra = dict(commitopts.get('extra', old.extra()))
-date = commitopts.get('date') or None # old.date()
+extra['branch'] = head.branch()
-extra = dict(commitopts.get('extra', {}))
-extra['branch'] = head.branch()
+new = context.memctx(repo,
+parents=newbases,
-new = context.memctx(repo,
+text=message,
-parents=newbases,
+files=files,
-text=message,
+filectxfn=filectxfn,
-files=files,
+user=user,
-filectxfn=filectxfn,
+date=date,
-user=user,
+extra=extra)
-date=date,
-extra=extra)
+if commitopts.get('edit'):
+new._text = cmdutil.commitforceeditor(repo, new, [])
-if commitopts.get('edit'):
+revcount = len(repo)
-new._text = cmdutil.commitforceeditor(repo, new, [])
+newid = repo.commitctx(new)
-revcount = len(repo)
+new = repo[newid]
-newid = repo.commitctx(new)
+created = len(repo) != revcount
-new = repo[newid]
+updatebookmarks(newid)
-created = len(repo) != revcount
-updatebookmarks(newid)
+tr.close()
+return newid, created
-return newid, created
+finally:
+lockmod.release(lock, wlock, tr)
 class MergeFailure(util.Abort):
 pass
 def relocate(repo, orig, dest, keepbranch=False):
 if r[-1]:  #some conflict
 raise util.Abort(
 'unresolved merge conflicts (see hg help resolve)')
 if commitmsg is None:
 commitmsg = orig.description()
-extra = {'rebase_source': orig.hex()}
+extra = dict(orig.extra())
+if 'branch' in extra:
+del extra['branch']
+extra['rebase_source'] = orig.hex()
 backup = repo.ui.backupconfig('phases', 'new-commit')
 try:
 targetphase = max(orig.phase(), phases.draft)
 repo.ui.setconfig('phases', 'new-commit', targetphase, 'rebase')
 finally:
 repo.ui.restoreconfig(backup)
 except util.Abort, exc:
 repo.dirstate.beginparentchange()
 repo.setparents(repo['.'].node(), nullid)
-repo.dirstate.write()
+writedirstate(repo.dirstate, tr)
 # fix up dirstate for copies and renames
 copies.duplicatecopies(repo, dest.rev(), orig.p1().rev())
 repo.dirstate.endparentchange()
 class LocalMergeFailure(MergeFailure, exc.__class__):
 pass
 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:
-repo._bookmarks.write()
+repo._bookmarks.recordchange(tr)
 tr.close()
 finally:
 tr.release()
 return nodenew
-def _bookmarksupdater(repo, oldid):
+def _bookmarksupdater(repo, oldid, tr):
 """Return a callable update(newid) updating the current bookmark
 and bookmarks bound to oldid to newid.
 """
 def updatebookmarks(newid):
 dirty = False
 if oldbookmarks:
 for b in oldbookmarks:
 repo._bookmarks[b] = newid
 dirty = True
 if dirty:
-repo._bookmarks.write()
+repo._bookmarks.recordchange(tr)
 return updatebookmarks
 ### bookmarks api compatibility layer ###
 def bmdeactivate(repo):
 try:
 def bmactive(repo):
 try:
 return repo._activebookmark
 except AttributeError:
 return repo._bookmarkcurrent
+### dirstate compatibility layer < hg 3.6
+def writedirstate(dirstate, tr):
+if dirstate.write.func_defaults is not None: # mercurial 3.6 and above
+return dirstate.write(tr)
+return dirstate.write()
 ### new command
 #############################
 metadataopts = [
 ('d', 'date', '',
 synopsis = '(DEPRECATED)'
 if len(entry) > 2:
 fn, opts, _syn = entry
 else:
 fn, opts, = entry
-deprecationwarning = _('%s have been deprecated in favor of %s\n' % (
+deprecationwarning = _('%s have been deprecated in favor of %s\n') % (
-oldalias, newalias))
+oldalias, newalias)
 def newfn(*args, **kwargs):
 ui = args[0]
 ui.warn(deprecationwarning)
 util.checksignature(fn)(*args, **kwargs)
 newfn.__doc__  = deprecationwarning
 ordering.extend(sorted(dependencies))
 return ordering
 @command('^evolve|stabilize|solve',
 [('n', 'dry-run', False,
-'do not perform actions, just print what would be done'),
+_('do not perform actions, just print what would be done')),
 ('', 'confirm', False,
-'ask for confirmation before performing the action'),
+_('ask for confirmation before performing the action')),
-('A', 'any', False, 'also consider troubled changesets unrelated to current working directory'),
+('A', 'any', False, _('also consider troubled changesets unrelated to current working directory')),
-('r', 'rev', [], 'solves troubles of these revisions'),
+('r', 'rev', [], _('solves troubles of these revisions')),
-('', 'bumped', False, 'solves only bumped changesets'),
+('', 'bumped', False, _('solves only bumped changesets')),
-('', 'divergent', False, 'solves only divergent changesets'),
+('', 'divergent', False, _('solves only divergent changesets')),
-('', 'unstable', False, 'solves only unstable changesets (default)'),
+('', 'unstable', False, _('solves only unstable changesets (default)')),
-('a', 'all', False, 'evolve all troubled changesets related to the current '
+('a', 'all', False, _('evolve all troubled changesets related to the current '
-'working directory and its descendants'),
+'working directory and its descendants')),
-('c', 'continue', False, 'continue an interrupted evolution'),
+('c', 'continue', False, _('continue an interrupted evolution')),
 ] + mergetoolopts,
 _('[OPTIONS]...'))
 def evolve(ui, repo, **opts):
 """solve troubles in your repository
 " trying to stabilize on its parent\n" %
 obs)
 obs = obs.parents()[0]
 newer = obsolete.successorssets(repo, obs.node())
 if len(newer) > 1:
-msg = _("skipping %s: divergent rewriting. can't choose destination\n" % obs)
+msg = _("skipping %s: divergent rewriting. can't choose destination\n") % obs
 ui.write_err(msg)
 return 2
 targets = newer[0]
 assert targets
 if len(targets) > 1:
-msg = _("does not handle split parents yet\n")
+# split target, figure out which one to pick, are they all in line?
-ui.write_err(msg)
+targetrevs = [repo[r].rev() for r in targets]
-return 2
+roots = repo.revs('roots(%ld)', targetrevs)
-target = targets[0]
+heads = repo.revs('heads(%ld)', targetrevs)
+if len(roots) > 1 or len(heads) > 1:
+msg = "cannot solve split accross two branches\n"
+ui.write_err(msg)
+return 2
+target = repo[heads.first()]
+else:
+target = targets[0]
 displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})
 target = repo[target]
 if not ui.quiet or confirm:
 repo.ui.write(_('move:'))
 displayer.show(orig)
 """Stabilize a bumped changeset"""
 repo = repo.unfiltered()
 bumped = repo[bumped.rev()]
 # For now we deny bumped merge
 if len(bumped.parents()) > 1:
-msg = _('skipping %s : we do not handle merge yet\n' % bumped)
+msg = _('skipping %s : we do not handle merge yet\n') % bumped
 ui.write_err(msg)
 return 2
 prec = repo.set('last(allprecursors(%d) and public())', bumped).next()
 # For now we deny target merge
 if len(prec.parents()) > 1:
-msg = _('skipping: %s: public version is a merge, this not handled yet\n' % prec)
+msg = _('skipping: %s: public version is a merge, this not handled yet\n') % prec
 ui.write_err(msg)
 return 2
 displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})
 if not ui.quiet or confirm:
 repo.ui.write('hg commit --msg "bumped update to %s"')
 return 0
 if progresscb: progresscb()
 newid = tmpctx = None
 tmpctx = bumped
-bmupdate = _bookmarksupdater(repo, bumped.node())
 # Basic check for common parent. Far too complicated and fragile
 tr = repo.transaction('bumped-stabilize')
+bmupdate = _bookmarksupdater(repo, bumped.node(), tr)
 try:
 if not list(repo.set('parents(%d) and parents(%d)', bumped, prec)):
 # Need to rebase the changeset at the right place
 repo.ui.status(
 _('rebasing to destination parent: %s\n') % prec.p1())
 displayer.show(divergent)
 ui.write(_('with: '))
 displayer.show(other)
 ui.write(_('base: '))
 displayer.show(base)
-if confirm and ui.prompt('perform evolve? [Ny]', 'n') != 'y':
+if confirm and ui.prompt(_('perform evolve? [Ny]'), 'n') != 'y':
 raise util.Abort(_('evolve aborted by user'))
 if dryrun:
 ui.write('hg update -c %s &&\n' % divergent)
 ui.write('hg merge %s &&\n' % other)
 ui.write('hg commit -m "auto merge resolving conflict between '
 shorttemplate = '[{rev}] {desc|firstline}\n'
 @command('^previous',
 [('B', 'move-bookmark', False,
-_('Move active bookmark after update')),
+_('move active bookmark after update')),
-('', 'merge', False, _('bring uncommited change along'))],
+('', 'merge', False, _('bring uncommitted change along')),
-'[-B]')
+('n', 'dry-run', False, _('do not perform actions, just print what would be done'))],
+'[OPTION]...')
 def cmdprevious(ui, repo, **opts):
 """update to parent and display summary lines"""
 wkctx = repo[None]
 wparents = wkctx.parents()
+dryrunopt = opts['dry_run']
 if len(wparents) != 1:
 raise util.Abort('merge in progress')
 if not opts['merge']:
 try:
 cmdutil.bailifchanged(repo)
 displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})
 if len(parents) == 1:
 p = parents[0]
 bm = bmactive(repo)
 shouldmove = opts.get('move_bookmark') and bm is not None
-ret = hg.update(repo, p.rev())
+if dryrunopt:
-if not ret:
+ui.write('hg update %s;\n' % p.rev())
-wlock = repo.wlock()
+if shouldmove:
-try:
+ui.write('hg bookmark %s -r %s;\n' % (bm, p.rev()))
-if shouldmove:
+else:
-repo._bookmarks[bm] = p.node()
+ret = hg.update(repo, p.rev())
-repo._bookmarks.write()
+if not ret:
-else:
+wlock = repo.wlock()
-bmdeactivate(repo)
+try:
-finally:
+if shouldmove:
-wlock.release()
+repo._bookmarks[bm] = p.node()
+repo._bookmarks.write()
+else:
+bmdeactivate(repo)
+finally:
+wlock.release()
 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('^next',
 [('B', 'move-bookmark', False,
-_('Move active bookmark after update')),
+_('move active bookmark after update')),
-('', 'merge', False, _('bring uncommited change along')),
+('', 'merge', False, _('bring uncommitted change along')),
-('', 'evolve', False, _('evolve the next changeset if necessary'))],
+('', 'evolve', False, _('evolve the next changeset if necessary')),
-'[-B]')
+('n', 'dry-run', False, _('do not perform actions, just print what would be done'))],
+'[OPTION]...')
 def cmdnext(ui, repo, **opts):
 """update to next child
 You can use the --evolve flag to get unstable children evolved on demand.
 The summary line of the destination is displayed for clarity"""
 wkctx = repo[None]
 wparents = wkctx.parents()
+dryrunopt = opts['dry_run']
 if len(wparents) != 1:
 raise util.Abort('merge in progress')
 if not opts['merge']:
 try:
 cmdutil.bailifchanged(repo)
 displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})
 if len(children) == 1:
 c = children[0]
 bm = bmactive(repo)
 shouldmove = opts.get('move_bookmark') and bm is not None
-ret = hg.update(repo, c.rev())
+if dryrunopt:
-if not ret:
+ui.write('hg update %s;\n' % c.rev())
-wlock = repo.wlock()
+if shouldmove:
-try:
+ui.write('hg bookmark %s -r %s;\n' % (bm, c.rev()))
-if shouldmove:
+else:
-repo._bookmarks[bm] = c.node()
+ret = hg.update(repo, c.rev())
-repo._bookmarks.write()
+if not ret:
-else:
+wlock = repo.wlock()
-bmdeactivate(repo)
+try:
-finally:
+if shouldmove:
-wlock.release()
+repo._bookmarks[bm] = c.node()
+repo._bookmarks.write()
+else:
+bmdeactivate(repo)
+finally:
+wlock.release()
 displayer.show(c)
 result = 0
 elif children:
 ui.warn("ambigious next changeset:\n")
 for c in children:
 msg = _('(%i unstable changesets to be evolved here, '
 'do you want --evolve?)\n')
 ui.warn(msg % len(aspchildren))
 result = 1
 elif 1 < len(aspchildren):
-ui.warn("ambigious next (unstable) changeset:\n")
+ui.warn(_("ambigious next (unstable) changeset:\n"))
 for c in aspchildren:
 displayer.show(repo[c])
 ui.warn(_('(run "hg evolve --rev REV" on one of them)\n'))
 return 1
 else:
 cmdutil.bailifchanged(repo)
-result = _solveone(ui, repo, repo[aspchildren[0]], False,
+result = _solveone(ui, repo, repo[aspchildren[0]], dryrunopt,
 False, lambda:None, category='unstable')
 if not result:
 ui.status(_('working directory now at %s\n') % repo['.'])
 return result
 return 1
 for m, n in marks.iteritems():
 if m != mark and n == repo[mark].node():
 uniquebm = False
 break
 if uniquebm:
-rsrevs = repo.revs("ancestors(bookmark(%s)) - "
+if util.safehasattr(repair, 'stripbmrevset'):
-"ancestors(head() and not bookmark(%s)) - "
+rsrevs = repair.stripbmrevset(repo, mark)
-"ancestors(bookmark() and not bookmark(%s)) - "
+else:
-"obsolete()",
+rsrevs = repo.revs("ancestors(bookmark(%s)) - "
-mark, mark, mark)
+"ancestors(head() and not bookmark(%s)) - "
+"ancestors(bookmark() and not bookmark(%s)) - "
+"obsolete()",
+mark, mark, mark)
 revs = set(revs)
 revs.update(set(rsrevs))
 revs = sorted(revs)
 return marks, revs
 [('n', 'new', [], _("successor changeset (DEPRECATED)")),
 ('s', 'succ', [], _("successor changeset")),
 ('r', 'rev', [], _("revisions to prune")),
 ('k', 'keep', None, _("does not modify working copy during prune")),
 ('', 'biject', False, _("do a 1-1 map between rev and successor ranges")),
+('', 'fold', False, _("record a fold (multiple precursors, one successors)")),
+('', 'split', False, _("record a split (on precursor, multiple successors)")),
 ('B', 'bookmark', '', _("remove revs only reachable from given"
 " bookmark"))] + metadataopts,
 _('[OPTION] [-r] REV...'))
 # -U  --noupdate option to prevent wc update and or bookmarks update ?
 def cmdprune(ui, repo, *revs, **opts):
 You can use the ``--biject`` option to specify a 1-1 (bijection) between
 revisions to prune and successor changesets. This option may be removed in
 a future release (with the functionality absorbed automatically).
+If you specify multiple revisions in --succ, you are recording a "split"
+and have to acknowledge it by usng --split. The same logic apply when you
+prune multiple changesets with a single successors, this will record a
+"fold" requires a --fold flag.
 """
 revs = scmutil.revrange(repo, list(revs) + opts.get('rev'))
 succs = opts['new'] + opts['succ']
 bookmark = opts.get('bookmark')
 metadata = _getmetadata(**opts)
 biject = opts.get('biject')
+fold = opts.get('fold')
+split = opts.get('split')
+options = [o for o in ('biject', 'fold', 'split') if opts.get(o)]
+if 1 < len(options):
+raise util.Abort(_("can only specify one of %s") % ', '.join(options))
 if bookmark:
 marks,revs = _reachablefrombookmark(repo, revs, bookmark)
 if not revs:
 # no revisions to prune - delete bookmark immediately
 sucs.sort()
 sucs = tuple(repo[n] for n in sucs)
 if not biject and len(sucs) > 1 and len(precs) > 1:
 msg = "Can't use multiple successors for multiple precursors"
 raise util.Abort(msg)
+elif biject and len(sucs) != len(precs):
-if biject and len(sucs) != len(precs):
 msg = "Can't use %d successors for %d precursors" \
 % (len(sucs), len(precs))
 raise util.Abort(msg)
+elif (len(precs) == 1 and len(sucs) > 1) and not split:
-relations = [(p, sucs) for p in precs]
+msg = "please add --split if you want to do a split"
-if biject:
+raise util.Abort(msg)
+elif len(sucs) == 1 and len(precs) > 1 and not fold:
+msg = "please add --fold if you want to do a fold"
+raise util.Abort(msg)
+elif biject:
 relations = [(p, (s,)) for p, s in zip(precs, sucs)]
+else:
+relations = [(p, sucs) for p in precs]
 wdp = repo['.']
 if len(sucs) == 1 and len(precs) == 1 and wdp in precs:
 # '.' killed, so update to the successor
 # reset files that only changed in the dirstate too
 dirstate = repo.dirstate
 dirchanges = [f for f in dirstate if dirstate[f] != 'n']
 changedfiles.extend(dirchanges)
 repo.dirstate.rebuild(newnode.node(), newnode.manifest(), changedfiles)
-repo.dirstate.write()
+writedirstate(dirstate, tr)
 else:
 bookactive = bmactive(repo)
 # Active bookmark that we don't want to delete (with -B option)
 # we deactivate and move it before the update and reactivate it
 # after
 #
 # but then revset took a lazy arrow in the knee and became much
 # slower. The new forms makes as much sense and a much faster.
 for dest in ctx.ancestors():
 if not dest.obsolete():
-updatebookmarks = _bookmarksupdater(repo, ctx.node())
+updatebookmarks = _bookmarksupdater(repo, ctx.node(), tr)
 updatebookmarks(dest.node())
 break
 tr.close()
 finally:
 if old.phase() == phases.public:
 raise util.Abort(_("cannot rewrite immutable changeset"))
 if len(old.parents()) > 1:
 raise util.Abort(_("cannot uncommit merge changeset"))
 oldphase = old.phase()
-updatebookmarks = _bookmarksupdater(repo, old.node())
 rev = None
 if opts.get('rev'):
 rev = scmutil.revsingle(repo, opts.get('rev'))
 if disallowunstable and not onahead:
 raise util.Abort(_("cannot uncommit in the middle of a stack"))
 # Recommit the filtered changeset
 tr = repo.transaction('uncommit')
+updatebookmarks = _bookmarksupdater(repo, old.node(), tr)
 newid = None
 includeorexclude = opts.get('include') or opts.get('exclude')
 if (pats or includeorexclude or opts.get('all')):
 match = scmutil.match(old, pats, opts)
 newid = _commitfiltered(repo, old, match, target=rev)
 if oldbookmarks:
 repo._bookmarks.write()
 return result
 finally:
 lockmod.release(lock, wlock)
+@command('^split',
+[('r', 'rev', [], _("revision to fold")),
+] + commitopts + commitopts2,
+_('hg split [OPTION]... [-r] REV'))
+def cmdsplit(ui, repo, *revs, **opts):
+"""Split the current commit using interactive selection (EXPERIMENTAL)
+By default, split the current revision by prompting for all its hunk to be
+redistributed into new changesets.
+Use --rev for splitting a given changeset instead.
+"""
+tr = wlock = lock = None
+newcommits = []
+revopt = opts.get('rev')
+if revopt:
+revs = scmutil.revrange(repo, revopt)
+if len(revs) != 1:
+raise util.Abort(_("you can only specify one revision to split"))
+else:
+rev = list(revs)[0]
+else:
+rev = '.'
+try:
+wlock = repo.wlock()
+lock = repo.lock()
+cmdutil.bailifchanged(repo)
+tr = repo.transaction('split')
+ctx = repo[rev]
+r = ctx.rev()
+disallowunstable = not obsolete.isenabled(repo,
+obsolete.allowunstableopt)
+if disallowunstable:
+# XXX We should check head revs
+if repo.revs("(%d::) - %d", rev, rev):
+raise util.Abort(_("cannot split commit: %s not a head") % ctx)
+if len(ctx.parents()) > 1:
+raise util.Abort(_("cannot split merge commits"))
+prev = ctx.p1()
+bmupdate = _bookmarksupdater(repo, ctx.node(), tr)
+bookactive = bmactive(repo)
+if bookactive is not None:
+repo.ui.status(_("(leaving bookmark %s)\n") % bmactive(repo))
+bmdeactivate(repo)
+hg.update(repo, prev)
+commands.revert(ui, repo, rev=r, all=True)
+def haschanges():
+modified, added, removed, deleted = repo.status()[:4]
+return modified or added or removed or deleted
+while haschanges():
+pats = ()
+cmdutil.dorecord(ui, repo, commands.commit, 'commit', False,
+cmdutil.recordfilter, *pats, **opts)
+# TODO: Does no seem like the best way to do this
+# We should make dorecord return the newly created commit
+newcommits.append(repo['.'])
+if haschanges():
+if ui.prompt('Done splitting? [yN]', default='n') == 'y':
+commands.commit(ui, repo, **opts)
+newcommits.append(repo['.'])
+break
+else:
+ui.status("no more change to split\n")
+tip = repo[newcommits[-1]]
+bmupdate(tip.node())
+if bookactive is not None:
+bmactivate(repo, bookactive)
+obsolete.createmarkers(repo, [(repo[r], newcommits)])
+tr.close()
+finally:
+lockmod.release(tr, lock, wlock)
 @eh.wrapcommand('strip', extension='strip', opts=[
 ('', 'bundle', None, _("delete the commit entirely and move it to a "
 "backup bundle")),
 ])
 cl = local.changelog
 dag = dagutil.revlogdag(cl)
 missing = set()
 common = set()
 undecided = set(probeset)
+totalnb = len(undecided)
+ui.progress("comparing with other", 0, total=totalnb)
 _takefullsample = setdiscovery._takefullsample
 if remote.capable('_evoext_obshash_1'):
 getremotehash = remote.evoext_obshash1
 localhash = _obsrelsethashtreefm1(local)
 else:
 sample = set(undecided)
 else:
 sample = _takefullsample(dag, undecided, size=fullsamplesize)
 roundtrips += 1
+ui.progress("comparing with other", totalnb - len(undecided),
+total=totalnb)
 ui.debug("query %i; still undecided: %i, sample size is: %i\n"
 % (roundtrips, len(undecided), len(sample)))
 # indices between sample and externalized version must match
 sample = list(sample)
 remotehash = getremotehash(dag.externalizeall(sample))
 undecided.difference_update(missing)
 undecided.difference_update(common)
+ui.progress("comparing with other", None, total=totalnb)
 result = dag.headsetofconnecteds(common)
 ui.debug("%d total queries\n" % roundtrips)
 if not result:
 return set([nullid])
 def _obsrelsethashtree(repo, encodeonemarker):
 cache = []
 unfi = repo.unfiltered()
 markercache = {}
+repo.ui.progress("preparing locally", 0, total=len(unfi))
 for i in unfi:
 ctx = unfi[i]
 entry = 0
 sha = util.sha1()
 # add data from p1
 sha.update(m)
 if entry:
 cache.append((ctx.node(), sha.digest()))
 else:
 cache.append((ctx.node(), nullid))
+repo.ui.progress("preparing locally", i, total=len(unfi))
+repo.ui.progress("preparing locally", None)
 return cache
 @command('debugobsrelsethashtree',
 [('', 'v0', None, 'hash on marker format "0"'),
 ('', 'v1', None, 'hash on marker format "1" (default)')
 @command(
 'debugobsconvert',
 [('', 'new-format', _bestformat, _('Destination format for markers.'))],
 '')
 def debugobsconvert(ui, repo, new_format):
+origmarkers = repo.obsstore._all  # settle version
 if new_format == repo.obsstore._version:
 msg = _('New format is the same as the old format, not upgrading!')
 raise util.Abort(msg)
 f = repo.svfs('obsstore', 'wb', atomictemp=True)
-origmarkers = repo.obsstore._all
 known = set()
 markers = []
 for m in origmarkers:
 # filter out invalid markers
 if nullid in m[1]:
 oldcap, args = wireproto.commands['capabilities']
 def newcap(repo, proto):
 return capabilities(oldcap, repo, proto)
 wireproto.commands['capabilities'] = (newcap, args)
-def _helploader():
+# Mercurial >= 3.6 passes ui
+def _helploader(ui=None):
 return help.gettext(evolutionhelptext)
 @eh.uisetup
 def _setuphelp(ui):
 for entry in help.helptable:

branch	stable
changeset 1518	bca3fce56b2c
parent 1517	a1f239a93c94
child 1519	c15d6168412f