cmdutil.py
2935 lines
| 106.5 KiB
| text/x-python
|
PythonLexer
/ mercurial / cmdutil.py
|
r2957 | # cmdutil.py - help for command processing in mercurial | ||
|
r2874 | # | ||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r2874 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r2874 | |||
|
r6211 | from node import hex, nullid, nullrev, short | ||
|
r3891 | from i18n import _ | ||
|
r14269 | import os, sys, errno, re, tempfile | ||
|
r15214 | import util, scmutil, templater, patch, error, templatekw, revlog, copies | ||
|
r12085 | import match as matchmod | ||
|
r20392 | import context, repair, graphmod, revset, phases, obsolete, pathutil | ||
|
r17811 | import changelog | ||
|
r18538 | import bookmarks | ||
|
r22427 | import encoding | ||
|
r17471 | import lock as lockmod | ||
|
r2874 | |||
|
r10401 | def parsealiases(cmd): | ||
return cmd.lstrip("^").split("|") | ||||
|
r7213 | def findpossible(cmd, table, strict=False): | ||
|
r4549 | """ | ||
Return cmd -> (aliases, command table entry) | ||||
for each matching command. | ||||
Return debug commands (or their aliases) only if no normal command matches. | ||||
""" | ||||
choice = {} | ||||
debugchoice = {} | ||||
|
r15600 | |||
if cmd in table: | ||||
# short-circuit exact matches, "log" alias beats "^log|history" | ||||
keys = [cmd] | ||||
else: | ||||
keys = table.keys() | ||||
for e in keys: | ||||
|
r10401 | aliases = parsealiases(e) | ||
|
r4549 | found = None | ||
if cmd in aliases: | ||||
found = cmd | ||||
|
r7213 | elif not strict: | ||
|
r4549 | for a in aliases: | ||
if a.startswith(cmd): | ||||
found = a | ||||
break | ||||
if found is not None: | ||||
if aliases[0].startswith("debug") or found.startswith("debug"): | ||||
|
r5178 | debugchoice[found] = (aliases, table[e]) | ||
|
r4549 | else: | ||
|
r5178 | choice[found] = (aliases, table[e]) | ||
|
r4549 | |||
if not choice and debugchoice: | ||||
choice = debugchoice | ||||
return choice | ||||
|
r7213 | def findcmd(cmd, table, strict=True): | ||
|
r4549 | """Return (aliases, command table entry) for command string.""" | ||
|
r7213 | choice = findpossible(cmd, table, strict) | ||
|
r4549 | |||
|
r5915 | if cmd in choice: | ||
|
r4549 | return choice[cmd] | ||
if len(choice) > 1: | ||||
clist = choice.keys() | ||||
clist.sort() | ||||
|
r7643 | raise error.AmbiguousCommand(cmd, clist) | ||
|
r4549 | |||
if choice: | ||||
return choice.values()[0] | ||||
|
r7643 | raise error.UnknownCommand(cmd) | ||
|
r4549 | |||
|
r10402 | def findrepo(p): | ||
while not os.path.isdir(os.path.join(p, ".hg")): | ||||
oldp, p = p, os.path.dirname(p) | ||||
if p == oldp: | ||||
return None | ||||
return p | ||||
|
r14289 | def bailifchanged(repo): | ||
|
r13878 | if repo.dirstate.p2() != nullid: | ||
|
r5716 | raise util.Abort(_('outstanding uncommitted merge')) | ||
|
r4549 | modified, added, removed, deleted = repo.status()[:4] | ||
if modified or added or removed or deleted: | ||||
|
r19804 | raise util.Abort(_('uncommitted changes')) | ||
|
r15231 | ctx = repo[None] | ||
|
r18364 | for s in sorted(ctx.substate): | ||
|
r15231 | if ctx.sub(s).dirty(): | ||
raise util.Abort(_("uncommitted changes in subrepo %s") % s) | ||||
|
r4549 | |||
|
r14635 | def logmessage(ui, opts): | ||
|
r4549 | """ get the log message according to -m and -l option """ | ||
|
r7667 | message = opts.get('message') | ||
logfile = opts.get('logfile') | ||||
|
r4549 | |||
if message and logfile: | ||||
raise util.Abort(_('options --message and --logfile are mutually ' | ||||
'exclusive')) | ||||
if not message and logfile: | ||||
try: | ||||
if logfile == '-': | ||||
|
r14635 | message = ui.fin.read() | ||
|
r4549 | else: | ||
|
r14249 | message = '\n'.join(util.readfile(logfile).splitlines()) | ||
|
r4549 | except IOError, inst: | ||
raise util.Abort(_("can't read commit message '%s': %s") % | ||||
(logfile, inst.strerror)) | ||||
return message | ||||
|
r22248 | def mergeeditform(ctxorbool, baseform): | ||
"""build appropriate editform from ctxorbool and baseform | ||||
|
r23139 | 'ctxorbool' is one of a ctx to be committed, or a bool whether | ||
|
r22248 | merging is committed. | ||
This returns editform 'baseform' with '.merge' if merging is | ||||
committed, or one with '.normal' suffix otherwise. | ||||
""" | ||||
if isinstance(ctxorbool, bool): | ||||
if ctxorbool: | ||||
return baseform + ".merge" | ||||
elif 1 < len(ctxorbool.parents()): | ||||
return baseform + ".merge" | ||||
return baseform + ".normal" | ||||
|
r21999 | def getcommiteditor(edit=False, finishdesc=None, extramsg=None, | ||
editform='', **opts): | ||||
|
r21419 | """get appropriate commit message editor according to '--edit' option | ||
'finishdesc' is a function to be called with edited commit message | ||||
(= 'description' of the new changeset) just after editing, but | ||||
before checking empty-ness. It should return actual text to be | ||||
stored into history. This allows to change description before | ||||
storing. | ||||
'extramsg' is a extra message to be shown in the editor instead of | ||||
'Leave message empty to abort commit' line. 'HG: ' prefix and EOL | ||||
is automatically added. | ||||
|
r21999 | 'editform' is a dot-separated list of names, to distinguish | ||
the purpose of commit text editing. | ||||
|
r21419 | 'getcommiteditor' returns 'commitforceeditor' regardless of | ||
'edit', if one of 'finishdesc' or 'extramsg' is specified, because | ||||
they are specific for usage in MQ. | ||||
""" | ||||
if edit or finishdesc or extramsg: | ||||
return lambda r, c, s: commitforceeditor(r, c, s, | ||||
finishdesc=finishdesc, | ||||
|
r21999 | extramsg=extramsg, | ||
editform=editform) | ||||
elif editform: | ||||
return lambda r, c, s: commiteditor(r, c, s, editform=editform) | ||||
|
r21405 | else: | ||
return commiteditor | ||||
|
r6190 | def loglimit(opts): | ||
"""get the log limit according to option -l/--limit""" | ||||
limit = opts.get('limit') | ||||
if limit: | ||||
try: | ||||
limit = int(limit) | ||||
except ValueError: | ||||
raise util.Abort(_('limit must be a positive integer')) | ||||
|
r10282 | if limit <= 0: | ||
raise util.Abort(_('limit must be positive')) | ||||
|
r6190 | else: | ||
|
r10111 | limit = None | ||
|
r6190 | return limit | ||
|
r14986 | def makefilename(repo, pat, node, desc=None, | ||
|
r2874 | total=None, seqno=None, revwidth=None, pathname=None): | ||
node_expander = { | ||||
'H': lambda: hex(node), | ||||
'R': lambda: str(repo.changelog.rev(node)), | ||||
'h': lambda: short(node), | ||||
|
r14986 | 'm': lambda: re.sub('[^\w]', '_', str(desc)) | ||
|
r2874 | } | ||
expander = { | ||||
'%': lambda: '%', | ||||
'b': lambda: os.path.basename(repo.root), | ||||
} | ||||
try: | ||||
if node: | ||||
expander.update(node_expander) | ||||
|
r4836 | if node: | ||
|
r2874 | expander['r'] = (lambda: | ||
|
r4836 | str(repo.changelog.rev(node)).zfill(revwidth or 0)) | ||
|
r2874 | if total is not None: | ||
expander['N'] = lambda: str(total) | ||||
if seqno is not None: | ||||
expander['n'] = lambda: str(seqno) | ||||
if total is not None and seqno is not None: | ||||
|
r3673 | expander['n'] = lambda: str(seqno).zfill(len(str(total))) | ||
|
r2874 | if pathname is not None: | ||
expander['s'] = lambda: os.path.basename(pathname) | ||||
expander['d'] = lambda: os.path.dirname(pathname) or '.' | ||||
expander['p'] = lambda: pathname | ||||
newname = [] | ||||
patlen = len(pat) | ||||
i = 0 | ||||
while i < patlen: | ||||
c = pat[i] | ||||
if c == '%': | ||||
i += 1 | ||||
c = pat[i] | ||||
c = expander[c]() | ||||
newname.append(c) | ||||
i += 1 | ||||
return ''.join(newname) | ||||
except KeyError, inst: | ||||
|
r8761 | raise util.Abort(_("invalid format spec '%%%s' in output filename") % | ||
|
r3072 | inst.args[0]) | ||
|
r2874 | |||
|
r14986 | def makefileobj(repo, pat, node=None, desc=None, total=None, | ||
|
r19944 | seqno=None, revwidth=None, mode='wb', modemap=None, | ||
|
r18613 | pathname=None): | ||
|
r7319 | |||
|
r13769 | writable = mode not in ('r', 'rb') | ||
|
r7319 | |||
|
r2874 | if not pat or pat == '-': | ||
|
r14637 | fp = writable and repo.ui.fout or repo.ui.fin | ||
|
r14948 | if util.safehasattr(fp, 'fileno'): | ||
|
r14638 | return os.fdopen(os.dup(fp.fileno()), mode) | ||
else: | ||||
# if this fp can't be duped properly, return | ||||
# a dummy object that can be closed | ||||
class wrappedfileobj(object): | ||||
noop = lambda x: None | ||||
def __init__(self, f): | ||||
self.f = f | ||||
def __getattr__(self, attr): | ||||
if attr == 'close': | ||||
return self.noop | ||||
else: | ||||
return getattr(self.f, attr) | ||||
return wrappedfileobj(fp) | ||||
|
r14948 | if util.safehasattr(pat, 'write') and writable: | ||
|
r2874 | return pat | ||
|
r14948 | if util.safehasattr(pat, 'read') and 'r' in mode: | ||
|
r2874 | return pat | ||
|
r18613 | fn = makefilename(repo, pat, node, desc, total, seqno, revwidth, pathname) | ||
|
r19944 | if modemap is not None: | ||
mode = modemap.get(fn, mode) | ||||
if mode == 'wb': | ||||
modemap[fn] = 'ab' | ||||
|
r18613 | return open(fn, mode) | ||
|
r2882 | |||
|
r14323 | def openrevlog(repo, cmd, file_, opts): | ||
"""opens the changelog, manifest, a filelog or a given revlog""" | ||||
cl = opts['changelog'] | ||||
mf = opts['manifest'] | ||||
msg = None | ||||
if cl and mf: | ||||
msg = _('cannot specify --changelog and --manifest at the same time') | ||||
elif cl or mf: | ||||
if file_: | ||||
msg = _('cannot specify filename with --changelog or --manifest') | ||||
elif not repo: | ||||
msg = _('cannot specify --changelog or --manifest ' | ||||
'without a repository') | ||||
if msg: | ||||
raise util.Abort(msg) | ||||
r = None | ||||
if repo: | ||||
if cl: | ||||
|
r21033 | r = repo.unfiltered().changelog | ||
|
r14323 | elif mf: | ||
r = repo.manifest | ||||
elif file_: | ||||
filelog = repo.file(file_) | ||||
if len(filelog): | ||||
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_) | ||||
r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), | ||||
file_[:-2] + ".i") | ||||
return r | ||||
|
r5610 | def copy(ui, repo, pats, opts, rename=False): | ||
|
r5589 | # called with the repo lock held | ||
# | ||||
# hgsep => pathname that uses "/" to separate directories | ||||
# ossep => pathname that uses os.sep to separate directories | ||||
cwd = repo.getcwd() | ||||
targets = {} | ||||
|
r5607 | after = opts.get("after") | ||
dryrun = opts.get("dry_run") | ||||
|
r11303 | wctx = repo[None] | ||
|
r5589 | |||
|
r5605 | def walkpat(pat): | ||
srcs = [] | ||||
|
r11223 | badstates = after and '?' or '?r' | ||
|
r14671 | m = scmutil.match(repo[None], [pat], opts, globbed=True) | ||
|
r6586 | for abs in repo.walk(m): | ||
|
r5605 | state = repo.dirstate[abs] | ||
|
r6584 | rel = m.rel(abs) | ||
exact = m.exact(abs) | ||||
|
r11223 | if state in badstates: | ||
|
r5605 | if exact and state == '?': | ||
ui.warn(_('%s: not copying - file is not managed\n') % rel) | ||||
if exact and state == 'r': | ||||
ui.warn(_('%s: not copying - file has been marked for' | ||||
' remove\n') % rel) | ||||
continue | ||||
# abs: hgsep | ||||
# rel: ossep | ||||
srcs.append((abs, rel, exact)) | ||||
return srcs | ||||
|
r5589 | |||
# abssrc: hgsep | ||||
# relsrc: ossep | ||||
# otarget: ossep | ||||
|
r5605 | def copyfile(abssrc, relsrc, otarget, exact): | ||
|
r20033 | abstarget = pathutil.canonpath(repo.root, cwd, otarget) | ||
|
r16542 | if '/' in abstarget: | ||
# We cannot normalize abstarget itself, this would prevent | ||||
# case only renames, like a => A. | ||||
abspath, absname = abstarget.rsplit('/', 1) | ||||
abstarget = repo.dirstate.normalize(abspath) + '/' + absname | ||||
|
r5589 | reltarget = repo.pathto(abstarget, cwd) | ||
|
r5607 | target = repo.wjoin(abstarget) | ||
|
r5589 | src = repo.wjoin(abssrc) | ||
|
r5608 | state = repo.dirstate[abstarget] | ||
|
r5607 | |||
|
r13962 | scmutil.checkportable(ui, abstarget) | ||
|
r13945 | |||
|
r5607 | # check for collisions | ||
prevsrc = targets.get(abstarget) | ||||
|
r5589 | if prevsrc is not None: | ||
ui.warn(_('%s: not overwriting - %s collides with %s\n') % | ||||
(reltarget, repo.pathto(abssrc, cwd), | ||||
repo.pathto(prevsrc, cwd))) | ||||
return | ||||
|
r5607 | |||
# check for overwrites | ||||
|
r12342 | exists = os.path.lexists(target) | ||
|
r16283 | samefile = False | ||
if exists and abssrc != abstarget: | ||||
if (repo.dirstate.normalize(abssrc) == | ||||
repo.dirstate.normalize(abstarget)): | ||||
if not rename: | ||||
ui.warn(_("%s: can't copy - same file\n") % reltarget) | ||||
return | ||||
exists = False | ||||
samefile = True | ||||
|
r8117 | if not after and exists or after and state in 'mn': | ||
|
r5589 | if not opts['force']: | ||
ui.warn(_('%s: not overwriting - file exists\n') % | ||||
reltarget) | ||||
return | ||||
|
r5607 | |||
if after: | ||||
|
r5608 | if not exists: | ||
|
r11152 | if rename: | ||
ui.warn(_('%s: not recording move - %s does not exist\n') % | ||||
(relsrc, reltarget)) | ||||
else: | ||||
ui.warn(_('%s: not recording copy - %s does not exist\n') % | ||||
(relsrc, reltarget)) | ||||
|
r5589 | return | ||
|
r5608 | elif not dryrun: | ||
|
r5589 | try: | ||
|
r5608 | if exists: | ||
os.unlink(target) | ||||
targetdir = os.path.dirname(target) or '.' | ||||
if not os.path.isdir(targetdir): | ||||
os.makedirs(targetdir) | ||||
|
r16283 | if samefile: | ||
tmp = target + "~hgrename" | ||||
os.rename(src, tmp) | ||||
os.rename(tmp, target) | ||||
else: | ||||
util.copyfile(src, target) | ||||
|
r14518 | srcexists = True | ||
|
r5589 | except IOError, inst: | ||
if inst.errno == errno.ENOENT: | ||||
ui.warn(_('%s: deleted in working copy\n') % relsrc) | ||||
|
r14518 | srcexists = False | ||
|
r5589 | else: | ||
ui.warn(_('%s: cannot copy - %s\n') % | ||||
(relsrc, inst.strerror)) | ||||
|
r5606 | return True # report a failure | ||
|
r5607 | |||
|
r5589 | if ui.verbose or not exact: | ||
|
r7894 | if rename: | ||
ui.status(_('moving %s to %s\n') % (relsrc, reltarget)) | ||||
else: | ||||
ui.status(_('copying %s to %s\n') % (relsrc, reltarget)) | ||||
|
r5608 | |||
|
r5589 | targets[abstarget] = abssrc | ||
|
r5607 | |||
# fix up dirstate | ||||
|
r14321 | scmutil.dirstatecopy(ui, repo, wctx, abssrc, abstarget, | ||
dryrun=dryrun, cwd=cwd) | ||||
|
r5610 | if rename and not dryrun: | ||
|
r16283 | if not after and srcexists and not samefile: | ||
|
r14518 | util.unlinkpath(repo.wjoin(abssrc)) | ||
wctx.forget([abssrc]) | ||||
|
r5589 | |||
# pat: ossep | ||||
# dest ossep | ||||
# srcs: list of (hgsep, hgsep, ossep, bool) | ||||
# return: function that takes hgsep and returns ossep | ||||
def targetpathfn(pat, dest, srcs): | ||||
if os.path.isdir(pat): | ||||
|
r20033 | abspfx = pathutil.canonpath(repo.root, cwd, pat) | ||
|
r5589 | abspfx = util.localpath(abspfx) | ||
if destdirexists: | ||||
striplen = len(os.path.split(abspfx)[0]) | ||||
else: | ||||
striplen = len(abspfx) | ||||
if striplen: | ||||
striplen += len(os.sep) | ||||
res = lambda p: os.path.join(dest, util.localpath(p)[striplen:]) | ||||
elif destdirexists: | ||||
res = lambda p: os.path.join(dest, | ||||
os.path.basename(util.localpath(p))) | ||||
else: | ||||
res = lambda p: dest | ||||
return res | ||||
# pat: ossep | ||||
# dest ossep | ||||
# srcs: list of (hgsep, hgsep, ossep, bool) | ||||
# return: function that takes hgsep and returns ossep | ||||
def targetpathafterfn(pat, dest, srcs): | ||||
|
r12085 | if matchmod.patkind(pat): | ||
|
r5589 | # a mercurial pattern | ||
res = lambda p: os.path.join(dest, | ||||
os.path.basename(util.localpath(p))) | ||||
else: | ||||
|
r20033 | abspfx = pathutil.canonpath(repo.root, cwd, pat) | ||
|
r5589 | if len(abspfx) < len(srcs[0][0]): | ||
# A directory. Either the target path contains the last | ||||
# component of the source path or it does not. | ||||
def evalpath(striplen): | ||||
score = 0 | ||||
for s in srcs: | ||||
t = os.path.join(dest, util.localpath(s[0])[striplen:]) | ||||
|
r12357 | if os.path.lexists(t): | ||
|
r5589 | score += 1 | ||
return score | ||||
abspfx = util.localpath(abspfx) | ||||
striplen = len(abspfx) | ||||
if striplen: | ||||
striplen += len(os.sep) | ||||
if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])): | ||||
score = evalpath(striplen) | ||||
striplen1 = len(os.path.split(abspfx)[0]) | ||||
if striplen1: | ||||
striplen1 += len(os.sep) | ||||
if evalpath(striplen1) > score: | ||||
striplen = striplen1 | ||||
res = lambda p: os.path.join(dest, | ||||
util.localpath(p)[striplen:]) | ||||
else: | ||||
# a file | ||||
if destdirexists: | ||||
res = lambda p: os.path.join(dest, | ||||
os.path.basename(util.localpath(p))) | ||||
else: | ||||
res = lambda p: dest | ||||
return res | ||||
|
r14321 | pats = scmutil.expandpats(pats) | ||
|
r5589 | if not pats: | ||
raise util.Abort(_('no source or destination specified')) | ||||
if len(pats) == 1: | ||||
raise util.Abort(_('no destination specified')) | ||||
dest = pats.pop() | ||||
|
r6258 | destdirexists = os.path.isdir(dest) and not os.path.islink(dest) | ||
|
r5589 | if not destdirexists: | ||
|
r12085 | if len(pats) > 1 or matchmod.patkind(pats[0]): | ||
|
r5589 | raise util.Abort(_('with multiple sources, destination must be an ' | ||
'existing directory')) | ||||
|
r5843 | if util.endswithsep(dest): | ||
|
r5589 | raise util.Abort(_('destination %s is not a directory') % dest) | ||
|
r5607 | |||
tfn = targetpathfn | ||||
if after: | ||||
|
r5589 | tfn = targetpathafterfn | ||
copylist = [] | ||||
for pat in pats: | ||||
|
r5605 | srcs = walkpat(pat) | ||
|
r5589 | if not srcs: | ||
continue | ||||
copylist.append((tfn(pat, dest, srcs), srcs)) | ||||
if not copylist: | ||||
raise util.Abort(_('no files to copy')) | ||||
|
r5606 | errors = 0 | ||
|
r5589 | for targetpath, srcs in copylist: | ||
|
r5605 | for abssrc, relsrc, exact in srcs: | ||
|
r5606 | if copyfile(abssrc, relsrc, targetpath(abssrc), exact): | ||
errors += 1 | ||||
|
r5589 | |||
if errors: | ||||
ui.warn(_('(consider using --after)\n')) | ||||
|
r5609 | |||
|
r11177 | return errors != 0 | ||
|
r5589 | |||
|
r9513 | def service(opts, parentfn=None, initfn=None, runfn=None, logfile=None, | ||
|
r10012 | runargs=None, appendpid=False): | ||
|
r4380 | '''Run a command as a service.''' | ||
|
r19867 | def writepid(pid): | ||
if opts['pid_file']: | ||||
mode = appendpid and 'a' or 'w' | ||||
fp = open(opts['pid_file'], mode) | ||||
fp.write(str(pid) + '\n') | ||||
fp.close() | ||||
|
r4380 | if opts['daemon'] and not opts['daemon_pipefds']: | ||
|
r10238 | # Signal child process startup with file removal | ||
lockfd, lockpath = tempfile.mkstemp(prefix='hg-service-') | ||||
|
r10282 | os.close(lockfd) | ||
|
r10238 | try: | ||
if not runargs: | ||||
|
r10239 | runargs = util.hgcmd() + sys.argv[1:] | ||
|
r10238 | runargs.append('--daemon-pipefds=%s' % lockpath) | ||
# Don't pass --cwd to the child process, because we've already | ||||
# changed directory. | ||||
|
r10282 | for i in xrange(1, len(runargs)): | ||
|
r10238 | if runargs[i].startswith('--cwd='): | ||
del runargs[i] | ||||
break | ||||
elif runargs[i].startswith('--cwd'): | ||||
|
r10282 | del runargs[i:i + 2] | ||
|
r10238 | break | ||
|
r10344 | def condfn(): | ||
return not os.path.exists(lockpath) | ||||
pid = util.rundetached(runargs, condfn) | ||||
if pid < 0: | ||||
raise util.Abort(_('child process failed to start')) | ||||
|
r19868 | writepid(pid) | ||
|
r10238 | finally: | ||
try: | ||||
os.unlink(lockpath) | ||||
except OSError, e: | ||||
if e.errno != errno.ENOENT: | ||||
raise | ||||
|
r4380 | if parentfn: | ||
return parentfn(pid) | ||||
else: | ||||
|
r9896 | return | ||
|
r4380 | |||
if initfn: | ||||
initfn() | ||||
|
r19868 | if not opts['daemon']: | ||
writepid(os.getpid()) | ||||
|
r4380 | |||
if opts['daemon_pipefds']: | ||||
|
r10238 | lockpath = opts['daemon_pipefds'] | ||
|
r4380 | try: | ||
os.setsid() | ||||
except AttributeError: | ||||
pass | ||||
|
r10238 | os.unlink(lockpath) | ||
|
r10240 | util.hidewindow() | ||
|
r4380 | sys.stdout.flush() | ||
sys.stderr.flush() | ||||
|
r8789 | |||
|
r17391 | nullfd = os.open(os.devnull, os.O_RDWR) | ||
|
r8789 | logfilefd = nullfd | ||
if logfile: | ||||
logfilefd = os.open(logfile, os.O_RDWR | os.O_CREAT | os.O_APPEND) | ||||
os.dup2(nullfd, 0) | ||||
os.dup2(logfilefd, 1) | ||||
os.dup2(logfilefd, 2) | ||||
if nullfd not in (0, 1, 2): | ||||
os.close(nullfd) | ||||
if logfile and logfilefd not in (0, 1, 2): | ||||
os.close(logfilefd) | ||||
|
r4380 | |||
if runfn: | ||||
return runfn() | ||||
|
r20500 | def tryimportone(ui, repo, hunk, parents, opts, msgs, updatefunc): | ||
"""Utility function used by commands.import to import a single patch | ||||
This function is explicitly defined here to help the evolve extension to | ||||
wrap this part of the import logic. | ||||
The API is currently a bit ugly because it a simple code translation from | ||||
the import command. Feel free to make it better. | ||||
:hunk: a patch (as a binary string) | ||||
:parents: nodes that will be parent of the created commit | ||||
:opts: the full dict of option passed to the import command | ||||
:msgs: list to save commit message to. | ||||
(used in case we need to save it when failing) | ||||
:updatefunc: a function that update a repo to a given node | ||||
updatefunc(<repo>, <node>) | ||||
""" | ||||
tmpname, message, user, date, branch, nodeid, p1, p2 = \ | ||||
patch.extract(ui, hunk) | ||||
update = not opts.get('bypass') | ||||
strip = opts["strip"] | ||||
sim = float(opts.get('similarity') or 0) | ||||
if not tmpname: | ||||
|
r21553 | return (None, None, False) | ||
|
r20500 | msg = _('applied to working directory') | ||
|
r21553 | rejects = False | ||
|
r20500 | try: | ||
cmdline_message = logmessage(ui, opts) | ||||
if cmdline_message: | ||||
# pickup the cmdline msg | ||||
message = cmdline_message | ||||
elif message: | ||||
# pickup the patch msg | ||||
message = message.strip() | ||||
else: | ||||
# launch the editor | ||||
message = None | ||||
ui.debug('message:\n%s\n' % message) | ||||
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')) | ||||
p1 = repo[p1] | ||||
p2 = repo[p2 or nullid] | ||||
elif p2: | ||||
try: | ||||
p1 = repo[p1] | ||||
p2 = repo[p2] | ||||
# Without any options, consider p2 only if the | ||||
# patch is being applied on top of the recorded | ||||
# first parent. | ||||
if p1 != parents[0]: | ||||
p1 = parents[0] | ||||
p2 = repo[nullid] | ||||
except error.RepoError: | ||||
p1, p2 = parents | ||||
|
r22303 | if p2.node() == nullid: | ||
ui.warn(_("warning: import the patch as a normal revision\n" | ||||
"(use --exact to import the patch as a merge)\n")) | ||||
|
r20500 | else: | ||
p1, p2 = parents | ||||
n = None | ||||
if update: | ||||
|
r22405 | repo.dirstate.beginparentchange() | ||
|
r20500 | if p1 != parents[0]: | ||
updatefunc(repo, p1.node()) | ||||
if p2 != parents[1]: | ||||
repo.setparents(p1.node(), p2.node()) | ||||
if opts.get('exact') or opts.get('import_branch'): | ||||
repo.dirstate.setbranch(branch or 'default') | ||||
|
r21553 | partial = opts.get('partial', False) | ||
|
r20500 | files = set() | ||
|
r21553 | try: | ||
patch.patch(ui, repo, tmpname, strip=strip, files=files, | ||||
eolmode=None, similarity=sim / 100.0) | ||||
except patch.PatchError, e: | ||||
if not partial: | ||||
raise util.Abort(str(e)) | ||||
if partial: | ||||
rejects = True | ||||
|
r20500 | files = list(files) | ||
if opts.get('no_commit'): | ||||
if message: | ||||
msgs.append(message) | ||||
else: | ||||
if opts.get('exact') or p2: | ||||
# If you got here, you either use --force and know what | ||||
# you are doing or used --exact or a merge patch while | ||||
# being updated to its first parent. | ||||
m = None | ||||
else: | ||||
m = scmutil.matchfiles(repo, files or []) | ||||
|
r22250 | editform = mergeeditform(repo[None], 'import.normal') | ||
|
r22278 | if opts.get('exact'): | ||
editor = None | ||||
else: | ||||
editor = getcommiteditor(editform=editform, **opts) | ||||
|
r20500 | n = repo.commit(message, opts.get('user') or user, | ||
opts.get('date') or date, match=m, | ||||
|
r21553 | editor=editor, force=partial) | ||
|
r22405 | repo.dirstate.endparentchange() | ||
|
r20500 | else: | ||
if opts.get('exact') or opts.get('import_branch'): | ||||
branch = branch or 'default' | ||||
else: | ||||
branch = p1.branch() | ||||
store = patch.filestore() | ||||
try: | ||||
files = set() | ||||
try: | ||||
patch.patchrepo(ui, repo, p1, store, tmpname, strip, | ||||
files, eolmode=None) | ||||
except patch.PatchError, e: | ||||
raise util.Abort(str(e)) | ||||
|
r22278 | if opts.get('exact'): | ||
editor = None | ||||
else: | ||||
editor = getcommiteditor(editform='import.bypass') | ||||
|
r20500 | memctx = context.makememctx(repo, (p1.node(), p2.node()), | ||
message, | ||||
opts.get('user') or user, | ||||
opts.get('date') or date, | ||||
branch, files, store, | ||||
|
r22011 | editor=editor) | ||
|
r20500 | n = memctx.commit() | ||
finally: | ||||
store.close() | ||||
|
r22485 | 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: | ||||
|
r20500 | raise util.Abort(_('patch is damaged or loses information')) | ||
if n: | ||||
# i18n: refers to a short changeset id | ||||
msg = _('created %s') % short(n) | ||||
|
r21553 | return (msg, n, rejects) | ||
|
r20500 | finally: | ||
os.unlink(tmpname) | ||||
|
r10611 | def export(repo, revs, template='hg-%h.patch', fp=None, switch_parent=False, | ||
opts=None): | ||||
'''export changesets as hg patches.''' | ||||
total = len(revs) | ||||
revwidth = max([len(str(rev)) for rev in revs]) | ||||
|
r18613 | filemode = {} | ||
|
r10611 | |||
def single(rev, seqno, fp): | ||||
ctx = repo[rev] | ||||
node = ctx.node() | ||||
parents = [p.node() for p in ctx.parents() if p] | ||||
branch = ctx.branch() | ||||
if switch_parent: | ||||
parents.reverse() | ||||
prev = (parents and parents[0]) or nullid | ||||
|
r13400 | shouldclose = False | ||
|
r17460 | if not fp and len(template) > 0: | ||
|
r14986 | desc_lines = ctx.description().rstrip().split('\n') | ||
desc = desc_lines[0] #Commit always has a first line. | ||||
fp = makefileobj(repo, template, node, desc=desc, total=total, | ||||
|
r18613 | seqno=seqno, revwidth=revwidth, mode='wb', | ||
modemap=filemode) | ||||
|
r13467 | if fp != template: | ||
shouldclose = True | ||||
|
r17460 | if fp and fp != sys.stdout and util.safehasattr(fp, 'name'): | ||
|
r10611 | repo.ui.note("%s\n" % fp.name) | ||
|
r17460 | if not fp: | ||
write = repo.ui.write | ||||
else: | ||||
def write(s, **kw): | ||||
fp.write(s) | ||||
write("# HG changeset patch\n") | ||||
write("# User %s\n" % ctx.user()) | ||||
write("# Date %d %d\n" % ctx.date()) | ||||
|
r18648 | write("# %s\n" % util.datestr(ctx.date())) | ||
|
r11821 | if branch and branch != 'default': | ||
|
r17460 | write("# Branch %s\n" % branch) | ||
write("# Node ID %s\n" % hex(node)) | ||||
write("# Parent %s\n" % hex(prev)) | ||||
|
r10611 | if len(parents) > 1: | ||
|
r17460 | write("# Parent %s\n" % hex(parents[1])) | ||
write(ctx.description().rstrip()) | ||||
write("\n\n") | ||||
|
r10611 | |||
|
r17460 | for chunk, label in patch.diffui(repo, prev, node, opts=opts): | ||
write(chunk, label=label) | ||||
|
r10611 | |||
|
r13400 | if shouldclose: | ||
fp.close() | ||||
|
r13081 | |||
|
r10611 | for seqno, rev in enumerate(revs): | ||
single(rev, seqno + 1, fp) | ||||
|
r11050 | def diffordiffstat(ui, repo, diffopts, node1, node2, match, | ||
|
r12167 | changes=None, stat=False, fp=None, prefix='', | ||
listsubrepos=False): | ||||
|
r11050 | '''show diff or diffstat.''' | ||
if fp is None: | ||||
write = ui.write | ||||
else: | ||||
def write(s, **kw): | ||||
fp.write(s) | ||||
if stat: | ||||
|
r11950 | diffopts = diffopts.copy(context=0) | ||
|
r11050 | width = 80 | ||
if not ui.plain(): | ||||
|
r12689 | width = ui.termwidth() | ||
|
r12167 | chunks = patch.diff(repo, node1, node2, match, changes, diffopts, | ||
prefix=prefix) | ||||
|
r11050 | for chunk, label in patch.diffstatui(util.iterlines(chunks), | ||
width=width, | ||||
git=diffopts.git): | ||||
write(chunk, label=label) | ||||
else: | ||||
for chunk, label in patch.diffui(repo, node1, node2, match, | ||||
|
r12167 | changes, diffopts, prefix=prefix): | ||
|
r11050 | write(chunk, label=label) | ||
|
r12167 | if listsubrepos: | ||
ctx1 = repo[node1] | ||||
|
r12175 | ctx2 = repo[node2] | ||
|
r20392 | for subpath, sub in scmutil.itersubrepos(ctx1, ctx2): | ||
|
r15698 | tempnode2 = node2 | ||
|
r15634 | try: | ||
if node2 is not None: | ||||
|
r15698 | tempnode2 = ctx2.substate[subpath][1] | ||
|
r15634 | except KeyError: | ||
# A subrepo that existed in node1 was deleted between node1 and | ||||
# node2 (inclusive). Thus, ctx2's substate won't contain that | ||||
# subpath. The best we can do is to ignore it. | ||||
|
r15698 | tempnode2 = None | ||
|
r12167 | submatch = matchmod.narrowmatcher(subpath, match) | ||
|
r18006 | sub.diff(ui, diffopts, tempnode2, submatch, changes=changes, | ||
|
r12167 | stat=stat, fp=fp, prefix=prefix) | ||
|
r3643 | class changeset_printer(object): | ||
'''show changeset information when templating not requested.''' | ||||
|
r22386 | def __init__(self, ui, repo, matchfn, diffopts, buffered): | ||
|
r3643 | self.ui = ui | ||
self.repo = repo | ||||
|
r3645 | self.buffered = buffered | ||
|
r22386 | self.matchfn = matchfn | ||
|
r7762 | self.diffopts = diffopts | ||
|
r3738 | self.header = {} | ||
self.hunk = {} | ||||
self.lastheader = None | ||||
|
r10152 | self.footer = None | ||
|
r3645 | |||
def flush(self, rev): | ||||
|
r3738 | if rev in self.header: | ||
h = self.header[rev] | ||||
if h != self.lastheader: | ||||
self.lastheader = h | ||||
self.ui.write(h) | ||||
del self.header[rev] | ||||
if rev in self.hunk: | ||||
self.ui.write(self.hunk[rev]) | ||||
del self.hunk[rev] | ||||
return 1 | ||||
return 0 | ||||
|
r3643 | |||
|
r10152 | def close(self): | ||
if self.footer: | ||||
self.ui.write(self.footer) | ||||
|
r11488 | def show(self, ctx, copies=None, matchfn=None, **props): | ||
|
r3738 | if self.buffered: | ||
self.ui.pushbuffer() | ||||
|
r11488 | self._show(ctx, copies, matchfn, props) | ||
|
r10819 | self.hunk[ctx.rev()] = self.ui.popbuffer(labeled=True) | ||
|
r3738 | else: | ||
|
r11488 | self._show(ctx, copies, matchfn, props) | ||
|
r3738 | |||
|
r11488 | def _show(self, ctx, copies, matchfn, props): | ||
|
r3643 | '''show a single changeset or file revision''' | ||
|
r7369 | changenode = ctx.node() | ||
rev = ctx.rev() | ||||
|
r3643 | |||
if self.ui.quiet: | ||||
|
r10819 | self.ui.write("%d:%s\n" % (rev, short(changenode)), | ||
label='log.node') | ||||
|
r3643 | return | ||
|
r7369 | log = self.repo.changelog | ||
|
r9547 | date = util.datestr(ctx.date()) | ||
|
r3643 | |||
hexfunc = self.ui.debugflag and hex or short | ||||
|
r4825 | parents = [(p, hexfunc(log.node(p))) | ||
for p in self._meaningful_parentrevs(log, rev)] | ||||
|
r3643 | |||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r10819 | self.ui.write(_("changeset: %d:%s\n") % (rev, hexfunc(changenode)), | ||
|
r17788 | label='log.changeset changeset.%s' % ctx.phasestr()) | ||
|
r3643 | |||
|
r9637 | branch = ctx.branch() | ||
|
r4176 | # don't show the default branch name | ||
if branch != 'default': | ||||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r10819 | self.ui.write(_("branch: %s\n") % branch, | ||
label='log.branch') | ||||
|
r13386 | for bookmark in self.repo.nodebookmarks(changenode): | ||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r13386 | self.ui.write(_("bookmark: %s\n") % bookmark, | ||
label='log.bookmark') | ||||
|
r3643 | for tag in self.repo.nodetags(changenode): | ||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r10819 | self.ui.write(_("tag: %s\n") % tag, | ||
label='log.tag') | ||||
|
r22765 | if self.ui.debugflag: | ||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r15907 | self.ui.write(_("phase: %s\n") % _(ctx.phasestr()), | ||
label='log.phase') | ||||
|
r3643 | for parent in parents: | ||
|
r22301 | label = 'log.parent changeset.%s' % self.repo[parent[0]].phasestr() | ||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r10819 | self.ui.write(_("parent: %d:%s\n") % parent, | ||
|
r22301 | label=label) | ||
|
r3643 | |||
if self.ui.debugflag: | ||||
|
r9547 | mnode = ctx.manifestnode() | ||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r3643 | self.ui.write(_("manifest: %d:%s\n") % | ||
|
r10819 | (self.repo.manifest.rev(mnode), hex(mnode)), | ||
label='ui.debug log.manifest') | ||||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r10819 | self.ui.write(_("user: %s\n") % ctx.user(), | ||
label='log.user') | ||||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r10819 | self.ui.write(_("date: %s\n") % date, | ||
label='log.date') | ||||
|
r3643 | |||
if self.ui.debugflag: | ||||
files = self.repo.status(log.parents(changenode)[0], changenode)[:3] | ||||
|
r17891 | for key, value in zip([# i18n: column positioning for "hg log" | ||
_("files:"), | ||||
# i18n: column positioning for "hg log" | ||||
_("files+:"), | ||||
# i18n: column positioning for "hg log" | ||||
_("files-:")], files): | ||||
|
r3643 | if value: | ||
|
r10819 | self.ui.write("%-12s %s\n" % (key, " ".join(value)), | ||
label='ui.debug log.files') | ||||
|
r9547 | elif ctx.files() and self.ui.verbose: | ||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r10819 | self.ui.write(_("files: %s\n") % " ".join(ctx.files()), | ||
label='ui.note log.files') | ||||
|
r3643 | if copies and self.ui.verbose: | ||
copies = ['%s (%s)' % c for c in copies] | ||||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r10819 | self.ui.write(_("copies: %s\n") % ' '.join(copies), | ||
label='ui.note log.copies') | ||||
|
r3643 | |||
|
r9637 | extra = ctx.extra() | ||
|
r3643 | if extra and self.ui.debugflag: | ||
|
r8209 | for key, value in sorted(extra.items()): | ||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r3643 | self.ui.write(_("extra: %s=%s\n") | ||
|
r10819 | % (key, value.encode('string_escape')), | ||
label='ui.debug log.extra') | ||||
|
r3643 | |||
|
r9547 | description = ctx.description().strip() | ||
|
r3643 | if description: | ||
if self.ui.verbose: | ||||
|
r10819 | self.ui.write(_("description:\n"), | ||
label='ui.note log.description') | ||||
self.ui.write(description, | ||||
label='ui.note log.description') | ||||
|
r3643 | self.ui.write("\n\n") | ||
else: | ||||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r3643 | self.ui.write(_("summary: %s\n") % | ||
|
r10819 | description.splitlines()[0], | ||
label='log.summary') | ||||
|
r3643 | self.ui.write("\n") | ||
|
r11488 | self.showpatch(changenode, matchfn) | ||
|
r3645 | |||
|
r11488 | def showpatch(self, node, matchfn): | ||
if not matchfn: | ||||
|
r22386 | matchfn = self.matchfn | ||
|
r11488 | if matchfn: | ||
|
r11061 | stat = self.diffopts.get('stat') | ||
|
r11950 | diff = self.diffopts.get('patch') | ||
|
r11061 | diffopts = patch.diffopts(self.ui, self.diffopts) | ||
|
r3645 | prev = self.repo.changelog.parents(node)[0] | ||
|
r11950 | if stat: | ||
diffordiffstat(self.ui, self.repo, diffopts, prev, node, | ||||
match=matchfn, stat=True) | ||||
if diff: | ||||
if stat: | ||||
self.ui.write("\n") | ||||
diffordiffstat(self.ui, self.repo, diffopts, prev, node, | ||||
match=matchfn, stat=False) | ||||
|
r3645 | self.ui.write("\n") | ||
|
r4825 | def _meaningful_parentrevs(self, log, rev): | ||
"""Return list of meaningful (or all if debug) parentrevs for rev. | ||||
For merges (two non-nullrev revisions) both parents are meaningful. | ||||
Otherwise the first parent revision is considered meaningful if it | ||||
is not the preceding revision. | ||||
""" | ||||
parents = log.parentrevs(rev) | ||||
if not self.ui.debugflag and parents[1] == nullrev: | ||||
if parents[0] >= rev - 1: | ||||
parents = [] | ||||
else: | ||||
parents = [parents[0]] | ||||
return parents | ||||
|
r22427 | class jsonchangeset(changeset_printer): | ||
'''format changeset information.''' | ||||
def __init__(self, ui, repo, matchfn, diffopts, buffered): | ||||
changeset_printer.__init__(self, ui, repo, matchfn, diffopts, buffered) | ||||
self.cache = {} | ||||
self._first = True | ||||
def close(self): | ||||
if not self._first: | ||||
self.ui.write("\n]\n") | ||||
else: | ||||
self.ui.write("[]\n") | ||||
def _show(self, ctx, copies, matchfn, props): | ||||
'''show a single changeset or file revision''' | ||||
hexnode = hex(ctx.node()) | ||||
rev = ctx.rev() | ||||
j = encoding.jsonescape | ||||
if self._first: | ||||
self.ui.write("[\n {") | ||||
self._first = False | ||||
else: | ||||
self.ui.write(",\n {") | ||||
if self.ui.quiet: | ||||
self.ui.write('\n "rev": %d' % rev) | ||||
self.ui.write(',\n "node": "%s"' % hexnode) | ||||
self.ui.write('\n }') | ||||
return | ||||
self.ui.write('\n "rev": %d' % rev) | ||||
self.ui.write(',\n "node": "%s"' % hexnode) | ||||
self.ui.write(',\n "branch": "%s"' % j(ctx.branch())) | ||||
self.ui.write(',\n "phase": "%s"' % ctx.phasestr()) | ||||
self.ui.write(',\n "user": "%s"' % j(ctx.user())) | ||||
self.ui.write(',\n "date": [%d, %d]' % ctx.date()) | ||||
self.ui.write(',\n "desc": "%s"' % j(ctx.description())) | ||||
self.ui.write(',\n "bookmarks": [%s]' % | ||||
", ".join('"%s"' % j(b) for b in ctx.bookmarks())) | ||||
self.ui.write(',\n "tags": [%s]' % | ||||
", ".join('"%s"' % j(t) for t in ctx.tags())) | ||||
self.ui.write(',\n "parents": [%s]' % | ||||
", ".join('"%s"' % c.hex() for c in ctx.parents())) | ||||
if self.ui.debugflag: | ||||
self.ui.write(',\n "manifest": "%s"' % hex(ctx.manifestnode())) | ||||
self.ui.write(',\n "extra": {%s}' % | ||||
", ".join('"%s": "%s"' % (j(k), j(v)) | ||||
for k, v in ctx.extra().items())) | ||||
files = ctx.status(ctx.p1()) | ||||
self.ui.write(',\n "modified": [%s]' % | ||||
", ".join('"%s"' % j(f) for f in files[0])) | ||||
self.ui.write(',\n "added": [%s]' % | ||||
", ".join('"%s"' % j(f) for f in files[1])) | ||||
self.ui.write(',\n "removed": [%s]' % | ||||
", ".join('"%s"' % j(f) for f in files[2])) | ||||
elif self.ui.verbose: | ||||
self.ui.write(',\n "files": [%s]' % | ||||
", ".join('"%s"' % j(f) for f in ctx.files())) | ||||
if copies: | ||||
self.ui.write(',\n "copies": {%s}' % | ||||
", ".join('"%s": %s' % (j(k), j(copies[k])) | ||||
for k in copies)) | ||||
matchfn = self.matchfn | ||||
if matchfn: | ||||
stat = self.diffopts.get('stat') | ||||
diff = self.diffopts.get('patch') | ||||
diffopts = patch.diffopts(self.ui, self.diffopts) | ||||
node, prev = ctx.node(), ctx.p1().node() | ||||
if stat: | ||||
self.ui.pushbuffer() | ||||
diffordiffstat(self.ui, self.repo, diffopts, prev, node, | ||||
match=matchfn, stat=True) | ||||
self.ui.write(',\n "diffstat": "%s"' % j(self.ui.popbuffer())) | ||||
if diff: | ||||
self.ui.pushbuffer() | ||||
diffordiffstat(self.ui, self.repo, diffopts, prev, node, | ||||
match=matchfn, stat=False) | ||||
self.ui.write(',\n "diff": "%s"' % j(self.ui.popbuffer())) | ||||
self.ui.write("\n }") | ||||
|
r4825 | |||
|
r3645 | class changeset_templater(changeset_printer): | ||
|
r3643 | '''format changeset information.''' | ||
|
r22386 | def __init__(self, ui, repo, matchfn, diffopts, tmpl, mapfile, buffered): | ||
changeset_printer.__init__(self, ui, repo, matchfn, diffopts, buffered) | ||||
|
r8360 | formatnode = ui.debugflag and (lambda x: x) or (lambda x: x[:12]) | ||
|
r10061 | defaulttempl = { | ||
'parent': '{rev}:{node|formatnode} ', | ||||
'manifest': '{rev}:{node|formatnode}', | ||||
'file_copy': '{name} ({source})', | ||||
'extra': '{key}={value|stringescape}' | ||||
} | ||||
# filecopy is preserved for compatibility reasons | ||||
defaulttempl['filecopy'] = defaulttempl['file_copy'] | ||||
|
r8360 | self.t = templater.templater(mapfile, {'formatnode': formatnode}, | ||
|
r10061 | cache=defaulttempl) | ||
|
r20667 | if tmpl: | ||
self.t.cache['changeset'] = tmpl | ||||
|
r3643 | |||
|
r20667 | self.cache = {} | ||
|
r3643 | |||
|
r7878 | def _meaningful_parentrevs(self, ctx): | ||
"""Return list of meaningful (or all if debug) parentrevs for rev. | ||||
""" | ||||
parents = ctx.parents() | ||||
if len(parents) > 1: | ||||
return parents | ||||
if self.ui.debugflag: | ||||
return [parents[0], self.repo['null']] | ||||
if parents[0].rev() >= ctx.rev() - 1: | ||||
return [] | ||||
return parents | ||||
|
r11488 | def _show(self, ctx, copies, matchfn, props): | ||
|
r3643 | '''show a single changeset or file revision''' | ||
|
r10053 | showlist = templatekw.showlist | ||
|
r3643 | |||
|
r10058 | # showparents() behaviour depends on ui trace level which | ||
# causes unexpected behaviours at templating level and makes | ||||
# it harder to extract it in a standalone function. Its | ||||
# behaviour cannot be changed so leave it here for now. | ||||
|
r3643 | def showparents(**args): | ||
|
r10260 | ctx = args['ctx'] | ||
|
r22764 | parents = [[('rev', p.rev()), | ||
('node', p.hex()), | ||||
('phase', p.phasestr())] | ||||
|
r7878 | for p in self._meaningful_parentrevs(ctx)] | ||
|
r3643 | return showlist('parent', parents, **args) | ||
props = props.copy() | ||||
|
r10054 | props.update(templatekw.keywords) | ||
|
r10058 | props['parents'] = showparents | ||
|
r10053 | props['templ'] = self.t | ||
|
r10054 | props['ctx'] = ctx | ||
|
r10055 | props['repo'] = self.repo | ||
|
r10058 | props['revcache'] = {'copies': copies} | ||
|
r10057 | props['cache'] = self.cache | ||
|
r3643 | |||
|
r8013 | # find correct templates for current mode | ||
tmplmodes = [ | ||||
(True, None), | ||||
(self.ui.verbose, 'verbose'), | ||||
(self.ui.quiet, 'quiet'), | ||||
(self.ui.debugflag, 'debug'), | ||||
] | ||||
|
r10152 | types = {'header': '', 'footer':'', 'changeset': 'changeset'} | ||
|
r8013 | for mode, postfix in tmplmodes: | ||
for type in types: | ||||
cur = postfix and ('%s_%s' % (type, postfix)) or type | ||||
if mode and cur in self.t: | ||||
types[type] = cur | ||||
|
r3643 | try: | ||
|
r8013 | |||
# write header | ||||
if types['header']: | ||||
h = templater.stringify(self.t(types['header'], **props)) | ||||
|
r3645 | if self.buffered: | ||
|
r7878 | self.header[ctx.rev()] = h | ||
|
r3645 | else: | ||
|
r11465 | if self.lastheader != h: | ||
self.lastheader = h | ||||
|
r11441 | self.ui.write(h) | ||
|
r8013 | |||
# write changeset metadata, then patch if requested | ||||
key = types['changeset'] | ||||
|
r3645 | self.ui.write(templater.stringify(self.t(key, **props))) | ||
|
r11488 | self.showpatch(ctx.node(), matchfn) | ||
|
r8013 | |||
|
r10160 | if types['footer']: | ||
|
r10152 | if not self.footer: | ||
self.footer = templater.stringify(self.t(types['footer'], | ||||
**props)) | ||||
|
r3643 | except KeyError, inst: | ||
|
r8013 | msg = _("%s: no key named '%s'") | ||
raise util.Abort(msg % (self.t.mapfile, inst.args[0])) | ||||
|
r3643 | except SyntaxError, inst: | ||
|
r10829 | raise util.Abort('%s: %s' % (self.t.mapfile, inst.args[0])) | ||
|
r3643 | |||
|
r20666 | def gettemplate(ui, tmpl, style): | ||
""" | ||||
Find the template matching the given template spec or style. | ||||
""" | ||||
# ui settings | ||||
|
r22582 | if not tmpl and not style: # template are stronger than style | ||
|
r20666 | tmpl = ui.config('ui', 'logtemplate') | ||
if tmpl: | ||||
try: | ||||
tmpl = templater.parsestring(tmpl) | ||||
except SyntaxError: | ||||
tmpl = templater.parsestring(tmpl, quoted=False) | ||||
|
r20668 | return tmpl, None | ||
|
r20666 | else: | ||
style = util.expandpath(ui.config('ui', 'style', '')) | ||||
|
r22582 | if not tmpl and style: | ||
|
r20666 | mapfile = style | ||
if not os.path.split(mapfile)[0]: | ||||
mapname = (templater.templatepath('map-cmdline.' + mapfile) | ||||
or templater.templatepath(mapfile)) | ||||
if mapname: | ||||
mapfile = mapname | ||||
return None, mapfile | ||||
|
r20668 | if not tmpl: | ||
return None, None | ||||
# looks like a literal template? | ||||
if '{' in tmpl: | ||||
return tmpl, None | ||||
# perhaps a stock style? | ||||
if not os.path.split(tmpl)[0]: | ||||
mapname = (templater.templatepath('map-cmdline.' + tmpl) | ||||
or templater.templatepath(tmpl)) | ||||
if mapname and os.path.isfile(mapname): | ||||
return None, mapname | ||||
# perhaps it's a reference to [templates] | ||||
t = ui.config('templates', tmpl) | ||||
if t: | ||||
try: | ||||
tmpl = templater.parsestring(t) | ||||
except SyntaxError: | ||||
tmpl = templater.parsestring(t, quoted=False) | ||||
return tmpl, None | ||||
|
r21944 | if tmpl == 'list': | ||
ui.write(_("available styles: %s\n") % templater.stylelist()) | ||||
raise util.Abort(_("specify a template")) | ||||
|
r20668 | # perhaps it's a path to a map or a template | ||
if ('/' in tmpl or '\\' in tmpl) and os.path.isfile(tmpl): | ||||
# is it a mapfile for a style? | ||||
if os.path.basename(tmpl).startswith("map-"): | ||||
return None, os.path.realpath(tmpl) | ||||
tmpl = open(tmpl).read() | ||||
return tmpl, None | ||||
# constant string? | ||||
|
r20666 | return tmpl, None | ||
|
r11488 | def show_changeset(ui, repo, opts, buffered=False): | ||
|
r3643 | """show one changeset using template or regular display. | ||
Display format will be the first non-empty hit of: | ||||
1. option 'template' | ||||
2. option 'style' | ||||
3. [ui] setting 'logtemplate' | ||||
4. [ui] setting 'style' | ||||
If all of these values are either the unset or the empty string, | ||||
regular display via changeset_printer() is done. | ||||
""" | ||||
# options | ||||
|
r22386 | matchfn = None | ||
|
r11061 | if opts.get('patch') or opts.get('stat'): | ||
|
r22386 | matchfn = scmutil.matchall(repo) | ||
|
r3837 | |||
|
r22427 | if opts.get('template') == 'json': | ||
return jsonchangeset(ui, repo, matchfn, opts, buffered) | ||||
|
r3837 | |||
|
r20666 | tmpl, mapfile = gettemplate(ui, opts.get('template'), opts.get('style')) | ||
|
r7967 | |||
|
r20666 | if not tmpl and not mapfile: | ||
|
r22386 | return changeset_printer(ui, repo, matchfn, opts, buffered) | ||
|
r3643 | |||
|
r7967 | try: | ||
|
r22386 | t = changeset_templater(ui, repo, matchfn, opts, tmpl, mapfile, | ||
buffered) | ||||
|
r7967 | except SyntaxError, inst: | ||
raise util.Abort(inst.args[0]) | ||||
return t | ||||
|
r3643 | |||
|
r20470 | def showmarker(ui, marker): | ||
"""utility function to display obsolescence marker in a readable way | ||||
To be used by debug function.""" | ||||
ui.write(hex(marker.precnode())) | ||||
for repl in marker.succnodes(): | ||||
ui.write(' ') | ||||
ui.write(hex(repl)) | ||||
|
r22215 | ui.write(' %X ' % marker.flags()) | ||
|
r22260 | parents = marker.parentnodes() | ||
if parents is not None: | ||||
ui.write('{%s} ' % ', '.join(hex(p) for p in parents)) | ||||
|
r22220 | ui.write('(%s) ' % util.datestr(marker.date())) | ||
|
r20470 | ui.write('{%s}' % (', '.join('%r: %r' % t for t in | ||
|
r22220 | sorted(marker.metadata().items()) | ||
if t[0] != 'date'))) | ||||
|
r20470 | ui.write('\n') | ||
|
r3814 | def finddate(ui, repo, date): | ||
"""Find the tipmost changeset that matches the given date spec""" | ||||
|
r9667 | |||
|
r5836 | df = util.matchdate(date) | ||
|
r14322 | m = scmutil.matchall(repo) | ||
|
r3814 | results = {} | ||
|
r9662 | |||
def prep(ctx, fns): | ||||
d = ctx.date() | ||||
if df(d[0]): | ||||
|
r9668 | results[ctx.rev()] = d | ||
|
r9662 | |||
|
r9667 | for ctx in walkchangerevs(repo, m, {'rev': None}, prep): | ||
|
r9662 | rev = ctx.rev() | ||
if rev in results: | ||||
|
r16937 | ui.status(_("found revision %s from %s\n") % | ||
|
r9662 | (rev, util.datestr(results[rev]))) | ||
return str(rev) | ||||
|
r3814 | |||
raise util.Abort(_("revision matching date not found")) | ||||
|
r20553 | def increasingwindows(windowsize=8, sizelimit=512): | ||
while True: | ||||
yield windowsize | ||||
if windowsize < sizelimit: | ||||
windowsize *= 2 | ||||
|
r16776 | |||
|
r19290 | class FileWalkError(Exception): | ||
pass | ||||
def walkfilerevs(repo, match, follow, revs, fncache): | ||||
'''Walks the file history for the matched files. | ||||
Returns the changeset revs that are involved in the file history. | ||||
Throws FileWalkError if the file history can't be walked using | ||||
filelogs alone. | ||||
''' | ||||
wanted = set() | ||||
copies = [] | ||||
minrev, maxrev = min(revs), max(revs) | ||||
def filerevgen(filelog, last): | ||||
""" | ||||
Only files, no patterns. Check the history of each file. | ||||
Examines filelog entries within minrev, maxrev linkrev range | ||||
Returns an iterator yielding (linkrev, parentlinkrevs, copied) | ||||
tuples in backwards order | ||||
""" | ||||
cl_count = len(repo) | ||||
revs = [] | ||||
for j in xrange(0, last + 1): | ||||
linkrev = filelog.linkrev(j) | ||||
if linkrev < minrev: | ||||
continue | ||||
# only yield rev for which we have the changelog, it can | ||||
# happen while doing "hg log" during a pull or commit | ||||
if linkrev >= cl_count: | ||||
break | ||||
parentlinkrevs = [] | ||||
for p in filelog.parentrevs(j): | ||||
if p != nullrev: | ||||
parentlinkrevs.append(filelog.linkrev(p)) | ||||
n = filelog.node(j) | ||||
revs.append((linkrev, parentlinkrevs, | ||||
follow and filelog.renamed(n))) | ||||
return reversed(revs) | ||||
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 ' | ||||
'revision: "%s"') % filename) | ||||
yield filename, pctx[filename].filenode() | ||||
else: | ||||
yield filename, None | ||||
for filename_node in copies: | ||||
yield filename_node | ||||
for file_, node in iterfiles(): | ||||
filelog = repo.file(file_) | ||||
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( | ||||
_('cannot follow nonexistent file: "%s"') % file_) | ||||
raise FileWalkError("Cannot walk via filelog") | ||||
else: | ||||
continue | ||||
if node is None: | ||||
last = len(filelog) - 1 | ||||
else: | ||||
last = filelog.rev(node) | ||||
# keep track of all ancestors of the file | ||||
ancestors = set([filelog.linkrev(last)]) | ||||
# iterate from latest to oldest revision | ||||
for rev, flparentlinkrevs, copied in filerevgen(filelog, last): | ||||
if not follow: | ||||
if rev > maxrev: | ||||
continue | ||||
else: | ||||
# Note that last might not be the first interesting | ||||
# rev to us: | ||||
# if the file has been changed after maxrev, we'll | ||||
# have linkrev(last) > maxrev, and we still need | ||||
# to explore the file graph | ||||
if rev not in ancestors: | ||||
continue | ||||
# XXX insert 1327 fix here | ||||
if flparentlinkrevs: | ||||
ancestors.update(flparentlinkrevs) | ||||
fncache.setdefault(rev, []).append(file_) | ||||
wanted.add(rev) | ||||
if copied: | ||||
copies.append(copied) | ||||
return wanted | ||||
|
r9665 | def walkchangerevs(repo, match, opts, prepare): | ||
|
r7807 | '''Iterate over files and the revs in which they changed. | ||
|
r3650 | |||
Callers most commonly need to iterate backwards over the history | ||||
|
r7807 | in which they are interested. Doing so has awful (quadratic-looking) | ||
|
r3650 | performance, so we use iterators in a "windowed" way. | ||
We walk a window of revisions in the desired order. Within the | ||||
window, we first walk forwards to gather data, then in the desired | ||||
order (usually backwards) to display it. | ||||
|
r9662 | This function returns an iterator yielding contexts. Before | ||
yielding each context, the iterator will first call the prepare | ||||
function on each context in the window in forward order.''' | ||||
|
r3650 | |||
follow = opts.get('follow') or opts.get('follow_first') | ||||
|
r17676 | if opts.get('rev'): | ||
revs = scmutil.revrange(repo, opts.get('rev')) | ||||
elif follow: | ||||
revs = repo.revs('reverse(:.)') | ||||
|
r3650 | else: | ||
|
r20704 | revs = revset.spanset(repo) | ||
|
r17676 | revs.reverse() | ||
|
r11281 | if not revs: | ||
return [] | ||||
|
r8152 | wanted = set() | ||
|
r9652 | slowpath = match.anypats() or (match.files() and opts.get('removed')) | ||
|
r3650 | fncache = {} | ||
|
r16108 | change = repo.changectx | ||
|
r3650 | |||
|
r11632 | # First step is to fill wanted, the set of revisions that we want to yield. | ||
# When it does not induce extra cost, we also fill fncache for revisions in | ||||
# wanted: a cache of filenames that were changed (ctx.files()) and that | ||||
# match the file filtering conditions. | ||||
|
r9652 | if not slowpath and not match.files(): | ||
|
r3650 | # No files, no patterns. Display all revs. | ||
|
r20553 | wanted = revs | ||
|
r9665 | |||
|
r16381 | if not slowpath and match.files(): | ||
|
r11632 | # We only have to read through the filelog to find wanted revisions | ||
|
r19290 | try: | ||
wanted = walkfilerevs(repo, match, follow, revs, fncache) | ||||
except FileWalkError: | ||||
slowpath = True | ||||
|
r11608 | |||
|
r19290 | # 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 | ||||
# existed in history, otherwise simply return | ||||
|
r17746 | for path in match.files(): | ||
if path == '.' or path in repo.store: | ||||
break | ||||
|
r18340 | else: | ||
return [] | ||||
|
r17746 | |||
|
r3650 | if slowpath: | ||
|
r11632 | # We have to read the changelog to match filenames against | ||
# changed files | ||||
|
r3650 | if follow: | ||
raise util.Abort(_('can only follow copies/renames for explicit ' | ||||
|
r8761 | 'filenames')) | ||
|
r3650 | |||
# The slow path checks files modified in every changeset. | ||||
|
r19730 | # This is really slow on large repos, so compute the set lazily. | ||
class lazywantedset(object): | ||||
def __init__(self): | ||||
self.set = set() | ||||
self.revs = set(revs) | ||||
# No need to worry about locality here because it will be accessed | ||||
# in the same order as the increasing window below. | ||||
def __contains__(self, value): | ||||
if value in self.set: | ||||
return True | ||||
elif not value in self.revs: | ||||
return False | ||||
else: | ||||
self.revs.discard(value) | ||||
ctx = change(value) | ||||
matches = filter(match, ctx.files()) | ||||
if matches: | ||||
fncache[value] = matches | ||||
self.set.add(value) | ||||
return True | ||||
return False | ||||
def discard(self, value): | ||||
self.revs.discard(value) | ||||
self.set.discard(value) | ||||
wanted = lazywantedset() | ||||
|
r3650 | |||
|
r8778 | class followfilter(object): | ||
|
r3650 | def __init__(self, onlyfirst=False): | ||
self.startrev = nullrev | ||||
|
r10024 | self.roots = set() | ||
|
r3650 | self.onlyfirst = onlyfirst | ||
def match(self, rev): | ||||
def realparents(rev): | ||||
if self.onlyfirst: | ||||
return repo.changelog.parentrevs(rev)[0:1] | ||||
else: | ||||
return filter(lambda x: x != nullrev, | ||||
repo.changelog.parentrevs(rev)) | ||||
if self.startrev == nullrev: | ||||
self.startrev = rev | ||||
return True | ||||
if rev > self.startrev: | ||||
# forward: all descendants | ||||
if not self.roots: | ||||
|
r10024 | self.roots.add(self.startrev) | ||
|
r3650 | for parent in realparents(rev): | ||
if parent in self.roots: | ||||
|
r10024 | self.roots.add(rev) | ||
|
r3650 | return True | ||
else: | ||||
# backwards: all parents | ||||
if not self.roots: | ||||
|
r10024 | self.roots.update(realparents(self.startrev)) | ||
|
r3650 | if rev in self.roots: | ||
self.roots.remove(rev) | ||||
|
r10024 | self.roots.update(realparents(rev)) | ||
|
r3650 | return True | ||
return False | ||||
# it might be worthwhile to do this in the iterator if the rev range | ||||
# is descending and the prune args are all within that range | ||||
for rev in opts.get('prune', ()): | ||||
|
r16380 | rev = repo[rev].rev() | ||
|
r3650 | ff = followfilter() | ||
stop = min(revs[0], revs[-1]) | ||||
|
r10282 | for x in xrange(rev, stop - 1, -1): | ||
|
r8152 | if ff.match(x): | ||
|
r20553 | wanted = wanted - [x] | ||
|
r18710 | |||
|
r11632 | # Now that wanted is correctly initialized, we can iterate over the | ||
# revision range, yielding only revisions in wanted. | ||||
|
r3650 | def iterate(): | ||
|
r9652 | if follow and not match.files(): | ||
|
r3650 | ff = followfilter(onlyfirst=opts.get('follow_first')) | ||
def want(rev): | ||||
|
r8119 | return ff.match(rev) and rev in wanted | ||
|
r3650 | else: | ||
def want(rev): | ||||
return rev in wanted | ||||
|
r20553 | it = iter(revs) | ||
stopiteration = False | ||||
for windowsize in increasingwindows(): | ||||
nrevs = [] | ||||
for i in xrange(windowsize): | ||||
try: | ||||
rev = it.next() | ||||
if want(rev): | ||||
nrevs.append(rev) | ||||
except (StopIteration): | ||||
stopiteration = True | ||||
break | ||||
|
r8209 | for rev in sorted(nrevs): | ||
|
r3650 | fns = fncache.get(rev) | ||
|
r9654 | ctx = change(rev) | ||
|
r3650 | if not fns: | ||
def fns_generator(): | ||||
|
r9654 | for f in ctx.files(): | ||
|
r9652 | if match(f): | ||
|
r3650 | yield f | ||
fns = fns_generator() | ||||
|
r9662 | prepare(ctx, fns) | ||
|
r3650 | for rev in nrevs: | ||
|
r9662 | yield change(rev) | ||
|
r20553 | |||
if stopiteration: | ||||
break | ||||
|
r9652 | return iterate() | ||
|
r5034 | |||
|
r22166 | def _makefollowlogfilematcher(repo, files, followfirst): | ||
|
r17180 | # When displaying a revision with --patch --follow FILE, we have | ||
# to know which file of the revision must be diffed. With | ||||
# --follow, we want the names of the ancestors of FILE in the | ||||
# revision, stored in "fcache". "fcache" is populated by | ||||
# reproducing the graph traversal already done by --follow revset | ||||
# and relating linkrevs to file names (which is not "correct" but | ||||
# good enough). | ||||
fcache = {} | ||||
fcacheready = [False] | ||||
pctx = repo['.'] | ||||
def populate(): | ||||
|
r21876 | for fn in files: | ||
|
r17180 | for i in ((pctx[fn],), pctx[fn].ancestors(followfirst=followfirst)): | ||
for c in i: | ||||
fcache.setdefault(c.linkrev(), set()).add(c.path()) | ||||
def filematcher(rev): | ||||
if not fcacheready[0]: | ||||
# Lazy initialization | ||||
fcacheready[0] = True | ||||
populate() | ||||
|
r21878 | return scmutil.matchfiles(repo, fcache.get(rev, [])) | ||
|
r17180 | |||
return filematcher | ||||
|
r22167 | def _makenofollowlogfilematcher(repo, pats, opts): | ||
'''hook for extensions to override the filematcher for non-follow cases''' | ||||
return None | ||||
|
r21108 | def _makelogrevset(repo, pats, opts, revs): | ||
|
r17180 | """Return (expr, filematcher) where expr is a revset string built | ||
from log options and file patterns or None. If --stat or --patch | ||||
are not passed filematcher is None. Otherwise it is a callable | ||||
taking a revision number and returning a match objects filtering | ||||
the files to be detailed when displaying the revision. | ||||
""" | ||||
opt2revset = { | ||||
'no_merges': ('not merge()', None), | ||||
'only_merges': ('merge()', None), | ||||
'_ancestors': ('ancestors(%(val)s)', None), | ||||
'_fancestors': ('_firstancestors(%(val)s)', None), | ||||
'_descendants': ('descendants(%(val)s)', None), | ||||
'_fdescendants': ('_firstdescendants(%(val)s)', None), | ||||
'_matchfiles': ('_matchfiles(%(val)s)', None), | ||||
'date': ('date(%(val)r)', None), | ||||
'branch': ('branch(%(val)r)', ' or '), | ||||
'_patslog': ('filelog(%(val)r)', ' or '), | ||||
'_patsfollow': ('follow(%(val)r)', ' or '), | ||||
'_patsfollowfirst': ('_followfirst(%(val)r)', ' or '), | ||||
'keyword': ('keyword(%(val)r)', ' or '), | ||||
'prune': ('not (%(val)r or ancestors(%(val)r))', ' and '), | ||||
'user': ('user(%(val)r)', ' or '), | ||||
} | ||||
opts = dict(opts) | ||||
# follow or not follow? | ||||
follow = opts.get('follow') or opts.get('follow_first') | ||||
followfirst = opts.get('follow_first') and 1 or 0 | ||||
# --follow with FILE behaviour depends on revs... | ||||
|
r20756 | it = iter(revs) | ||
startrev = it.next() | ||||
try: | ||||
followdescendants = startrev < it.next() | ||||
except (StopIteration): | ||||
followdescendants = False | ||||
|
r17180 | |||
# branch and only_branch are really aliases and must be handled at | ||||
# the same time | ||||
opts['branch'] = opts.get('branch', []) + opts.get('only_branch', []) | ||||
opts['branch'] = [repo.lookupbranch(b) for b in opts['branch']] | ||||
# pats/include/exclude are passed to match.match() directly in | ||||
|
r17424 | # _matchfiles() revset but walkchangerevs() builds its matcher with | ||
|
r17180 | # scmutil.match(). The difference is input pats are globbed on | ||
# platforms without shell expansion (windows). | ||||
pctx = repo[None] | ||||
match, pats = scmutil.matchandpats(pctx, pats, opts) | ||||
slowpath = match.anypats() or (match.files() and opts.get('removed')) | ||||
if not slowpath: | ||||
for f in match.files(): | ||||
if follow and f not in pctx: | ||||
|
r21998 | # If the file exists, it may be a directory, so let it | ||
# take the slow path. | ||||
if os.path.exists(repo.wjoin(f)): | ||||
slowpath = True | ||||
continue | ||||
else: | ||||
raise util.Abort(_('cannot follow file not in parent ' | ||||
'revision: "%s"') % f) | ||||
|
r17180 | filelog = repo.file(f) | ||
|
r19293 | if not filelog: | ||
|
r17180 | # 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( | ||||
_('cannot follow nonexistent file: "%s"') % f) | ||||
slowpath = True | ||||
|
r17746 | |||
# 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 | ||||
# existed in history - in that case, we'll continue down the | ||||
# slowpath; otherwise, we can turn off the slowpath | ||||
if slowpath: | ||||
for path in match.files(): | ||||
if path == '.' or path in repo.store: | ||||
break | ||||
else: | ||||
slowpath = False | ||||
|
r17180 | if slowpath: | ||
# See walkchangerevs() slow path. | ||||
# | ||||
# pats/include/exclude cannot be represented as separate | ||||
# revset expressions as their filtering logic applies at file | ||||
# level. For instance "-I a -X a" matches a revision touching | ||||
# "a" and "b" while "file(a) and not file(b)" does | ||||
# not. Besides, filesets are evaluated against the working | ||||
# directory. | ||||
matchargs = ['r:', 'd:relpath'] | ||||
for p in pats: | ||||
matchargs.append('p:' + p) | ||||
for p in opts.get('include', []): | ||||
matchargs.append('i:' + p) | ||||
for p in opts.get('exclude', []): | ||||
matchargs.append('x:' + p) | ||||
matchargs = ','.join(('%r' % p) for p in matchargs) | ||||
opts['_matchfiles'] = matchargs | ||||
else: | ||||
if follow: | ||||
fpats = ('_patsfollow', '_patsfollowfirst') | ||||
fnopats = (('_ancestors', '_fancestors'), | ||||
('_descendants', '_fdescendants')) | ||||
if pats: | ||||
|
r17424 | # follow() revset interprets its file argument as a | ||
|
r17180 | # manifest entry, so use match.files(), not pats. | ||
opts[fpats[followfirst]] = list(match.files()) | ||||
else: | ||||
opts[fnopats[followdescendants][followfirst]] = str(startrev) | ||||
else: | ||||
opts['_patslog'] = list(pats) | ||||
filematcher = None | ||||
if opts.get('patch') or opts.get('stat'): | ||||
|
r21998 | # When following files, track renames via a special matcher. | ||
# If we're forced to take the slowpath it means we're following | ||||
# at least one pattern/directory, so don't bother with rename tracking. | ||||
if follow and not match.always() and not slowpath: | ||||
|
r23139 | # _makefollowlogfilematcher expects its files argument to be | ||
# relative to the repo root, so use match.files(), not pats. | ||||
|
r22166 | filematcher = _makefollowlogfilematcher(repo, match.files(), | ||
followfirst) | ||||
|
r17180 | else: | ||
|
r22167 | filematcher = _makenofollowlogfilematcher(repo, pats, opts) | ||
if filematcher is None: | ||||
filematcher = lambda rev: match | ||||
|
r17180 | |||
expr = [] | ||||
for op, val in opts.iteritems(): | ||||
if not val: | ||||
continue | ||||
if op not in opt2revset: | ||||
continue | ||||
revop, andor = opt2revset[op] | ||||
if '%(val)' not in revop: | ||||
expr.append(revop) | ||||
else: | ||||
if not isinstance(val, list): | ||||
e = revop % {'val': val} | ||||
else: | ||||
e = '(' + andor.join((revop % {'val': v}) for v in val) + ')' | ||||
expr.append(e) | ||||
if expr: | ||||
expr = '(' + ' and '.join(expr) + ')' | ||||
else: | ||||
expr = None | ||||
return expr, filematcher | ||||
def getgraphlogrevs(repo, pats, opts): | ||||
"""Return (revs, expr, filematcher) where revs is an iterable of | ||||
revision numbers, expr is a revset string built from log options | ||||
and file patterns or None, and used to filter 'revs'. If --stat or | ||||
--patch are not passed filematcher is None. Otherwise it is a | ||||
callable taking a revision number and returning a match objects | ||||
filtering the files to be detailed when displaying the revision. | ||||
""" | ||||
if not len(repo): | ||||
|
r18171 | return [], None, None | ||
|
r18172 | limit = loglimit(opts) | ||
|
r17180 | # Default --rev value depends on --follow but --follow behaviour | ||
# depends on revisions resolved from --rev... | ||||
follow = opts.get('follow') or opts.get('follow_first') | ||||
|
r18169 | possiblyunsorted = False # whether revs might need sorting | ||
|
r17180 | if opts.get('rev'): | ||
revs = scmutil.revrange(repo, opts['rev']) | ||||
|
r21108 | # Don't sort here because _makelogrevset might depend on the | ||
|
r18169 | # order of revs | ||
possiblyunsorted = True | ||||
|
r17180 | else: | ||
if follow and len(repo) > 0: | ||||
|
r17676 | revs = repo.revs('reverse(:.)') | ||
|
r17180 | else: | ||
|
r20757 | revs = revset.spanset(repo) | ||
|
r17675 | revs.reverse() | ||
|
r17180 | if not revs: | ||
|
r20759 | return revset.baseset(), None, None | ||
|
r21108 | expr, filematcher = _makelogrevset(repo, pats, opts, revs) | ||
|
r18169 | if possiblyunsorted: | ||
revs.sort(reverse=True) | ||||
|
r17180 | if expr: | ||
|
r18171 | # Revset matchers often operate faster on revisions in changelog | ||
# order, because most filters deal with the changelog. | ||||
revs.reverse() | ||||
|
r17180 | matcher = revset.match(repo.ui, expr) | ||
|
r18171 | # Revset matches can reorder revisions. "A or B" typically returns | ||
# returns the revision matching A then the revision matching B. Sort | ||||
# again to fix that. | ||||
revs = matcher(repo, revs) | ||||
revs.sort(reverse=True) | ||||
|
r18243 | if limit is not None: | ||
|
r22807 | limitedrevs = [] | ||
|
r20755 | for idx, rev in enumerate(revs): | ||
if idx >= limit: | ||||
break | ||||
limitedrevs.append(rev) | ||||
|
r22807 | revs = revset.baseset(limitedrevs) | ||
|
r18172 | |||
|
r17180 | return revs, expr, filematcher | ||
|
r21127 | def getlogrevs(repo, pats, opts): | ||
"""Return (revs, expr, filematcher) where revs is an iterable of | ||||
revision numbers, expr is a revset string built from log options | ||||
and file patterns or None, and used to filter 'revs'. If --stat or | ||||
--patch are not passed filematcher is None. Otherwise it is a | ||||
callable taking a revision number and returning a match objects | ||||
filtering the files to be detailed when displaying the revision. | ||||
""" | ||||
limit = loglimit(opts) | ||||
# Default --rev value depends on --follow but --follow behaviour | ||||
# depends on revisions resolved from --rev... | ||||
follow = opts.get('follow') or opts.get('follow_first') | ||||
if opts.get('rev'): | ||||
revs = scmutil.revrange(repo, opts['rev']) | ||||
elif follow: | ||||
|
r21872 | revs = repo.revs('reverse(:.)') | ||
|
r21127 | else: | ||
revs = revset.spanset(repo) | ||||
revs.reverse() | ||||
if not revs: | ||||
return revset.baseset([]), None, None | ||||
expr, filematcher = _makelogrevset(repo, pats, opts, revs) | ||||
if expr: | ||||
# Revset matchers often operate faster on revisions in changelog | ||||
# order, because most filters deal with the changelog. | ||||
if not opts.get('rev'): | ||||
revs.reverse() | ||||
matcher = revset.match(repo.ui, expr) | ||||
# Revset matches can reorder revisions. "A or B" typically returns | ||||
# returns the revision matching A then the revision matching B. Sort | ||||
# again to fix that. | ||||
revs = matcher(repo, revs) | ||||
if not opts.get('rev'): | ||||
revs.sort(reverse=True) | ||||
if limit is not None: | ||||
count = 0 | ||||
|
r22806 | limitedrevs = [] | ||
|
r21127 | it = iter(revs) | ||
while count < limit: | ||||
try: | ||||
limitedrevs.append(it.next()) | ||||
except (StopIteration): | ||||
break | ||||
count += 1 | ||||
|
r22806 | revs = revset.baseset(limitedrevs) | ||
|
r21127 | |||
return revs, expr, filematcher | ||||
|
r17180 | def displaygraph(ui, dag, displayer, showparents, edgefn, getrenamed=None, | ||
filematcher=None): | ||||
seen, state = [], graphmod.asciistate() | ||||
for rev, type, ctx, parents in dag: | ||||
char = 'o' | ||||
if ctx.node() in showparents: | ||||
char = '@' | ||||
elif ctx.obsolete(): | ||||
char = 'x' | ||||
copies = None | ||||
if getrenamed and ctx.rev(): | ||||
copies = [] | ||||
for fn in ctx.files(): | ||||
rename = getrenamed(fn, ctx.rev()) | ||||
if rename: | ||||
copies.append((fn, rename[0])) | ||||
revmatchfn = None | ||||
if filematcher is not None: | ||||
revmatchfn = filematcher(ctx.rev()) | ||||
displayer.show(ctx, copies=copies, matchfn=revmatchfn) | ||||
lines = displayer.hunk.pop(rev).split('\n') | ||||
if not lines[-1]: | ||||
del lines[-1] | ||||
displayer.flush(rev) | ||||
edges = edgefn(type, char, lines, seen, rev, parents) | ||||
for type, char, lines, coldata in edges: | ||||
graphmod.ascii(ui, state, type, char, lines, coldata) | ||||
displayer.close() | ||||
|
r17181 | def graphlog(ui, repo, *pats, **opts): | ||
# Parameters are identical to log command ones | ||||
revs, expr, filematcher = getgraphlogrevs(repo, pats, opts) | ||||
revdag = graphmod.dagwalker(repo, revs) | ||||
getrenamed = None | ||||
if opts.get('copies'): | ||||
endrev = None | ||||
if opts.get('rev'): | ||||
|
r20760 | endrev = scmutil.revrange(repo, opts.get('rev')).max() + 1 | ||
|
r17181 | getrenamed = templatekw.getrenamedfn(repo, endrev=endrev) | ||
displayer = show_changeset(ui, repo, opts, buffered=True) | ||||
showparents = [ctx.node() for ctx in repo[None].parents()] | ||||
displaygraph(ui, revdag, displayer, showparents, | ||||
graphmod.asciiedges, getrenamed, filematcher) | ||||
|
r17182 | 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") | ||||
% op.replace("_", "-")) | ||||
def graphrevs(repo, nodes, opts): | ||||
limit = loglimit(opts) | ||||
nodes.reverse() | ||||
if limit is not None: | ||||
nodes = nodes[:limit] | ||||
return graphmod.nodes(repo, nodes) | ||||
|
r15911 | def add(ui, repo, match, dryrun, listsubrepos, prefix, explicitonly): | ||
|
r12270 | join = lambda f: os.path.join(prefix, f) | ||
|
r12269 | bad = [] | ||
oldbad = match.bad | ||||
match.bad = lambda x, y: bad.append(x) or oldbad(x, y) | ||||
names = [] | ||||
|
r12270 | wctx = repo[None] | ||
|
r14138 | cca = None | ||
abort, warn = scmutil.checkportabilityalert(ui) | ||||
if abort or warn: | ||||
|
r17201 | cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate) | ||
|
r23258 | for f in wctx.walk(match): | ||
|
r12269 | exact = match.exact(f) | ||
|
r23258 | if exact or not explicitonly and f not in wctx: | ||
|
r14138 | if cca: | ||
cca(f) | ||||
|
r12269 | names.append(f) | ||
if ui.verbose or not exact: | ||||
|
r12270 | ui.status(_('adding %s\n') % match.rel(join(f))) | ||
|
r18364 | for subpath in sorted(wctx.substate): | ||
|
r15410 | sub = wctx.sub(subpath) | ||
try: | ||||
submatch = matchmod.narrowmatcher(subpath, match) | ||||
if listsubrepos: | ||||
|
r15911 | bad.extend(sub.add(ui, submatch, dryrun, listsubrepos, prefix, | ||
False)) | ||||
|
r15410 | else: | ||
|
r15911 | bad.extend(sub.add(ui, submatch, dryrun, listsubrepos, prefix, | ||
True)) | ||||
|
r15410 | except error.LookupError: | ||
ui.status(_("skipping missing subrepository: %s\n") | ||||
% join(subpath)) | ||||
|
r12270 | |||
|
r12269 | if not dryrun: | ||
|
r12270 | rejected = wctx.add(names, prefix) | ||
|
r12269 | bad.extend(f for f in rejected if f in match.files()) | ||
return bad | ||||
|
r15912 | def forget(ui, repo, match, prefix, explicitonly): | ||
join = lambda f: os.path.join(prefix, f) | ||||
bad = [] | ||||
oldbad = match.bad | ||||
match.bad = lambda x, y: bad.append(x) or oldbad(x, y) | ||||
wctx = repo[None] | ||||
forgot = [] | ||||
s = repo.status(match=match, clean=True) | ||||
forget = sorted(s[0] + s[1] + s[3] + s[6]) | ||||
if explicitonly: | ||||
forget = [f for f in forget if match.exact(f)] | ||||
|
r18364 | for subpath in sorted(wctx.substate): | ||
|
r15912 | sub = wctx.sub(subpath) | ||
try: | ||||
submatch = matchmod.narrowmatcher(subpath, match) | ||||
subbad, subforgot = sub.forget(ui, submatch, prefix) | ||||
bad.extend([subpath + '/' + f for f in subbad]) | ||||
forgot.extend([subpath + '/' + f for f in subforgot]) | ||||
except error.LookupError: | ||||
ui.status(_("skipping missing subrepository: %s\n") | ||||
% join(subpath)) | ||||
|
r16070 | if not explicitonly: | ||
for f in match.files(): | ||||
|
r15912 | if f not in repo.dirstate and not os.path.isdir(match.rel(join(f))): | ||
if f not in forgot: | ||||
if os.path.exists(match.rel(join(f))): | ||||
ui.warn(_('not removing %s: ' | ||||
'file is already untracked\n') | ||||
% match.rel(join(f))) | ||||
bad.append(f) | ||||
for f in forget: | ||||
if ui.verbose or not match.exact(f): | ||||
ui.status(_('removing %s\n') % match.rel(join(f))) | ||||
rejected = wctx.forget(forget, prefix) | ||||
bad.extend(f for f in rejected if f in match.files()) | ||||
forgot.extend(forget) | ||||
return bad, forgot | ||||
|
r23289 | def remove(ui, repo, m, after, force): | ||
ret = 0 | ||||
s = repo.status(match=m, clean=True) | ||||
modified, added, deleted, clean = s[0], s[1], s[3], s[6] | ||||
# warn about failure to delete explicit files/dirs | ||||
wctx = repo[None] | ||||
for f in m.files(): | ||||
if f in repo.dirstate or f in wctx.dirs(): | ||||
continue | ||||
if os.path.exists(m.rel(f)): | ||||
if os.path.isdir(m.rel(f)): | ||||
ui.warn(_('not removing %s: no tracked files\n') % m.rel(f)) | ||||
else: | ||||
ui.warn(_('not removing %s: file is untracked\n') % m.rel(f)) | ||||
# missing files will generate a warning elsewhere | ||||
ret = 1 | ||||
if force: | ||||
list = modified + deleted + clean + added | ||||
elif after: | ||||
list = deleted | ||||
for f in modified + added + clean: | ||||
ui.warn(_('not removing %s: file still exists\n') % m.rel(f)) | ||||
ret = 1 | ||||
else: | ||||
list = deleted + clean | ||||
for f in modified: | ||||
ui.warn(_('not removing %s: file is modified (use -f' | ||||
' to force removal)\n') % m.rel(f)) | ||||
ret = 1 | ||||
for f in added: | ||||
ui.warn(_('not removing %s: file has been marked for add' | ||||
' (use forget to undo)\n') % m.rel(f)) | ||||
ret = 1 | ||||
for f in sorted(list): | ||||
if ui.verbose or not m.exact(f): | ||||
ui.status(_('removing %s\n') % m.rel(f)) | ||||
wlock = repo.wlock() | ||||
try: | ||||
if not after: | ||||
for f in list: | ||||
if f in added: | ||||
continue # we never unlink added files on remove | ||||
util.unlinkpath(repo.wjoin(f), ignoremissing=True) | ||||
repo[None].forget(list) | ||||
finally: | ||||
wlock.release() | ||||
return ret | ||||
|
r21041 | def cat(ui, repo, ctx, matcher, prefix, **opts): | ||
|
r21040 | err = 1 | ||
def write(path): | ||||
|
r21041 | fp = makefileobj(repo, opts.get('output'), ctx.node(), | ||
pathname=os.path.join(prefix, path)) | ||||
|
r21040 | data = ctx[path].data() | ||
if opts.get('decode'): | ||||
data = repo.wwritedata(path, data) | ||||
fp.write(data) | ||||
fp.close() | ||||
# Automation often uses hg cat on single files, so special case it | ||||
# for performance to avoid the cost of parsing the manifest. | ||||
if len(matcher.files()) == 1 and not matcher.anypats(): | ||||
file = matcher.files()[0] | ||||
mf = repo.manifest | ||||
mfnode = ctx._changeset[0] | ||||
if mf.find(mfnode, file)[0]: | ||||
write(file) | ||||
return 0 | ||||
|
r21041 | # Don't warn about "missing" files that are really in subrepos | ||
bad = matcher.bad | ||||
def badfn(path, msg): | ||||
for subpath in ctx.substate: | ||||
if path.startswith(subpath): | ||||
return | ||||
bad(path, msg) | ||||
matcher.bad = badfn | ||||
|
r21040 | for abs in ctx.walk(matcher): | ||
write(abs) | ||||
err = 0 | ||||
|
r21041 | |||
matcher.bad = bad | ||||
for subpath in sorted(ctx.substate): | ||||
sub = ctx.sub(subpath) | ||||
try: | ||||
submatch = matchmod.narrowmatcher(subpath, matcher) | ||||
if not sub.cat(ui, submatch, os.path.join(prefix, sub._path), | ||||
**opts): | ||||
err = 0 | ||||
except error.RepoLookupError: | ||||
ui.status(_("skipping missing subrepository: %s\n") | ||||
% os.path.join(prefix, subpath)) | ||||
|
r21040 | return err | ||
|
r5034 | def commit(ui, repo, commitfunc, pats, opts): | ||
'''commit the specified files or all outstanding changes''' | ||||
|
r6139 | date = opts.get('date') | ||
if date: | ||||
opts['date'] = util.parsedate(date) | ||||
|
r14635 | message = logmessage(ui, opts) | ||
|
r5034 | |||
|
r5829 | # extract addremove carefully -- this function can be called from a command | ||
# that doesn't support addremove | ||||
if opts.get('addremove'): | ||||
|
r14321 | scmutil.addremove(repo, pats, opts) | ||
|
r5829 | |||
|
r14671 | return commitfunc(ui, repo, message, | ||
scmutil.match(repo[None], pats, opts), opts) | ||||
|
r8407 | |||
|
r16458 | def amend(ui, repo, commitfunc, old, extra, pats, opts): | ||
|
r23101 | # amend will reuse the existing user if not specified, but the obsolete | ||
# marker creation requires that the current user's name is specified. | ||||
if obsolete._enabled: | ||||
ui.username() # raise exception if username not set | ||||
|
r16458 | ui.note(_('amending changeset %s\n') % old) | ||
base = old.p1() | ||||
|
r18197 | wlock = lock = newid = None | ||
|
r16458 | try: | ||
|
r17471 | wlock = repo.wlock() | ||
lock = repo.lock() | ||||
|
r17472 | tr = repo.transaction('amend') | ||
|
r17049 | try: | ||
|
r17473 | # See if we got a message from -m or -l, if not, open the editor | ||
# with the message of the changeset to amend | ||||
message = logmessage(ui, opts) | ||||
|
r17863 | # ensure logfile does not conflict with later enforcement of the | ||
# message. potential logfile content has been processed by | ||||
# `logmessage` anyway. | ||||
opts.pop('logfile') | ||||
|
r17472 | # First, do a regular commit to record all changes in the working | ||
# directory (if there are any) | ||||
ui.callhooks = False | ||||
|
r18198 | currentbookmark = repo._bookmarkcurrent | ||
|
r17472 | try: | ||
|
r18198 | repo._bookmarkcurrent = None | ||
|
r17473 | opts['message'] = 'temporary amend commit for %s' % old | ||
|
r17472 | node = commit(ui, repo, commitfunc, pats, opts) | ||
finally: | ||||
|
r18198 | repo._bookmarkcurrent = currentbookmark | ||
|
r17472 | ui.callhooks = True | ||
ctx = repo[node] | ||||
|
r16458 | |||
|
r17472 | # Participating changesets: | ||
# | ||||
# node/ctx o - new (intermediate) commit that contains changes | ||||
# | from working dir to go into amending commit | ||||
# | (or a workingctx if there were no changes) | ||||
# | | ||||
# old o - changeset to amend | ||||
# | | ||||
# base o - parent of amending changeset | ||||
|
r16458 | |||
|
r17472 | # Update extra dict from amended commit (e.g. to preserve graft | ||
# source) | ||||
extra.update(old.extra()) | ||||
|
r16630 | |||
|
r17472 | # Also update it from the intermediate commit or from the wctx | ||
extra.update(ctx.extra()) | ||||
|
r16630 | |||
|
r18909 | if len(old.parents()) > 1: | ||
# ctx.files() isn't reliable for merges, so fall back to the | ||||
# slower repo.status() method | ||||
files = set([fn for st in repo.status(base, old)[:3] | ||||
for fn in st]) | ||||
else: | ||||
files = set(old.files()) | ||||
|
r16458 | |||
|
r17472 | # Second, we use either the commit we just did, or if there were no | ||
# changes the parent of the working directory as the version of the | ||||
# files in the final amend commit | ||||
if node: | ||||
ui.note(_('copying changeset %s to %s\n') % (ctx, base)) | ||||
|
r16458 | |||
|
r17472 | user = ctx.user() | ||
date = ctx.date() | ||||
# Recompute copies (avoid recording a -> b -> a) | ||||
copied = copies.pathcopies(base, ctx) | ||||
|
r16458 | |||
|
r17472 | # Prune files which were reverted by the updates: if old | ||
# introduced file X and our intermediate commit, node, | ||||
# renamed that file, then those two files are the same and | ||||
# we can discard X from our list of files. Likewise if X | ||||
# was deleted, it's no longer relevant | ||||
files.update(ctx.files()) | ||||
|
r16458 | |||
|
r17472 | def samefile(f): | ||
if f in ctx.manifest(): | ||||
a = ctx.filectx(f) | ||||
if f in base.manifest(): | ||||
b = base.filectx(f) | ||||
return (not a.cmp(b) | ||||
and a.flags() == b.flags()) | ||||
else: | ||||
return False | ||||
|
r16458 | else: | ||
|
r17472 | return f not in base.manifest() | ||
files = [f for f in files if not samefile(f)] | ||||
|
r16458 | |||
|
r17472 | def filectxfn(repo, ctx_, path): | ||
try: | ||||
fctx = ctx[path] | ||||
flags = fctx.flags() | ||||
|
r21689 | mctx = context.memfilectx(repo, | ||
fctx.path(), fctx.data(), | ||||
|
r17472 | islink='l' in flags, | ||
isexec='x' in flags, | ||||
copied=copied.get(path)) | ||||
return mctx | ||||
except KeyError: | ||||
|
r22296 | return None | ||
|
r17472 | else: | ||
ui.note(_('copying changeset %s to %s\n') % (old, base)) | ||||
|
r16458 | |||
|
r17472 | # Use version of files as in the old cset | ||
def filectxfn(repo, ctx_, path): | ||||
try: | ||||
return old.filectx(path) | ||||
except KeyError: | ||||
|
r22296 | return None | ||
|
r16458 | |||
|
r17472 | user = opts.get('user') or old.user() | ||
date = opts.get('date') or old.date() | ||||
|
r22249 | editform = mergeeditform(old, 'commit.amend') | ||
|
r22010 | editor = getcommiteditor(editform=editform, **opts) | ||
|
r17473 | if not message: | ||
|
r22010 | editor = getcommiteditor(edit=True, editform=editform) | ||
|
r17473 | message = old.description() | ||
|
r16458 | |||
|
r17811 | pureextra = extra.copy() | ||
extra['amend_source'] = old.hex() | ||||
|
r17472 | new = context.memctx(repo, | ||
|
r18909 | parents=[base.node(), old.p2().node()], | ||
|
r17472 | text=message, | ||
files=files, | ||||
filectxfn=filectxfn, | ||||
user=user, | ||||
date=date, | ||||
|
r21240 | extra=extra, | ||
editor=editor) | ||||
|
r17811 | |||
newdesc = changelog.stripdesc(new.description()) | ||||
if ((not node) | ||||
and newdesc == old.description() | ||||
and user == old.user() | ||||
and date == old.date() | ||||
and pureextra == old.extra()): | ||||
# nothing changed. continuing here would create a new node | ||||
# anyway because of the amend_source noise. | ||||
# | ||||
# This not what we expect from amend. | ||||
return old.node() | ||||
|
r17472 | ph = repo.ui.config('phases', 'new-commit', phases.draft) | ||
try: | ||||
|
r20700 | if opts.get('secret'): | ||
commitphase = 'secret' | ||||
else: | ||||
commitphase = old.phase() | ||||
|
r20790 | repo.ui.setconfig('phases', 'new-commit', commitphase, 'amend') | ||
|
r17472 | newid = repo.commitctx(new) | ||
finally: | ||||
|
r20790 | repo.ui.setconfig('phases', 'new-commit', ph, 'amend') | ||
|
r17472 | if newid != old.node(): | ||
# Reroute the working copy parent to the new changeset | ||||
repo.setparents(newid, nullid) | ||||
# Move bookmarks from old parent to amend commit | ||||
bms = repo.nodebookmarks(old.node()) | ||||
if bms: | ||||
|
r17922 | marks = repo._bookmarks | ||
|
r17472 | for bm in bms: | ||
|
r17922 | marks[bm] = newid | ||
marks.write() | ||||
|
r17472 | #commit the whole amend process | ||
|
r22951 | createmarkers = obsolete.isenabled(repo, obsolete.createmarkersopt) | ||
if createmarkers and newid != old.node(): | ||||
|
r17475 | # mark the new changeset as successor of the rewritten one | ||
new = repo[newid] | ||||
obs = [(old, (new,))] | ||||
if node: | ||||
|
r17812 | obs.append((ctx, ())) | ||
|
r17475 | |||
obsolete.createmarkers(repo, obs) | ||||
|
r17472 | tr.close() | ||
|
r17461 | finally: | ||
|
r17472 | tr.release() | ||
|
r22951 | if not createmarkers and newid != old.node(): | ||
|
r17475 | # Strip the intermediate commit (if there was one) and the amended | ||
# commit | ||||
|
r17471 | if node: | ||
ui.note(_('stripping intermediate changeset %s\n') % ctx) | ||||
ui.note(_('stripping amended changeset %s\n') % old) | ||||
repair.strip(ui, repo, old.node(), topic='amend-backup') | ||||
|
r16458 | finally: | ||
|
r18197 | if newid is None: | ||
repo.dirstate.invalidate() | ||||
|
r19024 | lockmod.release(lock, wlock) | ||
|
r16458 | return newid | ||
|
r21999 | def commiteditor(repo, ctx, subs, editform=''): | ||
|
r8407 | if ctx.description(): | ||
return ctx.description() | ||||
|
r21999 | return commitforceeditor(repo, ctx, subs, editform=editform) | ||
|
r8407 | |||
|
r21999 | def commitforceeditor(repo, ctx, subs, finishdesc=None, extramsg=None, | ||
editform=''): | ||||
|
r21923 | if not extramsg: | ||
extramsg = _("Leave message empty to abort commit.") | ||||
|
r22012 | |||
forms = [e for e in editform.split('.') if e] | ||||
forms.insert(0, 'changeset') | ||||
while forms: | ||||
tmpl = repo.ui.config('committemplate', '.'.join(forms)) | ||||
if tmpl: | ||||
committext = buildcommittemplate(repo, ctx, subs, extramsg, tmpl) | ||||
break | ||||
forms.pop() | ||||
|
r21924 | else: | ||
committext = buildcommittext(repo, ctx, subs, extramsg) | ||||
|
r21869 | |||
# run editor in the repository root | ||||
olddir = os.getcwd() | ||||
os.chdir(repo.root) | ||||
|
r22205 | text = repo.ui.edit(committext, ctx.user(), ctx.extra(), editform=editform) | ||
|
r21869 | text = re.sub("(?m)^HG:.*(\n|$)", "", text) | ||
os.chdir(olddir) | ||||
if finishdesc: | ||||
text = finishdesc(text) | ||||
if not text.strip(): | ||||
raise util.Abort(_("empty commit message")) | ||||
return text | ||||
|
r21924 | 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, inst: | ||||
raise util.Abort(inst.args[0]) | ||||
|
r22013 | for k, v in repo.ui.configitems('committemplate'): | ||
if k != 'changeset': | ||||
t.t.cache[k] = v | ||||
|
r21924 | if not extramsg: | ||
extramsg = '' # ensure that extramsg is string | ||||
ui.pushbuffer() | ||||
t.show(ctx, extramsg=extramsg) | ||||
return ui.popbuffer() | ||||
|
r21869 | def buildcommittext(repo, ctx, subs, extramsg): | ||
|
r8407 | edittext = [] | ||
|
r8707 | modified, added, removed = ctx.modified(), ctx.added(), ctx.removed() | ||
|
r8407 | if ctx.description(): | ||
edittext.append(ctx.description()) | ||||
edittext.append("") | ||||
edittext.append("") # Empty line between message and comments. | ||||
edittext.append(_("HG: Enter commit message." | ||||
" Lines beginning with 'HG:' are removed.")) | ||||
|
r21923 | edittext.append("HG: %s" % extramsg) | ||
|
r8407 | edittext.append("HG: --") | ||
edittext.append(_("HG: user: %s") % ctx.user()) | ||||
if ctx.p2(): | ||||
edittext.append(_("HG: branch merge")) | ||||
if ctx.branch(): | ||||
|
r13047 | edittext.append(_("HG: branch '%s'") % ctx.branch()) | ||
|
r18538 | if bookmarks.iscurrent(repo): | ||
edittext.append(_("HG: bookmark '%s'") % repo._bookmarkcurrent) | ||||
|
r8994 | edittext.extend([_("HG: subrepo %s") % s for s in subs]) | ||
|
r8407 | edittext.extend([_("HG: added %s") % f for f in added]) | ||
|
r8707 | edittext.extend([_("HG: changed %s") % f for f in modified]) | ||
|
r8407 | edittext.extend([_("HG: removed %s") % f for f in removed]) | ||
|
r8707 | if not added and not modified and not removed: | ||
|
r8407 | edittext.append(_("HG: no files changed")) | ||
edittext.append("") | ||||
|
r21869 | return "\n".join(edittext) | ||
|
r14297 | |||
|
r18688 | def commitstatus(repo, node, branch, bheads=None, opts={}): | ||
ctx = repo[node] | ||||
parents = ctx.parents() | ||||
if (not opts.get('amend') and bheads and node not in bheads and not | ||||
[x for x in parents if x.node() in bheads and x.branch() == branch]): | ||||
repo.ui.status(_('created new head\n')) | ||||
# The message is not printed for initial roots. For the other | ||||
# changesets, it is printed in the following situations: | ||||
# | ||||
# Par column: for the 2 parents with ... | ||||
# N: null or no parent | ||||
# B: parent is on another named branch | ||||
# C: parent is a regular non head changeset | ||||
# H: parent was a branch head of the current branch | ||||
# Msg column: whether we print "created new head" message | ||||
# In the following, it is assumed that there already exists some | ||||
# initial branch heads of the current branch, otherwise nothing is | ||||
# printed anyway. | ||||
# | ||||
# Par Msg Comment | ||||
# N N y additional topo root | ||||
# | ||||
# B N y additional branch root | ||||
# C N y additional topo head | ||||
# H N n usual case | ||||
# | ||||
# B B y weird additional branch root | ||||
# C B y branch merge | ||||
# H B n merge with named branch | ||||
# | ||||
# C C y additional head from merge | ||||
# C H n merge with a head | ||||
# | ||||
# H H n head merge: head count decreases | ||||
if not opts.get('close_branch'): | ||||
for r in parents: | ||||
if r.closesbranch() and r.branch() == branch: | ||||
repo.ui.status(_('reopening closed branch head %d\n') % r) | ||||
if repo.ui.debugflag: | ||||
repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx.hex())) | ||||
elif repo.ui.verbose: | ||||
repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx)) | ||||
|
r16304 | def revert(ui, repo, ctx, parents, *pats, **opts): | ||
parent, p2 = parents | ||||
node = ctx.node() | ||||
mf = ctx.manifest() | ||||
|
r21579 | if node == p2: | ||
parent = p2 | ||||
|
r16304 | if node == parent: | ||
pmf = mf | ||||
else: | ||||
pmf = None | ||||
# need all matching names in dirstate and manifest of target rev, | ||||
# so have to walk both. do not print errors if files exist in one | ||||
# but not other. | ||||
|
r21575 | # `names` is a mapping for all elements in working copy and target revision | ||
# The mapping is in the form: | ||||
# <asb path in repo> -> (<path from CWD>, <exactly specified by matcher?>) | ||||
|
r16304 | names = {} | ||
wlock = repo.wlock() | ||||
try: | ||||
|
r21575 | ## filling of the `names` mapping | ||
# walk dirstate to fill `names` | ||||
|
r16304 | |||
m = scmutil.match(repo[None], pats, opts) | ||||
|
r22573 | if not m.always() or node != parent: | ||
m.bad = lambda x, y: False | ||||
for abs in repo.walk(m): | ||||
names[abs] = m.rel(abs), m.exact(abs) | ||||
# walk target manifest to fill `names` | ||||
def badfn(path, msg): | ||||
if path in names: | ||||
return | ||||
if path in ctx.substate: | ||||
|
r16304 | return | ||
|
r22573 | path_ = path + '/' | ||
for f in names: | ||||
if f.startswith(path_): | ||||
return | ||||
ui.warn("%s: %s\n" % (m.rel(path), msg)) | ||||
m = scmutil.match(ctx, pats, opts) | ||||
m.bad = badfn | ||||
for abs in ctx.walk(m): | ||||
if abs not in names: | ||||
names[abs] = m.rel(abs), m.exact(abs) | ||||
# Find status of all file in `names`. | ||||
m = scmutil.matchfiles(repo, names) | ||||
changes = repo.status(node1=node, match=m, | ||||
unknown=True, ignored=True, clean=True) | ||||
else: | ||||
changes = repo.status(match=m) | ||||
for kind in changes: | ||||
for abs in kind: | ||||
names[abs] = m.rel(abs), m.exact(abs) | ||||
m = scmutil.matchfiles(repo, names) | ||||
|
r22155 | modified = set(changes[0]) | ||
added = set(changes[1]) | ||||
removed = set(changes[2]) | ||||
|
r22236 | _deleted = set(changes[3]) | ||
unknown = set(changes[4]) | ||||
unknown.update(changes[5]) | ||||
|
r22186 | clean = set(changes[6]) | ||
|
r22610 | modadded = set() | ||
|
r22185 | |||
# split between files known in target manifest and the others | ||||
smf = set(mf) | ||||
# determine the exact nature of the deleted changesets | ||||
|
r22490 | deladded = _deleted - smf | ||
deleted = _deleted - deladded | ||||
|
r22155 | |||
|
r23139 | # We need to account for the state of file in the dirstate. | ||
|
r22155 | # | ||
|
r23139 | # Even, when we revert against something else than parent. This will | ||
|
r22155 | # slightly alter the behavior of revert (doing back up or not, delete | ||
|
r23139 | # or just forget etc). | ||
|
r22155 | if parent == node: | ||
dsmodified = modified | ||||
dsadded = added | ||||
dsremoved = removed | ||||
modified, added, removed = set(), set(), set() | ||||
else: | ||||
changes = repo.status(node1=parent, match=m) | ||||
dsmodified = set(changes[0]) | ||||
dsadded = set(changes[1]) | ||||
dsremoved = set(changes[2]) | ||||
|
r16304 | |||
|
r22188 | # only take into account for removes between wc and target | ||
clean |= dsremoved - removed | ||||
dsremoved &= removed | ||||
# distinct between dirstate remove and other | ||||
removed -= dsremoved | ||||
|
r22610 | modadded = added & dsmodified | ||
added -= modadded | ||||
|
r22190 | # tell newly modified apart. | ||
dsmodified &= modified | ||||
dsmodified |= modified & dsadded # dirstate added may needs backup | ||||
modified -= dsmodified | ||||
|
r22488 | # We need to wait for some post-processing to update this set | ||
# before making the distinction. The dirstate will be used for | ||||
# that purpose. | ||||
|
r22208 | dsadded = added | ||
|
r22209 | # in case of merge, files that are actually added can be reported as | ||
# modified, we need to post process the result | ||||
if p2 != nullid: | ||||
if pmf is None: | ||||
# only need parent manifest in the merge case, | ||||
# so do not read by default | ||||
pmf = repo[parent].manifest() | ||||
mergeadd = dsmodified - set(pmf) | ||||
dsadded |= mergeadd | ||||
dsmodified -= mergeadd | ||||
|
r16304 | |||
|
r21575 | # if f is a rename, update `names` to also revert the source | ||
|
r16304 | cwd = repo.getcwd() | ||
|
r22154 | for f in dsadded: | ||
|
r16304 | src = repo.dirstate.copied(f) | ||
|
r22213 | # XXX should we check for rename down to target node? | ||
|
r16304 | if src and src not in names and repo.dirstate[src] == 'r': | ||
|
r22154 | dsremoved.add(src) | ||
|
r16304 | names[src] = (repo.pathto(src, cwd), True) | ||
|
r22488 | # distinguish between file to forget and the other | ||
added = set() | ||||
for abs in dsadded: | ||||
if repo.dirstate[abs] != 'a': | ||||
added.add(abs) | ||||
dsadded -= added | ||||
|
r22490 | for abs in deladded: | ||
|
r16304 | if repo.dirstate[abs] == 'a': | ||
|
r22490 | dsadded.add(abs) | ||
deladded -= dsadded | ||||
|
r22396 | # For files marked as removed, we check if an unknown file is present at | ||
# the same path. If a such file exists it may need to be backed up. | ||||
# Making the distinction at this stage helps have simpler backup | ||||
# logic. | ||||
removunk = set() | ||||
for abs in removed: | ||||
target = repo.wjoin(abs) | ||||
if os.path.lexists(target): | ||||
removunk.add(abs) | ||||
removed -= removunk | ||||
dsremovunk = set() | ||||
for abs in dsremoved: | ||||
target = repo.wjoin(abs) | ||||
if os.path.lexists(target): | ||||
dsremovunk.add(abs) | ||||
dsremoved -= dsremovunk | ||||
|
r16304 | |||
|
r21575 | # action to be actually performed by revert | ||
# (<list of file>, message>) tuple | ||||
|
r21576 | actions = {'revert': ([], _('reverting %s\n')), | ||
'add': ([], _('adding %s\n')), | ||||
|
r22489 | 'remove': ([], _('removing %s\n')), | ||
|
r22491 | 'drop': ([], _('removing %s\n')), | ||
|
r22489 | 'forget': ([], _('forgetting %s\n')), | ||
|
r22231 | 'undelete': ([], _('undeleting %s\n')), | ||
|
r22234 | 'noop': (None, _('no changes needed to %s\n')), | ||
|
r22236 | 'unknown': (None, _('file not managed: %s\n')), | ||
|
r22231 | } | ||
|
r16304 | |||
|
r22608 | # "constant" that convey the backup strategy. | ||
# All set to `discard` if `no-backup` is set do avoid checking | ||||
# no_backup lower in the code. | ||||
|
r22609 | # These values are ordered for comparison purposes | ||
|
r22608 | backup = 2 # unconditionally do backup | ||
|
r22609 | check = 1 # check if the existing file differs from target | ||
|
r22608 | discard = 0 # never do backup | ||
if opts.get('no_backup'): | ||||
|
r22609 | backup = check = discard | ||
|
r16304 | |||
|
r22611 | backupanddel = actions['remove'] | ||
if not opts.get('no_backup'): | ||||
backupanddel = actions['drop'] | ||||
|
r16304 | disptable = ( | ||
# dispatch table: | ||||
# file state | ||||
|
r22153 | # action | ||
# make backup | ||||
|
r22371 | |||
## Sets that results that will change file on disk | ||||
# Modified compared to target, no local change | ||||
|
r22372 | (modified, actions['revert'], discard), | ||
|
r22397 | # Modified compared to target, but local file is deleted | ||
(deleted, actions['revert'], discard), | ||||
|
r22371 | # Modified compared to target, local change | ||
|
r22372 | (dsmodified, actions['revert'], backup), | ||
|
r22371 | # Added since target | ||
|
r22488 | (added, actions['remove'], discard), | ||
# Added in working directory | ||||
|
r22489 | (dsadded, actions['forget'], discard), | ||
|
r22610 | # Added since target, have local modification | ||
|
r22611 | (modadded, backupanddel, backup), | ||
|
r22490 | # Added since target but file is missing in working directory | ||
|
r22491 | (deladded, actions['drop'], discard), | ||
|
r22371 | # Removed since target, before working copy parent | ||
|
r22396 | (removed, actions['add'], discard), | ||
# Same as `removed` but an unknown file exists at the same path | ||||
|
r22609 | (removunk, actions['add'], check), | ||
|
r22371 | # Removed since targe, marked as such in working copy parent | ||
|
r22396 | (dsremoved, actions['undelete'], discard), | ||
# Same as `dsremoved` but an unknown file exists at the same path | ||||
|
r22609 | (dsremovunk, actions['undelete'], check), | ||
|
r22371 | ## the following sets does not result in any file changes | ||
# File with no modification | ||||
|
r22372 | (clean, actions['noop'], discard), | ||
|
r22371 | # Existing file, not tracked anywhere | ||
|
r22372 | (unknown, actions['unknown'], discard), | ||
|
r16304 | ) | ||
|
r22373 | needdata = ('revert', 'add', 'undelete') | ||
|
r22370 | _revertprefetch(repo, ctx, *[actions[name][0] for name in needdata]) | ||
|
r22395 | wctx = repo[None] | ||
|
r16304 | for abs, (rel, exact) in sorted(names.items()): | ||
|
r21575 | # target file to be touch on disk (relative to cwd) | ||
|
r16304 | target = repo.wjoin(abs) | ||
|
r21575 | # search the entry in the dispatch table. | ||
|
r22212 | # if the file is in any of these sets, it was touched in the working | ||
|
r21575 | # directory parent and we are sure it needs to be reverted. | ||
|
r22232 | for table, (xlist, msg), dobackup in disptable: | ||
|
r16304 | if abs not in table: | ||
continue | ||||
|
r22233 | if xlist is not None: | ||
xlist.append(abs) | ||||
|
r22609 | if dobackup and (backup <= dobackup | ||
or wctx[abs].cmp(ctx[abs])): | ||||
bakname = "%s.orig" % rel | ||||
ui.note(_('saving current version of %s as %s\n') % | ||||
(rel, bakname)) | ||||
if not opts.get('dry_run'): | ||||
util.rename(target, bakname) | ||||
|
r22233 | if ui.verbose or not exact: | ||
if not isinstance(msg, basestring): | ||||
msg = msg(abs) | ||||
ui.status(msg % rel) | ||||
elif exact: | ||||
|
r22234 | ui.warn(msg % rel) | ||
|
r16304 | break | ||
|
r21575 | |||
|
r21576 | |||
|
r16304 | if not opts.get('dry_run'): | ||
|
r21576 | _performrevert(repo, parents, ctx, actions) | ||
|
r19129 | |||
|
r22551 | # get the list of subrepos that must be reverted | ||
subrepomatch = scmutil.match(ctx, pats, opts) | ||||
targetsubs = sorted(s for s in ctx.substate if subrepomatch(s)) | ||||
|
r16429 | if targetsubs: | ||
# Revert the subrepos on the revert list | ||||
for sub in targetsubs: | ||||
ctx.sub(sub).revert(ui, ctx.substate[sub], *pats, **opts) | ||||
|
r16304 | finally: | ||
wlock.release() | ||||
|
r22370 | def _revertprefetch(repo, ctx, *files): | ||
"""Let extension changing the storage layer prefetch content""" | ||||
pass | ||||
|
r21576 | def _performrevert(repo, parents, ctx, actions): | ||
"""function that actually perform all the actions computed for revert | ||||
|
r20571 | |||
This is an independent function to let extension to plug in and react to | ||||
the imminent revert. | ||||
|
r21024 | Make sure you have the working directory locked when calling this function. | ||
|
r20571 | """ | ||
parent, p2 = parents | ||||
node = ctx.node() | ||||
def checkout(f): | ||||
fc = ctx[f] | ||||
repo.wwrite(f, fc.data(), fc.flags()) | ||||
audit_path = pathutil.pathauditor(repo.root) | ||||
|
r22489 | for f in actions['forget'][0]: | ||
repo.dirstate.drop(f) | ||||
|
r21576 | for f in actions['remove'][0]: | ||
|
r20571 | audit_path(f) | ||
|
r22491 | util.unlinkpath(repo.wjoin(f)) | ||
repo.dirstate.remove(f) | ||||
for f in actions['drop'][0]: | ||||
audit_path(f) | ||||
|
r20571 | repo.dirstate.remove(f) | ||
normal = None | ||||
if node == parent: | ||||
# We're reverting to our parent. If possible, we'd like status | ||||
# to report the file as clean. We have to use normallookup for | ||||
# merges to avoid losing information about merged/dirty files. | ||||
if p2 != nullid: | ||||
normal = repo.dirstate.normallookup | ||||
else: | ||||
normal = repo.dirstate.normal | ||||
|
r21576 | for f in actions['revert'][0]: | ||
|
r20571 | checkout(f) | ||
if normal: | ||||
normal(f) | ||||
|
r21576 | for f in actions['add'][0]: | ||
|
r20571 | checkout(f) | ||
repo.dirstate.add(f) | ||||
normal = repo.dirstate.normallookup | ||||
if node == parent and p2 == nullid: | ||||
normal = repo.dirstate.normal | ||||
|
r21576 | for f in actions['undelete'][0]: | ||
|
r20571 | checkout(f) | ||
normal(f) | ||||
copied = copies.pathcopies(repo[parent], ctx) | ||||
|
r21576 | for f in actions['add'][0] + actions['undelete'][0] + actions['revert'][0]: | ||
|
r20571 | if f in copied: | ||
repo.dirstate.copy(copied[f], f) | ||||
|
r14297 | def command(table): | ||
|
r21766 | """Returns a function object to be used as a decorator for making commands. | ||
This function receives a command table as its argument. The table should | ||||
be a dict. | ||||
The returned function can be used as a decorator for adding commands | ||||
to that command table. This function accepts multiple arguments to define | ||||
a command. | ||||
The first argument is the command name. | ||||
The options argument is an iterable of tuples defining command arguments. | ||||
See ``mercurial.fancyopts.fancyopts()`` for the format of each tuple. | ||||
|
r14297 | |||
|
r21766 | The synopsis argument defines a short, one line summary of how to use the | ||
command. This shows up in the help output. | ||||
|
r21767 | |||
The norepo argument defines whether the command does not require a | ||||
local repository. Most commands operate against a repository, thus the | ||||
default is False. | ||||
|
r21774 | |||
The optionalrepo argument defines whether the command optionally requires | ||||
a local repository. | ||||
|
r21777 | |||
The inferrepo argument defines whether to try to find a repository from the | ||||
command line arguments. If True, arguments will be examined for potential | ||||
repository locations. See ``findrepo()``. If a repository is found, it | ||||
will be used. | ||||
|
r21766 | """ | ||
|
r21777 | def cmd(name, options=(), synopsis=None, norepo=False, optionalrepo=False, | ||
inferrepo=False): | ||||
|
r14297 | def decorator(func): | ||
if synopsis: | ||||
|
r18235 | table[name] = func, list(options), synopsis | ||
|
r14297 | else: | ||
|
r18235 | table[name] = func, list(options) | ||
|
r21767 | |||
if norepo: | ||||
# Avoid import cycle. | ||||
import commands | ||||
commands.norepo += ' %s' % ' '.join(parsealiases(name)) | ||||
|
r21774 | if optionalrepo: | ||
import commands | ||||
commands.optionalrepo += ' %s' % ' '.join(parsealiases(name)) | ||||
|
r21777 | if inferrepo: | ||
import commands | ||||
commands.inferrepo += ' %s' % ' '.join(parsealiases(name)) | ||||
|
r14297 | return func | ||
return decorator | ||||
return cmd | ||||
|
r19211 | |||
|
r21051 | # a list of (ui, repo, otherpeer, opts, missing) functions called by | ||
# commands.outgoing. "missing" is "missing" of the result of | ||||
# "findcommonoutgoing()" | ||||
outgoinghooks = util.hooks() | ||||
|
r19211 | # a list of (ui, repo) functions called by commands.summary | ||
summaryhooks = util.hooks() | ||||
|
r19474 | |||
|
r21047 | # a list of (ui, repo, opts, changes) functions called by commands.summary. | ||
# | ||||
# functions should return tuple of booleans below, if 'changes' is None: | ||||
# (whether-incomings-are-needed, whether-outgoings-are-needed) | ||||
# | ||||
# otherwise, 'changes' is a tuple of tuples below: | ||||
# - (sourceurl, sourcebranch, sourcepeer, incoming) | ||||
# - (desturl, destbranch, destpeer, outgoing) | ||||
summaryremotehooks = util.hooks() | ||||
|
r19474 | # A list of state files kept by multistep operations like graft. | ||
# Since graft cannot be aborted, it is considered 'clearable' by update. | ||||
# note: bisect is intentionally excluded | ||||
|
r19496 | # (state file, clearable, allowcommit, error, hint) | ||
|
r19474 | unfinishedstates = [ | ||
|
r19496 | ('graftstate', True, False, _('graft in progress'), | ||
|
r19482 | _("use 'hg graft --continue' or 'hg update' to abort")), | ||
|
r19496 | ('updatestate', True, False, _('last update was interrupted'), | ||
|
r19482 | _("use 'hg update' to get a consistent checkout")) | ||
|
r19474 | ] | ||
|
r19496 | def checkunfinished(repo, commit=False): | ||
|
r19474 | '''Look for an unfinished multistep operation, like graft, and abort | ||
if found. It's probably good to check this right before | ||||
bailifchanged(). | ||||
''' | ||||
|
r19496 | for f, clearable, allowcommit, msg, hint in unfinishedstates: | ||
if commit and allowcommit: | ||||
continue | ||||
|
r19474 | if repo.vfs.exists(f): | ||
raise util.Abort(msg, hint=hint) | ||||
def clearunfinished(repo): | ||||
'''Check for unfinished operations (as above), and clear the ones | ||||
that are clearable. | ||||
''' | ||||
|
r19496 | for f, clearable, allowcommit, msg, hint in unfinishedstates: | ||
|
r19474 | if not clearable and repo.vfs.exists(f): | ||
raise util.Abort(msg, hint=hint) | ||||
|
r19496 | for f, clearable, allowcommit, msg, hint in unfinishedstates: | ||
|
r19474 | if clearable and repo.vfs.exists(f): | ||
util.unlink(repo.join(f)) | ||||