cmdutil.py
2080 lines
| 75.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 | ||
|
r17922 | import subrepo, context, repair, graphmod, revset, phases, obsolete | ||
|
r17811 | import changelog | ||
|
r18538 | import bookmarks | ||
|
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: | ||||
raise util.Abort(_("outstanding 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 | ||||
|
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, | ||
|
r18613 | seqno=None, revwidth=None, mode='wb', modemap={}, | ||
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) | ||
mode = modemap.get(fn, mode) | ||||
if mode == 'wb': | ||||
modemap[fn] = 'ab' | ||||
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: | ||||
r = repo.changelog | ||||
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): | ||
|
r13971 | abstarget = scmutil.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): | ||||
|
r13971 | abspfx = scmutil.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: | ||||
|
r13971 | abspfx = scmutil.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.''' | ||
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')) | ||||
|
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() | ||||
if opts['pid_file']: | ||||
|
r10012 | mode = appendpid and 'a' or 'w' | ||
fp = open(opts['pid_file'], mode) | ||||
|
r4380 | fp.write(str(os.getpid()) + '\n') | ||
fp.close() | ||||
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() | ||||
|
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] | ||
|
r12176 | for subpath, sub in subrepo.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.''' | ||||
|
r7762 | def __init__(self, ui, repo, patch, diffopts, buffered): | ||
|
r3643 | self.ui = ui | ||
self.repo = repo | ||||
|
r3645 | self.buffered = buffered | ||
self.patch = patch | ||||
|
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') | ||||
|
r15907 | if self.ui.debugflag and ctx.phase(): | ||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r15907 | self.ui.write(_("phase: %s\n") % _(ctx.phasestr()), | ||
label='log.phase') | ||||
|
r3643 | for parent in parents: | ||
|
r17891 | # i18n: column positioning for "hg log" | ||
|
r10819 | self.ui.write(_("parent: %d:%s\n") % parent, | ||
|
r17788 | label='log.parent changeset.%s' % ctx.phasestr()) | ||
|
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: | ||||
matchfn = self.patch | ||||
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 | ||||
|
r3645 | class changeset_templater(changeset_printer): | ||
|
r3643 | '''format changeset information.''' | ||
|
r7762 | def __init__(self, ui, repo, patch, diffopts, mapfile, buffered): | ||
changeset_printer.__init__(self, ui, repo, patch, 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) | ||
|
r10057 | self.cache = {} | ||
|
r3643 | |||
def use_template(self, t): | ||||
'''set template string to use''' | ||||
self.t.cache['changeset'] = t | ||||
|
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'] | ||
|
r7878 | parents = [[('rev', p.rev()), ('node', p.hex())] | ||
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 | |||
|
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 | ||||
|
r3837 | patch = False | ||
|
r11061 | if opts.get('patch') or opts.get('stat'): | ||
|
r14322 | patch = scmutil.matchall(repo) | ||
|
r3837 | |||
|
r3643 | tmpl = opts.get('template') | ||
|
r7967 | style = None | ||
|
r3643 | if tmpl: | ||
tmpl = templater.parsestring(tmpl, quoted=False) | ||||
else: | ||||
|
r7967 | style = opts.get('style') | ||
# ui settings | ||||
if not (tmpl or style): | ||||
tmpl = ui.config('ui', 'logtemplate') | ||||
if tmpl: | ||||
|
r16678 | try: | ||
tmpl = templater.parsestring(tmpl) | ||||
except SyntaxError: | ||||
tmpl = templater.parsestring(tmpl, quoted=False) | ||||
|
r7967 | else: | ||
|
r10249 | style = util.expandpath(ui.config('ui', 'style', '')) | ||
|
r7967 | |||
if not (tmpl or style): | ||||
return changeset_printer(ui, repo, patch, opts, buffered) | ||||
|
r3643 | |||
|
r7967 | mapfile = None | ||
if style and not tmpl: | ||||
mapfile = style | ||||
if not os.path.split(mapfile)[0]: | ||||
mapname = (templater.templatepath('map-cmdline.' + mapfile) | ||||
or templater.templatepath(mapfile)) | ||||
|
r10282 | if mapname: | ||
mapfile = mapname | ||||
|
r7967 | |||
try: | ||||
t = changeset_templater(ui, repo, patch, opts, mapfile, buffered) | ||||
except SyntaxError, inst: | ||||
raise util.Abort(inst.args[0]) | ||||
|
r10282 | if tmpl: | ||
t.use_template(tmpl) | ||||
|
r7967 | return t | ||
|
r3643 | |||
|
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")) | ||||
|
r16776 | def increasingwindows(start, end, windowsize=8, sizelimit=512): | ||
if start < end: | ||||
while start < end: | ||||
yield start, min(windowsize, end - start) | ||||
start += windowsize | ||||
if windowsize < sizelimit: | ||||
windowsize *= 2 | ||||
else: | ||||
while start > end: | ||||
yield start, min(windowsize, start - end - 1) | ||||
start -= windowsize | ||||
if windowsize < sizelimit: | ||||
windowsize *= 2 | ||||
|
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') | ||||
|
r6750 | if not len(repo): | ||
|
r9652 | return [] | ||
|
r17676 | if opts.get('rev'): | ||
revs = scmutil.revrange(repo, opts.get('rev')) | ||||
elif follow: | ||||
revs = repo.revs('reverse(:.)') | ||||
|
r3650 | else: | ||
|
r17676 | revs = list(repo) | ||
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. | ||
|
r8152 | wanted = set(revs) | ||
|
r3650 | copies = [] | ||
|
r9665 | |||
|
r16381 | if not slowpath and match.files(): | ||
|
r11632 | # We only have to read through the filelog to find wanted revisions | ||
|
r11607 | minrev, maxrev = min(revs), max(revs) | ||
|
r11606 | def filerevgen(filelog, last): | ||
|
r11899 | """ | ||
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 | ||||
""" | ||||
|
r6750 | cl_count = len(repo) | ||
|
r11608 | revs = [] | ||
|
r11634 | for j in xrange(0, last + 1): | ||
|
r11608 | 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 | ||||
|
r12971 | if linkrev >= cl_count: | ||
|
r11608 | break | ||
|
r11899 | |||
parentlinkrevs = [] | ||||
for p in filelog.parentrevs(j): | ||||
if p != nullrev: | ||||
parentlinkrevs.append(filelog.linkrev(p)) | ||||
|
r11608 | n = filelog.node(j) | ||
|
r11899 | revs.append((linkrev, parentlinkrevs, | ||
|
r11608 | follow and filelog.renamed(n))) | ||
|
r11901 | return reversed(revs) | ||
|
r3650 | def iterfiles(): | ||
|
r16165 | pctx = repo['.'] | ||
|
r9652 | for filename in match.files(): | ||
|
r16165 | 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 | ||||
|
r3650 | for filename_node in copies: | ||
yield filename_node | ||||
for file_, node in iterfiles(): | ||||
filelog = repo.file(file_) | ||||
|
r6750 | if not len(filelog): | ||
|
r6536 | if node is None: | ||
# A zero count may be a directory or deleted file, so | ||||
# try to find matching entries on the slow path. | ||||
|
r7404 | if follow: | ||
|
r10282 | raise util.Abort( | ||
_('cannot follow nonexistent file: "%s"') % file_) | ||||
|
r6536 | slowpath = True | ||
break | ||||
else: | ||||
continue | ||||
|
r11606 | |||
if node is None: | ||||
last = len(filelog) - 1 | ||||
else: | ||||
last = filelog.rev(node) | ||||
|
r11899 | |||
# 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): | ||||
|
r12972 | 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) | ||||
|
r11899 | |||
|
r11901 | fncache.setdefault(rev, []).append(file_) | ||
|
r11607 | wanted.add(rev) | ||
if copied: | ||||
copies.append(copied) | ||||
|
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, otherwise simply return | ||||
if slowpath: | ||||
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. | ||||
|
r11631 | for i in sorted(revs): | ||
|
r11609 | ctx = change(i) | ||
|
r9652 | matches = filter(match, ctx.files()) | ||
|
r3650 | if matches: | ||
|
r11609 | fncache[i] = matches | ||
wanted.add(i) | ||||
|
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): | ||
wanted.discard(x) | ||||
|
r3650 | |||
|
r18710 | # Choose a small initial window if we will probably only visit a | ||
# few commits. | ||||
limit = loglimit(opts) | ||||
windowsize = 8 | ||||
if limit: | ||||
windowsize = min(limit, windowsize) | ||||
|
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 | ||||
|
r18710 | for i, window in increasingwindows(0, len(revs), windowsize): | ||
|
r10282 | nrevs = [rev for rev in revs[i:i + window] if want(rev)] | ||
|
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) | ||
|
r9652 | return iterate() | ||
|
r5034 | |||
|
r17180 | def _makegraphfilematcher(repo, pats, followfirst): | ||
# 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['.'] | ||||
wctx = repo[None] | ||||
def populate(): | ||||
for fn in pats: | ||||
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() | ||||
return scmutil.match(wctx, fcache.get(rev, []), default='path') | ||||
return filematcher | ||||
def _makegraphlogrevset(repo, pats, opts, revs): | ||||
"""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... | ||||
startrev = revs[0] | ||||
followdescendants = (len(revs) > 1 and revs[0] < revs[1]) and 1 or 0 | ||||
# 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: | ||||
raise util.Abort(_('cannot follow file not in parent ' | ||||
'revision: "%s"') % f) | ||||
filelog = repo.file(f) | ||||
if not len(filelog): | ||||
# A zero count may be a directory or deleted file, so | ||||
# try to find matching entries on the slow path. | ||||
if follow: | ||||
raise util.Abort( | ||||
_('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. | ||||
# | ||||
if follow: | ||||
raise util.Abort(_('can only follow copies/renames for explicit ' | ||||
'filenames')) | ||||
# 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'): | ||||
if follow: | ||||
filematcher = _makegraphfilematcher(repo, pats, followfirst) | ||||
else: | ||||
filematcher = lambda rev: match | ||||
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']) | ||||
|
r18169 | # Don't sort here because _makegraphlogrevset might depend on the | ||
# order of revs | ||||
possiblyunsorted = True | ||||
|
r17180 | else: | ||
if follow and len(repo) > 0: | ||||
|
r17676 | revs = repo.revs('reverse(:.)') | ||
|
r17180 | else: | ||
|
r17675 | revs = list(repo.changelog) | ||
revs.reverse() | ||||
|
r17180 | if not revs: | ||
|
r18171 | return [], None, None | ||
|
r17180 | expr, filematcher = _makegraphlogrevset(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: | ||
|
r18172 | revs = revs[:limit] | ||
|
r17180 | return revs, expr, filematcher | ||
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'): | ||||
endrev = max(scmutil.revrange(repo, opts.get('rev'))) + 1 | ||||
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) | ||
|
r12269 | for f in repo.walk(match): | ||
exact = match.exact(f) | ||||
|
r15911 | if exact or not explicitonly and f not in repo.dirstate: | ||
|
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 | ||||
|
r18852 | def duplicatecopies(repo, rev, fromrev): | ||
'''reproduce copies from fromrev to rev in the dirstate''' | ||||
for dst, src in copies.pathcopies(repo[fromrev], repo[rev]).iteritems(): | ||||
|
r18853 | # copies.pathcopies returns backward renames, so dst might not | ||
# actually be in the dirstate | ||||
if repo.dirstate[dst] in "nma": | ||||
repo.dirstate.copy(src, dst) | ||||
|
r15214 | |||
|
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): | ||
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() | ||||
mctx = context.memfilectx(fctx.path(), fctx.data(), | ||||
islink='l' in flags, | ||||
isexec='x' in flags, | ||||
copied=copied.get(path)) | ||||
return mctx | ||||
except KeyError: | ||||
raise IOError | ||||
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: | ||||
raise IOError | ||||
|
r16458 | |||
|
r17472 | user = opts.get('user') or old.user() | ||
date = opts.get('date') or old.date() | ||||
|
r17924 | editmsg = False | ||
|
r17473 | if not message: | ||
|
r17924 | editmsg = True | ||
|
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, | ||||
extra=extra) | ||||
|
r17924 | if editmsg: | ||
new._text = commitforceeditor(repo, new, []) | ||||
|
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: | ||||
repo.ui.setconfig('phases', 'new-commit', old.phase()) | ||||
newid = repo.commitctx(new) | ||||
finally: | ||||
repo.ui.setconfig('phases', 'new-commit', ph) | ||||
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 | ||
|
r17475 | if obsolete._enabled and newid != old.node(): | ||
# 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() | ||
|
r17475 | if (not obsolete._enabled) and newid != old.node(): | ||
# 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() | ||||
|
r17471 | lockmod.release(wlock, lock) | ||
|
r16458 | return newid | ||
|
r8994 | def commiteditor(repo, ctx, subs): | ||
|
r8407 | if ctx.description(): | ||
return ctx.description() | ||||
|
r8994 | return commitforceeditor(repo, ctx, subs) | ||
|
r8407 | |||
|
r8994 | def commitforceeditor(repo, ctx, subs): | ||
|
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.")) | ||||
|
r8535 | edittext.append(_("HG: Leave message empty to abort commit.")) | ||
|
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("") | ||||
# run editor in the repository root | ||||
olddir = os.getcwd() | ||||
os.chdir(repo.root) | ||||
text = repo.ui.edit("\n".join(edittext), ctx.user()) | ||||
|
r12900 | text = re.sub("(?m)^HG:.*(\n|$)", "", text) | ||
|
r8407 | os.chdir(olddir) | ||
if not text.strip(): | ||||
raise util.Abort(_("empty commit message")) | ||||
return text | ||||
|
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() | ||||
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. | ||||
names = {} | ||||
wlock = repo.wlock() | ||||
try: | ||||
# walk dirstate. | ||||
m = scmutil.match(repo[None], pats, opts) | ||||
m.bad = lambda x, y: False | ||||
for abs in repo.walk(m): | ||||
names[abs] = m.rel(abs), m.exact(abs) | ||||
# walk target manifest. | ||||
def badfn(path, msg): | ||||
if path in names: | ||||
return | ||||
|
r16583 | if path in ctx.substate: | ||
|
r16304 | return | ||
path_ = path + '/' | ||||
for f in names: | ||||
if f.startswith(path_): | ||||
return | ||||
ui.warn("%s: %s\n" % (m.rel(path), msg)) | ||||
|
r16583 | m = scmutil.match(ctx, pats, opts) | ||
|
r16304 | m.bad = badfn | ||
|
r16583 | for abs in ctx.walk(m): | ||
|
r16304 | if abs not in names: | ||
names[abs] = m.rel(abs), m.exact(abs) | ||||
|
r16430 | # get the list of subrepos that must be reverted | ||
|
r18364 | targetsubs = sorted(s for s in ctx.substate if m(s)) | ||
|
r16304 | m = scmutil.matchfiles(repo, names) | ||
changes = repo.status(match=m)[:4] | ||||
modified, added, removed, deleted = map(set, changes) | ||||
# if f is a rename, also revert the source | ||||
cwd = repo.getcwd() | ||||
for f in added: | ||||
src = repo.dirstate.copied(f) | ||||
if src and src not in names and repo.dirstate[src] == 'r': | ||||
removed.add(src) | ||||
names[src] = (repo.pathto(src, cwd), True) | ||||
def removeforget(abs): | ||||
if repo.dirstate[abs] == 'a': | ||||
return _('forgetting %s\n') | ||||
return _('removing %s\n') | ||||
revert = ([], _('reverting %s\n')) | ||||
add = ([], _('adding %s\n')) | ||||
remove = ([], removeforget) | ||||
undelete = ([], _('undeleting %s\n')) | ||||
disptable = ( | ||||
# dispatch table: | ||||
# file state | ||||
# action if in target manifest | ||||
# action if not in target manifest | ||||
# make backup if in target manifest | ||||
# make backup if not in target manifest | ||||
(modified, revert, remove, True, True), | ||||
(added, revert, remove, True, False), | ||||
(removed, undelete, None, False, False), | ||||
(deleted, revert, remove, False, False), | ||||
) | ||||
for abs, (rel, exact) in sorted(names.items()): | ||||
mfentry = mf.get(abs) | ||||
target = repo.wjoin(abs) | ||||
def handle(xlist, dobackup): | ||||
xlist[0].append(abs) | ||||
if (dobackup and not opts.get('no_backup') and | ||||
os.path.lexists(target)): | ||||
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) | ||||
if ui.verbose or not exact: | ||||
msg = xlist[1] | ||||
if not isinstance(msg, basestring): | ||||
msg = msg(abs) | ||||
ui.status(msg % rel) | ||||
for table, hitlist, misslist, backuphit, backupmiss in disptable: | ||||
if abs not in table: | ||||
continue | ||||
# file has changed in dirstate | ||||
if mfentry: | ||||
handle(hitlist, backuphit) | ||||
elif misslist is not None: | ||||
handle(misslist, backupmiss) | ||||
break | ||||
else: | ||||
if abs not in repo.dirstate: | ||||
if mfentry: | ||||
handle(add, True) | ||||
elif exact: | ||||
ui.warn(_('file not managed: %s\n') % rel) | ||||
continue | ||||
# file has not changed in dirstate | ||||
if node == parent: | ||||
if exact: | ||||
ui.warn(_('no changes needed to %s\n') % rel) | ||||
continue | ||||
if pmf is None: | ||||
# only need parent manifest in this unlikely case, | ||||
# so do not read by default | ||||
pmf = repo[parent].manifest() | ||||
if abs in pmf and mfentry: | ||||
# if version of file is same in parent and target | ||||
# manifests, do nothing | ||||
if (pmf[abs] != mfentry or | ||||
pmf.flags(abs) != mf.flags(abs)): | ||||
handle(revert, False) | ||||
else: | ||||
handle(remove, False) | ||||
if not opts.get('dry_run'): | ||||
def checkout(f): | ||||
fc = ctx[f] | ||||
repo.wwrite(f, fc.data(), fc.flags()) | ||||
audit_path = scmutil.pathauditor(repo.root) | ||||
for f in remove[0]: | ||||
if repo.dirstate[f] == 'a': | ||||
repo.dirstate.drop(f) | ||||
continue | ||||
audit_path(f) | ||||
try: | ||||
util.unlinkpath(repo.wjoin(f)) | ||||
except OSError: | ||||
pass | ||||
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 | ||||
for f in revert[0]: | ||||
checkout(f) | ||||
if normal: | ||||
normal(f) | ||||
for f in add[0]: | ||||
checkout(f) | ||||
repo.dirstate.add(f) | ||||
normal = repo.dirstate.normallookup | ||||
if node == parent and p2 == nullid: | ||||
normal = repo.dirstate.normal | ||||
for f in undelete[0]: | ||||
checkout(f) | ||||
normal(f) | ||||
|
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() | ||||
|
r14297 | def command(table): | ||
'''returns a function object bound to table which can be used as | ||||
a decorator for populating table as a command table''' | ||||
|
r18235 | def cmd(name, options=(), synopsis=None): | ||
|
r14297 | def decorator(func): | ||
if synopsis: | ||||
|
r18235 | table[name] = func, list(options), synopsis | ||
|
r14297 | else: | ||
|
r18235 | table[name] = func, list(options) | ||
|
r14297 | return func | ||
return decorator | ||||
return cmd | ||||