def makepatch(ui, repo, name=None, pats=[], opts={}):
"""sets up the call for attic.createpatch and makes the call"""
s = repo.attic
force = opts.get('force')
if name and s.exists(name) and name != s.applied and not force:
raise util.Abort(_('attempting to overwrite existing patch'))
if name and s.applied and name != s.applied and not force:
raise util.Abort(_('a different patch is active'))
if not name:
name = s.applied
if not name:
raise util.Abort(_('you need to supply a patch name'))
date, user, message = None, None, ''
if s.applied:
data = patch.extract(ui, open(s.join(s.applied), 'r'))
tmpname, message, user, date, branch, nodeid, p1, p2 = data
os.unlink(tmpname)
msg = cmdutil.logmessage(opts)
if not msg:
msg = message
if opts.get('edit'):
msg = ui.edit(msg, ui.username())
setupheaderopts(ui, opts)
if opts.get('user'):
user=opts['user']
if not user:
user = ui.username()
if opts.get('date'):
date=opts['date']
if not date:
date = util.makedate()
date = util.parsedate(date)
s.createpatch(repo, name, msg, user, date, pats, opts)
def makepatch(ui, repo, name=None, pats=[], opts={}):
"""sets up the call for attic.createpatch and makes the call"""
s = repo.attic
force = opts.get('force')
if name and s.exists(name) and name != s.applied and not force:
raise util.Abort(_('attempting to overwrite existing patch'))
if name and s.applied and name != s.applied and not force:
raise util.Abort(_('a different patch is active'))
if not name:
name = s.applied
if not name:
raise util.Abort(_('you need to supply a patch name'))
date, user, message = None, None, ''
if s.applied:
data = patch.extract(ui, open(s.join(s.applied), 'r'))
tmpname, message, user, date, branch, nodeid, p1, p2 = data
os.unlink(tmpname)
msg = cmdutil.logmessage(opts)
if not msg:
msg = message
if opts.get('edit'):
msg = ui.edit(msg, ui.username())
setupheaderopts(ui, opts)
if opts.get('user'):
user = opts['user']
if not user:
user = ui.username()
if opts.get('date'):
date = opts['date']
if not date:
date = util.makedate()
date = util.parsedate(date)
s.createpatch(repo, name, msg, user, date, pats, opts)
def commitextra(ui, repo, *pats, **opts):
'''make a commit with extra fields'''
fields = opts.get('field')
extras = {}
for field in fields:
k, v = field.split('=', 1)
extras[k] = v
message = cmdutil.logmessage(ui, opts)
repo.commit(message, opts.get('user'), opts.get('date'),
match=scmutil.match(repo[None], pats, opts), extra=extras)
return 0
def close_branch(ui, repo, *revs, **opts):
"""close the given head revisions
This is equivalent to checking out each revision in a clean tree and running
``hg commit --close-branch``, except that it doesn't change the working
directory.
The commit message must be specified with -l or -m.
"""
def docommit(rev):
cctx = context.memctx(
repo,
parents=[rev, None],
text=message,
files=[],
filectxfn=None,
user=opts.get(b'user'),
date=opts.get(b'date'),
extra=extra,
)
tr = repo.transaction(b'commit')
ret = repo.commitctx(cctx, True)
bookmarks.update(repo, [rev, None], ret)
cctx.markcommitted(ret)
tr.close()
opts = pycompat.byteskwargs(opts)
revs += tuple(opts.get(b'rev', []))
revs = scmutil.revrange(repo, revs)
if not revs:
raise error.Abort(_(b'no revisions specified'))
heads = []
for branch in repo.branchmap():
heads.extend(repo.branchheads(branch))
heads = {repo[h].rev() for h in heads}
for rev in revs:
if rev not in heads:
raise error.Abort(_(b'revision is not an open head: %d') % rev)
message = cmdutil.logmessage(ui, opts)
if not message:
raise error.Abort(_(b"no commit message specified with -l or -m"))
extra = {b'close': b'1'}
with repo.wlock(), repo.lock():
for rev in revs:
r = repo[rev]
branch = r.branch()
extra[b'branch'] = branch
docommit(r)
return 0
def commitmerge(self):
message = (cmdutil.logmessage(self.ui, self.opts) or
('Automated merge with %s' %
urllib2.unquote(util.removeauth(self.remoterepository.url()))))
editor = cmdutil.commiteditor
if self.opts.get('edit'):
editor = cmdutil.commitforceeditor
n = self.repo.commit(message, self.opts['user'], self.opts['date'], editor=editor)
self.ui.status(_('new changeset %d:%s merges remote changes '
'with local\n') % (self.repo.changelog.rev(n),
short(n)))
def commitextra(ui, repo, *pats, **opts):
'''make a commit with extra fields'''
fields = opts.get('field')
extras = {}
for field in fields:
k, v = field.split('=', 1)
extras[k] = v
message = cmdutil.logmessage(ui, opts)
repo.commit(message, opts.get('user'), opts.get('date'),
match=scmutil.match(repo[None], pats, opts), extra=extras)
return 0
def postincoming(other, modheads):
if modheads == 0:
return 0
if modheads == 1:
return hg.clean(repo, repo.changelog.tip())
newheads = repo.heads(parent)
newchildren = [n for n in repo.heads(parent) if n != parent]
newparent = parent
if newchildren:
newparent = newchildren[0]
hg.clean(repo, newparent)
newheads = [n for n in repo.heads() if n != newparent]
if len(newheads) > 1:
ui.status(_('not merging with %d other new heads '
'(use "hg heads" and "hg merge" to merge them)') %
(len(newheads) - 1))
return
err = False
if newheads:
# By default, we consider the repository we're pulling
# *from* as authoritative, so we merge our changes into
# theirs.
if opts['switch_parent']:
firstparent, secondparent = newparent, newheads[0]
else:
firstparent, secondparent = newheads[0], newparent
ui.status(_('updating to %d:%s\n') %
(repo.changelog.rev(firstparent),
short(firstparent)))
hg.clean(repo, firstparent)
ui.status(_('merging with %d:%s\n') %
(repo.changelog.rev(secondparent), short(secondparent)))
err = hg.merge(repo, secondparent, remind=False)
if not err:
mod, add, rem = repo.status()[:3]
message = (cmdutil.logmessage(opts) or
(_('Automated merge with %s') %
util.removeauth(other.url())))
force_editor = opts.get('force_editor') or opts.get('edit')
n = repo.commit(mod + add + rem, message,
opts['user'], opts['date'], force=True,
force_editor=force_editor)
ui.status(_('new changeset %d:%s merges remote changes '
'with local\n') % (repo.changelog.rev(n),
short(n)))
def commits(ui, repo, *pats, **opts):
node1, node2 = cmdutil.revpair(repo, opts.get('rev'))
matcher = cmdutil.match(repo, pats, opts)
cwd = (pats and repo.getcwd()) or ''
modified, added, removed, deleted, unknown, ignored, clean = \
repo.status(node1=node1, node2=node2,
match=matcher,
unknown=True)
changetypes = (('modified', 'M', modified),
('added', 'A', added),
('removed', 'R', removed),
('deleted', '!', deleted),
('unknown', '?', unknown),
)
end = '\n'
status_lines = [end]
status_lines.append("%s %s%s" % (_pfx_root, repo.root, end))
for opt, char, changes in changetypes:
format = "%s %s %%s%s" % (_pfx, char, end)
for f in changes:
status_lines.append(format % repo.pathto(f, cwd))
contents = cmdutil.logmessage(opts)
if not contents:
contents = ui.edit("".join(status_lines), opts['user'])
sets = parse_changesets(contents)
if sets is None:
sys.exit(1)
for i, (message, files) in enumerate(sets):
print 'Committing set %d' % (i+1)
print message
for fn in files:
print fn
print
m = match.match(repo.root, '', files, exact=True)
if not opts['dry_run']:
repo.commit(match=m, text=message, user=opts['user'], date=opts['date'], force=util.always)
def metarewrite(repo, old, newbases, commitopts):
"""Return (nodeid, created) where nodeid is the identifier of the
changeset generated by the rewrite process, and created is True if
nodeid was actually created. If created is False, nodeid
references a changeset existing before the rewrite call.
"""
wlock = lock = tr = None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction('rewrite')
updatebookmarks = bookmarksupdater(repo, old.node(), tr)
message = cmdutil.logmessage(repo.ui, commitopts)
if not message:
message = old.description()
user = commitopts.get('user') or old.user()
date = commitopts.get('date') or None # old.date()
extra = dict(commitopts.get('extra', old.extra()))
extra['branch'] = old.branch()
new = context.metadataonlyctx(repo,
old,
parents=newbases,
text=message,
user=user,
date=date,
extra=extra)
if commitopts.get('edit'):
new._text = cmdutil.commitforceeditor(repo, new, [])
revcount = len(repo)
newid = repo.commitctx(new)
new = repo[newid]
created = len(repo) != revcount
updatebookmarks(newid)
tr.close()
return newid, created
finally:
lockmod.release(tr, lock, wlock)
def fetch(ui, repo, source=b'default', **opts):
"""pull changes from a remote repository, merge new changes if needed.
This finds all changes from the repository at the specified path
or URL and adds them to the local repository.
If the pulled changes add a new branch head, the head is
automatically merged, and the result of the merge is committed.
Otherwise, the working directory is updated to include the new
changes.
When a merge is needed, the working directory is first updated to
the newly pulled changes. Local changes are then merged into the
pulled changes. To switch the merge order, use --switch-parent.
See :hg:`help dates` for a list of formats valid for -d/--date.
Returns 0 on success.
"""
opts = pycompat.byteskwargs(opts)
date = opts.get(b'date')
if date:
opts[b'date'] = dateutil.parsedate(date)
parent = repo.dirstate.p1()
branch = repo.dirstate.branch()
try:
branchnode = repo.branchtip(branch)
except error.RepoLookupError:
branchnode = None
if parent != branchnode:
raise error.Abort(
_(b'working directory not at branch tip'),
hint=_(b"use 'hg update' to check out branch tip"),
)
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
cmdutil.bailifchanged(repo)
bheads = repo.branchheads(branch)
bheads = [head for head in bheads if len(repo[head].children()) == 0]
if len(bheads) > 1:
raise error.Abort(
_(b'multiple heads in this branch '
b'(use "hg heads ." and "hg merge" to merge)'))
other = hg.peer(repo, opts, ui.expandpath(source))
ui.status(
_(b'pulling from %s\n') % util.hidepassword(ui.expandpath(source)))
revs = None
if opts[b'rev']:
try:
revs = [other.lookup(rev) for rev in opts[b'rev']]
except error.CapabilityError:
err = _(b"other repository doesn't support revision lookup, "
b"so a rev cannot be specified.")
raise error.Abort(err)
# Are there any changes at all?
modheads = exchange.pull(repo, other, heads=revs).cgresult
if modheads == 0:
return 0
# Is this a simple fast-forward along the current branch?
newheads = repo.branchheads(branch)
newchildren = repo.changelog.nodesbetween([parent], newheads)[2]
if len(newheads) == 1 and len(newchildren):
if newchildren[0] != parent:
return hg.update(repo, newchildren[0])
else:
return 0
# Are there more than one additional branch heads?
newchildren = [n for n in newchildren if n != parent]
newparent = parent
if newchildren:
newparent = newchildren[0]
hg.clean(repo, newparent)
newheads = [n for n in newheads if n != newparent]
if len(newheads) > 1:
ui.status(
_(b'not merging with %d other new branch heads '
b'(use "hg heads ." and "hg merge" to merge them)\n') %
(len(newheads) - 1))
return 1
if not newheads:
return 0
# Otherwise, let's merge.
err = False
if newheads:
# By default, we consider the repository we're pulling
# *from* as authoritative, so we merge our changes into
# theirs.
if opts[b'switch_parent']:
firstparent, secondparent = newparent, newheads[0]
else:
firstparent, secondparent = newheads[0], newparent
ui.status(
_(b'updating to %d:%s\n') %
(repo.changelog.rev(firstparent), short(firstparent)))
hg.clean(repo, firstparent)
p2ctx = repo[secondparent]
ui.status(
_(b'merging with %d:%s\n') %
(p2ctx.rev(), short(secondparent)))
err = hg.merge(p2ctx, remind=False)
if not err:
# we don't translate commit messages
message = cmdutil.logmessage(
ui, opts) or (b'Automated merge with %s' %
util.removeauth(other.url()))
editopt = opts.get(b'edit') or opts.get(b'force_editor')
editor = cmdutil.getcommiteditor(edit=editopt, editform=b'fetch')
n = repo.commit(message,
opts[b'user'],
opts[b'date'],
editor=editor)
ui.status(
_(b'new changeset %d:%s merges remote changes with local\n') %
(repo.changelog.rev(n), short(n)))
return err
finally:
release(lock, wlock)
def fetch(ui, repo, source='default', **opts):
'''pull changes from a remote repository, merge new changes if needed.
This finds all changes from the repository at the specified path
or URL and adds them to the local repository.
If the pulled changes add a new branch head, the head is
automatically merged, and the result of the merge is committed.
Otherwise, the working directory is updated to include the new
changes.
When a merge occurs, the newly pulled changes are assumed to be
"authoritative". The head of the new changes is used as the first
parent, with local changes as the second. To switch the merge
order, use --switch-parent.
See 'hg help dates' for a list of formats valid for -d/--date.
'''
date = opts.get('date')
if date:
opts['date'] = util.parsedate(date)
parent, p2 = repo.dirstate.parents()
branch = repo.dirstate.branch()
branchnode = repo.branchtags().get(branch)
if parent != branchnode:
raise util.Abort(_('working dir not at branch tip '
'(use "hg update" to check out branch tip)'))
if p2 != nullid:
raise util.Abort(_('outstanding uncommitted merge'))
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
mod, add, rem, del_ = repo.status()[:4]
if mod or add or rem:
raise util.Abort(_('outstanding uncommitted changes'))
if del_:
raise util.Abort(_('working directory is missing some files'))
bheads = repo.branchheads(branch)
bheads = [head for head in bheads if len(repo[head].children()) == 0]
if len(bheads) > 1:
raise util.Abort(_('multiple heads in this branch '
'(use "hg heads ." and "hg merge" to merge)'))
other = hg.repository(cmdutil.remoteui(repo, opts),
ui.expandpath(source))
ui.status(_('pulling from %s\n') %
url.hidepassword(ui.expandpath(source)))
revs = None
if opts['rev']:
try:
revs = [other.lookup(rev) for rev in opts['rev']]
except error.CapabilityError:
err = _("Other repository doesn't support revision lookup, "
"so a rev cannot be specified.")
raise util.Abort(err)
# Are there any changes at all?
modheads = repo.pull(other, heads=revs)
if modheads == 0:
return 0
# Is this a simple fast-forward along the current branch?
newheads = repo.branchheads(branch)
newheads = [head for head in newheads if len(repo[head].children()) == 0]
newchildren = repo.changelog.nodesbetween([parent], newheads)[2]
if len(newheads) == 1:
if newchildren[0] != parent:
return hg.clean(repo, newchildren[0])
else:
return
# Are there more than one additional branch heads?
newchildren = [n for n in newchildren if n != parent]
newparent = parent
if newchildren:
newparent = newchildren[0]
hg.clean(repo, newparent)
newheads = [n for n in newheads if n != newparent]
if len(newheads) > 1:
ui.status(_('not merging with %d other new branch heads '
'(use "hg heads ." and "hg merge" to merge them)\n') %
(len(newheads) - 1))
return
# Otherwise, let's merge.
err = False
if newheads:
# By default, we consider the repository we're pulling
# *from* as authoritative, so we merge our changes into
# theirs.
if opts['switch_parent']:
firstparent, secondparent = newparent, newheads[0]
else:
firstparent, secondparent = newheads[0], newparent
ui.status(_('updating to %d:%s\n') %
(repo.changelog.rev(firstparent),
short(firstparent)))
hg.clean(repo, firstparent)
ui.status(_('merging with %d:%s\n') %
(repo.changelog.rev(secondparent), short(secondparent)))
err = hg.merge(repo, secondparent, remind=False)
if not err:
# we don't translate commit messages
message = (cmdutil.logmessage(opts) or
('Automated merge with %s' %
url.removeauth(other.url())))
editor = cmdutil.commiteditor
if opts.get('force_editor') or opts.get('edit'):
editor = cmdutil.commitforceeditor
n = repo.commit(message, opts['user'], opts['date'], editor=editor)
ui.status(_('new changeset %d:%s merges remote changes '
'with local\n') % (repo.changelog.rev(n),
short(n)))
finally:
release(lock, wlock)
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.
In its default configuration, Mercurial will prevent you from
rebasing published changes. See :hg:`help phases` for details.
If you don't specify a destination changeset (``-d/--dest``),
rebase uses the current branch tip 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.
For advanced usage, a third way is available through the ``--rev``
option. It allows you to specify an arbitrary set of changesets to
rebase. Descendants of revs you specify with this option are not
automatically included in the rebase.
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 branch tip 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.
.. container:: verbose
Examples:
- move "local changes" (current commit back to branching point)
to the current branch tip after a pull::
hg rebase
- move a single changeset to the stable branch::
hg rebase -r 5f493448 -d stable
- splice a commit and all its descendants onto another part of history::
hg rebase --source c0c3 --dest 4cf9
- rebase everything on a branch marked by a bookmark onto the
default branch::
hg rebase --base myfeature --dest default
- collapse a sequence of changes into a single commit::
hg rebase --collapse -r 1520:1525 -d .
- move a named branch while preserving its name::
hg rebase -r "branch(featureX)" -d 1.3 --keepbranches
Returns 0 on success, 1 if nothing to rebase or there are
unresolved conflicts.
"""
originalwd = target = None
activebookmark = None
external = nullrev
# Mapping between the old revision id and either what is the new rebased
# revision or what needs to be done with the old revision. The state dict
# will be what contains most of the rebase progress state.
state = {}
skipped = set()
targetancestors = set()
lock = wlock = None
try:
wlock = repo.wlock()
lock = repo.lock()
# 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)
e = opts.get('extrafn') # internal, used by e.g. hgsubversion
extrafns = [_savegraft]
if e:
extrafns = [e]
keepf = opts.get('keep', False)
keepbranchesf = opts.get('keepbranches', False)
# keepopen is not meant for use on the command line, but by
# other extensions
keepopen = opts.get('keepopen', False)
if opts.get('interactive'):
try:
if extensions.find('histedit'):
enablehistedit = ''
except KeyError:
enablehistedit = " --config extensions.histedit="
help = "hg%s help -e histedit" % enablehistedit
msg = _("interactive history editing is supported by the "
"'histedit' extension (see \"%s\")") % help
raise error.Abort(msg)
if collapsemsg and not collapsef:
raise error.Abort(
_('message can only be specified with collapse'))
if contf or abortf:
if contf and abortf:
raise error.Abort(_('cannot use both abort and continue'))
if collapsef:
raise error.Abort(
_('cannot use collapse with continue or abort'))
if srcf or basef or destf:
raise error.Abort(
_('abort and continue do not allow specifying revisions'))
if abortf and opts.get('tool', False):
ui.warn(_('tool option will be ignored\n'))
try:
(originalwd, target, state, skipped, collapsef, keepf,
keepbranchesf, external, activebookmark) = restorestatus(repo)
except error.RepoLookupError:
if abortf:
clearstatus(repo)
repo.ui.warn(_('rebase aborted (no revision is removed,'
' only broken state is cleared)\n'))
return 0
else:
msg = _('cannot continue inconsistent rebase')
hint = _('use "hg rebase --abort" to clear broken state')
raise error.Abort(msg, hint=hint)
if abortf:
return abort(repo, originalwd, target, state,
activebookmark=activebookmark)
else:
if srcf and basef:
raise error.Abort(_('cannot specify both a '
'source and a base'))
if revf and basef:
raise error.Abort(_('cannot specify both a '
'revision and a base'))
if revf and srcf:
raise error.Abort(_('cannot specify both a '
'revision and a source'))
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
if destf:
dest = scmutil.revsingle(repo, destf)
else:
dest = repo[_destrebase(repo)]
destf = str(dest)
if revf:
rebaseset = scmutil.revrange(repo, revf)
if not rebaseset:
ui.status(_('empty "rev" revision set - '
'nothing to rebase\n'))
return _nothingtorebase()
elif srcf:
src = scmutil.revrange(repo, [srcf])
if not src:
ui.status(_('empty "source" revision set - '
'nothing to rebase\n'))
return _nothingtorebase()
rebaseset = repo.revs('(%ld)::', src)
assert rebaseset
else:
base = scmutil.revrange(repo, [basef or '.'])
if not base:
ui.status(_('empty "base" revision set - '
"can't compute rebase set\n"))
return _nothingtorebase()
commonanc = repo.revs('ancestor(%ld, %d)', base, dest).first()
if commonanc is not None:
rebaseset = repo.revs('(%d::(%ld) - %d)::',
commonanc, base, commonanc)
else:
rebaseset = []
if not rebaseset:
# transform to list because smartsets are not comparable to
# lists. This should be improved to honor laziness of
# smartset.
if list(base) == [dest.rev()]:
if basef:
ui.status(_('nothing to rebase - %s is both "base"'
' and destination\n') % dest)
else:
ui.status(_('nothing to rebase - working directory '
'parent is also destination\n'))
elif not repo.revs('%ld - ::%d', base, dest):
if basef:
ui.status(_('nothing to rebase - "base" %s is '
'already an ancestor of destination '
'%s\n') %
('+'.join(str(repo[r]) for r in base),
dest))
else:
ui.status(_('nothing to rebase - working '
'directory parent is already an '
'ancestor of destination %s\n') % dest)
else: # can it happen?
ui.status(_('nothing to rebase from %s to %s\n') %
('+'.join(str(repo[r]) for r in base), dest))
return _nothingtorebase()
allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
if (not (keepf or allowunstable)
and repo.revs('first(children(%ld) - %ld)',
rebaseset, rebaseset)):
raise error.Abort(
_("can't remove original changesets with"
" unrebased descendants"),
hint=_('use --keep to keep original changesets'))
obsoletenotrebased = {}
if ui.configbool('experimental', 'rebaseskipobsolete'):
rebasesetrevs = set(rebaseset)
obsoletenotrebased = _computeobsoletenotrebased(repo,
rebasesetrevs,
dest)
# - plain prune (no successor) changesets are rebased
# - split changesets are not rebased if at least one of the
# changeset resulting from the split is an ancestor of dest
rebaseset = rebasesetrevs - set(obsoletenotrebased)
result = buildstate(repo, dest, rebaseset, collapsef,
obsoletenotrebased)
if not result:
# Empty state built, nothing to rebase
ui.status(_('nothing to rebase\n'))
return _nothingtorebase()
root = min(rebaseset)
if not keepf and not repo[root].mutable():
raise error.Abort(_("can't rebase public changeset %s")
% repo[root],
hint=_('see "hg help phases" for details'))
originalwd, target, state = result
if collapsef:
targetancestors = repo.changelog.ancestors([target],
inclusive=True)
external = externalparent(repo, state, targetancestors)
if dest.closesbranch() and not keepbranchesf:
ui.status(_('reopening closed branch head %s\n') % dest)
if keepbranchesf:
# insert _savebranch at the start of extrafns so if
# there's a user-provided extrafn it can clobber branch if
# desired
extrafns.insert(0, _savebranch)
if collapsef:
branches = set()
for rev in state:
branches.add(repo[rev].branch())
if len(branches) > 1:
raise error.Abort(_('cannot collapse multiple named '
'branches'))
# Rebase
if not targetancestors:
targetancestors = repo.changelog.ancestors([target], inclusive=True)
# Keep track of the current bookmarks in order to reset them later
currentbookmarks = repo._bookmarks.copy()
activebookmark = activebookmark or repo._activebookmark
if activebookmark:
bookmarks.deactivate(repo)
extrafn = _makeextrafn(extrafns)
sortedstate = sorted(state)
total = len(sortedstate)
pos = 0
for rev in sortedstate:
ctx = repo[rev]
desc = '%d:%s "%s"' % (ctx.rev(), ctx,
ctx.description().split('\n', 1)[0])
names = repo.nodetags(ctx.node()) + repo.nodebookmarks(ctx.node())
if names:
desc += ' (%s)' % ' '.join(names)
pos += 1
if state[rev] == revtodo:
ui.status(_('rebasing %s\n') % desc)
ui.progress(_("rebasing"), pos, ("%d:%s" % (rev, ctx)),
_('changesets'), total)
p1, p2, base = defineparents(repo, rev, target, state,
targetancestors)
storestatus(repo, originalwd, target, state, collapsef, keepf,
keepbranchesf, external, activebookmark)
if len(repo.parents()) == 2:
repo.ui.debug('resuming interrupted rebase\n')
else:
try:
ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
'rebase')
stats = rebasenode(repo, rev, p1, base, state,
collapsef, target)
if stats and stats[3] > 0:
raise error.InterventionRequired(
_('unresolved conflicts (see hg '
'resolve, then hg rebase --continue)'))
finally:
ui.setconfig('ui', 'forcemerge', '', 'rebase')
if not collapsef:
merging = p2 != nullrev
editform = cmdutil.mergeeditform(merging, 'rebase')
editor = cmdutil.getcommiteditor(editform=editform, **opts)
newnode = concludenode(repo, rev, p1, p2, extrafn=extrafn,
editor=editor,
keepbranches=keepbranchesf)
else:
# Skip commit if we are collapsing
repo.dirstate.beginparentchange()
repo.setparents(repo[p1].node())
repo.dirstate.endparentchange()
newnode = None
# Update the state
if newnode is not None:
state[rev] = repo[newnode].rev()
ui.debug('rebased as %s\n' % short(newnode))
else:
if not collapsef:
ui.warn(_('note: rebase of %d:%s created no changes '
'to commit\n') % (rev, ctx))
skipped.add(rev)
state[rev] = p1
ui.debug('next revision set to %s\n' % p1)
elif state[rev] == nullmerge:
ui.debug('ignoring null merge rebase of %s\n' % rev)
elif state[rev] == revignored:
ui.status(_('not rebasing ignored %s\n') % desc)
elif state[rev] == revprecursor:
targetctx = repo[obsoletenotrebased[rev]]
desctarget = '%d:%s "%s"' % (targetctx.rev(), targetctx,
targetctx.description().split('\n', 1)[0])
msg = _('note: not rebasing %s, already in destination as %s\n')
ui.status(msg % (desc, desctarget))
else:
ui.status(_('already rebased %s as %s\n') %
(desc, repo[state[rev]]))
ui.progress(_('rebasing'), None)
ui.note(_('rebase merging completed\n'))
if collapsef and not keepopen:
p1, p2, _base = defineparents(repo, min(state), target,
state, targetancestors)
editopt = opts.get('edit')
editform = 'rebase.collapse'
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()
editopt = True
editor = cmdutil.getcommiteditor(edit=editopt, editform=editform)
newnode = concludenode(repo, rev, p1, external, commitmsg=commitmsg,
extrafn=extrafn, editor=editor,
keepbranches=keepbranchesf)
if newnode is None:
newrev = target
else:
newrev = repo[newnode].rev()
for oldrev in state.iterkeys():
if state[oldrev] > nullmerge:
state[oldrev] = newrev
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()
# XXX this is the same as dest.node() for the non-continue path --
# this should probably be cleaned up
targetnode = repo[target].node()
# restore original working directory
# (we do this before stripping)
newwd = state.get(originalwd, originalwd)
if newwd < 0:
# original directory is a parent of rebase set root or ignored
newwd = originalwd
if newwd not in [c.rev() for c in repo[None].parents()]:
ui.note(_("update back to initial working directory parent\n"))
hg.updaterepo(repo, newwd, False)
if not keepf:
collapsedas = None
if collapsef:
collapsedas = newnode
clearrebased(ui, repo, state, skipped, collapsedas)
if currentbookmarks:
updatebookmarks(repo, targetnode, nstate, currentbookmarks)
if activebookmark not in repo._bookmarks:
# active bookmark was divergent one and has been deleted
activebookmark = None
clearstatus(repo)
ui.note(_("rebase completed\n"))
util.unlinkpath(repo.sjoin('undo'), ignoremissing=True)
if skipped:
ui.note(_("%d revisions have been skipped\n") % len(skipped))
if (activebookmark and
repo['.'].node() == repo._bookmarks[activebookmark]):
bookmarks.activate(repo, activebookmark)
finally:
release(lock, wlock)
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.
In its default configuration, Mercurial will prevent you from
rebasing published changes. See :hg:`help phases` for details.
If you don't specify a destination changeset (``-d/--dest``),
rebase uses the current branch tip 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.
For advanced usage, a third way is available through the ``--rev``
option. It allows you to specify an arbitrary set of changesets to
rebase. Descendants of revs you specify with this option are not
automatically included in the rebase.
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 branch tip 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.
.. container:: verbose
Examples:
- move "local changes" (current commit back to branching point)
to the current branch tip after a pull::
hg rebase
- move a single changeset to the stable branch::
hg rebase -r 5f493448 -d stable
- splice a commit and all its descendants onto another part of history::
hg rebase --source c0c3 --dest 4cf9
- rebase everything on a branch marked by a bookmark onto the
default branch::
hg rebase --base myfeature --dest default
- collapse a sequence of changes into a single commit::
hg rebase --collapse -r 1520:1525 -d .
- move a named branch while preserving its name::
hg rebase -r "branch(featureX)" -d 1.3 --keepbranches
Returns 0 on success, 1 if nothing to rebase or there are
unresolved conflicts.
"""
originalwd = target = None
activebookmark = None
external = nullrev
state = {}
skipped = set()
targetancestors = set()
lock = wlock = None
try:
wlock = repo.wlock()
lock = repo.lock()
# 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)
e = opts.get('extrafn') # internal, used by e.g. hgsubversion
extrafns = [_savegraft]
if e:
extrafns = [e]
keepf = opts.get('keep', False)
keepbranchesf = opts.get('keepbranches', False)
# keepopen is not meant for use on the command line, but by
# other extensions
keepopen = opts.get('keepopen', False)
if opts.get('interactive'):
msg = _("interactive history editing is supported by the "
"'histedit' extension (see 'hg help histedit')")
raise util.Abort(msg)
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 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'))
try:
(originalwd, target, state, skipped, collapsef, keepf,
keepbranchesf, external, activebookmark) = restorestatus(repo)
except error.RepoLookupError:
if abortf:
clearstatus(repo)
repo.ui.warn(_('rebase aborted (no revision is removed,'
' only broken state is cleared)\n'))
return 0
else:
msg = _('cannot continue inconsistent rebase')
hint = _('use "hg rebase --abort" to clear broken state')
raise util.Abort(msg, hint=hint)
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'))
cmdutil.checkunfinished(repo)
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 = scmutil.revsingle(repo, destf)
if revf:
rebaseset = scmutil.revrange(repo, revf)
if not rebaseset:
ui.status(_('empty "rev" revision set - '
'nothing to rebase\n'))
return 1
elif srcf:
src = scmutil.revrange(repo, [srcf])
if not src:
ui.status(_('empty "source" revision set - '
'nothing to rebase\n'))
return 1
rebaseset = repo.revs('(%ld)::', src)
assert rebaseset
else:
base = scmutil.revrange(repo, [basef or '.'])
if not base:
ui.status(_('empty "base" revision set - '
"can't compute rebase set\n"))
return 1
commonanc = repo.revs('ancestor(%ld, %d)', base, dest).first()
if commonanc is not None:
rebaseset = repo.revs('(%d::(%ld) - %d)::',
commonanc, base, commonanc)
else:
rebaseset = []
if not rebaseset:
# transform to list because smartsets are not comparable to
# lists. This should be improved to honor lazyness of
# smartset.
if list(base) == [dest.rev()]:
if basef:
ui.status(_('nothing to rebase - %s is both "base"'
' and destination\n') % dest)
else:
ui.status(_('nothing to rebase - working directory '
'parent is also destination\n'))
elif not repo.revs('%ld - ::%d', base, dest):
if basef:
ui.status(_('nothing to rebase - "base" %s is '
'already an ancestor of destination '
'%s\n') %
('+'.join(str(repo[r]) for r in base),
dest))
else:
ui.status(_('nothing to rebase - working '
'directory parent is already an '
'ancestor of destination %s\n') % dest)
else: # can it happen?
ui.status(_('nothing to rebase from %s to %s\n') %
('+'.join(str(repo[r]) for r in base), dest))
return 1
allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
if (not (keepf or allowunstable)
and 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'))
result = buildstate(repo, dest, rebaseset, collapsef)
if not result:
# Empty state built, nothing to rebase
ui.status(_('nothing to rebase\n'))
return 1
root = min(rebaseset)
if 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'))
originalwd, target, state = result
if collapsef:
targetancestors = repo.changelog.ancestors([target],
inclusive=True)
external = externalparent(repo, state, targetancestors)
if dest.closesbranch() and not keepbranchesf:
ui.status(_('reopening closed branch head %s\n') % dest)
if keepbranchesf:
# insert _savebranch at the start of extrafns so if
# there's a user-provided extrafn it can clobber branch if
# desired
extrafns.insert(0, _savebranch)
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 = repo.changelog.ancestors([target], inclusive=True)
# Keep track of the current bookmarks in order to reset them later
currentbookmarks = repo._bookmarks.copy()
activebookmark = activebookmark or repo._bookmarkcurrent
if activebookmark:
bookmarks.unsetcurrent(repo)
extrafn = _makeextrafn(extrafns)
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)
p1, p2 = defineparents(repo, rev, target, state,
targetancestors)
storestatus(repo, originalwd, target, state, collapsef, keepf,
keepbranchesf, external, activebookmark)
if len(repo.parents()) == 2:
repo.ui.debug('resuming interrupted rebase\n')
else:
try:
ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
'rebase')
stats = rebasenode(repo, rev, p1, state, collapsef,
target)
if stats and stats[3] > 0:
raise error.InterventionRequired(
_('unresolved conflicts (see hg '
'resolve, then hg rebase --continue)'))
finally:
ui.setconfig('ui', 'forcemerge', '', 'rebase')
if not collapsef:
merging = repo[p2].rev() != nullrev
editform = cmdutil.mergeeditform(merging, 'rebase')
editor = cmdutil.getcommiteditor(editform=editform, **opts)
newrev = concludenode(repo, rev, p1, p2, extrafn=extrafn,
editor=editor)
else:
# Skip commit if we are collapsing
repo.dirstate.beginparentchange()
repo.setparents(repo[p1].node())
repo.dirstate.endparentchange()
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)
editopt = opts.get('edit')
editform = 'rebase.collapse'
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()
editopt = True
editor = cmdutil.getcommiteditor(edit=editopt, editform=editform)
newrev = concludenode(repo, rev, p1, external, commitmsg=commitmsg,
extrafn=extrafn, editor=editor)
for oldrev in state.iterkeys():
if state[oldrev] > nullmerge:
state[oldrev] = newrev
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()
# XXX this is the same as dest.node() for the non-continue path --
# this should probably be cleaned up
targetnode = repo[target].node()
# restore original working directory
# (we do this before stripping)
newwd = state.get(originalwd, originalwd)
if newwd < 0:
# original directory is a parent of rebase set root or ignored
newwd = originalwd
if newwd not in [c.rev() for c in repo[None].parents()]:
ui.note(_("update back to initial working directory parent\n"))
hg.updaterepo(repo, newwd, False)
if not keepf:
collapsedas = None
if collapsef:
collapsedas = newrev
clearrebased(ui, repo, state, skipped, collapsedas)
if currentbookmarks:
updatebookmarks(repo, targetnode, nstate, currentbookmarks)
if activebookmark not in repo._bookmarks:
# active bookmark was divergent one and has been deleted
activebookmark = None
clearstatus(repo)
ui.note(_("rebase completed\n"))
util.unlinkpath(repo.sjoin('undo'), ignoremissing=True)
if skipped:
ui.note(_("%d revisions have been skipped\n") % len(skipped))
if (activebookmark and
repo['.'].node() == repo._bookmarks[activebookmark]):
bookmarks.setcurrent(repo, activebookmark)
finally:
release(lock, wlock)
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:
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:
revgen = repo.set('%lr', revf)
elif srcf:
revgen = repo.set('(%r)::', srcf)
else:
base = basef or '.'
revgen = repo.set('(children(ancestor(%r, %d)) and ::(%r))::',
base, dest, base)
rebaseset = [c.rev() for c in revgen]
if not rebaseset:
repo.ui.debug('base is ancestor of destination')
result = None
elif not keepf and list(
repo.set('first(children(%ld) - %ld)', rebaseset,
rebaseset)):
raise util.Abort(
_("can't remove original changesets with"
" unrebased descendants"),
hint=_('use --keep to keep original changesets'))
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))
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 fetch(ui, repo, source="default", **opts):
"""pull changes from a remote repository, merge new changes if needed.
This finds all changes from the repository at the specified path
or URL and adds them to the local repository.
If the pulled changes add a new branch head, the head is
automatically merged, and the result of the merge is committed.
Otherwise, the working directory is updated to include the new
changes.
When a merge is needed, the working directory is first updated to
the newly pulled changes. Local changes are then merged into the
pulled changes. To switch the merge order, use --switch-parent.
See :hg:`help dates` for a list of formats valid for -d/--date.
Returns 0 on success.
"""
date = opts.get("date")
if date:
opts["date"] = util.parsedate(date)
parent, p2 = repo.dirstate.parents()
branch = repo.dirstate.branch()
try:
branchnode = repo.branchtip(branch)
except error.RepoLookupError:
branchnode = None
if parent != branchnode:
raise util.Abort(_("working dir not at branch tip " '(use "hg update" to check out branch tip)'))
if p2 != nullid:
raise util.Abort(_("outstanding uncommitted merge"))
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
mod, add, rem, del_ = repo.status()[:4]
if mod or add or rem:
raise util.Abort(_("outstanding uncommitted changes"))
if del_:
raise util.Abort(_("working directory is missing some files"))
bheads = repo.branchheads(branch)
bheads = [head for head in bheads if len(repo[head].children()) == 0]
if len(bheads) > 1:
raise util.Abort(_("multiple heads in this branch " '(use "hg heads ." and "hg merge" to merge)'))
other = hg.peer(repo, opts, ui.expandpath(source))
ui.status(_("pulling from %s\n") % util.hidepassword(ui.expandpath(source)))
revs = None
if opts["rev"]:
try:
revs = [other.lookup(rev) for rev in opts["rev"]]
except error.CapabilityError:
err = _("other repository doesn't support revision lookup, " "so a rev cannot be specified.")
raise util.Abort(err)
# Are there any changes at all?
modheads = repo.pull(other, heads=revs)
if modheads == 0:
return 0
# Is this a simple fast-forward along the current branch?
newheads = repo.branchheads(branch)
newchildren = repo.changelog.nodesbetween([parent], newheads)[2]
if len(newheads) == 1 and len(newchildren):
if newchildren[0] != parent:
return hg.update(repo, newchildren[0])
else:
return 0
# Are there more than one additional branch heads?
newchildren = [n for n in newchildren if n != parent]
newparent = parent
if newchildren:
newparent = newchildren[0]
hg.clean(repo, newparent)
newheads = [n for n in newheads if n != newparent]
if len(newheads) > 1:
ui.status(
_("not merging with %d other new branch heads " '(use "hg heads ." and "hg merge" to merge them)\n')
% (len(newheads) - 1)
)
return 1
if not newheads:
return 0
# Otherwise, let's merge.
err = False
if newheads:
# By default, we consider the repository we're pulling
# *from* as authoritative, so we merge our changes into
# theirs.
if opts["switch_parent"]:
firstparent, secondparent = newparent, newheads[0]
else:
firstparent, secondparent = newheads[0], newparent
ui.status(_("updating to %d:%s\n") % (repo.changelog.rev(firstparent), short(firstparent)))
hg.clean(repo, firstparent)
ui.status(_("merging with %d:%s\n") % (repo.changelog.rev(secondparent), short(secondparent)))
err = hg.merge(repo, secondparent, remind=False)
if not err:
# we don't translate commit messages
message = cmdutil.logmessage(ui, opts) or ("Automated merge with %s" % util.removeauth(other.url()))
editor = cmdutil.commiteditor
if opts.get("force_editor") or opts.get("edit"):
editor = cmdutil.commitforceeditor
n = repo.commit(message, opts["user"], opts["date"], editor=editor)
ui.status(
_("new changeset %d:%s merges remote changes " "with local\n") % (repo.changelog.rev(n), short(n))
)
return err
finally:
release(lock, wlock)
def logmessageutil(ui, opts):
if ishg19orhigher:
cmdutil.logmessage(ui, opts)
else:
cmdutil.logmessage(opts)
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()
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)
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 '
'revision and a base'))
if detachf:
if not srcf:
raise util.Abort(
_('detach requires a revision to be specified'))
if basef:
raise util.Abort(_('cannot specify a base with detach'))
cmdutil.bailifchanged(repo)
result = buildstate(repo, destf, srcf, basef, 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))
external = checkexternal(repo, state, targetancestors)
if keepbranchesf:
assert not extrafn, 'cannot use both keepbranches and extrafn'
def extrafn(ctx, extra):
extra['branch'] = ctx.branch()
# Rebase
if not targetancestors:
targetancestors = set(repo.changelog.ancestors(target))
targetancestors.add(target)
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', '')
updatedirstate(repo, rev, target, p2)
if not collapsef:
newrev = concludenode(repo, rev, p1, p2, extrafn=extrafn)
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)
if 'qtip' in repo.tags():
updatemq(repo, state, skipped, **opts)
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")
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 amend(ui, repo, *pats, **opts):
'''amend the current changeset with more changes
'''
rebase = opts.get('rebase')
to = opts.get('to')
if rebase and _histediting(repo):
# if a histedit is in flight, it's dangerous to remove old commits
hint = _('during histedit, use amend without --rebase')
raise error.Abort('histedit in progress', hint=hint)
badflags = [flag for flag in
['rebase', 'fixup'] if opts.get(flag, None)]
if opts.get('interactive') and badflags:
raise error.Abort(_('--interactive and --%s are mutually exclusive') %
badflags[0])
fixup = opts.get('fixup')
badtoflags = [
'rebase', 'fixup', 'addremove', 'edit', 'interactive', 'include',
'exclude', 'message', 'logfile', 'date', 'user',
'no-move-detection', 'stack'
]
if to and any(opts.get(flag, None) for flag in badtoflags):
raise error.Abort(_('--to cannot be used with any other options'))
if fixup:
fixupamend(ui, repo)
return
if to:
amendtocommit(ui, repo, to)
return
old = repo['.']
if old.phase() == phases.public:
raise error.Abort(_('cannot amend public changesets'))
if len(repo[None].parents()) > 1:
raise error.Abort(_('cannot amend while merging'))
haschildren = len(old.children()) > 0
opts['message'] = cmdutil.logmessage(ui, opts)
# Avoid further processing of any logfile. If such a file existed, its
# contents have been copied into opts['message'] by logmessage
opts['logfile'] = ''
if not opts.get('noeditmessage') and not opts.get('message'):
opts['message'] = old.description()
commitdate = opts.get('date')
if not commitdate:
if ui.config('fbamend', 'date') == 'implicitupdate':
commitdate = 'now'
else:
commitdate = old.date()
active = bmactive(repo)
oldbookmarks = old.bookmarks()
tr = None
wlock = None
lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if opts.get('interactive'):
# Strip the interactive flag to avoid infinite recursive loop
opts.pop('interactive')
cmdutil.dorecord(ui, repo, amend, None, False,
cmdutil.recordfilter, *pats, **opts)
return
else:
node = cmdutil.amend(ui, repo, old, {}, pats, opts)
if node == old.node():
ui.status(_("nothing changed\n"))
return 1
if haschildren and not rebase:
msg = _("warning: the changeset's children were left behind\n")
if _histediting(repo):
ui.warn(msg)
ui.status(_('(this is okay since a histedit is in progress)\n'))
else:
_usereducation(ui)
ui.warn(msg)
ui.status(_("(use 'hg restack' to rebase them)\n"))
changes = []
# move old bookmarks to new node
for bm in oldbookmarks:
changes.append((bm, node))
userestack = ui.configbool('fbamend', 'userestack')
if not _histediting(repo) and not userestack:
preamendname = _preamendname(repo, node)
if haschildren:
changes.append((preamendname, old.node()))
elif not active:
# update bookmark if it isn't based on the active bookmark name
oldname = _preamendname(repo, old.node())
if oldname in repo._bookmarks:
changes.append((preamendname, repo._bookmarks[oldname]))
changes.append((oldname, None)) # delete the old name
tr = repo.transaction('fixupamend')
repo._bookmarks.applychanges(repo, tr, changes)
tr.close()
if rebase and haschildren:
fixupamend(ui, repo)
finally:
lockmod.release(wlock, lock, tr)
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.
In its default configuration, Mercurial will prevent you from
rebasing published changes. See :hg:`help phases` for details.
If you don't specify a destination changeset (``-d/--dest``),
rebase uses the current branch tip 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.
For advanced usage, a third way is available through the ``--rev``
option. It allows you to specify an arbitrary set of changesets to
rebase. Descendants of revs you specify with this option are not
automatically included in the rebase.
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 branch tip 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 or there are
unresolved conflicts.
"""
originalwd = target = None
activebookmark = None
external = nullrev
state = {}
skipped = set()
targetancestors = set()
editor = None
if opts.get('edit'):
editor = cmdutil.commitforceeditor
lock = wlock = None
try:
wlock = repo.wlock()
lock = repo.lock()
# 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)
e = opts.get('extrafn') # internal, used by e.g. hgsubversion
extrafns = [_savegraft]
if e:
extrafns = [e]
keepf = opts.get('keep', False)
keepbranchesf = opts.get('keepbranches', 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 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'))
try:
(originalwd, target, state, skipped, collapsef, keepf,
keepbranchesf, external, activebookmark) = restorestatus(repo)
except error.RepoLookupError:
if abortf:
clearstatus(repo)
repo.ui.warn(_('rebase aborted (no revision is removed,'
' only broken state is cleared)\n'))
return 0
else:
msg = _('cannot continue inconsistent rebase')
hint = _('use "hg rebase --abort" to clear borken state')
raise util.Abort(msg, hint=hint)
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'))
cmdutil.checkunfinished(repo)
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 = scmutil.revsingle(repo, destf)
if revf:
rebaseset = scmutil.revrange(repo, revf)
elif srcf:
src = scmutil.revrange(repo, [srcf])
rebaseset = repo.revs('(%ld)::', src)
else:
base = scmutil.revrange(repo, [basef or '.'])
rebaseset = repo.revs(
'(children(ancestor(%ld, %d)) and ::(%ld))::',
base, dest, base)
if rebaseset:
root = min(rebaseset)
else:
root = None
if not rebaseset:
repo.ui.debug('base is ancestor of destination\n')
result = None
elif (not (keepf or obsolete._enabled)
and 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'))
else:
result = buildstate(repo, dest, rebaseset, collapsef)
if not result:
# Empty state built, nothing to rebase
ui.status(_('nothing to rebase\n'))
return 1
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:
originalwd, target, state = result
if collapsef:
targetancestors = repo.changelog.ancestors([target],
inclusive=True)
external = externalparent(repo, state, targetancestors)
if keepbranchesf:
# insert _savebranch at the start of extrafns so if
# there's a user-provided extrafn it can clobber branch if
# desired
extrafns.insert(0, _savebranch)
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 = repo.changelog.ancestors([target], inclusive=True)
# Keep track of the current bookmarks in order to reset them later
currentbookmarks = repo._bookmarks.copy()
activebookmark = activebookmark or repo._bookmarkcurrent
if activebookmark:
bookmarks.unsetcurrent(repo)
extrafn = _makeextrafn(extrafns)
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)
p1, p2 = defineparents(repo, rev, target, state,
targetancestors)
storestatus(repo, originalwd, target, state, collapsef, keepf,
keepbranchesf, external, activebookmark)
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, collapsef)
if stats and stats[3] > 0:
raise error.InterventionRequired(
_('unresolved conflicts (see hg '
'resolve, then hg rebase --continue)'))
finally:
ui.setconfig('ui', 'forcemerge', '')
cmdutil.duplicatecopies(repo, rev, target)
if not collapsef:
newrev = concludenode(repo, rev, p1, p2, extrafn=extrafn,
editor=editor)
else:
# Skip commit if we are collapsing
repo.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)
for oldrev in state.iterkeys():
if state[oldrev] > nullmerge:
state[oldrev] = newrev
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()
# XXX this is the same as dest.node() for the non-continue path --
# this should probably be cleaned up
targetnode = repo[target].node()
# restore original working directory
# (we do this before stripping)
newwd = state.get(originalwd, originalwd)
if newwd not in [c.rev() for c in repo[None].parents()]:
ui.note(_("update back to initial working directory parent\n"))
hg.updaterepo(repo, newwd, False)
if not keepf:
collapsedas = None
if collapsef:
collapsedas = newrev
clearrebased(ui, repo, state, skipped, collapsedas)
if currentbookmarks:
updatebookmarks(repo, targetnode, nstate, currentbookmarks)
clearstatus(repo)
ui.note(_("rebase completed\n"))
util.unlinkpath(repo.sjoin('undo'), ignoremissing=True)
if skipped:
ui.note(_("%d revisions have been skipped\n") % len(skipped))
if (activebookmark and
repo['.'].node() == repo._bookmarks[activebookmark]):
bookmarks.setcurrent(repo, activebookmark)
finally:
release(lock, wlock)
def cdm_recommit(ui, repo, **opts):
'''compact outgoing deltas into a single, conglomerate, delta'''
if not os.getcwd().startswith(repo.root):
raise util.Abort('recommit is not safe to run with -R')
abort_if_dirty(wslist[repo])
heads = repo.heads()
if len(heads) > 1:
ui.warn('Workspace has multiple heads (or branches):\n')
for head in heads:
ui.warn('\t%d\n' % repo.changelog.rev(head))
raise util.Abort('you must merge before recommitting')
wlock = repo.wlock()
lock = repo.lock()
try:
active = wslist[repo].active(opts['parent'])
if len(active.revs) <= 0:
raise util.Abort("no changes to recommit")
if len(active.files()) <= 0:
ui.warn(
"Recommitting %d active changesets, but no active files\n" %
len(active.revs))
#
# During the course of a recommit, any file bearing a name
# matching the source name of any renamed file will be
# clobbered by the operation.
#
# As such, we ask the user before proceeding.
#
bogosity = [
f.parentname for f in active
if f.is_renamed() and os.path.exists(repo.wjoin(f.parentname))
]
if bogosity:
ui.warn("The following file names are the original name of a "
"rename and also present\n"
"in the working directory:\n")
for fname in bogosity:
ui.warn(" %s\n" % fname)
if not yes_no(
ui, "These files will be removed by recommit."
" Continue?", False):
raise util.Abort("recommit would clobber files")
user = opts['user'] or ui.username()
comments = '\n'.join(active.comments())
message = cmdutil.logmessage(opts) or ui.edit(comments, user)
if not message:
raise util.Abort('empty commit message')
bk = CdmBackup(ui, wslist[repo], backup_name(repo.root))
if bk.need_backup():
if yes_no(ui, 'Do you want to backup files first?', True):
bk.backup()
oldtags = repo.tags()
clearedtags = [(name, nd, repo.changelog.rev(nd), local)
for name, nd, local in active.tags()]
wslist[repo].squishdeltas(active, message, user=user)
finally:
lock.release()
wlock.release()
if clearedtags:
ui.write("Removed tags:\n")
for name, nd, rev, local in sorted(clearedtags,
key=lambda x: x[0].lower()):
ui.write(" %5s:%s:\t%s%s\n" % (rev, node.short(nd), name,
(local and ' (local)' or '')))
for ntag, nnode in sorted(repo.tags().items(),
key=lambda x: x[0].lower()):
if ntag in oldtags and ntag != "tip":
if oldtags[ntag] != nnode:
ui.write(
"tag '%s' now refers to revision %d:%s\n" %
(ntag, repo.changelog.rev(nnode), node.short(nnode)))
def cdm_recommit(ui, repo, **opts):
'''replace outgoing changesets with a single equivalent changeset
Replace all outgoing changesets with a single changeset containing
equivalent changes. This removes uninteresting changesets created
during development that would only serve as noise in the gate.
Any changed file that is now identical in content to that in the
parent workspace (whether identical in history or otherwise) will
not be included in the new changeset. Any merges information will
also be removed.
If no files are changed in comparison to the parent workspace, the
outgoing changesets will be removed, but no new changeset created.
recommit will refuse to run if the workspace contains more than
one outgoing head, even if those heads are on the same branch. To
recommit with only one branch containing outgoing changesets, your
workspace must be on that branch and at that branch head.
recommit will prompt you to take a backup if your workspace has
been changed since the last backup was taken. In almost all
cases, you should allow it to take one (the default).
recommit cannot be run if the workspace contains any uncommitted
changes, applied Mq patches, or has multiple outgoing heads (or
branches).
'''
ws = wslist[repo]
if not os.getcwd().startswith(repo.root):
raise util.Abort('recommit is not safe to run with -R')
abort_if_dirty(ws)
wlock = repo.wlock()
lock = repo.lock()
try:
parent = ws.parent(opts['parent'])
between = repo.changelog.nodesbetween(ws.findoutgoing(parent))[2]
heads = set(between) & set(repo.heads())
if len(heads) > 1:
ui.warn('Workspace has multiple outgoing heads (or branches):\n')
for head in sorted(map(repo.changelog.rev, heads), reverse=True):
ui.warn('\t%d\n' % head)
raise util.Abort('you must merge before recommitting')
#
# We can safely use the worklist here, as we know (from the
# abort_if_dirty() check above) that the working copy has not been
# modified.
#
active = ws.active(parent)
if filter(lambda b: len(b.parents()) > 1, active.bases()):
raise util.Abort('Cannot recommit a merge of two non-outgoing '
'changesets')
if len(active.revs) <= 0:
raise util.Abort("no changes to recommit")
if len(active.files()) <= 0:
ui.warn("Recommitting %d active changesets, but no active files\n" %
len(active.revs))
#
# During the course of a recommit, any file bearing a name
# matching the source name of any renamed file will be
# clobbered by the operation.
#
# As such, we ask the user before proceeding.
#
bogosity = [f.parentname for f in active if f.is_renamed() and
os.path.exists(repo.wjoin(f.parentname))]
if bogosity:
ui.warn("The following file names are the original name of a "
"rename and also present\n"
"in the working directory:\n")
for fname in bogosity:
ui.warn(" %s\n" % fname)
if not yes_no(ui, "These files will be removed by recommit."
" Continue?",
False):
raise util.Abort("recommit would clobber files")
user = opts['user'] or ui.username()
comments = '\n'.join(active.comments())
message = cmdutil.logmessage(opts) or ui.edit(comments, user)
if not message:
raise util.Abort('empty commit message')
bk = CdmBackup(ui, ws, backup_name(repo.root))
if bk.need_backup():
if yes_no(ui, 'Do you want to backup files first?', True):
bk.backup()
oldtags = repo.tags()
clearedtags = [(name, nd, repo.changelog.rev(nd), local)
for name, nd, local in active.tags()]
ws.squishdeltas(active, message, user=user)
finally:
lock.release()
wlock.release()
if clearedtags:
ui.write("Removed tags:\n")
for name, nd, rev, local in sorted(clearedtags,
key=lambda x: x[0].lower()):
ui.write(" %5s:%s:\t%s%s\n" % (rev, node.short(nd),
name, (local and ' (local)' or '')))
for ntag, nnode in sorted(repo.tags().items(),
key=lambda x: x[0].lower()):
if ntag in oldtags and ntag != "tip":
if oldtags[ntag] != nnode:
ui.write("tag '%s' now refers to revision %d:%s\n" %
(ntag, repo.changelog.rev(nnode),
node.short(nnode)))
def rewrite(repo, old, updates, head, newbases, commitopts):
"""Return (nodeid, created) where nodeid is the identifier of the
changeset generated by the rewrite process, and created is True if
nodeid was actually created. If created is False, nodeid
references a changeset existing before the rewrite call.
"""
wlock = lock = tr = None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction('rewrite')
if len(old.parents()) > 1: # XXX remove this unnecessary limitation.
raise error.Abort(_('cannot amend merge changesets'))
base = old.p1()
updatebookmarks = bookmarksupdater(
repo, [old.node()] + [u.node() for u in updates], tr)
# commit a new version of the old changeset, including the update
# collect all files which might be affected
files = set(old.files())
for u in updates:
files.update(u.files())
# Recompute copies (avoid recording a -> b -> a)
copied = copies.pathcopies(base, head)
# prune files which were reverted by the updates
def samefile(f):
if f in head.manifest():
a = head.filectx(f)
if f in base.manifest():
b = base.filectx(f)
return (a.data() == b.data()
and a.flags() == b.flags())
else:
return False
else:
return f not in base.manifest()
files = [f for f in files if not samefile(f)]
# commit version of these files as defined by head
headmf = head.manifest()
def filectxfn(repo, ctx, path):
if path in headmf:
fctx = head[path]
flags = fctx.flags()
mctx = context.memfilectx(repo, ctx, fctx.path(), fctx.data(),
islink='l' in flags,
isexec='x' in flags,
copied=copied.get(path))
return mctx
return None
message = cmdutil.logmessage(repo.ui, commitopts)
if not message:
message = old.description()
user = commitopts.get('user') or old.user()
# TODO: In case not date is given, we should take the old commit date
# if we are working one one changeset or mimic the fold behavior about
# date
date = commitopts.get('date') or None
extra = dict(commitopts.get('extra', old.extra()))
extra['branch'] = head.branch()
new = context.memctx(repo,
parents=newbases,
text=message,
files=files,
filectxfn=filectxfn,
user=user,
date=date,
extra=extra)
if commitopts.get('edit'):
new._text = cmdutil.commitforceeditor(repo, new, [])
revcount = len(repo)
newid = repo.commitctx(new)
new = repo[newid]
created = len(repo) != revcount
updatebookmarks(newid)
tr.close()
return newid, created
finally:
lockmod.release(tr, lock, wlock)
def uncommit(ui, repo, *pats, **opts):
"""uncommit part or all of a local changeset
This command undoes the effect of a local commit, returning the affected
files to their uncommitted state. This means that files modified or
deleted in the changeset will be left unchanged, and so will remain
modified in the working directory.
If no files are specified, the commit will be pruned, unless --keep is
given.
"""
opts = pycompat.byteskwargs(opts)
cmdutil.checknotesize(ui, opts)
cmdutil.resolvecommitoptions(ui, opts)
with repo.wlock(), repo.lock():
m, a, r, d = repo.status()[:4]
isdirtypath = any(set(m + a + r + d) & set(pats))
allowdirtywcopy = opts[
b'allow_dirty_working_copy'] or repo.ui.configbool(
b'experimental', b'uncommitondirtywdir')
if not allowdirtywcopy and (not pats or isdirtypath):
cmdutil.bailifchanged(
repo,
hint=_(b'requires --allow-dirty-working-copy to uncommit'),
)
old = repo[b'.']
rewriteutil.precheck(repo, [old.rev()], b'uncommit')
if len(old.parents()) > 1:
raise error.Abort(_(b"cannot uncommit merge changeset"))
match = scmutil.match(old, pats, opts)
# Check all explicitly given files; abort if there's a problem.
if match.files():
s = old.status(old.p1(), match, listclean=True)
eligible = set(s.added) | set(s.modified) | set(s.removed)
badfiles = set(match.files()) - eligible
# Naming a parent directory of an eligible file is OK, even
# if not everything tracked in that directory can be
# uncommitted.
if badfiles:
badfiles -= {f for f in util.dirs(eligible)}
for f in sorted(badfiles):
if f in s.clean:
hint = _(
b"file was not changed in working directory parent")
elif repo.wvfs.exists(f):
hint = _(b"file was untracked in working directory parent")
else:
hint = _(b"file does not exist")
raise error.Abort(
_(b'cannot uncommit "%s"') % scmutil.getuipathfn(repo)(f),
hint=hint,
)
with repo.transaction(b'uncommit'):
if not (opts[b'message'] or opts[b'logfile']):
opts[b'message'] = old.description()
message = cmdutil.logmessage(ui, opts)
keepcommit = pats
if not keepcommit:
if opts.get(b'keep') is not None:
keepcommit = opts.get(b'keep')
else:
keepcommit = ui.configbool(b'experimental',
b'uncommit.keep')
newid = _commitfiltered(
repo,
old,
match,
keepcommit,
message=message,
user=opts.get(b'user'),
date=opts.get(b'date'),
)
if newid is None:
ui.status(_(b"nothing to uncommit\n"))
return 1
mapping = {}
if newid != old.p1().node():
# Move local changes on filtered changeset
mapping[old.node()] = (newid, )
else:
# Fully removed the old commit
mapping[old.node()] = ()
with repo.dirstate.parentchange():
scmutil.movedirstate(repo, repo[newid], match)
scmutil.cleanupnodes(repo, mapping, b'uncommit', fixphase=True)
