| durin42 |
| hg-reviewers |
They are no longer necessary to make rebase behavior correct. Therefore
remove them to make the code cleaner and easier to reason about.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| release = lock.release | release = lock.release | ||||
| templateopts = cmdutil.templateopts | templateopts = cmdutil.templateopts | ||||
| # The following constants are used throughout the rebase module. The ordering of | # The following constants are used throughout the rebase module. The ordering of | ||||
| # their values must be maintained. | # their values must be maintained. | ||||
| # Indicates that a revision needs to be rebased | # Indicates that a revision needs to be rebased | ||||
| revtodo = -1 | revtodo = -1 | ||||
| nullmerge = -2 | |||||
| revignored = -3 | |||||
| # legacy revstates no longer needed in current code | # legacy revstates no longer needed in current code | ||||
| # -4: revprecursor, -5: revpruned | # -2: nullmerge, -3: revignored, -4: revprecursor, -5: revpruned | ||||
| legacystates = {'-4', '-5'} | legacystates = {'-2', '-3', '-4', '-5'} | ||||
| cmdtable = {} | cmdtable = {} | ||||
| command = registrar.command(cmdtable) | command = registrar.command(cmdtable) | ||||
| # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for | # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for | ||||
| # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should | # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should | ||||
| # be specifying the version(s) of Mercurial they are tested with, or | # be specifying the version(s) of Mercurial they are tested with, or | ||||
| # leave the attribute unspecified. | # leave the attribute unspecified. | ||||
| testedwith = 'ships-with-hg-core' | testedwith = 'ships-with-hg-core' | ||||
| # line 6 is a recent addition, so for backwards | # line 6 is a recent addition, so for backwards | ||||
| # compatibility check that the line doesn't look like the | # compatibility check that the line doesn't look like the | ||||
| # oldrev:newrev lines | # oldrev:newrev lines | ||||
| activebookmark = l | activebookmark = l | ||||
| else: | else: | ||||
| oldrev, newrev = l.split(':') | oldrev, newrev = l.split(':') | ||||
| if newrev in legacystates: | if newrev in legacystates: | ||||
| continue | continue | ||||
| if newrev in (str(nullmerge), str(revignored)): | |||||
| state[repo[oldrev].rev()] = int(newrev) | |||||
| elif newrev == nullid: | elif newrev == nullid: | ||||
| state[repo[oldrev].rev()] = revtodo | state[repo[oldrev].rev()] = revtodo | ||||
| # Legacy compat special case | # Legacy compat special case | ||||
| else: | else: | ||||
| state[repo[oldrev].rev()] = repo[newrev].rev() | state[repo[oldrev].rev()] = repo[newrev].rev() | ||||
| except IOError as err: | except IOError as err: | ||||
| if err.errno != errno.ENOENT: | if err.errno != errno.ENOENT: | ||||
| ui.debug('rebased as %s\n' % short(newnode)) | ui.debug('rebased as %s\n' % short(newnode)) | ||||
| else: | else: | ||||
| if not self.collapsef: | if not self.collapsef: | ||||
| ui.warn(_('note: rebase of %d:%s created no changes ' | ui.warn(_('note: rebase of %d:%s created no changes ' | ||||
| 'to commit\n') % (rev, ctx)) | 'to commit\n') % (rev, ctx)) | ||||
| self.skipped.add(rev) | self.skipped.add(rev) | ||||
| self.state[rev] = p1 | self.state[rev] = p1 | ||||
| ui.debug('next revision set to %s\n' % p1) | ui.debug('next revision set to %s\n' % p1) | ||||
| elif self.state[rev] == nullmerge: | |||||
| pass | |||||
| elif self.state[rev] == revignored: | |||||
| pass | |||||
| else: | else: | ||||
| ui.status(_('already rebased %s as %s\n') % | ui.status(_('already rebased %s as %s\n') % | ||||
| (desc, repo[self.state[rev]])) | (desc, repo[self.state[rev]])) | ||||
| ui.progress(_('rebasing'), None) | ui.progress(_('rebasing'), None) | ||||
| ui.note(_('rebase merging completed\n')) | ui.note(_('rebase merging completed\n')) | ||||
| def _finishrebase(self): | def _finishrebase(self): | ||||
| repo, ui, opts = self.repo, self.ui, self.opts | repo, ui, opts = self.repo, self.ui, self.opts | ||||
| if self.collapsef and not self.keepopen: | if self.collapsef and not self.keepopen: | ||||
| p1, p2, _base = defineparents(repo, min(self.state), | p1, p2, _base = defineparents(repo, min(self.state), | ||||
| self.dest, self.state) | self.dest, self.state) | ||||
| editopt = opts.get('edit') | editopt = opts.get('edit') | ||||
| editform = 'rebase.collapse' | editform = 'rebase.collapse' | ||||
| if self.collapsemsg: | if self.collapsemsg: | ||||
| commitmsg = self.collapsemsg | commitmsg = self.collapsemsg | ||||
| else: | else: | ||||
| commitmsg = 'Collapsed revision' | commitmsg = 'Collapsed revision' | ||||
| for rebased in sorted(self.state): | for rebased in sorted(self.state): | ||||
| if rebased not in self.skipped and\ | if rebased not in self.skipped and\ | ||||
| self.state[rebased] > nullmerge: | self.state[rebased] >= revtodo: | ||||
| commitmsg += '\n* %s' % repo[rebased].description() | commitmsg += '\n* %s' % repo[rebased].description() | ||||
| editopt = True | editopt = True | ||||
| editor = cmdutil.getcommiteditor(edit=editopt, editform=editform) | editor = cmdutil.getcommiteditor(edit=editopt, editform=editform) | ||||
| revtoreuse = max(self.state) | revtoreuse = max(self.state) | ||||
| dsguard = None | dsguard = None | ||||
| if ui.configbool('rebase', 'singletransaction'): | if ui.configbool('rebase', 'singletransaction'): | ||||
| dsguard = dirstateguard.dirstateguard(repo, 'rebase') | dsguard = dirstateguard.dirstateguard(repo, 'rebase') | ||||
| with util.acceptintervention(dsguard): | with util.acceptintervention(dsguard): | ||||
| newnode = concludenode(repo, revtoreuse, p1, self.external, | newnode = concludenode(repo, revtoreuse, p1, self.external, | ||||
| commitmsg=commitmsg, | commitmsg=commitmsg, | ||||
| extrafn=_makeextrafn(self.extrafns), | extrafn=_makeextrafn(self.extrafns), | ||||
| editor=editor, | editor=editor, | ||||
| keepbranches=self.keepbranchesf, | keepbranches=self.keepbranchesf, | ||||
| date=self.date) | date=self.date) | ||||
| if newnode is None: | if newnode is None: | ||||
| newrev = self.dest | newrev = self.dest | ||||
| else: | else: | ||||
| newrev = repo[newnode].rev() | newrev = repo[newnode].rev() | ||||
| for oldrev in self.state.iterkeys(): | for oldrev in self.state.iterkeys(): | ||||
| if self.state[oldrev] > nullmerge: | if self.state[oldrev] >= revtodo: | ||||
| self.state[oldrev] = newrev | self.state[oldrev] = newrev | ||||
| if 'qtip' in repo.tags(): | if 'qtip' in repo.tags(): | ||||
| updatemq(repo, self.state, self.skipped, **opts) | updatemq(repo, self.state, self.skipped, **opts) | ||||
| # restore original working directory | # restore original working directory | ||||
| # (we do this before stripping) | # (we do this before stripping) | ||||
| newwd = self.state.get(self.originalwd, self.originalwd) | newwd = self.state.get(self.originalwd, self.originalwd) | ||||
| [s.node for s in repo.mq.applied]): | [s.node for s in repo.mq.applied]): | ||||
| raise error.Abort(_('cannot rebase onto an applied mq patch')) | raise error.Abort(_('cannot rebase onto an applied mq patch')) | ||||
| roots = list(repo.set('roots(%ld)', rebaseset)) | roots = list(repo.set('roots(%ld)', rebaseset)) | ||||
| if not roots: | if not roots: | ||||
| raise error.Abort(_('no matching revisions')) | raise error.Abort(_('no matching revisions')) | ||||
| roots.sort() | roots.sort() | ||||
| state = dict.fromkeys(rebaseset, revtodo) | state = dict.fromkeys(rebaseset, revtodo) | ||||
| detachset = set() | |||||
| emptyrebase = True | emptyrebase = True | ||||
| for root in roots: | for root in roots: | ||||
| commonbase = root.ancestor(dest) | commonbase = root.ancestor(dest) | ||||
| if commonbase == root: | if commonbase == root: | ||||
| raise error.Abort(_('source is ancestor of destination')) | raise error.Abort(_('source is ancestor of destination')) | ||||
| if commonbase == dest: | if commonbase == dest: | ||||
| wctx = repo[None] | wctx = repo[None] | ||||
| if dest == wctx.p1(): | if dest == wctx.p1(): | ||||
| # when rebasing to '.', it will use the current wd branch name | # when rebasing to '.', it will use the current wd branch name | ||||
| samebranch = root.branch() == wctx.branch() | samebranch = root.branch() == wctx.branch() | ||||
| else: | else: | ||||
| samebranch = root.branch() == dest.branch() | samebranch = root.branch() == dest.branch() | ||||
| if not collapse and samebranch and dest in root.parents(): | if not collapse and samebranch and dest in root.parents(): | ||||
| # mark the revision as done by setting its new revision | # mark the revision as done by setting its new revision | ||||
| # equal to its old (current) revisions | # equal to its old (current) revisions | ||||
| state[root.rev()] = root.rev() | state[root.rev()] = root.rev() | ||||
| repo.ui.debug('source is a child of destination\n') | repo.ui.debug('source is a child of destination\n') | ||||
| continue | continue | ||||
| emptyrebase = False | emptyrebase = False | ||||
| repo.ui.debug('rebase onto %s starting from %s\n' % (dest, root)) | repo.ui.debug('rebase onto %s starting from %s\n' % (dest, root)) | ||||
| # Rebase tries to turn <dest> into a parent of <root> while | |||||
| # preserving the number of parents of rebased changesets: | |||||
| # | |||||
| # - A changeset with a single parent will always be rebased as a | |||||
| # changeset with a single parent. | |||||
| # | |||||
| # - A merge will be rebased as merge unless its parents are both | |||||
| # ancestors of <dest> or are themselves in the rebased set and | |||||
| # pruned while rebased. | |||||
| # | |||||
| # If one parent of <root> is an ancestor of <dest>, the rebased | |||||
| # version of this parent will be <dest>. This is always true with | |||||
| # --base option. | |||||
| # | |||||
| # Otherwise, we need to *replace* the original parents with | |||||
| # <dest>. This "detaches" the rebased set from its former location | |||||
| # and rebases it onto <dest>. Changes introduced by ancestors of | |||||
| # <root> not common with <dest> (the detachset, marked as | |||||
| # nullmerge) are "removed" from the rebased changesets. | |||||
| # | |||||
| # - If <root> has a single parent, set it to <dest>. | |||||
| # | |||||
| # - If <root> is a merge, we cannot decide which parent to | |||||
| # replace, the rebase operation is not clearly defined. | |||||
| # | |||||
| # The table below sums up this behavior: | |||||
| # | |||||
| # +------------------+----------------------+-------------------------+ | |||||
| # | | one parent | merge | | |||||
| # +------------------+----------------------+-------------------------+ | |||||
| # | parent in | new parent is <dest> | parents in ::<dest> are | | |||||
| # | ::<dest> | | remapped to <dest> | | |||||
| # +------------------+----------------------+-------------------------+ | |||||
| # | unrelated source | new parent is <dest> | ambiguous, abort | | |||||
| # +------------------+----------------------+-------------------------+ | |||||
| # | |||||
| # The actual abort is handled by `defineparents` | |||||
| if len(root.parents()) <= 1: | |||||
| # ancestors of <root> not ancestors of <dest> | |||||
| detachset.update(repo.changelog.findmissingrevs([commonbase.rev()], | |||||
| [root.rev()])) | |||||
| if emptyrebase: | if emptyrebase: | ||||
| return None | return None | ||||
| for rev in sorted(state): | for rev in sorted(state): | ||||
| parents = [p for p in repo.changelog.parentrevs(rev) if p != nullrev] | parents = [p for p in repo.changelog.parentrevs(rev) if p != nullrev] | ||||
| # if all parents of this revision are done, then so is this revision | # if all parents of this revision are done, then so is this revision | ||||
| if parents and all((state.get(p) == p for p in parents)): | if parents and all((state.get(p) == p for p in parents)): | ||||
| state[rev] = rev | state[rev] = rev | ||||
| for r in detachset: | |||||
| if r not in state: | |||||
| state[r] = nullmerge | |||||
| if len(roots) > 1: | |||||
| # If we have multiple roots, we may have "hole" in the rebase set. | |||||
| # Rebase roots that descend from those "hole" should not be detached as | |||||
| # other root are. We use the special `revignored` to inform rebase that | |||||
| # the revision should be ignored but that `defineparents` should search | |||||
| # a rebase destination that make sense regarding rebased topology. | |||||
| rebasedomain = set(repo.revs('%ld::%ld', rebaseset, rebaseset)) | |||||
| for ignored in set(rebasedomain) - set(rebaseset): | |||||
| state[ignored] = revignored | |||||
| unfi = repo.unfiltered() | unfi = repo.unfiltered() | ||||
| for r in obsoletenotrebased: | for r in obsoletenotrebased: | ||||
| desc = _ctxdesc(unfi[r]) | desc = _ctxdesc(unfi[r]) | ||||
| succ = obsoletenotrebased[r] | succ = obsoletenotrebased[r] | ||||
| if succ is None: | if succ is None: | ||||
| msg = _('note: not rebasing %s, it has no successor\n') % desc | msg = _('note: not rebasing %s, it has no successor\n') % desc | ||||
| del state[r] | del state[r] | ||||
| else: | else: | ||||