bookmarks.py
344 lines
| 11.6 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 | ||
# GNU General Public License version 2, incorporated herein by reference. | ||||
|
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 | |||
|
r9251 | 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 | ||
from mercurial import util, commands, localrepo, repair, extensions | ||||
import os | ||||
|
r7239 | |||
def parse(repo): | ||||
'''Parse .hg/bookmarks file and return a dictionary | ||||
|
r7250 | |||
|
r7789 | Bookmarks are stored as {HASH}\\s{NAME}\\n (localtags format) values | ||
|
r7252 | in the .hg/bookmarks file. They are read by the parse() method and | ||
returned as a dictionary with name => hash values. | ||||
|
r7250 | |||
|
r7239 | The parsed dictionary is cached until a write() operation is done. | ||
''' | ||||
try: | ||||
|
r10105 | bookmarks = {} | ||
|
r7239 | for line in repo.opener('bookmarks'): | ||
sha, refspec = line.strip().split(' ', 1) | ||||
|
r10105 | bookmarks[refspec] = repo.lookup(sha) | ||
|
r7239 | except: | ||
pass | ||||
|
r10105 | return bookmarks | ||
|
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')) | ||||
|
r7481 | if current(repo) not in refs: | ||
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 current(repo): | ||
'''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 | ||||
''' | ||||
if repo._bookmarkcurrent: | ||||
return repo._bookmarkcurrent | ||||
mark = None | ||||
if os.path.exists(repo.join('bookmarks.current')): | ||||
file = repo.opener('bookmarks.current') | ||||
|
r7666 | # No readline() in posixfile_nt, reading everything is cheap | ||
mark = (file.readlines() or [''])[0] | ||||
|
r7481 | if mark == '': | ||
mark = None | ||||
file.close() | ||||
repo._bookmarkcurrent = mark | ||||
return mark | ||||
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 | ''' | ||
|
r7484 | if current(repo) == 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 | ||
|
r7484 | current(repo) and refs[current(repo)] == repo.changectx('.').node()): | ||
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 | ||||
deleted. It is possible to use bookmark names in 'hg merge' and | ||||
'hg update' to merge and update respectively to a given bookmark. | ||||
|
r7250 | |||
|
r8725 | 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] | ||||
|
r7550 | if current(repo) == rename: | ||
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")) | ||
|
r7817 | if mark == current(repo): | ||
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: | ||
ui.status("no bookmarks set\n") | ||||
else: | ||||
for bmark, n in marks.iteritems(): | ||||
|
r7481 | if ui.configbool('bookmarks', 'track.current'): | ||
prefix = (bmark == current(repo) and n == cur) and '*' or ' ' | ||||
else: | ||||
prefix = (n == cur) and '*' or ' ' | ||||
|
r9459 | if ui.quiet: | ||
ui.write("%s\n" % bmark) | ||||
else: | ||||
ui.write(" %s %-25s %d:%s\n" % ( | ||||
prefix, bmark, repo.changelog.rev(n), hexfn(n))) | ||||
|
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 | ||
# init a bookmark cache as otherwise we would get a infinite reading | ||||
# in lookup() | ||||
|
r7481 | repo._bookmarkcurrent = None | ||
|
r7239 | |||
class bookmark_repo(repo.__class__): | ||||
|
r10105 | |||
@util.propertycache | ||||
def _bookmarks(self): | ||||
return parse(self) | ||||
|
r7239 | def rollback(self): | ||
if os.path.exists(self.join('undo.bookmarks')): | ||||
util.rename(self.join('undo.bookmarks'), self.join('bookmarks')) | ||||
|
r7250 | return super(bookmark_repo, self).rollback() | ||
|
r7239 | |||
def lookup(self, key): | ||||
if key in self._bookmarks: | ||||
key = self._bookmarks[key] | ||||
return super(bookmark_repo, self).lookup(key) | ||||
|
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],) | ||||
|
r10105 | marks = self._bookmarks | ||
|
r8862 | update = False | ||
|
r9237 | if ui.configbool('bookmarks', 'track.current'): | ||
mark = current(self) | ||||
if mark and marks[mark] in parents: | ||||
marks[mark] = node | ||||
update = True | ||||
else: | ||||
for mark, n in marks.items(): | ||||
|
r8862 | if n in parents: | ||
marks[mark] = node | ||||
update = True | ||||
if update: | ||||
|
r10106 | write(self) | ||
|
r8862 | return node | ||
finally: | ||||
wlock.release() | ||||
|
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() | ||
|
r10105 | marks = self._bookmarks | ||
|
r7239 | update = False | ||
|
r9236 | if ui.configbool('bookmarks', 'track.current'): | ||
mark = current(self) | ||||
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) | ||
|
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 | |||
|
r7239 | repo.__class__ = bookmark_repo | ||
|
r7638 | def uisetup(ui): | ||
extensions.wrapfunction(repair, "strip", strip) | ||||
if ui.configbool('bookmarks', 'track.current'): | ||||
extensions.wrapcommand(commands.table, 'update', updatecurbookmark) | ||||
|
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')), | ||||
('r', 'rev', '', _('revision')), | ||||
('d', 'delete', False, _('delete a given bookmark')), | ||||
|
r7255 | ('m', 'rename', '', _('rename a given bookmark'))], | ||
|
r7818 | _('hg bookmarks [-f] [-d] [-m NAME] [-r REV] [NAME]')), | ||
|
r7239 | } | ||