mercurial: comparison mercurial/cmdutil.py

equal deleted inserted replaced

-:d51c658d3f04
+:56b2bcea2529
 if not ui.interactive():
 if cmdsuggest:
 msg = _('running non-interactively, use %s instead') % cmdsuggest
 else:
 msg = _('running non-interactively')
-raise util.Abort(msg)
+raise error.Abort(msg)
 # make sure username is set before going interactive
 if not opts.get('user'):
 ui.username() # raise exception, username not provided
 """
 checkunfinished(repo, commit=True)
 merge = len(repo[None].parents()) > 1
 if merge:
-raise util.Abort(_('cannot partially commit a merge '
+raise error.Abort(_('cannot partially commit a merge '
 '(use "hg commit" instead)'))
 status = repo.status(match=match)
 diffopts = patch.difffeatureopts(ui, opts=opts, whitespace=True)
 diffopts.nodates = True
 # 1. filter patch, so we have intending-to apply subset of it
 try:
 chunks = filterfn(ui, originalchunks)
 except patch.PatchError as err:
-raise util.Abort(_('error parsing patch: %s') % err)
+raise error.Abort(_('error parsing patch: %s') % err)
 # We need to keep a backup of files that have been newly added and
 # modified during the recording process because there is a previous
 # version without the edit in the workdir
 newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
 try:
 ui.debug('applying patch\n')
 ui.debug(fp.getvalue())
 patch.internalpatch(ui, repo, fp, 1, eolmode=None)
 except patch.PatchError as err:
-raise util.Abort(str(err))
+raise error.Abort(str(err))
 del fp
 # 4. We prepared working directory according to filtered
 #    patch. Now is the time to delegate the job to
 #    commit/qrefresh or the like!
 return p
 def bailifchanged(repo, merge=True):
 if merge and repo.dirstate.p2() != nullid:
-raise util.Abort(_('outstanding uncommitted merge'))
+raise error.Abort(_('outstanding uncommitted merge'))
 modified, added, removed, deleted = repo.status()[:4]
 if modified or added or removed or deleted:
-raise util.Abort(_('uncommitted changes'))
+raise error.Abort(_('uncommitted changes'))
 ctx = repo[None]
 for s in sorted(ctx.substate):
 ctx.sub(s).bailifchanged()
 def logmessage(ui, opts):
 """ get the log message according to -m and -l option """
 message = opts.get('message')
 logfile = opts.get('logfile')
 if message and logfile:
-raise util.Abort(_('options --message and --logfile are mutually '
+raise error.Abort(_('options --message and --logfile are mutually '
 'exclusive'))
 if not message and logfile:
 try:
 if logfile == '-':
 message = ui.fin.read()
 else:
 message = '\n'.join(util.readfile(logfile).splitlines())
 except IOError as inst:
-raise util.Abort(_("can't read commit message '%s': %s") %
+raise error.Abort(_("can't read commit message '%s': %s") %
 (logfile, inst.strerror))
 return message
 def mergeeditform(ctxorbool, baseformname):
 """return appropriate editform name (referencing a committemplate)
 limit = opts.get('limit')
 if limit:
 try:
 limit = int(limit)
 except ValueError:
-raise util.Abort(_('limit must be a positive integer'))
+raise error.Abort(_('limit must be a positive integer'))
 if limit <= 0:
-raise util.Abort(_('limit must be positive'))
+raise error.Abort(_('limit must be positive'))
 else:
 limit = None
 return limit
 def makefilename(repo, pat, node, desc=None,
 c = expander[c]()
 newname.append(c)
 i += 1
 return ''.join(newname)
 except KeyError as inst:
-raise util.Abort(_("invalid format spec '%%%s' in output filename") %
+raise error.Abort(_("invalid format spec '%%%s' in output filename") %
 inst.args[0])
 def makefileobj(repo, pat, node=None, desc=None, total=None,
 seqno=None, revwidth=None, mode='wb', modemap=None,
 pathname=None):
 msg = _('cannot specify filename with --changelog or --manifest')
 elif not repo:
 msg = _('cannot specify --changelog or --manifest or --dir '
 'without a repository')
 if msg:
-raise util.Abort(msg)
+raise error.Abort(msg)
 r = None
 if repo:
 if cl:
 r = repo.unfiltered().changelog
 elif dir:
 if 'treemanifest' not in repo.requirements:
-raise util.Abort(_("--dir can only be used on repos with "
+raise error.Abort(_("--dir can only be used on repos with "
 "treemanifest enabled"))
 dirlog = repo.dirlog(file_)
 if len(dirlog):
 r = dirlog
 elif mf:
 r = filelog
 if not r:
 if not file_:
 raise error.CommandError(cmd, _('invalid arguments'))
 if not os.path.isfile(file_):
-raise util.Abort(_("revlog '%s' not found") % file_)
+raise error.Abort(_("revlog '%s' not found") % file_)
 r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False),
 file_[:-2] + ".i")
 return r
 def copy(ui, repo, pats, opts, rename=False):
 res = lambda p: dest
 return res
 pats = scmutil.expandpats(pats)
 if not pats:
-raise util.Abort(_('no source or destination specified'))
+raise error.Abort(_('no source or destination specified'))
 if len(pats) == 1:
-raise util.Abort(_('no destination specified'))
+raise error.Abort(_('no destination specified'))
 dest = pats.pop()
 destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
 if not destdirexists:
 if len(pats) > 1 or matchmod.patkind(pats[0]):
-raise util.Abort(_('with multiple sources, destination must be an '
+raise error.Abort(_('with multiple sources, destination must be an '
 'existing directory'))
 if util.endswithsep(dest):
-raise util.Abort(_('destination %s is not a directory') % dest)
+raise error.Abort(_('destination %s is not a directory') % dest)
 tfn = targetpathfn
 if after:
 tfn = targetpathafterfn
 copylist = []
 srcs = walkpat(pat)
 if not srcs:
 continue
 copylist.append((tfn(pat, dest, srcs), srcs))
 if not copylist:
-raise util.Abort(_('no files to copy'))
+raise error.Abort(_('no files to copy'))
 errors = 0
 for targetpath, srcs in copylist:
 for abssrc, relsrc, exact in srcs:
 if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
 break
 def condfn():
 return not os.path.exists(lockpath)
 pid = util.rundetached(runargs, condfn)
 if pid < 0:
-raise util.Abort(_('child process failed to start'))
+raise error.Abort(_('child process failed to start'))
 writepid(pid)
 finally:
 try:
 os.unlink(lockpath)
 except OSError as e:
 if len(parents) == 1:
 parents.append(repo[nullid])
 if opts.get('exact'):
 if not nodeid or not p1:
-raise util.Abort(_('not a Mercurial patch'))
+raise error.Abort(_('not a Mercurial patch'))
 p1 = repo[p1]
 p2 = repo[p2 or nullid]
 elif p2:
 try:
 p1 = repo[p1]
 try:
 patch.patch(ui, repo, tmpname, strip=strip, prefix=prefix,
 files=files, eolmode=None, similarity=sim / 100.0)
 except patch.PatchError as e:
 if not partial:
-raise util.Abort(str(e))
+raise error.Abort(str(e))
 if partial:
 rejects = True
 files = list(files)
 if opts.get('no_commit'):
 files = set()
 try:
 patch.patchrepo(ui, repo, p1, store, tmpname, strip, prefix,
 files, eolmode=None)
 except patch.PatchError as e:
-raise util.Abort(str(e))
+raise error.Abort(str(e))
 if opts.get('exact'):
 editor = None
 else:
 editor = getcommiteditor(editform='import.bypass')
 memctx = context.makememctx(repo, (p1.node(), p2.node()),
 if opts.get('exact') and opts.get('no_commit'):
 # --exact with --no-commit is still useful in that it does merge
 # and branch bits
 ui.warn(_("warning: can't check exact import with --no-commit\n"))
 elif opts.get('exact') and hex(n) != nodeid:
-raise util.Abort(_('patch is damaged or loses information'))
+raise error.Abort(_('patch is damaged or loses information'))
 if n:
 # i18n: refers to a short changeset id
 msg = _('created %s') % short(n)
 return (msg, n, rejects)
 finally:
 if not self.footer:
 self.footer = templater.stringify(
 self.t(self._parts['footer'], **props))
 except KeyError as inst:
 msg = _("%s: no key named '%s'")
-raise util.Abort(msg % (self.t.mapfile, inst.args[0]))
+raise error.Abort(msg % (self.t.mapfile, inst.args[0]))
 except SyntaxError as inst:
-raise util.Abort('%s: %s' % (self.t.mapfile, inst.args[0]))
+raise error.Abort('%s: %s' % (self.t.mapfile, inst.args[0]))
 def gettemplate(ui, tmpl, style):
 """
 Find the template matching the given template spec or style.
 """
 try:
 t = changeset_templater(ui, repo, matchfn, opts, tmpl, mapfile,
 buffered)
 except SyntaxError as inst:
-raise util.Abort(inst.args[0])
+raise error.Abort(inst.args[0])
 return t
 def showmarker(ui, marker):
 """utility function to display obsolescence marker in a readable way
 if rev in results:
 ui.status(_("found revision %s from %s\n") %
 (rev, util.datestr(results[rev])))
 return str(rev)
-raise util.Abort(_("revision matching date not found"))
+raise error.Abort(_("revision matching date not found"))
 def increasingwindows(windowsize=8, sizelimit=512):
 while True:
 yield windowsize
 if windowsize < sizelimit:
 def iterfiles():
 pctx = repo['.']
 for filename in match.files():
 if follow:
 if filename not in pctx:
-raise util.Abort(_('cannot follow file not in parent '
+raise error.Abort(_('cannot follow file not in parent '
 'revision: "%s"') % filename)
 yield filename, pctx[filename].filenode()
 else:
 yield filename, None
 for filename_node in copies:
 if not len(filelog):
 if node is None:
 # A zero count may be a directory or deleted file, so
 # try to find matching entries on the slow path.
 if follow:
-raise util.Abort(
+raise error.Abort(
 _('cannot follow nonexistent file: "%s"') % file_)
 raise FileWalkError("Cannot walk via filelog")
 else:
 continue
 if slowpath:
 # We have to read the changelog to match filenames against
 # changed files
 if follow:
-raise util.Abort(_('can only follow copies/renames for explicit '
+raise error.Abort(_('can only follow copies/renames for explicit '
 'filenames'))
 # The slow path checks files modified in every changeset.
 # This is really slow on large repos, so compute the set lazily.
 class lazywantedset(object):
 # take the slow path.
 if os.path.exists(repo.wjoin(f)):
 slowpath = True
 continue
 else:
-raise util.Abort(_('cannot follow file not in parent '
+raise error.Abort(_('cannot follow file not in parent '
 'revision: "%s"') % f)
 filelog = repo.file(f)
 if not filelog:
 # A zero count may be a directory or deleted file, so
 # try to find matching entries on the slow path.
 if follow:
-raise util.Abort(
+raise error.Abort(
 _('cannot follow nonexistent file: "%s"') % f)
 slowpath = True
 # We decided to fall back to the slowpath because at least one
 # of the paths was not a file. Check to see if at least one of them
 graphmod.asciiedges, getrenamed, filematcher)
 def checkunsupportedgraphflags(pats, opts):
 for op in ["newest_first"]:
 if op in opts and opts[op]:
-raise util.Abort(_("-G/--graph option is incompatible with --%s")
+raise error.Abort(_("-G/--graph option is incompatible with --%s")
 % op.replace("_", "-"))
 def graphrevs(repo, nodes, opts):
 limit = loglimit(opts)
 nodes.reverse()
 # extract addremove carefully -- this function can be called from a command
 # that doesn't support addremove
 if opts.get('addremove'):
 if scmutil.addremove(repo, matcher, "", opts) != 0:
-raise util.Abort(
+raise error.Abort(
 _("failed to mark all new/missing files as added/removed"))
 return commitfunc(ui, repo, message, matcher, opts)
 def amend(ui, repo, commitfunc, old, extra, pats, opts):
 os.chdir(olddir)
 if finishdesc:
 text = finishdesc(text)
 if not text.strip():
-raise util.Abort(_("empty commit message"))
+raise error.Abort(_("empty commit message"))
 return text
 def buildcommittemplate(repo, ctx, subs, extramsg, tmpl):
 ui = repo.ui
 tmpl, mapfile = gettemplate(ui, tmpl, None)
 try:
 t = changeset_templater(ui, repo, None, {}, tmpl, mapfile, False)
 except SyntaxError as inst:
-raise util.Abort(inst.args[0])
+raise error.Abort(inst.args[0])
 for k, v in repo.ui.configitems('committemplate'):
 if k != 'changeset':
 t.t.cache[k] = v
 # Revert the subrepos on the revert list
 for sub in targetsubs:
 try:
 wctx.sub(sub).revert(ctx.substate[sub], *pats, **opts)
 except KeyError:
-raise util.Abort("subrepository '%s' does not exist in %s!"
+raise error.Abort("subrepository '%s' does not exist in %s!"
 % (sub, short(ctx.node())))
 finally:
 wlock.release()
 def _revertprefetch(repo, ctx, *files):
 chunks = recordfilter(repo.ui, originalchunks)
 if reversehunks:
 chunks = patch.reversehunks(chunks)
 except patch.PatchError as err:
-raise util.Abort(_('error parsing patch: %s') % err)
+raise error.Abort(_('error parsing patch: %s') % err)
 newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
 # Apply changes
 fp = cStringIO.StringIO()
 for c in chunks:
 fp.seek(0)
 if dopatch:
 try:
 patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None)
 except patch.PatchError as err:
-raise util.Abort(str(err))
+raise error.Abort(str(err))
 del fp
 else:
 for f in actions['revert'][0]:
 checkout(f)
 if normal:
 '''
 for f, clearable, allowcommit, msg, hint in unfinishedstates:
 if commit and allowcommit:
 continue
 if repo.vfs.exists(f):
-raise util.Abort(msg, hint=hint)
+raise error.Abort(msg, hint=hint)
 def clearunfinished(repo):
 '''Check for unfinished operations (as above), and clear the ones
 that are clearable.
 '''
 for f, clearable, allowcommit, msg, hint in unfinishedstates:
 if not clearable and repo.vfs.exists(f):
-raise util.Abort(msg, hint=hint)
+raise error.Abort(msg, hint=hint)
 for f, clearable, allowcommit, msg, hint in unfinishedstates:
 if clearable and repo.vfs.exists(f):
 util.unlink(repo.join(f))
 class dirstateguard(object):
 def close(self):
 if not self._active: # already inactivated
 msg = (_("can't close already inactivated backup: %s")
 % self._filename)
-raise util.Abort(msg)
+raise error.Abort(msg)
 self._repo.vfs.unlink(self._filename)
 self._active = False
 self._closed = True
 def release(self):
 if not self._closed:
 if not self._active: # already inactivated
 msg = (_("can't release already inactivated backup: %s")
 % self._filename)
-raise util.Abort(msg)
+raise error.Abort(msg)
 self._abort()
 _bundlecompspecs = {'none': None,
 'bzip2': 'BZ',
 'gzip': 'GZ',
 elif spec in _bundlecompspecs:
 comp = spec
 elif spec in _bundleversionspecs:
 version = spec
 else:
-raise util.Abort(_('unknown bundle type specified with --type'))
+raise error.Abort(_('unknown bundle type specified with --type'))
 if comp is None:
 comp = 'BZ'
 else:
 try:
 comp = _bundlecompspecs[comp]
 except KeyError:
-raise util.Abort(_('unknown bundle type specified with --type'))
+raise error.Abort(_('unknown bundle type specified with --type'))
 if version is None:
 version = '01'
 if 'generaldelta' in repo.requirements:
 version = '02'
 else:
 try:
 version = _bundleversionspecs[version]
 except KeyError:
-raise util.Abort(_('unknown bundle type specified with --type'))
+raise error.Abort(_('unknown bundle type specified with --type'))
 return version, comp

changeset 26587	56b2bcea2529
parent 26579	dc2b8c005697
child 26632	59b5e8844eb0