cmdutil.py
1379 lines
| 47.4 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 _ | ||
|
r10463 | import os, sys, errno, re, glob, tempfile | ||
|
r11231 | import util, templater, patch, error, encoding, templatekw | ||
|
r12085 | import match as matchmod | ||
|
r12176 | import similar, revset, subrepo | ||
|
r2874 | |||
|
r3090 | revrangesep = ':' | ||
|
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 = {} | ||||
|
r5178 | for e in table.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 | ||||
|
r4549 | def bail_if_changed(repo): | ||
|
r5716 | if repo.dirstate.parents()[1] != nullid: | ||
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")) | ||||
def logmessage(opts): | ||||
""" 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 == '-': | ||||
message = sys.stdin.read() | ||||
else: | ||||
message = open(logfile).read() | ||||
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 | ||
|
r12619 | def revsingle(repo, revspec, default='.'): | ||
|
r12618 | if not revspec: | ||
return repo[default] | ||||
l = revrange(repo, [revspec]) | ||||
if len(l) < 1: | ||||
|
r12774 | raise util.Abort(_('empty revision set')) | ||
|
r12618 | return repo[l[-1]] | ||
|
r3707 | def revpair(repo, revs): | ||
|
r3090 | if not revs: | ||
return repo.dirstate.parents()[0], None | ||||
|
r12617 | |||
l = revrange(repo, revs) | ||||
if len(l) == 0: | ||||
return repo.dirstate.parents()[0], None | ||||
if len(l) == 1: | ||||
return repo.lookup(l[0]), None | ||||
return repo.lookup(l[0]), repo.lookup(l[-1]) | ||||
|
r3090 | |||
|
r3707 | def revrange(repo, revs): | ||
|
r3090 | """Yield revision as strings from a list of revision specifications.""" | ||
|
r3525 | |||
def revfix(repo, val, defval): | ||||
|
r3718 | if not val and val != 0 and defval is not None: | ||
|
r3525 | return defval | ||
return repo.changelog.rev(repo.lookup(val)) | ||||
|
r8368 | seen, l = set(), [] | ||
|
r3090 | for spec in revs: | ||
|
r11405 | # attempt to parse old-style ranges first to deal with | ||
# things like old-tag which contain query metacharacters | ||||
try: | ||||
|
r12925 | if isinstance(spec, int): | ||
seen.add(spec) | ||||
l.append(spec) | ||||
continue | ||||
|
r11405 | if revrangesep in spec: | ||
start, end = spec.split(revrangesep, 1) | ||||
start = revfix(repo, start, 0) | ||||
end = revfix(repo, end, len(repo) - 1) | ||||
step = start > end and -1 or 1 | ||||
for rev in xrange(start, end + step, step): | ||||
if rev in seen: | ||||
continue | ||||
seen.add(rev) | ||||
l.append(rev) | ||||
continue | ||||
|
r11410 | elif spec and spec in repo: # single unquoted rev | ||
|
r11405 | rev = revfix(repo, spec, None) | ||
|
r3090 | if rev in seen: | ||
continue | ||||
|
r8368 | seen.add(rev) | ||
|
r3526 | l.append(rev) | ||
|
r11410 | continue | ||
|
r11405 | except error.RepoLookupError: | ||
pass | ||||
# fall through to new-style queries if old-style fails | ||||
m = revset.match(spec) | ||||
for r in m(repo, range(len(repo))): | ||||
if r not in seen: | ||||
l.append(r) | ||||
seen.update(l) | ||||
|
r3526 | |||
return l | ||||
|
r3090 | |||
|
r2874 | def make_filename(repo, pat, node, | ||
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), | ||||
} | ||||
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 | |||
def make_file(repo, pat, node=None, | ||||
total=None, seqno=None, revwidth=None, mode='wb', pathname=None): | ||||
|
r7319 | |||
writable = 'w' in mode or 'a' in mode | ||||
|
r2874 | if not pat or pat == '-': | ||
|
r7319 | return writable and sys.stdout or sys.stdin | ||
if hasattr(pat, 'write') and writable: | ||||
|
r2874 | return pat | ||
if hasattr(pat, 'read') and 'r' in mode: | ||||
return pat | ||||
return open(make_filename(repo, pat, node, total, seqno, revwidth, | ||||
pathname), | ||||
mode) | ||||
|
r2882 | |||
|
r8614 | def expandpats(pats): | ||
if not util.expandglobs: | ||||
return list(pats) | ||||
ret = [] | ||||
for p in pats: | ||||
|
r12085 | kind, name = matchmod._patsplit(p, None) | ||
|
r8614 | if kind is None: | ||
|
r9118 | try: | ||
globbed = glob.glob(name) | ||||
except re.error: | ||||
globbed = [name] | ||||
|
r8614 | if globbed: | ||
ret.extend(globbed) | ||||
continue | ||||
ret.append(p) | ||||
return ret | ||||
|
r6579 | def match(repo, pats=[], opts={}, globbed=False, default='relpath'): | ||
|
r6575 | if not globbed and default == 'relpath': | ||
|
r8614 | pats = expandpats(pats or []) | ||
|
r12085 | m = matchmod.match(repo.root, repo.getcwd(), pats, | ||
|
r12164 | opts.get('include'), opts.get('exclude'), default, | ||
auditor=repo.auditor) | ||||
|
r6578 | def badfn(f, msg): | ||
repo.ui.warn("%s: %s\n" % (m.rel(f), msg)) | ||||
m.bad = badfn | ||||
|
r6579 | return m | ||
|
r2882 | |||
|
r6597 | def matchall(repo): | ||
|
r12085 | return matchmod.always(repo.root, repo.getcwd()) | ||
|
r6597 | |||
def matchfiles(repo, files): | ||||
|
r12085 | return matchmod.exact(repo.root, repo.getcwd(), files) | ||
|
r2883 | |||
|
r4917 | def addremove(repo, pats=[], opts={}, dry_run=None, similarity=None): | ||
|
r2883 | if dry_run is None: | ||
dry_run = opts.get('dry_run') | ||||
|
r2958 | if similarity is None: | ||
similarity = float(opts.get('similarity') or 0) | ||||
|
r8990 | # we'd use status here, except handling of symlinks and ignore is tricky | ||
added, unknown, deleted, removed = [], [], [], [] | ||||
|
r6651 | audit_path = util.path_auditor(repo.root) | ||
|
r6579 | m = match(repo, pats, opts) | ||
|
r6586 | for abs in repo.walk(m): | ||
|
r4522 | target = repo.wjoin(abs) | ||
|
r6651 | good = True | ||
try: | ||||
audit_path(abs) | ||||
except: | ||||
good = False | ||||
|
r6584 | rel = m.rel(abs) | ||
exact = m.exact(abs) | ||||
|
r6656 | if good and abs not in repo.dirstate: | ||
|
r8988 | unknown.append(abs) | ||
|
r2883 | if repo.ui.verbose or not exact: | ||
repo.ui.status(_('adding %s\n') % ((pats and rel) or abs)) | ||||
|
r12032 | elif repo.dirstate[abs] != 'r' and (not good or not os.path.lexists(target) | ||
|
r5487 | or (os.path.isdir(target) and not os.path.islink(target))): | ||
|
r8988 | deleted.append(abs) | ||
|
r2883 | if repo.ui.verbose or not exact: | ||
repo.ui.status(_('removing %s\n') % ((pats and rel) or abs)) | ||||
|
r8990 | # for finding renames | ||
elif repo.dirstate[abs] == 'r': | ||||
removed.append(abs) | ||||
elif repo.dirstate[abs] == 'a': | ||||
added.append(abs) | ||||
|
r10606 | copies = {} | ||
|
r2958 | if similarity > 0: | ||
|
r11059 | for old, new, score in similar.findrenames(repo, | ||
added + unknown, removed + deleted, similarity): | ||||
|
r8941 | if repo.ui.verbose or not m.exact(old) or not m.exact(new): | ||
|
r2958 | repo.ui.status(_('recording removal of %s as rename to %s ' | ||
'(%d%% similar)\n') % | ||||
|
r8941 | (m.rel(old), m.rel(new), score * 100)) | ||
|
r10606 | copies[new] = old | ||
if not dry_run: | ||||
|
r11303 | wctx = repo[None] | ||
|
r10606 | wlock = repo.wlock() | ||
try: | ||||
|
r11303 | wctx.remove(deleted) | ||
wctx.add(unknown) | ||||
|
r10606 | for new, old in copies.iteritems(): | ||
|
r11303 | wctx.copy(old, new) | ||
|
r10606 | finally: | ||
wlock.release() | ||||
|
r3643 | |||
|
r12266 | def updatedir(ui, repo, patches, similarity=0): | ||
'''Update dirstate after patch application according to metadata''' | ||||
if not patches: | ||||
return | ||||
copies = [] | ||||
removes = set() | ||||
cfiles = patches.keys() | ||||
cwd = repo.getcwd() | ||||
if cwd: | ||||
cfiles = [util.pathto(repo.root, cwd, f) for f in patches.keys()] | ||||
for f in patches: | ||||
gp = patches[f] | ||||
if not gp: | ||||
continue | ||||
if gp.op == 'RENAME': | ||||
copies.append((gp.oldpath, gp.path)) | ||||
removes.add(gp.oldpath) | ||||
elif gp.op == 'COPY': | ||||
copies.append((gp.oldpath, gp.path)) | ||||
elif gp.op == 'DELETE': | ||||
removes.add(gp.path) | ||||
wctx = repo[None] | ||||
for src, dst in copies: | ||||
|
r12874 | dirstatecopy(ui, repo, wctx, src, dst, cwd=cwd) | ||
|
r12266 | if (not similarity) and removes: | ||
wctx.remove(sorted(removes), True) | ||||
for f in patches: | ||||
gp = patches[f] | ||||
if gp and gp.mode: | ||||
islink, isexec = gp.mode | ||||
dst = repo.wjoin(gp.path) | ||||
# patch won't create empty files | ||||
|
r12357 | if gp.op == 'ADD' and not os.path.lexists(dst): | ||
|
r12266 | flags = (isexec and 'x' or '') + (islink and 'l' or '') | ||
repo.wwrite(gp.path, '', flags) | ||||
util.set_flags(dst, islink, isexec) | ||||
addremove(repo, cfiles, similarity=similarity) | ||||
files = patches.keys() | ||||
files.extend([r for r in removes if r not in files]) | ||||
return sorted(files) | ||||
|
r12874 | def dirstatecopy(ui, repo, wctx, src, dst, dryrun=False, cwd=None): | ||
"""Update the dirstate to reflect the intent of copying src to dst. For | ||||
different reasons it might not end with dst being marked as copied from src. | ||||
""" | ||||
origsrc = repo.dirstate.copied(src) or src | ||||
if dst == origsrc: # copying back a copy? | ||||
if repo.dirstate[dst] not in 'mn' and not dryrun: | ||||
repo.dirstate.normallookup(dst) | ||||
else: | ||||
if repo.dirstate[origsrc] == 'a' and origsrc == src: | ||||
if not ui.quiet: | ||||
ui.warn(_("%s has not been committed yet, so no copy " | ||||
"data will be stored for %s.\n") | ||||
% (repo.pathto(origsrc, cwd), repo.pathto(dst, cwd))) | ||||
if repo.dirstate[dst] in '?r' and not dryrun: | ||||
wctx.add([dst]) | ||||
elif not dryrun: | ||||
wctx.copy(origsrc, dst) | ||||
|
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' | ||
|
r6579 | m = match(repo, [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): | ||
|
r5589 | abstarget = util.canonpath(repo.root, cwd, otarget) | ||
reltarget = repo.pathto(abstarget, cwd) | ||||
|
r5607 | target = repo.wjoin(abstarget) | ||
|
r5589 | src = repo.wjoin(abssrc) | ||
|
r5608 | state = repo.dirstate[abstarget] | ||
|
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) | ||
|
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) | ||||
util.copyfile(src, target) | ||||
|
r5589 | except IOError, inst: | ||
if inst.errno == errno.ENOENT: | ||||
ui.warn(_('%s: deleted in working copy\n') % relsrc) | ||||
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 | ||||
|
r12874 | dirstatecopy(ui, repo, wctx, abssrc, abstarget, dryrun=dryrun, cwd=cwd) | ||
|
r5610 | if rename and not dryrun: | ||
|
r11303 | wctx.remove([abssrc], not after) | ||
|
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): | ||||
abspfx = util.canonpath(repo.root, cwd, pat) | ||||
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: | ||||
abspfx = util.canonpath(repo.root, cwd, pat) | ||||
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 | ||||
|
r8614 | pats = 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 | |||
nullfd = os.open(util.nulldev, os.O_RDWR) | ||||
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]) | ||||
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 | ||||
if not fp: | ||||
fp = make_file(repo, template, node, total=total, seqno=seqno, | ||||
revwidth=revwidth, mode='ab') | ||||
if fp != sys.stdout and hasattr(fp, 'name'): | ||||
repo.ui.note("%s\n" % fp.name) | ||||
fp.write("# HG changeset patch\n") | ||||
fp.write("# User %s\n" % ctx.user()) | ||||
fp.write("# Date %d %d\n" % ctx.date()) | ||||
|
r11821 | if branch and branch != 'default': | ||
|
r10611 | fp.write("# Branch %s\n" % branch) | ||
fp.write("# Node ID %s\n" % hex(node)) | ||||
fp.write("# Parent %s\n" % hex(prev)) | ||||
if len(parents) > 1: | ||||
fp.write("# Parent %s\n" % hex(parents[1])) | ||||
fp.write(ctx.description().rstrip()) | ||||
fp.write("\n\n") | ||||
for chunk in patch.diff(repo, prev, node, opts=opts): | ||||
fp.write(chunk) | ||||
|
r13081 | fp.flush() | ||
|
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): | ||
|
r12167 | if node2 is not None: | ||
|
r12209 | node2 = ctx2.substate[subpath][1] | ||
|
r12167 | submatch = matchmod.narrowmatcher(subpath, match) | ||
sub.diff(diffopts, node2, submatch, changes=changes, | ||||
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 | |||
|
r10819 | self.ui.write(_("changeset: %d:%s\n") % (rev, hexfunc(changenode)), | ||
label='log.changeset') | ||||
|
r3643 | |||
|
r9637 | branch = ctx.branch() | ||
|
r4176 | # don't show the default branch name | ||
if branch != 'default': | ||||
|
r10819 | self.ui.write(_("branch: %s\n") % branch, | ||
label='log.branch') | ||||
|
r3643 | for tag in self.repo.nodetags(changenode): | ||
|
r10819 | self.ui.write(_("tag: %s\n") % tag, | ||
label='log.tag') | ||||
|
r3643 | for parent in parents: | ||
|
r10819 | self.ui.write(_("parent: %d:%s\n") % parent, | ||
label='log.parent') | ||||
|
r3643 | |||
if self.ui.debugflag: | ||||
|
r9547 | mnode = ctx.manifestnode() | ||
|
r3643 | self.ui.write(_("manifest: %d:%s\n") % | ||
|
r10819 | (self.repo.manifest.rev(mnode), hex(mnode)), | ||
label='ui.debug log.manifest') | ||||
self.ui.write(_("user: %s\n") % ctx.user(), | ||||
label='log.user') | ||||
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] | ||||
for key, value in zip([_("files:"), _("files+:"), _("files-:")], | ||||
files): | ||||
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: | ||
|
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] | ||||
|
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()): | ||
|
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: | ||||
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'): | ||
|
r11488 | patch = 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: | ||||
tmpl = templater.parsestring(tmpl) | ||||
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) | ||
|
r9652 | m = 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: | ||||
ui.status(_("Found revision %s from %s\n") % | ||||
(rev, util.datestr(results[rev]))) | ||||
return str(rev) | ||||
|
r3814 | |||
raise util.Abort(_("revision matching date not found")) | ||||
|
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 | |||
def increasing_windows(start, end, windowsize=8, sizelimit=512): | ||||
if start < end: | ||||
while start < end: | ||||
|
r10282 | yield start, min(windowsize, end - start) | ||
|
r3650 | start += windowsize | ||
if windowsize < sizelimit: | ||||
windowsize *= 2 | ||||
else: | ||||
while start > end: | ||||
|
r10282 | yield start, min(windowsize, start - end - 1) | ||
|
r3650 | start -= windowsize | ||
if windowsize < sizelimit: | ||||
windowsize *= 2 | ||||
follow = opts.get('follow') or opts.get('follow_first') | ||||
|
r6750 | if not len(repo): | ||
|
r9652 | return [] | ||
|
r3650 | |||
if follow: | ||||
|
r6747 | defrange = '%s:0' % repo['.'].rev() | ||
|
r3650 | else: | ||
|
r6145 | defrange = '-1:0' | ||
|
r3707 | revs = revrange(repo, opts['rev'] or [defrange]) | ||
|
r11281 | if not revs: | ||
return [] | ||||
|
r8152 | wanted = set() | ||
|
r9652 | slowpath = match.anypats() or (match.files() and opts.get('removed')) | ||
|
r3650 | fncache = {} | ||
|
r9655 | change = util.cachefunc(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 | |||
|
r3650 | if not slowpath: | ||
|
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(): | ||
|
r9652 | for filename in match.files(): | ||
|
r3650 | yield filename, None | ||
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) | ||||
|
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', ()): | ||||
rev = repo.changelog.rev(repo.lookup(rev)) | ||||
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 | |||
|
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 | ||||
for i, window in increasing_windows(0, len(revs)): | ||||
|
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 | |||
|
r12270 | def add(ui, repo, match, dryrun, listsubrepos, prefix): | ||
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] | ||
|
r12269 | for f in repo.walk(match): | ||
exact = match.exact(f) | ||||
if exact or f not in repo.dirstate: | ||||
names.append(f) | ||||
if ui.verbose or not exact: | ||||
|
r12270 | ui.status(_('adding %s\n') % match.rel(join(f))) | ||
if listsubrepos: | ||||
for subpath in wctx.substate: | ||||
sub = wctx.sub(subpath) | ||||
try: | ||||
submatch = matchmod.narrowmatcher(subpath, match) | ||||
bad.extend(sub.add(ui, submatch, dryrun, prefix)) | ||||
except error.LookupError: | ||||
ui.status(_("skipping missing subrepository: %s\n") | ||||
% join(subpath)) | ||||
|
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 | ||||
|
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) | ||||
|
r5034 | message = logmessage(opts) | ||
|
r5829 | # extract addremove carefully -- this function can be called from a command | ||
# that doesn't support addremove | ||||
if opts.get('addremove'): | ||||
|
r5034 | addremove(repo, pats, opts) | ||
|
r5829 | |||
|
r8709 | return commitfunc(ui, repo, message, match(repo, pats, opts), opts) | ||
|
r8407 | |||
|
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()) | ||
|
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 | ||||