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