##// END OF EJS Templates
rebase: fix path auditing to audit path relative to repo root (issue5818)...
Martin von Zweigbergk -
r41197:1c8c54cf 4.8.1 stable
parent child Browse files
Show More
@@ -1,2442 +1,2442 b''
1 # context.py - changeset and file context objects for mercurial
1 # context.py - changeset and file context objects for mercurial
2 #
2 #
3 # Copyright 2006, 2007 Matt Mackall <mpm@selenic.com>
3 # Copyright 2006, 2007 Matt Mackall <mpm@selenic.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version.
6 # GNU General Public License version 2 or any later version.
7
7
8 from __future__ import absolute_import
8 from __future__ import absolute_import
9
9
10 import errno
10 import errno
11 import filecmp
11 import filecmp
12 import os
12 import os
13 import stat
13 import stat
14
14
15 from .i18n import _
15 from .i18n import _
16 from .node import (
16 from .node import (
17 addednodeid,
17 addednodeid,
18 hex,
18 hex,
19 modifiednodeid,
19 modifiednodeid,
20 nullid,
20 nullid,
21 nullrev,
21 nullrev,
22 short,
22 short,
23 wdirfilenodeids,
23 wdirfilenodeids,
24 wdirid,
24 wdirid,
25 )
25 )
26 from . import (
26 from . import (
27 dagop,
27 dagop,
28 encoding,
28 encoding,
29 error,
29 error,
30 fileset,
30 fileset,
31 match as matchmod,
31 match as matchmod,
32 obsolete as obsmod,
32 obsolete as obsmod,
33 patch,
33 patch,
34 pathutil,
34 pathutil,
35 phases,
35 phases,
36 pycompat,
36 pycompat,
37 repoview,
37 repoview,
38 scmutil,
38 scmutil,
39 sparse,
39 sparse,
40 subrepo,
40 subrepo,
41 subrepoutil,
41 subrepoutil,
42 util,
42 util,
43 )
43 )
44 from .utils import (
44 from .utils import (
45 dateutil,
45 dateutil,
46 stringutil,
46 stringutil,
47 )
47 )
48
48
49 propertycache = util.propertycache
49 propertycache = util.propertycache
50
50
51 class basectx(object):
51 class basectx(object):
52 """A basectx object represents the common logic for its children:
52 """A basectx object represents the common logic for its children:
53 changectx: read-only context that is already present in the repo,
53 changectx: read-only context that is already present in the repo,
54 workingctx: a context that represents the working directory and can
54 workingctx: a context that represents the working directory and can
55 be committed,
55 be committed,
56 memctx: a context that represents changes in-memory and can also
56 memctx: a context that represents changes in-memory and can also
57 be committed."""
57 be committed."""
58
58
59 def __init__(self, repo):
59 def __init__(self, repo):
60 self._repo = repo
60 self._repo = repo
61
61
62 def __bytes__(self):
62 def __bytes__(self):
63 return short(self.node())
63 return short(self.node())
64
64
65 __str__ = encoding.strmethod(__bytes__)
65 __str__ = encoding.strmethod(__bytes__)
66
66
67 def __repr__(self):
67 def __repr__(self):
68 return r"<%s %s>" % (type(self).__name__, str(self))
68 return r"<%s %s>" % (type(self).__name__, str(self))
69
69
70 def __eq__(self, other):
70 def __eq__(self, other):
71 try:
71 try:
72 return type(self) == type(other) and self._rev == other._rev
72 return type(self) == type(other) and self._rev == other._rev
73 except AttributeError:
73 except AttributeError:
74 return False
74 return False
75
75
76 def __ne__(self, other):
76 def __ne__(self, other):
77 return not (self == other)
77 return not (self == other)
78
78
79 def __contains__(self, key):
79 def __contains__(self, key):
80 return key in self._manifest
80 return key in self._manifest
81
81
82 def __getitem__(self, key):
82 def __getitem__(self, key):
83 return self.filectx(key)
83 return self.filectx(key)
84
84
85 def __iter__(self):
85 def __iter__(self):
86 return iter(self._manifest)
86 return iter(self._manifest)
87
87
88 def _buildstatusmanifest(self, status):
88 def _buildstatusmanifest(self, status):
89 """Builds a manifest that includes the given status results, if this is
89 """Builds a manifest that includes the given status results, if this is
90 a working copy context. For non-working copy contexts, it just returns
90 a working copy context. For non-working copy contexts, it just returns
91 the normal manifest."""
91 the normal manifest."""
92 return self.manifest()
92 return self.manifest()
93
93
94 def _matchstatus(self, other, match):
94 def _matchstatus(self, other, match):
95 """This internal method provides a way for child objects to override the
95 """This internal method provides a way for child objects to override the
96 match operator.
96 match operator.
97 """
97 """
98 return match
98 return match
99
99
100 def _buildstatus(self, other, s, match, listignored, listclean,
100 def _buildstatus(self, other, s, match, listignored, listclean,
101 listunknown):
101 listunknown):
102 """build a status with respect to another context"""
102 """build a status with respect to another context"""
103 # Load earliest manifest first for caching reasons. More specifically,
103 # Load earliest manifest first for caching reasons. More specifically,
104 # if you have revisions 1000 and 1001, 1001 is probably stored as a
104 # if you have revisions 1000 and 1001, 1001 is probably stored as a
105 # delta against 1000. Thus, if you read 1000 first, we'll reconstruct
105 # delta against 1000. Thus, if you read 1000 first, we'll reconstruct
106 # 1000 and cache it so that when you read 1001, we just need to apply a
106 # 1000 and cache it so that when you read 1001, we just need to apply a
107 # delta to what's in the cache. So that's one full reconstruction + one
107 # delta to what's in the cache. So that's one full reconstruction + one
108 # delta application.
108 # delta application.
109 mf2 = None
109 mf2 = None
110 if self.rev() is not None and self.rev() < other.rev():
110 if self.rev() is not None and self.rev() < other.rev():
111 mf2 = self._buildstatusmanifest(s)
111 mf2 = self._buildstatusmanifest(s)
112 mf1 = other._buildstatusmanifest(s)
112 mf1 = other._buildstatusmanifest(s)
113 if mf2 is None:
113 if mf2 is None:
114 mf2 = self._buildstatusmanifest(s)
114 mf2 = self._buildstatusmanifest(s)
115
115
116 modified, added = [], []
116 modified, added = [], []
117 removed = []
117 removed = []
118 clean = []
118 clean = []
119 deleted, unknown, ignored = s.deleted, s.unknown, s.ignored
119 deleted, unknown, ignored = s.deleted, s.unknown, s.ignored
120 deletedset = set(deleted)
120 deletedset = set(deleted)
121 d = mf1.diff(mf2, match=match, clean=listclean)
121 d = mf1.diff(mf2, match=match, clean=listclean)
122 for fn, value in d.iteritems():
122 for fn, value in d.iteritems():
123 if fn in deletedset:
123 if fn in deletedset:
124 continue
124 continue
125 if value is None:
125 if value is None:
126 clean.append(fn)
126 clean.append(fn)
127 continue
127 continue
128 (node1, flag1), (node2, flag2) = value
128 (node1, flag1), (node2, flag2) = value
129 if node1 is None:
129 if node1 is None:
130 added.append(fn)
130 added.append(fn)
131 elif node2 is None:
131 elif node2 is None:
132 removed.append(fn)
132 removed.append(fn)
133 elif flag1 != flag2:
133 elif flag1 != flag2:
134 modified.append(fn)
134 modified.append(fn)
135 elif node2 not in wdirfilenodeids:
135 elif node2 not in wdirfilenodeids:
136 # When comparing files between two commits, we save time by
136 # When comparing files between two commits, we save time by
137 # not comparing the file contents when the nodeids differ.
137 # not comparing the file contents when the nodeids differ.
138 # Note that this means we incorrectly report a reverted change
138 # Note that this means we incorrectly report a reverted change
139 # to a file as a modification.
139 # to a file as a modification.
140 modified.append(fn)
140 modified.append(fn)
141 elif self[fn].cmp(other[fn]):
141 elif self[fn].cmp(other[fn]):
142 modified.append(fn)
142 modified.append(fn)
143 else:
143 else:
144 clean.append(fn)
144 clean.append(fn)
145
145
146 if removed:
146 if removed:
147 # need to filter files if they are already reported as removed
147 # need to filter files if they are already reported as removed
148 unknown = [fn for fn in unknown if fn not in mf1 and
148 unknown = [fn for fn in unknown if fn not in mf1 and
149 (not match or match(fn))]
149 (not match or match(fn))]
150 ignored = [fn for fn in ignored if fn not in mf1 and
150 ignored = [fn for fn in ignored if fn not in mf1 and
151 (not match or match(fn))]
151 (not match or match(fn))]
152 # if they're deleted, don't report them as removed
152 # if they're deleted, don't report them as removed
153 removed = [fn for fn in removed if fn not in deletedset]
153 removed = [fn for fn in removed if fn not in deletedset]
154
154
155 return scmutil.status(modified, added, removed, deleted, unknown,
155 return scmutil.status(modified, added, removed, deleted, unknown,
156 ignored, clean)
156 ignored, clean)
157
157
158 @propertycache
158 @propertycache
159 def substate(self):
159 def substate(self):
160 return subrepoutil.state(self, self._repo.ui)
160 return subrepoutil.state(self, self._repo.ui)
161
161
162 def subrev(self, subpath):
162 def subrev(self, subpath):
163 return self.substate[subpath][1]
163 return self.substate[subpath][1]
164
164
165 def rev(self):
165 def rev(self):
166 return self._rev
166 return self._rev
167 def node(self):
167 def node(self):
168 return self._node
168 return self._node
169 def hex(self):
169 def hex(self):
170 return hex(self.node())
170 return hex(self.node())
171 def manifest(self):
171 def manifest(self):
172 return self._manifest
172 return self._manifest
173 def manifestctx(self):
173 def manifestctx(self):
174 return self._manifestctx
174 return self._manifestctx
175 def repo(self):
175 def repo(self):
176 return self._repo
176 return self._repo
177 def phasestr(self):
177 def phasestr(self):
178 return phases.phasenames[self.phase()]
178 return phases.phasenames[self.phase()]
179 def mutable(self):
179 def mutable(self):
180 return self.phase() > phases.public
180 return self.phase() > phases.public
181
181
182 def matchfileset(self, expr, badfn=None):
182 def matchfileset(self, expr, badfn=None):
183 return fileset.match(self, expr, badfn=badfn)
183 return fileset.match(self, expr, badfn=badfn)
184
184
185 def obsolete(self):
185 def obsolete(self):
186 """True if the changeset is obsolete"""
186 """True if the changeset is obsolete"""
187 return self.rev() in obsmod.getrevs(self._repo, 'obsolete')
187 return self.rev() in obsmod.getrevs(self._repo, 'obsolete')
188
188
189 def extinct(self):
189 def extinct(self):
190 """True if the changeset is extinct"""
190 """True if the changeset is extinct"""
191 return self.rev() in obsmod.getrevs(self._repo, 'extinct')
191 return self.rev() in obsmod.getrevs(self._repo, 'extinct')
192
192
193 def orphan(self):
193 def orphan(self):
194 """True if the changeset is not obsolete, but its ancestor is"""
194 """True if the changeset is not obsolete, but its ancestor is"""
195 return self.rev() in obsmod.getrevs(self._repo, 'orphan')
195 return self.rev() in obsmod.getrevs(self._repo, 'orphan')
196
196
197 def phasedivergent(self):
197 def phasedivergent(self):
198 """True if the changeset tries to be a successor of a public changeset
198 """True if the changeset tries to be a successor of a public changeset
199
199
200 Only non-public and non-obsolete changesets may be phase-divergent.
200 Only non-public and non-obsolete changesets may be phase-divergent.
201 """
201 """
202 return self.rev() in obsmod.getrevs(self._repo, 'phasedivergent')
202 return self.rev() in obsmod.getrevs(self._repo, 'phasedivergent')
203
203
204 def contentdivergent(self):
204 def contentdivergent(self):
205 """Is a successor of a changeset with multiple possible successor sets
205 """Is a successor of a changeset with multiple possible successor sets
206
206
207 Only non-public and non-obsolete changesets may be content-divergent.
207 Only non-public and non-obsolete changesets may be content-divergent.
208 """
208 """
209 return self.rev() in obsmod.getrevs(self._repo, 'contentdivergent')
209 return self.rev() in obsmod.getrevs(self._repo, 'contentdivergent')
210
210
211 def isunstable(self):
211 def isunstable(self):
212 """True if the changeset is either orphan, phase-divergent or
212 """True if the changeset is either orphan, phase-divergent or
213 content-divergent"""
213 content-divergent"""
214 return self.orphan() or self.phasedivergent() or self.contentdivergent()
214 return self.orphan() or self.phasedivergent() or self.contentdivergent()
215
215
216 def instabilities(self):
216 def instabilities(self):
217 """return the list of instabilities affecting this changeset.
217 """return the list of instabilities affecting this changeset.
218
218
219 Instabilities are returned as strings. possible values are:
219 Instabilities are returned as strings. possible values are:
220 - orphan,
220 - orphan,
221 - phase-divergent,
221 - phase-divergent,
222 - content-divergent.
222 - content-divergent.
223 """
223 """
224 instabilities = []
224 instabilities = []
225 if self.orphan():
225 if self.orphan():
226 instabilities.append('orphan')
226 instabilities.append('orphan')
227 if self.phasedivergent():
227 if self.phasedivergent():
228 instabilities.append('phase-divergent')
228 instabilities.append('phase-divergent')
229 if self.contentdivergent():
229 if self.contentdivergent():
230 instabilities.append('content-divergent')
230 instabilities.append('content-divergent')
231 return instabilities
231 return instabilities
232
232
233 def parents(self):
233 def parents(self):
234 """return contexts for each parent changeset"""
234 """return contexts for each parent changeset"""
235 return self._parents
235 return self._parents
236
236
237 def p1(self):
237 def p1(self):
238 return self._parents[0]
238 return self._parents[0]
239
239
240 def p2(self):
240 def p2(self):
241 parents = self._parents
241 parents = self._parents
242 if len(parents) == 2:
242 if len(parents) == 2:
243 return parents[1]
243 return parents[1]
244 return self._repo[nullrev]
244 return self._repo[nullrev]
245
245
246 def _fileinfo(self, path):
246 def _fileinfo(self, path):
247 if r'_manifest' in self.__dict__:
247 if r'_manifest' in self.__dict__:
248 try:
248 try:
249 return self._manifest[path], self._manifest.flags(path)
249 return self._manifest[path], self._manifest.flags(path)
250 except KeyError:
250 except KeyError:
251 raise error.ManifestLookupError(self._node, path,
251 raise error.ManifestLookupError(self._node, path,
252 _('not found in manifest'))
252 _('not found in manifest'))
253 if r'_manifestdelta' in self.__dict__ or path in self.files():
253 if r'_manifestdelta' in self.__dict__ or path in self.files():
254 if path in self._manifestdelta:
254 if path in self._manifestdelta:
255 return (self._manifestdelta[path],
255 return (self._manifestdelta[path],
256 self._manifestdelta.flags(path))
256 self._manifestdelta.flags(path))
257 mfl = self._repo.manifestlog
257 mfl = self._repo.manifestlog
258 try:
258 try:
259 node, flag = mfl[self._changeset.manifest].find(path)
259 node, flag = mfl[self._changeset.manifest].find(path)
260 except KeyError:
260 except KeyError:
261 raise error.ManifestLookupError(self._node, path,
261 raise error.ManifestLookupError(self._node, path,
262 _('not found in manifest'))
262 _('not found in manifest'))
263
263
264 return node, flag
264 return node, flag
265
265
266 def filenode(self, path):
266 def filenode(self, path):
267 return self._fileinfo(path)[0]
267 return self._fileinfo(path)[0]
268
268
269 def flags(self, path):
269 def flags(self, path):
270 try:
270 try:
271 return self._fileinfo(path)[1]
271 return self._fileinfo(path)[1]
272 except error.LookupError:
272 except error.LookupError:
273 return ''
273 return ''
274
274
275 def sub(self, path, allowcreate=True):
275 def sub(self, path, allowcreate=True):
276 '''return a subrepo for the stored revision of path, never wdir()'''
276 '''return a subrepo for the stored revision of path, never wdir()'''
277 return subrepo.subrepo(self, path, allowcreate=allowcreate)
277 return subrepo.subrepo(self, path, allowcreate=allowcreate)
278
278
279 def nullsub(self, path, pctx):
279 def nullsub(self, path, pctx):
280 return subrepo.nullsubrepo(self, path, pctx)
280 return subrepo.nullsubrepo(self, path, pctx)
281
281
282 def workingsub(self, path):
282 def workingsub(self, path):
283 '''return a subrepo for the stored revision, or wdir if this is a wdir
283 '''return a subrepo for the stored revision, or wdir if this is a wdir
284 context.
284 context.
285 '''
285 '''
286 return subrepo.subrepo(self, path, allowwdir=True)
286 return subrepo.subrepo(self, path, allowwdir=True)
287
287
288 def match(self, pats=None, include=None, exclude=None, default='glob',
288 def match(self, pats=None, include=None, exclude=None, default='glob',
289 listsubrepos=False, badfn=None):
289 listsubrepos=False, badfn=None):
290 r = self._repo
290 r = self._repo
291 return matchmod.match(r.root, r.getcwd(), pats,
291 return matchmod.match(r.root, r.getcwd(), pats,
292 include, exclude, default,
292 include, exclude, default,
293 auditor=r.nofsauditor, ctx=self,
293 auditor=r.nofsauditor, ctx=self,
294 listsubrepos=listsubrepos, badfn=badfn)
294 listsubrepos=listsubrepos, badfn=badfn)
295
295
296 def diff(self, ctx2=None, match=None, changes=None, opts=None,
296 def diff(self, ctx2=None, match=None, changes=None, opts=None,
297 losedatafn=None, prefix='', relroot='', copy=None,
297 losedatafn=None, prefix='', relroot='', copy=None,
298 hunksfilterfn=None):
298 hunksfilterfn=None):
299 """Returns a diff generator for the given contexts and matcher"""
299 """Returns a diff generator for the given contexts and matcher"""
300 if ctx2 is None:
300 if ctx2 is None:
301 ctx2 = self.p1()
301 ctx2 = self.p1()
302 if ctx2 is not None:
302 if ctx2 is not None:
303 ctx2 = self._repo[ctx2]
303 ctx2 = self._repo[ctx2]
304 return patch.diff(self._repo, ctx2, self, match=match, changes=changes,
304 return patch.diff(self._repo, ctx2, self, match=match, changes=changes,
305 opts=opts, losedatafn=losedatafn, prefix=prefix,
305 opts=opts, losedatafn=losedatafn, prefix=prefix,
306 relroot=relroot, copy=copy,
306 relroot=relroot, copy=copy,
307 hunksfilterfn=hunksfilterfn)
307 hunksfilterfn=hunksfilterfn)
308
308
309 def dirs(self):
309 def dirs(self):
310 return self._manifest.dirs()
310 return self._manifest.dirs()
311
311
312 def hasdir(self, dir):
312 def hasdir(self, dir):
313 return self._manifest.hasdir(dir)
313 return self._manifest.hasdir(dir)
314
314
315 def status(self, other=None, match=None, listignored=False,
315 def status(self, other=None, match=None, listignored=False,
316 listclean=False, listunknown=False, listsubrepos=False):
316 listclean=False, listunknown=False, listsubrepos=False):
317 """return status of files between two nodes or node and working
317 """return status of files between two nodes or node and working
318 directory.
318 directory.
319
319
320 If other is None, compare this node with working directory.
320 If other is None, compare this node with working directory.
321
321
322 returns (modified, added, removed, deleted, unknown, ignored, clean)
322 returns (modified, added, removed, deleted, unknown, ignored, clean)
323 """
323 """
324
324
325 ctx1 = self
325 ctx1 = self
326 ctx2 = self._repo[other]
326 ctx2 = self._repo[other]
327
327
328 # This next code block is, admittedly, fragile logic that tests for
328 # This next code block is, admittedly, fragile logic that tests for
329 # reversing the contexts and wouldn't need to exist if it weren't for
329 # reversing the contexts and wouldn't need to exist if it weren't for
330 # the fast (and common) code path of comparing the working directory
330 # the fast (and common) code path of comparing the working directory
331 # with its first parent.
331 # with its first parent.
332 #
332 #
333 # What we're aiming for here is the ability to call:
333 # What we're aiming for here is the ability to call:
334 #
334 #
335 # workingctx.status(parentctx)
335 # workingctx.status(parentctx)
336 #
336 #
337 # If we always built the manifest for each context and compared those,
337 # If we always built the manifest for each context and compared those,
338 # then we'd be done. But the special case of the above call means we
338 # then we'd be done. But the special case of the above call means we
339 # just copy the manifest of the parent.
339 # just copy the manifest of the parent.
340 reversed = False
340 reversed = False
341 if (not isinstance(ctx1, changectx)
341 if (not isinstance(ctx1, changectx)
342 and isinstance(ctx2, changectx)):
342 and isinstance(ctx2, changectx)):
343 reversed = True
343 reversed = True
344 ctx1, ctx2 = ctx2, ctx1
344 ctx1, ctx2 = ctx2, ctx1
345
345
346 match = self._repo.narrowmatch(match)
346 match = self._repo.narrowmatch(match)
347 match = ctx2._matchstatus(ctx1, match)
347 match = ctx2._matchstatus(ctx1, match)
348 r = scmutil.status([], [], [], [], [], [], [])
348 r = scmutil.status([], [], [], [], [], [], [])
349 r = ctx2._buildstatus(ctx1, r, match, listignored, listclean,
349 r = ctx2._buildstatus(ctx1, r, match, listignored, listclean,
350 listunknown)
350 listunknown)
351
351
352 if reversed:
352 if reversed:
353 # Reverse added and removed. Clear deleted, unknown and ignored as
353 # Reverse added and removed. Clear deleted, unknown and ignored as
354 # these make no sense to reverse.
354 # these make no sense to reverse.
355 r = scmutil.status(r.modified, r.removed, r.added, [], [], [],
355 r = scmutil.status(r.modified, r.removed, r.added, [], [], [],
356 r.clean)
356 r.clean)
357
357
358 if listsubrepos:
358 if listsubrepos:
359 for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
359 for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
360 try:
360 try:
361 rev2 = ctx2.subrev(subpath)
361 rev2 = ctx2.subrev(subpath)
362 except KeyError:
362 except KeyError:
363 # A subrepo that existed in node1 was deleted between
363 # A subrepo that existed in node1 was deleted between
364 # node1 and node2 (inclusive). Thus, ctx2's substate
364 # node1 and node2 (inclusive). Thus, ctx2's substate
365 # won't contain that subpath. The best we can do ignore it.
365 # won't contain that subpath. The best we can do ignore it.
366 rev2 = None
366 rev2 = None
367 submatch = matchmod.subdirmatcher(subpath, match)
367 submatch = matchmod.subdirmatcher(subpath, match)
368 s = sub.status(rev2, match=submatch, ignored=listignored,
368 s = sub.status(rev2, match=submatch, ignored=listignored,
369 clean=listclean, unknown=listunknown,
369 clean=listclean, unknown=listunknown,
370 listsubrepos=True)
370 listsubrepos=True)
371 for rfiles, sfiles in zip(r, s):
371 for rfiles, sfiles in zip(r, s):
372 rfiles.extend("%s/%s" % (subpath, f) for f in sfiles)
372 rfiles.extend("%s/%s" % (subpath, f) for f in sfiles)
373
373
374 for l in r:
374 for l in r:
375 l.sort()
375 l.sort()
376
376
377 return r
377 return r
378
378
379 class changectx(basectx):
379 class changectx(basectx):
380 """A changecontext object makes access to data related to a particular
380 """A changecontext object makes access to data related to a particular
381 changeset convenient. It represents a read-only context already present in
381 changeset convenient. It represents a read-only context already present in
382 the repo."""
382 the repo."""
383 def __init__(self, repo, rev, node):
383 def __init__(self, repo, rev, node):
384 super(changectx, self).__init__(repo)
384 super(changectx, self).__init__(repo)
385 self._rev = rev
385 self._rev = rev
386 self._node = node
386 self._node = node
387
387
388 def __hash__(self):
388 def __hash__(self):
389 try:
389 try:
390 return hash(self._rev)
390 return hash(self._rev)
391 except AttributeError:
391 except AttributeError:
392 return id(self)
392 return id(self)
393
393
394 def __nonzero__(self):
394 def __nonzero__(self):
395 return self._rev != nullrev
395 return self._rev != nullrev
396
396
397 __bool__ = __nonzero__
397 __bool__ = __nonzero__
398
398
399 @propertycache
399 @propertycache
400 def _changeset(self):
400 def _changeset(self):
401 return self._repo.changelog.changelogrevision(self.rev())
401 return self._repo.changelog.changelogrevision(self.rev())
402
402
403 @propertycache
403 @propertycache
404 def _manifest(self):
404 def _manifest(self):
405 return self._manifestctx.read()
405 return self._manifestctx.read()
406
406
407 @property
407 @property
408 def _manifestctx(self):
408 def _manifestctx(self):
409 return self._repo.manifestlog[self._changeset.manifest]
409 return self._repo.manifestlog[self._changeset.manifest]
410
410
411 @propertycache
411 @propertycache
412 def _manifestdelta(self):
412 def _manifestdelta(self):
413 return self._manifestctx.readdelta()
413 return self._manifestctx.readdelta()
414
414
415 @propertycache
415 @propertycache
416 def _parents(self):
416 def _parents(self):
417 repo = self._repo
417 repo = self._repo
418 p1, p2 = repo.changelog.parentrevs(self._rev)
418 p1, p2 = repo.changelog.parentrevs(self._rev)
419 if p2 == nullrev:
419 if p2 == nullrev:
420 return [repo[p1]]
420 return [repo[p1]]
421 return [repo[p1], repo[p2]]
421 return [repo[p1], repo[p2]]
422
422
423 def changeset(self):
423 def changeset(self):
424 c = self._changeset
424 c = self._changeset
425 return (
425 return (
426 c.manifest,
426 c.manifest,
427 c.user,
427 c.user,
428 c.date,
428 c.date,
429 c.files,
429 c.files,
430 c.description,
430 c.description,
431 c.extra,
431 c.extra,
432 )
432 )
433 def manifestnode(self):
433 def manifestnode(self):
434 return self._changeset.manifest
434 return self._changeset.manifest
435
435
436 def user(self):
436 def user(self):
437 return self._changeset.user
437 return self._changeset.user
438 def date(self):
438 def date(self):
439 return self._changeset.date
439 return self._changeset.date
440 def files(self):
440 def files(self):
441 return self._changeset.files
441 return self._changeset.files
442 def description(self):
442 def description(self):
443 return self._changeset.description
443 return self._changeset.description
444 def branch(self):
444 def branch(self):
445 return encoding.tolocal(self._changeset.extra.get("branch"))
445 return encoding.tolocal(self._changeset.extra.get("branch"))
446 def closesbranch(self):
446 def closesbranch(self):
447 return 'close' in self._changeset.extra
447 return 'close' in self._changeset.extra
448 def extra(self):
448 def extra(self):
449 """Return a dict of extra information."""
449 """Return a dict of extra information."""
450 return self._changeset.extra
450 return self._changeset.extra
451 def tags(self):
451 def tags(self):
452 """Return a list of byte tag names"""
452 """Return a list of byte tag names"""
453 return self._repo.nodetags(self._node)
453 return self._repo.nodetags(self._node)
454 def bookmarks(self):
454 def bookmarks(self):
455 """Return a list of byte bookmark names."""
455 """Return a list of byte bookmark names."""
456 return self._repo.nodebookmarks(self._node)
456 return self._repo.nodebookmarks(self._node)
457 def phase(self):
457 def phase(self):
458 return self._repo._phasecache.phase(self._repo, self._rev)
458 return self._repo._phasecache.phase(self._repo, self._rev)
459 def hidden(self):
459 def hidden(self):
460 return self._rev in repoview.filterrevs(self._repo, 'visible')
460 return self._rev in repoview.filterrevs(self._repo, 'visible')
461
461
462 def isinmemory(self):
462 def isinmemory(self):
463 return False
463 return False
464
464
465 def children(self):
465 def children(self):
466 """return list of changectx contexts for each child changeset.
466 """return list of changectx contexts for each child changeset.
467
467
468 This returns only the immediate child changesets. Use descendants() to
468 This returns only the immediate child changesets. Use descendants() to
469 recursively walk children.
469 recursively walk children.
470 """
470 """
471 c = self._repo.changelog.children(self._node)
471 c = self._repo.changelog.children(self._node)
472 return [self._repo[x] for x in c]
472 return [self._repo[x] for x in c]
473
473
474 def ancestors(self):
474 def ancestors(self):
475 for a in self._repo.changelog.ancestors([self._rev]):
475 for a in self._repo.changelog.ancestors([self._rev]):
476 yield self._repo[a]
476 yield self._repo[a]
477
477
478 def descendants(self):
478 def descendants(self):
479 """Recursively yield all children of the changeset.
479 """Recursively yield all children of the changeset.
480
480
481 For just the immediate children, use children()
481 For just the immediate children, use children()
482 """
482 """
483 for d in self._repo.changelog.descendants([self._rev]):
483 for d in self._repo.changelog.descendants([self._rev]):
484 yield self._repo[d]
484 yield self._repo[d]
485
485
486 def filectx(self, path, fileid=None, filelog=None):
486 def filectx(self, path, fileid=None, filelog=None):
487 """get a file context from this changeset"""
487 """get a file context from this changeset"""
488 if fileid is None:
488 if fileid is None:
489 fileid = self.filenode(path)
489 fileid = self.filenode(path)
490 return filectx(self._repo, path, fileid=fileid,
490 return filectx(self._repo, path, fileid=fileid,
491 changectx=self, filelog=filelog)
491 changectx=self, filelog=filelog)
492
492
493 def ancestor(self, c2, warn=False):
493 def ancestor(self, c2, warn=False):
494 """return the "best" ancestor context of self and c2
494 """return the "best" ancestor context of self and c2
495
495
496 If there are multiple candidates, it will show a message and check
496 If there are multiple candidates, it will show a message and check
497 merge.preferancestor configuration before falling back to the
497 merge.preferancestor configuration before falling back to the
498 revlog ancestor."""
498 revlog ancestor."""
499 # deal with workingctxs
499 # deal with workingctxs
500 n2 = c2._node
500 n2 = c2._node
501 if n2 is None:
501 if n2 is None:
502 n2 = c2._parents[0]._node
502 n2 = c2._parents[0]._node
503 cahs = self._repo.changelog.commonancestorsheads(self._node, n2)
503 cahs = self._repo.changelog.commonancestorsheads(self._node, n2)
504 if not cahs:
504 if not cahs:
505 anc = nullid
505 anc = nullid
506 elif len(cahs) == 1:
506 elif len(cahs) == 1:
507 anc = cahs[0]
507 anc = cahs[0]
508 else:
508 else:
509 # experimental config: merge.preferancestor
509 # experimental config: merge.preferancestor
510 for r in self._repo.ui.configlist('merge', 'preferancestor'):
510 for r in self._repo.ui.configlist('merge', 'preferancestor'):
511 try:
511 try:
512 ctx = scmutil.revsymbol(self._repo, r)
512 ctx = scmutil.revsymbol(self._repo, r)
513 except error.RepoLookupError:
513 except error.RepoLookupError:
514 continue
514 continue
515 anc = ctx.node()
515 anc = ctx.node()
516 if anc in cahs:
516 if anc in cahs:
517 break
517 break
518 else:
518 else:
519 anc = self._repo.changelog.ancestor(self._node, n2)
519 anc = self._repo.changelog.ancestor(self._node, n2)
520 if warn:
520 if warn:
521 self._repo.ui.status(
521 self._repo.ui.status(
522 (_("note: using %s as ancestor of %s and %s\n") %
522 (_("note: using %s as ancestor of %s and %s\n") %
523 (short(anc), short(self._node), short(n2))) +
523 (short(anc), short(self._node), short(n2))) +
524 ''.join(_(" alternatively, use --config "
524 ''.join(_(" alternatively, use --config "
525 "merge.preferancestor=%s\n") %
525 "merge.preferancestor=%s\n") %
526 short(n) for n in sorted(cahs) if n != anc))
526 short(n) for n in sorted(cahs) if n != anc))
527 return self._repo[anc]
527 return self._repo[anc]
528
528
529 def isancestorof(self, other):
529 def isancestorof(self, other):
530 """True if this changeset is an ancestor of other"""
530 """True if this changeset is an ancestor of other"""
531 return self._repo.changelog.isancestorrev(self._rev, other._rev)
531 return self._repo.changelog.isancestorrev(self._rev, other._rev)
532
532
533 def walk(self, match):
533 def walk(self, match):
534 '''Generates matching file names.'''
534 '''Generates matching file names.'''
535
535
536 # Wrap match.bad method to have message with nodeid
536 # Wrap match.bad method to have message with nodeid
537 def bad(fn, msg):
537 def bad(fn, msg):
538 # The manifest doesn't know about subrepos, so don't complain about
538 # The manifest doesn't know about subrepos, so don't complain about
539 # paths into valid subrepos.
539 # paths into valid subrepos.
540 if any(fn == s or fn.startswith(s + '/')
540 if any(fn == s or fn.startswith(s + '/')
541 for s in self.substate):
541 for s in self.substate):
542 return
542 return
543 match.bad(fn, _('no such file in rev %s') % self)
543 match.bad(fn, _('no such file in rev %s') % self)
544
544
545 m = matchmod.badmatch(self._repo.narrowmatch(match), bad)
545 m = matchmod.badmatch(self._repo.narrowmatch(match), bad)
546 return self._manifest.walk(m)
546 return self._manifest.walk(m)
547
547
548 def matches(self, match):
548 def matches(self, match):
549 return self.walk(match)
549 return self.walk(match)
550
550
551 class basefilectx(object):
551 class basefilectx(object):
552 """A filecontext object represents the common logic for its children:
552 """A filecontext object represents the common logic for its children:
553 filectx: read-only access to a filerevision that is already present
553 filectx: read-only access to a filerevision that is already present
554 in the repo,
554 in the repo,
555 workingfilectx: a filecontext that represents files from the working
555 workingfilectx: a filecontext that represents files from the working
556 directory,
556 directory,
557 memfilectx: a filecontext that represents files in-memory,
557 memfilectx: a filecontext that represents files in-memory,
558 """
558 """
559 @propertycache
559 @propertycache
560 def _filelog(self):
560 def _filelog(self):
561 return self._repo.file(self._path)
561 return self._repo.file(self._path)
562
562
563 @propertycache
563 @propertycache
564 def _changeid(self):
564 def _changeid(self):
565 if r'_changeid' in self.__dict__:
565 if r'_changeid' in self.__dict__:
566 return self._changeid
566 return self._changeid
567 elif r'_changectx' in self.__dict__:
567 elif r'_changectx' in self.__dict__:
568 return self._changectx.rev()
568 return self._changectx.rev()
569 elif r'_descendantrev' in self.__dict__:
569 elif r'_descendantrev' in self.__dict__:
570 # this file context was created from a revision with a known
570 # this file context was created from a revision with a known
571 # descendant, we can (lazily) correct for linkrev aliases
571 # descendant, we can (lazily) correct for linkrev aliases
572 return self._adjustlinkrev(self._descendantrev)
572 return self._adjustlinkrev(self._descendantrev)
573 else:
573 else:
574 return self._filelog.linkrev(self._filerev)
574 return self._filelog.linkrev(self._filerev)
575
575
576 @propertycache
576 @propertycache
577 def _filenode(self):
577 def _filenode(self):
578 if r'_fileid' in self.__dict__:
578 if r'_fileid' in self.__dict__:
579 return self._filelog.lookup(self._fileid)
579 return self._filelog.lookup(self._fileid)
580 else:
580 else:
581 return self._changectx.filenode(self._path)
581 return self._changectx.filenode(self._path)
582
582
583 @propertycache
583 @propertycache
584 def _filerev(self):
584 def _filerev(self):
585 return self._filelog.rev(self._filenode)
585 return self._filelog.rev(self._filenode)
586
586
587 @propertycache
587 @propertycache
588 def _repopath(self):
588 def _repopath(self):
589 return self._path
589 return self._path
590
590
591 def __nonzero__(self):
591 def __nonzero__(self):
592 try:
592 try:
593 self._filenode
593 self._filenode
594 return True
594 return True
595 except error.LookupError:
595 except error.LookupError:
596 # file is missing
596 # file is missing
597 return False
597 return False
598
598
599 __bool__ = __nonzero__
599 __bool__ = __nonzero__
600
600
601 def __bytes__(self):
601 def __bytes__(self):
602 try:
602 try:
603 return "%s@%s" % (self.path(), self._changectx)
603 return "%s@%s" % (self.path(), self._changectx)
604 except error.LookupError:
604 except error.LookupError:
605 return "%s@???" % self.path()
605 return "%s@???" % self.path()
606
606
607 __str__ = encoding.strmethod(__bytes__)
607 __str__ = encoding.strmethod(__bytes__)
608
608
609 def __repr__(self):
609 def __repr__(self):
610 return r"<%s %s>" % (type(self).__name__, str(self))
610 return r"<%s %s>" % (type(self).__name__, str(self))
611
611
612 def __hash__(self):
612 def __hash__(self):
613 try:
613 try:
614 return hash((self._path, self._filenode))
614 return hash((self._path, self._filenode))
615 except AttributeError:
615 except AttributeError:
616 return id(self)
616 return id(self)
617
617
618 def __eq__(self, other):
618 def __eq__(self, other):
619 try:
619 try:
620 return (type(self) == type(other) and self._path == other._path
620 return (type(self) == type(other) and self._path == other._path
621 and self._filenode == other._filenode)
621 and self._filenode == other._filenode)
622 except AttributeError:
622 except AttributeError:
623 return False
623 return False
624
624
625 def __ne__(self, other):
625 def __ne__(self, other):
626 return not (self == other)
626 return not (self == other)
627
627
628 def filerev(self):
628 def filerev(self):
629 return self._filerev
629 return self._filerev
630 def filenode(self):
630 def filenode(self):
631 return self._filenode
631 return self._filenode
632 @propertycache
632 @propertycache
633 def _flags(self):
633 def _flags(self):
634 return self._changectx.flags(self._path)
634 return self._changectx.flags(self._path)
635 def flags(self):
635 def flags(self):
636 return self._flags
636 return self._flags
637 def filelog(self):
637 def filelog(self):
638 return self._filelog
638 return self._filelog
639 def rev(self):
639 def rev(self):
640 return self._changeid
640 return self._changeid
641 def linkrev(self):
641 def linkrev(self):
642 return self._filelog.linkrev(self._filerev)
642 return self._filelog.linkrev(self._filerev)
643 def node(self):
643 def node(self):
644 return self._changectx.node()
644 return self._changectx.node()
645 def hex(self):
645 def hex(self):
646 return self._changectx.hex()
646 return self._changectx.hex()
647 def user(self):
647 def user(self):
648 return self._changectx.user()
648 return self._changectx.user()
649 def date(self):
649 def date(self):
650 return self._changectx.date()
650 return self._changectx.date()
651 def files(self):
651 def files(self):
652 return self._changectx.files()
652 return self._changectx.files()
653 def description(self):
653 def description(self):
654 return self._changectx.description()
654 return self._changectx.description()
655 def branch(self):
655 def branch(self):
656 return self._changectx.branch()
656 return self._changectx.branch()
657 def extra(self):
657 def extra(self):
658 return self._changectx.extra()
658 return self._changectx.extra()
659 def phase(self):
659 def phase(self):
660 return self._changectx.phase()
660 return self._changectx.phase()
661 def phasestr(self):
661 def phasestr(self):
662 return self._changectx.phasestr()
662 return self._changectx.phasestr()
663 def obsolete(self):
663 def obsolete(self):
664 return self._changectx.obsolete()
664 return self._changectx.obsolete()
665 def instabilities(self):
665 def instabilities(self):
666 return self._changectx.instabilities()
666 return self._changectx.instabilities()
667 def manifest(self):
667 def manifest(self):
668 return self._changectx.manifest()
668 return self._changectx.manifest()
669 def changectx(self):
669 def changectx(self):
670 return self._changectx
670 return self._changectx
671 def renamed(self):
671 def renamed(self):
672 return self._copied
672 return self._copied
673 def repo(self):
673 def repo(self):
674 return self._repo
674 return self._repo
675 def size(self):
675 def size(self):
676 return len(self.data())
676 return len(self.data())
677
677
678 def path(self):
678 def path(self):
679 return self._path
679 return self._path
680
680
681 def isbinary(self):
681 def isbinary(self):
682 try:
682 try:
683 return stringutil.binary(self.data())
683 return stringutil.binary(self.data())
684 except IOError:
684 except IOError:
685 return False
685 return False
686 def isexec(self):
686 def isexec(self):
687 return 'x' in self.flags()
687 return 'x' in self.flags()
688 def islink(self):
688 def islink(self):
689 return 'l' in self.flags()
689 return 'l' in self.flags()
690
690
691 def isabsent(self):
691 def isabsent(self):
692 """whether this filectx represents a file not in self._changectx
692 """whether this filectx represents a file not in self._changectx
693
693
694 This is mainly for merge code to detect change/delete conflicts. This is
694 This is mainly for merge code to detect change/delete conflicts. This is
695 expected to be True for all subclasses of basectx."""
695 expected to be True for all subclasses of basectx."""
696 return False
696 return False
697
697
698 _customcmp = False
698 _customcmp = False
699 def cmp(self, fctx):
699 def cmp(self, fctx):
700 """compare with other file context
700 """compare with other file context
701
701
702 returns True if different than fctx.
702 returns True if different than fctx.
703 """
703 """
704 if fctx._customcmp:
704 if fctx._customcmp:
705 return fctx.cmp(self)
705 return fctx.cmp(self)
706
706
707 if (fctx._filenode is None
707 if (fctx._filenode is None
708 and (self._repo._encodefilterpats
708 and (self._repo._encodefilterpats
709 # if file data starts with '\1\n', empty metadata block is
709 # if file data starts with '\1\n', empty metadata block is
710 # prepended, which adds 4 bytes to filelog.size().
710 # prepended, which adds 4 bytes to filelog.size().
711 or self.size() - 4 == fctx.size())
711 or self.size() - 4 == fctx.size())
712 or self.size() == fctx.size()):
712 or self.size() == fctx.size()):
713 return self._filelog.cmp(self._filenode, fctx.data())
713 return self._filelog.cmp(self._filenode, fctx.data())
714
714
715 return True
715 return True
716
716
717 def _adjustlinkrev(self, srcrev, inclusive=False):
717 def _adjustlinkrev(self, srcrev, inclusive=False):
718 """return the first ancestor of <srcrev> introducing <fnode>
718 """return the first ancestor of <srcrev> introducing <fnode>
719
719
720 If the linkrev of the file revision does not point to an ancestor of
720 If the linkrev of the file revision does not point to an ancestor of
721 srcrev, we'll walk down the ancestors until we find one introducing
721 srcrev, we'll walk down the ancestors until we find one introducing
722 this file revision.
722 this file revision.
723
723
724 :srcrev: the changeset revision we search ancestors from
724 :srcrev: the changeset revision we search ancestors from
725 :inclusive: if true, the src revision will also be checked
725 :inclusive: if true, the src revision will also be checked
726 """
726 """
727 repo = self._repo
727 repo = self._repo
728 cl = repo.unfiltered().changelog
728 cl = repo.unfiltered().changelog
729 mfl = repo.manifestlog
729 mfl = repo.manifestlog
730 # fetch the linkrev
730 # fetch the linkrev
731 lkr = self.linkrev()
731 lkr = self.linkrev()
732 if srcrev == lkr:
732 if srcrev == lkr:
733 return lkr
733 return lkr
734 # hack to reuse ancestor computation when searching for renames
734 # hack to reuse ancestor computation when searching for renames
735 memberanc = getattr(self, '_ancestrycontext', None)
735 memberanc = getattr(self, '_ancestrycontext', None)
736 iteranc = None
736 iteranc = None
737 if srcrev is None:
737 if srcrev is None:
738 # wctx case, used by workingfilectx during mergecopy
738 # wctx case, used by workingfilectx during mergecopy
739 revs = [p.rev() for p in self._repo[None].parents()]
739 revs = [p.rev() for p in self._repo[None].parents()]
740 inclusive = True # we skipped the real (revless) source
740 inclusive = True # we skipped the real (revless) source
741 else:
741 else:
742 revs = [srcrev]
742 revs = [srcrev]
743 if memberanc is None:
743 if memberanc is None:
744 memberanc = iteranc = cl.ancestors(revs, lkr,
744 memberanc = iteranc = cl.ancestors(revs, lkr,
745 inclusive=inclusive)
745 inclusive=inclusive)
746 # check if this linkrev is an ancestor of srcrev
746 # check if this linkrev is an ancestor of srcrev
747 if lkr not in memberanc:
747 if lkr not in memberanc:
748 if iteranc is None:
748 if iteranc is None:
749 iteranc = cl.ancestors(revs, lkr, inclusive=inclusive)
749 iteranc = cl.ancestors(revs, lkr, inclusive=inclusive)
750 fnode = self._filenode
750 fnode = self._filenode
751 path = self._path
751 path = self._path
752 for a in iteranc:
752 for a in iteranc:
753 ac = cl.read(a) # get changeset data (we avoid object creation)
753 ac = cl.read(a) # get changeset data (we avoid object creation)
754 if path in ac[3]: # checking the 'files' field.
754 if path in ac[3]: # checking the 'files' field.
755 # The file has been touched, check if the content is
755 # The file has been touched, check if the content is
756 # similar to the one we search for.
756 # similar to the one we search for.
757 if fnode == mfl[ac[0]].readfast().get(path):
757 if fnode == mfl[ac[0]].readfast().get(path):
758 return a
758 return a
759 # In theory, we should never get out of that loop without a result.
759 # In theory, we should never get out of that loop without a result.
760 # But if manifest uses a buggy file revision (not children of the
760 # But if manifest uses a buggy file revision (not children of the
761 # one it replaces) we could. Such a buggy situation will likely
761 # one it replaces) we could. Such a buggy situation will likely
762 # result is crash somewhere else at to some point.
762 # result is crash somewhere else at to some point.
763 return lkr
763 return lkr
764
764
765 def introrev(self):
765 def introrev(self):
766 """return the rev of the changeset which introduced this file revision
766 """return the rev of the changeset which introduced this file revision
767
767
768 This method is different from linkrev because it take into account the
768 This method is different from linkrev because it take into account the
769 changeset the filectx was created from. It ensures the returned
769 changeset the filectx was created from. It ensures the returned
770 revision is one of its ancestors. This prevents bugs from
770 revision is one of its ancestors. This prevents bugs from
771 'linkrev-shadowing' when a file revision is used by multiple
771 'linkrev-shadowing' when a file revision is used by multiple
772 changesets.
772 changesets.
773 """
773 """
774 attrs = vars(self)
774 attrs = vars(self)
775 hastoprev = (r'_changeid' in attrs or r'_changectx' in attrs)
775 hastoprev = (r'_changeid' in attrs or r'_changectx' in attrs)
776 if hastoprev:
776 if hastoprev:
777 return self._adjustlinkrev(self.rev(), inclusive=True)
777 return self._adjustlinkrev(self.rev(), inclusive=True)
778 else:
778 else:
779 return self.linkrev()
779 return self.linkrev()
780
780
781 def introfilectx(self):
781 def introfilectx(self):
782 """Return filectx having identical contents, but pointing to the
782 """Return filectx having identical contents, but pointing to the
783 changeset revision where this filectx was introduced"""
783 changeset revision where this filectx was introduced"""
784 introrev = self.introrev()
784 introrev = self.introrev()
785 if self.rev() == introrev:
785 if self.rev() == introrev:
786 return self
786 return self
787 return self.filectx(self.filenode(), changeid=introrev)
787 return self.filectx(self.filenode(), changeid=introrev)
788
788
789 def _parentfilectx(self, path, fileid, filelog):
789 def _parentfilectx(self, path, fileid, filelog):
790 """create parent filectx keeping ancestry info for _adjustlinkrev()"""
790 """create parent filectx keeping ancestry info for _adjustlinkrev()"""
791 fctx = filectx(self._repo, path, fileid=fileid, filelog=filelog)
791 fctx = filectx(self._repo, path, fileid=fileid, filelog=filelog)
792 if r'_changeid' in vars(self) or r'_changectx' in vars(self):
792 if r'_changeid' in vars(self) or r'_changectx' in vars(self):
793 # If self is associated with a changeset (probably explicitly
793 # If self is associated with a changeset (probably explicitly
794 # fed), ensure the created filectx is associated with a
794 # fed), ensure the created filectx is associated with a
795 # changeset that is an ancestor of self.changectx.
795 # changeset that is an ancestor of self.changectx.
796 # This lets us later use _adjustlinkrev to get a correct link.
796 # This lets us later use _adjustlinkrev to get a correct link.
797 fctx._descendantrev = self.rev()
797 fctx._descendantrev = self.rev()
798 fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
798 fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
799 elif r'_descendantrev' in vars(self):
799 elif r'_descendantrev' in vars(self):
800 # Otherwise propagate _descendantrev if we have one associated.
800 # Otherwise propagate _descendantrev if we have one associated.
801 fctx._descendantrev = self._descendantrev
801 fctx._descendantrev = self._descendantrev
802 fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
802 fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
803 return fctx
803 return fctx
804
804
805 def parents(self):
805 def parents(self):
806 _path = self._path
806 _path = self._path
807 fl = self._filelog
807 fl = self._filelog
808 parents = self._filelog.parents(self._filenode)
808 parents = self._filelog.parents(self._filenode)
809 pl = [(_path, node, fl) for node in parents if node != nullid]
809 pl = [(_path, node, fl) for node in parents if node != nullid]
810
810
811 r = fl.renamed(self._filenode)
811 r = fl.renamed(self._filenode)
812 if r:
812 if r:
813 # - In the simple rename case, both parent are nullid, pl is empty.
813 # - In the simple rename case, both parent are nullid, pl is empty.
814 # - In case of merge, only one of the parent is null id and should
814 # - In case of merge, only one of the parent is null id and should
815 # be replaced with the rename information. This parent is -always-
815 # be replaced with the rename information. This parent is -always-
816 # the first one.
816 # the first one.
817 #
817 #
818 # As null id have always been filtered out in the previous list
818 # As null id have always been filtered out in the previous list
819 # comprehension, inserting to 0 will always result in "replacing
819 # comprehension, inserting to 0 will always result in "replacing
820 # first nullid parent with rename information.
820 # first nullid parent with rename information.
821 pl.insert(0, (r[0], r[1], self._repo.file(r[0])))
821 pl.insert(0, (r[0], r[1], self._repo.file(r[0])))
822
822
823 return [self._parentfilectx(path, fnode, l) for path, fnode, l in pl]
823 return [self._parentfilectx(path, fnode, l) for path, fnode, l in pl]
824
824
825 def p1(self):
825 def p1(self):
826 return self.parents()[0]
826 return self.parents()[0]
827
827
828 def p2(self):
828 def p2(self):
829 p = self.parents()
829 p = self.parents()
830 if len(p) == 2:
830 if len(p) == 2:
831 return p[1]
831 return p[1]
832 return filectx(self._repo, self._path, fileid=-1, filelog=self._filelog)
832 return filectx(self._repo, self._path, fileid=-1, filelog=self._filelog)
833
833
834 def annotate(self, follow=False, skiprevs=None, diffopts=None):
834 def annotate(self, follow=False, skiprevs=None, diffopts=None):
835 """Returns a list of annotateline objects for each line in the file
835 """Returns a list of annotateline objects for each line in the file
836
836
837 - line.fctx is the filectx of the node where that line was last changed
837 - line.fctx is the filectx of the node where that line was last changed
838 - line.lineno is the line number at the first appearance in the managed
838 - line.lineno is the line number at the first appearance in the managed
839 file
839 file
840 - line.text is the data on that line (including newline character)
840 - line.text is the data on that line (including newline character)
841 """
841 """
842 getlog = util.lrucachefunc(lambda x: self._repo.file(x))
842 getlog = util.lrucachefunc(lambda x: self._repo.file(x))
843
843
844 def parents(f):
844 def parents(f):
845 # Cut _descendantrev here to mitigate the penalty of lazy linkrev
845 # Cut _descendantrev here to mitigate the penalty of lazy linkrev
846 # adjustment. Otherwise, p._adjustlinkrev() would walk changelog
846 # adjustment. Otherwise, p._adjustlinkrev() would walk changelog
847 # from the topmost introrev (= srcrev) down to p.linkrev() if it
847 # from the topmost introrev (= srcrev) down to p.linkrev() if it
848 # isn't an ancestor of the srcrev.
848 # isn't an ancestor of the srcrev.
849 f._changeid
849 f._changeid
850 pl = f.parents()
850 pl = f.parents()
851
851
852 # Don't return renamed parents if we aren't following.
852 # Don't return renamed parents if we aren't following.
853 if not follow:
853 if not follow:
854 pl = [p for p in pl if p.path() == f.path()]
854 pl = [p for p in pl if p.path() == f.path()]
855
855
856 # renamed filectx won't have a filelog yet, so set it
856 # renamed filectx won't have a filelog yet, so set it
857 # from the cache to save time
857 # from the cache to save time
858 for p in pl:
858 for p in pl:
859 if not r'_filelog' in p.__dict__:
859 if not r'_filelog' in p.__dict__:
860 p._filelog = getlog(p.path())
860 p._filelog = getlog(p.path())
861
861
862 return pl
862 return pl
863
863
864 # use linkrev to find the first changeset where self appeared
864 # use linkrev to find the first changeset where self appeared
865 base = self.introfilectx()
865 base = self.introfilectx()
866 if getattr(base, '_ancestrycontext', None) is None:
866 if getattr(base, '_ancestrycontext', None) is None:
867 cl = self._repo.changelog
867 cl = self._repo.changelog
868 if base.rev() is None:
868 if base.rev() is None:
869 # wctx is not inclusive, but works because _ancestrycontext
869 # wctx is not inclusive, but works because _ancestrycontext
870 # is used to test filelog revisions
870 # is used to test filelog revisions
871 ac = cl.ancestors([p.rev() for p in base.parents()],
871 ac = cl.ancestors([p.rev() for p in base.parents()],
872 inclusive=True)
872 inclusive=True)
873 else:
873 else:
874 ac = cl.ancestors([base.rev()], inclusive=True)
874 ac = cl.ancestors([base.rev()], inclusive=True)
875 base._ancestrycontext = ac
875 base._ancestrycontext = ac
876
876
877 return dagop.annotate(base, parents, skiprevs=skiprevs,
877 return dagop.annotate(base, parents, skiprevs=skiprevs,
878 diffopts=diffopts)
878 diffopts=diffopts)
879
879
880 def ancestors(self, followfirst=False):
880 def ancestors(self, followfirst=False):
881 visit = {}
881 visit = {}
882 c = self
882 c = self
883 if followfirst:
883 if followfirst:
884 cut = 1
884 cut = 1
885 else:
885 else:
886 cut = None
886 cut = None
887
887
888 while True:
888 while True:
889 for parent in c.parents()[:cut]:
889 for parent in c.parents()[:cut]:
890 visit[(parent.linkrev(), parent.filenode())] = parent
890 visit[(parent.linkrev(), parent.filenode())] = parent
891 if not visit:
891 if not visit:
892 break
892 break
893 c = visit.pop(max(visit))
893 c = visit.pop(max(visit))
894 yield c
894 yield c
895
895
896 def decodeddata(self):
896 def decodeddata(self):
897 """Returns `data()` after running repository decoding filters.
897 """Returns `data()` after running repository decoding filters.
898
898
899 This is often equivalent to how the data would be expressed on disk.
899 This is often equivalent to how the data would be expressed on disk.
900 """
900 """
901 return self._repo.wwritedata(self.path(), self.data())
901 return self._repo.wwritedata(self.path(), self.data())
902
902
903 class filectx(basefilectx):
903 class filectx(basefilectx):
904 """A filecontext object makes access to data related to a particular
904 """A filecontext object makes access to data related to a particular
905 filerevision convenient."""
905 filerevision convenient."""
906 def __init__(self, repo, path, changeid=None, fileid=None,
906 def __init__(self, repo, path, changeid=None, fileid=None,
907 filelog=None, changectx=None):
907 filelog=None, changectx=None):
908 """changeid must be a revision number, if specified.
908 """changeid must be a revision number, if specified.
909 fileid can be a file revision or node."""
909 fileid can be a file revision or node."""
910 self._repo = repo
910 self._repo = repo
911 self._path = path
911 self._path = path
912
912
913 assert (changeid is not None
913 assert (changeid is not None
914 or fileid is not None
914 or fileid is not None
915 or changectx is not None), \
915 or changectx is not None), \
916 ("bad args: changeid=%r, fileid=%r, changectx=%r"
916 ("bad args: changeid=%r, fileid=%r, changectx=%r"
917 % (changeid, fileid, changectx))
917 % (changeid, fileid, changectx))
918
918
919 if filelog is not None:
919 if filelog is not None:
920 self._filelog = filelog
920 self._filelog = filelog
921
921
922 if changeid is not None:
922 if changeid is not None:
923 self._changeid = changeid
923 self._changeid = changeid
924 if changectx is not None:
924 if changectx is not None:
925 self._changectx = changectx
925 self._changectx = changectx
926 if fileid is not None:
926 if fileid is not None:
927 self._fileid = fileid
927 self._fileid = fileid
928
928
929 @propertycache
929 @propertycache
930 def _changectx(self):
930 def _changectx(self):
931 try:
931 try:
932 return self._repo[self._changeid]
932 return self._repo[self._changeid]
933 except error.FilteredRepoLookupError:
933 except error.FilteredRepoLookupError:
934 # Linkrev may point to any revision in the repository. When the
934 # Linkrev may point to any revision in the repository. When the
935 # repository is filtered this may lead to `filectx` trying to build
935 # repository is filtered this may lead to `filectx` trying to build
936 # `changectx` for filtered revision. In such case we fallback to
936 # `changectx` for filtered revision. In such case we fallback to
937 # creating `changectx` on the unfiltered version of the reposition.
937 # creating `changectx` on the unfiltered version of the reposition.
938 # This fallback should not be an issue because `changectx` from
938 # This fallback should not be an issue because `changectx` from
939 # `filectx` are not used in complex operations that care about
939 # `filectx` are not used in complex operations that care about
940 # filtering.
940 # filtering.
941 #
941 #
942 # This fallback is a cheap and dirty fix that prevent several
942 # This fallback is a cheap and dirty fix that prevent several
943 # crashes. It does not ensure the behavior is correct. However the
943 # crashes. It does not ensure the behavior is correct. However the
944 # behavior was not correct before filtering either and "incorrect
944 # behavior was not correct before filtering either and "incorrect
945 # behavior" is seen as better as "crash"
945 # behavior" is seen as better as "crash"
946 #
946 #
947 # Linkrevs have several serious troubles with filtering that are
947 # Linkrevs have several serious troubles with filtering that are
948 # complicated to solve. Proper handling of the issue here should be
948 # complicated to solve. Proper handling of the issue here should be
949 # considered when solving linkrev issue are on the table.
949 # considered when solving linkrev issue are on the table.
950 return self._repo.unfiltered()[self._changeid]
950 return self._repo.unfiltered()[self._changeid]
951
951
952 def filectx(self, fileid, changeid=None):
952 def filectx(self, fileid, changeid=None):
953 '''opens an arbitrary revision of the file without
953 '''opens an arbitrary revision of the file without
954 opening a new filelog'''
954 opening a new filelog'''
955 return filectx(self._repo, self._path, fileid=fileid,
955 return filectx(self._repo, self._path, fileid=fileid,
956 filelog=self._filelog, changeid=changeid)
956 filelog=self._filelog, changeid=changeid)
957
957
958 def rawdata(self):
958 def rawdata(self):
959 return self._filelog.revision(self._filenode, raw=True)
959 return self._filelog.revision(self._filenode, raw=True)
960
960
961 def rawflags(self):
961 def rawflags(self):
962 """low-level revlog flags"""
962 """low-level revlog flags"""
963 return self._filelog.flags(self._filerev)
963 return self._filelog.flags(self._filerev)
964
964
965 def data(self):
965 def data(self):
966 try:
966 try:
967 return self._filelog.read(self._filenode)
967 return self._filelog.read(self._filenode)
968 except error.CensoredNodeError:
968 except error.CensoredNodeError:
969 if self._repo.ui.config("censor", "policy") == "ignore":
969 if self._repo.ui.config("censor", "policy") == "ignore":
970 return ""
970 return ""
971 raise error.Abort(_("censored node: %s") % short(self._filenode),
971 raise error.Abort(_("censored node: %s") % short(self._filenode),
972 hint=_("set censor.policy to ignore errors"))
972 hint=_("set censor.policy to ignore errors"))
973
973
974 def size(self):
974 def size(self):
975 return self._filelog.size(self._filerev)
975 return self._filelog.size(self._filerev)
976
976
977 @propertycache
977 @propertycache
978 def _copied(self):
978 def _copied(self):
979 """check if file was actually renamed in this changeset revision
979 """check if file was actually renamed in this changeset revision
980
980
981 If rename logged in file revision, we report copy for changeset only
981 If rename logged in file revision, we report copy for changeset only
982 if file revisions linkrev points back to the changeset in question
982 if file revisions linkrev points back to the changeset in question
983 or both changeset parents contain different file revisions.
983 or both changeset parents contain different file revisions.
984 """
984 """
985
985
986 renamed = self._filelog.renamed(self._filenode)
986 renamed = self._filelog.renamed(self._filenode)
987 if not renamed:
987 if not renamed:
988 return None
988 return None
989
989
990 if self.rev() == self.linkrev():
990 if self.rev() == self.linkrev():
991 return renamed
991 return renamed
992
992
993 name = self.path()
993 name = self.path()
994 fnode = self._filenode
994 fnode = self._filenode
995 for p in self._changectx.parents():
995 for p in self._changectx.parents():
996 try:
996 try:
997 if fnode == p.filenode(name):
997 if fnode == p.filenode(name):
998 return None
998 return None
999 except error.LookupError:
999 except error.LookupError:
1000 pass
1000 pass
1001 return renamed
1001 return renamed
1002
1002
1003 def children(self):
1003 def children(self):
1004 # hard for renames
1004 # hard for renames
1005 c = self._filelog.children(self._filenode)
1005 c = self._filelog.children(self._filenode)
1006 return [filectx(self._repo, self._path, fileid=x,
1006 return [filectx(self._repo, self._path, fileid=x,
1007 filelog=self._filelog) for x in c]
1007 filelog=self._filelog) for x in c]
1008
1008
1009 class committablectx(basectx):
1009 class committablectx(basectx):
1010 """A committablectx object provides common functionality for a context that
1010 """A committablectx object provides common functionality for a context that
1011 wants the ability to commit, e.g. workingctx or memctx."""
1011 wants the ability to commit, e.g. workingctx or memctx."""
1012 def __init__(self, repo, text="", user=None, date=None, extra=None,
1012 def __init__(self, repo, text="", user=None, date=None, extra=None,
1013 changes=None):
1013 changes=None):
1014 super(committablectx, self).__init__(repo)
1014 super(committablectx, self).__init__(repo)
1015 self._rev = None
1015 self._rev = None
1016 self._node = None
1016 self._node = None
1017 self._text = text
1017 self._text = text
1018 if date:
1018 if date:
1019 self._date = dateutil.parsedate(date)
1019 self._date = dateutil.parsedate(date)
1020 if user:
1020 if user:
1021 self._user = user
1021 self._user = user
1022 if changes:
1022 if changes:
1023 self._status = changes
1023 self._status = changes
1024
1024
1025 self._extra = {}
1025 self._extra = {}
1026 if extra:
1026 if extra:
1027 self._extra = extra.copy()
1027 self._extra = extra.copy()
1028 if 'branch' not in self._extra:
1028 if 'branch' not in self._extra:
1029 try:
1029 try:
1030 branch = encoding.fromlocal(self._repo.dirstate.branch())
1030 branch = encoding.fromlocal(self._repo.dirstate.branch())
1031 except UnicodeDecodeError:
1031 except UnicodeDecodeError:
1032 raise error.Abort(_('branch name not in UTF-8!'))
1032 raise error.Abort(_('branch name not in UTF-8!'))
1033 self._extra['branch'] = branch
1033 self._extra['branch'] = branch
1034 if self._extra['branch'] == '':
1034 if self._extra['branch'] == '':
1035 self._extra['branch'] = 'default'
1035 self._extra['branch'] = 'default'
1036
1036
1037 def __bytes__(self):
1037 def __bytes__(self):
1038 return bytes(self._parents[0]) + "+"
1038 return bytes(self._parents[0]) + "+"
1039
1039
1040 __str__ = encoding.strmethod(__bytes__)
1040 __str__ = encoding.strmethod(__bytes__)
1041
1041
1042 def __nonzero__(self):
1042 def __nonzero__(self):
1043 return True
1043 return True
1044
1044
1045 __bool__ = __nonzero__
1045 __bool__ = __nonzero__
1046
1046
1047 def _buildflagfunc(self):
1047 def _buildflagfunc(self):
1048 # Create a fallback function for getting file flags when the
1048 # Create a fallback function for getting file flags when the
1049 # filesystem doesn't support them
1049 # filesystem doesn't support them
1050
1050
1051 copiesget = self._repo.dirstate.copies().get
1051 copiesget = self._repo.dirstate.copies().get
1052 parents = self.parents()
1052 parents = self.parents()
1053 if len(parents) < 2:
1053 if len(parents) < 2:
1054 # when we have one parent, it's easy: copy from parent
1054 # when we have one parent, it's easy: copy from parent
1055 man = parents[0].manifest()
1055 man = parents[0].manifest()
1056 def func(f):
1056 def func(f):
1057 f = copiesget(f, f)
1057 f = copiesget(f, f)
1058 return man.flags(f)
1058 return man.flags(f)
1059 else:
1059 else:
1060 # merges are tricky: we try to reconstruct the unstored
1060 # merges are tricky: we try to reconstruct the unstored
1061 # result from the merge (issue1802)
1061 # result from the merge (issue1802)
1062 p1, p2 = parents
1062 p1, p2 = parents
1063 pa = p1.ancestor(p2)
1063 pa = p1.ancestor(p2)
1064 m1, m2, ma = p1.manifest(), p2.manifest(), pa.manifest()
1064 m1, m2, ma = p1.manifest(), p2.manifest(), pa.manifest()
1065
1065
1066 def func(f):
1066 def func(f):
1067 f = copiesget(f, f) # may be wrong for merges with copies
1067 f = copiesget(f, f) # may be wrong for merges with copies
1068 fl1, fl2, fla = m1.flags(f), m2.flags(f), ma.flags(f)
1068 fl1, fl2, fla = m1.flags(f), m2.flags(f), ma.flags(f)
1069 if fl1 == fl2:
1069 if fl1 == fl2:
1070 return fl1
1070 return fl1
1071 if fl1 == fla:
1071 if fl1 == fla:
1072 return fl2
1072 return fl2
1073 if fl2 == fla:
1073 if fl2 == fla:
1074 return fl1
1074 return fl1
1075 return '' # punt for conflicts
1075 return '' # punt for conflicts
1076
1076
1077 return func
1077 return func
1078
1078
1079 @propertycache
1079 @propertycache
1080 def _flagfunc(self):
1080 def _flagfunc(self):
1081 return self._repo.dirstate.flagfunc(self._buildflagfunc)
1081 return self._repo.dirstate.flagfunc(self._buildflagfunc)
1082
1082
1083 @propertycache
1083 @propertycache
1084 def _status(self):
1084 def _status(self):
1085 return self._repo.status()
1085 return self._repo.status()
1086
1086
1087 @propertycache
1087 @propertycache
1088 def _user(self):
1088 def _user(self):
1089 return self._repo.ui.username()
1089 return self._repo.ui.username()
1090
1090
1091 @propertycache
1091 @propertycache
1092 def _date(self):
1092 def _date(self):
1093 ui = self._repo.ui
1093 ui = self._repo.ui
1094 date = ui.configdate('devel', 'default-date')
1094 date = ui.configdate('devel', 'default-date')
1095 if date is None:
1095 if date is None:
1096 date = dateutil.makedate()
1096 date = dateutil.makedate()
1097 return date
1097 return date
1098
1098
1099 def subrev(self, subpath):
1099 def subrev(self, subpath):
1100 return None
1100 return None
1101
1101
1102 def manifestnode(self):
1102 def manifestnode(self):
1103 return None
1103 return None
1104 def user(self):
1104 def user(self):
1105 return self._user or self._repo.ui.username()
1105 return self._user or self._repo.ui.username()
1106 def date(self):
1106 def date(self):
1107 return self._date
1107 return self._date
1108 def description(self):
1108 def description(self):
1109 return self._text
1109 return self._text
1110 def files(self):
1110 def files(self):
1111 return sorted(self._status.modified + self._status.added +
1111 return sorted(self._status.modified + self._status.added +
1112 self._status.removed)
1112 self._status.removed)
1113
1113
1114 def modified(self):
1114 def modified(self):
1115 return self._status.modified
1115 return self._status.modified
1116 def added(self):
1116 def added(self):
1117 return self._status.added
1117 return self._status.added
1118 def removed(self):
1118 def removed(self):
1119 return self._status.removed
1119 return self._status.removed
1120 def deleted(self):
1120 def deleted(self):
1121 return self._status.deleted
1121 return self._status.deleted
1122 def branch(self):
1122 def branch(self):
1123 return encoding.tolocal(self._extra['branch'])
1123 return encoding.tolocal(self._extra['branch'])
1124 def closesbranch(self):
1124 def closesbranch(self):
1125 return 'close' in self._extra
1125 return 'close' in self._extra
1126 def extra(self):
1126 def extra(self):
1127 return self._extra
1127 return self._extra
1128
1128
1129 def isinmemory(self):
1129 def isinmemory(self):
1130 return False
1130 return False
1131
1131
1132 def tags(self):
1132 def tags(self):
1133 return []
1133 return []
1134
1134
1135 def bookmarks(self):
1135 def bookmarks(self):
1136 b = []
1136 b = []
1137 for p in self.parents():
1137 for p in self.parents():
1138 b.extend(p.bookmarks())
1138 b.extend(p.bookmarks())
1139 return b
1139 return b
1140
1140
1141 def phase(self):
1141 def phase(self):
1142 phase = phases.draft # default phase to draft
1142 phase = phases.draft # default phase to draft
1143 for p in self.parents():
1143 for p in self.parents():
1144 phase = max(phase, p.phase())
1144 phase = max(phase, p.phase())
1145 return phase
1145 return phase
1146
1146
1147 def hidden(self):
1147 def hidden(self):
1148 return False
1148 return False
1149
1149
1150 def children(self):
1150 def children(self):
1151 return []
1151 return []
1152
1152
1153 def flags(self, path):
1153 def flags(self, path):
1154 if r'_manifest' in self.__dict__:
1154 if r'_manifest' in self.__dict__:
1155 try:
1155 try:
1156 return self._manifest.flags(path)
1156 return self._manifest.flags(path)
1157 except KeyError:
1157 except KeyError:
1158 return ''
1158 return ''
1159
1159
1160 try:
1160 try:
1161 return self._flagfunc(path)
1161 return self._flagfunc(path)
1162 except OSError:
1162 except OSError:
1163 return ''
1163 return ''
1164
1164
1165 def ancestor(self, c2):
1165 def ancestor(self, c2):
1166 """return the "best" ancestor context of self and c2"""
1166 """return the "best" ancestor context of self and c2"""
1167 return self._parents[0].ancestor(c2) # punt on two parents for now
1167 return self._parents[0].ancestor(c2) # punt on two parents for now
1168
1168
1169 def walk(self, match):
1169 def walk(self, match):
1170 '''Generates matching file names.'''
1170 '''Generates matching file names.'''
1171 return sorted(self._repo.dirstate.walk(self._repo.narrowmatch(match),
1171 return sorted(self._repo.dirstate.walk(self._repo.narrowmatch(match),
1172 subrepos=sorted(self.substate),
1172 subrepos=sorted(self.substate),
1173 unknown=True, ignored=False))
1173 unknown=True, ignored=False))
1174
1174
1175 def matches(self, match):
1175 def matches(self, match):
1176 match = self._repo.narrowmatch(match)
1176 match = self._repo.narrowmatch(match)
1177 ds = self._repo.dirstate
1177 ds = self._repo.dirstate
1178 return sorted(f for f in ds.matches(match) if ds[f] != 'r')
1178 return sorted(f for f in ds.matches(match) if ds[f] != 'r')
1179
1179
1180 def ancestors(self):
1180 def ancestors(self):
1181 for p in self._parents:
1181 for p in self._parents:
1182 yield p
1182 yield p
1183 for a in self._repo.changelog.ancestors(
1183 for a in self._repo.changelog.ancestors(
1184 [p.rev() for p in self._parents]):
1184 [p.rev() for p in self._parents]):
1185 yield self._repo[a]
1185 yield self._repo[a]
1186
1186
1187 def markcommitted(self, node):
1187 def markcommitted(self, node):
1188 """Perform post-commit cleanup necessary after committing this ctx
1188 """Perform post-commit cleanup necessary after committing this ctx
1189
1189
1190 Specifically, this updates backing stores this working context
1190 Specifically, this updates backing stores this working context
1191 wraps to reflect the fact that the changes reflected by this
1191 wraps to reflect the fact that the changes reflected by this
1192 workingctx have been committed. For example, it marks
1192 workingctx have been committed. For example, it marks
1193 modified and added files as normal in the dirstate.
1193 modified and added files as normal in the dirstate.
1194
1194
1195 """
1195 """
1196
1196
1197 with self._repo.dirstate.parentchange():
1197 with self._repo.dirstate.parentchange():
1198 for f in self.modified() + self.added():
1198 for f in self.modified() + self.added():
1199 self._repo.dirstate.normal(f)
1199 self._repo.dirstate.normal(f)
1200 for f in self.removed():
1200 for f in self.removed():
1201 self._repo.dirstate.drop(f)
1201 self._repo.dirstate.drop(f)
1202 self._repo.dirstate.setparents(node)
1202 self._repo.dirstate.setparents(node)
1203
1203
1204 # write changes out explicitly, because nesting wlock at
1204 # write changes out explicitly, because nesting wlock at
1205 # runtime may prevent 'wlock.release()' in 'repo.commit()'
1205 # runtime may prevent 'wlock.release()' in 'repo.commit()'
1206 # from immediately doing so for subsequent changing files
1206 # from immediately doing so for subsequent changing files
1207 self._repo.dirstate.write(self._repo.currenttransaction())
1207 self._repo.dirstate.write(self._repo.currenttransaction())
1208
1208
1209 def dirty(self, missing=False, merge=True, branch=True):
1209 def dirty(self, missing=False, merge=True, branch=True):
1210 return False
1210 return False
1211
1211
1212 class workingctx(committablectx):
1212 class workingctx(committablectx):
1213 """A workingctx object makes access to data related to
1213 """A workingctx object makes access to data related to
1214 the current working directory convenient.
1214 the current working directory convenient.
1215 date - any valid date string or (unixtime, offset), or None.
1215 date - any valid date string or (unixtime, offset), or None.
1216 user - username string, or None.
1216 user - username string, or None.
1217 extra - a dictionary of extra values, or None.
1217 extra - a dictionary of extra values, or None.
1218 changes - a list of file lists as returned by localrepo.status()
1218 changes - a list of file lists as returned by localrepo.status()
1219 or None to use the repository status.
1219 or None to use the repository status.
1220 """
1220 """
1221 def __init__(self, repo, text="", user=None, date=None, extra=None,
1221 def __init__(self, repo, text="", user=None, date=None, extra=None,
1222 changes=None):
1222 changes=None):
1223 super(workingctx, self).__init__(repo, text, user, date, extra, changes)
1223 super(workingctx, self).__init__(repo, text, user, date, extra, changes)
1224
1224
1225 def __iter__(self):
1225 def __iter__(self):
1226 d = self._repo.dirstate
1226 d = self._repo.dirstate
1227 for f in d:
1227 for f in d:
1228 if d[f] != 'r':
1228 if d[f] != 'r':
1229 yield f
1229 yield f
1230
1230
1231 def __contains__(self, key):
1231 def __contains__(self, key):
1232 return self._repo.dirstate[key] not in "?r"
1232 return self._repo.dirstate[key] not in "?r"
1233
1233
1234 def hex(self):
1234 def hex(self):
1235 return hex(wdirid)
1235 return hex(wdirid)
1236
1236
1237 @propertycache
1237 @propertycache
1238 def _parents(self):
1238 def _parents(self):
1239 p = self._repo.dirstate.parents()
1239 p = self._repo.dirstate.parents()
1240 if p[1] == nullid:
1240 if p[1] == nullid:
1241 p = p[:-1]
1241 p = p[:-1]
1242 # use unfiltered repo to delay/avoid loading obsmarkers
1242 # use unfiltered repo to delay/avoid loading obsmarkers
1243 unfi = self._repo.unfiltered()
1243 unfi = self._repo.unfiltered()
1244 return [changectx(self._repo, unfi.changelog.rev(n), n) for n in p]
1244 return [changectx(self._repo, unfi.changelog.rev(n), n) for n in p]
1245
1245
1246 def _fileinfo(self, path):
1246 def _fileinfo(self, path):
1247 # populate __dict__['_manifest'] as workingctx has no _manifestdelta
1247 # populate __dict__['_manifest'] as workingctx has no _manifestdelta
1248 self._manifest
1248 self._manifest
1249 return super(workingctx, self)._fileinfo(path)
1249 return super(workingctx, self)._fileinfo(path)
1250
1250
1251 def filectx(self, path, filelog=None):
1251 def filectx(self, path, filelog=None):
1252 """get a file context from the working directory"""
1252 """get a file context from the working directory"""
1253 return workingfilectx(self._repo, path, workingctx=self,
1253 return workingfilectx(self._repo, path, workingctx=self,
1254 filelog=filelog)
1254 filelog=filelog)
1255
1255
1256 def dirty(self, missing=False, merge=True, branch=True):
1256 def dirty(self, missing=False, merge=True, branch=True):
1257 "check whether a working directory is modified"
1257 "check whether a working directory is modified"
1258 # check subrepos first
1258 # check subrepos first
1259 for s in sorted(self.substate):
1259 for s in sorted(self.substate):
1260 if self.sub(s).dirty(missing=missing):
1260 if self.sub(s).dirty(missing=missing):
1261 return True
1261 return True
1262 # check current working dir
1262 # check current working dir
1263 return ((merge and self.p2()) or
1263 return ((merge and self.p2()) or
1264 (branch and self.branch() != self.p1().branch()) or
1264 (branch and self.branch() != self.p1().branch()) or
1265 self.modified() or self.added() or self.removed() or
1265 self.modified() or self.added() or self.removed() or
1266 (missing and self.deleted()))
1266 (missing and self.deleted()))
1267
1267
1268 def add(self, list, prefix=""):
1268 def add(self, list, prefix=""):
1269 with self._repo.wlock():
1269 with self._repo.wlock():
1270 ui, ds = self._repo.ui, self._repo.dirstate
1270 ui, ds = self._repo.ui, self._repo.dirstate
1271 uipath = lambda f: ds.pathto(pathutil.join(prefix, f))
1271 uipath = lambda f: ds.pathto(pathutil.join(prefix, f))
1272 rejected = []
1272 rejected = []
1273 lstat = self._repo.wvfs.lstat
1273 lstat = self._repo.wvfs.lstat
1274 for f in list:
1274 for f in list:
1275 # ds.pathto() returns an absolute file when this is invoked from
1275 # ds.pathto() returns an absolute file when this is invoked from
1276 # the keyword extension. That gets flagged as non-portable on
1276 # the keyword extension. That gets flagged as non-portable on
1277 # Windows, since it contains the drive letter and colon.
1277 # Windows, since it contains the drive letter and colon.
1278 scmutil.checkportable(ui, os.path.join(prefix, f))
1278 scmutil.checkportable(ui, os.path.join(prefix, f))
1279 try:
1279 try:
1280 st = lstat(f)
1280 st = lstat(f)
1281 except OSError:
1281 except OSError:
1282 ui.warn(_("%s does not exist!\n") % uipath(f))
1282 ui.warn(_("%s does not exist!\n") % uipath(f))
1283 rejected.append(f)
1283 rejected.append(f)
1284 continue
1284 continue
1285 limit = ui.configbytes('ui', 'large-file-limit')
1285 limit = ui.configbytes('ui', 'large-file-limit')
1286 if limit != 0 and st.st_size > limit:
1286 if limit != 0 and st.st_size > limit:
1287 ui.warn(_("%s: up to %d MB of RAM may be required "
1287 ui.warn(_("%s: up to %d MB of RAM may be required "
1288 "to manage this file\n"
1288 "to manage this file\n"
1289 "(use 'hg revert %s' to cancel the "
1289 "(use 'hg revert %s' to cancel the "
1290 "pending addition)\n")
1290 "pending addition)\n")
1291 % (f, 3 * st.st_size // 1000000, uipath(f)))
1291 % (f, 3 * st.st_size // 1000000, uipath(f)))
1292 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
1292 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
1293 ui.warn(_("%s not added: only files and symlinks "
1293 ui.warn(_("%s not added: only files and symlinks "
1294 "supported currently\n") % uipath(f))
1294 "supported currently\n") % uipath(f))
1295 rejected.append(f)
1295 rejected.append(f)
1296 elif ds[f] in 'amn':
1296 elif ds[f] in 'amn':
1297 ui.warn(_("%s already tracked!\n") % uipath(f))
1297 ui.warn(_("%s already tracked!\n") % uipath(f))
1298 elif ds[f] == 'r':
1298 elif ds[f] == 'r':
1299 ds.normallookup(f)
1299 ds.normallookup(f)
1300 else:
1300 else:
1301 ds.add(f)
1301 ds.add(f)
1302 return rejected
1302 return rejected
1303
1303
1304 def forget(self, files, prefix=""):
1304 def forget(self, files, prefix=""):
1305 with self._repo.wlock():
1305 with self._repo.wlock():
1306 ds = self._repo.dirstate
1306 ds = self._repo.dirstate
1307 uipath = lambda f: ds.pathto(pathutil.join(prefix, f))
1307 uipath = lambda f: ds.pathto(pathutil.join(prefix, f))
1308 rejected = []
1308 rejected = []
1309 for f in files:
1309 for f in files:
1310 if f not in self._repo.dirstate:
1310 if f not in self._repo.dirstate:
1311 self._repo.ui.warn(_("%s not tracked!\n") % uipath(f))
1311 self._repo.ui.warn(_("%s not tracked!\n") % uipath(f))
1312 rejected.append(f)
1312 rejected.append(f)
1313 elif self._repo.dirstate[f] != 'a':
1313 elif self._repo.dirstate[f] != 'a':
1314 self._repo.dirstate.remove(f)
1314 self._repo.dirstate.remove(f)
1315 else:
1315 else:
1316 self._repo.dirstate.drop(f)
1316 self._repo.dirstate.drop(f)
1317 return rejected
1317 return rejected
1318
1318
1319 def undelete(self, list):
1319 def undelete(self, list):
1320 pctxs = self.parents()
1320 pctxs = self.parents()
1321 with self._repo.wlock():
1321 with self._repo.wlock():
1322 ds = self._repo.dirstate
1322 ds = self._repo.dirstate
1323 for f in list:
1323 for f in list:
1324 if self._repo.dirstate[f] != 'r':
1324 if self._repo.dirstate[f] != 'r':
1325 self._repo.ui.warn(_("%s not removed!\n") % ds.pathto(f))
1325 self._repo.ui.warn(_("%s not removed!\n") % ds.pathto(f))
1326 else:
1326 else:
1327 fctx = f in pctxs[0] and pctxs[0][f] or pctxs[1][f]
1327 fctx = f in pctxs[0] and pctxs[0][f] or pctxs[1][f]
1328 t = fctx.data()
1328 t = fctx.data()
1329 self._repo.wwrite(f, t, fctx.flags())
1329 self._repo.wwrite(f, t, fctx.flags())
1330 self._repo.dirstate.normal(f)
1330 self._repo.dirstate.normal(f)
1331
1331
1332 def copy(self, source, dest):
1332 def copy(self, source, dest):
1333 try:
1333 try:
1334 st = self._repo.wvfs.lstat(dest)
1334 st = self._repo.wvfs.lstat(dest)
1335 except OSError as err:
1335 except OSError as err:
1336 if err.errno != errno.ENOENT:
1336 if err.errno != errno.ENOENT:
1337 raise
1337 raise
1338 self._repo.ui.warn(_("%s does not exist!\n")
1338 self._repo.ui.warn(_("%s does not exist!\n")
1339 % self._repo.dirstate.pathto(dest))
1339 % self._repo.dirstate.pathto(dest))
1340 return
1340 return
1341 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
1341 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
1342 self._repo.ui.warn(_("copy failed: %s is not a file or a "
1342 self._repo.ui.warn(_("copy failed: %s is not a file or a "
1343 "symbolic link\n")
1343 "symbolic link\n")
1344 % self._repo.dirstate.pathto(dest))
1344 % self._repo.dirstate.pathto(dest))
1345 else:
1345 else:
1346 with self._repo.wlock():
1346 with self._repo.wlock():
1347 if self._repo.dirstate[dest] in '?':
1347 if self._repo.dirstate[dest] in '?':
1348 self._repo.dirstate.add(dest)
1348 self._repo.dirstate.add(dest)
1349 elif self._repo.dirstate[dest] in 'r':
1349 elif self._repo.dirstate[dest] in 'r':
1350 self._repo.dirstate.normallookup(dest)
1350 self._repo.dirstate.normallookup(dest)
1351 self._repo.dirstate.copy(source, dest)
1351 self._repo.dirstate.copy(source, dest)
1352
1352
1353 def match(self, pats=None, include=None, exclude=None, default='glob',
1353 def match(self, pats=None, include=None, exclude=None, default='glob',
1354 listsubrepos=False, badfn=None):
1354 listsubrepos=False, badfn=None):
1355 r = self._repo
1355 r = self._repo
1356
1356
1357 # Only a case insensitive filesystem needs magic to translate user input
1357 # Only a case insensitive filesystem needs magic to translate user input
1358 # to actual case in the filesystem.
1358 # to actual case in the filesystem.
1359 icasefs = not util.fscasesensitive(r.root)
1359 icasefs = not util.fscasesensitive(r.root)
1360 return matchmod.match(r.root, r.getcwd(), pats, include, exclude,
1360 return matchmod.match(r.root, r.getcwd(), pats, include, exclude,
1361 default, auditor=r.auditor, ctx=self,
1361 default, auditor=r.auditor, ctx=self,
1362 listsubrepos=listsubrepos, badfn=badfn,
1362 listsubrepos=listsubrepos, badfn=badfn,
1363 icasefs=icasefs)
1363 icasefs=icasefs)
1364
1364
1365 def _filtersuspectsymlink(self, files):
1365 def _filtersuspectsymlink(self, files):
1366 if not files or self._repo.dirstate._checklink:
1366 if not files or self._repo.dirstate._checklink:
1367 return files
1367 return files
1368
1368
1369 # Symlink placeholders may get non-symlink-like contents
1369 # Symlink placeholders may get non-symlink-like contents
1370 # via user error or dereferencing by NFS or Samba servers,
1370 # via user error or dereferencing by NFS or Samba servers,
1371 # so we filter out any placeholders that don't look like a
1371 # so we filter out any placeholders that don't look like a
1372 # symlink
1372 # symlink
1373 sane = []
1373 sane = []
1374 for f in files:
1374 for f in files:
1375 if self.flags(f) == 'l':
1375 if self.flags(f) == 'l':
1376 d = self[f].data()
1376 d = self[f].data()
1377 if (d == '' or len(d) >= 1024 or '\n' in d
1377 if (d == '' or len(d) >= 1024 or '\n' in d
1378 or stringutil.binary(d)):
1378 or stringutil.binary(d)):
1379 self._repo.ui.debug('ignoring suspect symlink placeholder'
1379 self._repo.ui.debug('ignoring suspect symlink placeholder'
1380 ' "%s"\n' % f)
1380 ' "%s"\n' % f)
1381 continue
1381 continue
1382 sane.append(f)
1382 sane.append(f)
1383 return sane
1383 return sane
1384
1384
1385 def _checklookup(self, files):
1385 def _checklookup(self, files):
1386 # check for any possibly clean files
1386 # check for any possibly clean files
1387 if not files:
1387 if not files:
1388 return [], [], []
1388 return [], [], []
1389
1389
1390 modified = []
1390 modified = []
1391 deleted = []
1391 deleted = []
1392 fixup = []
1392 fixup = []
1393 pctx = self._parents[0]
1393 pctx = self._parents[0]
1394 # do a full compare of any files that might have changed
1394 # do a full compare of any files that might have changed
1395 for f in sorted(files):
1395 for f in sorted(files):
1396 try:
1396 try:
1397 # This will return True for a file that got replaced by a
1397 # This will return True for a file that got replaced by a
1398 # directory in the interim, but fixing that is pretty hard.
1398 # directory in the interim, but fixing that is pretty hard.
1399 if (f not in pctx or self.flags(f) != pctx.flags(f)
1399 if (f not in pctx or self.flags(f) != pctx.flags(f)
1400 or pctx[f].cmp(self[f])):
1400 or pctx[f].cmp(self[f])):
1401 modified.append(f)
1401 modified.append(f)
1402 else:
1402 else:
1403 fixup.append(f)
1403 fixup.append(f)
1404 except (IOError, OSError):
1404 except (IOError, OSError):
1405 # A file become inaccessible in between? Mark it as deleted,
1405 # A file become inaccessible in between? Mark it as deleted,
1406 # matching dirstate behavior (issue5584).
1406 # matching dirstate behavior (issue5584).
1407 # The dirstate has more complex behavior around whether a
1407 # The dirstate has more complex behavior around whether a
1408 # missing file matches a directory, etc, but we don't need to
1408 # missing file matches a directory, etc, but we don't need to
1409 # bother with that: if f has made it to this point, we're sure
1409 # bother with that: if f has made it to this point, we're sure
1410 # it's in the dirstate.
1410 # it's in the dirstate.
1411 deleted.append(f)
1411 deleted.append(f)
1412
1412
1413 return modified, deleted, fixup
1413 return modified, deleted, fixup
1414
1414
1415 def _poststatusfixup(self, status, fixup):
1415 def _poststatusfixup(self, status, fixup):
1416 """update dirstate for files that are actually clean"""
1416 """update dirstate for files that are actually clean"""
1417 poststatus = self._repo.postdsstatus()
1417 poststatus = self._repo.postdsstatus()
1418 if fixup or poststatus:
1418 if fixup or poststatus:
1419 try:
1419 try:
1420 oldid = self._repo.dirstate.identity()
1420 oldid = self._repo.dirstate.identity()
1421
1421
1422 # updating the dirstate is optional
1422 # updating the dirstate is optional
1423 # so we don't wait on the lock
1423 # so we don't wait on the lock
1424 # wlock can invalidate the dirstate, so cache normal _after_
1424 # wlock can invalidate the dirstate, so cache normal _after_
1425 # taking the lock
1425 # taking the lock
1426 with self._repo.wlock(False):
1426 with self._repo.wlock(False):
1427 if self._repo.dirstate.identity() == oldid:
1427 if self._repo.dirstate.identity() == oldid:
1428 if fixup:
1428 if fixup:
1429 normal = self._repo.dirstate.normal
1429 normal = self._repo.dirstate.normal
1430 for f in fixup:
1430 for f in fixup:
1431 normal(f)
1431 normal(f)
1432 # write changes out explicitly, because nesting
1432 # write changes out explicitly, because nesting
1433 # wlock at runtime may prevent 'wlock.release()'
1433 # wlock at runtime may prevent 'wlock.release()'
1434 # after this block from doing so for subsequent
1434 # after this block from doing so for subsequent
1435 # changing files
1435 # changing files
1436 tr = self._repo.currenttransaction()
1436 tr = self._repo.currenttransaction()
1437 self._repo.dirstate.write(tr)
1437 self._repo.dirstate.write(tr)
1438
1438
1439 if poststatus:
1439 if poststatus:
1440 for ps in poststatus:
1440 for ps in poststatus:
1441 ps(self, status)
1441 ps(self, status)
1442 else:
1442 else:
1443 # in this case, writing changes out breaks
1443 # in this case, writing changes out breaks
1444 # consistency, because .hg/dirstate was
1444 # consistency, because .hg/dirstate was
1445 # already changed simultaneously after last
1445 # already changed simultaneously after last
1446 # caching (see also issue5584 for detail)
1446 # caching (see also issue5584 for detail)
1447 self._repo.ui.debug('skip updating dirstate: '
1447 self._repo.ui.debug('skip updating dirstate: '
1448 'identity mismatch\n')
1448 'identity mismatch\n')
1449 except error.LockError:
1449 except error.LockError:
1450 pass
1450 pass
1451 finally:
1451 finally:
1452 # Even if the wlock couldn't be grabbed, clear out the list.
1452 # Even if the wlock couldn't be grabbed, clear out the list.
1453 self._repo.clearpostdsstatus()
1453 self._repo.clearpostdsstatus()
1454
1454
1455 def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
1455 def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
1456 '''Gets the status from the dirstate -- internal use only.'''
1456 '''Gets the status from the dirstate -- internal use only.'''
1457 subrepos = []
1457 subrepos = []
1458 if '.hgsub' in self:
1458 if '.hgsub' in self:
1459 subrepos = sorted(self.substate)
1459 subrepos = sorted(self.substate)
1460 cmp, s = self._repo.dirstate.status(match, subrepos, ignored=ignored,
1460 cmp, s = self._repo.dirstate.status(match, subrepos, ignored=ignored,
1461 clean=clean, unknown=unknown)
1461 clean=clean, unknown=unknown)
1462
1462
1463 # check for any possibly clean files
1463 # check for any possibly clean files
1464 fixup = []
1464 fixup = []
1465 if cmp:
1465 if cmp:
1466 modified2, deleted2, fixup = self._checklookup(cmp)
1466 modified2, deleted2, fixup = self._checklookup(cmp)
1467 s.modified.extend(modified2)
1467 s.modified.extend(modified2)
1468 s.deleted.extend(deleted2)
1468 s.deleted.extend(deleted2)
1469
1469
1470 if fixup and clean:
1470 if fixup and clean:
1471 s.clean.extend(fixup)
1471 s.clean.extend(fixup)
1472
1472
1473 self._poststatusfixup(s, fixup)
1473 self._poststatusfixup(s, fixup)
1474
1474
1475 if match.always():
1475 if match.always():
1476 # cache for performance
1476 # cache for performance
1477 if s.unknown or s.ignored or s.clean:
1477 if s.unknown or s.ignored or s.clean:
1478 # "_status" is cached with list*=False in the normal route
1478 # "_status" is cached with list*=False in the normal route
1479 self._status = scmutil.status(s.modified, s.added, s.removed,
1479 self._status = scmutil.status(s.modified, s.added, s.removed,
1480 s.deleted, [], [], [])
1480 s.deleted, [], [], [])
1481 else:
1481 else:
1482 self._status = s
1482 self._status = s
1483
1483
1484 return s
1484 return s
1485
1485
1486 @propertycache
1486 @propertycache
1487 def _manifest(self):
1487 def _manifest(self):
1488 """generate a manifest corresponding to the values in self._status
1488 """generate a manifest corresponding to the values in self._status
1489
1489
1490 This reuse the file nodeid from parent, but we use special node
1490 This reuse the file nodeid from parent, but we use special node
1491 identifiers for added and modified files. This is used by manifests
1491 identifiers for added and modified files. This is used by manifests
1492 merge to see that files are different and by update logic to avoid
1492 merge to see that files are different and by update logic to avoid
1493 deleting newly added files.
1493 deleting newly added files.
1494 """
1494 """
1495 return self._buildstatusmanifest(self._status)
1495 return self._buildstatusmanifest(self._status)
1496
1496
1497 def _buildstatusmanifest(self, status):
1497 def _buildstatusmanifest(self, status):
1498 """Builds a manifest that includes the given status results."""
1498 """Builds a manifest that includes the given status results."""
1499 parents = self.parents()
1499 parents = self.parents()
1500
1500
1501 man = parents[0].manifest().copy()
1501 man = parents[0].manifest().copy()
1502
1502
1503 ff = self._flagfunc
1503 ff = self._flagfunc
1504 for i, l in ((addednodeid, status.added),
1504 for i, l in ((addednodeid, status.added),
1505 (modifiednodeid, status.modified)):
1505 (modifiednodeid, status.modified)):
1506 for f in l:
1506 for f in l:
1507 man[f] = i
1507 man[f] = i
1508 try:
1508 try:
1509 man.setflag(f, ff(f))
1509 man.setflag(f, ff(f))
1510 except OSError:
1510 except OSError:
1511 pass
1511 pass
1512
1512
1513 for f in status.deleted + status.removed:
1513 for f in status.deleted + status.removed:
1514 if f in man:
1514 if f in man:
1515 del man[f]
1515 del man[f]
1516
1516
1517 return man
1517 return man
1518
1518
1519 def _buildstatus(self, other, s, match, listignored, listclean,
1519 def _buildstatus(self, other, s, match, listignored, listclean,
1520 listunknown):
1520 listunknown):
1521 """build a status with respect to another context
1521 """build a status with respect to another context
1522
1522
1523 This includes logic for maintaining the fast path of status when
1523 This includes logic for maintaining the fast path of status when
1524 comparing the working directory against its parent, which is to skip
1524 comparing the working directory against its parent, which is to skip
1525 building a new manifest if self (working directory) is not comparing
1525 building a new manifest if self (working directory) is not comparing
1526 against its parent (repo['.']).
1526 against its parent (repo['.']).
1527 """
1527 """
1528 s = self._dirstatestatus(match, listignored, listclean, listunknown)
1528 s = self._dirstatestatus(match, listignored, listclean, listunknown)
1529 # Filter out symlinks that, in the case of FAT32 and NTFS filesystems,
1529 # Filter out symlinks that, in the case of FAT32 and NTFS filesystems,
1530 # might have accidentally ended up with the entire contents of the file
1530 # might have accidentally ended up with the entire contents of the file
1531 # they are supposed to be linking to.
1531 # they are supposed to be linking to.
1532 s.modified[:] = self._filtersuspectsymlink(s.modified)
1532 s.modified[:] = self._filtersuspectsymlink(s.modified)
1533 if other != self._repo['.']:
1533 if other != self._repo['.']:
1534 s = super(workingctx, self)._buildstatus(other, s, match,
1534 s = super(workingctx, self)._buildstatus(other, s, match,
1535 listignored, listclean,
1535 listignored, listclean,
1536 listunknown)
1536 listunknown)
1537 return s
1537 return s
1538
1538
1539 def _matchstatus(self, other, match):
1539 def _matchstatus(self, other, match):
1540 """override the match method with a filter for directory patterns
1540 """override the match method with a filter for directory patterns
1541
1541
1542 We use inheritance to customize the match.bad method only in cases of
1542 We use inheritance to customize the match.bad method only in cases of
1543 workingctx since it belongs only to the working directory when
1543 workingctx since it belongs only to the working directory when
1544 comparing against the parent changeset.
1544 comparing against the parent changeset.
1545
1545
1546 If we aren't comparing against the working directory's parent, then we
1546 If we aren't comparing against the working directory's parent, then we
1547 just use the default match object sent to us.
1547 just use the default match object sent to us.
1548 """
1548 """
1549 if other != self._repo['.']:
1549 if other != self._repo['.']:
1550 def bad(f, msg):
1550 def bad(f, msg):
1551 # 'f' may be a directory pattern from 'match.files()',
1551 # 'f' may be a directory pattern from 'match.files()',
1552 # so 'f not in ctx1' is not enough
1552 # so 'f not in ctx1' is not enough
1553 if f not in other and not other.hasdir(f):
1553 if f not in other and not other.hasdir(f):
1554 self._repo.ui.warn('%s: %s\n' %
1554 self._repo.ui.warn('%s: %s\n' %
1555 (self._repo.dirstate.pathto(f), msg))
1555 (self._repo.dirstate.pathto(f), msg))
1556 match.bad = bad
1556 match.bad = bad
1557 return match
1557 return match
1558
1558
1559 def markcommitted(self, node):
1559 def markcommitted(self, node):
1560 super(workingctx, self).markcommitted(node)
1560 super(workingctx, self).markcommitted(node)
1561
1561
1562 sparse.aftercommit(self._repo, node)
1562 sparse.aftercommit(self._repo, node)
1563
1563
1564 class committablefilectx(basefilectx):
1564 class committablefilectx(basefilectx):
1565 """A committablefilectx provides common functionality for a file context
1565 """A committablefilectx provides common functionality for a file context
1566 that wants the ability to commit, e.g. workingfilectx or memfilectx."""
1566 that wants the ability to commit, e.g. workingfilectx or memfilectx."""
1567 def __init__(self, repo, path, filelog=None, ctx=None):
1567 def __init__(self, repo, path, filelog=None, ctx=None):
1568 self._repo = repo
1568 self._repo = repo
1569 self._path = path
1569 self._path = path
1570 self._changeid = None
1570 self._changeid = None
1571 self._filerev = self._filenode = None
1571 self._filerev = self._filenode = None
1572
1572
1573 if filelog is not None:
1573 if filelog is not None:
1574 self._filelog = filelog
1574 self._filelog = filelog
1575 if ctx:
1575 if ctx:
1576 self._changectx = ctx
1576 self._changectx = ctx
1577
1577
1578 def __nonzero__(self):
1578 def __nonzero__(self):
1579 return True
1579 return True
1580
1580
1581 __bool__ = __nonzero__
1581 __bool__ = __nonzero__
1582
1582
1583 def linkrev(self):
1583 def linkrev(self):
1584 # linked to self._changectx no matter if file is modified or not
1584 # linked to self._changectx no matter if file is modified or not
1585 return self.rev()
1585 return self.rev()
1586
1586
1587 def parents(self):
1587 def parents(self):
1588 '''return parent filectxs, following copies if necessary'''
1588 '''return parent filectxs, following copies if necessary'''
1589 def filenode(ctx, path):
1589 def filenode(ctx, path):
1590 return ctx._manifest.get(path, nullid)
1590 return ctx._manifest.get(path, nullid)
1591
1591
1592 path = self._path
1592 path = self._path
1593 fl = self._filelog
1593 fl = self._filelog
1594 pcl = self._changectx._parents
1594 pcl = self._changectx._parents
1595 renamed = self.renamed()
1595 renamed = self.renamed()
1596
1596
1597 if renamed:
1597 if renamed:
1598 pl = [renamed + (None,)]
1598 pl = [renamed + (None,)]
1599 else:
1599 else:
1600 pl = [(path, filenode(pcl[0], path), fl)]
1600 pl = [(path, filenode(pcl[0], path), fl)]
1601
1601
1602 for pc in pcl[1:]:
1602 for pc in pcl[1:]:
1603 pl.append((path, filenode(pc, path), fl))
1603 pl.append((path, filenode(pc, path), fl))
1604
1604
1605 return [self._parentfilectx(p, fileid=n, filelog=l)
1605 return [self._parentfilectx(p, fileid=n, filelog=l)
1606 for p, n, l in pl if n != nullid]
1606 for p, n, l in pl if n != nullid]
1607
1607
1608 def children(self):
1608 def children(self):
1609 return []
1609 return []
1610
1610
1611 class workingfilectx(committablefilectx):
1611 class workingfilectx(committablefilectx):
1612 """A workingfilectx object makes access to data related to a particular
1612 """A workingfilectx object makes access to data related to a particular
1613 file in the working directory convenient."""
1613 file in the working directory convenient."""
1614 def __init__(self, repo, path, filelog=None, workingctx=None):
1614 def __init__(self, repo, path, filelog=None, workingctx=None):
1615 super(workingfilectx, self).__init__(repo, path, filelog, workingctx)
1615 super(workingfilectx, self).__init__(repo, path, filelog, workingctx)
1616
1616
1617 @propertycache
1617 @propertycache
1618 def _changectx(self):
1618 def _changectx(self):
1619 return workingctx(self._repo)
1619 return workingctx(self._repo)
1620
1620
1621 def data(self):
1621 def data(self):
1622 return self._repo.wread(self._path)
1622 return self._repo.wread(self._path)
1623 def renamed(self):
1623 def renamed(self):
1624 rp = self._repo.dirstate.copied(self._path)
1624 rp = self._repo.dirstate.copied(self._path)
1625 if not rp:
1625 if not rp:
1626 return None
1626 return None
1627 return rp, self._changectx._parents[0]._manifest.get(rp, nullid)
1627 return rp, self._changectx._parents[0]._manifest.get(rp, nullid)
1628
1628
1629 def size(self):
1629 def size(self):
1630 return self._repo.wvfs.lstat(self._path).st_size
1630 return self._repo.wvfs.lstat(self._path).st_size
1631 def date(self):
1631 def date(self):
1632 t, tz = self._changectx.date()
1632 t, tz = self._changectx.date()
1633 try:
1633 try:
1634 return (self._repo.wvfs.lstat(self._path)[stat.ST_MTIME], tz)
1634 return (self._repo.wvfs.lstat(self._path)[stat.ST_MTIME], tz)
1635 except OSError as err:
1635 except OSError as err:
1636 if err.errno != errno.ENOENT:
1636 if err.errno != errno.ENOENT:
1637 raise
1637 raise
1638 return (t, tz)
1638 return (t, tz)
1639
1639
1640 def exists(self):
1640 def exists(self):
1641 return self._repo.wvfs.exists(self._path)
1641 return self._repo.wvfs.exists(self._path)
1642
1642
1643 def lexists(self):
1643 def lexists(self):
1644 return self._repo.wvfs.lexists(self._path)
1644 return self._repo.wvfs.lexists(self._path)
1645
1645
1646 def audit(self):
1646 def audit(self):
1647 return self._repo.wvfs.audit(self._path)
1647 return self._repo.wvfs.audit(self._path)
1648
1648
1649 def cmp(self, fctx):
1649 def cmp(self, fctx):
1650 """compare with other file context
1650 """compare with other file context
1651
1651
1652 returns True if different than fctx.
1652 returns True if different than fctx.
1653 """
1653 """
1654 # fctx should be a filectx (not a workingfilectx)
1654 # fctx should be a filectx (not a workingfilectx)
1655 # invert comparison to reuse the same code path
1655 # invert comparison to reuse the same code path
1656 return fctx.cmp(self)
1656 return fctx.cmp(self)
1657
1657
1658 def remove(self, ignoremissing=False):
1658 def remove(self, ignoremissing=False):
1659 """wraps unlink for a repo's working directory"""
1659 """wraps unlink for a repo's working directory"""
1660 rmdir = self._repo.ui.configbool('experimental', 'removeemptydirs')
1660 rmdir = self._repo.ui.configbool('experimental', 'removeemptydirs')
1661 self._repo.wvfs.unlinkpath(self._path, ignoremissing=ignoremissing,
1661 self._repo.wvfs.unlinkpath(self._path, ignoremissing=ignoremissing,
1662 rmdir=rmdir)
1662 rmdir=rmdir)
1663
1663
1664 def write(self, data, flags, backgroundclose=False, **kwargs):
1664 def write(self, data, flags, backgroundclose=False, **kwargs):
1665 """wraps repo.wwrite"""
1665 """wraps repo.wwrite"""
1666 self._repo.wwrite(self._path, data, flags,
1666 self._repo.wwrite(self._path, data, flags,
1667 backgroundclose=backgroundclose,
1667 backgroundclose=backgroundclose,
1668 **kwargs)
1668 **kwargs)
1669
1669
1670 def markcopied(self, src):
1670 def markcopied(self, src):
1671 """marks this file a copy of `src`"""
1671 """marks this file a copy of `src`"""
1672 if self._repo.dirstate[self._path] in "nma":
1672 if self._repo.dirstate[self._path] in "nma":
1673 self._repo.dirstate.copy(src, self._path)
1673 self._repo.dirstate.copy(src, self._path)
1674
1674
1675 def clearunknown(self):
1675 def clearunknown(self):
1676 """Removes conflicting items in the working directory so that
1676 """Removes conflicting items in the working directory so that
1677 ``write()`` can be called successfully.
1677 ``write()`` can be called successfully.
1678 """
1678 """
1679 wvfs = self._repo.wvfs
1679 wvfs = self._repo.wvfs
1680 f = self._path
1680 f = self._path
1681 wvfs.audit(f)
1681 wvfs.audit(f)
1682 if self._repo.ui.configbool('experimental', 'merge.checkpathconflicts'):
1682 if self._repo.ui.configbool('experimental', 'merge.checkpathconflicts'):
1683 # remove files under the directory as they should already be
1683 # remove files under the directory as they should already be
1684 # warned and backed up
1684 # warned and backed up
1685 if wvfs.isdir(f) and not wvfs.islink(f):
1685 if wvfs.isdir(f) and not wvfs.islink(f):
1686 wvfs.rmtree(f, forcibly=True)
1686 wvfs.rmtree(f, forcibly=True)
1687 for p in reversed(list(util.finddirs(f))):
1687 for p in reversed(list(util.finddirs(f))):
1688 if wvfs.isfileorlink(p):
1688 if wvfs.isfileorlink(p):
1689 wvfs.unlink(p)
1689 wvfs.unlink(p)
1690 break
1690 break
1691 else:
1691 else:
1692 # don't remove files if path conflicts are not processed
1692 # don't remove files if path conflicts are not processed
1693 if wvfs.isdir(f) and not wvfs.islink(f):
1693 if wvfs.isdir(f) and not wvfs.islink(f):
1694 wvfs.removedirs(f)
1694 wvfs.removedirs(f)
1695
1695
1696 def setflags(self, l, x):
1696 def setflags(self, l, x):
1697 self._repo.wvfs.setflags(self._path, l, x)
1697 self._repo.wvfs.setflags(self._path, l, x)
1698
1698
1699 class overlayworkingctx(committablectx):
1699 class overlayworkingctx(committablectx):
1700 """Wraps another mutable context with a write-back cache that can be
1700 """Wraps another mutable context with a write-back cache that can be
1701 converted into a commit context.
1701 converted into a commit context.
1702
1702
1703 self._cache[path] maps to a dict with keys: {
1703 self._cache[path] maps to a dict with keys: {
1704 'exists': bool?
1704 'exists': bool?
1705 'date': date?
1705 'date': date?
1706 'data': str?
1706 'data': str?
1707 'flags': str?
1707 'flags': str?
1708 'copied': str? (path or None)
1708 'copied': str? (path or None)
1709 }
1709 }
1710 If `exists` is True, `flags` must be non-None and 'date' is non-None. If it
1710 If `exists` is True, `flags` must be non-None and 'date' is non-None. If it
1711 is `False`, the file was deleted.
1711 is `False`, the file was deleted.
1712 """
1712 """
1713
1713
1714 def __init__(self, repo):
1714 def __init__(self, repo):
1715 super(overlayworkingctx, self).__init__(repo)
1715 super(overlayworkingctx, self).__init__(repo)
1716 self.clean()
1716 self.clean()
1717
1717
1718 def setbase(self, wrappedctx):
1718 def setbase(self, wrappedctx):
1719 self._wrappedctx = wrappedctx
1719 self._wrappedctx = wrappedctx
1720 self._parents = [wrappedctx]
1720 self._parents = [wrappedctx]
1721 # Drop old manifest cache as it is now out of date.
1721 # Drop old manifest cache as it is now out of date.
1722 # This is necessary when, e.g., rebasing several nodes with one
1722 # This is necessary when, e.g., rebasing several nodes with one
1723 # ``overlayworkingctx`` (e.g. with --collapse).
1723 # ``overlayworkingctx`` (e.g. with --collapse).
1724 util.clearcachedproperty(self, '_manifest')
1724 util.clearcachedproperty(self, '_manifest')
1725
1725
1726 def data(self, path):
1726 def data(self, path):
1727 if self.isdirty(path):
1727 if self.isdirty(path):
1728 if self._cache[path]['exists']:
1728 if self._cache[path]['exists']:
1729 if self._cache[path]['data']:
1729 if self._cache[path]['data']:
1730 return self._cache[path]['data']
1730 return self._cache[path]['data']
1731 else:
1731 else:
1732 # Must fallback here, too, because we only set flags.
1732 # Must fallback here, too, because we only set flags.
1733 return self._wrappedctx[path].data()
1733 return self._wrappedctx[path].data()
1734 else:
1734 else:
1735 raise error.ProgrammingError("No such file or directory: %s" %
1735 raise error.ProgrammingError("No such file or directory: %s" %
1736 path)
1736 path)
1737 else:
1737 else:
1738 return self._wrappedctx[path].data()
1738 return self._wrappedctx[path].data()
1739
1739
1740 @propertycache
1740 @propertycache
1741 def _manifest(self):
1741 def _manifest(self):
1742 parents = self.parents()
1742 parents = self.parents()
1743 man = parents[0].manifest().copy()
1743 man = parents[0].manifest().copy()
1744
1744
1745 flag = self._flagfunc
1745 flag = self._flagfunc
1746 for path in self.added():
1746 for path in self.added():
1747 man[path] = addednodeid
1747 man[path] = addednodeid
1748 man.setflag(path, flag(path))
1748 man.setflag(path, flag(path))
1749 for path in self.modified():
1749 for path in self.modified():
1750 man[path] = modifiednodeid
1750 man[path] = modifiednodeid
1751 man.setflag(path, flag(path))
1751 man.setflag(path, flag(path))
1752 for path in self.removed():
1752 for path in self.removed():
1753 del man[path]
1753 del man[path]
1754 return man
1754 return man
1755
1755
1756 @propertycache
1756 @propertycache
1757 def _flagfunc(self):
1757 def _flagfunc(self):
1758 def f(path):
1758 def f(path):
1759 return self._cache[path]['flags']
1759 return self._cache[path]['flags']
1760 return f
1760 return f
1761
1761
1762 def files(self):
1762 def files(self):
1763 return sorted(self.added() + self.modified() + self.removed())
1763 return sorted(self.added() + self.modified() + self.removed())
1764
1764
1765 def modified(self):
1765 def modified(self):
1766 return [f for f in self._cache.keys() if self._cache[f]['exists'] and
1766 return [f for f in self._cache.keys() if self._cache[f]['exists'] and
1767 self._existsinparent(f)]
1767 self._existsinparent(f)]
1768
1768
1769 def added(self):
1769 def added(self):
1770 return [f for f in self._cache.keys() if self._cache[f]['exists'] and
1770 return [f for f in self._cache.keys() if self._cache[f]['exists'] and
1771 not self._existsinparent(f)]
1771 not self._existsinparent(f)]
1772
1772
1773 def removed(self):
1773 def removed(self):
1774 return [f for f in self._cache.keys() if
1774 return [f for f in self._cache.keys() if
1775 not self._cache[f]['exists'] and self._existsinparent(f)]
1775 not self._cache[f]['exists'] and self._existsinparent(f)]
1776
1776
1777 def isinmemory(self):
1777 def isinmemory(self):
1778 return True
1778 return True
1779
1779
1780 def filedate(self, path):
1780 def filedate(self, path):
1781 if self.isdirty(path):
1781 if self.isdirty(path):
1782 return self._cache[path]['date']
1782 return self._cache[path]['date']
1783 else:
1783 else:
1784 return self._wrappedctx[path].date()
1784 return self._wrappedctx[path].date()
1785
1785
1786 def markcopied(self, path, origin):
1786 def markcopied(self, path, origin):
1787 if self.isdirty(path):
1787 if self.isdirty(path):
1788 self._cache[path]['copied'] = origin
1788 self._cache[path]['copied'] = origin
1789 else:
1789 else:
1790 raise error.ProgrammingError('markcopied() called on clean context')
1790 raise error.ProgrammingError('markcopied() called on clean context')
1791
1791
1792 def copydata(self, path):
1792 def copydata(self, path):
1793 if self.isdirty(path):
1793 if self.isdirty(path):
1794 return self._cache[path]['copied']
1794 return self._cache[path]['copied']
1795 else:
1795 else:
1796 raise error.ProgrammingError('copydata() called on clean context')
1796 raise error.ProgrammingError('copydata() called on clean context')
1797
1797
1798 def flags(self, path):
1798 def flags(self, path):
1799 if self.isdirty(path):
1799 if self.isdirty(path):
1800 if self._cache[path]['exists']:
1800 if self._cache[path]['exists']:
1801 return self._cache[path]['flags']
1801 return self._cache[path]['flags']
1802 else:
1802 else:
1803 raise error.ProgrammingError("No such file or directory: %s" %
1803 raise error.ProgrammingError("No such file or directory: %s" %
1804 self._path)
1804 self._path)
1805 else:
1805 else:
1806 return self._wrappedctx[path].flags()
1806 return self._wrappedctx[path].flags()
1807
1807
1808 def __contains__(self, key):
1808 def __contains__(self, key):
1809 if key in self._cache:
1809 if key in self._cache:
1810 return self._cache[key]['exists']
1810 return self._cache[key]['exists']
1811 return key in self.p1()
1811 return key in self.p1()
1812
1812
1813 def _existsinparent(self, path):
1813 def _existsinparent(self, path):
1814 try:
1814 try:
1815 # ``commitctx` raises a ``ManifestLookupError`` if a path does not
1815 # ``commitctx` raises a ``ManifestLookupError`` if a path does not
1816 # exist, unlike ``workingctx``, which returns a ``workingfilectx``
1816 # exist, unlike ``workingctx``, which returns a ``workingfilectx``
1817 # with an ``exists()`` function.
1817 # with an ``exists()`` function.
1818 self._wrappedctx[path]
1818 self._wrappedctx[path]
1819 return True
1819 return True
1820 except error.ManifestLookupError:
1820 except error.ManifestLookupError:
1821 return False
1821 return False
1822
1822
1823 def _auditconflicts(self, path):
1823 def _auditconflicts(self, path):
1824 """Replicates conflict checks done by wvfs.write().
1824 """Replicates conflict checks done by wvfs.write().
1825
1825
1826 Since we never write to the filesystem and never call `applyupdates` in
1826 Since we never write to the filesystem and never call `applyupdates` in
1827 IMM, we'll never check that a path is actually writable -- e.g., because
1827 IMM, we'll never check that a path is actually writable -- e.g., because
1828 it adds `a/foo`, but `a` is actually a file in the other commit.
1828 it adds `a/foo`, but `a` is actually a file in the other commit.
1829 """
1829 """
1830 def fail(path, component):
1830 def fail(path, component):
1831 # p1() is the base and we're receiving "writes" for p2()'s
1831 # p1() is the base and we're receiving "writes" for p2()'s
1832 # files.
1832 # files.
1833 if 'l' in self.p1()[component].flags():
1833 if 'l' in self.p1()[component].flags():
1834 raise error.Abort("error: %s conflicts with symlink %s "
1834 raise error.Abort("error: %s conflicts with symlink %s "
1835 "in %s." % (path, component,
1835 "in %s." % (path, component,
1836 self.p1().rev()))
1836 self.p1().rev()))
1837 else:
1837 else:
1838 raise error.Abort("error: '%s' conflicts with file '%s' in "
1838 raise error.Abort("error: '%s' conflicts with file '%s' in "
1839 "%s." % (path, component,
1839 "%s." % (path, component,
1840 self.p1().rev()))
1840 self.p1().rev()))
1841
1841
1842 # Test that each new directory to be created to write this path from p2
1842 # Test that each new directory to be created to write this path from p2
1843 # is not a file in p1.
1843 # is not a file in p1.
1844 components = path.split('/')
1844 components = path.split('/')
1845 for i in pycompat.xrange(len(components)):
1845 for i in pycompat.xrange(len(components)):
1846 component = "/".join(components[0:i])
1846 component = "/".join(components[0:i])
1847 if component in self:
1847 if component in self:
1848 fail(path, component)
1848 fail(path, component)
1849
1849
1850 # Test the other direction -- that this path from p2 isn't a directory
1850 # Test the other direction -- that this path from p2 isn't a directory
1851 # in p1 (test that p1 doesn't any paths matching `path/*`).
1851 # in p1 (test that p1 doesn't have any paths matching `path/*`).
1852 match = matchmod.match('/', '', [path + '/'], default=b'relpath')
1852 match = self.match(pats=[path + '/'], default=b'path')
1853 matches = self.p1().manifest().matches(match)
1853 matches = self.p1().manifest().matches(match)
1854 mfiles = matches.keys()
1854 mfiles = matches.keys()
1855 if len(mfiles) > 0:
1855 if len(mfiles) > 0:
1856 if len(mfiles) == 1 and mfiles[0] == path:
1856 if len(mfiles) == 1 and mfiles[0] == path:
1857 return
1857 return
1858 # omit the files which are deleted in current IMM wctx
1858 # omit the files which are deleted in current IMM wctx
1859 mfiles = [m for m in mfiles if m in self]
1859 mfiles = [m for m in mfiles if m in self]
1860 if not mfiles:
1860 if not mfiles:
1861 return
1861 return
1862 raise error.Abort("error: file '%s' cannot be written because "
1862 raise error.Abort("error: file '%s' cannot be written because "
1863 " '%s/' is a folder in %s (containing %d "
1863 " '%s/' is a folder in %s (containing %d "
1864 "entries: %s)"
1864 "entries: %s)"
1865 % (path, path, self.p1(), len(mfiles),
1865 % (path, path, self.p1(), len(mfiles),
1866 ', '.join(mfiles)))
1866 ', '.join(mfiles)))
1867
1867
1868 def write(self, path, data, flags='', **kwargs):
1868 def write(self, path, data, flags='', **kwargs):
1869 if data is None:
1869 if data is None:
1870 raise error.ProgrammingError("data must be non-None")
1870 raise error.ProgrammingError("data must be non-None")
1871 self._auditconflicts(path)
1871 self._auditconflicts(path)
1872 self._markdirty(path, exists=True, data=data, date=dateutil.makedate(),
1872 self._markdirty(path, exists=True, data=data, date=dateutil.makedate(),
1873 flags=flags)
1873 flags=flags)
1874
1874
1875 def setflags(self, path, l, x):
1875 def setflags(self, path, l, x):
1876 flag = ''
1876 flag = ''
1877 if l:
1877 if l:
1878 flag = 'l'
1878 flag = 'l'
1879 elif x:
1879 elif x:
1880 flag = 'x'
1880 flag = 'x'
1881 self._markdirty(path, exists=True, date=dateutil.makedate(),
1881 self._markdirty(path, exists=True, date=dateutil.makedate(),
1882 flags=flag)
1882 flags=flag)
1883
1883
1884 def remove(self, path):
1884 def remove(self, path):
1885 self._markdirty(path, exists=False)
1885 self._markdirty(path, exists=False)
1886
1886
1887 def exists(self, path):
1887 def exists(self, path):
1888 """exists behaves like `lexists`, but needs to follow symlinks and
1888 """exists behaves like `lexists`, but needs to follow symlinks and
1889 return False if they are broken.
1889 return False if they are broken.
1890 """
1890 """
1891 if self.isdirty(path):
1891 if self.isdirty(path):
1892 # If this path exists and is a symlink, "follow" it by calling
1892 # If this path exists and is a symlink, "follow" it by calling
1893 # exists on the destination path.
1893 # exists on the destination path.
1894 if (self._cache[path]['exists'] and
1894 if (self._cache[path]['exists'] and
1895 'l' in self._cache[path]['flags']):
1895 'l' in self._cache[path]['flags']):
1896 return self.exists(self._cache[path]['data'].strip())
1896 return self.exists(self._cache[path]['data'].strip())
1897 else:
1897 else:
1898 return self._cache[path]['exists']
1898 return self._cache[path]['exists']
1899
1899
1900 return self._existsinparent(path)
1900 return self._existsinparent(path)
1901
1901
1902 def lexists(self, path):
1902 def lexists(self, path):
1903 """lexists returns True if the path exists"""
1903 """lexists returns True if the path exists"""
1904 if self.isdirty(path):
1904 if self.isdirty(path):
1905 return self._cache[path]['exists']
1905 return self._cache[path]['exists']
1906
1906
1907 return self._existsinparent(path)
1907 return self._existsinparent(path)
1908
1908
1909 def size(self, path):
1909 def size(self, path):
1910 if self.isdirty(path):
1910 if self.isdirty(path):
1911 if self._cache[path]['exists']:
1911 if self._cache[path]['exists']:
1912 return len(self._cache[path]['data'])
1912 return len(self._cache[path]['data'])
1913 else:
1913 else:
1914 raise error.ProgrammingError("No such file or directory: %s" %
1914 raise error.ProgrammingError("No such file or directory: %s" %
1915 self._path)
1915 self._path)
1916 return self._wrappedctx[path].size()
1916 return self._wrappedctx[path].size()
1917
1917
1918 def tomemctx(self, text, branch=None, extra=None, date=None, parents=None,
1918 def tomemctx(self, text, branch=None, extra=None, date=None, parents=None,
1919 user=None, editor=None):
1919 user=None, editor=None):
1920 """Converts this ``overlayworkingctx`` into a ``memctx`` ready to be
1920 """Converts this ``overlayworkingctx`` into a ``memctx`` ready to be
1921 committed.
1921 committed.
1922
1922
1923 ``text`` is the commit message.
1923 ``text`` is the commit message.
1924 ``parents`` (optional) are rev numbers.
1924 ``parents`` (optional) are rev numbers.
1925 """
1925 """
1926 # Default parents to the wrapped contexts' if not passed.
1926 # Default parents to the wrapped contexts' if not passed.
1927 if parents is None:
1927 if parents is None:
1928 parents = self._wrappedctx.parents()
1928 parents = self._wrappedctx.parents()
1929 if len(parents) == 1:
1929 if len(parents) == 1:
1930 parents = (parents[0], None)
1930 parents = (parents[0], None)
1931
1931
1932 # ``parents`` is passed as rev numbers; convert to ``commitctxs``.
1932 # ``parents`` is passed as rev numbers; convert to ``commitctxs``.
1933 if parents[1] is None:
1933 if parents[1] is None:
1934 parents = (self._repo[parents[0]], None)
1934 parents = (self._repo[parents[0]], None)
1935 else:
1935 else:
1936 parents = (self._repo[parents[0]], self._repo[parents[1]])
1936 parents = (self._repo[parents[0]], self._repo[parents[1]])
1937
1937
1938 files = self._cache.keys()
1938 files = self._cache.keys()
1939 def getfile(repo, memctx, path):
1939 def getfile(repo, memctx, path):
1940 if self._cache[path]['exists']:
1940 if self._cache[path]['exists']:
1941 return memfilectx(repo, memctx, path,
1941 return memfilectx(repo, memctx, path,
1942 self._cache[path]['data'],
1942 self._cache[path]['data'],
1943 'l' in self._cache[path]['flags'],
1943 'l' in self._cache[path]['flags'],
1944 'x' in self._cache[path]['flags'],
1944 'x' in self._cache[path]['flags'],
1945 self._cache[path]['copied'])
1945 self._cache[path]['copied'])
1946 else:
1946 else:
1947 # Returning None, but including the path in `files`, is
1947 # Returning None, but including the path in `files`, is
1948 # necessary for memctx to register a deletion.
1948 # necessary for memctx to register a deletion.
1949 return None
1949 return None
1950 return memctx(self._repo, parents, text, files, getfile, date=date,
1950 return memctx(self._repo, parents, text, files, getfile, date=date,
1951 extra=extra, user=user, branch=branch, editor=editor)
1951 extra=extra, user=user, branch=branch, editor=editor)
1952
1952
1953 def isdirty(self, path):
1953 def isdirty(self, path):
1954 return path in self._cache
1954 return path in self._cache
1955
1955
1956 def isempty(self):
1956 def isempty(self):
1957 # We need to discard any keys that are actually clean before the empty
1957 # We need to discard any keys that are actually clean before the empty
1958 # commit check.
1958 # commit check.
1959 self._compact()
1959 self._compact()
1960 return len(self._cache) == 0
1960 return len(self._cache) == 0
1961
1961
1962 def clean(self):
1962 def clean(self):
1963 self._cache = {}
1963 self._cache = {}
1964
1964
1965 def _compact(self):
1965 def _compact(self):
1966 """Removes keys from the cache that are actually clean, by comparing
1966 """Removes keys from the cache that are actually clean, by comparing
1967 them with the underlying context.
1967 them with the underlying context.
1968
1968
1969 This can occur during the merge process, e.g. by passing --tool :local
1969 This can occur during the merge process, e.g. by passing --tool :local
1970 to resolve a conflict.
1970 to resolve a conflict.
1971 """
1971 """
1972 keys = []
1972 keys = []
1973 for path in self._cache.keys():
1973 for path in self._cache.keys():
1974 cache = self._cache[path]
1974 cache = self._cache[path]
1975 try:
1975 try:
1976 underlying = self._wrappedctx[path]
1976 underlying = self._wrappedctx[path]
1977 if (underlying.data() == cache['data'] and
1977 if (underlying.data() == cache['data'] and
1978 underlying.flags() == cache['flags']):
1978 underlying.flags() == cache['flags']):
1979 keys.append(path)
1979 keys.append(path)
1980 except error.ManifestLookupError:
1980 except error.ManifestLookupError:
1981 # Path not in the underlying manifest (created).
1981 # Path not in the underlying manifest (created).
1982 continue
1982 continue
1983
1983
1984 for path in keys:
1984 for path in keys:
1985 del self._cache[path]
1985 del self._cache[path]
1986 return keys
1986 return keys
1987
1987
1988 def _markdirty(self, path, exists, data=None, date=None, flags=''):
1988 def _markdirty(self, path, exists, data=None, date=None, flags=''):
1989 # data not provided, let's see if we already have some; if not, let's
1989 # data not provided, let's see if we already have some; if not, let's
1990 # grab it from our underlying context, so that we always have data if
1990 # grab it from our underlying context, so that we always have data if
1991 # the file is marked as existing.
1991 # the file is marked as existing.
1992 if exists and data is None:
1992 if exists and data is None:
1993 oldentry = self._cache.get(path) or {}
1993 oldentry = self._cache.get(path) or {}
1994 data = oldentry.get('data') or self._wrappedctx[path].data()
1994 data = oldentry.get('data') or self._wrappedctx[path].data()
1995
1995
1996 self._cache[path] = {
1996 self._cache[path] = {
1997 'exists': exists,
1997 'exists': exists,
1998 'data': data,
1998 'data': data,
1999 'date': date,
1999 'date': date,
2000 'flags': flags,
2000 'flags': flags,
2001 'copied': None,
2001 'copied': None,
2002 }
2002 }
2003
2003
2004 def filectx(self, path, filelog=None):
2004 def filectx(self, path, filelog=None):
2005 return overlayworkingfilectx(self._repo, path, parent=self,
2005 return overlayworkingfilectx(self._repo, path, parent=self,
2006 filelog=filelog)
2006 filelog=filelog)
2007
2007
2008 class overlayworkingfilectx(committablefilectx):
2008 class overlayworkingfilectx(committablefilectx):
2009 """Wrap a ``workingfilectx`` but intercepts all writes into an in-memory
2009 """Wrap a ``workingfilectx`` but intercepts all writes into an in-memory
2010 cache, which can be flushed through later by calling ``flush()``."""
2010 cache, which can be flushed through later by calling ``flush()``."""
2011
2011
2012 def __init__(self, repo, path, filelog=None, parent=None):
2012 def __init__(self, repo, path, filelog=None, parent=None):
2013 super(overlayworkingfilectx, self).__init__(repo, path, filelog,
2013 super(overlayworkingfilectx, self).__init__(repo, path, filelog,
2014 parent)
2014 parent)
2015 self._repo = repo
2015 self._repo = repo
2016 self._parent = parent
2016 self._parent = parent
2017 self._path = path
2017 self._path = path
2018
2018
2019 def cmp(self, fctx):
2019 def cmp(self, fctx):
2020 return self.data() != fctx.data()
2020 return self.data() != fctx.data()
2021
2021
2022 def changectx(self):
2022 def changectx(self):
2023 return self._parent
2023 return self._parent
2024
2024
2025 def data(self):
2025 def data(self):
2026 return self._parent.data(self._path)
2026 return self._parent.data(self._path)
2027
2027
2028 def date(self):
2028 def date(self):
2029 return self._parent.filedate(self._path)
2029 return self._parent.filedate(self._path)
2030
2030
2031 def exists(self):
2031 def exists(self):
2032 return self.lexists()
2032 return self.lexists()
2033
2033
2034 def lexists(self):
2034 def lexists(self):
2035 return self._parent.exists(self._path)
2035 return self._parent.exists(self._path)
2036
2036
2037 def renamed(self):
2037 def renamed(self):
2038 path = self._parent.copydata(self._path)
2038 path = self._parent.copydata(self._path)
2039 if not path:
2039 if not path:
2040 return None
2040 return None
2041 return path, self._changectx._parents[0]._manifest.get(path, nullid)
2041 return path, self._changectx._parents[0]._manifest.get(path, nullid)
2042
2042
2043 def size(self):
2043 def size(self):
2044 return self._parent.size(self._path)
2044 return self._parent.size(self._path)
2045
2045
2046 def markcopied(self, origin):
2046 def markcopied(self, origin):
2047 self._parent.markcopied(self._path, origin)
2047 self._parent.markcopied(self._path, origin)
2048
2048
2049 def audit(self):
2049 def audit(self):
2050 pass
2050 pass
2051
2051
2052 def flags(self):
2052 def flags(self):
2053 return self._parent.flags(self._path)
2053 return self._parent.flags(self._path)
2054
2054
2055 def setflags(self, islink, isexec):
2055 def setflags(self, islink, isexec):
2056 return self._parent.setflags(self._path, islink, isexec)
2056 return self._parent.setflags(self._path, islink, isexec)
2057
2057
2058 def write(self, data, flags, backgroundclose=False, **kwargs):
2058 def write(self, data, flags, backgroundclose=False, **kwargs):
2059 return self._parent.write(self._path, data, flags, **kwargs)
2059 return self._parent.write(self._path, data, flags, **kwargs)
2060
2060
2061 def remove(self, ignoremissing=False):
2061 def remove(self, ignoremissing=False):
2062 return self._parent.remove(self._path)
2062 return self._parent.remove(self._path)
2063
2063
2064 def clearunknown(self):
2064 def clearunknown(self):
2065 pass
2065 pass
2066
2066
2067 class workingcommitctx(workingctx):
2067 class workingcommitctx(workingctx):
2068 """A workingcommitctx object makes access to data related to
2068 """A workingcommitctx object makes access to data related to
2069 the revision being committed convenient.
2069 the revision being committed convenient.
2070
2070
2071 This hides changes in the working directory, if they aren't
2071 This hides changes in the working directory, if they aren't
2072 committed in this context.
2072 committed in this context.
2073 """
2073 """
2074 def __init__(self, repo, changes,
2074 def __init__(self, repo, changes,
2075 text="", user=None, date=None, extra=None):
2075 text="", user=None, date=None, extra=None):
2076 super(workingcommitctx, self).__init__(repo, text, user, date, extra,
2076 super(workingcommitctx, self).__init__(repo, text, user, date, extra,
2077 changes)
2077 changes)
2078
2078
2079 def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
2079 def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
2080 """Return matched files only in ``self._status``
2080 """Return matched files only in ``self._status``
2081
2081
2082 Uncommitted files appear "clean" via this context, even if
2082 Uncommitted files appear "clean" via this context, even if
2083 they aren't actually so in the working directory.
2083 they aren't actually so in the working directory.
2084 """
2084 """
2085 if clean:
2085 if clean:
2086 clean = [f for f in self._manifest if f not in self._changedset]
2086 clean = [f for f in self._manifest if f not in self._changedset]
2087 else:
2087 else:
2088 clean = []
2088 clean = []
2089 return scmutil.status([f for f in self._status.modified if match(f)],
2089 return scmutil.status([f for f in self._status.modified if match(f)],
2090 [f for f in self._status.added if match(f)],
2090 [f for f in self._status.added if match(f)],
2091 [f for f in self._status.removed if match(f)],
2091 [f for f in self._status.removed if match(f)],
2092 [], [], [], clean)
2092 [], [], [], clean)
2093
2093
2094 @propertycache
2094 @propertycache
2095 def _changedset(self):
2095 def _changedset(self):
2096 """Return the set of files changed in this context
2096 """Return the set of files changed in this context
2097 """
2097 """
2098 changed = set(self._status.modified)
2098 changed = set(self._status.modified)
2099 changed.update(self._status.added)
2099 changed.update(self._status.added)
2100 changed.update(self._status.removed)
2100 changed.update(self._status.removed)
2101 return changed
2101 return changed
2102
2102
2103 def makecachingfilectxfn(func):
2103 def makecachingfilectxfn(func):
2104 """Create a filectxfn that caches based on the path.
2104 """Create a filectxfn that caches based on the path.
2105
2105
2106 We can't use util.cachefunc because it uses all arguments as the cache
2106 We can't use util.cachefunc because it uses all arguments as the cache
2107 key and this creates a cycle since the arguments include the repo and
2107 key and this creates a cycle since the arguments include the repo and
2108 memctx.
2108 memctx.
2109 """
2109 """
2110 cache = {}
2110 cache = {}
2111
2111
2112 def getfilectx(repo, memctx, path):
2112 def getfilectx(repo, memctx, path):
2113 if path not in cache:
2113 if path not in cache:
2114 cache[path] = func(repo, memctx, path)
2114 cache[path] = func(repo, memctx, path)
2115 return cache[path]
2115 return cache[path]
2116
2116
2117 return getfilectx
2117 return getfilectx
2118
2118
2119 def memfilefromctx(ctx):
2119 def memfilefromctx(ctx):
2120 """Given a context return a memfilectx for ctx[path]
2120 """Given a context return a memfilectx for ctx[path]
2121
2121
2122 This is a convenience method for building a memctx based on another
2122 This is a convenience method for building a memctx based on another
2123 context.
2123 context.
2124 """
2124 """
2125 def getfilectx(repo, memctx, path):
2125 def getfilectx(repo, memctx, path):
2126 fctx = ctx[path]
2126 fctx = ctx[path]
2127 # this is weird but apparently we only keep track of one parent
2127 # this is weird but apparently we only keep track of one parent
2128 # (why not only store that instead of a tuple?)
2128 # (why not only store that instead of a tuple?)
2129 copied = fctx.renamed()
2129 copied = fctx.renamed()
2130 if copied:
2130 if copied:
2131 copied = copied[0]
2131 copied = copied[0]
2132 return memfilectx(repo, memctx, path, fctx.data(),
2132 return memfilectx(repo, memctx, path, fctx.data(),
2133 islink=fctx.islink(), isexec=fctx.isexec(),
2133 islink=fctx.islink(), isexec=fctx.isexec(),
2134 copied=copied)
2134 copied=copied)
2135
2135
2136 return getfilectx
2136 return getfilectx
2137
2137
2138 def memfilefrompatch(patchstore):
2138 def memfilefrompatch(patchstore):
2139 """Given a patch (e.g. patchstore object) return a memfilectx
2139 """Given a patch (e.g. patchstore object) return a memfilectx
2140
2140
2141 This is a convenience method for building a memctx based on a patchstore.
2141 This is a convenience method for building a memctx based on a patchstore.
2142 """
2142 """
2143 def getfilectx(repo, memctx, path):
2143 def getfilectx(repo, memctx, path):
2144 data, mode, copied = patchstore.getfile(path)
2144 data, mode, copied = patchstore.getfile(path)
2145 if data is None:
2145 if data is None:
2146 return None
2146 return None
2147 islink, isexec = mode
2147 islink, isexec = mode
2148 return memfilectx(repo, memctx, path, data, islink=islink,
2148 return memfilectx(repo, memctx, path, data, islink=islink,
2149 isexec=isexec, copied=copied)
2149 isexec=isexec, copied=copied)
2150
2150
2151 return getfilectx
2151 return getfilectx
2152
2152
2153 class memctx(committablectx):
2153 class memctx(committablectx):
2154 """Use memctx to perform in-memory commits via localrepo.commitctx().
2154 """Use memctx to perform in-memory commits via localrepo.commitctx().
2155
2155
2156 Revision information is supplied at initialization time while
2156 Revision information is supplied at initialization time while
2157 related files data and is made available through a callback
2157 related files data and is made available through a callback
2158 mechanism. 'repo' is the current localrepo, 'parents' is a
2158 mechanism. 'repo' is the current localrepo, 'parents' is a
2159 sequence of two parent revisions identifiers (pass None for every
2159 sequence of two parent revisions identifiers (pass None for every
2160 missing parent), 'text' is the commit message and 'files' lists
2160 missing parent), 'text' is the commit message and 'files' lists
2161 names of files touched by the revision (normalized and relative to
2161 names of files touched by the revision (normalized and relative to
2162 repository root).
2162 repository root).
2163
2163
2164 filectxfn(repo, memctx, path) is a callable receiving the
2164 filectxfn(repo, memctx, path) is a callable receiving the
2165 repository, the current memctx object and the normalized path of
2165 repository, the current memctx object and the normalized path of
2166 requested file, relative to repository root. It is fired by the
2166 requested file, relative to repository root. It is fired by the
2167 commit function for every file in 'files', but calls order is
2167 commit function for every file in 'files', but calls order is
2168 undefined. If the file is available in the revision being
2168 undefined. If the file is available in the revision being
2169 committed (updated or added), filectxfn returns a memfilectx
2169 committed (updated or added), filectxfn returns a memfilectx
2170 object. If the file was removed, filectxfn return None for recent
2170 object. If the file was removed, filectxfn return None for recent
2171 Mercurial. Moved files are represented by marking the source file
2171 Mercurial. Moved files are represented by marking the source file
2172 removed and the new file added with copy information (see
2172 removed and the new file added with copy information (see
2173 memfilectx).
2173 memfilectx).
2174
2174
2175 user receives the committer name and defaults to current
2175 user receives the committer name and defaults to current
2176 repository username, date is the commit date in any format
2176 repository username, date is the commit date in any format
2177 supported by dateutil.parsedate() and defaults to current date, extra
2177 supported by dateutil.parsedate() and defaults to current date, extra
2178 is a dictionary of metadata or is left empty.
2178 is a dictionary of metadata or is left empty.
2179 """
2179 """
2180
2180
2181 # Mercurial <= 3.1 expects the filectxfn to raise IOError for missing files.
2181 # Mercurial <= 3.1 expects the filectxfn to raise IOError for missing files.
2182 # Extensions that need to retain compatibility across Mercurial 3.1 can use
2182 # Extensions that need to retain compatibility across Mercurial 3.1 can use
2183 # this field to determine what to do in filectxfn.
2183 # this field to determine what to do in filectxfn.
2184 _returnnoneformissingfiles = True
2184 _returnnoneformissingfiles = True
2185
2185
2186 def __init__(self, repo, parents, text, files, filectxfn, user=None,
2186 def __init__(self, repo, parents, text, files, filectxfn, user=None,
2187 date=None, extra=None, branch=None, editor=False):
2187 date=None, extra=None, branch=None, editor=False):
2188 super(memctx, self).__init__(repo, text, user, date, extra)
2188 super(memctx, self).__init__(repo, text, user, date, extra)
2189 self._rev = None
2189 self._rev = None
2190 self._node = None
2190 self._node = None
2191 parents = [(p or nullid) for p in parents]
2191 parents = [(p or nullid) for p in parents]
2192 p1, p2 = parents
2192 p1, p2 = parents
2193 self._parents = [self._repo[p] for p in (p1, p2)]
2193 self._parents = [self._repo[p] for p in (p1, p2)]
2194 files = sorted(set(files))
2194 files = sorted(set(files))
2195 self._files = files
2195 self._files = files
2196 if branch is not None:
2196 if branch is not None:
2197 self._extra['branch'] = encoding.fromlocal(branch)
2197 self._extra['branch'] = encoding.fromlocal(branch)
2198 self.substate = {}
2198 self.substate = {}
2199
2199
2200 if isinstance(filectxfn, patch.filestore):
2200 if isinstance(filectxfn, patch.filestore):
2201 filectxfn = memfilefrompatch(filectxfn)
2201 filectxfn = memfilefrompatch(filectxfn)
2202 elif not callable(filectxfn):
2202 elif not callable(filectxfn):
2203 # if store is not callable, wrap it in a function
2203 # if store is not callable, wrap it in a function
2204 filectxfn = memfilefromctx(filectxfn)
2204 filectxfn = memfilefromctx(filectxfn)
2205
2205
2206 # memoizing increases performance for e.g. vcs convert scenarios.
2206 # memoizing increases performance for e.g. vcs convert scenarios.
2207 self._filectxfn = makecachingfilectxfn(filectxfn)
2207 self._filectxfn = makecachingfilectxfn(filectxfn)
2208
2208
2209 if editor:
2209 if editor:
2210 self._text = editor(self._repo, self, [])
2210 self._text = editor(self._repo, self, [])
2211 self._repo.savecommitmessage(self._text)
2211 self._repo.savecommitmessage(self._text)
2212
2212
2213 def filectx(self, path, filelog=None):
2213 def filectx(self, path, filelog=None):
2214 """get a file context from the working directory
2214 """get a file context from the working directory
2215
2215
2216 Returns None if file doesn't exist and should be removed."""
2216 Returns None if file doesn't exist and should be removed."""
2217 return self._filectxfn(self._repo, self, path)
2217 return self._filectxfn(self._repo, self, path)
2218
2218
2219 def commit(self):
2219 def commit(self):
2220 """commit context to the repo"""
2220 """commit context to the repo"""
2221 return self._repo.commitctx(self)
2221 return self._repo.commitctx(self)
2222
2222
2223 @propertycache
2223 @propertycache
2224 def _manifest(self):
2224 def _manifest(self):
2225 """generate a manifest based on the return values of filectxfn"""
2225 """generate a manifest based on the return values of filectxfn"""
2226
2226
2227 # keep this simple for now; just worry about p1
2227 # keep this simple for now; just worry about p1
2228 pctx = self._parents[0]
2228 pctx = self._parents[0]
2229 man = pctx.manifest().copy()
2229 man = pctx.manifest().copy()
2230
2230
2231 for f in self._status.modified:
2231 for f in self._status.modified:
2232 man[f] = modifiednodeid
2232 man[f] = modifiednodeid
2233
2233
2234 for f in self._status.added:
2234 for f in self._status.added:
2235 man[f] = addednodeid
2235 man[f] = addednodeid
2236
2236
2237 for f in self._status.removed:
2237 for f in self._status.removed:
2238 if f in man:
2238 if f in man:
2239 del man[f]
2239 del man[f]
2240
2240
2241 return man
2241 return man
2242
2242
2243 @propertycache
2243 @propertycache
2244 def _status(self):
2244 def _status(self):
2245 """Calculate exact status from ``files`` specified at construction
2245 """Calculate exact status from ``files`` specified at construction
2246 """
2246 """
2247 man1 = self.p1().manifest()
2247 man1 = self.p1().manifest()
2248 p2 = self._parents[1]
2248 p2 = self._parents[1]
2249 # "1 < len(self._parents)" can't be used for checking
2249 # "1 < len(self._parents)" can't be used for checking
2250 # existence of the 2nd parent, because "memctx._parents" is
2250 # existence of the 2nd parent, because "memctx._parents" is
2251 # explicitly initialized by the list, of which length is 2.
2251 # explicitly initialized by the list, of which length is 2.
2252 if p2.node() != nullid:
2252 if p2.node() != nullid:
2253 man2 = p2.manifest()
2253 man2 = p2.manifest()
2254 managing = lambda f: f in man1 or f in man2
2254 managing = lambda f: f in man1 or f in man2
2255 else:
2255 else:
2256 managing = lambda f: f in man1
2256 managing = lambda f: f in man1
2257
2257
2258 modified, added, removed = [], [], []
2258 modified, added, removed = [], [], []
2259 for f in self._files:
2259 for f in self._files:
2260 if not managing(f):
2260 if not managing(f):
2261 added.append(f)
2261 added.append(f)
2262 elif self[f]:
2262 elif self[f]:
2263 modified.append(f)
2263 modified.append(f)
2264 else:
2264 else:
2265 removed.append(f)
2265 removed.append(f)
2266
2266
2267 return scmutil.status(modified, added, removed, [], [], [], [])
2267 return scmutil.status(modified, added, removed, [], [], [], [])
2268
2268
2269 class memfilectx(committablefilectx):
2269 class memfilectx(committablefilectx):
2270 """memfilectx represents an in-memory file to commit.
2270 """memfilectx represents an in-memory file to commit.
2271
2271
2272 See memctx and committablefilectx for more details.
2272 See memctx and committablefilectx for more details.
2273 """
2273 """
2274 def __init__(self, repo, changectx, path, data, islink=False,
2274 def __init__(self, repo, changectx, path, data, islink=False,
2275 isexec=False, copied=None):
2275 isexec=False, copied=None):
2276 """
2276 """
2277 path is the normalized file path relative to repository root.
2277 path is the normalized file path relative to repository root.
2278 data is the file content as a string.
2278 data is the file content as a string.
2279 islink is True if the file is a symbolic link.
2279 islink is True if the file is a symbolic link.
2280 isexec is True if the file is executable.
2280 isexec is True if the file is executable.
2281 copied is the source file path if current file was copied in the
2281 copied is the source file path if current file was copied in the
2282 revision being committed, or None."""
2282 revision being committed, or None."""
2283 super(memfilectx, self).__init__(repo, path, None, changectx)
2283 super(memfilectx, self).__init__(repo, path, None, changectx)
2284 self._data = data
2284 self._data = data
2285 if islink:
2285 if islink:
2286 self._flags = 'l'
2286 self._flags = 'l'
2287 elif isexec:
2287 elif isexec:
2288 self._flags = 'x'
2288 self._flags = 'x'
2289 else:
2289 else:
2290 self._flags = ''
2290 self._flags = ''
2291 self._copied = None
2291 self._copied = None
2292 if copied:
2292 if copied:
2293 self._copied = (copied, nullid)
2293 self._copied = (copied, nullid)
2294
2294
2295 def data(self):
2295 def data(self):
2296 return self._data
2296 return self._data
2297
2297
2298 def remove(self, ignoremissing=False):
2298 def remove(self, ignoremissing=False):
2299 """wraps unlink for a repo's working directory"""
2299 """wraps unlink for a repo's working directory"""
2300 # need to figure out what to do here
2300 # need to figure out what to do here
2301 del self._changectx[self._path]
2301 del self._changectx[self._path]
2302
2302
2303 def write(self, data, flags, **kwargs):
2303 def write(self, data, flags, **kwargs):
2304 """wraps repo.wwrite"""
2304 """wraps repo.wwrite"""
2305 self._data = data
2305 self._data = data
2306
2306
2307
2307
2308 class metadataonlyctx(committablectx):
2308 class metadataonlyctx(committablectx):
2309 """Like memctx but it's reusing the manifest of different commit.
2309 """Like memctx but it's reusing the manifest of different commit.
2310 Intended to be used by lightweight operations that are creating
2310 Intended to be used by lightweight operations that are creating
2311 metadata-only changes.
2311 metadata-only changes.
2312
2312
2313 Revision information is supplied at initialization time. 'repo' is the
2313 Revision information is supplied at initialization time. 'repo' is the
2314 current localrepo, 'ctx' is original revision which manifest we're reuisng
2314 current localrepo, 'ctx' is original revision which manifest we're reuisng
2315 'parents' is a sequence of two parent revisions identifiers (pass None for
2315 'parents' is a sequence of two parent revisions identifiers (pass None for
2316 every missing parent), 'text' is the commit.
2316 every missing parent), 'text' is the commit.
2317
2317
2318 user receives the committer name and defaults to current repository
2318 user receives the committer name and defaults to current repository
2319 username, date is the commit date in any format supported by
2319 username, date is the commit date in any format supported by
2320 dateutil.parsedate() and defaults to current date, extra is a dictionary of
2320 dateutil.parsedate() and defaults to current date, extra is a dictionary of
2321 metadata or is left empty.
2321 metadata or is left empty.
2322 """
2322 """
2323 def __init__(self, repo, originalctx, parents=None, text=None, user=None,
2323 def __init__(self, repo, originalctx, parents=None, text=None, user=None,
2324 date=None, extra=None, editor=False):
2324 date=None, extra=None, editor=False):
2325 if text is None:
2325 if text is None:
2326 text = originalctx.description()
2326 text = originalctx.description()
2327 super(metadataonlyctx, self).__init__(repo, text, user, date, extra)
2327 super(metadataonlyctx, self).__init__(repo, text, user, date, extra)
2328 self._rev = None
2328 self._rev = None
2329 self._node = None
2329 self._node = None
2330 self._originalctx = originalctx
2330 self._originalctx = originalctx
2331 self._manifestnode = originalctx.manifestnode()
2331 self._manifestnode = originalctx.manifestnode()
2332 if parents is None:
2332 if parents is None:
2333 parents = originalctx.parents()
2333 parents = originalctx.parents()
2334 else:
2334 else:
2335 parents = [repo[p] for p in parents if p is not None]
2335 parents = [repo[p] for p in parents if p is not None]
2336 parents = parents[:]
2336 parents = parents[:]
2337 while len(parents) < 2:
2337 while len(parents) < 2:
2338 parents.append(repo[nullid])
2338 parents.append(repo[nullid])
2339 p1, p2 = self._parents = parents
2339 p1, p2 = self._parents = parents
2340
2340
2341 # sanity check to ensure that the reused manifest parents are
2341 # sanity check to ensure that the reused manifest parents are
2342 # manifests of our commit parents
2342 # manifests of our commit parents
2343 mp1, mp2 = self.manifestctx().parents
2343 mp1, mp2 = self.manifestctx().parents
2344 if p1 != nullid and p1.manifestnode() != mp1:
2344 if p1 != nullid and p1.manifestnode() != mp1:
2345 raise RuntimeError(r"can't reuse the manifest: its p1 "
2345 raise RuntimeError(r"can't reuse the manifest: its p1 "
2346 r"doesn't match the new ctx p1")
2346 r"doesn't match the new ctx p1")
2347 if p2 != nullid and p2.manifestnode() != mp2:
2347 if p2 != nullid and p2.manifestnode() != mp2:
2348 raise RuntimeError(r"can't reuse the manifest: "
2348 raise RuntimeError(r"can't reuse the manifest: "
2349 r"its p2 doesn't match the new ctx p2")
2349 r"its p2 doesn't match the new ctx p2")
2350
2350
2351 self._files = originalctx.files()
2351 self._files = originalctx.files()
2352 self.substate = {}
2352 self.substate = {}
2353
2353
2354 if editor:
2354 if editor:
2355 self._text = editor(self._repo, self, [])
2355 self._text = editor(self._repo, self, [])
2356 self._repo.savecommitmessage(self._text)
2356 self._repo.savecommitmessage(self._text)
2357
2357
2358 def manifestnode(self):
2358 def manifestnode(self):
2359 return self._manifestnode
2359 return self._manifestnode
2360
2360
2361 @property
2361 @property
2362 def _manifestctx(self):
2362 def _manifestctx(self):
2363 return self._repo.manifestlog[self._manifestnode]
2363 return self._repo.manifestlog[self._manifestnode]
2364
2364
2365 def filectx(self, path, filelog=None):
2365 def filectx(self, path, filelog=None):
2366 return self._originalctx.filectx(path, filelog=filelog)
2366 return self._originalctx.filectx(path, filelog=filelog)
2367
2367
2368 def commit(self):
2368 def commit(self):
2369 """commit context to the repo"""
2369 """commit context to the repo"""
2370 return self._repo.commitctx(self)
2370 return self._repo.commitctx(self)
2371
2371
2372 @property
2372 @property
2373 def _manifest(self):
2373 def _manifest(self):
2374 return self._originalctx.manifest()
2374 return self._originalctx.manifest()
2375
2375
2376 @propertycache
2376 @propertycache
2377 def _status(self):
2377 def _status(self):
2378 """Calculate exact status from ``files`` specified in the ``origctx``
2378 """Calculate exact status from ``files`` specified in the ``origctx``
2379 and parents manifests.
2379 and parents manifests.
2380 """
2380 """
2381 man1 = self.p1().manifest()
2381 man1 = self.p1().manifest()
2382 p2 = self._parents[1]
2382 p2 = self._parents[1]
2383 # "1 < len(self._parents)" can't be used for checking
2383 # "1 < len(self._parents)" can't be used for checking
2384 # existence of the 2nd parent, because "metadataonlyctx._parents" is
2384 # existence of the 2nd parent, because "metadataonlyctx._parents" is
2385 # explicitly initialized by the list, of which length is 2.
2385 # explicitly initialized by the list, of which length is 2.
2386 if p2.node() != nullid:
2386 if p2.node() != nullid:
2387 man2 = p2.manifest()
2387 man2 = p2.manifest()
2388 managing = lambda f: f in man1 or f in man2
2388 managing = lambda f: f in man1 or f in man2
2389 else:
2389 else:
2390 managing = lambda f: f in man1
2390 managing = lambda f: f in man1
2391
2391
2392 modified, added, removed = [], [], []
2392 modified, added, removed = [], [], []
2393 for f in self._files:
2393 for f in self._files:
2394 if not managing(f):
2394 if not managing(f):
2395 added.append(f)
2395 added.append(f)
2396 elif f in self:
2396 elif f in self:
2397 modified.append(f)
2397 modified.append(f)
2398 else:
2398 else:
2399 removed.append(f)
2399 removed.append(f)
2400
2400
2401 return scmutil.status(modified, added, removed, [], [], [], [])
2401 return scmutil.status(modified, added, removed, [], [], [], [])
2402
2402
2403 class arbitraryfilectx(object):
2403 class arbitraryfilectx(object):
2404 """Allows you to use filectx-like functions on a file in an arbitrary
2404 """Allows you to use filectx-like functions on a file in an arbitrary
2405 location on disk, possibly not in the working directory.
2405 location on disk, possibly not in the working directory.
2406 """
2406 """
2407 def __init__(self, path, repo=None):
2407 def __init__(self, path, repo=None):
2408 # Repo is optional because contrib/simplemerge uses this class.
2408 # Repo is optional because contrib/simplemerge uses this class.
2409 self._repo = repo
2409 self._repo = repo
2410 self._path = path
2410 self._path = path
2411
2411
2412 def cmp(self, fctx):
2412 def cmp(self, fctx):
2413 # filecmp follows symlinks whereas `cmp` should not, so skip the fast
2413 # filecmp follows symlinks whereas `cmp` should not, so skip the fast
2414 # path if either side is a symlink.
2414 # path if either side is a symlink.
2415 symlinks = ('l' in self.flags() or 'l' in fctx.flags())
2415 symlinks = ('l' in self.flags() or 'l' in fctx.flags())
2416 if not symlinks and isinstance(fctx, workingfilectx) and self._repo:
2416 if not symlinks and isinstance(fctx, workingfilectx) and self._repo:
2417 # Add a fast-path for merge if both sides are disk-backed.
2417 # Add a fast-path for merge if both sides are disk-backed.
2418 # Note that filecmp uses the opposite return values (True if same)
2418 # Note that filecmp uses the opposite return values (True if same)
2419 # from our cmp functions (True if different).
2419 # from our cmp functions (True if different).
2420 return not filecmp.cmp(self.path(), self._repo.wjoin(fctx.path()))
2420 return not filecmp.cmp(self.path(), self._repo.wjoin(fctx.path()))
2421 return self.data() != fctx.data()
2421 return self.data() != fctx.data()
2422
2422
2423 def path(self):
2423 def path(self):
2424 return self._path
2424 return self._path
2425
2425
2426 def flags(self):
2426 def flags(self):
2427 return ''
2427 return ''
2428
2428
2429 def data(self):
2429 def data(self):
2430 return util.readfile(self._path)
2430 return util.readfile(self._path)
2431
2431
2432 def decodeddata(self):
2432 def decodeddata(self):
2433 with open(self._path, "rb") as f:
2433 with open(self._path, "rb") as f:
2434 return f.read()
2434 return f.read()
2435
2435
2436 def remove(self):
2436 def remove(self):
2437 util.unlink(self._path)
2437 util.unlink(self._path)
2438
2438
2439 def write(self, data, flags, **kwargs):
2439 def write(self, data, flags, **kwargs):
2440 assert not flags
2440 assert not flags
2441 with open(self._path, "wb") as f:
2441 with open(self._path, "wb") as f:
2442 f.write(data)
2442 f.write(data)
@@ -1,725 +1,724 b''
1 #require symlink execbit
1 #require symlink execbit
2 $ cat << EOF >> $HGRCPATH
2 $ cat << EOF >> $HGRCPATH
3 > [phases]
3 > [phases]
4 > publish=False
4 > publish=False
5 > [extensions]
5 > [extensions]
6 > amend=
6 > amend=
7 > rebase=
7 > rebase=
8 > debugdrawdag=$TESTDIR/drawdag.py
8 > debugdrawdag=$TESTDIR/drawdag.py
9 > strip=
9 > strip=
10 > [rebase]
10 > [rebase]
11 > experimental.inmemory=1
11 > experimental.inmemory=1
12 > [diff]
12 > [diff]
13 > git=1
13 > git=1
14 > [alias]
14 > [alias]
15 > tglog = log -G --template "{rev}: {node|short} '{desc}'\n"
15 > tglog = log -G --template "{rev}: {node|short} '{desc}'\n"
16 > EOF
16 > EOF
17
17
18 Rebase a simple DAG:
18 Rebase a simple DAG:
19 $ hg init repo1
19 $ hg init repo1
20 $ cd repo1
20 $ cd repo1
21 $ hg debugdrawdag <<'EOS'
21 $ hg debugdrawdag <<'EOS'
22 > c b
22 > c b
23 > |/
23 > |/
24 > d
24 > d
25 > |
25 > |
26 > a
26 > a
27 > EOS
27 > EOS
28 $ hg up -C a
28 $ hg up -C a
29 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
29 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
30 $ hg tglog
30 $ hg tglog
31 o 3: 814f6bd05178 'c'
31 o 3: 814f6bd05178 'c'
32 |
32 |
33 | o 2: db0e82a16a62 'b'
33 | o 2: db0e82a16a62 'b'
34 |/
34 |/
35 o 1: 02952614a83d 'd'
35 o 1: 02952614a83d 'd'
36 |
36 |
37 @ 0: b173517d0057 'a'
37 @ 0: b173517d0057 'a'
38
38
39 $ hg cat -r 3 c
39 $ hg cat -r 3 c
40 c (no-eol)
40 c (no-eol)
41 $ hg cat -r 2 b
41 $ hg cat -r 2 b
42 b (no-eol)
42 b (no-eol)
43 $ hg rebase --debug -r b -d c | grep rebasing
43 $ hg rebase --debug -r b -d c | grep rebasing
44 rebasing in-memory
44 rebasing in-memory
45 rebasing 2:db0e82a16a62 "b" (b)
45 rebasing 2:db0e82a16a62 "b" (b)
46 $ hg tglog
46 $ hg tglog
47 o 3: ca58782ad1e4 'b'
47 o 3: ca58782ad1e4 'b'
48 |
48 |
49 o 2: 814f6bd05178 'c'
49 o 2: 814f6bd05178 'c'
50 |
50 |
51 o 1: 02952614a83d 'd'
51 o 1: 02952614a83d 'd'
52 |
52 |
53 @ 0: b173517d0057 'a'
53 @ 0: b173517d0057 'a'
54
54
55 $ hg cat -r 3 b
55 $ hg cat -r 3 b
56 b (no-eol)
56 b (no-eol)
57 $ hg cat -r 2 c
57 $ hg cat -r 2 c
58 c (no-eol)
58 c (no-eol)
59 $ cd ..
59 $ cd ..
60
60
61 Case 2:
61 Case 2:
62 $ hg init repo2
62 $ hg init repo2
63 $ cd repo2
63 $ cd repo2
64 $ hg debugdrawdag <<'EOS'
64 $ hg debugdrawdag <<'EOS'
65 > c b
65 > c b
66 > |/
66 > |/
67 > d
67 > d
68 > |
68 > |
69 > a
69 > a
70 > EOS
70 > EOS
71
71
72 Add a symlink and executable file:
72 Add a symlink and executable file:
73 $ hg up -C c
73 $ hg up -C c
74 3 files updated, 0 files merged, 0 files removed, 0 files unresolved
74 3 files updated, 0 files merged, 0 files removed, 0 files unresolved
75 $ ln -s somefile e
75 $ ln -s somefile e
76 $ echo f > f
76 $ echo f > f
77 $ chmod +x f
77 $ chmod +x f
78 $ hg add e f
78 $ hg add e f
79 $ hg amend -q
79 $ hg amend -q
80 $ hg up -Cq a
80 $ hg up -Cq a
81
81
82 Write files to the working copy, and ensure they're still there after the rebase
82 Write files to the working copy, and ensure they're still there after the rebase
83 $ echo "abc" > a
83 $ echo "abc" > a
84 $ ln -s def b
84 $ ln -s def b
85 $ echo "ghi" > c
85 $ echo "ghi" > c
86 $ echo "jkl" > d
86 $ echo "jkl" > d
87 $ echo "mno" > e
87 $ echo "mno" > e
88 $ hg tglog
88 $ hg tglog
89 o 3: f56b71190a8f 'c'
89 o 3: f56b71190a8f 'c'
90 |
90 |
91 | o 2: db0e82a16a62 'b'
91 | o 2: db0e82a16a62 'b'
92 |/
92 |/
93 o 1: 02952614a83d 'd'
93 o 1: 02952614a83d 'd'
94 |
94 |
95 @ 0: b173517d0057 'a'
95 @ 0: b173517d0057 'a'
96
96
97 $ hg cat -r 3 c
97 $ hg cat -r 3 c
98 c (no-eol)
98 c (no-eol)
99 $ hg cat -r 2 b
99 $ hg cat -r 2 b
100 b (no-eol)
100 b (no-eol)
101 $ hg cat -r 3 e
101 $ hg cat -r 3 e
102 somefile (no-eol)
102 somefile (no-eol)
103 $ hg rebase --debug -s b -d a | grep rebasing
103 $ hg rebase --debug -s b -d a | grep rebasing
104 rebasing in-memory
104 rebasing in-memory
105 rebasing 2:db0e82a16a62 "b" (b)
105 rebasing 2:db0e82a16a62 "b" (b)
106 $ hg tglog
106 $ hg tglog
107 o 3: fc055c3b4d33 'b'
107 o 3: fc055c3b4d33 'b'
108 |
108 |
109 | o 2: f56b71190a8f 'c'
109 | o 2: f56b71190a8f 'c'
110 | |
110 | |
111 | o 1: 02952614a83d 'd'
111 | o 1: 02952614a83d 'd'
112 |/
112 |/
113 @ 0: b173517d0057 'a'
113 @ 0: b173517d0057 'a'
114
114
115 $ hg cat -r 2 c
115 $ hg cat -r 2 c
116 c (no-eol)
116 c (no-eol)
117 $ hg cat -r 3 b
117 $ hg cat -r 3 b
118 b (no-eol)
118 b (no-eol)
119 $ hg rebase --debug -s 1 -d 3 | grep rebasing
119 $ hg rebase --debug -s 1 -d 3 | grep rebasing
120 rebasing in-memory
120 rebasing in-memory
121 rebasing 1:02952614a83d "d" (d)
121 rebasing 1:02952614a83d "d" (d)
122 rebasing 2:f56b71190a8f "c"
122 rebasing 2:f56b71190a8f "c"
123 $ hg tglog
123 $ hg tglog
124 o 3: 753feb6fd12a 'c'
124 o 3: 753feb6fd12a 'c'
125 |
125 |
126 o 2: 09c044d2cb43 'd'
126 o 2: 09c044d2cb43 'd'
127 |
127 |
128 o 1: fc055c3b4d33 'b'
128 o 1: fc055c3b4d33 'b'
129 |
129 |
130 @ 0: b173517d0057 'a'
130 @ 0: b173517d0057 'a'
131
131
132 Ensure working copy files are still there:
132 Ensure working copy files are still there:
133 $ cat a
133 $ cat a
134 abc
134 abc
135 $ readlink.py b
135 $ readlink.py b
136 b -> def
136 b -> def
137 $ cat e
137 $ cat e
138 mno
138 mno
139
139
140 Ensure symlink and executable files were rebased properly:
140 Ensure symlink and executable files were rebased properly:
141 $ hg up -Cq 3
141 $ hg up -Cq 3
142 $ readlink.py e
142 $ readlink.py e
143 e -> somefile
143 e -> somefile
144 $ ls -l f | cut -c -10
144 $ ls -l f | cut -c -10
145 -rwxr-xr-x
145 -rwxr-xr-x
146
146
147 Rebase the working copy parent
147 Rebase the working copy parent
148 $ hg up -C 3
148 $ hg up -C 3
149 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
149 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
150 $ hg rebase -r 3 -d 0 --debug | grep rebasing
150 $ hg rebase -r 3 -d 0 --debug | grep rebasing
151 rebasing in-memory
151 rebasing in-memory
152 rebasing 3:753feb6fd12a "c" (tip)
152 rebasing 3:753feb6fd12a "c" (tip)
153 $ hg tglog
153 $ hg tglog
154 @ 3: 844a7de3e617 'c'
154 @ 3: 844a7de3e617 'c'
155 |
155 |
156 | o 2: 09c044d2cb43 'd'
156 | o 2: 09c044d2cb43 'd'
157 | |
157 | |
158 | o 1: fc055c3b4d33 'b'
158 | o 1: fc055c3b4d33 'b'
159 |/
159 |/
160 o 0: b173517d0057 'a'
160 o 0: b173517d0057 'a'
161
161
162
162
163 Test reporting of path conflicts
163 Test reporting of path conflicts
164
164
165 $ hg rm a
165 $ hg rm a
166 $ mkdir a
166 $ mkdir a
167 $ touch a/a
167 $ touch a/a
168 $ hg ci -Am "a/a"
168 $ hg ci -Am "a/a"
169 adding a/a
169 adding a/a
170 $ hg tglog
170 $ hg tglog
171 @ 4: daf7dfc139cb 'a/a'
171 @ 4: daf7dfc139cb 'a/a'
172 |
172 |
173 o 3: 844a7de3e617 'c'
173 o 3: 844a7de3e617 'c'
174 |
174 |
175 | o 2: 09c044d2cb43 'd'
175 | o 2: 09c044d2cb43 'd'
176 | |
176 | |
177 | o 1: fc055c3b4d33 'b'
177 | o 1: fc055c3b4d33 'b'
178 |/
178 |/
179 o 0: b173517d0057 'a'
179 o 0: b173517d0057 'a'
180
180
181 $ hg rebase -r . -d 2
181 $ hg rebase -r . -d 2
182 rebasing 4:daf7dfc139cb "a/a" (tip)
182 rebasing 4:daf7dfc139cb "a/a" (tip)
183 saved backup bundle to $TESTTMP/repo2/.hg/strip-backup/daf7dfc139cb-fdbfcf4f-rebase.hg
183 saved backup bundle to $TESTTMP/repo2/.hg/strip-backup/daf7dfc139cb-fdbfcf4f-rebase.hg
184
184
185 $ hg tglog
185 $ hg tglog
186 @ 4: c6ad37a4f250 'a/a'
186 @ 4: c6ad37a4f250 'a/a'
187 |
187 |
188 | o 3: 844a7de3e617 'c'
188 | o 3: 844a7de3e617 'c'
189 | |
189 | |
190 o | 2: 09c044d2cb43 'd'
190 o | 2: 09c044d2cb43 'd'
191 | |
191 | |
192 o | 1: fc055c3b4d33 'b'
192 o | 1: fc055c3b4d33 'b'
193 |/
193 |/
194 o 0: b173517d0057 'a'
194 o 0: b173517d0057 'a'
195
195
196 $ echo foo > foo
196 $ echo foo > foo
197 $ hg ci -Aqm "added foo"
197 $ hg ci -Aqm "added foo"
198 $ hg up '.^'
198 $ hg up '.^'
199 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
199 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
200 $ echo bar > bar
200 $ echo bar > bar
201 $ hg ci -Aqm "added bar"
201 $ hg ci -Aqm "added bar"
202 $ hg rm a/a
202 $ hg rm a/a
203 $ echo a > a
203 $ echo a > a
204 $ hg ci -Aqm "added a back!"
204 $ hg ci -Aqm "added a back!"
205 $ hg tglog
205 $ hg tglog
206 @ 7: 855e9797387e 'added a back!'
206 @ 7: 855e9797387e 'added a back!'
207 |
207 |
208 o 6: d14530e5e3e6 'added bar'
208 o 6: d14530e5e3e6 'added bar'
209 |
209 |
210 | o 5: 9b94b9373deb 'added foo'
210 | o 5: 9b94b9373deb 'added foo'
211 |/
211 |/
212 o 4: c6ad37a4f250 'a/a'
212 o 4: c6ad37a4f250 'a/a'
213 |
213 |
214 | o 3: 844a7de3e617 'c'
214 | o 3: 844a7de3e617 'c'
215 | |
215 | |
216 o | 2: 09c044d2cb43 'd'
216 o | 2: 09c044d2cb43 'd'
217 | |
217 | |
218 o | 1: fc055c3b4d33 'b'
218 o | 1: fc055c3b4d33 'b'
219 |/
219 |/
220 o 0: b173517d0057 'a'
220 o 0: b173517d0057 'a'
221
221
222 $ hg rebase -r . -d 5
222 $ hg rebase -r . -d 5
223 rebasing 7:855e9797387e "added a back!" (tip)
223 rebasing 7:855e9797387e "added a back!" (tip)
224 saved backup bundle to $TESTTMP/repo2/.hg/strip-backup/855e9797387e-81ee4c5d-rebase.hg
224 saved backup bundle to $TESTTMP/repo2/.hg/strip-backup/855e9797387e-81ee4c5d-rebase.hg
225
225
226 $ hg tglog
226 $ hg tglog
227 @ 7: bb3f02be2688 'added a back!'
227 @ 7: bb3f02be2688 'added a back!'
228 |
228 |
229 | o 6: d14530e5e3e6 'added bar'
229 | o 6: d14530e5e3e6 'added bar'
230 | |
230 | |
231 o | 5: 9b94b9373deb 'added foo'
231 o | 5: 9b94b9373deb 'added foo'
232 |/
232 |/
233 o 4: c6ad37a4f250 'a/a'
233 o 4: c6ad37a4f250 'a/a'
234 |
234 |
235 | o 3: 844a7de3e617 'c'
235 | o 3: 844a7de3e617 'c'
236 | |
236 | |
237 o | 2: 09c044d2cb43 'd'
237 o | 2: 09c044d2cb43 'd'
238 | |
238 | |
239 o | 1: fc055c3b4d33 'b'
239 o | 1: fc055c3b4d33 'b'
240 |/
240 |/
241 o 0: b173517d0057 'a'
241 o 0: b173517d0057 'a'
242
242
243 $ mkdir c
243 $ mkdir c
244 $ echo c > c/c
244 $ echo c > c/c
245 $ hg add c/c
245 $ hg add c/c
246 $ hg ci -m 'c/c'
246 $ hg ci -m 'c/c'
247 $ hg rebase -r . -d 3 -n
247 $ hg rebase -r . -d 3 -n
248 starting dry-run rebase; repository will not be changed
248 starting dry-run rebase; repository will not be changed
249 rebasing 8:755f0104af9b "c/c" (tip)
249 rebasing 8:755f0104af9b "c/c" (tip)
250 abort: error: 'c/c' conflicts with file 'c' in 3.
250 abort: error: 'c/c' conflicts with file 'c' in 3.
251 [255]
251 [255]
252 $ hg rebase -r 3 -d . -n
252 $ hg rebase -r 3 -d . -n
253 starting dry-run rebase; repository will not be changed
253 starting dry-run rebase; repository will not be changed
254 rebasing 3:844a7de3e617 "c"
254 rebasing 3:844a7de3e617 "c"
255 abort: error: file 'c' cannot be written because 'c/' is a folder in 755f0104af9b (containing 1 entries: c/c)
255 abort: error: file 'c' cannot be written because 'c/' is a folder in 755f0104af9b (containing 1 entries: c/c)
256 [255]
256 [255]
257
257
258 $ cd ..
258 $ cd ..
259
259
260 Test path auditing (issue5818)
260 Test path auditing (issue5818)
261
261
262 $ mkdir lib_
262 $ mkdir lib_
263 $ ln -s lib_ lib
263 $ ln -s lib_ lib
264 $ hg init repo
264 $ hg init repo
265 $ cd repo
265 $ cd repo
266 $ mkdir -p ".$TESTTMP/lib"
266 $ mkdir -p ".$TESTTMP/lib"
267 $ touch ".$TESTTMP/lib/a"
267 $ touch ".$TESTTMP/lib/a"
268 $ hg add ".$TESTTMP/lib/a"
268 $ hg add ".$TESTTMP/lib/a"
269 $ hg ci -m 'a'
269 $ hg ci -m 'a'
270
270
271 $ touch ".$TESTTMP/lib/b"
271 $ touch ".$TESTTMP/lib/b"
272 $ hg add ".$TESTTMP/lib/b"
272 $ hg add ".$TESTTMP/lib/b"
273 $ hg ci -m 'b'
273 $ hg ci -m 'b'
274
274
275 $ hg up -q '.^'
275 $ hg up -q '.^'
276 $ touch ".$TESTTMP/lib/c"
276 $ touch ".$TESTTMP/lib/c"
277 $ hg add ".$TESTTMP/lib/c"
277 $ hg add ".$TESTTMP/lib/c"
278 $ hg ci -m 'c'
278 $ hg ci -m 'c'
279 created new head
279 created new head
280 $ hg rebase -s 1 -d .
280 $ hg rebase -s 1 -d .
281 rebasing 1:* "b" (glob)
281 rebasing 1:* "b" (glob)
282 abort: path '*/lib/b' traverses symbolic link '*/lib' (glob)
282 saved backup bundle to $TESTTMP/repo/.hg/strip-backup/*-rebase.hg (glob)
283 [255]
284 $ cd ..
283 $ cd ..
285
284
286 Test dry-run rebasing
285 Test dry-run rebasing
287
286
288 $ hg init repo3
287 $ hg init repo3
289 $ cd repo3
288 $ cd repo3
290 $ echo a>a
289 $ echo a>a
291 $ hg ci -Aqma
290 $ hg ci -Aqma
292 $ echo b>b
291 $ echo b>b
293 $ hg ci -Aqmb
292 $ hg ci -Aqmb
294 $ echo c>c
293 $ echo c>c
295 $ hg ci -Aqmc
294 $ hg ci -Aqmc
296 $ echo d>d
295 $ echo d>d
297 $ hg ci -Aqmd
296 $ hg ci -Aqmd
298 $ echo e>e
297 $ echo e>e
299 $ hg ci -Aqme
298 $ hg ci -Aqme
300
299
301 $ hg up 1 -q
300 $ hg up 1 -q
302 $ echo f>f
301 $ echo f>f
303 $ hg ci -Amf
302 $ hg ci -Amf
304 adding f
303 adding f
305 created new head
304 created new head
306 $ echo g>g
305 $ echo g>g
307 $ hg ci -Aqmg
306 $ hg ci -Aqmg
308 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
307 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
309 @ 6:baf10c5166d4 test
308 @ 6:baf10c5166d4 test
310 | g
309 | g
311 |
310 |
312 o 5:6343ca3eff20 test
311 o 5:6343ca3eff20 test
313 | f
312 | f
314 |
313 |
315 | o 4:e860deea161a test
314 | o 4:e860deea161a test
316 | | e
315 | | e
317 | |
316 | |
318 | o 3:055a42cdd887 test
317 | o 3:055a42cdd887 test
319 | | d
318 | | d
320 | |
319 | |
321 | o 2:177f92b77385 test
320 | o 2:177f92b77385 test
322 |/ c
321 |/ c
323 |
322 |
324 o 1:d2ae7f538514 test
323 o 1:d2ae7f538514 test
325 | b
324 | b
326 |
325 |
327 o 0:cb9a9f314b8b test
326 o 0:cb9a9f314b8b test
328 a
327 a
329
328
330 Make sure it throws error while passing --continue or --abort with --dry-run
329 Make sure it throws error while passing --continue or --abort with --dry-run
331 $ hg rebase -s 2 -d 6 -n --continue
330 $ hg rebase -s 2 -d 6 -n --continue
332 abort: cannot specify both --dry-run and --continue
331 abort: cannot specify both --dry-run and --continue
333 [255]
332 [255]
334 $ hg rebase -s 2 -d 6 -n --abort
333 $ hg rebase -s 2 -d 6 -n --abort
335 abort: cannot specify both --dry-run and --abort
334 abort: cannot specify both --dry-run and --abort
336 [255]
335 [255]
337
336
338 Check dryrun gives correct results when there is no conflict in rebasing
337 Check dryrun gives correct results when there is no conflict in rebasing
339 $ hg rebase -s 2 -d 6 -n
338 $ hg rebase -s 2 -d 6 -n
340 starting dry-run rebase; repository will not be changed
339 starting dry-run rebase; repository will not be changed
341 rebasing 2:177f92b77385 "c"
340 rebasing 2:177f92b77385 "c"
342 rebasing 3:055a42cdd887 "d"
341 rebasing 3:055a42cdd887 "d"
343 rebasing 4:e860deea161a "e"
342 rebasing 4:e860deea161a "e"
344 dry-run rebase completed successfully; run without -n/--dry-run to perform this rebase
343 dry-run rebase completed successfully; run without -n/--dry-run to perform this rebase
345
344
346 $ hg diff
345 $ hg diff
347 $ hg status
346 $ hg status
348
347
349 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
348 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
350 @ 6:baf10c5166d4 test
349 @ 6:baf10c5166d4 test
351 | g
350 | g
352 |
351 |
353 o 5:6343ca3eff20 test
352 o 5:6343ca3eff20 test
354 | f
353 | f
355 |
354 |
356 | o 4:e860deea161a test
355 | o 4:e860deea161a test
357 | | e
356 | | e
358 | |
357 | |
359 | o 3:055a42cdd887 test
358 | o 3:055a42cdd887 test
360 | | d
359 | | d
361 | |
360 | |
362 | o 2:177f92b77385 test
361 | o 2:177f92b77385 test
363 |/ c
362 |/ c
364 |
363 |
365 o 1:d2ae7f538514 test
364 o 1:d2ae7f538514 test
366 | b
365 | b
367 |
366 |
368 o 0:cb9a9f314b8b test
367 o 0:cb9a9f314b8b test
369 a
368 a
370
369
371 Check dryrun working with --collapse when there is no conflict
370 Check dryrun working with --collapse when there is no conflict
372 $ hg rebase -s 2 -d 6 -n --collapse
371 $ hg rebase -s 2 -d 6 -n --collapse
373 starting dry-run rebase; repository will not be changed
372 starting dry-run rebase; repository will not be changed
374 rebasing 2:177f92b77385 "c"
373 rebasing 2:177f92b77385 "c"
375 rebasing 3:055a42cdd887 "d"
374 rebasing 3:055a42cdd887 "d"
376 rebasing 4:e860deea161a "e"
375 rebasing 4:e860deea161a "e"
377 dry-run rebase completed successfully; run without -n/--dry-run to perform this rebase
376 dry-run rebase completed successfully; run without -n/--dry-run to perform this rebase
378
377
379 Check dryrun gives correct results when there is conflict in rebasing
378 Check dryrun gives correct results when there is conflict in rebasing
380 Make a conflict:
379 Make a conflict:
381 $ hg up 6 -q
380 $ hg up 6 -q
382 $ echo conflict>e
381 $ echo conflict>e
383 $ hg ci -Aqm "conflict with e"
382 $ hg ci -Aqm "conflict with e"
384 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
383 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
385 @ 7:d2c195b28050 test
384 @ 7:d2c195b28050 test
386 | conflict with e
385 | conflict with e
387 |
386 |
388 o 6:baf10c5166d4 test
387 o 6:baf10c5166d4 test
389 | g
388 | g
390 |
389 |
391 o 5:6343ca3eff20 test
390 o 5:6343ca3eff20 test
392 | f
391 | f
393 |
392 |
394 | o 4:e860deea161a test
393 | o 4:e860deea161a test
395 | | e
394 | | e
396 | |
395 | |
397 | o 3:055a42cdd887 test
396 | o 3:055a42cdd887 test
398 | | d
397 | | d
399 | |
398 | |
400 | o 2:177f92b77385 test
399 | o 2:177f92b77385 test
401 |/ c
400 |/ c
402 |
401 |
403 o 1:d2ae7f538514 test
402 o 1:d2ae7f538514 test
404 | b
403 | b
405 |
404 |
406 o 0:cb9a9f314b8b test
405 o 0:cb9a9f314b8b test
407 a
406 a
408
407
409 $ hg rebase -s 2 -d 7 -n
408 $ hg rebase -s 2 -d 7 -n
410 starting dry-run rebase; repository will not be changed
409 starting dry-run rebase; repository will not be changed
411 rebasing 2:177f92b77385 "c"
410 rebasing 2:177f92b77385 "c"
412 rebasing 3:055a42cdd887 "d"
411 rebasing 3:055a42cdd887 "d"
413 rebasing 4:e860deea161a "e"
412 rebasing 4:e860deea161a "e"
414 merging e
413 merging e
415 transaction abort!
414 transaction abort!
416 rollback completed
415 rollback completed
417 hit a merge conflict
416 hit a merge conflict
418 [1]
417 [1]
419 $ hg diff
418 $ hg diff
420 $ hg status
419 $ hg status
421 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
420 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
422 @ 7:d2c195b28050 test
421 @ 7:d2c195b28050 test
423 | conflict with e
422 | conflict with e
424 |
423 |
425 o 6:baf10c5166d4 test
424 o 6:baf10c5166d4 test
426 | g
425 | g
427 |
426 |
428 o 5:6343ca3eff20 test
427 o 5:6343ca3eff20 test
429 | f
428 | f
430 |
429 |
431 | o 4:e860deea161a test
430 | o 4:e860deea161a test
432 | | e
431 | | e
433 | |
432 | |
434 | o 3:055a42cdd887 test
433 | o 3:055a42cdd887 test
435 | | d
434 | | d
436 | |
435 | |
437 | o 2:177f92b77385 test
436 | o 2:177f92b77385 test
438 |/ c
437 |/ c
439 |
438 |
440 o 1:d2ae7f538514 test
439 o 1:d2ae7f538514 test
441 | b
440 | b
442 |
441 |
443 o 0:cb9a9f314b8b test
442 o 0:cb9a9f314b8b test
444 a
443 a
445
444
446 Check dryrun working with --collapse when there is conflicts
445 Check dryrun working with --collapse when there is conflicts
447 $ hg rebase -s 2 -d 7 -n --collapse
446 $ hg rebase -s 2 -d 7 -n --collapse
448 starting dry-run rebase; repository will not be changed
447 starting dry-run rebase; repository will not be changed
449 rebasing 2:177f92b77385 "c"
448 rebasing 2:177f92b77385 "c"
450 rebasing 3:055a42cdd887 "d"
449 rebasing 3:055a42cdd887 "d"
451 rebasing 4:e860deea161a "e"
450 rebasing 4:e860deea161a "e"
452 merging e
451 merging e
453 hit a merge conflict
452 hit a merge conflict
454 [1]
453 [1]
455
454
456 In-memory rebase that fails due to merge conflicts
455 In-memory rebase that fails due to merge conflicts
457
456
458 $ hg rebase -s 2 -d 7
457 $ hg rebase -s 2 -d 7
459 rebasing 2:177f92b77385 "c"
458 rebasing 2:177f92b77385 "c"
460 rebasing 3:055a42cdd887 "d"
459 rebasing 3:055a42cdd887 "d"
461 rebasing 4:e860deea161a "e"
460 rebasing 4:e860deea161a "e"
462 merging e
461 merging e
463 transaction abort!
462 transaction abort!
464 rollback completed
463 rollback completed
465 hit merge conflicts; re-running rebase without in-memory merge
464 hit merge conflicts; re-running rebase without in-memory merge
466 rebasing 2:177f92b77385 "c"
465 rebasing 2:177f92b77385 "c"
467 rebasing 3:055a42cdd887 "d"
466 rebasing 3:055a42cdd887 "d"
468 rebasing 4:e860deea161a "e"
467 rebasing 4:e860deea161a "e"
469 merging e
468 merging e
470 warning: conflicts while merging e! (edit, then use 'hg resolve --mark')
469 warning: conflicts while merging e! (edit, then use 'hg resolve --mark')
471 unresolved conflicts (see hg resolve, then hg rebase --continue)
470 unresolved conflicts (see hg resolve, then hg rebase --continue)
472 [1]
471 [1]
473 $ hg rebase --abort
472 $ hg rebase --abort
474 saved backup bundle to $TESTTMP/repo3/.hg/strip-backup/c1e524d4287c-f91f82e1-backup.hg
473 saved backup bundle to $TESTTMP/repo3/.hg/strip-backup/c1e524d4287c-f91f82e1-backup.hg
475 rebase aborted
474 rebase aborted
476
475
477 Retrying without in-memory merge won't lose working copy changes
476 Retrying without in-memory merge won't lose working copy changes
478 $ cd ..
477 $ cd ..
479 $ hg clone repo3 repo3-dirty -q
478 $ hg clone repo3 repo3-dirty -q
480 $ cd repo3-dirty
479 $ cd repo3-dirty
481 $ echo dirty > a
480 $ echo dirty > a
482 $ hg rebase -s 2 -d 7
481 $ hg rebase -s 2 -d 7
483 rebasing 2:177f92b77385 "c"
482 rebasing 2:177f92b77385 "c"
484 rebasing 3:055a42cdd887 "d"
483 rebasing 3:055a42cdd887 "d"
485 rebasing 4:e860deea161a "e"
484 rebasing 4:e860deea161a "e"
486 merging e
485 merging e
487 transaction abort!
486 transaction abort!
488 rollback completed
487 rollback completed
489 hit merge conflicts; re-running rebase without in-memory merge
488 hit merge conflicts; re-running rebase without in-memory merge
490 abort: uncommitted changes
489 abort: uncommitted changes
491 [255]
490 [255]
492 $ cat a
491 $ cat a
493 dirty
492 dirty
494
493
495 Retrying without in-memory merge won't lose merge state
494 Retrying without in-memory merge won't lose merge state
496 $ cd ..
495 $ cd ..
497 $ hg clone repo3 repo3-merge-state -q
496 $ hg clone repo3 repo3-merge-state -q
498 $ cd repo3-merge-state
497 $ cd repo3-merge-state
499 $ hg merge 4
498 $ hg merge 4
500 merging e
499 merging e
501 warning: conflicts while merging e! (edit, then use 'hg resolve --mark')
500 warning: conflicts while merging e! (edit, then use 'hg resolve --mark')
502 2 files updated, 0 files merged, 0 files removed, 1 files unresolved
501 2 files updated, 0 files merged, 0 files removed, 1 files unresolved
503 use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
502 use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
504 [1]
503 [1]
505 $ hg resolve -l
504 $ hg resolve -l
506 U e
505 U e
507 $ hg rebase -s 2 -d 7
506 $ hg rebase -s 2 -d 7
508 rebasing 2:177f92b77385 "c"
507 rebasing 2:177f92b77385 "c"
509 abort: outstanding merge conflicts
508 abort: outstanding merge conflicts
510 [255]
509 [255]
511 $ hg resolve -l
510 $ hg resolve -l
512 U e
511 U e
513
512
514 ==========================
513 ==========================
515 Test for --confirm option|
514 Test for --confirm option|
516 ==========================
515 ==========================
517 $ cd ..
516 $ cd ..
518 $ hg clone repo3 repo4 -q
517 $ hg clone repo3 repo4 -q
519 $ cd repo4
518 $ cd repo4
520 $ hg strip 7 -q
519 $ hg strip 7 -q
521 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
520 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
522 @ 6:baf10c5166d4 test
521 @ 6:baf10c5166d4 test
523 | g
522 | g
524 |
523 |
525 o 5:6343ca3eff20 test
524 o 5:6343ca3eff20 test
526 | f
525 | f
527 |
526 |
528 | o 4:e860deea161a test
527 | o 4:e860deea161a test
529 | | e
528 | | e
530 | |
529 | |
531 | o 3:055a42cdd887 test
530 | o 3:055a42cdd887 test
532 | | d
531 | | d
533 | |
532 | |
534 | o 2:177f92b77385 test
533 | o 2:177f92b77385 test
535 |/ c
534 |/ c
536 |
535 |
537 o 1:d2ae7f538514 test
536 o 1:d2ae7f538514 test
538 | b
537 | b
539 |
538 |
540 o 0:cb9a9f314b8b test
539 o 0:cb9a9f314b8b test
541 a
540 a
542
541
543 Check it gives error when both --dryrun and --confirm is used:
542 Check it gives error when both --dryrun and --confirm is used:
544 $ hg rebase -s 2 -d . --confirm --dry-run
543 $ hg rebase -s 2 -d . --confirm --dry-run
545 abort: cannot specify both --confirm and --dry-run
544 abort: cannot specify both --confirm and --dry-run
546 [255]
545 [255]
547 $ hg rebase -s 2 -d . --confirm --abort
546 $ hg rebase -s 2 -d . --confirm --abort
548 abort: cannot specify both --confirm and --abort
547 abort: cannot specify both --confirm and --abort
549 [255]
548 [255]
550 $ hg rebase -s 2 -d . --confirm --continue
549 $ hg rebase -s 2 -d . --confirm --continue
551 abort: cannot specify both --confirm and --continue
550 abort: cannot specify both --confirm and --continue
552 [255]
551 [255]
553
552
554 Test --confirm option when there are no conflicts:
553 Test --confirm option when there are no conflicts:
555 $ hg rebase -s 2 -d . --keep --config ui.interactive=True --confirm << EOF
554 $ hg rebase -s 2 -d . --keep --config ui.interactive=True --confirm << EOF
556 > n
555 > n
557 > EOF
556 > EOF
558 starting in-memory rebase
557 starting in-memory rebase
559 rebasing 2:177f92b77385 "c"
558 rebasing 2:177f92b77385 "c"
560 rebasing 3:055a42cdd887 "d"
559 rebasing 3:055a42cdd887 "d"
561 rebasing 4:e860deea161a "e"
560 rebasing 4:e860deea161a "e"
562 rebase completed successfully
561 rebase completed successfully
563 apply changes (yn)? n
562 apply changes (yn)? n
564 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
563 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
565 @ 6:baf10c5166d4 test
564 @ 6:baf10c5166d4 test
566 | g
565 | g
567 |
566 |
568 o 5:6343ca3eff20 test
567 o 5:6343ca3eff20 test
569 | f
568 | f
570 |
569 |
571 | o 4:e860deea161a test
570 | o 4:e860deea161a test
572 | | e
571 | | e
573 | |
572 | |
574 | o 3:055a42cdd887 test
573 | o 3:055a42cdd887 test
575 | | d
574 | | d
576 | |
575 | |
577 | o 2:177f92b77385 test
576 | o 2:177f92b77385 test
578 |/ c
577 |/ c
579 |
578 |
580 o 1:d2ae7f538514 test
579 o 1:d2ae7f538514 test
581 | b
580 | b
582 |
581 |
583 o 0:cb9a9f314b8b test
582 o 0:cb9a9f314b8b test
584 a
583 a
585
584
586 $ hg rebase -s 2 -d . --keep --config ui.interactive=True --confirm << EOF
585 $ hg rebase -s 2 -d . --keep --config ui.interactive=True --confirm << EOF
587 > y
586 > y
588 > EOF
587 > EOF
589 starting in-memory rebase
588 starting in-memory rebase
590 rebasing 2:177f92b77385 "c"
589 rebasing 2:177f92b77385 "c"
591 rebasing 3:055a42cdd887 "d"
590 rebasing 3:055a42cdd887 "d"
592 rebasing 4:e860deea161a "e"
591 rebasing 4:e860deea161a "e"
593 rebase completed successfully
592 rebase completed successfully
594 apply changes (yn)? y
593 apply changes (yn)? y
595 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
594 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
596 o 9:9fd28f55f6dc test
595 o 9:9fd28f55f6dc test
597 | e
596 | e
598 |
597 |
599 o 8:12cbf031f469 test
598 o 8:12cbf031f469 test
600 | d
599 | d
601 |
600 |
602 o 7:c83b1da5b1ae test
601 o 7:c83b1da5b1ae test
603 | c
602 | c
604 |
603 |
605 @ 6:baf10c5166d4 test
604 @ 6:baf10c5166d4 test
606 | g
605 | g
607 |
606 |
608 o 5:6343ca3eff20 test
607 o 5:6343ca3eff20 test
609 | f
608 | f
610 |
609 |
611 | o 4:e860deea161a test
610 | o 4:e860deea161a test
612 | | e
611 | | e
613 | |
612 | |
614 | o 3:055a42cdd887 test
613 | o 3:055a42cdd887 test
615 | | d
614 | | d
616 | |
615 | |
617 | o 2:177f92b77385 test
616 | o 2:177f92b77385 test
618 |/ c
617 |/ c
619 |
618 |
620 o 1:d2ae7f538514 test
619 o 1:d2ae7f538514 test
621 | b
620 | b
622 |
621 |
623 o 0:cb9a9f314b8b test
622 o 0:cb9a9f314b8b test
624 a
623 a
625
624
626 Test --confirm option when there is a conflict
625 Test --confirm option when there is a conflict
627 $ hg up tip -q
626 $ hg up tip -q
628 $ echo ee>e
627 $ echo ee>e
629 $ hg ci --amend -m "conflict with e" -q
628 $ hg ci --amend -m "conflict with e" -q
630 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
629 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
631 @ 9:906d72f66a59 test
630 @ 9:906d72f66a59 test
632 | conflict with e
631 | conflict with e
633 |
632 |
634 o 8:12cbf031f469 test
633 o 8:12cbf031f469 test
635 | d
634 | d
636 |
635 |
637 o 7:c83b1da5b1ae test
636 o 7:c83b1da5b1ae test
638 | c
637 | c
639 |
638 |
640 o 6:baf10c5166d4 test
639 o 6:baf10c5166d4 test
641 | g
640 | g
642 |
641 |
643 o 5:6343ca3eff20 test
642 o 5:6343ca3eff20 test
644 | f
643 | f
645 |
644 |
646 | o 4:e860deea161a test
645 | o 4:e860deea161a test
647 | | e
646 | | e
648 | |
647 | |
649 | o 3:055a42cdd887 test
648 | o 3:055a42cdd887 test
650 | | d
649 | | d
651 | |
650 | |
652 | o 2:177f92b77385 test
651 | o 2:177f92b77385 test
653 |/ c
652 |/ c
654 |
653 |
655 o 1:d2ae7f538514 test
654 o 1:d2ae7f538514 test
656 | b
655 | b
657 |
656 |
658 o 0:cb9a9f314b8b test
657 o 0:cb9a9f314b8b test
659 a
658 a
660
659
661 $ hg rebase -s 4 -d . --keep --confirm
660 $ hg rebase -s 4 -d . --keep --confirm
662 starting in-memory rebase
661 starting in-memory rebase
663 rebasing 4:e860deea161a "e"
662 rebasing 4:e860deea161a "e"
664 merging e
663 merging e
665 hit a merge conflict
664 hit a merge conflict
666 [1]
665 [1]
667 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
666 $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
668 @ 9:906d72f66a59 test
667 @ 9:906d72f66a59 test
669 | conflict with e
668 | conflict with e
670 |
669 |
671 o 8:12cbf031f469 test
670 o 8:12cbf031f469 test
672 | d
671 | d
673 |
672 |
674 o 7:c83b1da5b1ae test
673 o 7:c83b1da5b1ae test
675 | c
674 | c
676 |
675 |
677 o 6:baf10c5166d4 test
676 o 6:baf10c5166d4 test
678 | g
677 | g
679 |
678 |
680 o 5:6343ca3eff20 test
679 o 5:6343ca3eff20 test
681 | f
680 | f
682 |
681 |
683 | o 4:e860deea161a test
682 | o 4:e860deea161a test
684 | | e
683 | | e
685 | |
684 | |
686 | o 3:055a42cdd887 test
685 | o 3:055a42cdd887 test
687 | | d
686 | | d
688 | |
687 | |
689 | o 2:177f92b77385 test
688 | o 2:177f92b77385 test
690 |/ c
689 |/ c
691 |
690 |
692 o 1:d2ae7f538514 test
691 o 1:d2ae7f538514 test
693 | b
692 | b
694 |
693 |
695 o 0:cb9a9f314b8b test
694 o 0:cb9a9f314b8b test
696 a
695 a
697
696
698 #if execbit
697 #if execbit
699
698
700 Test a metadata-only in-memory merge
699 Test a metadata-only in-memory merge
701 $ cd $TESTTMP
700 $ cd $TESTTMP
702 $ hg init no_exception
701 $ hg init no_exception
703 $ cd no_exception
702 $ cd no_exception
704 # Produce the following graph:
703 # Produce the following graph:
705 # o 'add +x to foo.txt'
704 # o 'add +x to foo.txt'
706 # | o r1 (adds bar.txt, just for something to rebase to)
705 # | o r1 (adds bar.txt, just for something to rebase to)
707 # |/
706 # |/
708 # o r0 (adds foo.txt, no +x)
707 # o r0 (adds foo.txt, no +x)
709 $ echo hi > foo.txt
708 $ echo hi > foo.txt
710 $ hg ci -qAm r0
709 $ hg ci -qAm r0
711 $ echo hi > bar.txt
710 $ echo hi > bar.txt
712 $ hg ci -qAm r1
711 $ hg ci -qAm r1
713 $ hg co -qr ".^"
712 $ hg co -qr ".^"
714 $ chmod +x foo.txt
713 $ chmod +x foo.txt
715 $ hg ci -qAm 'add +x to foo.txt'
714 $ hg ci -qAm 'add +x to foo.txt'
716 issue5960: this was raising an AttributeError exception
715 issue5960: this was raising an AttributeError exception
717 $ hg rebase -r . -d 1
716 $ hg rebase -r . -d 1
718 rebasing 2:539b93e77479 "add +x to foo.txt" (tip)
717 rebasing 2:539b93e77479 "add +x to foo.txt" (tip)
719 saved backup bundle to $TESTTMP/no_exception/.hg/strip-backup/*.hg (glob)
718 saved backup bundle to $TESTTMP/no_exception/.hg/strip-backup/*.hg (glob)
720 $ hg diff -c tip
719 $ hg diff -c tip
721 diff --git a/foo.txt b/foo.txt
720 diff --git a/foo.txt b/foo.txt
722 old mode 100644
721 old mode 100644
723 new mode 100755
722 new mode 100755
724
723
725 #endif
724 #endif
General Comments 0
You need to be logged in to leave comments. Login now