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