cmdutil.py
1258 lines
| 43.9 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 | ||
# GNU General Public License version 2, incorporated herein by reference. | ||||
|
r2874 | |||
|
r6211 | from node import hex, nullid, nullrev, short | ||
|
r3891 | from i18n import _ | ||
|
r8409 | import os, sys, bisect, stat, errno, re | ||
|
r8390 | import mdiff, bdiff, util, templater, patch, error, encoding | ||
|
r6579 | import match as _match | ||
|
r2874 | |||
|
r3090 | revrangesep = ':' | ||
|
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(): | ||
|
r4549 | aliases = e.lstrip("^").split("|") | ||
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 | |||
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')) | ||||
if limit <= 0: raise util.Abort(_('limit must be positive')) | ||||
else: | ||||
limit = sys.maxint | ||||
return limit | ||||
|
r8188 | def remoteui(src, opts): | ||
'build a remote ui from ui or repo and opts' | ||||
|
r8189 | if hasattr(src, 'baseui'): # looks like a repository | ||
dst = src.baseui # drop repo-specific config | ||||
|
r8188 | src = src.ui # copy target options from repo | ||
|
r8189 | else: # assume it's a global ui object | ||
|
r8188 | dst = src # keep all global options | ||
# copy ssh-specific options | ||||
for o in 'ssh', 'remotecmd': | ||||
v = opts.get(o) or src.config('ui', o) | ||||
if v: | ||||
dst.setconfig("ui", o, v) | ||||
# copy bundle-specific options | ||||
r = src.config('bundle', 'mainreporoot') | ||||
if r: | ||||
dst.setconfig('bundle', 'mainreporoot', r) | ||||
return dst | ||||
|
r4549 | |||
|
r3707 | def revpair(repo, revs): | ||
|
r3090 | '''return pair of nodes, given list of revisions. second item can | ||
be None, meaning use working dir.''' | ||||
|
r3525 | |||
def revfix(repo, val, defval): | ||||
|
r3825 | if not val and val != 0 and defval is not None: | ||
|
r3525 | val = defval | ||
return repo.lookup(val) | ||||
|
r3090 | if not revs: | ||
return repo.dirstate.parents()[0], None | ||||
end = None | ||||
if len(revs) == 1: | ||||
|
r3525 | if revrangesep in revs[0]: | ||
start, end = revs[0].split(revrangesep, 1) | ||||
|
r3090 | start = revfix(repo, start, 0) | ||
|
r6750 | end = revfix(repo, end, len(repo) - 1) | ||
|
r3090 | else: | ||
|
r3525 | start = revfix(repo, revs[0], None) | ||
|
r3090 | elif len(revs) == 2: | ||
if revrangesep in revs[0] or revrangesep in revs[1]: | ||||
raise util.Abort(_('too many revisions specified')) | ||||
start = revfix(repo, revs[0], None) | ||||
end = revfix(repo, revs[1], None) | ||||
else: | ||||
raise util.Abort(_('too many revisions specified')) | ||||
|
r3525 | return start, end | ||
|
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: | ||
if revrangesep in spec: | ||||
start, end = spec.split(revrangesep, 1) | ||||
start = revfix(repo, start, 0) | ||||
|
r6750 | end = revfix(repo, end, len(repo) - 1) | ||
|
r3090 | step = start > end and -1 or 1 | ||
for rev in xrange(start, end+step, step): | ||||
if rev in seen: | ||||
continue | ||||
|
r8368 | seen.add(rev) | ||
|
r3526 | l.append(rev) | ||
|
r3090 | else: | ||
rev = revfix(repo, spec, None) | ||||
if rev in seen: | ||||
continue | ||||
|
r8368 | seen.add(rev) | ||
|
r3526 | l.append(rev) | ||
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: | ||||
|
r3072 | raise util.Abort(_("invalid format spec '%%%s' in output file name") % | ||
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 | |||
|
r6579 | def match(repo, pats=[], opts={}, globbed=False, default='relpath'): | ||
|
r6575 | if not globbed and default == 'relpath': | ||
pats = util.expand_glob(pats or []) | ||||
|
r6579 | m = _match.match(repo.root, repo.getcwd(), pats, | ||
opts.get('include'), opts.get('exclude'), default) | ||||
|
r6578 | def badfn(f, msg): | ||
repo.ui.warn("%s: %s\n" % (m.rel(f), msg)) | ||||
return False | ||||
m.bad = badfn | ||||
|
r6579 | return m | ||
|
r2882 | |||
|
r6597 | def matchall(repo): | ||
return _match.always(repo.root, repo.getcwd()) | ||||
def matchfiles(repo, files): | ||||
return _match.exact(repo.root, repo.getcwd(), files) | ||||
|
r2883 | |||
|
r2958 | def findrenames(repo, added=None, removed=None, threshold=0.5): | ||
|
r4135 | '''find renamed files -- yields (before, after, score) tuples''' | ||
|
r2958 | if added is None or removed is None: | ||
added, removed = repo.status()[1:3] | ||||
|
r6747 | ctx = repo['.'] | ||
|
r2958 | for a in added: | ||
aa = repo.wread(a) | ||||
|
r4135 | bestname, bestscore = None, threshold | ||
|
r2958 | for r in removed: | ||
|
r3971 | rr = ctx.filectx(r).data() | ||
|
r4135 | |||
# bdiff.blocks() returns blocks of matching lines | ||||
# count the number of bytes in each | ||||
equal = 0 | ||||
alines = mdiff.splitnewlines(aa) | ||||
matches = bdiff.blocks(aa, rr) | ||||
for x1,x2,y1,y2 in matches: | ||||
for line in alines[x1:x2]: | ||||
equal += len(line) | ||||
|
r4472 | lengths = len(aa) + len(rr) | ||
if lengths: | ||||
myscore = equal*2.0 / lengths | ||||
if myscore >= bestscore: | ||||
bestname, bestscore = r, myscore | ||||
|
r4135 | if bestname: | ||
|
r2958 | yield bestname, a, bestscore | ||
|
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) | ||||
|
r2883 | add, remove = [], [] | ||
|
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: | ||
|
r2883 | add.append(abs) | ||
if repo.ui.verbose or not exact: | ||||
repo.ui.status(_('adding %s\n') % ((pats and rel) or abs)) | ||||
|
r6651 | if repo.dirstate[abs] != 'r' and (not good or not util.lexists(target) | ||
|
r5487 | or (os.path.isdir(target) and not os.path.islink(target))): | ||
|
r2883 | remove.append(abs) | ||
if repo.ui.verbose or not exact: | ||||
repo.ui.status(_('removing %s\n') % ((pats and rel) or abs)) | ||||
if not dry_run: | ||||
|
r5487 | repo.remove(remove) | ||
|
r4917 | repo.add(add) | ||
|
r2958 | if similarity > 0: | ||
for old, new, score in findrenames(repo, add, remove, similarity): | ||||
|
r8488 | oldexact, newexact = m.exact(old), m.exact(new) | ||
|
r2958 | if repo.ui.verbose or not oldexact or not newexact: | ||
|
r8488 | oldrel, newrel = m.rel(old), m.rel(new) | ||
|
r2958 | repo.ui.status(_('recording removal of %s as rename to %s ' | ||
'(%d%% similar)\n') % | ||||
(oldrel, newrel, score * 100)) | ||||
if not dry_run: | ||||
|
r4917 | repo.copy(old, new) | ||
|
r3643 | |||
|
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") | ||||
|
r5589 | |||
|
r5605 | def walkpat(pat): | ||
srcs = [] | ||||
|
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) | ||||
|
r5605 | if state in '?r': | ||
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 | ||||
|
r5608 | exists = os.path.exists(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: | ||
|
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 | ||||
|
r5605 | origsrc = repo.dirstate.copied(abssrc) or abssrc | ||
|
r5604 | if abstarget == origsrc: # copying back a copy? | ||
|
r5608 | if state not in 'mn' and not dryrun: | ||
repo.dirstate.normallookup(abstarget) | ||||
|
r5604 | else: | ||
|
r7121 | if repo.dirstate[origsrc] == 'a' and origsrc == abssrc: | ||
|
r5589 | 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), reltarget)) | ||||
|
r7121 | if repo.dirstate[abstarget] in '?r' and not dryrun: | ||
|
r5589 | repo.add([abstarget]) | ||
|
r5607 | elif not dryrun: | ||
|
r5589 | repo.copy(origsrc, abstarget) | ||
|
r5610 | |||
if rename and not dryrun: | ||||
|
r6566 | repo.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): | ||||
if util.patkind(pat, None)[0]: | ||||
# 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:]) | ||||
if os.path.exists(t): | ||||
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 | ||||
pats = util.expand_glob(pats) | ||||
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: | ||
if len(pats) > 1 or util.patkind(pats[0], None)[0]: | ||||
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 | |||
|
r5610 | return errors | ||
|
r5589 | |||
|
r4380 | def service(opts, parentfn=None, initfn=None, runfn=None): | ||
'''Run a command as a service.''' | ||||
if opts['daemon'] and not opts['daemon_pipefds']: | ||||
rfd, wfd = os.pipe() | ||||
args = sys.argv[:] | ||||
args.append('--daemon-pipefds=%d,%d' % (rfd, wfd)) | ||||
|
r5797 | # Don't pass --cwd to the child process, because we've already | ||
# changed directory. | ||||
for i in xrange(1,len(args)): | ||||
if args[i].startswith('--cwd='): | ||||
del args[i] | ||||
break | ||||
elif args[i].startswith('--cwd'): | ||||
del args[i:i+2] | ||||
break | ||||
|
r4380 | pid = os.spawnvp(os.P_NOWAIT | getattr(os, 'P_DETACH', 0), | ||
args[0], args) | ||||
os.close(wfd) | ||||
os.read(rfd, 1) | ||||
if parentfn: | ||||
return parentfn(pid) | ||||
else: | ||||
os._exit(0) | ||||
if initfn: | ||||
initfn() | ||||
if opts['pid_file']: | ||||
fp = open(opts['pid_file'], 'w') | ||||
fp.write(str(os.getpid()) + '\n') | ||||
fp.close() | ||||
if opts['daemon_pipefds']: | ||||
rfd, wfd = [int(x) for x in opts['daemon_pipefds'].split(',')] | ||||
os.close(rfd) | ||||
try: | ||||
os.setsid() | ||||
except AttributeError: | ||||
pass | ||||
os.write(wfd, 'y') | ||||
os.close(wfd) | ||||
sys.stdout.flush() | ||||
sys.stderr.flush() | ||||
fd = os.open(util.nulldev, os.O_RDWR) | ||||
if fd != 0: os.dup2(fd, 0) | ||||
if fd != 1: os.dup2(fd, 1) | ||||
if fd != 2: os.dup2(fd, 2) | ||||
if fd not in (0, 1, 2): os.close(fd) | ||||
if runfn: | ||||
return runfn() | ||||
|
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 | ||||
|
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 | |||
|
r7369 | def show(self, ctx, copies=(), **props): | ||
|
r3738 | if self.buffered: | ||
self.ui.pushbuffer() | ||||
|
r7369 | self._show(ctx, copies, props) | ||
self.hunk[ctx.rev()] = self.ui.popbuffer() | ||||
|
r3738 | else: | ||
|
r7369 | self._show(ctx, copies, props) | ||
|
r3738 | |||
|
r7369 | def _show(self, ctx, copies, props): | ||
|
r3643 | '''show a single changeset or file revision''' | ||
|
r7369 | changenode = ctx.node() | ||
rev = ctx.rev() | ||||
|
r3643 | |||
if self.ui.quiet: | ||||
self.ui.write("%d:%s\n" % (rev, short(changenode))) | ||||
return | ||||
|
r7369 | log = self.repo.changelog | ||
|
r3643 | changes = log.read(changenode) | ||
date = util.datestr(changes[2]) | ||||
extra = changes[5] | ||||
branch = extra.get("branch") | ||||
hexfunc = self.ui.debugflag and hex or short | ||||
|
r4825 | parents = [(p, hexfunc(log.node(p))) | ||
for p in self._meaningful_parentrevs(log, rev)] | ||||
|
r3643 | |||
self.ui.write(_("changeset: %d:%s\n") % (rev, hexfunc(changenode))) | ||||
|
r4176 | # don't show the default branch name | ||
if branch != 'default': | ||||
|
r7948 | branch = encoding.tolocal(branch) | ||
|
r3643 | self.ui.write(_("branch: %s\n") % branch) | ||
for tag in self.repo.nodetags(changenode): | ||||
self.ui.write(_("tag: %s\n") % tag) | ||||
for parent in parents: | ||||
self.ui.write(_("parent: %d:%s\n") % parent) | ||||
if self.ui.debugflag: | ||||
self.ui.write(_("manifest: %d:%s\n") % | ||||
(self.repo.manifest.rev(changes[0]), hex(changes[0]))) | ||||
self.ui.write(_("user: %s\n") % changes[1]) | ||||
self.ui.write(_("date: %s\n") % date) | ||||
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: | ||||
self.ui.write("%-12s %s\n" % (key, " ".join(value))) | ||||
elif changes[3] and self.ui.verbose: | ||||
self.ui.write(_("files: %s\n") % " ".join(changes[3])) | ||||
if copies and self.ui.verbose: | ||||
copies = ['%s (%s)' % c for c in copies] | ||||
self.ui.write(_("copies: %s\n") % ' '.join(copies)) | ||||
if extra and self.ui.debugflag: | ||||
|
r8209 | for key, value in sorted(extra.items()): | ||
|
r3643 | self.ui.write(_("extra: %s=%s\n") | ||
% (key, value.encode('string_escape'))) | ||||
description = changes[4].strip() | ||||
if description: | ||||
if self.ui.verbose: | ||||
self.ui.write(_("description:\n")) | ||||
self.ui.write(description) | ||||
self.ui.write("\n\n") | ||||
else: | ||||
self.ui.write(_("summary: %s\n") % | ||||
description.splitlines()[0]) | ||||
self.ui.write("\n") | ||||
|
r3645 | self.showpatch(changenode) | ||
def showpatch(self, node): | ||||
if self.patch: | ||||
prev = self.repo.changelog.parents(node)[0] | ||||
|
r7308 | chunks = patch.diff(self.repo, prev, node, match=self.patch, | ||
|
r7762 | opts=patch.diffopts(self.ui, self.diffopts)) | ||
|
r7308 | for chunk in chunks: | ||
self.ui.write(chunk) | ||||
|
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]) | ||
self.t = templater.templater(mapfile, {'formatnode': formatnode}, | ||||
|
r4352 | cache={ | ||
'parent': '{rev}:{node|formatnode} ', | ||||
'manifest': '{rev}:{node|formatnode}', | ||||
'filecopy': '{name} ({source})'}) | ||||
|
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 | ||||
|
r7369 | def _show(self, ctx, copies, props): | ||
|
r3643 | '''show a single changeset or file revision''' | ||
def showlist(name, values, plural=None, **args): | ||||
'''expand set of values. | ||||
name is name of key in template map. | ||||
values is list of strings or dicts. | ||||
plural is plural of name, if not simply name + 's'. | ||||
expansion works like this, given name 'foo'. | ||||
if values is empty, expand 'no_foos'. | ||||
if 'foo' not in template map, return values as a string, | ||||
joined by space. | ||||
expand 'start_foos'. | ||||
for each value, expand 'foo'. if 'last_foo' in template | ||||
map, expand it instead of 'foo' for last key. | ||||
expand 'end_foos'. | ||||
''' | ||||
if plural: names = plural | ||||
else: names = name + 's' | ||||
if not values: | ||||
noname = 'no_' + names | ||||
if noname in self.t: | ||||
yield self.t(noname, **args) | ||||
return | ||||
if name not in self.t: | ||||
if isinstance(values[0], str): | ||||
yield ' '.join(values) | ||||
else: | ||||
for v in values: | ||||
yield dict(v, **args) | ||||
return | ||||
startname = 'start_' + names | ||||
if startname in self.t: | ||||
yield self.t(startname, **args) | ||||
vargs = args.copy() | ||||
def one(v, tag=name): | ||||
try: | ||||
vargs.update(v) | ||||
except (AttributeError, ValueError): | ||||
try: | ||||
for a, b in v: | ||||
vargs[a] = b | ||||
except ValueError: | ||||
vargs[name] = v | ||||
return self.t(tag, **vargs) | ||||
lastname = 'last_' + name | ||||
if lastname in self.t: | ||||
last = values.pop() | ||||
else: | ||||
last = None | ||||
for v in values: | ||||
yield one(v) | ||||
if last is not None: | ||||
yield one(last, tag=lastname) | ||||
endname = 'end_' + names | ||||
if endname in self.t: | ||||
yield self.t(endname, **args) | ||||
def showbranches(**args): | ||||
|
r7878 | branch = ctx.branch() | ||
|
r4176 | if branch != 'default': | ||
|
r7948 | branch = encoding.tolocal(branch) | ||
|
r3648 | return showlist('branch', [branch], plural='branches', **args) | ||
|
r3643 | |||
def showparents(**args): | ||||
|
r7878 | parents = [[('rev', p.rev()), ('node', p.hex())] | ||
for p in self._meaningful_parentrevs(ctx)] | ||||
|
r3643 | return showlist('parent', parents, **args) | ||
def showtags(**args): | ||||
|
r7878 | return showlist('tag', ctx.tags(), **args) | ||
|
r3643 | |||
def showextras(**args): | ||||
|
r8209 | for key, value in sorted(ctx.extra().items()): | ||
|
r3643 | args = args.copy() | ||
args.update(dict(key=key, value=value)) | ||||
yield self.t('extra', **args) | ||||
def showcopies(**args): | ||||
c = [{'name': x[0], 'source': x[1]} for x in copies] | ||||
return showlist('file_copy', c, plural='file_copies', **args) | ||||
|
r5760 | |||
|
r5545 | files = [] | ||
def getfiles(): | ||||
|
r5760 | if not files: | ||
|
r7878 | files[:] = self.repo.status(ctx.parents()[0].node(), | ||
ctx.node())[:3] | ||||
|
r5545 | return files | ||
|
r5550 | def showfiles(**args): | ||
|
r7878 | return showlist('file', ctx.files(), **args) | ||
|
r5550 | def showmods(**args): | ||
return showlist('file_mod', getfiles()[0], **args) | ||||
|
r5545 | def showadds(**args): | ||
return showlist('file_add', getfiles()[1], **args) | ||||
def showdels(**args): | ||||
return showlist('file_del', getfiles()[2], **args) | ||||
def showmanifest(**args): | ||||
args = args.copy() | ||||
|
r7878 | args.update(dict(rev=self.repo.manifest.rev(ctx.changeset()[0]), | ||
node=hex(ctx.changeset()[0]))) | ||||
|
r5545 | return self.t('manifest', **args) | ||
|
r3643 | |||
|
r7879 | def showdiffstat(**args): | ||
diff = patch.diff(self.repo, ctx.parents()[0].node(), ctx.node()) | ||||
files, adds, removes = 0, 0, 0 | ||||
for i in patch.diffstatdata(util.iterlines(diff)): | ||||
files += 1 | ||||
adds += i[1] | ||||
removes += i[2] | ||||
return '%s: +%s/-%s' % (files, adds, removes) | ||||
|
r3643 | defprops = { | ||
|
r7878 | 'author': ctx.user(), | ||
|
r3643 | 'branches': showbranches, | ||
|
r7878 | 'date': ctx.date(), | ||
'desc': ctx.description().strip(), | ||||
|
r3643 | 'file_adds': showadds, | ||
'file_dels': showdels, | ||||
|
r5550 | 'file_mods': showmods, | ||
|
r3643 | 'files': showfiles, | ||
'file_copies': showcopies, | ||||
'manifest': showmanifest, | ||||
|
r7878 | 'node': ctx.hex(), | ||
|
r3643 | 'parents': showparents, | ||
|
r7878 | 'rev': ctx.rev(), | ||
|
r3643 | 'tags': showtags, | ||
'extras': showextras, | ||||
|
r7879 | 'diffstat': showdiffstat, | ||
|
r3643 | } | ||
props = props.copy() | ||||
props.update(defprops) | ||||
|
r8013 | # find correct templates for current mode | ||
tmplmodes = [ | ||||
(True, None), | ||||
(self.ui.verbose, 'verbose'), | ||||
(self.ui.quiet, 'quiet'), | ||||
(self.ui.debugflag, 'debug'), | ||||
] | ||||
types = {'header': '', 'changeset': 'changeset'} | ||||
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: | ||
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))) | ||
|
r7878 | self.showpatch(ctx.node()) | ||
|
r8013 | |||
|
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: | ||
raise util.Abort(_('%s: %s') % (self.t.mapfile, inst.args[0])) | ||||
|
r3837 | def show_changeset(ui, repo, opts, buffered=False, matchfn=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 | ||
if opts.get('patch'): | ||||
|
r6597 | patch = matchfn or 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: | ||||
style = ui.config('ui', 'style') | ||||
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)) | ||||
if mapname: mapfile = mapname | ||||
try: | ||||
t = changeset_templater(ui, repo, patch, opts, mapfile, buffered) | ||||
except SyntaxError, inst: | ||||
raise util.Abort(inst.args[0]) | ||||
if tmpl: t.use_template(tmpl) | ||||
return t | ||||
|
r3643 | |||
|
r3814 | def finddate(ui, repo, date): | ||
"""Find the tipmost changeset that matches the given date spec""" | ||||
|
r5836 | df = util.matchdate(date) | ||
|
r6747 | get = util.cachefunc(lambda r: repo[r].changeset()) | ||
|
r3814 | changeiter, matchfn = walkchangerevs(ui, repo, [], get, {'rev':None}) | ||
results = {} | ||||
for st, rev, fns in changeiter: | ||||
if st == 'add': | ||||
d = get(rev)[2] | ||||
if df(d[0]): | ||||
results[rev] = d | ||||
elif st == 'iter': | ||||
if rev in results: | ||||
|
r6953 | ui.status(_("Found revision %s from %s\n") % | ||
|
r3814 | (rev, util.datestr(results[rev]))) | ||
return str(rev) | ||||
raise util.Abort(_("revision matching date not found")) | ||||
|
r3650 | def walkchangerevs(ui, repo, pats, change, opts): | ||
|
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. | ||||
This function returns an (iterator, matchfn) tuple. The iterator | ||||
yields 3-tuples. They will be of one of the following forms: | ||||
"window", incrementing, lastrev: stepping through a window, | ||||
positive if walking forwards through revs, last rev in the | ||||
sequence iterated over - use to reset state for the current window | ||||
"add", rev, fns: out-of-order traversal of the given file names | ||||
fns, which changed during revision rev - use to gather data for | ||||
possible display | ||||
"iter", rev, None: in-order traversal of the revs earlier iterated | ||||
over with "add" - use to display data''' | ||||
def increasing_windows(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 | ||||
|
r6580 | m = match(repo, pats, opts) | ||
|
r3650 | follow = opts.get('follow') or opts.get('follow_first') | ||
|
r6750 | if not len(repo): | ||
|
r6580 | return [], m | ||
|
r3650 | |||
if follow: | ||||
|
r6747 | defrange = '%s:0' % repo['.'].rev() | ||
|
r3650 | else: | ||
|
r6145 | defrange = '-1:0' | ||
|
r3707 | revs = revrange(repo, opts['rev'] or [defrange]) | ||
|
r8152 | wanted = set() | ||
|
r7779 | slowpath = m.anypats() or (m.files() and opts.get('removed')) | ||
|
r3650 | fncache = {} | ||
|
r6580 | if not slowpath and not m.files(): | ||
|
r3650 | # No files, no patterns. Display all revs. | ||
|
r8152 | wanted = set(revs) | ||
|
r3650 | copies = [] | ||
if not slowpath: | ||||
# Only files, no patterns. Check the history of each file. | ||||
def filerevgen(filelog, node): | ||||
|
r6750 | cl_count = len(repo) | ||
|
r3650 | if node is None: | ||
|
r6750 | last = len(filelog) - 1 | ||
|
r3650 | else: | ||
last = filelog.rev(node) | ||||
for i, window in increasing_windows(last, nullrev): | ||||
revs = [] | ||||
for j in xrange(i - window, i + 1): | ||||
n = filelog.node(j) | ||||
|
r7361 | revs.append((filelog.linkrev(j), | ||
|
r3650 | follow and filelog.renamed(n))) | ||
|
r8210 | for rev in reversed(revs): | ||
|
r3650 | # only yield rev for which we have the changelog, it can | ||
# happen while doing "hg log" during a pull or commit | ||||
if rev[0] < cl_count: | ||||
yield rev | ||||
def iterfiles(): | ||||
|
r6580 | for filename in m.files(): | ||
|
r3650 | yield filename, None | ||
for filename_node in copies: | ||||
yield filename_node | ||||
minrev, maxrev = min(revs), max(revs) | ||||
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: | ||
raise util.Abort(_('cannot follow nonexistent file: "%s"') % file_) | ||||
|
r6536 | slowpath = True | ||
break | ||||
else: | ||||
|
r6553 | ui.warn(_('%s:%s copy source revision cannot be found!\n') | ||
|
r6536 | % (file_, short(node))) | ||
continue | ||||
|
r3650 | for rev, copied in filerevgen(filelog, node): | ||
if rev <= maxrev: | ||||
if rev < minrev: | ||||
break | ||||
fncache.setdefault(rev, []) | ||||
fncache[rev].append(file_) | ||||
|
r8152 | wanted.add(rev) | ||
|
r3650 | if follow and copied: | ||
copies.append(copied) | ||||
if slowpath: | ||||
if follow: | ||||
raise util.Abort(_('can only follow copies/renames for explicit ' | ||||
'file names')) | ||||
# The slow path checks files modified in every changeset. | ||||
def changerevgen(): | ||||
|
r6750 | for i, window in increasing_windows(len(repo) - 1, nullrev): | ||
|
r3650 | for j in xrange(i - window, i + 1): | ||
yield j, change(j)[3] | ||||
for rev, changefiles in changerevgen(): | ||||
|
r6580 | matches = filter(m, changefiles) | ||
|
r3650 | if matches: | ||
fncache[rev] = matches | ||||
|
r8152 | wanted.add(rev) | ||
|
r3650 | |||
class followfilter: | ||||
def __init__(self, onlyfirst=False): | ||||
self.startrev = nullrev | ||||
self.roots = [] | ||||
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: | ||||
self.roots.append(self.startrev) | ||||
for parent in realparents(rev): | ||||
if parent in self.roots: | ||||
self.roots.append(rev) | ||||
return True | ||||
else: | ||||
# backwards: all parents | ||||
if not self.roots: | ||||
self.roots.extend(realparents(self.startrev)) | ||||
if rev in self.roots: | ||||
self.roots.remove(rev) | ||||
self.roots.extend(realparents(rev)) | ||||
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]) | ||||
for x in xrange(rev, stop-1, -1): | ||||
|
r8152 | if ff.match(x): | ||
wanted.discard(x) | ||||
|
r3650 | |||
def iterate(): | ||||
|
r6580 | if follow and not m.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)): | ||||
yield 'window', revs[0] < revs[-1], revs[-1] | ||||
nrevs = [rev for rev in revs[i:i+window] if want(rev)] | ||||
|
r8209 | for rev in sorted(nrevs): | ||
|
r3650 | fns = fncache.get(rev) | ||
if not fns: | ||||
def fns_generator(): | ||||
for f in change(rev)[3]: | ||||
|
r6580 | if m(f): | ||
|
r3650 | yield f | ||
fns = fns_generator() | ||||
yield 'add', rev, fns | ||||
for rev in nrevs: | ||||
yield 'iter', rev, None | ||||
|
r6580 | return iterate(), m | ||
|
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 | |||
|
r6581 | m = match(repo, pats, opts) | ||
|
r5034 | if pats: | ||
|
r6760 | modified, added, removed = repo.status(match=m)[:3] | ||
|
r8209 | files = sorted(modified + added + removed) | ||
|
r6980 | |||
def is_dir(f): | ||||
name = f + '/' | ||||
i = bisect.bisect(files, name) | ||||
return i < len(files) and files[i].startswith(name) | ||||
|
r6581 | for f in m.files(): | ||
|
r5034 | if f == '.': | ||
continue | ||||
if f not in files: | ||||
rf = repo.wjoin(f) | ||||
|
r6112 | rel = repo.pathto(f) | ||
|
r5034 | try: | ||
mode = os.lstat(rf)[stat.ST_MODE] | ||||
except OSError: | ||||
|
r6980 | if is_dir(f): # deleted directory ? | ||
continue | ||||
|
r6112 | raise util.Abort(_("file %s not found!") % rel) | ||
|
r5034 | if stat.S_ISDIR(mode): | ||
|
r6980 | if not is_dir(f): | ||
|
r5034 | raise util.Abort(_("no match under directory %s!") | ||
|
r6112 | % rel) | ||
|
r5034 | elif not (stat.S_ISREG(mode) or stat.S_ISLNK(mode)): | ||
raise util.Abort(_("can't commit %s: " | ||||
|
r6112 | "unsupported file type!") % rel) | ||
|
r5034 | elif f not in repo.dirstate: | ||
|
r6112 | raise util.Abort(_("file %s not tracked!") % rel) | ||
|
r6597 | m = matchfiles(repo, files) | ||
|
r5034 | try: | ||
|
r6600 | return commitfunc(ui, repo, message, m, opts) | ||
|
r5034 | except ValueError, inst: | ||
raise util.Abort(str(inst)) | ||||
|
r8407 | |||
def commiteditor(repo, ctx, added, updated, removed): | ||||
if ctx.description(): | ||||
return ctx.description() | ||||
return commitforceeditor(repo, ctx, added, updated, removed) | ||||
def commitforceeditor(repo, ctx, added, updated, removed): | ||||
edittext = [] | ||||
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.")) | ||||
edittext.append("HG: --") | ||||
edittext.append(_("HG: user: %s") % ctx.user()) | ||||
if ctx.p2(): | ||||
edittext.append(_("HG: branch merge")) | ||||
if ctx.branch(): | ||||
edittext.append(_("HG: branch '%s'") | ||||
% encoding.tolocal(ctx.branch())) | ||||
edittext.extend([_("HG: added %s") % f for f in added]) | ||||
edittext.extend([_("HG: changed %s") % f for f in updated]) | ||||
edittext.extend([_("HG: removed %s") % f for f in removed]) | ||||
if not added and not updated and not removed: | ||||
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()) | ||||
|
r8409 | text = re.sub("(?m)^HG:.*\n", "", text) | ||
|
r8407 | os.chdir(olddir) | ||
if not text.strip(): | ||||
raise util.Abort(_("empty commit message")) | ||||
return text | ||||