Mercurial > hg > mercurial-crew-with-dirclash
comparison hgext/hbisect.py @ 1862:b41d71961aed
Moved bisect extension to hgext folder.
author | Thomas Arendsen Hein <thomas@intevation.de> |
---|---|
date | Wed, 08 Mar 2006 19:30:30 +0100 |
parents | contrib/hbisect.py@65949d1c9bf7 |
children | e7de4dd43472 |
comparison
equal
deleted
inserted
replaced
1861:65949d1c9bf7 | 1862:b41d71961aed |
---|---|
1 # bisect extension for mercurial | |
2 # | |
3 # Copyright 2005, 2006 Benoit Boissinot <benoit.boissinot@ens-lyon.org> | |
4 # Inspired by git bisect, extension skeleton taken from mq.py. | |
5 # | |
6 # This software may be used and distributed according to the terms | |
7 # of the GNU General Public License, incorporated herein by reference. | |
8 | |
9 from mercurial.demandload import demandload | |
10 demandload(globals(), "os sys sets mercurial:hg,util") | |
11 | |
12 versionstr = "0.0.3" | |
13 | |
14 def lookup_rev(ui, repo, rev=None): | |
15 """returns rev or the checked-out revision if rev is None""" | |
16 if not rev is None: | |
17 return repo.lookup(rev) | |
18 parents = [p for p in repo.dirstate.parents() if p != hg.nullid] | |
19 if len(parents) != 1: | |
20 ui.warn("unexpected number of parents\n") | |
21 ui.warn("please commit or revert\n") | |
22 sys.exit(1) | |
23 return parents.pop() | |
24 | |
25 def check_clean(ui, repo): | |
26 modified, added, removed, deleted, unknown = repo.changes() | |
27 if modified or added or removed: | |
28 ui.warn("Repository is not clean, please commit or revert\n") | |
29 sys.exit(1) | |
30 | |
31 class bisect(object): | |
32 """dichotomic search in the DAG of changesets""" | |
33 def __init__(self, ui, repo): | |
34 self.repo = repo | |
35 self.path = repo.join("bisect") | |
36 self.opener = util.opener(self.path) | |
37 self.ui = ui | |
38 self.goodrevs = [] | |
39 self.badrev = None | |
40 self.good_dirty = 0 | |
41 self.bad_dirty = 0 | |
42 self.good_path = "good" | |
43 self.bad_path = "bad" | |
44 | |
45 if os.path.exists(os.path.join(self.path, self.good_path)): | |
46 self.goodrevs = self.opener(self.good_path).read().splitlines() | |
47 self.goodrevs = [hg.bin(x) for x in self.goodrevs] | |
48 if os.path.exists(os.path.join(self.path, self.bad_path)): | |
49 r = self.opener(self.bad_path).read().splitlines() | |
50 if r: | |
51 self.badrev = hg.bin(r.pop(0)) | |
52 | |
53 def __del__(self): | |
54 if not os.path.isdir(self.path): | |
55 return | |
56 f = self.opener(self.good_path, "w") | |
57 f.write("\n".join([hg.hex(r) for r in self.goodrevs])) | |
58 if len(self.goodrevs) > 0: | |
59 f.write("\n") | |
60 f = self.opener(self.bad_path, "w") | |
61 if self.badrev: | |
62 f.write(hg.hex(self.badrev) + "\n") | |
63 | |
64 def init(self): | |
65 """start a new bisection""" | |
66 if os.path.isdir(self.path): | |
67 self.ui.warn("bisect directory already exists\n") | |
68 return 1 | |
69 os.mkdir(self.path) | |
70 check_clean(self.ui, self.repo) | |
71 return 0 | |
72 | |
73 def reset(self): | |
74 """finish a bisection""" | |
75 if os.path.isdir(self.path): | |
76 sl = [os.path.join(self.path, p) | |
77 for p in [self.bad_path, self.good_path]] | |
78 for s in sl: | |
79 if os.path.exists(s): | |
80 os.unlink(s) | |
81 os.rmdir(self.path) | |
82 # Not sure about this | |
83 #self.ui.write("Going back to tip\n") | |
84 #self.repo.update(self.repo.changelog.tip()) | |
85 return 1 | |
86 | |
87 def num_ancestors(self, head=None, stop=None): | |
88 """ | |
89 returns a dict with the mapping: | |
90 node -> number of ancestors (self included) | |
91 for all nodes who are ancestor of head and | |
92 not in stop. | |
93 """ | |
94 if head is None: | |
95 head = self.badrev | |
96 return self.__ancestors_and_nb_ancestors(head, stop)[1] | |
97 | |
98 def ancestors(self, head=None, stop=None): | |
99 """ | |
100 returns the set of the ancestors of head (self included) | |
101 who are not in stop. | |
102 """ | |
103 if head is None: | |
104 head = self.badrev | |
105 return self.__ancestors_and_nb_ancestors(head, stop)[0] | |
106 | |
107 def __ancestors_and_nb_ancestors(self, head, stop=None): | |
108 """ | |
109 if stop is None then ancestors of goodrevs are used as | |
110 lower limit. | |
111 | |
112 returns (anc, n_child) where anc is the set of the ancestors of head | |
113 and n_child is a dictionary with the following mapping: | |
114 node -> number of ancestors (self included) | |
115 """ | |
116 cl = self.repo.changelog | |
117 if not stop: | |
118 stop = sets.Set([]) | |
119 for i in xrange(len(self.goodrevs)-1, -1, -1): | |
120 g = self.goodrevs[i] | |
121 if g in stop: | |
122 continue | |
123 stop.update(cl.reachable(g)) | |
124 def num_children(a): | |
125 """ | |
126 returns a dictionnary with the following mapping | |
127 node -> [number of children, empty set] | |
128 """ | |
129 d = {a: [0, sets.Set([])]} | |
130 for i in xrange(cl.rev(a)+1): | |
131 n = cl.node(i) | |
132 if not d.has_key(n): | |
133 d[n] = [0, sets.Set([])] | |
134 parents = [p for p in cl.parents(n) if p != hg.nullid] | |
135 for p in parents: | |
136 d[p][0] += 1 | |
137 return d | |
138 | |
139 if head in stop: | |
140 self.ui.warn("Unconsistent state, %s is good and bad\n" | |
141 % hg.hex(head)) | |
142 sys.exit(1) | |
143 n_child = num_children(head) | |
144 for i in xrange(cl.rev(head)+1): | |
145 n = cl.node(i) | |
146 parents = [p for p in cl.parents(n) if p != hg.nullid] | |
147 for p in parents: | |
148 n_child[p][0] -= 1 | |
149 if not n in stop: | |
150 n_child[n][1].union_update(n_child[p][1]) | |
151 if n_child[p][0] == 0: | |
152 n_child[p] = len(n_child[p][1]) | |
153 if not n in stop: | |
154 n_child[n][1].add(n) | |
155 if n_child[n][0] == 0: | |
156 if n == head: | |
157 anc = n_child[n][1] | |
158 n_child[n] = len(n_child[n][1]) | |
159 return anc, n_child | |
160 | |
161 def next(self): | |
162 if not self.badrev: | |
163 self.ui.warn("You should give at least one bad\n") | |
164 sys.exit(1) | |
165 if not self.goodrevs: | |
166 self.ui.warn("No good revision given\n") | |
167 self.ui.warn("Assuming the first revision is good\n") | |
168 ancestors, num_ancestors = self.__ancestors_and_nb_ancestors( | |
169 self.badrev) | |
170 tot = len(ancestors) | |
171 if tot == 1: | |
172 if ancestors.pop() != self.badrev: | |
173 self.ui.warn("Could not find the first bad revision\n") | |
174 sys.exit(1) | |
175 self.ui.write( | |
176 "The first bad revision is : %s\n" % hg.hex(self.badrev)) | |
177 sys.exit(0) | |
178 self.ui.write("%d revisions left\n" % tot) | |
179 best_rev = None | |
180 best_len = -1 | |
181 for n in ancestors: | |
182 l = num_ancestors[n] | |
183 l = min(l, tot - l) | |
184 if l > best_len: | |
185 best_len = l | |
186 best_rev = n | |
187 return best_rev | |
188 | |
189 def autonext(self): | |
190 """find and update to the next revision to test""" | |
191 check_clean(self.ui, self.repo) | |
192 rev = self.next() | |
193 self.ui.write("Now testing %s\n" % hg.hex(rev)) | |
194 return self.repo.update(rev, force=True) | |
195 | |
196 def good(self, rev): | |
197 self.goodrevs.append(rev) | |
198 | |
199 def autogood(self, rev=None): | |
200 """mark revision as good and update to the next revision to test""" | |
201 check_clean(self.ui, self.repo) | |
202 rev = lookup_rev(self.ui, self.repo, rev) | |
203 self.good(rev) | |
204 if self.badrev: | |
205 self.autonext() | |
206 | |
207 def bad(self, rev): | |
208 self.badrev = rev | |
209 | |
210 def autobad(self, rev=None): | |
211 """mark revision as bad and update to the next revision to test""" | |
212 check_clean(self.ui, self.repo) | |
213 rev = lookup_rev(self.ui, self.repo, rev) | |
214 self.bad(rev) | |
215 if self.goodrevs: | |
216 self.autonext() | |
217 | |
218 # should we put it in the class ? | |
219 def test(ui, repo, rev): | |
220 """test the bisection code""" | |
221 b = bisect(ui, repo) | |
222 rev = repo.lookup(rev) | |
223 ui.write("testing with rev %s\n" % hg.hex(rev)) | |
224 anc = b.ancestors() | |
225 while len(anc) > 1: | |
226 if not rev in anc: | |
227 ui.warn("failure while bisecting\n") | |
228 sys.exit(1) | |
229 ui.write("it worked :)\n") | |
230 new_rev = b.next() | |
231 ui.write("choosing if good or bad\n") | |
232 if rev in b.ancestors(head=new_rev): | |
233 b.bad(new_rev) | |
234 ui.write("it is bad\n") | |
235 else: | |
236 b.good(new_rev) | |
237 ui.write("it is good\n") | |
238 anc = b.ancestors() | |
239 repo.update(new_rev, force=True) | |
240 for v in anc: | |
241 if v != rev: | |
242 ui.warn("fail to found cset! :(\n") | |
243 return 1 | |
244 ui.write("Found bad cset: %s\n" % hg.hex(b.badrev)) | |
245 ui.write("Everything is ok :)\n") | |
246 return 0 | |
247 | |
248 def bisect_run(ui, repo, cmd=None, *args): | |
249 """bisect extension: dichotomic search in the DAG of changesets | |
250 for subcommands see "hg bisect help\" | |
251 """ | |
252 def help_(cmd=None, *args): | |
253 """show help for a given bisect subcommand or all subcommands""" | |
254 cmdtable = bisectcmdtable | |
255 if cmd: | |
256 doc = cmdtable[cmd][0].__doc__ | |
257 synopsis = cmdtable[cmd][2] | |
258 ui.write(synopsis + "\n") | |
259 ui.write("\n" + doc + "\n") | |
260 return | |
261 ui.write("list of subcommands for the bisect extension\n\n") | |
262 cmds = cmdtable.keys() | |
263 cmds.sort() | |
264 m = max([len(c) for c in cmds]) | |
265 for cmd in cmds: | |
266 doc = cmdtable[cmd][0].__doc__.splitlines(0)[0].rstrip() | |
267 ui.write(" %-*s %s\n" % (m, cmd, doc)) | |
268 | |
269 b = bisect(ui, repo) | |
270 bisectcmdtable = { | |
271 "init": (b.init, 0, "hg bisect init"), | |
272 "bad": (b.autobad, 1, "hg bisect bad [<rev>]"), | |
273 "good": (b.autogood, 1, "hg bisect good [<rev>]"), | |
274 "next": (b.autonext, 0, "hg bisect next"), | |
275 "reset": (b.reset, 0, "hg bisect reset"), | |
276 "help": (help_, 1, "hg bisect help [<subcommand>]"), | |
277 } | |
278 | |
279 if not bisectcmdtable.has_key(cmd): | |
280 ui.warn("bisect: Unknown sub-command\n") | |
281 return help_() | |
282 if len(args) > bisectcmdtable[cmd][1]: | |
283 ui.warn("bisect: Too many arguments\n") | |
284 return help_() | |
285 return bisectcmdtable[cmd][0](*args) | |
286 | |
287 cmdtable = { | |
288 "bisect": (bisect_run, [], "hg bisect [help|init|reset|next|good|bad]"), | |
289 #"bisect-test": (test, [], "hg bisect-test rev"), | |
290 } |