phases: prevent rebase to rebase immutable changeset.

hgext/rebase.py

@@ -1,634 +1,643 b''
 # rebase.py - rebasing feature for mercurial
 #
 # Copyright 2008 Stefano Tortarolo <stefano.tortarolo at gmail dot com>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''command to move sets of revisions to a different ancestor
 
 This extension lets you rebase changesets in an existing Mercurial
 repository.
 
 For more information:
 http://mercurial.selenic.com/wiki/RebaseExtension
 '''
 
 from mercurial import hg, util, repair, merge, cmdutil, commands, bookmarks
 from mercurial import extensions, patch
 from mercurial.commands import templateopts
 from mercurial.node import nullrev
 from mercurial.lock import release
 from mercurial.i18n import _
 import os, errno
 
 nullmerge = -2
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
 
 @command('rebase',
     [('s', 'source', '',
      _('rebase from the specified changeset'), _('REV')),
     ('b', 'base', '',
      _('rebase from the base of the specified changeset '
        '(up to greatest common ancestor of base and dest)'),
      _('REV')),
     ('r', 'rev', [],
      _('rebase these revisions'),
      _('REV')),
     ('d', 'dest', '',
      _('rebase onto the specified changeset'), _('REV')),
     ('', 'collapse', False, _('collapse the rebased changesets')),
     ('m', 'message', '',
      _('use text as collapse commit message'), _('TEXT')),
     ('e', 'edit', False, _('invoke editor on commit messages')),
     ('l', 'logfile', '',
      _('read collapse commit message from file'), _('FILE')),
     ('', 'keep', False, _('keep original changesets')),
     ('', 'keepbranches', False, _('keep original branch names')),
     ('D', 'detach', False, _('force detaching of source from its original '
                             'branch')),
     ('t', 'tool', '', _('specify merge tool')),
     ('c', 'continue', False, _('continue an interrupted rebase')),
     ('a', 'abort', False, _('abort an interrupted rebase'))] +
      templateopts,
     _('hg rebase [-s REV | -b REV] [-d REV] [options]\n'
       'hg rebase {-a|-c}'))
 def rebase(ui, repo, **opts):
     """move changeset (and descendants) to a different branch
 
     Rebase uses repeated merging to graft changesets from one part of
     history (the source) onto another (the destination). This can be
     useful for linearizing *local* changes relative to a master
     development tree.
 
     You should not rebase changesets that have already been shared
     with others. Doing so will force everybody else to perform the
     same rebase or they will end up with duplicated changesets after
     pulling in your rebased changesets.
 
     If you don't specify a destination changeset (``-d/--dest``),
     rebase uses the tipmost head of the current named branch as the
     destination. (The destination changeset is not modified by
     rebasing, but new changesets are added as its descendants.)
 
     You can specify which changesets to rebase in two ways: as a
     "source" changeset or as a "base" changeset. Both are shorthand
     for a topologically related set of changesets (the "source
     branch"). If you specify source (``-s/--source``), rebase will
     rebase that changeset and all of its descendants onto dest. If you
     specify base (``-b/--base``), rebase will select ancestors of base
     back to but not including the common ancestor with dest. Thus,
     ``-b`` is less precise but more convenient than ``-s``: you can
     specify any changeset in the source branch, and rebase will select
     the whole branch. If you specify neither ``-s`` nor ``-b``, rebase
     uses the parent of the working directory as the base.
 
     By default, rebase recreates the changesets in the source branch
     as descendants of dest and then destroys the originals. Use
     ``--keep`` to preserve the original source changesets. Some
     changesets in the source branch (e.g. merges from the destination
     branch) may be dropped if they no longer contribute any change.
 
     One result of the rules for selecting the destination changeset
     and source branch is that, unlike ``merge``, rebase will do
     nothing if you are at the latest (tipmost) head of a named branch
     with two heads. You need to explicitly specify source and/or
     destination (or ``update`` to the other head, if it's the head of
     the intended source branch).
 
     If a rebase is interrupted to manually resolve a merge, it can be
     continued with --continue/-c or aborted with --abort/-a.
 
     Returns 0 on success, 1 if nothing to rebase.
     """
     originalwd = target = None
     external = nullrev
     state = {}
     skipped = set()
     targetancestors = set()
 
     editor = None
     if opts.get('edit'):
         editor = cmdutil.commitforceeditor
 
     lock = wlock = None
     try:
         lock = repo.lock()
         wlock = repo.wlock()
 
         # Validate input and define rebasing points
         destf = opts.get('dest', None)
         srcf = opts.get('source', None)
         basef = opts.get('base', None)
         revf = opts.get('rev', [])
         contf = opts.get('continue')
         abortf = opts.get('abort')
         collapsef = opts.get('collapse', False)
         collapsemsg = cmdutil.logmessage(ui, opts)
         extrafn = opts.get('extrafn') # internal, used by e.g. hgsubversion
         keepf = opts.get('keep', False)
         keepbranchesf = opts.get('keepbranches', False)
         detachf = opts.get('detach', False)
         # keepopen is not meant for use on the command line, but by
         # other extensions
         keepopen = opts.get('keepopen', False)
 
         if collapsemsg and not collapsef:
             raise util.Abort(
                 _('message can only be specified with collapse'))
 
         if contf or abortf:
             if contf and abortf:
                 raise util.Abort(_('cannot use both abort and continue'))
             if collapsef:
                 raise util.Abort(
                     _('cannot use collapse with continue or abort'))
             if detachf:
                 raise util.Abort(_('cannot use detach with continue or abort'))
             if srcf or basef or destf:
                 raise util.Abort(
                     _('abort and continue do not allow specifying revisions'))
             if opts.get('tool', False):
                 ui.warn(_('tool option will be ignored\n'))
 
             (originalwd, target, state, skipped, collapsef, keepf,
                                 keepbranchesf, external) = restorestatus(repo)
             if abortf:
                 return abort(repo, originalwd, target, state)
         else:
             if srcf and basef:
                 raise util.Abort(_('cannot specify both a '
                                    'source and a base'))
             if revf and basef:
                 raise util.Abort(_('cannot specify both a '
                                    'revision and a base'))
             if revf and srcf:
                 raise util.Abort(_('cannot specify both a '
                                    'revision and a source'))
             if detachf:
                 if not (srcf or revf):
                     raise util.Abort(
                         _('detach requires a revision to be specified'))
                 if basef:
                     raise util.Abort(_('cannot specify a base with detach'))
 
             cmdutil.bailifchanged(repo)
 
             if not destf:
                 # Destination defaults to the latest revision in the
                 # current branch
                 branch = repo[None].branch()
                 dest = repo[branch]
             else:
                 dest = repo[destf]
 
             if revf:
                 rebaseset = repo.revs('%lr', revf)
             elif srcf:
                 rebaseset = repo.revs('(%r)::', srcf)
             else:
                 base = basef or '.'
                 rebaseset = repo.revs('(children(ancestor(%r, %d)) & ::%r)::',
                     base, dest, base)
 
+            if rebaseset:
+                root = min(rebaseset)
+            else:
+                root = None
+
             if not rebaseset:
                 repo.ui.debug('base is ancestor of destination')
                 result = None
             elif not keepf and list(repo.revs('first(children(%ld) - %ld)',
                                               rebaseset, rebaseset)):
                 raise util.Abort(
                     _("can't remove original changesets with"
                       " unrebased descendants"),
                     hint=_('use --keep to keep original changesets'))
+            elif not keepf and not repo[root].mutable():
+                raise util.Abort(_("Can't rebase immutable changeset %s")
+                                 % repo[root],
+                                 hint=_('see hg help phases for details'))
             else:
                 result = buildstate(repo, dest, rebaseset, detachf)
 
             if not result:
                 # Empty state built, nothing to rebase
                 ui.status(_('nothing to rebase\n'))
                 return 1
             else:
                 originalwd, target, state = result
                 if collapsef:
                     targetancestors = set(repo.changelog.ancestors(target))
                     targetancestors.add(target)
                     external = checkexternal(repo, state, targetancestors)
 
         if keepbranchesf:
             assert not extrafn, 'cannot use both keepbranches and extrafn'
             def extrafn(ctx, extra):
                 extra['branch'] = ctx.branch()
             if collapsef:
                 branches = set()
                 for rev in state:
                     branches.add(repo[rev].branch())
                     if len(branches) > 1:
                         raise util.Abort(_('cannot collapse multiple named '
                             'branches'))
 
 
         # Rebase
         if not targetancestors:
             targetancestors = set(repo.changelog.ancestors(target))
             targetancestors.add(target)
 
         # Keep track of the current bookmarks in order to reset them later
         currentbookmarks = repo._bookmarks.copy()
 
         sortedstate = sorted(state)
         total = len(sortedstate)
         pos = 0
         for rev in sortedstate:
             pos += 1
             if state[rev] == -1:
                 ui.progress(_("rebasing"), pos, ("%d:%s" % (rev, repo[rev])),
                             _('changesets'), total)
                 storestatus(repo, originalwd, target, state, collapsef, keepf,
                                                     keepbranchesf, external)
                 p1, p2 = defineparents(repo, rev, target, state,
                                                         targetancestors)
                 if len(repo.parents()) == 2:
                     repo.ui.debug('resuming interrupted rebase\n')
                 else:
                     try:
                         ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
                         stats = rebasenode(repo, rev, p1, state)
                         if stats and stats[3] > 0:
                             raise util.Abort(_('unresolved conflicts (see hg '
                                         'resolve, then hg rebase --continue)'))
                     finally:
                         ui.setconfig('ui', 'forcemerge', '')
                 cmdutil.duplicatecopies(repo, rev, target, p2)
                 if not collapsef:
                     newrev = concludenode(repo, rev, p1, p2, extrafn=extrafn,
                                           editor=editor)
                 else:
                     # Skip commit if we are collapsing
                     repo.dirstate.setparents(repo[p1].node())
                     newrev = None
                 # Update the state
                 if newrev is not None:
                     state[rev] = repo[newrev].rev()
                 else:
                     if not collapsef:
                         ui.note(_('no changes, revision %d skipped\n') % rev)
                         ui.debug('next revision set to %s\n' % p1)
                         skipped.add(rev)
                     state[rev] = p1
 
         ui.progress(_('rebasing'), None)
         ui.note(_('rebase merging completed\n'))
 
         if collapsef and not keepopen:
             p1, p2 = defineparents(repo, min(state), target,
                                                         state, targetancestors)
             if collapsemsg:
                 commitmsg = collapsemsg
             else:
                 commitmsg = 'Collapsed revision'
                 for rebased in state:
                     if rebased not in skipped and state[rebased] != nullmerge:
                         commitmsg += '\n* %s' % repo[rebased].description()
                 commitmsg = ui.edit(commitmsg, repo.ui.username())
             newrev = concludenode(repo, rev, p1, external, commitmsg=commitmsg,
                                   extrafn=extrafn, editor=editor)
 
         if 'qtip' in repo.tags():
             updatemq(repo, state, skipped, **opts)
 
         if currentbookmarks:
             # Nodeids are needed to reset bookmarks
             nstate = {}
             for k, v in state.iteritems():
                 if v != nullmerge:
                     nstate[repo[k].node()] = repo[v].node()
 
         if not keepf:
             # Remove no more useful revisions
             rebased = [rev for rev in state if state[rev] != nullmerge]
             if rebased:
                 if set(repo.changelog.descendants(min(rebased))) - set(state):
                     ui.warn(_("warning: new changesets detected "
                               "on source branch, not stripping\n"))
                 else:
                     # backup the old csets by default
                     repair.strip(ui, repo, repo[min(rebased)].node(), "all")
 
         if currentbookmarks:
             updatebookmarks(repo, nstate, currentbookmarks, **opts)
 
         clearstatus(repo)
         ui.note(_("rebase completed\n"))
         if os.path.exists(repo.sjoin('undo')):
             util.unlinkpath(repo.sjoin('undo'))
         if skipped:
             ui.note(_("%d revisions have been skipped\n") % len(skipped))
     finally:
         release(lock, wlock)
 
 def checkexternal(repo, state, targetancestors):
     """Check whether one or more external revisions need to be taken in
     consideration. In the latter case, abort.
     """
     external = nullrev
     source = min(state)
     for rev in state:
         if rev == source:
             continue
         # Check externals and fail if there are more than one
         for p in repo[rev].parents():
             if (p.rev() not in state
                         and p.rev() not in targetancestors):
                 if external != nullrev:
                     raise util.Abort(_('unable to collapse, there is more '
                             'than one external parent'))
                 external = p.rev()
     return external
 
 def concludenode(repo, rev, p1, p2, commitmsg=None, editor=None, extrafn=None):
     'Commit the changes and store useful information in extra'
     try:
         repo.dirstate.setparents(repo[p1].node(), repo[p2].node())
         ctx = repo[rev]
         if commitmsg is None:
             commitmsg = ctx.description()
         extra = {'rebase_source': ctx.hex()}
         if extrafn:
             extrafn(ctx, extra)
         # Commit might fail if unresolved files exist
         newrev = repo.commit(text=commitmsg, user=ctx.user(),
                              date=ctx.date(), extra=extra, editor=editor)
         repo.dirstate.setbranch(repo[newrev].branch())
         return newrev
     except util.Abort:
         # Invalidate the previous setparents
         repo.dirstate.invalidate()
         raise
 
 def rebasenode(repo, rev, p1, state):
     'Rebase a single revision'
     # Merge phase
     # Update to target and merge it with local
     if repo['.'].rev() != repo[p1].rev():
         repo.ui.debug(" update to %d:%s\n" % (repo[p1].rev(), repo[p1]))
         merge.update(repo, p1, False, True, False)
     else:
         repo.ui.debug(" already in target\n")
     repo.dirstate.write()
     repo.ui.debug(" merge against %d:%s\n" % (repo[rev].rev(), repo[rev]))
     base = None
     if repo[rev].rev() != repo[min(state)].rev():
         base = repo[rev].p1().node()
     return merge.update(repo, rev, True, True, False, base)
 
 def defineparents(repo, rev, target, state, targetancestors):
     'Return the new parent relationship of the revision that will be rebased'
     parents = repo[rev].parents()
     p1 = p2 = nullrev
 
     P1n = parents[0].rev()
     if P1n in targetancestors:
         p1 = target
     elif P1n in state:
         if state[P1n] == nullmerge:
             p1 = target
         else:
             p1 = state[P1n]
     else: # P1n external
         p1 = target
         p2 = P1n
 
     if len(parents) == 2 and parents[1].rev() not in targetancestors:
         P2n = parents[1].rev()
         # interesting second parent
         if P2n in state:
             if p1 == target: # P1n in targetancestors or external
                 p1 = state[P2n]
             else:
                 p2 = state[P2n]
         else: # P2n external
             if p2 != nullrev: # P1n external too => rev is a merged revision
                 raise util.Abort(_('cannot use revision %d as base, result '
                         'would have 3 parents') % rev)
             p2 = P2n
     repo.ui.debug(" future parents are %d and %d\n" %
                             (repo[p1].rev(), repo[p2].rev()))
     return p1, p2
 
 def isagitpatch(repo, patchname):
     'Return true if the given patch is in git format'
     mqpatch = os.path.join(repo.mq.path, patchname)
     for line in patch.linereader(file(mqpatch, 'rb')):
         if line.startswith('diff --git'):
             return True
     return False
 
 def updatemq(repo, state, skipped, **opts):
     'Update rebased mq patches - finalize and then import them'
     mqrebase = {}
     mq = repo.mq
     original_series = mq.fullseries[:]
 
     for p in mq.applied:
         rev = repo[p.node].rev()
         if rev in state:
             repo.ui.debug('revision %d is an mq patch (%s), finalize it.\n' %
                                         (rev, p.name))
             mqrebase[rev] = (p.name, isagitpatch(repo, p.name))
 
     if mqrebase:
         mq.finish(repo, mqrebase.keys())
 
         # We must start import from the newest revision
         for rev in sorted(mqrebase, reverse=True):
             if rev not in skipped:
                 name, isgit = mqrebase[rev]
                 repo.ui.debug('import mq patch %d (%s)\n' % (state[rev], name))
                 mq.qimport(repo, (), patchname=name, git=isgit,
                                 rev=[str(state[rev])])
 
         # restore old series to preserve guards
         mq.fullseries = original_series
         mq.series_dirty = True
         mq.savedirty()
 
 def updatebookmarks(repo, nstate, originalbookmarks, **opts):
     'Move bookmarks to their correct changesets'
     current = repo._bookmarkcurrent
     for k, v in originalbookmarks.iteritems():
         if v in nstate:
             if nstate[v] != nullmerge:
                 # reset the pointer if the bookmark was moved incorrectly
                 if k != current:
                     repo._bookmarks[k] = nstate[v]
 
     bookmarks.write(repo)
 
 def storestatus(repo, originalwd, target, state, collapse, keep, keepbranches,
                                                                 external):
     'Store the current status to allow recovery'
     f = repo.opener("rebasestate", "w")
     f.write(repo[originalwd].hex() + '\n')
     f.write(repo[target].hex() + '\n')
     f.write(repo[external].hex() + '\n')
     f.write('%d\n' % int(collapse))
     f.write('%d\n' % int(keep))
     f.write('%d\n' % int(keepbranches))
     for d, v in state.iteritems():
         oldrev = repo[d].hex()
         if v != nullmerge:
             newrev = repo[v].hex()
         else:
             newrev = v
         f.write("%s:%s\n" % (oldrev, newrev))
     f.close()
     repo.ui.debug('rebase status stored\n')
 
 def clearstatus(repo):
     'Remove the status files'
     if os.path.exists(repo.join("rebasestate")):
         util.unlinkpath(repo.join("rebasestate"))
 
 def restorestatus(repo):
     'Restore a previously stored status'
     try:
         target = None
         collapse = False
         external = nullrev
         state = {}
         f = repo.opener("rebasestate")
         for i, l in enumerate(f.read().splitlines()):
             if i == 0:
                 originalwd = repo[l].rev()
             elif i == 1:
                 target = repo[l].rev()
             elif i == 2:
                 external = repo[l].rev()
             elif i == 3:
                 collapse = bool(int(l))
             elif i == 4:
                 keep = bool(int(l))
             elif i == 5:
                 keepbranches = bool(int(l))
             else:
                 oldrev, newrev = l.split(':')
                 if newrev != str(nullmerge):
                     state[repo[oldrev].rev()] = repo[newrev].rev()
                 else:
                     state[repo[oldrev].rev()] = int(newrev)
         skipped = set()
         # recompute the set of skipped revs
         if not collapse:
             seen = set([target])
             for old, new in sorted(state.items()):
                 if new != nullrev and new in seen:
                     skipped.add(old)
                 seen.add(new)
         repo.ui.debug('computed skipped revs: %s\n' % skipped)
         repo.ui.debug('rebase status resumed\n')
         return (originalwd, target, state, skipped,
                 collapse, keep, keepbranches, external)
     except IOError, err:
         if err.errno != errno.ENOENT:
             raise
         raise util.Abort(_('no rebase in progress'))
 
 def abort(repo, originalwd, target, state):
     'Restore the repository to its original state'
     if set(repo.changelog.descendants(target)) - set(state.values()):
         repo.ui.warn(_("warning: new changesets detected on target branch, "
                                                     "can't abort\n"))
         return -1
     else:
         # Strip from the first rebased revision
         merge.update(repo, repo[originalwd].rev(), False, True, False)
         rebased = filter(lambda x: x > -1 and x != target, state.values())
         if rebased:
             strippoint = min(rebased)
             # no backup of rebased cset versions needed
             repair.strip(repo.ui, repo, repo[strippoint].node())
         clearstatus(repo)
         repo.ui.warn(_('rebase aborted\n'))
         return 0
 
 def buildstate(repo, dest, rebaseset, detach):
     '''Define which revisions are going to be rebased and where
 
     repo: repo
     dest: context
     rebaseset: set of rev
     detach: boolean'''
 
     # This check isn't strictly necessary, since mq detects commits over an
     # applied patch. But it prevents messing up the working directory when
     # a partially completed rebase is blocked by mq.
     if 'qtip' in repo.tags() and (dest.node() in
                             [s.node for s in repo.mq.applied]):
         raise util.Abort(_('cannot rebase onto an applied mq patch'))
 
     detachset = set()
     roots = list(repo.set('roots(%ld)', rebaseset))
     if not roots:
         raise util.Abort(_('no matching revisions'))
     if len(roots) > 1:
         raise util.Abort(_("can't rebase multiple roots"))
     root = roots[0]
 
     commonbase = root.ancestor(dest)
     if commonbase == root:
         raise util.Abort(_('source is ancestor of destination'))
     if commonbase == dest:
         samebranch = root.branch() == dest.branch()
         if samebranch and root in dest.children():
            repo.ui.debug('source is a child of destination')
            return None
         # rebase on ancestor, force detach
         detach = True
     if detach:
         detachset = repo.revs('::%d - ::%d - %d', root, commonbase, root)
 
     repo.ui.debug('rebase onto %d starting from %d\n' % (dest, root))
     state = dict.fromkeys(rebaseset, nullrev)
     state.update(dict.fromkeys(detachset, nullmerge))
     return repo['.'].rev(), dest.rev(), state
 
 def pullrebase(orig, ui, repo, *args, **opts):
     'Call rebase after pull if the latter has been invoked with --rebase'
     if opts.get('rebase'):
         if opts.get('update'):
             del opts['update']
             ui.debug('--update and --rebase are not compatible, ignoring '
                      'the update flag\n')
 
         cmdutil.bailifchanged(repo)
         revsprepull = len(repo)
         origpostincoming = commands.postincoming
         def _dummy(*args, **kwargs):
             pass
         commands.postincoming = _dummy
         try:
             orig(ui, repo, *args, **opts)
         finally:
             commands.postincoming = origpostincoming
         revspostpull = len(repo)
         if revspostpull > revsprepull:
             rebase(ui, repo, **opts)
             branch = repo[None].branch()
             dest = repo[branch].rev()
             if dest != repo['.'].rev():
                 # there was nothing to rebase we force an update
                 hg.update(repo, dest)
     else:
         if opts.get('tool'):
             raise util.Abort(_('--tool can only be used with --rebase'))
         orig(ui, repo, *args, **opts)
 
 def uisetup(ui):
     'Replace pull with a decorator to provide --rebase option'
     entry = extensions.wrapcommand(commands.table, 'pull', pullrebase)
     entry[1].append(('', 'rebase', None,
                      _("rebase working directory to branch head")))
     entry[1].append(('t', 'tool', '',
                      _("specify merge tool for rebase")))

mercurial/store.py

@@ -1,427 +1,427 b''
 # store.py - repository store handling for Mercurial
 #
 # Copyright 2008 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from i18n import _
 import osutil, scmutil, util
 import os, stat
 
 _sha = util.sha1
 
 # This avoids a collision between a file named foo and a dir named
 # foo.i or foo.d
 def encodedir(path):
     '''
     >>> encodedir('data/foo.i')
     'data/foo.i'
     >>> encodedir('data/foo.i/bla.i')
     'data/foo.i.hg/bla.i'
     >>> encodedir('data/foo.i.hg/bla.i')
     'data/foo.i.hg.hg/bla.i'
     '''
     if not path.startswith('data/'):
         return path
     return (path
             .replace(".hg/", ".hg.hg/")
             .replace(".i/", ".i.hg/")
             .replace(".d/", ".d.hg/"))
 
 def decodedir(path):
     '''
     >>> decodedir('data/foo.i')
     'data/foo.i'
     >>> decodedir('data/foo.i.hg/bla.i')
     'data/foo.i/bla.i'
     >>> decodedir('data/foo.i.hg.hg/bla.i')
     'data/foo.i.hg/bla.i'
     '''
     if not path.startswith('data/') or ".hg/" not in path:
         return path
     return (path
             .replace(".d.hg/", ".d/")
             .replace(".i.hg/", ".i/")
             .replace(".hg.hg/", ".hg/"))
 
 def _buildencodefun():
     '''
     >>> enc, dec = _buildencodefun()
 
     >>> enc('nothing/special.txt')
     'nothing/special.txt'
     >>> dec('nothing/special.txt')
     'nothing/special.txt'
 
     >>> enc('HELLO')
     '_h_e_l_l_o'
     >>> dec('_h_e_l_l_o')
     'HELLO'
 
     >>> enc('hello:world?')
     'hello~3aworld~3f'
     >>> dec('hello~3aworld~3f')
     'hello:world?'
 
     >>> enc('the\x07quick\xADshot')
     'the~07quick~adshot'
     >>> dec('the~07quick~adshot')
     'the\\x07quick\\xadshot'
     '''
     e = '_'
     winreserved = [ord(x) for x in '\\:*?"<>|']
     cmap = dict([(chr(x), chr(x)) for x in xrange(127)])
     for x in (range(32) + range(126, 256) + winreserved):
         cmap[chr(x)] = "~%02x" % x
     for x in range(ord("A"), ord("Z")+1) + [ord(e)]:
         cmap[chr(x)] = e + chr(x).lower()
     dmap = {}
     for k, v in cmap.iteritems():
         dmap[v] = k
     def decode(s):
         i = 0
         while i < len(s):
             for l in xrange(1, 4):
                 try:
                     yield dmap[s[i:i + l]]
                     i += l
                     break
                 except KeyError:
                     pass
             else:
                 raise KeyError
     return (lambda s: "".join([cmap[c] for c in encodedir(s)]),
             lambda s: decodedir("".join(list(decode(s)))))
 
 encodefilename, decodefilename = _buildencodefun()
 
 def _buildlowerencodefun():
     '''
     >>> f = _buildlowerencodefun()
     >>> f('nothing/special.txt')
     'nothing/special.txt'
     >>> f('HELLO')
     'hello'
     >>> f('hello:world?')
     'hello~3aworld~3f'
     >>> f('the\x07quick\xADshot')
     'the~07quick~adshot'
     '''
     winreserved = [ord(x) for x in '\\:*?"<>|']
     cmap = dict([(chr(x), chr(x)) for x in xrange(127)])
     for x in (range(32) + range(126, 256) + winreserved):
         cmap[chr(x)] = "~%02x" % x
     for x in range(ord("A"), ord("Z")+1):
         cmap[chr(x)] = chr(x).lower()
     return lambda s: "".join([cmap[c] for c in s])
 
 lowerencode = _buildlowerencodefun()
 
 _winreservednames = '''con prn aux nul
     com1 com2 com3 com4 com5 com6 com7 com8 com9
     lpt1 lpt2 lpt3 lpt4 lpt5 lpt6 lpt7 lpt8 lpt9'''.split()
 def _auxencode(path, dotencode):
     '''
     Encodes filenames containing names reserved by Windows or which end in
     period or space. Does not touch other single reserved characters c.
     Specifically, c in '\\:*?"<>|' or ord(c) <= 31 are *not* encoded here.
     Additionally encodes space or period at the beginning, if dotencode is
     True.
     path is assumed to be all lowercase.
 
     >>> _auxencode('.foo/aux.txt/txt.aux/con/prn/nul/foo.', True)
     '~2efoo/au~78.txt/txt.aux/co~6e/pr~6e/nu~6c/foo~2e'
     >>> _auxencode('.com1com2/lpt9.lpt4.lpt1/conprn/foo.', False)
     '.com1com2/lp~749.lpt4.lpt1/conprn/foo~2e'
     >>> _auxencode('foo. ', True)
     'foo.~20'
     >>> _auxencode(' .foo', True)
     '~20.foo'
     '''
     res = []
     for n in path.split('/'):
         if n:
             base = n.split('.')[0]
             if base and (base in _winreservednames):
                 # encode third letter ('aux' -> 'au~78')
                 ec = "~%02x" % ord(n[2])
                 n = n[0:2] + ec + n[3:]
             if n[-1] in '. ':
                 # encode last period or space ('foo...' -> 'foo..~2e')
                 n = n[:-1] + "~%02x" % ord(n[-1])
             if dotencode and n[0] in '. ':
                 n = "~%02x" % ord(n[0]) + n[1:]
         res.append(n)
     return '/'.join(res)
 
 _maxstorepathlen = 120
 _dirprefixlen = 8
 _maxshortdirslen = 8 * (_dirprefixlen + 1) - 4
 def _hybridencode(path, auxencode):
     '''encodes path with a length limit
 
     Encodes all paths that begin with 'data/', according to the following.
 
     Default encoding (reversible):
 
     Encodes all uppercase letters 'X' as '_x'. All reserved or illegal
     characters are encoded as '~xx', where xx is the two digit hex code
     of the character (see encodefilename).
     Relevant path components consisting of Windows reserved filenames are
     masked by encoding the third character ('aux' -> 'au~78', see auxencode).
 
     Hashed encoding (not reversible):
 
     If the default-encoded path is longer than _maxstorepathlen, a
     non-reversible hybrid hashing of the path is done instead.
     This encoding uses up to _dirprefixlen characters of all directory
     levels of the lowerencoded path, but not more levels than can fit into
     _maxshortdirslen.
     Then follows the filler followed by the sha digest of the full path.
     The filler is the beginning of the basename of the lowerencoded path
     (the basename is everything after the last path separator). The filler
     is as long as possible, filling in characters from the basename until
     the encoded path has _maxstorepathlen characters (or all chars of the
     basename have been taken).
     The extension (e.g. '.i' or '.d') is preserved.
 
     The string 'data/' at the beginning is replaced with 'dh/', if the hashed
     encoding was used.
     '''
     if not path.startswith('data/'):
         return path
     # escape directories ending with .i and .d
     path = encodedir(path)
     ndpath = path[len('data/'):]
     res = 'data/' + auxencode(encodefilename(ndpath))
     if len(res) > _maxstorepathlen:
         digest = _sha(path).hexdigest()
         aep = auxencode(lowerencode(ndpath))
         _root, ext = os.path.splitext(aep)
         parts = aep.split('/')
         basename = parts[-1]
         sdirs = []
         for p in parts[:-1]:
             d = p[:_dirprefixlen]
             if d[-1] in '. ':
                 # Windows can't access dirs ending in period or space
                 d = d[:-1] + '_'
             t = '/'.join(sdirs) + '/' + d
             if len(t) > _maxshortdirslen:
                 break
             sdirs.append(d)
         dirs = '/'.join(sdirs)
         if len(dirs) > 0:
             dirs += '/'
         res = 'dh/' + dirs + digest + ext
         spaceleft = _maxstorepathlen - len(res)
         if spaceleft > 0:
             filler = basename[:spaceleft]
             res = 'dh/' + dirs + filler + digest + ext
     return res
 
 def _calcmode(path):
     try:
         # files in .hg/ will be created using this mode
         mode = os.stat(path).st_mode
             # avoid some useless chmods
         if (0777 & ~util.umask) == (0777 & mode):
             mode = None
     except OSError:
         mode = None
     return mode
 
 _data = 'data 00manifest.d 00manifest.i 00changelog.d 00changelog.i phaseroots'
 
 class basicstore(object):
     '''base class for local repository stores'''
     def __init__(self, path, openertype):
         self.path = path
         self.createmode = _calcmode(path)
         op = openertype(self.path)
         op.createmode = self.createmode
         self.opener = scmutil.filteropener(op, encodedir)
 
     def join(self, f):
         return self.path + '/' + encodedir(f)
 
     def _walk(self, relpath, recurse):
         '''yields (unencoded, encoded, size)'''
         path = self.path
         if relpath:
             path += '/' + relpath
         striplen = len(self.path) + 1
         l = []
         if os.path.isdir(path):
             visit = [path]
             while visit:
                 p = visit.pop()
                 for f, kind, st in osutil.listdir(p, stat=True):
                     fp = p + '/' + f
                     if kind == stat.S_IFREG and f[-2:] in ('.d', '.i'):
                         n = util.pconvert(fp[striplen:])
                         l.append((decodedir(n), n, st.st_size))
                     elif kind == stat.S_IFDIR and recurse:
                         visit.append(fp)
         return sorted(l)
 
     def datafiles(self):
         return self._walk('data', True)
 
     def walk(self):
         '''yields (unencoded, encoded, size)'''
         # yield data files first
         for x in self.datafiles():
             yield x
         # yield manifest before changelog
         for x in reversed(self._walk('', False)):
             yield x
 
     def copylist(self):
         return ['requires'] + _data.split()
 
     def write(self):
         pass
 
 class encodedstore(basicstore):
     def __init__(self, path, openertype):
         self.path = path + '/store'
         self.createmode = _calcmode(self.path)
         op = openertype(self.path)
         op.createmode = self.createmode
         self.opener = scmutil.filteropener(op, encodefilename)
 
     def datafiles(self):
         for a, b, size in self._walk('data', True):
             try:
                 a = decodefilename(a)
             except KeyError:
                 a = None
             yield a, b, size
 
     def join(self, f):
         return self.path + '/' + encodefilename(f)
 
     def copylist(self):
         return (['requires', '00changelog.i'] +
                 ['store/' + f for f in _data.split()])
 
 class fncache(object):
     # the filename used to be partially encoded
     # hence the encodedir/decodedir dance
     def __init__(self, opener):
         self.opener = opener
         self.entries = None
         self._dirty = False
 
     def _load(self):
         '''fill the entries from the fncache file'''
         self.entries = set()
         self._dirty = False
         try:
             fp = self.opener('fncache', mode='rb')
         except IOError:
             # skip nonexistent file
             return
         for n, line in enumerate(fp):
             if (len(line) < 2) or (line[-1] != '\n'):
                 t = _('invalid entry in fncache, line %s') % (n + 1)
                 raise util.Abort(t)
             self.entries.add(decodedir(line[:-1]))
         fp.close()
 
     def rewrite(self, files):
         fp = self.opener('fncache', mode='wb')
         for p in files:
             fp.write(encodedir(p) + '\n')
         fp.close()
         self.entries = set(files)
         self._dirty = False
 
     def write(self):
         if not self._dirty:
             return
         fp = self.opener('fncache', mode='wb', atomictemp=True)
         for p in self.entries:
             fp.write(encodedir(p) + '\n')
         fp.close()
         self._dirty = False
 
     def add(self, fn):
         if self.entries is None:
             self._load()
         if fn not in self.entries:
             self._dirty = True
             self.entries.add(fn)
 
     def __contains__(self, fn):
         if self.entries is None:
             self._load()
         return fn in self.entries
 
     def __iter__(self):
         if self.entries is None:
             self._load()
         return iter(self.entries)
 
 class _fncacheopener(scmutil.abstractopener):
     def __init__(self, op, fnc, encode):
         self.opener = op
         self.fncache = fnc
         self.encode = encode
 
     def __call__(self, path, mode='r', *args, **kw):
         if mode not in ('r', 'rb') and path.startswith('data/'):
             self.fncache.add(path)
         return self.opener(self.encode(path), mode, *args, **kw)
 
 class fncachestore(basicstore):
     def __init__(self, path, openertype, encode):
         self.encode = encode
         self.path = path + '/store'
         self.createmode = _calcmode(self.path)
         op = openertype(self.path)
         op.createmode = self.createmode
         fnc = fncache(op)
         self.fncache = fnc
         self.opener = _fncacheopener(op, fnc, encode)
 
     def join(self, f):
         return self.path + '/' + self.encode(f)
 
     def datafiles(self):
         rewrite = False
         existing = []
         spath = self.path
         for f in self.fncache:
             ef = self.encode(f)
             try:
                 st = os.stat(spath + '/' + ef)
                 yield f, ef, st.st_size
                 existing.append(f)
             except OSError:
                 # nonexistent entry
                 rewrite = True
         if rewrite:
             # rewrite fncache to remove nonexistent entries
             # (may be caused by rollback / strip)
             self.fncache.rewrite(existing)
 
     def copylist(self):
-        d = ('data dh fncache'
-             ' 00manifest.d 00manifest.i 00changelog.d 00changelog.i phaseroots')
+        d = ('data dh fncache phaseroots'
+             ' 00manifest.d 00manifest.i 00changelog.d 00changelog.i')
         return (['requires', '00changelog.i'] +
                 ['store/' + f for f in d.split()])
 
     def write(self):
         self.fncache.write()
 
 def store(requirements, path, openertype):
     if 'store' in requirements:
         if 'fncache' in requirements:
             auxencode = lambda f: _auxencode(f, 'dotencode' in requirements)
             encode = lambda f: _hybridencode(f, auxencode)
             return fncachestore(path, openertype, encode)
         return encodedstore(path, openertype)
     return basicstore(path, openertype)

tests/test-largefiles.t

@@ -1,877 +1,879 b''
   $ "$TESTDIR/hghave" symlink unix-permissions serve || exit 80
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > purge=
   > rebase=
   > transplant=
+  > [phases]
+  > publish=False
   > [largefiles]
   > minsize=2
   > patterns=glob:**.dat
   > EOF
 
 Create the repo with a couple of revisions of both large and normal
 files, testing that status correctly shows largefiles.
 
   $ hg init a
   $ cd a
   $ mkdir sub
   $ echo normal1 > normal1
   $ echo normal2 > sub/normal2
   $ echo large1 > large1
   $ echo large2 > sub/large2
   $ hg add normal1 sub/normal2
   $ hg add --large large1 sub/large2
   $ hg commit -m "add files"
   $ echo normal11 > normal1
   $ echo normal22 > sub/normal2
   $ echo large11 > large1
   $ echo large22 > sub/large2
   $ hg st
   M large1
   M normal1
   M sub/large2
   M sub/normal2
   $ hg commit -m "edit files"
 
 Commit preserved largefile contents.
 
   $ cat normal1
   normal11
   $ cat large1
   large11
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
 
 Remove both largefiles and normal files.
  
   $ hg remove normal1 large1
   $ hg commit -m "remove files"
   $ ls
   sub
 
 Copy both largefiles and normal files (testing that status output is correct).
 
   $ hg cp sub/normal2 normal1
   $ hg cp sub/large2 large1
   $ hg st
   A large1
   A normal1
   $ hg commit -m "copy files"
   $ cat normal1
   normal22
   $ cat large1
   large22
 
 Test moving largefiles and verify that normal files are also unaffected.
 
   $ hg mv normal1 normal3
   $ hg mv large1 large3
   $ hg mv sub/normal2 sub/normal4
   $ hg mv sub/large2 sub/large4
   $ hg commit -m "move files"
   $ cat normal3
   normal22
   $ cat large3
   large22
   $ cat sub/normal4
   normal22
   $ cat sub/large4
   large22
 
 Test archiving the various revisions.  These hit corner cases known with
 archiving.
 
   $ hg archive -r 0 ../archive0
   $ hg archive -r 1 ../archive1
   $ hg archive -r 2 ../archive2
   $ hg archive -r 3 ../archive3
   $ hg archive -r 4 ../archive4
   $ cd ../archive0
   $ cat normal1 
   normal1
   $ cat large1
   large1
   $ cat sub/normal2
   normal2
   $ cat sub/large2
   large2
   $ cd ../archive1
   $ cat normal1
   normal11
   $ cat large1
   large11
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
   $ cd ../archive2
   $ ls
   sub
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
   $ cd ../archive3
   $ cat normal1
   normal22
   $ cat large1
   large22
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
   $ cd ../archive4
   $ cat normal3
   normal22
   $ cat large3
   large22
   $ cat sub/normal4
   normal22
   $ cat sub/large4
   large22
 
 Commit corner case: specify files to commit.
 
   $ cd ../a
   $ echo normal3 > normal3
   $ echo large3 > large3
   $ echo normal4 > sub/normal4
   $ echo large4 > sub/large4
   $ hg commit normal3 large3 sub/normal4 sub/large4 -m "edit files again"
   $ cat normal3
   normal3
   $ cat large3
   large3
   $ cat sub/normal4
   normal4
   $ cat sub/large4
   large4
 
 One more commit corner case: commit from a subdirectory.
 
   $ cd ../a
   $ echo normal33 > normal3
   $ echo large33 > large3
   $ echo normal44 > sub/normal4
   $ echo large44 > sub/large4
   $ cd sub
   $ hg commit -m "edit files yet again"
   $ cat ../normal3
   normal33
   $ cat ../large3
   large33
   $ cat normal4
   normal44
   $ cat large4
   large44
 
 Committing standins is not allowed.
 
   $ cd ..
   $ echo large3 > large3
   $ hg commit .hglf/large3 -m "try to commit standin"
   abort: file ".hglf/large3" is a largefile standin
   (commit the largefile itself instead)
   [255]
 
 Corner cases for adding largefiles.
 
   $ echo large5 > large5
   $ hg add --large large5
   $ hg add --large large5
   large5 already a largefile
   $ mkdir sub2
   $ echo large6 > sub2/large6
   $ echo large7 > sub2/large7
   $ hg add --large sub2
   adding sub2/large6 as a largefile (glob)
   adding sub2/large7 as a largefile (glob)
   $ hg st
   M large3
   A large5
   A sub2/large6
   A sub2/large7
 
 Config settings (pattern **.dat, minsize 2 MB) are respected.
 
   $ echo testdata > test.dat
   $ dd bs=1k count=2k if=/dev/zero of=reallylarge > /dev/null 2> /dev/null
   $ hg add
   adding reallylarge as a largefile
   adding test.dat as a largefile
 
 Test that minsize and --lfsize handle float values;
 also tests that --lfsize overrides largefiles.minsize.
 (0.250 MB = 256 kB = 262144 B)
 
   $ dd if=/dev/zero of=ratherlarge bs=1024 count=256 > /dev/null 2> /dev/null
   $ dd if=/dev/zero of=medium bs=1024 count=128 > /dev/null 2> /dev/null
   $ hg --config largefiles.minsize=.25 add
   adding ratherlarge as a largefile
   adding medium
   $ hg forget medium
   $ hg --config largefiles.minsize=.25 add --lfsize=.125
   adding medium as a largefile
   $ dd if=/dev/zero of=notlarge bs=1024 count=127 > /dev/null 2> /dev/null
   $ hg --config largefiles.minsize=.25 add --lfsize=.125
   adding notlarge
   $ hg forget notlarge
 
 Test forget on largefiles.
 
   $ hg forget large3 large5 test.dat reallylarge ratherlarge medium
   $ hg st
   A sub2/large6
   A sub2/large7
   R large3
   ? large5
   ? medium
   ? notlarge
   ? ratherlarge
   ? reallylarge
   ? test.dat
   $ hg commit -m "add/edit more largefiles"
   $ hg st
   ? large3
   ? large5
   ? medium
   ? notlarge
   ? ratherlarge
   ? reallylarge
   ? test.dat
 
 Purge with largefiles: verify that largefiles are still in the working
 dir after a purge.
 
   $ hg purge --all
   $ cat sub/large4
   large44
   $ cat sub2/large6
   large6
   $ cat sub2/large7
   large7
 
 Clone a largefiles repo.
 
   $ hg clone . ../b
   updating to branch default
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   3 largefiles updated, 0 removed
   $ cd ../b
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal33
   $ cat sub/normal4
   normal44
   $ cat sub/large4
   large44
   $ cat sub2/large6
   large6
   $ cat sub2/large7
   large7
   $ cd ..
   $ hg clone a -r 3 c
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 10 changes to 4 files
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   2 largefiles updated, 0 removed
   $ cd c
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal1
   normal22
   $ cat large1
   large22
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
 
 Old revisions of a clone have correct largefiles content (this also
 tests update).
 
   $ hg update -r 1 
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ cat large1
   large11
   $ cat sub/large2
   large22
 
 Rebasing between two repositories does not revert largefiles to old
 revisions (this was a very bad bug that took a lot of work to fix).
 
   $ cd ..
   $ hg clone a d
   updating to branch default
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   3 largefiles updated, 0 removed
   $ cd b
   $ echo large4-modified > sub/large4
   $ echo normal3-modified > normal3
   $ hg commit -m "modify normal file and largefile in repo b"
   $ cd ../d
   $ echo large6-modified > sub2/large6
   $ echo normal4-modified > sub/normal4
   $ hg commit -m "modify normal file largefile in repo d"
   $ cd ..
   $ hg clone d e
   updating to branch default
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   3 largefiles updated, 0 removed
   $ cd d
   $ hg pull --rebase ../b
   pulling from ../b
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files (+1 heads)
   getting changed largefiles
   1 largefiles updated, 0 removed
   saved backup bundle to $TESTTMP/d/.hg/strip-backup/f574fb32bb45-backup.hg (glob)
   nothing to rebase
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
   $ cd ../e
   $ hg pull ../b
   pulling from ../b
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg rebase
   getting changed largefiles
   1 largefiles updated, 0 removed
   saved backup bundle to $TESTTMP/e/.hg/strip-backup/f574fb32bb45-backup.hg (glob)
   $ hg log
   changeset:   9:598410d3eb9a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify normal file largefile in repo d
   
   changeset:   8:a381d2c8c80e
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify normal file and largefile in repo b
   
   changeset:   7:daea875e9014
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add/edit more largefiles
   
   changeset:   6:4355d653f84f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files yet again
   
   changeset:   5:9d5af5072dbd
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files again
   
   changeset:   4:74c02385b94c
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     move files
   
   changeset:   3:9e8fbc4bce62
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     copy files
   
   changeset:   2:51a0ae4d5864
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     remove files
   
   changeset:   1:ce8896473775
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files
   
   changeset:   0:30d30fe6a5be
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add files
   
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Rollback on largefiles.
 
   $ echo large4-modified-again > sub/large4 
   $ hg commit -m "Modify large4 again"
   $ hg rollback
   repository tip rolled back to revision 9 (undo commit)
   working directory now based on revision 9
   $ hg st
   M sub/large4
   $ hg log
   changeset:   9:598410d3eb9a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify normal file largefile in repo d
   
   changeset:   8:a381d2c8c80e
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify normal file and largefile in repo b
   
   changeset:   7:daea875e9014
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add/edit more largefiles
   
   changeset:   6:4355d653f84f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files yet again
   
   changeset:   5:9d5af5072dbd
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files again
   
   changeset:   4:74c02385b94c
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     move files
   
   changeset:   3:9e8fbc4bce62
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     copy files
   
   changeset:   2:51a0ae4d5864
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     remove files
   
   changeset:   1:ce8896473775
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files
   
   changeset:   0:30d30fe6a5be
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add files
   
   $ cat sub/large4
   large4-modified-again
 
 "update --check" refuses to update with uncommitted changes.
   $ hg update --check 8
   abort: uncommitted local changes
   [255]
 
 "update --clean" leaves correct largefiles in working copy.
 
   $ hg update --clean 
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Now "update check" is happy.
   $ hg update --check 8
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ hg update --check
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   1 largefiles updated, 0 removed
 
 "revert" works on largefiles (and normal files too).
   $ echo hack3 >> normal3
   $ echo hack4 >> sub/normal4
   $ echo hack4 >> sub/large4
   $ hg rm sub2/large6
   $ echo new >> sub2/large8
   $ hg add --large sub2/large8
 # XXX we don't really want to report that we're reverting the standin;
 # that's just an implementation detail. But I don't see an obvious fix. ;-(
   $ hg revert sub
   reverting .hglf/sub/large4 (glob)
   reverting sub/normal4 (glob)
   $ hg status
   M normal3
   A sub2/large8
   R sub2/large6
   ? sub/large4.orig
   ? sub/normal4.orig
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ hg revert -a --no-backup
   undeleting .hglf/sub2/large6 (glob)
   forgetting .hglf/sub2/large8 (glob)
   reverting normal3
   $ hg status
   ? sub/large4.orig
   ? sub/normal4.orig
   ? sub2/large8
   $ cat normal3
   normal3-modified
   $ cat sub2/large6
   large6-modified
   $ rm sub/*.orig sub2/large8
 
 revert some files to an older revision
   $ hg revert --no-backup -r 8 sub2
   reverting .hglf/sub2/large6 (glob)
   $ cat sub2/large6
   large6
   $ hg revert --no-backup sub2
   reverting .hglf/sub2/large6 (glob)
   $ hg status
 
 "verify --large" actually verifies largefiles
 
   $ hg verify --large
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   10 files, 10 changesets, 28 total revisions
   searching 1 changesets for largefiles
   verified existence of 3 revisions of 3 largefiles
 
 Merging does not revert to old versions of largefiles (this has also
 been very problematic).
 
   $ cd ..
   $ hg clone -r 7 e f
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 24 changes to 10 files
   updating to branch default
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   3 largefiles updated, 0 removed
   $ cd f
   $ echo "large4-merge-test" > sub/large4
   $ hg commit -m "Modify large4 to test merge"
   $ hg pull ../e
   pulling from ../e
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 4 changes to 4 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg merge
   merging sub/large4
   largefile sub/large4 has a merge conflict
   keep (l)ocal or take (o)ther? l
   3 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ hg commit -m "Merge repos e and f"
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-merge-test
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Test status after merging with a branch that introduces a new largefile:
 
   $ echo large > large
   $ hg add --large large
   $ hg commit -m 'add largefile'
   $ hg update -q ".^"
   $ echo change >> normal3
   $ hg commit -m 'some change'
   created new head
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ hg status
   M large
 
 Test that a normal file and a largefile with the same name and path cannot
 coexist.
 
   $ rm sub2/large7
   $ echo "largeasnormal" > sub2/large7
   $ hg add sub2/large7
   sub2/large7 already a largefile
 
 Test that transplanting a largefile change works correctly.
 
   $ cd ..
   $ hg clone -r 8 d g
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 26 changes to 10 files
   updating to branch default
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   3 largefiles updated, 0 removed
   $ cd g
   $ hg transplant -s ../d 598410d3eb9a 
   searching for changes
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Test that renaming a largefile results in correct output for status
 
   $ hg rename sub/large4 large4-renamed
   $ hg st
   A large4-renamed
   R sub/large4
   $ hg commit -m "test rename output"
   $ cat large4-renamed
   large4-modified
   $ cd sub2
   $ hg rename large6 large6-renamed
   $ hg st
   A sub2/large6-renamed
   R sub2/large6
   $ cd ../..
 
 vanilla clients not locked out from largefiles servers on vanilla repos
   $ mkdir r1
   $ cd r1
   $ hg init
   $ echo c1 > f1
   $ hg add f1
   $ hg com -m "m1"
   $ cd ..
   $ hg serve -R r1 -d -p $HGPORT --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg --config extensions.largefiles=! clone http://localhost:$HGPORT r2
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 largefiles clients still work with vanilla servers
   $ hg --config extensions.largefiles=! serve -R r1 -d -p $HGPORT1 --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg clone http://localhost:$HGPORT1 r3
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 vanilla clients locked out from largefiles http repos
   $ mkdir r4
   $ cd r4
   $ hg init
   $ echo c1 > f1
   $ hg add --large f1
   $ hg com -m "m1"
   $ cd ..
   $ hg serve -R r4 -d -p $HGPORT2 --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg --config extensions.largefiles=! clone http://localhost:$HGPORT2 r5
   abort: remote error:
   
   This repository uses the largefiles extension.
   
   Please enable it in your Mercurial config file.
   [255]
 
 used all HGPORTs, kill all daemons
   $ "$TESTDIR/killdaemons.py"
 
 vanilla clients locked out from largefiles ssh repos
   $ hg --config extensions.largefiles=! clone -e "python $TESTDIR/dummyssh" ssh://user@dummy/r4 r5
   abort: remote error:
   
   This repository uses the largefiles extension.
   
   Please enable it in your Mercurial config file.
   [255]
 
 largefiles clients refuse to push largefiles repos to vanilla servers
   $ mkdir r6
   $ cd r6
   $ hg init
   $ echo c1 > f1
   $ hg add f1
   $ hg com -m "m1"
   $ cat >> .hg/hgrc <<!
   > [web]
   > push_ssl = false
   > allow_push = *
   > !
   $ cd ..
   $ hg clone r6 r7
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd r7
   $ echo c2 > f2
   $ hg add --large f2
   $ hg com -m "m2"
   $ hg --config extensions.largefiles=! -R ../r6 serve -d -p $HGPORT --pid-file ../hg.pid
   $ cat ../hg.pid >> $DAEMON_PIDS
   $ hg push http://localhost:$HGPORT
   pushing to http://localhost:$HGPORT/
   searching for changes
   abort: http://localhost:$HGPORT/ does not appear to be a largefile store
   [255]
   $ cd ..
 
 Clone a local repository owned by another user
 We have to simulate that here by setting $HOME and removing write permissions
   $ ORIGHOME="$HOME"
   $ mkdir alice
   $ HOME="`pwd`/alice"
   $ cd alice
   $ hg init pubrepo
   $ cd pubrepo
   $ dd if=/dev/urandom bs=1k count=11k > a-large-file 2> /dev/null
   $ hg add --large a-large-file
   $ hg commit -m "Add a large file"
   $ cd ..
   $ chmod -R a-w pubrepo
   $ cd ..
   $ mkdir bob
   $ HOME="`pwd`/bob"
   $ cd bob
   $ hg clone --pull ../alice/pubrepo pubrepo
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ cd ..
   $ chmod -R u+w alice/pubrepo
   $ HOME="$ORIGHOME"
 
 Symlink to a large largefile should behave the same as a symlink to a normal file
   $ hg init largesymlink
   $ cd largesymlink
   $ dd if=/dev/zero bs=1k count=10k of=largefile 2>/dev/null
   $ hg add --large largefile
   $ hg commit -m "commit a large file"
   $ ln -s largefile largelink
   $ hg add largelink
   $ hg commit -m "commit a large symlink"
   $ rm -f largelink
   $ hg up >/dev/null
   $ test -f largelink
   [1]
   $ test -L largelink
   [1]
   $ rm -f largelink # make next part of the test independent of the previous
   $ hg up -C >/dev/null
   $ test -f largelink
   $ test -L largelink
   $ cd ..
 
 

tests/test-rebase-abort.t

@@ -1,148 +1,151 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
 
   $ echo c1 > common
   $ hg add common
   $ hg ci -m C1
 
   $ echo c2 >> common
   $ hg ci -m C2
 
   $ echo c3 >> common
   $ hg ci -m C3
 
   $ hg up -q -C 1
 
   $ echo l1 >> extra
   $ hg add extra
   $ hg ci -m L1
   created new head
 
   $ sed -e 's/c2/l2/' common > common.new
   $ mv common.new common
   $ hg ci -m L2
 
   $ hg tglog
   @  4: 'L2'
   |
   o  3: 'L1'
   |
   | o  2: 'C3'
   |/
   o  1: 'C2'
   |
   o  0: 'C1'
   
 
 Conflicting rebase:
 
   $ hg rebase -s 3 -d 2
   merging common
   warning: conflicts during merge.
   merging common incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
 Abort:
 
   $ hg rebase --abort
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/*-backup.hg (glob)
   rebase aborted
 
   $ hg tglog
   @  4: 'L2'
   |
   o  3: 'L1'
   |
   | o  2: 'C3'
   |/
   o  1: 'C2'
   |
   o  0: 'C1'
   
   $ cd ..
 
 
 Constrcut new repo:
 
   $ hg init b
   $ cd b
 
   $ echo a > a
   $ hg ci -Am A
   adding a
 
   $ echo b > b
   $ hg ci -Am B
   adding b
 
   $ echo c > c
   $ hg ci -Am C
   adding c
 
   $ hg up -q 0
 
   $ echo b > b
   $ hg ci -Am 'B bis'
   adding b
   created new head
 
   $ echo c1 > c
   $ hg ci -Am C1
   adding c
 
 Rebase and abort without generating new changesets:
 
   $ hg tglog
   @  4: 'C1'
   |
   o  3: 'B bis'
   |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase -b 4 -d 2
   merging c
   warning: conflicts during merge.
   merging c incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
   $ hg tglog
   @  4: 'C1'
   |
   o  3: 'B bis'
   |
   | @  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase -a
   rebase aborted
 
   $ hg tglog
   @  4: 'C1'
   |
   o  3: 'B bis'
   |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   

tests/test-rebase-bookmarks.t

@@ -1,85 +1,88 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' bookmarks: {bookmarks}\n"
   > EOF
 
 Create a repo with several bookmarks
   $ hg init a
   $ cd a
 
   $ echo a > a
   $ hg ci -Am A
   adding a
 
   $ echo b > b
   $ hg ci -Am B
   adding b
   $ hg book 'X'
   $ hg book 'Y'
  
   $ echo c > c
   $ hg ci -Am C
   adding c
   $ hg book 'Z'
 
   $ hg up -q 0
 
   $ echo d > d
   $ hg ci -Am D
   adding d
   created new head
 
   $ hg tglog 
   @  3: 'D' bookmarks:
   |
   | o  2: 'C' bookmarks: Y Z
   | |
   | o  1: 'B' bookmarks: X
   |/
   o  0: 'A' bookmarks:
   
  
 Move only rebased bookmarks
 
   $ cd ..
   $ hg clone -q a a1
 
   $ cd a1
   $ hg up -q Z
 
   $ hg rebase --detach -s Y -d 3
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog 
   @  3: 'C' bookmarks: Y Z
   |
   o  2: 'D' bookmarks:
   |
   | o  1: 'B' bookmarks: X
   |/
   o  0: 'A' bookmarks:
   
 Keep bookmarks to the correct rebased changeset
 
   $ cd ..
   $ hg clone -q a a2
 
   $ cd a2
   $ hg up -q Z
 
   $ hg rebase -s 1 -d 3
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog 
   @  3: 'C' bookmarks: Y Z
   |
   o  2: 'B' bookmarks: X
   |
   o  1: 'D' bookmarks:
   |
   o  0: 'A' bookmarks:
   

tests/test-rebase-cache.t

@@ -1,261 +1,264 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog  = log -G --template "{rev}: '{desc}' {branches}\n"
   > theads = heads --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
   $ hg init a
   $ cd a
 
   $ echo a > a
   $ hg ci -Am A
   adding a
 
   $ hg branch branch1
   marked working directory as branch branch1
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -m 'branch1'
 
   $ echo b > b
   $ hg ci -Am B
   adding b
 
   $ hg up -q 0
 
   $ hg branch branch2
   marked working directory as branch branch2
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -m 'branch2'
 
   $ echo c > C
   $ hg ci -Am C
   adding C
 
   $ hg up -q 2
 
   $ hg branch -f branch2
   marked working directory as branch branch2
   (branches are permanent and global, did you want a bookmark?)
   $ echo d > d
   $ hg ci -Am D
   adding d
   created new head
 
   $ echo e > e
   $ hg ci -Am E
   adding e
 
   $ hg update default
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
 
   $ hg branch branch3
   marked working directory as branch branch3
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -m 'branch3'
 
   $ echo f > f
   $ hg ci -Am F
   adding f
 
   $ cd ..
 
 
 Rebase part of branch2 (5-6) onto branch3 (8):
 
   $ hg clone -q -u . a a1
   $ cd a1
 
   $ hg tglog  
   @  8: 'F' branch3
   |
   o  7: 'branch3' branch3
   |
   | o  6: 'E' branch2
   | |
   | o  5: 'D' branch2
   | |
   | | o  4: 'C' branch2
   | | |
   +---o  3: 'branch2' branch2
   | |
   | o  2: 'B' branch1
   | |
   | o  1: 'branch1' branch1
   |/
   o  0: 'A'
   
   $ hg branches
   branch3                        8:4666b71e8e32
   branch2                        6:5097051d331d
   branch1                        2:0a03079c47fd (inactive)
   default                        0:1994f17a630e (inactive)
 
   $ hg theads
   8: 'F' branch3
   6: 'E' branch2
   4: 'C' branch2
   2: 'B' branch1
   0: 'A' 
 
   $ hg rebase --detach -s 5 -d 8
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg branches
   branch3                        8:466cdfb14b62
   branch2                        4:e4fdb121d036
   branch1                        2:0a03079c47fd
   default                        0:1994f17a630e (inactive)
 
   $ hg theads
   8: 'E' branch3
   4: 'C' branch2
   2: 'B' branch1
   0: 'A' 
 
   $ hg tglog  
   @  8: 'E' branch3
   |
   o  7: 'D' branch3
   |
   o  6: 'F' branch3
   |
   o  5: 'branch3' branch3
   |
   | o  4: 'C' branch2
   | |
   | o  3: 'branch2' branch2
   |/
   | o  2: 'B' branch1
   | |
   | o  1: 'branch1' branch1
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Rebase head of branch3 (8) onto branch2 (6):
 
   $ hg clone -q -u . a a2
   $ cd a2
 
   $ hg tglog
   @  8: 'F' branch3
   |
   o  7: 'branch3' branch3
   |
   | o  6: 'E' branch2
   | |
   | o  5: 'D' branch2
   | |
   | | o  4: 'C' branch2
   | | |
   +---o  3: 'branch2' branch2
   | |
   | o  2: 'B' branch1
   | |
   | o  1: 'branch1' branch1
   |/
   o  0: 'A'
   
   $ hg rebase --detach -s 8 -d 6
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg branches
   branch2                        8:6b4bdc1b5ac0
   branch3                        7:653b9feb4616
   branch1                        2:0a03079c47fd (inactive)
   default                        0:1994f17a630e (inactive)
 
   $ hg theads
   8: 'F' branch2
   7: 'branch3' branch3
   4: 'C' branch2
   2: 'B' branch1
   0: 'A' 
 
   $ hg tglog
   @  8: 'F' branch2
   |
   | o  7: 'branch3' branch3
   | |
   o |  6: 'E' branch2
   | |
   o |  5: 'D' branch2
   | |
   | | o  4: 'C' branch2
   | | |
   | | o  3: 'branch2' branch2
   | |/
   o |  2: 'B' branch1
   | |
   o |  1: 'branch1' branch1
   |/
   o  0: 'A'
   
   $ hg verify -q
 
   $ cd ..
 
 
 Rebase entire branch3 (7-8) onto branch2 (6):
 
   $ hg clone -q -u . a a3
   $ cd a3
 
   $ hg tglog
   @  8: 'F' branch3
   |
   o  7: 'branch3' branch3
   |
   | o  6: 'E' branch2
   | |
   | o  5: 'D' branch2
   | |
   | | o  4: 'C' branch2
   | | |
   +---o  3: 'branch2' branch2
   | |
   | o  2: 'B' branch1
   | |
   | o  1: 'branch1' branch1
   |/
   o  0: 'A'
   
   $ hg rebase --detach -s 7 -d 6
   saved backup bundle to $TESTTMP/a3/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg branches
   branch2                        7:6b4bdc1b5ac0
   branch1                        2:0a03079c47fd (inactive)
   default                        0:1994f17a630e (inactive)
 
   $ hg theads
   7: 'F' branch2
   4: 'C' branch2
   2: 'B' branch1
   0: 'A' 
 
   $ hg tglog   
   @  7: 'F' branch2
   |
   o  6: 'E' branch2
   |
   o  5: 'D' branch2
   |
   | o  4: 'C' branch2
   | |
   | o  3: 'branch2' branch2
   | |
   o |  2: 'B' branch1
   | |
   o |  1: 'branch1' branch1
   |/
   o  0: 'A'
   
   $ hg verify -q
 

tests/test-rebase-check-restore.t

@@ -1,143 +1,146 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
 
   $ echo A > A
   $ hg add A
   $ hg ci -m A
 
   $ echo 'B' > B
   $ hg add B
   $ hg ci -m B
 
   $ echo C >> A
   $ hg ci -m C
 
   $ hg up -q -C 0
 
   $ echo D >> A
   $ hg ci -m D
   created new head
 
   $ echo E > E
   $ hg add E
   $ hg ci -m E
 
   $ hg up -q -C 0
 
   $ hg branch 'notdefault'
   marked working directory as branch notdefault
   (branches are permanent and global, did you want a bookmark?)
   $ echo F >> A
   $ hg ci -m F
 
   $ cd ..
 
 
 Rebasing B onto E - check keep:
 
   $ hg clone -q -u . a a1
   $ cd a1
 
   $ hg tglog
   @  5: 'F' notdefault
   |
   | o  4: 'E'
   | |
   | o  3: 'D'
   |/
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase -s 1 -d 4 --keep
   merging A
   warning: conflicts during merge.
   merging A incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
 Solve the conflict and go on:
 
   $ echo 'conflict solved' > A
   $ rm A.orig
   $ hg resolve -m A
   $ hg rebase --continue
 
   $ hg tglog
   @  7: 'C'
   |
   o  6: 'B'
   |
   | o  5: 'F' notdefault
   | |
   o |  4: 'E'
   | |
   o |  3: 'D'
   |/
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Rebase F onto E - check keepbranches:
 
   $ hg clone -q -u . a a2
   $ cd a2
 
   $ hg tglog
   @  5: 'F' notdefault
   |
   | o  4: 'E'
   | |
   | o  3: 'D'
   |/
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase -s 5 -d 4 --keepbranches
   merging A
   warning: conflicts during merge.
   merging A incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
 Solve the conflict and go on:
 
   $ echo 'conflict solved' > A
   $ rm A.orig
   $ hg resolve -m A
   $ hg rebase --continue
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  5: 'F' notdefault
   |
   o  4: 'E'
   |
   o  3: 'D'
   |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   

tests/test-rebase-collapse.t

@@ -1,484 +1,487 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
 Create repo a:
 
   $ hg init a
   $ cd a
   $ hg unbundle $TESTDIR/bundles/rebase.hg
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Rebasing B onto H:
 
   $ hg clone -q -u 3 a a1
   $ cd a1
 
   $ hg rebase --collapse --keepbranches
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  5: 'Collapsed revision
   |  * B
   |  * C
   |  * D'
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   B
   C
   D
   F
   H
 
   $ cd ..
 
 
 Rebasing E onto H:
 
   $ hg clone -q -u . a a2
   $ cd a2
 
   $ hg rebase --source 4 --collapse
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  6: 'Collapsed revision
   |  * E
   |  * G'
   o  5: 'H'
   |
   o  4: 'F'
   |
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   E
   F
   H
 
   $ cd ..
 
 Rebasing G onto H with custom message:
 
   $ hg clone -q -u . a a3
   $ cd a3
 
   $ hg rebase --base 6 -m 'custom message'
   abort: message can only be specified with collapse
   [255]
 
   $ hg rebase --source 4 --collapse -m 'custom message'
   saved backup bundle to $TESTTMP/a3/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  6: 'custom message'
   |
   o  5: 'H'
   |
   o  4: 'F'
   |
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   E
   F
   H
 
   $ cd ..
 
 Create repo b:
 
   $ hg init b
   $ cd b
 
   $ echo A > A
   $ hg ci -Am A
   adding A
   $ echo B > B
   $ hg ci -Am B
   adding B
 
   $ hg up -q 0
 
   $ echo C > C
   $ hg ci -Am C
   adding C
   created new head
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ echo D > D
   $ hg ci -Am D
   adding D
 
   $ hg up -q 1
 
   $ echo E > E
   $ hg ci -Am E
   adding E
   created new head
 
   $ echo F > F
   $ hg ci -Am F
   adding F
 
   $ hg merge
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m G
 
   $ hg up -q 0
 
   $ echo H > H
   $ hg ci -Am H
   adding H
   created new head
 
   $ hg tglog
   @  7: 'H'
   |
   | o    6: 'G'
   | |\
   | | o  5: 'F'
   | | |
   | | o  4: 'E'
   | | |
   | o |  3: 'D'
   | |\|
   | o |  2: 'C'
   |/ /
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Rebase and collapse - more than one external (fail):
 
   $ hg clone -q -u . b b1
   $ cd b1
 
   $ hg rebase -s 2 --collapse
   abort: unable to collapse, there is more than one external parent
   [255]
 
 Rebase and collapse - E onto H:
 
   $ hg rebase -s 4 --collapse
   saved backup bundle to $TESTTMP/b1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @    5: 'Collapsed revision
   |\   * E
   | |  * F
   | |  * G'
   | o  4: 'H'
   | |
   o |    3: 'D'
   |\ \
   | o |  2: 'C'
   | |/
   o /  1: 'B'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   B
   C
   D
   E
   F
   H
 
   $ cd ..
 
 
 Create repo c:
 
   $ hg init c
   $ cd c
 
   $ echo A > A
   $ hg ci -Am A
   adding A
   $ echo B > B
   $ hg ci -Am B
   adding B
 
   $ hg up -q 0
 
   $ echo C > C
   $ hg ci -Am C
   adding C
   created new head
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ echo D > D
   $ hg ci -Am D
   adding D
 
   $ hg up -q 1
 
   $ echo E > E
   $ hg ci -Am E
   adding E
   created new head
   $ echo F > E
   $ hg ci -m 'F'
 
   $ echo G > G
   $ hg ci -Am G
   adding G
 
   $ hg merge
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg ci -m H
 
   $ hg up -q 0
 
   $ echo I > I
   $ hg ci -Am I
   adding I
   created new head
 
   $ hg tglog
   @  8: 'I'
   |
   | o    7: 'H'
   | |\
   | | o  6: 'G'
   | | |
   | | o  5: 'F'
   | | |
   | | o  4: 'E'
   | | |
   | o |  3: 'D'
   | |\|
   | o |  2: 'C'
   |/ /
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Rebase and collapse - E onto I:
 
   $ hg clone -q -u . c c1
   $ cd c1
 
   $ hg rebase -s 4 --collapse
   merging E
   saved backup bundle to $TESTTMP/c1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @    5: 'Collapsed revision
   |\   * E
   | |  * F
   | |  * G
   | |  * H'
   | o  4: 'I'
   | |
   o |    3: 'D'
   |\ \
   | o |  2: 'C'
   | |/
   o /  1: 'B'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   B
   C
   D
   E
   G
   I
 
   $ cat E
   F
 
   $ cd ..
 
 
 Create repo d:
 
   $ hg init d
   $ cd d
 
   $ echo A > A
   $ hg ci -Am A
   adding A
   $ echo B > B
   $ hg ci -Am B
   adding B
   $ echo C > C
   $ hg ci -Am C
   adding C
 
   $ hg up -q 1
 
   $ echo D > D
   $ hg ci -Am D
   adding D
   created new head
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg ci -m E
 
   $ hg up -q 0
 
   $ echo F > F
   $ hg ci -Am F
   adding F
   created new head
 
   $ hg tglog
   @  5: 'F'
   |
   | o    4: 'E'
   | |\
   | | o  3: 'D'
   | | |
   | o |  2: 'C'
   | |/
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Rebase and collapse - B onto F:
 
   $ hg clone -q -u . d d1
   $ cd d1
 
   $ hg rebase -s 1 --collapse
   saved backup bundle to $TESTTMP/d1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  2: 'Collapsed revision
   |  * B
   |  * C
   |  * D
   |  * E'
   o  1: 'F'
   |
   o  0: 'A'
   
   $ hg manifest
   A
   B
   C
   D
   F
 
 Interactions between collapse and keepbranches
   $ cd ..
   $ hg init e
   $ cd e
   $ echo 'a' > a
   $ hg ci -Am 'A'
   adding a
 
   $ hg branch '1'
   marked working directory as branch 1
   (branches are permanent and global, did you want a bookmark?)
   $ echo 'b' > b
   $ hg ci -Am 'B'
   adding b
 
   $ hg branch '2'
   marked working directory as branch 2
   (branches are permanent and global, did you want a bookmark?)
   $ echo 'c' > c
   $ hg ci -Am 'C'
   adding c
 
   $ hg up -q 0
   $ echo 'd' > d
   $ hg ci -Am 'D'
   adding d
 
   $ hg tglog
   @  3: 'D'
   |
   | o  2: 'C' 2
   | |
   | o  1: 'B' 1
   |/
   o  0: 'A'
   
   $ hg rebase --keepbranches --collapse -s 1 -d 3
   abort: cannot collapse multiple named branches
   [255]
 

tests/test-rebase-conflicts.t

@@ -1,115 +1,118 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
   $ hg init a
   $ cd a
   $ echo c1 >common
   $ hg add common
   $ hg ci -m C1
 
   $ echo c2 >>common
   $ hg ci -m C2
 
   $ echo c3 >>common
   $ hg ci -m C3
 
   $ hg up -q -C 1
 
   $ echo l1 >>extra
   $ hg add extra
   $ hg ci -m L1
   created new head
 
   $ sed -e 's/c2/l2/' common > common.new
   $ mv common.new common
   $ hg ci -m L2
 
   $ echo l3 >> extra2
   $ hg add extra2
   $ hg ci -m L3
 
   $ hg tglog
   @  5: 'L3'
   |
   o  4: 'L2'
   |
   o  3: 'L1'
   |
   | o  2: 'C3'
   |/
   o  1: 'C2'
   |
   o  0: 'C1'
   
 Try to call --continue:
 
   $ hg rebase --continue
   abort: no rebase in progress
   [255]
 
 Conflicting rebase:
 
   $ hg rebase -s 3 -d 2
   merging common
   warning: conflicts during merge.
   merging common incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
 Try to continue without solving the conflict:
 
   $ hg rebase --continue 
   abort: unresolved merge conflicts (see hg help resolve)
   [255]
 
 Conclude rebase:
 
   $ echo 'resolved merge' >common
   $ hg resolve -m common
   $ hg rebase --continue
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  5: 'L3'
   |
   o  4: 'L2'
   |
   o  3: 'L1'
   |
   o  2: 'C3'
   |
   o  1: 'C2'
   |
   o  0: 'C1'
   
 Check correctness:
 
   $ hg cat -r 0 common
   c1
 
   $ hg cat -r 1 common
   c1
   c2
 
   $ hg cat -r 2 common
   c1
   c2
   c3
 
   $ hg cat -r 3 common
   c1
   c2
   c3
 
   $ hg cat -r 4 common
   resolved merge
 
   $ hg cat -r 5 common
   resolved merge
 

tests/test-rebase-detach.t

@@ -1,395 +1,398 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
   $ hg unbundle $TESTDIR/bundles/rebase.hg
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ..
 
 
 Rebasing D onto H detaching from C:
 
   $ hg clone -q -u . a a1
   $ cd a1
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase --detach -s 3 -d 7
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  7: 'D'
   |
   o  6: 'H'
   |
   | o  5: 'G'
   |/|
   o |  4: 'F'
   | |
   | o  3: 'E'
   |/
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   D
   F
   H
 
   $ cd ..
 
 
 Rebasing C onto H detaching from B:
 
   $ hg clone -q -u . a a2
   $ cd a2
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase --detach -s 2 -d 7
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  7: 'D'
   |
   o  6: 'C'
   |
   o  5: 'H'
   |
   | o  4: 'G'
   |/|
   o |  3: 'F'
   | |
   | o  2: 'E'
   |/
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   C
   D
   F
   H
 
   $ cd ..
 
 
 Rebasing B onto H using detach (same as not using it):
 
   $ hg clone -q -u . a a3
   $ cd a3
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase --detach -s 1 -d 7
   saved backup bundle to $TESTTMP/a3/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  7: 'D'
   |
   o  6: 'C'
   |
   o  5: 'B'
   |
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   B
   C
   D
   F
   H
 
   $ cd ..
 
 
 Rebasing C onto H detaching from B and collapsing:
 
   $ hg clone -q -u . a a4
   $ cd a4
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase --detach --collapse -s 2 -d 7
   saved backup bundle to $TESTTMP/a4/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  6: 'Collapsed revision
   |  * C
   |  * D'
   o  5: 'H'
   |
   | o  4: 'G'
   |/|
   o |  3: 'F'
   | |
   | o  2: 'E'
   |/
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   C
   D
   F
   H
 
   $ cd ..
 
 Rebasing across null as ancestor
   $ hg clone -q -U a a5
 
   $ cd a5
 
   $ echo x > x
 
   $ hg add x
 
   $ hg ci -m "extra branch"
   created new head
 
   $ hg tglog
   @  8: 'extra branch'
   
   o  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase --detach -s 1 -d tip
   saved backup bundle to $TESTTMP/a5/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   o  5: 'extra branch'
   
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
 
   $ hg rebase -d 5 -s 7
   saved backup bundle to $TESTTMP/a5/.hg/strip-backup/13547172c9c0-backup.hg (glob)
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   | o  6: 'B'
   |/
   o  5: 'extra branch'
   
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ cd ..
 
 Verify that target is not selected as external rev (issue3085)
 
   $ hg clone -q -U a a6
   $ cd a6
   $ hg up -q 6
 
   $ echo "I" >> E
   $ hg ci -m "I"
   $ hg merge 7
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m "Merge"
   $ echo "J" >> F
   $ hg ci -m "J"
 
   $ hg rebase -s 8 -d 7 --collapse --detach --config ui.merge=internal:other
   remote changed E which local deleted
   use (c)hanged version or leave (d)eleted? c
   saved backup bundle to $TESTTMP/a6/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'Collapsed revision
   |  * I
   |  * Merge
   |  * J'
   o  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
 
   $ hg parents
   changeset:   8:9472f4b1d736
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Collapsed revision
   
 
   $ cd ..
 
 Ensure --continue restores a correct state (issue3046):
   $ hg clone -q a a7
   $ cd a7
   $ hg up -q 3
   $ echo 'H2' > H
   $ hg ci -A -m 'H2'
   adding H
   $ hg rebase -s 8 -d 7 --detach --config ui.merge=internal:fail
   merging H
   warning: conflicts during merge.
   merging H incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
   $ hg resolve --all -t internal:local
   $ hg rebase -c
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/6215fafa5447-backup.hg (glob)
   $ hg tglog
   @  8: 'H2'
   |
   o  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
 

tests/test-rebase-interruptions.t

@@ -1,194 +1,197 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
 
   $ echo A > A
   $ hg ci -Am A
   adding A
 
   $ echo B > B
   $ hg ci -Am B
   adding B
 
   $ echo C >> A
   $ hg ci -m C
 
   $ hg up -q -C 0
 
   $ echo D >> A
   $ hg ci -m D
   created new head
 
   $ echo E > E
   $ hg ci -Am E
   adding E
 
   $ cd ..
 
 
 Changes during an interruption - continue:
 
   $ hg clone -q -u . a a1
   $ cd a1
 
   $ hg tglog
   @  4: 'E'
   |
   o  3: 'D'
   |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
 Rebasing B onto E:
 
   $ hg rebase -s 1 -d 4
   merging A
   warning: conflicts during merge.
   merging A incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
 Force a commit on C during the interruption:
 
   $ hg up -q -C 2
 
   $ echo 'Extra' > Extra
   $ hg add Extra
   $ hg ci -m 'Extra'
 
   $ hg tglog
   @  6: 'Extra'
   |
   | o  5: 'B'
   | |
   | o  4: 'E'
   | |
   | o  3: 'D'
   | |
   o |  2: 'C'
   | |
   o |  1: 'B'
   |/
   o  0: 'A'
   
 Resume the rebasing:
 
   $ hg rebase --continue
   merging A
   warning: conflicts during merge.
   merging A incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
 Solve the conflict and go on:
 
   $ echo 'conflict solved' > A
   $ rm A.orig
   $ hg resolve -m A
 
   $ hg rebase --continue
   warning: new changesets detected on source branch, not stripping
 
   $ hg tglog
   @  7: 'C'
   |
   | o  6: 'Extra'
   | |
   o |  5: 'B'
   | |
   o |  4: 'E'
   | |
   o |  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Changes during an interruption - abort:
 
   $ hg clone -q -u . a a2
   $ cd a2
 
   $ hg tglog
   @  4: 'E'
   |
   o  3: 'D'
   |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
 Rebasing B onto E:
 
   $ hg rebase -s 1 -d 4
   merging A
   warning: conflicts during merge.
   merging A incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
 Force a commit on B' during the interruption:
 
   $ hg up -q -C 5
 
   $ echo 'Extra' > Extra
   $ hg add Extra
   $ hg ci -m 'Extra'
 
   $ hg tglog
   @  6: 'Extra'
   |
   o  5: 'B'
   |
   o  4: 'E'
   |
   o  3: 'D'
   |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
 Abort the rebasing:
 
   $ hg rebase --abort
   warning: new changesets detected on target branch, can't abort
   [255]
 
   $ hg tglog
   @  6: 'Extra'
   |
   o  5: 'B'
   |
   o  4: 'E'
   |
   o  3: 'D'
   |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 

tests/test-rebase-issue-noparam-single-rev.t

@@ -1,123 +1,126 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
 
   $ echo c1 > c1
   $ hg ci -Am c1
   adding c1
 
   $ echo c2 > c2
   $ hg ci -Am c2
   adding c2
 
   $ echo l1 > l1
   $ hg ci -Am l1
   adding l1
 
   $ hg up -q -C 1
 
   $ echo r1 > r1
   $ hg ci -Am r1
   adding r1
   created new head
 
   $ echo r2 > r2
   $ hg ci -Am r2
   adding r2
 
   $ hg tglog
   @  4: 'r2'
   |
   o  3: 'r1'
   |
   | o  2: 'l1'
   |/
   o  1: 'c2'
   |
   o  0: 'c1'
   
 Rebase with no arguments - single revision in source branch:
 
   $ hg up -q -C 2
 
   $ hg rebase
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  4: 'l1'
   |
   o  3: 'r2'
   |
   o  2: 'r1'
   |
   o  1: 'c2'
   |
   o  0: 'c1'
   
   $ cd ..
 
 
   $ hg init b
   $ cd b
 
   $ echo c1 > c1
   $ hg ci -Am c1
   adding c1
 
   $ echo c2 > c2
   $ hg ci -Am c2
   adding c2
 
   $ echo l1 > l1
   $ hg ci -Am l1
   adding l1
 
   $ echo l2 > l2
   $ hg ci -Am l2
   adding l2
 
   $ hg up -q -C 1
 
   $ echo r1 > r1
   $ hg ci -Am r1
   adding r1
   created new head
 
   $ hg tglog
   @  4: 'r1'
   |
   | o  3: 'l2'
   | |
   | o  2: 'l1'
   |/
   o  1: 'c2'
   |
   o  0: 'c1'
   
 Rebase with no arguments - single revision in target branch:
 
   $ hg up -q -C 3
 
   $ hg rebase
   saved backup bundle to $TESTTMP/b/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  4: 'l2'
   |
   o  3: 'l1'
   |
   o  2: 'r1'
   |
   o  1: 'c2'
   |
   o  0: 'c1'
   

tests/test-rebase-mq-skip.t

@@ -1,136 +1,139 b''
 This emulates the effects of an hg pull --rebase in which the remote repo
 already has one local mq patch
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > mq=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' tags: {tags}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
   $ hg qinit -c
 
   $ echo c1 > c1
   $ hg add c1
   $ hg ci -m C1
 
   $ echo r1 > r1
   $ hg add r1
   $ hg ci -m R1
 
   $ hg up -q 0
 
   $ hg qnew p0.patch
   $ echo p0 > p0
   $ hg add p0
   $ hg qref -m P0
 
   $ hg qnew p1.patch
   $ echo p1 > p1
   $ hg add p1
   $ hg qref -m P1
 
   $ hg export qtip > p1.patch 
 
   $ hg up -q -C 1
 
   $ hg import p1.patch
   applying p1.patch
 
   $ rm p1.patch
 
   $ hg up -q -C qtip
 
   $ hg rebase
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  3: 'P0' tags: p0.patch qbase qtip tip
   |
   o  2: 'P1' tags: qparent
   |
   o  1: 'R1' tags:
   |
   o  0: 'C1' tags:
   
   $ cd ..
 
 
   $ hg init b
   $ cd b
   $ hg qinit -c
 
   $ for i in r0 r1 r2 r3 r4 r5 r6;
   > do
   >     echo $i > $i
   >     hg ci -Am $i
   > done
   adding r0
   adding r1
   adding r2
   adding r3
   adding r4
   adding r5
   adding r6
 
   $ hg qimport -r 1:tip
 
   $ hg up -q 0
 
   $ for i in r1 r3 r7 r8;
   > do
   >     echo $i > $i
   >     hg ci -Am branch2-$i
   > done
   adding r1
   created new head
   adding r3
   adding r7
   adding r8
 
   $ echo somethingelse > r4
   $ hg ci -Am branch2-r4
   adding r4
 
   $ echo r6 > r6
   $ hg ci -Am branch2-r6
   adding r6
 
   $ hg up -q qtip
 
   $ HGMERGE=internal:fail hg rebase
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
   $ HGMERGE=internal:local hg resolve --all
 
   $ hg rebase --continue
   saved backup bundle to $TESTTMP/b/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  9: 'r5' tags: 5.diff qtip tip
   |
   o  8: 'r4' tags: 4.diff
   |
   o  7: 'r2' tags: 2.diff qbase
   |
   o  6: 'branch2-r6' tags: qparent
   |
   o  5: 'branch2-r4' tags:
   |
   o  4: 'branch2-r8' tags:
   |
   o  3: 'branch2-r7' tags:
   |
   o  2: 'branch2-r3' tags:
   |
   o  1: 'branch2-r1' tags:
   |
   o  0: 'r0' tags:
   

tests/test-rebase-named-branches.t

@@ -1,108 +1,111 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
   $ hg init a
   $ cd a
   $ hg unbundle $TESTDIR/bundles/rebase.hg
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
 
 
 Rebasing descendant onto ancestor across different named branches
 
   $ hg clone -q -u . a a1
 
   $ cd a1
 
   $ hg branch dev
   marked working directory as branch dev
   (branches are permanent and global, did you want a bookmark?)
 
   $ echo x > x
 
   $ hg add x
 
   $ hg ci -m 'extra named branch'
 
   $ hg tglog
   @  8: 'extra named branch' dev
   |
   o  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
 
 
   $ hg rebase -s 1 -d 8 --keepbranches
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   o  5: 'extra named branch' dev
   |
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ hg rebase -s 4 -d 5
   abort: source is ancestor of destination
   [255]
 
   $ hg rebase -s 5 -d 4
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   o  5: 'extra named branch'
   |
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ cd ..

tests/test-rebase-parameters.t

@@ -1,389 +1,392 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
   $ hg unbundle $TESTDIR/bundles/rebase.hg
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ echo I > I
   $ hg ci -AmI
   adding I
 
   $ hg tglog
   @  8: 'I'
   |
   o  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 These fail:
 
   $ hg clone -q -u . a a1
   $ cd a1
 
   $ hg rebase -s 8 -d 7
   nothing to rebase
   [1]
 
   $ hg rebase --continue --abort
   abort: cannot use both abort and continue
   [255]
 
   $ hg rebase --continue --collapse
   abort: cannot use collapse with continue or abort
   [255]
 
   $ hg rebase --continue --dest 4
   abort: abort and continue do not allow specifying revisions
   [255]
 
   $ hg rebase --base 5 --source 4
   abort: cannot specify both a source and a base
   [255]
 
   $ hg rebase
   nothing to rebase
   [1]
 
   $ hg up -q 7
 
   $ hg rebase --traceback
   nothing to rebase
   [1]
 
 
 These work:
 
 Rebase with no arguments (from 3 onto 8):
 
   $ hg up -q -C 3
 
   $ hg rebase
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   o  5: 'I'
   |
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
 Try to rollback after a rebase (fail):
 
   $ hg rollback
   no rollback information available
   [1]
 
   $ cd ..
 
 
 Rebase with base == '.' => same as no arguments (from 3 onto 8):
 
   $ hg clone -q -u 3 a a2
   $ cd a2
 
   $ hg rebase --base .
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   o  5: 'I'
   |
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Rebase with dest == `hg branch` => same as no arguments (from 3 onto 8):
 
   $ hg clone -q -u 3 a a3
   $ cd a3
 
   $ hg rebase --dest `hg branch`
   saved backup bundle to $TESTTMP/a3/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   o  5: 'I'
   |
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Specify only source (from 2 onto 8):
 
   $ hg clone -q -u . a a4
   $ cd a4
 
   $ hg rebase --source 2
   saved backup bundle to $TESTTMP/a4/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o    7: 'C'
   |\
   | o  6: 'I'
   | |
   | o  5: 'H'
   | |
   | | o  4: 'G'
   | |/|
   | o |  3: 'F'
   | | |
   | | o  2: 'E'
   | |/
   o |  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Specify only dest (from 3 onto 6):
 
   $ hg clone -q -u 3 a a5
   $ cd a5
 
   $ hg rebase --dest 6
   saved backup bundle to $TESTTMP/a5/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   | o  5: 'I'
   | |
   | o  4: 'H'
   | |
   o |  3: 'G'
   |\|
   | o  2: 'F'
   | |
   o |  1: 'E'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Specify only base (from 1 onto 8):
 
   $ hg clone -q -u . a a6
   $ cd a6
 
   $ hg rebase --base 3
   saved backup bundle to $TESTTMP/a6/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   o  5: 'I'
   |
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Specify source and dest (from 2 onto 7):
 
   $ hg clone -q -u . a a7
   $ cd a7
 
   $ hg rebase --detach --source 2 --dest 7
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   | o  6: 'I'
   |/
   o  5: 'H'
   |
   | o  4: 'G'
   |/|
   o |  3: 'F'
   | |
   | o  2: 'E'
   |/
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Specify base and dest (from 1 onto 7):
 
   $ hg clone -q -u . a a8
   $ cd a8
 
   $ hg rebase --base 3 --dest 7
   saved backup bundle to $TESTTMP/a8/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   | o  5: 'I'
   |/
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ cd ..
 
 Test --tool parameter:
 
   $ hg init b
   $ cd b
 
   $ echo c1 > c1
   $ hg ci -Am c1
   adding c1
 
   $ echo c2 > c2
   $ hg ci -Am c2
   adding c2
 
   $ hg up -q 0
   $ echo c2b > c2
   $ hg ci -Am c2b
   adding c2
   created new head
 
   $ cd ..
 
   $ hg clone -q -u . b b1
   $ cd b1
 
   $ hg rebase -s 2 -d 1 --tool internal:local
   saved backup bundle to $TESTTMP/b1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg cat c2
   c2
 
   $ cd ..
 
 
   $ hg clone -q -u . b b2
   $ cd b2
 
   $ hg rebase -s 2 -d 1 --tool internal:other
   saved backup bundle to $TESTTMP/b2/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg cat c2
   c2b
 
   $ cd ..
 
 
   $ hg clone -q -u . b b3
   $ cd b3
 
   $ hg rebase -s 2 -d 1 --tool internal:fail
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
   $ hg resolve -l
   U c2
 
   $ hg resolve -m c2
   $ hg rebase -c --tool internal:fail
   tool option will be ignored
   saved backup bundle to $TESTTMP/b3/.hg/strip-backup/*-backup.hg (glob)
 

tests/test-rebase-scenario-global.t

@@ -1,508 +1,521 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
+  > [phases]
+  > publish=False
+  > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
   $ hg unbundle $TESTDIR/bundles/rebase.hg
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
 
 
 Rebasing
 D onto H - simple rebase:
 
   $ hg clone -q -u . a a1
   $ cd a1
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
 
   $ hg rebase -s 3 -d 7
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @    7: 'D'
   |\
   | o  6: 'H'
   | |
   | | o  5: 'G'
   | |/|
   | o |  4: 'F'
   | | |
   | | o  3: 'E'
   | |/
   o |  2: 'C'
   | |
   o |  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 D onto F - intermediate point:
 
   $ hg clone -q -u . a a2
   $ cd a2
 
   $ hg rebase -s 3 -d 5
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @    7: 'D'
   |\
   | | o  6: 'H'
   | |/
   | | o  5: 'G'
   | |/|
   | o |  4: 'F'
   | | |
   | | o  3: 'E'
   | |/
   o |  2: 'C'
   | |
   o |  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 E onto H - skip of G:
 
   $ hg clone -q -u . a a3
   $ cd a3
 
   $ hg rebase -s 4 -d 7
   saved backup bundle to $TESTTMP/a3/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  6: 'E'
   |
   o  5: 'H'
   |
   o  4: 'F'
   |
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 F onto E - rebase of a branching point (skip G):
 
   $ hg clone -q -u . a a4
   $ cd a4
 
   $ hg rebase -s 5 -d 4
   saved backup bundle to $TESTTMP/a4/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  6: 'H'
   |
   o  5: 'F'
   |
   o  4: 'E'
   |
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 G onto H - merged revision having a parent in ancestors of target:
 
   $ hg clone -q -u . a a5
   $ cd a5
 
   $ hg rebase -s 6 -d 7
   saved backup bundle to $TESTTMP/a5/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @    7: 'G'
   |\
   | o  6: 'H'
   | |
   | o  5: 'F'
   | |
   o |  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 F onto B - G maintains E as parent:
 
   $ hg clone -q -u . a a6
   $ cd a6
 
   $ hg rebase -s 5 -d 1
   saved backup bundle to $TESTTMP/a6/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   | |
   | | o  3: 'D'
   | | |
   +---o  2: 'C'
   | |
   o |  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 These will fail (using --source):
 
 G onto F - rebase onto an ancestor:
 
   $ hg clone -q -u . a a7
   $ cd a7
 
   $ hg rebase -s 6 -d 5
   nothing to rebase
   [1]
 
 F onto G - rebase onto a descendant:
 
   $ hg rebase -s 5 -d 6
   abort: source is ancestor of destination
   [255]
 
 G onto B - merge revision with both parents not in ancestors of target:
 
   $ hg rebase -s 6 -d 1
   abort: cannot use revision 6 as base, result would have 3 parents
   [255]
 
 
 These will abort gracefully (using --base):
 
 G onto G - rebase onto same changeset:
 
   $ hg rebase -b 6 -d 6
   nothing to rebase
   [1]
 
 G onto F - rebase onto an ancestor:
 
   $ hg rebase -b 6 -d 5
   nothing to rebase
   [1]
 
 F onto G - rebase onto a descendant:
 
   $ hg rebase -b 5 -d 6
   nothing to rebase
   [1]
 
 C onto A - rebase onto an ancestor:
 
   $ hg rebase -d 0 -s 2
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/5fddd98957c8-backup.hg (glob)
   $ hg tglog
   @  7: 'D'
   |
   o  6: 'C'
   |
   | o  5: 'H'
   | |
   | | o  4: 'G'
   | |/|
   | o |  3: 'F'
   |/ /
   | o  2: 'E'
   |/
   | o  1: 'B'
   |/
   o  0: 'A'
   
+
+Check rebasing public changeset
+
+  $ hg pull --config phases.publish=True -q -r 6 . # update phase of 6
+  $ hg rebase -d 5 -b 6
+  abort: Can't rebase immutable changeset e1c4361dd923
+  (see hg help phases for details)
+  [255]
+
+  $ hg rebase -d 5 -b 6 --keep
   $ cd ..
 
 Test for revset
 
 We need a bit different graph
 All destination are B
 
   $ hg init ah
   $ cd ah
   $ hg unbundle $TESTDIR/bundles/rebase-revset.hg
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 9 changes to 9 files (+2 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg tglog
   o  8: 'I'
   |
   o  7: 'H'
   |
   o  6: 'G'
   |
   | o  5: 'F'
   | |
   | o  4: 'E'
   |/
   o  3: 'D'
   |
   o  2: 'C'
   |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 Simple case with keep:
 
 Source on have two descendant heads but ask for one
 
   $ hg clone -q -u . ah ah1
   $ cd ah1
   $ hg rebase -r '2::8' -d 1
   abort: can't remove original changesets with unrebased descendants
   (use --keep to keep original changesets)
   [255]
   $ hg rebase -r '2::8' -d 1 --keep
   $ hg tglog
   @  13: 'I'
   |
   o  12: 'H'
   |
   o  11: 'G'
   |
   o  10: 'D'
   |
   o  9: 'C'
   |
   | o  8: 'I'
   | |
   | o  7: 'H'
   | |
   | o  6: 'G'
   | |
   | | o  5: 'F'
   | | |
   | | o  4: 'E'
   | |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   o |  1: 'B'
   |/
   o  0: 'A'
   
 
   $ cd ..
 
 Base on have one descendant heads we ask for but common ancestor have two
 
   $ hg clone -q -u . ah ah2
   $ cd ah2
   $ hg rebase -r '3::8' -d 1
   abort: can't remove original changesets with unrebased descendants
   (use --keep to keep original changesets)
   [255]
   $ hg rebase -r '3::8' -d 1 --keep
   $ hg tglog
   @  12: 'I'
   |
   o  11: 'H'
   |
   o  10: 'G'
   |
   o    9: 'D'
   |\
   | | o  8: 'I'
   | | |
   | | o  7: 'H'
   | | |
   | | o  6: 'G'
   | | |
   | | | o  5: 'F'
   | | | |
   | | | o  4: 'E'
   | | |/
   | | o  3: 'D'
   | |/
   | o  2: 'C'
   | |
   o |  1: 'B'
   |/
   o  0: 'A'
   
 
   $ cd ..
 
 rebase subset
 
   $ hg clone -q -u . ah ah3
   $ cd ah3
   $ hg rebase -r '3::7' -d 1
   abort: can't remove original changesets with unrebased descendants
   (use --keep to keep original changesets)
   [255]
   $ hg rebase -r '3::7' -d 1 --keep
   $ hg tglog
   @  11: 'H'
   |
   o  10: 'G'
   |
   o    9: 'D'
   |\
   | | o  8: 'I'
   | | |
   | | o  7: 'H'
   | | |
   | | o  6: 'G'
   | | |
   | | | o  5: 'F'
   | | | |
   | | | o  4: 'E'
   | | |/
   | | o  3: 'D'
   | |/
   | o  2: 'C'
   | |
   o |  1: 'B'
   |/
   o  0: 'A'
   
 
   $ cd ..
 
 rebase subset with multiple head
 
   $ hg clone -q -u . ah ah4
   $ cd ah4
   $ hg rebase -r '3::(7+5)' -d 1
   abort: can't remove original changesets with unrebased descendants
   (use --keep to keep original changesets)
   [255]
   $ hg rebase -r '3::(7+5)' -d 1 --keep
   $ hg tglog
   @  13: 'H'
   |
   o  12: 'G'
   |
   | o  11: 'F'
   | |
   | o  10: 'E'
   |/
   o    9: 'D'
   |\
   | | o  8: 'I'
   | | |
   | | o  7: 'H'
   | | |
   | | o  6: 'G'
   | | |
   | | | o  5: 'F'
   | | | |
   | | | o  4: 'E'
   | | |/
   | | o  3: 'D'
   | |/
   | o  2: 'C'
   | |
   o |  1: 'B'
   |/
   o  0: 'A'
   
 
   $ cd ..
 
 More advanced tests
 
 rebase on ancestor with revset
 
   $ hg clone -q -u . ah ah5
   $ cd ah5
   $ hg rebase -r '6::' -d 2
   saved backup bundle to $TESTTMP/ah5/.hg/strip-backup/3d8a618087a7-backup.hg (glob)
   $ hg tglog
   @  8: 'I'
   |
   o  7: 'H'
   |
   o  6: 'G'
   |
   | o  5: 'F'
   | |
   | o  4: 'E'
   | |
   | o  3: 'D'
   |/
   o  2: 'C'
   |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ cd ..
 
 
 rebase with multiple root.
 We rebase E and G on B
 We would expect heads are I, F if it was supported
 
   $ hg clone -q -u . ah ah6
   $ cd ah6
   $ hg rebase -r '(4+6)::' -d 1
   abort: can't rebase multiple roots
   [255]
   $ cd ..