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

annotate mercurial/dirstate.py @ 24537:2bb13f2b778c stable

dirstate: don't require exact case when adding dirs on icasefs (issue4578) We don't require it when adding files on a case insensitive filesystem, so don't require it to add directories for consistency. The problem with the previous code was that _walkexplicit() was only returning the normalized directory. The file(s) in the directory are then appended, and passed to the matcher. But if the user asks for 'capsdir1/capsdir', the matcher will not accept 'CapsDir1/CapsDir/AbC.txt', and the name is dropped. Matching based on the non-normalized name is required. If not normalizing, skip the extra string building for efficiency. '.' is replaced with '' so that the path being tested when no file is specified, isn't prefixed with './' (and therefore fail the match).

author	Matt Harbison <matt_harbison@yahoo.com>
date	Tue, 31 Mar 2015 11:11:39 -0400
parents	3cc630be5f09
children	9fbda55c68d7 1784ca148392

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 _
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	10 import scmutil, util, ignore, osutil, parsers, encoding, pathutil
23496 ee5a4ed4c8b1 dirstate: use the 'nogc' decorator Pierre-Yves David <pierre-yves.david@fb.com> parents: 23375 diff changeset	11 import os, stat, errno
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	12
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	13 propertycache = util.propertycache
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	14 filecache = scmutil.filecache
17733 3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	15 _rangemask = 0x7fffffff
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	16
21809 e250b8300e6e parsers: inline fields of dirstate values in C version Siddharth Agarwal <sid0@fb.com> parents: 21808 diff changeset	17 dirstatetuple = parsers.dirstatetuple
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	18
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	19 class repocache(filecache):
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	20 """filecache for files in .hg/"""
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	21 def join(self, obj, fname):
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	22 return obj._opener.join(fname)
4610 274c99fc629f dirstate: simplify state() Matt Mackall <mpm@selenic.com> parents: 4609 diff changeset	23
16202 53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	24 class rootcache(filecache):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	25 """filecache for files in the repository root"""
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	26 def join(self, obj, fname):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	27 return obj._join(fname)
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	28
1559 59b3639df0a9 Convert all classes to new-style classes by deriving them from object. Eric Hopper <hopper@omnifarious.org> parents: 1541 diff changeset	29 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	30
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	31 def __init__(self, opener, ui, root, validate):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	32 '''Create a new dirstate object.
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	33
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	34 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	35 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	36 the dirstate.
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	37 '''
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	38 self._opener = opener
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	39 self._validate = validate
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	40 self._root = root
24198 3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	41 # 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	42 # UNC path pointing to root share (issue4557)
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	43 if root.endswith(os.sep):
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	44 self._rootdir = root
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	45 else:
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	46 self._rootdir = root + os.sep
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	47 self._dirty = False
4965 4106dde15aed Merge with crew Matt Mackall <mpm@selenic.com> parents: 4911 4953 diff changeset	48 self._dirtypl = False
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	49 self._lastnormaltime = 0
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	50 self._ui = ui
16200 9d4a2942a732 dirstate: add filecache support Idan Kamara <idankk86@gmail.com> parents: 16143 diff changeset	51 self._filecache = {}
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	52 self._parentwriters = 0
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	53
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	54 def beginparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	55 '''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	56 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	57 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	58 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	59 match the contents.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	60 '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	61 self._parentwriters += 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	62
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	63 def endparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	64 '''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	65 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	66 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	67 '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	68 if self._parentwriters > 0:
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	69 self._parentwriters -= 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	70
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	71 def pendingparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	72 '''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	73 that modify the dirstate parent.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	74 '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	75 return self._parentwriters > 0
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	76
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	77 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	78 def _map(self):
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	79 '''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	80 (state, mode, size, time).'''
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	81 self._read()
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	82 return self._map
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	83
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	84 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	85 def _copymap(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	86 self._read()
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	87 return self._copymap
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	88
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	89 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	90 def _foldmap(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	91 f = {}
22782 a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap Siddharth Agarwal <sid0@fb.com> parents: 22459 diff changeset	92 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	93 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	94 if s[0] != 'r':
22782 a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap Siddharth Agarwal <sid0@fb.com> parents: 22459 diff changeset	95 f[normcase(name)] = name
16302 49b54f1ae053 dirstate: normalize case of directory components Matt Mackall <mpm@selenic.com> parents: 16258 diff changeset	96 for name in self._dirs:
22782 a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap Siddharth Agarwal <sid0@fb.com> parents: 22459 diff changeset	97 f[normcase(name)] = name
15668 8e020155e76c dirstate: prevent useless util.fspath() invocation for '.' FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15550 diff changeset	98 f['.'] = '.' # prevents useless util.fspath() invocation
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	99 return f
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	100
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	101 @repocache('branch')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	102 def _branch(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	103 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	104 return self._opener.read("branch").strip() or "default"
15799 e43c140eb08f dirstate: propagate IOError other than ENOENT when reading branch Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15670 diff changeset	105 except IOError, inst:
e43c140eb08f dirstate: propagate IOError other than ENOENT when reading branch Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15670 diff changeset	106 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	107 raise
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	108 return "default"
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	109
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	110 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	111 def _pl(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	112 try:
13400 14f3795a5ed7 explicitly close files Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 13343 diff changeset	113 fp = self._opener("dirstate")
14f3795a5ed7 explicitly close files Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 13343 diff changeset	114 st = fp.read(40)
14f3795a5ed7 explicitly close files Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 13343 diff changeset	115 fp.close()
8716 f3322bb29a0e dirstate: don't complain about 0-length files Matt Mackall <mpm@selenic.com> parents: 8708 diff changeset	116 l = len(st)
f3322bb29a0e dirstate: don't complain about 0-length files Matt Mackall <mpm@selenic.com> parents: 8708 diff changeset	117 if l == 40:
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	118 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	119 elif l > 0 and l < 40:
8640 8536119f2f94 dirstate: notice truncated parents read Matt Mackall <mpm@selenic.com> parents: 8589 diff changeset	120 raise util.Abort(_('working directory state appears damaged!'))
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	121 except IOError, err:
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	122 if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	123 raise
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	124 return [nullid, nullid]
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	125
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	126 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	127 def _dirs(self):
18899 d8ff607ef721 scmutil: use new dirs class in dirstate and context Bryan O'Sullivan <bryano@fb.com> parents: 18897 diff changeset	128 return scmutil.dirs(self._map, 'r')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	129
16143 fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15801 diff changeset	130 def dirs(self):
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15801 diff changeset	131 return self._dirs
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15801 diff changeset	132
16202 53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	133 @rootcache('.hgignore')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	134 def _ignore(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	135 files = [self._join('.hgignore')]
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	136 for name, path in self._ui.configitems("ui"):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	137 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	138 # 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	139 # 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	140 files.append(os.path.join(self._rootdir, util.expandpath(path)))
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	141 return ignore.ignore(self._root, files, self._ui.warn)
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	142
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	143 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	144 def _slash(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	145 return self._ui.configbool('ui', 'slash') and os.sep != '/'
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	146
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	147 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	148 def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	149 return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	150
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	151 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	152 def _checkexec(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	153 return util.checkexec(self._root)
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	154
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	155 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	156 def _checkcase(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	157 return not util.checkcase(self._join('.hg'))
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	158
4905 fc61495ea9cf dirstate: make wjoin function private Matt Mackall <mpm@selenic.com> parents: 4904 diff changeset	159 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	160 # 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	161 # 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	162 return self._rootdir + f
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	163
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	164 def flagfunc(self, buildfallback):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	165 if self._checklink and self._checkexec:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	166 def f(x):
18869 e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	167 try:
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	168 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	169 if util.statislink(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	170 return 'l'
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	171 if util.statisexec(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	172 return 'x'
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	173 except OSError:
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	174 pass
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	175 return ''
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	176 return f
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	177
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	178 fallback = buildfallback()
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	179 if self._checklink:
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	180 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	181 if os.path.islink(self._join(x)):
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	182 return 'l'
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	183 if 'x' in fallback(x):
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	184 return 'x'
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	185 return ''
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	186 return f
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	187 if self._checkexec:
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	188 def f(x):
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	189 if 'l' in fallback(x):
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	190 return 'l'
14273 38af0f514134 rename util.is_exec to isexec Adrian Buehlmann <adrian@cadifra.com> parents: 14168 diff changeset	191 if util.isexec(self._join(x)):
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	192 return 'x'
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	193 return ''
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	194 return f
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	195 else:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	196 return fallback
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	197
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	198 @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	199 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	200 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	201
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	202 def getcwd(self):
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	203 cwd = self._cwd
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	204 if cwd == self._root:
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	205 return ''
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	206 # 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	207 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	208 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	209 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	210 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	211 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	212 else:
c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	213 # 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	214 return cwd
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	215
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	216 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	217 if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	218 cwd = self.getcwd()
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	219 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	220 if self._slash:
19210 865beb849720 dirstate: don't overnormalize for ui.slash Matt Mackall <mpm@selenic.com> parents: 19128 diff changeset	221 return util.pconvert(path)
4527 b422b558015b Add ui.slash hgrc setting Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4525 diff changeset	222 return path
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	223
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	224 def __getitem__(self, key):
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	225 '''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	226
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	227 States are:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	228 n normal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	229 m needs merging
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	230 r marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	231 a marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	232 ? not tracked
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	233 '''
4906 30847b8af7ca dirstate: add __contains__ and make __getitem__ more useful Matt Mackall <mpm@selenic.com> parents: 4905 diff changeset	234 return self._map.get(key, ("?",))[0]
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	235
3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	236 def __contains__(self, key):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	237 return key in self._map
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	238
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	239 def __iter__(self):
8209 a1a5a57efe90 replace util.sort with sorted built-in Matt Mackall <mpm@selenic.com> parents: 8151 diff changeset	240 for x in sorted(self._map):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	241 yield x
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	242
18792 10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	243 def iteritems(self):
10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	244 return self._map.iteritems()
10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	245
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	246 def parents(self):
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	247 return [self._validate(p) for p in self._pl]
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	248
13876 10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	249 def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	250 return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	251
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	252 def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	253 return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	254
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	255 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	256 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	257
1062 6d5a62a549fa pep-0008 cleanup benoit.boissinot@ens-lyon.fr parents: 1040 diff changeset	258 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	259 """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	260
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	261 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	262 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	263 returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	264
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	265 See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	266 """
22407 d259322a394b dirstate: add exception when calling setparent without begin/end (API) Durham Goode <durham@fb.com> parents: 22404 diff changeset	267 if self._parentwriters == 0:
22459 0c7b018d3258 dirstate: copyedit exception for no beginparentchange call Siddharth Agarwal <sid0@fb.com> parents: 22407 diff changeset	268 raise ValueError("cannot set dirstate parent without "
0c7b018d3258 dirstate: copyedit exception for no beginparentchange call Siddharth Agarwal <sid0@fb.com> parents: 22407 diff changeset	269 "calling dirstate.beginparentchange")
22407 d259322a394b dirstate: add exception when calling setparent without begin/end (API) Durham Goode <durham@fb.com> parents: 22404 diff changeset	270
4965 4106dde15aed Merge with crew Matt Mackall <mpm@selenic.com> parents: 4911 4953 diff changeset	271 self._dirty = self._dirtypl = True
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	272 oldp2 = self._pl[1]
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	273 self._pl = p1, p2
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	274 copies = {}
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	275 if oldp2 != nullid and p2 == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	276 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	277 # 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	278 if s[0] == 'm':
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	279 if f in self._copymap:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	280 copies[f] = self._copymap[f]
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	281 self.normallookup(f)
22895 dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	282 # 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	283 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	284 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	285 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	286 self.add(f)
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	287 return copies
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	288
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	289 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	290 self._branch = encoding.fromlocal(branch)
16472 14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	291 f = self._opener('branch', 'w', atomictemp=True)
14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	292 try:
14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	293 f.write(self._branch + '\n')
14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	294 f.close()
18317 365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	295
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	296 # 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	297 # replacing the underlying file
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	298 ce = self._filecache['_branch']
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	299 if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	300 ce.refresh()
18076 3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	301 except: # re-raises
3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	302 f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	303 raise
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	304
4615 9b00b73a5286 dirstate: hide some more internals Matt Mackall <mpm@selenic.com> parents: 4614 diff changeset	305 def _read(self):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	306 self._map = {}
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	307 self._copymap = {}
4607 49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	308 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	309 st = self._opener.read("dirstate")
4607 49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	310 except IOError, err:
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	311 if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	312 raise
4607 49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	313 return
49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	314 if not st:
49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	315 return
49dcac6ede26 dirstate: fold parse into read Matt Mackall <mpm@selenic.com> parents: 4606 diff changeset	316
18649 0969980308c7 dirstate: disable gc while parsing the dirstate Siddharth Agarwal <sid0@fb.com> parents: 18567 diff changeset	317 # 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	318 # 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	319 # 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	320 # 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	321 # 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	322 # 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	323 # 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	324 # 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	325 # 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	326 # parsing the dirstate.
23496 ee5a4ed4c8b1 dirstate: use the 'nogc' decorator Pierre-Yves David <pierre-yves.david@fb.com> parents: 23375 diff changeset	327 #
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator Pierre-Yves David <pierre-yves.david@fb.com> parents: 23375 diff changeset	328 # (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	329 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	330 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	331 if not self._dirtypl:
7093 16bafcebd3d1 dirstate: C parsing extension Matt Mackall <mpm@selenic.com> parents: 7069 diff changeset	332 self._pl = p
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	333
4613 3a645af7fb76 localrepo and dirstate: rename reload to invalidate Matt Mackall <mpm@selenic.com> parents: 4612 diff changeset	334 def invalidate(self):
13200 6f011cf52f9a avoid .split() in for loops and use tuples instead David Soria Parra <dsp@php.net> parents: 13047 diff changeset	335 for a in ("_map", "_copymap", "_foldmap", "_branch", "_pl", "_dirs",
6f011cf52f9a avoid .split() in for loops and use tuples instead David Soria Parra <dsp@php.net> parents: 13047 diff changeset	336 "_ignore"):
4953 6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4952 diff changeset	337 if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4952 diff changeset	338 delattr(self, a)
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	339 self._lastnormaltime = 0
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	340 self._dirty = False
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	341 self._parentwriters = 0
4375 109077e7048d When reloading the dirstate, recompute ignore information if needed. Bryan O'Sullivan <bos@serpentine.com> parents: 4374 diff changeset	342
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	343 def copy(self, source, dest):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	344 """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	345 if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit() Patrick Mezard <pmezard@gmail.com> parents: 6479 diff changeset	346 return
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	347 self._dirty = True
7566 5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	348 if source is not None:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	349 self._copymap[dest] = source
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	350 elif dest in self._copymap:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	351 del self._copymap[dest]
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	352
ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	353 def copied(self, file):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	354 return self._copymap.get(file, None)
3154 b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	355
b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	356 def copies(self):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	357 return self._copymap
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 514 diff changeset	358
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	359 def _droppath(self, f):
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	360 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	361 self._dirs.delpath(f)
2953 3d5547845158 fix issue 322. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2859 diff changeset	362
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	363 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	364 oldstate = self[f]
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	365 if state == 'a' or oldstate == 'r':
13974 23f2736abce3 move checkfilename from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13944 diff changeset	366 scmutil.checkfilename(f)
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	367 if f in self._dirs:
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	368 raise util.Abort(_('directory %r already in dirstate') % f)
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	369 # shadows
18897 38982de2b4eb scmutil: migrate finddirs from dirstate Bryan O'Sullivan <bryano@fb.com> parents: 18869 diff changeset	370 for d in scmutil.finddirs(f):
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	371 if d in self._dirs:
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	372 break
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	373 if d in self._map and self[d] != 'r':
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	374 raise util.Abort(
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	375 _('file %r in dirstate clashes with %r') % (d, f))
80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	376 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	377 self._dirs.addpath(f)
17094 c2016bae3b97 dirstate: factor common update code into _addpath Joshua Redstone <joshua.redstone@fb.com> parents: 16955 diff changeset	378 self._dirty = True
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	379 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	380
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	381 def normal(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	382 '''Mark a file normal and clean.'''
4905 fc61495ea9cf dirstate: make wjoin function private Matt Mackall <mpm@selenic.com> parents: 4904 diff changeset	383 s = os.lstat(self._join(f))
13754 ae157ca56cd5 dirstate: check mtime when adding to _lastnormal Adrian Buehlmann <adrian@cadifra.com> parents: 13743 diff changeset	384 mtime = int(s.st_mtime)
17733 3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	385 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	386 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	387 if f in self._copymap:
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	388 del self._copymap[f]
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	389 if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	390 # 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	391 # 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	392 # modifications that happen within the same timeslot.
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	393 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	394
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	395 def normallookup(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	396 '''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	397 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	398 # 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	399 # 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	400 # 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	401 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	402 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	403 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	404 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	405 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	406 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	407 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	408 if source:
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	409 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	410 return
53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	411 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	412 return
17094 c2016bae3b97 dirstate: factor common update code into _addpath Joshua Redstone <joshua.redstone@fb.com> parents: 16955 diff changeset	413 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	414 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	415 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	416
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	417 def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	418 '''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	419 if self._pl[1] == nullid:
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	420 raise util.Abort(_("setting %r to other parent "
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	421 "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	422 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	423 # merge-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	424 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	425 else:
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	426 # add-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	427 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	428
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	429 if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	430 del self._copymap[f]
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	431
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	432 def add(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	433 '''Mark a file added.'''
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	434 self._addpath(f, 'a', 0, -1, -1)
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	435 if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	436 del self._copymap[f]
4616 70352337934e dirstate: refactor checkinterfering Matt Mackall <mpm@selenic.com> parents: 4615 diff changeset	437
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	438 def remove(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	439 '''Mark a file removed.'''
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	440 self._dirty = True
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	441 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	442 size = 0
fed1a9c22076 dirstate.remove: during merges, remember the previous file state Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6257 diff changeset	443 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	444 # 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	445 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	446 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	447 size = -1
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	448 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	449 size = -2
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	450 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	451 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	452 del self._copymap[f]
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	453
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	454 def merge(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	455 '''Mark a file merged.'''
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	456 if self._pl[1] == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	457 return self.normallookup(f)
22897 8fe74328f700 dirstate: merge falls through to otherparent Matt Mackall <mpm@selenic.com> parents: 22896 diff changeset	458 return self.otherparent(f)
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	459
14434 cc8c09855d19 dirstate: rename forget to drop Matt Mackall <mpm@selenic.com> parents: 14273 diff changeset	460 def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop Matt Mackall <mpm@selenic.com> parents: 14273 diff changeset	461 '''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	462 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	463 self._dirty = True
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080) Matt Mackall <mpm@selenic.com> parents: 15337 diff changeset	464 self._droppath(f)
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080) Matt Mackall <mpm@selenic.com> parents: 15337 diff changeset	465 del self._map[f]
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	466
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	467 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	468 normed = util.normcase(path)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	469 folded = self._foldmap.get(normed, None)
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	470 if folded is None:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	471 if isknown:
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	472 folded = path
7068 57377fa7eda2 issue 1286: dirstat regression on case folding systems Petr Kodl <petrkodl@gmail.com> parents: 7034 diff changeset	473 else:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	474 if exists is None:
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	475 exists = os.path.lexists(os.path.join(self._root, path))
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	476 if not exists:
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	477 # Maybe a path component exists
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	478 if not ignoremissing and '/' in path:
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	479 d, f = path.rsplit('/', 1)
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	480 d = self._normalize(d, isknown, ignoremissing, None)
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	481 folded = d + "/" + f
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	482 else:
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	483 # No path components, preserve original case
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	484 folded = path
16302 49b54f1ae053 dirstate: normalize case of directory components Matt Mackall <mpm@selenic.com> parents: 16258 diff changeset	485 else:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	486 # recursively normalize leading directory components
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	487 # against dirstate
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	488 if '/' in normed:
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	489 d, f = normed.rsplit('/', 1)
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	490 d = self._normalize(d, isknown, ignoremissing, True)
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	491 r = self._root + "/" + d
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	492 folded = d + "/" + util.fspath(f, r)
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	493 else:
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	494 folded = util.fspath(normed, self._root)
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	495 self._foldmap[normed] = folded
16302 49b54f1ae053 dirstate: normalize case of directory components Matt Mackall <mpm@selenic.com> parents: 16258 diff changeset	496
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	497 return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	498
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	499 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	500 '''
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	501 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	502
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	503 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	504 disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	505
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	506 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	507 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	508 existing path components.
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	509
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	510 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	511
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	512 - 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	513 - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	514 - version provided via command arguments
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	515 '''
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	516
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	517 if self._checkcase:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	518 return self._normalize(path, isknown, ignoremissing)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	519 return path
6677 9865e15febd0 Add a normalize() method to dirstate Paul Moore <p.f.moore@gmail.com> parents: 6675 diff changeset	520
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	521 def clear(self):
b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	522 self._map = {}
5487 7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660). Maxim Dounin <mdounin@mdounin.ru> parents: 5396 diff changeset	523 if "_dirs" in self.__dict__:
10394 4612cded5176 fix coding style (reported by pylint) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10282 diff changeset	524 delattr(self, "_dirs")
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	525 self._copymap = {}
b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	526 self._pl = [nullid, nullid]
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	527 self._lastnormaltime = 0
5123 79373ec3f27d merge with crew-stable Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5045 5065 diff changeset	528 self._dirty = True
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	529
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	530 def rebuild(self, parent, allfiles, changedfiles=None):
e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	531 changedfiles = changedfiles or allfiles
e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	532 oldmap = self._map
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	533 self.clear()
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	534 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	535 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	536 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	537 else:
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	538 if 'x' in allfiles.flags(f):
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	539 self._map[f] = dirstatetuple('n', 0777, -1, 0)
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	540 else:
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	541 self._map[f] = dirstatetuple('n', 0666, -1, 0)
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	542 self._pl = (parent, nullid)
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	543 self._dirty = True
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	544
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	545 def write(self):
4612 17ee7407097f dirstate: simplify dirty handling Matt Mackall <mpm@selenic.com> parents: 4611 diff changeset	546 if not self._dirty:
1794 98b6c1cad58b only write the dirstate when something changed Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1755 diff changeset	547 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	548
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21810 diff changeset	549 # 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	550 # 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	551 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	552 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	553 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	554 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	555
6326 af3f26b6bba4 dirstate: ignore stat data for files that were updated too recently Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6298 diff changeset	556 st = self._opener("dirstate", "w", atomictemp=True)
9509 e4ca8c258d9b dirstate: kill dirstate.granularity config option Adrian Buehlmann <adrian@cadifra.com> parents: 9379 diff changeset	557 # 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	558 # filesystem's notion of 'now'
16955 92e1c64ba0d4 parsers: add a C function to pack the dirstate Bryan O'Sullivan <bryano@fb.com> parents: 16686 diff changeset	559 now = util.fstat(st).st_mtime
21026 7ee03e190c1d dirstate: inline local finish function Mads Kiilerich <madski@unity3d.com> parents: 20632 diff changeset	560 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	561 st.close()
7ee03e190c1d dirstate: inline local finish function Mads Kiilerich <madski@unity3d.com> parents: 20632 diff changeset	562 self._lastnormaltime = 0
7ee03e190c1d dirstate: inline local finish function Mads Kiilerich <madski@unity3d.com> parents: 20632 diff changeset	563 self._dirty = self._dirtypl = False
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	564
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	565 def _dirignore(self, f):
6479 31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078) Patrick Mezard <pmezard@gmail.com> parents: 6327 diff changeset	566 if f == '.':
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078) Patrick Mezard <pmezard@gmail.com> parents: 6327 diff changeset	567 return False
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	568 if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	569 return True
18897 38982de2b4eb scmutil: migrate finddirs from dirstate Bryan O'Sullivan <bryano@fb.com> parents: 18869 diff changeset	570 for p in scmutil.finddirs(f):
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	571 if self._ignore(p):
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	572 return True
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	573 return False
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	574
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	575 def _walkexplicit(self, match, subrepos):
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	576 '''Get stat data about the files explicitly specified by match.
3529 09d99b7e4da0 simplify dirstate walking Matt Mackall <mpm@selenic.com> parents: 3223 diff changeset	577
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	578 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	579 - 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	580 listings mapping subrepos and .hg to None.
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	581 - 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	582 - 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	583 directories and that were not found.'''
6578 f242d3684f83 walk: begin refactoring badmatch handling Matt Mackall <mpm@selenic.com> parents: 6577 diff changeset	584
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	585 def badtype(mode):
8310 8417d82d3969 dirstate: translate forgotten string Simon Heimberg <simohe@besonet.ch> parents: 8261 diff changeset	586 kind = _('unknown')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	587 if stat.S_ISCHR(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	588 kind = _('character device')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	589 elif stat.S_ISBLK(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	590 kind = _('block device')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	591 elif stat.S_ISFIFO(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	592 kind = _('fifo')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	593 elif stat.S_ISSOCK(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	594 kind = _('socket')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	595 elif stat.S_ISDIR(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	596 kind = _('directory')
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	597 return _('unsupported file type (type is %s)') % kind
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	598
19142 c3d3e4d75ec3 dirstate.walk: cache match.explicitdir and traversedir locally Siddharth Agarwal <sid0@fb.com> parents: 19137 diff changeset	599 matchedir = match.explicitdir
8676 acd69fc201a5 walk: we always have a badfn Matt Mackall <mpm@selenic.com> parents: 8675 diff changeset	600 badfn = match.bad
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	601 dmap = self._map
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	602 normpath = util.normpath
46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	603 lstat = os.lstat
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	604 getkind = stat.S_IFMT
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	605 dirkind = stat.S_IFDIR
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	606 regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	607 lnkkind = stat.S_IFLNK
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	608 join = self._join
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	609 dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	610 foundadd = dirsfound.append
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	611 dirsnotfound = []
19175 63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append Siddharth Agarwal <sid0@fb.com> parents: 19174 diff changeset	612 notfoundadd = dirsnotfound.append
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	613
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	614 if match.matchfn != match.exact and self._checkcase:
12907 e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	615 normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	616 else:
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	617 normalize = None
12907 e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	618
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	619 files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	620 subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	621 i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	622 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	623 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	624 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	625 i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	626 continue
13339 22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619) trbs <trbs@trbs.net> parents: 13233 diff changeset	627 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	628 del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	629 j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	630
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	631 if not files or '.' in files:
2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	632 files = ['']
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	633 results = dict.fromkeys(subrepos)
24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	634 results['.hg'] = None
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	635
23375 a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	636 alldirs = None
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	637 for ff in files:
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	638 if normalize:
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	639 nf = normalize(normpath(ff), False, True)
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	640 else:
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	641 nf = normpath(ff)
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	642 if nf in results:
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	643 continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	644
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	645 try:
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	646 st = lstat(join(nf))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	647 kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	648 if kind == dirkind:
8588 2624f485b9bc dirstate: set more states in step 1 of walk Simon Heimberg <simohe@besonet.ch> parents: 8521 diff changeset	649 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	650 # 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	651 results[nf] = None
19143 3cb9468535bd match: make explicitdir and traversedir None by default Siddharth Agarwal <sid0@fb.com> parents: 19142 diff changeset	652 if matchedir:
3cb9468535bd match: make explicitdir and traversedir None by default Siddharth Agarwal <sid0@fb.com> parents: 19142 diff changeset	653 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	654 foundadd((nf, ff))
12401 4cdaf1adafc8 backout most of 4f8067c94729 Matt Mackall <mpm@selenic.com> parents: 12387 diff changeset	655 elif kind == regkind or kind == lnkkind:
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	656 results[nf] = st
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	657 else:
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	658 badfn(ff, badtype(kind))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	659 if nf in dmap:
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	660 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	661 except OSError, inst: # nf not found on disk - it is dirstate only
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	662 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	663 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	664 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	665 if alldirs is None:
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	666 alldirs = scmutil.dirs(dmap)
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	667 if nf in alldirs:
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	668 if matchedir:
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	669 matchedir(nf)
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	670 notfoundadd(nf)
8677 34df078b8b1b walk: simplify logic for badfn clause Matt Mackall <mpm@selenic.com> parents: 8676 diff changeset	671 else:
8680 b6511055d37b match: ignore return of match.bad Matt Mackall <mpm@selenic.com> parents: 8677 diff changeset	672 badfn(ff, inst.strerror)
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	673
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	674 return results, dirsfound, dirsnotfound
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	675
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	676 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	677 '''
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	678 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	679 matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	680
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	681 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	682
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	683 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	684 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	685
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	686 '''
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	687 # 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	688 # 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	689 # 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	690
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	691 if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	692 ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	693 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	694 elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	695 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	696 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	697 else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	698 # 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	699 ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	700 dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	701
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	702 matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	703 matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	704 matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	705 dmap = self._map
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	706 listdir = osutil.listdir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	707 lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	708 dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	709 regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	710 lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	711 join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	712
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	713 exact = skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	714 if matchfn == match.exact: # match.exact
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	715 exact = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	716 dirignore = util.always # skip step 2
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	717 elif match.files() and not match.anypats(): # match.match, no patterns
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	718 skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	719
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	720 if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	721 normalize = self._normalize
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	722 skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	723 else:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	724 normalize = None
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	725
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	726 # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	727 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	728
19172 c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code Siddharth Agarwal <sid0@fb.com> parents: 19171 diff changeset	729 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	730 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	731 wadd = work.append
252de7b77cfd dirstate.walk: move dirignore filter out of explicit walk code Siddharth Agarwal <sid0@fb.com> parents: 19170 diff changeset	732
6826 eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	733 # step 2: visit subdirectories
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	734 while work:
24537 2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578) Matt Harbison <matt_harbison@yahoo.com> parents: 24198 diff changeset	735 nd, d = work.pop()
7099 6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7096 diff changeset	736 skip = None
6826 eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	737 if nd == '.':
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	738 nd = ''
24537 2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578) Matt Harbison <matt_harbison@yahoo.com> parents: 24198 diff changeset	739 d = ''
6826 eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	740 else:
7099 6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7096 diff changeset	741 skip = '.hg'
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7096 diff changeset	742 try:
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7096 diff changeset	743 entries = listdir(join(nd), stat=True, skip=skip)
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7096 diff changeset	744 except OSError, inst:
17879 7b0b1da49f15 dirstate: handle dangling junctions on windows (issue2579) Bryan O'Sullivan <bryano@fb.com> parents: 17821 diff changeset	745 if inst.errno in (errno.EACCES, errno.ENOENT):
21116 30c60e28aa9b dirstate: report bad subdirectories as match.bad, not just a warning (BC) Mads Kiilerich <madski@unity3d.com> parents: 21115 diff changeset	746 match.bad(self.pathto(nd), inst.strerror)
7099 6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7096 diff changeset	747 continue
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7096 diff changeset	748 raise
6826 eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	749 for f, kind, st in entries:
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	750 if normalize:
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	751 nf = normalize(nd and (nd + "/" + f) or f, True, True)
24537 2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578) Matt Harbison <matt_harbison@yahoo.com> parents: 24198 diff changeset	752 f = d and (d + "/" + f) or f
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	753 else:
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	754 nf = nd and (nd + "/" + f) or f
24537 2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578) Matt Harbison <matt_harbison@yahoo.com> parents: 24198 diff changeset	755 f = nf
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	756 if nf not in results:
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	757 if kind == dirkind:
55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	758 if not ignore(nf):
19143 3cb9468535bd match: make explicitdir and traversedir None by default Siddharth Agarwal <sid0@fb.com> parents: 19142 diff changeset	759 if matchtdir:
3cb9468535bd match: make explicitdir and traversedir None by default Siddharth Agarwal <sid0@fb.com> parents: 19142 diff changeset	760 matchtdir(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	761 wadd((nf, f))
18814 1413ba410244 dirstate.walk: fast path match-always case during traversal Siddharth Agarwal <sid0@fb.com> parents: 18812 diff changeset	762 if 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	763 results[nf] = None
6832 643ff33812f8 dirstate.walk: inline imatch Matt Mackall <mpm@selenic.com> parents: 6831 diff changeset	764 elif kind == regkind or kind == lnkkind:
643ff33812f8 dirstate.walk: inline imatch Matt Mackall <mpm@selenic.com> parents: 6831 diff changeset	765 if nf in dmap:
18814 1413ba410244 dirstate.walk: fast path match-always case during traversal Siddharth Agarwal <sid0@fb.com> parents: 18812 diff changeset	766 if matchalways or matchfn(nf):
6832 643ff33812f8 dirstate.walk: inline imatch Matt Mackall <mpm@selenic.com> parents: 6831 diff changeset	767 results[nf] = st
24537 2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578) Matt Harbison <matt_harbison@yahoo.com> parents: 24198 diff changeset	768 elif (matchalways or matchfn(f)) and not ignore(nf):
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	769 results[nf] = st
18814 1413ba410244 dirstate.walk: fast path match-always case during traversal Siddharth Agarwal <sid0@fb.com> parents: 18812 diff changeset	770 elif nf in dmap and (matchalways or matchfn(nf)):
6832 643ff33812f8 dirstate.walk: inline imatch Matt Mackall <mpm@selenic.com> parents: 6831 diff changeset	771 results[nf] = None
536 c15b4bc0a11c Refactor diffrevs/diffdir into changes mpm@selenic.com parents: 529 diff changeset	772
18812 1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	773 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	774 del results[s]
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	775 del results['.hg']
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	776
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	777 # 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	778 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	779 # 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	780 # 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	781 # 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	782 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	783 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	784 else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	785 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	786 visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	787
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	788 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	789 # 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	790 # 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	791 # 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	792 # 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	793 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	794
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	795 for nf in iter(visit):
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	796 # 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	797 # under a symlink directory.
19128 f4930b533d55 hgignore: fix regression with hgignore directory matches (issue3921) Durham Goode <durham@fb.com> parents: 19103 diff changeset	798 if 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	799 try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	800 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	801 # 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	802 except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	803 # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	804 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	805 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	806 # 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	807 # 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	808 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	809 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	810 # 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	811 # 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	812 nf = iter(visit).next
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	813 for st in util.statfiles([join(i) for i in visit]):
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	814 results[nf()] = st
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	815 return results
669 8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback. mwilli2@localhost.localdomain parents: 667 diff changeset	816
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	817 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	818 '''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	819 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	820 scmutil.status and:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	821
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	822 unsure:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	823 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	824 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	825 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	826 status.modified:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	827 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	828 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	829 status.clean:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	830 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	831 dirstate was written
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	832 '''
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	833 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	834 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	835 removed, deleted, clean = [], [], []
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	836
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	837 dmap = self._map
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	838 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	839 madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	840 aadd = added.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	841 uadd = unknown.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	842 iadd = ignored.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	843 radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	844 dadd = deleted.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	845 cadd = clean.append
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	846 mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	847 dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	848 checkexec = self._checkexec
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	849 copymap = self._copymap
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	850 lastnormaltime = self._lastnormaltime
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	851
19191 ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	852 # 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	853 # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	854 # - 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	855 # 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	856 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	857 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	858 full=full).iteritems():
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	859 if fn not in dmap:
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	860 if (listignored or mexact(fn)) and dirignore(fn):
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	861 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	862 iadd(fn)
19910 601944f41257 dirstate.status: return explicit unknown files even when not asked Siddharth Agarwal <sid0@fb.com> parents: 19651 diff changeset	863 else:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	864 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	865 continue
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	866
21810 4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	867 # 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	868 # 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	869 # 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	870 # 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	871 # 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	872 # 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	873 # 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	874 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	875 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	876 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	877 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	878 time = t[3]
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	879
6818 6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	880 if not st and state in "nma":
6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	881 dadd(fn)
6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	882 elif state == 'n':
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	883 mtime = int(st.st_mtime)
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	884 if (size >= 0 and
17733 3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	885 ((size != st.st_size and size != st.st_size & _rangemask)
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	886 or ((mode ^ st.st_mode) & 0100 and checkexec))
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	887 or size == -2 # other parent
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	888 or fn in copymap):
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	889 madd(fn)
19651 902c646019ad dirstate.status: don't ignore symlink placeholders in the normal set Siddharth Agarwal <sid0@fb.com> parents: 19216 diff changeset	890 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	891 ladd(fn)
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	892 elif mtime == lastnormaltime:
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	893 # fn may have been changed in the same timeslot without
7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	894 # changing its size. This can happen if we quickly do
7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	895 # multiple commits in a single transaction.
7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	896 # 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	897 ladd(fn)
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	898 elif listclean:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	899 cadd(fn)
6590 9f80e062d71c status: rename type_ to state Matt Mackall <mpm@selenic.com> parents: 6589 diff changeset	900 elif state == 'm':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	901 madd(fn)
6590 9f80e062d71c status: rename type_ to state Matt Mackall <mpm@selenic.com> parents: 6589 diff changeset	902 elif state == 'a':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	903 aadd(fn)
6590 9f80e062d71c status: rename type_ to state Matt Mackall <mpm@selenic.com> parents: 6589 diff changeset	904 elif state == 'r':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	905 radd(fn)
1183 d9e85a75dbda Optimize dirstate walking mason@suse.com parents: 1117 diff changeset	906
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22911 diff changeset	907 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	908 unknown, ignored, clean))
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	909
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	910 def matches(self, match):
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	911 '''
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	912 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	913 '''
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	914 dmap = self._map
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	915 if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	916 return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	917 files = match.files()
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	918 if match.matchfn == match.exact:
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	919 # 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	920 # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	921 return [f for f in files if f in dmap]
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	922 if not match.anypats() and util.all(fn in dmap for fn in files):
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	923 # 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	924 # that
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	925 return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	926 return [f for f in dmap if match(f)]

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/dirstate.py @ 24537:2bb13f2b778c stable