Abort: add a hint argument, printed in the next line inside parenthesis

discovery was using a custom made message for this purpose
push now returns -1 after aborting, instead of 1 previously

mercurial/discovery.py

@@ -1,352 +1,348 b''
 # discovery.py - protocol changeset discovery functions
 #
 # Copyright 2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from node import nullid, short
 from i18n import _
 import util, error
 
 def findincoming(repo, remote, base=None, heads=None, force=False):
     """Return list of roots of the subsets of missing nodes from remote
 
     If base dict is specified, assume that these nodes and their parents
     exist on the remote side and that no child of a node of base exists
     in both remote and repo.
     Furthermore base will be updated to include the nodes that exists
     in repo and remote but no children exists in repo and remote.
     If a list of heads is specified, return only nodes which are heads
     or ancestors of these heads.
 
     All the ancestors of base are in repo and in remote.
     All the descendants of the list returned are missing in repo.
     (and so we know that the rest of the nodes are missing in remote, see
     outgoing)
     """
     return findcommonincoming(repo, remote, base, heads, force)[1]
 
 def findcommonincoming(repo, remote, base=None, heads=None, force=False):
     """Return a tuple (common, missing roots, heads) used to identify
     missing nodes from remote.
 
     If base dict is specified, assume that these nodes and their parents
     exist on the remote side and that no child of a node of base exists
     in both remote and repo.
     Furthermore base will be updated to include the nodes that exists
     in repo and remote but no children exists in both repo and remote.
     In other words, base is the set of heads of the DAG resulting from
     the intersection of the nodes from repo and remote.
     If a list of heads is specified, return only nodes which are heads
     or ancestors of these heads.
 
     All the ancestors of base are in repo and in remote.
     """
     m = repo.changelog.nodemap
     search = []
     fetch = set()
     seen = set()
     seenbranch = set()
     if base is None:
         base = {}
 
     if not heads:
         heads = remote.heads()
 
     if repo.changelog.tip() == nullid:
         base[nullid] = 1
         if heads != [nullid]:
             return [nullid], [nullid], list(heads)
         return [nullid], [], []
 
     # assume we're closer to the tip than the root
     # and start by examining the heads
     repo.ui.status(_("searching for changes\n"))
 
     unknown = []
     for h in heads:
         if h not in m:
             unknown.append(h)
         else:
             base[h] = 1
 
     heads = unknown
     if not unknown:
         return base.keys(), [], []
 
     req = set(unknown)
     reqcnt = 0
 
     # search through remote branches
     # a 'branch' here is a linear segment of history, with four parts:
     # head, root, first parent, second parent
     # (a branch always has two parents (or none) by definition)
     unknown = remote.branches(unknown)
     while unknown:
         r = []
         while unknown:
             n = unknown.pop(0)
             if n[0] in seen:
                 continue
 
             repo.ui.debug("examining %s:%s\n"
                           % (short(n[0]), short(n[1])))
             if n[0] == nullid: # found the end of the branch
                 pass
             elif n in seenbranch:
                 repo.ui.debug("branch already found\n")
                 continue
             elif n[1] and n[1] in m: # do we know the base?
                 repo.ui.debug("found incomplete branch %s:%s\n"
                               % (short(n[0]), short(n[1])))
                 search.append(n[0:2]) # schedule branch range for scanning
                 seenbranch.add(n)
             else:
                 if n[1] not in seen and n[1] not in fetch:
                     if n[2] in m and n[3] in m:
                         repo.ui.debug("found new changeset %s\n" %
                                       short(n[1]))
                         fetch.add(n[1]) # earliest unknown
                     for p in n[2:4]:
                         if p in m:
                             base[p] = 1 # latest known
 
                 for p in n[2:4]:
                     if p not in req and p not in m:
                         r.append(p)
                         req.add(p)
             seen.add(n[0])
 
         if r:
             reqcnt += 1
             repo.ui.progress(_('searching'), reqcnt, unit=_('queries'))
             repo.ui.debug("request %d: %s\n" %
                         (reqcnt, " ".join(map(short, r))))
             for p in xrange(0, len(r), 10):
                 for b in remote.branches(r[p:p + 10]):
                     repo.ui.debug("received %s:%s\n" %
                                   (short(b[0]), short(b[1])))
                     unknown.append(b)
 
     # do binary search on the branches we found
     while search:
         newsearch = []
         reqcnt += 1
         repo.ui.progress(_('searching'), reqcnt, unit=_('queries'))
         for n, l in zip(search, remote.between(search)):
             l.append(n[1])
             p = n[0]
             f = 1
             for i in l:
                 repo.ui.debug("narrowing %d:%d %s\n" % (f, len(l), short(i)))
                 if i in m:
                     if f <= 2:
                         repo.ui.debug("found new branch changeset %s\n" %
                                           short(p))
                         fetch.add(p)
                         base[i] = 1
                     else:
                         repo.ui.debug("narrowed branch search to %s:%s\n"
                                       % (short(p), short(i)))
                         newsearch.append((p, i))
                     break
                 p, f = i, f * 2
             search = newsearch
 
     # sanity check our fetch list
     for f in fetch:
         if f in m:
             raise error.RepoError(_("already have changeset ")
                                   + short(f[:4]))
 
     if base.keys() == [nullid]:
         if force:
             repo.ui.warn(_("warning: repository is unrelated\n"))
         else:
             raise util.Abort(_("repository is unrelated"))
 
     repo.ui.debug("found new changesets starting at " +
                  " ".join([short(f) for f in fetch]) + "\n")
 
     repo.ui.progress(_('searching'), None)
     repo.ui.debug("%d total queries\n" % reqcnt)
 
     return base.keys(), list(fetch), heads
 
 def findoutgoing(repo, remote, base=None, heads=None, force=False):
     """Return list of nodes that are roots of subsets not in remote
 
     If base dict is specified, assume that these nodes and their parents
     exist on the remote side.
     If a list of heads is specified, return only nodes which are heads
     or ancestors of these heads, and return a second element which
     contains all remote heads which get new children.
     """
     if base is None:
         base = {}
         findincoming(repo, remote, base, heads, force=force)
 
     repo.ui.debug("common changesets up to "
                   + " ".join(map(short, base.keys())) + "\n")
 
     remain = set(repo.changelog.nodemap)
 
     # prune everything remote has from the tree
     remain.remove(nullid)
     remove = base.keys()
     while remove:
         n = remove.pop(0)
         if n in remain:
             remain.remove(n)
             for p in repo.changelog.parents(n):
                 remove.append(p)
 
     # find every node whose parents have been pruned
     subset = []
     # find every remote head that will get new children
     updated_heads = set()
     for n in remain:
         p1, p2 = repo.changelog.parents(n)
         if p1 not in remain and p2 not in remain:
             subset.append(n)
         if heads:
             if p1 in heads:
                 updated_heads.add(p1)
             if p2 in heads:
                 updated_heads.add(p2)
 
     # this is the set of all roots we have to push
     if heads:
         return subset, list(updated_heads)
     else:
         return subset
 
 def prepush(repo, remote, force, revs, newbranch):
     '''Analyze the local and remote repositories and determine which
     changesets need to be pushed to the remote. Return value depends
     on circumstances:
 
     If we are not going to push anything, return a tuple (None,
     outgoing) where outgoing is 0 if there are no outgoing
     changesets and 1 if there are, but we refuse to push them
     (e.g. would create new remote heads).
 
     Otherwise, return a tuple (changegroup, remoteheads), where
     changegroup is a readable file-like object whose read() returns
     successive changegroup chunks ready to be sent over the wire and
     remoteheads is the list of remote heads.'''
     common = {}
     remote_heads = remote.heads()
     inc = findincoming(repo, remote, common, remote_heads, force=force)
 
     cl = repo.changelog
     update, updated_heads = findoutgoing(repo, remote, common, remote_heads)
     outg, bases, heads = cl.nodesbetween(update, revs)
 
     if not bases:
         repo.ui.status(_("no changes found\n"))
         return None, 1
 
     if not force and remote_heads != [nullid]:
 
         def fail_multiple_heads(unsynced, branch=None):
             if branch:
-                msg = _("abort: push creates new remote heads"
-                        " on branch '%s'!\n") % branch
+                msg = _("push creates new remote heads "
+                        "on branch '%s'!") % branch
             else:
-                msg = _("abort: push creates new remote heads!\n")
-            repo.ui.warn(msg)
+                msg = _("push creates new remote heads!")
+
             if unsynced:
-                repo.ui.status(_("(you should pull and merge or"
-                                 " use push -f to force)\n"))
+                hint = _("you should pull and merge or use push -f to force")
             else:
-                repo.ui.status(_("(did you forget to merge?"
-                                 " use push -f to force)\n"))
-            return None, 0
+                hint = _("did you forget to merge? use push -f to force")
+            raise util.Abort(msg, hint=hint)
 
         if remote.capable('branchmap'):
             # Check for each named branch if we're creating new remote heads.
             # To be a remote head after push, node must be either:
             # - unknown locally
             # - a local outgoing head descended from update
             # - a remote head that's known locally and not
             #   ancestral to an outgoing head
             #
             # New named branches cannot be created without --force.
 
             # 1. Create set of branches involved in the push.
             branches = set(repo[n].branch() for n in outg)
 
             # 2. Check for new branches on the remote.
             remotemap = remote.branchmap()
             newbranches = branches - set(remotemap)
             if newbranches and not newbranch: # new branch requires --new-branch
                 branchnames = ', '.join(sorted(newbranches))
-                repo.ui.warn(_("abort: push creates "
-                               "new remote branches: %s!\n")
-                             % branchnames)
-                repo.ui.status(_("(use 'hg push --new-branch' to create new "
-                                 "remote branches)\n"))
-                return None, 0
+                raise util.Abort(_("push creates new remote branches: %s!")
+                                   % branchnames,
+                                 hint=_("use 'hg push --new-branch' to create"
+                                        " new remote branches"))
             branches.difference_update(newbranches)
 
             # 3. Construct the initial oldmap and newmap dicts.
             # They contain information about the remote heads before and
             # after the push, respectively.
             # Heads not found locally are not included in either dict,
             # since they won't be affected by the push.
             # unsynced contains all branches with incoming changesets.
             oldmap = {}
             newmap = {}
             unsynced = set()
             for branch in branches:
                 remoteheads = remotemap[branch]
                 prunedheads = [h for h in remoteheads if h in cl.nodemap]
                 oldmap[branch] = prunedheads
                 newmap[branch] = list(prunedheads)
                 if len(remoteheads) > len(prunedheads):
                     unsynced.add(branch)
 
             # 4. Update newmap with outgoing changes.
             # This will possibly add new heads and remove existing ones.
             ctxgen = (repo[n] for n in outg)
             repo._updatebranchcache(newmap, ctxgen)
 
             # 5. Check for new heads.
             # If there are more heads after the push than before, a suitable
             # warning, depending on unsynced status, is displayed.
             for branch in branches:
                 if len(newmap[branch]) > len(oldmap[branch]):
                     return fail_multiple_heads(branch in unsynced, branch)
 
             # 6. Check for unsynced changes on involved branches.
             if unsynced:
                 repo.ui.warn(_("note: unsynced remote changes!\n"))
 
         else:
             # Old servers: Check for new topological heads.
             # Code based on _updatebranchcache.
             newheads = set(h for h in remote_heads if h in cl.nodemap)
             oldheadcnt = len(newheads)
             newheads.update(outg)
             if len(newheads) > 1:
                 for latest in reversed(outg):
                     if latest not in newheads:
                         continue
                     minhrev = min(cl.rev(h) for h in newheads)
                     reachable = cl.reachable(latest, cl.node(minhrev))
                     reachable.remove(latest)
                     newheads.difference_update(reachable)
             if len(newheads) > oldheadcnt:
                 return fail_multiple_heads(inc)
             if inc:
                 repo.ui.warn(_("note: unsynced remote changes!\n"))
 
     if revs is None:
         # use the fast path, no race possible on push
         nodes = repo.changelog.findmissing(common.keys())
         cg = repo._changegroup(nodes, 'push')
     else:
         cg = repo.changegroupsubset(update, revs, 'push')
     return cg, remote_heads

mercurial/dispatch.py

@@ -1,546 +1,550 b''
 # dispatch.py - command dispatching for mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from i18n import _
 import os, sys, atexit, signal, pdb, socket, errno, shlex, time, traceback
 import util, commands, hg, fancyopts, extensions, hook, error
 import cmdutil, encoding
 import ui as uimod
 
 def run():
     "run the command in sys.argv"
     sys.exit(dispatch(sys.argv[1:]))
 
 def dispatch(args):
     "run the command specified in args"
     try:
         u = uimod.ui()
         if '--traceback' in args:
             u.setconfig('ui', 'traceback', 'on')
     except util.Abort, inst:
         sys.stderr.write(_("abort: %s\n") % inst)
+        if inst.hint:
+            sys.stdout.write(_("(%s)\n") % inst.hint)
         return -1
     except error.ParseError, inst:
         if len(inst.args) > 1:
             sys.stderr.write(_("hg: parse error at %s: %s\n") %
                              (inst.args[1], inst.args[0]))
         else:
             sys.stderr.write(_("hg: parse error: %s\n") % inst.args[0])
         return -1
     return _runcatch(u, args)
 
 def _runcatch(ui, args):
     def catchterm(*args):
         raise error.SignalInterrupt
 
     try:
         for name in 'SIGBREAK', 'SIGHUP', 'SIGTERM':
             num = getattr(signal, name, None)
             if num:
                 signal.signal(num, catchterm)
     except ValueError:
         pass # happens if called in a thread
 
     try:
         try:
             # enter the debugger before command execution
             if '--debugger' in args:
                 ui.warn(_("entering debugger - "
                         "type c to continue starting hg or h for help\n"))
                 pdb.set_trace()
             try:
                 return _dispatch(ui, args)
             finally:
                 ui.flush()
         except:
             # enter the debugger when we hit an exception
             if '--debugger' in args:
                 traceback.print_exc()
                 pdb.post_mortem(sys.exc_info()[2])
             ui.traceback()
             raise
 
     # Global exception handling, alphabetically
     # Mercurial-specific first, followed by built-in and library exceptions
     except error.AmbiguousCommand, inst:
         ui.warn(_("hg: command '%s' is ambiguous:\n    %s\n") %
                 (inst.args[0], " ".join(inst.args[1])))
     except error.ParseError, inst:
         if len(inst.args) > 1:
             ui.warn(_("hg: parse error at %s: %s\n") %
                              (inst.args[1], inst.args[0]))
         else:
             ui.warn(_("hg: parse error: %s\n") % inst.args[0])
         return -1
     except error.LockHeld, inst:
         if inst.errno == errno.ETIMEDOUT:
             reason = _('timed out waiting for lock held by %s') % inst.locker
         else:
             reason = _('lock held by %s') % inst.locker
         ui.warn(_("abort: %s: %s\n") % (inst.desc or inst.filename, reason))
     except error.LockUnavailable, inst:
         ui.warn(_("abort: could not lock %s: %s\n") %
                (inst.desc or inst.filename, inst.strerror))
     except error.CommandError, inst:
         if inst.args[0]:
             ui.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1]))
             commands.help_(ui, inst.args[0])
         else:
             ui.warn(_("hg: %s\n") % inst.args[1])
             commands.help_(ui, 'shortlist')
     except error.RepoError, inst:
         ui.warn(_("abort: %s!\n") % inst)
     except error.ResponseError, inst:
         ui.warn(_("abort: %s") % inst.args[0])
         if not isinstance(inst.args[1], basestring):
             ui.warn(" %r\n" % (inst.args[1],))
         elif not inst.args[1]:
             ui.warn(_(" empty string\n"))
         else:
             ui.warn("\n%r\n" % util.ellipsis(inst.args[1]))
     except error.RevlogError, inst:
         ui.warn(_("abort: %s!\n") % inst)
     except error.SignalInterrupt:
         ui.warn(_("killed!\n"))
     except error.UnknownCommand, inst:
         ui.warn(_("hg: unknown command '%s'\n") % inst.args[0])
         try:
             # check if the command is in a disabled extension
             # (but don't check for extensions themselves)
             commands.help_(ui, inst.args[0], unknowncmd=True)
         except error.UnknownCommand:
             commands.help_(ui, 'shortlist')
     except util.Abort, inst:
         ui.warn(_("abort: %s\n") % inst)
+        if inst.hint:
+            ui.status(_("(%s)\n") % inst.hint)
     except ImportError, inst:
         ui.warn(_("abort: %s!\n") % inst)
         m = str(inst).split()[-1]
         if m in "mpatch bdiff".split():
             ui.warn(_("(did you forget to compile extensions?)\n"))
         elif m in "zlib".split():
             ui.warn(_("(is your Python install correct?)\n"))
     except IOError, inst:
         if hasattr(inst, "code"):
             ui.warn(_("abort: %s\n") % inst)
         elif hasattr(inst, "reason"):
             try: # usually it is in the form (errno, strerror)
                 reason = inst.reason.args[1]
             except: # it might be anything, for example a string
                 reason = inst.reason
             ui.warn(_("abort: error: %s\n") % reason)
         elif hasattr(inst, "args") and inst.args[0] == errno.EPIPE:
             if ui.debugflag:
                 ui.warn(_("broken pipe\n"))
         elif getattr(inst, "strerror", None):
             if getattr(inst, "filename", None):
                 ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))
             else:
                 ui.warn(_("abort: %s\n") % inst.strerror)
         else:
             raise
     except OSError, inst:
         if getattr(inst, "filename", None):
             ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))
         else:
             ui.warn(_("abort: %s\n") % inst.strerror)
     except KeyboardInterrupt:
         try:
             ui.warn(_("interrupted!\n"))
         except IOError, inst:
             if inst.errno == errno.EPIPE:
                 if ui.debugflag:
                     ui.warn(_("\nbroken pipe\n"))
             else:
                 raise
     except MemoryError:
         ui.warn(_("abort: out of memory\n"))
     except SystemExit, inst:
         # Commands shouldn't sys.exit directly, but give a return code.
         # Just in case catch this and and pass exit code to caller.
         return inst.code
     except socket.error, inst:
         ui.warn(_("abort: %s\n") % inst.args[-1])
     except:
         ui.warn(_("** unknown exception encountered, details follow\n"))
         ui.warn(_("** report bug details to "
                  "http://mercurial.selenic.com/bts/\n"))
         ui.warn(_("** or [e-mail]\n"))
         ui.warn(_("** Python %s\n") % sys.version.replace('\n', ''))
         ui.warn(_("** Mercurial Distributed SCM (version %s)\n")
                % util.version())
         ui.warn(_("** Extensions loaded: %s\n")
                % ", ".join([x[0] for x in extensions.extensions()]))
         raise
 
     return -1
 
 def aliasargs(fn):
     if hasattr(fn, 'args'):
         return fn.args
     return []
 
 class cmdalias(object):
     def __init__(self, name, definition, cmdtable):
         self.name = name
         self.definition = definition
         self.args = []
         self.opts = []
         self.help = ''
         self.norepo = True
         self.badalias = False
 
         try:
             cmdutil.findcmd(self.name, cmdtable, True)
             self.shadows = True
         except error.UnknownCommand:
             self.shadows = False
 
         if not self.definition:
             def fn(ui, *args):
                 ui.warn(_("no definition for alias '%s'\n") % self.name)
                 return 1
             self.fn = fn
             self.badalias = True
 
             return
 
         if self.definition.startswith('!'):
             def fn(ui, *args):
                 cmd = '%s %s' % (self.definition[1:], ' '.join(args))
                 return util.system(cmd)
             self.fn = fn
             return
 
         args = shlex.split(self.definition)
         cmd = args.pop(0)
         args = map(util.expandpath, args)
 
         try:
             tableentry = cmdutil.findcmd(cmd, cmdtable, False)[1]
             if len(tableentry) > 2:
                 self.fn, self.opts, self.help = tableentry
             else:
                 self.fn, self.opts = tableentry
 
             self.args = aliasargs(self.fn) + args
             if cmd not in commands.norepo.split(' '):
                 self.norepo = False
             if self.help.startswith("hg " + cmd):
                 # drop prefix in old-style help lines so hg shows the alias
                 self.help = self.help[4 + len(cmd):]
             self.__doc__ = self.fn.__doc__
 
         except error.UnknownCommand:
             def fn(ui, *args):
                 ui.warn(_("alias '%s' resolves to unknown command '%s'\n") \
                             % (self.name, cmd))
                 try:
                     # check if the command is in a disabled extension
                     commands.help_(ui, cmd, unknowncmd=True)
                 except error.UnknownCommand:
                     pass
                 return 1
             self.fn = fn
             self.badalias = True
         except error.AmbiguousCommand:
             def fn(ui, *args):
                 ui.warn(_("alias '%s' resolves to ambiguous command '%s'\n") \
                             % (self.name, cmd))
                 return 1
             self.fn = fn
             self.badalias = True
 
     def __call__(self, ui, *args, **opts):
         if self.shadows:
             ui.debug("alias '%s' shadows command\n" % self.name)
 
         return self.fn(ui, *args, **opts)
 
 def addaliases(ui, cmdtable):
     # aliases are processed after extensions have been loaded, so they
     # may use extension commands. Aliases can also use other alias definitions,
     # but only if they have been defined prior to the current definition.
     for alias, definition in ui.configitems('alias'):
         aliasdef = cmdalias(alias, definition, cmdtable)
         cmdtable[alias] = (aliasdef, aliasdef.opts, aliasdef.help)
         if aliasdef.norepo:
             commands.norepo += ' %s' % alias
 
 def _parse(ui, args):
     options = {}
     cmdoptions = {}
 
     try:
         args = fancyopts.fancyopts(args, commands.globalopts, options)
     except fancyopts.getopt.GetoptError, inst:
         raise error.CommandError(None, inst)
 
     if args:
         cmd, args = args[0], args[1:]
         aliases, entry = cmdutil.findcmd(cmd, commands.table,
                                      ui.config("ui", "strict"))
         cmd = aliases[0]
         args = aliasargs(entry[0]) + args
         defaults = ui.config("defaults", cmd)
         if defaults:
             args = map(util.expandpath, shlex.split(defaults)) + args
         c = list(entry[1])
     else:
         cmd = None
         c = []
 
     # combine global options into local
     for o in commands.globalopts:
         c.append((o[0], o[1], options[o[1]], o[3]))
 
     try:
         args = fancyopts.fancyopts(args, c, cmdoptions, True)
     except fancyopts.getopt.GetoptError, inst:
         raise error.CommandError(cmd, inst)
 
     # separate global options back out
     for o in commands.globalopts:
         n = o[1]
         options[n] = cmdoptions[n]
         del cmdoptions[n]
 
     return (cmd, cmd and entry[0] or None, args, options, cmdoptions)
 
 def _parseconfig(ui, config):
     """parse the --config options from the command line"""
     for cfg in config:
         try:
             name, value = cfg.split('=', 1)
             section, name = name.split('.', 1)
             if not section or not name:
                 raise IndexError
             ui.setconfig(section, name, value)
         except (IndexError, ValueError):
             raise util.Abort(_('malformed --config option: %r '
                                '(use --config section.name=value)') % cfg)
 
 def _earlygetopt(aliases, args):
     """Return list of values for an option (or aliases).
 
     The values are listed in the order they appear in args.
     The options and values are removed from args.
     """
     try:
         argcount = args.index("--")
     except ValueError:
         argcount = len(args)
     shortopts = [opt for opt in aliases if len(opt) == 2]
     values = []
     pos = 0
     while pos < argcount:
         if args[pos] in aliases:
             if pos + 1 >= argcount:
                 # ignore and let getopt report an error if there is no value
                 break
             del args[pos]
             values.append(args.pop(pos))
             argcount -= 2
         elif args[pos][:2] in shortopts:
             # short option can have no following space, e.g. hg log -Rfoo
             values.append(args.pop(pos)[2:])
             argcount -= 1
         else:
             pos += 1
     return values
 
 def runcommand(lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions):
     # run pre-hook, and abort if it fails
     ret = hook.hook(lui, repo, "pre-%s" % cmd, False, args=" ".join(fullargs),
                     pats=cmdpats, opts=cmdoptions)
     if ret:
         return ret
     ret = _runcommand(ui, options, cmd, d)
     # run post-hook, passing command result
     hook.hook(lui, repo, "post-%s" % cmd, False, args=" ".join(fullargs),
               result=ret, pats=cmdpats, opts=cmdoptions)
     return ret
 
 _loaded = set()
 def _dispatch(ui, args):
     # read --config before doing anything else
     # (e.g. to change trust settings for reading .hg/hgrc)
     _parseconfig(ui, _earlygetopt(['--config'], args))
 
     # check for cwd
     cwd = _earlygetopt(['--cwd'], args)
     if cwd:
         os.chdir(cwd[-1])
 
     # read the local repository .hgrc into a local ui object
     path = cmdutil.findrepo(os.getcwd()) or ""
     if not path:
         lui = ui
     else:
         try:
             lui = ui.copy()
             lui.readconfig(os.path.join(path, ".hg", "hgrc"))
         except IOError:
             pass
 
     # now we can expand paths, even ones in .hg/hgrc
     rpath = _earlygetopt(["-R", "--repository", "--repo"], args)
     if rpath:
         path = lui.expandpath(rpath[-1])
         lui = ui.copy()
         lui.readconfig(os.path.join(path, ".hg", "hgrc"))
 
     # Configure extensions in phases: uisetup, extsetup, cmdtable, and
     # reposetup. Programs like TortoiseHg will call _dispatch several
     # times so we keep track of configured extensions in _loaded.
     extensions.loadall(lui)
     exts = [ext for ext in extensions.extensions() if ext[0] not in _loaded]
     # Propagate any changes to lui.__class__ by extensions
     ui.__class__ = lui.__class__
 
     # (uisetup and extsetup are handled in extensions.loadall)
 
     for name, module in exts:
         cmdtable = getattr(module, 'cmdtable', {})
         overrides = [cmd for cmd in cmdtable if cmd in commands.table]
         if overrides:
             ui.warn(_("extension '%s' overrides commands: %s\n")
                     % (name, " ".join(overrides)))
         commands.table.update(cmdtable)
         _loaded.add(name)
 
     # (reposetup is handled in hg.repository)
 
     addaliases(lui, commands.table)
 
     # check for fallback encoding
     fallback = lui.config('ui', 'fallbackencoding')
     if fallback:
         encoding.fallbackencoding = fallback
 
     fullargs = args
     cmd, func, args, options, cmdoptions = _parse(lui, args)
 
     if options["config"]:
         raise util.Abort(_("Option --config may not be abbreviated!"))
     if options["cwd"]:
         raise util.Abort(_("Option --cwd may not be abbreviated!"))
     if options["repository"]:
         raise util.Abort(_(
             "Option -R has to be separated from other options (e.g. not -qR) "
             "and --repository may only be abbreviated as --repo!"))
 
     if options["encoding"]:
         encoding.encoding = options["encoding"]
     if options["encodingmode"]:
         encoding.encodingmode = options["encodingmode"]
     if options["time"]:
         def get_times():
             t = os.times()
             if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()
                 t = (t[0], t[1], t[2], t[3], time.clock())
             return t
         s = get_times()
         def print_time():
             t = get_times()
             ui.warn(_("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n") %
                 (t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))
         atexit.register(print_time)
 
     if options['verbose'] or options['debug'] or options['quiet']:
         ui.setconfig('ui', 'verbose', str(bool(options['verbose'])))
         ui.setconfig('ui', 'debug', str(bool(options['debug'])))
         ui.setconfig('ui', 'quiet', str(bool(options['quiet'])))
     if options['traceback']:
         ui.setconfig('ui', 'traceback', 'on')
     if options['noninteractive']:
         ui.setconfig('ui', 'interactive', 'off')
 
     if options['help']:
         return commands.help_(ui, cmd, options['version'])
     elif options['version']:
         return commands.version_(ui)
     elif not cmd:
         return commands.help_(ui, 'shortlist')
 
     repo = None
     cmdpats = args[:]
     if cmd not in commands.norepo.split():
         try:
             repo = hg.repository(ui, path=path)
             ui = repo.ui
             if not repo.local():
                 raise util.Abort(_("repository '%s' is not local") % path)
             ui.setconfig("bundle", "mainreporoot", repo.root)
         except error.RepoError:
             if cmd not in commands.optionalrepo.split():
                 if args and not path: # try to infer -R from command args
                     repos = map(cmdutil.findrepo, args)
                     guess = repos[0]
                     if guess and repos.count(guess) == len(repos):
                         return _dispatch(ui, ['--repository', guess] + fullargs)
                 if not path:
                     raise error.RepoError(_("There is no Mercurial repository"
                                       " here (.hg not found)"))
                 raise
         args.insert(0, repo)
     elif rpath:
         ui.warn("warning: --repository ignored\n")
 
     d = lambda: util.checksignature(func)(ui, *args, **cmdoptions)
     return runcommand(lui, repo, cmd, fullargs, ui, options, d,
                       cmdpats, cmdoptions)
 
 def _runcommand(ui, options, cmd, cmdfunc):
     def checkargs():
         try:
             return cmdfunc()
         except error.SignatureError:
             raise error.CommandError(cmd, _("invalid arguments"))
 
     if options['profile']:
         format = ui.config('profiling', 'format', default='text')
 
         if not format in ['text', 'kcachegrind']:
             ui.warn(_("unrecognized profiling format '%s'"
                         " - Ignored\n") % format)
             format = 'text'
 
         output = ui.config('profiling', 'output')
 
         if output:
             path = ui.expandpath(output)
             ostream = open(path, 'wb')
         else:
             ostream = sys.stderr
 
         try:
             from mercurial import lsprof
         except ImportError:
             raise util.Abort(_(
                 'lsprof not available - install from '
                 'http://codespeak.net/svn/user/arigo/hack/misc/lsprof/'))
         p = lsprof.Profiler()
         p.enable(subcalls=True)
         try:
             return checkargs()
         finally:
             p.disable()
 
             if format == 'kcachegrind':
                 import lsprofcalltree
                 calltree = lsprofcalltree.KCacheGrind(p)
                 calltree.output(ostream)
             else:
                 # format == 'text'
                 stats = lsprof.Stats(p.getstats())
                 stats.sort()
                 stats.pprint(top=10, file=ostream, climit=5)
 
             if output:
                 ostream.close()
     else:
         return checkargs()

mercurial/error.py

@@ -1,78 +1,81 b''
 # error.py - Mercurial exceptions
 #
 # Copyright 2005-2008 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """Mercurial exceptions.
 
 This allows us to catch exceptions at higher levels without forcing
 imports.
 """
 
 # Do not import anything here, please
 
 class RevlogError(Exception):
     pass
 
 class LookupError(RevlogError, KeyError):
     def __init__(self, name, index, message):
         self.name = name
         if isinstance(name, str) and len(name) == 20:
             from node import short
             name = short(name)
         RevlogError.__init__(self, '%s@%s: %s' % (index, name, message))
 
     def __str__(self):
         return RevlogError.__str__(self)
 
 class CommandError(Exception):
     """Exception raised on errors in parsing the command line."""
 
 class Abort(Exception):
     """Raised if a command needs to print an error and exit."""
+    def __init__(self, *args, **kw):
+        Exception.__init__(self, *args)
+        self.hint = kw.get('hint')
 
 class ConfigError(Abort):
     'Exception raised when parsing config files'
 
 class ParseError(Exception):
     'Exception raised when parsing config files (msg[, pos])'
 
 class RepoError(Exception):
     pass
 
 class RepoLookupError(RepoError):
     pass
 
 class CapabilityError(RepoError):
     pass
 
 class LockError(IOError):
     def __init__(self, errno, strerror, filename, desc):
         IOError.__init__(self, errno, strerror, filename)
         self.desc = desc
 
 class LockHeld(LockError):
     def __init__(self, errno, filename, desc, locker):
         LockError.__init__(self, errno, 'Lock held', filename, desc)
         self.locker = locker
 
 class LockUnavailable(LockError):
     pass
 
 class ResponseError(Exception):
     """Raised to print an error with part of output and exit."""
 
 class UnknownCommand(Exception):
     """Exception raised if command is not in the command table."""
 
 class AmbiguousCommand(Exception):
     """Exception raised if command shortcut matches more than one command."""
 
 # derived from KeyboardInterrupt to simplify some breakout code
 class SignalInterrupt(KeyboardInterrupt):
     """Exception raised on SIGTERM and SIGHUP."""
 
 class SignatureError(Exception):
     pass

tests/test-push-warn.out

@@ -1,323 +1,323 b''
 updating to branch default
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 pushing to ../a
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (you should pull and merge or use push -f to force)
 pulling from ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 pushing to ../a
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (did you forget to merge? use push -f to force)
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 pushing to ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 1 changes to 1 files
 adding foo
 updating to branch default
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 merging foo
 0 files updated, 1 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 pushing to ../c
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (did you forget to merge? use push -f to force)
-1
+255
 pushing to ../c
 searching for changes
 no changes found
 0
 pushing to ../c
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (did you forget to merge? use push -f to force)
-1
+255
 pushing to ../c
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (did you forget to merge? use push -f to force)
-1
+255
 pushing to ../c
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 2 changes to 1 files (+2 heads)
 0
 pushing to ../c
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (-1 heads)
 0
 comparing with ../c
 searching for changes
 no changes found
 % issue 450
 pushing to ../e
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 0
 pushing to ../e
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 0
 % issue 736
 % push on existing branch and new branch
 pushing to ../f
 searching for changes
 abort: push creates new remote branches: c!
 (use 'hg push --new-branch' to create new remote branches)
-1
+255
 pushing to ../f
 searching for changes
 abort: push creates new remote branches: c!
 (use 'hg push --new-branch' to create new remote branches)
-1
+255
 % multiple new branches
 pushing to ../f
 searching for changes
 abort: push creates new remote branches: c, d!
 (use 'hg push --new-branch' to create new remote branches)
-1
+255
 pushing to ../f
 searching for changes
 abort: push creates new remote branches: c, d!
 (use 'hg push --new-branch' to create new remote branches)
-1
+255
 % fail on multiple head push
 pushing to ../f
 searching for changes
 abort: push creates new remote heads on branch 'a'!
 (did you forget to merge? use push -f to force)
-1
+255
 % push replacement head on existing branches
 pushing to ../f
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 2 changes to 1 files
 0
 % merge of branch a to other branch b followed by unrelated push on branch a
 pushing to ../f
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (-1 heads)
 0
 pushing to ../f
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (+1 heads)
 0
 % cheating the counting algorithm
 pushing to ../f
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 2 changes to 1 files
 0
 % failed push of new named branch
 pushing to ../f
 searching for changes
 abort: push creates new remote branches: e!
 (use 'hg push --new-branch' to create new remote branches)
-1
+255
 % using --new-branch to push new named branch
 pushing to ../f
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 0
 % checking prepush logic does not allow silently pushing multiple new heads
 adding init
 adding a
 updating to branch default
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding b
 created new head
 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding c
 created new head
 pushing to h
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (you should pull and merge or use push -f to force)
 
 % check prepush logic with merged branches
 marked working directory as branch a
 adding foo
 updating to branch a
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 marked working directory as branch b
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 pushing to j
 searching for changes
 abort: push creates new remote branches: b!
 (use 'hg push --new-branch' to create new remote branches)
 
 % prepush -r should not allow you to sneak in new heads
 pushing to ../l
 searching for changes
 abort: push creates new remote heads on branch 'a'!
 (did you forget to merge? use push -f to force)
 % check prepush with new branch head on former topo non-head
 marked working directory as branch A
 adding a
 marked working directory as branch B
 adding b
 updating to branch B
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 adding b1
 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding a2
 %% glog of local
 @  2: A a2
 |
 | o  1: B b
 |/
 o  0: A a
 
 %% glog of remote
 @  2: B b1
 |
 o  1: B b
 |
 o  0: A a
 
 %% outgoing
 comparing with inner
 searching for changes
 2: A a2
 pushing to inner
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (+1 heads)
 % check prepush with new branch head on former topo head
 marked working directory as branch A
 adding a
 marked working directory as branch B
 adding b
 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding a1
 updating to branch A
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding b1
 adding a2
 %% glog of local
 @  3: A a2
 |
 o  2: A a1
 |
 | o  1: B b
 |/
 o  0: A a
 
 %% glog of remote
 @  3: B b1
 |
 | o  2: A a1
 | |
 o |  1: B b
 |/
 o  0: A a
 
 %% outgoing
 comparing with inner
 searching for changes
 3: A a2
 pushing to inner
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 % check prepush with new branch head and new child of former branch head
 % but child is on different branch
 marked working directory as branch A
 adding a
 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 marked working directory as branch B
 adding b
 updating to branch B
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 marked working directory as branch B
 created new head
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 marked working directory as branch A
 created new head
 %% glog of local
 @  5: A b3
 |
 | o  4: B a3
 | |
 o |  3: B b1
 | |
 o |  2: B b0
  /
 o  1: A a1
 |
 o  0: A a0
 
 %% glog of remote
 @  3: B b1
 |
 o  2: B b0
 
 o  1: A a1
 |
 o  0: A a0
 
 %% outgoing
 comparing with inner
 searching for changes
 4: B a3
 5: A b3
 pushing to inner
 searching for changes
 abort: push creates new remote heads on branch 'A'!
 (did you forget to merge? use push -f to force)
 pushing to inner
 searching for changes
 abort: push creates new remote heads on branch 'A'!
 (did you forget to merge? use push -f to force)
 comparing with inner
 searching for changes
 no changes found