|
@@
-1,234
+1,231
b''
|
|
1
|
# Mercurial extension to provide the 'hg bookmark' command
|
|
1
|
# Mercurial extension to provide the 'hg bookmark' command
|
|
2
|
#
|
|
2
|
#
|
|
3
|
# Copyright 2008 David Soria Parra <dsp@php.net>
|
|
3
|
# Copyright 2008 David Soria Parra <dsp@php.net>
|
|
4
|
#
|
|
4
|
#
|
|
5
|
# This software may be used and distributed according to the terms
|
|
5
|
# This software may be used and distributed according to the terms
|
|
6
|
# of the GNU General Public License, incorporated herein by reference.
|
|
6
|
# of the GNU General Public License, incorporated herein by reference.
|
|
7
|
|
|
7
|
|
|
8
|
'''mercurial bookmarks
|
|
8
|
'''mercurial bookmarks
|
|
9
|
|
|
9
|
|
|
10
|
Mercurial bookmarks are local moveable pointers to changesets. Every
|
|
10
|
Mercurial bookmarks are local moveable pointers to changesets. Every
|
|
11
|
bookmark points to a changeset identified by its hash. If you commit a
|
|
11
|
bookmark points to a changeset identified by its hash. If you commit a
|
|
12
|
changeset that is based on a changeset that has a bookmark on it, the
|
|
12
|
changeset that is based on a changeset that has a bookmark on it, the
|
|
13
|
bookmark is forwarded to the new changeset.
|
|
13
|
bookmark is forwarded to the new changeset.
|
|
14
|
|
|
14
|
|
|
15
|
It is possible to use bookmark names in every revision lookup (e.g. hg
|
|
15
|
It is possible to use bookmark names in every revision lookup (e.g. hg
|
|
16
|
merge, hg update).
|
|
16
|
merge, hg update).
|
|
17
|
'''
|
|
17
|
'''
|
|
18
|
|
|
18
|
|
|
19
|
from mercurial.commands import templateopts, hex, short
|
|
19
|
from mercurial.commands import templateopts, hex, short
|
|
20
|
from mercurial.i18n import _
|
|
20
|
from mercurial.i18n import _
|
|
21
|
from mercurial import cmdutil, util, commands, changelog
|
|
21
|
from mercurial import cmdutil, util, commands, changelog
|
|
22
|
from mercurial.node import nullid, nullrev
|
|
22
|
from mercurial.node import nullid, nullrev
|
|
23
|
from mercurial.repo import RepoError
|
|
23
|
from mercurial.repo import RepoError
|
|
24
|
import mercurial, mercurial.localrepo, mercurial.repair, os
|
|
24
|
import mercurial, mercurial.localrepo, mercurial.repair, os
|
|
25
|
|
|
25
|
|
|
26
|
def parse(repo):
|
|
26
|
def parse(repo):
|
|
27
|
'''Parse .hg/bookmarks file and return a dictionary
|
|
27
|
'''Parse .hg/bookmarks file and return a dictionary
|
|
28
|
|
|
28
|
|
|
29
|
Bookmarks are stored as {HASH}\s{NAME}\n (localtags format) values
|
|
29
|
Bookmarks are stored as {HASH}\s{NAME}\n (localtags format) values
|
|
30
|
in the .hg/bookmarks file. They are read by the parse() method and
|
|
30
|
in the .hg/bookmarks file. They are read by the parse() method and
|
|
31
|
returned as a dictionary with name => hash values.
|
|
31
|
returned as a dictionary with name => hash values.
|
|
32
|
|
|
32
|
|
|
33
|
The parsed dictionary is cached until a write() operation is done.
|
|
33
|
The parsed dictionary is cached until a write() operation is done.
|
|
34
|
'''
|
|
34
|
'''
|
|
35
|
try:
|
|
35
|
try:
|
|
36
|
if repo._bookmarks:
|
|
36
|
if repo._bookmarks:
|
|
37
|
return repo._bookmarks
|
|
37
|
return repo._bookmarks
|
|
38
|
repo._bookmarks = {}
|
|
38
|
repo._bookmarks = {}
|
|
39
|
for line in repo.opener('bookmarks'):
|
|
39
|
for line in repo.opener('bookmarks'):
|
|
40
|
sha, refspec = line.strip().split(' ', 1)
|
|
40
|
sha, refspec = line.strip().split(' ', 1)
|
|
41
|
repo._bookmarks[refspec] = repo.lookup(sha)
|
|
41
|
repo._bookmarks[refspec] = repo.lookup(sha)
|
|
42
|
except:
|
|
42
|
except:
|
|
43
|
pass
|
|
43
|
pass
|
|
44
|
return repo._bookmarks
|
|
44
|
return repo._bookmarks
|
|
45
|
|
|
45
|
|
|
46
|
def write(repo, refs):
|
|
46
|
def write(repo, refs):
|
|
47
|
'''Write bookmarks
|
|
47
|
'''Write bookmarks
|
|
48
|
|
|
48
|
|
|
49
|
Write the given bookmark => hash dictionary to the .hg/bookmarks file
|
|
49
|
Write the given bookmark => hash dictionary to the .hg/bookmarks file
|
|
50
|
in a format equal to those of localtags.
|
|
50
|
in a format equal to those of localtags.
|
|
51
|
|
|
51
|
|
|
52
|
We also store a backup of the previous state in undo.bookmarks that
|
|
52
|
We also store a backup of the previous state in undo.bookmarks that
|
|
53
|
can be copied back on rollback.
|
|
53
|
can be copied back on rollback.
|
|
54
|
'''
|
|
54
|
'''
|
|
55
|
if os.path.exists(repo.join('bookmarks')):
|
|
55
|
if os.path.exists(repo.join('bookmarks')):
|
|
56
|
util.copyfile(repo.join('bookmarks'), repo.join('undo.bookmarks'))
|
|
56
|
util.copyfile(repo.join('bookmarks'), repo.join('undo.bookmarks'))
|
|
57
|
file = repo.opener('bookmarks', 'w+')
|
|
57
|
file = repo.opener('bookmarks', 'w+')
|
|
58
|
for refspec, node in refs.items():
|
|
58
|
for refspec, node in refs.items():
|
|
59
|
file.write("%s %s\n" % (hex(node), refspec))
|
|
59
|
file.write("%s %s\n" % (hex(node), refspec))
|
|
60
|
file.close()
|
|
60
|
file.close()
|
|
61
|
|
|
61
|
|
|
62
|
def bookmark(ui, repo, mark=None, rev=None, force=False, delete=False, rename=None):
|
|
62
|
def bookmark(ui, repo, mark=None, rev=None, force=False, delete=False, rename=None):
|
|
63
|
'''mercurial bookmarks
|
|
63
|
'''mercurial bookmarks
|
|
64
|
|
|
64
|
|
|
65
|
Bookmarks are pointers to certain commits that move when
|
|
65
|
Bookmarks are pointers to certain commits that move when
|
|
66
|
commiting. Bookmarks are local. They can be renamed, copied and
|
|
66
|
commiting. Bookmarks are local. They can be renamed, copied and
|
|
67
|
deleted. It is possible to use bookmark names in 'hg merge' and 'hg
|
|
67
|
deleted. It is possible to use bookmark names in 'hg merge' and 'hg
|
|
68
|
update' to update to a given bookmark.
|
|
68
|
update' to update to a given bookmark.
|
|
69
|
|
|
69
|
|
|
70
|
You can use 'hg bookmark NAME' to set a bookmark on the current
|
|
70
|
You can use 'hg bookmark NAME' to set a bookmark on the current
|
|
71
|
tip with the given name. If you specify a revision using -r REV
|
|
71
|
tip with the given name. If you specify a revision using -r REV
|
|
72
|
(where REV may be an existing bookmark), the bookmark is set to
|
|
72
|
(where REV may be an existing bookmark), the bookmark is set to
|
|
73
|
that revision.
|
|
73
|
that revision.
|
|
74
|
'''
|
|
74
|
'''
|
|
75
|
hexfn = ui.debugflag and hex or short
|
|
75
|
hexfn = ui.debugflag and hex or short
|
|
76
|
marks = parse(repo)
|
|
76
|
marks = parse(repo)
|
|
77
|
cur = repo.changectx('.').node()
|
|
77
|
cur = repo.changectx('.').node()
|
|
78
|
|
|
78
|
|
|
79
|
if rename:
|
|
79
|
if rename:
|
|
80
|
if rename not in marks:
|
|
80
|
if rename not in marks:
|
|
81
|
raise util.Abort(_("a bookmark of this name does not exist"))
|
|
81
|
raise util.Abort(_("a bookmark of this name does not exist"))
|
|
82
|
if mark in marks and not force:
|
|
82
|
if mark in marks and not force:
|
|
83
|
raise util.Abort(_("a bookmark of the same name already exists"))
|
|
83
|
raise util.Abort(_("a bookmark of the same name already exists"))
|
|
84
|
if mark is None:
|
|
84
|
if mark is None:
|
|
85
|
raise util.Abort(_("new bookmark name required"))
|
|
85
|
raise util.Abort(_("new bookmark name required"))
|
|
86
|
marks[mark] = marks[rename]
|
|
86
|
marks[mark] = marks[rename]
|
|
87
|
del marks[rename]
|
|
87
|
del marks[rename]
|
|
88
|
write(repo, marks)
|
|
88
|
write(repo, marks)
|
|
89
|
return
|
|
89
|
return
|
|
90
|
|
|
90
|
|
|
91
|
if delete:
|
|
91
|
if delete:
|
|
92
|
if mark == None:
|
|
92
|
if mark == None:
|
|
93
|
raise util.Abort(_("bookmark name required"))
|
|
93
|
raise util.Abort(_("bookmark name required"))
|
|
94
|
if mark not in marks:
|
|
94
|
if mark not in marks:
|
|
95
|
raise util.Abort(_("a bookmark of this name does not exist"))
|
|
95
|
raise util.Abort(_("a bookmark of this name does not exist"))
|
|
96
|
del marks[mark]
|
|
96
|
del marks[mark]
|
|
97
|
write(repo, marks)
|
|
97
|
write(repo, marks)
|
|
98
|
return
|
|
98
|
return
|
|
99
|
|
|
99
|
|
|
100
|
if mark != None:
|
|
100
|
if mark != None:
|
|
101
|
if "\n" in mark:
|
|
101
|
if "\n" in mark:
|
|
102
|
raise util.Abort(_("bookmark name cannot contain newlines"))
|
|
102
|
raise util.Abort(_("bookmark name cannot contain newlines"))
|
|
103
|
mark = mark.strip()
|
|
103
|
mark = mark.strip()
|
|
104
|
if mark in marks and not force:
|
|
104
|
if mark in marks and not force:
|
|
105
|
raise util.Abort(_("a bookmark of the same name already exists"))
|
|
105
|
raise util.Abort(_("a bookmark of the same name already exists"))
|
|
106
|
if ((mark in repo.branchtags() or mark == repo.dirstate.branch())
|
|
106
|
if ((mark in repo.branchtags() or mark == repo.dirstate.branch())
|
|
107
|
and not force):
|
|
107
|
and not force):
|
|
108
|
raise util.Abort(
|
|
108
|
raise util.Abort(
|
|
109
|
_("a bookmark cannot have the name of an existing branch"))
|
|
109
|
_("a bookmark cannot have the name of an existing branch"))
|
|
110
|
if rev:
|
|
110
|
if rev:
|
|
111
|
marks[mark] = repo.lookup(rev)
|
|
111
|
marks[mark] = repo.lookup(rev)
|
|
112
|
else:
|
|
112
|
else:
|
|
113
|
marks[mark] = repo.changectx('.').node()
|
|
113
|
marks[mark] = repo.changectx('.').node()
|
|
114
|
write(repo, marks)
|
|
114
|
write(repo, marks)
|
|
115
|
return
|
|
115
|
return
|
|
116
|
|
|
116
|
|
|
117
|
if mark == None:
|
|
117
|
if mark == None:
|
|
118
|
if rev:
|
|
118
|
if rev:
|
|
119
|
raise util.Abort(_("bookmark name required"))
|
|
119
|
raise util.Abort(_("bookmark name required"))
|
|
120
|
if len(marks) == 0:
|
|
120
|
if len(marks) == 0:
|
|
121
|
ui.status("no bookmarks set\n")
|
|
121
|
ui.status("no bookmarks set\n")
|
|
122
|
else:
|
|
122
|
else:
|
|
123
|
for bmark, n in marks.iteritems():
|
|
123
|
for bmark, n in marks.iteritems():
|
|
124
|
prefix = (n == cur) and '*' or ' '
|
|
124
|
prefix = (n == cur) and '*' or ' '
|
|
125
|
ui.write(" %s %-25s %d:%s\n" % (
|
|
125
|
ui.write(" %s %-25s %d:%s\n" % (
|
|
126
|
prefix, bmark, repo.changelog.rev(n), hexfn(n)))
|
|
126
|
prefix, bmark, repo.changelog.rev(n), hexfn(n)))
|
|
127
|
return
|
|
127
|
return
|
|
128
|
|
|
128
|
|
|
129
|
def _revstostrip(changelog, node):
|
|
129
|
def _revstostrip(changelog, node):
|
|
130
|
srev = changelog.rev(node)
|
|
130
|
srev = changelog.rev(node)
|
|
131
|
tostrip = [srev]
|
|
131
|
tostrip = [srev]
|
|
132
|
saveheads = []
|
|
132
|
saveheads = []
|
|
133
|
for r in xrange(srev, len(changelog)):
|
|
133
|
for r in xrange(srev, len(changelog)):
|
|
134
|
parents = changelog.parentrevs(r)
|
|
134
|
parents = changelog.parentrevs(r)
|
|
135
|
if parents[0] in tostrip or parents[1] in tostrip:
|
|
135
|
if parents[0] in tostrip or parents[1] in tostrip:
|
|
136
|
tostrip.append(r)
|
|
136
|
tostrip.append(r)
|
|
137
|
if parents[1] != nullrev:
|
|
137
|
if parents[1] != nullrev:
|
|
138
|
for p in parents:
|
|
138
|
for p in parents:
|
|
139
|
if p not in tostrip and p > srev:
|
|
139
|
if p not in tostrip and p > srev:
|
|
140
|
saveheads.append(p)
|
|
140
|
saveheads.append(p)
|
|
141
|
return [r for r in tostrip if r not in saveheads]
|
|
141
|
return [r for r in tostrip if r not in saveheads]
|
|
142
|
|
|
142
|
|
|
143
|
def strip(ui, repo, node, backup="all"):
|
|
143
|
def strip(ui, repo, node, backup="all"):
|
|
144
|
"""Strip bookmarks if revisions are stripped using
|
|
144
|
"""Strip bookmarks if revisions are stripped using
|
|
145
|
the mercurial.strip method. This usually happens during
|
|
145
|
the mercurial.strip method. This usually happens during
|
|
146
|
qpush and qpop"""
|
|
146
|
qpush and qpop"""
|
|
147
|
revisions = _revstostrip(repo.changelog, node)
|
|
147
|
revisions = _revstostrip(repo.changelog, node)
|
|
148
|
marks = parse(repo)
|
|
148
|
marks = parse(repo)
|
|
149
|
update = []
|
|
149
|
update = []
|
|
150
|
for mark, n in marks.items():
|
|
150
|
for mark, n in marks.items():
|
|
151
|
if repo.changelog.rev(n) in revisions:
|
|
151
|
if repo.changelog.rev(n) in revisions:
|
|
152
|
update.append(mark)
|
|
152
|
update.append(mark)
|
|
153
|
oldstrip(ui, repo, node, backup)
|
|
153
|
oldstrip(ui, repo, node, backup)
|
|
154
|
if len(update) > 0:
|
|
154
|
if len(update) > 0:
|
|
155
|
for m in update:
|
|
155
|
for m in update:
|
|
156
|
marks[m] = repo.changectx('.').node()
|
|
156
|
marks[m] = repo.changectx('.').node()
|
|
157
|
write(repo, marks)
|
|
157
|
write(repo, marks)
|
|
158
|
|
|
158
|
|
|
159
|
oldstrip = mercurial.repair.strip
|
|
159
|
oldstrip = mercurial.repair.strip
|
|
160
|
mercurial.repair.strip = strip
|
|
160
|
mercurial.repair.strip = strip
|
|
161
|
|
|
161
|
|
|
162
|
def reposetup(ui, repo):
|
|
162
|
def reposetup(ui, repo):
|
|
163
|
if not isinstance(repo, mercurial.localrepo.localrepository):
|
|
163
|
if not isinstance(repo, mercurial.localrepo.localrepository):
|
|
164
|
return
|
|
164
|
return
|
|
165
|
|
|
165
|
|
|
166
|
# init a bookmark cache as otherwise we would get a infinite reading
|
|
166
|
# init a bookmark cache as otherwise we would get a infinite reading
|
|
167
|
# in lookup()
|
|
167
|
# in lookup()
|
|
168
|
repo._bookmarks = None
|
|
168
|
repo._bookmarks = None
|
|
169
|
|
|
169
|
|
|
170
|
class bookmark_repo(repo.__class__):
|
|
170
|
class bookmark_repo(repo.__class__):
|
|
171
|
def rollback(self):
|
|
171
|
def rollback(self):
|
|
172
|
if os.path.exists(self.join('undo.bookmarks')):
|
|
172
|
if os.path.exists(self.join('undo.bookmarks')):
|
|
173
|
util.rename(self.join('undo.bookmarks'), self.join('bookmarks'))
|
|
173
|
util.rename(self.join('undo.bookmarks'), self.join('bookmarks'))
|
|
174
|
return super(bookmark_repo, self).rollback()
|
|
174
|
return super(bookmark_repo, self).rollback()
|
|
175
|
|
|
175
|
|
|
176
|
def lookup(self, key):
|
|
176
|
def lookup(self, key):
|
|
177
|
if self._bookmarks is None:
|
|
177
|
if self._bookmarks is None:
|
|
178
|
self._bookmarks = parse(self)
|
|
178
|
self._bookmarks = parse(self)
|
|
179
|
if key in self._bookmarks:
|
|
179
|
if key in self._bookmarks:
|
|
180
|
key = self._bookmarks[key]
|
|
180
|
key = self._bookmarks[key]
|
|
181
|
return super(bookmark_repo, self).lookup(key)
|
|
181
|
return super(bookmark_repo, self).lookup(key)
|
|
182
|
|
|
182
|
|
|
183
|
def commit(self, *k, **kw):
|
|
183
|
def commit(self, *k, **kw):
|
|
184
|
"""Add a revision to the repository and
|
|
184
|
"""Add a revision to the repository and
|
|
185
|
move the bookmark"""
|
|
185
|
move the bookmark"""
|
|
186
|
node = super(bookmark_repo, self).commit(*k, **kw)
|
|
186
|
node = super(bookmark_repo, self).commit(*k, **kw)
|
|
187
|
if node == None:
|
|
187
|
if node == None:
|
|
188
|
return None
|
|
188
|
return None
|
|
189
|
parents = repo.changelog.parents(node)
|
|
189
|
parents = repo.changelog.parents(node)
|
|
190
|
if parents[1] == nullid:
|
|
190
|
if parents[1] == nullid:
|
|
191
|
parents = (parents[0],)
|
|
191
|
parents = (parents[0],)
|
|
192
|
marks = parse(repo)
|
|
192
|
marks = parse(repo)
|
|
193
|
update = False
|
|
193
|
update = False
|
|
194
|
for mark, n in marks.items():
|
|
194
|
for mark, n in marks.items():
|
|
195
|
if n in parents:
|
|
195
|
if n in parents:
|
|
196
|
marks[mark] = node
|
|
196
|
marks[mark] = node
|
|
197
|
update = True
|
|
197
|
update = True
|
|
198
|
if update:
|
|
198
|
if update:
|
|
199
|
write(repo, marks)
|
|
199
|
write(repo, marks)
|
|
200
|
return node
|
|
200
|
return node
|
|
201
|
|
|
201
|
|
|
202
|
def addchangegroup(self, source, srctype, url, emptyok=False):
|
|
202
|
def addchangegroup(self, source, srctype, url, emptyok=False):
|
|
203
|
try:
|
|
203
|
parents = repo.dirstate.parents()
|
|
204
|
onode = repo.changectx('.').node()
|
|
|
|
|
205
|
except RepoError, inst:
|
|
|
|
|
206
|
pass
|
|
|
|
|
207
|
|
|
204
|
|
|
208
|
result = super(bookmark_repo, self).addchangegroup(
|
|
205
|
result = super(bookmark_repo, self).addchangegroup(
|
|
209
|
source, srctype, url, emptyok)
|
|
206
|
source, srctype, url, emptyok)
|
|
210
|
if result > 1:
|
|
207
|
if result > 1:
|
|
211
|
# We have more heads than before
|
|
208
|
# We have more heads than before
|
|
212
|
return result
|
|
209
|
return result
|
|
213
|
node = repo.changelog.tip()
|
|
210
|
node = repo.changelog.tip()
|
|
214
|
marks = parse(repo)
|
|
211
|
marks = parse(repo)
|
|
215
|
update = False
|
|
212
|
update = False
|
|
216
|
for mark, n in marks.items():
|
|
213
|
for mark, n in marks.items():
|
|
217
|
if n == onode:
|
|
214
|
if n in parents:
|
|
218
|
marks[mark] = node
|
|
215
|
marks[mark] = node
|
|
219
|
update = True
|
|
216
|
update = True
|
|
220
|
if update:
|
|
217
|
if update:
|
|
221
|
write(repo, marks)
|
|
218
|
write(repo, marks)
|
|
222
|
return result
|
|
219
|
return result
|
|
223
|
|
|
220
|
|
|
224
|
repo.__class__ = bookmark_repo
|
|
221
|
repo.__class__ = bookmark_repo
|
|
225
|
|
|
222
|
|
|
226
|
cmdtable = {
|
|
223
|
cmdtable = {
|
|
227
|
"bookmarks":
|
|
224
|
"bookmarks":
|
|
228
|
(bookmark,
|
|
225
|
(bookmark,
|
|
229
|
[('f', 'force', False, _('force')),
|
|
226
|
[('f', 'force', False, _('force')),
|
|
230
|
('r', 'rev', '', _('revision')),
|
|
227
|
('r', 'rev', '', _('revision')),
|
|
231
|
('d', 'delete', False, _('delete a given bookmark')),
|
|
228
|
('d', 'delete', False, _('delete a given bookmark')),
|
|
232
|
('m', 'rename', '', _('rename a given bookmark'))],
|
|
229
|
('m', 'rename', '', _('rename a given bookmark'))],
|
|
233
|
_('hg bookmarks [-d] [-m NAME] [-r NAME] [NAME]')),
|
|
230
|
_('hg bookmarks [-d] [-m NAME] [-r NAME] [NAME]')),
|
|
234
|
}
|
|
231
|
}
|