##// END OF EJS Templates
py3: convert kwargs' keys to str using pycompat.strkwargs
Pulkit Goyal -
r32289:770bbfdc default
parent child Browse files
Show More
@@ -1,3486 +1,3487 b''
1 # cmdutil.py - help for command processing in mercurial
1 # cmdutil.py - help for command processing in mercurial
2 #
2 #
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version.
6 # GNU General Public License version 2 or any later version.
7
7
8 from __future__ import absolute_import
8 from __future__ import absolute_import
9
9
10 import errno
10 import errno
11 import itertools
11 import itertools
12 import os
12 import os
13 import re
13 import re
14 import tempfile
14 import tempfile
15
15
16 from .i18n import _
16 from .i18n import _
17 from .node import (
17 from .node import (
18 bin,
18 bin,
19 hex,
19 hex,
20 nullid,
20 nullid,
21 nullrev,
21 nullrev,
22 short,
22 short,
23 )
23 )
24
24
25 from . import (
25 from . import (
26 bookmarks,
26 bookmarks,
27 changelog,
27 changelog,
28 copies,
28 copies,
29 crecord as crecordmod,
29 crecord as crecordmod,
30 encoding,
30 encoding,
31 error,
31 error,
32 formatter,
32 formatter,
33 graphmod,
33 graphmod,
34 lock as lockmod,
34 lock as lockmod,
35 match as matchmod,
35 match as matchmod,
36 obsolete,
36 obsolete,
37 patch,
37 patch,
38 pathutil,
38 pathutil,
39 phases,
39 phases,
40 pycompat,
40 pycompat,
41 repair,
41 repair,
42 revlog,
42 revlog,
43 revset,
43 revset,
44 scmutil,
44 scmutil,
45 smartset,
45 smartset,
46 templatekw,
46 templatekw,
47 templater,
47 templater,
48 util,
48 util,
49 vfs as vfsmod,
49 vfs as vfsmod,
50 )
50 )
51 stringio = util.stringio
51 stringio = util.stringio
52
52
53 # special string such that everything below this line will be ingored in the
53 # special string such that everything below this line will be ingored in the
54 # editor text
54 # editor text
55 _linebelow = "^HG: ------------------------ >8 ------------------------$"
55 _linebelow = "^HG: ------------------------ >8 ------------------------$"
56
56
57 def ishunk(x):
57 def ishunk(x):
58 hunkclasses = (crecordmod.uihunk, patch.recordhunk)
58 hunkclasses = (crecordmod.uihunk, patch.recordhunk)
59 return isinstance(x, hunkclasses)
59 return isinstance(x, hunkclasses)
60
60
61 def newandmodified(chunks, originalchunks):
61 def newandmodified(chunks, originalchunks):
62 newlyaddedandmodifiedfiles = set()
62 newlyaddedandmodifiedfiles = set()
63 for chunk in chunks:
63 for chunk in chunks:
64 if ishunk(chunk) and chunk.header.isnewfile() and chunk not in \
64 if ishunk(chunk) and chunk.header.isnewfile() and chunk not in \
65 originalchunks:
65 originalchunks:
66 newlyaddedandmodifiedfiles.add(chunk.header.filename())
66 newlyaddedandmodifiedfiles.add(chunk.header.filename())
67 return newlyaddedandmodifiedfiles
67 return newlyaddedandmodifiedfiles
68
68
69 def parsealiases(cmd):
69 def parsealiases(cmd):
70 return cmd.lstrip("^").split("|")
70 return cmd.lstrip("^").split("|")
71
71
72 def setupwrapcolorwrite(ui):
72 def setupwrapcolorwrite(ui):
73 # wrap ui.write so diff output can be labeled/colorized
73 # wrap ui.write so diff output can be labeled/colorized
74 def wrapwrite(orig, *args, **kw):
74 def wrapwrite(orig, *args, **kw):
75 label = kw.pop('label', '')
75 label = kw.pop('label', '')
76 for chunk, l in patch.difflabel(lambda: args):
76 for chunk, l in patch.difflabel(lambda: args):
77 orig(chunk, label=label + l)
77 orig(chunk, label=label + l)
78
78
79 oldwrite = ui.write
79 oldwrite = ui.write
80 def wrap(*args, **kwargs):
80 def wrap(*args, **kwargs):
81 return wrapwrite(oldwrite, *args, **kwargs)
81 return wrapwrite(oldwrite, *args, **kwargs)
82 setattr(ui, 'write', wrap)
82 setattr(ui, 'write', wrap)
83 return oldwrite
83 return oldwrite
84
84
85 def filterchunks(ui, originalhunks, usecurses, testfile, operation=None):
85 def filterchunks(ui, originalhunks, usecurses, testfile, operation=None):
86 if usecurses:
86 if usecurses:
87 if testfile:
87 if testfile:
88 recordfn = crecordmod.testdecorator(testfile,
88 recordfn = crecordmod.testdecorator(testfile,
89 crecordmod.testchunkselector)
89 crecordmod.testchunkselector)
90 else:
90 else:
91 recordfn = crecordmod.chunkselector
91 recordfn = crecordmod.chunkselector
92
92
93 return crecordmod.filterpatch(ui, originalhunks, recordfn, operation)
93 return crecordmod.filterpatch(ui, originalhunks, recordfn, operation)
94
94
95 else:
95 else:
96 return patch.filterpatch(ui, originalhunks, operation)
96 return patch.filterpatch(ui, originalhunks, operation)
97
97
98 def recordfilter(ui, originalhunks, operation=None):
98 def recordfilter(ui, originalhunks, operation=None):
99 """ Prompts the user to filter the originalhunks and return a list of
99 """ Prompts the user to filter the originalhunks and return a list of
100 selected hunks.
100 selected hunks.
101 *operation* is used for to build ui messages to indicate the user what
101 *operation* is used for to build ui messages to indicate the user what
102 kind of filtering they are doing: reverting, committing, shelving, etc.
102 kind of filtering they are doing: reverting, committing, shelving, etc.
103 (see patch.filterpatch).
103 (see patch.filterpatch).
104 """
104 """
105 usecurses = crecordmod.checkcurses(ui)
105 usecurses = crecordmod.checkcurses(ui)
106 testfile = ui.config('experimental', 'crecordtest', None)
106 testfile = ui.config('experimental', 'crecordtest', None)
107 oldwrite = setupwrapcolorwrite(ui)
107 oldwrite = setupwrapcolorwrite(ui)
108 try:
108 try:
109 newchunks, newopts = filterchunks(ui, originalhunks, usecurses,
109 newchunks, newopts = filterchunks(ui, originalhunks, usecurses,
110 testfile, operation)
110 testfile, operation)
111 finally:
111 finally:
112 ui.write = oldwrite
112 ui.write = oldwrite
113 return newchunks, newopts
113 return newchunks, newopts
114
114
115 def dorecord(ui, repo, commitfunc, cmdsuggest, backupall,
115 def dorecord(ui, repo, commitfunc, cmdsuggest, backupall,
116 filterfn, *pats, **opts):
116 filterfn, *pats, **opts):
117 from . import merge as mergemod
117 from . import merge as mergemod
118 opts = pycompat.byteskwargs(opts)
118 opts = pycompat.byteskwargs(opts)
119 if not ui.interactive():
119 if not ui.interactive():
120 if cmdsuggest:
120 if cmdsuggest:
121 msg = _('running non-interactively, use %s instead') % cmdsuggest
121 msg = _('running non-interactively, use %s instead') % cmdsuggest
122 else:
122 else:
123 msg = _('running non-interactively')
123 msg = _('running non-interactively')
124 raise error.Abort(msg)
124 raise error.Abort(msg)
125
125
126 # make sure username is set before going interactive
126 # make sure username is set before going interactive
127 if not opts.get('user'):
127 if not opts.get('user'):
128 ui.username() # raise exception, username not provided
128 ui.username() # raise exception, username not provided
129
129
130 def recordfunc(ui, repo, message, match, opts):
130 def recordfunc(ui, repo, message, match, opts):
131 """This is generic record driver.
131 """This is generic record driver.
132
132
133 Its job is to interactively filter local changes, and
133 Its job is to interactively filter local changes, and
134 accordingly prepare working directory into a state in which the
134 accordingly prepare working directory into a state in which the
135 job can be delegated to a non-interactive commit command such as
135 job can be delegated to a non-interactive commit command such as
136 'commit' or 'qrefresh'.
136 'commit' or 'qrefresh'.
137
137
138 After the actual job is done by non-interactive command, the
138 After the actual job is done by non-interactive command, the
139 working directory is restored to its original state.
139 working directory is restored to its original state.
140
140
141 In the end we'll record interesting changes, and everything else
141 In the end we'll record interesting changes, and everything else
142 will be left in place, so the user can continue working.
142 will be left in place, so the user can continue working.
143 """
143 """
144
144
145 checkunfinished(repo, commit=True)
145 checkunfinished(repo, commit=True)
146 wctx = repo[None]
146 wctx = repo[None]
147 merge = len(wctx.parents()) > 1
147 merge = len(wctx.parents()) > 1
148 if merge:
148 if merge:
149 raise error.Abort(_('cannot partially commit a merge '
149 raise error.Abort(_('cannot partially commit a merge '
150 '(use "hg commit" instead)'))
150 '(use "hg commit" instead)'))
151
151
152 def fail(f, msg):
152 def fail(f, msg):
153 raise error.Abort('%s: %s' % (f, msg))
153 raise error.Abort('%s: %s' % (f, msg))
154
154
155 force = opts.get('force')
155 force = opts.get('force')
156 if not force:
156 if not force:
157 vdirs = []
157 vdirs = []
158 match.explicitdir = vdirs.append
158 match.explicitdir = vdirs.append
159 match.bad = fail
159 match.bad = fail
160
160
161 status = repo.status(match=match)
161 status = repo.status(match=match)
162 if not force:
162 if not force:
163 repo.checkcommitpatterns(wctx, vdirs, match, status, fail)
163 repo.checkcommitpatterns(wctx, vdirs, match, status, fail)
164 diffopts = patch.difffeatureopts(ui, opts=opts, whitespace=True)
164 diffopts = patch.difffeatureopts(ui, opts=opts, whitespace=True)
165 diffopts.nodates = True
165 diffopts.nodates = True
166 diffopts.git = True
166 diffopts.git = True
167 diffopts.showfunc = True
167 diffopts.showfunc = True
168 originaldiff = patch.diff(repo, changes=status, opts=diffopts)
168 originaldiff = patch.diff(repo, changes=status, opts=diffopts)
169 originalchunks = patch.parsepatch(originaldiff)
169 originalchunks = patch.parsepatch(originaldiff)
170
170
171 # 1. filter patch, since we are intending to apply subset of it
171 # 1. filter patch, since we are intending to apply subset of it
172 try:
172 try:
173 chunks, newopts = filterfn(ui, originalchunks)
173 chunks, newopts = filterfn(ui, originalchunks)
174 except patch.PatchError as err:
174 except patch.PatchError as err:
175 raise error.Abort(_('error parsing patch: %s') % err)
175 raise error.Abort(_('error parsing patch: %s') % err)
176 opts.update(newopts)
176 opts.update(newopts)
177
177
178 # We need to keep a backup of files that have been newly added and
178 # We need to keep a backup of files that have been newly added and
179 # modified during the recording process because there is a previous
179 # modified during the recording process because there is a previous
180 # version without the edit in the workdir
180 # version without the edit in the workdir
181 newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
181 newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
182 contenders = set()
182 contenders = set()
183 for h in chunks:
183 for h in chunks:
184 try:
184 try:
185 contenders.update(set(h.files()))
185 contenders.update(set(h.files()))
186 except AttributeError:
186 except AttributeError:
187 pass
187 pass
188
188
189 changed = status.modified + status.added + status.removed
189 changed = status.modified + status.added + status.removed
190 newfiles = [f for f in changed if f in contenders]
190 newfiles = [f for f in changed if f in contenders]
191 if not newfiles:
191 if not newfiles:
192 ui.status(_('no changes to record\n'))
192 ui.status(_('no changes to record\n'))
193 return 0
193 return 0
194
194
195 modified = set(status.modified)
195 modified = set(status.modified)
196
196
197 # 2. backup changed files, so we can restore them in the end
197 # 2. backup changed files, so we can restore them in the end
198
198
199 if backupall:
199 if backupall:
200 tobackup = changed
200 tobackup = changed
201 else:
201 else:
202 tobackup = [f for f in newfiles if f in modified or f in \
202 tobackup = [f for f in newfiles if f in modified or f in \
203 newlyaddedandmodifiedfiles]
203 newlyaddedandmodifiedfiles]
204 backups = {}
204 backups = {}
205 if tobackup:
205 if tobackup:
206 backupdir = repo.vfs.join('record-backups')
206 backupdir = repo.vfs.join('record-backups')
207 try:
207 try:
208 os.mkdir(backupdir)
208 os.mkdir(backupdir)
209 except OSError as err:
209 except OSError as err:
210 if err.errno != errno.EEXIST:
210 if err.errno != errno.EEXIST:
211 raise
211 raise
212 try:
212 try:
213 # backup continues
213 # backup continues
214 for f in tobackup:
214 for f in tobackup:
215 fd, tmpname = tempfile.mkstemp(prefix=f.replace('/', '_')+'.',
215 fd, tmpname = tempfile.mkstemp(prefix=f.replace('/', '_')+'.',
216 dir=backupdir)
216 dir=backupdir)
217 os.close(fd)
217 os.close(fd)
218 ui.debug('backup %r as %r\n' % (f, tmpname))
218 ui.debug('backup %r as %r\n' % (f, tmpname))
219 util.copyfile(repo.wjoin(f), tmpname, copystat=True)
219 util.copyfile(repo.wjoin(f), tmpname, copystat=True)
220 backups[f] = tmpname
220 backups[f] = tmpname
221
221
222 fp = stringio()
222 fp = stringio()
223 for c in chunks:
223 for c in chunks:
224 fname = c.filename()
224 fname = c.filename()
225 if fname in backups:
225 if fname in backups:
226 c.write(fp)
226 c.write(fp)
227 dopatch = fp.tell()
227 dopatch = fp.tell()
228 fp.seek(0)
228 fp.seek(0)
229
229
230 # 2.5 optionally review / modify patch in text editor
230 # 2.5 optionally review / modify patch in text editor
231 if opts.get('review', False):
231 if opts.get('review', False):
232 patchtext = (crecordmod.diffhelptext
232 patchtext = (crecordmod.diffhelptext
233 + crecordmod.patchhelptext
233 + crecordmod.patchhelptext
234 + fp.read())
234 + fp.read())
235 reviewedpatch = ui.edit(patchtext, "",
235 reviewedpatch = ui.edit(patchtext, "",
236 extra={"suffix": ".diff"},
236 extra={"suffix": ".diff"},
237 repopath=repo.path)
237 repopath=repo.path)
238 fp.truncate(0)
238 fp.truncate(0)
239 fp.write(reviewedpatch)
239 fp.write(reviewedpatch)
240 fp.seek(0)
240 fp.seek(0)
241
241
242 [os.unlink(repo.wjoin(c)) for c in newlyaddedandmodifiedfiles]
242 [os.unlink(repo.wjoin(c)) for c in newlyaddedandmodifiedfiles]
243 # 3a. apply filtered patch to clean repo (clean)
243 # 3a. apply filtered patch to clean repo (clean)
244 if backups:
244 if backups:
245 # Equivalent to hg.revert
245 # Equivalent to hg.revert
246 m = scmutil.matchfiles(repo, backups.keys())
246 m = scmutil.matchfiles(repo, backups.keys())
247 mergemod.update(repo, repo.dirstate.p1(),
247 mergemod.update(repo, repo.dirstate.p1(),
248 False, True, matcher=m)
248 False, True, matcher=m)
249
249
250 # 3b. (apply)
250 # 3b. (apply)
251 if dopatch:
251 if dopatch:
252 try:
252 try:
253 ui.debug('applying patch\n')
253 ui.debug('applying patch\n')
254 ui.debug(fp.getvalue())
254 ui.debug(fp.getvalue())
255 patch.internalpatch(ui, repo, fp, 1, eolmode=None)
255 patch.internalpatch(ui, repo, fp, 1, eolmode=None)
256 except patch.PatchError as err:
256 except patch.PatchError as err:
257 raise error.Abort(str(err))
257 raise error.Abort(str(err))
258 del fp
258 del fp
259
259
260 # 4. We prepared working directory according to filtered
260 # 4. We prepared working directory according to filtered
261 # patch. Now is the time to delegate the job to
261 # patch. Now is the time to delegate the job to
262 # commit/qrefresh or the like!
262 # commit/qrefresh or the like!
263
263
264 # Make all of the pathnames absolute.
264 # Make all of the pathnames absolute.
265 newfiles = [repo.wjoin(nf) for nf in newfiles]
265 newfiles = [repo.wjoin(nf) for nf in newfiles]
266 return commitfunc(ui, repo, *newfiles, **opts)
266 return commitfunc(ui, repo, *newfiles, **opts)
267 finally:
267 finally:
268 # 5. finally restore backed-up files
268 # 5. finally restore backed-up files
269 try:
269 try:
270 dirstate = repo.dirstate
270 dirstate = repo.dirstate
271 for realname, tmpname in backups.iteritems():
271 for realname, tmpname in backups.iteritems():
272 ui.debug('restoring %r to %r\n' % (tmpname, realname))
272 ui.debug('restoring %r to %r\n' % (tmpname, realname))
273
273
274 if dirstate[realname] == 'n':
274 if dirstate[realname] == 'n':
275 # without normallookup, restoring timestamp
275 # without normallookup, restoring timestamp
276 # may cause partially committed files
276 # may cause partially committed files
277 # to be treated as unmodified
277 # to be treated as unmodified
278 dirstate.normallookup(realname)
278 dirstate.normallookup(realname)
279
279
280 # copystat=True here and above are a hack to trick any
280 # copystat=True here and above are a hack to trick any
281 # editors that have f open that we haven't modified them.
281 # editors that have f open that we haven't modified them.
282 #
282 #
283 # Also note that this racy as an editor could notice the
283 # Also note that this racy as an editor could notice the
284 # file's mtime before we've finished writing it.
284 # file's mtime before we've finished writing it.
285 util.copyfile(tmpname, repo.wjoin(realname), copystat=True)
285 util.copyfile(tmpname, repo.wjoin(realname), copystat=True)
286 os.unlink(tmpname)
286 os.unlink(tmpname)
287 if tobackup:
287 if tobackup:
288 os.rmdir(backupdir)
288 os.rmdir(backupdir)
289 except OSError:
289 except OSError:
290 pass
290 pass
291
291
292 def recordinwlock(ui, repo, message, match, opts):
292 def recordinwlock(ui, repo, message, match, opts):
293 with repo.wlock():
293 with repo.wlock():
294 return recordfunc(ui, repo, message, match, opts)
294 return recordfunc(ui, repo, message, match, opts)
295
295
296 return commit(ui, repo, recordinwlock, pats, opts)
296 return commit(ui, repo, recordinwlock, pats, opts)
297
297
298 def findpossible(cmd, table, strict=False):
298 def findpossible(cmd, table, strict=False):
299 """
299 """
300 Return cmd -> (aliases, command table entry)
300 Return cmd -> (aliases, command table entry)
301 for each matching command.
301 for each matching command.
302 Return debug commands (or their aliases) only if no normal command matches.
302 Return debug commands (or their aliases) only if no normal command matches.
303 """
303 """
304 choice = {}
304 choice = {}
305 debugchoice = {}
305 debugchoice = {}
306
306
307 if cmd in table:
307 if cmd in table:
308 # short-circuit exact matches, "log" alias beats "^log|history"
308 # short-circuit exact matches, "log" alias beats "^log|history"
309 keys = [cmd]
309 keys = [cmd]
310 else:
310 else:
311 keys = table.keys()
311 keys = table.keys()
312
312
313 allcmds = []
313 allcmds = []
314 for e in keys:
314 for e in keys:
315 aliases = parsealiases(e)
315 aliases = parsealiases(e)
316 allcmds.extend(aliases)
316 allcmds.extend(aliases)
317 found = None
317 found = None
318 if cmd in aliases:
318 if cmd in aliases:
319 found = cmd
319 found = cmd
320 elif not strict:
320 elif not strict:
321 for a in aliases:
321 for a in aliases:
322 if a.startswith(cmd):
322 if a.startswith(cmd):
323 found = a
323 found = a
324 break
324 break
325 if found is not None:
325 if found is not None:
326 if aliases[0].startswith("debug") or found.startswith("debug"):
326 if aliases[0].startswith("debug") or found.startswith("debug"):
327 debugchoice[found] = (aliases, table[e])
327 debugchoice[found] = (aliases, table[e])
328 else:
328 else:
329 choice[found] = (aliases, table[e])
329 choice[found] = (aliases, table[e])
330
330
331 if not choice and debugchoice:
331 if not choice and debugchoice:
332 choice = debugchoice
332 choice = debugchoice
333
333
334 return choice, allcmds
334 return choice, allcmds
335
335
336 def findcmd(cmd, table, strict=True):
336 def findcmd(cmd, table, strict=True):
337 """Return (aliases, command table entry) for command string."""
337 """Return (aliases, command table entry) for command string."""
338 choice, allcmds = findpossible(cmd, table, strict)
338 choice, allcmds = findpossible(cmd, table, strict)
339
339
340 if cmd in choice:
340 if cmd in choice:
341 return choice[cmd]
341 return choice[cmd]
342
342
343 if len(choice) > 1:
343 if len(choice) > 1:
344 clist = choice.keys()
344 clist = choice.keys()
345 clist.sort()
345 clist.sort()
346 raise error.AmbiguousCommand(cmd, clist)
346 raise error.AmbiguousCommand(cmd, clist)
347
347
348 if choice:
348 if choice:
349 return choice.values()[0]
349 return choice.values()[0]
350
350
351 raise error.UnknownCommand(cmd, allcmds)
351 raise error.UnknownCommand(cmd, allcmds)
352
352
353 def findrepo(p):
353 def findrepo(p):
354 while not os.path.isdir(os.path.join(p, ".hg")):
354 while not os.path.isdir(os.path.join(p, ".hg")):
355 oldp, p = p, os.path.dirname(p)
355 oldp, p = p, os.path.dirname(p)
356 if p == oldp:
356 if p == oldp:
357 return None
357 return None
358
358
359 return p
359 return p
360
360
361 def bailifchanged(repo, merge=True, hint=None):
361 def bailifchanged(repo, merge=True, hint=None):
362 """ enforce the precondition that working directory must be clean.
362 """ enforce the precondition that working directory must be clean.
363
363
364 'merge' can be set to false if a pending uncommitted merge should be
364 'merge' can be set to false if a pending uncommitted merge should be
365 ignored (such as when 'update --check' runs).
365 ignored (such as when 'update --check' runs).
366
366
367 'hint' is the usual hint given to Abort exception.
367 'hint' is the usual hint given to Abort exception.
368 """
368 """
369
369
370 if merge and repo.dirstate.p2() != nullid:
370 if merge and repo.dirstate.p2() != nullid:
371 raise error.Abort(_('outstanding uncommitted merge'), hint=hint)
371 raise error.Abort(_('outstanding uncommitted merge'), hint=hint)
372 modified, added, removed, deleted = repo.status()[:4]
372 modified, added, removed, deleted = repo.status()[:4]
373 if modified or added or removed or deleted:
373 if modified or added or removed or deleted:
374 raise error.Abort(_('uncommitted changes'), hint=hint)
374 raise error.Abort(_('uncommitted changes'), hint=hint)
375 ctx = repo[None]
375 ctx = repo[None]
376 for s in sorted(ctx.substate):
376 for s in sorted(ctx.substate):
377 ctx.sub(s).bailifchanged(hint=hint)
377 ctx.sub(s).bailifchanged(hint=hint)
378
378
379 def logmessage(ui, opts):
379 def logmessage(ui, opts):
380 """ get the log message according to -m and -l option """
380 """ get the log message according to -m and -l option """
381 message = opts.get('message')
381 message = opts.get('message')
382 logfile = opts.get('logfile')
382 logfile = opts.get('logfile')
383
383
384 if message and logfile:
384 if message and logfile:
385 raise error.Abort(_('options --message and --logfile are mutually '
385 raise error.Abort(_('options --message and --logfile are mutually '
386 'exclusive'))
386 'exclusive'))
387 if not message and logfile:
387 if not message and logfile:
388 try:
388 try:
389 if logfile == '-':
389 if logfile == '-':
390 message = ui.fin.read()
390 message = ui.fin.read()
391 else:
391 else:
392 message = '\n'.join(util.readfile(logfile).splitlines())
392 message = '\n'.join(util.readfile(logfile).splitlines())
393 except IOError as inst:
393 except IOError as inst:
394 raise error.Abort(_("can't read commit message '%s': %s") %
394 raise error.Abort(_("can't read commit message '%s': %s") %
395 (logfile, inst.strerror))
395 (logfile, inst.strerror))
396 return message
396 return message
397
397
398 def mergeeditform(ctxorbool, baseformname):
398 def mergeeditform(ctxorbool, baseformname):
399 """return appropriate editform name (referencing a committemplate)
399 """return appropriate editform name (referencing a committemplate)
400
400
401 'ctxorbool' is either a ctx to be committed, or a bool indicating whether
401 'ctxorbool' is either a ctx to be committed, or a bool indicating whether
402 merging is committed.
402 merging is committed.
403
403
404 This returns baseformname with '.merge' appended if it is a merge,
404 This returns baseformname with '.merge' appended if it is a merge,
405 otherwise '.normal' is appended.
405 otherwise '.normal' is appended.
406 """
406 """
407 if isinstance(ctxorbool, bool):
407 if isinstance(ctxorbool, bool):
408 if ctxorbool:
408 if ctxorbool:
409 return baseformname + ".merge"
409 return baseformname + ".merge"
410 elif 1 < len(ctxorbool.parents()):
410 elif 1 < len(ctxorbool.parents()):
411 return baseformname + ".merge"
411 return baseformname + ".merge"
412
412
413 return baseformname + ".normal"
413 return baseformname + ".normal"
414
414
415 def getcommiteditor(edit=False, finishdesc=None, extramsg=None,
415 def getcommiteditor(edit=False, finishdesc=None, extramsg=None,
416 editform='', **opts):
416 editform='', **opts):
417 """get appropriate commit message editor according to '--edit' option
417 """get appropriate commit message editor according to '--edit' option
418
418
419 'finishdesc' is a function to be called with edited commit message
419 'finishdesc' is a function to be called with edited commit message
420 (= 'description' of the new changeset) just after editing, but
420 (= 'description' of the new changeset) just after editing, but
421 before checking empty-ness. It should return actual text to be
421 before checking empty-ness. It should return actual text to be
422 stored into history. This allows to change description before
422 stored into history. This allows to change description before
423 storing.
423 storing.
424
424
425 'extramsg' is a extra message to be shown in the editor instead of
425 'extramsg' is a extra message to be shown in the editor instead of
426 'Leave message empty to abort commit' line. 'HG: ' prefix and EOL
426 'Leave message empty to abort commit' line. 'HG: ' prefix and EOL
427 is automatically added.
427 is automatically added.
428
428
429 'editform' is a dot-separated list of names, to distinguish
429 'editform' is a dot-separated list of names, to distinguish
430 the purpose of commit text editing.
430 the purpose of commit text editing.
431
431
432 'getcommiteditor' returns 'commitforceeditor' regardless of
432 'getcommiteditor' returns 'commitforceeditor' regardless of
433 'edit', if one of 'finishdesc' or 'extramsg' is specified, because
433 'edit', if one of 'finishdesc' or 'extramsg' is specified, because
434 they are specific for usage in MQ.
434 they are specific for usage in MQ.
435 """
435 """
436 if edit or finishdesc or extramsg:
436 if edit or finishdesc or extramsg:
437 return lambda r, c, s: commitforceeditor(r, c, s,
437 return lambda r, c, s: commitforceeditor(r, c, s,
438 finishdesc=finishdesc,
438 finishdesc=finishdesc,
439 extramsg=extramsg,
439 extramsg=extramsg,
440 editform=editform)
440 editform=editform)
441 elif editform:
441 elif editform:
442 return lambda r, c, s: commiteditor(r, c, s, editform=editform)
442 return lambda r, c, s: commiteditor(r, c, s, editform=editform)
443 else:
443 else:
444 return commiteditor
444 return commiteditor
445
445
446 def loglimit(opts):
446 def loglimit(opts):
447 """get the log limit according to option -l/--limit"""
447 """get the log limit according to option -l/--limit"""
448 limit = opts.get('limit')
448 limit = opts.get('limit')
449 if limit:
449 if limit:
450 try:
450 try:
451 limit = int(limit)
451 limit = int(limit)
452 except ValueError:
452 except ValueError:
453 raise error.Abort(_('limit must be a positive integer'))
453 raise error.Abort(_('limit must be a positive integer'))
454 if limit <= 0:
454 if limit <= 0:
455 raise error.Abort(_('limit must be positive'))
455 raise error.Abort(_('limit must be positive'))
456 else:
456 else:
457 limit = None
457 limit = None
458 return limit
458 return limit
459
459
460 def makefilename(repo, pat, node, desc=None,
460 def makefilename(repo, pat, node, desc=None,
461 total=None, seqno=None, revwidth=None, pathname=None):
461 total=None, seqno=None, revwidth=None, pathname=None):
462 node_expander = {
462 node_expander = {
463 'H': lambda: hex(node),
463 'H': lambda: hex(node),
464 'R': lambda: str(repo.changelog.rev(node)),
464 'R': lambda: str(repo.changelog.rev(node)),
465 'h': lambda: short(node),
465 'h': lambda: short(node),
466 'm': lambda: re.sub('[^\w]', '_', str(desc))
466 'm': lambda: re.sub('[^\w]', '_', str(desc))
467 }
467 }
468 expander = {
468 expander = {
469 '%': lambda: '%',
469 '%': lambda: '%',
470 'b': lambda: os.path.basename(repo.root),
470 'b': lambda: os.path.basename(repo.root),
471 }
471 }
472
472
473 try:
473 try:
474 if node:
474 if node:
475 expander.update(node_expander)
475 expander.update(node_expander)
476 if node:
476 if node:
477 expander['r'] = (lambda:
477 expander['r'] = (lambda:
478 str(repo.changelog.rev(node)).zfill(revwidth or 0))
478 str(repo.changelog.rev(node)).zfill(revwidth or 0))
479 if total is not None:
479 if total is not None:
480 expander['N'] = lambda: str(total)
480 expander['N'] = lambda: str(total)
481 if seqno is not None:
481 if seqno is not None:
482 expander['n'] = lambda: str(seqno)
482 expander['n'] = lambda: str(seqno)
483 if total is not None and seqno is not None:
483 if total is not None and seqno is not None:
484 expander['n'] = lambda: str(seqno).zfill(len(str(total)))
484 expander['n'] = lambda: str(seqno).zfill(len(str(total)))
485 if pathname is not None:
485 if pathname is not None:
486 expander['s'] = lambda: os.path.basename(pathname)
486 expander['s'] = lambda: os.path.basename(pathname)
487 expander['d'] = lambda: os.path.dirname(pathname) or '.'
487 expander['d'] = lambda: os.path.dirname(pathname) or '.'
488 expander['p'] = lambda: pathname
488 expander['p'] = lambda: pathname
489
489
490 newname = []
490 newname = []
491 patlen = len(pat)
491 patlen = len(pat)
492 i = 0
492 i = 0
493 while i < patlen:
493 while i < patlen:
494 c = pat[i:i + 1]
494 c = pat[i:i + 1]
495 if c == '%':
495 if c == '%':
496 i += 1
496 i += 1
497 c = pat[i:i + 1]
497 c = pat[i:i + 1]
498 c = expander[c]()
498 c = expander[c]()
499 newname.append(c)
499 newname.append(c)
500 i += 1
500 i += 1
501 return ''.join(newname)
501 return ''.join(newname)
502 except KeyError as inst:
502 except KeyError as inst:
503 raise error.Abort(_("invalid format spec '%%%s' in output filename") %
503 raise error.Abort(_("invalid format spec '%%%s' in output filename") %
504 inst.args[0])
504 inst.args[0])
505
505
506 class _unclosablefile(object):
506 class _unclosablefile(object):
507 def __init__(self, fp):
507 def __init__(self, fp):
508 self._fp = fp
508 self._fp = fp
509
509
510 def close(self):
510 def close(self):
511 pass
511 pass
512
512
513 def __iter__(self):
513 def __iter__(self):
514 return iter(self._fp)
514 return iter(self._fp)
515
515
516 def __getattr__(self, attr):
516 def __getattr__(self, attr):
517 return getattr(self._fp, attr)
517 return getattr(self._fp, attr)
518
518
519 def __enter__(self):
519 def __enter__(self):
520 return self
520 return self
521
521
522 def __exit__(self, exc_type, exc_value, exc_tb):
522 def __exit__(self, exc_type, exc_value, exc_tb):
523 pass
523 pass
524
524
525 def makefileobj(repo, pat, node=None, desc=None, total=None,
525 def makefileobj(repo, pat, node=None, desc=None, total=None,
526 seqno=None, revwidth=None, mode='wb', modemap=None,
526 seqno=None, revwidth=None, mode='wb', modemap=None,
527 pathname=None):
527 pathname=None):
528
528
529 writable = mode not in ('r', 'rb')
529 writable = mode not in ('r', 'rb')
530
530
531 if not pat or pat == '-':
531 if not pat or pat == '-':
532 if writable:
532 if writable:
533 fp = repo.ui.fout
533 fp = repo.ui.fout
534 else:
534 else:
535 fp = repo.ui.fin
535 fp = repo.ui.fin
536 return _unclosablefile(fp)
536 return _unclosablefile(fp)
537 if util.safehasattr(pat, 'write') and writable:
537 if util.safehasattr(pat, 'write') and writable:
538 return pat
538 return pat
539 if util.safehasattr(pat, 'read') and 'r' in mode:
539 if util.safehasattr(pat, 'read') and 'r' in mode:
540 return pat
540 return pat
541 fn = makefilename(repo, pat, node, desc, total, seqno, revwidth, pathname)
541 fn = makefilename(repo, pat, node, desc, total, seqno, revwidth, pathname)
542 if modemap is not None:
542 if modemap is not None:
543 mode = modemap.get(fn, mode)
543 mode = modemap.get(fn, mode)
544 if mode == 'wb':
544 if mode == 'wb':
545 modemap[fn] = 'ab'
545 modemap[fn] = 'ab'
546 return open(fn, mode)
546 return open(fn, mode)
547
547
548 def openrevlog(repo, cmd, file_, opts):
548 def openrevlog(repo, cmd, file_, opts):
549 """opens the changelog, manifest, a filelog or a given revlog"""
549 """opens the changelog, manifest, a filelog or a given revlog"""
550 cl = opts['changelog']
550 cl = opts['changelog']
551 mf = opts['manifest']
551 mf = opts['manifest']
552 dir = opts['dir']
552 dir = opts['dir']
553 msg = None
553 msg = None
554 if cl and mf:
554 if cl and mf:
555 msg = _('cannot specify --changelog and --manifest at the same time')
555 msg = _('cannot specify --changelog and --manifest at the same time')
556 elif cl and dir:
556 elif cl and dir:
557 msg = _('cannot specify --changelog and --dir at the same time')
557 msg = _('cannot specify --changelog and --dir at the same time')
558 elif cl or mf or dir:
558 elif cl or mf or dir:
559 if file_:
559 if file_:
560 msg = _('cannot specify filename with --changelog or --manifest')
560 msg = _('cannot specify filename with --changelog or --manifest')
561 elif not repo:
561 elif not repo:
562 msg = _('cannot specify --changelog or --manifest or --dir '
562 msg = _('cannot specify --changelog or --manifest or --dir '
563 'without a repository')
563 'without a repository')
564 if msg:
564 if msg:
565 raise error.Abort(msg)
565 raise error.Abort(msg)
566
566
567 r = None
567 r = None
568 if repo:
568 if repo:
569 if cl:
569 if cl:
570 r = repo.unfiltered().changelog
570 r = repo.unfiltered().changelog
571 elif dir:
571 elif dir:
572 if 'treemanifest' not in repo.requirements:
572 if 'treemanifest' not in repo.requirements:
573 raise error.Abort(_("--dir can only be used on repos with "
573 raise error.Abort(_("--dir can only be used on repos with "
574 "treemanifest enabled"))
574 "treemanifest enabled"))
575 dirlog = repo.manifestlog._revlog.dirlog(dir)
575 dirlog = repo.manifestlog._revlog.dirlog(dir)
576 if len(dirlog):
576 if len(dirlog):
577 r = dirlog
577 r = dirlog
578 elif mf:
578 elif mf:
579 r = repo.manifestlog._revlog
579 r = repo.manifestlog._revlog
580 elif file_:
580 elif file_:
581 filelog = repo.file(file_)
581 filelog = repo.file(file_)
582 if len(filelog):
582 if len(filelog):
583 r = filelog
583 r = filelog
584 if not r:
584 if not r:
585 if not file_:
585 if not file_:
586 raise error.CommandError(cmd, _('invalid arguments'))
586 raise error.CommandError(cmd, _('invalid arguments'))
587 if not os.path.isfile(file_):
587 if not os.path.isfile(file_):
588 raise error.Abort(_("revlog '%s' not found") % file_)
588 raise error.Abort(_("revlog '%s' not found") % file_)
589 r = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False),
589 r = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False),
590 file_[:-2] + ".i")
590 file_[:-2] + ".i")
591 return r
591 return r
592
592
593 def copy(ui, repo, pats, opts, rename=False):
593 def copy(ui, repo, pats, opts, rename=False):
594 # called with the repo lock held
594 # called with the repo lock held
595 #
595 #
596 # hgsep => pathname that uses "/" to separate directories
596 # hgsep => pathname that uses "/" to separate directories
597 # ossep => pathname that uses os.sep to separate directories
597 # ossep => pathname that uses os.sep to separate directories
598 cwd = repo.getcwd()
598 cwd = repo.getcwd()
599 targets = {}
599 targets = {}
600 after = opts.get("after")
600 after = opts.get("after")
601 dryrun = opts.get("dry_run")
601 dryrun = opts.get("dry_run")
602 wctx = repo[None]
602 wctx = repo[None]
603
603
604 def walkpat(pat):
604 def walkpat(pat):
605 srcs = []
605 srcs = []
606 if after:
606 if after:
607 badstates = '?'
607 badstates = '?'
608 else:
608 else:
609 badstates = '?r'
609 badstates = '?r'
610 m = scmutil.match(repo[None], [pat], opts, globbed=True)
610 m = scmutil.match(repo[None], [pat], opts, globbed=True)
611 for abs in repo.walk(m):
611 for abs in repo.walk(m):
612 state = repo.dirstate[abs]
612 state = repo.dirstate[abs]
613 rel = m.rel(abs)
613 rel = m.rel(abs)
614 exact = m.exact(abs)
614 exact = m.exact(abs)
615 if state in badstates:
615 if state in badstates:
616 if exact and state == '?':
616 if exact and state == '?':
617 ui.warn(_('%s: not copying - file is not managed\n') % rel)
617 ui.warn(_('%s: not copying - file is not managed\n') % rel)
618 if exact and state == 'r':
618 if exact and state == 'r':
619 ui.warn(_('%s: not copying - file has been marked for'
619 ui.warn(_('%s: not copying - file has been marked for'
620 ' remove\n') % rel)
620 ' remove\n') % rel)
621 continue
621 continue
622 # abs: hgsep
622 # abs: hgsep
623 # rel: ossep
623 # rel: ossep
624 srcs.append((abs, rel, exact))
624 srcs.append((abs, rel, exact))
625 return srcs
625 return srcs
626
626
627 # abssrc: hgsep
627 # abssrc: hgsep
628 # relsrc: ossep
628 # relsrc: ossep
629 # otarget: ossep
629 # otarget: ossep
630 def copyfile(abssrc, relsrc, otarget, exact):
630 def copyfile(abssrc, relsrc, otarget, exact):
631 abstarget = pathutil.canonpath(repo.root, cwd, otarget)
631 abstarget = pathutil.canonpath(repo.root, cwd, otarget)
632 if '/' in abstarget:
632 if '/' in abstarget:
633 # We cannot normalize abstarget itself, this would prevent
633 # We cannot normalize abstarget itself, this would prevent
634 # case only renames, like a => A.
634 # case only renames, like a => A.
635 abspath, absname = abstarget.rsplit('/', 1)
635 abspath, absname = abstarget.rsplit('/', 1)
636 abstarget = repo.dirstate.normalize(abspath) + '/' + absname
636 abstarget = repo.dirstate.normalize(abspath) + '/' + absname
637 reltarget = repo.pathto(abstarget, cwd)
637 reltarget = repo.pathto(abstarget, cwd)
638 target = repo.wjoin(abstarget)
638 target = repo.wjoin(abstarget)
639 src = repo.wjoin(abssrc)
639 src = repo.wjoin(abssrc)
640 state = repo.dirstate[abstarget]
640 state = repo.dirstate[abstarget]
641
641
642 scmutil.checkportable(ui, abstarget)
642 scmutil.checkportable(ui, abstarget)
643
643
644 # check for collisions
644 # check for collisions
645 prevsrc = targets.get(abstarget)
645 prevsrc = targets.get(abstarget)
646 if prevsrc is not None:
646 if prevsrc is not None:
647 ui.warn(_('%s: not overwriting - %s collides with %s\n') %
647 ui.warn(_('%s: not overwriting - %s collides with %s\n') %
648 (reltarget, repo.pathto(abssrc, cwd),
648 (reltarget, repo.pathto(abssrc, cwd),
649 repo.pathto(prevsrc, cwd)))
649 repo.pathto(prevsrc, cwd)))
650 return
650 return
651
651
652 # check for overwrites
652 # check for overwrites
653 exists = os.path.lexists(target)
653 exists = os.path.lexists(target)
654 samefile = False
654 samefile = False
655 if exists and abssrc != abstarget:
655 if exists and abssrc != abstarget:
656 if (repo.dirstate.normalize(abssrc) ==
656 if (repo.dirstate.normalize(abssrc) ==
657 repo.dirstate.normalize(abstarget)):
657 repo.dirstate.normalize(abstarget)):
658 if not rename:
658 if not rename:
659 ui.warn(_("%s: can't copy - same file\n") % reltarget)
659 ui.warn(_("%s: can't copy - same file\n") % reltarget)
660 return
660 return
661 exists = False
661 exists = False
662 samefile = True
662 samefile = True
663
663
664 if not after and exists or after and state in 'mn':
664 if not after and exists or after and state in 'mn':
665 if not opts['force']:
665 if not opts['force']:
666 if state in 'mn':
666 if state in 'mn':
667 msg = _('%s: not overwriting - file already committed\n')
667 msg = _('%s: not overwriting - file already committed\n')
668 if after:
668 if after:
669 flags = '--after --force'
669 flags = '--after --force'
670 else:
670 else:
671 flags = '--force'
671 flags = '--force'
672 if rename:
672 if rename:
673 hint = _('(hg rename %s to replace the file by '
673 hint = _('(hg rename %s to replace the file by '
674 'recording a rename)\n') % flags
674 'recording a rename)\n') % flags
675 else:
675 else:
676 hint = _('(hg copy %s to replace the file by '
676 hint = _('(hg copy %s to replace the file by '
677 'recording a copy)\n') % flags
677 'recording a copy)\n') % flags
678 else:
678 else:
679 msg = _('%s: not overwriting - file exists\n')
679 msg = _('%s: not overwriting - file exists\n')
680 if rename:
680 if rename:
681 hint = _('(hg rename --after to record the rename)\n')
681 hint = _('(hg rename --after to record the rename)\n')
682 else:
682 else:
683 hint = _('(hg copy --after to record the copy)\n')
683 hint = _('(hg copy --after to record the copy)\n')
684 ui.warn(msg % reltarget)
684 ui.warn(msg % reltarget)
685 ui.warn(hint)
685 ui.warn(hint)
686 return
686 return
687
687
688 if after:
688 if after:
689 if not exists:
689 if not exists:
690 if rename:
690 if rename:
691 ui.warn(_('%s: not recording move - %s does not exist\n') %
691 ui.warn(_('%s: not recording move - %s does not exist\n') %
692 (relsrc, reltarget))
692 (relsrc, reltarget))
693 else:
693 else:
694 ui.warn(_('%s: not recording copy - %s does not exist\n') %
694 ui.warn(_('%s: not recording copy - %s does not exist\n') %
695 (relsrc, reltarget))
695 (relsrc, reltarget))
696 return
696 return
697 elif not dryrun:
697 elif not dryrun:
698 try:
698 try:
699 if exists:
699 if exists:
700 os.unlink(target)
700 os.unlink(target)
701 targetdir = os.path.dirname(target) or '.'
701 targetdir = os.path.dirname(target) or '.'
702 if not os.path.isdir(targetdir):
702 if not os.path.isdir(targetdir):
703 os.makedirs(targetdir)
703 os.makedirs(targetdir)
704 if samefile:
704 if samefile:
705 tmp = target + "~hgrename"
705 tmp = target + "~hgrename"
706 os.rename(src, tmp)
706 os.rename(src, tmp)
707 os.rename(tmp, target)
707 os.rename(tmp, target)
708 else:
708 else:
709 util.copyfile(src, target)
709 util.copyfile(src, target)
710 srcexists = True
710 srcexists = True
711 except IOError as inst:
711 except IOError as inst:
712 if inst.errno == errno.ENOENT:
712 if inst.errno == errno.ENOENT:
713 ui.warn(_('%s: deleted in working directory\n') % relsrc)
713 ui.warn(_('%s: deleted in working directory\n') % relsrc)
714 srcexists = False
714 srcexists = False
715 else:
715 else:
716 ui.warn(_('%s: cannot copy - %s\n') %
716 ui.warn(_('%s: cannot copy - %s\n') %
717 (relsrc, inst.strerror))
717 (relsrc, inst.strerror))
718 return True # report a failure
718 return True # report a failure
719
719
720 if ui.verbose or not exact:
720 if ui.verbose or not exact:
721 if rename:
721 if rename:
722 ui.status(_('moving %s to %s\n') % (relsrc, reltarget))
722 ui.status(_('moving %s to %s\n') % (relsrc, reltarget))
723 else:
723 else:
724 ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
724 ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
725
725
726 targets[abstarget] = abssrc
726 targets[abstarget] = abssrc
727
727
728 # fix up dirstate
728 # fix up dirstate
729 scmutil.dirstatecopy(ui, repo, wctx, abssrc, abstarget,
729 scmutil.dirstatecopy(ui, repo, wctx, abssrc, abstarget,
730 dryrun=dryrun, cwd=cwd)
730 dryrun=dryrun, cwd=cwd)
731 if rename and not dryrun:
731 if rename and not dryrun:
732 if not after and srcexists and not samefile:
732 if not after and srcexists and not samefile:
733 repo.wvfs.unlinkpath(abssrc)
733 repo.wvfs.unlinkpath(abssrc)
734 wctx.forget([abssrc])
734 wctx.forget([abssrc])
735
735
736 # pat: ossep
736 # pat: ossep
737 # dest ossep
737 # dest ossep
738 # srcs: list of (hgsep, hgsep, ossep, bool)
738 # srcs: list of (hgsep, hgsep, ossep, bool)
739 # return: function that takes hgsep and returns ossep
739 # return: function that takes hgsep and returns ossep
740 def targetpathfn(pat, dest, srcs):
740 def targetpathfn(pat, dest, srcs):
741 if os.path.isdir(pat):
741 if os.path.isdir(pat):
742 abspfx = pathutil.canonpath(repo.root, cwd, pat)
742 abspfx = pathutil.canonpath(repo.root, cwd, pat)
743 abspfx = util.localpath(abspfx)
743 abspfx = util.localpath(abspfx)
744 if destdirexists:
744 if destdirexists:
745 striplen = len(os.path.split(abspfx)[0])
745 striplen = len(os.path.split(abspfx)[0])
746 else:
746 else:
747 striplen = len(abspfx)
747 striplen = len(abspfx)
748 if striplen:
748 if striplen:
749 striplen += len(pycompat.ossep)
749 striplen += len(pycompat.ossep)
750 res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
750 res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
751 elif destdirexists:
751 elif destdirexists:
752 res = lambda p: os.path.join(dest,
752 res = lambda p: os.path.join(dest,
753 os.path.basename(util.localpath(p)))
753 os.path.basename(util.localpath(p)))
754 else:
754 else:
755 res = lambda p: dest
755 res = lambda p: dest
756 return res
756 return res
757
757
758 # pat: ossep
758 # pat: ossep
759 # dest ossep
759 # dest ossep
760 # srcs: list of (hgsep, hgsep, ossep, bool)
760 # srcs: list of (hgsep, hgsep, ossep, bool)
761 # return: function that takes hgsep and returns ossep
761 # return: function that takes hgsep and returns ossep
762 def targetpathafterfn(pat, dest, srcs):
762 def targetpathafterfn(pat, dest, srcs):
763 if matchmod.patkind(pat):
763 if matchmod.patkind(pat):
764 # a mercurial pattern
764 # a mercurial pattern
765 res = lambda p: os.path.join(dest,
765 res = lambda p: os.path.join(dest,
766 os.path.basename(util.localpath(p)))
766 os.path.basename(util.localpath(p)))
767 else:
767 else:
768 abspfx = pathutil.canonpath(repo.root, cwd, pat)
768 abspfx = pathutil.canonpath(repo.root, cwd, pat)
769 if len(abspfx) < len(srcs[0][0]):
769 if len(abspfx) < len(srcs[0][0]):
770 # A directory. Either the target path contains the last
770 # A directory. Either the target path contains the last
771 # component of the source path or it does not.
771 # component of the source path or it does not.
772 def evalpath(striplen):
772 def evalpath(striplen):
773 score = 0
773 score = 0
774 for s in srcs:
774 for s in srcs:
775 t = os.path.join(dest, util.localpath(s[0])[striplen:])
775 t = os.path.join(dest, util.localpath(s[0])[striplen:])
776 if os.path.lexists(t):
776 if os.path.lexists(t):
777 score += 1
777 score += 1
778 return score
778 return score
779
779
780 abspfx = util.localpath(abspfx)
780 abspfx = util.localpath(abspfx)
781 striplen = len(abspfx)
781 striplen = len(abspfx)
782 if striplen:
782 if striplen:
783 striplen += len(pycompat.ossep)
783 striplen += len(pycompat.ossep)
784 if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):
784 if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):
785 score = evalpath(striplen)
785 score = evalpath(striplen)
786 striplen1 = len(os.path.split(abspfx)[0])
786 striplen1 = len(os.path.split(abspfx)[0])
787 if striplen1:
787 if striplen1:
788 striplen1 += len(pycompat.ossep)
788 striplen1 += len(pycompat.ossep)
789 if evalpath(striplen1) > score:
789 if evalpath(striplen1) > score:
790 striplen = striplen1
790 striplen = striplen1
791 res = lambda p: os.path.join(dest,
791 res = lambda p: os.path.join(dest,
792 util.localpath(p)[striplen:])
792 util.localpath(p)[striplen:])
793 else:
793 else:
794 # a file
794 # a file
795 if destdirexists:
795 if destdirexists:
796 res = lambda p: os.path.join(dest,
796 res = lambda p: os.path.join(dest,
797 os.path.basename(util.localpath(p)))
797 os.path.basename(util.localpath(p)))
798 else:
798 else:
799 res = lambda p: dest
799 res = lambda p: dest
800 return res
800 return res
801
801
802 pats = scmutil.expandpats(pats)
802 pats = scmutil.expandpats(pats)
803 if not pats:
803 if not pats:
804 raise error.Abort(_('no source or destination specified'))
804 raise error.Abort(_('no source or destination specified'))
805 if len(pats) == 1:
805 if len(pats) == 1:
806 raise error.Abort(_('no destination specified'))
806 raise error.Abort(_('no destination specified'))
807 dest = pats.pop()
807 dest = pats.pop()
808 destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
808 destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
809 if not destdirexists:
809 if not destdirexists:
810 if len(pats) > 1 or matchmod.patkind(pats[0]):
810 if len(pats) > 1 or matchmod.patkind(pats[0]):
811 raise error.Abort(_('with multiple sources, destination must be an '
811 raise error.Abort(_('with multiple sources, destination must be an '
812 'existing directory'))
812 'existing directory'))
813 if util.endswithsep(dest):
813 if util.endswithsep(dest):
814 raise error.Abort(_('destination %s is not a directory') % dest)
814 raise error.Abort(_('destination %s is not a directory') % dest)
815
815
816 tfn = targetpathfn
816 tfn = targetpathfn
817 if after:
817 if after:
818 tfn = targetpathafterfn
818 tfn = targetpathafterfn
819 copylist = []
819 copylist = []
820 for pat in pats:
820 for pat in pats:
821 srcs = walkpat(pat)
821 srcs = walkpat(pat)
822 if not srcs:
822 if not srcs:
823 continue
823 continue
824 copylist.append((tfn(pat, dest, srcs), srcs))
824 copylist.append((tfn(pat, dest, srcs), srcs))
825 if not copylist:
825 if not copylist:
826 raise error.Abort(_('no files to copy'))
826 raise error.Abort(_('no files to copy'))
827
827
828 errors = 0
828 errors = 0
829 for targetpath, srcs in copylist:
829 for targetpath, srcs in copylist:
830 for abssrc, relsrc, exact in srcs:
830 for abssrc, relsrc, exact in srcs:
831 if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
831 if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
832 errors += 1
832 errors += 1
833
833
834 if errors:
834 if errors:
835 ui.warn(_('(consider using --after)\n'))
835 ui.warn(_('(consider using --after)\n'))
836
836
837 return errors != 0
837 return errors != 0
838
838
839 ## facility to let extension process additional data into an import patch
839 ## facility to let extension process additional data into an import patch
840 # list of identifier to be executed in order
840 # list of identifier to be executed in order
841 extrapreimport = [] # run before commit
841 extrapreimport = [] # run before commit
842 extrapostimport = [] # run after commit
842 extrapostimport = [] # run after commit
843 # mapping from identifier to actual import function
843 # mapping from identifier to actual import function
844 #
844 #
845 # 'preimport' are run before the commit is made and are provided the following
845 # 'preimport' are run before the commit is made and are provided the following
846 # arguments:
846 # arguments:
847 # - repo: the localrepository instance,
847 # - repo: the localrepository instance,
848 # - patchdata: data extracted from patch header (cf m.patch.patchheadermap),
848 # - patchdata: data extracted from patch header (cf m.patch.patchheadermap),
849 # - extra: the future extra dictionary of the changeset, please mutate it,
849 # - extra: the future extra dictionary of the changeset, please mutate it,
850 # - opts: the import options.
850 # - opts: the import options.
851 # XXX ideally, we would just pass an ctx ready to be computed, that would allow
851 # XXX ideally, we would just pass an ctx ready to be computed, that would allow
852 # mutation of in memory commit and more. Feel free to rework the code to get
852 # mutation of in memory commit and more. Feel free to rework the code to get
853 # there.
853 # there.
854 extrapreimportmap = {}
854 extrapreimportmap = {}
855 # 'postimport' are run after the commit is made and are provided the following
855 # 'postimport' are run after the commit is made and are provided the following
856 # argument:
856 # argument:
857 # - ctx: the changectx created by import.
857 # - ctx: the changectx created by import.
858 extrapostimportmap = {}
858 extrapostimportmap = {}
859
859
860 def tryimportone(ui, repo, hunk, parents, opts, msgs, updatefunc):
860 def tryimportone(ui, repo, hunk, parents, opts, msgs, updatefunc):
861 """Utility function used by commands.import to import a single patch
861 """Utility function used by commands.import to import a single patch
862
862
863 This function is explicitly defined here to help the evolve extension to
863 This function is explicitly defined here to help the evolve extension to
864 wrap this part of the import logic.
864 wrap this part of the import logic.
865
865
866 The API is currently a bit ugly because it a simple code translation from
866 The API is currently a bit ugly because it a simple code translation from
867 the import command. Feel free to make it better.
867 the import command. Feel free to make it better.
868
868
869 :hunk: a patch (as a binary string)
869 :hunk: a patch (as a binary string)
870 :parents: nodes that will be parent of the created commit
870 :parents: nodes that will be parent of the created commit
871 :opts: the full dict of option passed to the import command
871 :opts: the full dict of option passed to the import command
872 :msgs: list to save commit message to.
872 :msgs: list to save commit message to.
873 (used in case we need to save it when failing)
873 (used in case we need to save it when failing)
874 :updatefunc: a function that update a repo to a given node
874 :updatefunc: a function that update a repo to a given node
875 updatefunc(<repo>, <node>)
875 updatefunc(<repo>, <node>)
876 """
876 """
877 # avoid cycle context -> subrepo -> cmdutil
877 # avoid cycle context -> subrepo -> cmdutil
878 from . import context
878 from . import context
879 extractdata = patch.extract(ui, hunk)
879 extractdata = patch.extract(ui, hunk)
880 tmpname = extractdata.get('filename')
880 tmpname = extractdata.get('filename')
881 message = extractdata.get('message')
881 message = extractdata.get('message')
882 user = opts.get('user') or extractdata.get('user')
882 user = opts.get('user') or extractdata.get('user')
883 date = opts.get('date') or extractdata.get('date')
883 date = opts.get('date') or extractdata.get('date')
884 branch = extractdata.get('branch')
884 branch = extractdata.get('branch')
885 nodeid = extractdata.get('nodeid')
885 nodeid = extractdata.get('nodeid')
886 p1 = extractdata.get('p1')
886 p1 = extractdata.get('p1')
887 p2 = extractdata.get('p2')
887 p2 = extractdata.get('p2')
888
888
889 nocommit = opts.get('no_commit')
889 nocommit = opts.get('no_commit')
890 importbranch = opts.get('import_branch')
890 importbranch = opts.get('import_branch')
891 update = not opts.get('bypass')
891 update = not opts.get('bypass')
892 strip = opts["strip"]
892 strip = opts["strip"]
893 prefix = opts["prefix"]
893 prefix = opts["prefix"]
894 sim = float(opts.get('similarity') or 0)
894 sim = float(opts.get('similarity') or 0)
895 if not tmpname:
895 if not tmpname:
896 return (None, None, False)
896 return (None, None, False)
897
897
898 rejects = False
898 rejects = False
899
899
900 try:
900 try:
901 cmdline_message = logmessage(ui, opts)
901 cmdline_message = logmessage(ui, opts)
902 if cmdline_message:
902 if cmdline_message:
903 # pickup the cmdline msg
903 # pickup the cmdline msg
904 message = cmdline_message
904 message = cmdline_message
905 elif message:
905 elif message:
906 # pickup the patch msg
906 # pickup the patch msg
907 message = message.strip()
907 message = message.strip()
908 else:
908 else:
909 # launch the editor
909 # launch the editor
910 message = None
910 message = None
911 ui.debug('message:\n%s\n' % message)
911 ui.debug('message:\n%s\n' % message)
912
912
913 if len(parents) == 1:
913 if len(parents) == 1:
914 parents.append(repo[nullid])
914 parents.append(repo[nullid])
915 if opts.get('exact'):
915 if opts.get('exact'):
916 if not nodeid or not p1:
916 if not nodeid or not p1:
917 raise error.Abort(_('not a Mercurial patch'))
917 raise error.Abort(_('not a Mercurial patch'))
918 p1 = repo[p1]
918 p1 = repo[p1]
919 p2 = repo[p2 or nullid]
919 p2 = repo[p2 or nullid]
920 elif p2:
920 elif p2:
921 try:
921 try:
922 p1 = repo[p1]
922 p1 = repo[p1]
923 p2 = repo[p2]
923 p2 = repo[p2]
924 # Without any options, consider p2 only if the
924 # Without any options, consider p2 only if the
925 # patch is being applied on top of the recorded
925 # patch is being applied on top of the recorded
926 # first parent.
926 # first parent.
927 if p1 != parents[0]:
927 if p1 != parents[0]:
928 p1 = parents[0]
928 p1 = parents[0]
929 p2 = repo[nullid]
929 p2 = repo[nullid]
930 except error.RepoError:
930 except error.RepoError:
931 p1, p2 = parents
931 p1, p2 = parents
932 if p2.node() == nullid:
932 if p2.node() == nullid:
933 ui.warn(_("warning: import the patch as a normal revision\n"
933 ui.warn(_("warning: import the patch as a normal revision\n"
934 "(use --exact to import the patch as a merge)\n"))
934 "(use --exact to import the patch as a merge)\n"))
935 else:
935 else:
936 p1, p2 = parents
936 p1, p2 = parents
937
937
938 n = None
938 n = None
939 if update:
939 if update:
940 if p1 != parents[0]:
940 if p1 != parents[0]:
941 updatefunc(repo, p1.node())
941 updatefunc(repo, p1.node())
942 if p2 != parents[1]:
942 if p2 != parents[1]:
943 repo.setparents(p1.node(), p2.node())
943 repo.setparents(p1.node(), p2.node())
944
944
945 if opts.get('exact') or importbranch:
945 if opts.get('exact') or importbranch:
946 repo.dirstate.setbranch(branch or 'default')
946 repo.dirstate.setbranch(branch or 'default')
947
947
948 partial = opts.get('partial', False)
948 partial = opts.get('partial', False)
949 files = set()
949 files = set()
950 try:
950 try:
951 patch.patch(ui, repo, tmpname, strip=strip, prefix=prefix,
951 patch.patch(ui, repo, tmpname, strip=strip, prefix=prefix,
952 files=files, eolmode=None, similarity=sim / 100.0)
952 files=files, eolmode=None, similarity=sim / 100.0)
953 except patch.PatchError as e:
953 except patch.PatchError as e:
954 if not partial:
954 if not partial:
955 raise error.Abort(str(e))
955 raise error.Abort(str(e))
956 if partial:
956 if partial:
957 rejects = True
957 rejects = True
958
958
959 files = list(files)
959 files = list(files)
960 if nocommit:
960 if nocommit:
961 if message:
961 if message:
962 msgs.append(message)
962 msgs.append(message)
963 else:
963 else:
964 if opts.get('exact') or p2:
964 if opts.get('exact') or p2:
965 # If you got here, you either use --force and know what
965 # If you got here, you either use --force and know what
966 # you are doing or used --exact or a merge patch while
966 # you are doing or used --exact or a merge patch while
967 # being updated to its first parent.
967 # being updated to its first parent.
968 m = None
968 m = None
969 else:
969 else:
970 m = scmutil.matchfiles(repo, files or [])
970 m = scmutil.matchfiles(repo, files or [])
971 editform = mergeeditform(repo[None], 'import.normal')
971 editform = mergeeditform(repo[None], 'import.normal')
972 if opts.get('exact'):
972 if opts.get('exact'):
973 editor = None
973 editor = None
974 else:
974 else:
975 editor = getcommiteditor(editform=editform, **opts)
975 editor = getcommiteditor(editform=editform, **opts)
976 extra = {}
976 extra = {}
977 for idfunc in extrapreimport:
977 for idfunc in extrapreimport:
978 extrapreimportmap[idfunc](repo, extractdata, extra, opts)
978 extrapreimportmap[idfunc](repo, extractdata, extra, opts)
979 overrides = {}
979 overrides = {}
980 if partial:
980 if partial:
981 overrides[('ui', 'allowemptycommit')] = True
981 overrides[('ui', 'allowemptycommit')] = True
982 with repo.ui.configoverride(overrides, 'import'):
982 with repo.ui.configoverride(overrides, 'import'):
983 n = repo.commit(message, user,
983 n = repo.commit(message, user,
984 date, match=m,
984 date, match=m,
985 editor=editor, extra=extra)
985 editor=editor, extra=extra)
986 for idfunc in extrapostimport:
986 for idfunc in extrapostimport:
987 extrapostimportmap[idfunc](repo[n])
987 extrapostimportmap[idfunc](repo[n])
988 else:
988 else:
989 if opts.get('exact') or importbranch:
989 if opts.get('exact') or importbranch:
990 branch = branch or 'default'
990 branch = branch or 'default'
991 else:
991 else:
992 branch = p1.branch()
992 branch = p1.branch()
993 store = patch.filestore()
993 store = patch.filestore()
994 try:
994 try:
995 files = set()
995 files = set()
996 try:
996 try:
997 patch.patchrepo(ui, repo, p1, store, tmpname, strip, prefix,
997 patch.patchrepo(ui, repo, p1, store, tmpname, strip, prefix,
998 files, eolmode=None)
998 files, eolmode=None)
999 except patch.PatchError as e:
999 except patch.PatchError as e:
1000 raise error.Abort(str(e))
1000 raise error.Abort(str(e))
1001 if opts.get('exact'):
1001 if opts.get('exact'):
1002 editor = None
1002 editor = None
1003 else:
1003 else:
1004 editor = getcommiteditor(editform='import.bypass')
1004 editor = getcommiteditor(editform='import.bypass')
1005 memctx = context.makememctx(repo, (p1.node(), p2.node()),
1005 memctx = context.makememctx(repo, (p1.node(), p2.node()),
1006 message,
1006 message,
1007 user,
1007 user,
1008 date,
1008 date,
1009 branch, files, store,
1009 branch, files, store,
1010 editor=editor)
1010 editor=editor)
1011 n = memctx.commit()
1011 n = memctx.commit()
1012 finally:
1012 finally:
1013 store.close()
1013 store.close()
1014 if opts.get('exact') and nocommit:
1014 if opts.get('exact') and nocommit:
1015 # --exact with --no-commit is still useful in that it does merge
1015 # --exact with --no-commit is still useful in that it does merge
1016 # and branch bits
1016 # and branch bits
1017 ui.warn(_("warning: can't check exact import with --no-commit\n"))
1017 ui.warn(_("warning: can't check exact import with --no-commit\n"))
1018 elif opts.get('exact') and hex(n) != nodeid:
1018 elif opts.get('exact') and hex(n) != nodeid:
1019 raise error.Abort(_('patch is damaged or loses information'))
1019 raise error.Abort(_('patch is damaged or loses information'))
1020 msg = _('applied to working directory')
1020 msg = _('applied to working directory')
1021 if n:
1021 if n:
1022 # i18n: refers to a short changeset id
1022 # i18n: refers to a short changeset id
1023 msg = _('created %s') % short(n)
1023 msg = _('created %s') % short(n)
1024 return (msg, n, rejects)
1024 return (msg, n, rejects)
1025 finally:
1025 finally:
1026 os.unlink(tmpname)
1026 os.unlink(tmpname)
1027
1027
1028 # facility to let extensions include additional data in an exported patch
1028 # facility to let extensions include additional data in an exported patch
1029 # list of identifiers to be executed in order
1029 # list of identifiers to be executed in order
1030 extraexport = []
1030 extraexport = []
1031 # mapping from identifier to actual export function
1031 # mapping from identifier to actual export function
1032 # function as to return a string to be added to the header or None
1032 # function as to return a string to be added to the header or None
1033 # it is given two arguments (sequencenumber, changectx)
1033 # it is given two arguments (sequencenumber, changectx)
1034 extraexportmap = {}
1034 extraexportmap = {}
1035
1035
1036 def export(repo, revs, template='hg-%h.patch', fp=None, switch_parent=False,
1036 def export(repo, revs, template='hg-%h.patch', fp=None, switch_parent=False,
1037 opts=None, match=None):
1037 opts=None, match=None):
1038 '''export changesets as hg patches.'''
1038 '''export changesets as hg patches.'''
1039
1039
1040 total = len(revs)
1040 total = len(revs)
1041 revwidth = max([len(str(rev)) for rev in revs])
1041 revwidth = max([len(str(rev)) for rev in revs])
1042 filemode = {}
1042 filemode = {}
1043
1043
1044 def single(rev, seqno, fp):
1044 def single(rev, seqno, fp):
1045 ctx = repo[rev]
1045 ctx = repo[rev]
1046 node = ctx.node()
1046 node = ctx.node()
1047 parents = [p.node() for p in ctx.parents() if p]
1047 parents = [p.node() for p in ctx.parents() if p]
1048 branch = ctx.branch()
1048 branch = ctx.branch()
1049 if switch_parent:
1049 if switch_parent:
1050 parents.reverse()
1050 parents.reverse()
1051
1051
1052 if parents:
1052 if parents:
1053 prev = parents[0]
1053 prev = parents[0]
1054 else:
1054 else:
1055 prev = nullid
1055 prev = nullid
1056
1056
1057 shouldclose = False
1057 shouldclose = False
1058 if not fp and len(template) > 0:
1058 if not fp and len(template) > 0:
1059 desc_lines = ctx.description().rstrip().split('\n')
1059 desc_lines = ctx.description().rstrip().split('\n')
1060 desc = desc_lines[0] #Commit always has a first line.
1060 desc = desc_lines[0] #Commit always has a first line.
1061 fp = makefileobj(repo, template, node, desc=desc, total=total,
1061 fp = makefileobj(repo, template, node, desc=desc, total=total,
1062 seqno=seqno, revwidth=revwidth, mode='wb',
1062 seqno=seqno, revwidth=revwidth, mode='wb',
1063 modemap=filemode)
1063 modemap=filemode)
1064 shouldclose = True
1064 shouldclose = True
1065 if fp and not getattr(fp, 'name', '<unnamed>').startswith('<'):
1065 if fp and not getattr(fp, 'name', '<unnamed>').startswith('<'):
1066 repo.ui.note("%s\n" % fp.name)
1066 repo.ui.note("%s\n" % fp.name)
1067
1067
1068 if not fp:
1068 if not fp:
1069 write = repo.ui.write
1069 write = repo.ui.write
1070 else:
1070 else:
1071 def write(s, **kw):
1071 def write(s, **kw):
1072 fp.write(s)
1072 fp.write(s)
1073
1073
1074 write("# HG changeset patch\n")
1074 write("# HG changeset patch\n")
1075 write("# User %s\n" % ctx.user())
1075 write("# User %s\n" % ctx.user())
1076 write("# Date %d %d\n" % ctx.date())
1076 write("# Date %d %d\n" % ctx.date())
1077 write("# %s\n" % util.datestr(ctx.date()))
1077 write("# %s\n" % util.datestr(ctx.date()))
1078 if branch and branch != 'default':
1078 if branch and branch != 'default':
1079 write("# Branch %s\n" % branch)
1079 write("# Branch %s\n" % branch)
1080 write("# Node ID %s\n" % hex(node))
1080 write("# Node ID %s\n" % hex(node))
1081 write("# Parent %s\n" % hex(prev))
1081 write("# Parent %s\n" % hex(prev))
1082 if len(parents) > 1:
1082 if len(parents) > 1:
1083 write("# Parent %s\n" % hex(parents[1]))
1083 write("# Parent %s\n" % hex(parents[1]))
1084
1084
1085 for headerid in extraexport:
1085 for headerid in extraexport:
1086 header = extraexportmap[headerid](seqno, ctx)
1086 header = extraexportmap[headerid](seqno, ctx)
1087 if header is not None:
1087 if header is not None:
1088 write('# %s\n' % header)
1088 write('# %s\n' % header)
1089 write(ctx.description().rstrip())
1089 write(ctx.description().rstrip())
1090 write("\n\n")
1090 write("\n\n")
1091
1091
1092 for chunk, label in patch.diffui(repo, prev, node, match, opts=opts):
1092 for chunk, label in patch.diffui(repo, prev, node, match, opts=opts):
1093 write(chunk, label=label)
1093 write(chunk, label=label)
1094
1094
1095 if shouldclose:
1095 if shouldclose:
1096 fp.close()
1096 fp.close()
1097
1097
1098 for seqno, rev in enumerate(revs):
1098 for seqno, rev in enumerate(revs):
1099 single(rev, seqno + 1, fp)
1099 single(rev, seqno + 1, fp)
1100
1100
1101 def diffordiffstat(ui, repo, diffopts, node1, node2, match,
1101 def diffordiffstat(ui, repo, diffopts, node1, node2, match,
1102 changes=None, stat=False, fp=None, prefix='',
1102 changes=None, stat=False, fp=None, prefix='',
1103 root='', listsubrepos=False):
1103 root='', listsubrepos=False):
1104 '''show diff or diffstat.'''
1104 '''show diff or diffstat.'''
1105 if fp is None:
1105 if fp is None:
1106 write = ui.write
1106 write = ui.write
1107 else:
1107 else:
1108 def write(s, **kw):
1108 def write(s, **kw):
1109 fp.write(s)
1109 fp.write(s)
1110
1110
1111 if root:
1111 if root:
1112 relroot = pathutil.canonpath(repo.root, repo.getcwd(), root)
1112 relroot = pathutil.canonpath(repo.root, repo.getcwd(), root)
1113 else:
1113 else:
1114 relroot = ''
1114 relroot = ''
1115 if relroot != '':
1115 if relroot != '':
1116 # XXX relative roots currently don't work if the root is within a
1116 # XXX relative roots currently don't work if the root is within a
1117 # subrepo
1117 # subrepo
1118 uirelroot = match.uipath(relroot)
1118 uirelroot = match.uipath(relroot)
1119 relroot += '/'
1119 relroot += '/'
1120 for matchroot in match.files():
1120 for matchroot in match.files():
1121 if not matchroot.startswith(relroot):
1121 if not matchroot.startswith(relroot):
1122 ui.warn(_('warning: %s not inside relative root %s\n') % (
1122 ui.warn(_('warning: %s not inside relative root %s\n') % (
1123 match.uipath(matchroot), uirelroot))
1123 match.uipath(matchroot), uirelroot))
1124
1124
1125 if stat:
1125 if stat:
1126 diffopts = diffopts.copy(context=0)
1126 diffopts = diffopts.copy(context=0)
1127 width = 80
1127 width = 80
1128 if not ui.plain():
1128 if not ui.plain():
1129 width = ui.termwidth()
1129 width = ui.termwidth()
1130 chunks = patch.diff(repo, node1, node2, match, changes, diffopts,
1130 chunks = patch.diff(repo, node1, node2, match, changes, diffopts,
1131 prefix=prefix, relroot=relroot)
1131 prefix=prefix, relroot=relroot)
1132 for chunk, label in patch.diffstatui(util.iterlines(chunks),
1132 for chunk, label in patch.diffstatui(util.iterlines(chunks),
1133 width=width):
1133 width=width):
1134 write(chunk, label=label)
1134 write(chunk, label=label)
1135 else:
1135 else:
1136 for chunk, label in patch.diffui(repo, node1, node2, match,
1136 for chunk, label in patch.diffui(repo, node1, node2, match,
1137 changes, diffopts, prefix=prefix,
1137 changes, diffopts, prefix=prefix,
1138 relroot=relroot):
1138 relroot=relroot):
1139 write(chunk, label=label)
1139 write(chunk, label=label)
1140
1140
1141 if listsubrepos:
1141 if listsubrepos:
1142 ctx1 = repo[node1]
1142 ctx1 = repo[node1]
1143 ctx2 = repo[node2]
1143 ctx2 = repo[node2]
1144 for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
1144 for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
1145 tempnode2 = node2
1145 tempnode2 = node2
1146 try:
1146 try:
1147 if node2 is not None:
1147 if node2 is not None:
1148 tempnode2 = ctx2.substate[subpath][1]
1148 tempnode2 = ctx2.substate[subpath][1]
1149 except KeyError:
1149 except KeyError:
1150 # A subrepo that existed in node1 was deleted between node1 and
1150 # A subrepo that existed in node1 was deleted between node1 and
1151 # node2 (inclusive). Thus, ctx2's substate won't contain that
1151 # node2 (inclusive). Thus, ctx2's substate won't contain that
1152 # subpath. The best we can do is to ignore it.
1152 # subpath. The best we can do is to ignore it.
1153 tempnode2 = None
1153 tempnode2 = None
1154 submatch = matchmod.subdirmatcher(subpath, match)
1154 submatch = matchmod.subdirmatcher(subpath, match)
1155 sub.diff(ui, diffopts, tempnode2, submatch, changes=changes,
1155 sub.diff(ui, diffopts, tempnode2, submatch, changes=changes,
1156 stat=stat, fp=fp, prefix=prefix)
1156 stat=stat, fp=fp, prefix=prefix)
1157
1157
1158 def _changesetlabels(ctx):
1158 def _changesetlabels(ctx):
1159 labels = ['log.changeset', 'changeset.%s' % ctx.phasestr()]
1159 labels = ['log.changeset', 'changeset.%s' % ctx.phasestr()]
1160 if ctx.obsolete():
1160 if ctx.obsolete():
1161 labels.append('changeset.obsolete')
1161 labels.append('changeset.obsolete')
1162 if ctx.troubled():
1162 if ctx.troubled():
1163 labels.append('changeset.troubled')
1163 labels.append('changeset.troubled')
1164 for trouble in ctx.troubles():
1164 for trouble in ctx.troubles():
1165 labels.append('trouble.%s' % trouble)
1165 labels.append('trouble.%s' % trouble)
1166 return ' '.join(labels)
1166 return ' '.join(labels)
1167
1167
1168 class changeset_printer(object):
1168 class changeset_printer(object):
1169 '''show changeset information when templating not requested.'''
1169 '''show changeset information when templating not requested.'''
1170
1170
1171 def __init__(self, ui, repo, matchfn, diffopts, buffered):
1171 def __init__(self, ui, repo, matchfn, diffopts, buffered):
1172 self.ui = ui
1172 self.ui = ui
1173 self.repo = repo
1173 self.repo = repo
1174 self.buffered = buffered
1174 self.buffered = buffered
1175 self.matchfn = matchfn
1175 self.matchfn = matchfn
1176 self.diffopts = diffopts
1176 self.diffopts = diffopts
1177 self.header = {}
1177 self.header = {}
1178 self.hunk = {}
1178 self.hunk = {}
1179 self.lastheader = None
1179 self.lastheader = None
1180 self.footer = None
1180 self.footer = None
1181
1181
1182 def flush(self, ctx):
1182 def flush(self, ctx):
1183 rev = ctx.rev()
1183 rev = ctx.rev()
1184 if rev in self.header:
1184 if rev in self.header:
1185 h = self.header[rev]
1185 h = self.header[rev]
1186 if h != self.lastheader:
1186 if h != self.lastheader:
1187 self.lastheader = h
1187 self.lastheader = h
1188 self.ui.write(h)
1188 self.ui.write(h)
1189 del self.header[rev]
1189 del self.header[rev]
1190 if rev in self.hunk:
1190 if rev in self.hunk:
1191 self.ui.write(self.hunk[rev])
1191 self.ui.write(self.hunk[rev])
1192 del self.hunk[rev]
1192 del self.hunk[rev]
1193 return 1
1193 return 1
1194 return 0
1194 return 0
1195
1195
1196 def close(self):
1196 def close(self):
1197 if self.footer:
1197 if self.footer:
1198 self.ui.write(self.footer)
1198 self.ui.write(self.footer)
1199
1199
1200 def show(self, ctx, copies=None, matchfn=None, **props):
1200 def show(self, ctx, copies=None, matchfn=None, **props):
1201 if self.buffered:
1201 if self.buffered:
1202 self.ui.pushbuffer(labeled=True)
1202 self.ui.pushbuffer(labeled=True)
1203 self._show(ctx, copies, matchfn, props)
1203 self._show(ctx, copies, matchfn, props)
1204 self.hunk[ctx.rev()] = self.ui.popbuffer()
1204 self.hunk[ctx.rev()] = self.ui.popbuffer()
1205 else:
1205 else:
1206 self._show(ctx, copies, matchfn, props)
1206 self._show(ctx, copies, matchfn, props)
1207
1207
1208 def _show(self, ctx, copies, matchfn, props):
1208 def _show(self, ctx, copies, matchfn, props):
1209 '''show a single changeset or file revision'''
1209 '''show a single changeset or file revision'''
1210 changenode = ctx.node()
1210 changenode = ctx.node()
1211 rev = ctx.rev()
1211 rev = ctx.rev()
1212 if self.ui.debugflag:
1212 if self.ui.debugflag:
1213 hexfunc = hex
1213 hexfunc = hex
1214 else:
1214 else:
1215 hexfunc = short
1215 hexfunc = short
1216 # as of now, wctx.node() and wctx.rev() return None, but we want to
1216 # as of now, wctx.node() and wctx.rev() return None, but we want to
1217 # show the same values as {node} and {rev} templatekw
1217 # show the same values as {node} and {rev} templatekw
1218 revnode = (scmutil.intrev(rev), hexfunc(bin(ctx.hex())))
1218 revnode = (scmutil.intrev(rev), hexfunc(bin(ctx.hex())))
1219
1219
1220 if self.ui.quiet:
1220 if self.ui.quiet:
1221 self.ui.write("%d:%s\n" % revnode, label='log.node')
1221 self.ui.write("%d:%s\n" % revnode, label='log.node')
1222 return
1222 return
1223
1223
1224 date = util.datestr(ctx.date())
1224 date = util.datestr(ctx.date())
1225
1225
1226 # i18n: column positioning for "hg log"
1226 # i18n: column positioning for "hg log"
1227 self.ui.write(_("changeset: %d:%s\n") % revnode,
1227 self.ui.write(_("changeset: %d:%s\n") % revnode,
1228 label=_changesetlabels(ctx))
1228 label=_changesetlabels(ctx))
1229
1229
1230 # branches are shown first before any other names due to backwards
1230 # branches are shown first before any other names due to backwards
1231 # compatibility
1231 # compatibility
1232 branch = ctx.branch()
1232 branch = ctx.branch()
1233 # don't show the default branch name
1233 # don't show the default branch name
1234 if branch != 'default':
1234 if branch != 'default':
1235 # i18n: column positioning for "hg log"
1235 # i18n: column positioning for "hg log"
1236 self.ui.write(_("branch: %s\n") % branch,
1236 self.ui.write(_("branch: %s\n") % branch,
1237 label='log.branch')
1237 label='log.branch')
1238
1238
1239 for nsname, ns in self.repo.names.iteritems():
1239 for nsname, ns in self.repo.names.iteritems():
1240 # branches has special logic already handled above, so here we just
1240 # branches has special logic already handled above, so here we just
1241 # skip it
1241 # skip it
1242 if nsname == 'branches':
1242 if nsname == 'branches':
1243 continue
1243 continue
1244 # we will use the templatename as the color name since those two
1244 # we will use the templatename as the color name since those two
1245 # should be the same
1245 # should be the same
1246 for name in ns.names(self.repo, changenode):
1246 for name in ns.names(self.repo, changenode):
1247 self.ui.write(ns.logfmt % name,
1247 self.ui.write(ns.logfmt % name,
1248 label='log.%s' % ns.colorname)
1248 label='log.%s' % ns.colorname)
1249 if self.ui.debugflag:
1249 if self.ui.debugflag:
1250 # i18n: column positioning for "hg log"
1250 # i18n: column positioning for "hg log"
1251 self.ui.write(_("phase: %s\n") % ctx.phasestr(),
1251 self.ui.write(_("phase: %s\n") % ctx.phasestr(),
1252 label='log.phase')
1252 label='log.phase')
1253 for pctx in scmutil.meaningfulparents(self.repo, ctx):
1253 for pctx in scmutil.meaningfulparents(self.repo, ctx):
1254 label = 'log.parent changeset.%s' % pctx.phasestr()
1254 label = 'log.parent changeset.%s' % pctx.phasestr()
1255 # i18n: column positioning for "hg log"
1255 # i18n: column positioning for "hg log"
1256 self.ui.write(_("parent: %d:%s\n")
1256 self.ui.write(_("parent: %d:%s\n")
1257 % (pctx.rev(), hexfunc(pctx.node())),
1257 % (pctx.rev(), hexfunc(pctx.node())),
1258 label=label)
1258 label=label)
1259
1259
1260 if self.ui.debugflag and rev is not None:
1260 if self.ui.debugflag and rev is not None:
1261 mnode = ctx.manifestnode()
1261 mnode = ctx.manifestnode()
1262 # i18n: column positioning for "hg log"
1262 # i18n: column positioning for "hg log"
1263 self.ui.write(_("manifest: %d:%s\n") %
1263 self.ui.write(_("manifest: %d:%s\n") %
1264 (self.repo.manifestlog._revlog.rev(mnode),
1264 (self.repo.manifestlog._revlog.rev(mnode),
1265 hex(mnode)),
1265 hex(mnode)),
1266 label='ui.debug log.manifest')
1266 label='ui.debug log.manifest')
1267 # i18n: column positioning for "hg log"
1267 # i18n: column positioning for "hg log"
1268 self.ui.write(_("user: %s\n") % ctx.user(),
1268 self.ui.write(_("user: %s\n") % ctx.user(),
1269 label='log.user')
1269 label='log.user')
1270 # i18n: column positioning for "hg log"
1270 # i18n: column positioning for "hg log"
1271 self.ui.write(_("date: %s\n") % date,
1271 self.ui.write(_("date: %s\n") % date,
1272 label='log.date')
1272 label='log.date')
1273
1273
1274 if ctx.troubled():
1274 if ctx.troubled():
1275 # i18n: column positioning for "hg log"
1275 # i18n: column positioning for "hg log"
1276 self.ui.write(_("trouble: %s\n") % ', '.join(ctx.troubles()),
1276 self.ui.write(_("trouble: %s\n") % ', '.join(ctx.troubles()),
1277 label='log.trouble')
1277 label='log.trouble')
1278
1278
1279 if self.ui.debugflag:
1279 if self.ui.debugflag:
1280 files = ctx.p1().status(ctx)[:3]
1280 files = ctx.p1().status(ctx)[:3]
1281 for key, value in zip([# i18n: column positioning for "hg log"
1281 for key, value in zip([# i18n: column positioning for "hg log"
1282 _("files:"),
1282 _("files:"),
1283 # i18n: column positioning for "hg log"
1283 # i18n: column positioning for "hg log"
1284 _("files+:"),
1284 _("files+:"),
1285 # i18n: column positioning for "hg log"
1285 # i18n: column positioning for "hg log"
1286 _("files-:")], files):
1286 _("files-:")], files):
1287 if value:
1287 if value:
1288 self.ui.write("%-12s %s\n" % (key, " ".join(value)),
1288 self.ui.write("%-12s %s\n" % (key, " ".join(value)),
1289 label='ui.debug log.files')
1289 label='ui.debug log.files')
1290 elif ctx.files() and self.ui.verbose:
1290 elif ctx.files() and self.ui.verbose:
1291 # i18n: column positioning for "hg log"
1291 # i18n: column positioning for "hg log"
1292 self.ui.write(_("files: %s\n") % " ".join(ctx.files()),
1292 self.ui.write(_("files: %s\n") % " ".join(ctx.files()),
1293 label='ui.note log.files')
1293 label='ui.note log.files')
1294 if copies and self.ui.verbose:
1294 if copies and self.ui.verbose:
1295 copies = ['%s (%s)' % c for c in copies]
1295 copies = ['%s (%s)' % c for c in copies]
1296 # i18n: column positioning for "hg log"
1296 # i18n: column positioning for "hg log"
1297 self.ui.write(_("copies: %s\n") % ' '.join(copies),
1297 self.ui.write(_("copies: %s\n") % ' '.join(copies),
1298 label='ui.note log.copies')
1298 label='ui.note log.copies')
1299
1299
1300 extra = ctx.extra()
1300 extra = ctx.extra()
1301 if extra and self.ui.debugflag:
1301 if extra and self.ui.debugflag:
1302 for key, value in sorted(extra.items()):
1302 for key, value in sorted(extra.items()):
1303 # i18n: column positioning for "hg log"
1303 # i18n: column positioning for "hg log"
1304 self.ui.write(_("extra: %s=%s\n")
1304 self.ui.write(_("extra: %s=%s\n")
1305 % (key, util.escapestr(value)),
1305 % (key, util.escapestr(value)),
1306 label='ui.debug log.extra')
1306 label='ui.debug log.extra')
1307
1307
1308 description = ctx.description().strip()
1308 description = ctx.description().strip()
1309 if description:
1309 if description:
1310 if self.ui.verbose:
1310 if self.ui.verbose:
1311 self.ui.write(_("description:\n"),
1311 self.ui.write(_("description:\n"),
1312 label='ui.note log.description')
1312 label='ui.note log.description')
1313 self.ui.write(description,
1313 self.ui.write(description,
1314 label='ui.note log.description')
1314 label='ui.note log.description')
1315 self.ui.write("\n\n")
1315 self.ui.write("\n\n")
1316 else:
1316 else:
1317 # i18n: column positioning for "hg log"
1317 # i18n: column positioning for "hg log"
1318 self.ui.write(_("summary: %s\n") %
1318 self.ui.write(_("summary: %s\n") %
1319 description.splitlines()[0],
1319 description.splitlines()[0],
1320 label='log.summary')
1320 label='log.summary')
1321 self.ui.write("\n")
1321 self.ui.write("\n")
1322
1322
1323 self.showpatch(ctx, matchfn)
1323 self.showpatch(ctx, matchfn)
1324
1324
1325 def showpatch(self, ctx, matchfn):
1325 def showpatch(self, ctx, matchfn):
1326 if not matchfn:
1326 if not matchfn:
1327 matchfn = self.matchfn
1327 matchfn = self.matchfn
1328 if matchfn:
1328 if matchfn:
1329 stat = self.diffopts.get('stat')
1329 stat = self.diffopts.get('stat')
1330 diff = self.diffopts.get('patch')
1330 diff = self.diffopts.get('patch')
1331 diffopts = patch.diffallopts(self.ui, self.diffopts)
1331 diffopts = patch.diffallopts(self.ui, self.diffopts)
1332 node = ctx.node()
1332 node = ctx.node()
1333 prev = ctx.p1().node()
1333 prev = ctx.p1().node()
1334 if stat:
1334 if stat:
1335 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
1335 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
1336 match=matchfn, stat=True)
1336 match=matchfn, stat=True)
1337 if diff:
1337 if diff:
1338 if stat:
1338 if stat:
1339 self.ui.write("\n")
1339 self.ui.write("\n")
1340 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
1340 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
1341 match=matchfn, stat=False)
1341 match=matchfn, stat=False)
1342 self.ui.write("\n")
1342 self.ui.write("\n")
1343
1343
1344 class jsonchangeset(changeset_printer):
1344 class jsonchangeset(changeset_printer):
1345 '''format changeset information.'''
1345 '''format changeset information.'''
1346
1346
1347 def __init__(self, ui, repo, matchfn, diffopts, buffered):
1347 def __init__(self, ui, repo, matchfn, diffopts, buffered):
1348 changeset_printer.__init__(self, ui, repo, matchfn, diffopts, buffered)
1348 changeset_printer.__init__(self, ui, repo, matchfn, diffopts, buffered)
1349 self.cache = {}
1349 self.cache = {}
1350 self._first = True
1350 self._first = True
1351
1351
1352 def close(self):
1352 def close(self):
1353 if not self._first:
1353 if not self._first:
1354 self.ui.write("\n]\n")
1354 self.ui.write("\n]\n")
1355 else:
1355 else:
1356 self.ui.write("[]\n")
1356 self.ui.write("[]\n")
1357
1357
1358 def _show(self, ctx, copies, matchfn, props):
1358 def _show(self, ctx, copies, matchfn, props):
1359 '''show a single changeset or file revision'''
1359 '''show a single changeset or file revision'''
1360 rev = ctx.rev()
1360 rev = ctx.rev()
1361 if rev is None:
1361 if rev is None:
1362 jrev = jnode = 'null'
1362 jrev = jnode = 'null'
1363 else:
1363 else:
1364 jrev = '%d' % rev
1364 jrev = '%d' % rev
1365 jnode = '"%s"' % hex(ctx.node())
1365 jnode = '"%s"' % hex(ctx.node())
1366 j = encoding.jsonescape
1366 j = encoding.jsonescape
1367
1367
1368 if self._first:
1368 if self._first:
1369 self.ui.write("[\n {")
1369 self.ui.write("[\n {")
1370 self._first = False
1370 self._first = False
1371 else:
1371 else:
1372 self.ui.write(",\n {")
1372 self.ui.write(",\n {")
1373
1373
1374 if self.ui.quiet:
1374 if self.ui.quiet:
1375 self.ui.write(('\n "rev": %s') % jrev)
1375 self.ui.write(('\n "rev": %s') % jrev)
1376 self.ui.write((',\n "node": %s') % jnode)
1376 self.ui.write((',\n "node": %s') % jnode)
1377 self.ui.write('\n }')
1377 self.ui.write('\n }')
1378 return
1378 return
1379
1379
1380 self.ui.write(('\n "rev": %s') % jrev)
1380 self.ui.write(('\n "rev": %s') % jrev)
1381 self.ui.write((',\n "node": %s') % jnode)
1381 self.ui.write((',\n "node": %s') % jnode)
1382 self.ui.write((',\n "branch": "%s"') % j(ctx.branch()))
1382 self.ui.write((',\n "branch": "%s"') % j(ctx.branch()))
1383 self.ui.write((',\n "phase": "%s"') % ctx.phasestr())
1383 self.ui.write((',\n "phase": "%s"') % ctx.phasestr())
1384 self.ui.write((',\n "user": "%s"') % j(ctx.user()))
1384 self.ui.write((',\n "user": "%s"') % j(ctx.user()))
1385 self.ui.write((',\n "date": [%d, %d]') % ctx.date())
1385 self.ui.write((',\n "date": [%d, %d]') % ctx.date())
1386 self.ui.write((',\n "desc": "%s"') % j(ctx.description()))
1386 self.ui.write((',\n "desc": "%s"') % j(ctx.description()))
1387
1387
1388 self.ui.write((',\n "bookmarks": [%s]') %
1388 self.ui.write((',\n "bookmarks": [%s]') %
1389 ", ".join('"%s"' % j(b) for b in ctx.bookmarks()))
1389 ", ".join('"%s"' % j(b) for b in ctx.bookmarks()))
1390 self.ui.write((',\n "tags": [%s]') %
1390 self.ui.write((',\n "tags": [%s]') %
1391 ", ".join('"%s"' % j(t) for t in ctx.tags()))
1391 ", ".join('"%s"' % j(t) for t in ctx.tags()))
1392 self.ui.write((',\n "parents": [%s]') %
1392 self.ui.write((',\n "parents": [%s]') %
1393 ", ".join('"%s"' % c.hex() for c in ctx.parents()))
1393 ", ".join('"%s"' % c.hex() for c in ctx.parents()))
1394
1394
1395 if self.ui.debugflag:
1395 if self.ui.debugflag:
1396 if rev is None:
1396 if rev is None:
1397 jmanifestnode = 'null'
1397 jmanifestnode = 'null'
1398 else:
1398 else:
1399 jmanifestnode = '"%s"' % hex(ctx.manifestnode())
1399 jmanifestnode = '"%s"' % hex(ctx.manifestnode())
1400 self.ui.write((',\n "manifest": %s') % jmanifestnode)
1400 self.ui.write((',\n "manifest": %s') % jmanifestnode)
1401
1401
1402 self.ui.write((',\n "extra": {%s}') %
1402 self.ui.write((',\n "extra": {%s}') %
1403 ", ".join('"%s": "%s"' % (j(k), j(v))
1403 ", ".join('"%s": "%s"' % (j(k), j(v))
1404 for k, v in ctx.extra().items()))
1404 for k, v in ctx.extra().items()))
1405
1405
1406 files = ctx.p1().status(ctx)
1406 files = ctx.p1().status(ctx)
1407 self.ui.write((',\n "modified": [%s]') %
1407 self.ui.write((',\n "modified": [%s]') %
1408 ", ".join('"%s"' % j(f) for f in files[0]))
1408 ", ".join('"%s"' % j(f) for f in files[0]))
1409 self.ui.write((',\n "added": [%s]') %
1409 self.ui.write((',\n "added": [%s]') %
1410 ", ".join('"%s"' % j(f) for f in files[1]))
1410 ", ".join('"%s"' % j(f) for f in files[1]))
1411 self.ui.write((',\n "removed": [%s]') %
1411 self.ui.write((',\n "removed": [%s]') %
1412 ", ".join('"%s"' % j(f) for f in files[2]))
1412 ", ".join('"%s"' % j(f) for f in files[2]))
1413
1413
1414 elif self.ui.verbose:
1414 elif self.ui.verbose:
1415 self.ui.write((',\n "files": [%s]') %
1415 self.ui.write((',\n "files": [%s]') %
1416 ", ".join('"%s"' % j(f) for f in ctx.files()))
1416 ", ".join('"%s"' % j(f) for f in ctx.files()))
1417
1417
1418 if copies:
1418 if copies:
1419 self.ui.write((',\n "copies": {%s}') %
1419 self.ui.write((',\n "copies": {%s}') %
1420 ", ".join('"%s": "%s"' % (j(k), j(v))
1420 ", ".join('"%s": "%s"' % (j(k), j(v))
1421 for k, v in copies))
1421 for k, v in copies))
1422
1422
1423 matchfn = self.matchfn
1423 matchfn = self.matchfn
1424 if matchfn:
1424 if matchfn:
1425 stat = self.diffopts.get('stat')
1425 stat = self.diffopts.get('stat')
1426 diff = self.diffopts.get('patch')
1426 diff = self.diffopts.get('patch')
1427 diffopts = patch.difffeatureopts(self.ui, self.diffopts, git=True)
1427 diffopts = patch.difffeatureopts(self.ui, self.diffopts, git=True)
1428 node, prev = ctx.node(), ctx.p1().node()
1428 node, prev = ctx.node(), ctx.p1().node()
1429 if stat:
1429 if stat:
1430 self.ui.pushbuffer()
1430 self.ui.pushbuffer()
1431 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
1431 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
1432 match=matchfn, stat=True)
1432 match=matchfn, stat=True)
1433 self.ui.write((',\n "diffstat": "%s"')
1433 self.ui.write((',\n "diffstat": "%s"')
1434 % j(self.ui.popbuffer()))
1434 % j(self.ui.popbuffer()))
1435 if diff:
1435 if diff:
1436 self.ui.pushbuffer()
1436 self.ui.pushbuffer()
1437 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
1437 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
1438 match=matchfn, stat=False)
1438 match=matchfn, stat=False)
1439 self.ui.write((',\n "diff": "%s"') % j(self.ui.popbuffer()))
1439 self.ui.write((',\n "diff": "%s"') % j(self.ui.popbuffer()))
1440
1440
1441 self.ui.write("\n }")
1441 self.ui.write("\n }")
1442
1442
1443 class changeset_templater(changeset_printer):
1443 class changeset_templater(changeset_printer):
1444 '''format changeset information.'''
1444 '''format changeset information.'''
1445
1445
1446 def __init__(self, ui, repo, matchfn, diffopts, tmpl, mapfile, buffered):
1446 def __init__(self, ui, repo, matchfn, diffopts, tmpl, mapfile, buffered):
1447 changeset_printer.__init__(self, ui, repo, matchfn, diffopts, buffered)
1447 changeset_printer.__init__(self, ui, repo, matchfn, diffopts, buffered)
1448 assert not (tmpl and mapfile)
1448 assert not (tmpl and mapfile)
1449 defaulttempl = templatekw.defaulttempl
1449 defaulttempl = templatekw.defaulttempl
1450 if mapfile:
1450 if mapfile:
1451 self.t = templater.templater.frommapfile(mapfile,
1451 self.t = templater.templater.frommapfile(mapfile,
1452 cache=defaulttempl)
1452 cache=defaulttempl)
1453 else:
1453 else:
1454 self.t = formatter.maketemplater(ui, 'changeset', tmpl,
1454 self.t = formatter.maketemplater(ui, 'changeset', tmpl,
1455 cache=defaulttempl)
1455 cache=defaulttempl)
1456
1456
1457 self._counter = itertools.count()
1457 self._counter = itertools.count()
1458 self.cache = {}
1458 self.cache = {}
1459
1459
1460 # find correct templates for current mode
1460 # find correct templates for current mode
1461 tmplmodes = [
1461 tmplmodes = [
1462 (True, None),
1462 (True, None),
1463 (self.ui.verbose, 'verbose'),
1463 (self.ui.verbose, 'verbose'),
1464 (self.ui.quiet, 'quiet'),
1464 (self.ui.quiet, 'quiet'),
1465 (self.ui.debugflag, 'debug'),
1465 (self.ui.debugflag, 'debug'),
1466 ]
1466 ]
1467
1467
1468 self._parts = {'header': '', 'footer': '', 'changeset': 'changeset',
1468 self._parts = {'header': '', 'footer': '', 'changeset': 'changeset',
1469 'docheader': '', 'docfooter': ''}
1469 'docheader': '', 'docfooter': ''}
1470 for mode, postfix in tmplmodes:
1470 for mode, postfix in tmplmodes:
1471 for t in self._parts:
1471 for t in self._parts:
1472 cur = t
1472 cur = t
1473 if postfix:
1473 if postfix:
1474 cur += "_" + postfix
1474 cur += "_" + postfix
1475 if mode and cur in self.t:
1475 if mode and cur in self.t:
1476 self._parts[t] = cur
1476 self._parts[t] = cur
1477
1477
1478 if self._parts['docheader']:
1478 if self._parts['docheader']:
1479 self.ui.write(templater.stringify(self.t(self._parts['docheader'])))
1479 self.ui.write(templater.stringify(self.t(self._parts['docheader'])))
1480
1480
1481 def close(self):
1481 def close(self):
1482 if self._parts['docfooter']:
1482 if self._parts['docfooter']:
1483 if not self.footer:
1483 if not self.footer:
1484 self.footer = ""
1484 self.footer = ""
1485 self.footer += templater.stringify(self.t(self._parts['docfooter']))
1485 self.footer += templater.stringify(self.t(self._parts['docfooter']))
1486 return super(changeset_templater, self).close()
1486 return super(changeset_templater, self).close()
1487
1487
1488 def _show(self, ctx, copies, matchfn, props):
1488 def _show(self, ctx, copies, matchfn, props):
1489 '''show a single changeset or file revision'''
1489 '''show a single changeset or file revision'''
1490 props = props.copy()
1490 props = props.copy()
1491 props.update(templatekw.keywords)
1491 props.update(templatekw.keywords)
1492 props['templ'] = self.t
1492 props['templ'] = self.t
1493 props['ctx'] = ctx
1493 props['ctx'] = ctx
1494 props['repo'] = self.repo
1494 props['repo'] = self.repo
1495 props['ui'] = self.repo.ui
1495 props['ui'] = self.repo.ui
1496 props['index'] = next(self._counter)
1496 props['index'] = next(self._counter)
1497 props['revcache'] = {'copies': copies}
1497 props['revcache'] = {'copies': copies}
1498 props['cache'] = self.cache
1498 props['cache'] = self.cache
1499 props = pycompat.strkwargs(props)
1499
1500
1500 # write header
1501 # write header
1501 if self._parts['header']:
1502 if self._parts['header']:
1502 h = templater.stringify(self.t(self._parts['header'], **props))
1503 h = templater.stringify(self.t(self._parts['header'], **props))
1503 if self.buffered:
1504 if self.buffered:
1504 self.header[ctx.rev()] = h
1505 self.header[ctx.rev()] = h
1505 else:
1506 else:
1506 if self.lastheader != h:
1507 if self.lastheader != h:
1507 self.lastheader = h
1508 self.lastheader = h
1508 self.ui.write(h)
1509 self.ui.write(h)
1509
1510
1510 # write changeset metadata, then patch if requested
1511 # write changeset metadata, then patch if requested
1511 key = self._parts['changeset']
1512 key = self._parts['changeset']
1512 self.ui.write(templater.stringify(self.t(key, **props)))
1513 self.ui.write(templater.stringify(self.t(key, **props)))
1513 self.showpatch(ctx, matchfn)
1514 self.showpatch(ctx, matchfn)
1514
1515
1515 if self._parts['footer']:
1516 if self._parts['footer']:
1516 if not self.footer:
1517 if not self.footer:
1517 self.footer = templater.stringify(
1518 self.footer = templater.stringify(
1518 self.t(self._parts['footer'], **props))
1519 self.t(self._parts['footer'], **props))
1519
1520
1520 def gettemplate(ui, tmpl, style):
1521 def gettemplate(ui, tmpl, style):
1521 """
1522 """
1522 Find the template matching the given template spec or style.
1523 Find the template matching the given template spec or style.
1523 """
1524 """
1524
1525
1525 # ui settings
1526 # ui settings
1526 if not tmpl and not style: # template are stronger than style
1527 if not tmpl and not style: # template are stronger than style
1527 tmpl = ui.config('ui', 'logtemplate')
1528 tmpl = ui.config('ui', 'logtemplate')
1528 if tmpl:
1529 if tmpl:
1529 return templater.unquotestring(tmpl), None
1530 return templater.unquotestring(tmpl), None
1530 else:
1531 else:
1531 style = util.expandpath(ui.config('ui', 'style', ''))
1532 style = util.expandpath(ui.config('ui', 'style', ''))
1532
1533
1533 if not tmpl and style:
1534 if not tmpl and style:
1534 mapfile = style
1535 mapfile = style
1535 if not os.path.split(mapfile)[0]:
1536 if not os.path.split(mapfile)[0]:
1536 mapname = (templater.templatepath('map-cmdline.' + mapfile)
1537 mapname = (templater.templatepath('map-cmdline.' + mapfile)
1537 or templater.templatepath(mapfile))
1538 or templater.templatepath(mapfile))
1538 if mapname:
1539 if mapname:
1539 mapfile = mapname
1540 mapfile = mapname
1540 return None, mapfile
1541 return None, mapfile
1541
1542
1542 if not tmpl:
1543 if not tmpl:
1543 return None, None
1544 return None, None
1544
1545
1545 return formatter.lookuptemplate(ui, 'changeset', tmpl)
1546 return formatter.lookuptemplate(ui, 'changeset', tmpl)
1546
1547
1547 def show_changeset(ui, repo, opts, buffered=False):
1548 def show_changeset(ui, repo, opts, buffered=False):
1548 """show one changeset using template or regular display.
1549 """show one changeset using template or regular display.
1549
1550
1550 Display format will be the first non-empty hit of:
1551 Display format will be the first non-empty hit of:
1551 1. option 'template'
1552 1. option 'template'
1552 2. option 'style'
1553 2. option 'style'
1553 3. [ui] setting 'logtemplate'
1554 3. [ui] setting 'logtemplate'
1554 4. [ui] setting 'style'
1555 4. [ui] setting 'style'
1555 If all of these values are either the unset or the empty string,
1556 If all of these values are either the unset or the empty string,
1556 regular display via changeset_printer() is done.
1557 regular display via changeset_printer() is done.
1557 """
1558 """
1558 # options
1559 # options
1559 matchfn = None
1560 matchfn = None
1560 if opts.get('patch') or opts.get('stat'):
1561 if opts.get('patch') or opts.get('stat'):
1561 matchfn = scmutil.matchall(repo)
1562 matchfn = scmutil.matchall(repo)
1562
1563
1563 if opts.get('template') == 'json':
1564 if opts.get('template') == 'json':
1564 return jsonchangeset(ui, repo, matchfn, opts, buffered)
1565 return jsonchangeset(ui, repo, matchfn, opts, buffered)
1565
1566
1566 tmpl, mapfile = gettemplate(ui, opts.get('template'), opts.get('style'))
1567 tmpl, mapfile = gettemplate(ui, opts.get('template'), opts.get('style'))
1567
1568
1568 if not tmpl and not mapfile:
1569 if not tmpl and not mapfile:
1569 return changeset_printer(ui, repo, matchfn, opts, buffered)
1570 return changeset_printer(ui, repo, matchfn, opts, buffered)
1570
1571
1571 return changeset_templater(ui, repo, matchfn, opts, tmpl, mapfile, buffered)
1572 return changeset_templater(ui, repo, matchfn, opts, tmpl, mapfile, buffered)
1572
1573
1573 def showmarker(fm, marker, index=None):
1574 def showmarker(fm, marker, index=None):
1574 """utility function to display obsolescence marker in a readable way
1575 """utility function to display obsolescence marker in a readable way
1575
1576
1576 To be used by debug function."""
1577 To be used by debug function."""
1577 if index is not None:
1578 if index is not None:
1578 fm.write('index', '%i ', index)
1579 fm.write('index', '%i ', index)
1579 fm.write('precnode', '%s ', hex(marker.precnode()))
1580 fm.write('precnode', '%s ', hex(marker.precnode()))
1580 succs = marker.succnodes()
1581 succs = marker.succnodes()
1581 fm.condwrite(succs, 'succnodes', '%s ',
1582 fm.condwrite(succs, 'succnodes', '%s ',
1582 fm.formatlist(map(hex, succs), name='node'))
1583 fm.formatlist(map(hex, succs), name='node'))
1583 fm.write('flag', '%X ', marker.flags())
1584 fm.write('flag', '%X ', marker.flags())
1584 parents = marker.parentnodes()
1585 parents = marker.parentnodes()
1585 if parents is not None:
1586 if parents is not None:
1586 fm.write('parentnodes', '{%s} ',
1587 fm.write('parentnodes', '{%s} ',
1587 fm.formatlist(map(hex, parents), name='node', sep=', '))
1588 fm.formatlist(map(hex, parents), name='node', sep=', '))
1588 fm.write('date', '(%s) ', fm.formatdate(marker.date()))
1589 fm.write('date', '(%s) ', fm.formatdate(marker.date()))
1589 meta = marker.metadata().copy()
1590 meta = marker.metadata().copy()
1590 meta.pop('date', None)
1591 meta.pop('date', None)
1591 fm.write('metadata', '{%s}', fm.formatdict(meta, fmt='%r: %r', sep=', '))
1592 fm.write('metadata', '{%s}', fm.formatdict(meta, fmt='%r: %r', sep=', '))
1592 fm.plain('\n')
1593 fm.plain('\n')
1593
1594
1594 def finddate(ui, repo, date):
1595 def finddate(ui, repo, date):
1595 """Find the tipmost changeset that matches the given date spec"""
1596 """Find the tipmost changeset that matches the given date spec"""
1596
1597
1597 df = util.matchdate(date)
1598 df = util.matchdate(date)
1598 m = scmutil.matchall(repo)
1599 m = scmutil.matchall(repo)
1599 results = {}
1600 results = {}
1600
1601
1601 def prep(ctx, fns):
1602 def prep(ctx, fns):
1602 d = ctx.date()
1603 d = ctx.date()
1603 if df(d[0]):
1604 if df(d[0]):
1604 results[ctx.rev()] = d
1605 results[ctx.rev()] = d
1605
1606
1606 for ctx in walkchangerevs(repo, m, {'rev': None}, prep):
1607 for ctx in walkchangerevs(repo, m, {'rev': None}, prep):
1607 rev = ctx.rev()
1608 rev = ctx.rev()
1608 if rev in results:
1609 if rev in results:
1609 ui.status(_("found revision %s from %s\n") %
1610 ui.status(_("found revision %s from %s\n") %
1610 (rev, util.datestr(results[rev])))
1611 (rev, util.datestr(results[rev])))
1611 return '%d' % rev
1612 return '%d' % rev
1612
1613
1613 raise error.Abort(_("revision matching date not found"))
1614 raise error.Abort(_("revision matching date not found"))
1614
1615
1615 def increasingwindows(windowsize=8, sizelimit=512):
1616 def increasingwindows(windowsize=8, sizelimit=512):
1616 while True:
1617 while True:
1617 yield windowsize
1618 yield windowsize
1618 if windowsize < sizelimit:
1619 if windowsize < sizelimit:
1619 windowsize *= 2
1620 windowsize *= 2
1620
1621
1621 class FileWalkError(Exception):
1622 class FileWalkError(Exception):
1622 pass
1623 pass
1623
1624
1624 def walkfilerevs(repo, match, follow, revs, fncache):
1625 def walkfilerevs(repo, match, follow, revs, fncache):
1625 '''Walks the file history for the matched files.
1626 '''Walks the file history for the matched files.
1626
1627
1627 Returns the changeset revs that are involved in the file history.
1628 Returns the changeset revs that are involved in the file history.
1628
1629
1629 Throws FileWalkError if the file history can't be walked using
1630 Throws FileWalkError if the file history can't be walked using
1630 filelogs alone.
1631 filelogs alone.
1631 '''
1632 '''
1632 wanted = set()
1633 wanted = set()
1633 copies = []
1634 copies = []
1634 minrev, maxrev = min(revs), max(revs)
1635 minrev, maxrev = min(revs), max(revs)
1635 def filerevgen(filelog, last):
1636 def filerevgen(filelog, last):
1636 """
1637 """
1637 Only files, no patterns. Check the history of each file.
1638 Only files, no patterns. Check the history of each file.
1638
1639
1639 Examines filelog entries within minrev, maxrev linkrev range
1640 Examines filelog entries within minrev, maxrev linkrev range
1640 Returns an iterator yielding (linkrev, parentlinkrevs, copied)
1641 Returns an iterator yielding (linkrev, parentlinkrevs, copied)
1641 tuples in backwards order
1642 tuples in backwards order
1642 """
1643 """
1643 cl_count = len(repo)
1644 cl_count = len(repo)
1644 revs = []
1645 revs = []
1645 for j in xrange(0, last + 1):
1646 for j in xrange(0, last + 1):
1646 linkrev = filelog.linkrev(j)
1647 linkrev = filelog.linkrev(j)
1647 if linkrev < minrev:
1648 if linkrev < minrev:
1648 continue
1649 continue
1649 # only yield rev for which we have the changelog, it can
1650 # only yield rev for which we have the changelog, it can
1650 # happen while doing "hg log" during a pull or commit
1651 # happen while doing "hg log" during a pull or commit
1651 if linkrev >= cl_count:
1652 if linkrev >= cl_count:
1652 break
1653 break
1653
1654
1654 parentlinkrevs = []
1655 parentlinkrevs = []
1655 for p in filelog.parentrevs(j):
1656 for p in filelog.parentrevs(j):
1656 if p != nullrev:
1657 if p != nullrev:
1657 parentlinkrevs.append(filelog.linkrev(p))
1658 parentlinkrevs.append(filelog.linkrev(p))
1658 n = filelog.node(j)
1659 n = filelog.node(j)
1659 revs.append((linkrev, parentlinkrevs,
1660 revs.append((linkrev, parentlinkrevs,
1660 follow and filelog.renamed(n)))
1661 follow and filelog.renamed(n)))
1661
1662
1662 return reversed(revs)
1663 return reversed(revs)
1663 def iterfiles():
1664 def iterfiles():
1664 pctx = repo['.']
1665 pctx = repo['.']
1665 for filename in match.files():
1666 for filename in match.files():
1666 if follow:
1667 if follow:
1667 if filename not in pctx:
1668 if filename not in pctx:
1668 raise error.Abort(_('cannot follow file not in parent '
1669 raise error.Abort(_('cannot follow file not in parent '
1669 'revision: "%s"') % filename)
1670 'revision: "%s"') % filename)
1670 yield filename, pctx[filename].filenode()
1671 yield filename, pctx[filename].filenode()
1671 else:
1672 else:
1672 yield filename, None
1673 yield filename, None
1673 for filename_node in copies:
1674 for filename_node in copies:
1674 yield filename_node
1675 yield filename_node
1675
1676
1676 for file_, node in iterfiles():
1677 for file_, node in iterfiles():
1677 filelog = repo.file(file_)
1678 filelog = repo.file(file_)
1678 if not len(filelog):
1679 if not len(filelog):
1679 if node is None:
1680 if node is None:
1680 # A zero count may be a directory or deleted file, so
1681 # A zero count may be a directory or deleted file, so
1681 # try to find matching entries on the slow path.
1682 # try to find matching entries on the slow path.
1682 if follow:
1683 if follow:
1683 raise error.Abort(
1684 raise error.Abort(
1684 _('cannot follow nonexistent file: "%s"') % file_)
1685 _('cannot follow nonexistent file: "%s"') % file_)
1685 raise FileWalkError("Cannot walk via filelog")
1686 raise FileWalkError("Cannot walk via filelog")
1686 else:
1687 else:
1687 continue
1688 continue
1688
1689
1689 if node is None:
1690 if node is None:
1690 last = len(filelog) - 1
1691 last = len(filelog) - 1
1691 else:
1692 else:
1692 last = filelog.rev(node)
1693 last = filelog.rev(node)
1693
1694
1694 # keep track of all ancestors of the file
1695 # keep track of all ancestors of the file
1695 ancestors = set([filelog.linkrev(last)])
1696 ancestors = set([filelog.linkrev(last)])
1696
1697
1697 # iterate from latest to oldest revision
1698 # iterate from latest to oldest revision
1698 for rev, flparentlinkrevs, copied in filerevgen(filelog, last):
1699 for rev, flparentlinkrevs, copied in filerevgen(filelog, last):
1699 if not follow:
1700 if not follow:
1700 if rev > maxrev:
1701 if rev > maxrev:
1701 continue
1702 continue
1702 else:
1703 else:
1703 # Note that last might not be the first interesting
1704 # Note that last might not be the first interesting
1704 # rev to us:
1705 # rev to us:
1705 # if the file has been changed after maxrev, we'll
1706 # if the file has been changed after maxrev, we'll
1706 # have linkrev(last) > maxrev, and we still need
1707 # have linkrev(last) > maxrev, and we still need
1707 # to explore the file graph
1708 # to explore the file graph
1708 if rev not in ancestors:
1709 if rev not in ancestors:
1709 continue
1710 continue
1710 # XXX insert 1327 fix here
1711 # XXX insert 1327 fix here
1711 if flparentlinkrevs:
1712 if flparentlinkrevs:
1712 ancestors.update(flparentlinkrevs)
1713 ancestors.update(flparentlinkrevs)
1713
1714
1714 fncache.setdefault(rev, []).append(file_)
1715 fncache.setdefault(rev, []).append(file_)
1715 wanted.add(rev)
1716 wanted.add(rev)
1716 if copied:
1717 if copied:
1717 copies.append(copied)
1718 copies.append(copied)
1718
1719
1719 return wanted
1720 return wanted
1720
1721
1721 class _followfilter(object):
1722 class _followfilter(object):
1722 def __init__(self, repo, onlyfirst=False):
1723 def __init__(self, repo, onlyfirst=False):
1723 self.repo = repo
1724 self.repo = repo
1724 self.startrev = nullrev
1725 self.startrev = nullrev
1725 self.roots = set()
1726 self.roots = set()
1726 self.onlyfirst = onlyfirst
1727 self.onlyfirst = onlyfirst
1727
1728
1728 def match(self, rev):
1729 def match(self, rev):
1729 def realparents(rev):
1730 def realparents(rev):
1730 if self.onlyfirst:
1731 if self.onlyfirst:
1731 return self.repo.changelog.parentrevs(rev)[0:1]
1732 return self.repo.changelog.parentrevs(rev)[0:1]
1732 else:
1733 else:
1733 return filter(lambda x: x != nullrev,
1734 return filter(lambda x: x != nullrev,
1734 self.repo.changelog.parentrevs(rev))
1735 self.repo.changelog.parentrevs(rev))
1735
1736
1736 if self.startrev == nullrev:
1737 if self.startrev == nullrev:
1737 self.startrev = rev
1738 self.startrev = rev
1738 return True
1739 return True
1739
1740
1740 if rev > self.startrev:
1741 if rev > self.startrev:
1741 # forward: all descendants
1742 # forward: all descendants
1742 if not self.roots:
1743 if not self.roots:
1743 self.roots.add(self.startrev)
1744 self.roots.add(self.startrev)
1744 for parent in realparents(rev):
1745 for parent in realparents(rev):
1745 if parent in self.roots:
1746 if parent in self.roots:
1746 self.roots.add(rev)
1747 self.roots.add(rev)
1747 return True
1748 return True
1748 else:
1749 else:
1749 # backwards: all parents
1750 # backwards: all parents
1750 if not self.roots:
1751 if not self.roots:
1751 self.roots.update(realparents(self.startrev))
1752 self.roots.update(realparents(self.startrev))
1752 if rev in self.roots:
1753 if rev in self.roots:
1753 self.roots.remove(rev)
1754 self.roots.remove(rev)
1754 self.roots.update(realparents(rev))
1755 self.roots.update(realparents(rev))
1755 return True
1756 return True
1756
1757
1757 return False
1758 return False
1758
1759
1759 def walkchangerevs(repo, match, opts, prepare):
1760 def walkchangerevs(repo, match, opts, prepare):
1760 '''Iterate over files and the revs in which they changed.
1761 '''Iterate over files and the revs in which they changed.
1761
1762
1762 Callers most commonly need to iterate backwards over the history
1763 Callers most commonly need to iterate backwards over the history
1763 in which they are interested. Doing so has awful (quadratic-looking)
1764 in which they are interested. Doing so has awful (quadratic-looking)
1764 performance, so we use iterators in a "windowed" way.
1765 performance, so we use iterators in a "windowed" way.
1765
1766
1766 We walk a window of revisions in the desired order. Within the
1767 We walk a window of revisions in the desired order. Within the
1767 window, we first walk forwards to gather data, then in the desired
1768 window, we first walk forwards to gather data, then in the desired
1768 order (usually backwards) to display it.
1769 order (usually backwards) to display it.
1769
1770
1770 This function returns an iterator yielding contexts. Before
1771 This function returns an iterator yielding contexts. Before
1771 yielding each context, the iterator will first call the prepare
1772 yielding each context, the iterator will first call the prepare
1772 function on each context in the window in forward order.'''
1773 function on each context in the window in forward order.'''
1773
1774
1774 follow = opts.get('follow') or opts.get('follow_first')
1775 follow = opts.get('follow') or opts.get('follow_first')
1775 revs = _logrevs(repo, opts)
1776 revs = _logrevs(repo, opts)
1776 if not revs:
1777 if not revs:
1777 return []
1778 return []
1778 wanted = set()
1779 wanted = set()
1779 slowpath = match.anypats() or ((match.isexact() or match.prefix()) and
1780 slowpath = match.anypats() or ((match.isexact() or match.prefix()) and
1780 opts.get('removed'))
1781 opts.get('removed'))
1781 fncache = {}
1782 fncache = {}
1782 change = repo.changectx
1783 change = repo.changectx
1783
1784
1784 # First step is to fill wanted, the set of revisions that we want to yield.
1785 # First step is to fill wanted, the set of revisions that we want to yield.
1785 # When it does not induce extra cost, we also fill fncache for revisions in
1786 # When it does not induce extra cost, we also fill fncache for revisions in
1786 # wanted: a cache of filenames that were changed (ctx.files()) and that
1787 # wanted: a cache of filenames that were changed (ctx.files()) and that
1787 # match the file filtering conditions.
1788 # match the file filtering conditions.
1788
1789
1789 if match.always():
1790 if match.always():
1790 # No files, no patterns. Display all revs.
1791 # No files, no patterns. Display all revs.
1791 wanted = revs
1792 wanted = revs
1792 elif not slowpath:
1793 elif not slowpath:
1793 # We only have to read through the filelog to find wanted revisions
1794 # We only have to read through the filelog to find wanted revisions
1794
1795
1795 try:
1796 try:
1796 wanted = walkfilerevs(repo, match, follow, revs, fncache)
1797 wanted = walkfilerevs(repo, match, follow, revs, fncache)
1797 except FileWalkError:
1798 except FileWalkError:
1798 slowpath = True
1799 slowpath = True
1799
1800
1800 # We decided to fall back to the slowpath because at least one
1801 # We decided to fall back to the slowpath because at least one
1801 # of the paths was not a file. Check to see if at least one of them
1802 # of the paths was not a file. Check to see if at least one of them
1802 # existed in history, otherwise simply return
1803 # existed in history, otherwise simply return
1803 for path in match.files():
1804 for path in match.files():
1804 if path == '.' or path in repo.store:
1805 if path == '.' or path in repo.store:
1805 break
1806 break
1806 else:
1807 else:
1807 return []
1808 return []
1808
1809
1809 if slowpath:
1810 if slowpath:
1810 # We have to read the changelog to match filenames against
1811 # We have to read the changelog to match filenames against
1811 # changed files
1812 # changed files
1812
1813
1813 if follow:
1814 if follow:
1814 raise error.Abort(_('can only follow copies/renames for explicit '
1815 raise error.Abort(_('can only follow copies/renames for explicit '
1815 'filenames'))
1816 'filenames'))
1816
1817
1817 # The slow path checks files modified in every changeset.
1818 # The slow path checks files modified in every changeset.
1818 # This is really slow on large repos, so compute the set lazily.
1819 # This is really slow on large repos, so compute the set lazily.
1819 class lazywantedset(object):
1820 class lazywantedset(object):
1820 def __init__(self):
1821 def __init__(self):
1821 self.set = set()
1822 self.set = set()
1822 self.revs = set(revs)
1823 self.revs = set(revs)
1823
1824
1824 # No need to worry about locality here because it will be accessed
1825 # No need to worry about locality here because it will be accessed
1825 # in the same order as the increasing window below.
1826 # in the same order as the increasing window below.
1826 def __contains__(self, value):
1827 def __contains__(self, value):
1827 if value in self.set:
1828 if value in self.set:
1828 return True
1829 return True
1829 elif not value in self.revs:
1830 elif not value in self.revs:
1830 return False
1831 return False
1831 else:
1832 else:
1832 self.revs.discard(value)
1833 self.revs.discard(value)
1833 ctx = change(value)
1834 ctx = change(value)
1834 matches = filter(match, ctx.files())
1835 matches = filter(match, ctx.files())
1835 if matches:
1836 if matches:
1836 fncache[value] = matches
1837 fncache[value] = matches
1837 self.set.add(value)
1838 self.set.add(value)
1838 return True
1839 return True
1839 return False
1840 return False
1840
1841
1841 def discard(self, value):
1842 def discard(self, value):
1842 self.revs.discard(value)
1843 self.revs.discard(value)
1843 self.set.discard(value)
1844 self.set.discard(value)
1844
1845
1845 wanted = lazywantedset()
1846 wanted = lazywantedset()
1846
1847
1847 # it might be worthwhile to do this in the iterator if the rev range
1848 # it might be worthwhile to do this in the iterator if the rev range
1848 # is descending and the prune args are all within that range
1849 # is descending and the prune args are all within that range
1849 for rev in opts.get('prune', ()):
1850 for rev in opts.get('prune', ()):
1850 rev = repo[rev].rev()
1851 rev = repo[rev].rev()
1851 ff = _followfilter(repo)
1852 ff = _followfilter(repo)
1852 stop = min(revs[0], revs[-1])
1853 stop = min(revs[0], revs[-1])
1853 for x in xrange(rev, stop - 1, -1):
1854 for x in xrange(rev, stop - 1, -1):
1854 if ff.match(x):
1855 if ff.match(x):
1855 wanted = wanted - [x]
1856 wanted = wanted - [x]
1856
1857
1857 # Now that wanted is correctly initialized, we can iterate over the
1858 # Now that wanted is correctly initialized, we can iterate over the
1858 # revision range, yielding only revisions in wanted.
1859 # revision range, yielding only revisions in wanted.
1859 def iterate():
1860 def iterate():
1860 if follow and match.always():
1861 if follow and match.always():
1861 ff = _followfilter(repo, onlyfirst=opts.get('follow_first'))
1862 ff = _followfilter(repo, onlyfirst=opts.get('follow_first'))
1862 def want(rev):
1863 def want(rev):
1863 return ff.match(rev) and rev in wanted
1864 return ff.match(rev) and rev in wanted
1864 else:
1865 else:
1865 def want(rev):
1866 def want(rev):
1866 return rev in wanted
1867 return rev in wanted
1867
1868
1868 it = iter(revs)
1869 it = iter(revs)
1869 stopiteration = False
1870 stopiteration = False
1870 for windowsize in increasingwindows():
1871 for windowsize in increasingwindows():
1871 nrevs = []
1872 nrevs = []
1872 for i in xrange(windowsize):
1873 for i in xrange(windowsize):
1873 rev = next(it, None)
1874 rev = next(it, None)
1874 if rev is None:
1875 if rev is None:
1875 stopiteration = True
1876 stopiteration = True
1876 break
1877 break
1877 elif want(rev):
1878 elif want(rev):
1878 nrevs.append(rev)
1879 nrevs.append(rev)
1879 for rev in sorted(nrevs):
1880 for rev in sorted(nrevs):
1880 fns = fncache.get(rev)
1881 fns = fncache.get(rev)
1881 ctx = change(rev)
1882 ctx = change(rev)
1882 if not fns:
1883 if not fns:
1883 def fns_generator():
1884 def fns_generator():
1884 for f in ctx.files():
1885 for f in ctx.files():
1885 if match(f):
1886 if match(f):
1886 yield f
1887 yield f
1887 fns = fns_generator()
1888 fns = fns_generator()
1888 prepare(ctx, fns)
1889 prepare(ctx, fns)
1889 for rev in nrevs:
1890 for rev in nrevs:
1890 yield change(rev)
1891 yield change(rev)
1891
1892
1892 if stopiteration:
1893 if stopiteration:
1893 break
1894 break
1894
1895
1895 return iterate()
1896 return iterate()
1896
1897
1897 def _makefollowlogfilematcher(repo, files, followfirst):
1898 def _makefollowlogfilematcher(repo, files, followfirst):
1898 # When displaying a revision with --patch --follow FILE, we have
1899 # When displaying a revision with --patch --follow FILE, we have
1899 # to know which file of the revision must be diffed. With
1900 # to know which file of the revision must be diffed. With
1900 # --follow, we want the names of the ancestors of FILE in the
1901 # --follow, we want the names of the ancestors of FILE in the
1901 # revision, stored in "fcache". "fcache" is populated by
1902 # revision, stored in "fcache". "fcache" is populated by
1902 # reproducing the graph traversal already done by --follow revset
1903 # reproducing the graph traversal already done by --follow revset
1903 # and relating revs to file names (which is not "correct" but
1904 # and relating revs to file names (which is not "correct" but
1904 # good enough).
1905 # good enough).
1905 fcache = {}
1906 fcache = {}
1906 fcacheready = [False]
1907 fcacheready = [False]
1907 pctx = repo['.']
1908 pctx = repo['.']
1908
1909
1909 def populate():
1910 def populate():
1910 for fn in files:
1911 for fn in files:
1911 fctx = pctx[fn]
1912 fctx = pctx[fn]
1912 fcache.setdefault(fctx.introrev(), set()).add(fctx.path())
1913 fcache.setdefault(fctx.introrev(), set()).add(fctx.path())
1913 for c in fctx.ancestors(followfirst=followfirst):
1914 for c in fctx.ancestors(followfirst=followfirst):
1914 fcache.setdefault(c.rev(), set()).add(c.path())
1915 fcache.setdefault(c.rev(), set()).add(c.path())
1915
1916
1916 def filematcher(rev):
1917 def filematcher(rev):
1917 if not fcacheready[0]:
1918 if not fcacheready[0]:
1918 # Lazy initialization
1919 # Lazy initialization
1919 fcacheready[0] = True
1920 fcacheready[0] = True
1920 populate()
1921 populate()
1921 return scmutil.matchfiles(repo, fcache.get(rev, []))
1922 return scmutil.matchfiles(repo, fcache.get(rev, []))
1922
1923
1923 return filematcher
1924 return filematcher
1924
1925
1925 def _makenofollowlogfilematcher(repo, pats, opts):
1926 def _makenofollowlogfilematcher(repo, pats, opts):
1926 '''hook for extensions to override the filematcher for non-follow cases'''
1927 '''hook for extensions to override the filematcher for non-follow cases'''
1927 return None
1928 return None
1928
1929
1929 def _makelogrevset(repo, pats, opts, revs):
1930 def _makelogrevset(repo, pats, opts, revs):
1930 """Return (expr, filematcher) where expr is a revset string built
1931 """Return (expr, filematcher) where expr is a revset string built
1931 from log options and file patterns or None. If --stat or --patch
1932 from log options and file patterns or None. If --stat or --patch
1932 are not passed filematcher is None. Otherwise it is a callable
1933 are not passed filematcher is None. Otherwise it is a callable
1933 taking a revision number and returning a match objects filtering
1934 taking a revision number and returning a match objects filtering
1934 the files to be detailed when displaying the revision.
1935 the files to be detailed when displaying the revision.
1935 """
1936 """
1936 opt2revset = {
1937 opt2revset = {
1937 'no_merges': ('not merge()', None),
1938 'no_merges': ('not merge()', None),
1938 'only_merges': ('merge()', None),
1939 'only_merges': ('merge()', None),
1939 '_ancestors': ('ancestors(%(val)s)', None),
1940 '_ancestors': ('ancestors(%(val)s)', None),
1940 '_fancestors': ('_firstancestors(%(val)s)', None),
1941 '_fancestors': ('_firstancestors(%(val)s)', None),
1941 '_descendants': ('descendants(%(val)s)', None),
1942 '_descendants': ('descendants(%(val)s)', None),
1942 '_fdescendants': ('_firstdescendants(%(val)s)', None),
1943 '_fdescendants': ('_firstdescendants(%(val)s)', None),
1943 '_matchfiles': ('_matchfiles(%(val)s)', None),
1944 '_matchfiles': ('_matchfiles(%(val)s)', None),
1944 'date': ('date(%(val)r)', None),
1945 'date': ('date(%(val)r)', None),
1945 'branch': ('branch(%(val)r)', ' or '),
1946 'branch': ('branch(%(val)r)', ' or '),
1946 '_patslog': ('filelog(%(val)r)', ' or '),
1947 '_patslog': ('filelog(%(val)r)', ' or '),
1947 '_patsfollow': ('follow(%(val)r)', ' or '),
1948 '_patsfollow': ('follow(%(val)r)', ' or '),
1948 '_patsfollowfirst': ('_followfirst(%(val)r)', ' or '),
1949 '_patsfollowfirst': ('_followfirst(%(val)r)', ' or '),
1949 'keyword': ('keyword(%(val)r)', ' or '),
1950 'keyword': ('keyword(%(val)r)', ' or '),
1950 'prune': ('not (%(val)r or ancestors(%(val)r))', ' and '),
1951 'prune': ('not (%(val)r or ancestors(%(val)r))', ' and '),
1951 'user': ('user(%(val)r)', ' or '),
1952 'user': ('user(%(val)r)', ' or '),
1952 }
1953 }
1953
1954
1954 opts = dict(opts)
1955 opts = dict(opts)
1955 # follow or not follow?
1956 # follow or not follow?
1956 follow = opts.get('follow') or opts.get('follow_first')
1957 follow = opts.get('follow') or opts.get('follow_first')
1957 if opts.get('follow_first'):
1958 if opts.get('follow_first'):
1958 followfirst = 1
1959 followfirst = 1
1959 else:
1960 else:
1960 followfirst = 0
1961 followfirst = 0
1961 # --follow with FILE behavior depends on revs...
1962 # --follow with FILE behavior depends on revs...
1962 it = iter(revs)
1963 it = iter(revs)
1963 startrev = next(it)
1964 startrev = next(it)
1964 followdescendants = startrev < next(it, startrev)
1965 followdescendants = startrev < next(it, startrev)
1965
1966
1966 # branch and only_branch are really aliases and must be handled at
1967 # branch and only_branch are really aliases and must be handled at
1967 # the same time
1968 # the same time
1968 opts['branch'] = opts.get('branch', []) + opts.get('only_branch', [])
1969 opts['branch'] = opts.get('branch', []) + opts.get('only_branch', [])
1969 opts['branch'] = [repo.lookupbranch(b) for b in opts['branch']]
1970 opts['branch'] = [repo.lookupbranch(b) for b in opts['branch']]
1970 # pats/include/exclude are passed to match.match() directly in
1971 # pats/include/exclude are passed to match.match() directly in
1971 # _matchfiles() revset but walkchangerevs() builds its matcher with
1972 # _matchfiles() revset but walkchangerevs() builds its matcher with
1972 # scmutil.match(). The difference is input pats are globbed on
1973 # scmutil.match(). The difference is input pats are globbed on
1973 # platforms without shell expansion (windows).
1974 # platforms without shell expansion (windows).
1974 wctx = repo[None]
1975 wctx = repo[None]
1975 match, pats = scmutil.matchandpats(wctx, pats, opts)
1976 match, pats = scmutil.matchandpats(wctx, pats, opts)
1976 slowpath = match.anypats() or ((match.isexact() or match.prefix()) and
1977 slowpath = match.anypats() or ((match.isexact() or match.prefix()) and
1977 opts.get('removed'))
1978 opts.get('removed'))
1978 if not slowpath:
1979 if not slowpath:
1979 for f in match.files():
1980 for f in match.files():
1980 if follow and f not in wctx:
1981 if follow and f not in wctx:
1981 # If the file exists, it may be a directory, so let it
1982 # If the file exists, it may be a directory, so let it
1982 # take the slow path.
1983 # take the slow path.
1983 if os.path.exists(repo.wjoin(f)):
1984 if os.path.exists(repo.wjoin(f)):
1984 slowpath = True
1985 slowpath = True
1985 continue
1986 continue
1986 else:
1987 else:
1987 raise error.Abort(_('cannot follow file not in parent '
1988 raise error.Abort(_('cannot follow file not in parent '
1988 'revision: "%s"') % f)
1989 'revision: "%s"') % f)
1989 filelog = repo.file(f)
1990 filelog = repo.file(f)
1990 if not filelog:
1991 if not filelog:
1991 # A zero count may be a directory or deleted file, so
1992 # A zero count may be a directory or deleted file, so
1992 # try to find matching entries on the slow path.
1993 # try to find matching entries on the slow path.
1993 if follow:
1994 if follow:
1994 raise error.Abort(
1995 raise error.Abort(
1995 _('cannot follow nonexistent file: "%s"') % f)
1996 _('cannot follow nonexistent file: "%s"') % f)
1996 slowpath = True
1997 slowpath = True
1997
1998
1998 # We decided to fall back to the slowpath because at least one
1999 # We decided to fall back to the slowpath because at least one
1999 # of the paths was not a file. Check to see if at least one of them
2000 # of the paths was not a file. Check to see if at least one of them
2000 # existed in history - in that case, we'll continue down the
2001 # existed in history - in that case, we'll continue down the
2001 # slowpath; otherwise, we can turn off the slowpath
2002 # slowpath; otherwise, we can turn off the slowpath
2002 if slowpath:
2003 if slowpath:
2003 for path in match.files():
2004 for path in match.files():
2004 if path == '.' or path in repo.store:
2005 if path == '.' or path in repo.store:
2005 break
2006 break
2006 else:
2007 else:
2007 slowpath = False
2008 slowpath = False
2008
2009
2009 fpats = ('_patsfollow', '_patsfollowfirst')
2010 fpats = ('_patsfollow', '_patsfollowfirst')
2010 fnopats = (('_ancestors', '_fancestors'),
2011 fnopats = (('_ancestors', '_fancestors'),
2011 ('_descendants', '_fdescendants'))
2012 ('_descendants', '_fdescendants'))
2012 if slowpath:
2013 if slowpath:
2013 # See walkchangerevs() slow path.
2014 # See walkchangerevs() slow path.
2014 #
2015 #
2015 # pats/include/exclude cannot be represented as separate
2016 # pats/include/exclude cannot be represented as separate
2016 # revset expressions as their filtering logic applies at file
2017 # revset expressions as their filtering logic applies at file
2017 # level. For instance "-I a -X a" matches a revision touching
2018 # level. For instance "-I a -X a" matches a revision touching
2018 # "a" and "b" while "file(a) and not file(b)" does
2019 # "a" and "b" while "file(a) and not file(b)" does
2019 # not. Besides, filesets are evaluated against the working
2020 # not. Besides, filesets are evaluated against the working
2020 # directory.
2021 # directory.
2021 matchargs = ['r:', 'd:relpath']
2022 matchargs = ['r:', 'd:relpath']
2022 for p in pats:
2023 for p in pats:
2023 matchargs.append('p:' + p)
2024 matchargs.append('p:' + p)
2024 for p in opts.get('include', []):
2025 for p in opts.get('include', []):
2025 matchargs.append('i:' + p)
2026 matchargs.append('i:' + p)
2026 for p in opts.get('exclude', []):
2027 for p in opts.get('exclude', []):
2027 matchargs.append('x:' + p)
2028 matchargs.append('x:' + p)
2028 matchargs = ','.join(('%r' % p) for p in matchargs)
2029 matchargs = ','.join(('%r' % p) for p in matchargs)
2029 opts['_matchfiles'] = matchargs
2030 opts['_matchfiles'] = matchargs
2030 if follow:
2031 if follow:
2031 opts[fnopats[0][followfirst]] = '.'
2032 opts[fnopats[0][followfirst]] = '.'
2032 else:
2033 else:
2033 if follow:
2034 if follow:
2034 if pats:
2035 if pats:
2035 # follow() revset interprets its file argument as a
2036 # follow() revset interprets its file argument as a
2036 # manifest entry, so use match.files(), not pats.
2037 # manifest entry, so use match.files(), not pats.
2037 opts[fpats[followfirst]] = list(match.files())
2038 opts[fpats[followfirst]] = list(match.files())
2038 else:
2039 else:
2039 op = fnopats[followdescendants][followfirst]
2040 op = fnopats[followdescendants][followfirst]
2040 opts[op] = 'rev(%d)' % startrev
2041 opts[op] = 'rev(%d)' % startrev
2041 else:
2042 else:
2042 opts['_patslog'] = list(pats)
2043 opts['_patslog'] = list(pats)
2043
2044
2044 filematcher = None
2045 filematcher = None
2045 if opts.get('patch') or opts.get('stat'):
2046 if opts.get('patch') or opts.get('stat'):
2046 # When following files, track renames via a special matcher.
2047 # When following files, track renames via a special matcher.
2047 # If we're forced to take the slowpath it means we're following
2048 # If we're forced to take the slowpath it means we're following
2048 # at least one pattern/directory, so don't bother with rename tracking.
2049 # at least one pattern/directory, so don't bother with rename tracking.
2049 if follow and not match.always() and not slowpath:
2050 if follow and not match.always() and not slowpath:
2050 # _makefollowlogfilematcher expects its files argument to be
2051 # _makefollowlogfilematcher expects its files argument to be
2051 # relative to the repo root, so use match.files(), not pats.
2052 # relative to the repo root, so use match.files(), not pats.
2052 filematcher = _makefollowlogfilematcher(repo, match.files(),
2053 filematcher = _makefollowlogfilematcher(repo, match.files(),
2053 followfirst)
2054 followfirst)
2054 else:
2055 else:
2055 filematcher = _makenofollowlogfilematcher(repo, pats, opts)
2056 filematcher = _makenofollowlogfilematcher(repo, pats, opts)
2056 if filematcher is None:
2057 if filematcher is None:
2057 filematcher = lambda rev: match
2058 filematcher = lambda rev: match
2058
2059
2059 expr = []
2060 expr = []
2060 for op, val in sorted(opts.iteritems()):
2061 for op, val in sorted(opts.iteritems()):
2061 if not val:
2062 if not val:
2062 continue
2063 continue
2063 if op not in opt2revset:
2064 if op not in opt2revset:
2064 continue
2065 continue
2065 revop, andor = opt2revset[op]
2066 revop, andor = opt2revset[op]
2066 if '%(val)' not in revop:
2067 if '%(val)' not in revop:
2067 expr.append(revop)
2068 expr.append(revop)
2068 else:
2069 else:
2069 if not isinstance(val, list):
2070 if not isinstance(val, list):
2070 e = revop % {'val': val}
2071 e = revop % {'val': val}
2071 else:
2072 else:
2072 e = '(' + andor.join((revop % {'val': v}) for v in val) + ')'
2073 e = '(' + andor.join((revop % {'val': v}) for v in val) + ')'
2073 expr.append(e)
2074 expr.append(e)
2074
2075
2075 if expr:
2076 if expr:
2076 expr = '(' + ' and '.join(expr) + ')'
2077 expr = '(' + ' and '.join(expr) + ')'
2077 else:
2078 else:
2078 expr = None
2079 expr = None
2079 return expr, filematcher
2080 return expr, filematcher
2080
2081
2081 def _logrevs(repo, opts):
2082 def _logrevs(repo, opts):
2082 # Default --rev value depends on --follow but --follow behavior
2083 # Default --rev value depends on --follow but --follow behavior
2083 # depends on revisions resolved from --rev...
2084 # depends on revisions resolved from --rev...
2084 follow = opts.get('follow') or opts.get('follow_first')
2085 follow = opts.get('follow') or opts.get('follow_first')
2085 if opts.get('rev'):
2086 if opts.get('rev'):
2086 revs = scmutil.revrange(repo, opts['rev'])
2087 revs = scmutil.revrange(repo, opts['rev'])
2087 elif follow and repo.dirstate.p1() == nullid:
2088 elif follow and repo.dirstate.p1() == nullid:
2088 revs = smartset.baseset()
2089 revs = smartset.baseset()
2089 elif follow:
2090 elif follow:
2090 revs = repo.revs('reverse(:.)')
2091 revs = repo.revs('reverse(:.)')
2091 else:
2092 else:
2092 revs = smartset.spanset(repo)
2093 revs = smartset.spanset(repo)
2093 revs.reverse()
2094 revs.reverse()
2094 return revs
2095 return revs
2095
2096
2096 def getgraphlogrevs(repo, pats, opts):
2097 def getgraphlogrevs(repo, pats, opts):
2097 """Return (revs, expr, filematcher) where revs is an iterable of
2098 """Return (revs, expr, filematcher) where revs is an iterable of
2098 revision numbers, expr is a revset string built from log options
2099 revision numbers, expr is a revset string built from log options
2099 and file patterns or None, and used to filter 'revs'. If --stat or
2100 and file patterns or None, and used to filter 'revs'. If --stat or
2100 --patch are not passed filematcher is None. Otherwise it is a
2101 --patch are not passed filematcher is None. Otherwise it is a
2101 callable taking a revision number and returning a match objects
2102 callable taking a revision number and returning a match objects
2102 filtering the files to be detailed when displaying the revision.
2103 filtering the files to be detailed when displaying the revision.
2103 """
2104 """
2104 limit = loglimit(opts)
2105 limit = loglimit(opts)
2105 revs = _logrevs(repo, opts)
2106 revs = _logrevs(repo, opts)
2106 if not revs:
2107 if not revs:
2107 return smartset.baseset(), None, None
2108 return smartset.baseset(), None, None
2108 expr, filematcher = _makelogrevset(repo, pats, opts, revs)
2109 expr, filematcher = _makelogrevset(repo, pats, opts, revs)
2109 if opts.get('rev'):
2110 if opts.get('rev'):
2110 # User-specified revs might be unsorted, but don't sort before
2111 # User-specified revs might be unsorted, but don't sort before
2111 # _makelogrevset because it might depend on the order of revs
2112 # _makelogrevset because it might depend on the order of revs
2112 if not (revs.isdescending() or revs.istopo()):
2113 if not (revs.isdescending() or revs.istopo()):
2113 revs.sort(reverse=True)
2114 revs.sort(reverse=True)
2114 if expr:
2115 if expr:
2115 matcher = revset.match(repo.ui, expr, order=revset.followorder)
2116 matcher = revset.match(repo.ui, expr, order=revset.followorder)
2116 revs = matcher(repo, revs)
2117 revs = matcher(repo, revs)
2117 if limit is not None:
2118 if limit is not None:
2118 limitedrevs = []
2119 limitedrevs = []
2119 for idx, rev in enumerate(revs):
2120 for idx, rev in enumerate(revs):
2120 if idx >= limit:
2121 if idx >= limit:
2121 break
2122 break
2122 limitedrevs.append(rev)
2123 limitedrevs.append(rev)
2123 revs = smartset.baseset(limitedrevs)
2124 revs = smartset.baseset(limitedrevs)
2124
2125
2125 return revs, expr, filematcher
2126 return revs, expr, filematcher
2126
2127
2127 def getlogrevs(repo, pats, opts):
2128 def getlogrevs(repo, pats, opts):
2128 """Return (revs, expr, filematcher) where revs is an iterable of
2129 """Return (revs, expr, filematcher) where revs is an iterable of
2129 revision numbers, expr is a revset string built from log options
2130 revision numbers, expr is a revset string built from log options
2130 and file patterns or None, and used to filter 'revs'. If --stat or
2131 and file patterns or None, and used to filter 'revs'. If --stat or
2131 --patch are not passed filematcher is None. Otherwise it is a
2132 --patch are not passed filematcher is None. Otherwise it is a
2132 callable taking a revision number and returning a match objects
2133 callable taking a revision number and returning a match objects
2133 filtering the files to be detailed when displaying the revision.
2134 filtering the files to be detailed when displaying the revision.
2134 """
2135 """
2135 limit = loglimit(opts)
2136 limit = loglimit(opts)
2136 revs = _logrevs(repo, opts)
2137 revs = _logrevs(repo, opts)
2137 if not revs:
2138 if not revs:
2138 return smartset.baseset([]), None, None
2139 return smartset.baseset([]), None, None
2139 expr, filematcher = _makelogrevset(repo, pats, opts, revs)
2140 expr, filematcher = _makelogrevset(repo, pats, opts, revs)
2140 if expr:
2141 if expr:
2141 matcher = revset.match(repo.ui, expr, order=revset.followorder)
2142 matcher = revset.match(repo.ui, expr, order=revset.followorder)
2142 revs = matcher(repo, revs)
2143 revs = matcher(repo, revs)
2143 if limit is not None:
2144 if limit is not None:
2144 limitedrevs = []
2145 limitedrevs = []
2145 for idx, r in enumerate(revs):
2146 for idx, r in enumerate(revs):
2146 if limit <= idx:
2147 if limit <= idx:
2147 break
2148 break
2148 limitedrevs.append(r)
2149 limitedrevs.append(r)
2149 revs = smartset.baseset(limitedrevs)
2150 revs = smartset.baseset(limitedrevs)
2150
2151
2151 return revs, expr, filematcher
2152 return revs, expr, filematcher
2152
2153
2153 def _graphnodeformatter(ui, displayer):
2154 def _graphnodeformatter(ui, displayer):
2154 spec = ui.config('ui', 'graphnodetemplate')
2155 spec = ui.config('ui', 'graphnodetemplate')
2155 if not spec:
2156 if not spec:
2156 return templatekw.showgraphnode # fast path for "{graphnode}"
2157 return templatekw.showgraphnode # fast path for "{graphnode}"
2157
2158
2158 spec = templater.unquotestring(spec)
2159 spec = templater.unquotestring(spec)
2159 templ = formatter.gettemplater(ui, 'graphnode', spec)
2160 templ = formatter.gettemplater(ui, 'graphnode', spec)
2160 cache = {}
2161 cache = {}
2161 if isinstance(displayer, changeset_templater):
2162 if isinstance(displayer, changeset_templater):
2162 cache = displayer.cache # reuse cache of slow templates
2163 cache = displayer.cache # reuse cache of slow templates
2163 props = templatekw.keywords.copy()
2164 props = templatekw.keywords.copy()
2164 props['templ'] = templ
2165 props['templ'] = templ
2165 props['cache'] = cache
2166 props['cache'] = cache
2166 def formatnode(repo, ctx):
2167 def formatnode(repo, ctx):
2167 props['ctx'] = ctx
2168 props['ctx'] = ctx
2168 props['repo'] = repo
2169 props['repo'] = repo
2169 props['ui'] = repo.ui
2170 props['ui'] = repo.ui
2170 props['revcache'] = {}
2171 props['revcache'] = {}
2171 return templater.stringify(templ('graphnode', **props))
2172 return templater.stringify(templ('graphnode', **props))
2172 return formatnode
2173 return formatnode
2173
2174
2174 def displaygraph(ui, repo, dag, displayer, edgefn, getrenamed=None,
2175 def displaygraph(ui, repo, dag, displayer, edgefn, getrenamed=None,
2175 filematcher=None):
2176 filematcher=None):
2176 formatnode = _graphnodeformatter(ui, displayer)
2177 formatnode = _graphnodeformatter(ui, displayer)
2177 state = graphmod.asciistate()
2178 state = graphmod.asciistate()
2178 styles = state['styles']
2179 styles = state['styles']
2179
2180
2180 # only set graph styling if HGPLAIN is not set.
2181 # only set graph styling if HGPLAIN is not set.
2181 if ui.plain('graph'):
2182 if ui.plain('graph'):
2182 # set all edge styles to |, the default pre-3.8 behaviour
2183 # set all edge styles to |, the default pre-3.8 behaviour
2183 styles.update(dict.fromkeys(styles, '|'))
2184 styles.update(dict.fromkeys(styles, '|'))
2184 else:
2185 else:
2185 edgetypes = {
2186 edgetypes = {
2186 'parent': graphmod.PARENT,
2187 'parent': graphmod.PARENT,
2187 'grandparent': graphmod.GRANDPARENT,
2188 'grandparent': graphmod.GRANDPARENT,
2188 'missing': graphmod.MISSINGPARENT
2189 'missing': graphmod.MISSINGPARENT
2189 }
2190 }
2190 for name, key in edgetypes.items():
2191 for name, key in edgetypes.items():
2191 # experimental config: experimental.graphstyle.*
2192 # experimental config: experimental.graphstyle.*
2192 styles[key] = ui.config('experimental', 'graphstyle.%s' % name,
2193 styles[key] = ui.config('experimental', 'graphstyle.%s' % name,
2193 styles[key])
2194 styles[key])
2194 if not styles[key]:
2195 if not styles[key]:
2195 styles[key] = None
2196 styles[key] = None
2196
2197
2197 # experimental config: experimental.graphshorten
2198 # experimental config: experimental.graphshorten
2198 state['graphshorten'] = ui.configbool('experimental', 'graphshorten')
2199 state['graphshorten'] = ui.configbool('experimental', 'graphshorten')
2199
2200
2200 for rev, type, ctx, parents in dag:
2201 for rev, type, ctx, parents in dag:
2201 char = formatnode(repo, ctx)
2202 char = formatnode(repo, ctx)
2202 copies = None
2203 copies = None
2203 if getrenamed and ctx.rev():
2204 if getrenamed and ctx.rev():
2204 copies = []
2205 copies = []
2205 for fn in ctx.files():
2206 for fn in ctx.files():
2206 rename = getrenamed(fn, ctx.rev())
2207 rename = getrenamed(fn, ctx.rev())
2207 if rename:
2208 if rename:
2208 copies.append((fn, rename[0]))
2209 copies.append((fn, rename[0]))
2209 revmatchfn = None
2210 revmatchfn = None
2210 if filematcher is not None:
2211 if filematcher is not None:
2211 revmatchfn = filematcher(ctx.rev())
2212 revmatchfn = filematcher(ctx.rev())
2212 displayer.show(ctx, copies=copies, matchfn=revmatchfn)
2213 displayer.show(ctx, copies=copies, matchfn=revmatchfn)
2213 lines = displayer.hunk.pop(rev).split('\n')
2214 lines = displayer.hunk.pop(rev).split('\n')
2214 if not lines[-1]:
2215 if not lines[-1]:
2215 del lines[-1]
2216 del lines[-1]
2216 displayer.flush(ctx)
2217 displayer.flush(ctx)
2217 edges = edgefn(type, char, lines, state, rev, parents)
2218 edges = edgefn(type, char, lines, state, rev, parents)
2218 for type, char, lines, coldata in edges:
2219 for type, char, lines, coldata in edges:
2219 graphmod.ascii(ui, state, type, char, lines, coldata)
2220 graphmod.ascii(ui, state, type, char, lines, coldata)
2220 displayer.close()
2221 displayer.close()
2221
2222
2222 def graphlog(ui, repo, pats, opts):
2223 def graphlog(ui, repo, pats, opts):
2223 # Parameters are identical to log command ones
2224 # Parameters are identical to log command ones
2224 revs, expr, filematcher = getgraphlogrevs(repo, pats, opts)
2225 revs, expr, filematcher = getgraphlogrevs(repo, pats, opts)
2225 revdag = graphmod.dagwalker(repo, revs)
2226 revdag = graphmod.dagwalker(repo, revs)
2226
2227
2227 getrenamed = None
2228 getrenamed = None
2228 if opts.get('copies'):
2229 if opts.get('copies'):
2229 endrev = None
2230 endrev = None
2230 if opts.get('rev'):
2231 if opts.get('rev'):
2231 endrev = scmutil.revrange(repo, opts.get('rev')).max() + 1
2232 endrev = scmutil.revrange(repo, opts.get('rev')).max() + 1
2232 getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
2233 getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
2233
2234
2234 ui.pager('log')
2235 ui.pager('log')
2235 displayer = show_changeset(ui, repo, opts, buffered=True)
2236 displayer = show_changeset(ui, repo, opts, buffered=True)
2236 displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges, getrenamed,
2237 displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges, getrenamed,
2237 filematcher)
2238 filematcher)
2238
2239
2239 def checkunsupportedgraphflags(pats, opts):
2240 def checkunsupportedgraphflags(pats, opts):
2240 for op in ["newest_first"]:
2241 for op in ["newest_first"]:
2241 if op in opts and opts[op]:
2242 if op in opts and opts[op]:
2242 raise error.Abort(_("-G/--graph option is incompatible with --%s")
2243 raise error.Abort(_("-G/--graph option is incompatible with --%s")
2243 % op.replace("_", "-"))
2244 % op.replace("_", "-"))
2244
2245
2245 def graphrevs(repo, nodes, opts):
2246 def graphrevs(repo, nodes, opts):
2246 limit = loglimit(opts)
2247 limit = loglimit(opts)
2247 nodes.reverse()
2248 nodes.reverse()
2248 if limit is not None:
2249 if limit is not None:
2249 nodes = nodes[:limit]
2250 nodes = nodes[:limit]
2250 return graphmod.nodes(repo, nodes)
2251 return graphmod.nodes(repo, nodes)
2251
2252
2252 def add(ui, repo, match, prefix, explicitonly, **opts):
2253 def add(ui, repo, match, prefix, explicitonly, **opts):
2253 join = lambda f: os.path.join(prefix, f)
2254 join = lambda f: os.path.join(prefix, f)
2254 bad = []
2255 bad = []
2255
2256
2256 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
2257 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
2257 names = []
2258 names = []
2258 wctx = repo[None]
2259 wctx = repo[None]
2259 cca = None
2260 cca = None
2260 abort, warn = scmutil.checkportabilityalert(ui)
2261 abort, warn = scmutil.checkportabilityalert(ui)
2261 if abort or warn:
2262 if abort or warn:
2262 cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate)
2263 cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate)
2263
2264
2264 badmatch = matchmod.badmatch(match, badfn)
2265 badmatch = matchmod.badmatch(match, badfn)
2265 dirstate = repo.dirstate
2266 dirstate = repo.dirstate
2266 # We don't want to just call wctx.walk here, since it would return a lot of
2267 # We don't want to just call wctx.walk here, since it would return a lot of
2267 # clean files, which we aren't interested in and takes time.
2268 # clean files, which we aren't interested in and takes time.
2268 for f in sorted(dirstate.walk(badmatch, sorted(wctx.substate),
2269 for f in sorted(dirstate.walk(badmatch, sorted(wctx.substate),
2269 True, False, full=False)):
2270 True, False, full=False)):
2270 exact = match.exact(f)
2271 exact = match.exact(f)
2271 if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f):
2272 if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f):
2272 if cca:
2273 if cca:
2273 cca(f)
2274 cca(f)
2274 names.append(f)
2275 names.append(f)
2275 if ui.verbose or not exact:
2276 if ui.verbose or not exact:
2276 ui.status(_('adding %s\n') % match.rel(f))
2277 ui.status(_('adding %s\n') % match.rel(f))
2277
2278
2278 for subpath in sorted(wctx.substate):
2279 for subpath in sorted(wctx.substate):
2279 sub = wctx.sub(subpath)
2280 sub = wctx.sub(subpath)
2280 try:
2281 try:
2281 submatch = matchmod.subdirmatcher(subpath, match)
2282 submatch = matchmod.subdirmatcher(subpath, match)
2282 if opts.get(r'subrepos'):
2283 if opts.get(r'subrepos'):
2283 bad.extend(sub.add(ui, submatch, prefix, False, **opts))
2284 bad.extend(sub.add(ui, submatch, prefix, False, **opts))
2284 else:
2285 else:
2285 bad.extend(sub.add(ui, submatch, prefix, True, **opts))
2286 bad.extend(sub.add(ui, submatch, prefix, True, **opts))
2286 except error.LookupError:
2287 except error.LookupError:
2287 ui.status(_("skipping missing subrepository: %s\n")
2288 ui.status(_("skipping missing subrepository: %s\n")
2288 % join(subpath))
2289 % join(subpath))
2289
2290
2290 if not opts.get(r'dry_run'):
2291 if not opts.get(r'dry_run'):
2291 rejected = wctx.add(names, prefix)
2292 rejected = wctx.add(names, prefix)
2292 bad.extend(f for f in rejected if f in match.files())
2293 bad.extend(f for f in rejected if f in match.files())
2293 return bad
2294 return bad
2294
2295
2295 def addwebdirpath(repo, serverpath, webconf):
2296 def addwebdirpath(repo, serverpath, webconf):
2296 webconf[serverpath] = repo.root
2297 webconf[serverpath] = repo.root
2297 repo.ui.debug('adding %s = %s\n' % (serverpath, repo.root))
2298 repo.ui.debug('adding %s = %s\n' % (serverpath, repo.root))
2298
2299
2299 for r in repo.revs('filelog("path:.hgsub")'):
2300 for r in repo.revs('filelog("path:.hgsub")'):
2300 ctx = repo[r]
2301 ctx = repo[r]
2301 for subpath in ctx.substate:
2302 for subpath in ctx.substate:
2302 ctx.sub(subpath).addwebdirpath(serverpath, webconf)
2303 ctx.sub(subpath).addwebdirpath(serverpath, webconf)
2303
2304
2304 def forget(ui, repo, match, prefix, explicitonly):
2305 def forget(ui, repo, match, prefix, explicitonly):
2305 join = lambda f: os.path.join(prefix, f)
2306 join = lambda f: os.path.join(prefix, f)
2306 bad = []
2307 bad = []
2307 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
2308 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
2308 wctx = repo[None]
2309 wctx = repo[None]
2309 forgot = []
2310 forgot = []
2310
2311
2311 s = repo.status(match=matchmod.badmatch(match, badfn), clean=True)
2312 s = repo.status(match=matchmod.badmatch(match, badfn), clean=True)
2312 forget = sorted(s.modified + s.added + s.deleted + s.clean)
2313 forget = sorted(s.modified + s.added + s.deleted + s.clean)
2313 if explicitonly:
2314 if explicitonly:
2314 forget = [f for f in forget if match.exact(f)]
2315 forget = [f for f in forget if match.exact(f)]
2315
2316
2316 for subpath in sorted(wctx.substate):
2317 for subpath in sorted(wctx.substate):
2317 sub = wctx.sub(subpath)
2318 sub = wctx.sub(subpath)
2318 try:
2319 try:
2319 submatch = matchmod.subdirmatcher(subpath, match)
2320 submatch = matchmod.subdirmatcher(subpath, match)
2320 subbad, subforgot = sub.forget(submatch, prefix)
2321 subbad, subforgot = sub.forget(submatch, prefix)
2321 bad.extend([subpath + '/' + f for f in subbad])
2322 bad.extend([subpath + '/' + f for f in subbad])
2322 forgot.extend([subpath + '/' + f for f in subforgot])
2323 forgot.extend([subpath + '/' + f for f in subforgot])
2323 except error.LookupError:
2324 except error.LookupError:
2324 ui.status(_("skipping missing subrepository: %s\n")
2325 ui.status(_("skipping missing subrepository: %s\n")
2325 % join(subpath))
2326 % join(subpath))
2326
2327
2327 if not explicitonly:
2328 if not explicitonly:
2328 for f in match.files():
2329 for f in match.files():
2329 if f not in repo.dirstate and not repo.wvfs.isdir(f):
2330 if f not in repo.dirstate and not repo.wvfs.isdir(f):
2330 if f not in forgot:
2331 if f not in forgot:
2331 if repo.wvfs.exists(f):
2332 if repo.wvfs.exists(f):
2332 # Don't complain if the exact case match wasn't given.
2333 # Don't complain if the exact case match wasn't given.
2333 # But don't do this until after checking 'forgot', so
2334 # But don't do this until after checking 'forgot', so
2334 # that subrepo files aren't normalized, and this op is
2335 # that subrepo files aren't normalized, and this op is
2335 # purely from data cached by the status walk above.
2336 # purely from data cached by the status walk above.
2336 if repo.dirstate.normalize(f) in repo.dirstate:
2337 if repo.dirstate.normalize(f) in repo.dirstate:
2337 continue
2338 continue
2338 ui.warn(_('not removing %s: '
2339 ui.warn(_('not removing %s: '
2339 'file is already untracked\n')
2340 'file is already untracked\n')
2340 % match.rel(f))
2341 % match.rel(f))
2341 bad.append(f)
2342 bad.append(f)
2342
2343
2343 for f in forget:
2344 for f in forget:
2344 if ui.verbose or not match.exact(f):
2345 if ui.verbose or not match.exact(f):
2345 ui.status(_('removing %s\n') % match.rel(f))
2346 ui.status(_('removing %s\n') % match.rel(f))
2346
2347
2347 rejected = wctx.forget(forget, prefix)
2348 rejected = wctx.forget(forget, prefix)
2348 bad.extend(f for f in rejected if f in match.files())
2349 bad.extend(f for f in rejected if f in match.files())
2349 forgot.extend(f for f in forget if f not in rejected)
2350 forgot.extend(f for f in forget if f not in rejected)
2350 return bad, forgot
2351 return bad, forgot
2351
2352
2352 def files(ui, ctx, m, fm, fmt, subrepos):
2353 def files(ui, ctx, m, fm, fmt, subrepos):
2353 rev = ctx.rev()
2354 rev = ctx.rev()
2354 ret = 1
2355 ret = 1
2355 ds = ctx.repo().dirstate
2356 ds = ctx.repo().dirstate
2356
2357
2357 for f in ctx.matches(m):
2358 for f in ctx.matches(m):
2358 if rev is None and ds[f] == 'r':
2359 if rev is None and ds[f] == 'r':
2359 continue
2360 continue
2360 fm.startitem()
2361 fm.startitem()
2361 if ui.verbose:
2362 if ui.verbose:
2362 fc = ctx[f]
2363 fc = ctx[f]
2363 fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags())
2364 fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags())
2364 fm.data(abspath=f)
2365 fm.data(abspath=f)
2365 fm.write('path', fmt, m.rel(f))
2366 fm.write('path', fmt, m.rel(f))
2366 ret = 0
2367 ret = 0
2367
2368
2368 for subpath in sorted(ctx.substate):
2369 for subpath in sorted(ctx.substate):
2369 submatch = matchmod.subdirmatcher(subpath, m)
2370 submatch = matchmod.subdirmatcher(subpath, m)
2370 if (subrepos or m.exact(subpath) or any(submatch.files())):
2371 if (subrepos or m.exact(subpath) or any(submatch.files())):
2371 sub = ctx.sub(subpath)
2372 sub = ctx.sub(subpath)
2372 try:
2373 try:
2373 recurse = m.exact(subpath) or subrepos
2374 recurse = m.exact(subpath) or subrepos
2374 if sub.printfiles(ui, submatch, fm, fmt, recurse) == 0:
2375 if sub.printfiles(ui, submatch, fm, fmt, recurse) == 0:
2375 ret = 0
2376 ret = 0
2376 except error.LookupError:
2377 except error.LookupError:
2377 ui.status(_("skipping missing subrepository: %s\n")
2378 ui.status(_("skipping missing subrepository: %s\n")
2378 % m.abs(subpath))
2379 % m.abs(subpath))
2379
2380
2380 return ret
2381 return ret
2381
2382
2382 def remove(ui, repo, m, prefix, after, force, subrepos, warnings=None):
2383 def remove(ui, repo, m, prefix, after, force, subrepos, warnings=None):
2383 join = lambda f: os.path.join(prefix, f)
2384 join = lambda f: os.path.join(prefix, f)
2384 ret = 0
2385 ret = 0
2385 s = repo.status(match=m, clean=True)
2386 s = repo.status(match=m, clean=True)
2386 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
2387 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
2387
2388
2388 wctx = repo[None]
2389 wctx = repo[None]
2389
2390
2390 if warnings is None:
2391 if warnings is None:
2391 warnings = []
2392 warnings = []
2392 warn = True
2393 warn = True
2393 else:
2394 else:
2394 warn = False
2395 warn = False
2395
2396
2396 subs = sorted(wctx.substate)
2397 subs = sorted(wctx.substate)
2397 total = len(subs)
2398 total = len(subs)
2398 count = 0
2399 count = 0
2399 for subpath in subs:
2400 for subpath in subs:
2400 count += 1
2401 count += 1
2401 submatch = matchmod.subdirmatcher(subpath, m)
2402 submatch = matchmod.subdirmatcher(subpath, m)
2402 if subrepos or m.exact(subpath) or any(submatch.files()):
2403 if subrepos or m.exact(subpath) or any(submatch.files()):
2403 ui.progress(_('searching'), count, total=total, unit=_('subrepos'))
2404 ui.progress(_('searching'), count, total=total, unit=_('subrepos'))
2404 sub = wctx.sub(subpath)
2405 sub = wctx.sub(subpath)
2405 try:
2406 try:
2406 if sub.removefiles(submatch, prefix, after, force, subrepos,
2407 if sub.removefiles(submatch, prefix, after, force, subrepos,
2407 warnings):
2408 warnings):
2408 ret = 1
2409 ret = 1
2409 except error.LookupError:
2410 except error.LookupError:
2410 warnings.append(_("skipping missing subrepository: %s\n")
2411 warnings.append(_("skipping missing subrepository: %s\n")
2411 % join(subpath))
2412 % join(subpath))
2412 ui.progress(_('searching'), None)
2413 ui.progress(_('searching'), None)
2413
2414
2414 # warn about failure to delete explicit files/dirs
2415 # warn about failure to delete explicit files/dirs
2415 deleteddirs = util.dirs(deleted)
2416 deleteddirs = util.dirs(deleted)
2416 files = m.files()
2417 files = m.files()
2417 total = len(files)
2418 total = len(files)
2418 count = 0
2419 count = 0
2419 for f in files:
2420 for f in files:
2420 def insubrepo():
2421 def insubrepo():
2421 for subpath in wctx.substate:
2422 for subpath in wctx.substate:
2422 if f.startswith(subpath + '/'):
2423 if f.startswith(subpath + '/'):
2423 return True
2424 return True
2424 return False
2425 return False
2425
2426
2426 count += 1
2427 count += 1
2427 ui.progress(_('deleting'), count, total=total, unit=_('files'))
2428 ui.progress(_('deleting'), count, total=total, unit=_('files'))
2428 isdir = f in deleteddirs or wctx.hasdir(f)
2429 isdir = f in deleteddirs or wctx.hasdir(f)
2429 if (f in repo.dirstate or isdir or f == '.'
2430 if (f in repo.dirstate or isdir or f == '.'
2430 or insubrepo() or f in subs):
2431 or insubrepo() or f in subs):
2431 continue
2432 continue
2432
2433
2433 if repo.wvfs.exists(f):
2434 if repo.wvfs.exists(f):
2434 if repo.wvfs.isdir(f):
2435 if repo.wvfs.isdir(f):
2435 warnings.append(_('not removing %s: no tracked files\n')
2436 warnings.append(_('not removing %s: no tracked files\n')
2436 % m.rel(f))
2437 % m.rel(f))
2437 else:
2438 else:
2438 warnings.append(_('not removing %s: file is untracked\n')
2439 warnings.append(_('not removing %s: file is untracked\n')
2439 % m.rel(f))
2440 % m.rel(f))
2440 # missing files will generate a warning elsewhere
2441 # missing files will generate a warning elsewhere
2441 ret = 1
2442 ret = 1
2442 ui.progress(_('deleting'), None)
2443 ui.progress(_('deleting'), None)
2443
2444
2444 if force:
2445 if force:
2445 list = modified + deleted + clean + added
2446 list = modified + deleted + clean + added
2446 elif after:
2447 elif after:
2447 list = deleted
2448 list = deleted
2448 remaining = modified + added + clean
2449 remaining = modified + added + clean
2449 total = len(remaining)
2450 total = len(remaining)
2450 count = 0
2451 count = 0
2451 for f in remaining:
2452 for f in remaining:
2452 count += 1
2453 count += 1
2453 ui.progress(_('skipping'), count, total=total, unit=_('files'))
2454 ui.progress(_('skipping'), count, total=total, unit=_('files'))
2454 warnings.append(_('not removing %s: file still exists\n')
2455 warnings.append(_('not removing %s: file still exists\n')
2455 % m.rel(f))
2456 % m.rel(f))
2456 ret = 1
2457 ret = 1
2457 ui.progress(_('skipping'), None)
2458 ui.progress(_('skipping'), None)
2458 else:
2459 else:
2459 list = deleted + clean
2460 list = deleted + clean
2460 total = len(modified) + len(added)
2461 total = len(modified) + len(added)
2461 count = 0
2462 count = 0
2462 for f in modified:
2463 for f in modified:
2463 count += 1
2464 count += 1
2464 ui.progress(_('skipping'), count, total=total, unit=_('files'))
2465 ui.progress(_('skipping'), count, total=total, unit=_('files'))
2465 warnings.append(_('not removing %s: file is modified (use -f'
2466 warnings.append(_('not removing %s: file is modified (use -f'
2466 ' to force removal)\n') % m.rel(f))
2467 ' to force removal)\n') % m.rel(f))
2467 ret = 1
2468 ret = 1
2468 for f in added:
2469 for f in added:
2469 count += 1
2470 count += 1
2470 ui.progress(_('skipping'), count, total=total, unit=_('files'))
2471 ui.progress(_('skipping'), count, total=total, unit=_('files'))
2471 warnings.append(_("not removing %s: file has been marked for add"
2472 warnings.append(_("not removing %s: file has been marked for add"
2472 " (use 'hg forget' to undo add)\n") % m.rel(f))
2473 " (use 'hg forget' to undo add)\n") % m.rel(f))
2473 ret = 1
2474 ret = 1
2474 ui.progress(_('skipping'), None)
2475 ui.progress(_('skipping'), None)
2475
2476
2476 list = sorted(list)
2477 list = sorted(list)
2477 total = len(list)
2478 total = len(list)
2478 count = 0
2479 count = 0
2479 for f in list:
2480 for f in list:
2480 count += 1
2481 count += 1
2481 if ui.verbose or not m.exact(f):
2482 if ui.verbose or not m.exact(f):
2482 ui.progress(_('deleting'), count, total=total, unit=_('files'))
2483 ui.progress(_('deleting'), count, total=total, unit=_('files'))
2483 ui.status(_('removing %s\n') % m.rel(f))
2484 ui.status(_('removing %s\n') % m.rel(f))
2484 ui.progress(_('deleting'), None)
2485 ui.progress(_('deleting'), None)
2485
2486
2486 with repo.wlock():
2487 with repo.wlock():
2487 if not after:
2488 if not after:
2488 for f in list:
2489 for f in list:
2489 if f in added:
2490 if f in added:
2490 continue # we never unlink added files on remove
2491 continue # we never unlink added files on remove
2491 repo.wvfs.unlinkpath(f, ignoremissing=True)
2492 repo.wvfs.unlinkpath(f, ignoremissing=True)
2492 repo[None].forget(list)
2493 repo[None].forget(list)
2493
2494
2494 if warn:
2495 if warn:
2495 for warning in warnings:
2496 for warning in warnings:
2496 ui.warn(warning)
2497 ui.warn(warning)
2497
2498
2498 return ret
2499 return ret
2499
2500
2500 def cat(ui, repo, ctx, matcher, prefix, **opts):
2501 def cat(ui, repo, ctx, matcher, prefix, **opts):
2501 err = 1
2502 err = 1
2502
2503
2503 def write(path):
2504 def write(path):
2504 fp = makefileobj(repo, opts.get('output'), ctx.node(),
2505 fp = makefileobj(repo, opts.get('output'), ctx.node(),
2505 pathname=os.path.join(prefix, path))
2506 pathname=os.path.join(prefix, path))
2506 data = ctx[path].data()
2507 data = ctx[path].data()
2507 if opts.get('decode'):
2508 if opts.get('decode'):
2508 data = repo.wwritedata(path, data)
2509 data = repo.wwritedata(path, data)
2509 fp.write(data)
2510 fp.write(data)
2510 fp.close()
2511 fp.close()
2511
2512
2512 # Automation often uses hg cat on single files, so special case it
2513 # Automation often uses hg cat on single files, so special case it
2513 # for performance to avoid the cost of parsing the manifest.
2514 # for performance to avoid the cost of parsing the manifest.
2514 if len(matcher.files()) == 1 and not matcher.anypats():
2515 if len(matcher.files()) == 1 and not matcher.anypats():
2515 file = matcher.files()[0]
2516 file = matcher.files()[0]
2516 mfl = repo.manifestlog
2517 mfl = repo.manifestlog
2517 mfnode = ctx.manifestnode()
2518 mfnode = ctx.manifestnode()
2518 try:
2519 try:
2519 if mfnode and mfl[mfnode].find(file)[0]:
2520 if mfnode and mfl[mfnode].find(file)[0]:
2520 write(file)
2521 write(file)
2521 return 0
2522 return 0
2522 except KeyError:
2523 except KeyError:
2523 pass
2524 pass
2524
2525
2525 for abs in ctx.walk(matcher):
2526 for abs in ctx.walk(matcher):
2526 write(abs)
2527 write(abs)
2527 err = 0
2528 err = 0
2528
2529
2529 for subpath in sorted(ctx.substate):
2530 for subpath in sorted(ctx.substate):
2530 sub = ctx.sub(subpath)
2531 sub = ctx.sub(subpath)
2531 try:
2532 try:
2532 submatch = matchmod.subdirmatcher(subpath, matcher)
2533 submatch = matchmod.subdirmatcher(subpath, matcher)
2533
2534
2534 if not sub.cat(submatch, os.path.join(prefix, sub._path),
2535 if not sub.cat(submatch, os.path.join(prefix, sub._path),
2535 **opts):
2536 **opts):
2536 err = 0
2537 err = 0
2537 except error.RepoLookupError:
2538 except error.RepoLookupError:
2538 ui.status(_("skipping missing subrepository: %s\n")
2539 ui.status(_("skipping missing subrepository: %s\n")
2539 % os.path.join(prefix, subpath))
2540 % os.path.join(prefix, subpath))
2540
2541
2541 return err
2542 return err
2542
2543
2543 def commit(ui, repo, commitfunc, pats, opts):
2544 def commit(ui, repo, commitfunc, pats, opts):
2544 '''commit the specified files or all outstanding changes'''
2545 '''commit the specified files or all outstanding changes'''
2545 date = opts.get('date')
2546 date = opts.get('date')
2546 if date:
2547 if date:
2547 opts['date'] = util.parsedate(date)
2548 opts['date'] = util.parsedate(date)
2548 message = logmessage(ui, opts)
2549 message = logmessage(ui, opts)
2549 matcher = scmutil.match(repo[None], pats, opts)
2550 matcher = scmutil.match(repo[None], pats, opts)
2550
2551
2551 # extract addremove carefully -- this function can be called from a command
2552 # extract addremove carefully -- this function can be called from a command
2552 # that doesn't support addremove
2553 # that doesn't support addremove
2553 if opts.get('addremove'):
2554 if opts.get('addremove'):
2554 if scmutil.addremove(repo, matcher, "", opts) != 0:
2555 if scmutil.addremove(repo, matcher, "", opts) != 0:
2555 raise error.Abort(
2556 raise error.Abort(
2556 _("failed to mark all new/missing files as added/removed"))
2557 _("failed to mark all new/missing files as added/removed"))
2557
2558
2558 return commitfunc(ui, repo, message, matcher, opts)
2559 return commitfunc(ui, repo, message, matcher, opts)
2559
2560
2560 def samefile(f, ctx1, ctx2):
2561 def samefile(f, ctx1, ctx2):
2561 if f in ctx1.manifest():
2562 if f in ctx1.manifest():
2562 a = ctx1.filectx(f)
2563 a = ctx1.filectx(f)
2563 if f in ctx2.manifest():
2564 if f in ctx2.manifest():
2564 b = ctx2.filectx(f)
2565 b = ctx2.filectx(f)
2565 return (not a.cmp(b)
2566 return (not a.cmp(b)
2566 and a.flags() == b.flags())
2567 and a.flags() == b.flags())
2567 else:
2568 else:
2568 return False
2569 return False
2569 else:
2570 else:
2570 return f not in ctx2.manifest()
2571 return f not in ctx2.manifest()
2571
2572
2572 def amend(ui, repo, commitfunc, old, extra, pats, opts):
2573 def amend(ui, repo, commitfunc, old, extra, pats, opts):
2573 # avoid cycle context -> subrepo -> cmdutil
2574 # avoid cycle context -> subrepo -> cmdutil
2574 from . import context
2575 from . import context
2575
2576
2576 # amend will reuse the existing user if not specified, but the obsolete
2577 # amend will reuse the existing user if not specified, but the obsolete
2577 # marker creation requires that the current user's name is specified.
2578 # marker creation requires that the current user's name is specified.
2578 if obsolete.isenabled(repo, obsolete.createmarkersopt):
2579 if obsolete.isenabled(repo, obsolete.createmarkersopt):
2579 ui.username() # raise exception if username not set
2580 ui.username() # raise exception if username not set
2580
2581
2581 ui.note(_('amending changeset %s\n') % old)
2582 ui.note(_('amending changeset %s\n') % old)
2582 base = old.p1()
2583 base = old.p1()
2583 createmarkers = obsolete.isenabled(repo, obsolete.createmarkersopt)
2584 createmarkers = obsolete.isenabled(repo, obsolete.createmarkersopt)
2584
2585
2585 wlock = lock = newid = None
2586 wlock = lock = newid = None
2586 try:
2587 try:
2587 wlock = repo.wlock()
2588 wlock = repo.wlock()
2588 lock = repo.lock()
2589 lock = repo.lock()
2589 with repo.transaction('amend') as tr:
2590 with repo.transaction('amend') as tr:
2590 # See if we got a message from -m or -l, if not, open the editor
2591 # See if we got a message from -m or -l, if not, open the editor
2591 # with the message of the changeset to amend
2592 # with the message of the changeset to amend
2592 message = logmessage(ui, opts)
2593 message = logmessage(ui, opts)
2593 # ensure logfile does not conflict with later enforcement of the
2594 # ensure logfile does not conflict with later enforcement of the
2594 # message. potential logfile content has been processed by
2595 # message. potential logfile content has been processed by
2595 # `logmessage` anyway.
2596 # `logmessage` anyway.
2596 opts.pop('logfile')
2597 opts.pop('logfile')
2597 # First, do a regular commit to record all changes in the working
2598 # First, do a regular commit to record all changes in the working
2598 # directory (if there are any)
2599 # directory (if there are any)
2599 ui.callhooks = False
2600 ui.callhooks = False
2600 activebookmark = repo._bookmarks.active
2601 activebookmark = repo._bookmarks.active
2601 try:
2602 try:
2602 repo._bookmarks.active = None
2603 repo._bookmarks.active = None
2603 opts['message'] = 'temporary amend commit for %s' % old
2604 opts['message'] = 'temporary amend commit for %s' % old
2604 node = commit(ui, repo, commitfunc, pats, opts)
2605 node = commit(ui, repo, commitfunc, pats, opts)
2605 finally:
2606 finally:
2606 repo._bookmarks.active = activebookmark
2607 repo._bookmarks.active = activebookmark
2607 repo._bookmarks.recordchange(tr)
2608 repo._bookmarks.recordchange(tr)
2608 ui.callhooks = True
2609 ui.callhooks = True
2609 ctx = repo[node]
2610 ctx = repo[node]
2610
2611
2611 # Participating changesets:
2612 # Participating changesets:
2612 #
2613 #
2613 # node/ctx o - new (intermediate) commit that contains changes
2614 # node/ctx o - new (intermediate) commit that contains changes
2614 # | from working dir to go into amending commit
2615 # | from working dir to go into amending commit
2615 # | (or a workingctx if there were no changes)
2616 # | (or a workingctx if there were no changes)
2616 # |
2617 # |
2617 # old o - changeset to amend
2618 # old o - changeset to amend
2618 # |
2619 # |
2619 # base o - parent of amending changeset
2620 # base o - parent of amending changeset
2620
2621
2621 # Update extra dict from amended commit (e.g. to preserve graft
2622 # Update extra dict from amended commit (e.g. to preserve graft
2622 # source)
2623 # source)
2623 extra.update(old.extra())
2624 extra.update(old.extra())
2624
2625
2625 # Also update it from the intermediate commit or from the wctx
2626 # Also update it from the intermediate commit or from the wctx
2626 extra.update(ctx.extra())
2627 extra.update(ctx.extra())
2627
2628
2628 if len(old.parents()) > 1:
2629 if len(old.parents()) > 1:
2629 # ctx.files() isn't reliable for merges, so fall back to the
2630 # ctx.files() isn't reliable for merges, so fall back to the
2630 # slower repo.status() method
2631 # slower repo.status() method
2631 files = set([fn for st in repo.status(base, old)[:3]
2632 files = set([fn for st in repo.status(base, old)[:3]
2632 for fn in st])
2633 for fn in st])
2633 else:
2634 else:
2634 files = set(old.files())
2635 files = set(old.files())
2635
2636
2636 # Second, we use either the commit we just did, or if there were no
2637 # Second, we use either the commit we just did, or if there were no
2637 # changes the parent of the working directory as the version of the
2638 # changes the parent of the working directory as the version of the
2638 # files in the final amend commit
2639 # files in the final amend commit
2639 if node:
2640 if node:
2640 ui.note(_('copying changeset %s to %s\n') % (ctx, base))
2641 ui.note(_('copying changeset %s to %s\n') % (ctx, base))
2641
2642
2642 user = ctx.user()
2643 user = ctx.user()
2643 date = ctx.date()
2644 date = ctx.date()
2644 # Recompute copies (avoid recording a -> b -> a)
2645 # Recompute copies (avoid recording a -> b -> a)
2645 copied = copies.pathcopies(base, ctx)
2646 copied = copies.pathcopies(base, ctx)
2646 if old.p2:
2647 if old.p2:
2647 copied.update(copies.pathcopies(old.p2(), ctx))
2648 copied.update(copies.pathcopies(old.p2(), ctx))
2648
2649
2649 # Prune files which were reverted by the updates: if old
2650 # Prune files which were reverted by the updates: if old
2650 # introduced file X and our intermediate commit, node,
2651 # introduced file X and our intermediate commit, node,
2651 # renamed that file, then those two files are the same and
2652 # renamed that file, then those two files are the same and
2652 # we can discard X from our list of files. Likewise if X
2653 # we can discard X from our list of files. Likewise if X
2653 # was deleted, it's no longer relevant
2654 # was deleted, it's no longer relevant
2654 files.update(ctx.files())
2655 files.update(ctx.files())
2655 files = [f for f in files if not samefile(f, ctx, base)]
2656 files = [f for f in files if not samefile(f, ctx, base)]
2656
2657
2657 def filectxfn(repo, ctx_, path):
2658 def filectxfn(repo, ctx_, path):
2658 try:
2659 try:
2659 fctx = ctx[path]
2660 fctx = ctx[path]
2660 flags = fctx.flags()
2661 flags = fctx.flags()
2661 mctx = context.memfilectx(repo,
2662 mctx = context.memfilectx(repo,
2662 fctx.path(), fctx.data(),
2663 fctx.path(), fctx.data(),
2663 islink='l' in flags,
2664 islink='l' in flags,
2664 isexec='x' in flags,
2665 isexec='x' in flags,
2665 copied=copied.get(path))
2666 copied=copied.get(path))
2666 return mctx
2667 return mctx
2667 except KeyError:
2668 except KeyError:
2668 return None
2669 return None
2669 else:
2670 else:
2670 ui.note(_('copying changeset %s to %s\n') % (old, base))
2671 ui.note(_('copying changeset %s to %s\n') % (old, base))
2671
2672
2672 # Use version of files as in the old cset
2673 # Use version of files as in the old cset
2673 def filectxfn(repo, ctx_, path):
2674 def filectxfn(repo, ctx_, path):
2674 try:
2675 try:
2675 return old.filectx(path)
2676 return old.filectx(path)
2676 except KeyError:
2677 except KeyError:
2677 return None
2678 return None
2678
2679
2679 user = opts.get('user') or old.user()
2680 user = opts.get('user') or old.user()
2680 date = opts.get('date') or old.date()
2681 date = opts.get('date') or old.date()
2681 editform = mergeeditform(old, 'commit.amend')
2682 editform = mergeeditform(old, 'commit.amend')
2682 editor = getcommiteditor(editform=editform, **opts)
2683 editor = getcommiteditor(editform=editform, **opts)
2683 if not message:
2684 if not message:
2684 editor = getcommiteditor(edit=True, editform=editform)
2685 editor = getcommiteditor(edit=True, editform=editform)
2685 message = old.description()
2686 message = old.description()
2686
2687
2687 pureextra = extra.copy()
2688 pureextra = extra.copy()
2688 extra['amend_source'] = old.hex()
2689 extra['amend_source'] = old.hex()
2689
2690
2690 new = context.memctx(repo,
2691 new = context.memctx(repo,
2691 parents=[base.node(), old.p2().node()],
2692 parents=[base.node(), old.p2().node()],
2692 text=message,
2693 text=message,
2693 files=files,
2694 files=files,
2694 filectxfn=filectxfn,
2695 filectxfn=filectxfn,
2695 user=user,
2696 user=user,
2696 date=date,
2697 date=date,
2697 extra=extra,
2698 extra=extra,
2698 editor=editor)
2699 editor=editor)
2699
2700
2700 newdesc = changelog.stripdesc(new.description())
2701 newdesc = changelog.stripdesc(new.description())
2701 if ((not node)
2702 if ((not node)
2702 and newdesc == old.description()
2703 and newdesc == old.description()
2703 and user == old.user()
2704 and user == old.user()
2704 and date == old.date()
2705 and date == old.date()
2705 and pureextra == old.extra()):
2706 and pureextra == old.extra()):
2706 # nothing changed. continuing here would create a new node
2707 # nothing changed. continuing here would create a new node
2707 # anyway because of the amend_source noise.
2708 # anyway because of the amend_source noise.
2708 #
2709 #
2709 # This not what we expect from amend.
2710 # This not what we expect from amend.
2710 return old.node()
2711 return old.node()
2711
2712
2712 ph = repo.ui.config('phases', 'new-commit', phases.draft)
2713 ph = repo.ui.config('phases', 'new-commit', phases.draft)
2713 try:
2714 try:
2714 if opts.get('secret'):
2715 if opts.get('secret'):
2715 commitphase = 'secret'
2716 commitphase = 'secret'
2716 else:
2717 else:
2717 commitphase = old.phase()
2718 commitphase = old.phase()
2718 repo.ui.setconfig('phases', 'new-commit', commitphase, 'amend')
2719 repo.ui.setconfig('phases', 'new-commit', commitphase, 'amend')
2719 newid = repo.commitctx(new)
2720 newid = repo.commitctx(new)
2720 finally:
2721 finally:
2721 repo.ui.setconfig('phases', 'new-commit', ph, 'amend')
2722 repo.ui.setconfig('phases', 'new-commit', ph, 'amend')
2722 if newid != old.node():
2723 if newid != old.node():
2723 # Reroute the working copy parent to the new changeset
2724 # Reroute the working copy parent to the new changeset
2724 repo.setparents(newid, nullid)
2725 repo.setparents(newid, nullid)
2725
2726
2726 # Move bookmarks from old parent to amend commit
2727 # Move bookmarks from old parent to amend commit
2727 bms = repo.nodebookmarks(old.node())
2728 bms = repo.nodebookmarks(old.node())
2728 if bms:
2729 if bms:
2729 marks = repo._bookmarks
2730 marks = repo._bookmarks
2730 for bm in bms:
2731 for bm in bms:
2731 ui.debug('moving bookmarks %r from %s to %s\n' %
2732 ui.debug('moving bookmarks %r from %s to %s\n' %
2732 (marks, old.hex(), hex(newid)))
2733 (marks, old.hex(), hex(newid)))
2733 marks[bm] = newid
2734 marks[bm] = newid
2734 marks.recordchange(tr)
2735 marks.recordchange(tr)
2735 #commit the whole amend process
2736 #commit the whole amend process
2736 if createmarkers:
2737 if createmarkers:
2737 # mark the new changeset as successor of the rewritten one
2738 # mark the new changeset as successor of the rewritten one
2738 new = repo[newid]
2739 new = repo[newid]
2739 obs = [(old, (new,))]
2740 obs = [(old, (new,))]
2740 if node:
2741 if node:
2741 obs.append((ctx, ()))
2742 obs.append((ctx, ()))
2742
2743
2743 obsolete.createmarkers(repo, obs)
2744 obsolete.createmarkers(repo, obs)
2744 if not createmarkers and newid != old.node():
2745 if not createmarkers and newid != old.node():
2745 # Strip the intermediate commit (if there was one) and the amended
2746 # Strip the intermediate commit (if there was one) and the amended
2746 # commit
2747 # commit
2747 if node:
2748 if node:
2748 ui.note(_('stripping intermediate changeset %s\n') % ctx)
2749 ui.note(_('stripping intermediate changeset %s\n') % ctx)
2749 ui.note(_('stripping amended changeset %s\n') % old)
2750 ui.note(_('stripping amended changeset %s\n') % old)
2750 repair.strip(ui, repo, old.node(), topic='amend-backup')
2751 repair.strip(ui, repo, old.node(), topic='amend-backup')
2751 finally:
2752 finally:
2752 lockmod.release(lock, wlock)
2753 lockmod.release(lock, wlock)
2753 return newid
2754 return newid
2754
2755
2755 def commiteditor(repo, ctx, subs, editform=''):
2756 def commiteditor(repo, ctx, subs, editform=''):
2756 if ctx.description():
2757 if ctx.description():
2757 return ctx.description()
2758 return ctx.description()
2758 return commitforceeditor(repo, ctx, subs, editform=editform,
2759 return commitforceeditor(repo, ctx, subs, editform=editform,
2759 unchangedmessagedetection=True)
2760 unchangedmessagedetection=True)
2760
2761
2761 def commitforceeditor(repo, ctx, subs, finishdesc=None, extramsg=None,
2762 def commitforceeditor(repo, ctx, subs, finishdesc=None, extramsg=None,
2762 editform='', unchangedmessagedetection=False):
2763 editform='', unchangedmessagedetection=False):
2763 if not extramsg:
2764 if not extramsg:
2764 extramsg = _("Leave message empty to abort commit.")
2765 extramsg = _("Leave message empty to abort commit.")
2765
2766
2766 forms = [e for e in editform.split('.') if e]
2767 forms = [e for e in editform.split('.') if e]
2767 forms.insert(0, 'changeset')
2768 forms.insert(0, 'changeset')
2768 templatetext = None
2769 templatetext = None
2769 while forms:
2770 while forms:
2770 tmpl = repo.ui.config('committemplate', '.'.join(forms))
2771 tmpl = repo.ui.config('committemplate', '.'.join(forms))
2771 if tmpl:
2772 if tmpl:
2772 tmpl = templater.unquotestring(tmpl)
2773 tmpl = templater.unquotestring(tmpl)
2773 templatetext = committext = buildcommittemplate(
2774 templatetext = committext = buildcommittemplate(
2774 repo, ctx, subs, extramsg, tmpl)
2775 repo, ctx, subs, extramsg, tmpl)
2775 break
2776 break
2776 forms.pop()
2777 forms.pop()
2777 else:
2778 else:
2778 committext = buildcommittext(repo, ctx, subs, extramsg)
2779 committext = buildcommittext(repo, ctx, subs, extramsg)
2779
2780
2780 # run editor in the repository root
2781 # run editor in the repository root
2781 olddir = pycompat.getcwd()
2782 olddir = pycompat.getcwd()
2782 os.chdir(repo.root)
2783 os.chdir(repo.root)
2783
2784
2784 # make in-memory changes visible to external process
2785 # make in-memory changes visible to external process
2785 tr = repo.currenttransaction()
2786 tr = repo.currenttransaction()
2786 repo.dirstate.write(tr)
2787 repo.dirstate.write(tr)
2787 pending = tr and tr.writepending() and repo.root
2788 pending = tr and tr.writepending() and repo.root
2788
2789
2789 editortext = repo.ui.edit(committext, ctx.user(), ctx.extra(),
2790 editortext = repo.ui.edit(committext, ctx.user(), ctx.extra(),
2790 editform=editform, pending=pending,
2791 editform=editform, pending=pending,
2791 repopath=repo.path)
2792 repopath=repo.path)
2792 text = editortext
2793 text = editortext
2793
2794
2794 # strip away anything below this special string (used for editors that want
2795 # strip away anything below this special string (used for editors that want
2795 # to display the diff)
2796 # to display the diff)
2796 stripbelow = re.search(_linebelow, text, flags=re.MULTILINE)
2797 stripbelow = re.search(_linebelow, text, flags=re.MULTILINE)
2797 if stripbelow:
2798 if stripbelow:
2798 text = text[:stripbelow.start()]
2799 text = text[:stripbelow.start()]
2799
2800
2800 text = re.sub("(?m)^HG:.*(\n|$)", "", text)
2801 text = re.sub("(?m)^HG:.*(\n|$)", "", text)
2801 os.chdir(olddir)
2802 os.chdir(olddir)
2802
2803
2803 if finishdesc:
2804 if finishdesc:
2804 text = finishdesc(text)
2805 text = finishdesc(text)
2805 if not text.strip():
2806 if not text.strip():
2806 raise error.Abort(_("empty commit message"))
2807 raise error.Abort(_("empty commit message"))
2807 if unchangedmessagedetection and editortext == templatetext:
2808 if unchangedmessagedetection and editortext == templatetext:
2808 raise error.Abort(_("commit message unchanged"))
2809 raise error.Abort(_("commit message unchanged"))
2809
2810
2810 return text
2811 return text
2811
2812
2812 def buildcommittemplate(repo, ctx, subs, extramsg, tmpl):
2813 def buildcommittemplate(repo, ctx, subs, extramsg, tmpl):
2813 ui = repo.ui
2814 ui = repo.ui
2814 tmpl, mapfile = gettemplate(ui, tmpl, None)
2815 tmpl, mapfile = gettemplate(ui, tmpl, None)
2815
2816
2816 t = changeset_templater(ui, repo, None, {}, tmpl, mapfile, False)
2817 t = changeset_templater(ui, repo, None, {}, tmpl, mapfile, False)
2817
2818
2818 for k, v in repo.ui.configitems('committemplate'):
2819 for k, v in repo.ui.configitems('committemplate'):
2819 if k != 'changeset':
2820 if k != 'changeset':
2820 t.t.cache[k] = v
2821 t.t.cache[k] = v
2821
2822
2822 if not extramsg:
2823 if not extramsg:
2823 extramsg = '' # ensure that extramsg is string
2824 extramsg = '' # ensure that extramsg is string
2824
2825
2825 ui.pushbuffer()
2826 ui.pushbuffer()
2826 t.show(ctx, extramsg=extramsg)
2827 t.show(ctx, extramsg=extramsg)
2827 return ui.popbuffer()
2828 return ui.popbuffer()
2828
2829
2829 def hgprefix(msg):
2830 def hgprefix(msg):
2830 return "\n".join(["HG: %s" % a for a in msg.split("\n") if a])
2831 return "\n".join(["HG: %s" % a for a in msg.split("\n") if a])
2831
2832
2832 def buildcommittext(repo, ctx, subs, extramsg):
2833 def buildcommittext(repo, ctx, subs, extramsg):
2833 edittext = []
2834 edittext = []
2834 modified, added, removed = ctx.modified(), ctx.added(), ctx.removed()
2835 modified, added, removed = ctx.modified(), ctx.added(), ctx.removed()
2835 if ctx.description():
2836 if ctx.description():
2836 edittext.append(ctx.description())
2837 edittext.append(ctx.description())
2837 edittext.append("")
2838 edittext.append("")
2838 edittext.append("") # Empty line between message and comments.
2839 edittext.append("") # Empty line between message and comments.
2839 edittext.append(hgprefix(_("Enter commit message."
2840 edittext.append(hgprefix(_("Enter commit message."
2840 " Lines beginning with 'HG:' are removed.")))
2841 " Lines beginning with 'HG:' are removed.")))
2841 edittext.append(hgprefix(extramsg))
2842 edittext.append(hgprefix(extramsg))
2842 edittext.append("HG: --")
2843 edittext.append("HG: --")
2843 edittext.append(hgprefix(_("user: %s") % ctx.user()))
2844 edittext.append(hgprefix(_("user: %s") % ctx.user()))
2844 if ctx.p2():
2845 if ctx.p2():
2845 edittext.append(hgprefix(_("branch merge")))
2846 edittext.append(hgprefix(_("branch merge")))
2846 if ctx.branch():
2847 if ctx.branch():
2847 edittext.append(hgprefix(_("branch '%s'") % ctx.branch()))
2848 edittext.append(hgprefix(_("branch '%s'") % ctx.branch()))
2848 if bookmarks.isactivewdirparent(repo):
2849 if bookmarks.isactivewdirparent(repo):
2849 edittext.append(hgprefix(_("bookmark '%s'") % repo._activebookmark))
2850 edittext.append(hgprefix(_("bookmark '%s'") % repo._activebookmark))
2850 edittext.extend([hgprefix(_("subrepo %s") % s) for s in subs])
2851 edittext.extend([hgprefix(_("subrepo %s") % s) for s in subs])
2851 edittext.extend([hgprefix(_("added %s") % f) for f in added])
2852 edittext.extend([hgprefix(_("added %s") % f) for f in added])
2852 edittext.extend([hgprefix(_("changed %s") % f) for f in modified])
2853 edittext.extend([hgprefix(_("changed %s") % f) for f in modified])
2853 edittext.extend([hgprefix(_("removed %s") % f) for f in removed])
2854 edittext.extend([hgprefix(_("removed %s") % f) for f in removed])
2854 if not added and not modified and not removed:
2855 if not added and not modified and not removed:
2855 edittext.append(hgprefix(_("no files changed")))
2856 edittext.append(hgprefix(_("no files changed")))
2856 edittext.append("")
2857 edittext.append("")
2857
2858
2858 return "\n".join(edittext)
2859 return "\n".join(edittext)
2859
2860
2860 def commitstatus(repo, node, branch, bheads=None, opts=None):
2861 def commitstatus(repo, node, branch, bheads=None, opts=None):
2861 if opts is None:
2862 if opts is None:
2862 opts = {}
2863 opts = {}
2863 ctx = repo[node]
2864 ctx = repo[node]
2864 parents = ctx.parents()
2865 parents = ctx.parents()
2865
2866
2866 if (not opts.get('amend') and bheads and node not in bheads and not
2867 if (not opts.get('amend') and bheads and node not in bheads and not
2867 [x for x in parents if x.node() in bheads and x.branch() == branch]):
2868 [x for x in parents if x.node() in bheads and x.branch() == branch]):
2868 repo.ui.status(_('created new head\n'))
2869 repo.ui.status(_('created new head\n'))
2869 # The message is not printed for initial roots. For the other
2870 # The message is not printed for initial roots. For the other
2870 # changesets, it is printed in the following situations:
2871 # changesets, it is printed in the following situations:
2871 #
2872 #
2872 # Par column: for the 2 parents with ...
2873 # Par column: for the 2 parents with ...
2873 # N: null or no parent
2874 # N: null or no parent
2874 # B: parent is on another named branch
2875 # B: parent is on another named branch
2875 # C: parent is a regular non head changeset
2876 # C: parent is a regular non head changeset
2876 # H: parent was a branch head of the current branch
2877 # H: parent was a branch head of the current branch
2877 # Msg column: whether we print "created new head" message
2878 # Msg column: whether we print "created new head" message
2878 # In the following, it is assumed that there already exists some
2879 # In the following, it is assumed that there already exists some
2879 # initial branch heads of the current branch, otherwise nothing is
2880 # initial branch heads of the current branch, otherwise nothing is
2880 # printed anyway.
2881 # printed anyway.
2881 #
2882 #
2882 # Par Msg Comment
2883 # Par Msg Comment
2883 # N N y additional topo root
2884 # N N y additional topo root
2884 #
2885 #
2885 # B N y additional branch root
2886 # B N y additional branch root
2886 # C N y additional topo head
2887 # C N y additional topo head
2887 # H N n usual case
2888 # H N n usual case
2888 #
2889 #
2889 # B B y weird additional branch root
2890 # B B y weird additional branch root
2890 # C B y branch merge
2891 # C B y branch merge
2891 # H B n merge with named branch
2892 # H B n merge with named branch
2892 #
2893 #
2893 # C C y additional head from merge
2894 # C C y additional head from merge
2894 # C H n merge with a head
2895 # C H n merge with a head
2895 #
2896 #
2896 # H H n head merge: head count decreases
2897 # H H n head merge: head count decreases
2897
2898
2898 if not opts.get('close_branch'):
2899 if not opts.get('close_branch'):
2899 for r in parents:
2900 for r in parents:
2900 if r.closesbranch() and r.branch() == branch:
2901 if r.closesbranch() and r.branch() == branch:
2901 repo.ui.status(_('reopening closed branch head %d\n') % r)
2902 repo.ui.status(_('reopening closed branch head %d\n') % r)
2902
2903
2903 if repo.ui.debugflag:
2904 if repo.ui.debugflag:
2904 repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx.hex()))
2905 repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx.hex()))
2905 elif repo.ui.verbose:
2906 elif repo.ui.verbose:
2906 repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx))
2907 repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx))
2907
2908
2908 def postcommitstatus(repo, pats, opts):
2909 def postcommitstatus(repo, pats, opts):
2909 return repo.status(match=scmutil.match(repo[None], pats, opts))
2910 return repo.status(match=scmutil.match(repo[None], pats, opts))
2910
2911
2911 def revert(ui, repo, ctx, parents, *pats, **opts):
2912 def revert(ui, repo, ctx, parents, *pats, **opts):
2912 parent, p2 = parents
2913 parent, p2 = parents
2913 node = ctx.node()
2914 node = ctx.node()
2914
2915
2915 mf = ctx.manifest()
2916 mf = ctx.manifest()
2916 if node == p2:
2917 if node == p2:
2917 parent = p2
2918 parent = p2
2918
2919
2919 # need all matching names in dirstate and manifest of target rev,
2920 # need all matching names in dirstate and manifest of target rev,
2920 # so have to walk both. do not print errors if files exist in one
2921 # so have to walk both. do not print errors if files exist in one
2921 # but not other. in both cases, filesets should be evaluated against
2922 # but not other. in both cases, filesets should be evaluated against
2922 # workingctx to get consistent result (issue4497). this means 'set:**'
2923 # workingctx to get consistent result (issue4497). this means 'set:**'
2923 # cannot be used to select missing files from target rev.
2924 # cannot be used to select missing files from target rev.
2924
2925
2925 # `names` is a mapping for all elements in working copy and target revision
2926 # `names` is a mapping for all elements in working copy and target revision
2926 # The mapping is in the form:
2927 # The mapping is in the form:
2927 # <asb path in repo> -> (<path from CWD>, <exactly specified by matcher?>)
2928 # <asb path in repo> -> (<path from CWD>, <exactly specified by matcher?>)
2928 names = {}
2929 names = {}
2929
2930
2930 with repo.wlock():
2931 with repo.wlock():
2931 ## filling of the `names` mapping
2932 ## filling of the `names` mapping
2932 # walk dirstate to fill `names`
2933 # walk dirstate to fill `names`
2933
2934
2934 interactive = opts.get('interactive', False)
2935 interactive = opts.get('interactive', False)
2935 wctx = repo[None]
2936 wctx = repo[None]
2936 m = scmutil.match(wctx, pats, opts)
2937 m = scmutil.match(wctx, pats, opts)
2937
2938
2938 # we'll need this later
2939 # we'll need this later
2939 targetsubs = sorted(s for s in wctx.substate if m(s))
2940 targetsubs = sorted(s for s in wctx.substate if m(s))
2940
2941
2941 if not m.always():
2942 if not m.always():
2942 for abs in repo.walk(matchmod.badmatch(m, lambda x, y: False)):
2943 for abs in repo.walk(matchmod.badmatch(m, lambda x, y: False)):
2943 names[abs] = m.rel(abs), m.exact(abs)
2944 names[abs] = m.rel(abs), m.exact(abs)
2944
2945
2945 # walk target manifest to fill `names`
2946 # walk target manifest to fill `names`
2946
2947
2947 def badfn(path, msg):
2948 def badfn(path, msg):
2948 if path in names:
2949 if path in names:
2949 return
2950 return
2950 if path in ctx.substate:
2951 if path in ctx.substate:
2951 return
2952 return
2952 path_ = path + '/'
2953 path_ = path + '/'
2953 for f in names:
2954 for f in names:
2954 if f.startswith(path_):
2955 if f.startswith(path_):
2955 return
2956 return
2956 ui.warn("%s: %s\n" % (m.rel(path), msg))
2957 ui.warn("%s: %s\n" % (m.rel(path), msg))
2957
2958
2958 for abs in ctx.walk(matchmod.badmatch(m, badfn)):
2959 for abs in ctx.walk(matchmod.badmatch(m, badfn)):
2959 if abs not in names:
2960 if abs not in names:
2960 names[abs] = m.rel(abs), m.exact(abs)
2961 names[abs] = m.rel(abs), m.exact(abs)
2961
2962
2962 # Find status of all file in `names`.
2963 # Find status of all file in `names`.
2963 m = scmutil.matchfiles(repo, names)
2964 m = scmutil.matchfiles(repo, names)
2964
2965
2965 changes = repo.status(node1=node, match=m,
2966 changes = repo.status(node1=node, match=m,
2966 unknown=True, ignored=True, clean=True)
2967 unknown=True, ignored=True, clean=True)
2967 else:
2968 else:
2968 changes = repo.status(node1=node, match=m)
2969 changes = repo.status(node1=node, match=m)
2969 for kind in changes:
2970 for kind in changes:
2970 for abs in kind:
2971 for abs in kind:
2971 names[abs] = m.rel(abs), m.exact(abs)
2972 names[abs] = m.rel(abs), m.exact(abs)
2972
2973
2973 m = scmutil.matchfiles(repo, names)
2974 m = scmutil.matchfiles(repo, names)
2974
2975
2975 modified = set(changes.modified)
2976 modified = set(changes.modified)
2976 added = set(changes.added)
2977 added = set(changes.added)
2977 removed = set(changes.removed)
2978 removed = set(changes.removed)
2978 _deleted = set(changes.deleted)
2979 _deleted = set(changes.deleted)
2979 unknown = set(changes.unknown)
2980 unknown = set(changes.unknown)
2980 unknown.update(changes.ignored)
2981 unknown.update(changes.ignored)
2981 clean = set(changes.clean)
2982 clean = set(changes.clean)
2982 modadded = set()
2983 modadded = set()
2983
2984
2984 # We need to account for the state of the file in the dirstate,
2985 # We need to account for the state of the file in the dirstate,
2985 # even when we revert against something else than parent. This will
2986 # even when we revert against something else than parent. This will
2986 # slightly alter the behavior of revert (doing back up or not, delete
2987 # slightly alter the behavior of revert (doing back up or not, delete
2987 # or just forget etc).
2988 # or just forget etc).
2988 if parent == node:
2989 if parent == node:
2989 dsmodified = modified
2990 dsmodified = modified
2990 dsadded = added
2991 dsadded = added
2991 dsremoved = removed
2992 dsremoved = removed
2992 # store all local modifications, useful later for rename detection
2993 # store all local modifications, useful later for rename detection
2993 localchanges = dsmodified | dsadded
2994 localchanges = dsmodified | dsadded
2994 modified, added, removed = set(), set(), set()
2995 modified, added, removed = set(), set(), set()
2995 else:
2996 else:
2996 changes = repo.status(node1=parent, match=m)
2997 changes = repo.status(node1=parent, match=m)
2997 dsmodified = set(changes.modified)
2998 dsmodified = set(changes.modified)
2998 dsadded = set(changes.added)
2999 dsadded = set(changes.added)
2999 dsremoved = set(changes.removed)
3000 dsremoved = set(changes.removed)
3000 # store all local modifications, useful later for rename detection
3001 # store all local modifications, useful later for rename detection
3001 localchanges = dsmodified | dsadded
3002 localchanges = dsmodified | dsadded
3002
3003
3003 # only take into account for removes between wc and target
3004 # only take into account for removes between wc and target
3004 clean |= dsremoved - removed
3005 clean |= dsremoved - removed
3005 dsremoved &= removed
3006 dsremoved &= removed
3006 # distinct between dirstate remove and other
3007 # distinct between dirstate remove and other
3007 removed -= dsremoved
3008 removed -= dsremoved
3008
3009
3009 modadded = added & dsmodified
3010 modadded = added & dsmodified
3010 added -= modadded
3011 added -= modadded
3011
3012
3012 # tell newly modified apart.
3013 # tell newly modified apart.
3013 dsmodified &= modified
3014 dsmodified &= modified
3014 dsmodified |= modified & dsadded # dirstate added may need backup
3015 dsmodified |= modified & dsadded # dirstate added may need backup
3015 modified -= dsmodified
3016 modified -= dsmodified
3016
3017
3017 # We need to wait for some post-processing to update this set
3018 # We need to wait for some post-processing to update this set
3018 # before making the distinction. The dirstate will be used for
3019 # before making the distinction. The dirstate will be used for
3019 # that purpose.
3020 # that purpose.
3020 dsadded = added
3021 dsadded = added
3021
3022
3022 # in case of merge, files that are actually added can be reported as
3023 # in case of merge, files that are actually added can be reported as
3023 # modified, we need to post process the result
3024 # modified, we need to post process the result
3024 if p2 != nullid:
3025 if p2 != nullid:
3025 mergeadd = set(dsmodified)
3026 mergeadd = set(dsmodified)
3026 for path in dsmodified:
3027 for path in dsmodified:
3027 if path in mf:
3028 if path in mf:
3028 mergeadd.remove(path)
3029 mergeadd.remove(path)
3029 dsadded |= mergeadd
3030 dsadded |= mergeadd
3030 dsmodified -= mergeadd
3031 dsmodified -= mergeadd
3031
3032
3032 # if f is a rename, update `names` to also revert the source
3033 # if f is a rename, update `names` to also revert the source
3033 cwd = repo.getcwd()
3034 cwd = repo.getcwd()
3034 for f in localchanges:
3035 for f in localchanges:
3035 src = repo.dirstate.copied(f)
3036 src = repo.dirstate.copied(f)
3036 # XXX should we check for rename down to target node?
3037 # XXX should we check for rename down to target node?
3037 if src and src not in names and repo.dirstate[src] == 'r':
3038 if src and src not in names and repo.dirstate[src] == 'r':
3038 dsremoved.add(src)
3039 dsremoved.add(src)
3039 names[src] = (repo.pathto(src, cwd), True)
3040 names[src] = (repo.pathto(src, cwd), True)
3040
3041
3041 # determine the exact nature of the deleted changesets
3042 # determine the exact nature of the deleted changesets
3042 deladded = set(_deleted)
3043 deladded = set(_deleted)
3043 for path in _deleted:
3044 for path in _deleted:
3044 if path in mf:
3045 if path in mf:
3045 deladded.remove(path)
3046 deladded.remove(path)
3046 deleted = _deleted - deladded
3047 deleted = _deleted - deladded
3047
3048
3048 # distinguish between file to forget and the other
3049 # distinguish between file to forget and the other
3049 added = set()
3050 added = set()
3050 for abs in dsadded:
3051 for abs in dsadded:
3051 if repo.dirstate[abs] != 'a':
3052 if repo.dirstate[abs] != 'a':
3052 added.add(abs)
3053 added.add(abs)
3053 dsadded -= added
3054 dsadded -= added
3054
3055
3055 for abs in deladded:
3056 for abs in deladded:
3056 if repo.dirstate[abs] == 'a':
3057 if repo.dirstate[abs] == 'a':
3057 dsadded.add(abs)
3058 dsadded.add(abs)
3058 deladded -= dsadded
3059 deladded -= dsadded
3059
3060
3060 # For files marked as removed, we check if an unknown file is present at
3061 # For files marked as removed, we check if an unknown file is present at
3061 # the same path. If a such file exists it may need to be backed up.
3062 # the same path. If a such file exists it may need to be backed up.
3062 # Making the distinction at this stage helps have simpler backup
3063 # Making the distinction at this stage helps have simpler backup
3063 # logic.
3064 # logic.
3064 removunk = set()
3065 removunk = set()
3065 for abs in removed:
3066 for abs in removed:
3066 target = repo.wjoin(abs)
3067 target = repo.wjoin(abs)
3067 if os.path.lexists(target):
3068 if os.path.lexists(target):
3068 removunk.add(abs)
3069 removunk.add(abs)
3069 removed -= removunk
3070 removed -= removunk
3070
3071
3071 dsremovunk = set()
3072 dsremovunk = set()
3072 for abs in dsremoved:
3073 for abs in dsremoved:
3073 target = repo.wjoin(abs)
3074 target = repo.wjoin(abs)
3074 if os.path.lexists(target):
3075 if os.path.lexists(target):
3075 dsremovunk.add(abs)
3076 dsremovunk.add(abs)
3076 dsremoved -= dsremovunk
3077 dsremoved -= dsremovunk
3077
3078
3078 # action to be actually performed by revert
3079 # action to be actually performed by revert
3079 # (<list of file>, message>) tuple
3080 # (<list of file>, message>) tuple
3080 actions = {'revert': ([], _('reverting %s\n')),
3081 actions = {'revert': ([], _('reverting %s\n')),
3081 'add': ([], _('adding %s\n')),
3082 'add': ([], _('adding %s\n')),
3082 'remove': ([], _('removing %s\n')),
3083 'remove': ([], _('removing %s\n')),
3083 'drop': ([], _('removing %s\n')),
3084 'drop': ([], _('removing %s\n')),
3084 'forget': ([], _('forgetting %s\n')),
3085 'forget': ([], _('forgetting %s\n')),
3085 'undelete': ([], _('undeleting %s\n')),
3086 'undelete': ([], _('undeleting %s\n')),
3086 'noop': (None, _('no changes needed to %s\n')),
3087 'noop': (None, _('no changes needed to %s\n')),
3087 'unknown': (None, _('file not managed: %s\n')),
3088 'unknown': (None, _('file not managed: %s\n')),
3088 }
3089 }
3089
3090
3090 # "constant" that convey the backup strategy.
3091 # "constant" that convey the backup strategy.
3091 # All set to `discard` if `no-backup` is set do avoid checking
3092 # All set to `discard` if `no-backup` is set do avoid checking
3092 # no_backup lower in the code.
3093 # no_backup lower in the code.
3093 # These values are ordered for comparison purposes
3094 # These values are ordered for comparison purposes
3094 backupinteractive = 3 # do backup if interactively modified
3095 backupinteractive = 3 # do backup if interactively modified
3095 backup = 2 # unconditionally do backup
3096 backup = 2 # unconditionally do backup
3096 check = 1 # check if the existing file differs from target
3097 check = 1 # check if the existing file differs from target
3097 discard = 0 # never do backup
3098 discard = 0 # never do backup
3098 if opts.get('no_backup'):
3099 if opts.get('no_backup'):
3099 backupinteractive = backup = check = discard
3100 backupinteractive = backup = check = discard
3100 if interactive:
3101 if interactive:
3101 dsmodifiedbackup = backupinteractive
3102 dsmodifiedbackup = backupinteractive
3102 else:
3103 else:
3103 dsmodifiedbackup = backup
3104 dsmodifiedbackup = backup
3104 tobackup = set()
3105 tobackup = set()
3105
3106
3106 backupanddel = actions['remove']
3107 backupanddel = actions['remove']
3107 if not opts.get('no_backup'):
3108 if not opts.get('no_backup'):
3108 backupanddel = actions['drop']
3109 backupanddel = actions['drop']
3109
3110
3110 disptable = (
3111 disptable = (
3111 # dispatch table:
3112 # dispatch table:
3112 # file state
3113 # file state
3113 # action
3114 # action
3114 # make backup
3115 # make backup
3115
3116
3116 ## Sets that results that will change file on disk
3117 ## Sets that results that will change file on disk
3117 # Modified compared to target, no local change
3118 # Modified compared to target, no local change
3118 (modified, actions['revert'], discard),
3119 (modified, actions['revert'], discard),
3119 # Modified compared to target, but local file is deleted
3120 # Modified compared to target, but local file is deleted
3120 (deleted, actions['revert'], discard),
3121 (deleted, actions['revert'], discard),
3121 # Modified compared to target, local change
3122 # Modified compared to target, local change
3122 (dsmodified, actions['revert'], dsmodifiedbackup),
3123 (dsmodified, actions['revert'], dsmodifiedbackup),
3123 # Added since target
3124 # Added since target
3124 (added, actions['remove'], discard),
3125 (added, actions['remove'], discard),
3125 # Added in working directory
3126 # Added in working directory
3126 (dsadded, actions['forget'], discard),
3127 (dsadded, actions['forget'], discard),
3127 # Added since target, have local modification
3128 # Added since target, have local modification
3128 (modadded, backupanddel, backup),
3129 (modadded, backupanddel, backup),
3129 # Added since target but file is missing in working directory
3130 # Added since target but file is missing in working directory
3130 (deladded, actions['drop'], discard),
3131 (deladded, actions['drop'], discard),
3131 # Removed since target, before working copy parent
3132 # Removed since target, before working copy parent
3132 (removed, actions['add'], discard),
3133 (removed, actions['add'], discard),
3133 # Same as `removed` but an unknown file exists at the same path
3134 # Same as `removed` but an unknown file exists at the same path
3134 (removunk, actions['add'], check),
3135 (removunk, actions['add'], check),
3135 # Removed since targe, marked as such in working copy parent
3136 # Removed since targe, marked as such in working copy parent
3136 (dsremoved, actions['undelete'], discard),
3137 (dsremoved, actions['undelete'], discard),
3137 # Same as `dsremoved` but an unknown file exists at the same path
3138 # Same as `dsremoved` but an unknown file exists at the same path
3138 (dsremovunk, actions['undelete'], check),
3139 (dsremovunk, actions['undelete'], check),
3139 ## the following sets does not result in any file changes
3140 ## the following sets does not result in any file changes
3140 # File with no modification
3141 # File with no modification
3141 (clean, actions['noop'], discard),
3142 (clean, actions['noop'], discard),
3142 # Existing file, not tracked anywhere
3143 # Existing file, not tracked anywhere
3143 (unknown, actions['unknown'], discard),
3144 (unknown, actions['unknown'], discard),
3144 )
3145 )
3145
3146
3146 for abs, (rel, exact) in sorted(names.items()):
3147 for abs, (rel, exact) in sorted(names.items()):
3147 # target file to be touch on disk (relative to cwd)
3148 # target file to be touch on disk (relative to cwd)
3148 target = repo.wjoin(abs)
3149 target = repo.wjoin(abs)
3149 # search the entry in the dispatch table.
3150 # search the entry in the dispatch table.
3150 # if the file is in any of these sets, it was touched in the working
3151 # if the file is in any of these sets, it was touched in the working
3151 # directory parent and we are sure it needs to be reverted.
3152 # directory parent and we are sure it needs to be reverted.
3152 for table, (xlist, msg), dobackup in disptable:
3153 for table, (xlist, msg), dobackup in disptable:
3153 if abs not in table:
3154 if abs not in table:
3154 continue
3155 continue
3155 if xlist is not None:
3156 if xlist is not None:
3156 xlist.append(abs)
3157 xlist.append(abs)
3157 if dobackup:
3158 if dobackup:
3158 # If in interactive mode, don't automatically create
3159 # If in interactive mode, don't automatically create
3159 # .orig files (issue4793)
3160 # .orig files (issue4793)
3160 if dobackup == backupinteractive:
3161 if dobackup == backupinteractive:
3161 tobackup.add(abs)
3162 tobackup.add(abs)
3162 elif (backup <= dobackup or wctx[abs].cmp(ctx[abs])):
3163 elif (backup <= dobackup or wctx[abs].cmp(ctx[abs])):
3163 bakname = scmutil.origpath(ui, repo, rel)
3164 bakname = scmutil.origpath(ui, repo, rel)
3164 ui.note(_('saving current version of %s as %s\n') %
3165 ui.note(_('saving current version of %s as %s\n') %
3165 (rel, bakname))
3166 (rel, bakname))
3166 if not opts.get('dry_run'):
3167 if not opts.get('dry_run'):
3167 if interactive:
3168 if interactive:
3168 util.copyfile(target, bakname)
3169 util.copyfile(target, bakname)
3169 else:
3170 else:
3170 util.rename(target, bakname)
3171 util.rename(target, bakname)
3171 if ui.verbose or not exact:
3172 if ui.verbose or not exact:
3172 if not isinstance(msg, basestring):
3173 if not isinstance(msg, basestring):
3173 msg = msg(abs)
3174 msg = msg(abs)
3174 ui.status(msg % rel)
3175 ui.status(msg % rel)
3175 elif exact:
3176 elif exact:
3176 ui.warn(msg % rel)
3177 ui.warn(msg % rel)
3177 break
3178 break
3178
3179
3179 if not opts.get('dry_run'):
3180 if not opts.get('dry_run'):
3180 needdata = ('revert', 'add', 'undelete')
3181 needdata = ('revert', 'add', 'undelete')
3181 _revertprefetch(repo, ctx, *[actions[name][0] for name in needdata])
3182 _revertprefetch(repo, ctx, *[actions[name][0] for name in needdata])
3182 _performrevert(repo, parents, ctx, actions, interactive, tobackup)
3183 _performrevert(repo, parents, ctx, actions, interactive, tobackup)
3183
3184
3184 if targetsubs:
3185 if targetsubs:
3185 # Revert the subrepos on the revert list
3186 # Revert the subrepos on the revert list
3186 for sub in targetsubs:
3187 for sub in targetsubs:
3187 try:
3188 try:
3188 wctx.sub(sub).revert(ctx.substate[sub], *pats, **opts)
3189 wctx.sub(sub).revert(ctx.substate[sub], *pats, **opts)
3189 except KeyError:
3190 except KeyError:
3190 raise error.Abort("subrepository '%s' does not exist in %s!"
3191 raise error.Abort("subrepository '%s' does not exist in %s!"
3191 % (sub, short(ctx.node())))
3192 % (sub, short(ctx.node())))
3192
3193
3193 def _revertprefetch(repo, ctx, *files):
3194 def _revertprefetch(repo, ctx, *files):
3194 """Let extension changing the storage layer prefetch content"""
3195 """Let extension changing the storage layer prefetch content"""
3195 pass
3196 pass
3196
3197
3197 def _performrevert(repo, parents, ctx, actions, interactive=False,
3198 def _performrevert(repo, parents, ctx, actions, interactive=False,
3198 tobackup=None):
3199 tobackup=None):
3199 """function that actually perform all the actions computed for revert
3200 """function that actually perform all the actions computed for revert
3200
3201
3201 This is an independent function to let extension to plug in and react to
3202 This is an independent function to let extension to plug in and react to
3202 the imminent revert.
3203 the imminent revert.
3203
3204
3204 Make sure you have the working directory locked when calling this function.
3205 Make sure you have the working directory locked when calling this function.
3205 """
3206 """
3206 parent, p2 = parents
3207 parent, p2 = parents
3207 node = ctx.node()
3208 node = ctx.node()
3208 excluded_files = []
3209 excluded_files = []
3209 matcher_opts = {"exclude": excluded_files}
3210 matcher_opts = {"exclude": excluded_files}
3210
3211
3211 def checkout(f):
3212 def checkout(f):
3212 fc = ctx[f]
3213 fc = ctx[f]
3213 repo.wwrite(f, fc.data(), fc.flags())
3214 repo.wwrite(f, fc.data(), fc.flags())
3214
3215
3215 def doremove(f):
3216 def doremove(f):
3216 try:
3217 try:
3217 repo.wvfs.unlinkpath(f)
3218 repo.wvfs.unlinkpath(f)
3218 except OSError:
3219 except OSError:
3219 pass
3220 pass
3220 repo.dirstate.remove(f)
3221 repo.dirstate.remove(f)
3221
3222
3222 audit_path = pathutil.pathauditor(repo.root)
3223 audit_path = pathutil.pathauditor(repo.root)
3223 for f in actions['forget'][0]:
3224 for f in actions['forget'][0]:
3224 if interactive:
3225 if interactive:
3225 choice = repo.ui.promptchoice(
3226 choice = repo.ui.promptchoice(
3226 _("forget added file %s (Yn)?$$ &Yes $$ &No") % f)
3227 _("forget added file %s (Yn)?$$ &Yes $$ &No") % f)
3227 if choice == 0:
3228 if choice == 0:
3228 repo.dirstate.drop(f)
3229 repo.dirstate.drop(f)
3229 else:
3230 else:
3230 excluded_files.append(repo.wjoin(f))
3231 excluded_files.append(repo.wjoin(f))
3231 else:
3232 else:
3232 repo.dirstate.drop(f)
3233 repo.dirstate.drop(f)
3233 for f in actions['remove'][0]:
3234 for f in actions['remove'][0]:
3234 audit_path(f)
3235 audit_path(f)
3235 if interactive:
3236 if interactive:
3236 choice = repo.ui.promptchoice(
3237 choice = repo.ui.promptchoice(
3237 _("remove added file %s (Yn)?$$ &Yes $$ &No") % f)
3238 _("remove added file %s (Yn)?$$ &Yes $$ &No") % f)
3238 if choice == 0:
3239 if choice == 0:
3239 doremove(f)
3240 doremove(f)
3240 else:
3241 else:
3241 excluded_files.append(repo.wjoin(f))
3242 excluded_files.append(repo.wjoin(f))
3242 else:
3243 else:
3243 doremove(f)
3244 doremove(f)
3244 for f in actions['drop'][0]:
3245 for f in actions['drop'][0]:
3245 audit_path(f)
3246 audit_path(f)
3246 repo.dirstate.remove(f)
3247 repo.dirstate.remove(f)
3247
3248
3248 normal = None
3249 normal = None
3249 if node == parent:
3250 if node == parent:
3250 # We're reverting to our parent. If possible, we'd like status
3251 # We're reverting to our parent. If possible, we'd like status
3251 # to report the file as clean. We have to use normallookup for
3252 # to report the file as clean. We have to use normallookup for
3252 # merges to avoid losing information about merged/dirty files.
3253 # merges to avoid losing information about merged/dirty files.
3253 if p2 != nullid:
3254 if p2 != nullid:
3254 normal = repo.dirstate.normallookup
3255 normal = repo.dirstate.normallookup
3255 else:
3256 else:
3256 normal = repo.dirstate.normal
3257 normal = repo.dirstate.normal
3257
3258
3258 newlyaddedandmodifiedfiles = set()
3259 newlyaddedandmodifiedfiles = set()
3259 if interactive:
3260 if interactive:
3260 # Prompt the user for changes to revert
3261 # Prompt the user for changes to revert
3261 torevert = [repo.wjoin(f) for f in actions['revert'][0]]
3262 torevert = [repo.wjoin(f) for f in actions['revert'][0]]
3262 m = scmutil.match(ctx, torevert, matcher_opts)
3263 m = scmutil.match(ctx, torevert, matcher_opts)
3263 diffopts = patch.difffeatureopts(repo.ui, whitespace=True)
3264 diffopts = patch.difffeatureopts(repo.ui, whitespace=True)
3264 diffopts.nodates = True
3265 diffopts.nodates = True
3265 diffopts.git = True
3266 diffopts.git = True
3266 operation = 'discard'
3267 operation = 'discard'
3267 reversehunks = True
3268 reversehunks = True
3268 if node != parent:
3269 if node != parent:
3269 operation = 'revert'
3270 operation = 'revert'
3270 reversehunks = repo.ui.configbool('experimental',
3271 reversehunks = repo.ui.configbool('experimental',
3271 'revertalternateinteractivemode',
3272 'revertalternateinteractivemode',
3272 True)
3273 True)
3273 if reversehunks:
3274 if reversehunks:
3274 diff = patch.diff(repo, ctx.node(), None, m, opts=diffopts)
3275 diff = patch.diff(repo, ctx.node(), None, m, opts=diffopts)
3275 else:
3276 else:
3276 diff = patch.diff(repo, None, ctx.node(), m, opts=diffopts)
3277 diff = patch.diff(repo, None, ctx.node(), m, opts=diffopts)
3277 originalchunks = patch.parsepatch(diff)
3278 originalchunks = patch.parsepatch(diff)
3278
3279
3279 try:
3280 try:
3280
3281
3281 chunks, opts = recordfilter(repo.ui, originalchunks,
3282 chunks, opts = recordfilter(repo.ui, originalchunks,
3282 operation=operation)
3283 operation=operation)
3283 if reversehunks:
3284 if reversehunks:
3284 chunks = patch.reversehunks(chunks)
3285 chunks = patch.reversehunks(chunks)
3285
3286
3286 except patch.PatchError as err:
3287 except patch.PatchError as err:
3287 raise error.Abort(_('error parsing patch: %s') % err)
3288 raise error.Abort(_('error parsing patch: %s') % err)
3288
3289
3289 newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
3290 newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
3290 if tobackup is None:
3291 if tobackup is None:
3291 tobackup = set()
3292 tobackup = set()
3292 # Apply changes
3293 # Apply changes
3293 fp = stringio()
3294 fp = stringio()
3294 for c in chunks:
3295 for c in chunks:
3295 # Create a backup file only if this hunk should be backed up
3296 # Create a backup file only if this hunk should be backed up
3296 if ishunk(c) and c.header.filename() in tobackup:
3297 if ishunk(c) and c.header.filename() in tobackup:
3297 abs = c.header.filename()
3298 abs = c.header.filename()
3298 target = repo.wjoin(abs)
3299 target = repo.wjoin(abs)
3299 bakname = scmutil.origpath(repo.ui, repo, m.rel(abs))
3300 bakname = scmutil.origpath(repo.ui, repo, m.rel(abs))
3300 util.copyfile(target, bakname)
3301 util.copyfile(target, bakname)
3301 tobackup.remove(abs)
3302 tobackup.remove(abs)
3302 c.write(fp)
3303 c.write(fp)
3303 dopatch = fp.tell()
3304 dopatch = fp.tell()
3304 fp.seek(0)
3305 fp.seek(0)
3305 if dopatch:
3306 if dopatch:
3306 try:
3307 try:
3307 patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None)
3308 patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None)
3308 except patch.PatchError as err:
3309 except patch.PatchError as err:
3309 raise error.Abort(str(err))
3310 raise error.Abort(str(err))
3310 del fp
3311 del fp
3311 else:
3312 else:
3312 for f in actions['revert'][0]:
3313 for f in actions['revert'][0]:
3313 checkout(f)
3314 checkout(f)
3314 if normal:
3315 if normal:
3315 normal(f)
3316 normal(f)
3316
3317
3317 for f in actions['add'][0]:
3318 for f in actions['add'][0]:
3318 # Don't checkout modified files, they are already created by the diff
3319 # Don't checkout modified files, they are already created by the diff
3319 if f not in newlyaddedandmodifiedfiles:
3320 if f not in newlyaddedandmodifiedfiles:
3320 checkout(f)
3321 checkout(f)
3321 repo.dirstate.add(f)
3322 repo.dirstate.add(f)
3322
3323
3323 normal = repo.dirstate.normallookup
3324 normal = repo.dirstate.normallookup
3324 if node == parent and p2 == nullid:
3325 if node == parent and p2 == nullid:
3325 normal = repo.dirstate.normal
3326 normal = repo.dirstate.normal
3326 for f in actions['undelete'][0]:
3327 for f in actions['undelete'][0]:
3327 checkout(f)
3328 checkout(f)
3328 normal(f)
3329 normal(f)
3329
3330
3330 copied = copies.pathcopies(repo[parent], ctx)
3331 copied = copies.pathcopies(repo[parent], ctx)
3331
3332
3332 for f in actions['add'][0] + actions['undelete'][0] + actions['revert'][0]:
3333 for f in actions['add'][0] + actions['undelete'][0] + actions['revert'][0]:
3333 if f in copied:
3334 if f in copied:
3334 repo.dirstate.copy(copied[f], f)
3335 repo.dirstate.copy(copied[f], f)
3335
3336
3336 def command(table):
3337 def command(table):
3337 """Returns a function object to be used as a decorator for making commands.
3338 """Returns a function object to be used as a decorator for making commands.
3338
3339
3339 This function receives a command table as its argument. The table should
3340 This function receives a command table as its argument. The table should
3340 be a dict.
3341 be a dict.
3341
3342
3342 The returned function can be used as a decorator for adding commands
3343 The returned function can be used as a decorator for adding commands
3343 to that command table. This function accepts multiple arguments to define
3344 to that command table. This function accepts multiple arguments to define
3344 a command.
3345 a command.
3345
3346
3346 The first argument is the command name.
3347 The first argument is the command name.
3347
3348
3348 The options argument is an iterable of tuples defining command arguments.
3349 The options argument is an iterable of tuples defining command arguments.
3349 See ``mercurial.fancyopts.fancyopts()`` for the format of each tuple.
3350 See ``mercurial.fancyopts.fancyopts()`` for the format of each tuple.
3350
3351
3351 The synopsis argument defines a short, one line summary of how to use the
3352 The synopsis argument defines a short, one line summary of how to use the
3352 command. This shows up in the help output.
3353 command. This shows up in the help output.
3353
3354
3354 The norepo argument defines whether the command does not require a
3355 The norepo argument defines whether the command does not require a
3355 local repository. Most commands operate against a repository, thus the
3356 local repository. Most commands operate against a repository, thus the
3356 default is False.
3357 default is False.
3357
3358
3358 The optionalrepo argument defines whether the command optionally requires
3359 The optionalrepo argument defines whether the command optionally requires
3359 a local repository.
3360 a local repository.
3360
3361
3361 The inferrepo argument defines whether to try to find a repository from the
3362 The inferrepo argument defines whether to try to find a repository from the
3362 command line arguments. If True, arguments will be examined for potential
3363 command line arguments. If True, arguments will be examined for potential
3363 repository locations. See ``findrepo()``. If a repository is found, it
3364 repository locations. See ``findrepo()``. If a repository is found, it
3364 will be used.
3365 will be used.
3365 """
3366 """
3366 def cmd(name, options=(), synopsis=None, norepo=False, optionalrepo=False,
3367 def cmd(name, options=(), synopsis=None, norepo=False, optionalrepo=False,
3367 inferrepo=False):
3368 inferrepo=False):
3368 def decorator(func):
3369 def decorator(func):
3369 func.norepo = norepo
3370 func.norepo = norepo
3370 func.optionalrepo = optionalrepo
3371 func.optionalrepo = optionalrepo
3371 func.inferrepo = inferrepo
3372 func.inferrepo = inferrepo
3372 if synopsis:
3373 if synopsis:
3373 table[name] = func, list(options), synopsis
3374 table[name] = func, list(options), synopsis
3374 else:
3375 else:
3375 table[name] = func, list(options)
3376 table[name] = func, list(options)
3376 return func
3377 return func
3377 return decorator
3378 return decorator
3378
3379
3379 return cmd
3380 return cmd
3380
3381
3381 # a list of (ui, repo, otherpeer, opts, missing) functions called by
3382 # a list of (ui, repo, otherpeer, opts, missing) functions called by
3382 # commands.outgoing. "missing" is "missing" of the result of
3383 # commands.outgoing. "missing" is "missing" of the result of
3383 # "findcommonoutgoing()"
3384 # "findcommonoutgoing()"
3384 outgoinghooks = util.hooks()
3385 outgoinghooks = util.hooks()
3385
3386
3386 # a list of (ui, repo) functions called by commands.summary
3387 # a list of (ui, repo) functions called by commands.summary
3387 summaryhooks = util.hooks()
3388 summaryhooks = util.hooks()
3388
3389
3389 # a list of (ui, repo, opts, changes) functions called by commands.summary.
3390 # a list of (ui, repo, opts, changes) functions called by commands.summary.
3390 #
3391 #
3391 # functions should return tuple of booleans below, if 'changes' is None:
3392 # functions should return tuple of booleans below, if 'changes' is None:
3392 # (whether-incomings-are-needed, whether-outgoings-are-needed)
3393 # (whether-incomings-are-needed, whether-outgoings-are-needed)
3393 #
3394 #
3394 # otherwise, 'changes' is a tuple of tuples below:
3395 # otherwise, 'changes' is a tuple of tuples below:
3395 # - (sourceurl, sourcebranch, sourcepeer, incoming)
3396 # - (sourceurl, sourcebranch, sourcepeer, incoming)
3396 # - (desturl, destbranch, destpeer, outgoing)
3397 # - (desturl, destbranch, destpeer, outgoing)
3397 summaryremotehooks = util.hooks()
3398 summaryremotehooks = util.hooks()
3398
3399
3399 # A list of state files kept by multistep operations like graft.
3400 # A list of state files kept by multistep operations like graft.
3400 # Since graft cannot be aborted, it is considered 'clearable' by update.
3401 # Since graft cannot be aborted, it is considered 'clearable' by update.
3401 # note: bisect is intentionally excluded
3402 # note: bisect is intentionally excluded
3402 # (state file, clearable, allowcommit, error, hint)
3403 # (state file, clearable, allowcommit, error, hint)
3403 unfinishedstates = [
3404 unfinishedstates = [
3404 ('graftstate', True, False, _('graft in progress'),
3405 ('graftstate', True, False, _('graft in progress'),
3405 _("use 'hg graft --continue' or 'hg update' to abort")),
3406 _("use 'hg graft --continue' or 'hg update' to abort")),
3406 ('updatestate', True, False, _('last update was interrupted'),
3407 ('updatestate', True, False, _('last update was interrupted'),
3407 _("use 'hg update' to get a consistent checkout"))
3408 _("use 'hg update' to get a consistent checkout"))
3408 ]
3409 ]
3409
3410
3410 def checkunfinished(repo, commit=False):
3411 def checkunfinished(repo, commit=False):
3411 '''Look for an unfinished multistep operation, like graft, and abort
3412 '''Look for an unfinished multistep operation, like graft, and abort
3412 if found. It's probably good to check this right before
3413 if found. It's probably good to check this right before
3413 bailifchanged().
3414 bailifchanged().
3414 '''
3415 '''
3415 for f, clearable, allowcommit, msg, hint in unfinishedstates:
3416 for f, clearable, allowcommit, msg, hint in unfinishedstates:
3416 if commit and allowcommit:
3417 if commit and allowcommit:
3417 continue
3418 continue
3418 if repo.vfs.exists(f):
3419 if repo.vfs.exists(f):
3419 raise error.Abort(msg, hint=hint)
3420 raise error.Abort(msg, hint=hint)
3420
3421
3421 def clearunfinished(repo):
3422 def clearunfinished(repo):
3422 '''Check for unfinished operations (as above), and clear the ones
3423 '''Check for unfinished operations (as above), and clear the ones
3423 that are clearable.
3424 that are clearable.
3424 '''
3425 '''
3425 for f, clearable, allowcommit, msg, hint in unfinishedstates:
3426 for f, clearable, allowcommit, msg, hint in unfinishedstates:
3426 if not clearable and repo.vfs.exists(f):
3427 if not clearable and repo.vfs.exists(f):
3427 raise error.Abort(msg, hint=hint)
3428 raise error.Abort(msg, hint=hint)
3428 for f, clearable, allowcommit, msg, hint in unfinishedstates:
3429 for f, clearable, allowcommit, msg, hint in unfinishedstates:
3429 if clearable and repo.vfs.exists(f):
3430 if clearable and repo.vfs.exists(f):
3430 util.unlink(repo.vfs.join(f))
3431 util.unlink(repo.vfs.join(f))
3431
3432
3432 afterresolvedstates = [
3433 afterresolvedstates = [
3433 ('graftstate',
3434 ('graftstate',
3434 _('hg graft --continue')),
3435 _('hg graft --continue')),
3435 ]
3436 ]
3436
3437
3437 def howtocontinue(repo):
3438 def howtocontinue(repo):
3438 '''Check for an unfinished operation and return the command to finish
3439 '''Check for an unfinished operation and return the command to finish
3439 it.
3440 it.
3440
3441
3441 afterresolvedstates tuples define a .hg/{file} and the corresponding
3442 afterresolvedstates tuples define a .hg/{file} and the corresponding
3442 command needed to finish it.
3443 command needed to finish it.
3443
3444
3444 Returns a (msg, warning) tuple. 'msg' is a string and 'warning' is
3445 Returns a (msg, warning) tuple. 'msg' is a string and 'warning' is
3445 a boolean.
3446 a boolean.
3446 '''
3447 '''
3447 contmsg = _("continue: %s")
3448 contmsg = _("continue: %s")
3448 for f, msg in afterresolvedstates:
3449 for f, msg in afterresolvedstates:
3449 if repo.vfs.exists(f):
3450 if repo.vfs.exists(f):
3450 return contmsg % msg, True
3451 return contmsg % msg, True
3451 workingctx = repo[None]
3452 workingctx = repo[None]
3452 dirty = any(repo.status()) or any(workingctx.sub(s).dirty()
3453 dirty = any(repo.status()) or any(workingctx.sub(s).dirty()
3453 for s in workingctx.substate)
3454 for s in workingctx.substate)
3454 if dirty:
3455 if dirty:
3455 return contmsg % _("hg commit"), False
3456 return contmsg % _("hg commit"), False
3456 return None, None
3457 return None, None
3457
3458
3458 def checkafterresolved(repo):
3459 def checkafterresolved(repo):
3459 '''Inform the user about the next action after completing hg resolve
3460 '''Inform the user about the next action after completing hg resolve
3460
3461
3461 If there's a matching afterresolvedstates, howtocontinue will yield
3462 If there's a matching afterresolvedstates, howtocontinue will yield
3462 repo.ui.warn as the reporter.
3463 repo.ui.warn as the reporter.
3463
3464
3464 Otherwise, it will yield repo.ui.note.
3465 Otherwise, it will yield repo.ui.note.
3465 '''
3466 '''
3466 msg, warning = howtocontinue(repo)
3467 msg, warning = howtocontinue(repo)
3467 if msg is not None:
3468 if msg is not None:
3468 if warning:
3469 if warning:
3469 repo.ui.warn("%s\n" % msg)
3470 repo.ui.warn("%s\n" % msg)
3470 else:
3471 else:
3471 repo.ui.note("%s\n" % msg)
3472 repo.ui.note("%s\n" % msg)
3472
3473
3473 def wrongtooltocontinue(repo, task):
3474 def wrongtooltocontinue(repo, task):
3474 '''Raise an abort suggesting how to properly continue if there is an
3475 '''Raise an abort suggesting how to properly continue if there is an
3475 active task.
3476 active task.
3476
3477
3477 Uses howtocontinue() to find the active task.
3478 Uses howtocontinue() to find the active task.
3478
3479
3479 If there's no task (repo.ui.note for 'hg commit'), it does not offer
3480 If there's no task (repo.ui.note for 'hg commit'), it does not offer
3480 a hint.
3481 a hint.
3481 '''
3482 '''
3482 after = howtocontinue(repo)
3483 after = howtocontinue(repo)
3483 hint = None
3484 hint = None
3484 if after[1]:
3485 if after[1]:
3485 hint = after[0]
3486 hint = after[0]
3486 raise error.Abort(_('no %s in progress') % task, hint=hint)
3487 raise error.Abort(_('no %s in progress') % task, hint=hint)
General Comments 0
You need to be logged in to leave comments. Login now