| hg-reviewers |
Before this patch, during a rebase if you get a point where you can't
figure out what to do next then either you had to complete your series
or abandon all the work you have done during this rebase.
Now, with this feature you can stop at any point by keeping the rebased
csets and mark original csets as obsolete. And if you don't have evolution
extension enabled then you can use --keep option as an alternative which
will keep original csets too, instead of marking them obsolete.
| Lint Skipped |
| Unit Tests Skipped |
+ def _stoprebase(self):
+ """stop the interrupted rebase"""
+ self.restorestatus()
+ if not self.stateobj.exists():
+ raise error.Abort(_("no interrupted rebase found"))
+ allowunstable = obsolete.isenabled(self.repo, obsolete.allowunstableopt)
+ if not (self.keepf or allowunstable):
+ raise error.Abort(_("can't remove original changesets with"
+ " unrebased descendants"),
+ hint=_('either enable evolve extension to allow unstable '
+ 'revisions or use --keep to keep original changesets'))
+
+ # update to the last rebased node if any
+ ctx = self.repo[None]
+ pars = [p.node() for p in ctx.parents()]
+ p1 = pars[0]
+ hg.updaterepo(self.repo, p1, overwrite=True)
Perhaps this differs from what a successful rebase would do. Unlike graft,
hg rebase goes back to the original working directory.
+ # either mark obsolete or keep rebased revisions
+ repo, ui, opts = self.repo, self.ui, self.opts
+ fm = ui.formatter('rebase', opts)
+ fm.startitem()
+ clearrebased(ui, repo, self.destmap, self.state, self.skipped,
+ collapsedas=None, keepf=self.keepf, fm=fm)
+ clearstatus(self.repo)
+ fm.end()
+ return 0
I doubt if this would work with --collapse. Can you try writing some tests?
I'm not pretty sure, but it might be possible to utilize _finishrebase()
to implement --stop, roughly by:
+ elif stop:
+ #todo: raise error for conflicting options
Yes!
right, will change it.
+ # either mark obsolete or keep rebased revisions
+ repo, ui, opts = self.repo, self.ui, self.opts
+ fm = ui.formatter('rebase', opts)
+ fm.startitem()
+ clearrebased(ui, repo, self.destmap, self.state, self.skipped,
+ collapsedas=None, keepf=self.keepf, fm=fm)
+ clearstatus(self.repo)
+ fm.end()
+ return 0I doubt if this would work with --collapse. Can you try writing some tests?
What is the expected behaviour in case of --collapse? Should it collapse only those revisions which are rebased, then we may have to ask user to change commit message accordingly.
I'm not pretty sure, but it might be possible to utilize _finishrebase()
to implement --stop, roughly by:
- restore status
- drop revisions that aren't rebased yet
- finish it
yeah, trying to do it in _finishrebase()
+ elif stop:
+ #todo: raise error for conflicting optionsYes!
> I doubt if this would work with --collapse. Can you try writing some tests? What is the expected behaviour in case of --collapse? Should it collapse only those revisions which are rebased, then we may have to ask user to change commit message accordingly.
No idea. Perhaps we can revisit it later by making hg rebase --stop just
abort if it was a --collapse session.
Excellent! I like the feature and this has been on my TODO for long. Thanks for coding this up. You also need to take care of bookmark movements. Bookmark from changesets which have successfully rebased should be moved to their successors when we call --stop.
| hgext/rebase.py | ||
|---|---|---|
| 595 | nit: 'cannot stop in --collapse session' Also, if we cannot stop, we should not fallback to aborting. | |
| 604 | nit: we don't mention about evolve or any out of tree extension from core. How about making --stop only work when obsmarkers are enabled and error out if they are not enabled? | |
| 692 | Can we prevent having s and S evaluate to different options i.e. leave 'S' for now? | |
@pulkit I will send a follow up which will take care of bookmarks movement. Thanks for review!
| hgext/rebase.py | ||
|---|---|---|
| 595 | Ah, right. We should only print that message and keep everything as it is. | |
| 604 | okay, will remove mentioning of evolve.
Don't ^ line check that obsmarker are enabled or not? | |
| 692 | okay, will remove 'S'. | |
@pulkit
I think bookmarks movement is already handled by clearrebased() function. I going to send a patch to reflect this behaviour. Correct me if I am missing something.
- def _finishrebase(self):
+ def _finishrebase(self, stoprebase=False):
repo, ui, opts = self.repo, self.ui, self.opts fm = ui.formatter('rebase', opts) fm.startitem()+ if stoprebase:
+ self.restorestatus()
+ if self.collapsef:
+ ui.status(_("cannot stop in --collapse session\n"))
+ return
raise Abort because it's an error?
+
+ allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
+ if not (self.keepf or allowunstable):
+ raise error.Abort(_("can't remove original changesets with"
+ " unrebased descendants"),
+ hint=_('either enable obsmarkers to allow unstable '
+ 'revisions or use --keep to keep original '
+ 'changesets'))
It will be nice if we can move the pre-process out from _finishrebase(),
and get rid of the stoprebase flag somehow.
if self.collapsef: p1, p2, _base = defineparents(repo, min(self.state), self.destmap, self.state, self.skipped,@@ -626,7 +640,10 @@
newwd = self.originalwd if newwd not in [c.rev() for c in repo[None].parents()]: ui.note(_("update back to initial working directory parent\n"))
- hg.updaterepo(repo, newwd, overwrite=False)
+ if stoprebase:
+ hg.updaterepo(repo, newwd, overwrite=True)
+ else:
+ hg.updaterepo(repo, newwd, overwrite=False)
This implies an interrupted merge won't be cleared if no update is required.
(try hg up 3 && hg rebase -s 1 -d 5 in the first test you've added.)
Perhaps the rebase --stop flow can be processed as follows?
rbsrt = rebaseruntime(repo, ui)
rbsrt.restorestatus()
... check unsupported options ...
with repo.wlock(), repo.lock():
if needupdate(repo, state):
.. update to the current working revision with overwrite=True
.. to clear interrupted merge
rbsrt._finishrebase()Queued, many thanks.
+ elif stop:
+ rbsrt = rebaseruntime(repo, ui)
+ rbsrt.restorestatus()
Perhaps restorestatus() needs to be covered by the lock to prevent it from
being updated by another process. Can you send a follow up?
nit: 'cannot stop in --collapse session'
Also, if we cannot stop, we should not fallback to aborting.