mercurial-crew-with-dirclash: comparison hgext/hbisect.py

equal deleted inserted replaced

-:5b178298b7f4
+:1772852d7d14
 # Inspired by git bisect, extension skeleton taken from mq.py.
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
+from mercurial.i18n import gettext as _
 from mercurial.demandload import demandload
-demandload(globals(), "os sys sets mercurial:hg,util")
+demandload(globals(), "os sys sets mercurial:hg,util,commands")
 versionstr = "0.0.3"
 def lookup_rev(ui, repo, rev=None):
 """returns rev or the checked-out revision if rev is None"""
 if not rev is None:
 return repo.lookup(rev)
 parents = [p for p in repo.dirstate.parents() if p != hg.nullid]
 if len(parents) != 1:
-ui.warn("unexpected number of parents\n")
+raise util.Abort(_("unexpected number of parents, "
-ui.warn("please commit or revert\n")
+"please commit or revert"))
-sys.exit(1)
 return parents.pop()
 def check_clean(ui, repo):
 modified, added, removed, deleted, unknown = repo.changes()
 if modified or added or removed:
 f.write(hg.hex(self.badrev) + "\n")
 def init(self):
 """start a new bisection"""
 if os.path.isdir(self.path):
-self.ui.warn("bisect directory already exists\n")
+raise util.Abort(_("bisect directory already exists\n"))
-return 1
 os.mkdir(self.path)
 check_clean(self.ui, self.repo)
 return 0
 def reset(self):
 for p in parents:
 d[p][0] += 1
 return d
 if head in stop:
-self.ui.warn("Unconsistent state, %s is good and bad\n"
+raise util.Abort(_("Unconsistent state, %s:%s is good and bad")
-% hg.hex(head))
+% (cl.rev(head), hg.short(head)))
-sys.exit(1)
 n_child = num_children(head)
 for i in xrange(cl.rev(head)+1):
 n = cl.node(i)
 parents = [p for p in cl.parents(n) if p != hg.nullid]
 for p in parents:
 n_child[n] = len(n_child[n][1])
 return anc, n_child
 def next(self):
 if not self.badrev:
-self.ui.warn("You should give at least one bad\n")
+raise util.Abort(_("You should give at least one bad revision"))
-sys.exit(1)
 if not self.goodrevs:
-self.ui.warn("No good revision given\n")
+self.ui.warn(_("No good revision given\n"))
-self.ui.warn("Assuming the first revision is good\n")
+self.ui.warn(_("Marking the first revision as good\n"))
 ancestors, num_ancestors = self.__ancestors_and_nb_ancestors(
 self.badrev)
 tot = len(ancestors)
 if tot == 1:
 if ancestors.pop() != self.badrev:
-self.ui.warn("Could not find the first bad revision\n")
+raise util.Abort(_("Could not find the first bad revision"))
-sys.exit(1)
+self.ui.write(_("The first bad revision is:\n"))
-self.ui.write(
+displayer = commands.show_changeset(self.ui, self.repo, {})
-"The first bad revision is: %s\n" % hg.hex(self.badrev))
+displayer.show(changenode=self.badrev)
-sys.exit(0)
+return None
-self.ui.write("%d revisions left\n" % tot)
 best_rev = None
 best_len = -1
 for n in ancestors:
 l = num_ancestors[n]
 l = min(l, tot - l)
 if l > best_len:
 best_len = l
 best_rev = n
+assert best_rev is not None
+nb_tests = 0
+q, r = divmod(tot, 2)
+while q:
+nb_tests += 1
+q, r = divmod(q, 2)
+msg = _("Testing changeset %s:%s (%s changesets remaining, "
+"~%s tests)\n") % (self.repo.changelog.rev(best_rev),
+hg.short(best_rev), tot, nb_tests)
+self.ui.write(msg)
 return best_rev
 def autonext(self):
 """find and update to the next revision to test"""
 check_clean(self.ui, self.repo)
 rev = self.next()
-self.ui.write("Now testing %s\n" % hg.hex(rev))
+if rev is not None:
 return self.repo.update(rev, force=True)
 def good(self, rev):
 self.goodrevs.append(rev)
 def autogood(self, rev=None):
 """mark revision as good and update to the next revision to test"""
 check_clean(self.ui, self.repo)
 rev = lookup_rev(self.ui, self.repo, rev)
 self.good(rev)
 if self.badrev:
-self.autonext()
+return self.autonext()
 def bad(self, rev):
 self.badrev = rev
 def autobad(self, rev=None):
 ui.write("it is bad\n")
 else:
 b.good(new_rev)
 ui.write("it is good\n")
 anc = b.ancestors()
-repo.update(new_rev, force=True)
+#repo.update(new_rev, force=True)
 for v in anc:
 if v != rev:
 ui.warn("fail to found cset! :(\n")
 return 1
 ui.write("Found bad cset: %s\n" % hg.hex(b.badrev))
 doc = cmdtable[cmd][0].__doc__
 synopsis = cmdtable[cmd][2]
 ui.write(synopsis + "\n")
 ui.write("\n" + doc + "\n")
 return
-ui.write("list of subcommands for the bisect extension\n\n")
+ui.write(_("list of subcommands for the bisect extension\n\n"))
 cmds = cmdtable.keys()
 cmds.sort()
 m = max([len(c) for c in cmds])
 for cmd in cmds:
 doc = cmdtable[cmd][0].__doc__.splitlines(0)[0].rstrip()
 ui.write(" %-*s   %s\n" % (m, cmd, doc))
 b = bisect(ui, repo)
 bisectcmdtable = {
-"init": (b.init, 0, "hg bisect init"),
+"init": (b.init, 0, _("hg bisect init")),
-"bad": (b.autobad, 1, "hg bisect bad [<rev>]"),
+"bad": (b.autobad, 1, _("hg bisect bad [<rev>]")),
-"good": (b.autogood, 1, "hg bisect good [<rev>]"),
+"good": (b.autogood, 1, _("hg bisect good [<rev>]")),
-"next": (b.autonext, 0, "hg bisect next"),
+"next": (b.autonext, 0, _("hg bisect next")),
-"reset": (b.reset, 0, "hg bisect reset"),
+"reset": (b.reset, 0, _("hg bisect reset")),
-"help": (help_, 1, "hg bisect help [<subcommand>]"),
+"help": (help_, 1, _("hg bisect help [<subcommand>]")),
 }
 if not bisectcmdtable.has_key(cmd):
-ui.warn("bisect: Unknown sub-command\n")
+ui.warn(_("bisect: Unknown sub-command\n"))
 return help_()
 if len(args) > bisectcmdtable[cmd][1]:
-ui.warn("bisect: Too many arguments\n")
+ui.warn(_("bisect: Too many arguments\n"))
 return help_()
 return bisectcmdtable[cmd][0](*args)
 cmdtable = {
-"bisect": (bisect_run, [], "hg bisect [help|init|reset|next|good|bad]"),
+"bisect": (bisect_run, [], _("hg bisect [help|init|reset|next|good|bad]")),
 #"bisect-test": (test, [], "hg bisect-test rev"),
 }

changeset 2348	1772852d7d14
parent 2305	e7de4dd43472
child 2734	07026da25ed8