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