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