mercurial-scm/hg-stable: mercurial/dirstate.py annotate

annotate mercurial/dirstate.py @ 26634:09bb1ee7e73e

dirstate: make writing in-memory changes aware of transaction activity This patch delays writing in-memory changes out, if transaction is running. '_getfsnow()' is defined as a function, to hook it easily for ambiguous timestamp tests (see also fakedirstatewritetime.py) 'if tr:' code path in this patch is still disabled at this revision, because there is no client invoking 'dirstate.write()' with repo object. BTW, this patch changes 'dirstate.invalidate()' semantics around 'dirstate.write()' in a transaction scope: before: with repo.transaction(): dirstate.CHANGE('A') dirstate.write() # change for A is written out here dirstate.CHANGE('B') dirstate.invalidate() # discards only change for B after: with repo.transaction(): dirstate.CHANGE('A') dirstate.write() # change for A is still kept in memory dirstate.CHANGE('B') dirstate.invalidate() # discards changes for A and B Fortunately, there is no code path expecting the former, at least, in Mercurial itself, because 'dirstateguard' was introduced to remove such 'dirstate.invalidate()'.

author	FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
date	Wed, 14 Oct 2015 02:49:17 +0900
parents	020b12d591f3
children	79d86ab65c9d

rev	line source
8226 8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	1 # dirstate.py - working directory tracking for mercurial
8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	2 #
8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	4 #
8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	5 # This software may be used and distributed according to the terms of the
10263 25e572394f5c Update license to GPLv2+ Matt Mackall <mpm@selenic.com> parents: 9678 diff changeset	6 # GNU General Public License version 2 or any later version.
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	7
6211 f89fd07fc51d Expand import * to allow Pyflakes to find problems Joel Rosdahl <joel@rosdahl.net> parents: 6201 diff changeset	8 from node import nullid
3891 6b4127c7d52a Simplify i18n imports Matt Mackall <mpm@selenic.com> parents: 3877 diff changeset	9 from i18n import _
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26521 diff changeset	10 import scmutil, util, osutil, parsers, encoding, pathutil, error
23496 ee5a4ed4c8b1 dirstate: use the 'nogc' decorator Pierre-Yves David <pierre-yves.david@fb.com> parents: 23375 diff changeset	11 import os, stat, errno
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	12 import match as matchmod
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	13
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	14 propertycache = util.propertycache
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	15 filecache = scmutil.filecache
17733 3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	16 _rangemask = 0x7fffffff
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	17
21809 e250b8300e6e parsers: inline fields of dirstate values in C version Siddharth Agarwal <sid0@fb.com> parents: 21808 diff changeset	18 dirstatetuple = parsers.dirstatetuple
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	19
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	20 class repocache(filecache):
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	21 """filecache for files in .hg/"""
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	22 def join(self, obj, fname):
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	23 return obj._opener.join(fname)
4610 274c99fc629f dirstate: simplify state() Matt Mackall <mpm@selenic.com> parents: 4609 diff changeset	24
16202 53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	25 class rootcache(filecache):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	26 """filecache for files in the repository root"""
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	27 def join(self, obj, fname):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	28 return obj._join(fname)
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	29
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	30 def _getfsnow(vfs):
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	31 '''Get "now" timestamp on filesystem'''
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	32 tmpfd, tmpname = vfs.mkstemp()
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	33 try:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	34 return util.statmtimesec(os.fstat(tmpfd))
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	35 finally:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	36 os.close(tmpfd)
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	37 vfs.unlink(tmpname)
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	38
1559 59b3639df0a9 Convert all classes to new-style classes by deriving them from object. Eric Hopper <hopper@omnifarious.org> parents: 1541 diff changeset	39 class dirstate(object):
2393 5083cba2a777 dirstate: refactor the dirstate binary format, remove magic numbers Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 2063 diff changeset	40
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	41 def __init__(self, opener, ui, root, validate):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	42 '''Create a new dirstate object.
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	43
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	44 opener is an open()-like callable that can be used to open the
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	45 dirstate file; root is the root of the directory tracked by
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	46 the dirstate.
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	47 '''
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	48 self._opener = opener
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	49 self._validate = validate
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	50 self._root = root
24198 3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	51 # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	52 # UNC path pointing to root share (issue4557)
24833 cb981009d697 dirstate: use pathutil.normasprefix to ensure os.sep at the end of root FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	53 self._rootdir = pathutil.normasprefix(root)
26294 1ffc61c4e32e hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568) Yuya Nishihara <yuya@tcha.org> parents: 26293 diff changeset	54 # internal config: ui.forcecwd
1ffc61c4e32e hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568) Yuya Nishihara <yuya@tcha.org> parents: 26293 diff changeset	55 forcecwd = ui.config('ui', 'forcecwd')
1ffc61c4e32e hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568) Yuya Nishihara <yuya@tcha.org> parents: 26293 diff changeset	56 if forcecwd:
1ffc61c4e32e hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568) Yuya Nishihara <yuya@tcha.org> parents: 26293 diff changeset	57 self._cwd = forcecwd
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	58 self._dirty = False
4965 4106dde15aed Merge with crew Matt Mackall <mpm@selenic.com> parents: 4911 4953 diff changeset	59 self._dirtypl = False
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	60 self._lastnormaltime = 0
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	61 self._ui = ui
16200 9d4a2942a732 dirstate: add filecache support Idan Kamara <idankk86@gmail.com> parents: 16143 diff changeset	62 self._filecache = {}
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	63 self._parentwriters = 0
25226 00d426a38137 dirstate: use self._filename instead of immediate string `dirstate` FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25216 diff changeset	64 self._filename = 'dirstate'
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	65 self._pendingfilename = '%s.pending' % self._filename
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	66
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	67 def beginparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	68 '''Marks the beginning of a set of changes that involve changing
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	69 the dirstate parents. If there is an exception during this time,
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	70 the dirstate will not be written when the wlock is released. This
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	71 prevents writing an incoherent dirstate where the parent doesn't
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	72 match the contents.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	73 '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	74 self._parentwriters += 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	75
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	76 def endparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	77 '''Marks the end of a set of changes that involve changing the
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	78 dirstate parents. Once all parent changes have been marked done,
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	79 the wlock will be free to write the dirstate on release.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	80 '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	81 if self._parentwriters > 0:
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	82 self._parentwriters -= 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	83
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	84 def pendingparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	85 '''Returns true if the dirstate is in the middle of a set of changes
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	86 that modify the dirstate parent.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	87 '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	88 return self._parentwriters > 0
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	89
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	90 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	91 def _map(self):
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	92 '''Return the dirstate contents as a map from filename to
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	93 (state, mode, size, time).'''
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	94 self._read()
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	95 return self._map
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	96
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	97 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	98 def _copymap(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	99 self._read()
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	100 return self._copymap
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	101
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	102 @propertycache
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	103 def _filefoldmap(self):
24610 4a4018831d2e dirstate: use parsers.make_file_foldmap when available Siddharth Agarwal <sid0@fb.com> parents: 24561 diff changeset	104 try:
4a4018831d2e dirstate: use parsers.make_file_foldmap when available Siddharth Agarwal <sid0@fb.com> parents: 24561 diff changeset	105 makefilefoldmap = parsers.make_file_foldmap
4a4018831d2e dirstate: use parsers.make_file_foldmap when available Siddharth Agarwal <sid0@fb.com> parents: 24561 diff changeset	106 except AttributeError:
4a4018831d2e dirstate: use parsers.make_file_foldmap when available Siddharth Agarwal <sid0@fb.com> parents: 24561 diff changeset	107 pass
4a4018831d2e dirstate: use parsers.make_file_foldmap when available Siddharth Agarwal <sid0@fb.com> parents: 24561 diff changeset	108 else:
4a4018831d2e dirstate: use parsers.make_file_foldmap when available Siddharth Agarwal <sid0@fb.com> parents: 24561 diff changeset	109 return makefilefoldmap(self._map, util.normcasespec,
4a4018831d2e dirstate: use parsers.make_file_foldmap when available Siddharth Agarwal <sid0@fb.com> parents: 24561 diff changeset	110 util.normcasefallback)
4a4018831d2e dirstate: use parsers.make_file_foldmap when available Siddharth Agarwal <sid0@fb.com> parents: 24561 diff changeset	111
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	112 f = {}
22782 a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap Siddharth Agarwal <sid0@fb.com> parents: 22459 diff changeset	113 normcase = util.normcase
19103 0176d0db4671 icasefs: ignore removed files at building "dirstate._foldmap" up on icasefs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18899 diff changeset	114 for name, s in self._map.iteritems():
0176d0db4671 icasefs: ignore removed files at building "dirstate._foldmap" up on icasefs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18899 diff changeset	115 if s[0] != 'r':
22782 a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap Siddharth Agarwal <sid0@fb.com> parents: 22459 diff changeset	116 f[normcase(name)] = name
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	117 f['.'] = '.' # prevents useless util.fspath() invocation
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	118 return f
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	119
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	120 @propertycache
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	121 def _dirfoldmap(self):
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	122 f = {}
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	123 normcase = util.normcase
16302 49b54f1ae053 dirstate: normalize case of directory components Matt Mackall <mpm@selenic.com> parents: 16258 diff changeset	124 for name in self._dirs:
22782 a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap Siddharth Agarwal <sid0@fb.com> parents: 22459 diff changeset	125 f[normcase(name)] = name
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	126 return f
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	127
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	128 @repocache('branch')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	129 def _branch(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	130 try:
14168 135e244776f0 prevent transient leaks of file handle by using new helper functions Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 13974 diff changeset	131 return self._opener.read("branch").strip() or "default"
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	132 except IOError as inst:
15799 e43c140eb08f dirstate: propagate IOError other than ENOENT when reading branch Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15670 diff changeset	133 if inst.errno != errno.ENOENT:
e43c140eb08f dirstate: propagate IOError other than ENOENT when reading branch Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15670 diff changeset	134 raise
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	135 return "default"
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	136
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	137 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	138 def _pl(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	139 try:
25226 00d426a38137 dirstate: use self._filename instead of immediate string `dirstate` FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25216 diff changeset	140 fp = self._opener(self._filename)
13400 14f3795a5ed7 explicitly close files Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 13343 diff changeset	141 st = fp.read(40)
14f3795a5ed7 explicitly close files Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 13343 diff changeset	142 fp.close()
8716 f3322bb29a0e dirstate: don't complain about 0-length files Matt Mackall <mpm@selenic.com> parents: 8708 diff changeset	143 l = len(st)
f3322bb29a0e dirstate: don't complain about 0-length files Matt Mackall <mpm@selenic.com> parents: 8708 diff changeset	144 if l == 40:
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	145 return st[:20], st[20:40]
8716 f3322bb29a0e dirstate: don't complain about 0-length files Matt Mackall <mpm@selenic.com> parents: 8708 diff changeset	146 elif l > 0 and l < 40:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26521 diff changeset	147 raise error.Abort(_('working directory state appears damaged!'))
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	148 except IOError as err:
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	149 if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	150 raise
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	151 return [nullid, nullid]
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	152
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	153 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	154 def _dirs(self):
24635 21e1ece30f8c util: move dirs() and finddirs() from scmutil to util Drew Gottlieb <drgott@google.com> parents: 24632 diff changeset	155 return util.dirs(self._map, 'r')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	156
16143 fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15801 diff changeset	157 def dirs(self):
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15801 diff changeset	158 return self._dirs
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15801 diff changeset	159
16202 53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	160 @rootcache('.hgignore')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	161 def _ignore(self):
25163 3139900f31b1 ignore: remove .hgignore from ignore list if nonexistent Durham Goode <durham@fb.com> parents: 25151 diff changeset	162 files = []
3139900f31b1 ignore: remove .hgignore from ignore list if nonexistent Durham Goode <durham@fb.com> parents: 25151 diff changeset	163 if os.path.exists(self._join('.hgignore')):
3139900f31b1 ignore: remove .hgignore from ignore list if nonexistent Durham Goode <durham@fb.com> parents: 25151 diff changeset	164 files.append(self._join('.hgignore'))
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	165 for name, path in self._ui.configitems("ui"):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	166 if name == 'ignore' or name.startswith('ignore.'):
23629 a04c7b74b3d5 ignore: resolve ignore files relative to repo root (issue4473) (BC) Siddharth Agarwal <sid0@fb.com> parents: 23496 diff changeset	167 # we need to use os.path.join here rather than self._join
a04c7b74b3d5 ignore: resolve ignore files relative to repo root (issue4473) (BC) Siddharth Agarwal <sid0@fb.com> parents: 23496 diff changeset	168 # because path is arbitrary and user-specified
a04c7b74b3d5 ignore: resolve ignore files relative to repo root (issue4473) (BC) Siddharth Agarwal <sid0@fb.com> parents: 23496 diff changeset	169 files.append(os.path.join(self._rootdir, util.expandpath(path)))
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	170
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	171 if not files:
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	172 return util.never
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	173
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	174 pats = ['include:%s' % f for f in files]
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	175 return matchmod.match(self._root, '', [], pats, warn=self._ui.warn)
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	176
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	177 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	178 def _slash(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	179 return self._ui.configbool('ui', 'slash') and os.sep != '/'
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	180
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	181 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	182 def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	183 return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	184
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	185 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	186 def _checkexec(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	187 return util.checkexec(self._root)
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	188
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	189 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	190 def _checkcase(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	191 return not util.checkcase(self._join('.hg'))
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	192
4905 fc61495ea9cf dirstate: make wjoin function private Matt Mackall <mpm@selenic.com> parents: 4904 diff changeset	193 def _join(self, f):
6972 63d1d3e489f8 performance: normalize self._root, avoid calling os.path.join() in dirstate Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 6971 diff changeset	194 # much faster than os.path.join()
6973 8c136043867b dirstate: explain why appending instead of os.path.join() is safe Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 6972 diff changeset	195 # it's safe because f is always a relative path
6972 63d1d3e489f8 performance: normalize self._root, avoid calling os.path.join() in dirstate Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 6971 diff changeset	196 return self._rootdir + f
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	197
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	198 def flagfunc(self, buildfallback):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	199 if self._checklink and self._checkexec:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	200 def f(x):
18869 e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	201 try:
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	202 st = os.lstat(self._join(x))
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	203 if util.statislink(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	204 return 'l'
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	205 if util.statisexec(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	206 return 'x'
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	207 except OSError:
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	208 pass
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	209 return ''
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	210 return f
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	211
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	212 fallback = buildfallback()
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	213 if self._checklink:
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	214 def f(x):
6972 63d1d3e489f8 performance: normalize self._root, avoid calling os.path.join() in dirstate Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 6971 diff changeset	215 if os.path.islink(self._join(x)):
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	216 return 'l'
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	217 if 'x' in fallback(x):
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	218 return 'x'
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	219 return ''
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	220 return f
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	221 if self._checkexec:
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	222 def f(x):
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	223 if 'l' in fallback(x):
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	224 return 'l'
14273 38af0f514134 rename util.is_exec to isexec Adrian Buehlmann <adrian@cadifra.com> parents: 14168 diff changeset	225 if util.isexec(self._join(x)):
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	226 return 'x'
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	227 return ''
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	228 return f
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	229 else:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	230 return fallback
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	231
20335 e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121) Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 20033 diff changeset	232 @propertycache
e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121) Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 20033 diff changeset	233 def _cwd(self):
e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121) Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 20033 diff changeset	234 return os.getcwd()
e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121) Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 20033 diff changeset	235
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	236 def getcwd(self):
26293 3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	237 '''Return the path from which a canonical path is calculated.
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	238
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	239 This path should be used to resolve file patterns or to convert
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	240 canonical paths back to file paths for display. It shouldn't be
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	241 used to get real file paths. Use vfs functions instead.
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	242 '''
20335 e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121) Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 20033 diff changeset	243 cwd = self._cwd
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	244 if cwd == self._root:
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	245 return ''
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	246 # self._root ends with a path separator if self._root is '/' or 'C:\'
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	247 rootsep = self._root
5843 83c354c4d529 Add endswithsep() and use it instead of using os.sep and os.altsep directly. Shun-ichi GOTO <shunichi.goto@gmail.com> parents: 5842 diff changeset	248 if not util.endswithsep(rootsep):
4230 c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	249 rootsep += os.sep
c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	250 if cwd.startswith(rootsep):
c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	251 return cwd[len(rootsep):]
c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	252 else:
c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	253 # we're outside the repo. return an absolute path.
c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	254 return cwd
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	255
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	256 def pathto(self, f, cwd=None):
78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	257 if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	258 cwd = self.getcwd()
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	259 path = util.pathto(self._root, cwd, f)
4527 b422b558015b Add ui.slash hgrc setting Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4525 diff changeset	260 if self._slash:
19210 865beb849720 dirstate: don't overnormalize for ui.slash Matt Mackall <mpm@selenic.com> parents: 19128 diff changeset	261 return util.pconvert(path)
4527 b422b558015b Add ui.slash hgrc setting Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4525 diff changeset	262 return path
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	263
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	264 def __getitem__(self, key):
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	265 '''Return the current state of key (a filename) in the dirstate.
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	266
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	267 States are:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	268 n normal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	269 m needs merging
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	270 r marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	271 a marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	272 ? not tracked
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	273 '''
4906 30847b8af7ca dirstate: add __contains__ and make __getitem__ more useful Matt Mackall <mpm@selenic.com> parents: 4905 diff changeset	274 return self._map.get(key, ("?",))[0]
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	275
3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	276 def __contains__(self, key):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	277 return key in self._map
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	278
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	279 def __iter__(self):
8209 a1a5a57efe90 replace util.sort with sorted built-in Matt Mackall <mpm@selenic.com> parents: 8151 diff changeset	280 for x in sorted(self._map):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	281 yield x
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	282
18792 10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	283 def iteritems(self):
10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	284 return self._map.iteritems()
10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	285
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	286 def parents(self):
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	287 return [self._validate(p) for p in self._pl]
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	288
13876 10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	289 def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	290 return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	291
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	292 def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	293 return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	294
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	295 def branch(self):
13047 6c375e07d673 branch: operate on branch names in local string space where possible Matt Mackall <mpm@selenic.com> parents: 13032 diff changeset	296 return encoding.tolocal(self._branch)
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	297
1062 6d5a62a549fa pep-0008 cleanup benoit.boissinot@ens-lyon.fr parents: 1040 diff changeset	298 def setparents(self, p1, p2=nullid):
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	299 """Set dirstate parents to p1 and p2.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	300
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	301 When moving from two parents to one, 'm' merged entries a
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	302 adjusted to normal and previous copy records discarded and
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	303 returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	304
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	305 See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	306 """
22407 d259322a394b dirstate: add exception when calling setparent without begin/end (API) Durham Goode <durham@fb.com> parents: 22404 diff changeset	307 if self._parentwriters == 0:
22459 0c7b018d3258 dirstate: copyedit exception for no beginparentchange call Siddharth Agarwal <sid0@fb.com> parents: 22407 diff changeset	308 raise ValueError("cannot set dirstate parent without "
0c7b018d3258 dirstate: copyedit exception for no beginparentchange call Siddharth Agarwal <sid0@fb.com> parents: 22407 diff changeset	309 "calling dirstate.beginparentchange")
22407 d259322a394b dirstate: add exception when calling setparent without begin/end (API) Durham Goode <durham@fb.com> parents: 22404 diff changeset	310
4965 4106dde15aed Merge with crew Matt Mackall <mpm@selenic.com> parents: 4911 4953 diff changeset	311 self._dirty = self._dirtypl = True
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	312 oldp2 = self._pl[1]
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	313 self._pl = p1, p2
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	314 copies = {}
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	315 if oldp2 != nullid and p2 == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	316 for f, s in self._map.iteritems():
22895 dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	317 # Discard 'm' markers when moving away from a merge state
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	318 if s[0] == 'm':
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	319 if f in self._copymap:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	320 copies[f] = self._copymap[f]
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	321 self.normallookup(f)
22895 dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	322 # Also fix up otherparent markers
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	323 elif s[0] == 'n' and s[2] == -2:
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	324 if f in self._copymap:
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	325 copies[f] = self._copymap[f]
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	326 self.add(f)
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	327 return copies
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	328
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	329 def setbranch(self, branch):
13047 6c375e07d673 branch: operate on branch names in local string space where possible Matt Mackall <mpm@selenic.com> parents: 13032 diff changeset	330 self._branch = encoding.fromlocal(branch)
16472 14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	331 f = self._opener('branch', 'w', atomictemp=True)
14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	332 try:
14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	333 f.write(self._branch + '\n')
14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	334 f.close()
18317 365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	335
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	336 # make sure filecache has the correct stat info for _branch after
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	337 # replacing the underlying file
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	338 ce = self._filecache['_branch']
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	339 if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	340 ce.refresh()
18076 3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	341 except: # re-raises
3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	342 f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	343 raise
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	344
4615 9b00b73a5286 dirstate: hide some more internals Matt Mackall <mpm@selenic.com> parents: 4614 diff changeset	345 def _read(self):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	346 self._map = {}
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	347 self._copymap = {}
4607 49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	348 try:
25227 fd0f919170d2 dirstate: use open/read of vfs(opener) explicitly instead of read FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25226 diff changeset	349 fp = self._opener.open(self._filename)
fd0f919170d2 dirstate: use open/read of vfs(opener) explicitly instead of read FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25226 diff changeset	350 try:
fd0f919170d2 dirstate: use open/read of vfs(opener) explicitly instead of read FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25226 diff changeset	351 st = fp.read()
fd0f919170d2 dirstate: use open/read of vfs(opener) explicitly instead of read FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25226 diff changeset	352 finally:
fd0f919170d2 dirstate: use open/read of vfs(opener) explicitly instead of read FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25226 diff changeset	353 fp.close()
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	354 except IOError as err:
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	355 if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	356 raise
4607 49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	357 return
49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	358 if not st:
49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	359 return
49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	360
25585 868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	361 if util.safehasattr(parsers, 'dict_new_presized'):
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	362 # Make an estimate of the number of files in the dirstate based on
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	363 # its size. From a linear regression on a set of real-world repos,
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	364 # all over 10,000 files, the size of a dirstate entry is 85
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	365 # bytes. The cost of resizing is significantly higher than the cost
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	366 # of filling in a larger presized dict, so subtract 20% from the
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	367 # size.
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	368 #
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	369 # This heuristic is imperfect in many ways, so in a future dirstate
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	370 # format update it makes sense to just record the number of entries
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	371 # on write.
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	372 self._map = parsers.dict_new_presized(len(st) / 71)
868b7ee8b570 dirstate: use a presized dict for the dirstate Siddharth Agarwal <sid0@fb.com> parents: 25448 diff changeset	373
18649 0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	374 # Python's garbage collector triggers a GC each time a certain number
0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	375 # of container objects (the number being defined by
0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	376 # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	377 # for each file in the dirstate. The C version then immediately marks
0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	378 # them as not to be tracked by the collector. However, this has no
0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	379 # effect on when GCs are triggered, only on what objects the GC looks
0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	380 # into. This means that O(number of files) GCs are unavoidable.
0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	381 # Depending on when in the process's lifetime the dirstate is parsed,
0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	382 # this can get very expensive. As a workaround, disable GC while
0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	383 # parsing the dirstate.
23496 ee5a4ed4c8b1 dirstate: use the 'nogc' decorator Pierre-Yves David <pierre-yves.david@fb.com> parents: 23375 diff changeset	384 #
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator Pierre-Yves David <pierre-yves.david@fb.com> parents: 23375 diff changeset	385 # (we cannot decorate the function directly since it is in a C module)
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator Pierre-Yves David <pierre-yves.david@fb.com> parents: 23375 diff changeset	386 parse_dirstate = util.nogc(parsers.parse_dirstate)
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator Pierre-Yves David <pierre-yves.david@fb.com> parents: 23375 diff changeset	387 p = parse_dirstate(self._map, self._copymap, st)
4952 a11921d24ec4 add dirstate._dirtypl variable Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4677 diff changeset	388 if not self._dirtypl:
7093 16bafcebd3d1 dirstate: C parsing extension Matt Mackall <mpm@selenic.com> parents: 7069 diff changeset	389 self._pl = p
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	390
4613 3a645af7fb76 localrepo and dirstate: rename reload to invalidate Matt Mackall <mpm@selenic.com> parents: 4612 diff changeset	391 def invalidate(self):
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	392 for a in ("_map", "_copymap", "_filefoldmap", "_dirfoldmap", "_branch",
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	393 "_pl", "_dirs", "_ignore"):
4953 6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4952 diff changeset	394 if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4952 diff changeset	395 delattr(self, a)
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	396 self._lastnormaltime = 0
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	397 self._dirty = False
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	398 self._parentwriters = 0
4375 109077e7048d When reloading the dirstate, recompute ignore information if needed. Bryan O'Sullivan <bos@serpentine.com> parents: 4374 diff changeset	399
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	400 def copy(self, source, dest):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	401 """Mark dest as a copy of source. Unmark dest if source is None."""
6680 deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit() Patrick Mezard <pmezard@gmail.com> parents: 6479 diff changeset	402 if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit() Patrick Mezard <pmezard@gmail.com> parents: 6479 diff changeset	403 return
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	404 self._dirty = True
7566 5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	405 if source is not None:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	406 self._copymap[dest] = source
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	407 elif dest in self._copymap:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	408 del self._copymap[dest]
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	409
ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	410 def copied(self, file):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	411 return self._copymap.get(file, None)
3154 b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	412
b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	413 def copies(self):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	414 return self._copymap
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 514 diff changeset	415
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	416 def _droppath(self, f):
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	417 if self[f] not in "?r" and "_dirs" in self.__dict__:
18899 d8ff607ef721 scmutil: use new dirs class in dirstate and context Bryan O'Sullivan <bryano@fb.com> parents: 18897 diff changeset	418 self._dirs.delpath(f)
2953 3d5547845158 fix issue 322. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2859 diff changeset	419
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	420 def _addpath(self, f, state, mode, size, mtime):
5487 7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660). Maxim Dounin <mdounin@mdounin.ru> parents: 5396 diff changeset	421 oldstate = self[f]
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	422 if state == 'a' or oldstate == 'r':
13974 23f2736abce3 move checkfilename from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13944 diff changeset	423 scmutil.checkfilename(f)
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	424 if f in self._dirs:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26521 diff changeset	425 raise error.Abort(_('directory %r already in dirstate') % f)
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	426 # shadows
24635 21e1ece30f8c util: move dirs() and finddirs() from scmutil to util Drew Gottlieb <drgott@google.com> parents: 24632 diff changeset	427 for d in util.finddirs(f):
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	428 if d in self._dirs:
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	429 break
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	430 if d in self._map and self[d] != 'r':
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26521 diff changeset	431 raise error.Abort(
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	432 _('file %r in dirstate clashes with %r') % (d, f))
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	433 if oldstate in "?r" and "_dirs" in self.__dict__:
18899 d8ff607ef721 scmutil: use new dirs class in dirstate and context Bryan O'Sullivan <bryano@fb.com> parents: 18897 diff changeset	434 self._dirs.addpath(f)
17094 c2016bae3b97 dirstate: factor common update code into _addpath Joshua Redstone <joshua.redstone@fb.com> parents: 16955 diff changeset	435 self._dirty = True
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	436 self._map[f] = dirstatetuple(state, mode, size, mtime)
5487 7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660). Maxim Dounin <mdounin@mdounin.ru> parents: 5396 diff changeset	437
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	438 def normal(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	439 '''Mark a file normal and clean.'''
4905 fc61495ea9cf dirstate: make wjoin function private Matt Mackall <mpm@selenic.com> parents: 4904 diff changeset	440 s = os.lstat(self._join(f))
26492 3a0bb61371c5 util: extract stub function to get mtime with second accuracy Yuya Nishihara <yuya@tcha.org> parents: 26294 diff changeset	441 mtime = util.statmtimesec(s)
17733 3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	442 self._addpath(f, 'n', s.st_mode,
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	443 s.st_size & _rangemask, mtime & _rangemask)
5915 d0576d065993 Prefer i in d over d.has_key(i) Christian Ebert <blacktrash@gmx.net> parents: 5843 diff changeset	444 if f in self._copymap:
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	445 del self._copymap[f]
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	446 if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	447 # Remember the most recent modification timeslot for status(),
13754 ae157ca56cd5 dirstate: check mtime when adding to _lastnormal Adrian Buehlmann <adrian@cadifra.com> parents: 13743 diff changeset	448 # to make sure we won't miss future size-preserving file content
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal Adrian Buehlmann <adrian@cadifra.com> parents: 13743 diff changeset	449 # modifications that happen within the same timeslot.
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	450 self._lastnormaltime = mtime
13704 a464763e99f1 dirstate: avoid a race with multiple commits in the same process Greg Ward <greg@gerg.ca> parents: 13400 diff changeset	451
5210 90d9ec0dc69d merge: forcefully mark files that we get from the second parent as dirty Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5123 diff changeset	452 def normallookup(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	453 '''Mark a file normal, but possibly dirty.'''
6298 53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	454 if self._pl[1] != nullid and f in self._map:
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	455 # if there is a merge going on and the file was either
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	456 # in state 'm' (-1) or coming from other parent (-2) before
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	457 # being removed, restore that state.
6298 53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	458 entry = self._map[f]
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	459 if entry[0] == 'r' and entry[2] in (-1, -2):
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	460 source = self._copymap.get(f)
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	461 if entry[2] == -1:
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	462 self.merge(f)
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	463 elif entry[2] == -2:
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	464 self.otherparent(f)
6298 53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	465 if source:
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	466 self.copy(source, f)
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	467 return
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	468 if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2:
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	469 return
17094 c2016bae3b97 dirstate: factor common update code into _addpath Joshua Redstone <joshua.redstone@fb.com> parents: 16955 diff changeset	470 self._addpath(f, 'n', 0, -1, -1)
5210 90d9ec0dc69d merge: forcefully mark files that we get from the second parent as dirty Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5123 diff changeset	471 if f in self._copymap:
90d9ec0dc69d merge: forcefully mark files that we get from the second parent as dirty Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5123 diff changeset	472 del self._copymap[f]
90d9ec0dc69d merge: forcefully mark files that we get from the second parent as dirty Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5123 diff changeset	473
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	474 def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	475 '''Mark as coming from the other parent, always dirty.'''
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	476 if self._pl[1] == nullid:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26521 diff changeset	477 raise error.Abort(_("setting %r to other parent "
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	478 "only allowed in merges") % f)
22896 7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	479 if f in self and self[f] == 'n':
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	480 # merge-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	481 self._addpath(f, 'm', 0, -2, -1)
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	482 else:
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	483 # add-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	484 self._addpath(f, 'n', 0, -2, -1)
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	485
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	486 if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	487 del self._copymap[f]
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	488
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	489 def add(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	490 '''Mark a file added.'''
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	491 self._addpath(f, 'a', 0, -1, -1)
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	492 if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	493 del self._copymap[f]
4616 70352337934e dirstate: refactor checkinterfering Matt Mackall <mpm@selenic.com> parents: 4615 diff changeset	494
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	495 def remove(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	496 '''Mark a file removed.'''
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	497 self._dirty = True
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	498 self._droppath(f)
6297 fed1a9c22076 dirstate.remove: during merges, remember the previous file state Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6257 diff changeset	499 size = 0
fed1a9c22076 dirstate.remove: during merges, remember the previous file state Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6257 diff changeset	500 if self._pl[1] != nullid and f in self._map:
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	501 # backup the previous state
6297 fed1a9c22076 dirstate.remove: during merges, remember the previous file state Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6257 diff changeset	502 entry = self._map[f]
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	503 if entry[0] == 'm': # merge
6297 fed1a9c22076 dirstate.remove: during merges, remember the previous file state Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6257 diff changeset	504 size = -1
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	505 elif entry[0] == 'n' and entry[2] == -2: # other parent
6297 fed1a9c22076 dirstate.remove: during merges, remember the previous file state Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6257 diff changeset	506 size = -2
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	507 self._map[f] = dirstatetuple('r', 0, size, 0)
6297 fed1a9c22076 dirstate.remove: during merges, remember the previous file state Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6257 diff changeset	508 if size == 0 and f in self._copymap:
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	509 del self._copymap[f]
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	510
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	511 def merge(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	512 '''Mark a file merged.'''
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	513 if self._pl[1] == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	514 return self.normallookup(f)
22897 8fe74328f700 dirstate: merge falls through to otherparent Matt Mackall <mpm@selenic.com> parents: 22896 diff changeset	515 return self.otherparent(f)
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	516
14434 cc8c09855d19 dirstate: rename forget to drop Matt Mackall <mpm@selenic.com> parents: 14273 diff changeset	517 def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop Matt Mackall <mpm@selenic.com> parents: 14273 diff changeset	518 '''Drop a file from the dirstate'''
15399 41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080) Matt Mackall <mpm@selenic.com> parents: 15337 diff changeset	519 if f in self._map:
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080) Matt Mackall <mpm@selenic.com> parents: 15337 diff changeset	520 self._dirty = True
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080) Matt Mackall <mpm@selenic.com> parents: 15337 diff changeset	521 self._droppath(f)
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080) Matt Mackall <mpm@selenic.com> parents: 15337 diff changeset	522 del self._map[f]
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	523
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	524 def _discoverpath(self, path, normed, ignoremissing, exists, storemap):
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	525 if exists is None:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	526 exists = os.path.lexists(os.path.join(self._root, path))
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	527 if not exists:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	528 # Maybe a path component exists
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	529 if not ignoremissing and '/' in path:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	530 d, f = path.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	531 d = self._normalize(d, False, ignoremissing, None)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	532 folded = d + "/" + f
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	533 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	534 # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	535 folded = path
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	536 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	537 # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	538 # against dirstate
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	539 if '/' in normed:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	540 d, f = normed.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	541 d = self._normalize(d, False, ignoremissing, True)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	542 r = self._root + "/" + d
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	543 folded = d + "/" + util.fspath(f, r)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	544 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	545 folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	546 storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	547
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	548 return folded
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	549
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	550 def _normalizefile(self, path, isknown, ignoremissing=False, exists=None):
15488 6eff984d8e76 dirstate: fix case-folding identity for traditional Unix Matt Mackall <mpm@selenic.com> parents: 15399 diff changeset	551 normed = util.normcase(path)
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	552 folded = self._filefoldmap.get(normed, None)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	553 if folded is None:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	554 if isknown:
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	555 folded = path
7068 57377fa7eda2 issue 1286: dirstat regression on case folding systems Petr Kodl <petrkodl@gmail.com> parents: 7034 diff changeset	556 else:
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	557 folded = self._discoverpath(path, normed, ignoremissing, exists,
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	558 self._filefoldmap)
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	559 return folded
16302 49b54f1ae053 dirstate: normalize case of directory components Matt Mackall <mpm@selenic.com> parents: 16258 diff changeset	560
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	561 def _normalize(self, path, isknown, ignoremissing=False, exists=None):
15488 6eff984d8e76 dirstate: fix case-folding identity for traditional Unix Matt Mackall <mpm@selenic.com> parents: 15399 diff changeset	562 normed = util.normcase(path)
24561 6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary Siddharth Agarwal <sid0@fb.com> parents: 24560 diff changeset	563 folded = self._filefoldmap.get(normed, None)
6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary Siddharth Agarwal <sid0@fb.com> parents: 24560 diff changeset	564 if folded is None:
6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary Siddharth Agarwal <sid0@fb.com> parents: 24560 diff changeset	565 folded = self._dirfoldmap.get(normed, None)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	566 if folded is None:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	567 if isknown:
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	568 folded = path
7068 57377fa7eda2 issue 1286: dirstat regression on case folding systems Petr Kodl <petrkodl@gmail.com> parents: 7034 diff changeset	569 else:
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	570 # store discovered result in dirfoldmap so that future
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	571 # normalizefile calls don't start matching directories
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	572 folded = self._discoverpath(path, normed, ignoremissing, exists,
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	573 self._dirfoldmap)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	574 return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	575
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	576 def normalize(self, path, isknown=False, ignoremissing=False):
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	577 '''
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	578 normalize the case of a pathname when on a casefolding filesystem
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	579
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	580 isknown specifies whether the filename came from walking the
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	581 disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	582
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	583 If ignoremissing is True, missing path are returned
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	584 unchanged. Otherwise, we try harder to normalize possibly
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	585 existing path components.
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	586
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	587 The normalized case is determined based on the following precedence:
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	588
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	589 - version of name already stored in the dirstate
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	590 - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	591 - version provided via command arguments
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	592 '''
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	593
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	594 if self._checkcase:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	595 return self._normalize(path, isknown, ignoremissing)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	596 return path
6677 9865e15febd0 Add a normalize() method to dirstate Paul Moore <p.f.moore@gmail.com> parents: 6675 diff changeset	597
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	598 def clear(self):
b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	599 self._map = {}
5487 7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660). Maxim Dounin <mdounin@mdounin.ru> parents: 5396 diff changeset	600 if "_dirs" in self.__dict__:
10394 4612cded5176 fix coding style (reported by pylint) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10282 diff changeset	601 delattr(self, "_dirs")
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	602 self._copymap = {}
b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	603 self._pl = [nullid, nullid]
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	604 self._lastnormaltime = 0
5123 79373ec3f27d merge with crew-stable Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5045 5065 diff changeset	605 self._dirty = True
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	606
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	607 def rebuild(self, parent, allfiles, changedfiles=None):
25448 2bbfc2042d93 dirstate: avoid invalidating every entries when list is empty Pierre-Yves David <pierre-yves.david@fb.com> parents: 25275 diff changeset	608 if changedfiles is None:
2bbfc2042d93 dirstate: avoid invalidating every entries when list is empty Pierre-Yves David <pierre-yves.david@fb.com> parents: 25275 diff changeset	609 changedfiles = allfiles
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	610 oldmap = self._map
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	611 self.clear()
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	612 for f in allfiles:
e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	613 if f not in changedfiles:
e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	614 self._map[f] = oldmap[f]
1755 a8f7791e3680 add 'debugrebuildstate' to rebuild the dirstate from a given revision Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	615 else:
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	616 if 'x' in allfiles.flags(f):
25658 e93036747902 global: mass rewrite to use modern octal syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25585 diff changeset	617 self._map[f] = dirstatetuple('n', 0o777, -1, 0)
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	618 else:
25658 e93036747902 global: mass rewrite to use modern octal syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25585 diff changeset	619 self._map[f] = dirstatetuple('n', 0o666, -1, 0)
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	620 self._pl = (parent, nullid)
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	621 self._dirty = True
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	622
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	623 def write(self, repo=None):
4612 17ee7407097f dirstate: simplify dirty handling Matt Mackall <mpm@selenic.com> parents: 4611 diff changeset	624 if not self._dirty:
1794 98b6c1cad58b only write the dirstate when something changed Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1755 diff changeset	625 return
21931 89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21810 diff changeset	626
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21810 diff changeset	627 # enough 'delaywrite' prevents 'pack_dirstate' from dropping
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21810 diff changeset	628 # timestamp of each entries in dirstate, because of 'now > mtime'
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21810 diff changeset	629 delaywrite = self._ui.configint('debug', 'dirstate.delaywrite', 0)
23866 9dd442148301 dirstate: ignore negative debug.dirstate.delaywrite values - they crashed it Mads Kiilerich <madski@unity3d.com> parents: 23629 diff changeset	630 if delaywrite > 0:
21931 89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21810 diff changeset	631 import time # to avoid useless import
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21810 diff changeset	632 time.sleep(delaywrite)
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21810 diff changeset	633
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	634 filename = self._filename
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	635 if not repo:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	636 tr = None
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	637 if self._opener.lexists(self._pendingfilename):
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	638 # if pending file already exists, in-memory changes
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	639 # should be written into it, because it has priority
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	640 # to '.hg/dirstate' at reading under HG_PENDING mode
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	641 filename = self._pendingfilename
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	642 else:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	643 tr = repo.currenttransaction()
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	644
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	645 if tr:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	646 # 'dirstate.write()' is not only for writing in-memory
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	647 # changes out, but also for dropping ambiguous timestamp.
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	648 # delayed writing re-raise "ambiguous timestamp issue".
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	649 # See also the wiki page below for detail:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	650 # https://www.mercurial-scm.org/wiki/DirstateTransactionPlan
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	651
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	652 # emulate dropping timestamp in 'parsers.pack_dirstate'
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	653 now = _getfsnow(repo.vfs)
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	654 dmap = self._map
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	655 for f, e in dmap.iteritems():
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	656 if e[0] == 'n' and e[3] == now:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	657 dmap[f] = dirstatetuple(e[0], e[1], e[2], -1)
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	658
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	659 # emulate that all 'dirstate.normal' results are written out
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	660 self._lastnormaltime = 0
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	661
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	662 # delay writing in-memory changes out
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	663 tr.addfilegenerator('dirstate', (self._filename,),
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	664 self._writedirstate, location='plain')
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	665 return
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	666
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	667 st = self._opener(filename, "w", atomictemp=True)
26521 3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26492 diff changeset	668 self._writedirstate(st)
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26492 diff changeset	669
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26492 diff changeset	670 def _writedirstate(self, st):
9509 e4ca8c258d9b dirstate: kill dirstate.granularity config option Adrian Buehlmann <adrian@cadifra.com> parents: 9379 diff changeset	671 # use the modification time of the newly created temporary file as the
e4ca8c258d9b dirstate: kill dirstate.granularity config option Adrian Buehlmann <adrian@cadifra.com> parents: 9379 diff changeset	672 # filesystem's notion of 'now'
26630 3111b45a2bbf parsers: make pack_dirstate take now in integer for consistency FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26592 diff changeset	673 now = util.statmtimesec(util.fstat(st)) & _rangemask
21026 7ee03e190c1d dirstate: inline local finish function Mads Kiilerich <madski@unity3d.com> parents: 20632 diff changeset	674 st.write(parsers.pack_dirstate(self._map, self._copymap, self._pl, now))
7ee03e190c1d dirstate: inline local finish function Mads Kiilerich <madski@unity3d.com> parents: 20632 diff changeset	675 st.close()
7ee03e190c1d dirstate: inline local finish function Mads Kiilerich <madski@unity3d.com> parents: 20632 diff changeset	676 self._lastnormaltime = 0
7ee03e190c1d dirstate: inline local finish function Mads Kiilerich <madski@unity3d.com> parents: 20632 diff changeset	677 self._dirty = self._dirtypl = False
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	678
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	679 def _dirignore(self, f):
6479 31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078) Patrick Mezard <pmezard@gmail.com> parents: 6327 diff changeset	680 if f == '.':
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078) Patrick Mezard <pmezard@gmail.com> parents: 6327 diff changeset	681 return False
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	682 if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	683 return True
24635 21e1ece30f8c util: move dirs() and finddirs() from scmutil to util Drew Gottlieb <drgott@google.com> parents: 24632 diff changeset	684 for p in util.finddirs(f):
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	685 if self._ignore(p):
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	686 return True
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	687 return False
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	688
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	689 def _walkexplicit(self, match, subrepos):
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	690 '''Get stat data about the files explicitly specified by match.
3529 09d99b7e4da0 simplify dirstate walking Matt Mackall <mpm@selenic.com> parents: 3223 diff changeset	691
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	692 Return a triple (results, dirsfound, dirsnotfound).
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	693 - results is a mapping from filename to stat result. It also contains
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	694 listings mapping subrepos and .hg to None.
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	695 - dirsfound is a list of files found to be directories.
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	696 - dirsnotfound is a list of files that the dirstate thinks are
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	697 directories and that were not found.'''
6578 f242d3684f83 walk: begin refactoring badmatch handling Matt Mackall <mpm@selenic.com> parents: 6577 diff changeset	698
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	699 def badtype(mode):
8310 8417d82d3969 dirstate: translate forgotten string Simon Heimberg <simohe@besonet.ch> parents: 8261 diff changeset	700 kind = _('unknown')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	701 if stat.S_ISCHR(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	702 kind = _('character device')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	703 elif stat.S_ISBLK(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	704 kind = _('block device')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	705 elif stat.S_ISFIFO(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	706 kind = _('fifo')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	707 elif stat.S_ISSOCK(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	708 kind = _('socket')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	709 elif stat.S_ISDIR(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	710 kind = _('directory')
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	711 return _('unsupported file type (type is %s)') % kind
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	712
19142 c3d3e4d75ec3 dirstate.walk: cache match.explicitdir and traversedir locally Siddharth Agarwal <sid0@fb.com> parents: 19137 diff changeset	713 matchedir = match.explicitdir
8676 acd69fc201a5 walk: we always have a badfn Matt Mackall <mpm@selenic.com> parents: 8675 diff changeset	714 badfn = match.bad
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	715 dmap = self._map
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	716 lstat = os.lstat
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	717 getkind = stat.S_IFMT
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	718 dirkind = stat.S_IFDIR
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	719 regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	720 lnkkind = stat.S_IFLNK
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	721 join = self._join
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	722 dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	723 foundadd = dirsfound.append
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	724 dirsnotfound = []
19175 63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append Siddharth Agarwal <sid0@fb.com> parents: 19174 diff changeset	725 notfoundadd = dirsnotfound.append
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	726
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	727 if not match.isexact() and self._checkcase:
12907 e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	728 normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	729 else:
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	730 normalize = None
12907 e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	731
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	732 files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	733 subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	734 i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	735 while i < len(files) and j < len(subrepos):
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	736 subpath = subrepos[j] + "/"
13233 0b30e6148ec5 subrepo: do not report known files inside repositories as unknown Oleg Stepanov <oleg.stepanov@jetbrains.com> parents: 12907 diff changeset	737 if files[i] < subpath:
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	738 i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	739 continue
13339 22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619) trbs <trbs@trbs.net> parents: 13233 diff changeset	740 while i < len(files) and files[i].startswith(subpath):
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	741 del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	742 j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	743
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	744 if not files or '.' in files:
24521 489026bffbf6 dirstate._walkexplicit: indicate root as '.', not '' Siddharth Agarwal <sid0@fb.com> parents: 24448 diff changeset	745 files = ['.']
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	746 results = dict.fromkeys(subrepos)
24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	747 results['.hg'] = None
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	748
23375 a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	749 alldirs = None
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	750 for ff in files:
24523 a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.' Siddharth Agarwal <sid0@fb.com> parents: 24522 diff changeset	751 # constructing the foldmap is expensive, so don't do it for the
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.' Siddharth Agarwal <sid0@fb.com> parents: 24522 diff changeset	752 # common case where files is ['.']
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.' Siddharth Agarwal <sid0@fb.com> parents: 24522 diff changeset	753 if normalize and ff != '.':
24522 18085e46caa9 dirstate._walkexplicit: drop normpath calls Siddharth Agarwal <sid0@fb.com> parents: 24521 diff changeset	754 nf = normalize(ff, False, True)
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	755 else:
24522 18085e46caa9 dirstate._walkexplicit: drop normpath calls Siddharth Agarwal <sid0@fb.com> parents: 24521 diff changeset	756 nf = ff
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	757 if nf in results:
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	758 continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	759
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	760 try:
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	761 st = lstat(join(nf))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	762 kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	763 if kind == dirkind:
8588 2624f485b9bc dirstate: set more states in step 1 of walk Simon Heimberg <simohe@besonet.ch> parents: 8521 diff changeset	764 if nf in dmap:
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	765 # file replaced by dir on disk but still in dirstate
8588 2624f485b9bc dirstate: set more states in step 1 of walk Simon Heimberg <simohe@besonet.ch> parents: 8521 diff changeset	766 results[nf] = None
19143 3cb9468535bd match: make explicitdir and traversedir None by default Siddharth Agarwal <sid0@fb.com> parents: 19142 diff changeset	767 if matchedir:
3cb9468535bd match: make explicitdir and traversedir None by default Siddharth Agarwal <sid0@fb.com> parents: 19142 diff changeset	768 matchedir(nf)
24537 2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578) Matt Harbison <matt_harbison@yahoo.com> parents: 24198 diff changeset	769 foundadd((nf, ff))
12401 4cdaf1adafc8 backout most of 4f8067c94729 Matt Mackall <mpm@selenic.com> parents: 12387 diff changeset	770 elif kind == regkind or kind == lnkkind:
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	771 results[nf] = st
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	772 else:
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	773 badfn(ff, badtype(kind))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	774 if nf in dmap:
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	775 results[nf] = None
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	776 except OSError as inst: # nf not found on disk - it is dirstate only
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	777 if nf in dmap: # does it exactly match a missing file?
8675 fb74e1e69da0 walk: simplify check for missing file Matt Mackall <mpm@selenic.com> parents: 8645 diff changeset	778 results[nf] = None
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	779 else: # does it match a missing directory?
23375 a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	780 if alldirs is None:
24635 21e1ece30f8c util: move dirs() and finddirs() from scmutil to util Drew Gottlieb <drgott@google.com> parents: 24632 diff changeset	781 alldirs = util.dirs(dmap)
23375 a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	782 if nf in alldirs:
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	783 if matchedir:
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	784 matchedir(nf)
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	785 notfoundadd(nf)
8677 34df078b8b1b walk: simplify logic for badfn clause Matt Mackall <mpm@selenic.com> parents: 8676 diff changeset	786 else:
8680 b6511055d37b match: ignore return of match.bad Matt Mackall <mpm@selenic.com> parents: 8677 diff changeset	787 badfn(ff, inst.strerror)
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	788
25877 85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	789 # Case insensitive filesystems cannot rely on lstat() failing to detect
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	790 # a case-only rename. Prune the stat object for any file that does not
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	791 # match the case in the filesystem, if there are multiple files that
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	792 # normalize to the same path.
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	793 if match.isexact() and self._checkcase:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	794 normed = {}
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	795
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	796 for f, st in results.iteritems():
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	797 if st is None:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	798 continue
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	799
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	800 nc = util.normcase(f)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	801 paths = normed.get(nc)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	802
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	803 if paths is None:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	804 paths = set()
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	805 normed[nc] = paths
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	806
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	807 paths.add(f)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	808
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	809 for norm, paths in normed.iteritems():
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	810 if len(paths) > 1:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	811 for path in paths:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	812 folded = self._discoverpath(path, norm, True, None,
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	813 self._dirfoldmap)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	814 if path != folded:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	815 results[path] = None
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	816
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	817 return results, dirsfound, dirsnotfound
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	818
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	819 def walk(self, match, subrepos, unknown, ignored, full=True):
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	820 '''
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	821 Walk recursively through the directory tree, finding all files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	822 matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	823
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	824 If full is False, maybe skip some known-clean files.
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	825
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	826 Return a dict mapping filename to stat-like object (either
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	827 mercurial.osutil.stat instance or return value of os.stat()).
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	828
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	829 '''
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	830 # full is a flag that extensions that hook into walk can use -- this
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	831 # implementation doesn't use it at all. This satisfies the contract
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	832 # because we only guarantee a "maybe".
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	833
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	834 if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	835 ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	836 dirignore = util.never
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	837 elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	838 ignore = self._ignore
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	839 dirignore = self._dirignore
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	840 else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	841 # if not unknown and not ignored, drop dir recursion and step 2
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	842 ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	843 dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	844
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	845 matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	846 matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	847 matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	848 dmap = self._map
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	849 listdir = osutil.listdir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	850 lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	851 dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	852 regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	853 lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	854 join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	855
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	856 exact = skipstep3 = False
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	857 if match.isexact(): # match.exact
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	858 exact = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	859 dirignore = util.always # skip step 2
25234 3c346969c321 dirstate: avoid match.files() in walk() Martin von Zweigbergk <martinvonz@google.com> parents: 25227 diff changeset	860 elif match.prefix(): # match.match, no patterns
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	861 skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	862
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	863 if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	864 normalize = self._normalize
24541 e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize Siddharth Agarwal <sid0@fb.com> parents: 24540 diff changeset	865 normalizefile = self._normalizefile
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	866 skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	867 else:
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	868 normalize = self._normalize
24541 e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize Siddharth Agarwal <sid0@fb.com> parents: 24540 diff changeset	869 normalizefile = None
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	870
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	871 # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	872 results, work, dirsnotfound = self._walkexplicit(match, subrepos)
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	873
19172 c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code Siddharth Agarwal <sid0@fb.com> parents: 19171 diff changeset	874 skipstep3 = skipstep3 and not (work or dirsnotfound)
24537 2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578) Matt Harbison <matt_harbison@yahoo.com> parents: 24198 diff changeset	875 work = [d for d in work if not dirignore(d[0])]
19171 252de7b77cfd dirstate.walk: move dirignore filter out of explicit walk code Siddharth Agarwal <sid0@fb.com> parents: 19170 diff changeset	876
6826 eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	877 # step 2: visit subdirectories
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	878 def traverse(work, alreadynormed):
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	879 wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	880 while work:
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	881 nd = work.pop()
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	882 skip = None
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	883 if nd == '.':
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	884 nd = ''
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	885 else:
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	886 skip = '.hg'
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	887 try:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	888 entries = listdir(join(nd), stat=True, skip=skip)
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	889 except OSError as inst:
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	890 if inst.errno in (errno.EACCES, errno.ENOENT):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	891 match.bad(self.pathto(nd), inst.strerror)
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	892 continue
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	893 raise
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	894 for f, kind, st in entries:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	895 if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	896 # even though f might be a directory, we're only
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	897 # interested in comparing it to files currently in the
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	898 # dmap -- therefore normalizefile is enough
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	899 nf = normalizefile(nd and (nd + "/" + f) or f, True,
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	900 True)
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	901 else:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	902 nf = nd and (nd + "/" + f) or f
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	903 if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	904 if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	905 if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	906 if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	907 matchtdir(nf)
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	908 wadd(nf)
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	909 if nf in dmap and (matchalways or matchfn(nf)):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	910 results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	911 elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	912 if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	913 if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	914 results[nf] = st
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	915 elif ((matchalways or matchfn(nf))
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	916 and not ignore(nf)):
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	917 # unknown file -- normalize if necessary
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	918 if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	919 nf = normalize(nf, False, True)
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	920 results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	921 elif nf in dmap and (matchalways or matchfn(nf)):
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	922 results[nf] = None
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	923
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	924 for nd, d in work:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	925 # alreadynormed means that processwork doesn't have to do any
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	926 # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	927 alreadynormed = not normalize or nd == d
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	928 traverse([d], alreadynormed)
536 c15b4bc0a11c Refactor diffrevs/diffdir into changes mpm@selenic.com parents: 529 diff changeset	929
18812 1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	930 for s in subrepos:
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	931 del results[s]
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	932 del results['.hg']
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	933
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	934 # step 3: visit remaining files from dmap
8684 5bb7780b57c7 match: fold plan cases down to two special cases Matt Mackall <mpm@selenic.com> parents: 8683 diff changeset	935 if not skipstep3 and not exact:
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	936 # If a dmap file is not in results yet, it was either
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	937 # a) not matching matchfn b) ignored, c) missing, or d) under a
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	938 # symlink directory.
18815 a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	939 if not results and matchalways:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	940 visit = dmap.keys()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	941 else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	942 visit = [f for f in dmap if f not in results and matchfn(f)]
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	943 visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	944
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	945 if unknown:
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	946 # unknown == True means we walked all dirs under the roots
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	947 # that wasn't ignored, and everything that matched was stat'ed
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	948 # and is already in results.
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	949 # The rest must thus be ignored or under a symlink.
20033 f962870712da pathutil: tease out a new library to break an import cycle from canonpath use Augie Fackler <raf@durin42.com> parents: 19910 diff changeset	950 audit_path = pathutil.pathauditor(self._root)
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	951
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	952 for nf in iter(visit):
24621 1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	953 # If a stat for the same file was already added with a
1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	954 # different case, don't add one for this, since that would
1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	955 # make it appear as if the file exists under both names
1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	956 # on disk.
24632 b2fb1403994e merge with stable Matt Mackall <mpm@selenic.com> parents: 24610 24621 diff changeset	957 if (normalizefile and
b2fb1403994e merge with stable Matt Mackall <mpm@selenic.com> parents: 24610 24621 diff changeset	958 normalizefile(nf, True, True) in results):
24621 1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	959 results[nf] = None
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	960 # Report ignored items in the dmap as long as they are not
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	961 # under a symlink directory.
24621 1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	962 elif audit_path.check(nf):
18663 05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	963 try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	964 results[nf] = lstat(join(nf))
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	965 # file was just ignored, no links, and exists
18663 05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	966 except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	967 # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	968 results[nf] = None
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	969 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	970 # It's either missing or under a symlink directory
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	971 # which we in this case report as missing
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	972 results[nf] = None
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	973 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	974 # We may not have walked the full directory tree above,
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	975 # so stat and check everything we missed.
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	976 nf = iter(visit).next
26592 502b56a9e897 dirstate: batch calls to statfiles (issue4878) Matt Mackall <mpm@selenic.com> parents: 26587 diff changeset	977 pos = 0
502b56a9e897 dirstate: batch calls to statfiles (issue4878) Matt Mackall <mpm@selenic.com> parents: 26587 diff changeset	978 while pos < len(visit):
502b56a9e897 dirstate: batch calls to statfiles (issue4878) Matt Mackall <mpm@selenic.com> parents: 26587 diff changeset	979 # visit in mid-sized batches so that we don't
502b56a9e897 dirstate: batch calls to statfiles (issue4878) Matt Mackall <mpm@selenic.com> parents: 26587 diff changeset	980 # block signals indefinitely
502b56a9e897 dirstate: batch calls to statfiles (issue4878) Matt Mackall <mpm@selenic.com> parents: 26587 diff changeset	981 xr = xrange(pos, min(len(visit), pos + 1000))
502b56a9e897 dirstate: batch calls to statfiles (issue4878) Matt Mackall <mpm@selenic.com> parents: 26587 diff changeset	982 for st in util.statfiles([join(visit[n]) for n in xr]):
502b56a9e897 dirstate: batch calls to statfiles (issue4878) Matt Mackall <mpm@selenic.com> parents: 26587 diff changeset	983 results[nf()] = st
502b56a9e897 dirstate: batch calls to statfiles (issue4878) Matt Mackall <mpm@selenic.com> parents: 26587 diff changeset	984 pos += 1000
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	985 return results
669 8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback. mwilli2@localhost.localdomain parents: 667 diff changeset	986
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	987 def status(self, match, subrepos, ignored, clean, unknown):
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	988 '''Determine the status of the working copy relative to the
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	989 dirstate and return a pair of (unsure, status), where status is of type
4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	990 scmutil.status and:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	991
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	992 unsure:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	993 files that might have been modified since the dirstate was
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	994 written, but need to be read to be sure (size is the same
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	995 but mtime differs)
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	996 status.modified:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	997 files that have definitely been modified since the dirstate
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	998 was written (different size or mode)
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	999 status.clean:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1000 files that have definitely not been modified since the
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1001 dirstate was written
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1002 '''
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1003 listignored, listclean, listunknown = ignored, clean, unknown
2022 a59da8cc35e4 New option -i/--ignored for 'hg status' to show ignored files. Thomas Arendsen Hein <thomas@intevation.de> parents: 2008 diff changeset	1004 lookup, modified, added, unknown, ignored = [], [], [], [], []
2661 5c10b7ed3411 status: add -c (clean) and -A (all files) options Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2486 diff changeset	1005 removed, deleted, clean = [], [], []
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	1006
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1007 dmap = self._map
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1008 ladd = lookup.append # aka "unsure"
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1009 madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1010 aadd = added.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1011 uadd = unknown.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1012 iadd = ignored.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1013 radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1014 dadd = deleted.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1015 cadd = clean.append
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1016 mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1017 dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1018 checkexec = self._checkexec
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1019 copymap = self._copymap
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1020 lastnormaltime = self._lastnormaltime
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1021
19191 ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1022 # We need to do full walks when either
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1023 # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1024 # - match.traversedir does something, because match.traversedir should
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1025 # be called for every dir in the working dir
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1026 full = listclean or match.traversedir is not None
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1027 for fn, st in self.walk(match, subrepos, listunknown, listignored,
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1028 full=full).iteritems():
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	1029 if fn not in dmap:
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1030 if (listignored or mexact(fn)) and dirignore(fn):
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1031 if listignored:
6033 a1ebd5cd7e55 dirstate.status: avoid putting ignored files in the unknown list Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6032 diff changeset	1032 iadd(fn)
19910 601944f41257 dirstate.status: return explicit unknown files even when not asked Siddharth Agarwal <sid0@fb.com> parents: 19651 diff changeset	1033 else:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1034 uadd(fn)
1471 f56f38a1a85f rewrote changes function in dirstate to use generic walk code Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1402 diff changeset	1035 continue
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	1036
21810 4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1037 # This is equivalent to 'state, mode, size, time = dmap[fn]' but not
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1038 # written like that for performance reasons. dmap[fn] is not a
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1039 # Python tuple in compiled builds. The CPython UNPACK_SEQUENCE
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1040 # opcode has fast paths when the value to be unpacked is a tuple or
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1041 # a list, but falls back to creating a full-fledged iterator in
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1042 # general. That is much slower than simply accessing and storing the
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1043 # tuple members one by one.
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1044 t = dmap[fn]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1045 state = t[0]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1046 mode = t[1]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1047 size = t[2]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1048 time = t[3]
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	1049
6818 6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	1050 if not st and state in "nma":
6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	1051 dadd(fn)
6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	1052 elif state == 'n':
26492 3a0bb61371c5 util: extract stub function to get mtime with second accuracy Yuya Nishihara <yuya@tcha.org> parents: 26294 diff changeset	1053 mtime = util.statmtimesec(st)
6257 bfd49ce0db64 dirstate: ignore mode changes if the fs does not supports the exec bit Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6212 diff changeset	1054 if (size >= 0 and
17733 3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	1055 ((size != st.st_size and size != st.st_size & _rangemask)
25658 e93036747902 global: mass rewrite to use modern octal syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25585 diff changeset	1056 or ((mode ^ st.st_mode) & 0o100 and checkexec))
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	1057 or size == -2 # other parent
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1058 or fn in copymap):
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1059 madd(fn)
19651 902c646019ad dirstate.status: don't ignore symlink placeholders in the normal set Siddharth Agarwal <sid0@fb.com> parents: 19216 diff changeset	1060 elif time != mtime and time != mtime & _rangemask:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1061 ladd(fn)
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1062 elif mtime == lastnormaltime:
24181 5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now' Mads Kiilerich <madski@unity3d.com> parents: 23866 diff changeset	1063 # fn may have just been marked as normal and it may have
5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now' Mads Kiilerich <madski@unity3d.com> parents: 23866 diff changeset	1064 # changed in the same second without changing its size.
5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now' Mads Kiilerich <madski@unity3d.com> parents: 23866 diff changeset	1065 # This can happen if we quickly do multiple commits.
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	1066 # Force lookup, so we don't miss such a racy file change.
13704 a464763e99f1 dirstate: avoid a race with multiple commits in the same process Greg Ward <greg@gerg.ca> parents: 13400 diff changeset	1067 ladd(fn)
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1068 elif listclean:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1069 cadd(fn)
6590 9f80e062d71c status: rename type_ to state Matt Mackall <mpm@selenic.com> parents: 6589 diff changeset	1070 elif state == 'm':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1071 madd(fn)
6590 9f80e062d71c status: rename type_ to state Matt Mackall <mpm@selenic.com> parents: 6589 diff changeset	1072 elif state == 'a':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1073 aadd(fn)
6590 9f80e062d71c status: rename type_ to state Matt Mackall <mpm@selenic.com> parents: 6589 diff changeset	1074 elif state == 'r':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1075 radd(fn)
1183 d9e85a75dbda Optimize dirstate walking mason@suse.com parents: 1117 diff changeset	1076
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22911 diff changeset	1077 return (lookup, scmutil.status(modified, added, removed, deleted,
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22911 diff changeset	1078 unknown, ignored, clean))
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1079
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1080 def matches(self, match):
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1081 '''
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1082 return files in the dirstate (in whatever state) filtered by match
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1083 '''
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1084 dmap = self._map
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1085 if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1086 return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1087 files = match.files()
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	1088 if match.isexact():
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1089 # fast path -- filter the other way around, since typically files is
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1090 # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1091 return [f for f in files if f in dmap]
25275 d94e403b5237 dirstate: use match.prefix() instead of 'not match.anypats()' Martin von Zweigbergk <martinvonz@google.com> parents: 25234 diff changeset	1092 if match.prefix() and all(fn in dmap for fn in files):
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1093 # fast path -- all the values are known to be files, so just return
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1094 # that
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1095 return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1096 return [f for f in dmap if match(f)]
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1097
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1098 def _actualfilename(self, repo):
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1099 if repo.currenttransaction():
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1100 return self._pendingfilename
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1101 else:
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1102 return self._filename
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1103
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1104 def _savebackup(self, repo, suffix):
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1105 '''Save current dirstate into backup file with suffix'''
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1106 filename = self._actualfilename(repo)
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1107
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1108 # use '_writedirstate' instead of 'write' to write changes certainly,
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1109 # because the latter omits writing out if transaction is running.
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1110 # output file will be used to create backup of dirstate at this point.
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1111 self._writedirstate(self._opener(filename, "w", atomictemp=True))
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1112
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1113 tr = repo.currenttransaction()
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1114 if tr:
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1115 # ensure that subsequent tr.writepending returns True for
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1116 # changes written out above, even if dirstate is never
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1117 # changed after this
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1118 tr.addfilegenerator('dirstate', (self._filename,),
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1119 self._writedirstate, location='plain')
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1120
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1121 # ensure that pending file written above is unlinked at
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1122 # failure, even if tr.writepending isn't invoked until the
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1123 # end of this transaction
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1124 tr.registertmp(filename, location='plain')
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1125
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1126 self._opener.write(filename + suffix, self._opener.tryread(filename))
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1127
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1128 def _restorebackup(self, repo, suffix):
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1129 '''Restore dirstate by backup file with suffix'''
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1130 # this "invalidate()" prevents "wlock.release()" from writing
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1131 # changes of dirstate out after restoring from backup file
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1132 self.invalidate()
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1133 filename = self._actualfilename(repo)
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1134 self._opener.rename(filename + suffix, filename)
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1135
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1136 def _clearbackup(self, repo, suffix):
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1137 '''Clear backup file with suffix'''
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1138 filename = self._actualfilename(repo)
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1139 self._opener.unlink(filename + suffix)

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/dirstate.py @ 26634:09bb1ee7e73e