bookmarks.py
522 lines
| 18.4 KiB
| text/x-python
|
PythonLexer
/ hgext / bookmarks.py
|
r7239 | # Mercurial extension to provide the 'hg bookmark' command | ||
# | ||||
# Copyright 2008 David Soria Parra <dsp@php.net> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r7252 | |||
|
r8894 | '''track a line of development with movable markers | ||
|
r7239 | |||
|
r9251 | Bookmarks are local movable markers to changesets. Every bookmark | ||
points to a changeset identified by its hash. If you commit a | ||||
changeset that is based on a changeset that has a bookmark on it, the | ||||
bookmark shifts to the new changeset. | ||||
|
r7239 | |||
|
r11193 | It is possible to use bookmark names in every revision lookup (e.g. | ||
:hg:`merge`, :hg:`update`). | ||||
|
r7481 | |||
|
r9251 | By default, when several bookmarks point to the same changeset, they | ||
will all move forward together. It is possible to obtain a more | ||||
git-like experience by adding the following configuration option to | ||||
your .hgrc:: | ||||
|
r7481 | |||
|
r8892 | [bookmarks] | ||
track.current = True | ||||
|
r7481 | |||
|
r9251 | This will cause Mercurial to track the bookmark that you are currently | ||
using, and only update it. This is similar to git's approach to | ||||
branching. | ||||
|
r7239 | ''' | ||
|
r7252 | |||
|
r7239 | from mercurial.i18n import _ | ||
|
r7638 | from mercurial.node import nullid, nullrev, hex, short | ||
|
r11431 | from mercurial import util, commands, repair, extensions, pushkey, hg, url | ||
|
r7638 | import os | ||
|
r7239 | |||
|
r10106 | def write(repo): | ||
|
r7239 | '''Write bookmarks | ||
|
r7250 | |||
|
r7239 | Write the given bookmark => hash dictionary to the .hg/bookmarks file | ||
in a format equal to those of localtags. | ||||
We also store a backup of the previous state in undo.bookmarks that | ||||
can be copied back on rollback. | ||||
''' | ||||
|
r10106 | refs = repo._bookmarks | ||
|
r7253 | if os.path.exists(repo.join('bookmarks')): | ||
util.copyfile(repo.join('bookmarks'), repo.join('undo.bookmarks')) | ||||
|
r10107 | if repo._bookmarkcurrent not in refs: | ||
|
r7481 | setcurrent(repo, None) | ||
|
r8862 | wlock = repo.wlock() | ||
try: | ||||
file = repo.opener('bookmarks', 'w', atomictemp=True) | ||||
for refspec, node in refs.iteritems(): | ||||
file.write("%s %s\n" % (hex(node), refspec)) | ||||
file.rename() | ||||
finally: | ||||
wlock.release() | ||||
|
r7239 | |||
|
r7481 | def setcurrent(repo, mark): | ||
'''Set the name of the bookmark that we are currently on | ||||
Set the name of the bookmark that we are on (hg update <bookmark>). | ||||
|
r8087 | The name is recorded in .hg/bookmarks.current | ||
|
r7481 | ''' | ||
|
r10107 | current = repo._bookmarkcurrent | ||
if current == mark: | ||||
|
r7481 | return | ||
|
r7484 | |||
|
r10105 | refs = repo._bookmarks | ||
|
r7484 | |||
|
r7491 | # do not update if we do update to a rev equal to the current bookmark | ||
|
r7817 | if (mark and mark not in refs and | ||
|
r10107 | current and refs[current] == repo.changectx('.').node()): | ||
|
r7484 | return | ||
|
r7481 | if mark not in refs: | ||
mark = '' | ||||
|
r8862 | wlock = repo.wlock() | ||
try: | ||||
file = repo.opener('bookmarks.current', 'w', atomictemp=True) | ||||
file.write(mark) | ||||
file.rename() | ||||
finally: | ||||
wlock.release() | ||||
|
r7481 | repo._bookmarkcurrent = mark | ||
|
r7255 | def bookmark(ui, repo, mark=None, rev=None, force=False, delete=False, rename=None): | ||
|
r8894 | '''track a line of development with movable markers | ||
|
r7250 | |||
|
r9251 | Bookmarks are pointers to certain commits that move when | ||
committing. Bookmarks are local. They can be renamed, copied and | ||||
|
r10973 | deleted. It is possible to use bookmark names in :hg:`merge` and | ||
:hg:`update` to merge and update respectively to a given bookmark. | ||||
|
r7250 | |||
|
r10973 | You can use :hg:`bookmark NAME` to set a bookmark on the working | ||
|
r9251 | directory's parent revision with the given name. If you specify | ||
a revision using -r REV (where REV may be an existing bookmark), | ||||
the bookmark is assigned to that revision. | ||||
|
r7239 | ''' | ||
hexfn = ui.debugflag and hex or short | ||||
|
r10105 | marks = repo._bookmarks | ||
|
r7239 | cur = repo.changectx('.').node() | ||
|
r7255 | if rename: | ||
if rename not in marks: | ||||
|
r7251 | raise util.Abort(_("a bookmark of this name does not exist")) | ||
|
r7239 | if mark in marks and not force: | ||
raise util.Abort(_("a bookmark of the same name already exists")) | ||||
|
r7254 | if mark is None: | ||
raise util.Abort(_("new bookmark name required")) | ||||
|
r7255 | marks[mark] = marks[rename] | ||
del marks[rename] | ||||
|
r10107 | if repo._bookmarkcurrent == rename: | ||
|
r7550 | setcurrent(repo, mark) | ||
|
r10106 | write(repo) | ||
|
r7239 | return | ||
|
r7250 | |||
|
r7239 | if delete: | ||
|
r8527 | if mark is None: | ||
|
r7239 | raise util.Abort(_("bookmark name required")) | ||
if mark not in marks: | ||||
|
r7251 | raise util.Abort(_("a bookmark of this name does not exist")) | ||
|
r10107 | if mark == repo._bookmarkcurrent: | ||
|
r7817 | setcurrent(repo, None) | ||
|
r7239 | del marks[mark] | ||
|
r10106 | write(repo) | ||
|
r7239 | return | ||
if mark != None: | ||||
|
r7259 | if "\n" in mark: | ||
raise util.Abort(_("bookmark name cannot contain newlines")) | ||||
|
r7260 | mark = mark.strip() | ||
|
r7239 | if mark in marks and not force: | ||
raise util.Abort(_("a bookmark of the same name already exists")) | ||||
|
r7250 | if ((mark in repo.branchtags() or mark == repo.dirstate.branch()) | ||
|
r7239 | and not force): | ||
|
r7252 | raise util.Abort( | ||
_("a bookmark cannot have the name of an existing branch")) | ||||
|
r7239 | if rev: | ||
marks[mark] = repo.lookup(rev) | ||||
else: | ||||
marks[mark] = repo.changectx('.').node() | ||||
|
r7816 | setcurrent(repo, mark) | ||
|
r10106 | write(repo) | ||
|
r7239 | return | ||
|
r8527 | if mark is None: | ||
|
r7258 | if rev: | ||
raise util.Abort(_("bookmark name required")) | ||||
|
r7239 | if len(marks) == 0: | ||
|
r10510 | ui.status(_("no bookmarks set\n")) | ||
|
r7239 | else: | ||
for bmark, n in marks.iteritems(): | ||||
|
r7481 | if ui.configbool('bookmarks', 'track.current'): | ||
|
r10107 | current = repo._bookmarkcurrent | ||
|
r10820 | if bmark == current and n == cur: | ||
prefix, label = '*', 'bookmarks.current' | ||||
else: | ||||
prefix, label = ' ', '' | ||||
|
r7481 | else: | ||
|
r10820 | if n == cur: | ||
prefix, label = '*', 'bookmarks.current' | ||||
else: | ||||
prefix, label = ' ', '' | ||||
|
r7481 | |||
|
r9459 | if ui.quiet: | ||
|
r10820 | ui.write("%s\n" % bmark, label=label) | ||
|
r9459 | else: | ||
ui.write(" %s %-25s %d:%s\n" % ( | ||||
|
r10820 | prefix, bmark, repo.changelog.rev(n), hexfn(n)), | ||
label=label) | ||||
|
r7239 | return | ||
def _revstostrip(changelog, node): | ||||
srev = changelog.rev(node) | ||||
tostrip = [srev] | ||||
saveheads = [] | ||||
|
r7283 | for r in xrange(srev, len(changelog)): | ||
|
r7239 | parents = changelog.parentrevs(r) | ||
if parents[0] in tostrip or parents[1] in tostrip: | ||||
tostrip.append(r) | ||||
if parents[1] != nullrev: | ||||
for p in parents: | ||||
|
r7283 | if p not in tostrip and p > srev: | ||
|
r7239 | saveheads.append(p) | ||
return [r for r in tostrip if r not in saveheads] | ||||
|
r7638 | def strip(oldstrip, ui, repo, node, backup="all"): | ||
|
r7239 | """Strip bookmarks if revisions are stripped using | ||
the mercurial.strip method. This usually happens during | ||||
qpush and qpop""" | ||||
revisions = _revstostrip(repo.changelog, node) | ||||
|
r10105 | marks = repo._bookmarks | ||
|
r7239 | update = [] | ||
|
r7622 | for mark, n in marks.iteritems(): | ||
|
r7239 | if repo.changelog.rev(n) in revisions: | ||
update.append(mark) | ||||
|
r7280 | oldstrip(ui, repo, node, backup) | ||
|
r7239 | if len(update) > 0: | ||
for m in update: | ||||
marks[m] = repo.changectx('.').node() | ||||
|
r10106 | write(repo) | ||
|
r7239 | |||
def reposetup(ui, repo): | ||||
|
r9643 | if not repo.local(): | ||
|
r7239 | return | ||
class bookmark_repo(repo.__class__): | ||||
|
r10105 | |||
@util.propertycache | ||||
def _bookmarks(self): | ||||
|
r10109 | '''Parse .hg/bookmarks file and return a dictionary | ||
Bookmarks are stored as {HASH}\\s{NAME}\\n (localtags format) values | ||||
in the .hg/bookmarks file. They are read returned as a dictionary | ||||
with name => hash values. | ||||
''' | ||||
try: | ||||
bookmarks = {} | ||||
for line in self.opener('bookmarks'): | ||||
sha, refspec = line.strip().split(' ', 1) | ||||
bookmarks[refspec] = super(bookmark_repo, self).lookup(sha) | ||||
except: | ||||
pass | ||||
return bookmarks | ||||
|
r7239 | |||
|
r10107 | @util.propertycache | ||
def _bookmarkcurrent(self): | ||||
|
r10109 | '''Get the current bookmark | ||
If we use gittishsh branches we have a current bookmark that | ||||
we are on. This function returns the name of the bookmark. It | ||||
is stored in .hg/bookmarks.current | ||||
''' | ||||
mark = None | ||||
if os.path.exists(self.join('bookmarks.current')): | ||||
file = self.opener('bookmarks.current') | ||||
# No readline() in posixfile_nt, reading everything is cheap | ||||
mark = (file.readlines() or [''])[0] | ||||
if mark == '': | ||||
mark = None | ||||
file.close() | ||||
return mark | ||||
|
r10107 | |||
|
r10882 | def rollback(self, *args): | ||
|
r7239 | if os.path.exists(self.join('undo.bookmarks')): | ||
util.rename(self.join('undo.bookmarks'), self.join('bookmarks')) | ||||
|
r10882 | return super(bookmark_repo, self).rollback(*args) | ||
|
r7239 | |||
def lookup(self, key): | ||||
if key in self._bookmarks: | ||||
key = self._bookmarks[key] | ||||
return super(bookmark_repo, self).lookup(key) | ||||
|
r10108 | def _bookmarksupdate(self, parents, node): | ||
|
r10105 | marks = self._bookmarks | ||
|
r7239 | update = False | ||
|
r9236 | if ui.configbool('bookmarks', 'track.current'): | ||
|
r10107 | mark = self._bookmarkcurrent | ||
|
r9236 | if mark and marks[mark] in parents: | ||
|
r7239 | marks[mark] = node | ||
update = True | ||||
|
r9236 | else: | ||
for mark, n in marks.items(): | ||||
if n in parents: | ||||
marks[mark] = node | ||||
update = True | ||||
|
r7239 | if update: | ||
|
r10106 | write(self) | ||
|
r10108 | |||
|
r9235 | def commitctx(self, ctx, error=False): | ||
|
r7239 | """Add a revision to the repository and | ||
move the bookmark""" | ||||
|
r8862 | wlock = self.wlock() # do both commit and bookmark with lock held | ||
try: | ||||
|
r9235 | node = super(bookmark_repo, self).commitctx(ctx, error) | ||
|
r8862 | if node is None: | ||
return None | ||||
|
r8944 | parents = self.changelog.parents(node) | ||
|
r8862 | if parents[1] == nullid: | ||
parents = (parents[0],) | ||||
|
r10108 | |||
self._bookmarksupdate(parents, node) | ||||
|
r8862 | return node | ||
finally: | ||||
wlock.release() | ||||
|
r7239 | |||
|
r11373 | def pull(self, remote, heads=None, force=False): | ||
result = super(bookmark_repo, self).pull(remote, heads, force) | ||||
self.ui.debug("checking for updated bookmarks\n") | ||||
rb = remote.listkeys('bookmarks') | ||||
changes = 0 | ||||
for k in rb.keys(): | ||||
if k in self._bookmarks: | ||||
nr, nl = rb[k], self._bookmarks[k] | ||||
if nr in self: | ||||
cr = self[nr] | ||||
cl = self[nl] | ||||
if cl.rev() >= cr.rev(): | ||||
continue | ||||
if cr in cl.descendants(): | ||||
self._bookmarks[k] = cr.node() | ||||
changes += 1 | ||||
self.ui.status(_("updating bookmark %s\n") % k) | ||||
else: | ||||
self.ui.warn(_("not updating divergent" | ||||
" bookmark %s\n") % k) | ||||
if changes: | ||||
write(repo) | ||||
return result | ||||
|
r11374 | def push(self, remote, force=False, revs=None, newbranch=False): | ||
result = super(bookmark_repo, self).push(remote, force, revs, | ||||
newbranch) | ||||
self.ui.debug("checking for updated bookmarks\n") | ||||
rb = remote.listkeys('bookmarks') | ||||
for k in rb.keys(): | ||||
if k in self._bookmarks: | ||||
nr, nl = rb[k], self._bookmarks[k] | ||||
if nr in self: | ||||
cr = self[nr] | ||||
cl = self[nl] | ||||
if cl in cr.descendants(): | ||||
r = remote.pushkey('bookmarks', k, nr, nl) | ||||
if r: | ||||
self.ui.status(_("updating bookmark %s\n") % k) | ||||
else: | ||||
self.ui.warn(_("failed to update bookmark" | ||||
" %s!\n") % k) | ||||
return result | ||||
|
r7239 | def addchangegroup(self, source, srctype, url, emptyok=False): | ||
|
r8944 | parents = self.dirstate.parents() | ||
|
r7239 | |||
|
r7252 | result = super(bookmark_repo, self).addchangegroup( | ||
source, srctype, url, emptyok) | ||||
|
r7239 | if result > 1: | ||
# We have more heads than before | ||||
return result | ||||
|
r8944 | node = self.changelog.tip() | ||
|
r10108 | |||
self._bookmarksupdate(parents, node) | ||||
|
r7239 | return result | ||
|
r9145 | def _findtags(self): | ||
|
r7480 | """Merge bookmarks with normal tags""" | ||
|
r9145 | (tags, tagtypes) = super(bookmark_repo, self)._findtags() | ||
|
r10105 | tags.update(self._bookmarks) | ||
|
r9145 | return (tags, tagtypes) | ||
|
r7480 | |||
|
r10597 | if hasattr(repo, 'invalidate'): | ||
def invalidate(self): | ||||
super(bookmark_repo, self).invalidate() | ||||
for attr in ('_bookmarks', '_bookmarkcurrent'): | ||||
if attr in self.__dict__: | ||||
|
r10956 | delattr(self, attr) | ||
|
r10597 | |||
|
r7239 | repo.__class__ = bookmark_repo | ||
|
r11372 | def listbookmarks(repo): | ||
d = {} | ||||
for k, v in repo._bookmarks.iteritems(): | ||||
d[k] = hex(v) | ||||
return d | ||||
def pushbookmark(repo, key, old, new): | ||||
w = repo.wlock() | ||||
try: | ||||
marks = repo._bookmarks | ||||
if hex(marks.get(key, '')) != old: | ||||
return False | ||||
if new == '': | ||||
del marks[key] | ||||
else: | ||||
if new not in repo: | ||||
return False | ||||
marks[key] = repo[new].node() | ||||
write(repo) | ||||
return True | ||||
finally: | ||||
w.release() | ||||
|
r11378 | def pull(oldpull, ui, repo, source="default", **opts): | ||
# translate bookmark args to rev args for actual pull | ||||
if opts.get('bookmark'): | ||||
# this is an unpleasant hack as pull will do this internally | ||||
source, branches = hg.parseurl(ui.expandpath(source), | ||||
opts.get('branch')) | ||||
other = hg.repository(hg.remoteui(repo, opts), source) | ||||
rb = other.listkeys('bookmarks') | ||||
for b in opts['bookmark']: | ||||
if b not in rb: | ||||
raise util.Abort(_('remote bookmark %s not found!') % b) | ||||
opts.setdefault('rev', []).append(b) | ||||
result = oldpull(ui, repo, source, **opts) | ||||
# update specified bookmarks | ||||
if opts.get('bookmark'): | ||||
for b in opts['bookmark']: | ||||
# explicit pull overrides local bookmark if any | ||||
ui.status(_("importing bookmark %s\n") % b) | ||||
repo._bookmarks[b] = repo[rb[b]].node() | ||||
write(repo) | ||||
return result | ||||
|
r11379 | def push(oldpush, ui, repo, dest=None, **opts): | ||
dopush = True | ||||
if opts.get('bookmark'): | ||||
dopush = False | ||||
for b in opts['bookmark']: | ||||
if b in repo._bookmarks: | ||||
dopush = True | ||||
opts.setdefault('rev', []).append(b) | ||||
result = 0 | ||||
if dopush: | ||||
result = oldpush(ui, repo, dest, **opts) | ||||
if opts.get('bookmark'): | ||||
# this is an unpleasant hack as push will do this internally | ||||
dest = ui.expandpath(dest or 'default-push', dest or 'default') | ||||
dest, branches = hg.parseurl(dest, opts.get('branch')) | ||||
other = hg.repository(hg.remoteui(repo, opts), dest) | ||||
rb = other.listkeys('bookmarks') | ||||
for b in opts['bookmark']: | ||||
# explicit push overrides remote bookmark if any | ||||
if b in repo._bookmarks: | ||||
ui.status(_("exporting bookmark %s\n") % b) | ||||
new = repo[b].hex() | ||||
else: | ||||
ui.status(_("deleting remote bookmark %s\n") % b) | ||||
new = '' # delete | ||||
old = rb.get(b, '') | ||||
r = other.pushkey('bookmarks', b, old, new) | ||||
if not r: | ||||
ui.warn(_('updating bookmark %s failed!\n') % b) | ||||
if not result: | ||||
result = 2 | ||||
return result | ||||
|
r11431 | def diffbookmarks(ui, repo, remote): | ||
ui.status(_("searching for changes\n")) | ||||
lmarks = repo.listkeys('bookmarks') | ||||
rmarks = remote.listkeys('bookmarks') | ||||
diff = set(rmarks) - set(lmarks) | ||||
for k in diff: | ||||
ui.write(" %-25s %s\n" % (k, rmarks[k][:12])) | ||||
if len(diff) <= 0: | ||||
ui.status(_("no changes found\n")) | ||||
def incoming(oldincoming, ui, repo, source="default", **opts): | ||||
if opts.get('bookmarks'): | ||||
source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch')) | ||||
other = hg.repository(hg.remoteui(repo, opts), source) | ||||
ui.status(_('comparing with %s\n') % url.hidepassword(source)) | ||||
diffbookmarks(ui, repo, other) | ||||
else: | ||||
oldincoming(ui, repo, source, **opts) | ||||
def outgoing(oldoutgoing, ui, repo, source="default", **opts): | ||||
if opts.get('bookmarks'): | ||||
source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch')) | ||||
other = hg.repository(hg.remoteui(repo, opts), source) | ||||
ui.status(_('comparing with %s\n') % url.hidepassword(source)) | ||||
diffbookmarks(ui, other, repo) | ||||
else: | ||||
oldoutgoing(ui, repo, source, **opts) | ||||
|
r7638 | def uisetup(ui): | ||
extensions.wrapfunction(repair, "strip", strip) | ||||
if ui.configbool('bookmarks', 'track.current'): | ||||
extensions.wrapcommand(commands.table, 'update', updatecurbookmark) | ||||
|
r11378 | |||
entry = extensions.wrapcommand(commands.table, 'pull', pull) | ||||
entry[1].append(('B', 'bookmark', [], | ||||
_("bookmark to import"))) | ||||
|
r11379 | entry = extensions.wrapcommand(commands.table, 'push', push) | ||
entry[1].append(('B', 'bookmark', [], | ||||
_("bookmark to export"))) | ||||
|
r11431 | entry = extensions.wrapcommand(commands.table, 'incoming', incoming) | ||
entry[1].append(('B', 'bookmarks', False, | ||||
_("compare bookmark"))) | ||||
entry = extensions.wrapcommand(commands.table, 'outgoing', outgoing) | ||||
entry[1].append(('B', 'bookmarks', False, | ||||
_("compare bookmark"))) | ||||
|
r11378 | |||
|
r11372 | pushkey.register('bookmarks', pushbookmark, listbookmarks) | ||
|
r7638 | |||
|
r7481 | def updatecurbookmark(orig, ui, repo, *args, **opts): | ||
'''Set the current bookmark | ||||
If the user updates to a bookmark we update the .hg/bookmarks.current | ||||
file. | ||||
''' | ||||
res = orig(ui, repo, *args, **opts) | ||||
rev = opts['rev'] | ||||
if not rev and len(args) > 0: | ||||
rev = args[0] | ||||
setcurrent(repo, rev) | ||||
return res | ||||
|
r7239 | cmdtable = { | ||
"bookmarks": | ||||
(bookmark, | ||||
[('f', 'force', False, _('force')), | ||||
|
r11321 | ('r', 'rev', '', _('revision'), _('REV')), | ||
|
r7239 | ('d', 'delete', False, _('delete a given bookmark')), | ||
|
r11321 | ('m', 'rename', '', _('rename a given bookmark'), _('NAME'))], | ||
|
r7818 | _('hg bookmarks [-f] [-d] [-m NAME] [-r REV] [NAME]')), | ||
|
r7239 | } | ||
|
r10826 | |||
colortable = {'bookmarks.current': 'green'} | ||||