bookmarks.py
322 lines
| 10.8 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 | |||
|
r7239 | '''mercurial bookmarks | ||
|
r7252 | Mercurial bookmarks are local moveable pointers 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 is forwarded to the new changeset. | ||||
|
r7239 | |||
|
r7252 | It is possible to use bookmark names in every revision lookup (e.g. hg | ||
merge, hg update). | ||||
|
r7481 | |||
|
r7984 | The bookmark extension offers the possiblity to have a more git-like | ||
experience by adding the following configuration option to your .hgrc: | ||||
|
r7481 | |||
[bookmarks] | ||||
track.current = True | ||||
|
r7984 | This will cause bookmarks to track the bookmark that you are currently | ||
on, and just updates it. This is similar to git's approach of | ||||
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: | ||||
if repo._bookmarks: | ||||
return repo._bookmarks | ||||
repo._bookmarks = {} | ||||
for line in repo.opener('bookmarks'): | ||||
sha, refspec = line.strip().split(' ', 1) | ||||
repo._bookmarks[refspec] = repo.lookup(sha) | ||||
except: | ||||
pass | ||||
return repo._bookmarks | ||||
def write(repo, refs): | ||||
'''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. | ||||
''' | ||||
|
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) | ||||
|
r7550 | file = repo.opener('bookmarks', 'w+') | ||
|
r7622 | for refspec, node in refs.iteritems(): | ||
|
r7239 | file.write("%s %s\n" % (hex(node), refspec)) | ||
file.close() | ||||
|
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 | |||
|
r7481 | refs = parse(repo) | ||
|
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 = '' | ||||
file = repo.opener('bookmarks.current', 'w+') | ||||
file.write(mark) | ||||
file.close() | ||||
repo._bookmarkcurrent = mark | ||||
|
r7255 | def bookmark(ui, repo, mark=None, rev=None, force=False, delete=False, rename=None): | ||
|
r7239 | '''mercurial bookmarks | ||
|
r7250 | |||
|
r7252 | Bookmarks are pointers to certain commits that move when | ||
commiting. Bookmarks are local. They can be renamed, copied and | ||||
|
r7984 | deleted. It is possible to use bookmark names in 'hg merge' and | ||
'hg update' to update to a given bookmark. | ||||
|
r7250 | |||
|
r7257 | You can use 'hg bookmark NAME' to set a bookmark on the current | ||
tip with the given name. If you specify a revision using -r REV | ||||
(where REV may be an existing bookmark), the bookmark is set to | ||||
that revision. | ||||
|
r7239 | ''' | ||
hexfn = ui.debugflag and hex or short | ||||
marks = parse(repo) | ||||
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) | ||||
|
r7239 | write(repo, marks) | ||
return | ||||
|
r7250 | |||
|
r7239 | if delete: | ||
if mark == None: | ||||
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] | ||
write(repo, marks) | ||||
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) | ||
|
r7239 | write(repo, marks) | ||
return | ||||
if mark == 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 ' ' | ||||
|
r7252 | 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) | ||||
marks = parse(repo) | ||||
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() | ||||
write(repo, marks) | ||||
def reposetup(ui, repo): | ||||
|
r7638 | if not isinstance(repo, localrepo.localrepository): | ||
|
r7239 | return | ||
# init a bookmark cache as otherwise we would get a infinite reading | ||||
# in lookup() | ||||
repo._bookmarks = None | ||||
|
r7481 | repo._bookmarkcurrent = None | ||
|
r7239 | |||
class bookmark_repo(repo.__class__): | ||||
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 self._bookmarks is None: | ||||
self._bookmarks = parse(self) | ||||
if key in self._bookmarks: | ||||
key = self._bookmarks[key] | ||||
return super(bookmark_repo, self).lookup(key) | ||||
def commit(self, *k, **kw): | ||||
"""Add a revision to the repository and | ||||
move the bookmark""" | ||||
node = super(bookmark_repo, self).commit(*k, **kw) | ||||
|
r7262 | if node == None: | ||
return None | ||||
|
r7239 | parents = repo.changelog.parents(node) | ||
|
r7256 | if parents[1] == nullid: | ||
parents = (parents[0],) | ||||
|
r7239 | marks = parse(repo) | ||
update = False | ||||
for mark, n in marks.items(): | ||||
|
r7481 | if ui.configbool('bookmarks', 'track.current'): | ||
if mark == current(repo) and n in parents: | ||||
marks[mark] = node | ||||
update = True | ||||
else: | ||||
if n in parents: | ||||
marks[mark] = node | ||||
update = True | ||||
|
r7239 | if update: | ||
write(repo, marks) | ||||
return node | ||||
def addchangegroup(self, source, srctype, url, emptyok=False): | ||||
|
r7316 | parents = repo.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 | ||||
node = repo.changelog.tip() | ||||
marks = parse(repo) | ||||
update = False | ||||
for mark, n in marks.items(): | ||||
|
r7316 | if n in parents: | ||
|
r7239 | marks[mark] = node | ||
update = True | ||||
if update: | ||||
write(repo, marks) | ||||
return result | ||||
|
r7480 | def tags(self): | ||
"""Merge bookmarks with normal tags""" | ||||
if self.tagscache: | ||||
return self.tagscache | ||||
tagscache = super(bookmark_repo, self).tags() | ||||
tagscache.update(parse(repo)) | ||||
return tagscache | ||||
|
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 | } | ||